Experiment for updating the tcmalloc chromium branch to r144 (gperftools 2.0).

third_party/tcmalloc/chromium/src/profile-handler.cc

 // Copyright (c) 2009, Google Inc.
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // 
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 28 matching lines @@
 #if !(defined(__CYGWIN__) || defined(__CYGWIN32__))
 
 #include <stdio.h>
 #include <errno.h>
 #include <sys/time.h>
 
 #include <list>
 #include <string>
 
 #include "base/dynamic_annotations.h"
+#include "base/googleinit.h"
 #include "base/logging.h"
 #include "base/spinlock.h"
 #include "maybe_threads.h"
 
 using std::list;
 using std::string;
 
 // This structure is used by ProfileHandlerRegisterCallback and
 // ProfileHandlerUnregisterCallback as a handle to a registered callback.
 struct ProfileHandlerToken {
@@ skipping 73 matching lines @@
 
   // SIGPROF/SIGALRM interrupt frequency, read-only after construction.
   int32 frequency_;
 
   // ITIMER_PROF (which uses SIGPROF), or ITIMER_REAL (which uses SIGALRM)
   int timer_type_;
 
   // Counts the number of callbacks registered.
   int32 callback_count_ GUARDED_BY(control_lock_);
 
+  // Is profiling allowed at all?
+  bool allowed_;
+
   // Whether or not the threading system provides interval timers that are
   // shared by all threads in a process.
   enum {
     // No timer initialization attempted yet.
     TIMERS_UNTOUCHED,
     // First thread has registered and set timer.
     TIMERS_ONE_SET,
     // Timers are shared by all threads.
     TIMERS_SHARED,
     // Timers are separate in each thread.
@@ skipping 40 matching lines @@
   // thread.  This actually checks the kernel's interval timer setting.  (It is
   // used to detect whether timers are shared or separate.)
   bool IsTimerRunning() EXCLUSIVE_LOCKS_REQUIRED(control_lock_);
 
   // Sets the timer interrupt signal handler.
   void EnableHandler() EXCLUSIVE_LOCKS_REQUIRED(control_lock_);
 
   // Disables (ignores) the timer interrupt signal.
   void DisableHandler() EXCLUSIVE_LOCKS_REQUIRED(control_lock_);
 
+  // Returns true if the handler is not being used by something else.
+  // This checks the kernel's signal handler table.
+  bool IsSignalHandlerAvailable();
+
   // SIGPROF/SIGALRM handler. Iterate over and call all the registered callbacks.
   static void SignalHandler(int sig, siginfo_t* sinfo, void* ucontext);
 
   DISALLOW_COPY_AND_ASSIGN(ProfileHandler);
 };
 
 ProfileHandler* ProfileHandler::instance_ = NULL;
 pthread_once_t ProfileHandler::once_ = PTHREAD_ONCE_INIT;
 
 const int32 ProfileHandler::kMaxFrequency;
@@ skipping 20 matching lines @@
     // (but doesn't do anything) even when pthreads isn't linked in.
     Init();
     assert(instance_ != NULL);
   }
   return instance_;
 }
 
 ProfileHandler::ProfileHandler()
     : interrupts_(0),
       callback_count_(0),
