[sanitizer] Revert rL317822

[cryptoad]

Summary

This reverts D39490.

For toolchains generated with older NDKs (<=r13b as far as we tested),
cpu_set_t doesn't exist in sched.h.
We have to figure out another way to get the number of CPUs without this.

[rnk]

lgtm, thanks, sorry to bear the bad news. =/

lib/sanitizer_common/sanitizer_common.h

 const s32 kReleaseToOSIntervalNever = -1;
 
 void CheckNoDeepBind(const char *filename, int flag);
 
 // Returns the requested amount of random data (up to 256 bytes) that can then
 // be used to seed a PRNG. Defaults to blocking like the underlying syscall.
 bool GetRandom(void *buffer, uptr length, bool blocking = true);
 
-// Returns the number of logical processors on the system.
-u32 GetNumberOfCPUs();
-
 }  // namespace __sanitizer
 
 inline void *operator new(__sanitizer::operator_new_size_type size,
                           __sanitizer::LowLevelAllocator &alloc) {
   return alloc.Allocate(size);
 }
 
 #endif  // SANITIZER_COMMON_H

lib/sanitizer_common/sanitizer_fuchsia.cc

 bool GetRandom(void *buffer, uptr length, bool blocking) {
   CHECK_LE(length, ZX_CPRNG_DRAW_MAX_LEN);
   size_t size;
   CHECK_EQ(_zx_cprng_draw(buffer, length, &size), ZX_OK);
   CHECK_EQ(size, length);
   return true;
 }
 
-u32 GetNumberOfCPUs() {
-  return zx_system_get_num_cpus();
-}
-
 }  // namespace __sanitizer
 
 using namespace __sanitizer;  // NOLINT
 
 extern "C" {
 void __sanitizer_startup_hook(int argc, char **argv, char **envp,
                               void *stack_base, size_t stack_size) {
   __sanitizer::StoredArgv = argv;

lib/sanitizer_common/sanitizer_linux_libcdep.cc

 #include "sanitizer_linux.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_procmaps.h"
 #include "sanitizer_stacktrace.h"
 
 #include <dlfcn.h>  // for dlsym()
 #include <link.h>
 #include <pthread.h>
-#include <sched.h>
 #include <signal.h>
 #include <sys/resource.h>
 #include <syslog.h>
 
 #if SANITIZER_FREEBSD
 #include <pthread_np.h>
 #include <osreldate.h>
-#include <sys/sysctl.h>
 #define pthread_getattr_np pthread_attr_get_np
 #endif
 
-#if SANITIZER_NETBSD
-#include <sys/sysctl.h>
-#endif
-
 #if SANITIZER_LINUX
 #include <sys/prctl.h>
 #endif
 
 #if SANITIZER_ANDROID
 #include <android/api-level.h>
 #endif
 
while (!(*pos >= '0' && *pos <= '9') && *pos != 0)
     pos++;
   // Read the number.
   uptr rss = 0;
   while (*pos >= '0' && *pos <= '9')
     rss = rss * 10 + *pos++ - '0';
   return rss * GetPageSizeCached();
 }
 
-// sysconf(_SC_NPROCESSORS_{CONF,ONLN}) cannot be used as they allocate memory.
-u32 GetNumberOfCPUs() {
-#if SANITIZER_FREEBSD || SANITIZER_NETBSD
-  u32 ncpu;
-  int req[2];
-  size_t len = sizeof(ncpu);
-  req[0] = CTL_HW;
-  req[1] = HW_NCPU;
-  CHECK_EQ(sysctl(req, 2, &ncpu, &len, NULL, 0), 0);
-  return ncpu;
-#else
-  cpu_set_t CPUs;
-  CHECK_EQ(sched_getaffinity(0, sizeof(cpu_set_t), &CPUs), 0);
-  return CPU_COUNT(&CPUs);
-#endif
-}
-
 // 64-bit Android targets don't provide the deprecated __android_log_write.
 // Starting with the L release, syslog() works and is preferable to
 // __android_log_write.
 #if SANITIZER_LINUX
 
 #if SANITIZER_ANDROID
 static atomic_uint8_t android_log_initialized;
 

lib/sanitizer_common/sanitizer_mac.cc

void CheckNoDeepBind(const char *filename, int flag) {
   // Do nothing.
 }
 
 // FIXME: implement on this platform.
 bool GetRandom(void *buffer, uptr length, bool blocking) {
   UNIMPLEMENTED();
 }
 
-// FIXME: implement on this platform.
-u32 GetNumberOfCPUs() {
-  UNIMPLEMENTED();
-}
-
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_MAC

lib/sanitizer_common/sanitizer_win.cc

void CheckNoDeepBind(const char *filename, int flag) {
   // Do nothing.
 }
 
 // FIXME: implement on this platform.
 bool GetRandom(void *buffer, uptr length, bool blocking) {
   UNIMPLEMENTED();
 }
 
-// FIXME: implement on this platform.
-u32 GetNumberOfCPUs() {
-  UNIMPLEMENTED();
-}
-
 }  // namespace __sanitizer
 
 #endif  // _WIN32

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 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 = Min(Max(1U, GetNumberOfCPUs()),
+  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) {