[scudo] Ensure proper allocator alignment in TSD test

[cryptoad]

Summary

The MockAllocator used in ScudoTSDTest wasn't allocated
properly aligned, which resulted in the TSDs of the shared
registry not being aligned either. This lead to some failures
like: https://reviews.llvm.org/D103119#2822008

This changes how the MockAllocator is allocated, same as
Vitaly did in the combined tests, properly aligning it, which
results in the TSDs being aligned as well.

Add a DCHECK in the shared registry to check that it is.

[cryptoad]

Add stdlib.h to the test for posix_memalign. My builds don't
complain but I assume something will eventually.

[yroux]

LGTM, I confirm that it fixes the alignement issue observed on Thumbv7 bots

[vitalybuka]

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

157 ↗

(On Diff #352483)

Should we just check isAligned(this, alignof(*this)) ?

[vitalybuka]

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

157 ↗

(On Diff #352483)

I guess alignas in allocator promises alignment which is not delivered buy "new"
So maybe more consistent solution is just to put DCHECK(isAligned) into every class with alignas statement.

[vitalybuka]

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

157 ↗

(On Diff #352483)

e.g.
GlobalQuarantine::Init
SizeClassAllocator64::Init
SizeClassAllocator32::SizeClassAllocator32
TSD::Init

[yroux]

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

157 ↗

(On Diff #352483)

Ah yes, it seems better indeed.
I verified it on ARM and it fixes the issue as well

[cryptoad]

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

157 ↗

(On Diff #352483)

ack, working on it.

[cryptoad]

Adding more isAligned DCHECK as Vitaly suggested.

alignof(*this) was triggering a warning in my build:

'alignof' applied to an expression is a GNU extension [-Wgnu-alignof-expression]

so I decided to use the ThisT construct instead which doesn't
exhibit the same issue.

[vitalybuka]

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

173

this is the modern way do to typedefs
using ThisT = GlobalQuarantine<Callback, Node> ;

[cryptoad]

Using using instead of typedef on the newly added ones.

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

public:
 
   void init(s32 ReleaseToOsInterval) {
     if (SCUDO_FUCHSIA)
       reportError("SizeClassAllocator32 is not supported on Fuchsia");
 
     if (SCUDO_TRUSTY)
       reportError("SizeClassAllocator32 is not supported on Trusty");
 
+    DCHECK(isAligned(reinterpret_cast<uptr>(this), alignof(ThisT)));
     PossibleRegions.init();
-
     u32 Seed;
     const u64 Time = getMonotonicTime();
     if (!getRandom(reinterpret_cast<void *>(&Seed), sizeof(Seed)))
       Seed = static_cast<u32>(
           Time ^ (reinterpret_cast<uptr>(SizeClassInfoArray) >> 6));
     for (uptr I = 0; I < NumClasses; I++) {
       SizeClassInfo *Sci = getSizeClassInfo(I);
       Sci->RandState = getRandomU32(&Seed);

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

static uptr getSizeByClassId(uptr ClassId) {
     return (ClassId == SizeClassMap::BatchClassId)
                ? roundUpTo(sizeof(TransferBatch), 1U << CompactPtrScale)
                : SizeClassMap::getSizeByClassId(ClassId);
   }
 
   static bool canAllocate(uptr Size) { return Size <= SizeClassMap::MaxSize; }
 
   void init(s32 ReleaseToOsInterval) {
+    DCHECK(isAligned(reinterpret_cast<uptr>(this), alignof(ThisT)));
     DCHECK_EQ(PrimaryBase, 0U);
     // Reserve the space required for the Primary.
     PrimaryBase = reinterpret_cast<uptr>(
         map(nullptr, PrimarySize, nullptr, MAP_NOACCESS, &Data));
 
     u32 Seed;
     const u64 Time = getMonotonicTime();
     if (!getRandom(reinterpret_cast<void *>(&Seed), sizeof(Seed)))

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

 
 // The callback interface is:
 // void Callback::recycle(Node *Ptr);
 // void *Callback::allocate(uptr Size);
 // void Callback::deallocate(void *Ptr);
 template <typename Callback, typename Node> class GlobalQuarantine {
 public:
   typedef QuarantineCache<Callback> CacheT;
+  using ThisT = GlobalQuarantine<Callback, Node>;
 
   void init(uptr Size, uptr CacheSize) {
+    DCHECK(isAligned(reinterpret_cast<uptr>(this), alignof(ThisT)));
     DCHECK_EQ(atomic_load_relaxed(&MaxSize), 0U);
     DCHECK_EQ(atomic_load_relaxed(&MinSize), 0U);
     DCHECK_EQ(atomic_load_relaxed(&MaxCacheSize), 0U);
     // Thread local quarantine size can be zero only when global quarantine size
     // is zero (it allows us to perform just one atomic read per put() call).
     CHECK((Size == 0 && CacheSize == 0) || CacheSize != 0);
 
     atomic_store_relaxed(&MaxSize, Size);

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

 //===-- tsd_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 "tsd_exclusive.h"
 #include "tsd_shared.h"
 
+#include <stdlib.h>
+
 #include <condition_variable>
 #include <mutex>
 #include <set>
 #include <thread>
 
 // We mock out an allocator with a TSD registry, mostly using empty stubs. The
 // cache contains a single volatile uptr, to be able to test that several
 // concurrent threads will not access or modify the same cache at the same time.
public:
   void unmapTestOnly() { TSDRegistry.unmapTestOnly(this); }
   void initCache(CacheT *Cache) { *Cache = {}; }
   void commitBack(scudo::TSD<MockAllocator> *TSD) {}
   TSDRegistryT *getTSDRegistry() { return &TSDRegistry; }
   void callPostInitCallback() {}
 
   bool isInitialized() { return Initialized; }
 
+  void *operator new(size_t Size) {
+    void *P = nullptr;
+    EXPECT_EQ(0, posix_memalign(&P, alignof(ThisT), Size));
+    return P;
+  }
+  void operator delete(void *P) { free(P); }
+
 private:
   bool Initialized = false;
   TSDRegistryT TSDRegistry;
 };
 
 struct OneCache {
   template <class Allocator>
   using TSDRegistryT = scudo::TSDRegistrySharedT<Allocator, 1U, 1U>;

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

 #define PTHREAD_DESTRUCTOR_ITERATIONS 4
 #endif
 
 namespace scudo {
 
 template <class Allocator> struct alignas(SCUDO_CACHE_LINE_SIZE) TSD {
   typename Allocator::CacheT Cache;
   typename Allocator::QuarantineCacheT QuarantineCache;
+  using ThisT = TSD<Allocator>;
   u8 DestructorIterations = 0;
 
   void init(Allocator *Instance) {
     DCHECK_EQ(DestructorIterations, 0U);
+    DCHECK(isAligned(reinterpret_cast<uptr>(this), alignof(ThisT)));
     Instance->initCache(&Cache);
     DestructorIterations = PTHREAD_DESTRUCTOR_ITERATIONS;
   }
 
   void commitBack(Allocator *Instance) { Instance->commitBack(this); }
 
   inline bool tryLock() {
     if (Mutex.tryLock()) {