VM restart + shutdown fixes

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"
@@ skipping 159 matching lines @@
 }
 
 
 class IsolateMessageHandler : public MessageHandler {
  public:
   explicit IsolateMessageHandler(Isolate* isolate);
   ~IsolateMessageHandler();
 
   const char* name() const;
   void MessageNotify(Message::Priority priority);
-  bool HandleMessage(Message* message);
+  MessageStatus HandleMessage(Message* message);
   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:
   // A result of false indicates that the isolate should terminate the
   // processing of further events.
   RawError* HandleLibMessage(const Array& message);
 
-  bool ProcessUnhandledException(const Error& result);
+  MessageStatus ProcessUnhandledException(const Error& result);
   Isolate* isolate_;
 };
 
 
 IsolateMessageHandler::IsolateMessageHandler(Isolate* isolate)
     : isolate_(isolate) {
 }
 
 
 IsolateMessageHandler::~IsolateMessageHandler() {
@@ skipping 70 matching lines @@
         SerializeObject(message, &data, &len, false);
         this->PostMessage(
             new Message(Message::kIllegalPort,
                         data, len,
                         Message::kNormalPriority),
             priority == Isolate::kBeforeNextEventAction /* at_head */);
       }
       break;
     }
     case Isolate::kKillMsg:
-    case Isolate::kInternalKillMsg: {
+    case Isolate::kInternalKillMsg:
+    case Isolate::kVMRestartMsg: {
       // [ OOB, kKillMsg, terminate capability, priority ]
       if (message.Length() != 4) return Error::null();
       Object& obj = Object::Handle(I, message.At(3));
       if (!obj.IsSmi()) return Error::null();
       const intptr_t priority = Smi::Cast(obj).Value();
       if (priority == Isolate::kImmediateAction) {
         obj = message.At(2);
         // Signal that the isolate should stop execution.
         if (I->VerifyTerminateCapability(obj)) {
           if (msg_type == Isolate::kKillMsg) {
             const String& msg = String::Handle(String::New(
                 "isolate terminated by Isolate.kill"));
             const UnwindError& error =
                 UnwindError::Handle(UnwindError::New(msg));
             error.set_is_user_initiated(true);
             return error.raw();
-          } else {
-            // TODO(turnidge): We should give the message handler a way
-            // to detect when an isolate is unwinding.
-            I->message_handler()->set_pause_on_start(false);
-            I->message_handler()->set_pause_on_exit(false);
+          } else if (msg_type == Isolate::kInternalKillMsg) {
             const String& msg = String::Handle(String::New(
                 "isolate terminated by vm"));
             return UnwindError::New(msg);
+          } else if (msg_type == Isolate::kVMRestartMsg) {
+            const String& msg = String::Handle(String::New(

[Cutch, 2015/10/05 18:10:46]

Maybe a comment here that this path kills the current isolate.

[turnidge, 2015/10/05 22:18:24]

Done.

+                "isolate terminated for vm restart"));
+            const UnwindError& error =
+                UnwindError::Handle(UnwindError::New(msg));
+            error.set_is_vm_restart(true);
+            return error.raw();
+          } else {
+            UNREACHABLE();
           }
         } else {
           return Error::null();
         }
       } else {
         ASSERT((priority == Isolate::kBeforeNextEventAction) ||
                (priority == Isolate::kAsEventAction));
         // Update the message so that it will be handled immediately when it
         // is picked up from the message queue the next time.
         message.SetAt(
@@ skipping 91 matching lines @@
     I->ScheduleInterrupts(Isolate::kMessageInterrupt);
   }
   Dart_MessageNotifyCallback callback = I->message_notify_callback();
   if (callback) {
     // Allow the embedder to handle message notification.
     (*callback)(Api::CastIsolate(I));
   }
 }
 
 
-bool IsolateMessageHandler::HandleMessage(Message* message) {
+MessageHandler::MessageStatus IsolateMessageHandler::HandleMessage(
+    Message* message) {
   ASSERT(IsCurrentIsolate());
   Thread* thread = Thread::Current();
   StackZone stack_zone(thread);
   Zone* zone = stack_zone.GetZone();
   HandleScope handle_scope(thread);
   TimelineDurationScope tds(thread, I->GetIsolateStream(), "HandleMessage");
   tds.SetNumArguments(1);
   tds.CopyArgument(0, "isolateName", I->name());
 
   // If the message is in band we lookup the handler to dispatch to.  If the
   // receive port was closed, we drop the message without deserializing it.
   // Illegal port is a special case for artificially enqueued isolate library
   // messages which are handled in C++ code below.
   Object& msg_handler = Object::Handle(zone);
   if (!message->IsOOB() && (message->dest_port() != Message::kIllegalPort)) {
     msg_handler = DartLibraryCalls::LookupHandler(message->dest_port());
     if (msg_handler.IsError()) {
       delete message;
       return ProcessUnhandledException(Error::Cast(msg_handler));
     }
     if (msg_handler.IsNull()) {
       // If the port has been closed then the message will be dropped at this
       // point. Make sure to post to the delivery failure port in that case.
       if (message->RedirectToDeliveryFailurePort()) {
         PortMap::PostMessage(message);
       } else {
         delete message;
       }
-      return true;
+      return kOK;
     }
   }
 
   // Parse the message.
   MessageSnapshotReader reader(message->data(), message->len(), thread);
   const Object& msg_obj = Object::Handle(zone, reader.ReadObject());
   if (msg_obj.IsError()) {
     // An error occurred while reading the message.
     delete message;
     return ProcessUnhandledException(Error::Cast(msg_obj));
   }
   if (!msg_obj.IsNull() && !msg_obj.IsInstance()) {
     // TODO(turnidge): We need to decide what an isolate does with
     // malformed messages.  If they (eventually) come from a remote
     // machine, then it might make sense to drop the message entirely.
     // In the case that the message originated locally, which is
     // always true for now, then this should never occur.
     UNREACHABLE();
   }
 
   Instance& msg = Instance::Handle(zone);
   msg ^= msg_obj.raw();  // Can't use Instance::Cast because may be null.
 
-  bool success = true;
+  MessageStatus status = kOK;
   if (message->IsOOB()) {
     // OOB messages are expected to be fixed length arrays where the first
     // element is a Smi describing the OOB destination. Messages that do not
     // confirm to this layout are silently ignored.
     if (msg.IsArray()) {
       const Array& oob_msg = Array::Cast(msg);
       if (oob_msg.Length() > 0) {
         const Object& oob_tag = Object::Handle(zone, oob_msg.At(0));
         if (oob_tag.IsSmi()) {
           switch (Smi::Cast(oob_tag).Value()) {
             case Message::kServiceOOBMsg: {
               Service::HandleIsolateMessage(I, oob_msg);
               break;
             }
             case Message::kIsolateLibOOBMsg: {
               const Error& error = Error::Handle(HandleLibMessage(oob_msg));
               if (!error.IsNull()) {
-                success = ProcessUnhandledException(error);
+                status = ProcessUnhandledException(error);
               }
               break;
             }
 #if defined(DEBUG)
             // Malformed OOB messages are silently ignored in release builds.
             default: {
               UNREACHABLE();
               break;
             }
 #endif  // defined(DEBUG)
           }
         }
       }
     }
   } else if (message->dest_port() == Message::kIllegalPort) {
     // Check whether this is a delayed OOB message which needed handling as
     // part of the regular message dispatch. All other messages are dropped on
     // the floor.
     if (msg.IsArray()) {
       const Array& msg_arr = Array::Cast(msg);
       if (msg_arr.Length() > 0) {
         const Object& oob_tag = Object::Handle(zone, msg_arr.At(0));
         if (oob_tag.IsSmi() &&
             (Smi::Cast(oob_tag).Value() == Message::kDelayedIsolateLibOOBMsg)) {
           const Error& error = Error::Handle(HandleLibMessage(msg_arr));
           if (!error.IsNull()) {
-            success = ProcessUnhandledException(error);
+            status = ProcessUnhandledException(error);
           }
         }
       }
     }
   } else {
     const Object& result = Object::Handle(zone,
         DartLibraryCalls::HandleMessage(msg_handler, msg));
     if (result.IsError()) {
-      success = ProcessUnhandledException(Error::Cast(result));
+      status = ProcessUnhandledException(Error::Cast(result));
     } else {
       ASSERT(result.IsNull());
     }
   }
   delete message;
-  if (success) {
+  if (status == kOK) {
     const Object& result =
         Object::Handle(zone, I->InvokePendingServiceExtensionCalls());
     if (result.IsError()) {
-      success = ProcessUnhandledException(Error::Cast(result));
+      status = ProcessUnhandledException(Error::Cast(result));
     } else {
       ASSERT(result.IsNull());
     }
   }
-  return success;
+  return status;
 }
 
 
 void IsolateMessageHandler::NotifyPauseOnStart() {
   if (Service::debug_stream.enabled()) {
     StartIsolateScope start_isolate(I);
     StackZone zone(T);
     HandleScope handle_scope(T);
     ServiceEvent pause_event(I, ServiceEvent::kPauseStart);
     Service::HandleEvent(&pause_event);
@@ skipping 23 matching lines @@
   ASSERT(IsCurrentIsolate());
 }
 #endif
 
 
 bool IsolateMessageHandler::IsCurrentIsolate() const {
   return (I == Isolate::Current());
 }
 
 
-bool IsolateMessageHandler::ProcessUnhandledException(const Error& result) {
+MessageHandler::MessageStatus IsolateMessageHandler::ProcessUnhandledException(
+    const Error& result) {
   // Notify the debugger about specific unhandled exceptions which are withheld
   // when being thrown.
   if (result.IsUnhandledException()) {
     const UnhandledException& error = UnhandledException::Cast(result);
     RawInstance* exception = error.exception();
     if ((exception == I->object_store()->out_of_memory()) ||
         (exception == I->object_store()->stack_overflow())) {
       // We didn't notify the debugger when the stack was full. Do it now.
       I->debugger()->SignalExceptionThrown(Instance::Handle(exception));
     }
@@ skipping 23 matching lines @@
     const Instance& stacktrace = Instance::Handle(I, uhe.stacktrace());
     tmp = DartLibraryCalls::ToString(stacktrace);
     if (!tmp.IsString()) {
       tmp = String::New(stacktrace.ToCString());
     }
     stacktrace_str ^= tmp.raw();;
   } else {
     exc_str = String::New(result.ToErrorCString());
   }
   if (result.IsUnwindError()) {
     // Unwind errors are always fatal and don't notify listeners.

[zra, 2015/10/05 16:56:47]

Is this comment still correct?

[turnidge, 2015/10/05 22:18:24]

Updated.

     I->object_store()->set_sticky_error(result);
-    return false;
+    const UnwindError& unwind = UnwindError::Cast(result);
+    if (unwind.is_user_initiated()) {
+      return kError;
+    } else if (unwind.is_vm_restart()) {
+      return kRestart;
+    } else {
+      return kShutdown;
+    }
   } else {
     bool has_listener = I->NotifyErrorListeners(exc_str, stacktrace_str);
     if (I->ErrorsFatal()) {
       if (has_listener) {
         I->object_store()->clear_sticky_error();
       } else {
         I->object_store()->set_sticky_error(result);
       }
-      return false;
+      return kError;
     }
   }
-  return true;
+  return kOK;
 }
 
 
 Isolate::Flags::Flags()
   : type_checks_(FLAG_enable_type_checks),
     asserts_(FLAG_enable_asserts),
     error_on_bad_type_(FLAG_error_on_bad_type),
     error_on_bad_override_(FLAG_error_on_bad_override) {}
 
 
@@ skipping 638 matching lines @@
       intptr_t len = 0;
       SerializeObject(arr, &data, &len, false);
       Message* msg = new Message(port_id, data, len, Message::kNormalPriority);
       PortMap::PostMessage(msg);
     }
   }
   return listeners.Length() > 0;
 }
 
 
-static void StoreError(Isolate* isolate, const Object& obj) {
-  ASSERT(obj.IsError());
-  isolate->object_store()->set_sticky_error(Error::Cast(obj));
+static

[zra, 2015/10/05 16:56:47]

It looks like we'd usually break the long line in the parameter list rather than
here.

[turnidge, 2015/10/05 22:18:24]

Done.

+MessageHandler::MessageStatus StoreError(Isolate* isolate, const Error& error) {
+  isolate->object_store()->set_sticky_error(error);
+  if (error.IsUnwindError()) {
+    const UnwindError& unwind = UnwindError::Cast(error);
+    if (!unwind.is_user_initiated()) {
+      if (unwind.is_vm_restart()) {
+        return MessageHandler::kRestart;
+      } else {
+        return MessageHandler::kShutdown;
+      }
+    }
+  }
+  return MessageHandler::kError;
 }
 
 
-static bool RunIsolate(uword parameter) {
+static MessageHandler::MessageStatus RunIsolate(uword parameter) {
   Isolate* isolate = reinterpret_cast<Isolate*>(parameter);
   IsolateSpawnState* state = NULL;
   Thread* thread = Thread::Current();
   {
     // TODO(turnidge): Is this locking required here at all anymore?
     MutexLocker ml(isolate->mutex());
     state = isolate->spawn_state();
   }
   {
     StartIsolateScope start_scope(isolate);
@@ skipping 13 matching lines @@
       const SendPort& listener =
           SendPort::Handle(SendPort::New(state->on_error_port()));
       isolate->AddErrorListener(listener);
     }
 
     // Switch back to spawning isolate.
 
 
     if (!ClassFinalizer::ProcessPendingClasses()) {
       // Error is in sticky error already.
-      return false;
+#if defined(DEBUG)
+      const Error& error =
+          Error::Handle(isolate->object_store()->sticky_error());
+      ASSERT(!error.IsUnwindError());
+#endif
+      return MessageHandler::kError;
     }
 
     Object& result = Object::Handle();
     result = state->ResolveFunction();
     bool is_spawn_uri = state->is_spawn_uri();
     if (result.IsError()) {
-      StoreError(isolate, result);
-      return false;
+      return StoreError(isolate, Error::Cast(result));
     }
     ASSERT(result.IsFunction());
     Function& func = Function::Handle(isolate);
     func ^= result.raw();
 
     // TODO(turnidge): Currently we need a way to force a one-time
     // breakpoint for all spawned isolates to support isolate
     // debugging.  Remove this once the vmservice becomes the standard
     // way to debug. Set the breakpoint on the static function instead
     // of its implicit closure function because that latter is merely
@@ skipping 34 matching lines @@
     args.SetAt(6, capabilities);
 
     const Library& lib = Library::Handle(Library::IsolateLibrary());
     const String& entry_name = String::Handle(String::New("_startIsolate"));
     const Function& entry_point =
         Function::Handle(lib.LookupLocalFunction(entry_name));
     ASSERT(entry_point.IsFunction() && !entry_point.IsNull());
 
     result = DartEntry::InvokeFunction(entry_point, args);
     if (result.IsError()) {
-      StoreError(isolate, result);
-      return false;
+      return StoreError(isolate, Error::Cast(result));
     }
   }
-  return true;
+  return MessageHandler::kOK;
 }
 
 
 static void ShutdownIsolate(uword parameter) {
   Isolate* isolate = reinterpret_cast<Isolate*>(parameter);
   {
     // Print the error if there is one.  This may execute dart code to
     // print the exception object, so we need to use a StartIsolateScope.
     Thread* thread = Thread::Current();
     StartIsolateScope start_scope(isolate);
@@ skipping 38 matching lines @@
   if ((interrupt_bits & kVMInterrupt) != 0) {
     thread_registry()->CheckSafepoint();
     if (store_buffer()->Overflowed()) {
       if (FLAG_verbose_gc) {
         OS::PrintErr("Scavenge scheduled by store buffer overflow.\n");
       }
       heap()->CollectGarbage(Heap::kNew);
     }
   }
   if ((interrupt_bits & kMessageInterrupt) != 0) {
-    bool ok = message_handler()->HandleOOBMessages();
-    if (!ok) {
+    MessageHandler::MessageStatus status =
+        message_handler()->HandleOOBMessages();
+    if (status != MessageHandler::kOK) {
       // False result from HandleOOBMessages signals that the isolate should
       // be terminating.
       if (FLAG_trace_isolates) {
         OS::Print("[!] Terminating isolate due to OOB message:\n"
                   "\tisolate:    %s\n", name());
       }
       const Error& error = Error::Handle(object_store()->sticky_error());
+      ASSERT(!error.IsNull() && error.IsUnwindError());
       object_store()->clear_sticky_error();
-      ASSERT(!error.IsNull());
       return error.raw();
     }
   }
   return Error::null();
 }
 
 
 uword Isolate::GetAndClearStackOverflowFlags() {
   uword stack_overflow_flags = stack_overflow_flags_;
   stack_overflow_flags_ = 0;
@@ skipping 776 matching lines @@
 
 
 template<class C>
 C* Isolate::AllocateReusableHandle() {
   C* handle = reinterpret_cast<C*>(reusable_handles_.AllocateScopedHandle());
   C::initializeHandle(handle, C::null());
   return handle;
 }
 
 
-void Isolate::KillLocked() {
+void Isolate::KillLocked(LibMsgId msg_id) {
   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 msg_type;
   msg_type.type = Dart_CObject_kInt32;
-  msg_type.value.as_int32 = Isolate::kInternalKillMsg;
+  msg_type.value.as_int32 = msg_id;
   list_values[1] = &msg_type;
 
   Dart_CObject cap;
   cap.type = Dart_CObject_kCapability;
   cap.value.as_capability.id = terminate_capability();
   list_values[2] = &cap;
 
   Dart_CObject imm;
   imm.type = Dart_CObject_kInt32;
   imm.value.as_int32 = Isolate::kImmediateAction;
@@ skipping 254 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart