test: add PageTableLeak test

PiperOrigin-RevId: 643437188

test/syscalls/BUILD

@@ -396,6 +396,12 @@ syscall_test(
  test = "//test/syscalls/linux:mlock_test",
 )
 
+syscall_test(
+ timeout = "eternal", # YES_I_REALLY_NEED_AN_ETERNAL_TEST
+ save = False, # save tests incorrectly shorten timeout to "long"
+ test = "//test/syscalls/linux:mmap_eternal_test",
+)
+
 syscall_test(
  size = "medium",
  shard_count = more_shards,

test/syscalls/linux/BUILD

@@ -1381,6 +1381,23 @@ cc_binary(
  ],
 )
 
+cc_binary(
+ name = "mmap_eternal_test",
+ testonly = 1,
+ srcs = ["mmap_eternal.cc"],
+ linkstatic = 1,
+ malloc = "//test/util:errno_safe_allocator",
+ deps = select_gtest() + [
+ "//test/util:logging",
+ "//test/util:memory_util",
+ "//test/util:multiprocess_util",
+ "//test/util:posix_error",
+ "//test/util:save_util",
+ "//test/util:test_main",
+ "//test/util:test_util",
+ ],
+)
+
 cc_binary(
  name = "mmap_test",
  testonly = 1,

test/syscalls/linux/mmap_eternal.cc

@@ -0,0 +1,85 @@
+// Copyright 2024 The gVisor Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// mmap tests that often take longer than 900s to run and thus may be skipped
+// by test automation.
+
+#include <stddef.h>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "test/util/logging.h"
+#include "test/util/memory_util.h"
+#include "test/util/multiprocess_util.h"
+#include "test/util/posix_error.h"
+#include "test/util/save_util.h"
+#include "test/util/test_util.h"
+
+namespace gvisor {
+namespace testing {
+
+namespace {
+
+// Tests that when using one entry per page table leaf page at a time, page
+// table pages that become empty do not accumulate.
+TEST(MmapEternalTest, PageTableLeak) {
+ // Skip this test on platforms where app page tables are managed as for
+ // ordinary processes by the host kernel, both because there's relatively
+ // little value in exercising this behavior (separately from
+ // Platform::kNative) and because MM can be slow enough on such platforms to
+ // cause the test to time out.
+ SKIP_IF(GvisorPlatform() == Platform::kPtrace ||
+ GvisorPlatform() == Platform::kSystrap);
+
+ // Guess how much virtual address space we need.
+ constexpr size_t kMemoryLimitBytes = 12L << 30;
+ const size_t kMemoryLimitPages = kMemoryLimitBytes / kPageSize;
+ const size_t kEntriesPerPageTablePage = kPageSize / sizeof(void*);
+ const size_t kMemoryPerPageTableLeafPage =
+ kPageSize * kEntriesPerPageTablePage;
+ const size_t kMemorySizeBytes =
+ kMemoryLimitPages * kMemoryPerPageTableLeafPage;
+
+ // Reserve virtual address space.
+ Mapping m = ASSERT_NO_ERRNO_AND_VALUE(
+ MmapAnon(kMemorySizeBytes, PROT_NONE, MAP_PRIVATE));
+
+ // Map and unmap one page at a time. This uses a subprocess since the
+ // existence of our reservation VMA interferes with page table freeing;
+ // forking ensures that there are no other threads in the subprocess,
+ // allowing us to safely unmap the reservation.
+ const DisableSave ds;
+ const auto rest = [&] {
+ char* ptr = static_cast<char*>(m.ptr());
+ char const* const end = static_cast<char*>(m.endptr());
+ m.reset();
+ while (ptr < end) {
+ TEST_PCHECK(
+ MmapSafe(ptr, kPageSize, PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED | MAP_POPULATE, -1,
+ 0) == ptr);
+ TEST_PCHECK(MunmapSafe(ptr, kPageSize) == 0);
+ ptr += kMemoryPerPageTableLeafPage;
+ }
+ };
+
+ // The test passes if this does not result in an OOM kill (of the subprocess
+ // or the sandbox).
+ EXPECT_THAT(InForkedProcess(rest), IsPosixErrorOkAndHolds(0));
+}
+
+} // namespace
+
+} // namespace testing
+} // namespace gvisor

test/util/memory_util.h

@@ -32,6 +32,13 @@
 namespace gvisor {
 namespace testing {
 
+// Async-signal-safe version of mmap(2).
+inline void* MmapSafe(void* addr, size_t length, int prot, int flags, int fd,
+ off_t offset) {
+ return reinterpret_cast<void*>(
+ syscall(SYS_mmap, addr, length, prot, flags, fd, offset));
+}
+
 // Async-signal-safe version of munmap(2).
 inline int MunmapSafe(void* addr, size_t length) {
  return syscall(SYS_munmap, addr, length);
@@ -110,7 +117,7 @@ class Mapping {
 // Wrapper around mmap(2) that returns a Mapping.
 inline PosixErrorOr<Mapping> Mmap(void* addr, size_t length, int prot,
  int flags, int fd, off_t offset) {
- void* ptr = mmap(addr, length, prot, flags, fd, offset);
+ void* ptr = MmapSafe(addr, length, prot, flags, fd, offset);
  if (ptr == MAP_FAILED) {
  return PosixError(
  errno, absl::StrFormat("mmap(%p, %d, %x, %x, %d, %d)", addr, length,