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

   1 //===-- quarantine_test.cpp -------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "tests/scudo_unit_test.h"
  10
  11 #include "quarantine.h"
  12
  13 #include <pthread.h>
  14 #include <stdlib.h>
  15
  16 static void *FakePtr = reinterpret_cast<void *>(0xFA83FA83);
  17 static const scudo::uptr BlockSize = 8UL;
  18 static const scudo::uptr LargeBlockSize = 16384UL;
  19
  20 struct QuarantineCallback {
  21   void recycle(void *P) { EXPECT_EQ(P, FakePtr); }
  22   void *allocate(scudo::uptr Size) { return malloc(Size); }
  23   void deallocate(void *P) { free(P); }
  24 };
  25
  26 typedef scudo::GlobalQuarantine<QuarantineCallback, void> QuarantineT;
  27 typedef typename QuarantineT::CacheT CacheT;
  28
  29 static QuarantineCallback Cb;
  30
  31 static void deallocateCache(CacheT *Cache) {
  32   while (scudo::QuarantineBatch *Batch = Cache->dequeueBatch())
  33     Cb.deallocate(Batch);
  34 }
  35
  36 TEST(ScudoQuarantineTest, QuarantineBatchMerge) {
  37   // Verify the trivial case.
  38   scudo::QuarantineBatch Into;
  39   Into.init(FakePtr, 4UL);
  40   scudo::QuarantineBatch From;
  41   From.init(FakePtr, 8UL);
  42
  43   Into.merge(&From);
  44
  45   EXPECT_EQ(Into.Count, 2UL);
  46   EXPECT_EQ(Into.Batch[0], FakePtr);
  47   EXPECT_EQ(Into.Batch[1], FakePtr);
  48   EXPECT_EQ(Into.Size, 12UL + sizeof(scudo::QuarantineBatch));
  49   EXPECT_EQ(Into.getQuarantinedSize(), 12UL);
  50
  51   EXPECT_EQ(From.Count, 0UL);
  52   EXPECT_EQ(From.Size, sizeof(scudo::QuarantineBatch));
  53   EXPECT_EQ(From.getQuarantinedSize(), 0UL);
  54
  55   // Merge the batch to the limit.
  56   for (scudo::uptr I = 2; I < scudo::QuarantineBatch::MaxCount; ++I)
  57     From.push_back(FakePtr, 8UL);
  58   EXPECT_TRUE(Into.Count + From.Count == scudo::QuarantineBatch::MaxCount);
  59   EXPECT_TRUE(Into.canMerge(&From));
  60
  61   Into.merge(&From);
  62   EXPECT_TRUE(Into.Count == scudo::QuarantineBatch::MaxCount);
  63
  64   // No more space, not even for one element.
  65   From.init(FakePtr, 8UL);
  66
  67   EXPECT_FALSE(Into.canMerge(&From));
  68 }
  69
  70 TEST(ScudoQuarantineTest, QuarantineCacheMergeBatchesEmpty) {
  71   CacheT Cache;
  72   CacheT ToDeallocate;
  73   Cache.init();
  74   ToDeallocate.init();
  75   Cache.mergeBatches(&ToDeallocate);
  76
  77   EXPECT_EQ(ToDeallocate.getSize(), 0UL);
  78   EXPECT_EQ(ToDeallocate.dequeueBatch(), nullptr);
  79 }
  80
  81 TEST(SanitizerCommon, QuarantineCacheMergeBatchesOneBatch) {
  82   CacheT Cache;
  83   Cache.init();
  84   Cache.enqueue(Cb, FakePtr, BlockSize);
  85   EXPECT_EQ(BlockSize + sizeof(scudo::QuarantineBatch), Cache.getSize());
  86
  87   CacheT ToDeallocate;
  88   ToDeallocate.init();
  89   Cache.mergeBatches(&ToDeallocate);
  90
  91   // Nothing to merge, nothing to deallocate.
  92   EXPECT_EQ(BlockSize + sizeof(scudo::QuarantineBatch), Cache.getSize());
  93
  94   EXPECT_EQ(ToDeallocate.getSize(), 0UL);
  95   EXPECT_EQ(ToDeallocate.dequeueBatch(), nullptr);
  96
  97   deallocateCache(&Cache);
  98 }
  99
 100 TEST(ScudoQuarantineTest, QuarantineCacheMergeBatchesSmallBatches) {
 101   // Make a Cache with two batches small enough to merge.
 102   CacheT From;
 103   From.init();
 104   From.enqueue(Cb, FakePtr, BlockSize);
 105   CacheT Cache;
 106   Cache.init();
 107   Cache.enqueue(Cb, FakePtr, BlockSize);
 108
 109   Cache.transfer(&From);
 110   EXPECT_EQ(BlockSize * 2 + sizeof(scudo::QuarantineBatch) * 2,
 111             Cache.getSize());
 112
 113   CacheT ToDeallocate;
 114   ToDeallocate.init();
 115   Cache.mergeBatches(&ToDeallocate);
 116
 117   // Batches merged, one batch to deallocate.
 118   EXPECT_EQ(BlockSize * 2 + sizeof(scudo::QuarantineBatch), Cache.getSize());
 119   EXPECT_EQ(ToDeallocate.getSize(), sizeof(scudo::QuarantineBatch));
 120
 121   deallocateCache(&Cache);
 122   deallocateCache(&ToDeallocate);
 123 }
 124
 125 TEST(ScudoQuarantineTest, QuarantineCacheMergeBatchesTooBigToMerge) {
 126   const scudo::uptr NumBlocks = scudo::QuarantineBatch::MaxCount - 1;
 127
 128   // Make a Cache with two batches small enough to merge.
 129   CacheT From;
 130   CacheT Cache;
 131   From.init();
 132   Cache.init();
 133   for (scudo::uptr I = 0; I < NumBlocks; ++I) {
 134     From.enqueue(Cb, FakePtr, BlockSize);
 135     Cache.enqueue(Cb, FakePtr, BlockSize);
 136   }
 137   Cache.transfer(&From);
 138   EXPECT_EQ(BlockSize * NumBlocks * 2 + sizeof(scudo::QuarantineBatch) * 2,
 139             Cache.getSize());
 140
 141   CacheT ToDeallocate;
 142   ToDeallocate.init();
 143   Cache.mergeBatches(&ToDeallocate);
 144
 145   // Batches cannot be merged.
 146   EXPECT_EQ(BlockSize * NumBlocks * 2 + sizeof(scudo::QuarantineBatch) * 2,
 147             Cache.getSize());
 148   EXPECT_EQ(ToDeallocate.getSize(), 0UL);
 149
 150   deallocateCache(&Cache);
 151 }
 152
 153 TEST(ScudoQuarantineTest, QuarantineCacheMergeBatchesALotOfBatches) {
 154   const scudo::uptr NumBatchesAfterMerge = 3;
 155   const scudo::uptr NumBlocks =
 156       scudo::QuarantineBatch::MaxCount * NumBatchesAfterMerge;
 157   const scudo::uptr NumBatchesBeforeMerge = NumBlocks;
 158
 159   // Make a Cache with many small batches.
 160   CacheT Cache;
 161   Cache.init();
 162   for (scudo::uptr I = 0; I < NumBlocks; ++I) {
 163     CacheT From;
 164     From.init();
 165     From.enqueue(Cb, FakePtr, BlockSize);
 166     Cache.transfer(&From);
 167   }
 168
 169   EXPECT_EQ(BlockSize * NumBlocks +
 170                 sizeof(scudo::QuarantineBatch) * NumBatchesBeforeMerge,
 171             Cache.getSize());
 172
 173   CacheT ToDeallocate;
 174   ToDeallocate.init();
 175   Cache.mergeBatches(&ToDeallocate);
 176
 177   // All blocks should fit Into 3 batches.
 178   EXPECT_EQ(BlockSize * NumBlocks +
 179                 sizeof(scudo::QuarantineBatch) * NumBatchesAfterMerge,
 180             Cache.getSize());
 181
 182   EXPECT_EQ(ToDeallocate.getSize(),
 183             sizeof(scudo::QuarantineBatch) *
 184                 (NumBatchesBeforeMerge - NumBatchesAfterMerge));
 185
 186   deallocateCache(&Cache);
 187   deallocateCache(&ToDeallocate);
 188 }
 189
 190 static const scudo::uptr MaxQuarantineSize = 1024UL << 10; // 1MB
 191 static const scudo::uptr MaxCacheSize = 256UL << 10;       // 256KB
 192
 193 TEST(ScudoQuarantineTest, GlobalQuarantine) {
 194   QuarantineT Quarantine;
 195   CacheT Cache;
 196   Cache.init();
 197   Quarantine.init(MaxQuarantineSize, MaxCacheSize);
 198   EXPECT_EQ(Quarantine.getMaxSize(), MaxQuarantineSize);
 199   EXPECT_EQ(Quarantine.getCacheSize(), MaxCacheSize);
 200
 201   bool DrainOccurred = false;
 202   scudo::uptr CacheSize = Cache.getSize();
 203   EXPECT_EQ(Cache.getSize(), 0UL);
 204   // We quarantine enough blocks that a drain has to occur. Verify this by
 205   // looking for a decrease of the size of the cache.
 206   for (scudo::uptr I = 0; I < 128UL; I++) {
 207     Quarantine.put(&Cache, Cb, FakePtr, LargeBlockSize);
 208     if (!DrainOccurred && Cache.getSize() < CacheSize)
 209       DrainOccurred = true;
 210     CacheSize = Cache.getSize();
 211   }
 212   EXPECT_TRUE(DrainOccurred);
 213
 214   Quarantine.drainAndRecycle(&Cache, Cb);
 215   EXPECT_EQ(Cache.getSize(), 0UL);
 216
 217   scudo::ScopedString Str;
 218   Quarantine.getStats(&Str);
 219   Str.output();
 220 }
 221
 222 struct PopulateQuarantineThread {
 223   pthread_t Thread;
 224   QuarantineT *Quarantine;
 225   CacheT Cache;
 226 };
 227
 228 void *populateQuarantine(void *Param) {
 229   PopulateQuarantineThread *P = static_cast<PopulateQuarantineThread *>(Param);
 230   P->Cache.init();
 231   for (scudo::uptr I = 0; I < 128UL; I++)
 232     P->Quarantine->put(&P->Cache, Cb, FakePtr, LargeBlockSize);
 233   return 0;
 234 }
 235
 236 TEST(ScudoQuarantineTest, ThreadedGlobalQuarantine) {
 237   QuarantineT Quarantine;
 238   Quarantine.init(MaxQuarantineSize, MaxCacheSize);
 239
 240   const scudo::uptr NumberOfThreads = 32U;
 241   PopulateQuarantineThread T[NumberOfThreads];
 242   for (scudo::uptr I = 0; I < NumberOfThreads; I++) {
 243     T[I].Quarantine = &Quarantine;
 244     pthread_create(&T[I].Thread, 0, populateQuarantine, &T[I]);
 245   }
 246   for (scudo::uptr I = 0; I < NumberOfThreads; I++)
 247     pthread_join(T[I].Thread, 0);
 248
 249   scudo::ScopedString Str;
 250   Quarantine.getStats(&Str);
 251   Str.output();
 252
 253   for (scudo::uptr I = 0; I < NumberOfThreads; I++)
 254     Quarantine.drainAndRecycle(&T[I].Cache, Cb);
 255 }