Shutdown the service isolate when shutting down the VM

runtime/vm/service_isolate.cc

 // Copyright (c) 2015, 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 "vm/service_isolate.h"
 
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/isolate.h"
@@ skipping 98 matching lines @@
 static Dart_Port ExtractPort(Isolate* isolate, Dart_Handle receivePort) {
   const ReceivePort& rp = Api::UnwrapReceivePortHandle(isolate, receivePort);
   if (rp.IsNull()) {
     return ILLEGAL_PORT;
   }
   return rp.Id();
 }
 
 
 // These must be kept in sync with service/constants.dart
+#define VM_SERVICE_ISOLATE_EXIT_MESSAGE_ID 0
 #define VM_SERVICE_ISOLATE_STARTUP_MESSAGE_ID 1
 #define VM_SERVICE_ISOLATE_SHUTDOWN_MESSAGE_ID 2
 
 static RawArray* MakeServiceControlMessage(Dart_Port port_id, intptr_t code,
                                            const String& name) {
   const Array& list = Array::Handle(Array::New(4));
   ASSERT(!list.IsNull());
   const Integer& code_int = Integer::Handle(Integer::New(code));
   const Integer& port_int = Integer::Handle(Integer::New(port_id));
   const SendPort& send_port = SendPort::Handle(SendPort::New(port_id));
   list.SetAt(0, code_int);
   list.SetAt(1, port_int);
   list.SetAt(2, send_port);
   list.SetAt(3, name);
   return list.raw();
 }
 
 
+static RawArray* MakeServiceExitMessage() {
+  const Array& list = Array::Handle(Array::New(1));
+  ASSERT(!list.IsNull());
+  const intptr_t code = VM_SERVICE_ISOLATE_EXIT_MESSAGE_ID;
+  const Integer& code_int = Integer::Handle(Integer::New(code));
+  list.SetAt(0, code_int);
+  return list.raw();
+}
+
+
 const char* ServiceIsolate::kName = "vm-service";
 Isolate* ServiceIsolate::isolate_ = NULL;
 Dart_Port ServiceIsolate::port_ = ILLEGAL_PORT;
 Dart_Port ServiceIsolate::load_port_ = ILLEGAL_PORT;
 Dart_IsolateCreateCallback ServiceIsolate::create_callback_ = NULL;
+uint8_t* ServiceIsolate::exit_message_ = NULL;
+intptr_t ServiceIsolate::exit_message_length_ = 0;
 Monitor* ServiceIsolate::monitor_ = NULL;
 bool ServiceIsolate::initializing_ = true;
+bool ServiceIsolate::shutting_down_ = false;
 
 
 class RegisterRunningIsolatesVisitor : public IsolateVisitor {
  public:
   explicit RegisterRunningIsolatesVisitor(Isolate* service_isolate)
       : IsolateVisitor(),
         register_function_(Function::Handle(service_isolate)),
         service_isolate_(service_isolate) {
     ASSERT(ServiceIsolate::IsServiceIsolate(Isolate::Current()));
     // Get library.
@@ skipping 118 matching lines @@
 
     {
       if (FLAG_trace_service) {
         OS::Print("vm-service: Registering running isolates.\n");
       }
       // Register running isolates with service.
       RegisterRunningIsolatesVisitor register_isolates(isolate);
       Isolate::VisitIsolates(&register_isolates);
     }
   }
+
+  static void OnExit(Dart_NativeArguments args) {
+    NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
+    Isolate* isolate = arguments->isolate();
+    StackZone zone(isolate);
+    HANDLESCOPE(isolate);
+    {
+      if (FLAG_trace_service) {
+        OS::Print("vm-service: processed exit message.\n");
+      }
+      ServiceIsolate::FinishedExiting();
+    }
+  }
 };
 
 
 struct ServiceNativeEntry {
   const char* name;
   int num_arguments;
   Dart_NativeFunction function;
 };
 
 
 static ServiceNativeEntry _ServiceNativeEntries[] = {
   {"VMService_SendIsolateServiceMessage", 2,
     ServiceIsolateNatives::SendIsolateServiceMessage},
   {"VMService_SendRootServiceMessage", 1,
     ServiceIsolateNatives::SendRootServiceMessage},
   {"VMService_SetEventMask", 1,
     ServiceIsolateNatives::SetEventMask},
   {"VMService_OnStart", 0,
     ServiceIsolateNatives::OnStart },
+  {"VMService_OnExit", 0,
+    ServiceIsolateNatives::OnExit },
 };
 
 
 static Dart_NativeFunction ServiceNativeResolver(Dart_Handle name,
                                                  int num_arguments,
                                                  bool* auto_setup_scope) {
   const Object& obj = Object::Handle(Api::UnwrapHandle(name));
   if (!obj.IsString()) {
     return NULL;
   }
@@ skipping 116 matching lines @@
   if (FLAG_trace_service) {
     OS::Print("vm-service: Isolate %s %" Pd64 " deregistered.\n",
               name.ToCString(),
               Dart_GetMainPortId());
   }
   return PortMap::PostMessage(
       new Message(port_, data, len, Message::kNormalPriority));
 }
 
 
