Enables clean VM shutdown.

runtime/vm/isolate.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/isolate.h"
 
 #include "include/dart_api.h"
+#include "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "vm/code_observers.h"
 #include "vm/compiler_stats.h"
 #include "vm/coverage.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/heap.h"
@@ skipping 132 matching lines @@
   void NotifyPauseOnStart();
   void NotifyPauseOnExit();
 
 #if defined(DEBUG)
   // Check that it is safe to access this handler.
   void CheckAccess();
 #endif
   bool IsCurrentIsolate() const;
   virtual Isolate* isolate() const { return isolate_; }
 
- private:
   // Keep both these enums in sync with isolate_patch.dart.
   // The different Isolate API message types.
   enum {
     kPauseMsg = 1,
     kResumeMsg = 2,
     kPingMsg = 3,
     kKillMsg = 4,
     kAddExitMsg = 5,
     kDelExitMsg = 6,
     kAddErrorMsg = 7,
     kDelErrorMsg = 8,
     kErrorFatalMsg = 9,
   };
   // The different Isolate API message priorities for ping and kill messages.
   enum {
     kImmediateAction = 0,
     kBeforeNextEventAction = 1,
     kAsEventAction = 2
   };
 
+ private:
   // A result of false indicates that the isolate should terminate the
   // processing of further events.
   bool HandleLibMessage(const Array& message);
 
   bool ProcessUnhandledException(const Error& result);
   Isolate* isolate_;
 };
 
 
 IsolateMessageHandler::IsolateMessageHandler(Isolate* isolate)
@@ skipping 544 matching lines @@
 bool Isolate::IsIsolateOf(Thread* thread) {
   return this == thread->isolate();
 }
 #endif  // DEBUG
 
 
 void Isolate::InitOnce() {
   create_callback_ = NULL;
   isolates_list_monitor_ = new Monitor();
   ASSERT(isolates_list_monitor_ != NULL);
+  creation_enabled_ = true;

[turnidge, 2015/08/04 21:39:02]

Consider calling EnableIsolateCreation here?

[zra, 2015/08/05 06:23:06]

Done.

 }
 
 
 Isolate* Isolate::Init(const char* name_prefix,
                        const Dart_IsolateFlags& api_flags,
                        bool is_vm_isolate) {
   Isolate* result = new Isolate(api_flags);
   ASSERT(result != NULL);
 
   // Initialize metrics.
@@ skipping 52 matching lines @@
   if (FLAG_trace_isolates) {
     if (name_prefix == NULL || strcmp(name_prefix, "vm-isolate") != 0) {
       OS::Print("[+] Starting isolate:\n"
                 "\tisolate:    %s\n", result->name());
     }
   }
   if (FLAG_compiler_stats) {
     result->compiler_stats_ = new CompilerStats(result);
   }
   ObjectIdRing::Init(result);
-  // Add to isolate list.
-  AddIsolateTolist(result);
+
+  // Add to isolate list. Shutdown and delete the isolate on failure.
+  if (!AddIsolateToList(result)) {
+    result->Shutdown();
+    delete result;
+    return NULL;
+  }
 
   return result;
 }
 
 
 void Isolate::InitializeStackLimit() {
   SetStackLimitFromStackBase(Isolate::GetCurrentStackPointer());
 }
 
 
@@ skipping 622 matching lines @@
   }
 #endif  // DEBUG
 
   // First, perform higher-level cleanup that may need to allocate.
   {
     // Ensure we have a zone and handle scope so that we can call VM functions.
     StackZone stack_zone(this);
     HandleScope handle_scope(this);
 
     // Write out the coverage data if collection has been enabled.
-    CodeCoverage::Write(this);
+    if ((this != Dart::vm_isolate()) &&
+        !ServiceIsolate::IsServiceIsolateDescendant(this)) {
+      CodeCoverage::Write(this);
+    }
 
     if ((timeline_event_recorder_ != NULL) &&
         (FLAG_timeline_trace_dir != NULL)) {
       timeline_event_recorder_->WriteTo(FLAG_timeline_trace_dir);
     }
   }
 
   // Remove this isolate from the list *before* we start tearing it down, to
   // avoid exposing it in a state of decay.
   RemoveIsolateFromList(this);
@@ skipping 76 matching lines @@
     Isolate::unhandled_exception_callback_ = NULL;
 Dart_IsolateShutdownCallback Isolate::shutdown_callback_ = NULL;
 Dart_FileOpenCallback Isolate::file_open_callback_ = NULL;
 Dart_FileReadCallback Isolate::file_read_callback_ = NULL;
 Dart_FileWriteCallback Isolate::file_write_callback_ = NULL;
 Dart_FileCloseCallback Isolate::file_close_callback_ = NULL;
 Dart_EntropySource Isolate::entropy_source_callback_ = NULL;
 
 Monitor* Isolate::isolates_list_monitor_ = NULL;
 Isolate* Isolate::isolates_list_head_ = NULL;
-
+bool Isolate::creation_enabled_ = true;

[turnidge, 2015/08/04 21:39:02]

Maybe we should start this as false.

[zra, 2015/08/05 06:23:06]

