[scudo] Switch to use MemMap in tests

[cferris]

I notice a lot of casting in the use of the map. Would it make sense to create some helper functions that return void* and also take void*? I don't think it's worth doing here, but something to think about as a follow-up cl.

For example, you could add getMapBasePtr that returns void*, and add another version of remap/map that takes void* and calls the uptr version. Maybe add some others where you would have had to cast the pointers around.

[Chia-hungDuan]

Remove some reinterpret_cast<>() by using scudo::uptr if possible. In general,
we only need void* when using memset in these tests.

[Chia-hungDuan]

In D146570#4242385, @cferris wrote:

I notice a lot of casting in the use of the map. Would it make sense to create some helper functions that return void* and also take void*? I don't think it's worth doing here, but something to think about as a follow-up cl.

For example, you could add getMapBasePtr that returns void*, and add another version of remap/map that takes void* and calls the uptr version. Maybe add some others where you would have had to cast the pointers around.

In general, we expect most of operations are operating on uptr. It will use void* only when it binds to other system APIs. For example, we use memset in these tests. I revise a little bit so the we try to use uptr as much as possible and which reduces the use of reinterpret_cast. Let me know if it looks more clean.

[cferris]

LGTM

[Chia-hungDuan]

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

52

This is a bug. I'll revert this change

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::ReservedMapT ReservedMap;
+  ReservedMap.reserve(/*Addr=*/0U, Size, "testSEGV");
+  void *P = reinterpret_cast<void *>(ReservedMap.getMapBase());
+  ASSERT_NE(P, nullptr);
   EXPECT_DEATH(memset(P, 0xaa, Size), "");
-  scudo::unmap(P, Size, UNMAP_ALL, &Data);
+  ReservedMap.unmap(reinterpret_cast<scudo::uptr>(P), Size, UNMAP_ALL);
 }
 
 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"));
+  void *P = reinterpret_cast<void *>(MemMap.getMapBase());
   EXPECT_LT(getResidentMemorySize(), OnStart + Threshold);
 
   memset(P, 1, Size);
   EXPECT_GT(getResidentMemorySize(), OnStart + Size - Threshold);
 
-  releasePagesToOS((uptr)P, 0, Size, &Data);
+  MemMap.releasePagesToOS(reinterpret_cast<uptr>(P), Size);
   EXPECT_LT(getResidentMemorySize(), OnStart + Threshold);
 
   memset(P, 1, Size);
   EXPECT_GT(getResidentMemorySize(), OnStart + Size - Threshold);
 
-  unmap(P, Size, 0, &Data);
+  MemMap.unmap(reinterpret_cast<uptr>(P), 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"));
+  uptr *P = reinterpret_cast<uptr *>(MemMap.getMapBase());
+  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(reinterpret_cast<uptr>(P), Size);
   EXPECT_EQ(std::count(P, P + N, 0), N);
 
-  unmap(P, Size, 0, &Data);
+  MemMap.unmap(reinterpret_cast<uptr>(P), 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);
+  scudo::ReservedMapT ReservedMap;
+  ReservedMap.reserve(/*Addr=*/0U, Size, MappingName);
+  void *P = reinterpret_cast<void *>(ReservedMap.getMapBase());
   EXPECT_NE(P, nullptr);
   EXPECT_DEATH(memset(P, 0xaa, Size), "");
-  scudo::unmap(P, Size, UNMAP_ALL, &Data);
+
+  ReservedMap.unmap(reinterpret_cast<scudo::uptr>(P), Size, UNMAP_ALL);
 }
 
 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);
+          scudo::MemMapT MemMap;
+          MemMap.map(/*Addr=*/0U, Size, MappingName);
+          void *P = reinterpret_cast<void *>(MemMap.getMapBase());
           if (!P)
             continue;
-          scudo::unmap(P, Size, 0, nullptr);
+          MemMap.unmap(reinterpret_cast<scudo::uptr>(P), Size);
           memset(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);
+  scudo::ReservedMapT ReservedMap;
+  ReservedMap.reserve(/*Addr=*/0U, Size + 2 * PageSize, MappingName);
+  void *P = reinterpret_cast<void *>(ReservedMap.getMapBase());
+  ASSERT_NE(P, nullptr);
+  scudo::MemMapT MemMap = ReservedMap.allocate(reinterpret_cast<scudo::uptr>(P),
+                                               Size + 2 * PageSize);
+  ASSERT_TRUE(MemMap.isAllocated());
+  void *Q = reinterpret_cast<void *>(MemMap.getMapBase() + PageSize);
+  ASSERT_TRUE(
+      MemMap.remap(reinterpret_cast<scudo::uptr>(Q), Size, MappingName));
   memset(Q, 0xaa, Size);
   EXPECT_DEATH(memset(Q, 0xaa, Size + 1), "");
-  scudo::unmap(P, Size + 2 * PageSize, UNMAP_ALL, &Data);
+  MemMap.unmap(MemMap.getMapBase(), MemMap.getMapCapacity(), UNMAP_ALL);
 }
 
 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);
+  scudo::ReservedMapT ReservedMap;
+  ReservedMap.reserve(/*Addr=*/0U, Size, MappingName);
+  void *P = reinterpret_cast<void *>(ReservedMap.getMapBase());
+  ASSERT_NE(P, nullptr);
+
+  scudo::MemMapT MemMap =
+      ReservedMap.allocate(reinterpret_cast<scudo::uptr>(P), Size);
+  ASSERT_TRUE(MemMap.isAllocated());
+  void *Q = reinterpret_cast<void *>(MemMap.getMapBase() + PageSize);
+  ASSERT_TRUE(
+      MemMap.remap(reinterpret_cast<scudo::uptr>(Q), PageSize, MappingName));
   memset(Q, 0xaa, PageSize);
   Q = reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(Q) + PageSize);
-  EXPECT_EQ(scudo::map(Q, PageSize, MappingName, 0, &Data), Q);
+  ASSERT_TRUE(
+      MemMap.remap(reinterpret_cast<scudo::uptr>(Q), PageSize, MappingName));
   memset(Q, 0xbb, PageSize);
-  scudo::unmap(P, Size, UNMAP_ALL, &Data);
+  MemMap.unmap(MemMap.getMapBase(), MemMap.getMapCapacity(), UNMAP_ALL);
 }

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));
+    scudo::MemMapT MemMap;
+    ASSERT_TRUE(MemMap.map(/*Addr=*/0U, BufferSize, "MemtagTest", MAP_MEMTAG));
+    Buffer = reinterpret_cast<u8 *>(MemMap.getMapBase());
     Addr = reinterpret_cast<uptr>(Buffer);
     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.getMapBase(), MemMap.getMapCapacity());
+    }
   }
 
   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