Poll selector

.gitignore

@@ -1,3 +1,4 @@
+.idea/
 .cargo
 Cargo.lock
 target*

Cargo.toml

@@ -42,6 +42,10 @@ os-ext = [
 # Enables `mio::net` module containing networking primitives.
 net = []
 
+# Forces the use of the poll system call instead of epoll on systems
+# where both are available
+force-old-poll = ["os-poll"]
+
 [dependencies]
 log = "0.4.8"
 

src/io_source.rs

@@ -142,9 +142,8 @@ where
     ) -> io::Result<()> {
         #[cfg(debug_assertions)]
         self.selector_id.associate(registry)?;
-        registry
-            .selector()
-            .register(self.inner.as_raw_fd(), token, interests)
+        self.state
+            .register(registry, token, interests, self.inner.as_raw_fd())
     }
 
     fn reregister(
@@ -155,15 +154,14 @@ where
     ) -> io::Result<()> {
         #[cfg(debug_assertions)]
         self.selector_id.check_association(registry)?;
-        registry
-            .selector()
-            .reregister(self.inner.as_raw_fd(), token, interests)
+        self.state
+            .reregister(registry, token, interests, self.inner.as_raw_fd())
     }
 
     fn deregister(&mut self, registry: &Registry) -> io::Result<()> {
         #[cfg(debug_assertions)]
         self.selector_id.remove_association(registry)?;
-        registry.selector().deregister(self.inner.as_raw_fd())
+        self.state.deregister(registry, self.inner.as_raw_fd())
     }
 }
 

src/macros.rs

@@ -68,3 +68,76 @@ macro_rules! cfg_any_os_ext {
         )*
     }
 }
+
+/// The `os-poll` feature or one feature that requires is is enabled and the system
+/// supports epoll.
+macro_rules! cfg_epoll_selector {
+    ($($item:item)*) => {
+        $(
+            #[cfg(all(
+                any(feature = "os-poll", feature = "net"),
+                any(
+                    target_os = "android",
+                    target_os = "illumos",
+                    target_os = "linux",
+                    target_os = "redox",
+                ),
+                not(feature = "force-old-poll")
+            ))]
+            $item
+        )*
+    };
+}
+
+/// The `os-poll` feature or one feature that requires is is enabled and the system
+/// supports kqueue.
+macro_rules! cfg_kqueue_selector {
+    ($($item:item)*) => {
+        $(
+            #[cfg(all(
+                any(feature = "os-poll", feature = "net"),
+                any(
+                    target_os = "dragonfly",
+                    target_os = "freebsd",
+                    target_os = "ios",
+                    target_os = "macos",
+                    target_os = "netbsd",
+                    target_os = "openbsd"
+                ),
+                not(feature = "force-old-poll")
+            ))]
+            $item
+        )*
+    };
+}
+
+/// The `os-poll` feature or one feature that requires is is enabled and the system
+/// is a generic unix which does not support epoll nor kqueue.
+macro_rules! cfg_poll_selector {
+    ($($item:item)*) => {
+        $(
+            #[cfg(
+                all(
+                    unix,
+                    any(feature = "os-poll", feature = "net"),
+                    any(
+                        not(any(
+                            target_os = "android",
+                            target_os = "illumos",
+                            target_os = "linux",
+                            target_os = "redox",
+                            target_os = "dragonfly",
+                            target_os = "freebsd",
+                            target_os = "ios",
+                            target_os = "macos",
+                            target_os = "netbsd",
+                            target_os = "openbsd"
+                        )),
+                        feature = "force-old-poll"
+                    )
+                )
+            )]
+            $item
+        )*
+    };
+}

src/net/mod.rs

@@ -36,4 +36,6 @@ pub use self::udp::UdpSocket;
 #[cfg(unix)]
 mod uds;
 #[cfg(unix)]
-pub use self::uds::{SocketAddr, UnixDatagram, UnixListener, UnixStream};
+pub use self::uds::{SocketAddr, UnixListener, UnixStream};
+#[cfg(all(unix, not(target_os = "haiku")))]
+pub use self::uds::UnixDatagram;

src/net/uds/mod.rs

@@ -1,4 +1,6 @@
+#[cfg(not(target_os = "haiku"))]
 mod datagram;
