Quick fix for racy shutdown issues in VmStats.

runtime/bin/vmstats_impl.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 "bin/vmstats_impl.h"
 
 #include <sstream>
 
 #include "bin/file.h"
 #include "bin/log.h"
 #include "bin/platform.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 #include "include/dart_debugger_api.h"
 #include "platform/json.h"
 
 #define BUFSIZE 8192
 #define RETRY_PAUSE 100  // milliseconds
 
 static const char* INDEX_HTML = "index.html";
 static const char* VMSTATS_HTML = "vmstats.html";
 static const char* DEFAULT_HOST = "localhost";
 
 // Global static pointer used to ensure a single instance of the class.
 VmStats* VmStats::instance_ = NULL;
-dart::Monitor VmStats::instance_monitor_;
-dart::Mutex VmStatusService::mutex_;
+dart::Monitor* VmStats::instance_monitor_;
+dart::Mutex* VmStatusService::mutex_;
 
 
 void VmStats::Start(int port, const char* root_dir) {
   if (instance_ != NULL) {
     FATAL("VmStats already started.");
   }
-  MonitorLocker ml(&instance_monitor_);
   instance_ = new VmStats();
+  instance_monitor_ = new dart::Monitor();
   VmStatusService::InitOnce();
   Socket::Initialize();
 
   if (root_dir != NULL) {
     instance_->root_directory_ = root_dir;
   }
 
   // TODO(tball): allow host to be specified.
   char* host = const_cast<char*>(DEFAULT_HOST);
   OSError* os_error;
   const char* host_ip = Socket::LookupIPv4Address(host, &os_error);
   if (host_ip == NULL) {
     Log::PrintErr("Failed IP lookup of VmStats host %s: %s\n",
                   host, os_error->message());
     return;
   }
 
   const intptr_t BACKLOG = 128;  // Default value from HttpServer.dart
   int64_t address = ServerSocket::CreateBindListen(host_ip, port, BACKLOG);
   if (address < 0) {
     Log::PrintErr("Failed binding VmStats socket: %s:%d\n", host, port);
     return;
   }
   instance_->bind_address_ = address;
   Log::Print("VmStats URL: http://%s:%"Pd"/\n", host, Socket::GetPort(address));
 
+  MonitorLocker ml(instance_monitor_);
   instance_->running_ = true;
   int err = dart::Thread::Start(WebServer, address);
   if (err != 0) {
     Log::PrintErr("Failed starting VmStats thread: %d\n", err);
     Shutdown();
   }
 }
 
 
 void VmStats::Stop() {
-  MonitorLocker ml(&instance_monitor_);
-  if (instance_ != NULL) {
-    instance_->running_ = false;
-  }
+  ASSERT(instance_ != NULL);
+  MonitorLocker ml(instance_monitor_);
+  instance_->running_ = false;
 }
 
 
 void VmStats::Shutdown() {
-  MonitorLocker ml(&instance_monitor_);
+  ASSERT(instance_ != NULL);
+  MonitorLocker ml(instance_monitor_);
   Socket::Close(instance_->bind_address_);
   delete instance_;
   instance_ = NULL;
 }
 
 
 void VmStats::AddIsolate(IsolateData* isolate_data,
                          Dart_Isolate isolate) {
-  MonitorLocker ml(&instance_monitor_);
   if (instance_ != NULL) {
+    MonitorLocker ml(instance_monitor_);
     instance_->isolate_table_[isolate_data] = isolate;
   }
 }
 
 
 void VmStats::RemoveIsolate(IsolateData* isolate_data) {
-  MonitorLocker ml(&instance_monitor_);
   if (instance_ != NULL) {
+    MonitorLocker ml(instance_monitor_);
     instance_->isolate_table_.erase(isolate_data);
   }
 }
 
 
 static const char* ContentType(const char* url) {
   const char* suffix = strrchr(url, '.');
   if (suffix != NULL) {
     if (!strcmp(suffix, ".html")) {
       return "text/html; charset=UTF-8";
@@ skipping 177 matching lines @@
 }
 
 
 // Global static pointer used to ensure a single instance of the class.
 VmStatusService* VmStatusService::instance_ = NULL;
 
 
 void VmStatusService::InitOnce() {
   ASSERT(VmStatusService::instance_ == NULL);
   VmStatusService::instance_ = new VmStatusService();
+  VmStatusService::mutex_ = new dart::Mutex();
 
   // Register built-in status plug-ins. RegisterPlugin is not used because
   // this isn't called within an isolate, and because parameter checking
   // isn't necessary.
   instance_->RegisterPlugin(&Dart_GetVmStatus);
 
   // TODO(tball): dynamically load any additional plug-ins.
 }
 
 
 int VmStatusService::RegisterPlugin(Dart_VmStatusCallback callback) {
-  MutexLocker ml(&mutex_);
+  MutexLocker ml(mutex_);
   if (callback == NULL) {
     return -1;
   }
   VmStatusPlugin* plugin = new VmStatusPlugin(callback);
   VmStatusPlugin* list = instance_->registered_plugin_list_;
   if (list == NULL) {
     instance_->registered_plugin_list_ = plugin;
   } else {
     list->Append(plugin);
   }
   return 0;
 }
 
 
 char* VmStatusService::GetVmStatus(const char* request) {
   VmStatusPlugin* plugin = instance_->registered_plugin_list_;
   while (plugin != NULL) {
     char* result = (plugin->callback())(request);
     if (result != NULL) {
       return result;
     }
     plugin = plugin->next();
   }
   return NULL;
 }