diff --git a/.gitignore b/.gitignore
index ac1542720..6ebb15549 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+.idea/
 .cargo
 Cargo.lock
 target*
diff --git a/Cargo.toml b/Cargo.toml
index 8433f91ca..2c1ac636e 100644
--- a/Cargo.toml
+++ b/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"
 
diff --git a/src/io_source.rs b/src/io_source.rs
index 99623c116..06dc5e17e 100644
--- a/src/io_source.rs
+++ b/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())
     }
 }
 
diff --git a/src/macros.rs b/src/macros.rs
index f97f90911..c93573f01 100644
--- a/src/macros.rs
+++ b/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
+        )*
+    };
+}
diff --git a/src/net/mod.rs b/src/net/mod.rs
index 7d714ca00..796f79c21 100644
--- a/src/net/mod.rs
+++ b/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;
diff --git a/src/net/uds/mod.rs b/src/net/uds/mod.rs
index 6b4ffdc43..08806f150 100644
--- a/src/net/uds/mod.rs
+++ b/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;
diff --git a/src/poll.rs b/src/poll.rs
index 289d6686c..9f14d4a4b 100644
--- a/src/poll.rs
+++ b/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,7 +728,22 @@ 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()
@@ -705,7 +751,22 @@ impl AsRawFd for Registry {
 }
 
 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();
diff --git a/src/sys/unix/mod.rs b/src/sys/unix/mod.rs
index 231480a5d..f01ce8810 100644
--- a/src/sys/unix/mod.rs
+++ b/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;
     }
