[scudo] Add unmapTestOnly() to secondary.

[hctim]

Summary

When trying to track down a vaddr-poisoning bug, I found that that the
secondary cache isn't emptied on test teardown. We should probably do
that to make the tests hermetic. Otherwise, repeating the tests lots of
times using --gtest_repeat fails after the mmap vaddr space is
exhausted.

To repro:
$ ninja check-scudo_standalone # build
$ ./projects/compiler-rt/lib/scudo/standalone/tests/ScudoUnitTest-x86_64-Test \
--gtest_filter=ScudoSecondaryTest.*:-ScudoSecondaryTest.SecondaryCombinations \
--gtest_repeat=10000

compiler-rt/lib/scudo/standalone/combined.h

ALWAYS_INLINE void initThreadMaybe(bool MinimalInit = false) {
     TSDRegistry.initThreadMaybe(this, MinimalInit);
   }
 
   void reset() { memset(this, 0, sizeof(*this)); }
 
   void unmapTestOnly() {
     TSDRegistry.unmapTestOnly();
     Primary.unmapTestOnly();
+    Secondary.unmapTestOnly();
 #ifdef GWP_ASAN_HOOKS
     if (getFlags()->GWP_ASAN_InstallSignalHandlers)
       gwp_asan::segv_handler::uninstallSignalHandlers();
     GuardedAlloc.uninitTestOnly();
 #endif // GWP_ASAN_HOOKS
   }
 
   TSDRegistryT *getTSDRegistry() { return &TSDRegistry; }

compiler-rt/lib/scudo/standalone/secondary.h

bool retrieve(UNUSED Options Options, UNUSED uptr Size, UNUSED uptr Alignment,
     return false;
   }
   void store(UNUSED Options Options, LargeBlock::Header *H) { unmap(H); }
   bool canCache(UNUSED uptr Size) { return false; }
   void disable() {}
   void enable() {}
   void releaseToOS() {}
   void disableMemoryTagging() {}
+  void unmapTestOnly() {}
   bool setOption(Option O, UNUSED sptr Value) {
     if (O == Option::ReleaseInterval || O == Option::MaxCacheEntriesCount ||
         O == Option::MaxCacheEntrySize)
       return false;
     // Not supported by the Secondary Cache, but not an error either.
     return true;
   }
 };
for (u32 I = 0; I < MaxCount; I++)
                             &Entries[I].Data);
     QuarantinePos = -1U;
   }
 
   void disable() { Mutex.lock(); }
 
   void enable() { Mutex.unlock(); }
 
+  void unmapTestOnly() { empty(); }
+
 private:
   void empty() {
     struct {
       void *MapBase;
       uptr MapSize;
       MapPlatformData Data;
     } MapInfo[Config::SecondaryCacheEntriesArraySize];
     uptr N = 0;
public:
   uptr canCache(uptr Size) { return Cache.canCache(Size); }
 
   bool setOption(Option O, sptr Value) { return Cache.setOption(O, Value); }
 
   void releaseToOS() { Cache.releaseToOS(); }
 
   void disableMemoryTagging() { Cache.disableMemoryTagging(); }
 
+  void unmapTestOnly() { Cache.unmapTestOnly(); }
+
 private:
   typename Config::SecondaryCache Cache;
 
   HybridMutex Mutex;
   DoublyLinkedList<LargeBlock::Header> InUseBlocks;
   uptr AllocatedBytes = 0;
   uptr FreedBytes = 0;
   uptr LargestSize = 0;

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

template <typename Config> static void testSecondaryBasic(void) {
   std::shuffle(V.begin(), V.end(), std::mt19937(std::random_device()()));
   while (!V.empty()) {
     L->deallocate(scudo::Options{}, V.back());
     V.pop_back();
   }
   scudo::ScopedString Str(1024);
   L->getStats(&Str);
   Str.output();
+  L->unmapTestOnly();
 }
 
 struct NoCacheConfig {
   typedef scudo::MapAllocatorNoCache SecondaryCache;
   static const bool MaySupportMemoryTagging = false;
 };
 
 struct TestConfig {
for (scudo::uptr AlignLog = FIRST_32_SECOND_64(3, 4); AlignLog <= 16;
         memset(AlignedP, 0xff, UserSize);
         L->deallocate(scudo::Options{}, P);
       }
     }
   }
   scudo::ScopedString Str(1024);
   L->getStats(&Str);
   Str.output();
+  L->unmapTestOnly();
 }
 
 TEST(ScudoSecondaryTest, SecondaryIterate) {
   std::unique_ptr<LargeAllocator> L(new LargeAllocator);
   L->init(nullptr);
   std::vector<void *> V;
   const scudo::uptr PageSize = scudo::getPageSizeCached();
   for (scudo::uptr I = 0; I < 32U; I++)
     V.push_back(L->allocate(scudo::Options{}, (std::rand() % 16) * PageSize));
   auto Lambda = [V](scudo::uptr Block) {
     EXPECT_NE(std::find(V.begin(), V.end(), reinterpret_cast<void *>(Block)),
               V.end());
   };
   L->disable();
   L->iterateOverBlocks(Lambda);
   L->enable();
   while (!V.empty()) {
     L->deallocate(scudo::Options{}, V.back());
     V.pop_back();
   }
   scudo::ScopedString Str(1024);
   L->getStats(&Str);
   Str.output();
+  L->unmapTestOnly();
 }
 
 TEST(ScudoSecondaryTest, SecondaryOptions) {
   std::unique_ptr<LargeAllocator> L(new LargeAllocator);
   L->init(nullptr);
   // Attempt to set a maximum number of entries higher than the array size.
   EXPECT_FALSE(L->setOption(scudo::Option::MaxCacheEntriesCount, 4096U));
   // A negative number will be cast to a scudo::u32, and fail.
   EXPECT_FALSE(L->setOption(scudo::Option::MaxCacheEntriesCount, -1));
   if (L->canCache(0U)) {
     // Various valid combinations.
     EXPECT_TRUE(L->setOption(scudo::Option::MaxCacheEntriesCount, 4U));
     EXPECT_TRUE(L->setOption(scudo::Option::MaxCacheEntrySize, 1UL << 20));
     EXPECT_TRUE(L->canCache(1UL << 18));
     EXPECT_TRUE(L->setOption(scudo::Option::MaxCacheEntrySize, 1UL << 17));
     EXPECT_FALSE(L->canCache(1UL << 18));
     EXPECT_TRUE(L->canCache(1UL << 16));
     EXPECT_TRUE(L->setOption(scudo::Option::MaxCacheEntriesCount, 0U));
     EXPECT_FALSE(L->canCache(1UL << 16));
     EXPECT_TRUE(L->setOption(scudo::Option::MaxCacheEntriesCount, 4U));
     EXPECT_TRUE(L->setOption(scudo::Option::MaxCacheEntrySize, 1UL << 20));
     EXPECT_TRUE(L->canCache(1UL << 16));
   }
+  L->unmapTestOnly();
 }
 
 static std::mutex Mutex;
 static std::condition_variable Cv;
 static bool Ready;
 
 static void performAllocations(LargeAllocator *L) {
   std::vector<void *> V;
for (scudo::uptr I = 0; I < ARRAY_SIZE(Threads); I++)
     Ready = true;
     Cv.notify_all();
   }
   for (auto &T : Threads)
     T.join();
   scudo::ScopedString Str(1024);
   L->getStats(&Str);
   Str.output();
+  L->unmapTestOnly();
 }