- Implement Isolate.kill.

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 "platform/assert.h"
 #include "platform/json.h"
 #include "vm/code_observers.h"
@@ skipping 88 matching lines @@
   virtual Isolate* isolate() const { return isolate_; }
   bool UnhandledExceptionCallbackHandler(const Object& message,
                                          const UnhandledException& error);
 
  private:
   // Keep in sync with isolate_patch.dart.
   enum {
     kPauseMsg = 1,
     kResumeMsg = 2,
     kPingMsg = 3,
+    kKillMsg = 4,
 
     kImmediateAction = 0,
     kBeforeNextEventAction = 1,
     kAsEventAction = 2
   };
 
-  void HandleLibMessage(const Array& message);
+  // A result of false indicates that the isolate should terminate the
+  // processing of further events.
+  bool HandleLibMessage(const Array& message);

[siva, 2014/12/13 00:24:05]

Not for this CL but it might be more readable to have this return
enum {
  kContinueMessageProcessing = 0,
  kTerminateIsolate = 1
};

[Ivan Posva, 2014/12/13 00:36:47]

Seems like a plan.

+
   bool ProcessUnhandledException(const Object& message, const Error& result);
   RawFunction* ResolveCallbackFunction();
   Isolate* isolate_;
 };
 
 
 IsolateMessageHandler::IsolateMessageHandler(Isolate* isolate)
     : isolate_(isolate) {
 }
 
 
 IsolateMessageHandler::~IsolateMessageHandler() {
 }
 
 const char* IsolateMessageHandler::name() const {
   return isolate_->name();
 }
 
 
 // Isolate library OOB messages are fixed sized arrays which have the
 // following format:
 // [ OOB dispatch, Isolate library dispatch, <message specific data> ]
