[scudo][standalone] Allow sched_getaffinity to fail

[cryptoad]

Summary

In some configuration, sched_getaffinity can fail. Some reasons for
that being the lack of CAP_SYS_NICE capability or some syscall
filtering and so on.

This should not be fatal to the allocator, so in this situation, we
will fallback to the MaxTSDCount value specified in the allocator
configuration.

[merge_guards_bot]

Unit tests: pass. 62019 tests passed, 0 failed and 783 were skipped.

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[hctim]

compiler-rt/lib/scudo/standalone/linux.cpp

133

Should probably add comment about the zero error-condition to the shared header.

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

23

Should the fallback here still be 1 instead of MaxTSDCount? Seems to me like falling back to having a single TSD is safer than spawning 8 (for fuchsia) or 2 (for android) for a single-threaded program.

[cryptoad]

compiler-rt/lib/scudo/standalone/linux.cpp

133

Ack

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

23

I debated this, and I think that having a fallback to 1 is very restricting, eg: a single cache/lock.
I think it's less limiting to fallback to multiple caches, it will potentially allow us to make use of multiple cores if there are more than 1. If not, everything still works but we use a bit more memory which I don't think is a big issue.

[cryptoad]

Commenting getNumberOfCPUs to indicate failure value in common.h,
moving sched_getaffinity comment in linux.cpp in body of function.

[merge_guards_bot]

Unit tests: pass. 62019 tests passed, 0 failed and 783 were skipped.

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[eugenis]

LGTM

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

23

I think I also prefer to fallback to MaxTSDCount.

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

inline uptr getPageSizeCached() {
   // Bionic uses a hardcoded value.
   if (SCUDO_ANDROID)
     return 4096U;
   if (LIKELY(PageSizeCached))
     return PageSizeCached;
   return getPageSizeSlow();
 }
 
+// Returns 0 if the number of CPUs could not be determined.
 u32 getNumberOfCPUs();
 
 const char *getEnv(const char *Name);
 
 u64 getMonotonicTime();
 
 // Our randomness gathering function is limited to 256 bytes to ensure we get
 // as many bytes as requested, and avoid interruptions (on Linux).

compiler-rt/lib/scudo/standalone/linux.cpp

 
 u64 getMonotonicTime() {
   timespec TS;
   clock_gettime(CLOCK_MONOTONIC, &TS);
   return static_cast<u64>(TS.tv_sec) * (1000ULL * 1000 * 1000) +
          static_cast<u64>(TS.tv_nsec);
 }
 
 u32 getNumberOfCPUs() {
   cpu_set_t CPUs;
-  CHECK_EQ(sched_getaffinity(0, sizeof(cpu_set_t), &CPUs), 0);
+  // sched_getaffinity can fail for a variety of legitimate reasons (lack of
+  // CAP_SYS_NICE, syscall filtering, etc), in which case we shall return 0.
+  if (sched_getaffinity(0, sizeof(cpu_set_t), &CPUs) != 0)
+    return 0;
   return static_cast<u32>(CPU_COUNT(&CPUs));
 }
 
 // Blocking is possibly unused if the getrandom block is not compiled in.
 bool getRandom(void *Buffer, uptr Length, UNUSED bool Blocking) {
   if (!Buffer || !Length || Length > MaxRandomLength)
     return false;
   ssize_t ReadBytes;

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

 #include "tsd.h"
 
 namespace scudo {
 
 template <class Allocator, u32 MaxTSDCount> struct TSDRegistrySharedT {
   void initLinkerInitialized(Allocator *Instance) {
     Instance->initLinkerInitialized();
     CHECK_EQ(pthread_key_create(&PThreadKey, nullptr), 0); // For non-TLS
-    NumberOfTSDs = Min(Max(1U, getNumberOfCPUs()), MaxTSDCount);
+    const u32 NumberOfCPUs = getNumberOfCPUs();
+    NumberOfTSDs =
+        (NumberOfCPUs == 0) ? MaxTSDCount : Min(NumberOfCPUs, MaxTSDCount);
     TSDs = reinterpret_cast<TSD<Allocator> *>(
         map(nullptr, sizeof(TSD<Allocator>) * NumberOfTSDs, "scudo:tsd"));
     for (u32 I = 0; I < NumberOfTSDs; I++)
       TSDs[I].initLinkerInitialized(Instance);
     // Compute all the coprimes of NumberOfTSDs. This will be used to walk the
     // array of TSDs in a random order. For details, see:
     // https://lemire.me/blog/2017/09/18/visiting-all-values-in-an-array-exactly-once-in-random-order/
     for (u32 I = 0; I < NumberOfTSDs; I++) {