+#[cfg(not(target_os = "haiku"))]
 pub use self::datagram::UnixDatagram;
 
 mod listener;

src/poll.rs

@@ -1,10 +1,26 @@
 use crate::{event, sys, Events, Interest, Token};
 use log::trace;
-#[cfg(unix)]
-use std::os::unix::io::{AsRawFd, RawFd};
 use std::time::Duration;
 use std::{fmt, io};
 
+#[cfg(all(
+    unix,
+    any(
+        target_os = "android",
+        target_os = "illumos",
+        target_os = "linux",
+        target_os = "redox",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ),
+    not(feature = "force-old-poll")
+))]
+use std::os::unix::io::{AsRawFd, RawFd};
+
 /// Polls for readiness events on all registered values.
 ///
 /// `Poll` allows a program to monitor a large number of [`event::Source`]s,
@@ -412,7 +428,22 @@ impl Poll {
     }
 }
 
-#[cfg(unix)]
+#[cfg(all(
+    unix,
+    any(
+        target_os = "android",
+        target_os = "illumos",
+        target_os = "linux",
+        target_os = "redox",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ),
+    not(feature = "force-old-poll")
+))]
 impl AsRawFd for Poll {
     fn as_raw_fd(&self) -> RawFd {
         self.registry.as_raw_fd()
@@ -697,15 +728,45 @@ impl fmt::Debug for Registry {
     }
 }
 
-#[cfg(unix)]
+#[cfg(all(
+    unix,
+    any(
+        target_os = "android",
+        target_os = "illumos",
+        target_os = "linux",
+        target_os = "redox",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ),
+    not(feature = "force-old-poll")
+))]
 impl AsRawFd for Registry {
     fn as_raw_fd(&self) -> RawFd {
         self.selector.as_raw_fd()
     }
 }
 
 cfg_os_poll! {
-    #[cfg(unix)]
+    #[cfg(all(
+        unix,
+        any(
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "linux",
+            target_os = "redox",
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd"
+        ),
+        not(feature = "force-old-poll")
+    ))]
     #[test]
     pub fn as_raw_fd() {
         let poll = Poll::new().unwrap();

src/sys/unix/mod.rs

@@ -15,7 +15,7 @@ macro_rules! syscall {
 
 cfg_os_poll! {
     mod selector;
-    pub(crate) use self::selector::{event, Event, Events, Selector};
+    pub(crate) use self::selector::{event, Event, Events, Selector, IoSourceState};
 
     mod sourcefd;
     pub use self::sourcefd::SourceFd;
@@ -32,28 +32,6 @@ cfg_os_poll! {
         pub use self::uds::SocketAddr;
     }
 
-    cfg_io_source! {
-        use std::io;
-
-        // Both `kqueue` and `epoll` don't need to hold any user space state.
-        pub(crate) struct IoSourceState;
-
-        impl IoSourceState {
-            pub fn new() -> IoSourceState {
-                IoSourceState
-            }
-
-            pub fn do_io<T, F, R>(&self, f: F, io: &T) -> io::Result<R>
-            where
-                F: FnOnce(&T) -> io::Result<R>,
-            {
-                // We don't hold state, so we can just call the function and
-                // return.
-                f(io)
-            }
-        }
-    }
-
     cfg_os_ext! {
         pub(crate) mod pipe;
     }

src/sys/unix/net.rs

@@ -41,13 +41,13 @@ pub(crate) fn new_socket(domain: libc::c_int, socket_type: libc::c_int) -> io::R
         .map(|_| socket)
     });
 
-    // Darwin doesn't have SOCK_NONBLOCK or SOCK_CLOEXEC.
-    #[cfg(any(target_os = "ios", target_os = "macos"))]
+    // Darwin nor Haiku have SOCK_NONBLOCK or SOCK_CLOEXEC.
+    #[cfg(any(target_os = "ios", target_os = "macos", target_os = "haiku"))]
     let socket = socket.and_then(|socket| {
         // For platforms that don't support flags in socket, we need to
         // set the flags ourselves.
-        syscall!(fcntl(socket, libc::F_SETFL, libc::O_NONBLOCK))
-            .and_then(|_| syscall!(fcntl(socket, libc::F_SETFD, libc::FD_CLOEXEC)).map(|_| socket))
+        syscall!(fcntl(socket, libc::F_SETFL, libc::O_NONBLOCK | libc::FD_CLOEXEC))
+            .map(|_| socket)
             .map_err(|e| {
                 // If either of the `fcntl` calls failed, ensure the socket is
                 // closed and return the error.
@@ -89,14 +89,18 @@ pub(crate) fn socket_addr(addr: &SocketAddr) -> (SocketAddrCRepr, libc::socklen_
                 sin_family: libc::AF_INET as libc::sa_family_t,
                 sin_port: addr.port().to_be(),
                 sin_addr,
+                #[cfg(not(target_os = "haiku"))]
                 sin_zero: [0; 8],
+                #[cfg(target_os = "haiku")]
+                sin_zero: [0; 24],
                 #[cfg(any(
                     target_os = "dragonfly",
                     target_os = "freebsd",
                     target_os = "ios",
                     target_os = "macos",
                     target_os = "netbsd",
-                    target_os = "openbsd"
+                    target_os = "openbsd",
+                    target_os = "haiku",
                 ))]
                 sin_len: 0,
             };
@@ -120,7 +124,8 @@ pub(crate) fn socket_addr(addr: &SocketAddr) -> (SocketAddrCRepr, libc::socklen_
                     target_os = "ios",
                     target_os = "macos",
                     target_os = "netbsd",
-                    target_os = "openbsd"
+                    target_os = "openbsd",
+                    target_os = "haiku",
                 ))]
                 sin6_len: 0,
                 #[cfg(target_os = "illumos")]

