base/threading/watchdog.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/threading/watchdog.h"
   6
   7 #include "base/compiler_specific.h"
   8 #include "base/lazy_instance.h"
   9 #include "base/logging.h"
  10 #include "base/threading/platform_thread.h"
  11
  12 namespace base {
  13
  14 namespace {
  15
  16 // When the debugger breaks (when we alarm), all the other alarms that are
  17 // armed will expire (also alarm).  To diminish this effect, we track any
  18 // delay due to debugger breaks, and we *try* to adjust the effective start
  19 // time of other alarms to step past the debugging break.
  20 // Without this safety net, any alarm will typically trigger a host of follow
  21 // on alarms from callers that specify old times.
  22
  23 // Lock for access of static data...
  24 LazyInstance<Lock>::Leaky g_static_lock = LAZY_INSTANCE_INITIALIZER;
  25
  26 // When did we last alarm and get stuck (for a while) in a debugger?
  27 TimeTicks g_last_debugged_alarm_time;
  28
  29 // How long did we sit on a break in the debugger?
  30 TimeDelta g_last_debugged_alarm_delay;
  31
  32 }  // namespace
  33
  34 // Start thread running in a Disarmed state.
  35 Watchdog::Watchdog(const TimeDelta& duration,
  36                    const std::string& thread_watched_name,
  37                    bool enabled)
  38   : enabled_(enabled),
  39     lock_(),
  40     condition_variable_(&lock_),
  41     state_(DISARMED),
  42     duration_(duration),
  43     thread_watched_name_(thread_watched_name),
  44     ALLOW_THIS_IN_INITIALIZER_LIST(delegate_(this)) {
  45   if (!enabled_)
  46     return;  // Don't start thread, or doing anything really.
  47   enabled_ = PlatformThread::Create(0,  // Default stack size.
  48                                     &delegate_,
  49                                     &handle_);
  50   DCHECK(enabled_);
  51 }
  52
  53 // Notify watchdog thread, and wait for it to finish up.
  54 Watchdog::~Watchdog() {
  55   if (!enabled_)
  56     return;
  57   if (!IsJoinable())
  58     Cleanup();
  59   condition_variable_.Signal();
  60   PlatformThread::Join(handle_);
  61 }
  62
  63 void Watchdog::Cleanup() {
  64   if (!enabled_)
  65     return;
  66   {
  67     AutoLock lock(lock_);
  68     state_ = SHUTDOWN;
  69   }
  70   condition_variable_.Signal();
  71 }
  72
  73 bool Watchdog::IsJoinable() {
  74   if (!enabled_)
  75     return true;
  76   AutoLock lock(lock_);
  77   return (state_ == JOINABLE);
  78 }
  79
  80 void Watchdog::Arm() {
  81   ArmAtStartTime(TimeTicks::Now());
  82 }
  83
  84 void Watchdog::ArmSomeTimeDeltaAgo(const TimeDelta& time_delta) {
  85   ArmAtStartTime(TimeTicks::Now() - time_delta);
  86 }
  87
  88 // Start clock for watchdog.
  89 void Watchdog::ArmAtStartTime(const TimeTicks start_time) {
  90   {
  91     AutoLock lock(lock_);
  92     start_time_ = start_time;
  93     state_ = ARMED;
  94   }
  95   // Force watchdog to wake up, and go to sleep with the timer ticking with the
  96   // proper duration.
  97   condition_variable_.Signal();
  98 }
  99
 100 // Disable watchdog so that it won't do anything when time expires.
 101 void Watchdog::Disarm() {
 102   AutoLock lock(lock_);
 103   state_ = DISARMED;
 104   // We don't need to signal, as the watchdog will eventually wake up, and it
 105   // will check its state and time, and act accordingly.
 106 }
 107
 108 void Watchdog::Alarm() {
 109   DVLOG(1) << "Watchdog alarmed for " << thread_watched_name_;
 110 }
 111
 112 //------------------------------------------------------------------------------
 113 // Internal private methods that the watchdog thread uses.
 114
 115 void Watchdog::ThreadDelegate::ThreadMain() {
 116   SetThreadName();
 117   TimeDelta remaining_duration;
 118   while (1) {
 119     AutoLock lock(watchdog_->lock_);
 120     while (DISARMED == watchdog_->state_)
 121       watchdog_->condition_variable_.Wait();
 122     if (SHUTDOWN == watchdog_->state_) {
 123       watchdog_->state_ = JOINABLE;
 124       return;
 125     }
 126     DCHECK(ARMED == watchdog_->state_);
 127     remaining_duration = watchdog_->duration_ -
 128         (TimeTicks::Now() - watchdog_->start_time_);
 129     if (remaining_duration.InMilliseconds() > 0) {
 130       // Spurios wake?  Timer drifts?  Go back to sleep for remaining time.
 131       watchdog_->condition_variable_.TimedWait(remaining_duration);
 132       continue;
 133     }
 134     // We overslept, so this seems like a real alarm.
 135     // Watch out for a user that stopped the debugger on a different alarm!
 136     {
 137       AutoLock static_lock(*g_static_lock.Pointer());
 138       if (g_last_debugged_alarm_time > watchdog_->start_time_) {
 139         // False alarm: we started our clock before the debugger break (last
 140         // alarm time).
 141         watchdog_->start_time_ += g_last_debugged_alarm_delay;
 142         if (g_last_debugged_alarm_time > watchdog_->start_time_)
 143           // Too many alarms must have taken place.
 144           watchdog_->state_ = DISARMED;
 145         continue;
 146       }
 147     }
 148     watchdog_->state_ = DISARMED;  // Only alarm at most once.
 149     TimeTicks last_alarm_time = TimeTicks::Now();
 150     {
 151       AutoUnlock lock(watchdog_->lock_);
 152       watchdog_->Alarm();  // Set a break point here to debug on alarms.
 153     }
 154     TimeDelta last_alarm_delay = TimeTicks::Now() - last_alarm_time;
 155     if (last_alarm_delay <= TimeDelta::FromMilliseconds(2))
 156       continue;
 157     // Ignore race of two alarms/breaks going off at roughly the same time.
 158     AutoLock static_lock(*g_static_lock.Pointer());
 159     // This was a real debugger break.
 160     g_last_debugged_alarm_time = last_alarm_time;
 161     g_last_debugged_alarm_delay = last_alarm_delay;
 162   }
 163 }
 164
 165 void Watchdog::ThreadDelegate::SetThreadName() const {
 166   std::string name = watchdog_->thread_watched_name_ + " Watchdog";
 167   PlatformThread::SetName(name.c_str());
 168   DVLOG(1) << "Watchdog active: " << name;
 169 }
 170
 171 // static
 172 void Watchdog::ResetStaticData() {
 173   AutoLock lock(*g_static_lock.Pointer());
 174   g_last_debugged_alarm_time = TimeTicks();
 175   g_last_debugged_alarm_delay = TimeDelta();
 176 }
 177
 178 }  // namespace base