Done.

 
 void Isolate::IterateObjectPointers(ObjectPointerVisitor* visitor,
                                     bool visit_prologue_weak_handles,
                                     bool validate_frames) {
   HeapIterationScope heap_iteration_scope;
   VisitObjectPointers(visitor, visit_prologue_weak_handles, validate_frames);
 }
 
 
 void Isolate::VisitObjectPointers(ObjectPointerVisitor* visitor,
@@ skipping 328 matching lines @@
   intptr_t count = 0;
   Isolate* current = isolates_list_head_;
   while (current != NULL) {
     count++;
     current = current->next_;
   }
   return count;
 }
 
 
-void Isolate::AddIsolateTolist(Isolate* isolate) {
+bool Isolate::AddIsolateToList(Isolate* isolate) {
   MonitorLocker ml(isolates_list_monitor_);
+  if (!creation_enabled_) {
+    return false;
+  }
   ASSERT(isolate != NULL);
   ASSERT(isolate->next_ == NULL);
   isolate->next_ = isolates_list_head_;
   isolates_list_head_ = isolate;
+  return true;
 }
 
 
 void Isolate::RemoveIsolateFromList(Isolate* isolate) {
   MonitorLocker ml(isolates_list_monitor_);
   ASSERT(isolate != NULL);
   if (isolate == isolates_list_head_) {
     isolates_list_head_ = isolate->next_;
     return;
   }
   Isolate* previous = NULL;
   Isolate* current = isolates_list_head_;
   while (current) {
     if (current == isolate) {
       ASSERT(previous != NULL);
       previous->next_ = current->next_;
       return;
     }
     previous = current;
     current = current->next_;
   }
-  UNREACHABLE();
+  // If we are shutting down an isolate that tried to start after the VM
+  // started going down, then it may not be in the list.

[turnidge, 2015/08/04 21:39:02]

I feel like there is a simpler version of this comment out there... maybe...

// If we are shutting down the VM, the isolate may not be in the list.

[zra, 2015/08/05 06:23:06]

Done.

+  ASSERT(!creation_enabled_);
 }
 
 
 #if defined(DEBUG)
 void Isolate::CheckForDuplicateThreadState(InterruptableThreadState* state) {
   MonitorLocker ml(isolates_list_monitor_);
   ASSERT(state != NULL);
   Isolate* current = isolates_list_head_;
   while (current) {
     ASSERT(current->thread_state() != state);
     current = current->next_;
   }
 }
+
+
+int Isolate::IsolateCount() {
+  MonitorLocker ml(isolates_list_monitor_);
+  Isolate* current = isolates_list_head_;
+  int count = 0;
+  while (current) {
+    count++;
+    current = current->next_;
+  }
+  return count;
+}
 #endif
 
 
+void Isolate::DisableIsolateCreation() {
+  MonitorLocker ml(isolates_list_monitor_);
+  creation_enabled_ = false;
+}
+
+
+void Isolate::EnableIsolateCreation() {
+  MonitorLocker ml(isolates_list_monitor_);
+  creation_enabled_ = true;
+}
+
+
 template<class T>
 T* Isolate::AllocateReusableHandle() {
   T* handle = reinterpret_cast<T*>(reusable_handles_.AllocateScopedHandle());
   T::initializeHandle(handle, T::null());
   return handle;
 }
 
 
+void Isolate::KillIsolate(Isolate* isolate) {
+  Dart_CObject kill_msg;
+  Dart_CObject* list_values[4];
+  kill_msg.type = Dart_CObject_kArray;
+  kill_msg.value.as_array.length = 4;
+  kill_msg.value.as_array.values = list_values;
+
+  Dart_CObject oob;
+  oob.type = Dart_CObject_kInt32;
+  oob.value.as_int32 = Message::kIsolateLibOOBMsg;
+  list_values[0] = &oob;
+
+  Dart_CObject kill;
+  kill.type = Dart_CObject_kInt32;
+  kill.value.as_int32 = IsolateMessageHandler::kKillMsg;
+  list_values[1] = &kill;
+
+  Dart_CObject cap;
+  cap.type = Dart_CObject_kCapability;
+  cap.value.as_capability.id = isolate->terminate_capability();
+  list_values[2] = &cap;
+
+  Dart_CObject imm;
+  imm.type = Dart_CObject_kInt32;
+  imm.value.as_int32 = IsolateMessageHandler::kImmediateAction;
+  list_values[3] = &imm;
+
+  isolate->ScheduleInterrupts(Isolate::kMessageInterrupt);
+  Dart_PostOOBCObject(isolate->main_port(), &kill_msg);
+}
+
+
+class IsolateKillerVisitor : public IsolateVisitor {
+ public:
+  IsolateKillerVisitor() {}
+
+  virtual ~IsolateKillerVisitor() {}
+
+  void VisitIsolate(Isolate* isolate) {
+    ASSERT(isolate != NULL);
+    if (ServiceIsolate::IsServiceIsolateDescendant(isolate) ||
+        (isolate == Dart::vm_isolate())) {
+      return;
+    }
+    Isolate::KillIsolate(isolate);
+  }
+};
+
+
+void Isolate::KillAllIsolates() {
+  IsolateKillerVisitor visitor;
+  VisitIsolates(&visitor);
+}
+
+
 static RawInstance* DeserializeObject(Isolate* isolate,
                                       Zone* zone,
                                       uint8_t* obj_data,
                                       intptr_t obj_len) {
   if (obj_data == NULL) {
     return Instance::null();
   }
   MessageSnapshotReader reader(obj_data,
                                obj_len,
                                isolate,
@@ skipping 186 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart