Reland D146570 "[scudo] Switch to use MemMap in tests"

[Chia-hungDuan]

Summary

This reverts commit 89cc5304969ded574550e0ad113f59f3d4f50303.

[Chia-hungDuan]

Fix variable shadowing

[Chia-hungDuan]

Verified on MTE device

[cferris]

Mostly small nits.

compiler-rt/lib/scudo/standalone/tests/common_test.cpp

40

You lost the ASSERT_NE(nullptr, P) line. Even though getBase should not even return 0, it's probably worth keeping it in just in case.

61

Same as above, missing P is not nullptr check.

compiler-rt/lib/scudo/standalone/tests/memtag_test.cpp

51

Should there be a check that Addr is non-zero?

66

Technically, you don't do this any other place because MemMap is already initialized properly. Doesn't matter if you leave this or not though.

[Chia-hungDuan]

Address review comment

compiler-rt/lib/scudo/standalone/tests/common_test.cpp

40

Good catch!

compiler-rt/lib/scudo/standalone/tests/memtag_test.cpp

66

Right, just added because of some weird bug only happens on Android (Which I need to add {} for MemMap). Just in case it complains again and in order to make the style consistent.

[cferris]

LGTM.

compiler-rt/lib/scudo/standalone/tests/combined_test.cpp

 //===-- combined_test.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "memtag.h"
 #include "tests/scudo_unit_test.h"
 
 #include "allocator_config.h"
 #include "chunk.h"
 #include "combined.h"
+#include "mem_map.h"
 
 #include <condition_variable>
 #include <memory>
 #include <mutex>
 #include <set>
 #include <stdlib.h>
 #include <thread>
 #include <vector>