+      allowed_(true),
       timer_sharing_(TIMERS_UNTOUCHED) {
   SpinLockHolder cl(&control_lock_);
 
   timer_type_ = (getenv("CPUPROFILE_REALTIME") ? ITIMER_REAL : ITIMER_PROF);
 
   // Get frequency of interrupts (if specified)
   char junk;
   const char* fr = getenv("CPUPROFILE_FREQUENCY");
   if (fr != NULL && (sscanf(fr, "%u%c", &frequency_, &junk) == 1) &&
       (frequency_ > 0)) {
     // Limit to kMaxFrequency
     frequency_ = (frequency_ > kMaxFrequency) ? kMaxFrequency : frequency_;
   } else {
     frequency_ = kDefaultFrequency;
   }
 
+  if (!allowed_) {
+    return;
+  }
+
+  // If something else is using the signal handler,
+  // assume it has priority over us and stop.
+  if (!IsSignalHandlerAvailable()) {
+    RAW_LOG(INFO, "Disabling profiler because %s handler is already in use.",
+                    timer_type_ == ITIMER_REAL ? "SIGALRM" : "SIGPROF");
+    allowed_ = false;
+    return;
+  }
+
   // Ignore signals until we decide to turn profiling on.  (Paranoia;
   // should already be ignored.)
   DisableHandler();
 }
 
 ProfileHandler::~ProfileHandler() {
   Reset();
 }
 
 void ProfileHandler::RegisterThread() {
   SpinLockHolder cl(&control_lock_);
 
+  if (!allowed_) {
+    return;
+  }
+
   // We try to detect whether timers are being shared by setting a
   // timer in the first call to this function, then checking whether
   // it's set in the second call.
   //
   // Note that this detection method requires that the first two calls
   // to RegisterThread must be made from different threads.  (Subsequent
   // calls will see timer_sharing_ set to either TIMERS_SEPARATE or
   // TIMERS_SHARED, and won't try to detect the timer sharing type.)
   //
   // Also note that if timer settings were inherited across new thread
@@ skipping 25 matching lines @@
       // Nothing needed.
       break;
     case TIMERS_SEPARATE:
       StartTimer();
       break;
   }
 }
 
 ProfileHandlerToken* ProfileHandler::RegisterCallback(
     ProfileHandlerCallback callback, void* callback_arg) {
+
   ProfileHandlerToken* token = new ProfileHandlerToken(callback, callback_arg);
 
   SpinLockHolder cl(&control_lock_);
   DisableHandler();
   {
     SpinLockHolder sl(&signal_lock_);
     callbacks_.push_back(token);
   }
   // Start the timer if timer is shared and this is a first callback.
   if ((callback_count_ == 0) && (timer_sharing_ == TIMERS_SHARED)) {
@@ skipping 54 matching lines @@
   DisableHandler();
   {
     SpinLockHolder sl(&signal_lock_);  // Protects interrupts_.
     state->interrupts = interrupts_;
   }
   if (callback_count_ > 0) {
     EnableHandler();
   }
   state->frequency = frequency_;
   state->callback_count = callback_count_;
+  state->allowed = allowed_;
 }
 
 void ProfileHandler::StartTimer() {
+  if (!allowed_) {
+    return;
+  }
   struct itimerval timer;
   timer.it_interval.tv_sec = 0;
   timer.it_interval.tv_usec = 1000000 / frequency_;
   timer.it_value = timer.it_interval;
   setitimer(timer_type_, &timer, 0);
 }
 
 void ProfileHandler::StopTimer() {
+  if (!allowed_) {
+    return;
+  }
   struct itimerval timer;
   memset(&timer, 0, sizeof timer);
   setitimer(timer_type_, &timer, 0);
 }
 
 bool ProfileHandler::IsTimerRunning() {
+  if (!allowed_) {
+    return false;
+  }
   struct itimerval current_timer;
   RAW_CHECK(0 == getitimer(timer_type_, &current_timer), "getitimer");
   return (current_timer.it_value.tv_sec != 0 ||
           current_timer.it_value.tv_usec != 0);
 }
 
 void ProfileHandler::EnableHandler() {
+  if (!allowed_) {
+    return;
+  }
   struct sigaction sa;
   sa.sa_sigaction = SignalHandler;
   sa.sa_flags = SA_RESTART | SA_SIGINFO;
   sigemptyset(&sa.sa_mask);
   const int signal_number = (timer_type_ == ITIMER_PROF ? SIGPROF : SIGALRM);
   RAW_CHECK(sigaction(signal_number, &sa, NULL) == 0, "sigprof (enable)");
 }
 
 void ProfileHandler::DisableHandler() {
+  if (!allowed_) {
+    return;
+  }
   struct sigaction sa;
   sa.sa_handler = SIG_IGN;
   sa.sa_flags = SA_RESTART;
   sigemptyset(&sa.sa_mask);
   const int signal_number = (timer_type_ == ITIMER_PROF ? SIGPROF : SIGALRM);
   RAW_CHECK(sigaction(signal_number, &sa, NULL) == 0, "sigprof (disable)");
 }
 
+bool ProfileHandler::IsSignalHandlerAvailable() {
+  struct sigaction sa;
+  const int signal_number = (timer_type_ == ITIMER_PROF ? SIGPROF : SIGALRM);
+  RAW_CHECK(sigaction(signal_number, NULL, &sa) == 0, "is-signal-handler avail");
+
+  // We only take over the handler if the current one is unset.
+  // It must be SIG_IGN or SIG_DFL, not some other function.
+  // SIG_IGN must be allowed because when profiling is allowed but
+  // not actively in use, this code keeps the handler set to SIG_IGN.
+  // That setting will be inherited across fork+exec.  In order for
+  // any child to be able to use profiling, SIG_IGN must be treated
+  // as available.
+  return sa.sa_handler == SIG_IGN || sa.sa_handler == SIG_DFL;
+}
+
 void ProfileHandler::SignalHandler(int sig, siginfo_t* sinfo, void* ucontext) {
   int saved_errno = errno;
-  RAW_CHECK(instance_ != NULL, "ProfileHandler is not initialized");
+  // At this moment, instance_ must be initialized because the handler is
+  // enabled in RegisterThread or RegisterCallback only after
+  // ProfileHandler::Instance runs.
+  ProfileHandler* instance = ANNOTATE_UNPROTECTED_READ(instance_);
+  RAW_CHECK(instance != NULL, "ProfileHandler is not initialized");
   {
-    SpinLockHolder sl(&instance_->signal_lock_);
-    ++instance_->interrupts_;
-    for (CallbackIterator it = instance_->callbacks_.begin();
-         it != instance_->callbacks_.end();
+    SpinLockHolder sl(&instance->signal_lock_);
+    ++instance->interrupts_;
+    for (CallbackIterator it = instance->callbacks_.begin();
+         it != instance->callbacks_.end();
          ++it) {
       (*it)->callback(sig, sinfo, ucontext, (*it)->callback_arg);
     }
   }
   errno = saved_errno;
 }
 
-// The sole purpose of this class is to initialize the ProfileHandler singleton
-// when the global static objects are created. Note that the main thread will
-// be registered at this time.
-class ProfileHandlerInitializer {
- public:
-  ProfileHandlerInitializer() {
-    ProfileHandler::Instance()->RegisterThread();
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ProfileHandlerInitializer);
-};
-// ProfileHandlerInitializer singleton
-static ProfileHandlerInitializer profile_handler_initializer;
+// This module initializer registers the main thread, so it must be
+// executed in the context of the main thread.
+REGISTER_MODULE_INITIALIZER(profile_main, ProfileHandlerRegisterThread());
 
 extern "C" void ProfileHandlerRegisterThread() {
   ProfileHandler::Instance()->RegisterThread();
 }
 
 extern "C" ProfileHandlerToken* ProfileHandlerRegisterCallback(
     ProfileHandlerCallback callback, void* callback_arg) {
   return ProfileHandler::Instance()->RegisterCallback(callback, callback_arg);
 }
 
@@ skipping 26 matching lines @@
 extern "C" void ProfileHandlerUnregisterCallback(ProfileHandlerToken* token) {
 }
 
 extern "C" void ProfileHandlerReset() {
 }
 
 extern "C" void ProfileHandlerGetState(ProfileHandlerState* state) {
 }
 
 #endif  // OS_CYGWIN