Use POLL* rather than EPOLL* event bits on Fuchsia

runtime/bin/eventhandler_fuchsia.cc

 // Copyright (c) 2016, 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.
 
 #if !defined(DART_IO_DISABLED)
 
 #include "platform/globals.h"
 #if defined(HOST_OS_FUCHSIA)
 
 #include "bin/eventhandler.h"
 #include "bin/eventhandler_fuchsia.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <magenta/status.h>
 #include <magenta/syscalls.h>
 #include <magenta/syscalls/object.h>
 #include <magenta/syscalls/port.h>
 #include <mxio/private.h>
+#include <poll.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
-#include <sys/epoll.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include "bin/fdutils.h"
 #include "bin/lockers.h"
 #include "bin/log.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
@@ skipping 48 matching lines @@
   MutexLocker ml(mutex_);
   const ssize_t read_bytes = NO_RETRY_EXPECTED(read(fd_, buffer, num_bytes));
   const int err = errno;
   LOG_INFO("IOHandle::Read: fd = %ld. read %ld bytes\n", fd_, read_bytes);
 
   // Resubscribe to read events. We resubscribe to events even if read() returns
   // an error. The error might be, e.g. EWOULDBLOCK, in which case
   // re-subscription is necessary. Logic in the caller decides which errors are
   // real, and which are ignore-and-continue.
   read_events_enabled_ = true;
-  if (!AsyncWaitLocked(MX_HANDLE_INVALID, EPOLLIN, wait_key_)) {
+  if (!AsyncWaitLocked(MX_HANDLE_INVALID, POLLIN, wait_key_)) {
     LOG_ERR("IOHandle::AsyncWait failed for fd = %ld\n", fd_);
   }
 
   errno = err;
   return read_bytes;
 }
 
 
 intptr_t IOHandle::Write(const void* buffer, intptr_t num_bytes) {
   MutexLocker ml(mutex_);
   const ssize_t written_bytes =
       NO_RETRY_EXPECTED(write(fd_, buffer, num_bytes));
   const int err = errno;
   LOG_INFO("IOHandle::Write: fd = %ld. wrote %ld bytes\n", fd_, written_bytes);
 
   // Resubscribe to write events.
   write_events_enabled_ = true;
-  if (!AsyncWaitLocked(MX_HANDLE_INVALID, EPOLLOUT, wait_key_)) {
+  if (!AsyncWaitLocked(MX_HANDLE_INVALID, POLLOUT, wait_key_)) {
     LOG_ERR("IOHandle::AsyncWait failed for fd = %ld\n", fd_);
   }
 
   errno = err;
   return written_bytes;
 }
 
 
 intptr_t IOHandle::Accept(struct sockaddr* addr, socklen_t* addrlen) {
   MutexLocker ml(mutex_);
   const intptr_t socket = NO_RETRY_EXPECTED(accept(fd_, addr, addrlen));
   const int err = errno;
   LOG_INFO("IOHandle::Accept: fd = %ld. socket = %ld\n", fd_, socket);
 
   // Re-subscribe to read events.
   read_events_enabled_ = true;
-  if (!AsyncWaitLocked(MX_HANDLE_INVALID, EPOLLIN, wait_key_)) {
+  if (!AsyncWaitLocked(MX_HANDLE_INVALID, POLLIN, wait_key_)) {
     LOG_ERR("IOHandle::AsyncWait failed for fd = %ld\n", fd_);
   }
 
   errno = err;
   return socket;
 }
 
 
 void IOHandle::Close() {
   MutexLocker ml(mutex_);
   VOID_NO_RETRY_EXPECTED(close(fd_));
 }
 
 
 uint32_t IOHandle::MaskToEpollEvents(intptr_t mask) {
   MutexLocker ml(mutex_);
-  // Do not ask for EPOLLERR and EPOLLHUP explicitly as they are
+  // Do not ask for POLLERR and POLLHUP explicitly as they are
   // triggered anyway.
-  uint32_t events = EPOLLRDHUP;
+  uint32_t events = POLLRDHUP;
   if (read_events_enabled_ && ((mask & (1 << kInEvent)) != 0)) {
-    events |= EPOLLIN;
+    events |= POLLIN;
   }
   if (write_events_enabled_ && ((mask & (1 << kOutEvent)) != 0)) {
-    events |= EPOLLOUT;
+    events |= POLLOUT;
   }
   return events;
 }
 
 
 intptr_t IOHandle::EpollEventsToMask(intptr_t events) {
-  if ((events & EPOLLERR) != 0) {
-    // Return error only if EPOLLIN is present.
-    return ((events & EPOLLIN) != 0) ? (1 << kErrorEvent) : 0;
+  if ((events & POLLERR) != 0) {
+    // Return error only if POLLIN is present.
+    return ((events & POLLIN) != 0) ? (1 << kErrorEvent) : 0;
   }
   intptr_t event_mask = 0;
-  if ((events & EPOLLIN) != 0) {
+  if ((events & POLLIN) != 0) {
     event_mask |= (1 << kInEvent);
   }
-  if ((events & EPOLLOUT) != 0) {
+  if ((events & POLLOUT) != 0) {
     event_mask |= (1 << kOutEvent);
   }
-  if ((events & (EPOLLHUP | EPOLLRDHUP)) != 0) {
+  if ((events & (POLLHUP | POLLRDHUP)) != 0) {
     event_mask |= (1 << kCloseEvent);
   }
   return event_mask;
 }
 
 
 bool IOHandle::AsyncWaitLocked(mx_handle_t port,
                                uint32_t events,
                                uint64_t key) {
   LOG_INFO("IOHandle::AsyncWait: fd = %ld\n", fd_);
@@ skipping 402 matching lines @@
   // The hashmap does not support keys with value 0.
   return dart::Utils::WordHash(fd + 1);
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(HOST_OS_FUCHSIA)
 
 #endif  // !defined(DART_IO_DISABLED)