Terminate event handler thread on isolate shutdown.

runtime/bin/eventhandler_linux.cc

 // Copyright (c) 2012, 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 "bin/eventhandler.h"
 
 #include <errno.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
@@ skipping 15 matching lines @@
     UNREACHABLE();
     return 0;
   }
   return ((static_cast<int64_t>(tv.tv_sec) * 1000000) + tv.tv_usec) / 1000;
 }
 
 
 static const int kInterruptMessageSize = sizeof(InterruptMessage);
 static const int kInfinityTimeout = -1;
 static const int kTimerId = -1;
+static const int kShutdownId = -2;
 
 
 intptr_t SocketData::GetPollEvents() {
   // Do not ask for EPOLLERR and EPOLLHUP explicitly as they are
   // triggered anyway.
   intptr_t events = 0;
   if (!IsClosedRead()) {
     if ((mask_ & (1 << kInEvent)) != 0) {
       events |= EPOLLIN;
     }
@@ skipping 52 matching lines @@
 EventHandlerImplementation::EventHandlerImplementation()
     : socket_map_(&HashMap::SamePointerValue, 16) {
   intptr_t result;
   result = TEMP_FAILURE_RETRY(pipe(interrupt_fds_));
   if (result != 0) {
     FATAL("Pipe creation failed");
   }
   FDUtils::SetNonBlocking(interrupt_fds_[0]);
   timeout_ = kInfinityTimeout;
   timeout_port_ = 0;
+  shutdown_ = false;
   // The initial size passed to epoll_create is ignore on newer (>=
   // 2.6.8) Linux versions
   static const int kEpollInitialSize = 64;
   epoll_fd_ = TEMP_FAILURE_RETRY(epoll_create(kEpollInitialSize));
   if (epoll_fd_ == -1) {
     FATAL("Failed creating epoll file descriptor");
   }
   // Register the interrupt_fd with the epoll instance.
   struct epoll_event event;
   event.events = EPOLLIN;
@@ skipping 68 matching lines @@
   }
   return (total_read == kInterruptMessageSize) ? true : false;
 }
 
 void EventHandlerImplementation::HandleInterruptFd() {
   InterruptMessage msg;
   while (GetInterruptMessage(&msg)) {
     if (msg.id == kTimerId) {
       timeout_ = msg.data;
       timeout_port_ = msg.dart_port;
+    } else if (msg.id == kShutdownId) {
+      shutdown_ = true;
     } else {
       SocketData* sd = GetSocketData(msg.id);
       if ((msg.data & (1 << kShutdownReadCommand)) != 0) {
         ASSERT(msg.data == (1 << kShutdownReadCommand));
         // Close the socket for reading.
         sd->ShutdownRead();
         UpdateEpollInstance(epoll_fd_, sd);
       } else if ((msg.data & (1 << kShutdownWriteCommand)) != 0) {
         ASSERT(msg.data == (1 << kShutdownWriteCommand));
         // Close the socket for writing.
@@ skipping 160 matching lines @@
   }
 }
 
 
 void EventHandlerImplementation::Poll(uword args) {
   static const intptr_t kMaxEvents = 16;
   struct epoll_event events[kMaxEvents];
   EventHandlerImplementation* handler =
       reinterpret_cast<EventHandlerImplementation*>(args);
   ASSERT(handler != NULL);
-  while (1) {
+  while (!handler->shutdown_) {
     intptr_t millis = handler->GetTimeout();
     intptr_t result = TEMP_FAILURE_RETRY(epoll_wait(handler->epoll_fd_,
                                                     events,
                                                     kMaxEvents,
                                                     millis));
     ASSERT(EAGAIN == EWOULDBLOCK);
     if (result == -1) {
       if (errno != EWOULDBLOCK) {
         perror("Poll failed");
       }
     } else {
       handler->HandleTimeout();
       handler->HandleEvents(events, result);
     }
   }
 }
 
 
-void EventHandlerImplementation::StartEventHandler() {
+void EventHandlerImplementation::Start() {
   int result = dart::Thread::Start(&EventHandlerImplementation::Poll,
                                    reinterpret_cast<uword>(this));
   if (result != 0) {
     FATAL1("Failed to start event handler thread %d", result);
   }
 }
 
 
+void EventHandlerImplementation::Shutdown() {
+  SendData(kShutdownId, 0, 0);
+}
+
+
 void EventHandlerImplementation::SendData(intptr_t id,
                                           Dart_Port dart_port,
                                           intptr_t data) {
   WakeupHandler(id, dart_port, data);
 }
 
 
 void* EventHandlerImplementation::GetHashmapKeyFromFd(intptr_t fd) {
   // The hashmap does not support keys with value 0.
   return reinterpret_cast<void*>(fd + 1);
 }
 
 
 uint32_t EventHandlerImplementation::GetHashmapHashFromFd(intptr_t fd) {
   // The hashmap does not support keys with value 0.
   return dart::Utils::WordHash(fd + 1);
 }