[scudo] Allow for non-Android Shared TSD platforms, part 1

[cryptoad]

Summary

This first part just prepares the grounds for part 2 and doesn't add any new
functionality. It mostly consists of small refactors:

• move the pthread.h include higher as it will be used in the headers;
• use errno.h in scudo_allocator.cpp instead of the sanitizer one, update the errno assignments accordingly (otherwise it creates conflicts on some platforms due to pthread.h including errno.h);
• introduce and use getCurrentTSD and setCurrentTSD for the shared TSD model code;

lib/scudo/scudo_allocator.cpp

 #include "scudo_allocator.h"
 #include "scudo_crc32.h"
 #include "scudo_flags.h"
 #include "scudo_tsd.h"
 #include "scudo_utils.h"
 
 #include "sanitizer_common/sanitizer_allocator_checks.h"
 #include "sanitizer_common/sanitizer_allocator_interface.h"
-#include "sanitizer_common/sanitizer_errno.h"
 #include "sanitizer_common/sanitizer_quarantine.h"
 
+#include <errno.h>
 #include <string.h>
 
 namespace __scudo {
 
 // Global static cookie, initialized at start-up.
 static uptr Cookie;
 
 // We default to software CRC32 if the alternatives are not supported, either

 void *scudoValloc(uptr Size) {
   return SetErrnoOnNull(
       Instance.allocate(Size, GetPageSizeCached(), FromMemalign));
 }
 
 void *scudoPvalloc(uptr Size) {
   uptr PageSize = GetPageSizeCached();
   if (UNLIKELY(CheckForPvallocOverflow(Size, PageSize))) {
-    errno = errno_ENOMEM;
+    errno = ENOMEM;
     return Instance.handleBadRequest();
   }
   // pvalloc(0) should allocate one page.
   Size = Size ? RoundUpTo(Size, PageSize) : PageSize;
   return SetErrnoOnNull(Instance.allocate(Size, PageSize, FromMemalign));
 }
 
 void *scudoMemalign(uptr Alignment, uptr Size) {
   if (UNLIKELY(!IsPowerOfTwo(Alignment))) {
-    errno = errno_EINVAL;
+    errno = EINVAL;
     return Instance.handleBadRequest();
   }
   return SetErrnoOnNull(Instance.allocate(Size, Alignment, FromMemalign));
 }
 
 int scudoPosixMemalign(void **MemPtr, uptr Alignment, uptr Size) {
   if (UNLIKELY(!CheckPosixMemalignAlignment(Alignment))) {
     Instance.handleBadRequest();
-    return errno_EINVAL;
+    return EINVAL;
   }
   void *Ptr = Instance.allocate(Size, Alignment, FromMemalign);
   if (UNLIKELY(!Ptr))
-    return errno_ENOMEM;
+    return ENOMEM;
   *MemPtr = Ptr;
   return 0;
 }
 
 void *scudoAlignedAlloc(uptr Alignment, uptr Size) {
   if (UNLIKELY(!CheckAlignedAllocAlignmentAndSize(Alignment, Size))) {
-    errno = errno_EINVAL;
+    errno = EINVAL;
     return Instance.handleBadRequest();
   }
   return SetErrnoOnNull(Instance.allocate(Size, Alignment, FromMalloc));
 }
 
 uptr scudoMallocUsableSize(void *Ptr) {
   return Instance.getUsableSize(Ptr);
 }

lib/scudo/scudo_tsd.h

 //===----------------------------------------------------------------------===//
 
 #ifndef SCUDO_TSD_H_
 #define SCUDO_TSD_H_
 
 #include "scudo_allocator.h"
 #include "scudo_utils.h"
 
+#include <pthread.h>
+
 namespace __scudo {
 
 struct ALIGNED(64) ScudoTSD {
   AllocatorCache Cache;
   ScudoPrng Prng;
   uptr QuarantineCachePlaceHolder[4];
 
   void init(bool Shared);

lib/scudo/scudo_tsd_exclusive.cpp

 /// Scudo exclusive TSD implementation.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "scudo_tsd.h"
 
 #if SCUDO_TSD_EXCLUSIVE
 
-#include <pthread.h>
-
 namespace __scudo {
 
 static pthread_once_t GlobalInitialized = PTHREAD_ONCE_INIT;
 static pthread_key_t PThreadKey;
 
 __attribute__((tls_model("initial-exec")))
 THREADLOCAL ThreadState ScudoThreadState = ThreadNotInitialized;
 __attribute__((tls_model("initial-exec")))

lib/scudo/scudo_tsd_shared.cpp

 /// Scudo shared TSD implementation.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "scudo_tsd.h"
 
 #if !SCUDO_TSD_EXCLUSIVE
 
-#include <pthread.h>
-
 namespace __scudo {
 
 static pthread_once_t GlobalInitialized = PTHREAD_ONCE_INIT;
 static pthread_key_t PThreadKey;
 
 static atomic_uint32_t CurrentIndex;
 static ScudoTSD *TSDs;
 static u32 NumberOfTSDs;
static void initOnce() {
   if (NumberOfTSDs > 32)
     NumberOfTSDs = 32;
   TSDs = reinterpret_cast<ScudoTSD *>(
       MmapOrDie(sizeof(ScudoTSD) * NumberOfTSDs, "ScudoTSDs"));
   for (u32 i = 0; i < NumberOfTSDs; i++)
     TSDs[i].init(/*Shared=*/true);
 }
 
+ALWAYS_INLINE void setCurrentTSD(ScudoTSD *TSD) {
+  *get_android_tls_ptr() = reinterpret_cast<uptr>(TSD);
+}
+
 void initThread(bool MinimalInit) {
   pthread_once(&GlobalInitialized, initOnce);
   // Initial context assignment is done in a plain round-robin fashion.
   u32 Index = atomic_fetch_add(&CurrentIndex, 1, memory_order_relaxed);
-  ScudoTSD *TSD = &TSDs[Index % NumberOfTSDs];
-  *get_android_tls_ptr() = reinterpret_cast<uptr>(TSD);
+  setCurrentTSD(&TSDs[Index % NumberOfTSDs]);
 }
 
 ScudoTSD *getTSDAndLockSlow() {
   ScudoTSD *TSD;
   if (NumberOfTSDs > 1) {
     // Go through all the contexts and find the first unlocked one.
     for (u32 i = 0; i < NumberOfTSDs; i++) {
       TSD = &TSDs[i];
       if (TSD->tryLock()) {
-        *get_android_tls_ptr() = reinterpret_cast<uptr>(TSD);
+        setCurrentTSD(TSD);
         return TSD;
       }
     }
     // No luck, find the one with the lowest Precedence, and slow lock it.
     u64 LowestPrecedence = UINT64_MAX;
     for (u32 i = 0; i < NumberOfTSDs; i++) {
       u64 Precedence = TSDs[i].getPrecedence();
       if (Precedence && Precedence < LowestPrecedence) {
         TSD = &TSDs[i];
         LowestPrecedence = Precedence;
       }
     }
     if (LIKELY(LowestPrecedence != UINT64_MAX)) {
       TSD->lock();
-      *get_android_tls_ptr() = reinterpret_cast<uptr>(TSD);
+      setCurrentTSD(TSD);
       return TSD;
     }
   }
   // Last resort, stick with the current one.
-  TSD = reinterpret_cast<ScudoTSD *>(*get_android_tls_ptr());
+  TSD = getCurrentTSD();
   TSD->lock();
   return TSD;
 }
 
 }  // namespace __scudo
 
 #endif  // !SCUDO_TSD_EXCLUSIVE

lib/scudo/scudo_tsd_shared.inc

 //===----------------------------------------------------------------------===//
 
 #ifndef SCUDO_TSD_H_
 # error "This file must be included inside scudo_tsd.h."
 #endif  // SCUDO_TSD_H_
 
 #if !SCUDO_TSD_EXCLUSIVE
 
+ALWAYS_INLINE ScudoTSD* getCurrentTSD() {
+  return reinterpret_cast<ScudoTSD *>(*get_android_tls_ptr());
+}
+
 ALWAYS_INLINE void initThreadMaybe(bool MinimalInit = false) {
-  if (LIKELY(*get_android_tls_ptr()))
+  if (LIKELY(getCurrentTSD()))
     return;
   initThread(MinimalInit);
 }
 
 ScudoTSD *getTSDAndLockSlow();
 
 ALWAYS_INLINE ScudoTSD *getTSDAndLock() {
-  ScudoTSD *TSD = reinterpret_cast<ScudoTSD *>(*get_android_tls_ptr());
+  ScudoTSD *TSD = getCurrentTSD();
   CHECK(TSD && "No TSD associated with the current thread!");
   // Try to lock the currently associated context.
   if (TSD->tryLock())
     return TSD;
   // If it failed, go the slow path.
   return getTSDAndLockSlow();
 }
 
 #endif  // !SCUDO_TSD_EXCLUSIVE