blob: 2ddca75a3d67eb1bfd8d056d332e94d81563fa93 [file]
// Copyright 2022 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 <fcntl.h>
#include <inttypes.h>
#include <lib/fit/defer.h>
#include <lib/stdcompat/string_view.h>
#include <string.h>
#include <sys/auxv.h>
#include <sys/inotify.h>
#include <sys/mman.h>
#include <sys/mount.h>
#include <sys/statvfs.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
#include <atomic>
#include <charconv>
#include <cstdint>
#include <cstdio>
#include <optional>
#include <ostream>
#include <string>
#include <thread>
#include <vector>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <linux/capability.h>
#include "src/lib/files/file.h"
#include "src/lib/fxl/strings/split_string.h"
#include "src/lib/fxl/strings/string_number_conversions.h"
#include "src/lib/fxl/strings/string_printf.h"
#include "src/starnix/tests/syscalls/cpp/capabilities_helper.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"
constexpr size_t PAGE_SIZE = 0x1000;
#ifndef MAP_FIXED_NOREPLACE
#define MAP_FIXED_NOREPLACE 0x100000
#endif
#ifndef MREMAP_DONTUNMAP
#define MREMAP_DONTUNMAP 4
#endif
namespace {
#if __x86_64__
constexpr size_t MMAP_FILE_SIZE = 64;
constexpr intptr_t LIMIT_4GB = 0x80000000;
TEST(MmapTest, UnmapPartialMapped) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
uint8_t* mmap_addr = reinterpret_cast<uint8_t*>(
mmap(nullptr, page_size * 2, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
ASSERT_NE(mmap_addr, MAP_FAILED) << strerror(errno);
EXPECT_EQ(munmap(mmap_addr, page_size), 0) << strerror(errno);
EXPECT_EQ(munmap(mmap_addr + page_size, page_size), 0) << strerror(errno);
}
TEST(MmapTest, Map32Test) {
char* tmp = getenv("TEST_TMPDIR");
std::string path = tmp == nullptr ? "/tmp/mmaptest" : std::string(tmp) + "/mmaptest";
int fd = open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0777);
ASSERT_GE(fd, 0);
for (unsigned char i = 0; i < MMAP_FILE_SIZE; i++) {
ASSERT_EQ(write(fd, &i, sizeof(i)), 1);
}
close(fd);
int fdm = open(path.c_str(), O_RDWR);
ASSERT_GE(fdm, 0);
void* mapped =
mmap(nullptr, MMAP_FILE_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_32BIT, fdm, 0);
intptr_t maploc = reinterpret_cast<intptr_t>(mapped);
intptr_t limit = LIMIT_4GB - MMAP_FILE_SIZE;
ASSERT_GT(maploc, 0);
ASSERT_LE(maploc, limit);
ASSERT_EQ(munmap(mapped, MMAP_FILE_SIZE), 0);
close(fd);
unlink(path.c_str());
}
#endif
TEST(MmapTest, MprotectMultipleMappings) {
char* page1 = (char*)mmap(nullptr, PAGE_SIZE * 2, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(page1, MAP_FAILED) << strerror(errno);
char* page2 = (char*)mmap(page1 + PAGE_SIZE, PAGE_SIZE, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
ASSERT_NE(page2, MAP_FAILED) << strerror(errno);
memset(page1, 'F', PAGE_SIZE * 2);
// This gets the starnix mapping state out of sync with the real zircon mappings...
ASSERT_EQ(mprotect(page1, PAGE_SIZE * 2, PROT_READ), 0) << strerror(errno);
// ...so madvise clears a page that is not mapped.
ASSERT_EQ(madvise(page2, PAGE_SIZE, MADV_DONTNEED), 0) << strerror(errno);
ASSERT_EQ(*page1, 'F');
ASSERT_EQ(*page2, 0); // would fail
}
TEST(MmapTest, MprotectSecondPageStringRead) {
char* addr = static_cast<char*>(
mmap(nullptr, PAGE_SIZE * 2, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
mprotect(addr + PAGE_SIZE, PAGE_SIZE, 0);
strcpy(addr, "/dev/null");
int fd = open(addr, O_RDONLY);
EXPECT_NE(fd, -1);
close(fd);
munmap(addr, PAGE_SIZE * 2);
}
TEST(MMapTest, MapFileThenGrow) {
char* tmp = getenv("TEST_TMPDIR");
std::string path = tmp == nullptr ? "/tmp/mmap_grow_test" : std::string(tmp) + "/mmap_grow_test";
int fd = open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0777);
size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
// Resize the file to be 3 pages long.
size_t file_size = page_size * 3;
SAFE_SYSCALL(ftruncate(fd, file_size));
// Create a file-backed mapping that is 8 pages long.
size_t mapping_len = page_size * 8;
std::byte* mapping_addr = static_cast<std::byte*>(
mmap(nullptr, mapping_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
ASSERT_NE(mapping_addr, MAP_FAILED);
// Resize the file to be 6.5 pages long.
file_size = page_size * 6 + page_size / 2;
SAFE_SYSCALL(ftruncate(fd, file_size));
// Stores to the area past the original mapping should be reflected in the underlying file.
off_t store_offset = page_size * 4;
*reinterpret_cast<volatile std::byte*>(mapping_addr + store_offset) = std::byte{1};
SAFE_SYSCALL(msync(mapping_addr + store_offset, page_size, MS_SYNC));
std::byte file_value;
SAFE_SYSCALL(pread(fd, &file_value, 1, store_offset));
EXPECT_EQ(file_value, std::byte{1});
// Writes to the file past the original mapping should be reflected in the mapping.
off_t load_offset = page_size * 5;
std::byte stored_value{2};
SAFE_SYSCALL(pwrite(fd, &stored_value, 1, load_offset));
SAFE_SYSCALL(msync(mapping_addr + load_offset, page_size, MS_SYNC));
std::byte read_value = *reinterpret_cast<volatile std::byte*>(mapping_addr + load_offset);
EXPECT_EQ(read_value, stored_value);
// Loads and stores to the page corresponding to the end of the file work, even past the end of
// the file.
store_offset = file_size + 16;
*reinterpret_cast<volatile std::byte*>(mapping_addr + store_offset) = std::byte{3};
load_offset = store_offset;
read_value = *reinterpret_cast<volatile std::byte*>(mapping_addr + load_offset);
EXPECT_EQ(read_value, std::byte{3});
// Note: https://man7.org/linux/man-pages/man2/mmap.2.html#BUGS says that stores to memory past
// the end of the file may be visible to other memory mappings of the same file even after the
// file is closed and unmapped.
SAFE_SYSCALL(munmap(mapping_addr, mapping_len));
close(fd);
unlink(path.c_str());
}
TEST(MMapTest, MapFixedUnalignedFails) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* mmap_addr = mmap(nullptr, page_size * 2, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(mmap_addr, MAP_FAILED);
void* unaligned_addr = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(mmap_addr) + 1);
EXPECT_EQ(
mmap(unaligned_addr, page_size, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0),
MAP_FAILED);
EXPECT_EQ(errno, EINVAL);
}
TEST(MmapTest, FileCreatedWithLessPermsPrivate) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
char* tmp = getenv("TEST_TMPDIR");
std::string dir = tmp == nullptr ? "/tmp" : std::string(tmp);
std::string path = dir + "/test_mmap_file_without_perms_for_private";
int fd = SAFE_SYSCALL(creat(path.c_str(), 0));
void* addr = mmap(nullptr, page_size, PROT_NONE, MAP_PRIVATE, fd, 0);
EXPECT_EQ(addr, MAP_FAILED);
EXPECT_EQ(errno, EACCES);
SAFE_SYSCALL(close(fd));
SAFE_SYSCALL(unlink(path.c_str()));
}
TEST(MmapTest, FileCreatedWithLessPermsShared) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
char* tmp = getenv("TEST_TMPDIR");
std::string dir = tmp == nullptr ? "/tmp" : std::string(tmp);
std::string path = dir + "/test_mmap_file_without_perms_for_shared";
int fd = SAFE_SYSCALL(creat(path.c_str(), 0));
void* addr = mmap(nullptr, page_size, PROT_NONE, MAP_SHARED, fd, 0);
EXPECT_EQ(addr, MAP_FAILED);
EXPECT_EQ(errno, EACCES);
SAFE_SYSCALL(close(fd));
SAFE_SYSCALL(unlink(path.c_str()));
}
TEST(MmapTest, CannotMmapNoexecAsExecutable) {
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Test uses mount() but running without sysadmin. Skipping.";
}
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir temp_dir;
SAFE_SYSCALL(mount(nullptr, temp_dir.path().c_str(), "tmpfs", MS_NOEXEC, nullptr));
std::string file_path = temp_dir.path() + "/executable_file";
close(SAFE_SYSCALL(creat(file_path.c_str(), 755)));
fbl::unique_fd fd(open(file_path.c_str(), O_RDONLY));
void* res = mmap(nullptr, page_size, PROT_READ | PROT_EXEC, MAP_SHARED, fd.get(), 0);
EXPECT_EQ(res, MAP_FAILED);
EXPECT_EQ(errno, EPERM);
if (res != MAP_FAILED) {
munmap(res, page_size);
}
}
TEST(MmapTest, CannotMmapNoexecAsPrivateWritableExecutable) {
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Test uses mount() but running without sysadmin. Skipping.";
}
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir temp_dir;
SAFE_SYSCALL(mount(nullptr, temp_dir.path().c_str(), "tmpfs", MS_NOEXEC, nullptr));
std::string file_path = temp_dir.path() + "/executable_file";
close(SAFE_SYSCALL(creat(file_path.c_str(), 0755)));
fbl::unique_fd fd(open(file_path.c_str(), O_RDONLY));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
void* res =
mmap(nullptr, page_size, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE, fd.get(), 0);
EXPECT_EQ(res, MAP_FAILED);
EXPECT_EQ(errno, EPERM);
if (res != MAP_FAILED) {
munmap(res, page_size);
}
}
TEST(MmapTest, CanMprotectNonExecMmapToExecutable) {
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Test uses mount() but running without sysadmin. Skipping.";
}
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir temp_dir;
SAFE_SYSCALL(mount(nullptr, temp_dir.path().c_str(), "tmpfs", 0, nullptr));
std::string file_path = temp_dir.path() + "/executable_file";
close(SAFE_SYSCALL(creat(file_path.c_str(), 0755)));
fbl::unique_fd fd(open(file_path.c_str(), O_RDONLY));
void* res = mmap(nullptr, page_size, PROT_READ, MAP_SHARED, fd.get(), 0);
ASSERT_NE(res, MAP_FAILED);
EXPECT_THAT(mprotect(res, page_size, PROT_READ | PROT_EXEC), SyscallSucceeds());
munmap(res, page_size);
}
TEST(MmapTest, CannotMprotectNoexecAsExecutable) {
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Test uses mount() but running without sysadmin. Skipping.";
}
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir temp_dir;
SAFE_SYSCALL(mount(nullptr, temp_dir.path().c_str(), "tmpfs", MS_NOEXEC, nullptr));
std::string file_path = temp_dir.path() + "/executable_file";
close(SAFE_SYSCALL(creat(file_path.c_str(), 0755)));
int raw_fd = open(file_path.c_str(), O_RDONLY);
ASSERT_THAT(raw_fd, SyscallSucceeds());
fbl::unique_fd fd(raw_fd);
for (int flags : {MAP_SHARED, MAP_PRIVATE}) {
SCOPED_TRACE(flags);
auto mapping =
test_helper::ScopedMMap::MMap(nullptr, page_size, PROT_READ, flags, fd.get(), /*offset=*/0);
ASSERT_THAT(mapping, SyscallResultIsOk());
EXPECT_THAT(mprotect(mapping->mapping(), page_size, PROT_READ | PROT_EXEC),
SyscallFailsWithErrno(EACCES));
}
}
// Returns whether the filesystem of `path` is mounted with `noexec`.
bool IsOnNoexecMount(const std::string& path) {
struct statvfs buf = {};
return statvfs(path.c_str(), &buf) == 0 && (buf.f_flag & ST_NOEXEC) != 0;
}
// Creates an executable file at `path`, filled with `size` bytes of `value`.
void CreateExecutableFile(const std::string& path, size_t size, uint8_t value) {
int raw_fd = open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0755);
ASSERT_THAT(raw_fd, SyscallSucceeds());
fbl::unique_fd fd(raw_fd);
std::vector<uint8_t> contents(size, value);
ASSERT_EQ(write(fd.get(), contents.data(), contents.size()),
static_cast<ssize_t>(contents.size()));
}
TEST(MmapTest, MprotectExecPreservesWrittenPrivateFileMapping) {
// A private file mapping created without PROT_EXEC can later be made executable. Data written
// to the mapping before that must be preserved, and must not be carried through to the file.
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir tmp_dir;
if (IsOnNoexecMount(tmp_dir.path())) {
GTEST_SKIP() << "The temporary directory is on a noexec mount";
}
std::string path = tmp_dir.path() + "/private_mprotect_exec_file";
ASSERT_NO_FATAL_FAILURE(CreateExecutableFile(path, page_size, 0xAA));
int raw_fd = open(path.c_str(), O_RDONLY);
ASSERT_THAT(raw_fd, SyscallSucceeds());
fbl::unique_fd fd(raw_fd);
auto mapping = test_helper::ScopedMMap::MMap(nullptr, page_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE, fd.get(), /*offset=*/0);
ASSERT_THAT(mapping, SyscallResultIsOk());
volatile uint8_t* bytes = static_cast<volatile uint8_t*>(mapping->mapping());
bytes[0] = 0xBB;
ASSERT_THAT(mprotect(mapping->mapping(), page_size, PROT_READ | PROT_EXEC), SyscallSucceeds());
EXPECT_EQ(bytes[0], 0xBB);
EXPECT_EQ(bytes[1], 0xAA);
uint8_t file_byte = 0;
ASSERT_EQ(pread(fd.get(), &file_byte, 1, /*offset=*/0), 1);
EXPECT_EQ(file_byte, 0xAA);
}
TEST(MmapTest, MprotectExecOfPartialSharedFileMappingStaysCoherent) {
// Making part of a shared file mapping executable must keep it backed by the file's memory at
// the same offset: writes through the mapping reach the file, and writes to the file are
// visible through the mapping.
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir tmp_dir;
if (IsOnNoexecMount(tmp_dir.path())) {
GTEST_SKIP() << "The temporary directory is on a noexec mount";
}
std::string path = tmp_dir.path() + "/shared_mprotect_exec_file";
ASSERT_NO_FATAL_FAILURE(CreateExecutableFile(path, page_size * 3, 0));
int raw_fd = open(path.c_str(), O_RDWR);
ASSERT_THAT(raw_fd, SyscallSucceeds());
fbl::unique_fd fd(raw_fd);
auto mapping = test_helper::ScopedMMap::MMap(nullptr, page_size * 3, PROT_READ | PROT_WRITE,
MAP_SHARED, fd.get(), /*offset=*/0);
ASSERT_THAT(mapping, SyscallResultIsOk());
volatile uint8_t* bytes = static_cast<volatile uint8_t*>(mapping->mapping());
bytes[0] = 0x11;
bytes[page_size] = 0x22;
bytes[page_size * 2] = 0x33;
// Only make the middle page executable.
ASSERT_THAT(mprotect(static_cast<uint8_t*>(mapping->mapping()) + page_size, page_size,
PROT_READ | PROT_WRITE | PROT_EXEC),
SyscallSucceeds());
EXPECT_EQ(bytes[0], 0x11);
EXPECT_EQ(bytes[page_size], 0x22);
EXPECT_EQ(bytes[page_size * 2], 0x33);
// Writes through the executable page reach the file.
bytes[page_size + 1] = 0x44;
uint8_t file_byte = 0;
ASSERT_EQ(pread(fd.get(), &file_byte, 1, page_size + 1), 1);
EXPECT_EQ(file_byte, 0x44);
// Writes to the file are visible through the executable page.
const uint8_t file_value = 0x55;
ASSERT_EQ(pwrite(fd.get(), &file_value, 1, page_size + 2), 1);
EXPECT_EQ(bytes[page_size + 2], 0x55);
}
TEST(MmapTest, ForkAfterMprotectExecOfPartialPrivateFileMapping) {
// After making only part of a private file mapping executable, a forked child must be able to
// use both parts and see the parent's modifications.
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir tmp_dir;
if (IsOnNoexecMount(tmp_dir.path())) {
GTEST_SKIP() << "The temporary directory is on a noexec mount";
}
std::string path = tmp_dir.path() + "/fork_mprotect_exec_file";
ASSERT_NO_FATAL_FAILURE(CreateExecutableFile(path, page_size * 2, 0xAA));
int raw_fd = open(path.c_str(), O_RDONLY);
ASSERT_THAT(raw_fd, SyscallSucceeds());
fbl::unique_fd fd(raw_fd);
for (int prot : {PROT_READ, PROT_READ | PROT_WRITE}) {
SCOPED_TRACE(prot);
auto mapping = test_helper::ScopedMMap::MMap(nullptr, page_size * 2, prot, MAP_PRIVATE,
fd.get(), /*offset=*/0);
ASSERT_THAT(mapping, SyscallResultIsOk());
uint8_t* bytes = static_cast<uint8_t*>(mapping->mapping());
ASSERT_THAT(mprotect(bytes + page_size, page_size, prot | PROT_EXEC), SyscallSucceeds());
uint8_t expected_first = 0xAA;
uint8_t expected_second = 0xAA;
if ((prot & PROT_WRITE) != 0) {
expected_first = 0xBB;
expected_second = 0xCC;
bytes[0] = expected_first;
bytes[page_size] = expected_second;
}
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
volatile uint8_t* child_bytes = bytes;
EXPECT_EQ(child_bytes[0], expected_first);
EXPECT_EQ(child_bytes[page_size], expected_second);
});
ASSERT_TRUE(helper.WaitForChildren());
}
}
class MMapProcTest : public ProcTestBase {
protected:
void VerifyCommittedProtNoneMemoryOnFork(void* mapped, size_t page_size) {
uintptr_t base = reinterpret_cast<uintptr_t>(mapped);
void* page0 = reinterpret_cast<void*>(base);
void* page1 = reinterpret_cast<void*>(base + page_size);
void* page2 = reinterpret_cast<void*>(base + 2 * page_size);
void* page3 = reinterpret_cast<void*>(base + 3 * page_size);
void* page4 = reinterpret_cast<void*>(base + 4 * page_size);
// Pages 0 and 4 are outer PROT_NONE guard pages.
// Pages 1 and 3 are uncommitted PROT_READ pages to prevent page 2 from coalescing when its
// protection is changed to PROT_NONE.
SAFE_SYSCALL(mprotect(page0, page_size, PROT_NONE));
SAFE_SYSCALL(mprotect(page1, page_size, PROT_READ));
SAFE_SYSCALL(mprotect(page3, page_size, PROT_READ));
SAFE_SYSCALL(mprotect(page4, page_size, PROT_NONE));
// Commit page 2 by writing data, then change its protection to PROT_NONE.
volatile char* data = reinterpret_cast<volatile char*>(page2);
data[0] = 42;
SAFE_SYSCALL(mprotect(page2, page_size, PROT_NONE));
std::string parent_smaps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/smaps", &parent_smaps));
auto parent_mapping =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(page2), parent_smaps);
ASSERT_NE(parent_mapping, std::nullopt);
EXPECT_EQ(parent_mapping->end - parent_mapping->start, page_size);
EXPECT_EQ(parent_mapping->perms, "---p");
EXPECT_EQ(parent_mapping->rss, page_size / 1024);
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
std::string child_smaps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/smaps", &child_smaps));
auto guard_mapping =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(page1), child_smaps);
ASSERT_NE(guard_mapping, std::nullopt);
EXPECT_EQ(guard_mapping->rss, 0u);
auto forked_mapping =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(page2), child_smaps);
ASSERT_NE(forked_mapping, std::nullopt);
EXPECT_EQ(forked_mapping->end - forked_mapping->start, page_size);
EXPECT_EQ(forked_mapping->perms, "---p");
EXPECT_EQ(forked_mapping->rss, page_size / 1024);
// Making the committed page readable again preserves its contents and Rss.
SAFE_SYSCALL(mprotect(page2, page_size, PROT_READ));
EXPECT_EQ(data[0], 42);
std::string child_smaps_after;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/smaps", &child_smaps_after));
auto restored_mapping = test_helper::find_memory_mapping_ext(
reinterpret_cast<uintptr_t>(page2), child_smaps_after);
ASSERT_NE(restored_mapping, std::nullopt);
EXPECT_EQ(restored_mapping->perms, "r--p");
EXPECT_EQ(restored_mapping->rss, page_size / 1024);
});
EXPECT_TRUE(helper.WaitForChildren());
}
};
TEST_F(MMapProcTest, CommonMappingsHavePathnames) {
uintptr_t stack_addr = reinterpret_cast<uintptr_t>(__builtin_frame_address(0));
uintptr_t vdso_addr = static_cast<uintptr_t>(getauxval(AT_SYSINFO_EHDR));
std::string maps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto stack_mapping = test_helper::find_memory_mapping(stack_addr, maps);
ASSERT_NE(stack_mapping, std::nullopt);
EXPECT_EQ(stack_mapping->pathname, "[stack]");
if (vdso_addr) {
auto vdso_mapping = test_helper::find_memory_mapping(vdso_addr, maps);
ASSERT_NE(vdso_mapping, std::nullopt);
EXPECT_EQ(vdso_mapping->pathname, "[vdso]");
}
}
TEST_F(MMapProcTest, MapFileWithNewlineInName) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
char* tmp = getenv("TEST_TMPDIR");
std::string dir = tmp == nullptr ? "/tmp" : std::string(tmp);
std::string path = dir + "/mmap\nnewline";
fbl::unique_fd fd = fbl::unique_fd(open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0777));
ASSERT_TRUE(fd);
SAFE_SYSCALL(ftruncate(fd.get(), page_size));
void* p = mmap(nullptr, page_size, PROT_READ, MAP_SHARED, fd.get(), 0);
std::string address_formatted = fxl::StringPrintf("%8" PRIxPTR, (uintptr_t)p);
std::string maps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto mapping = test_helper::find_memory_mapping(reinterpret_cast<uintptr_t>(p), maps);
EXPECT_NE(mapping, std::nullopt);
EXPECT_EQ(mapping->pathname, dir + "/mmap\\012newline");
munmap(p, page_size);
unlink(path.c_str());
}
TEST_F(MMapProcTest, MapDeletedField) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
char* tmp = getenv("TEST_TMPDIR");
std::string dir = tmp == nullptr ? "/tmp" : std::string(tmp);
std::string path = dir + "/tmpfile";
fbl::unique_fd fd = fbl::unique_fd(open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0777));
ASSERT_TRUE(fd);
SAFE_SYSCALL(ftruncate(fd.get(), page_size));
void* p = mmap(nullptr, page_size, PROT_READ, MAP_SHARED, fd.get(), 0);
std::string address_formatted = fxl::StringPrintf("%8" PRIxPTR, (uintptr_t)p);
fd.reset();
unlink(path.c_str());
std::string maps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto mapping = test_helper::find_memory_mapping(reinterpret_cast<uintptr_t>(p), maps);
EXPECT_NE(mapping, std::nullopt);
EXPECT_EQ(mapping->pathname, dir + "/tmpfile (deleted)");
munmap(p, page_size);
}
TEST_F(MMapProcTest, AdjacentFileMappings) {
size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
char* tmp = getenv("TEST_TMPDIR");
std::string dir = tmp == nullptr ? "/tmp" : std::string(tmp);
std::string path = dir + "/mmap_test";
int fd = open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0777);
ASSERT_GE(fd, 0);
SAFE_SYSCALL(ftruncate(fd, page_size * 2));
// Find two adjacent available pages in memory.
void* p = mmap(nullptr, page_size * 2, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(MAP_FAILED, p);
SAFE_SYSCALL(munmap(p, page_size * 2));
// Map the first page of the file into the first page of our available space.
ASSERT_NE(MAP_FAILED, mmap(p, page_size, PROT_READ, MAP_SHARED | MAP_FIXED, fd, 0));
// Map the second page of the file into the second page of our available space.
ASSERT_NE(MAP_FAILED, mmap((void*)((intptr_t)p + page_size), page_size, PROT_READ,
MAP_SHARED | MAP_FIXED, fd, page_size));
std::string maps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
// Expect one line for this file covering 2 pages
std::vector<std::string_view> lines =
fxl::SplitString(maps, "\n", fxl::kKeepWhitespace, fxl::kSplitWantNonEmpty);
bool found_entry = false;
for (auto line : lines) {
if (cpp20::ends_with(line, path)) {
EXPECT_FALSE(found_entry) << "extra entry found: " << line;
found_entry = true;
}
}
close(fd);
unlink(path.c_str());
}
TEST_F(MMapProcTest, OrderOfLayout) {
size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
static int anchor;
uintptr_t executable_addr = reinterpret_cast<uintptr_t>(&anchor);
uintptr_t program_break = reinterpret_cast<uintptr_t>(sbrk(0));
uintptr_t mmap_general_addr = reinterpret_cast<uintptr_t>(
mmap(nullptr, page_size, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
ASSERT_NE((void*)mmap_general_addr, MAP_FAILED);
uintptr_t stack_addr = reinterpret_cast<uintptr_t>(__builtin_frame_address(0));
EXPECT_LT(executable_addr, program_break);
EXPECT_LT(program_break, mmap_general_addr);
EXPECT_LT(mmap_general_addr, stack_addr);
SAFE_SYSCALL(munmap((void*)mmap_general_addr, page_size));
}
TEST_F(MMapProcTest, MremapDontUnmapKeepsFlags) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
// Reserve 5 pages with no protection and use this range for the new mappings. This is to ensure
// the mappings will not be merged with anything else.
void* reserved = mmap(nullptr, 5 * page_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(reserved, MAP_FAILED);
void* source = reinterpret_cast<void*>(reinterpret_cast<intptr_t>(reserved) + page_size);
void* dest = reinterpret_cast<void*>(reinterpret_cast<intptr_t>(reserved) + 3 * page_size);
source = mmap(source, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
-1, 0);
ASSERT_NE(source, MAP_FAILED);
reinterpret_cast<volatile char*>(source)[1] = 'a';
void* remapped =
mremap(source, page_size, page_size, MREMAP_MAYMOVE | MREMAP_DONTUNMAP | MREMAP_FIXED, dest);
EXPECT_NE(remapped, MAP_FAILED);
ASSERT_EQ(remapped, dest);
std::string smaps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/smaps", &smaps));
auto source_mapping =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(source), smaps);
ASSERT_NE(source_mapping, std::nullopt);
EXPECT_EQ(source_mapping->rss, 0u);
auto remapped_mapping =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(remapped), smaps);
ASSERT_NE(remapped_mapping, std::nullopt);
EXPECT_NE(remapped_mapping->rss, 0u);
EXPECT_EQ(source_mapping->vm_flags, remapped_mapping->vm_flags);
SAFE_SYSCALL(munmap(reserved, 5 * page_size));
}
TEST_F(MMapProcTest, PrivateMemoryOnFork) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
const size_t kSize = 3 * page_size;
int flags = MAP_ANON | MAP_PRIVATE;
// Map three pages and mark extra ones as having PROT_NONE to avoid coalescing
void* mapped = mmap(nullptr, kSize, PROT_READ | PROT_WRITE, flags, -1, 0);
ASSERT_NE(mapped, nullptr) << "errno=" << errno << ", " << strerror(errno);
SAFE_SYSCALL(mprotect(mapped, page_size, PROT_NONE));
SAFE_SYSCALL(
mprotect(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(mapped) + 2 * page_size),
page_size, PROT_NONE));
// Commit the allocated page by writing some data.
volatile char* data = reinterpret_cast<char*>(mapped) + page_size;
data[0] = 42;
std::string maps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/smaps", &maps));
auto base_mapping =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(mapped) + page_size, maps);
ASSERT_NE(base_mapping, std::nullopt);
EXPECT_EQ(base_mapping->pathname, "");
EXPECT_EQ(base_mapping->perms, "rw-p");
EXPECT_EQ(base_mapping->rss, page_size / 1024);
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
std::string maps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/smaps", &maps));
auto forked_mapping =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(mapped) + page_size, maps);
ASSERT_NE(forked_mapping, std::nullopt);
EXPECT_EQ(forked_mapping->pathname, "");
EXPECT_EQ(forked_mapping->perms, "rw-p");
// Rss reflects a full page, not shared with the parent
EXPECT_EQ(forked_mapping->rss, page_size / 1024);
});
SAFE_SYSCALL(munmap(mapped, kSize));
}
TEST_F(MMapProcTest, SmapsRssSplitMappings) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
const size_t kSize = 5 * page_size;
int flags = MAP_ANON | MAP_PRIVATE;
// Map 5 pages.
void* mapped = mmap(nullptr, kSize, PROT_READ | PROT_WRITE, flags, -1, 0);
ASSERT_NE(mapped, nullptr) << "errno=" << errno << ", " << strerror(errno);
// Mark pages 0 and 4 as non-readable/non-writable. They act as guard pages to avoid coalescing.
SAFE_SYSCALL(mprotect(mapped, page_size, PROT_NONE));
SAFE_SYSCALL(
mprotect(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(mapped) + (4 * page_size)),
page_size, PROT_NONE));
// Add some attribute that is invisible to Zircon. That will make Starnix see 3 separate mappings
// where Zircon will only see one.
SAFE_SYSCALL(
madvise(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(mapped) + (2 * page_size)),
page_size, MADV_WIPEONFORK));
// Commit pages 1-3 by writing some data.
for (int i = 1; i < 4; i++) {
volatile char* data = reinterpret_cast<char*>(mapped) + i * page_size;
data[0] = 42;
}
std::string smaps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/smaps", &smaps));
// Check that all the mappings (pages 1-3) are present in smaps, with a non-zero Rss.
auto first_mapping =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(mapped) + page_size, smaps);
ASSERT_NE(first_mapping, std::nullopt);
EXPECT_EQ(first_mapping->end - first_mapping->start, page_size);
EXPECT_GT(first_mapping->rss, 0u);
auto middle_mapping = test_helper::find_memory_mapping_ext(
reinterpret_cast<uintptr_t>(mapped) + (2 * page_size), smaps);
ASSERT_NE(middle_mapping, std::nullopt);
EXPECT_EQ(middle_mapping->end - middle_mapping->start, page_size);
EXPECT_GT(middle_mapping->rss, 0u);
auto last_mapping = test_helper::find_memory_mapping_ext(
reinterpret_cast<uintptr_t>(mapped) + (3 * page_size), smaps);
ASSERT_NE(last_mapping, std::nullopt);
EXPECT_EQ(last_mapping->end - last_mapping->start, page_size);
EXPECT_GT(last_mapping->rss, 0u);
SAFE_SYSCALL(munmap(mapped, kSize));
}
TEST_F(MMapProcTest, SmapsRssSplitMappingsStrict) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
const size_t kSize = 5 * page_size;
int flags = MAP_ANON | MAP_PRIVATE;
// Map 5 pages.
void* mapped = mmap(nullptr, kSize, PROT_READ | PROT_WRITE, flags, -1, 0);
ASSERT_NE(mapped, nullptr) << "errno=" << errno << ", " << strerror(errno);
// Mark pages 0 and 4 as non-readable/non-writable. They act as guard pages to avoid coalescing.
SAFE_SYSCALL(mprotect(mapped, page_size, PROT_NONE));
SAFE_SYSCALL(
mprotect(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(mapped) + (4 * page_size)),
page_size, PROT_NONE));
// Add some attribute that is invisible to Zircon. That will make Starnix see 3 separate mappings
// where Zircon will only see one.
SAFE_SYSCALL(
madvise(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(mapped) + (2 * page_size)),
page_size, MADV_WIPEONFORK));
// Commit the middle page by writing some data.
volatile char* data = reinterpret_cast<char*>(mapped) + (2 * page_size);
data[0] = 42;
std::string smaps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/smaps", &smaps));
// Check that all the mappings (pages 1-3) are present in smaps, with a non-zero Rss.
auto first_mapping =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(mapped) + page_size, smaps);
ASSERT_NE(first_mapping, std::nullopt);
EXPECT_EQ(first_mapping->end - first_mapping->start, page_size);
// First mapping is uncommitted
EXPECT_EQ(first_mapping->rss, 0u);
auto middle_mapping = test_helper::find_memory_mapping_ext(
reinterpret_cast<uintptr_t>(mapped) + (2 * page_size), smaps);
ASSERT_NE(middle_mapping, std::nullopt);
EXPECT_EQ(middle_mapping->end - middle_mapping->start, page_size);
// Second mapping is committed.
EXPECT_GT(middle_mapping->rss, 0u);
auto last_mapping = test_helper::find_memory_mapping_ext(
reinterpret_cast<uintptr_t>(mapped) + (3 * page_size), smaps);
ASSERT_NE(last_mapping, std::nullopt);
EXPECT_EQ(last_mapping->end - last_mapping->start, page_size);
// Third mapping is uncommitted.
EXPECT_EQ(last_mapping->rss, 0u);
SAFE_SYSCALL(munmap(mapped, kSize));
}
TEST_F(MMapProcTest, UncommittedProtNoneAndAccessibleMappingsOnFork) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
const size_t kSize = 6 * page_size;
auto mapping = test_helper::ScopedMMap::MMap(nullptr, kSize, PROT_READ | PROT_WRITE,
MAP_ANON | MAP_PRIVATE, -1, 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
void* mapped = mapping->mapping();
uintptr_t base = reinterpret_cast<uintptr_t>(mapped);
void* page0 = reinterpret_cast<void*>(base);
void* page1 = reinterpret_cast<void*>(base + page_size);
void* page2 = reinterpret_cast<void*>(base + 2 * page_size);
void* page3 = reinterpret_cast<void*>(base + 3 * page_size);
void* page4 = reinterpret_cast<void*>(base + 4 * page_size);
void* page5 = reinterpret_cast<void*>(base + 5 * page_size);
// Pages 0 and 5 are outer PROT_NONE guard pages; page 2 is an inner uncommitted PROT_NONE page.
SAFE_SYSCALL(mprotect(page0, page_size, PROT_NONE));
SAFE_SYSCALL(mprotect(page2, page_size, PROT_NONE));
SAFE_SYSCALL(mprotect(page5, page_size, PROT_NONE));
// Commit pages 1, 3, and 4, then set distinct accessible protections (rw-p, r--p, r-xp).
reinterpret_cast<volatile char*>(page1)[0] = 1;
reinterpret_cast<volatile char*>(page3)[0] = 2;
reinterpret_cast<volatile char*>(page4)[0] = 3;
SAFE_SYSCALL(mprotect(page3, page_size, PROT_READ));
SAFE_SYSCALL(mprotect(page4, page_size, PROT_READ | PROT_EXEC));
auto verify_smaps = [&]() {
std::string smaps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/smaps", &smaps));
auto rw_mapping =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(page1), smaps);
ASSERT_NE(rw_mapping, std::nullopt);
EXPECT_EQ(rw_mapping->end - rw_mapping->start, page_size);
EXPECT_EQ(rw_mapping->perms, "rw-p");
EXPECT_EQ(rw_mapping->rss, page_size / 1024);
auto prot_none_mapping =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(page2), smaps);
ASSERT_NE(prot_none_mapping, std::nullopt);
EXPECT_EQ(prot_none_mapping->end - prot_none_mapping->start, page_size);
EXPECT_EQ(prot_none_mapping->perms, "---p");
EXPECT_EQ(prot_none_mapping->rss, 0u);
auto ro_mapping =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(page3), smaps);
ASSERT_NE(ro_mapping, std::nullopt);
EXPECT_EQ(ro_mapping->end - ro_mapping->start, page_size);
EXPECT_EQ(ro_mapping->perms, "r--p");
EXPECT_EQ(ro_mapping->rss, page_size / 1024);
auto rx_mapping =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(page4), smaps);
ASSERT_NE(rx_mapping, std::nullopt);
EXPECT_EQ(rx_mapping->end - rx_mapping->start, page_size);
EXPECT_EQ(rx_mapping->perms, "r-xp");
EXPECT_EQ(rx_mapping->rss, page_size / 1024);
};
ASSERT_NO_FATAL_FAILURE(verify_smaps());
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] { ASSERT_NO_FATAL_FAILURE(verify_smaps()); });
EXPECT_TRUE(helper.WaitForChildren());
}
TEST_F(MMapProcTest, CommittedProtNonePrivateMemoryOnFork) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
const size_t kSize = 5 * page_size;
auto mapping = test_helper::ScopedMMap::MMap(nullptr, kSize, PROT_READ | PROT_WRITE,
MAP_ANON | MAP_PRIVATE, -1, 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
VerifyCommittedProtNoneMemoryOnFork(mapping->mapping(), page_size);
}
TEST_F(MMapProcTest, CommittedProtNoneFileCowMemoryOnFork) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
const size_t kSize = 5 * page_size;
test_helper::ScopedTempFD temp_file;
ASSERT_TRUE(temp_file);
SAFE_SYSCALL(ftruncate(temp_file.fd(), kSize));
auto mapping = test_helper::ScopedMMap::MMap(nullptr, kSize, PROT_READ | PROT_WRITE, MAP_PRIVATE,
temp_file.fd(), 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
VerifyCommittedProtNoneMemoryOnFork(mapping->mapping(), page_size);
}
class MMapProcStatmTest : public ProcTestBase, public testing::WithParamInterface<int> {
protected:
void ReadStatm(size_t* vm_size_out, size_t* rss_size_out) {
std::string statm;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/statm", &statm));
auto parts = SplitString(statm, " ", fxl::kTrimWhitespace, fxl::kSplitWantAll);
EXPECT_EQ(parts.size(), 7U) << statm;
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
if (vm_size_out) {
size_t vm_size_pages = 0;
EXPECT_TRUE(fxl::StringToNumberWithError(parts[0], &vm_size_pages)) << parts[0];
*vm_size_out = vm_size_pages * page_size;
}
if (rss_size_out) {
size_t rss_size_pages = 0;
EXPECT_TRUE(fxl::StringToNumberWithError(parts[1], &rss_size_pages)) << parts[1];
*rss_size_out = rss_size_pages * page_size;
}
}
};
TEST_P(MMapProcStatmTest, RssAfterUnmap) {
const size_t kSize = 4 * 1024 * 1024;
size_t vm_size_base;
size_t rss_base;
ASSERT_NO_FATAL_FAILURE(ReadStatm(&vm_size_base, &rss_base));
int flags = MAP_ANON | GetParam();
void* mapped = mmap(nullptr, kSize, PROT_READ | PROT_WRITE, flags, -1, 0);
ASSERT_NE(mapped, nullptr) << "errno=" << errno << ", " << strerror(errno);
size_t vm_size_mapped;
size_t rss_mapped;
ReadStatm(&vm_size_mapped, &rss_mapped);
EXPECT_GT(vm_size_mapped, vm_size_base);
// Commit the allocated pages by writing some data.
volatile char* data = reinterpret_cast<char*>(mapped);
size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
for (size_t i = 0; i < kSize; i += page_size) {
data[i] = 42;
}
size_t vm_size_committed;
size_t rss_committed;
ReadStatm(&vm_size_committed, &rss_committed);
EXPECT_GT(vm_size_committed, vm_size_base);
EXPECT_GT(rss_committed, rss_base);
EXPECT_GT(rss_committed, rss_mapped);
// Unmap half of the allocation.
SAFE_SYSCALL(munmap(mapped, kSize / 2));
size_t vm_size_unmapped_half;
size_t rss_unmapped_half;
ReadStatm(&vm_size_unmapped_half, &rss_unmapped_half);
EXPECT_GT(vm_size_unmapped_half, vm_size_base);
EXPECT_LT(vm_size_unmapped_half, vm_size_mapped);
EXPECT_GT(rss_unmapped_half, rss_mapped);
EXPECT_LT(rss_unmapped_half, rss_committed);
// Unmap the rest of the allocation
SAFE_SYSCALL(munmap(reinterpret_cast<char*>(mapped) + kSize / 2, kSize / 2));
size_t vm_size_unmapped_all;
size_t rss_unmapped_all;
ReadStatm(&vm_size_unmapped_all, &rss_unmapped_all);
EXPECT_LT(vm_size_unmapped_all, vm_size_unmapped_half);
EXPECT_LT(rss_unmapped_all, rss_unmapped_half);
}
TEST_P(MMapProcStatmTest, RssAfterMapOverride) {
const size_t kSize = 4 * 1024 * 1024;
size_t vm_size_base;
size_t rss_base;
ASSERT_NO_FATAL_FAILURE(ReadStatm(&vm_size_base, &rss_base));
int flags = MAP_ANON | MAP_POPULATE | GetParam();
void* mapped = mmap(nullptr, kSize, PROT_READ | PROT_WRITE, flags, -1, 0);
ASSERT_NE(mapped, nullptr) << "errno=" << errno << ", " << strerror(errno);
size_t vm_size_mapped;
size_t rss_mapped;
ReadStatm(&vm_size_mapped, &rss_mapped);
EXPECT_GT(vm_size_mapped, vm_size_base);
EXPECT_GT(rss_mapped, rss_base);
// Map middle the region again without MAP_POPULATE. This should release memory.
flags = MAP_ANON | MAP_FIXED | GetParam();
void* remap_addr = reinterpret_cast<char*>(mapped) + kSize / 4;
void* mapped2 = mmap(remap_addr, kSize / 2, PROT_READ | PROT_WRITE, flags, -1, 0);
EXPECT_EQ(mapped2, remap_addr);
size_t vm_size_remapped;
size_t rss_remapped;
ReadStatm(&vm_size_remapped, &rss_remapped);
EXPECT_LT(rss_remapped, rss_mapped);
munmap(mapped, kSize);
}
TEST_P(MMapProcStatmTest, VmSizeWithProtNoneOnForkAfterSmaps) {
const size_t kSize = 4 * 1024 * 1024;
size_t vm_size_base = 0;
ASSERT_NO_FATAL_FAILURE(ReadStatm(&vm_size_base, nullptr));
int flags = MAP_ANON | GetParam();
auto mapping = test_helper::ScopedMMap::MMap(nullptr, kSize, PROT_NONE, flags, -1, 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
void* mapped = mapping->mapping();
// Compare against `vm_size_base + kSize / 2` to tolerate small (~64 KiB) heap arena
// fluctuations from temporary string buffers in `ReadFileToString` while still verifying
// that the 4 MiB PROT_NONE mapping is accounted for in `VmSize`.
size_t vm_size_parent = 0;
ASSERT_NO_FATAL_FAILURE(ReadStatm(&vm_size_parent, nullptr));
EXPECT_GT(vm_size_parent, vm_size_base + kSize / 2);
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
// Read /proc/self/smaps before /proc/self/statm. In Starnix, MemoryManager::snapshot_of
// marks forked mappings as MappingMode::Lazy, and MemoryManager::get_stats (statm) computes
// vm_size from Zircon user VMAR mappings that are materialized when smaps is generated.
std::string smaps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/smaps", &smaps));
auto forked_mapping =
test_helper::find_memory_mapping_ext(reinterpret_cast<uintptr_t>(mapped), smaps);
ASSERT_NE(forked_mapping, std::nullopt);
EXPECT_GE(forked_mapping->end - forked_mapping->start, kSize);
EXPECT_EQ(forked_mapping->rss, 0u);
size_t vm_size_child = 0;
ASSERT_NO_FATAL_FAILURE(ReadStatm(&vm_size_child, nullptr));
EXPECT_GT(vm_size_child, vm_size_base + kSize / 2);
});
EXPECT_TRUE(helper.WaitForChildren());
}
INSTANTIATE_TEST_SUITE_P(Private, MMapProcStatmTest, testing::Values(MAP_PRIVATE));
INSTANTIATE_TEST_SUITE_P(Shared, MMapProcStatmTest, testing::Values(MAP_SHARED));
// The initial layout for each test is:
//
// ---- 0x00000000
// ~~
// ---- lowest_addr_ - start of the playground area, offset 0
// ~~
// ---- lowest_guard_region_page - start of guard region (not a mapping)
// 256 pages
// ---- initial_grows_down_low - start of MAP_GROWSDOWN mapping at the start of the test
// 2 pages (initially, expected to grow)
// ---- grows_down_high - end of MAP_GROWSDOWN mapping
// 16 pages
// ---- highest_addr_ - end of the playground area, offset playground_size()
class MapGrowsdownTest : public testing::Test {
protected:
void SetUp() override {
page_size_ = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
playground_size_ = 8 * 1024 * page_size_;
// Find a large portion of unused address space to use in tests.
void* base_addr =
mmap(nullptr, playground_size_, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(base_addr, MAP_FAILED) << "mmap failed: " << strerror(errno) << "(" << errno << ")";
SAFE_SYSCALL(munmap(base_addr, playground_size_));
lowest_addr_ = static_cast<std::byte*>(base_addr);
highest_addr_ = lowest_addr_ + playground_size_;
// Create a new mapping with MAP_GROWSDOWN a bit below the top of the playground.
initial_grows_down_size_ = 2 * page_size();
initial_grows_down_low_offset_ = playground_size() - 16 * page_size();
void* grow_initial_low_address =
MapRelative(initial_grows_down_low_offset_, initial_grows_down_size_,
PROT_READ | PROT_WRITE, MAP_GROWSDOWN);
ASSERT_NE(grow_initial_low_address, MAP_FAILED)
<< "mmap failed: " << strerror(errno) << "(" << errno << ")";
ASSERT_EQ(grow_initial_low_address, OffsetToAddress(initial_grows_down_low_offset_));
grows_down_high_offset_ = initial_grows_down_low_offset_ + initial_grows_down_size_;
}
void TearDown() override { SAFE_SYSCALL(munmap(lowest_addr_, playground_size_)); }
void* MapRelative(size_t offset, size_t len, int prot, int flags) {
return mmap(OffsetToAddress(offset), len, prot, flags | MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS,
-1, 0);
}
// Tests that a read at |offset| within the playground generates a fault.
bool TestThatReadSegfaults(intptr_t offset) {
return TestThatAccessSegfaults(OffsetToAddress(offset), test_helper::AccessType::Read);
}
// Tests that a write at |offset| within the playground generates a fault.
bool TestThatWriteSegfaults(intptr_t offset) {
return TestThatAccessSegfaults(OffsetToAddress(offset), test_helper::AccessType::Write);
}
std::byte* OffsetToAddress(intptr_t offset) { return lowest_addr_ + offset; }
char ReadAtOffset(intptr_t offset) {
return std::to_integer<char>(*static_cast<volatile std::byte*>(OffsetToAddress(offset)));
}
void WriteAtOffset(intptr_t offset) {
*static_cast<volatile std::byte*>(OffsetToAddress(offset)) = std::byte{};
}
void PrintCurrentMappingsToStderr() {
std::string maps;
ASSERT_TRUE(files::ReadFileToString("/proc/self/maps", &maps));
fprintf(stderr, "Playground area is [%p, %p)\n", lowest_addr_, highest_addr_);
fprintf(stderr, "MAP_GROWSDOWN region initially mapped to [%p, %p)\n",
OffsetToAddress(initial_grows_down_low_offset_),
OffsetToAddress(grows_down_high_offset_));
fprintf(stderr, "%s\n", maps.c_str());
}
void ResetPartialTransferMappings() {
std::byte* page_a = OffsetToAddress(initial_grows_down_low_offset() - 2 * page_size());
std::byte* page_c = OffsetToAddress(initial_grows_down_low_offset());
SAFE_SYSCALL(munmap(page_a, 2 * page_size()));
ASSERT_EQ(MapRelative(initial_grows_down_low_offset() - 2 * page_size(), page_size(),
PROT_READ | PROT_WRITE, MAP_GROWSDOWN),
page_a);
memset(page_a, 'a', page_size());
memset(page_c, 'c', page_size());
}
size_t page_size() const { return page_size_; }
size_t playground_size() const { return playground_size_; }
size_t initial_grows_down_size() const { return initial_grows_down_size_; }
intptr_t initial_grows_down_low_offset() const { return initial_grows_down_low_offset_; }
intptr_t grows_down_high_offset() const { return grows_down_high_offset_; }
std::byte* lowest_addr() const { return lowest_addr_; }
std::byte* highest_addr() const { return highest_addr_; }
private:
size_t page_size_;
size_t initial_grows_down_size_;
intptr_t initial_grows_down_low_offset_;
intptr_t grows_down_high_offset_;
size_t playground_size_;
std::byte* lowest_addr_;
std::byte* highest_addr_;
};
TEST_F(MapGrowsdownTest, Grow) {
size_t expected_guard_region_size = 256 * page_size();
// Create a mapping 4 guard page regions below the first mapping to constrain growth.
size_t gap_to_next_mapping = 4 * expected_guard_region_size;
intptr_t constraint_offset = initial_grows_down_low_offset() - gap_to_next_mapping;
void* constraint_mapping = MapRelative(constraint_offset, page_size(), PROT_NONE, 0);
ASSERT_NE(constraint_mapping, MAP_FAILED)
<< "mmap failed: " << strerror(errno) << "(" << errno << ")";
// Read from pages sequentially in the guard regions from just below the MAP_GROWSDOWN mapping
// down to the edge of the second mapping.
for (size_t i = 0; i < 4 * expected_guard_region_size / page_size(); i += 128) {
ASSERT_EQ(ReadAtOffset(initial_grows_down_low_offset() - i * page_size()), 0);
}
ASSERT_EQ(
ReadAtOffset(initial_grows_down_low_offset() - 4 * expected_guard_region_size + page_size()),
0);
// We should have grown our MAP_GROWSDOWN mapping to touch constraint_mapping. Test by trying to
// make a new mapping immediately above constraint_mapping with MAP_FIXED_NOREPLACE - this should
// fail with EXXIST.
intptr_t test_mapping_offset = constraint_offset + page_size();
void* desired_test_mapping_address = OffsetToAddress(test_mapping_offset);
void* rv = mmap(desired_test_mapping_address, page_size(), PROT_READ,
MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
EXPECT_EQ(rv, MAP_FAILED);
EXPECT_EQ(errno, EEXIST);
size_t expected_growsdown_final_size = initial_grows_down_size() + 4 * expected_guard_region_size;
intptr_t final_grows_down_offset = grows_down_high_offset() - expected_growsdown_final_size;
std::byte* final_grows_down_address = OffsetToAddress(final_grows_down_offset);
SAFE_SYSCALL(munmap(final_grows_down_address, expected_growsdown_final_size));
SAFE_SYSCALL(munmap(constraint_mapping, gap_to_next_mapping));
}
std::optional<size_t> ReadVmStkKb() {
std::string status;
if (!files::ReadFileToString("/proc/self/status", &status)) {
return std::nullopt;
}
for (const auto& line :
fxl::SplitString(status, "\n", fxl::kTrimWhitespace, fxl::kSplitWantNonEmpty)) {
if (cpp20::starts_with(line, "VmStk:")) {
size_t value = 0;
if (sscanf(line.data(), "VmStk: %zu kB", &value) == 1) {
return value;
}
}
}
return std::nullopt;
}
std::optional<size_t> ReadMainStackVmaSizeKb() {
std::string maps;
if (!files::ReadFileToString("/proc/self/maps", &maps)) {
return std::nullopt;
}
auto info = test_helper::find_memory_mapping(
[](const test_helper::MemoryMapping& mapping) { return mapping.pathname == "[stack]"; },
maps);
if (!info.has_value()) {
return std::nullopt;
}
return (info->end - info->start) / 1024;
}
TEST_F(MapGrowsdownTest, VmStkUpdatesOnGrowAndUnmap) {
const size_t page_size_kb = page_size() / 1024;
const std::optional<size_t> main_stack_kb = ReadMainStackVmaSizeKb();
ASSERT_TRUE(main_stack_kb.has_value());
EXPECT_GT(*main_stack_kb, 0u);
const std::optional<size_t> initial_vm_stk_kb = ReadVmStkKb();
ASSERT_TRUE(initial_vm_stk_kb.has_value());
// Initial VmStk includes the main thread's [stack] VMA plus the 2-page MAP_GROWSDOWN mapping
// created in MapGrowsdownTest::SetUp().
EXPECT_EQ(*initial_vm_stk_kb, *main_stack_kb + 2 * page_size_kb);
// Touch 4 pages below the initial 2-page MAP_GROWSDOWN mapping to grow it by 4 pages.
intptr_t grow_offset = initial_grows_down_low_offset() - 4 * page_size();
WriteAtOffset(grow_offset);
ASSERT_EQ(ReadAtOffset(grow_offset), '\0');
const std::optional<size_t> grown_vm_stk_kb = ReadVmStkKb();
ASSERT_TRUE(grown_vm_stk_kb.has_value());
EXPECT_EQ(*grown_vm_stk_kb, *initial_vm_stk_kb + 4 * page_size_kb);
// Shrink the 6-page MAP_GROWSDOWN region in-place to 4 pages via mremap.
void* remapped =
mremap(OffsetToAddress(grow_offset), 6 * page_size(), 4 * page_size(), /*flags=*/0);
ASSERT_EQ(remapped, OffsetToAddress(grow_offset));
const std::optional<size_t> after_shrink_vm_stk_kb = ReadVmStkKb();
ASSERT_TRUE(after_shrink_vm_stk_kb.has_value());
EXPECT_EQ(*after_shrink_vm_stk_kb, *main_stack_kb + (4 * page_size_kb));
// Split the 4-page MAP_GROWSDOWN mapping into three mappings via mprotect on the middle 2 pages;
// all resulting VMAs retain VM_GROWSDOWN so VmStk is unchanged.
const intptr_t middle_offset = grow_offset + static_cast<intptr_t>(page_size());
ASSERT_THAT(mprotect(OffsetToAddress(middle_offset), 2 * page_size(), PROT_READ),
SyscallSucceeds());
const std::optional<size_t> after_split_vm_stk_kb = ReadVmStkKb();
ASSERT_TRUE(after_split_vm_stk_kb.has_value());
EXPECT_EQ(*after_split_vm_stk_kb, *main_stack_kb + (4 * page_size_kb));
// Unmap the middle 2-page split VMA and verify VmStk decreases by 2 pages.
ASSERT_THAT(munmap(OffsetToAddress(middle_offset), 2 * page_size()), SyscallSucceeds());
const std::optional<size_t> after_partial_unmap_vm_stk_kb = ReadVmStkKb();
ASSERT_TRUE(after_partial_unmap_vm_stk_kb.has_value());
EXPECT_EQ(*after_partial_unmap_vm_stk_kb, *main_stack_kb + (2 * page_size_kb));
// Unmap the remaining pages of the MAP_GROWSDOWN region.
ASSERT_THAT(munmap(OffsetToAddress(grow_offset), 4 * page_size()), SyscallSucceeds());
const std::optional<size_t> after_unmap_vm_stk_kb = ReadVmStkKb();
ASSERT_TRUE(after_unmap_vm_stk_kb.has_value());
EXPECT_EQ(*after_unmap_vm_stk_kb, *main_stack_kb);
}
TEST_F(MapGrowsdownTest, TouchPageAbove) {
// The page immediately above the MAP_GROWSDOWN region is unmapped so issuing a read should SEGV.
ASSERT_TRUE(TestThatReadSegfaults(grows_down_high_offset()));
}
TEST_F(MapGrowsdownTest, TouchHighestGuardRegionPage) {
intptr_t highest_guard_region_page_offset = initial_grows_down_low_offset() - page_size();
intptr_t lowest_guard_region_page_offset = highest_guard_region_page_offset - 512 * page_size();
// Try making a NOREPLACE mapping just below the guard region.
intptr_t test_offset = lowest_guard_region_page_offset - page_size();
std::byte* test_address = OffsetToAddress(test_offset);
void* test_mapping = mmap(test_address, page_size(), PROT_READ,
MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(test_mapping, MAP_FAILED) << "mmap failed: " << strerror(errno) << "(" << errno << ")";
ASSERT_EQ(test_mapping, test_address);
SAFE_SYSCALL(munmap(test_mapping, page_size()));
// Read from the highest guard region page. This should trigger growth of the MAP_GROWSDOWN
// mapping by one page.
EXPECT_EQ(ReadAtOffset(test_offset), '\0');
// Now mapping the page we just touched should fail.
void* rv = mmap(test_address, page_size(), PROT_READ,
MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_EQ(rv, MAP_FAILED);
ASSERT_EQ(errno, EEXIST);
// And we shouldn't be able to make a NOREPLACE mapping in the new guard region.
test_mapping = mmap(test_address, page_size(), PROT_READ,
MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_EQ(test_mapping, MAP_FAILED);
ASSERT_EQ(errno, EEXIST);
}
#if defined(__aarch64__)
TEST_F(MapGrowsdownTest, GrowWithTaggedAddress) {
intptr_t test_offset = initial_grows_down_low_offset() - page_size();
uintptr_t untagged_addr = reinterpret_cast<uintptr_t>(OffsetToAddress(test_offset));
// Set a non-zero Top Byte Ignore (TBI) tag in bits [63:56].
uintptr_t tagged_addr = untagged_addr | (uintptr_t{0xb4} << 56);
volatile char* tagged_ptr = reinterpret_cast<volatile char*>(tagged_addr);
*tagged_ptr = 't';
EXPECT_EQ(*tagged_ptr, 't');
EXPECT_EQ(ReadAtOffset(test_offset), 't');
// Also test a tagged read fault on an unmapped page further down.
EXPECT_EQ(*(tagged_ptr - page_size()), '\0');
}
#endif
TEST_F(MapGrowsdownTest, MapNoreplaceInGuardRegion) {
// Make a MAP_GROWSDOWN mapping slightly below the top of the playground area.
size_t initial_grows_down_size = 2 * page_size();
intptr_t grow_low_offset = playground_size() - 16 * page_size();
void* grow_initial_low_address =
MapRelative(grow_low_offset, initial_grows_down_size, PROT_READ, MAP_GROWSDOWN);
ASSERT_NE(grow_initial_low_address, MAP_FAILED)
<< "mmap failed: " << strerror(errno) << "(" << errno << ")";
ASSERT_EQ(grow_initial_low_address, OffsetToAddress(grow_low_offset));
// The page immediately below grow_low_address is the highest guard page. Try making a new mapping
// in this region.
intptr_t highest_guard_region_page_offset = grow_low_offset - page_size();
std::byte* highest_guard_region_page_address = OffsetToAddress(highest_guard_region_page_offset);
void* rv = mmap(highest_guard_region_page_address, page_size(), PROT_READ,
MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_EQ(rv, highest_guard_region_page_address);
// Now that we've mapped something else into the guard region, touching the pages below the new
// mapping will no longer trigger growth of our MAP_GROWSDOWN section.
intptr_t test_offset = highest_guard_region_page_offset - page_size();
ASSERT_TRUE(TestThatReadSegfaults(test_offset));
// Unmap our mapping in the guard region.
SAFE_SYSCALL(munmap(highest_guard_region_page_address, page_size()));
// Now the region is growable again.
ASSERT_EQ(ReadAtOffset(test_offset), '\0');
// Since we've grown the region, we can no longer map into what used to be the top of the guard
// region.
rv = mmap(highest_guard_region_page_address, page_size(), PROT_READ,
MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_EQ(rv, MAP_FAILED);
ASSERT_EQ(errno, EEXIST);
}
TEST_F(MapGrowsdownTest, MapHintInGuardRegion) {
// Make a MAP_GROWSDOWN mapping slightly below the top of the playground area.
size_t initial_grows_down_size = 2 * page_size();
intptr_t grow_low_offset = playground_size() - 16 * page_size();
void* grow_initial_low_address =
MapRelative(grow_low_offset, initial_grows_down_size, PROT_READ, MAP_GROWSDOWN);
ASSERT_NE(grow_initial_low_address, MAP_FAILED)
<< "mmap failed: " << strerror(errno) << "(" << errno << ")";
ASSERT_EQ(grow_initial_low_address, OffsetToAddress(grow_low_offset));
// The page immediately below grow_low_address is the highest guard page. Try making a new mapping
// in this region.
intptr_t highest_guard_region_page_offset = grow_low_offset - page_size();
std::byte* highest_guard_region_page_address = OffsetToAddress(highest_guard_region_page_offset);
void* rv = mmap(highest_guard_region_page_address, page_size(), PROT_READ,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(rv, MAP_FAILED);
ASSERT_NE(rv, highest_guard_region_page_address);
// Unmap our new mapping, which could have been placed outside the playground.
SAFE_SYSCALL(munmap(rv, page_size()));
}
TEST_F(MapGrowsdownTest, MprotectBeforeGrow) {
// Reduce the protection on the low page of the growsdown region to read-only
SAFE_SYSCALL(mprotect(OffsetToAddress(initial_grows_down_low_offset()), page_size(),
PROT_READ | PROT_GROWSDOWN));
// The high page of the initial region should still be writable.
WriteAtOffset(grows_down_high_offset() - page_size());
// Grow the region by touching a page in the guard region.
intptr_t test_offset = initial_grows_down_low_offset() - page_size();
ASSERT_EQ(ReadAtOffset(test_offset), 0);
// The new page should have only PROT_READ protections as the mprotect on the bottom of the
// growsdown region extends to new pages.
ASSERT_TRUE(TestThatWriteSegfaults(test_offset));
}
TEST_F(MapGrowsdownTest, MprotectAfterGrow) {
// Grow the region down by 2 pages by accessing a page in the guard region.
intptr_t test_offset = initial_grows_down_low_offset() - 2 * page_size();
ASSERT_EQ(ReadAtOffset(initial_grows_down_low_offset() - 2 * page_size()), 0);
// Set protection on low page of the initial growsdown region to PROT_NONE | PROT_GROWSDOWN.
SAFE_SYSCALL(mprotect(OffsetToAddress(initial_grows_down_low_offset()), page_size(),
PROT_NONE | PROT_GROWSDOWN));
// This also changes the protection of pages below the mprotect() region, so we can no longer read
// at |test_offset|.
ASSERT_TRUE(TestThatReadSegfaults(test_offset));
}
TEST_F(MapGrowsdownTest, MprotectMixGrowsdownAndRegular) {
// Grow the region down by 3 pages by accessing a page in the guard region.
intptr_t test_offset = initial_grows_down_low_offset() - 3 * page_size();
ASSERT_EQ(ReadAtOffset(test_offset), 0);
// Now there are 5 pages with protection PROT_READ | PROT_WRITE below grows_down_high_offset().
// Reduce the protections on the second-lowest page to PROT_READ without the PROT_GROWSDOWN flag.
// This applies only to the specified range of addresses - one page, in this case.
SAFE_SYSCALL(mprotect(OffsetToAddress(initial_grows_down_low_offset() - 2 * page_size()),
page_size(), PROT_READ));
// The lowest page of the mapping should still be PROT_READ | PROT_WRITE
ASSERT_EQ(ReadAtOffset(test_offset), '\0');
WriteAtOffset(test_offset);
// Now set the second-highest page to PROT_READ with the MAP_GROWSDOWN flag.
// Unlike mprotect() without the PROT_GROWSDOWN flag, this protection applies from the specified
// range down to the next manually specified protection region.
SAFE_SYSCALL(mprotect(OffsetToAddress(initial_grows_down_low_offset()), page_size(),
PROT_READ | PROT_GROWSDOWN));
// This page and the page below it are now read-only.
ASSERT_TRUE(TestThatWriteSegfaults(initial_grows_down_low_offset()));
ASSERT_EQ(ReadAtOffset(initial_grows_down_low_offset()), '\0');
ASSERT_TRUE(TestThatWriteSegfaults(initial_grows_down_low_offset() - page_size()));
ASSERT_EQ(ReadAtOffset(initial_grows_down_low_offset() - page_size()), '\0');
// The lowest page of the mapping should still be PROT_READ | PROT_WRITE.
WriteAtOffset(test_offset);
}
TEST_F(MapGrowsdownTest, ProtectionAfterGrowWithoutProtGrowsdownFlag) {
// Reduce protection on the lowest page of the growsdown region to PROT_READ without the
// PROT_GROWSDOWN flag.
SAFE_SYSCALL(mprotect(OffsetToAddress(initial_grows_down_low_offset()), page_size(), PROT_READ));
// Grow the region down by one page with a read.
intptr_t test_offset = initial_grows_down_low_offset() - page_size();
ASSERT_EQ(ReadAtOffset(test_offset), '\0');
// The new page has protections PROT_READ from the bottom of the growsdown region, even though
// that protection was specified without the PROT_GROWSDOWN flag.
ASSERT_TRUE(TestThatWriteSegfaults(test_offset));
}
TEST_F(MapGrowsdownTest, MprotectOnAdjacentGrowsdownMapping) {
// Create a second MAP_GROWSDOWN mapping immediately below the initial mapping with PROT_READ |
// PROT_WRITE.
intptr_t second_mapping_offset = initial_grows_down_low_offset() - page_size();
void* rv = MapRelative(second_mapping_offset, page_size(), PROT_READ | PROT_WRITE, MAP_GROWSDOWN);
ASSERT_NE(rv, MAP_FAILED) << "mmap failed: " << strerror(errno) << "(" << errno << ")";
ASSERT_EQ(rv, OffsetToAddress(second_mapping_offset));
// Reduce protection on top mapping with MAP_GROWSDOWN flag.
SAFE_SYSCALL(mprotect(OffsetToAddress(initial_grows_down_low_offset()), page_size(),
PROT_READ | PROT_GROWSDOWN));
// Strangely enough, this applies through to the second mapping.
ASSERT_TRUE(TestThatWriteSegfaults(second_mapping_offset));
}
TEST_F(MapGrowsdownTest, MprotectOnAdjacentNonGrowsdownMappingBelow) {
// Create a second mapping immediately below the initial mapping with PROT_READ | PROT_WRITE.
intptr_t second_mapping_offset = initial_grows_down_low_offset() - page_size();
void* rv = MapRelative(second_mapping_offset, page_size(), PROT_READ | PROT_WRITE, 0);
ASSERT_NE(rv, MAP_FAILED) << "mmap failed: " << strerror(errno) << "(" << errno << ")";
ASSERT_EQ(rv, OffsetToAddress(second_mapping_offset));
// Reduce protection on top mapping with PROT_GROWSDOWN flag.
SAFE_SYSCALL(mprotect(OffsetToAddress(initial_grows_down_low_offset()), page_size(),
PROT_READ | PROT_GROWSDOWN));
// The protection change does not propagate to the adjacent non-MAP_GROWSDOWN mapping so it's
// still PROT_READ | PROT_WRITE.
WriteAtOffset(second_mapping_offset);
}
TEST_F(MapGrowsdownTest, SyscallReadsBelowGrowsdown) {
// This address is not in any mapping but it is just below a MAP_GROWSDOWN mapping.
std::byte* address_below_growsdown =
OffsetToAddress(initial_grows_down_low_offset() - page_size());
int fds[2];
SAFE_SYSCALL(pipe(fds));
// This syscall should grow the region to include the address read from and insert a '\0' into the
// pipe.
ASSERT_THAT(write(fds[1], address_below_growsdown, 1), SyscallSucceeds());
char buf;
SAFE_SYSCALL(read(fds[0], &buf, 1));
EXPECT_EQ(buf, '\0');
}
TEST_F(MapGrowsdownTest, SyscallWritesBelowGrowsdown) {
// This address is not in any mapping but it is just below a MAP_GROWSDOWN mapping.
std::byte* address_below_growsdown =
OffsetToAddress(initial_grows_down_low_offset() - page_size());
int fds[2];
SAFE_SYSCALL(pipe(fds));
char buf = 'a';
ASSERT_THAT(write(fds[1], &buf, 1), SyscallSucceeds());
// This syscall should grow the region to include the address written to and read an 'a' from the
// pipe.
SAFE_SYSCALL(read(fds[0], address_below_growsdown, 1));
EXPECT_EQ(std::to_integer<char>(*address_below_growsdown), 'a');
}
TEST_F(MapGrowsdownTest, PartialReadBelowGrowsdown) {
// Layout:
// Page A: [initial_grows_down_low_offset() - 2 * page_size(), ...) -> MAP_GROWSDOWN mapping
// Page B: [initial_grows_down_low_offset() - 1 * page_size(), ...) -> Unmapped (empty)
// Page C: [initial_grows_down_low_offset(), ...) -> MAP_GROWSDOWN mapping
std::byte* page_a = OffsetToAddress(initial_grows_down_low_offset() - 2 * page_size());
std::byte* page_b = OffsetToAddress(initial_grows_down_low_offset() - page_size());
std::byte* last_growsdown_page = OffsetToAddress(grows_down_high_offset() - page_size());
// Read /proc/self/mem from a forked child so Starnix uses syscall_read_memory_partial.
fbl::unique_fd mem_fd(open("/proc/self/mem", O_RDONLY));
ASSERT_TRUE(mem_fd.is_valid()) << strerror(errno);
auto check_pread_in_child = [&](std::byte* addr, size_t len, std::string_view expected) {
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
std::string buf(len, '\0');
const off64_t offset = static_cast<off64_t>(reinterpret_cast<uintptr_t>(addr));
ASSERT_EQ(pread64(mem_fd.get(), buf.data(), len, offset),
static_cast<ssize_t>(expected.size()));
buf.resize(expected.size());
EXPECT_EQ(buf, expected);
});
EXPECT_TRUE(helper.WaitForChildren());
};
const std::string a_page(page_size(), 'a');
const std::string zero_page(page_size(), '\0');
const std::string c_page(page_size(), 'c');
// Reading 2 pages starting at the last mapped page (followed by an unmapped page) reads 1 page.
ASSERT_NO_FATAL_FAILURE(ResetPartialTransferMappings());
memset(last_growsdown_page, 'z', page_size());
check_pread_in_child(last_growsdown_page, 2 * page_size(), std::string(page_size(), 'z'));
// Reading [A, B, C] extends C into B mid-read and reads all 3 pages.
ASSERT_NO_FATAL_FAILURE(ResetPartialTransferMappings());
check_pread_in_child(page_a, 3 * page_size(), a_page + zero_page + c_page);
// Reading [B, C] extends C into B and reads 2 pages.
ASSERT_NO_FATAL_FAILURE(ResetPartialTransferMappings());
check_pread_in_child(page_b, 2 * page_size(), zero_page + c_page);
// Reading [A, B] extends C into B and reads 2 pages.
ASSERT_NO_FATAL_FAILURE(ResetPartialTransferMappings());
check_pread_in_child(page_a, 2 * page_size(), a_page + zero_page);
}
TEST_F(MapGrowsdownTest, PartialWriteBelowGrowsdown) {
std::byte* page_a = OffsetToAddress(initial_grows_down_low_offset() - 2 * page_size());
std::byte* page_b = OffsetToAddress(initial_grows_down_low_offset() - page_size());
std::byte* last_growsdown_page = OffsetToAddress(grows_down_high_offset() - page_size());
// Write /proc/self/mem from a forked child so Starnix uses syscall_write_memory_partial.
fbl::unique_fd mem_fd(open("/proc/self/mem", O_RDWR));
ASSERT_TRUE(mem_fd.is_valid()) << strerror(errno);
auto check_pwrite_in_child = [&](std::byte* addr, std::string_view data, ssize_t expected_res) {
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
const off64_t offset = static_cast<off64_t>(reinterpret_cast<uintptr_t>(addr));
EXPECT_EQ(pwrite64(mem_fd.get(), data.data(), data.size(), offset), expected_res);
});
EXPECT_TRUE(helper.WaitForChildren());
};
// Writing 2 pages starting at the last mapped page (followed by an unmapped page) writes 1 page.
ASSERT_NO_FATAL_FAILURE(ResetPartialTransferMappings());
std::string two_pages(2 * page_size(), 'w');
check_pwrite_in_child(last_growsdown_page, two_pages, page_size());
EXPECT_EQ(memcmp(last_growsdown_page, two_pages.data(), page_size()), 0);
// Writing [A, B, C] extends C into B mid-write and writes all 3 pages.
ASSERT_NO_FATAL_FAILURE(ResetPartialTransferMappings());
std::string three_pages(3 * page_size(), 'x');
check_pwrite_in_child(page_a, three_pages, 3 * page_size());
EXPECT_EQ(memcmp(page_a, three_pages.data(), 3 * page_size()), 0);
// Writing [B, C] extends C into B and writes 2 pages.
ASSERT_NO_FATAL_FAILURE(ResetPartialTransferMappings());
check_pwrite_in_child(page_b, two_pages, 2 * page_size());
EXPECT_EQ(memcmp(page_b, two_pages.data(), 2 * page_size()), 0);
// Writing [A, B] extends C into B and writes 2 pages.
ASSERT_NO_FATAL_FAILURE(ResetPartialTransferMappings());
check_pwrite_in_child(page_a, two_pages, 2 * page_size());
EXPECT_EQ(memcmp(page_a, two_pages.data(), 2 * page_size()), 0);
}
TEST_F(MapGrowsdownTest, PartialZeroBelowGrowsdown) {
std::byte* page_a = OffsetToAddress(initial_grows_down_low_offset() - 2 * page_size());
std::byte* page_b = OffsetToAddress(initial_grows_down_low_offset() - page_size());
std::byte* last_growsdown_page = OffsetToAddress(grows_down_high_offset() - page_size());
fbl::unique_fd zero_fd(open("/dev/zero", O_RDONLY));
ASSERT_TRUE(zero_fd.is_valid()) << strerror(errno);
const std::string zero_page(page_size(), '\0');
// Reading 2 pages from /dev/zero into the last mapped page (followed by an unmapped page).
ASSERT_NO_FATAL_FAILURE(ResetPartialTransferMappings());
memset(last_growsdown_page, 'z', page_size());
EXPECT_EQ(read(zero_fd.get(), last_growsdown_page, 2 * page_size()),
static_cast<ssize_t>(page_size()));
EXPECT_EQ(memcmp(last_growsdown_page, zero_page.data(), page_size()), 0);
// Reading < 1 page across the boundary between mapped and unmapped page.
memset(last_growsdown_page, 'z', page_size());
EXPECT_EQ(read(zero_fd.get(), last_growsdown_page + page_size() - 16, 32), 16);
EXPECT_EQ(memcmp(last_growsdown_page + page_size() - 16, zero_page.data(), 16), 0);
// Reading [A, B, C] from /dev/zero extends C into B and zeroes all 3 pages.
ASSERT_NO_FATAL_FAILURE(ResetPartialTransferMappings());
EXPECT_EQ(read(zero_fd.get(), page_a, 3 * page_size()), static_cast<ssize_t>(3 * page_size()));
EXPECT_EQ(memcmp(page_a, zero_page.data(), page_size()), 0);
EXPECT_EQ(memcmp(page_b, zero_page.data(), page_size()), 0);
EXPECT_EQ(memcmp(page_b + page_size(), zero_page.data(), page_size()), 0);
// Reading [B, C] from /dev/zero extends C into B and zeroes 2 pages.
ASSERT_NO_FATAL_FAILURE(ResetPartialTransferMappings());
EXPECT_EQ(read(zero_fd.get(), page_b, 2 * page_size()), static_cast<ssize_t>(2 * page_size()));
EXPECT_EQ(memcmp(page_b, zero_page.data(), page_size()), 0);
EXPECT_EQ(memcmp(page_b + page_size(), zero_page.data(), page_size()), 0);
// Reading [A, B] from /dev/zero extends C into B and zeroes 2 pages.
ASSERT_NO_FATAL_FAILURE(ResetPartialTransferMappings());
EXPECT_EQ(read(zero_fd.get(), page_a, 2 * page_size()), static_cast<ssize_t>(2 * page_size()));
EXPECT_EQ(memcmp(page_a, zero_page.data(), page_size()), 0);
EXPECT_EQ(memcmp(page_b, zero_page.data(), page_size()), 0);
// waitid with WNOHANG zeroes the initial fields of siginfo_t: fails with EFAULT if straddling
// into an unmapped page, and succeeds by extending C into B if straddling [A, B].
ASSERT_NO_FATAL_FAILURE(ResetPartialTransferMappings());
test_helper::ForkHelper helper;
pid_t child = helper.RunInForkedProcess([] { pause(); });
helper.ExpectSignal(SIGKILL);
auto* partial_unmapped_siginfo =
reinterpret_cast<siginfo_t*>(last_growsdown_page + page_size() - 8);
EXPECT_THAT(
syscall(SYS_waitid, P_PID, child, partial_unmapped_siginfo, WEXITED | WNOHANG, nullptr),
SyscallFailsWithErrno(EFAULT));
auto* growsdown_siginfo = reinterpret_cast<siginfo_t*>(page_a + page_size() - 8);
EXPECT_THAT(syscall(SYS_waitid, P_PID, child, growsdown_siginfo, WEXITED | WNOHANG, nullptr),
SyscallSucceeds());
EXPECT_EQ(growsdown_siginfo->si_signo, 0);
EXPECT_EQ(growsdown_siginfo->si_code, 0);
EXPECT_EQ(growsdown_siginfo->si_pid, 0);
kill(child, SIGKILL);
EXPECT_TRUE(helper.WaitForChildren());
}
TEST(Mprotect, ProtGrowsdownOnNonGrowsdownMapping) {
size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* rv = mmap(nullptr, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(rv, MAP_FAILED) << "mmap failed: " << strerror(errno) << "(" << errno << ")";
EXPECT_EQ(mprotect(rv, page_size, PROT_READ | PROT_GROWSDOWN), -1);
EXPECT_EQ(errno, EINVAL);
}
TEST(Mprotect, UnalignedMprotectEnd) {
size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* rv = mmap(nullptr, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(rv, MAP_FAILED) << "mmap failed: " << strerror(errno) << "(" << errno << ")";
EXPECT_EQ(mprotect(rv, 5, PROT_READ), 0);
}
TEST_F(MMapProcTest, MProtectIsThreadSafe) {
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
const size_t page_size = sysconf(_SC_PAGE_SIZE);
void* mmap1 = mmap(nullptr, page_size, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(mmap1, MAP_FAILED);
uintptr_t addr = reinterpret_cast<uintptr_t>(mmap1);
ASSERT_TRUE(test_helper::TryRead(addr));
ASSERT_FALSE(test_helper::TryWrite(addr));
std::atomic<bool> start = false;
std::atomic<int> count = 2;
std::thread protect_rw([addr, &start, &count, page_size]() {
count -= 1;
while (!start) {
}
ASSERT_EQ(0, mprotect(reinterpret_cast<void*>(addr), page_size, PROT_READ | PROT_WRITE));
});
std::thread protect_none([addr, &start, &count, page_size]() {
count -= 1;
while (!start) {
}
ASSERT_EQ(0, mprotect(reinterpret_cast<void*>(addr), page_size, PROT_NONE));
});
while (count != 0) {
}
start = true;
protect_none.join();
protect_rw.join();
std::string maps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto mapping = test_helper::find_memory_mapping(addr, maps);
ASSERT_NE(mapping, std::nullopt);
std::string perms = mapping->perms;
ASSERT_FALSE(perms.empty());
if (cpp20::starts_with(std::string_view(perms), "---p")) {
// protect_none was the last one. We should not be able to read nor
// write in this mapping.
EXPECT_FALSE(test_helper::TryRead(addr));
EXPECT_FALSE(test_helper::TryWrite(addr));
} else if (cpp20::starts_with(std::string_view(perms), "rw-p")) {
// protect_rw was the last one. We should be able to read and write
// in this mapping.
EXPECT_TRUE(test_helper::TryRead(addr));
EXPECT_TRUE(test_helper::TryWrite(addr));
volatile uint8_t* ptr = reinterpret_cast<volatile uint8_t*>(addr);
*ptr = 5;
EXPECT_EQ(*ptr, 5);
} else {
ASSERT_FALSE(true) << "invalid perms for mapping: " << perms;
}
});
}
TEST(Mprotect, GrowTempFilePermissions) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
char* tmp = getenv("TEST_TMPDIR");
std::string dir = tmp == nullptr ? "/tmp" : std::string(tmp);
std::string path = dir + "/grow_temp_file_permissions";
{
uint8_t buf[] = {'a'};
fbl::unique_fd fd = fbl::unique_fd(open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0777));
ASSERT_TRUE(fd);
ASSERT_EQ(write(fd.get(), &buf[0], sizeof(buf)), 1) << errno << ": " << strerror(errno);
}
ASSERT_EQ(0, chmod(path.c_str(), S_IRUSR | S_IRGRP | S_IROTH));
std::string before;
ASSERT_TRUE(files::ReadFileToString(path, &before));
{
uint8_t buf[] = {'b'};
fbl::unique_fd fd = fbl::unique_fd(open(path.c_str(), O_RDONLY));
ASSERT_EQ(-1, write(fd.get(), buf, sizeof(buf)));
void* ptr = mmap(nullptr, page_size, PROT_READ, MAP_SHARED, fd.get(), 0);
EXPECT_NE(ptr, MAP_FAILED);
EXPECT_NE(mprotect(ptr, page_size, PROT_READ | PROT_WRITE), 0);
EXPECT_TRUE(test_helper::TestThatAccessSegfaults(ptr, test_helper::AccessType::Write));
}
std::string after;
ASSERT_TRUE(files::ReadFileToString(path, &after));
EXPECT_EQ(before, after);
ASSERT_EQ(0, unlink(path.c_str()));
}
TEST_F(MMapProcTest, MprotectFailureIsConsistent) {
// Test that even if mprotect fails, we either see the new mapping or the old
// one, and the accesses are consistent with what is reported by the kernel.
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
char* tmp = getenv("TEST_TMPDIR");
std::string dir = tmp == nullptr ? "/tmp" : std::string(tmp);
std::string path = dir + "/test_mprotect_consistent_failure";
{
uint8_t buf[] = {1};
fbl::unique_fd fd = fbl::unique_fd(open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0777));
ASSERT_TRUE(fd);
ASSERT_EQ(write(fd.get(), &buf[0], sizeof(buf)), 1);
}
fbl::unique_fd fd = fbl::unique_fd(open(path.c_str(), O_RDONLY));
ASSERT_TRUE(fd);
void* ptr = mmap(0, page_size * 3, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(ptr, MAP_FAILED);
uintptr_t ptr_addr = reinterpret_cast<uintptr_t>(ptr);
ASSERT_NE(mmap(reinterpret_cast<void*>(ptr_addr + page_size), page_size, PROT_READ,
MAP_SHARED | MAP_FIXED, fd.get(), 0),
MAP_FAILED);
ASSERT_NE(mprotect(reinterpret_cast<void*>(ptr_addr), page_size * 3,
PROT_READ | PROT_WRITE | PROT_EXEC),
0);
std::string maps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto second_page = test_helper::find_memory_mapping(ptr_addr + page_size, maps);
ASSERT_NE(second_page, std::nullopt);
EXPECT_EQ(second_page->perms, "r--s");
EXPECT_TRUE(test_helper::TryRead(ptr_addr + page_size));
EXPECT_FALSE(test_helper::TryWrite(ptr_addr + page_size));
auto test_consistency = [](const auto& mapping, uintptr_t addr) {
auto new_perms = "rwxp";
auto old_perms = "---p";
if (mapping->perms == new_perms) {
EXPECT_TRUE(test_helper::TryRead(addr));
EXPECT_TRUE(test_helper::TryWrite(addr));
volatile uint8_t* ptr = reinterpret_cast<volatile uint8_t*>(addr);
*ptr = 5;
EXPECT_EQ(*ptr, 5);
} else if (mapping->perms == old_perms) {
EXPECT_FALSE(test_helper::TryRead(addr));
EXPECT_FALSE(test_helper::TryWrite(addr));
} else {
ASSERT_FALSE(true) << "invalid perms for mapping: " << mapping->perms;
}
};
auto first_page = test_helper::find_memory_mapping(ptr_addr, maps);
ASSERT_NE(first_page, std::nullopt);
test_consistency(first_page, ptr_addr);
auto third_page = test_helper::find_memory_mapping(ptr_addr + page_size * 2, maps);
ASSERT_NE(third_page, std::nullopt);
test_consistency(third_page, ptr_addr + page_size * 2);
munmap(ptr, page_size * 3);
unlink(path.c_str());
}
TEST_F(MMapProcTest, MProtectAppliedPartially) {
// Calls mprotect on a region that contains 3 adjacent mappings:
// The first and third mapping can be mprotected with RW, but the second can't
// because it's a mapping of a read-only file.
// Tests that mprotect fails, but still changes the permissions of the
// first mapping.
// Create a file
test_helper::ScopedTempDir tmp_dir;
std::string path = tmp_dir.path() + "/test_mprotect_applied_partially";
fbl::unique_fd fd = fbl::unique_fd(open(path.c_str(), O_RDONLY | O_CREAT | O_TRUNC, 0777));
ASSERT_TRUE(fd);
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
// Find unused address space to hold the 3 adjacent mappings
char* base_address = nullptr;
{
auto mapping = test_helper::ScopedMMap::MMap(nullptr, page_size * 3, PROT_NONE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
EXPECT_TRUE(*mapping);
base_address = static_cast<char*>(mapping->mapping());
}
// Create the 3 adjacent mappings
auto first_mapping = test_helper::ScopedMMap::MMap(
base_address, page_size, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0);
auto second_mapping = test_helper::ScopedMMap::MMap(
base_address + page_size, page_size, PROT_READ, MAP_SHARED | MAP_FIXED, fd.get(), 0);
auto third_mapping =
test_helper::ScopedMMap::MMap(base_address + 2 * page_size, page_size, PROT_NONE,
MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0);
ASSERT_TRUE(*first_mapping);
ASSERT_TRUE(*second_mapping);
ASSERT_TRUE(*third_mapping);
// Helper that checks if the permissions of `mapping` match `expected_perms`.
auto perms_of_mapping_match = [this](test_helper::ScopedMMap& mapping,
std::string expected_perms) -> testing::AssertionResult {
std::string maps;
if (!files::ReadFileToString(proc_path() + "/self/maps", &maps)) {
return testing::AssertionFailure() << "reading /proc/self/maps failed";
}
auto first_mapping_report =
test_helper::find_memory_mapping(reinterpret_cast<uintptr_t>(mapping.mapping()), maps);
if (!first_mapping_report.has_value()) {
return testing::AssertionFailure() << "mapping not found in /proc/self/maps";
}
if (first_mapping_report->perms != expected_perms) {
return testing::AssertionFailure()
<< "expected perms " << expected_perms << ", got " << first_mapping_report->perms;
}
return testing::AssertionSuccess();
};
// Check the permissions before and after `mprotect`.
EXPECT_TRUE(perms_of_mapping_match(*first_mapping, "---p"));
EXPECT_TRUE(perms_of_mapping_match(*third_mapping, "---p"));
errno = 0;
EXPECT_EQ(mprotect(first_mapping->mapping(), page_size * 3, PROT_READ | PROT_WRITE), -1);
EXPECT_EQ(errno, EACCES);
EXPECT_TRUE(perms_of_mapping_match(*first_mapping, "rw-p"));
EXPECT_TRUE(perms_of_mapping_match(*third_mapping, "---p"));
}
TEST_F(MMapProcTest, PrivateFileMappingCanBeWritableAndExecutable) {
// A `MAP_PRIVATE` mapping of a regular file can be simultaneously writable and executable, even
// if the file descriptor is read-only. Writes through the mapping are visible in the mapping but
// are not carried through to the underlying file.
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir tmp_dir;
std::string path = tmp_dir.path() + "/private_rwx_file";
{
fbl::unique_fd fd(open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0755));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
std::vector<uint8_t> contents(page_size, 0xAA);
ASSERT_EQ(write(fd.get(), contents.data(), contents.size()), static_cast<ssize_t>(page_size));
}
fbl::unique_fd fd(open(path.c_str(), O_RDONLY));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
auto mapping = test_helper::ScopedMMap::MMap(
nullptr, page_size, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE, fd.get(), 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
uintptr_t addr = reinterpret_cast<uintptr_t>(mapping->mapping());
std::string maps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto mapping_report = test_helper::find_memory_mapping(addr, maps);
ASSERT_NE(mapping_report, std::nullopt);
EXPECT_EQ(mapping_report->perms, "rwxp");
volatile uint8_t* bytes = reinterpret_cast<volatile uint8_t*>(addr);
EXPECT_EQ(bytes[0], 0xAA);
bytes[0] = 0xBB;
EXPECT_EQ(bytes[0], 0xBB);
uint8_t file_byte = 0;
ASSERT_EQ(pread(fd.get(), &file_byte, 1, 0), 1);
EXPECT_EQ(file_byte, 0xAA);
}
TEST_F(MMapProcTest, PrivateFileMappingMprotectMergesMappings) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir tmp_dir;
std::string path = tmp_dir.path() + "/private_merge_file";
fbl::unique_fd fd(open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0644));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
SAFE_SYSCALL(ftruncate(fd.get(), page_size * 3));
auto expect_single_mapping = [&](uintptr_t addr, size_t length, const char* expected_perms) {
std::string maps;
EXPECT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto report = test_helper::find_memory_mapping(addr, maps);
EXPECT_NE(report, std::nullopt);
if (report.has_value()) {
EXPECT_EQ(report->start, addr);
EXPECT_EQ(report->end, addr + length);
EXPECT_EQ(report->perms, expected_perms);
}
};
auto set_prot = [&](uintptr_t addr, size_t page, int prot) {
SAFE_SYSCALL(mprotect(reinterpret_cast<void*>(addr + page * page_size), page_size, prot));
};
{
auto mapping =
test_helper::ScopedMMap::MMap(nullptr, page_size * 2, PROT_READ, MAP_PRIVATE, fd.get(), 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
uintptr_t addr = reinterpret_cast<uintptr_t>(mapping->mapping());
expect_single_mapping(addr, page_size * 2, "r--p");
// mprotect(PROT_WRITE) on two consecutive pages should merge into one mapping in
// /proc/self/maps.
set_prot(addr, 0, PROT_READ | PROT_WRITE);
set_prot(addr, 1, PROT_READ | PROT_WRITE);
expect_single_mapping(addr, page_size * 2, "rw-p");
}
{
// Splitting a read-only private file mapping first (with PROT_NONE) and then promoting
// consecutive pages to PROT_WRITE should also merge them into one mapping.
auto mapping =
test_helper::ScopedMMap::MMap(nullptr, page_size * 2, PROT_READ, MAP_PRIVATE, fd.get(), 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
uintptr_t addr = reinterpret_cast<uintptr_t>(mapping->mapping());
set_prot(addr, 0, PROT_NONE);
set_prot(addr, 0, PROT_READ | PROT_WRITE);
set_prot(addr, 1, PROT_READ | PROT_WRITE);
expect_single_mapping(addr, page_size * 2, "rw-p");
}
{
// Split a 3-page mapping into 3 pieces, then promote the last piece first so that the pieces
// preceding it must be promoted along with it.
auto mapping =
test_helper::ScopedMMap::MMap(nullptr, page_size * 3, PROT_READ, MAP_PRIVATE, fd.get(), 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
uintptr_t addr = reinterpret_cast<uintptr_t>(mapping->mapping());
set_prot(addr, 1, PROT_NONE);
set_prot(addr, 2, PROT_READ | PROT_WRITE);
set_prot(addr, 1, PROT_READ | PROT_WRITE);
set_prot(addr, 0, PROT_READ | PROT_WRITE);
expect_single_mapping(addr, page_size * 3, "rw-p");
volatile uint8_t* bytes = reinterpret_cast<volatile uint8_t*>(addr);
bytes[0] = 0xBB;
EXPECT_EQ(bytes[0], 0xBB);
uint8_t file_byte = 0xFF;
ASSERT_EQ(pread(fd.get(), &file_byte, 1, 0), 1);
EXPECT_EQ(file_byte, 0);
}
{
// Split a 3-page mapping into 3 pieces before forking. In the child, promote the middle piece
// first and then promote the pieces on either side: they should merge into a single mapping.
// Note that on Linux, `mprotect(PROT_WRITE)` permanently sets `VM_ACCOUNT` on a private VMA,
// so the pieces only merge once all of them have been made writable.
auto mapping =
test_helper::ScopedMMap::MMap(nullptr, page_size * 3, PROT_READ, MAP_PRIVATE, fd.get(), 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
uintptr_t addr = reinterpret_cast<uintptr_t>(mapping->mapping());
set_prot(addr, 1, PROT_NONE);
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
set_prot(addr, 1, PROT_READ | PROT_WRITE);
set_prot(addr, 0, PROT_READ | PROT_WRITE);
set_prot(addr, 2, PROT_READ | PROT_WRITE);
expect_single_mapping(addr, page_size * 3, "rw-p");
});
EXPECT_TRUE(helper.WaitForChildren());
}
}
// Split a 3-page writable private file mapping by making the outer pages read-only, modify the
// middle page via `pread` from `/proc/self/exe` (which writes directly into the user VMAR via
// `zx::Stream::readv_at`), and verify that restoring `PROT_WRITE` on the outer pages merges all
// three pieces back into a single mapping.
TEST_F(MMapProcTest, PrivateFileMappingMprotectMergesMappingsWithPread) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir tmp_dir;
std::string path = tmp_dir.path() + "/private_merge_pread_file";
fbl::unique_fd fd(open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0644));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
SAFE_SYSCALL(ftruncate(fd.get(), page_size * 3));
auto set_prot = [&](uintptr_t addr, size_t page, int prot) {
SAFE_SYSCALL(mprotect(reinterpret_cast<void*>(addr + page * page_size), page_size, prot));
};
auto mapping = test_helper::ScopedMMap::MMap(
/* addr = */ nullptr, page_size * 3, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd.get(),
/* offset = */ 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
uintptr_t addr = reinterpret_cast<uintptr_t>(mapping->mapping());
set_prot(addr, /* page = */ 0, PROT_READ);
set_prot(addr, /* page = */ 2, PROT_READ);
fbl::unique_fd exe_fd(open("/proc/self/exe", O_RDONLY));
ASSERT_TRUE(exe_fd.is_valid()) << strerror(errno);
ASSERT_THAT(pread(exe_fd.get(), reinterpret_cast<void*>(addr + page_size), /* count = */ 4,
/* offset = */ 0),
SyscallSucceedsWithValue(4));
set_prot(addr, /* page = */ 0, PROT_READ | PROT_WRITE);
set_prot(addr, /* page = */ 2, PROT_READ | PROT_WRITE);
std::string maps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto report = test_helper::find_memory_mapping(addr, maps);
ASSERT_NE(report, std::nullopt);
EXPECT_EQ(report->start, addr);
EXPECT_EQ(report->end, addr + page_size * 3);
EXPECT_EQ(report->perms, "rw-p");
uint8_t file_byte = 0xFF;
ASSERT_THAT(
pread(fd.get(), &file_byte, /* count = */ 1, /* offset = */ static_cast<off_t>(page_size)),
SyscallSucceedsWithValue(1));
EXPECT_EQ(file_byte, 0);
}
// Verify that once a writable private file mapping is modified, its copy-on-write state is
// preserved in both parent and child across `fork()`, allowing split pieces to coalesce in
// `/proc/self/maps` when their protections match again.
TEST_F(MMapProcTest, PrivateFileMappingCowModifiedPreservedAcrossFork) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir tmp_dir;
std::string path = tmp_dir.path() + "/private_cow_fork_preserved_file";
fbl::unique_fd fd(open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0644));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
SAFE_SYSCALL(ftruncate(fd.get(), page_size * 3));
auto expect_single_mapping = [&](uintptr_t addr, size_t length, const char* expected_perms) {
std::string maps;
EXPECT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto report = test_helper::find_memory_mapping(addr, maps);
EXPECT_NE(report, std::nullopt);
if (report.has_value()) {
EXPECT_EQ(report->start, addr);
EXPECT_EQ(report->end, addr + length);
EXPECT_EQ(report->perms, expected_perms);
}
};
auto expect_split_mappings = [&](uintptr_t addr) {
std::string maps;
EXPECT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
for (size_t i = 0; i < 3; ++i) {
auto report = test_helper::find_memory_mapping(addr + i * page_size, maps);
EXPECT_NE(report, std::nullopt);
if (report.has_value()) {
EXPECT_EQ(report->start, addr + i * page_size);
EXPECT_EQ(report->end, addr + (i + 1) * page_size);
EXPECT_EQ(report->perms, "rw-p");
}
}
};
auto mapping = test_helper::ScopedMMap::MMap(
/* addr = */ nullptr, page_size * 3, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd.get(),
/* offset = */ 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
uintptr_t addr = reinterpret_cast<uintptr_t>(mapping->mapping());
// Modify the first page before splitting the 3-page mapping into two pieces separated by a
// read-only middle page, then fork.
reinterpret_cast<volatile uint8_t*>(addr)[0] = 0xAB;
SAFE_SYSCALL(mprotect(reinterpret_cast<void*>(addr + page_size), page_size, PROT_READ));
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(addr)[0], 0xAB);
// Write to the first page while the middle page is read-only so the write only touches the
// first piece, then restore write permissions on the middle page. On Starnix all 3 pages
// coalesce back into a single mapping, whereas on Linux private mappings that were modified and
// split before `fork()` remain separate in the child process.
reinterpret_cast<volatile uint8_t*>(addr)[0] = 0xCD;
SAFE_SYSCALL(
mprotect(reinterpret_cast<void*>(addr + page_size), page_size, PROT_READ | PROT_WRITE));
if (test_helper::IsStarnix()) {
expect_single_mapping(addr, page_size * 3, "rw-p");
} else {
expect_split_mappings(addr);
}
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(addr)[0], 0xCD);
});
EXPECT_TRUE(helper.WaitForChildren());
SAFE_SYSCALL(
mprotect(reinterpret_cast<void*>(addr + page_size), page_size, PROT_READ | PROT_WRITE));
expect_single_mapping(addr, page_size * 3, "rw-p");
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(addr)[0], 0xAB);
}
// Verify that copy-on-write modifications made in a child process after `fork()` are independent
// from the parent process.
TEST_F(MMapProcTest, PrivateFileMappingCowModifiedIndependentAcrossFork) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir tmp_dir;
std::string path = tmp_dir.path() + "/private_cow_fork_independent_file";
fbl::unique_fd fd(open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0644));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
SAFE_SYSCALL(ftruncate(fd.get(), page_size * 2));
auto expect_single_mapping = [&](uintptr_t addr, size_t length, const char* expected_perms) {
std::string maps;
EXPECT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto report = test_helper::find_memory_mapping(addr, maps);
EXPECT_NE(report, std::nullopt);
if (report.has_value()) {
EXPECT_EQ(report->start, addr);
EXPECT_EQ(report->end, addr + length);
EXPECT_EQ(report->perms, expected_perms);
}
};
auto mapping = test_helper::ScopedMMap::MMap(
/* addr = */ nullptr, page_size * 2, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd.get(),
/* offset = */ 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
uintptr_t addr = reinterpret_cast<uintptr_t>(mapping->mapping());
// Split the unmodified 2-page writable mapping before forking.
SAFE_SYSCALL(mprotect(reinterpret_cast<void*>(addr + page_size), page_size, PROT_READ));
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
// Modify the first page in the child, then restore write permissions on the second page: both
// pieces should still coalesce in the child.
reinterpret_cast<volatile uint8_t*>(addr)[0] = 0xEF;
SAFE_SYSCALL(
mprotect(reinterpret_cast<void*>(addr + page_size), page_size, PROT_READ | PROT_WRITE));
expect_single_mapping(addr, page_size * 2, "rw-p");
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(addr)[0], 0xEF);
});
EXPECT_TRUE(helper.WaitForChildren());
// The parent's mapping remains unmodified and coalesces when write permissions are restored.
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(addr)[0], 0);
SAFE_SYSCALL(
mprotect(reinterpret_cast<void*>(addr + page_size), page_size, PROT_READ | PROT_WRITE));
expect_single_mapping(addr, page_size * 2, "rw-p");
}
// Verify that shrinking and regrowing a modified private file mapping via `mremap()` preserves its
// copy-on-write state across the remapped range.
TEST_F(MMapProcTest, PrivateFileMappingMremapShrinkAndRegrowPreservesCowModified) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir tmp_dir;
std::string path = tmp_dir.path() + "/private_cow_mremap_shrink_regrow_file";
fbl::unique_fd fd(open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0644));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
SAFE_SYSCALL(ftruncate(fd.get(), page_size * 3));
auto expect_single_mapping = [&](uintptr_t addr, size_t length, const char* expected_perms) {
std::string maps;
EXPECT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto report = test_helper::find_memory_mapping(addr, maps);
EXPECT_NE(report, std::nullopt);
if (report.has_value()) {
EXPECT_EQ(report->start, addr);
EXPECT_EQ(report->end, addr + length);
EXPECT_EQ(report->perms, expected_perms);
}
};
auto mapping = test_helper::ScopedMMap::MMap(
/* addr = */ nullptr, page_size * 3, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd.get(),
/* offset = */ 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
uintptr_t addr = reinterpret_cast<uintptr_t>(mapping->mapping());
// Shrink the 3-page mapping down to 2 pages, split off the second page as read-only, modify the
// first page, regrow the first page to 2 pages (replacing the read-only second page), and then
// regrow to 3 pages: all 3 pages remain in a single coalesced mapping with the modification
// intact.
void* shrunk = mremap(reinterpret_cast<void*>(addr), page_size * 3, page_size * 2,
/* flags = */ 0);
ASSERT_EQ(shrunk, reinterpret_cast<void*>(addr)) << strerror(errno);
SAFE_SYSCALL(mprotect(reinterpret_cast<void*>(addr + page_size), page_size, PROT_READ));
reinterpret_cast<volatile uint8_t*>(addr)[0] = 0xAB;
SAFE_SYSCALL(munmap(reinterpret_cast<void*>(addr + page_size), page_size));
void* grown = mremap(reinterpret_cast<void*>(addr), page_size, page_size * 3, /* flags = */ 0);
ASSERT_EQ(grown, reinterpret_cast<void*>(addr)) << strerror(errno);
expect_single_mapping(addr, page_size * 3, "rw-p");
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(addr)[0], 0xAB);
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(addr + page_size)[0], 0);
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(addr + page_size * 2)[0], 0);
}
// Verify that shrinking a modified private file mapping via `mremap()` and mapping the unmapped
// range again from the source file keeps modifications to the first mapping isolated from the
// newly mapped range.
TEST_F(MMapProcTest, PrivateFileMappingMremapShrinkAndMmapRetainsSeparateMappings) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir tmp_dir;
std::string path = tmp_dir.path() + "/private_cow_mremap_shrink_mmap_file";
fbl::unique_fd fd(open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0644));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
SAFE_SYSCALL(ftruncate(fd.get(), page_size * 2));
auto mapping = test_helper::ScopedMMap::MMap(
/* addr = */ nullptr, page_size * 2, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd.get(),
/* offset = */ 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
uintptr_t addr = reinterpret_cast<uintptr_t>(mapping->mapping());
reinterpret_cast<volatile uint8_t*>(addr)[0] = 0xAB;
reinterpret_cast<volatile uint8_t*>(addr + page_size)[0] = 0xCD;
void* shrunk = mremap(reinterpret_cast<void*>(addr), page_size * 2, page_size, /* flags = */ 0);
ASSERT_EQ(shrunk, reinterpret_cast<void*>(addr)) << strerror(errno);
// Map the second page again from the underlying file: it should observe the unmodified file
// contents (`0`) while the first page retains its copy-on-write modification (`0xAB`), and on
// Starnix the two mappings remain distinct in `/proc/self/maps` because they are backed by
// separate copy-on-write child VMOs, whereas Linux coalesces them into a single mapping.
void* remapped = mmap(/* addr = */ reinterpret_cast<void*>(addr + page_size), page_size,
PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED, /* fd = */ fd.get(),
/* offset = */ static_cast<off_t>(page_size));
ASSERT_EQ(remapped, reinterpret_cast<void*>(addr + page_size)) << strerror(errno);
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(addr)[0], 0xAB);
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(addr + page_size)[0], 0);
std::string maps;
ASSERT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto first = test_helper::find_memory_mapping(addr, maps);
ASSERT_NE(first, std::nullopt);
EXPECT_EQ(first->start, addr);
EXPECT_EQ(first->perms, "rw-p");
if (test_helper::IsStarnix()) {
EXPECT_EQ(first->end, addr + page_size);
auto second = test_helper::find_memory_mapping(addr + page_size, maps);
ASSERT_NE(second, std::nullopt);
EXPECT_EQ(second->start, addr + page_size);
EXPECT_EQ(second->end, addr + page_size * 2);
EXPECT_EQ(second->perms, "rw-p");
} else {
EXPECT_EQ(first->end, addr + page_size * 2);
}
}
// Verify that moving pages of a modified private file mapping to a second location via `mremap()`
// preserves their copy-on-write state across `mremap()` and `fork()`.
TEST_F(MMapProcTest, PrivateFileMappingMremapMovePreservesCowModified) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir tmp_dir;
std::string path = tmp_dir.path() + "/private_cow_mremap_move_file";
fbl::unique_fd fd(open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0644));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
SAFE_SYSCALL(ftruncate(fd.get(), page_size * 3));
auto expect_single_mapping = [&](uintptr_t addr, size_t length, const char* expected_perms) {
std::string maps;
EXPECT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto report = test_helper::find_memory_mapping(addr, maps);
EXPECT_NE(report, std::nullopt);
if (report.has_value()) {
EXPECT_EQ(report->start, addr);
EXPECT_EQ(report->end, addr + length);
EXPECT_EQ(report->perms, expected_perms);
}
};
auto expect_split_mappings = [&](uintptr_t addr) {
std::string maps;
EXPECT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
for (size_t i = 0; i < 3; ++i) {
auto report = test_helper::find_memory_mapping(addr + i * page_size, maps);
EXPECT_NE(report, std::nullopt);
if (report.has_value()) {
EXPECT_EQ(report->start, addr + i * page_size);
EXPECT_EQ(report->end, addr + (i + 1) * page_size);
EXPECT_EQ(report->perms, "rw-p");
}
}
};
auto mapping = test_helper::ScopedMMap::MMap(
/* addr = */ nullptr, page_size * 3, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd.get(),
/* offset = */ 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
uintptr_t src_addr = reinterpret_cast<uintptr_t>(mapping->mapping());
reinterpret_cast<volatile uint8_t*>(src_addr)[0] = 0xAB;
reinterpret_cast<volatile uint8_t*>(src_addr + page_size)[0] = 0xBC;
// Move the middle page to `dst_addr`, leaving an unmapped gap between `page 0` and `page 2`.
void* dst_addr = mmap(/* addr = */ nullptr, page_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS,
/* fd = */ -1, /* offset = */ 0);
ASSERT_NE(dst_addr, MAP_FAILED) << strerror(errno);
auto cleanup_dst = fit::defer([&] { SAFE_SYSCALL(munmap(dst_addr, page_size)); });
void* moved = mremap(reinterpret_cast<void*>(src_addr + page_size), page_size, page_size,
MREMAP_MAYMOVE | MREMAP_FIXED, dst_addr);
ASSERT_EQ(moved, dst_addr) << strerror(errno);
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(src_addr)[0], 0xAB);
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(dst_addr)[0], 0xBC);
// Write to `page 0` while `page 1` is an unmapped gap so the write only affects `page 0`, and
// verify `page 2` and `dst_addr` remain readable.
reinterpret_cast<volatile uint8_t*>(src_addr)[0] = 0xCD;
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(src_addr + page_size * 2)[0], 0);
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(dst_addr)[0], 0xBC);
// Moving `dst_addr` back into the middle gap preserves its contents; on Starnix all 3 pages
// also coalesce back into a single mapping, whereas on Linux private mappings that were
// modified and split before `fork()` remain separate in the child process.
void* restored = mremap(dst_addr, page_size, page_size, MREMAP_MAYMOVE | MREMAP_FIXED,
reinterpret_cast<void*>(src_addr + page_size));
ASSERT_EQ(restored, reinterpret_cast<void*>(src_addr + page_size)) << strerror(errno);
if (test_helper::IsStarnix()) {
expect_single_mapping(src_addr, page_size * 3, "rw-p");
} else {
expect_split_mappings(src_addr);
}
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(src_addr)[0], 0xCD);
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(src_addr + page_size)[0], 0xBC);
});
EXPECT_TRUE(helper.WaitForChildren());
void* restored = mremap(dst_addr, page_size, page_size, MREMAP_MAYMOVE | MREMAP_FIXED,
reinterpret_cast<void*>(src_addr + page_size));
ASSERT_EQ(restored, reinterpret_cast<void*>(src_addr + page_size)) << strerror(errno);
cleanup_dst.cancel();
expect_single_mapping(src_addr, page_size * 3, "rw-p");
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(src_addr)[0], 0xAB);
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(src_addr + page_size)[0], 0xBC);
}
// Verify that when part of an unmodified private file mapping is moved to a second location via
// `mremap()` and then modified:
// - If the mapping was already promoted onto a shared copy-on-write child VMO before `mremap()`
// (via `mprotect(PROT_READ | PROT_WRITE)` on a `PROT_READ` mapping), modifying the moved piece
// updates the copy-on-write modified state on the stationary pieces too so they coalesce again on
// Starnix.
// - If the mapping was created writable (`PROT_READ | PROT_WRITE`) so copy-on-write child VMO
// creation is deferred until the first write, modifying the moved piece only promotes that piece
// while the non-contiguous stationary pieces stay backed by the file VMO and remain separate when
// the moved piece is remapped back into the gap.
TEST_F(MMapProcTest, PrivateFileMappingMremapModifyMovedUpdatesOriginalCowModified) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir tmp_dir;
std::string path = tmp_dir.path() + "/private_cow_mremap_modify_moved_file";
fbl::unique_fd fd(open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0644));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
SAFE_SYSCALL(ftruncate(fd.get(), page_size * 3));
auto expect_single_mapping = [&](uintptr_t addr, size_t length, const char* expected_perms) {
std::string maps;
EXPECT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto report = test_helper::find_memory_mapping(addr, maps);
EXPECT_NE(report, std::nullopt);
if (report.has_value()) {
EXPECT_EQ(report->start, addr);
EXPECT_EQ(report->end, addr + length);
EXPECT_EQ(report->perms, expected_perms);
}
};
auto expect_split_mappings = [&](uintptr_t addr) {
std::string maps;
EXPECT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
for (size_t i = 0; i < 3; ++i) {
auto report = test_helper::find_memory_mapping(addr + i * page_size, maps);
EXPECT_NE(report, std::nullopt);
if (report.has_value()) {
EXPECT_EQ(report->start, addr + i * page_size);
EXPECT_EQ(report->end, addr + (i + 1) * page_size);
EXPECT_EQ(report->perms, "rw-p");
}
}
};
{
// Map `PROT_READ` and promote to `PROT_READ | PROT_WRITE` via `mprotect()` so all 3 pages share
// an unmodified copy-on-write child VMO before `mremap()` splits the mapping.
auto mapping = test_helper::ScopedMMap::MMap(
/* addr = */ nullptr, page_size * 3, PROT_READ, MAP_PRIVATE, fd.get(),
/* offset = */ 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
uintptr_t src_addr = reinterpret_cast<uintptr_t>(mapping->mapping());
SAFE_SYSCALL(
mprotect(reinterpret_cast<void*>(src_addr), page_size * 3, PROT_READ | PROT_WRITE));
// Move the middle page of the unmodified mapping to `dst_addr`, leaving `page 0` and `page 2`
// at `src_addr` separated by an unmapped gap.
void* dst_addr = mmap(/* addr = */ nullptr, page_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS,
/* fd = */ -1, /* offset = */ 0);
ASSERT_NE(dst_addr, MAP_FAILED) << strerror(errno);
auto cleanup_dst = fit::defer([&] { SAFE_SYSCALL(munmap(dst_addr, page_size)); });
void* moved = mremap(reinterpret_cast<void*>(src_addr + page_size), page_size, page_size,
MREMAP_MAYMOVE | MREMAP_FIXED, dst_addr);
ASSERT_EQ(moved, dst_addr) << strerror(errno);
// Modify the moved mapping at `dst_addr`, then move it back into the middle gap: the moved
// page retains its modification (without altering the underlying file), and on Starnix both the
// moved piece and the stationary pieces share the same copy-on-write state and coalesce back
// into a single 3-page mapping.
reinterpret_cast<volatile uint8_t*>(dst_addr)[0] = 0xAB;
void* restored = mremap(dst_addr, page_size, page_size, MREMAP_MAYMOVE | MREMAP_FIXED,
reinterpret_cast<void*>(src_addr + page_size));
ASSERT_EQ(restored, reinterpret_cast<void*>(src_addr + page_size)) << strerror(errno);
cleanup_dst.cancel();
if (test_helper::IsStarnix()) {
expect_single_mapping(src_addr, page_size * 3, "rw-p");
} else {
expect_split_mappings(src_addr);
}
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(src_addr + page_size)[0], 0xAB);
uint8_t file_byte = 0xFF;
ASSERT_THAT(pread(fd.get(), &file_byte, 1, static_cast<off_t>(page_size)),
SyscallSucceedsWithValue(1));
EXPECT_EQ(file_byte, 0);
}
{
// Map directly with `PROT_READ | PROT_WRITE` so copy-on-write child VMO creation is deferred
// until the first write. Moving the middle page before any write and then modifying it promotes
// only the moved page, leaving the non-contiguous stationary pages backed by the file VMO so
// the 3 pages remain separate mappings when the middle page is moved back.
auto mapping = test_helper::ScopedMMap::MMap(
/* addr = */ nullptr, page_size * 3, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd.get(),
/* offset = */ 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
uintptr_t src_addr = reinterpret_cast<uintptr_t>(mapping->mapping());
void* dst_addr = mmap(/* addr = */ nullptr, page_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS,
/* fd = */ -1, /* offset = */ 0);
ASSERT_NE(dst_addr, MAP_FAILED) << strerror(errno);
auto cleanup_dst = fit::defer([&] { SAFE_SYSCALL(munmap(dst_addr, page_size)); });
void* moved = mremap(reinterpret_cast<void*>(src_addr + page_size), page_size, page_size,
MREMAP_MAYMOVE | MREMAP_FIXED, dst_addr);
ASSERT_EQ(moved, dst_addr) << strerror(errno);
reinterpret_cast<volatile uint8_t*>(dst_addr)[0] = 0xCD;
void* restored = mremap(dst_addr, page_size, page_size, MREMAP_MAYMOVE | MREMAP_FIXED,
reinterpret_cast<void*>(src_addr + page_size));
ASSERT_EQ(restored, reinterpret_cast<void*>(src_addr + page_size)) << strerror(errno);
cleanup_dst.cancel();
expect_split_mappings(src_addr);
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(src_addr + page_size)[0], 0xCD);
uint8_t file_byte = 0xFF;
ASSERT_THAT(pread(fd.get(), &file_byte, 1, static_cast<off_t>(page_size)),
SyscallSucceedsWithValue(1));
EXPECT_EQ(file_byte, 0);
}
}
// Verify that modifying a private file mapping does not mark a second independent private mapping
// of the same file descriptor as copy-on-write modified.
TEST_F(MMapProcTest, PrivateFileMappingSecondMmapIsNotCowModified) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir tmp_dir;
std::string path = tmp_dir.path() + "/private_cow_second_mmap_file";
fbl::unique_fd fd(open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0644));
ASSERT_TRUE(fd.is_valid()) << strerror(errno);
SAFE_SYSCALL(ftruncate(fd.get(), page_size * 2));
auto expect_single_mapping = [&](uintptr_t addr, size_t length, const char* expected_perms) {
std::string maps;
EXPECT_TRUE(files::ReadFileToString(proc_path() + "/self/maps", &maps));
auto report = test_helper::find_memory_mapping(addr, maps);
EXPECT_NE(report, std::nullopt);
if (report.has_value()) {
EXPECT_EQ(report->start, addr);
EXPECT_EQ(report->end, addr + length);
EXPECT_EQ(report->perms, expected_perms);
}
};
auto first_mapping = test_helper::ScopedMMap::MMap(
/* addr = */ nullptr, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd.get(),
/* offset = */ 0);
ASSERT_THAT(first_mapping, SyscallResultIsOk());
uintptr_t first_addr = reinterpret_cast<uintptr_t>(first_mapping->mapping());
// Modify the first private mapping.
reinterpret_cast<volatile uint8_t*>(first_addr)[0] = 0xAB;
// Map the same file privately a second time. The second mapping is backed by its own unmodified
// copy-on-write state: it observes the original file contents (`0`), and splitting it via
// `mprotect()` and restoring permissions coalesces it back into a single mapping.
auto second_mapping = test_helper::ScopedMMap::MMap(
/* addr = */ nullptr, page_size * 2, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd.get(),
/* offset = */ 0);
ASSERT_THAT(second_mapping, SyscallResultIsOk());
uintptr_t second_addr = reinterpret_cast<uintptr_t>(second_mapping->mapping());
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(first_addr)[0], 0xAB);
EXPECT_EQ(reinterpret_cast<volatile uint8_t*>(second_addr)[0], 0);
SAFE_SYSCALL(mprotect(reinterpret_cast<void*>(second_addr + page_size), page_size, PROT_READ));
SAFE_SYSCALL(mprotect(reinterpret_cast<void*>(second_addr + page_size), page_size,
PROT_READ | PROT_WRITE));
expect_single_mapping(second_addr, page_size * 2, "rw-p");
}
class MMapAllProtectionsTest : public testing::TestWithParam<std::tuple<int, int>> {};
TEST_P(MMapAllProtectionsTest, PrivateFileMappingAllowAllProtections) {
// Calls with the given protection levels `mmap` with `MAP_PRIVATE` and `mprotect`.
// Does so over various file descriptors, and expect the calls to succeed.
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempDir tmp_dir;
std::string path = tmp_dir.path() + "/private_mapped_file";
std::vector<fbl::unique_fd> fds;
fds.emplace_back(test_helper::MemFdCreate("try_read", O_RDONLY));
fds.emplace_back(open("/proc/self/exe", O_RDONLY));
fds.emplace_back(open(path.c_str(), O_RDONLY | O_CREAT | O_TRUNC, 0666));
const auto [mmap_prot, mprotect_flag] = MMapAllProtectionsTest::GetParam();
for (const auto& fd : fds) {
ASSERT_TRUE(fd.is_valid());
auto mapping =
test_helper::ScopedMMap::MMap(nullptr, page_size, mmap_prot, MAP_PRIVATE, fd.get(), 0);
EXPECT_THAT(mapping, SyscallResultIsOk());
if (mapping.is_ok()) {
auto addr = mapping->mapping();
EXPECT_THAT(mprotect(addr, page_size, mprotect_flag), SyscallSucceeds());
}
}
}
namespace {
std::string ProtectionToString(int prot) {
std::string result;
if (prot & PROT_READ) {
result += "r";
} else {
result += "_";
}
if (prot & PROT_WRITE) {
result += "w";
} else {
result += "_";
}
if (prot & PROT_EXEC) {
result += "x";
} else {
result += "_";
}
return result;
}
const auto kAllMmapProtections =
testing::Values(PROT_READ, PROT_READ | PROT_WRITE, PROT_READ | PROT_EXEC,
PROT_READ | PROT_WRITE | PROT_EXEC, PROT_NONE);
} // namespace
INSTANTIATE_TEST_SUITE_P(MMapAllProtectionsTest, MMapAllProtectionsTest,
testing::Combine(kAllMmapProtections, kAllMmapProtections),
[](const testing::TestParamInfo<std::tuple<int, int>>& info) {
return ProtectionToString(std::get<0>(info.param)) + "_and_" +
ProtectionToString(std::get<1>(info.param));
});
bool IsMapped(uintptr_t addr) {
static const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
int rv = msync(reinterpret_cast<void*>(addr & ~(page_size - 1)), page_size, MS_ASYNC);
if (rv == 0) {
return true;
}
if (errno != ENOMEM) {
ADD_FAILURE() << "Unexpected msync error " << errno << " on addr " << addr;
abort();
}
return false;
}
// Creates a mapping 4 pages long:
// | first_page | second_page | third_page | fourth_page |
// ^
// |
// +--- mapping
//
// Then we mark the first 3 pages as MADV_DONTFORK, undo the annotation on the third page with
// DOFORK, remap the first page to a different location, and create a new mapping at the location
// previously occupied by the first page.
//
// DONTFORK DONTFORK DONTFORK DONTFORK
// | new page | second_page | third_page | | fourth_page | .... | remapped_first_page |
// remapped_extended | ^ ^ | | | +---
// remapped
// |
// +--- mapping
//
// After forking, in the child process we expect the new mapping and the third page of the original
// mapping to exist in the child. The first page retains its DONTFORK behavior from the madvise()
// call even in its new location. The second page in the remapped location inherits the DONTFORK
// flag from the allocation it is extending. The second page of the original mapping preserves its
// DONTFORK flag from the madvise() call. The remapped first page does not have a DONTFORK flag set
// since it is a new allocation despite it existing in a memory range that had DONTFORK set
// previously.
TEST(Madvise, SetDontForkThenRemap) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* mapping = mmap(nullptr, 4 * page_size, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(mapping, MAP_FAILED);
SAFE_SYSCALL(madvise(mapping, page_size * 3, MADV_DONTFORK));
SAFE_SYSCALL(
madvise(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(mapping) + page_size * 2),
page_size, MADV_DOFORK));
void* remapped = mremap(mapping, page_size, page_size * 2, MREMAP_MAYMOVE);
ASSERT_NE(remapped, MAP_FAILED);
void* new_mapping = mmap(mapping, page_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
ASSERT_EQ(new_mapping, mapping);
test_helper::ForkHelper helper;
helper.RunInForkedProcess([&] {
EXPECT_TRUE(IsMapped(reinterpret_cast<uintptr_t>(mapping)));
EXPECT_TRUE(IsMapped(reinterpret_cast<uintptr_t>(mapping) + 2 * page_size));
EXPECT_TRUE(IsMapped(reinterpret_cast<uintptr_t>(mapping) + 3 * page_size));
EXPECT_FALSE(IsMapped(reinterpret_cast<uintptr_t>(mapping) + page_size));
EXPECT_FALSE(IsMapped(reinterpret_cast<uintptr_t>(remapped)));
EXPECT_FALSE(IsMapped(reinterpret_cast<uintptr_t>(remapped) + page_size));
});
EXPECT_TRUE(helper.WaitForChildren());
munmap(mapping, 4 * page_size);
munmap(remapped, 2 * page_size);
}
TEST(Mremap, RemapMayMoveSpanningMappings) {
if (test_helper::IsKernelVersionAtLeast(6, 17)) {
GTEST_SKIP() << "Moving multiple mappings is supported in Linux 6.17 and newer, skipping.";
}
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* mapping =
mmap(nullptr, 2 * page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(mapping, MAP_FAILED);
SAFE_SYSCALL(mprotect(mapping, page_size, PROT_READ));
void* destination =
mmap(nullptr, 2 * page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(destination, MAP_FAILED);
SAFE_SYSCALL(munmap(destination, 2 * page_size));
void* remapped =
mremap(mapping, 2 * page_size, 2 * page_size, MREMAP_MAYMOVE | MREMAP_FIXED, destination);
EXPECT_EQ(remapped, MAP_FAILED);
EXPECT_EQ(errno, EFAULT);
SAFE_SYSCALL(munmap(mapping, 2 * page_size));
}
TEST(Mremap, BadAddressReturnsEfault) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
// Map and immediately unmap a 2-page region so we can obtain two guaranteed
// unmapped, non-overlapping addresses (`addr` and `dst`).
void* base = mmap(nullptr, 2 * page_size, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(base, MAP_FAILED);
SAFE_SYSCALL(munmap(base, 2 * page_size));
void* addr = base;
void* dst = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(base) + page_size);
// Expanding unmapped address should return EFAULT.
EXPECT_EQ(mremap(addr, page_size, 2 * page_size, 0), MAP_FAILED);
EXPECT_EQ(errno, EFAULT);
EXPECT_EQ(mremap(addr, page_size, 2 * page_size, MREMAP_MAYMOVE), MAP_FAILED);
EXPECT_EQ(errno, EFAULT);
// Shrinking unmapped address should return EFAULT.
EXPECT_EQ(mremap(addr, 2 * page_size, page_size, 0), MAP_FAILED);
EXPECT_EQ(errno, EFAULT);
// Remapping with the same size on unmapped address should return EFAULT.
EXPECT_EQ(mremap(addr, page_size, page_size, 0), MAP_FAILED);
EXPECT_EQ(errno, EFAULT);
// Moving unmapped address to a non-overlapping destination with FIXED should return EFAULT.
EXPECT_EQ(mremap(addr, page_size, page_size, MREMAP_MAYMOVE | MREMAP_FIXED, dst), MAP_FAILED);
EXPECT_EQ(errno, EFAULT);
// Remapping with old_length == 0 on unmapped address should return EFAULT.
EXPECT_EQ(mremap(addr, 0, page_size, MREMAP_MAYMOVE), MAP_FAILED);
EXPECT_EQ(errno, EFAULT);
EXPECT_EQ(mremap(addr, 0, page_size, 0), MAP_FAILED);
EXPECT_EQ(errno, EFAULT);
// Unaligned address should return EINVAL, not EFAULT (alignment check happens first).
void* unaligned_addr = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(addr) + 1);
EXPECT_EQ(mremap(unaligned_addr, page_size, 2 * page_size, 0), MAP_FAILED);
EXPECT_EQ(errno, EINVAL);
}
TEST(Mremap, RemapPartOfMapping) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* mapping =
mmap(nullptr, 3 * page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(mapping, MAP_FAILED);
reinterpret_cast<volatile char*>(mapping)[0] = 'a';
reinterpret_cast<volatile char*>(mapping)[page_size] = 'b';
reinterpret_cast<volatile char*>(mapping)[2 * page_size] = 'c';
void* target =
mmap(nullptr, 3 * page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(target, MAP_FAILED);
reinterpret_cast<volatile char*>(target)[0] = 'x';
reinterpret_cast<volatile char*>(target)[page_size] = 'y';
reinterpret_cast<volatile char*>(target)[2 * page_size] = 'z';
void* remap_source = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(mapping) + page_size);
void* remap_destination =
reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(target) + page_size);
void* remapped =
mremap(remap_source, page_size, page_size, MREMAP_MAYMOVE | MREMAP_FIXED, remap_destination);
ASSERT_EQ(remapped, remap_destination);
EXPECT_EQ('a', reinterpret_cast<volatile char*>(mapping)[0]);
EXPECT_TRUE(test_helper::TestThatAccessSegfaults(static_cast<std::byte*>(mapping) + page_size,
test_helper::AccessType::Read));
EXPECT_EQ('c', reinterpret_cast<volatile char*>(mapping)[2 * page_size]);
EXPECT_EQ('x', reinterpret_cast<volatile char*>(target)[0]);
EXPECT_EQ('b', reinterpret_cast<volatile char*>(target)[page_size]);
EXPECT_EQ('z', reinterpret_cast<volatile char*>(target)[2 * page_size]);
}
TEST(Mremap, MremapSharedCopy) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* source =
mmap(nullptr, page_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(source, MAP_FAILED);
reinterpret_cast<volatile char*>(source)[0] = 'a';
void* remapped = mremap(source, 0, page_size, MREMAP_MAYMOVE);
ASSERT_NE(remapped, MAP_FAILED);
ASSERT_NE(remapped, source);
EXPECT_EQ('a', reinterpret_cast<volatile char*>(remapped)[0]);
EXPECT_EQ('a', reinterpret_cast<volatile char*>(source)[0]);
// Changes are shared
reinterpret_cast<volatile char*>(remapped)[0] = 'b';
EXPECT_EQ('b', reinterpret_cast<volatile char*>(source)[0]);
SAFE_SYSCALL(munmap(source, page_size));
SAFE_SYSCALL(munmap(remapped, page_size));
}
TEST(Mremap, MremapDontUnmap) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* source =
mmap(nullptr, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(source, MAP_FAILED);
reinterpret_cast<volatile char*>(source)[1] = 'a';
void* remapped = mremap(source, page_size, page_size, MREMAP_MAYMOVE | MREMAP_DONTUNMAP, 0);
ASSERT_NE(remapped, MAP_FAILED);
ASSERT_NE(remapped, source);
EXPECT_EQ('a', reinterpret_cast<volatile char*>(remapped)[1]);
// MREMAP_DONTUNMAP leaves the source mapped but makes any new access to the unmapped range a
// pagefault that will be zero-filled in the absence of userfaultfd.
EXPECT_EQ('\0', reinterpret_cast<volatile char*>(source)[1]);
SAFE_SYSCALL(munmap(source, page_size));
SAFE_SYSCALL(munmap(remapped, page_size));
}
TEST(Mremap, MremapDontUnmapFixed) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* source =
mmap(nullptr, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(source, MAP_FAILED);
void* available =
mmap(nullptr, 2 * page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(available, MAP_FAILED);
SAFE_SYSCALL(munmap(available, 2 * page_size));
// Check that the specified address wasn't ignored: if it was, remap would land on
// available + page_size instead as this is the next unused range.
void* remapped = mremap(source, page_size, page_size,
MREMAP_MAYMOVE | MREMAP_DONTUNMAP | MREMAP_FIXED, available);
ASSERT_EQ(remapped, available);
SAFE_SYSCALL(munmap(source, page_size));
SAFE_SYSCALL(munmap(remapped, page_size));
}
TEST(Mremap, MremapDontUnmapSharedAnon) {
if (!test_helper::IsStarnix() && !test_helper::IsKernelVersionAtLeast(5, 13)) {
GTEST_SKIP()
<< "MREMAP_DONTUNMAP on shared memory isn't supported on Linux with kernel version older"
<< " than 5.13, skipping.";
}
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* source =
mmap(nullptr, page_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(source, MAP_FAILED);
reinterpret_cast<volatile char*>(source)[0] = 'a';
void* remapped = mremap(source, page_size, page_size, MREMAP_MAYMOVE | MREMAP_DONTUNMAP, 0);
ASSERT_NE(remapped, MAP_FAILED);
ASSERT_NE(remapped, source);
EXPECT_EQ('a', reinterpret_cast<volatile char*>(remapped)[0]);
// MREMAP_DONTUNMAP on shared anonymous memory creates a new mapping of the same memory.
EXPECT_EQ('a', reinterpret_cast<volatile char*>(source)[0]);
SAFE_SYSCALL(munmap(source, page_size));
SAFE_SYSCALL(munmap(remapped, page_size));
}
TEST(Mremap, MremapDontUnmapGap) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* source =
mmap(nullptr, 3 * page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(source, MAP_FAILED);
SAFE_SYSCALL(
munmap(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(source) + page_size), page_size));
void* remapped =
mremap(source, 3 * page_size, 3 * page_size, MREMAP_MAYMOVE | MREMAP_DONTUNMAP, 0);
ASSERT_EQ(remapped, MAP_FAILED);
SAFE_SYSCALL(munmap(source, 3 * page_size));
}
TEST(Mremap, MremapDontUnmapTwoSharedAnon) {
if (!test_helper::IsStarnix() && !test_helper::IsKernelVersionAtLeast(5, 13)) {
GTEST_SKIP()
<< "MREMAP_DONTUNMAP on shared memory isn't supported on Linux with kernel version older"
<< " than 5.13, skipping.";
}
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* source =
mmap(nullptr, 2 * page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(source, MAP_FAILED);
SAFE_SYSCALL(munmap(source, 2 * page_size));
void* page1 = mmap(source, page_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(page1, MAP_FAILED);
void* page2 = mmap(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(source) + page_size),
page_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(page2, MAP_FAILED);
void* remapped =
mremap(source, 2 * page_size, 2 * page_size, MREMAP_MAYMOVE | MREMAP_DONTUNMAP, 0);
ASSERT_EQ(remapped, MAP_FAILED);
SAFE_SYSCALL(munmap(source, 2 * page_size));
}
TEST(Mremap, GrowThenGrow) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* space =
mmap(nullptr, 3 * page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(space, MAP_FAILED);
munmap(space, 3 * page_size);
void* mapping = mmap(space, page_size, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
ASSERT_EQ(mapping, space);
void* first_remap = mremap(mapping, page_size, 2 * page_size, 0);
ASSERT_EQ(first_remap, mapping);
void* second_remap = mremap(mapping, 2 * page_size, 3 * page_size, 0);
ASSERT_EQ(second_remap, mapping);
munmap(mapping, 3 * page_size);
}
TEST(Mmap, ProtExecInChild) {
test_helper::ForkHelper helper;
helper.RunInForkedProcess([] {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* mapped =
mmap(nullptr, page_size, PROT_READ | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(mapped, MAP_FAILED);
});
ASSERT_TRUE(helper.WaitForChildren());
}
TEST(Mmap, ChoosesSameAddress) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* addr1 = mmap(nullptr, page_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(addr1, MAP_FAILED);
ASSERT_EQ(munmap(addr1, page_size), 0);
void* addr2 = mmap(nullptr, page_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_EQ(addr1, addr2);
ASSERT_EQ(munmap(addr2, page_size), 0);
}
TEST(Mmap, AddressesAreInDescendingOrder) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
std::vector<void*> addresses;
auto restorer = fit::defer([&]() {
for (auto addr : addresses) {
EXPECT_EQ(munmap(addr, page_size), 0);
}
});
for (size_t i = 0; i < 10; i++) {
void* addr = mmap(nullptr, page_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(addr, MAP_FAILED);
addresses.push_back(addr);
}
for (size_t i = 1; i < addresses.size(); i++) {
EXPECT_LT(addresses[i], addresses[i - 1]);
}
}
TEST(Mmap, HintIgnoredIfInUse) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* page_in_use = mmap(nullptr, page_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(page_in_use, MAP_FAILED);
// Probe for the next available address
void* next_addr = mmap(nullptr, page_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(next_addr, page_in_use);
ASSERT_EQ(munmap(next_addr, page_size), 0);
// Try to mmap at the address that is unavailable, without an overwrite flag.
void* hint_result = mmap(page_in_use, page_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
// mmap should have given us the next available address, ignoring the hint
EXPECT_EQ(hint_result, next_addr);
ASSERT_EQ(munmap(hint_result, page_size), 0);
ASSERT_EQ(munmap(page_in_use, page_size), 0);
}
TEST(Mmap, HintRoundedDownIfMisaligned) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
// Probe for a next available 1-page and 2-page gaps
void* next_onepage = mmap(nullptr, page_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(next_onepage, MAP_FAILED);
void* next_twopage = mmap(nullptr, 2 * page_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(next_twopage, MAP_FAILED);
ASSERT_EQ(munmap(next_onepage, page_size), 0);
ASSERT_EQ(munmap(next_twopage, 2 * page_size), 0);
void* hint_result = mmap(static_cast<char*>(next_twopage) + 1, page_size, PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(hint_result, MAP_FAILED);
EXPECT_NE(hint_result,
next_onepage); // Not ignoring the hint by allocating the next available 1-page gap
EXPECT_EQ(hint_result, next_twopage); // Instead, rounding down the hinted address and using it.
ASSERT_EQ(munmap(hint_result, page_size), 0);
hint_result = mmap(static_cast<char*>(next_twopage) + page_size - 1, page_size, PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(hint_result, MAP_FAILED);
EXPECT_NE(hint_result,
next_onepage); // Not ignoring the hint by allocating the next available 1-page gap
EXPECT_EQ(hint_result, next_twopage); // Instead, rounding down the hinted address and using it.
ASSERT_EQ(munmap(hint_result, page_size), 0);
}
TEST(Mmap, FixedAddressTooLow) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* low_addr = reinterpret_cast<void*>(page_size);
void* addr = mmap(low_addr, page_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
ASSERT_EQ(addr, MAP_FAILED);
}
TEST(Mmap, HintedAddressTooLow) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
void* low_addr = reinterpret_cast<void*>(page_size);
void* addr = mmap(low_addr, page_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(addr, MAP_FAILED);
ASSERT_NE(addr, low_addr);
ASSERT_EQ(munmap(addr, page_size), 0);
}
TEST(Madvise, MadvRemoveZeroesMemory) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
std::vector<char> test_data(page_size, 'a');
std::vector<char> zero_data(page_size, '\0');
int fd = SAFE_SYSCALL(test_helper::MemFdCreate("madv_remove", 0));
SAFE_SYSCALL(write(fd, test_data.data(), test_data.size()));
void* addr = mmap(nullptr, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
ASSERT_NE(addr, MAP_FAILED);
close(fd);
EXPECT_THAT(madvise(addr, page_size, MADV_REMOVE), SyscallSucceeds());
EXPECT_EQ(memcmp(addr, zero_data.data(), zero_data.size()), 0);
SAFE_SYSCALL(munmap(addr, page_size));
}
TEST(MMapTest, MsyncFlags) {
char* mutable_storage = getenv("MUTABLE_STORAGE");
// TODO(https://fxbug.dev/317285180) Fallback to /tmp if "MUTABLE_STORAGE" isn't set. This env var
// is required once bare host tests removed.
std::string dir = (mutable_storage != nullptr) ? std::string(mutable_storage) : "/tmp";
ASSERT_FALSE(dir.empty());
std::string test_folder = dir + "/msync_flags_XXXXXX";
ASSERT_NE(mkdtemp(test_folder.data()), nullptr)
<< "failed to create test folder: " << std::strerror(errno);
std::string path = test_folder + "/msync_flags_test";
auto cleanup = fit::defer([&]() {
remove(path.c_str());
rmdir(test_folder.c_str());
});
int fd = open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0777);
ASSERT_GE(fd, 0) << "Failed to open test file: " << strerror(errno);
size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
SAFE_SYSCALL(ftruncate(fd, page_size));
void* addr = mmap(nullptr, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
ASSERT_NE(addr, MAP_FAILED);
// Test MS_ASYNC
// Should return immediately (handled as no-op or scheduled).
*reinterpret_cast<volatile char*>(addr) = 'a';
EXPECT_THAT(msync(addr, page_size, MS_ASYNC), SyscallSucceeds());
// Test MS_SYNC
// Should persist data.
*reinterpret_cast<volatile char*>(addr) = 'b';
EXPECT_THAT(msync(addr, page_size, MS_SYNC), SyscallSucceeds());
// Verify data on disk
char file_content;
EXPECT_EQ(pread(fd, &file_content, 1, 0), 1);
EXPECT_EQ(file_content, 'b');
// Test MS_INVALIDATE (combined with MS_SYNC)
*reinterpret_cast<volatile char*>(addr) = 'c';
EXPECT_THAT(msync(addr, page_size, MS_SYNC | MS_INVALIDATE), SyscallSucceeds());
EXPECT_EQ(pread(fd, &file_content, 1, 0), 1);
EXPECT_EQ(file_content, 'c');
// Test MS_SYNC | MS_ASYNC (invalid)
EXPECT_THAT(msync(addr, page_size, MS_SYNC | MS_ASYNC), SyscallFailsWithErrno(EINVAL));
// Test MS_INVALIDATE only (should be like MS_ASYNC)
*reinterpret_cast<volatile char*>(addr) = 'd';
EXPECT_THAT(msync(addr, page_size, MS_INVALIDATE), SyscallSucceeds());
// Data might not be synced
// Test 0 flags (should be like MS_ASYNC)
*reinterpret_cast<volatile char*>(addr) = 'e';
EXPECT_THAT(msync(addr, page_size, 0), SyscallSucceeds());
// Data might not be synced
// Final sync to check last write if needed
*reinterpret_cast<volatile char*>(addr) = 'f';
EXPECT_THAT(msync(addr, page_size, MS_SYNC), SyscallSucceeds());
EXPECT_EQ(pread(fd, &file_content, 1, 0), 1);
EXPECT_EQ(file_content, 'f');
SAFE_SYSCALL(munmap(addr, page_size));
close(fd);
}
// Tests that mmap_min_addr specifies the minimum address that unprivileged processes can mmap.
TEST(MmapTest, MmapMinAddr) {
if (!test_helper::HasSysAdmin()) {
GTEST_SKIP() << "Need CAP_SYS_ADMIN to run MmapTest.MmapMinAddr";
}
const char kMmapMinAddr[] = "/proc/sys/vm/mmap_min_addr";
std::string original_value;
EXPECT_TRUE(files::ReadFileToString(kMmapMinAddr, &original_value));
// Restore the original value after the test.
auto cleanup = fit::defer(
[original_value, kMmapMinAddr]() { files::WriteFile(kMmapMinAddr, original_value); });
// Tries to mmap at `target_addr` as an unprivileged process.
// Returns 0 on success, and the error number on failure.
auto try_mmap_unprivileged = [](size_t target_addr) -> int {
test_helper::ForkHelper helper;
helper.OnlyWaitForForkedChildren();
pid_t pid = helper.RunInForkedProcess([target_addr] {
// Drop all capabilities to become unprivileged.
test_helper::DropAllCapabilities();
fit::result<int, test_helper::ScopedMMap> mmap_result = test_helper::ScopedMMap::MMap(
reinterpret_cast<void*>(target_addr), 4096, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
if (mmap_result.is_error()) {
_exit(mmap_result.error_value());
}
_exit(0);
});
test_helper::ForkResult result = helper.WaitForChild(pid);
if (result.determined_result == testing::AssertionSuccess()) {
return 0;
}
return result.subprocess_exit_status;
};
constexpr size_t k5Mb = 5242880;
// Write 10MB to mmap_min_addr.
EXPECT_TRUE(files::WriteFile(kMmapMinAddr, "10485760\n"));
// mmap at 5MB should fail because 5MB < 10MB.
EXPECT_EQ(try_mmap_unprivileged(k5Mb), EPERM);
// Write 0MB to mmap_min_addr.
EXPECT_TRUE(files::WriteFile(kMmapMinAddr, "0\n"));
// mmap at 5MB should succeed now.
EXPECT_EQ(try_mmap_unprivileged(k5Mb), 0);
}
TEST(MmapTest, MapFixedBelowMmapMinAddrFailsWithEperm) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
std::string min_addr_str;
ASSERT_TRUE(files::ReadFileToString("/proc/sys/vm/mmap_min_addr", &min_addr_str));
size_t mmap_min_addr = std::stoul(min_addr_str);
ASSERT_GE(mmap_min_addr, page_size);
void* low_addr = reinterpret_cast<void*>(mmap_min_addr - page_size);
if (test_helper::IsStarnix() && test_helper::HasCapability(CAP_SYS_RAWIO)) {
// On Starnix, [0, RESTRICTED_ASPACE_BASE) is reserved outside the user VMAR, so when
// CAP_SYS_RAWIO is held, fixed mappings below mmap_min_addr pass the capability check and
// fail with EINVAL.
EXPECT_THAT(reinterpret_cast<intptr_t>(mmap(nullptr, page_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0)),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(
reinterpret_cast<intptr_t>(mmap(nullptr, page_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED_NOREPLACE, -1, 0)),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(reinterpret_cast<intptr_t>(mmap(low_addr, page_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0)),
SyscallFailsWithErrno(EINVAL));
EXPECT_THAT(
reinterpret_cast<intptr_t>(mmap(low_addr, page_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED_NOREPLACE, -1, 0)),
SyscallFailsWithErrno(EINVAL));
}
test_helper::ForkHelper helper;
helper.RunInForkedProcess([page_size, mmap_min_addr, low_addr] {
test_helper::DropAllCapabilities();
// Unaligned fixed mappings below mmap_min_addr must fail with EINVAL even without
// CAP_SYS_RAWIO.
EXPECT_THAT(reinterpret_cast<intptr_t>(mmap(reinterpret_cast<void*>(1), page_size,
PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0)),
SyscallFailsWithErrno(EINVAL));
// Fixed mappings at NULL (0) without CAP_SYS_RAWIO must fail with EPERM.
EXPECT_THAT(reinterpret_cast<intptr_t>(mmap(nullptr, page_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0)),
SyscallFailsWithErrno(EPERM));
EXPECT_THAT(
reinterpret_cast<intptr_t>(mmap(nullptr, page_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED_NOREPLACE, -1, 0)),
SyscallFailsWithErrno(EPERM));
// Fixed mappings below mmap_min_addr without CAP_SYS_RAWIO must fail with EPERM (not ENOMEM).
EXPECT_THAT(reinterpret_cast<intptr_t>(mmap(low_addr, page_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0)),
SyscallFailsWithErrno(EPERM));
EXPECT_THAT(
reinterpret_cast<intptr_t>(mmap(low_addr, page_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED_NOREPLACE, -1, 0)),
SyscallFailsWithErrno(EPERM));
// Non-fixed mapping with a hint below mmap_min_addr must succeed and map at >= mmap_min_addr.
if (mmap_min_addr > page_size) {
void* hinted = mmap(reinterpret_cast<void*>(page_size), page_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
ASSERT_NE(hinted, MAP_FAILED);
EXPECT_GE(reinterpret_cast<uintptr_t>(hinted), mmap_min_addr);
SAFE_SYSCALL(munmap(hinted, page_size));
}
});
EXPECT_TRUE(helper.WaitForChildren());
}
// Verifies that closing a file descriptor while it remains mapped defers the
// close event until the memory mapping is unmapped.
//
// When a file is mapped and its file descriptor is closed, the underlying file
// description remains open for the lifetime of the mapping.
//
// An inotify watch is used to observe this deferred-close behavior: closing the
// file descriptor does not trigger an IN_CLOSE_* event while the mapping is
// active; the event is delivered only after unmapping the memory.
TEST(MmapTest, FileCloseDeferredWhileMapped) {
test_helper::ScopedTempDir temp_dir;
const std::string test_file_path = temp_dir.path() + "/mapped_file";
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
std::string file_contents(page_size, 'a');
ASSERT_TRUE(files::WriteFile(test_file_path, file_contents));
// Use an inotify watch to observe when the close event occurs.
fbl::unique_fd inotify_fd(inotify_init1(IN_NONBLOCK | IN_CLOEXEC));
ASSERT_THAT(inotify_fd.get(), SyscallSucceeds());
int wd = inotify_add_watch(inotify_fd.get(), test_file_path.c_str(),
IN_CLOSE_NOWRITE | IN_CLOSE_WRITE);
ASSERT_THAT(wd, SyscallSucceeds());
// Open the file and map it into memory.
fbl::unique_fd file_fd(open(test_file_path.c_str(), O_RDONLY));
ASSERT_THAT(file_fd.get(), SyscallSucceeds());
void* mapped_addr = mmap(nullptr, page_size, PROT_READ, MAP_SHARED, file_fd.get(), 0);
ASSERT_NE(mapped_addr, MAP_FAILED) << strerror(errno);
// Close the file descriptor while the mapping is still active.
file_fd.reset();
// No close event should be emitted yet while the mapping exists.
char event_buf[sizeof(struct inotify_event) + NAME_MAX + 1];
EXPECT_THAT(read(inotify_fd.get(), event_buf, sizeof(event_buf)), SyscallFailsWithErrno(EAGAIN));
// Unmap the memory.
ASSERT_THAT(munmap(mapped_addr, page_size), SyscallSucceeds());
// The close event should now be delivered.
ssize_t bytes_read = read(inotify_fd.get(), event_buf, sizeof(event_buf));
ASSERT_THAT(bytes_read, SyscallSucceeds());
ASSERT_GE(bytes_read, static_cast<ssize_t>(sizeof(struct inotify_event)));
const auto* event = reinterpret_cast<const struct inotify_event*>(event_buf);
EXPECT_EQ(event->wd, wd);
EXPECT_TRUE(event->mask & IN_CLOSE_NOWRITE);
}
// Regression test for https://fxbug.dev/297433933: When a file is mapped twice
// (once read-only and once read-write with MAP_PRIVATE) and the process forks,
// writing to the writable MAP_PRIVATE mapping in the parent after fork() must
// not be visible through either the read-only mapping or the writable mapping
// in the child.
TEST(MmapTest, PrivateReadAndWriteFileMappingsIsolatedAcrossFork) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempFD temp_file;
ASSERT_TRUE(temp_file);
const std::string initial_contents(page_size, 'a');
ASSERT_THAT(pwrite(temp_file.fd(), initial_contents.data(), initial_contents.size(),
/* offset = */ 0),
SyscallSucceedsWithValue(static_cast<ssize_t>(page_size)));
for (int read_map_flags : {MAP_PRIVATE, MAP_SHARED}) {
SCOPED_TRACE(read_map_flags == MAP_PRIVATE ? "read_mapping=MAP_PRIVATE"
: "read_mapping=MAP_SHARED");
auto read_mapping = test_helper::ScopedMMap::MMap(
/* addr = */ nullptr, page_size, PROT_READ, read_map_flags, temp_file.fd(),
/* offset = */ 0);
ASSERT_THAT(read_mapping, SyscallResultIsOk());
auto write_mapping = test_helper::ScopedMMap::MMap(
/* addr = */ nullptr, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, temp_file.fd(),
/* offset = */ 0);
ASSERT_THAT(write_mapping, SyscallResultIsOk());
volatile char* read_bytes = static_cast<volatile char*>(read_mapping->mapping());
volatile char* write_bytes = static_cast<volatile char*>(write_mapping->mapping());
// Fault in both mappings before fork().
ASSERT_EQ(read_bytes[0], 'a');
ASSERT_EQ(write_bytes[0], 'a');
auto [parent_wrote, wait_for_parent_write] = test_helper::MakeRendezvous();
test_helper::ForkHelper helper;
helper.KillChildrenOnDestroy();
helper.RunInForkedProcess([&] {
wait_for_parent_write.hold();
EXPECT_EQ(read_bytes[0], 'a');
EXPECT_EQ(write_bytes[0], 'a');
// Writing to the child's writable MAP_PRIVATE mapping must not affect its
// read-only mapping or the parent's mappings.
write_bytes[0] = 'c';
EXPECT_EQ(read_bytes[0], 'a');
EXPECT_EQ(write_bytes[0], 'c');
});
// Write to the writable MAP_PRIVATE mapping in the parent after fork().
write_bytes[0] = 'b';
parent_wrote.poke();
ASSERT_TRUE(helper.WaitForChildren());
EXPECT_EQ(write_bytes[0], 'b');
EXPECT_EQ(read_bytes[0], 'a');
}
char file_byte = 0;
ASSERT_THAT(pread(temp_file.fd(), &file_byte, /* count = */ 1, /* offset = */ 0),
SyscallSucceedsWithValue(1));
EXPECT_EQ(file_byte, 'a');
}
// Regression test for https://fxbug.dev/297433933: When a single MAP_PRIVATE
// file mapping is split via mprotect() into a read-only page and a read-write
// page, forking and writing in the parent must keep both pages isolated in the
// child.
TEST(MmapTest, SplitPrivateReadAndWriteFileMappingIsolatedAcrossFork) {
const size_t page_size = SAFE_SYSCALL(sysconf(_SC_PAGE_SIZE));
test_helper::ScopedTempFD temp_file;
ASSERT_TRUE(temp_file);
const std::string initial_contents(page_size * 2, 'a');
ASSERT_THAT(pwrite(temp_file.fd(), initial_contents.data(), initial_contents.size(),
/* offset = */ 0),
SyscallSucceedsWithValue(static_cast<ssize_t>(page_size * 2)));
// Test both starting with PROT_READ (promoting page 1 to PROT_READ | PROT_WRITE)
// and starting with PROT_READ | PROT_WRITE (writing a private copy-on-write
// value to page 0 before downgrading it to PROT_READ).
for (int initial_prot : {PROT_READ, PROT_READ | PROT_WRITE}) {
SCOPED_TRACE(initial_prot == PROT_READ ? "initial_prot=PROT_READ"
: "initial_prot=PROT_READ|PROT_WRITE");
auto mapping = test_helper::ScopedMMap::MMap(
/* addr = */ nullptr, page_size * 2, initial_prot, MAP_PRIVATE, temp_file.fd(),
/* offset = */ 0);
ASSERT_THAT(mapping, SyscallResultIsOk());
char* base = static_cast<char*>(mapping->mapping());
volatile char* read_page = base;
volatile char* write_page = base + page_size;
const char expected_read_byte = (initial_prot & PROT_WRITE) ? 'p' : 'a';
if (initial_prot == PROT_READ) {
ASSERT_THAT(mprotect(base + page_size, page_size, PROT_READ | PROT_WRITE), SyscallSucceeds());
} else {
// Trigger a private CoW copy before downgrading page 0 to PROT_READ.
read_page[0] = expected_read_byte;
ASSERT_THAT(mprotect(base, page_size, PROT_READ), SyscallSucceeds());
}
// Fault in both pages before fork().
ASSERT_EQ(read_page[0], expected_read_byte);
ASSERT_EQ(write_page[0], 'a');
auto [parent_wrote, wait_for_parent_write] = test_helper::MakeRendezvous();
test_helper::ForkHelper helper;
helper.KillChildrenOnDestroy();
helper.RunInForkedProcess([&] {
wait_for_parent_write.hold();
EXPECT_EQ(read_page[0], expected_read_byte);
EXPECT_EQ(write_page[0], 'a');
write_page[0] = 'd';
EXPECT_EQ(read_page[0], expected_read_byte);
EXPECT_EQ(write_page[0], 'd');
});
// Modify the writable page in the parent, and also make page 0 writable in
// the parent and modify it, verifying that the child's read-only page 0 is
// isolated from post-fork writes in the parent.
write_page[0] = 'b';
SAFE_SYSCALL(mprotect(base, page_size, PROT_READ | PROT_WRITE));
read_page[0] = 'c';
parent_wrote.poke();
ASSERT_TRUE(helper.WaitForChildren());
EXPECT_EQ(read_page[0], 'c');
EXPECT_EQ(write_page[0], 'b');
}
}
} // namespace