Handle EINTR on all IO operations

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 <errno.h>
 #include <poll.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/time.h>
@@ skipping 37 matching lines @@
   return events;
 }
 
 
 EventHandlerImplementation::EventHandlerImplementation() {
   intptr_t result;
   socket_map_size_ = kInitialPortMapSize;
   socket_map_ = reinterpret_cast<SocketData*>(calloc(socket_map_size_,
                                                      sizeof(SocketData)));
   ASSERT(socket_map_ != NULL);
-  result = pipe(interrupt_fds_);
+  result = TEMP_FAILURE_RETRY(pipe(interrupt_fds_));
   if (result != 0) {
     FATAL("Pipe creation failed");
   }
   FDUtils::SetNonBlocking(interrupt_fds_[0]);
   timeout_ = kInfinityTimeout;
   timeout_port_ = 0;
 }
 
 
 EventHandlerImplementation::~EventHandlerImplementation() {
   free(socket_map_);
-  close(interrupt_fds_[0]);
-  close(interrupt_fds_[1]);
+  TEMP_FAILURE_RETRY(close(interrupt_fds_[0]));
+  TEMP_FAILURE_RETRY(close(interrupt_fds_[1]));
 }
 
 
 // TODO(hpayer): Use hash table instead of array.
 SocketData* EventHandlerImplementation::GetSocketData(intptr_t fd) {
   ASSERT(fd >= 0);
   if (fd >= socket_map_size_) {
     intptr_t new_socket_map_size = socket_map_size_;
     do {
       new_socket_map_size = new_socket_map_size * kPortMapGrowingFactor;
     } while (fd >= new_socket_map_size);
     size_t new_socket_map_bytes = new_socket_map_size * sizeof(SocketData);
     socket_map_ = reinterpret_cast<SocketData*>(realloc(socket_map_,
-                                                      new_socket_map_bytes));
+                                                        new_socket_map_bytes));
     ASSERT(socket_map_ != NULL);
     size_t socket_map_bytes = socket_map_size_ * sizeof(SocketData);
     memset(socket_map_ + socket_map_size_,
            0,
            new_socket_map_bytes - socket_map_bytes);
     socket_map_size_ = new_socket_map_size;
   }
 
   SocketData* sd = socket_map_ + fd;
   sd->set_fd(fd);  // For now just make sure the fd is set.
@@ skipping 44 matching lines @@
     }
   }
   ASSERT(numPollfds == j);
   *pollfds_size = j;
   return pollfds;
 }
 
 
 bool EventHandlerImplementation::GetInterruptMessage(InterruptMessage* msg) {
   int total_read = 0;
-  int bytes_read = read(interrupt_fds_[0], msg, kInterruptMessageSize);
+  int bytes_read =
+      TEMP_FAILURE_RETRY(read(interrupt_fds_[0], msg, kInterruptMessageSize));
   if (bytes_read < 0) {
     return false;
   }
   total_read = bytes_read;
   while (total_read < kInterruptMessageSize) {
-    bytes_read = read(interrupt_fds_[0],
-                  msg + total_read,
-                  kInterruptMessageSize - total_read);
+    bytes_read = TEMP_FAILURE_RETRY(read(interrupt_fds_[0],
+                                         msg + total_read,
+                                         kInterruptMessageSize - total_read));
     if (bytes_read > 0) {
       total_read = total_read + bytes_read;
     }
   }
   return (total_read == kInterruptMessageSize) ? true : false;
 }
 
 void EventHandlerImplementation::HandleInterruptFd() {
   InterruptMessage msg;
   while (GetInterruptMessage(&msg)) {
@@ skipping 79 matching lines @@
           // end-of-file.
           if (sd->fd() == STDIN_FILENO) {
             event_mask = (1 << kCloseEvent);
             sd->MarkClosedRead();
           }
         } else {
           // If POLLIN is set with no available data and no POLLHUP use
           // recv to peek for whether the other end of the socket
           // actually closed.
           char buffer;
-          ssize_t bytesPeeked = recv(sd->fd(), &buffer, 1, MSG_PEEK);
+          ssize_t bytesPeeked =
+              TEMP_FAILURE_RETRY(recv(sd->fd(), &buffer, 1, MSG_PEEK));
+          ASSERT(EAGAIN == EWOULDBLOCK);
           if (bytesPeeked == 0) {
             event_mask = (1 << kCloseEvent);
             sd->MarkClosedRead();
-          } else if (errno != EAGAIN) {
+          } else if (errno != EWOULDBLOCK) {
             fprintf(stderr, "Error recv: %s\n", strerror(errno));
           }
         }
       }
     }
 
     // On pipes POLLHUP is reported without POLLIN when there is no
     // more data to read.
     if (sd->IsPipe()) {
       if (((pollfd->revents & POLLIN) == 0) &&
@@ skipping 66 matching lines @@
 
 
 void* EventHandlerImplementation::Poll(void* args) {
   intptr_t pollfds_size;
   struct pollfd* pollfds;
   EventHandlerImplementation* handler =
       reinterpret_cast<EventHandlerImplementation*>(args);
   while (1) {
     pollfds = handler->GetPollFds(&pollfds_size);
     intptr_t millis = handler->GetTimeout();
-    intptr_t result = poll(pollfds, pollfds_size, millis);
+    intptr_t result = TEMP_FAILURE_RETRY(poll(pollfds, pollfds_size, millis));
+    ASSERT(EAGAIN == EWOULDBLOCK);
     if (result == -1) {
-      if (errno != EAGAIN && errno != EINTR) {
+      if (errno != EWOULDBLOCK) {
         perror("Poll failed");
       }
     } else {
       handler->HandleTimeout();
       handler->HandleEvents(pollfds, pollfds_size, result);
     }
     free(pollfds);
   }
   return NULL;
 }
 
 
 void EventHandlerImplementation::StartEventHandler() {
   pthread_t handler_thread;
   int result = pthread_create(&handler_thread,
                               NULL,
                               &EventHandlerImplementation::Poll,
                               this);
   if (result != 0) {
     FATAL("Create start event handler thread");
   }
 }
 
 
 void EventHandlerImplementation::SendData(intptr_t id,
                                           Dart_Port dart_port,
                                           intptr_t data) {
   WakeupHandler(id, dart_port, data);
 }