diff --git a/src/sys/unix/net.rs b/src/sys/unix/net.rs
index 78f1387b1..983ee9f42 100644
--- a/src/sys/unix/net.rs
+++ b/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")]
diff --git a/src/sys/unix/pipe.rs b/src/sys/unix/pipe.rs
index 7a95b9697..63ed6fea5 100644
--- a/src/sys/unix/pipe.rs
+++ b/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`");
 
diff --git a/src/sys/unix/selector/epoll.rs b/src/sys/unix/selector/epoll.rs
index 1256663da..0c0c8f13c 100644
--- a/src/sys/unix/selector/epoll.rs
+++ b/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),
diff --git a/src/sys/unix/selector/io_source/edge_triggered.rs b/src/sys/unix/selector/io_source/edge_triggered.rs
new file mode 100644
index 000000000..2cde390af
--- /dev/null
+++ b/src/sys/unix/selector/io_source/edge_triggered.rs
@@ -0,0 +1,104 @@
+use crate::sys::Selector;
+use crate::{Interest, Registry, Token};
+use std::io;
+use std::os::unix::io::RawFd;
+
+struct InternalState {
+    selector: Selector,
+    token: Token,
+    interests: Interest,
+    fd: RawFd,
+    is_registered: bool,
+}
+
+impl Drop for InternalState {
+    fn drop(&mut self) {
+        if self.is_registered {
+            let _ = self.selector.deregister(self.fd);
+        }
+    }
+}
+
+pub(crate) struct IoSourceState {
+    inner: Option<Box<InternalState>>,
+}
+
+impl IoSourceState {
+    pub fn new() -> IoSourceState {
+        IoSourceState { inner: None }
+    }
+
+    pub fn do_io<T, F, R>(&self, f: F, io: &T) -> io::Result<R>
+    where
+        F: FnOnce(&T) -> io::Result<R>,
+    {
+        let result = f(io);
+
+        if let Err(err) = &result {
+            if err.kind() == io::ErrorKind::WouldBlock {
+                self.inner.as_ref().map_or(Ok(()), |state| {
+                    state
+                        .selector
+                        .reregister(state.fd, state.token, state.interests)
+                })?;
+            }
+        }
+
+        result
+    }
+
+    pub fn register(
+        &mut self,
+        registry: &Registry,
+        token: Token,
+        interests: Interest,
+        fd: RawFd,
+    ) -> io::Result<()> {
+        if self.inner.is_some() {
+            Err(io::ErrorKind::AlreadyExists.into())
+        } else {
+            let selector = registry.selector().try_clone()?;
+
+            selector.register(fd, token, interests).map(move |()| {
+                let state = InternalState {
+                    selector,
+                    token,
+                    interests,
+                    fd,
+                    is_registered: true,
+                };
+
+                self.inner = Some(Box::new(state));
+            })
+        }
+    }
+
+    pub fn reregister(
+        &mut self,
+        registry: &Registry,
+        token: Token,
+        interests: Interest,
+        fd: RawFd,
+    ) -> io::Result<()> {
+        match self.inner.as_mut() {
+            Some(state) => registry
+                .selector()
+                .reregister(fd, token, interests)
+                .map(|()| {
+                    state.token = token;
+                    state.interests = interests;
+                }),
+            None => Err(io::ErrorKind::NotFound.into()),
+        }
+    }
+
+    pub fn deregister(&mut self, registry: &Registry, fd: RawFd) -> io::Result<()> {
+        if let Some(mut state) = self.inner.take() {
+            // Deregistration _may_ fail below, however, dropping the state would only
+            // do the same thing twice anyway
+            state.is_registered = false;
+        }
+
+        registry.selector().deregister(fd)
+    }
+}
diff --git a/src/sys/unix/selector/io_source/mod.rs b/src/sys/unix/selector/io_source/mod.rs
new file mode 100644
index 000000000..f6cd533e6
--- /dev/null
+++ b/src/sys/unix/selector/io_source/mod.rs
@@ -0,0 +1,11 @@
+cfg_epoll_selector! {
+    pub(super) mod stateless;
+}
+
+cfg_kqueue_selector! {
+    pub(super) mod stateless;
+}
+
+cfg_poll_selector! {
+    pub(super) mod edge_triggered;
+}
diff --git a/src/sys/unix/selector/io_source/stateless.rs b/src/sys/unix/selector/io_source/stateless.rs
new file mode 100644
index 000000000..dbf5bd71f
--- /dev/null
+++ b/src/sys/unix/selector/io_source/stateless.rs
@@ -0,0 +1,47 @@
+use crate::{Interest, Registry, Token};
+use std::io;
+use std::os::unix::io::RawFd;
+
+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)
+    }
+
+    pub fn register(
+        &mut self,
+        registry: &Registry,
+        token: Token,
+        interests: Interest,
+        fd: RawFd,
+    ) -> io::Result<()> {
+        // Pass through, we don't have any state
+        registry.selector().register(fd, token, interests)
+    }
+
+    pub fn reregister(
+        &mut self,
+        registry: &Registry,
+        token: Token,
+        interests: Interest,
+        fd: RawFd,
+    ) -> io::Result<()> {
+        // Pass through, we don't have any state
+        registry.selector().reregister(fd, token, interests)
+    }
+
+    pub fn deregister(&mut self, registry: &Registry, fd: RawFd) -> io::Result<()> {
+        // Pass through, we don't have any state
+        registry.selector().deregister(fd)
+    }
+}
diff --git a/src/sys/unix/selector/mod.rs b/src/sys/unix/selector/mod.rs
index 9ae4c1416..11bac1711 100644
--- a/src/sys/unix/selector/mod.rs
+++ b/src/sys/unix/selector/mod.rs
@@ -1,38 +1,24 @@
-#[cfg(any(
-    target_os = "android",
-    target_os = "illumos",
-    target_os = "linux",
-    target_os = "redox",
-))]
-mod epoll;
+cfg_io_source! {
+    mod io_source;
+}
 
-#[cfg(any(
-    target_os = "android",
-    target_os = "illumos",
-    target_os = "linux",
-    target_os = "redox",
-))]
-pub(crate) use self::epoll::{event, Event, Events, Selector};
+cfg_epoll_selector! {
+    mod epoll;
+    pub(crate) use self::epoll::{event, Event, Events, Selector};
+    pub(crate) use self::io_source::stateless::IoSourceState;
+}
 
-#[cfg(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd"
-))]
-mod kqueue;
+cfg_kqueue_selector! {
+    mod kqueue;
+    pub(crate) use self::kqueue::{event, Event, Events, Selector};
+    pub(crate) use self::io_source::stateless::IoSourceState;
+}
 
-#[cfg(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd"
-))]
-pub(crate) use self::kqueue::{event, Event, Events, Selector};
+cfg_poll_selector! {
+    mod poll;
+    pub(crate) use self::poll::{event, Event, Events, Selector};
+    pub(crate) use self::io_source::edge_triggered ::IoSourceState;
+}
 
 /// Lowest file descriptor used in `Selector::try_clone`.
 ///
@@ -42,4 +28,21 @@ pub(crate) use self::kqueue::{event, Event, Events, Selector};
 /// blindly assume this to be true, which means using any one of those a select
 /// could result in some interesting and unexpected errors. Avoid that by using
 /// an fd that doesn't have a pre-determined usage.
+// TODO: Compact this into a macro too (naming?)
+#[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")
+))]
 const LOWEST_FD: libc::c_int = 3;
diff --git a/src/sys/unix/selector/poll.rs b/src/sys/unix/selector/poll.rs
new file mode 100644
index 000000000..905724a76
--- /dev/null
+++ b/src/sys/unix/selector/poll.rs
@@ -0,0 +1,636 @@
+// This implementation is based on the one in the `polling` crate.
+// Thanks to https://github.com/Kestrer for the original implementation!
+
+use crate::{Interest, Token};
+use std::collections::HashMap;
+use std::convert::TryInto;
+use std::fmt::{Debug, Formatter};
+use std::os::unix::io::RawFd;
+#[cfg(debug_assertions)]
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{Arc, Condvar, Mutex};
+use std::time::{Duration, Instant};
+use std::{fmt, io};
+
+/// Unique id for use as `SelectorId`.
+#[cfg(debug_assertions)]
+static NEXT_ID: AtomicUsize = AtomicUsize::new(1);
+
+#[cfg(target_os = "espidf")]
+type NotifyType = u64;
+
+#[cfg(not(target_os = "espidf"))]
+type NotifyType = u8;
+
+#[derive(Debug)]
+pub struct Selector {
+    state: Arc<SelectorState>,
+    /// Whether this selector currently has an associated waker.
+    #[cfg(debug_assertions)]
+    has_waker: AtomicBool,
+}
+
+impl Selector {
+    pub fn new() -> io::Result<Selector> {
+        let state = SelectorState::new()?;
+
+        Ok(Selector {
+            state: Arc::new(state),
+            #[cfg(debug_assertions)]
+            has_waker: AtomicBool::new(false),
+        })
+    }
+
+    pub fn try_clone(&self) -> io::Result<Selector> {
+        let state = self.state.clone();
+
+        Ok(Selector {
+            state,
+            #[cfg(debug_assertions)]
+            has_waker: AtomicBool::new(false),
+        })
+    }
+
+    pub fn select(&self, events: &mut Events, timeout: Option<Duration>) -> io::Result<()> {
+        self.state.select(events, timeout)
+    }
+
+    pub fn register_waker_fd(&self, fd: RawFd, token: Token) -> io::Result<()> {
+        self.state.register_waker_fd(fd, token)
+    }
+
+    pub fn register(&self, fd: RawFd, token: Token, interests: Interest) -> io::Result<()> {
+        self.state.register(fd, token, interests)
+    }
+
+    pub fn reregister(&self, fd: RawFd, token: Token, interests: Interest) -> io::Result<()> {
+        self.state.reregister(fd, token, interests)
+    }
+
+    pub fn deregister(&self, fd: RawFd) -> io::Result<()> {
+        self.state.deregister(fd)
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn register_waker(&self) -> bool {
+        self.has_waker.swap(true, Ordering::AcqRel)
+    }
+}
+
+cfg_io_source! {
+    impl Selector {
+        #[cfg(debug_assertions)]
+        pub fn id(&self) -> usize {
+            self.state.id
+        }
+    }
+}
+
+/// Interface to poll.
+#[derive(Debug)]
+struct SelectorState {
+    /// File descriptors to poll.
+    fds: Mutex<Fds>,
+
+    /// File descriptors which will be removed before the next poll call.
+    ///
+    /// When a file descriptor is deregistered while a poll is running, we need to filter
+    /// out all removed descriptors after that poll is finished running.
+    pending_removal: Mutex<Vec<RawFd>>,
+
+    /// The file descriptor of the read half of the notify pipe. This is also stored as the first
+    /// file descriptor in `fds.poll_fds`.
+    notify_read: RawFd,
+    /// The file descriptor of the write half of the notify pipe.
+    ///
+    /// Data is written to this to wake up the current instance of `wait`, which can occur when the
+    /// user notifies it (in which case `notified` would have been set) or when an operation needs
+    /// to occur (in which case `waiting_operations` would have been incremented).
+    notify_write: RawFd,
+
+    /// The number of operations (`add`, `modify` or `delete`) that are currently waiting on the
+    /// mutex to become free. When this is nonzero, `wait` must be suspended until it reaches zero
+    /// again.
+    waiting_operations: AtomicUsize,
+    /// The condition variable that gets notified when `waiting_operations` reaches zero or
+    /// `notified` becomes true.
+    ///
+    /// This is used with the `fds` mutex.
+    operations_complete: Condvar,
+
+    /// This selectors id.
+    #[cfg(debug_assertions)]
+    id: usize,
+}
+
+/// The file descriptors to poll in a `Poller`.
+#[derive(Debug, Clone)]
+struct Fds {
+    /// The list of `pollfds` taken by poll.
+    ///
+    /// The first file descriptor is always present and is used to notify the poller. It is also
+    /// stored in `notify_read`.
+    poll_fds: Vec<PollFd>,
+    /// The map of each file descriptor to data associated with it. This does not include the file
+    /// descriptors `notify_read` or `notify_write`.
+    fd_data: HashMap<RawFd, FdData>,
+}
+
+/// Transparent wrapper around `libc::pollfd`, used to support `Debug` derives without adding the
+/// `extra_traits` feature of `libc`.
+#[repr(transparent)]
+#[derive(Clone)]
+struct PollFd(libc::pollfd);
+
+impl Debug for PollFd {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.debug_struct("pollfd")
+            .field("fd", &self.0.fd)
+            .field("events", &self.0.events)
+            .field("revents", &self.0.revents)
+            .finish()
+    }
+}
+
+/// Data associated with a file descriptor in a poller.
+#[derive(Debug, Clone)]
+struct FdData {
+    /// The index into `poll_fds` this file descriptor is.
+    poll_fds_index: usize,
+    /// The key of the `Event` associated with this file descriptor.
+    token: Token,
+    /// Indicates whether this is a waker fd which needs to be reset after becoming ready
+    is_waker: bool,
+}
+
+impl SelectorState {
+    pub fn new() -> io::Result<SelectorState> {
+        let notify_fds = Self::create_notify_fds()?;
+
+        Ok(Self {
+            fds: Mutex::new(Fds {
+                poll_fds: vec![PollFd(libc::pollfd {
+                    fd: notify_fds[0],
+                    events: libc::POLLRDNORM,
+                    revents: 0,
+                })],
+                fd_data: HashMap::new(),
+            }),
+            pending_removal: Mutex::new(Vec::new()),
+            notify_read: notify_fds[0],
+            notify_write: notify_fds[1],
+            waiting_operations: AtomicUsize::new(0),
+            operations_complete: Condvar::new(),
+            #[cfg(debug_assertions)]
+            id: NEXT_ID.fetch_add(1, Ordering::Relaxed),
+        })
+    }
+
+    fn create_notify_fds() -> io::Result<[libc::c_int; 2]> {
+        let mut notify_fd = [0, 0];
+
+        // Note that the eventfd() implementation in ESP-IDF deviates from the specification in the following ways:
+        // 1) The file descriptor is always in a non-blocking mode, as if EFD_NONBLOCK was passed as a flag;
+        //    passing EFD_NONBLOCK or calling fcntl(.., F_GETFL/F_SETFL) on the eventfd() file descriptor is not supported
+        // 2) It always returns the counter value, even if it is 0. This is contrary to the specification which mandates
+        //    that it should instead fail with EAGAIN
+        //
+        // (1) is not a problem for us, as we want the eventfd() file descriptor to be in a non-blocking mode anyway
+        // (2) is also not a problem, as long as we don't try to read the counter value in an endless loop when we detect being notified
+        #[cfg(target_os = "espidf")]
+        {
+            extern "C" {
+                fn eventfd(initval: libc::c_uint, flags: libc::c_int) -> libc::c_int;
+            }
+
+            let fd = unsafe { eventfd(0, 0) };
+            if fd == -1 {
+                // TODO: Switch back to syscall! once
+                // https://github.com/rust-lang/libc/pull/2864 is published
+                return Err(std::io::ErrorKind::Other.into());
+            }
+
+            notify_fd[0] = fd;
+            notify_fd[1] = fd;
+        }
+
+        #[cfg(not(target_os = "espidf"))]
+        {
+            syscall!(pipe(notify_fd.as_mut_ptr()))?;
+
+            // Put the reading side into non-blocking mode.
+            let notify_read_flags = syscall!(fcntl(notify_fd[0], libc::F_GETFL))?;
+
+            syscall!(fcntl(
+                notify_fd[0],
+                libc::F_SETFL,
+                notify_read_flags | libc::O_NONBLOCK
+            ))?;
+        }
+
+        Ok(notify_fd)
+    }
+
+    pub fn select(&self, events: &mut Events, timeout: Option<Duration>) -> io::Result<()> {
+        let deadline = timeout.map(|t| Instant::now() + t);
+
+        events.clear();
+
+        let mut fds = self.fds.lock().unwrap();
+
+        loop {
+            // Complete all current operations.
+            loop {
+                if self.waiting_operations.load(Ordering::SeqCst) == 0 {
+                    break;
+                }
+
+                fds = self.operations_complete.wait(fds).unwrap();
+            }
+
+            // Perform the poll.
+            log::trace!("Polling on {:?}", fds);
+            let num_events = poll(&mut fds.poll_fds, deadline)?;
+            if num_events == 0 && deadline.map(|v| v <= Instant::now()).unwrap_or(false) {
+                // timeout
+                return Ok(());
+            }
+
+            log::trace!("Poll finished: {:?}", fds);
+            let notified = fds.poll_fds[0].0.revents != 0;
+            let num_fd_events = if notified { num_events - 1 } else { num_events };
+
+            // Read all notifications.
+            if notified {
+                if self.notify_read != self.notify_write {
+                    // When using the `pipe` syscall, we have to read all accumulated notifications in the pipe.
+                    while syscall!(read(self.notify_read, &mut [0; 64] as *mut _ as *mut _, 64))
+                        .is_ok()
+                    {}
+                } else {
+                    // When using the `eventfd` syscall, it is OK to read just once, so as to clear the counter.
+                    // In fact, reading in a loop will result in an endless loop on the ESP-IDF
+                    // which is not following the specification strictly.
+                    let _ = self.pop_notification();
+                }
+            }
+
+            // We now check whether this poll was performed with descriptors which were pending
+            // for removal and filter out any matching.
+            let mut pending_removal_guard = self.pending_removal.lock().unwrap();
+            let pending_removal = std::mem::replace(pending_removal_guard.as_mut(), Vec::new());
+            drop(pending_removal_guard);
+
+            // Store the events if there were any.
+            if num_fd_events > 0 {
+                let fds = &mut *fds;
+
+                events.reserve(num_fd_events);
+                for fd_data in fds.fd_data.values_mut() {
+                    let PollFd(poll_fd) = &mut fds.poll_fds[fd_data.poll_fds_index];
+
+                    if pending_removal.contains(&poll_fd.fd) {
+                        // Fd was removed while poll was running
+                        continue;
+                    }
+
+                    if poll_fd.events == 0 {
+                        // We can get events even when we didn't ask for them.
+                        // This mainly happens when we have a HUP but did not ask for read nor for
+                        // write readiness.
+                        //
+                        // TODO: Can this cause busy loops?
+                        // continue;
+                    }
+
+                    if poll_fd.revents != 0 {
+                        // Store event
+                        events.push(Event {
+                            token: fd_data.token,
+                            events: poll_fd.revents,
+                        });
+
+                        if fd_data.is_waker {
+                            // Don't remove interests, instead tell the waker to reset itself
+                            crate::sys::Waker::reset_by_fd(poll_fd.fd)?;
+                        } else {
+                            // Remove the interest which just got triggered
+                            // the IoSourceState used with this selector will add back the interest
+                            // as soon as an WouldBlock I/O error occurred
+                            poll_fd.events &= !poll_fd.revents;
+                        }
+
+                        if events.len() == num_fd_events {
+                            break;
+                        }
+                    }
+                }
+
+                break;
+            }
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn register_waker_fd(&self, fd: RawFd, token: Token) -> io::Result<()> {
+        self.register_internal(fd, token, Interest::READABLE, true)
+    }
+
+    pub fn register(&self, fd: RawFd, token: Token, interests: Interest) -> io::Result<()> {
+        self.register_internal(fd, token, interests, false)
+    }
+
+    pub fn register_internal(
+        &self,
+        fd: RawFd,
+        token: Token,
+        interests: Interest,
+        is_waker: bool,
+    ) -> io::Result<()> {
+        if fd == self.notify_read || fd == self.notify_write {
+            return Err(io::Error::from(io::ErrorKind::InvalidInput));
+        }
+
+        // We must handle the unlikely case that the following order of operations happens:
+        //
+        // register(1 as RawFd)
+        // deregister(1 as RawFd)
+        // register(1 as RawFd)
+        // <poll happens>
+        //
+        // Fd's pending removal only get cleared when poll has been run. It is possible that
+        // between registering and deregistering and then _again_ registering the file descriptor
+        // poll never gets called, thus the fd stays stuck in the pending removal list.
+        //
+        // To avoid this scenario we remove an fd from pending removals when registering it.
+        let mut pending_removal = self.pending_removal.lock().unwrap();
+        if let Some(idx) = pending_removal.iter().position(|&pending| pending == fd) {
+            pending_removal.remove(idx);
+        }
+        drop(pending_removal);
+
+        self.modify_fds(|fds| {
+            if fds.fd_data.contains_key(&fd) {
+                return Err(io::Error::new(
+                    io::ErrorKind::AlreadyExists,
+                    "\
+                    same file descriptor registered twice for polling \
+                    (an old file descriptor might have been closed without deregistration)\
+                    ",
+                ));
+            }
+
+            let poll_fds_index = fds.poll_fds.len();
+            fds.fd_data.insert(
+                fd,
+                FdData {
+                    poll_fds_index,
+                    token,
+                    is_waker,
+                },
+            );
+
+            fds.poll_fds.push(PollFd(libc::pollfd {
+                fd,
+                events: interests_to_poll(interests),
+                revents: 0,
+            }));
+
+            Ok(())
+        })
+    }
+
+    pub fn reregister(&self, fd: RawFd, token: Token, interests: Interest) -> io::Result<()> {
+        self.modify_fds(|fds| {
+            let data = fds.fd_data.get_mut(&fd).ok_or(io::ErrorKind::NotFound)?;
+            data.token = token;
+            let poll_fds_index = data.poll_fds_index;
+            fds.poll_fds[poll_fds_index].0.events = interests_to_poll(interests);
+
+            Ok(())
+        })
+    }
+
+    pub fn deregister(&self, fd: RawFd) -> io::Result<()> {
+        let mut pending_removal = self.pending_removal.lock().unwrap();
+        pending_removal.push(fd);
+        drop(pending_removal);
+
+        self.modify_fds(|fds| {
+            let data = fds.fd_data.remove(&fd).ok_or(io::ErrorKind::NotFound)?;
+            fds.poll_fds.swap_remove(data.poll_fds_index);
+            if let Some(swapped_pollfd) = fds.poll_fds.get(data.poll_fds_index) {
+                fds.fd_data
+                    .get_mut(&swapped_pollfd.0.fd)
+                    .unwrap()
+                    .poll_fds_index = data.poll_fds_index;
+            }
+
+            Ok(())
+        })
+    }
+
+    /// Perform a modification on `fds`, interrupting the current caller of `wait` if it's running.
+    fn modify_fds<T>(&self, f: impl FnOnce(&mut Fds) -> io::Result<T>) -> io::Result<T> {
+        self.waiting_operations.fetch_add(1, Ordering::SeqCst);
+
+        // Wake up the current caller of `wait` if there is one.
+        let sent_notification = self.notify_inner().is_ok();
+
+        let mut fds = self.fds.lock().unwrap();
+
+        // If there was no caller of `wait` our notification was not removed from the pipe.
+        if sent_notification {
+            let _ = self.pop_notification();
+        }
+
+        let res = f(&mut *fds);
+
+        if self.waiting_operations.fetch_sub(1, Ordering::SeqCst) == 1 {
+            self.operations_complete.notify_one();
+        }
+
+        res
+    }
+
+    /// Wake the current thread that is calling `wait`.
+    fn notify_inner(&self) -> io::Result<()> {
+        syscall!(write(
+            self.notify_write,
+            &(1 as NotifyType) as *const _ as *const _,
+            std::mem::size_of::<NotifyType>()
+        ))?;
+        Ok(())
+    }
+
+    /// Remove a notification created by `notify_inner`.
+    fn pop_notification(&self) -> io::Result<()> {
+        syscall!(read(
+            self.notify_read,
+            &mut [0; std::mem::size_of::<NotifyType>()] as *mut _ as *mut _,
+            std::mem::size_of::<NotifyType>()
+        ))?;
+        Ok(())
+    }
+}
+
+impl Drop for SelectorState {
+    fn drop(&mut self) {
+        let _ = syscall!(close(self.notify_read));
+
+        if self.notify_read != self.notify_write {
+            let _ = syscall!(close(self.notify_write));
+        }
+    }
+}
+
+#[cfg(not(target_os = "haiku"))]
+const READ_EVENTS: libc::c_short = libc::POLLIN | libc::POLLRDHUP;
+#[cfg(target_os = "haiku")]
+const READ_EVENTS: libc::c_short = libc::POLLIN;
+
+const WRITE_EVENTS: libc::c_short = libc::POLLOUT;
+
+/// Get the input poll events for the given event.
+fn interests_to_poll(interest: Interest) -> libc::c_short {
+    let mut kind = 0;
+
+    if interest.is_readable() {
+        kind |= READ_EVENTS;
+    }
+
+    if interest.is_writable() {
+        kind |= WRITE_EVENTS;
+    }
+
+    kind
+}
+
+/// Helper function to call poll.
+fn poll(fds: &mut [PollFd], deadline: Option<Instant>) -> io::Result<usize> {
+    loop {
+        // Convert the timeout to milliseconds.
+        let timeout_ms = deadline
+            .map(|deadline| {
+                let timeout = deadline.saturating_duration_since(Instant::now());
+
+                // Round up to a whole millisecond.
+                let mut ms = timeout.as_millis().try_into().unwrap_or(u64::MAX);
+                if Duration::from_millis(ms) < timeout {
+                    ms = ms.saturating_add(1);
+                }
+                ms.try_into().unwrap_or(i32::MAX)
+            })
+            .unwrap_or(-1);
+
+        let res = syscall!(poll(
+            fds.as_mut_ptr() as *mut libc::pollfd,
+            fds.len() as libc::nfds_t,
+            timeout_ms,
+        ));
+
+        match res {
+            Ok(num_events) => break Ok(num_events as usize),
+            // poll returns EAGAIN if we can retry it.
+            Err(e) if e.raw_os_error() == Some(libc::EAGAIN) => continue,
+            Err(e) => return Err(e),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Event {
+    token: Token,
+    events: libc::c_short,
+}
+
+pub type Events = Vec<Event>;
+
+pub mod event {
+    use crate::sys::Event;
+    use crate::Token;
+    use std::fmt;
+
+    pub fn token(event: &Event) -> Token {
+        event.token
+    }
+
+    pub fn is_readable(event: &Event) -> bool {
+        (event.events & libc::POLLIN) != 0 || (event.events & libc::POLLPRI) != 0
+    }
+
+    pub fn is_writable(event: &Event) -> bool {
+        (event.events & libc::POLLOUT) != 0
+    }
+
+    pub fn is_error(event: &Event) -> bool {
+        (event.events & libc::POLLERR) != 0
+    }
+
+    #[cfg(not(target_os = "haiku"))]
+    pub fn is_read_closed(event: &Event) -> bool {
+        // Both halves of the socket have closed
+        (event.events & libc::POLLHUP) != 0
+            // Socket has received FIN or called shutdown(SHUT_RD)
+            || (event.events & libc::POLLRDHUP) != 0
+    }
+
+    #[cfg(target_os = "haiku")]
+    pub fn is_read_closed(event: &Event) -> bool {
+        event.events & libc::POLLHUP != 0
+    }
+
+    pub fn is_write_closed(event: &Event) -> bool {
+        // Both halves of the socket have closed
+        (event.events & libc::POLLHUP) != 0
+            // Unix pipe write end has closed
+            || ((event.events & libc::POLLOUT) != 0 && (event.events & libc::POLLERR) != 0)
+            // The other side (read end) of a Unix pipe has closed.
+            || (event.events == libc::POLLERR)
+    }
+
+    pub fn is_priority(event: &Event) -> bool {
+        (event.events & libc::POLLPRI) != 0
+    }
+
+    pub fn is_aio(_: &Event) -> bool {
+        // Not supported in the kernel, only in libc.
+        false
+    }
+
+    pub fn is_lio(_: &Event) -> bool {
+        // Not supported.
+        false
+    }
+
+    pub fn debug_details(f: &mut fmt::Formatter<'_>, event: &Event) -> fmt::Result {
+        #[allow(clippy::trivially_copy_pass_by_ref)]
+        fn check_events(got: &libc::c_short, want: &libc::c_short) -> bool {
+            (*got & want) != 0
+        }
+        debug_detail!(
+            EventsDetails(libc::c_short),
+            check_events,
+            libc::POLLIN,
+            libc::POLLPRI,
+            libc::POLLOUT,
+            libc::POLLRDNORM,
+            libc::POLLRDBAND,
+            libc::POLLWRNORM,
+            libc::POLLWRBAND,
+            libc::POLLERR,
+            libc::POLLHUP,
+            #[cfg(not(target_os = "haiku"))]
+            libc::POLLRDHUP,
+        );
+
+        // Can't reference fields in packed structures.
+        let e_u64 = event.token.0;
+        f.debug_struct("epoll_event")
+            .field("events", &EventsDetails(event.events))
+            .field("u64", &e_u64)
+            .finish()
+    }
+}
diff --git a/src/sys/unix/tcp.rs b/src/sys/unix/tcp.rs
index c4d7e9469..27f68365d 100644
--- a/src/sys/unix/tcp.rs
+++ b/src/sys/unix/tcp.rs
@@ -88,7 +88,8 @@ pub(crate) fn accept(listener: &net::TcpListener) -> io::Result<(net::TcpStream,
         all(target_arch = "x86", target_os = "android"),
         target_os = "ios",
         target_os = "macos",
-        target_os = "redox"
+        target_os = "redox",
+        target_os = "haiku",
     ))]
     let stream = {
         syscall!(accept(
diff --git a/src/sys/unix/uds/listener.rs b/src/sys/unix/uds/listener.rs
index 79bd14ee0..995b381c5 100644
--- a/src/sys/unix/uds/listener.rs
+++ b/src/sys/unix/uds/listener.rs
@@ -43,6 +43,7 @@ pub(crate) fn accept(listener: &net::UnixListener) -> io::Result<(UnixStream, So
         target_os = "macos",
         target_os = "netbsd",
         target_os = "redox",
+        target_os = "haiku",
         // Android x86's seccomp profile forbids calls to `accept4(2)`
         // See https://github.com/tokio-rs/mio/issues/1445 for details
         all(
@@ -66,6 +67,7 @@ pub(crate) fn accept(listener: &net::UnixListener) -> io::Result<(UnixStream, So
         target_os = "macos",
         target_os = "netbsd",
         target_os = "redox",
+        target_os = "haiku",
         all(target_arch = "x86", target_os = "android")
     ))]
     let socket = syscall!(accept(
@@ -77,11 +79,7 @@ pub(crate) fn accept(listener: &net::UnixListener) -> io::Result<(UnixStream, So
         // Ensure the socket is closed if either of the `fcntl` calls
         // error below.
         let s = unsafe { net::UnixStream::from_raw_fd(socket) };
-        syscall!(fcntl(socket, libc::F_SETFD, libc::FD_CLOEXEC))?;
-
-        // See https://github.com/tokio-rs/mio/issues/1450
-        #[cfg(all(target_arch = "x86", target_os = "android"))]
-        syscall!(fcntl(socket, libc::F_SETFL, libc::O_NONBLOCK))?;
+        syscall!(fcntl(socket, libc::F_SETFD, libc::FD_CLOEXEC | libc::O_NONBLOCK))?;
 
         Ok(s)
     });
diff --git a/src/sys/unix/uds/mod.rs b/src/sys/unix/uds/mod.rs
index 526bbdfd0..024481a6c 100644
--- a/src/sys/unix/uds/mod.rs
+++ b/src/sys/unix/uds/mod.rs
@@ -20,6 +20,7 @@ cfg_os_poll! {
     use std::path::Path;
     use std::{io, mem};
 
+    #[cfg(not(target_os = "haiku"))]
     pub(crate) mod datagram;
     pub(crate) mod listener;
     pub(crate) mod stream;
@@ -77,25 +78,23 @@ cfg_os_poll! {
     fn pair<T>(flags: libc::c_int) -> io::Result<(T, T)>
         where T: FromRawFd,
     {
-        #[cfg(not(any(target_os = "ios", target_os = "macos")))]
+        #[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "haiku")))]
         let flags = flags | libc::SOCK_NONBLOCK | libc::SOCK_CLOEXEC;
 
         let mut fds = [-1; 2];
         syscall!(socketpair(libc::AF_UNIX, flags, 0, fds.as_mut_ptr()))?;
         let pair = unsafe { (T::from_raw_fd(fds[0]), T::from_raw_fd(fds[1])) };
 
-        // Darwin doesn't have SOCK_NONBLOCK or SOCK_CLOEXEC.
+        // Darwin nor Haiku have SOCK_NONBLOCK or SOCK_CLOEXEC.
         //
         // In order to set those flags, additional `fcntl` sys calls must be
         // performed. If a `fnctl` fails after the sockets have been created,
         // the file descriptors will leak. Creating `pair` above ensures that if
         // there is an error, the file descriptors are closed.
-        #[cfg(any(target_os = "ios", target_os = "macos"))]
+        #[cfg(any(target_os = "ios", target_os = "macos", target_os = "haiku"))]
         {
-            syscall!(fcntl(fds[0], libc::F_SETFL, libc::O_NONBLOCK))?;
-            syscall!(fcntl(fds[0], libc::F_SETFD, libc::FD_CLOEXEC))?;
-            syscall!(fcntl(fds[1], libc::F_SETFL, libc::O_NONBLOCK))?;
-            syscall!(fcntl(fds[1], libc::F_SETFD, libc::FD_CLOEXEC))?;
+            syscall!(fcntl(fds[0], libc::F_SETFD, libc::FD_CLOEXEC | libc::O_NONBLOCK))?;
+            syscall!(fcntl(fds[1], libc::F_SETFL, libc::FD_CLOEXEC | libc::O_NONBLOCK))?;
         }
         Ok(pair)
     }
diff --git a/src/sys/unix/waker.rs b/src/sys/unix/waker.rs
index de88e3181..f46537b57 100644
--- a/src/sys/unix/waker.rs
+++ b/src/sys/unix/waker.rs
@@ -1,11 +1,12 @@
 #[cfg(any(target_os = "linux", target_os = "android"))]
 mod eventfd {
     use crate::sys::Selector;
-    use crate::{Interest, Token};
+    use crate::Token;
 
     use std::fs::File;
     use std::io::{self, Read, Write};
-    use std::os::unix::io::FromRawFd;
+    use std::mem::ManuallyDrop;
+    use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
 
     /// Waker backed by `eventfd`.
     ///
@@ -16,17 +17,20 @@ mod eventfd {
     #[derive(Debug)]
     pub struct Waker {
         fd: File,
+        selector: Selector,
     }
 
     impl Waker {
         pub fn new(selector: &Selector, token: Token) -> io::Result<Waker> {
+            let selector = selector.try_clone()?;
+
             syscall!(eventfd(0, libc::EFD_CLOEXEC | libc::EFD_NONBLOCK)).and_then(|fd| {
                 // Turn the file descriptor into a file first so we're ensured
                 // it's closed when dropped, e.g. when register below fails.
                 let file = unsafe { File::from_raw_fd(fd) };
                 selector
-                    .register(fd, token, Interest::READABLE)
-                    .map(|()| Waker { fd: file })
+                    .register_waker_fd(fd, token)
+                    .map(|()| Waker { fd: file, selector })
             })
         }
 
@@ -44,10 +48,17 @@ mod eventfd {
             }
         }
 
-        /// Reset the eventfd object, only need to call this if `wake` fails.
+        /// Reset the eventfd object
         fn reset(&self) -> io::Result<()> {
+            Self::reset_by_fd(self.fd.as_raw_fd())
+        }
+
+        /// Reset the eventfd object
+        pub(crate) fn reset_by_fd(fd: RawFd) -> io::Result<()> {
+            let mut file = ManuallyDrop::new(unsafe { File::from_raw_fd(fd) });
+
             let mut buf: [u8; 8] = 0u64.to_ne_bytes();
-            match (&self.fd).read(&mut buf) {
+            match file.read(&mut buf) {
                 Ok(_) => Ok(()),
                 // If the `Waker` hasn't been awoken yet this will return a
                 // `WouldBlock` error which we can safely ignore.
@@ -56,6 +67,12 @@ mod eventfd {
             }
         }
     }
+
+    impl Drop for Waker {
+        fn drop(&mut self) {
+            let _ = self.selector.deregister(self.fd.as_raw_fd());
+        }
+    }
 }
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -92,6 +109,11 @@ mod kqueue {
         pub fn wake(&self) -> io::Result<()> {
             self.selector.wake(self.token)
         }
+
+        pub(crate) fn reset_by_fd(fd: RawFd) -> io::Result<()> {
+            // No-op for kqueue
+            Ok(())
+        }
     }
 }
 
@@ -104,14 +126,16 @@ pub use self::kqueue::Waker;
     target_os = "netbsd",
     target_os = "openbsd",
     target_os = "redox",
+    target_os = "haiku",
 ))]
 mod pipe {
     use crate::sys::unix::Selector;
-    use crate::{Interest, Token};
+    use crate::Token;
 
     use std::fs::File;
     use std::io::{self, Read, Write};
-    use std::os::unix::io::FromRawFd;
+    use std::mem::ManuallyDrop;
+    use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
 
     /// Waker backed by a unix pipe.
     ///
@@ -121,19 +145,46 @@ mod pipe {
     pub struct Waker {
         sender: File,
         receiver: File,
+        selector: Selector,
     }
 
     impl Waker {
         pub fn new(selector: &Selector, token: Token) -> io::Result<Waker> {
+            let selector = selector.try_clone()?;
+
             let mut fds = [-1; 2];
-            syscall!(pipe2(fds.as_mut_ptr(), libc::O_NONBLOCK | libc::O_CLOEXEC))?;
+
+            #[cfg(not(target_os = "haiku"))]
+            {
+                syscall!(pipe2(fds.as_mut_ptr(), libc::O_NONBLOCK | libc::O_CLOEXEC))?;
+            }
+
+            #[cfg(target_os = "haiku")]
+            {
+                // Haiku does not have `pipe2(2)`, manually set nonblocking
+                syscall!(pipe(fds.as_mut_ptr()))?;
+
+                for fd in &fds {
+                    unsafe {
+                        if libc::fcntl(*fd, libc::F_SETFL, libc::O_NONBLOCK | libc::FD_CLOEXEC) != 0
+                        {
+                            let err = io::Error::last_os_error();
+                            let _ = libc::close(fds[0]);
+                            let _ = libc::close(fds[1]);
+                            return Err(err);
+                        }
+                    }
+                }
+            }
             // Turn the file descriptors into files first so we're ensured
             // they're closed when dropped, e.g. when register below fails.
             let sender = unsafe { File::from_raw_fd(fds[1]) };
             let receiver = unsafe { File::from_raw_fd(fds[0]) };
-            selector
-                .register(fds[0], token, Interest::READABLE)
-                .map(|()| Waker { sender, receiver })
+            selector.register_waker_fd(fds[0], token).map(|()| Waker {
+                sender,
+                receiver,
+                selector,
+            })
         }
 
         pub fn wake(&self) -> io::Result<()> {
@@ -148,7 +199,7 @@ mod pipe {
                 Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => {
                     // The reading end is full so we'll empty the buffer and try
                     // again.
-                    self.empty();
+                    self.reset();
                     self.wake()
                 }
                 Err(ref err) if err.kind() == io::ErrorKind::Interrupted => self.wake(),
@@ -156,18 +207,30 @@ mod pipe {
             }
         }
 
-        /// Empty the pipe's buffer, only need to call this if `wake` fails.
+        fn reset(&self) {
+            let _ = Self::reset_by_fd(self.receiver.as_raw_fd());
+        }
+
+        /// Empty the pipe's buffer.
         /// This ignores any errors.
-        fn empty(&self) {
+        pub(crate) fn reset_by_fd(fd: RawFd) -> io::Result<()> {
+            let mut file = ManuallyDrop::new(unsafe { File::from_raw_fd(fd) });
+
             let mut buf = [0; 4096];
             loop {
-                match (&self.receiver).read(&mut buf) {
+                match file.read(&mut buf) {
                     Ok(n) if n > 0 => continue,
-                    _ => return,
+                    _ => return Ok(()),
                 }
             }
         }
     }
+
+    impl Drop for Waker {
+        fn drop(&mut self) {
+            let _ = self.selector.deregister(self.receiver.as_raw_fd());
+        }
+    }
 }
 
 #[cfg(any(
@@ -176,5 +239,6 @@ mod pipe {
     target_os = "netbsd",
     target_os = "openbsd",
     target_os = "redox",
+    target_os = "haiku",
 ))]
 pub use self::pipe::Waker;
diff --git a/tests/regressions.rs b/tests/regressions.rs
index 0e3e5a9d8..5a3028253 100644
--- a/tests/regressions.rs
+++ b/tests/regressions.rs
@@ -107,7 +107,7 @@ fn issue_1205() {
 }
 
 #[test]
-#[cfg(unix)]
+#[cfg(all(unix, not(target_os = "haiku")))]
 fn issue_1403() {
     use mio::net::UnixDatagram;
     use util::temp_file;
diff --git a/tests/tcp_stream.rs b/tests/tcp_stream.rs
index a2288a173..b0842aaa0 100644
--- a/tests/tcp_stream.rs
+++ b/tests/tcp_stream.rs
@@ -639,14 +639,13 @@ fn tcp_reset_close_event() {
         vec![ExpectEvent::new(ID1, Readiness::READ_CLOSED)],
     );
 
-    // Make sure we quiesce. `expect_no_events` seems to flake sometimes on mac/freebsd.
-    loop {
-        poll.poll(&mut events, Some(Duration::from_millis(100)))
-            .expect("poll failed");
-        if events.iter().count() == 0 {
-            break;
-        }
-    }
+    // Something weird is going on here. Linux keeps emitting HUP, so even though everything is
+    // closed down you still get events. In the linux kernel source there is a comment stating
+    // that EPOLLHUP is not done correctly (see net/ipv4/tcp.c, v6.0-rc7 tcp_poll) and other flaky
+    // things are going on.
+    // TODO: investigate what exactly is going on here and why a loop expecting no more events
+    //       ever worked (linux documentation says that HUP is not maskable and causes poll to
+    //       always return, no exceptions)
 }
 
 #[test]
diff --git a/tests/unix_datagram.rs b/tests/unix_datagram.rs
index 7c4b01f14..48a8e0bf5 100644
--- a/tests/unix_datagram.rs
+++ b/tests/unix_datagram.rs
@@ -1,4 +1,4 @@
-#![cfg(all(unix, feature = "os-poll", feature = "net"))]
+#![cfg(all(unix, not(target_os = "haiku"), feature = "os-poll", feature = "net"))]
 
 use mio::net::UnixDatagram;
 use mio::{Interest, Token};
diff --git a/tests/unix_stream.rs b/tests/unix_stream.rs
index 79b7c3d4b..0403ec4de 100644
--- a/tests/unix_stream.rs
+++ b/tests/unix_stream.rs
@@ -2,7 +2,7 @@
 
 use mio::net::UnixStream;
 use mio::{Interest, Token};
-use std::io::{self, IoSlice, IoSliceMut, Read, Write};
+use std::io::{self, ErrorKind, IoSlice, IoSliceMut, Read, Write};
 use std::net::Shutdown;
 use std::os::unix::net;
 use std::path::Path;
@@ -442,6 +442,11 @@ where
     );
 
     expect_read!(stream.read(&mut buf), DATA1);
+    // mio can only guarantee further readiness events when WouldBlock is returned
+    assert_eq!(
+        stream.read(&mut buf).map_err(|err| err.kind()).err(),
+        Some(ErrorKind::WouldBlock)
+    );
 
     assert!(stream.take_error().unwrap().is_none());