-void IsolateMessageHandler::HandleLibMessage(const Array& message) {
-  if (message.Length() < 2) return;
+bool IsolateMessageHandler::HandleLibMessage(const Array& message) {
+  if (message.Length() < 2) return true;
   const Object& type = Object::Handle(I, message.At(1));
-  if (!type.IsSmi()) return;
+  if (!type.IsSmi()) return true;
   const Smi& msg_type = Smi::Cast(type);
   switch (msg_type.Value()) {
     case kPauseMsg: {
       // [ OOB, kPauseMsg, pause capability, resume capability ]
-      if (message.Length() != 4) return;
+      if (message.Length() != 4) return true;
       Object& obj = Object::Handle(I, message.At(2));
-      if (!obj.IsCapability()) return;
-      if (!I->VerifyPauseCapability(Capability::Cast(obj))) return;
+      if (!I->VerifyPauseCapability(obj)) return true;
       obj = message.At(3);
-      if (!obj.IsCapability()) return;
+      if (!obj.IsCapability()) return true;
       if (I->AddResumeCapability(Capability::Cast(obj))) {
         increment_paused();
       }
       break;
     }
     case kResumeMsg: {
       // [ OOB, kResumeMsg, pause capability, resume capability ]
-      if (message.Length() != 4) return;
+      if (message.Length() != 4) return true;
       Object& obj = Object::Handle(I, message.At(2));
-      if (!obj.IsCapability()) return;
-      if (!I->VerifyPauseCapability(Capability::Cast(obj))) return;
+      if (!I->VerifyPauseCapability(obj)) return true;
       obj = message.At(3);
-      if (!obj.IsCapability()) return;
+      if (!obj.IsCapability()) return true;
       if (I->RemoveResumeCapability(Capability::Cast(obj))) {
         decrement_paused();
       }
       break;
     }
     case kPingMsg: {
-      // [ OOB, kPingMsg, responsePort, pingType ]
-      if (message.Length() != 4) return;
+      // [ OOB, kPingMsg, responsePort, priority ]
+      if (message.Length() != 4) return true;
       const Object& obj2 = Object::Handle(I, message.At(2));
-      if (!obj2.IsSendPort()) return;
+      if (!obj2.IsSendPort()) return true;
       const SendPort& send_port = SendPort::Cast(obj2);
       const Object& obj3 = Object::Handle(I, message.At(3));
-      if (!obj3.IsSmi()) return;
-      const intptr_t ping_type = Smi::Cast(obj3).Value();
-      if (ping_type == kImmediateAction) {
+      if (!obj3.IsSmi()) return true;
+      const intptr_t priority = Smi::Cast(obj3).Value();
+      if (priority == kImmediateAction) {
         uint8_t* data = NULL;
         intptr_t len = 0;
         SerializeObject(Object::null_instance(), &data, &len);
         PortMap::PostMessage(new Message(send_port.Id(),
                                          data, len,
                                          Message::kNormalPriority));
-      } else if (ping_type == kBeforeNextEventAction) {
+      } else {
+        ASSERT((priority == kBeforeNextEventAction) ||
+               (priority == 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(
             0, Smi::Handle(I, Smi::New(Message::kDelayedIsolateLibOOBMsg)));
         message.SetAt(3, Smi::Handle(I, Smi::New(kImmediateAction)));
         uint8_t* data = NULL;
         intptr_t len = 0;
         SerializeObject(message, &data, &len);
         this->PostMessage(new Message(Message::kIllegalPort,
                                       data, len,
                                       Message::kNormalPriority),
-                          true /* at_head */);
-      } else if (ping_type == kAsEventAction) {
+                          priority == kBeforeNextEventAction /* at_head */);
+      }
+      break;
+    }
+    case kKillMsg: {
+      // [ OOB, kKillMsg, terminate capability, priority ]
+      if (message.Length() != 4) return true;
+      Object& obj = Object::Handle(I, message.At(3));
+      if (!obj.IsSmi()) return true;
+      const intptr_t priority = Smi::Cast(obj).Value();
+      if (priority == kImmediateAction) {
+        obj = message.At(2);
+        // Signal that the isolate should stop execution.
+        return !I->VerifyTerminateCapability(obj);
+      } else {
+        ASSERT((priority == kBeforeNextEventAction) ||
+               (priority == 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(
             0, Smi::Handle(I, Smi::New(Message::kDelayedIsolateLibOOBMsg)));
         message.SetAt(3, Smi::Handle(I, Smi::New(kImmediateAction)));
         uint8_t* data = NULL;
         intptr_t len = 0;
         SerializeObject(message, &data, &len);
         this->PostMessage(new Message(Message::kIllegalPort,
                                       data, len,
-                                      Message::kNormalPriority));
+                                      Message::kNormalPriority),
+                          priority == kBeforeNextEventAction /* at_head */);
       }
       break;
     }
 #if defined(DEBUG)
     // Malformed OOB messages are silently ignored in release builds.
     default:
       UNREACHABLE();
       break;
 #endif  // defined(DEBUG)
   }
+  return true;
 }
 
 
 void IsolateMessageHandler::MessageNotify(Message::Priority priority) {
   if (priority >= Message::kOOBPriority) {
     // Handle out of band messages even if the isolate is busy.
     I->ScheduleInterrupts(Isolate::kMessageInterrupt);
   }
   Dart_MessageNotifyCallback callback = I->message_notify_callback();
   if (callback) {
@@ skipping 65 matching lines @@
       const Array& oob_msg = Array::Cast(msg);
       if (oob_msg.Length() > 0) {
         const Object& oob_tag = Object::Handle(I, 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: {
-              HandleLibMessage(oob_msg);
+              success = HandleLibMessage(oob_msg);
               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(I, msg_arr.At(0));
         if (oob_tag.IsSmi() &&
             (Smi::Cast(oob_tag).Value() == Message::kDelayedIsolateLibOOBMsg)) {
-          HandleLibMessage(Array::Cast(msg_arr));
+          success = HandleLibMessage(Array::Cast(msg_arr));
         }
       }
     }
   } else {
     const Object& result = Object::Handle(I,
         DartLibraryCalls::HandleMessage(msg_handler, msg));
     if (result.IsError()) {
       success = ProcessUnhandledException(msg, Error::Cast(result));
     } else {
       ASSERT(result.IsNull());
@@ skipping 473 matching lines @@
   }
   IsolateSpawnState* state = spawn_state();
   if (state != NULL) {
     ASSERT(this == state->isolate());
     Run();
   }
   return true;
 }
 
 
-bool Isolate::VerifyPauseCapability(const Capability& capability) const {
-  return !capability.IsNull() && (pause_capability() == capability.Id());
+bool Isolate::VerifyPauseCapability(const Object& capability) const {
+  return !capability.IsNull() &&
+      capability.IsCapability() &&
+      (pause_capability() == Capability::Cast(capability).Id());
+}
+
+
+bool Isolate::VerifyTerminateCapability(const Object& capability) const {
+  return !capability.IsNull() &&
+      capability.IsCapability() &&
+      (terminate_capability() == Capability::Cast(capability).Id());
 }
 
 
 bool Isolate::AddResumeCapability(const Capability& capability) {
   // Ensure a limit for the number of resume capabilities remembered.
   static const intptr_t kMaxResumeCapabilities = kSmiMax / (6*kWordSize);
 
   const GrowableObjectArray& caps = GrowableObjectArray::Handle(
       this, object_store()->resume_capabilities());
   Capability& current = Capability::Handle(this);
@@ skipping 131 matching lines @@
 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.
     StartIsolateScope start_scope(isolate);
     StackZone zone(isolate);
     HandleScope handle_scope(isolate);
     Error& error = Error::Handle();
     error = isolate->object_store()->sticky_error();
-    if (!error.IsNull()) {
+    if (!error.IsNull() && !error.IsUnwindError()) {
       OS::PrintErr("in ShutdownIsolate: %s\n", error.ToErrorCString());
     }
     Dart::RunShutdownCallback();
   }
   {
     // Shut the isolate down.
     SwitchIsolateScope switch_scope(isolate);
     Dart::ShutdownIsolate();
   }
 }
@@ skipping 651 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart