[scudo] Allow to specify the maximum number of TSDs at compile time

[cryptoad]

Summary

This introduces SCUDO_MAX_CACHES allowing to define an upper bound to the
number of ScudoTSD created in the Shared TSD model (by default 32U).
This name felt clearer than SCUDO_MAX_TSDS which is technically what it really
is. I am opened to suggestions if that doesn't feel right.

Additionally change getNumberOfCPUs to return a u32 to be more consistent.

[alekseyshl]

lib/scudo/scudo_platform.h

44

SCUDO_MAX_SHARED_THREAD_CACHES, maybe?

[cryptoad]

lib/scudo/scudo_platform.h

44

I would vote for something shorter if possible :)

[alekseyshl]

lib/scudo/scudo_platform.h

44

SCUDO_MAX_CACHES is not clear at all, what kind of cache is governed by this define. Call it SCUDO_MAX_TSD_CACHES then.

[cryptoad]

lib/scudo/scudo_platform.h

44

After sleeping over this, I don't think the initial CACHE naming for that define was appropriate.
A TSD contains not only the Cache but the QuarantineCache, the Prng, and some other private members.
Something like SCUDO_MAX_SHARED_TSDS (the final S is somewhat awkward) would encompass the fact that it's a maximum value that only applies to shared TSDs.
My fear would be that to someone using this, the concept of Thread Specific Data might be foreign at best.

[alekseyshl]

lib/scudo/scudo_platform.h

44

I agree, but why would someone not aware of what TSD is want to change this value?

Another option, SCUDO_SHARED_TSD_POOL_SIZE, to avoid that S at the end.

[cryptoad]

Renaming the define to SCUDO_SHARED_TSD_POOL_SIZE.
Adding a static_cast<u32> to make sure it's unsigned.

lib/scudo/scudo_platform.h

 # endif  // SANITIZER_ANDROID || SANITIZER_FUCHSIA
 #endif  // SCUDO_TSD_EXCLUSIVE
 
 // If the exclusive TSD model is chosen, make sure the platform supports it.
 #if SCUDO_TSD_EXCLUSIVE && !SCUDO_TSD_EXCLUSIVE_SUPPORTED
 # error "The exclusive TSD model is not supported on this platform."
 #endif
 
+// Maximum number of TSDs that can be created for the Shared model.
+#ifndef SCUDO_SHARED_TSD_POOL_SIZE
+# define SCUDO_SHARED_TSD_POOL_SIZE 32U
+#endif  // SCUDO_SHARED_TSD_POOL_SIZE
+
 namespace __scudo {
 
 #if SANITIZER_CAN_USE_ALLOCATOR64
 # if defined(__aarch64__) && SANITIZER_ANDROID
 const uptr AllocatorSize = 0x2000000000ULL;  // 128G.
 typedef VeryCompactSizeClassMap SizeClassMap;
 # elif defined(__aarch64__)
 const uptr AllocatorSize = 0x10000000000ULL;  // 1T.

lib/scudo/scudo_tsd_shared.cpp

 static pthread_once_t GlobalInitialized = PTHREAD_ONCE_INIT;
 pthread_key_t PThreadKey;
 
 static atomic_uint32_t CurrentIndex;
 static ScudoTSD *TSDs;
 static u32 NumberOfTSDs;
 
 // sysconf(_SC_NPROCESSORS_{CONF,ONLN}) cannot be used as they allocate memory.
-static uptr getNumberOfCPUs() {
+static u32 getNumberOfCPUs() {
   cpu_set_t CPUs;
   CHECK_EQ(sched_getaffinity(0, sizeof(cpu_set_t), &CPUs), 0);
   return CPU_COUNT(&CPUs);
 }
 
 static void initOnce() {
   CHECK_EQ(pthread_key_create(&PThreadKey, NULL), 0);
   initScudo();
-  NumberOfTSDs = getNumberOfCPUs();
-  if (NumberOfTSDs == 0)
-    NumberOfTSDs = 1;
-  if (NumberOfTSDs > 32)
-    NumberOfTSDs = 32;
+  NumberOfTSDs = Min(Max(1U, getNumberOfCPUs()),
+                     static_cast<u32>(SCUDO_SHARED_TSD_POOL_SIZE));
   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) {
 #if SANITIZER_ANDROID