blob: b1728c45f73956a103842c4e0a214141b938a39d [file]
// Copyright 2025 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <sys/mman.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <optional>
#include <string_view>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "src/lib/files/file.h"
#include "src/lib/fxl/strings/split_string.h"
#include "src/starnix/tests/syscalls/cpp/proc_test_base.h"
#include "src/starnix/tests/syscalls/cpp/syscall_matchers.h"
#include "src/starnix/tests/syscalls/cpp/test_helper.h"
#ifndef MLOCK_ONFAULT
#define MLOCK_ONFAULT 0x01
#endif
// Whether the container is configured to never populate memory on mlock().
#ifdef MLOCK_ALWAYS_ONFAULT
constexpr bool kMlockAlwaysOnFault = true;
#else
constexpr bool kMlockAlwaysOnFault = false;
#endif
class MlockProcTest : public ProcTestBase {
protected:
// Returns the /proc/self/smaps entry of the mapping that contains `addr`.
std::optional<test_helper::MemoryMappingExt> GetSmapsEntry(const volatile void* addr) {
std::string smaps;
if (!files::ReadFileToString(proc_path() + "/self/smaps", &smaps)) {
return std::nullopt;
}
return test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(addr), smaps);
}
// Returns the RSS in bytes of the mapping that contains `addr`, from /proc/self/smaps.
std::optional<size_t> GetRss(const volatile void* addr) {
auto mapping = GetSmapsEntry(addr);
if (!mapping) {
return std::nullopt;
}
return mapping->rss * 1024;
}
// Maps `size` bytes of read-write private anonymous memory between two PROT_NONE guard pages,
// so that its /proc/self/smaps entry is not merged with neighboring mappings. Returns the start
// of the read-write memory in `start`.
static fit::result<int, test_helper::ScopedMMap> MapIsolated(size_t size, uint8_t** start) {
const size_t page_size = sysconf(_SC_PAGE_SIZE);
auto mapping = test_helper::ScopedMMap::MMap(nullptr, size + 2 * page_size, PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (mapping.is_error()) {
return mapping;
}
*start = reinterpret_cast<uint8_t*>(mapping->mapping()) + page_size;
if (mprotect(*start, size, PROT_READ | PROT_WRITE) != 0) {
return fit::error(errno);
}
return mapping;
}
std::optional<size_t> GetVmLckInKb() {
std::string status;
if (!files::ReadFileToString(proc_path() + "/self/status", &status)) {
return std::nullopt;
}
const std::string_view prefix = "VmLck";
for (const auto& line :
fxl::SplitString(status, "\n", fxl::kTrimWhitespace, fxl::kSplitWantNonEmpty)) {
std::vector<std::string_view> fields =
fxl::SplitString(line, ":", fxl::kTrimWhitespace, fxl::kSplitWantNonEmpty);
if (fields[0] == prefix) {
if (fields.size() != 2) {
return std::nullopt;
}
return test_helper::parse_field_in_kb(fields[1]);
}
}
return std::nullopt;
}
};
TEST_F(MlockProcTest, UnalignedAddress) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
auto mapping = test_helper::ScopedMMap::MMap(nullptr, page_size, PROT_READ,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
auto mapped_page = reinterpret_cast<uint8_t*>(mapping->mapping());
ASSERT_EQ(mlock(reinterpret_cast<void*>(mapped_page + 10), page_size - 10), 0) << strerror(errno);
std::string smaps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/smaps", &smaps));
auto smap = test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(mapped_page), smaps);
ASSERT_NE(smap, std::nullopt);
ASSERT_TRUE(smap->ContainsFlag("lo")) << *smap;
}
TEST_F(MlockProcTest, UnlignedLength) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
auto mapping = test_helper::ScopedMMap::MMap(nullptr, page_size, PROT_READ,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
ASSERT_EQ(mlock(mapping->mapping(), page_size - 10), 0) << strerror(errno);
std::string smaps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/smaps", &smaps));
auto smap =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(mapping->mapping()), smaps);
ASSERT_NE(smap, std::nullopt);
ASSERT_TRUE(smap->ContainsFlag("lo")) << *smap;
}
TEST_F(MlockProcTest, RoundingIsCorrect) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
auto mapping = test_helper::ScopedMMap::MMap(nullptr, page_size * 2, PROT_READ,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
// Ask to lock two bytes, starting one byte before the page boundary. This should produce a 2-page
// lock.
auto midpoint = reinterpret_cast<uint8_t*>(mapping->mapping()) + page_size;
ASSERT_EQ(mlock(midpoint - 1, 2), 0) << strerror(errno);
std::string smaps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/smaps", &smaps));
auto smap =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(mapping->mapping()), smaps);
ASSERT_NE(smap, std::nullopt);
ASSERT_EQ(smap->start, reinterpret_cast<uintptr_t>(mapping->mapping()));
ASSERT_EQ(smap->end, reinterpret_cast<uintptr_t>(mapping->mapping()) + (2 * page_size));
ASSERT_TRUE(smap->ContainsFlag("lo")) << *smap;
}
TEST_F(MlockProcTest, SplitMapping) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
auto mapping = test_helper::ScopedMMap::MMap(nullptr, page_size * 3, PROT_READ,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
auto first_page = reinterpret_cast<uint8_t*>(mapping->mapping());
auto first_addr = reinterpret_cast<uintptr_t>(first_page);
auto second_page = reinterpret_cast<void*>(first_page + page_size);
auto second_addr = reinterpret_cast<uintptr_t>(second_page);
auto third_addr = second_addr + page_size;
// Lock the middle page of the mapping.
ASSERT_EQ(mlock(second_page, page_size), 0) << strerror(errno);
std::string smaps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/smaps", &smaps));
auto first_mapping = test_helper::find_memory_mapping_ext(first_addr, smaps);
ASSERT_NE(first_mapping, std::nullopt);
ASSERT_EQ(first_mapping->start, first_addr) << *first_mapping;
ASSERT_EQ(first_mapping->end, second_addr) << *first_mapping;
ASSERT_FALSE(first_mapping->ContainsFlag("lo")) << *first_mapping;
auto second_mapping = test_helper::find_memory_mapping_ext(second_addr, smaps);
ASSERT_NE(second_mapping, std::nullopt);
ASSERT_EQ(second_mapping->start, second_addr) << *second_mapping;
ASSERT_EQ(second_mapping->end, third_addr) << *second_mapping;
ASSERT_TRUE(second_mapping->ContainsFlag("lo")) << *second_mapping;
auto third_mapping = test_helper::find_memory_mapping_ext(third_addr, smaps);
ASSERT_NE(third_mapping, std::nullopt);
ASSERT_EQ(third_mapping->start, third_addr) << *third_mapping;
ASSERT_EQ(third_mapping->end, third_addr + page_size) << *third_mapping;
ASSERT_FALSE(third_mapping->ContainsFlag("lo")) << *third_mapping;
}
TEST_F(MlockProcTest, MlockOnePageIncreasesVmLck) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
const size_t map_size = 2 * page_size;
// Map 2 private-anonymous pages.
auto mapping = test_helper::ScopedMMap::MMap(nullptr, map_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
// Touch them to ensure non-zero number of committed bytes.
reinterpret_cast<volatile char*>(mapping->mapping())[0] = 'a';
reinterpret_cast<volatile char*>(mapping->mapping())[page_size] = 'a';
// Record the `VmLck` value.
auto vmlck_before = GetVmLckInKb();
ASSERT_NE(vmlck_before, std::nullopt);
// Test that locking any of the two pages results in the increase of VmLck by one page
for (int i = 0; i < 2; i++) {
// Lock one page.
ASSERT_EQ(mlock(reinterpret_cast<uint8_t*>(mapping->mapping()) + (i * page_size), page_size), 0)
<< strerror(errno);
// Record the `VmLck` value again.
auto vmlck_after = GetVmLckInKb();
ASSERT_NE(vmlck_after, std::nullopt);
// Check that the new value is greater than the base one by exactly one page.
EXPECT_GT(*vmlck_after, *vmlck_before);
EXPECT_EQ(*vmlck_after - *vmlck_before, page_size / 1024);
ASSERT_EQ(munlock(reinterpret_cast<uint8_t*>(mapping->mapping()) + (i * page_size), page_size),
0)
<< strerror(errno);
}
}
TEST_F(MlockProcTest, MlockPrefaultsPrivateAnonymousMemory) {
if (kMlockAlwaysOnFault) {
GTEST_SKIP() << "mlock() does not populate memory in this configuration";
}
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
const size_t map_size = 4 * page_size;
uint8_t* start;
auto mapping = MapIsolated(map_size, &start);
ASSERT_THAT(mapping, SyscallResultIsOk());
ASSERT_EQ(GetRss(start), 0u);
ASSERT_THAT(mlock(start, map_size), SyscallSucceeds());
EXPECT_EQ(GetRss(start), map_size);
}
TEST_F(MlockProcTest, MlockOnFaultDoesNotPrefault) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
const size_t map_size = 4 * page_size;
uint8_t* start;
auto mapping = MapIsolated(map_size, &start);
ASSERT_THAT(mapping, SyscallResultIsOk());
ASSERT_THAT(syscall(SYS_mlock2, start, map_size, MLOCK_ONFAULT), SyscallSucceeds());
EXPECT_EQ(GetRss(start), 0u);
}
TEST_F(MlockProcTest, MlockAfterMlockOnFaultPrefaults) {
if (kMlockAlwaysOnFault) {
GTEST_SKIP() << "mlock() does not populate memory in this configuration";
}
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
const size_t map_size = 2 * page_size;
uint8_t* start;
auto mapping = MapIsolated(map_size, &start);
ASSERT_THAT(mapping, SyscallResultIsOk());
ASSERT_THAT(syscall(SYS_mlock2, start, map_size, MLOCK_ONFAULT), SyscallSucceeds());
ASSERT_EQ(GetRss(start), 0u);
// Locking the already locked range again without MLOCK_ONFAULT populates it.
ASSERT_THAT(mlock(start, map_size), SyscallSucceeds());
EXPECT_EQ(GetRss(start), map_size);
}
TEST_F(MlockProcTest, MlockPrefaultsOnlyWritablePrivateAnonymousMappings) {
if (kMlockAlwaysOnFault) {
GTEST_SKIP() << "mlock() does not populate memory in this configuration";
}
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
const size_t map_size = 3 * page_size;
uint8_t* start;
auto mapping = MapIsolated(map_size, &start);
ASSERT_THAT(mapping, SyscallResultIsOk());
uint8_t* read_only_page = start + 2 * page_size;
ASSERT_THAT(mprotect(read_only_page, page_size, PROT_READ), SyscallSucceeds());
ASSERT_THAT(mlock(start, map_size), SyscallSucceeds());
// Writable pages get their own memory, read-only ones are backed by the shared zero page,
// which is not accounted in RSS.
EXPECT_EQ(GetRss(start), 2 * page_size);
EXPECT_EQ(GetRss(read_only_page), 0u);
}
TEST_F(MlockProcTest, MlockAfterForkCopiesPrivatePages) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
const size_t map_size = 2 * page_size;
uint8_t* start;
auto mapping = MapIsolated(map_size, &start);
ASSERT_THAT(mapping, SyscallResultIsOk());
auto base = reinterpret_cast<volatile char*>(start);
base[0] = 'a';
base[page_size] = 'a';
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
ASSERT_THAT(mlock(start, map_size), SyscallSucceeds());
if (!kMlockAlwaysOnFault) {
EXPECT_EQ(GetRss(start), map_size);
}
// Populating the copy-on-write pages preserves their contents...
EXPECT_EQ(base[0], 'a');
EXPECT_EQ(base[page_size], 'a');
base[0] = 'b';
EXPECT_EQ(base[0], 'b');
});
ASSERT_TRUE(helper.WaitForChildren());
// ...and does not affect the parent.
EXPECT_EQ(base[0], 'a');
EXPECT_EQ(base[page_size], 'a');
}
TEST_F(MlockProcTest, MlockStopsPopulatingAtProtNoneMapping) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
uint8_t* start;
auto mapping = MapIsolated(3 * page_size, &start);
ASSERT_THAT(mapping, SyscallResultIsOk());
uint8_t* prot_none_page = start + page_size;
uint8_t* last_page = start + 2 * page_size;
ASSERT_THAT(mprotect(prot_none_page, page_size, PROT_NONE), SyscallSucceeds());
EXPECT_THAT(mlock(start, 3 * page_size), SyscallFailsWithErrno(ENOMEM));
// The whole range is locked, but only the pages before the PROT_NONE mapping are populated.
for (uint8_t* page : {start, prot_none_page, last_page}) {
auto smap = GetSmapsEntry(page);
ASSERT_NE(smap, std::nullopt);
EXPECT_TRUE(smap->ContainsFlag("lo")) << *smap;
}
if (!kMlockAlwaysOnFault) {
EXPECT_EQ(GetRss(start), page_size);
}
EXPECT_EQ(GetRss(last_page), 0u);
}
class MlockProtTest : public MlockProcTest,
public ::testing::WithParamInterface<std::tuple<int, int, bool>> {};
TEST_P(MlockProtTest, MlockApplied) {
const auto [prot, sharing, file_backed] = GetParam();
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
const size_t size = 2 * page_size;
test_helper::ScopedTempFD file;
int fd = -1;
int flags = sharing;
if (file_backed) {
ASSERT_TRUE(file);
std::string contents(size, 'f');
ASSERT_THAT(write(file.fd(), contents.data(), size), SyscallSucceedsWithValue(size));
fd = file.fd();
} else {
flags |= MAP_ANONYMOUS;
}
auto mapping = test_helper::ScopedMMap::MMap(nullptr, size, prot, flags, fd, 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
auto base = reinterpret_cast<volatile char*>(mapping->mapping());
// PROT_NONE mappings cannot be populated, so mlock() fails, but the range is locked in all
// cases.
if (prot == PROT_NONE) {
EXPECT_THAT(mlock(mapping->mapping(), size), SyscallFailsWithErrno(ENOMEM));
} else {
EXPECT_THAT(mlock(mapping->mapping(), size), SyscallSucceeds());
}
auto smap = GetSmapsEntry(base);
ASSERT_NE(smap, std::nullopt);
EXPECT_TRUE(smap->ContainsFlag("lo")) << *smap;
// Locking preserves the contents of the mapping and its sharing semantics.
const char initial = file_backed ? 'f' : 0;
if (prot & PROT_READ) {
EXPECT_EQ(base[0], initial);
EXPECT_EQ(base[page_size], initial);
}
if (prot & PROT_WRITE) {
base[0] = 'w';
if (file_backed) {
char c;
ASSERT_THAT(pread(fd, &c, 1, 0), SyscallSucceedsWithValue(1));
EXPECT_EQ(c, sharing == MAP_SHARED ? 'w' : 'f');
}
}
}
INSTANTIATE_TEST_SUITE_P(
All, MlockProtTest,
::testing::Combine(::testing::Values(PROT_NONE, PROT_READ, PROT_WRITE, PROT_READ | PROT_WRITE),
::testing::Values(MAP_PRIVATE, MAP_SHARED), ::testing::Bool()),
[](const ::testing::TestParamInfo<MlockProtTest::ParamType>& info) {
// Structured bindings would be split by the macro at their commas.
const int prot = std::get<0>(info.param);
const int sharing = std::get<1>(info.param);
const bool file_backed = std::get<2>(info.param);
std::string name;
name += (prot & PROT_READ) ? "R" : "";
name += (prot & PROT_WRITE) ? "W" : "";
if (prot == PROT_NONE) {
name += "None";
}
name += sharing == MAP_SHARED ? "_Shared" : "_Private";
name += file_backed ? "_File" : "_Anon";
return name;
});