Make service lifecycle checks thread safe

runtime/vm/service.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 "vm/service.h"
 
 #include "include/dart_api.h"
 #include "platform/globals.h"
 
 #include "vm/compiler.h"
@@ skipping 254 matching lines @@
     OS::Print("[%" Pd "] %s took %" Pd64 " micros.\n",
               OS::ProcessId(), name_, elapsed);
   }
 
  private:
   const char* name_;
   int64_t start_;
 };
 
 
+bool Service::IsRunning() {
+  MonitorLocker ml(monitor_);
+  return (service_port_ != ILLEGAL_PORT) && (service_isolate_ != NULL);
+}
+
+
+void Service::SetServicePort(Dart_Port port) {
+  MonitorLocker ml(monitor_);
+  service_port_ = port;
+}
+
+
+void Service::SetServiceIsolate(Isolate* isolate) {
+  MonitorLocker ml(monitor_);
+  service_isolate_ = isolate;
+}
+
+
+bool Service::HasServiceIsolate() {
+  MonitorLocker ml(monitor_);
+  return service_isolate_ != NULL;
+}
+
+
+bool Service::IsServiceIsolate(Isolate* isolate) {
+  MonitorLocker ml(monitor_);
+  return isolate == service_isolate_;
+}
+
 Dart_Port Service::WaitForLoadPort() {
   MonitorLocker ml(monitor_);
 
   while (initializing_ && (load_port_ == ILLEGAL_PORT)) {
     ml.Wait();
   }
 
   return load_port_;
 }
 
@@ skipping 44 matching lines @@
   return list.raw();
 }
 
 
 class RegisterRunningIsolatesVisitor : public IsolateVisitor {
  public:
   explicit RegisterRunningIsolatesVisitor(Isolate* service_isolate)
       : IsolateVisitor(),
         register_function_(Function::Handle(service_isolate)),
         service_isolate_(service_isolate) {
-    ASSERT(Isolate::Current() == service_isolate_);
+    ASSERT(Service::IsServiceIsolate(Isolate::Current()));
     // Get library.
     const String& library_url = Symbols::DartVMService();
     ASSERT(!library_url.IsNull());
     const Library& library =
         Library::Handle(Library::LookupLibrary(library_url));
     ASSERT(!library.IsNull());
     // Get function.
     const String& function_name =
         String::Handle(String::New("_registerIsolate"));
     ASSERT(!function_name.IsNull());
     register_function_ = library.LookupFunctionAllowPrivate(function_name);
     ASSERT(!register_function_.IsNull());
   }
 
   virtual void VisitIsolate(Isolate* isolate) {
-    ASSERT(Isolate::Current() == service_isolate_);
-    if ((isolate == service_isolate_) ||
+    ASSERT(Service::IsServiceIsolate(Isolate::Current()));
+    if (Service::IsServiceIsolate(isolate) ||
         (isolate == Dart::vm_isolate())) {
       // We do not register the service or vm isolate.
       return;
     }
     // Setup arguments for call.
     Dart_Port port_id = isolate->main_port();
     const Integer& port_int = Integer::Handle(Integer::New(port_id));
     ASSERT(!port_int.IsNull());
     const SendPort& send_port = SendPort::Handle(SendPort::New(port_id));
     const String& name = String::Handle(String::New(isolate->name()));
     ASSERT(!name.IsNull());
     const Array& args = Array::Handle(Array::New(3));
     ASSERT(!args.IsNull());
     args.SetAt(0, port_int);
     args.SetAt(1, send_port);
     args.SetAt(2, name);
     Object& r = Object::Handle(service_isolate_);
     r = DartEntry::InvokeFunction(register_function_, args);
     if (FLAG_trace_service) {
-      OS::Print("Isolate %s %" Pd64 " registered with service \n",
+      OS::Print("vm-service: Isolate %s %" Pd64 " registered.\n",
                 name.ToCString(),
                 port_id);
     }
     ASSERT(!r.IsError());
   }
 
  private:
   Function& register_function_;
   Isolate* service_isolate_;
 };
 
 
 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();
 }
 
 
 static void OnStart(Dart_NativeArguments args) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->isolate();
   StackZone zone(isolate);
   HANDLESCOPE(isolate);
   {
     if (FLAG_trace_service) {
-      OS::Print("Booting dart:vmservice library\n");
+      OS::Print("vm-service: Booting dart:vmservice library.\n");
     }
     // Boot the dart:vmservice library.
     Dart_EnterScope();
     Dart_Handle url_str =
         Dart_NewStringFromCString(Symbols::Name(Symbols::kDartVMServiceId));
     Dart_Handle library = Dart_LookupLibrary(url_str);
     ASSERT(Dart_IsLibrary(library));
     Dart_Handle result =
         Dart_Invoke(library, Dart_NewStringFromCString("boot"), 0, NULL);
     ASSERT(!Dart_IsError(result));
     Dart_Port port = ExtractPort(isolate, result);
     ASSERT(port != ILLEGAL_PORT);
-    Service::set_port(port);
+    Service::SetServicePort(port);
     Dart_ExitScope();
   }
 
   {
     if (FLAG_trace_service) {
-      OS::Print("Registering running isolates\n");
+      OS::Print("vm-service: Registering running isolates.\n");
     }
     // Register running isolates with service.
     RegisterRunningIsolatesVisitor register_isolates(isolate);
     Isolate::VisitIsolates(&register_isolates);
   }
 }
 
 
 struct VmServiceNativeEntry {
   const char* name;
@@ skipping 30 matching lines @@
       return entry.function;
     }
   }
   return NULL;
 }
 
 const char* Service::kServiceIsolateName = "vm-service";
 EmbedderServiceHandler* Service::isolate_service_handler_head_ = NULL;
 EmbedderServiceHandler* Service::root_service_handler_head_ = NULL;
 Isolate* Service::service_isolate_ = NULL;
