Handle EINTR.

Author: dvander

bsd/bsd-kqueue.cc

@@ -47,7 +47,7 @@ KqueueImpl::Shutdown()
       detach_for_shutdown(listeners_[i].transport);
   }
 
-  close(kq_);
+  AMIO_RETRY_IF_ENTR(close(kq_));
 }
 
 PassRef<IOError>
@@ -155,8 +155,11 @@ KqueueImpl::Poll(int timeoutMs)
   }
 
   int nevents = kevent(kq_, nullptr, 0, event_buffer_.get(), event_buffer_.length(), timeoutp);
-  if (nevents == -1)
+  if (nevents == -1) {
+    if (errno == EINTR)
+      return nullptr;
     return new PosixError();
+  }
 
   AutoMaybeLock lock(lock_);
 

include/amio-eventloop.h

@@ -154,7 +154,8 @@ class EventQueue : public IODispatcher
   virtual void Shutdown() = 0;
 };
 
-// An event loop for I/O multiplexing.
+// An event loop for I/O multiplexing. This is essentially a wrapper around
+// a Poller and a single EventQueue. Tasks are prioritized over events.
 class AMIO_LINK EventLoopForIO
  : public EventLoop,
    public IODispatcher

include/amio-posix.h

@@ -371,6 +371,18 @@ class AutoDisableSigPipe
   void (*prev_handler_)(int);
 };
 
+// Posix system calls can be interrupted on EINTR. This macro will automatically
+// retry syscalls that fail for that reason. This is based on HANDLE_EINTR from
+// Chromium.
+#define AMIO_RETRY_IF_EINTR(expr)                 \
+  ({                                              \
+    __typeof__(expr) syscall_rv;                  \
+    do {                                          \
+      syscall_rv = expr;                          \
+    } while (syscall_rv == -1 && errno == EINTR); \
+    syscall_rv;                                   \
+  })
+
 } // namespace amio
 
 #endif // _include_amio_posix_header_h_

linux/linux-epoll.cc

@@ -73,7 +73,7 @@ EpollImpl::Shutdown()
       detach_for_shutdown_locked(listeners_[i].transport);
   }
 
-  close(ep_);
+  AMIO_RETRY_IF_EINTR(close(ep_));
   ep_ = -1;
 }
 
@@ -187,8 +187,11 @@ EpollImpl::Poll(int timeoutMs)
   AutoMaybeLock poll_lock(poll_lock_);
 
   int nevents = epoll_wait(ep_, event_buffer_, max_events_, timeoutMs);
-  if (nevents == -1)
+  if (nevents == -1) {
+    if (errno == EINTR)
+      return nullptr;
     return new PosixError();
+  }
 
   // Now we acquire the transport lock.
   AutoMaybeLock lock(lock_);

posix/posix-net.cc

@@ -277,7 +277,7 @@ ConnectionForSocket(Ref<PosixConnection> *outp, int fd, AddressFamily af)
       *outp = new PosixConnectionT<UnixAddress>(fd);
       return nullptr;
     default:
-      close(fd);
+      AMIO_RETRY_IF_EINTR(close(fd));
       return eUnsupportedAddressFamily;
   }
 }