for (auto &T : Threads)
     T.join();
   Allocator->releaseToOS(scudo::ReleaseToOS::Force);
 }
 
 // Test that multiple instantiations of the allocator have not messed up the
 // process's signal handlers (GWP-ASan used to do this).
 TEST(ScudoCombinedDeathTest, SKIP_ON_FUCHSIA(testSEGV)) {
   const scudo::uptr Size = 4 * scudo::getPageSizeCached();
-  scudo::MapPlatformData Data = {};
-  void *P = scudo::map(nullptr, Size, "testSEGV", MAP_NOACCESS, &Data);
-  EXPECT_NE(P, nullptr);
+  scudo::ReservedMemoryT ReservedMemory;
+  ASSERT_TRUE(ReservedMemory.create(/*Addr=*/0U, Size, "testSEGV"));
+  void *P = reinterpret_cast<void *>(ReservedMemory.getBase());
+  ASSERT_NE(P, nullptr);
   EXPECT_DEATH(memset(P, 0xaa, Size), "");
-  scudo::unmap(P, Size, UNMAP_ALL, &Data);
+  ReservedMemory.release();
 }
 
 struct DeathSizeClassConfig {
   static const scudo::uptr NumBits = 1;
   static const scudo::uptr MinSizeLog = 10;
   static const scudo::uptr MidSizeLog = 10;
   static const scudo::uptr MaxSizeLog = 13;
   static const scudo::u16 MaxNumCachedHint = 8;

compiler-rt/lib/scudo/standalone/tests/common_test.cpp

 //===-- common_test.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "internal_defs.h"
 #include "tests/scudo_unit_test.h"
 
 #include "common.h"
+#include "mem_map.h"
 #include <algorithm>
 #include <fstream>
 
 namespace scudo {
 
 static uptr getResidentMemorySize() {
   if (!SCUDO_LINUX)
     UNREACHABLE("Not implemented!");
   uptr Size;
   uptr Resident;
   std::ifstream IFS("/proc/self/statm");
   IFS >> Size;
   IFS >> Resident;
   return Resident * getPageSizeCached();
 }
 
 // Fuchsia needs getResidentMemorySize implementation.
 TEST(ScudoCommonTest, SKIP_ON_FUCHSIA(ResidentMemorySize)) {
   uptr OnStart = getResidentMemorySize();
   EXPECT_GT(OnStart, 0UL);
 
   const uptr Size = 1ull << 30;
   const uptr Threshold = Size >> 3;
 
-  MapPlatformData Data = {};
-  void *P = map(nullptr, Size, "ResidentMemorySize", 0, &Data);
-  ASSERT_NE(nullptr, P);
+  MemMapT MemMap;
+  ASSERT_TRUE(MemMap.map(/*Addr=*/0U, Size, "ResidentMemorySize"));
+  ASSERT_NE(MemMap.getBase(), 0U);
+  void *P = reinterpret_cast<void *>(MemMap.getBase());
   EXPECT_LT(getResidentMemorySize(), OnStart + Threshold);
 
   memset(P, 1, Size);
   EXPECT_GT(getResidentMemorySize(), OnStart + Size - Threshold);
 
-  releasePagesToOS((uptr)P, 0, Size, &Data);
+  MemMap.releasePagesToOS(MemMap.getBase(), Size);
   EXPECT_LT(getResidentMemorySize(), OnStart + Threshold);
 
   memset(P, 1, Size);
   EXPECT_GT(getResidentMemorySize(), OnStart + Size - Threshold);
 
-  unmap(P, Size, 0, &Data);
+  MemMap.unmap(MemMap.getBase(), Size);
 }
 
 TEST(ScudoCommonTest, Zeros) {
   const uptr Size = 1ull << 20;
 
-  MapPlatformData Data = {};
-  uptr *P = reinterpret_cast<uptr *>(map(nullptr, Size, "Zeros", 0, &Data));
-  const ptrdiff_t N = Size / sizeof(*P);
-  ASSERT_NE(nullptr, P);
+  MemMapT MemMap;
+  ASSERT_TRUE(MemMap.map(/*Addr=*/0U, Size, "Zeros"));
+  ASSERT_NE(MemMap.getBase(), 0U);
+  uptr *P = reinterpret_cast<uptr *>(MemMap.getBase());
+  const ptrdiff_t N = Size / sizeof(uptr);
   EXPECT_EQ(std::count(P, P + N, 0), N);
 
   memset(P, 1, Size);
   EXPECT_EQ(std::count(P, P + N, 0), 0);
 
-  releasePagesToOS((uptr)P, 0, Size, &Data);
+  MemMap.releasePagesToOS(MemMap.getBase(), Size);
   EXPECT_EQ(std::count(P, P + N, 0), N);
 
-  unmap(P, Size, 0, &Data);
+  MemMap.unmap(MemMap.getBase(), Size);
 }
 
 #if 0
 // This test is temorarily disabled because it may not work as expected. E.g.,
 // it doesn't dirty the pages so the pages may not be commited and it may only
 // work on the single thread environment. As a result, this test is flaky and is
 // impacting many test scenarios.
 TEST(ScudoCommonTest, GetRssFromBuffer) {

compiler-rt/lib/scudo/standalone/tests/map_test.cpp

 //===-- map_test.cpp --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "tests/scudo_unit_test.h"
 
 #include "common.h"
+#include "mem_map.h"
 
 #include <string.h>
 #include <unistd.h>
 
 static const char *MappingName = "scudo:test";
 
 TEST(ScudoMapTest, PageSize) {
   EXPECT_EQ(scudo::getPageSizeCached(),
             static_cast<scudo::uptr>(sysconf(_SC_PAGESIZE)));
 }
 
 TEST(ScudoMapDeathTest, MapNoAccessUnmap) {
   const scudo::uptr Size = 4 * scudo::getPageSizeCached();
-  scudo::MapPlatformData Data = {};
-  void *P = scudo::map(nullptr, Size, MappingName, MAP_NOACCESS, &Data);
-  EXPECT_NE(P, nullptr);
-  EXPECT_DEATH(memset(P, 0xaa, Size), "");
-  scudo::unmap(P, Size, UNMAP_ALL, &Data);
+  scudo::ReservedMemoryT ReservedMemory;
+
+  ASSERT_TRUE(ReservedMemory.create(/*Addr=*/0U, Size, MappingName));
+  EXPECT_NE(ReservedMemory.getBase(), 0U);
+  EXPECT_DEATH(
+      memset(reinterpret_cast<void *>(ReservedMemory.getBase()), 0xaa, Size),
+      "");
+
+  ReservedMemory.release();
 }
 
 TEST(ScudoMapDeathTest, MapUnmap) {
   const scudo::uptr Size = 4 * scudo::getPageSizeCached();
   EXPECT_DEATH(
       {
         // Repeat few time to avoid missing crash if it's mmaped by unrelated
         // code.
         for (int i = 0; i < 10; ++i) {
-          void *P = scudo::map(nullptr, Size, MappingName, 0, nullptr);
-          if (!P)
+          scudo::MemMapT MemMap;
+          MemMap.map(/*Addr=*/0U, Size, MappingName);
+          scudo::uptr P = MemMap.getBase();
+          if (P == 0U)
             continue;
-          scudo::unmap(P, Size, 0, nullptr);
-          memset(P, 0xbb, Size);
+          MemMap.unmap(MemMap.getBase(), Size);
+          memset(reinterpret_cast<void *>(P), 0xbb, Size);
         }
       },
       "");
 }
 
 TEST(ScudoMapDeathTest, MapWithGuardUnmap) {
   const scudo::uptr PageSize = scudo::getPageSizeCached();
   const scudo::uptr Size = 4 * PageSize;
-  scudo::MapPlatformData Data = {};
-  void *P = scudo::map(nullptr, Size + 2 * PageSize, MappingName, MAP_NOACCESS,
-                       &Data);
-  EXPECT_NE(P, nullptr);
-  void *Q =
-      reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(P) + PageSize);
-  EXPECT_EQ(scudo::map(Q, Size, MappingName, 0, &Data), Q);
-  memset(Q, 0xaa, Size);
-  EXPECT_DEATH(memset(Q, 0xaa, Size + 1), "");
-  scudo::unmap(P, Size + 2 * PageSize, UNMAP_ALL, &Data);
+  scudo::ReservedMemoryT ReservedMemory;
+  ASSERT_TRUE(
+      ReservedMemory.create(/*Addr=*/0U, Size + 2 * PageSize, MappingName));
+  ASSERT_NE(ReservedMemory.getBase(), 0U);
+
+  scudo::MemMapT MemMap =
+      ReservedMemory.dispatch(ReservedMemory.getBase(), Size + 2 * PageSize);
+  ASSERT_TRUE(MemMap.isAllocated());
+  scudo::uptr Q = MemMap.getBase() + PageSize;
+  ASSERT_TRUE(MemMap.remap(Q, Size, MappingName));
+  memset(reinterpret_cast<void *>(Q), 0xaa, Size);
+  EXPECT_DEATH(memset(reinterpret_cast<void *>(Q), 0xaa, Size + 1), "");
+  MemMap.unmap(MemMap.getBase(), MemMap.getCapacity());
 }
 
 TEST(ScudoMapTest, MapGrowUnmap) {
   const scudo::uptr PageSize = scudo::getPageSizeCached();
   const scudo::uptr Size = 4 * PageSize;
-  scudo::MapPlatformData Data = {};
-  void *P = scudo::map(nullptr, Size, MappingName, MAP_NOACCESS, &Data);
-  EXPECT_NE(P, nullptr);
-  void *Q =
-      reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(P) + PageSize);
-  EXPECT_EQ(scudo::map(Q, PageSize, MappingName, 0, &Data), Q);
-  memset(Q, 0xaa, PageSize);
-  Q = reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(Q) + PageSize);
-  EXPECT_EQ(scudo::map(Q, PageSize, MappingName, 0, &Data), Q);
-  memset(Q, 0xbb, PageSize);
-  scudo::unmap(P, Size, UNMAP_ALL, &Data);
+  scudo::ReservedMemoryT ReservedMemory;
+  ReservedMemory.create(/*Addr=*/0U, Size, MappingName);
+  ASSERT_TRUE(ReservedMemory.isCreated());
+
+  scudo::MemMapT MemMap =
+      ReservedMemory.dispatch(ReservedMemory.getBase(), Size);
+  ASSERT_TRUE(MemMap.isAllocated());
+  scudo::uptr Q = MemMap.getBase() + PageSize;
+  ASSERT_TRUE(MemMap.remap(Q, PageSize, MappingName));
+  memset(reinterpret_cast<void *>(Q), 0xaa, PageSize);
+  Q += PageSize;
+  ASSERT_TRUE(MemMap.remap(Q, PageSize, MappingName));
+  memset(reinterpret_cast<void *>(Q), 0xbb, PageSize);
+  MemMap.unmap(MemMap.getBase(), MemMap.getCapacity());
 }

