[scudo] Check the return values of the pthread_* functions

[cryptoad]

Summary

Currently we are not enforcing the success of pthread_once, and
pthread_setspecific. Errors could lead to harder to debug issues later in
the thread's life. This adds checks for a 0 return value for both.
If pthread_setspecific fails in the teardown path, opt for an immediate
teardown as opposed to a fatal failure.

[cryptoad]

Other Sanitizers use GetPthreadDestructorIterations() instead of
PTHREAD_DESTRUCTOR_ITERATIONS, so do that here as well.

lib/scudo/scudo_tls_linux.cpp

 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_platform.h"
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
 
 #include "scudo_tls.h"
 
-#include <limits.h>
 #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")))
 THREADLOCAL ScudoThreadContext ThreadLocalContext;
 
 static void teardownThread(void *Ptr) {
-  uptr Iteration = reinterpret_cast<uptr>(Ptr);
+  uptr I = reinterpret_cast<uptr>(Ptr);
   // The glibc POSIX thread-local-storage deallocation routine calls user
   // provided destructors in a loop of PTHREAD_DESTRUCTOR_ITERATIONS.
   // We want to be called last since other destructors might call free and the
   // like, so we wait until PTHREAD_DESTRUCTOR_ITERATIONS before draining the
   // quarantine and swallowing the cache.
-  if (Iteration < PTHREAD_DESTRUCTOR_ITERATIONS) {
-    pthread_setspecific(PThreadKey, reinterpret_cast<void *>(Iteration + 1));
+  if (I > 1) {
+    // If pthread_setspecific fails, we will go ahead with the teardown.
+    if (LIKELY(pthread_setspecific(PThreadKey,
+                                   reinterpret_cast<void *>(I - 1)) == 0))
       return;
   }
   ThreadLocalContext.commitBack();
   ScudoThreadState = ThreadTornDown;
 }
 
 
 static void initOnce() {
   CHECK_EQ(pthread_key_create(&PThreadKey, teardownThread), 0);
   initScudo();
 }
 
 void initThread() {
-  pthread_once(&GlobalInitialized, initOnce);
-  pthread_setspecific(PThreadKey, reinterpret_cast<void *>(1));
+  CHECK_EQ(pthread_once(&GlobalInitialized, initOnce), 0);
+  CHECK_EQ(pthread_setspecific(PThreadKey, reinterpret_cast<void *>(
+      GetPthreadDestructorIterations())), 0);
   ThreadLocalContext.init();
   ScudoThreadState = ThreadInitialized;
 }
 
 }  // namespace __scudo
 
 #endif  // SANITIZER_LINUX && !SANITIZER_ANDROID