-Dart_Port Service::port_ = ILLEGAL_PORT;
+Dart_Port Service::service_port_ = ILLEGAL_PORT;
 Dart_Port Service::load_port_ = ILLEGAL_PORT;
 Monitor* Service::monitor_ = NULL;
 bool Service::initializing_ = true;
 uint32_t Service::event_mask_ = 0;
 
 
 bool Service::IsServiceIsolateName(const char* name) {
   ASSERT(name != NULL);
   return strcmp(name, kServiceIsolateName) == 0;
 }
@@ skipping 14 matching lines @@
   const Array& list = Array::Handle(
       MakeServiceControlMessage(Dart_GetMainPortId(),
                                 VM_SERVICE_ISOLATE_STARTUP_MESSAGE_ID,
                                 name));
   ASSERT(!list.IsNull());
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator, false);
   writer.WriteMessage(list);
   intptr_t len = writer.BytesWritten();
   if (FLAG_trace_service) {
-    OS::Print("Isolate %s %" Pd64 " registered with service \n",
+    OS::Print("vm-service: Isolate %s %" Pd64 " registered.\n",
               name.ToCString(),
               Dart_GetMainPortId());
   }
   return PortMap::PostMessage(
-      new Message(port_, data, len, Message::kNormalPriority));
+      new Message(service_port_, data, len, Message::kNormalPriority));
 }
 
 
 bool Service::SendIsolateShutdownMessage() {
   if (!IsRunning()) {
     return false;
   }
   Isolate* isolate = Isolate::Current();
   if (IsServiceIsolate(isolate)) {
     return false;
   }
   ASSERT(isolate != NULL);
   HANDLESCOPE(isolate);
   const String& name = String::Handle(String::New(isolate->name()));
   ASSERT(!name.IsNull());
   const Array& list = Array::Handle(
       MakeServiceControlMessage(Dart_GetMainPortId(),
                                 VM_SERVICE_ISOLATE_SHUTDOWN_MESSAGE_ID,
                                 name));
   ASSERT(!list.IsNull());
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator, false);
   writer.WriteMessage(list);
   intptr_t len = writer.BytesWritten();
   if (FLAG_trace_service) {
-    OS::Print("Isolate %s %" Pd64 " deregistered with service \n",
+    OS::Print("vm-service: Isolate %s %" Pd64 " deregistered.\n",
               name.ToCString(),
               Dart_GetMainPortId());
   }
   return PortMap::PostMessage(
-      new Message(port_, data, len, Message::kNormalPriority));
+      new Message(service_port_, data, len, Message::kNormalPriority));
 }
 
 
 Dart_Handle Service::GetSource(const char* name) {
   ASSERT(name != NULL);
   int i = 0;
   while (true) {
     const char* path = Resources::Path(i);
     if (path == NULL) {
       break;
@@ skipping 30 matching lines @@
   }
   Dart_Handle source = GetSource(url_string);
   if (Dart_IsError(source)) {
     return source;
   }
   return Dart_LoadSource(library, url, source, 0, 0);
 }
 
 
 void Service::MaybeInjectVMServiceLibrary(Isolate* isolate) {
-  if (service_isolate_ != NULL) {
-    // Service isolate already exists.
-    return;
-  }
+  ASSERT(isolate != NULL);
+  ASSERT(isolate->name() != NULL);
   if (!Service::IsServiceIsolateName(isolate->name())) {
     // Not service isolate.
     return;
   }
-  service_isolate_ = isolate;
-  ASSERT(isolate != NULL);
+  if (HasServiceIsolate()) {
+    // Service isolate already exists.
+    return;
+  }
+  SetServiceIsolate(isolate);
 
   StackZone zone(isolate);
   HANDLESCOPE(isolate);
 
   // Register dart:vmservice library.
   const String& url_str = String::Handle(Symbols::DartVMService().raw());
   const Library& library = Library::Handle(Library::New(url_str));
   library.Register();
   library.set_native_entry_resolver(VmServiceNativeResolver);
 
@@ skipping 29 matching lines @@
 
 void Service::FinishedInitializing() {
   MonitorLocker ml(monitor_);
   initializing_ = false;
   ml.NotifyAll();
 }
 
 
 static void ShutdownIsolate(uword parameter) {
   Isolate* isolate = reinterpret_cast<Isolate*>(parameter);
+  ASSERT(Service::IsServiceIsolate(isolate));
   {
     // Print the error if there is one.  This may execute dart code to
     // print the exception object, so we need to use a StartIsolateScope.
     StartIsolateScope start_scope(isolate);
     StackZone zone(isolate);
     HandleScope handle_scope(isolate);
     Error& error = Error::Handle();
     error = isolate->object_store()->sticky_error();
     if (!error.IsNull()) {
-      OS::PrintErr("Service shutting down: %s\n", error.ToErrorCString());
+      OS::PrintErr("vm-service: Error: %s\n", error.ToErrorCString());
     }
     Dart::RunShutdownCallback();
   }
   {
     // Shut the isolate down.
     SwitchIsolateScope switch_scope(isolate);
     Dart::ShutdownIsolate();
   }
+  Service::SetServiceIsolate(NULL);
+  Service::SetServicePort(ILLEGAL_PORT);
+  if (FLAG_trace_service) {
+    OS::Print("vm-service: Shutdown.\n");
+  }
 }
 
 
 class RunServiceTask : public ThreadPool::Task {
  public:
   virtual void Run() {
     ASSERT(Isolate::Current() == NULL);
     char* error = NULL;
     Isolate* isolate = NULL;
 
     Dart_IsolateCreateCallback create_callback = Isolate::CreateCallback();
     if (create_callback == NULL) {
       Service::FinishedInitializing();
       return;
     }
 
     isolate =
         reinterpret_cast<Isolate*>(create_callback(Service::kServiceIsolateName,
                                                    NULL,
                                                    NULL,
                                                    NULL,
                                                    &error));
     Isolate::SetCurrent(NULL);
 
     if (isolate == NULL) {
-      OS::PrintErr("Service startup error: %s\n", error);
+      OS::PrintErr("vm-service: Isolate creation error: %s\n", error);
       Service::FinishedInitializing();
       return;
     }
 
     RunMain(isolate);
 
     Service::FinishedInitializing();
 
     isolate->message_handler()->Run(Dart::thread_pool(),
                                     NULL,
                                     ShutdownIsolate,
                                     reinterpret_cast<uword>(isolate));
   }
 
  protected:
   void RunMain(Isolate* isolate) {
     StartIsolateScope iso_scope(isolate);
     StackZone zone(isolate);
     HANDLESCOPE(isolate);
     // Invoke main which will return the loadScriptPort.
     const Library& root_library =
         Library::Handle(isolate, isolate->object_store()->root_library());
     if (root_library.IsNull()) {
+      if (FLAG_trace_service) {
+        OS::Print("vm-service: Embedder did not install a script.");
+      }
       // Service isolate is not supported by embedder.
       return;
     }
     ASSERT(!root_library.IsNull());
     const String& entry_name = String::Handle(isolate, String::New("main"));
     ASSERT(!entry_name.IsNull());
     const Function& entry =
         Function::Handle(isolate,
                          root_library.LookupFunctionAllowPrivate(entry_name));
     if (entry.IsNull()) {
       // Service isolate is not supported by embedder.
+      if (FLAG_trace_service) {
+        OS::Print("vm-service: Embedder did not provide a main function.");
+      }
       return;
     }
     ASSERT(!entry.IsNull());
     const Object& result =
         Object::Handle(isolate,
                        DartEntry::InvokeFunction(entry,
                                                  Object::empty_array()));
     ASSERT(!result.IsNull());
     if (result.IsError()) {
       // Service isolate did not initialize properly.
+      if (FLAG_trace_service) {
+        const Error& error = Error::Cast(result);
+        OS::Print("vm-service: Calling main resulted in an error: %s",
+                  error.ToErrorCString());
+      }
       return;
     }
     ASSERT(result.IsReceivePort());
     const ReceivePort& rp = ReceivePort::Cast(result);
     Service::SetLoadPort(rp.Id());
   }
 };
 
 
 void Service::RunService() {
@@ skipping 1824 matching lines @@
 static IsolateMessageHandler FindIsolateMessageHandler(const char* command) {
   intptr_t num_message_handlers = sizeof(isolate_handlers) /
                                   sizeof(isolate_handlers[0]);
   for (intptr_t i = 0; i < num_message_handlers; i++) {
     const IsolateMessageHandlerEntry& entry = isolate_handlers[i];
     if (strcmp(command, entry.command) == 0) {
       return entry.handler;
     }
   }
   if (FLAG_trace_service) {
-    OS::Print("Service has no isolate message handler for <%s>\n", command);
+    OS::Print("vm-service: No isolate message handler for <%s>.\n", command);
   }
   return NULL;
 }
 
 
 void Service::HandleRootMessage(const Instance& msg) {
   Isolate* isolate = Isolate::Current();
   ASSERT(!msg.IsNull());
   ASSERT(msg.IsArray());
 
@@ skipping 168 matching lines @@
 static RootMessageHandler FindRootMessageHandler(const char* command) {
   intptr_t num_message_handlers = sizeof(root_handlers) /
                                   sizeof(root_handlers[0]);
   for (intptr_t i = 0; i < num_message_handlers; i++) {
     const RootMessageHandlerEntry& entry = root_handlers[i];
     if (strcmp(command, entry.command) == 0) {
       return entry.handler;
     }
   }
   if (FLAG_trace_service) {
-    OS::Print("Service has no root message handler for <%s>\n", command);
+    OS::Print("vm-service: No root message handler for <%s>.\n", command);
   }
   return NULL;
 }
 
 
 void Service::SendEvent(intptr_t eventId, const Object& eventMessage) {
   if (!IsRunning()) {
     return;
   }
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   HANDLESCOPE(isolate);
 
   // Construct a list of the form [eventId, eventMessage].
   const Array& list = Array::Handle(Array::New(2));
   ASSERT(!list.IsNull());
   list.SetAt(0, Integer::Handle(Integer::New(eventId)));
   list.SetAt(1, eventMessage);
 
   // Push the event to port_.
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator, false);
   writer.WriteMessage(list);
   intptr_t len = writer.BytesWritten();
   if (FLAG_trace_service) {
-    OS::Print("Pushing event of type %" Pd ", len %" Pd "\n", eventId, len);
+    OS::Print("vm-service: Pushing event of type %" Pd ", len %" Pd "\n",
+              eventId, len);
   }
   // TODO(turnidge): For now we ignore failure to send an event.  Revisit?
   PortMap::PostMessage(
-      new Message(port_, data, len, Message::kNormalPriority));
+      new Message(service_port_, data, len, Message::kNormalPriority));
 }
 
 
 void Service::SendEvent(intptr_t eventId,
                         const String& meta,
                         const uint8_t* data,
                         intptr_t size) {
   // Bitstream: [meta data size (big-endian 64 bit)] [meta data (UTF-8)] [data]
   const intptr_t meta_bytes = Utf8::Length(meta);
   const intptr_t total_bytes = sizeof(uint64_t) + meta_bytes + size;
@@ skipping 125 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 }  // namespace dart