compiler-rt/lib/scudo/standalone/tests/memtag_test.cpp

 //===-- memtag_test.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "common.h"
+#include "mem_map.h"
 #include "memtag.h"
 #include "platform.h"
 #include "tests/scudo_unit_test.h"
 
 #if SCUDO_LINUX
 namespace scudo {
 
 TEST(MemtagBasicDeathTest, Unsupported) {

 
 class MemtagTest : public Test {
 protected:
   void SetUp() override {
     if (!archSupportsMemoryTagging() || !systemDetectsMemoryTagFaultsTestOnly())
       GTEST_SKIP() << "Memory tagging is not supported";
 
     BufferSize = getPageSizeCached();
-    Buffer = reinterpret_cast<u8 *>(
-        map(nullptr, BufferSize, "MemtagTest", MAP_MEMTAG, &Data));
-    Addr = reinterpret_cast<uptr>(Buffer);
+    ASSERT_FALSE(MemMap.isAllocated());
+    ASSERT_TRUE(MemMap.map(/*Addr=*/0U, BufferSize, "MemtagTest", MAP_MEMTAG));
+    ASSERT_NE(MemMap.getBase(), 0U);
+    Addr = MemMap.getBase();
+    Buffer = reinterpret_cast<u8 *>(Addr);
     EXPECT_TRUE(isAligned(Addr, archMemoryTagGranuleSize()));
     EXPECT_EQ(Addr, untagPointer(Addr));
   }
 
   void TearDown() override {
-    if (Buffer)
-      unmap(Buffer, BufferSize, 0, &Data);
+    if (Buffer) {
+      ASSERT_TRUE(MemMap.isAllocated());
+      MemMap.unmap(MemMap.getBase(), MemMap.getCapacity());
+    }
   }
 
   uptr BufferSize = 0;
-  MapPlatformData Data = {};
+  scudo::MemMapT MemMap = {};
   u8 *Buffer = nullptr;
   uptr Addr = 0;
 };
 
 using MemtagDeathTest = MemtagTest;
 
 TEST_F(MemtagTest, ArchMemoryTagGranuleSize) {
   EXPECT_GT(archMemoryTagGranuleSize(), 1u);
for (LoadPtr += archMemoryTagGranuleSize(); LoadPtr < NoTagEnd;
          LoadPtr += archMemoryTagGranuleSize()) {
       EXPECT_EQ(addFixedTag(LoadPtr, 5), loadTag(LoadPtr));
     }
 
     // Untagged right granule.
     EXPECT_EQ(LoadPtr, loadTag(LoadPtr));
 
     // Reset tags without using StoreTags.
-    releasePagesToOS(Addr, 0, BufferSize, &Data);
+    MemMap.releasePagesToOS(Addr, BufferSize);
   }
 }
 
 } // namespace scudo
 
 #endif