Use POLL* rather than EPOLL* event bits on Fuchsia

runtime/bin/process_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/process.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <launchpad/launchpad.h>
 #include <launchpad/vmo.h>
 #include <magenta/process.h>
 #include <magenta/status.h>
 #include <magenta/syscalls.h>
 #include <magenta/syscalls/object.h>
 #include <magenta/types.h>
 #include <mxio/private.h>
 #include <mxio/util.h>
+#include <poll.h>
 #include <pthread.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/epoll.h>
 #include <unistd.h>
 
 #include "bin/dartutils.h"
 #include "bin/eventhandler.h"
 #include "bin/fdutils.h"
 #include "bin/lockers.h"
 #include "bin/log.h"
 #include "platform/signal_blocker.h"
 #include "platform/utils.h"
 
@@ skipping 469 matching lines @@
                   mx_status_get_string(status));
     return false;
   }
 
   IOHandle* out_tmp = out_iohandle;
   IOHandle* err_tmp = err_iohandle;
   IOHandle* exit_tmp = exit_iohandle;
   const uint64_t out_key = reinterpret_cast<uint64_t>(out_tmp);
   const uint64_t err_key = reinterpret_cast<uint64_t>(err_tmp);
   const uint64_t exit_key = reinterpret_cast<uint64_t>(exit_tmp);
-  const uint32_t events = EPOLLRDHUP | EPOLLIN;
+  const uint32_t events = POLLRDHUP | POLLIN;
   if (!out_tmp->AsyncWait(port, events, out_key)) {
     return false;
   }
   if (!err_tmp->AsyncWait(port, events, err_key)) {
     return false;
   }
   if (!exit_tmp->AsyncWait(port, events, exit_key)) {
     return false;
   }
   while ((out_tmp != NULL) || (err_tmp != NULL) || (exit_tmp != NULL)) {
     mx_port_packet_t pkt;
     status =
         mx_port_wait(port, MX_TIME_INFINITE, reinterpret_cast<void*>(&pkt), 0);
     if (status != MX_OK) {
       Log::PrintErr("Process::Wait: mx_port_wait failed: %s\n",
                     mx_status_get_string(status));
       return false;
     }
     IOHandle* event_handle = reinterpret_cast<IOHandle*>(pkt.key);
     const intptr_t event_mask = event_handle->WaitEnd(pkt.signal.observed);
     if (event_handle == out_tmp) {
-      if ((event_mask & EPOLLIN) != 0) {
+      if ((event_mask & POLLIN) != 0) {
         const intptr_t avail = FDUtils::AvailableBytes(out_tmp->fd());
         if (!out_data.Read(out_tmp->fd(), avail)) {
           return false;
         }
       }
-      if ((event_mask & EPOLLRDHUP) != 0) {
+      if ((event_mask & POLLRDHUP) != 0) {
         out_tmp->CancelWait(port, out_key);
         out_tmp = NULL;
       }
     } else if (event_handle == err_tmp) {
-      if ((event_mask & EPOLLIN) != 0) {
+      if ((event_mask & POLLIN) != 0) {
         const intptr_t avail = FDUtils::AvailableBytes(err_tmp->fd());
         if (!err_data.Read(err_tmp->fd(), avail)) {
           return false;
         }
       }
-      if ((event_mask & EPOLLRDHUP) != 0) {
+      if ((event_mask & POLLRDHUP) != 0) {
         err_tmp->CancelWait(port, err_key);
         err_tmp = NULL;
       }
     } else if (event_handle == exit_tmp) {
-      if ((event_mask & EPOLLIN) != 0) {
+      if ((event_mask & POLLIN) != 0) {
         const intptr_t avail = FDUtils::AvailableBytes(exit_tmp->fd());
         if (avail == 8) {
           intptr_t b =
               NO_RETRY_EXPECTED(read(exit_tmp->fd(), exit_code_data.bytes, 8));
           if (b != 8) {
             return false;
           }
         }
       }
-      if ((event_mask & EPOLLRDHUP) != 0) {
+      if ((event_mask & POLLRDHUP) != 0) {
         exit_tmp->CancelWait(port, exit_key);
         exit_tmp = NULL;
       }
     } else {
       Log::PrintErr("Process::Wait: Unexpected wait key: %p\n", event_handle);
     }
     if (out_tmp != NULL) {
       if (!out_tmp->AsyncWait(port, events, out_key)) {
         return false;
       }
@@ skipping 285 matching lines @@
 }
 
 void Process::ClearSignalHandler(intptr_t signal) {}
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(HOST_OS_FUCHSIA)
 
 #endif  // !defined(DART_IO_DISABLED)