src/sys/unix/pipe.rs

@@ -109,6 +109,7 @@ use crate::{event, Interest, Registry, Token};
 ///
 /// ```
 /// # use std::io;
+/// # use std::io::Read;
 /// #
 /// # use mio::{Poll, Events, Interest, Token};
 /// # use mio::unix::pipe;
@@ -138,6 +139,15 @@ use crate::{event, Interest, Registry, Token};
 ///             println!("Sender dropped!");
 ///             return Ok(());
 ///         },
+///         PIPE_RECV => {
+///             // Some platforms only signal a read readines event
+///             println!("Pipe is readable due to dropped sender!");
+///
+///             // Reading from a closed pipe always returns Ok(0)
+///             let mut buf = [0; 1];
+///             assert_eq!(receiver.read(&mut buf).ok(), Some(0));
+///             return Ok(());
+///         }
 ///         _ => unreachable!(),
 ///     }
 /// }
@@ -163,7 +173,7 @@ pub fn new() -> io::Result<(Sender, Receiver)> {
         }
     }
 
-    #[cfg(any(target_os = "ios", target_os = "macos"))]
+    #[cfg(any(target_os = "ios", target_os = "macos", target_os = "haiku"))]
     unsafe {
         // For platforms that don't have `pipe2(2)` we need to manually set the
         // correct flags on the file descriptor.
@@ -172,9 +182,7 @@ pub fn new() -> io::Result<(Sender, Receiver)> {
         }
 
         for fd in &fds {
-            if libc::fcntl(*fd, libc::F_SETFL, libc::O_NONBLOCK) != 0
-                || libc::fcntl(*fd, libc::F_SETFD, libc::FD_CLOEXEC) != 0
-            {
+            if libc::fcntl(*fd, libc::F_SETFL, libc::O_NONBLOCK | libc::FD_CLOEXEC) != 0 {
                 let err = io::Error::last_os_error();
                 // Don't leak file descriptors. Can't handle error though.
                 let _ = libc::close(fds[0]);
@@ -195,6 +203,7 @@ pub fn new() -> io::Result<(Sender, Receiver)> {
         target_os = "macos",
         target_os = "illumos",
         target_os = "redox",
+        target_os = "haiku",
     )))]
     compile_error!("unsupported target for `mio::unix::pipe`");
 

src/sys/unix/selector/epoll.rs

@@ -116,6 +116,11 @@ impl Selector {
         })
     }
 
+    pub(crate) fn register_waker_fd(&self, fd: RawFd, token: Token) -> io::Result<()> {
+        // No special handling required for epoll
+        self.register(fd, token, Interest::READABLE)
+    }
+
     pub fn register(&self, fd: RawFd, token: Token, interests: Interest) -> io::Result<()> {
         let mut event = libc::epoll_event {
             events: interests_to_epoll(interests),