+void ServiceIsolate::SendServiceExitMessage() {
+  if (!IsRunning()) {

[zra, 2015/03/24 21:53:59]

Should this be an ASSERT()?

[Cutch, 2015/03/24 23:39:07]

No, we may have failed to startup the service isolate or the service isolate
could have already exited.

+    return;
+  }
+  if ((exit_message_ == NULL) || (exit_message_length_ == 0)) {

[zra, 2015/03/24 21:53:59]

ditto

[Cutch, 2015/03/24 23:39:07]

Similarly.

+    return;
+  }
+  if (FLAG_trace_service) {
+    OS::Print("vm-service: sending service exit message.\n");
+  }
+  PortMap::PostMessage(new Message(port_,
+                                   exit_message_,
+                                   exit_message_length_,
+                                   Message::kNormalPriority));
+}
+
+
 void ServiceIsolate::SetServicePort(Dart_Port port) {
   MonitorLocker ml(monitor_);
   port_ = port;
 }
 
 
 void ServiceIsolate::SetServiceIsolate(Isolate* isolate) {
   MonitorLocker ml(monitor_);
   isolate_ = isolate;
   if (isolate_ != NULL) {
@@ skipping 52 matching lines @@
   ASSERT(error.IsNull());
   Dart_Handle result = Dart_FinalizeLoading(false);
   ASSERT(!Dart_IsError(result));
   Dart_ExitScope();
 
   // Uninstall our library tag handler.
   isolate->set_library_tag_handler(NULL);
 }
 
 
+void ServiceIsolate::ConstructExitMessageAndCache(Isolate* isolate) {
+  // Construct and cache exit message here so we can send it without needing an
+  // isolate.
+  StartIsolateScope iso_scope(isolate);
+  StackZone zone(isolate);
+  HANDLESCOPE(isolate);
+  ASSERT(exit_message_ == NULL);
+  ASSERT(exit_message_length_ == 0);
+  const Array& list = Array::Handle(MakeServiceExitMessage());
+  ASSERT(!list.IsNull());
+  MessageWriter writer(&exit_message_, &allocator, false);
+  writer.WriteMessage(list);
+  exit_message_length_ = writer.BytesWritten();
+  ASSERT(exit_message_ != NULL);
+  ASSERT(exit_message_length_ != 0);
+}
+
+
+void ServiceIsolate::FinishedExiting() {
+  MonitorLocker ml(monitor_);
+  shutting_down_ = false;
+  ml.NotifyAll();
+}
+
+
 void ServiceIsolate::FinishedInitializing() {
   MonitorLocker ml(monitor_);
   initializing_ = false;
   ml.NotifyAll();
 }
 
 
 class RunServiceTask : public ThreadPool::Task {
  public:
   virtual void Run() {
@@ skipping 17 matching lines @@
                                                    NULL,
                                                    &error));
     if (isolate == NULL) {
       OS::PrintErr("vm-service: Isolate creation error: %s\n", error);
       ServiceIsolate::FinishedInitializing();
       return;
     }
 
     Isolate::SetCurrent(NULL);
 
+    ServiceIsolate::ConstructExitMessageAndCache(isolate);
+
     RunMain(isolate);
 
     ServiceIsolate::FinishedInitializing();
 
     isolate->message_handler()->Run(Dart::thread_pool(),
                                     NULL,
                                     ShutdownIsolate,
                                     reinterpret_cast<uword>(isolate));
   }
 
@@ skipping 79 matching lines @@
   ASSERT(monitor_ == NULL);
   monitor_ = new Monitor();
   ASSERT(monitor_ != NULL);
   // Grab the isolate create callback here to avoid race conditions with tests
   // that change this after Dart_Initialize returns.
   create_callback_ = Isolate::CreateCallback();
   Dart::thread_pool()->Run(new RunServiceTask());
 }
 
 
+void ServiceIsolate::Shutdown() {
+  if (!IsRunning()) {

[zra, 2015/03/24 21:53:59]

ditto

[Cutch, 2015/03/24 23:39:07]

ditto.

+    return;
+  }
+  {
+    MonitorLocker ml(monitor_);
+    shutting_down_ = true;
+  }
+  SendServiceExitMessage();
+  {
+    MonitorLocker ml(monitor_);
+    while (shutting_down_ && (port_ != ILLEGAL_PORT)) {

[zra, 2015/03/24 21:53:59]

Why would port_ be illegal?

[Cutch, 2015/03/24 23:39:07]

Before the service isolate starts up and after it shuts down the port_ is
ILLEGAL_PORT (the canonical value for an uninitialized Dart_Port).

+      ml.Wait();
+    }
+  }
+}
+
+
 Dart_Handle ServiceIsolate::GetSource(const char* name) {
   ASSERT(name != NULL);
   int i = 0;
   while (true) {
     const char* path = Resources::Path(i);
     if (path == NULL) {
       break;
     }
     ASSERT(*path != '\0');
     // Skip the '/'.
@@ skipping 27 matching lines @@
     return result;
   }
   Dart_Handle source = GetSource(url_string);
   if (Dart_IsError(source)) {
     return source;
   }
   return Dart_LoadSource(library, url, source, 0, 0);
 }
 
 }  // namespace dart