llvm/unittests/Support/MemoryTest.cpp

   1 //===- llvm/unittest/Support/AllocatorTest.cpp - BumpPtrAllocator tests ---===//
   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 "llvm/Support/Memory.h"
  10 #include "llvm/Support/Process.h"
  11 #include "gtest/gtest.h"
  12 #include <cassert>
  13 #include <cstdlib>
  14
  15 #if defined(__NetBSD__)
  16 // clang-format off
  17 #include <sys/param.h>
  18 #include <sys/types.h>
  19 #include <sys/sysctl.h>
  20 #include <err.h>
  21 #include <unistd.h>
  22 // clang-format on
  23 #endif
  24
  25 using namespace llvm;
  26 using namespace sys;
  27
  28 namespace {
  29
  30 bool IsMPROTECT() {
  31 #if defined(__NetBSD__)
  32   int mib[3];
  33   int paxflags;
  34   size_t len = sizeof(paxflags);
  35
  36   mib[0] = CTL_PROC;
  37   mib[1] = getpid();
  38   mib[2] = PROC_PID_PAXFLAGS;
  39
  40   if (sysctl(mib, 3, &paxflags, &len, NULL, 0) != 0)
  41     err(EXIT_FAILURE, "sysctl");
  42
  43   return !!(paxflags & CTL_PROC_PAXFLAGS_MPROTECT);
  44 #elif defined(__APPLE__) && defined(__aarch64__)
  45   return true;
  46 #else
  47   return false;
  48 #endif
  49 }
  50
  51 class MappedMemoryTest : public ::testing::TestWithParam<unsigned> {
  52 public:
  53   MappedMemoryTest() {
  54     Flags = GetParam();
  55     PageSize = sys::Process::getPageSizeEstimate();
  56   }
  57
  58 protected:
  59   // Adds RW flags to permit testing of the resulting memory
  60   unsigned getTestableEquivalent(unsigned RequestedFlags) {
  61     switch (RequestedFlags) {
  62     case Memory::MF_READ:
  63     case Memory::MF_WRITE:
  64     case Memory::MF_READ|Memory::MF_WRITE:
  65       return Memory::MF_READ|Memory::MF_WRITE;
  66     case Memory::MF_READ|Memory::MF_EXEC:
  67     case Memory::MF_READ|Memory::MF_WRITE|Memory::MF_EXEC:
  68     case Memory::MF_EXEC:
  69       return Memory::MF_READ|Memory::MF_WRITE|Memory::MF_EXEC;
  70     }
  71     // Default in case values are added to the enum, as required by some compilers
  72     return Memory::MF_READ|Memory::MF_WRITE;
  73   }
  74
  75   // Returns true if the memory blocks overlap
  76   bool doesOverlap(MemoryBlock M1, MemoryBlock M2) {
  77     if (M1.base() == M2.base())
  78       return true;
  79
  80     if (M1.base() > M2.base())
  81       return (unsigned char *)M2.base() + M2.allocatedSize() > M1.base();
  82
  83     return (unsigned char *)M1.base() + M1.allocatedSize() > M2.base();
  84   }
  85
  86   unsigned Flags;
  87   size_t   PageSize;
  88 };
  89
  90 // MPROTECT prevents W+X mmaps
  91 #define CHECK_UNSUPPORTED() \
  92   do { \
  93     if ((Flags & Memory::MF_WRITE) && (Flags & Memory::MF_EXEC) && \
  94         IsMPROTECT()) \
  95       return; \
  96   } while (0)
  97
  98 TEST_P(MappedMemoryTest, AllocAndRelease) {
  99   CHECK_UNSUPPORTED();
 100   std::error_code EC;
 101   MemoryBlock M1 = Memory::allocateMappedMemory(sizeof(int), nullptr, Flags,EC);
 102   EXPECT_EQ(std::error_code(), EC);
 103
 104   EXPECT_NE((void*)nullptr, M1.base());
 105   EXPECT_LE(sizeof(int), M1.allocatedSize());
 106
 107   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 108 }
 109
 110 TEST_P(MappedMemoryTest, AllocAndReleaseHuge) {
 111   CHECK_UNSUPPORTED();
 112   std::error_code EC;
 113   MemoryBlock M1 = Memory::allocateMappedMemory(
 114       sizeof(int), nullptr, Flags | Memory::MF_HUGE_HINT, EC);
 115   EXPECT_EQ(std::error_code(), EC);
 116
 117   // Test large/huge memory pages. In the worst case, 4kb pages should be
 118   // returned, if large pages aren't available.
 119
 120   EXPECT_NE((void *)nullptr, M1.base());
 121   EXPECT_LE(sizeof(int), M1.allocatedSize());
 122
 123   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 124 }
 125
 126 TEST_P(MappedMemoryTest, MultipleAllocAndRelease) {
 127   CHECK_UNSUPPORTED();
 128   std::error_code EC;
 129   MemoryBlock M1 = Memory::allocateMappedMemory(16, nullptr, Flags, EC);
 130   EXPECT_EQ(std::error_code(), EC);
 131   MemoryBlock M2 = Memory::allocateMappedMemory(64, nullptr, Flags, EC);
 132   EXPECT_EQ(std::error_code(), EC);
 133   MemoryBlock M3 = Memory::allocateMappedMemory(32, nullptr, Flags, EC);
 134   EXPECT_EQ(std::error_code(), EC);
 135
 136   EXPECT_NE((void*)nullptr, M1.base());
 137   EXPECT_LE(16U, M1.allocatedSize());
 138   EXPECT_NE((void*)nullptr, M2.base());
 139   EXPECT_LE(64U, M2.allocatedSize());
 140   EXPECT_NE((void*)nullptr, M3.base());
 141   EXPECT_LE(32U, M3.allocatedSize());
 142
 143   EXPECT_FALSE(doesOverlap(M1, M2));
 144   EXPECT_FALSE(doesOverlap(M2, M3));
 145   EXPECT_FALSE(doesOverlap(M1, M3));
 146
 147   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 148   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 149   MemoryBlock M4 = Memory::allocateMappedMemory(16, nullptr, Flags, EC);
 150   EXPECT_EQ(std::error_code(), EC);
 151   EXPECT_NE((void*)nullptr, M4.base());
 152   EXPECT_LE(16U, M4.allocatedSize());
 153   EXPECT_FALSE(Memory::releaseMappedMemory(M4));
 154   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 155 }
 156
 157 TEST_P(MappedMemoryTest, BasicWrite) {
 158   // This test applies only to readable and writeable combinations
 159   if (Flags &&
 160       !((Flags & Memory::MF_READ) && (Flags & Memory::MF_WRITE)))
 161     return;
 162   CHECK_UNSUPPORTED();
 163
 164   std::error_code EC;
 165   MemoryBlock M1 = Memory::allocateMappedMemory(sizeof(int), nullptr, Flags,EC);
 166   EXPECT_EQ(std::error_code(), EC);
 167
 168   EXPECT_NE((void*)nullptr, M1.base());
 169   EXPECT_LE(sizeof(int), M1.allocatedSize());
 170
 171   int *a = (int*)M1.base();
 172   *a = 1;
 173   EXPECT_EQ(1, *a);
 174
 175   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 176 }
 177
 178 TEST_P(MappedMemoryTest, MultipleWrite) {
 179   // This test applies only to readable and writeable combinations
 180   if (Flags &&
 181       !((Flags & Memory::MF_READ) && (Flags & Memory::MF_WRITE)))
 182     return;
 183   CHECK_UNSUPPORTED();
 184
 185   std::error_code EC;
 186   MemoryBlock M1 = Memory::allocateMappedMemory(sizeof(int), nullptr, Flags,
 187                                                 EC);
 188   EXPECT_EQ(std::error_code(), EC);
 189   MemoryBlock M2 = Memory::allocateMappedMemory(8 * sizeof(int), nullptr, Flags,
 190                                                 EC);
 191   EXPECT_EQ(std::error_code(), EC);
 192   MemoryBlock M3 = Memory::allocateMappedMemory(4 * sizeof(int), nullptr, Flags,
 193                                                 EC);
 194   EXPECT_EQ(std::error_code(), EC);
 195
 196   EXPECT_FALSE(doesOverlap(M1, M2));
 197   EXPECT_FALSE(doesOverlap(M2, M3));
 198   EXPECT_FALSE(doesOverlap(M1, M3));
 199
 200   EXPECT_NE((void*)nullptr, M1.base());
 201   EXPECT_LE(1U * sizeof(int), M1.allocatedSize());
 202   EXPECT_NE((void*)nullptr, M2.base());
 203   EXPECT_LE(8U * sizeof(int), M2.allocatedSize());
 204   EXPECT_NE((void*)nullptr, M3.base());
 205   EXPECT_LE(4U * sizeof(int), M3.allocatedSize());
 206
 207   int *x = (int*)M1.base();
 208   *x = 1;
 209
 210   int *y = (int*)M2.base();
 211   for (int i = 0; i < 8; i++) {
 212     y[i] = i;
 213   }
 214
 215   int *z = (int*)M3.base();
 216   *z = 42;
 217
 218   EXPECT_EQ(1, *x);
 219   EXPECT_EQ(7, y[7]);
 220   EXPECT_EQ(42, *z);
 221
 222   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 223   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 224
 225   MemoryBlock M4 = Memory::allocateMappedMemory(64 * sizeof(int), nullptr,
 226                                                 Flags, EC);
 227   EXPECT_EQ(std::error_code(), EC);
 228   EXPECT_NE((void*)nullptr, M4.base());
 229   EXPECT_LE(64U * sizeof(int), M4.allocatedSize());
 230   x = (int*)M4.base();
 231   *x = 4;
 232   EXPECT_EQ(4, *x);
 233   EXPECT_FALSE(Memory::releaseMappedMemory(M4));
 234
 235   // Verify that M2 remains unaffected by other activity
 236   for (int i = 0; i < 8; i++) {
 237     EXPECT_EQ(i, y[i]);
 238   }
 239   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 240 }
 241
 242 TEST_P(MappedMemoryTest, EnabledWrite) {
 243   // MPROTECT prevents W+X, and since this test always adds W we need
 244   // to block any variant with X.
 245   if ((Flags & Memory::MF_EXEC) && IsMPROTECT())
 246     return;
 247
 248   std::error_code EC;
 249   MemoryBlock M1 = Memory::allocateMappedMemory(2 * sizeof(int), nullptr, Flags,
 250                                                 EC);
 251   EXPECT_EQ(std::error_code(), EC);
 252   MemoryBlock M2 = Memory::allocateMappedMemory(8 * sizeof(int), nullptr, Flags,
 253                                                 EC);
 254   EXPECT_EQ(std::error_code(), EC);
 255   MemoryBlock M3 = Memory::allocateMappedMemory(4 * sizeof(int), nullptr, Flags,
 256                                                 EC);
 257   EXPECT_EQ(std::error_code(), EC);
 258
 259   EXPECT_NE((void*)nullptr, M1.base());
 260   EXPECT_LE(2U * sizeof(int), M1.allocatedSize());
 261   EXPECT_NE((void*)nullptr, M2.base());
 262   EXPECT_LE(8U * sizeof(int), M2.allocatedSize());
 263   EXPECT_NE((void*)nullptr, M3.base());
 264   EXPECT_LE(4U * sizeof(int), M3.allocatedSize());
 265
 266   EXPECT_FALSE(Memory::protectMappedMemory(M1, getTestableEquivalent(Flags)));
 267   EXPECT_FALSE(Memory::protectMappedMemory(M2, getTestableEquivalent(Flags)));
 268   EXPECT_FALSE(Memory::protectMappedMemory(M3, getTestableEquivalent(Flags)));
 269
 270   EXPECT_FALSE(doesOverlap(M1, M2));
 271   EXPECT_FALSE(doesOverlap(M2, M3));
 272   EXPECT_FALSE(doesOverlap(M1, M3));
 273
 274   int *x = (int*)M1.base();
 275   *x = 1;
 276   int *y = (int*)M2.base();
 277   for (unsigned int i = 0; i < 8; i++) {
 278     y[i] = i;
 279   }
 280   int *z = (int*)M3.base();
 281   *z = 42;
 282
 283   EXPECT_EQ(1, *x);
 284   EXPECT_EQ(7, y[7]);
 285   EXPECT_EQ(42, *z);
 286
 287   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 288   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 289   EXPECT_EQ(6, y[6]);
 290
 291   MemoryBlock M4 = Memory::allocateMappedMemory(16, nullptr, Flags, EC);
 292   EXPECT_EQ(std::error_code(), EC);
 293   EXPECT_NE((void*)nullptr, M4.base());
 294   EXPECT_LE(16U, M4.allocatedSize());
 295   EXPECT_EQ(std::error_code(),
 296             Memory::protectMappedMemory(M4, getTestableEquivalent(Flags)));
 297   x = (int*)M4.base();
 298   *x = 4;
 299   EXPECT_EQ(4, *x);
 300   EXPECT_FALSE(Memory::releaseMappedMemory(M4));
 301   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 302 }
 303
 304 TEST_P(MappedMemoryTest, SuccessiveNear) {
 305   CHECK_UNSUPPORTED();
 306   std::error_code EC;
 307   MemoryBlock M1 = Memory::allocateMappedMemory(16, nullptr, Flags, EC);
 308   EXPECT_EQ(std::error_code(), EC);
 309   MemoryBlock M2 = Memory::allocateMappedMemory(64, &M1, Flags, EC);
 310   EXPECT_EQ(std::error_code(), EC);
 311   MemoryBlock M3 = Memory::allocateMappedMemory(32, &M2, Flags, EC);
 312   EXPECT_EQ(std::error_code(), EC);
 313
 314   EXPECT_NE((void*)nullptr, M1.base());
 315   EXPECT_LE(16U, M1.allocatedSize());
 316   EXPECT_NE((void*)nullptr, M2.base());
 317   EXPECT_LE(64U, M2.allocatedSize());
 318   EXPECT_NE((void*)nullptr, M3.base());
 319   EXPECT_LE(32U, M3.allocatedSize());
 320
 321   EXPECT_FALSE(doesOverlap(M1, M2));
 322   EXPECT_FALSE(doesOverlap(M2, M3));
 323   EXPECT_FALSE(doesOverlap(M1, M3));
 324
 325   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 326   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 327   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 328 }
 329
 330 TEST_P(MappedMemoryTest, DuplicateNear) {
 331   CHECK_UNSUPPORTED();
 332   std::error_code EC;
 333   MemoryBlock Near((void*)(3*PageSize), 16);
 334   MemoryBlock M1 = Memory::allocateMappedMemory(16, &Near, Flags, EC);
 335   EXPECT_EQ(std::error_code(), EC);
 336   MemoryBlock M2 = Memory::allocateMappedMemory(64, &Near, Flags, EC);
 337   EXPECT_EQ(std::error_code(), EC);
 338   MemoryBlock M3 = Memory::allocateMappedMemory(32, &Near, Flags, EC);
 339   EXPECT_EQ(std::error_code(), EC);
 340
 341   EXPECT_NE((void*)nullptr, M1.base());
 342   EXPECT_LE(16U, M1.allocatedSize());
 343   EXPECT_NE((void*)nullptr, M2.base());
 344   EXPECT_LE(64U, M2.allocatedSize());
 345   EXPECT_NE((void*)nullptr, M3.base());
 346   EXPECT_LE(32U, M3.allocatedSize());
 347
 348   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 349   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 350   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 351 }
 352
 353 TEST_P(MappedMemoryTest, ZeroNear) {
 354   CHECK_UNSUPPORTED();
 355   std::error_code EC;
 356   MemoryBlock Near(nullptr, 0);
 357   MemoryBlock M1 = Memory::allocateMappedMemory(16, &Near, Flags, EC);
 358   EXPECT_EQ(std::error_code(), EC);
 359   MemoryBlock M2 = Memory::allocateMappedMemory(64, &Near, Flags, EC);
 360   EXPECT_EQ(std::error_code(), EC);
 361   MemoryBlock M3 = Memory::allocateMappedMemory(32, &Near, Flags, EC);
 362   EXPECT_EQ(std::error_code(), EC);
 363
 364   EXPECT_NE((void*)nullptr, M1.base());
 365   EXPECT_LE(16U, M1.allocatedSize());
 366   EXPECT_NE((void*)nullptr, M2.base());
 367   EXPECT_LE(64U, M2.allocatedSize());
 368   EXPECT_NE((void*)nullptr, M3.base());
 369   EXPECT_LE(32U, M3.allocatedSize());
 370
 371   EXPECT_FALSE(doesOverlap(M1, M2));
 372   EXPECT_FALSE(doesOverlap(M2, M3));
 373   EXPECT_FALSE(doesOverlap(M1, M3));
 374
 375   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 376   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 377   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 378 }
 379
 380 TEST_P(MappedMemoryTest, ZeroSizeNear) {
 381   CHECK_UNSUPPORTED();
 382   std::error_code EC;
 383   MemoryBlock Near((void*)(4*PageSize), 0);
 384   MemoryBlock M1 = Memory::allocateMappedMemory(16, &Near, Flags, EC);
 385   EXPECT_EQ(std::error_code(), EC);
 386   MemoryBlock M2 = Memory::allocateMappedMemory(64, &Near, Flags, EC);
 387   EXPECT_EQ(std::error_code(), EC);
 388   MemoryBlock M3 = Memory::allocateMappedMemory(32, &Near, Flags, EC);
 389   EXPECT_EQ(std::error_code(), EC);
 390
 391   EXPECT_NE((void*)nullptr, M1.base());
 392   EXPECT_LE(16U, M1.allocatedSize());
 393   EXPECT_NE((void*)nullptr, M2.base());
 394   EXPECT_LE(64U, M2.allocatedSize());
 395   EXPECT_NE((void*)nullptr, M3.base());
 396   EXPECT_LE(32U, M3.allocatedSize());
 397
 398   EXPECT_FALSE(doesOverlap(M1, M2));
 399   EXPECT_FALSE(doesOverlap(M2, M3));
 400   EXPECT_FALSE(doesOverlap(M1, M3));
 401
 402   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 403   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 404   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 405 }
 406
 407 TEST_P(MappedMemoryTest, UnalignedNear) {
 408   CHECK_UNSUPPORTED();
 409   std::error_code EC;
 410   MemoryBlock Near((void*)(2*PageSize+5), 0);
 411   MemoryBlock M1 = Memory::allocateMappedMemory(15, &Near, Flags, EC);
 412   EXPECT_EQ(std::error_code(), EC);
 413
 414   EXPECT_NE((void*)nullptr, M1.base());
 415   EXPECT_LE(sizeof(int), M1.allocatedSize());
 416
 417   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 418 }
 419
 420 // Note that Memory::MF_WRITE is not supported exclusively across
 421 // operating systems and architectures and can imply MF_READ|MF_WRITE
 422 unsigned MemoryFlags[] = {
 423                            Memory::MF_READ,
 424                            Memory::MF_WRITE,
 425                            Memory::MF_READ|Memory::MF_WRITE,
 426                            Memory::MF_EXEC,
 427                            Memory::MF_READ|Memory::MF_EXEC,
 428                            Memory::MF_READ|Memory::MF_WRITE|Memory::MF_EXEC
 429                          };
 430
 431 INSTANTIATE_TEST_SUITE_P(AllocationTests, MappedMemoryTest,
 432                          ::testing::ValuesIn(MemoryFlags));
 433
 434 }  // anonymous namespace