Added ctrl-\ command that dumps isolate stacks to dart binary.

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"
@@ skipping 15 matching lines @@
 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.");
   }
   instance_ = new VmStats();
   instance_monitor_ = new dart::Monitor();
+  Initialize();
+
+  if (port != 0) {
+    StartServer(port, root_dir);
+  }
+}
+
+
+void VmStats::StartServer(int port, const char* root_dir) {
   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;
@@ skipping 15 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_);
@@ skipping 238 matching lines @@
       }
       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;
+    }
+  }
+}
+
+void VmStats::DumpStack() {
+  Log::Print("Isolate dump:\n");
+  IsolateTable::iterator itr;
+  MonitorLocker ml(instance_monitor_);

[siva, 2013/04/05 15:55:09]

This could lead to potential deadlocks if the signal is handled by a thread
running an Isolate which is already holding this lock (say an Isolate is on it's
way out and it is trying to remove itself from the list and the signal handler
runs on that thread).

+  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);

[siva, 2013/04/05 15:55:09]

I assume this schedules an interrupt on the isolate and waits for the
stack_trace to be collected. I was wondering how this would work if the signal
was handled by the thread which is currently running the Isolate, wouldn't it
lead to a dead lock.

The code it would execute I presume is:
char* Isolate::DoStacktraceInterrupt(Dart_IsolateInterruptCallback cb) {
  ASSERT(stacktrace_ == NULL);
  SetVmStatsCallback(cb);
  if (status_sync == NULL) {
    status_sync = new Monitor();
  }
  ScheduleInterrupts(Isolate::kVmStatusInterrupt);
  {
    MonitorLocker ml(status_sync);
    if (stacktrace_ == NULL) {  // It may already be available.
      ml.Wait();
    }
  }
  SetVmStatsCallback(NULL);
  ASSERT(stacktrace_ != NULL);
  // result is freed by VmStats::WebServer().
  char* result = stacktrace_;
  stacktrace_ = NULL;
  return result;
}

+    if (trace != NULL) {
+      dart::JSONScanner scanner(trace);
+      SeekNamedValue("url", &scanner);
+      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(trace);
+      free(url);
+      free(line);
+      free(function);
+    }
+  }
+}
+
+
 // 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
@@ skipping 25 matching lines @@
   VmStatusPlugin* plugin = instance_->registered_plugin_list_;
   while (plugin != NULL) {
     char* result = (plugin->callback())(request);
     if (result != NULL) {
       return result;
     }
     plugin = plugin->next();
   }
   return NULL;
 }