Guard against profiler shutdown race

runtime/vm/profiler.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <cstdio>
 
 #include "platform/utils.h"
 
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
@@ skipping 50 matching lines @@
 
 // Notes on stack frame walking:
 //
 // The sampling profiler will collect up to Sample::kNumStackFrames stack frames
 // The stack frame walking code uses the frame pointer to traverse the stack.
 // If the VM is compiled without frame pointers (which is the default on
 // recent GCC versions with optimizing enabled) the stack walking code will
 // fail (sometimes leading to a crash).
 //
 
-DEFINE_FLAG(bool, profile, false, "Enable Sampling Profiler");
+DEFINE_FLAG(bool, profile, true, "Enable Sampling Profiler");
 DEFINE_FLAG(bool, trace_profiled_isolates, false, "Trace profiled isolates.");
 
 bool ProfilerManager::initialized_ = false;
 bool ProfilerManager::shutdown_ = false;
 bool ProfilerManager::thread_running_ = false;
 Monitor* ProfilerManager::monitor_ = NULL;
 Monitor* ProfilerManager::start_stop_monitor_ = NULL;
 Isolate** ProfilerManager::isolates_ = NULL;
 intptr_t ProfilerManager::isolates_capacity_ = 0;
 intptr_t ProfilerManager::isolates_size_ = 0;
@@ skipping 52 matching lines @@
     }
   }
   NativeSymbolResolver::ShutdownOnce();
   {
     ScopedMonitor shutdown_lock(start_stop_monitor_);
     while (thread_running_) {
       // Wait until profiler thread has exited.
       shutdown_lock.Wait();
     }
   }
-  initialized_ = false;
   if (FLAG_trace_profiled_isolates) {
     OS::Print("ProfilerManager shut down (%" Pd ").\n", size_at_shutdown);
   }
 }
 
 
 void ProfilerManager::SetupIsolateForProfiling(Isolate* isolate) {
   if (!FLAG_profile) {
     return;
   }
@@ skipping 50 matching lines @@
   {
     ScopedSignalBlocker ssb;
     FreeIsolateProfilingData(isolate);
   }
 }
 
 
 void ProfilerManager::ScheduleIsolateHelper(Isolate* isolate) {
   ScopedMonitor lock(monitor_);
   {
+    if (shutdown_) {
+      // Shutdown.
+      return;
+    }
     ScopedMutex profiler_data_lock(isolate->profiler_data_mutex());
     IsolateProfilerData* profiler_data = isolate->profiler_data();
     if (profiler_data == NULL) {
       return;
     }
     profiler_data->Scheduled(OS::GetCurrentTimeMicros(),
                              Thread::GetCurrentThreadId());
   }
   intptr_t i = FindIsolate(isolate);
   if (i >= 0) {
@@ skipping 28 matching lines @@
 void ProfilerManager::DescheduleIsolate(Isolate* isolate) {
   if (!FLAG_profile) {
     return;
   }
   ASSERT(initialized_);
   ASSERT(isolate != NULL);
   {
     ScopedSignalBlocker ssb;
     {
       ScopedMonitor lock(monitor_);
+      if (shutdown_) {
+        // Shutdown.
+        return;
+      }
       intptr_t i = FindIsolate(isolate);
       if (i < 0) {
         // Not scheduled.
         return;
       }
       {
         ScopedMutex profiler_data_lock(isolate->profiler_data_mutex());
         IsolateProfilerData* profiler_data = isolate->profiler_data();
         if (profiler_data != NULL) {
           profiler_data->Descheduled();
@@ skipping 414 matching lines @@
     return false;
   }
   uintptr_t cursor = reinterpret_cast<uintptr_t>(fp);
   cursor += sizeof(fp);
   bool r = cursor >= lower_bound_ && cursor < stack_upper_;
   return r;
 }
 
 
 }  // namespace dart