@@ -365,7 +365,7 @@ amio::net::ConnectTo(Ref<Connection> *outp, Protocol protocol, Ref<Address> addr
   if (Ref<IOError> error = ConnectionForAddress(&conn, address, protocol))
     return error;
 
-  int rv = connect(conn->fd(), address->SockAddr(), address->SockAddrLen());
+  int rv = AMIO_RETRY_IF_EINTR(connect(conn->fd(), address->SockAddr(), address->SockAddrLen()));
   if (rv == -1)
     return new PosixError();
 
@@ -405,7 +405,7 @@ class PosixServer
   void OnReadReady() override {
     size_t failures = 0;
     while (failures < 10) {
-      int rv = accept(transport_->fd(), nullptr, nullptr);
+      int rv = AMIO_RETRY_IF_EINTR(accept(transport_->fd(), nullptr, nullptr));
       if (rv == -1) {
         switch (errno) {
 #if defined(KE_LINUX)

posix/posix-poll.cc

@@ -199,8 +199,11 @@ PollImpl::Poll(int timeoutMs)
   }
 
   int nevents = poll(poll_buffer, poll_buffer_len, timeoutMs);
-  if (nevents == -1)
+  if (nevents == -1) {
+    if (errno == EINTR)
+      return nullptr;
     return new PosixError();
+  }
   if (nevents == 0)
     return nullptr;
 

posix/posix-select.cc

@@ -173,8 +173,11 @@ SelectImpl::Poll(int timeoutMs)
   }
 
   int result = select(fd_watermark + 1, &read_fds, &write_fds, nullptr, timeoutp);
-  if (result == -1)
+  if (result == -1) {
+    if (errno == EINTR)
+      return nullptr;
     return new PosixError();
+  }
 
   AutoMaybeLock lock(lock_);
 

posix/posix-transport.cc

@@ -51,7 +51,7 @@ PosixTransport::Close()
     poller->detach_unlocked(this);
   }
 
-  close(fd_);
+  AMIO_RETRY_IF_EINTR(close(fd_));
   fd_ = -1;
 
   assert(!poller_.get() && !listener_);
@@ -62,7 +62,7 @@ PosixTransport::Read(IOResult *result, void *buffer, size_t maxlength)
 {
   *result = IOResult();
 
-  ssize_t rv = read(fd_, buffer, maxlength);
+  ssize_t rv = AMIO_RETRY_IF_EINTR(read(fd_, buffer, maxlength));
   if (rv == -1) {
     if (errno == EWOULDBLOCK || errno == EAGAIN) {
       if (Ref<IOError> error = ReadIsBlocked()) {
@@ -91,7 +91,7 @@ PosixTransport::Write(IOResult *result, const void *buffer, size_t maxlength)
 {
   *result = IOResult();
 
-  ssize_t rv = write(fd_, buffer, maxlength);
+  ssize_t rv = AMIO_RETRY_IF_EINTR(write(fd_, buffer, maxlength));
   if (rv == -1) {
     if (errno == EWOULDBLOCK || errno == EAGAIN) {
       if (Ref<IOError> error = WriteIsBlocked()) {

solaris/amio-solaris-devpoll.cc

@@ -61,7 +61,7 @@ DevPollImpl::Shutdown()
       fds_[i].transport->detach();
   }
 
-  close(dp_);
+  AMIO_RETRY_IF_EINTR(close(dp_));
 }
 
 static inline PassRef<IOError>
@@ -79,7 +79,7 @@ WriteDevPoll(int dp, int fd, TransportFlags flags)
     pe.events = POLLREMOVE;
   }
 
-  int rv = write(dp, &pe, sizeof(pe));
+  int rv = AMIO_RETRY_IF_EINTR(write(dp, &pe, sizeof(pe)));
   if (rv == -1)
     return new PosixError();
   if (size_t(rv) != sizeof(pe))
@@ -185,7 +185,7 @@ DevPollImpl::Poll(int timeoutMs)
   params.dp_nfds = event_buffer_.length();
   params.dp_timeout = timeoutMs;
 
-  int nevents = ioctl(dp_, DP_POLL, &params);
+  int nevents = AMIO_RETRY_IF_EINTR(ioctl(dp_, DP_POLL, &params));
   if (nevents == -1)
     return new PosixError();
 

solaris/amio-solaris-port.cc

@@ -53,7 +53,7 @@ PortImpl::Shutdown()
       fds_[i].transport->detach();
   }
 
-  close(port_);
+  AMIO_RETRY_IF_EINTR(close(port_));
 }
 
 PassRef<IOError>
@@ -186,7 +186,7 @@ PortImpl::Poll(int timeoutMs)
   // return more.
   uint_t nevents = 1;
   if (port_getn(port_, event_buffer->get(), event_buffer->length(), &nevents, timeoutp) == -1) {
-    if (errno == ETIME)
+    if (errno == ETIME || errno == EINTR)
       return nullptr;
     return new PosixError();
   }