Added ctrl-\ support in dart binary to dump isolate stacks.

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 "bin/file.h"
 #include "bin/log.h"
 #include "bin/platform.h"
 #include "bin/resources.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_;
 
 
-void VmStats::Start(int port, const char* root_dir) {
+void VmStats::Start(int port, const char* root_dir, bool verbose) {
   if (instance_ != NULL) {
     FATAL("VmStats already started.");
   }
-  instance_ = new VmStats();
+  instance_ = new VmStats(verbose);
   instance_monitor_ = new dart::Monitor();
+  Initialize();
   VmStatusService::InitOnce();
+
+  if (port >= 0) {
+    StartServer(port, root_dir);
+  }
+}
+
+
+void VmStats::StartServer(int port, const char* root_dir) {
+  ASSERT(port >= 0);
+  ASSERT(instance_ != NULL);
+  ASSERT(instance_monitor_ != NULL);
   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);
@@ skipping 14 matching lines @@
 
   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() {
   ASSERT(instance_ != NULL);
   MonitorLocker ml(instance_monitor_);
   instance_->running_ = false;
 }
 
 
 void VmStats::Shutdown() {
   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) {
-  if (instance_ != NULL) {
-    MonitorLocker ml(instance_monitor_);
-    instance_->isolate_table_[isolate_data] = isolate;
-  }
+  MonitorLocker ml(instance_monitor_);
+  instance_->isolate_table_[isolate_data] = isolate;
 }
 
 
 void VmStats::RemoveIsolate(IsolateData* isolate_data) {
-  if (instance_ != NULL) {
-    MonitorLocker ml(instance_monitor_);
-    instance_->isolate_table_.erase(isolate_data);
-  }
+  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";
     }
     if (!strcmp(suffix, ".dart")) {
@@ skipping 115 matching lines @@
 
     // Extract GET URL, and null-terminate URL in case request line has
     // HTTP version.
     for (int i = 4; i < len; i++) {
       if (buffer[i] == ' ') {
         buffer[i] = '\0';
       }
     }
     char* url = strdup(&buffer[4]);
 
-    Log::Print("vmstats: %s requested\n", url);
+    if (instance_->verbose_) {
+      Log::Print("vmstats: %s requested\n", url);
+    }
     char* content = NULL;
 
     // Check for VmStats-specific URLs.
     if (strcmp(url, "/isolates") == 0) {
       content = instance_->IsolatesStatus();
     } else {
       // Check plug-ins.
       content = VmStatusService::GetVmStatus(url);
     }
 
@@ skipping 59 matching lines @@
   IsolateTable::iterator itr;
   bool first = true;
   for (itr = isolate_table_.begin(); itr != isolate_table_.end(); ++itr) {
     Dart_Isolate isolate = itr->second;
     static char request[512];
     snprintf(request, sizeof(request),
              "/isolate/0x%"Px,
              reinterpret_cast<intptr_t>(isolate));
     char* status = VmStatusService::GetVmStatus(request);
     if (status != NULL) {
-      text.AddString(status);
       if (!first) {
         text.AddString(",\n");
       }
+      text.AddString(status);
       first = false;
       free(status);
     }
   }
   text.AddString("\n]\n}\n");
   return strdup(text.buf());
 }
 
 
+// Advance the scanner to the value token of a specified name-value pair.
+void SeekNamedValue(const char* name, dart::JSONScanner* scanner) {
+  while (!scanner->EOM()) {
+    scanner->Scan();
+    if (scanner->IsStringLiteral(name)) {
+      scanner->Scan();
+      ASSERT(scanner->CurrentToken() == dart::JSONScanner::TokenColon);
+      scanner->Scan();
+     return;
+    }
+  }
+}
+
+
+// Windows doesn't have strndup(), so this is a simple, private version.
+static char* StrNDup(const char* s, uword len) {
+  if (strlen(s) < len) {
+    len = strlen(s);
+  }
+  char* result = reinterpret_cast<char*>(malloc(len + 1));
+  memmove(result, s, len);
+  result[len + 1] = '\0';
+  return result;
+}
+
+
+void VmStats::DumpStackThread(uword unused) {
+  Log::Print("Isolate dump:\n");
+  IsolateTable::iterator itr;
+  MonitorLocker ml(instance_monitor_);
+  for (itr = instance_->isolate_table_.begin();
+       itr != instance_->isolate_table_.end(); ++itr) {
+    Dart_Isolate isolate = itr->second;
+
+    // Print isolate name and details.
+    static char buffer[512];
+    snprintf(buffer, sizeof(buffer),
+             "/isolate/0x%"Px, reinterpret_cast<intptr_t>(isolate));
+    char* isolate_details = VmStatusService::GetVmStatus(buffer);
+    if (isolate_details != NULL) {
+      dart::JSONScanner scanner(isolate_details);
+      SeekNamedValue("name", &scanner);
+      char* name = StrNDup(scanner.TokenChars(), scanner.TokenLen());
+      SeekNamedValue("port", &scanner);
+      char* port = StrNDup(scanner.TokenChars(), scanner.TokenLen());
+      Log::Print("\"%s\" port=%s\n", name, port);
+      free(isolate_details);
+      free(port);
+      free(name);
+    }
+
+    // Print stack trace.
+    snprintf(buffer, sizeof(buffer),
+             "/isolate/0x%"Px"/stacktrace",
+             reinterpret_cast<intptr_t>(isolate));
+    char* trace = VmStatusService::GetVmStatus(buffer);
+    if (trace != NULL) {
+      dart::JSONScanner scanner(trace);
+      while (true) {
+        SeekNamedValue("url", &scanner);
+        if (scanner.CurrentToken() == dart::JSONScanner::TokenEOM) {
+          break;
+        }
+        char* url = StrNDup(scanner.TokenChars(), scanner.TokenLen());
+        SeekNamedValue("line", &scanner);
+        char* line = StrNDup(scanner.TokenChars(), scanner.TokenLen());
+        SeekNamedValue("function", &scanner);
+        char* function = StrNDup(scanner.TokenChars(), scanner.TokenLen());
+        Log::Print("  at %s(%s:%s)\n", function, url, line);
+        free(url);
+        free(line);
+        free(function);
+      }
+      free(trace);
+    }
+  }
+}
+
+
+void VmStats::DumpStack() {
+  int err = dart::Thread::Start(DumpStackThread, 0);
+  if (err != 0) {
+    Log::PrintErr("Failed starting VmStats stackdump thread: %d\n", err);
+    Shutdown();
+  }
+}
+
+
 // 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) {
+  ASSERT(VmStatusService::instance_ != NULL);
+  ASSERT(VmStatusService::mutex_ != NULL);
   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) {
+  ASSERT(VmStatusService::instance_ != NULL);
   VmStatusPlugin* plugin = instance_->registered_plugin_list_;
   while (plugin != NULL) {
     char* result = (plugin->callback())(request);
     if (result != NULL) {
       return result;
     }
     plugin = plugin->next();
   }
   return NULL;
 }