Explicitly handle listen sockets and connection sockets differently in Linux and Mac OS eventhandler

runtime/bin/eventhandler_linux.cc

 // Copyright (c) 2011, 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 78 matching lines @@
   port_map_[fd].dart_port = dart_port;
   port_map_[fd].mask = mask;
 }
 
 
 Dart_Port EventHandlerImplementation::PortFor(intptr_t fd) {
   return port_map_[fd].dart_port;
 }
 
 
+bool EventHandlerImplementation::IsListeningSocket(intptr_t fd) {
+  return (port_map_[fd].mask & (1 << kListenSocket)) != 0;

[Mads Ager (google), 2011/10/28 08:33:23]

kListeningSocket?

[Søren Gjesse, 2011/10/28 09:24:19]

Done.

+}
+
+
 void EventHandlerImplementation::RegisterFdWakeup(intptr_t id,
                                                   Dart_Port dart_port,
                                                   intptr_t data) {
   WakeupHandler(id, dart_port, data);
 }
 
 
 void EventHandlerImplementation::CloseFd(intptr_t id) {
   SetPort(id, 0, 0);
   close(id);
@@ skipping 20 matching lines @@
   intptr_t result =
     write(interrupt_fds_[1], &msg, kInterruptMessageSize);
   if (result != kInterruptMessageSize) {
     perror("Interrupt message failure");
   }
 }
 
 
 void EventHandlerImplementation::SetPollEvents(struct pollfd* pollfds,
                                                intptr_t mask) {
-  /*
-   * We do not set POLLERR and POLLHUP explicitly since they are triggered
-   * anyway.
-   */
-  pollfds->events |= POLLRDHUP;
+  // Do not ask for POLLERR and POLLHUP explicitly as they are
+  // triggered anyway.
   if ((mask & (1 << kInEvent)) != 0) {
     pollfds->events |= POLLIN;
   }
   if ((mask & (1 << kOutEvent)) != 0) {
     pollfds->events |= POLLOUT;
   }
+  pollfds->events |= POLLRDHUP;
 }
 
 
 struct pollfd* EventHandlerImplementation::GetPollFds(intptr_t* pollfds_size) {
   struct pollfd* pollfds;
 
   intptr_t numPollfds = 1 + port_map_entries_;
   pollfds = reinterpret_cast<struct pollfd*>(calloc(sizeof(struct pollfd),
                                                     numPollfds));
   pollfds[0].fd = interrupt_fds_[0];
@@ skipping 46 matching lines @@
       CloseFd(msg.id);
     } else {
       SetPort(msg.id, msg.dart_port, msg.data);
     }
   }
 }
 
 
 intptr_t EventHandlerImplementation::GetPollEvents(struct pollfd* pollfd) {
   intptr_t event_mask = 0;
-  /*
-   * We prioritize the events in the following order.
-   */
-  if ((pollfd->revents & POLLIN) != 0) {
-    if (FDUtils::AvailableBytes(pollfd->fd) != 0) {
-      event_mask = (1 << kInEvent);
-    } else if (((pollfd->revents & POLLHUP) != 0) ||
-               ((pollfd->revents & POLLRDHUP) != 0)) {
-      event_mask = (1 << kCloseEvent);
-    } else if ((pollfd->revents & POLLERR) != 0) {
-      event_mask = (1 << kErrorEvent);
-    } else {
-      /*
-       * Accept event.
-       */
-      event_mask = (1 << kInEvent);
+  if (IsListeningSocket(pollfd->fd)) {
+    // For listening sockets the POLLIN event indicate that there are
+    // connections ready for accept.
+    if ((pollfd->revents & POLLIN) != 0) event_mask |= (1 << kInEvent);

[Mads Ager (google), 2011/10/28 08:33:23]

Should we assert that there is no overlap in these? Can we ever get more than
one of these and what does that mean?

[Søren Gjesse, 2011/10/28 09:24:19]

I would be reluctant to try to assert anything here. However reading the
documentation once more both POLLHUP and POLLERR are always provided together
with POLLIN, so POLLIN should only mean "connections ready for accept" if
provided alone.

+    if ((pollfd->revents & POLLHUP) != 0) event_mask |= (1 << kCloseEvent);
+    if ((pollfd->revents & POLLERR) != 0) event_mask |= (1 << kErrorEvent);
+  } else {
+    // Prioritize data events over close and error events.
+    if ((pollfd->revents & POLLIN) != 0) {
+      if (FDUtils::AvailableBytes(pollfd->fd) != 0) {
+        event_mask = (1 << kInEvent);
+      } else if (((pollfd->revents & POLLHUP) != 0) ||
+                 ((pollfd->revents & POLLRDHUP) != 0)) {
+        event_mask = (1 << kCloseEvent);
+      } else if ((pollfd->revents & POLLERR) != 0) {
+        event_mask = (1 << kErrorEvent);
+      }
     }
-  }
 
-  if ((pollfd->revents & POLLOUT) != 0) {
-    event_mask |= (1 << kOutEvent);
+    if ((pollfd->revents & POLLOUT) != 0) event_mask |= (1 << kOutEvent);
   }
 
   return event_mask;
 }
 
 
 void EventHandlerImplementation::HandleEvents(struct pollfd* pollfds,
                                               int pollfds_size,
                                               int result_size) {
   if ((pollfds[0].revents & POLLIN) != 0) {
@@ skipping 71 matching lines @@
     FATAL("Create start event handler thread");
   }
 }
 
 
 void EventHandlerImplementation::SendData(intptr_t id,
                                           Dart_Port dart_port,
                                           intptr_t data) {
   RegisterFdWakeup(id, dart_port, data);
 }