Reland (2) of Enable allocator shim for Android (crrev.com/1875043003)

tools/cygprofile/cygprofile.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "tools/cygprofile/cygprofile.h"
 
 #include <fcntl.h>
 #include <pthread.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 33 matching lines @@
 
 // "cyglog.PID.LWP.PPID"
 const char kLogFilenameFormat[] = "%scyglog.%d.%d-%d";
 
 // Magic value of above to prevent instrumentation. Used when ThreadLog is being
 // constructed (to prevent reentering by malloc, for example) and by the flush
 // log thread (to prevent it from being logged0.
 ThreadLog* const kMagicBeingConstructed = reinterpret_cast<ThreadLog*>(1);
 
 // Per-thread pointer to the current log object.
-static __thread ThreadLog* g_tls_log = NULL;
+pthread_key_t g_tls_slot;
+
+// Used to initialize the tls slot, once per the entire process.
+pthread_once_t g_tls_slot_initializer_once = PTHREAD_ONCE_INIT;
+
+// This variable is to prevent re-entrancy in the __cyg_profile_func_enter()
+// while the TLS slot itself is being initialized. Volatile here is required
+// to avoid compiler optimizations as this need to be read in a re-entrant way.
+// This variable is written by one thread only, which is the first thread that
+// happens to run the TLSSlotInitializer(). In practice this will happen very
+// early in the startup process, as soon as the first instrumented function is
+// called.
+volatile bool g_tls_slot_being_initialized = false;
+
+// Initializes the global TLS slot. This is invoked only once per process.
+static void TLSSlotInitializer()
+{
+    g_tls_slot_being_initialized = true;
+    PCHECK(0 == pthread_key_create(&g_tls_slot, NULL));
+    g_tls_slot_being_initialized = false;
+}
 
 // Returns light-weight process ID. On Linux, this is a system-wide unique
 // thread id.
 pid_t GetTID() {
   return syscall(__NR_gettid);
 }
 
 timespec GetCurrentTime() {
   timespec timestamp;
   clock_gettime(CLOCK_MONOTONIC, &timestamp);
@@ skipping 79 matching lines @@
 
 }  // namespace
 
 // Custom thread implementation that joins on destruction. Note that
 // base::Thread has non-trivial dependencies on e.g. AtExitManager which makes
 // it hard to use it early.
 class Thread {
  public:
   Thread(const base::Closure& thread_callback)
       : thread_callback_(thread_callback) {
-    CHECK_EQ(0, pthread_create(&handle_, NULL, &Thread::EntryPoint, this));
+    PCHECK(0 == pthread_create(&handle_, NULL, &Thread::EntryPoint, this));
   }
 
   ~Thread() {
-    CHECK_EQ(0, pthread_join(handle_, NULL));
+    PCHECK(0 == pthread_join(handle_, NULL));
   }
 
  private:
   static void* EntryPoint(void* data) {
     // Disable logging on this thread. Although this routine is not instrumented
     // (cygprofile.gyp provides that), the called routines are and thus will
     // call instrumentation.
-    CHECK(g_tls_log == NULL);  // Must be 0 as this is a new thread.
-    g_tls_log = kMagicBeingConstructed;
+    pthread_once(&g_tls_slot_initializer_once, TLSSlotInitializer);
+    ThreadLog* thread_log = reinterpret_cast<ThreadLog*>(
+        pthread_getspecific(g_tls_slot));
+    CHECK(thread_log == NULL);  // Must be 0 as this is a new thread.
+    PCHECK(0 == pthread_setspecific(g_tls_slot, kMagicBeingConstructed));
 
     Thread* const instance = reinterpret_cast<Thread*>(data);
     instance->thread_callback_.Run();
     return NULL;
   }
 
   const base::Closure thread_callback_;
   pthread_t handle_;
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
@@ skipping 14 matching lines @@
         base::Bind(&ThreadLog::FlushInternal, base::Unretained(this))) {
 }
 
 ThreadLog::ThreadLog(const FlushCallback& flush_callback)
   : tid_(GetTID()),
     in_use_(false),
     flush_callback_(flush_callback) {
 }
 
 ThreadLog::~ThreadLog() {
-  g_tls_log = NULL;
+  PCHECK(0 == pthread_setspecific(g_tls_slot, NULL));
 }
 
 void ThreadLog::AddEntry(void* address) {
   if (in_use_)
     return;
   in_use_ = true;
 
   CHECK_EQ(tid_, GetTID());
   const std::pair<base::hash_set<void*>::iterator, bool> pair =
       called_functions_.insert(address);
@@ skipping 138 matching lines @@
 extern "C" {
 
 // The GCC compiler callbacks, called on every function invocation providing
 // addresses of caller and callee codes.
 void __cyg_profile_func_enter(void* this_fn, void* call_site)
     __attribute__((no_instrument_function));
 void __cyg_profile_func_exit(void* this_fn, void* call_site)
     __attribute__((no_instrument_function));
 
 void __cyg_profile_func_enter(void* this_fn, void* callee_unused) {
-  if (g_tls_log == NULL) {
-    g_tls_log = kMagicBeingConstructed;
-    ThreadLog* new_log = new ThreadLog();
-    CHECK(new_log);
-    g_logs_manager.Pointer()->AddLog(base::WrapUnique(new_log));
-    g_tls_log = new_log;
+  // Avoid re-entrancy while initializing the TLS slot (once per process).
+  if (g_tls_slot_being_initialized)
+    return;
+
+  pthread_once(&g_tls_slot_initializer_once, TLSSlotInitializer);
+  ThreadLog* thread_log = reinterpret_cast<ThreadLog*>(
+      pthread_getspecific(g_tls_slot));
+
+  if (thread_log == NULL) {
+    PCHECK(0 == pthread_setspecific(g_tls_slot, kMagicBeingConstructed));
+    thread_log = new ThreadLog();
+    CHECK(thread_log);
+    g_logs_manager.Pointer()->AddLog(base::WrapUnique(thread_log));
+    PCHECK(0 == pthread_setspecific(g_tls_slot, thread_log));
   }
 
-  if (g_tls_log != kMagicBeingConstructed)
-    g_tls_log->AddEntry(this_fn);
+  if (thread_log != kMagicBeingConstructed)
+    thread_log->AddEntry(this_fn);
 }
 
 void __cyg_profile_func_exit(void* this_fn, void* call_site) {}
 
 }  // extern "C"
 }  // namespace cygprofile