| // 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 |