Initial support for poll-based backend

.github/workflows/ci.yml

@@ -31,6 +31,18 @@ jobs:
       run: cargo test --all-features
     - name: Tests release build
       run: cargo test --release --all-features
+  TestPoll:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    env:
+      RUSTFLAGS: "--cfg mio_unsupported_force_poll_poll"
+    steps:
+    - uses: actions/checkout@v3
+    - uses: dtolnay/rust-toolchain@stable
+    - name: Tests
+      run: cargo test --all-features
+    - name: Tests release build
+      run: cargo test --release --all-features
   MinimalVersions:
     runs-on: ${{ matrix.os }}
     timeout-minutes: 10
@@ -133,6 +145,7 @@ jobs:
     runs-on: ubuntu-latest
     needs:
       - Test
+      - TestPoll
       - MinimalVersions
       - MSRV
       - Nightly

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/poll.rs

@@ -1,5 +1,5 @@
 use crate::{event, sys, Events, Interest, Token};
-#[cfg(unix)]
+#[cfg(all(unix, not(mio_unsupported_force_poll_poll)))]
 use std::os::unix::io::{AsRawFd, RawFd};
 use std::time::Duration;
 use std::{fmt, io};
@@ -411,7 +411,7 @@ impl Poll {
     }
 }
 
-#[cfg(unix)]
+#[cfg(all(unix, not(mio_unsupported_force_poll_poll)))]
 impl AsRawFd for Poll {
     fn as_raw_fd(&self) -> RawFd {
         self.registry.as_raw_fd()
@@ -696,15 +696,18 @@ impl fmt::Debug for Registry {
     }
 }
 
-#[cfg(unix)]
+#[cfg(all(unix, not(mio_unsupported_force_poll_poll)))]
 impl AsRawFd for Registry {
     fn as_raw_fd(&self) -> RawFd {
         self.selector.as_raw_fd()
     }
 }
 
 cfg_os_poll! {
-    #[cfg(unix)]
+    #[cfg(all(
+        unix,
+        not(mio_unsupported_force_poll_poll)
+    ))]
     #[test]
     pub fn as_raw_fd() {
         let poll = Poll::new().unwrap();

src/sys/shell/mod.rs

@@ -23,8 +23,10 @@ cfg_io_source! {
     use std::io;
     #[cfg(windows)]
     use std::os::windows::io::RawSocket;
+    #[cfg(unix)]
+    use std::os::unix::io::RawFd;
 
-    #[cfg(windows)]
+    #[cfg(any(windows, unix))]
     use crate::{Registry, Token, Interest};
 
     pub(crate) struct IoSourceState;
@@ -44,6 +46,33 @@ cfg_io_source! {
         }
     }
 
+    #[cfg(unix)]
+    impl IoSourceState {
+        pub fn register(
+            &mut self,
+            _: &Registry,
+            _: Token,
+            _: Interest,
+            _: RawFd,
+        ) -> io::Result<()> {
+            os_required!()
+        }
+
+        pub fn reregister(
+            &mut self,
+            _: &Registry,
+            _: Token,
+            _: Interest,
+            _: RawFd,
+        ) -> io::Result<()> {
+           os_required!()
+        }
+
+        pub fn deregister(&mut self, _: &Registry, _: RawFd) -> io::Result<()> {
+            os_required!()
+        }
+    }
+
     #[cfg(windows)]
     impl IoSourceState {
          pub fn register(

src/sys/unix/mod.rs

@@ -33,25 +33,65 @@ cfg_os_poll! {
     }
 
     cfg_io_source! {
-        use std::io;
-
         // Both `kqueue` and `epoll` don't need to hold any user space state.
-        pub(crate) struct IoSourceState;
+        #[cfg(not(mio_unsupported_force_poll_poll))]
+        mod stateless_io_source {
+            use std::io;
+            use std::os::unix::io::RawFd;
+            use crate::Registry;
+            use crate::Token;
+            use crate::Interest;
 
-        impl IoSourceState {
-            pub fn new() -> IoSourceState {
-                IoSourceState
-            }
+            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 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)
+                }
             }
         }
+
+        #[cfg(not(mio_unsupported_force_poll_poll))]
+        pub(crate) use self::stateless_io_source::IoSourceState;
+
+        #[cfg(mio_unsupported_force_poll_poll)]
+        pub(crate) use self::selector::IoSourceState;
     }
 
     cfg_os_ext! {

src/sys/unix/selector/mod.rs

@@ -1,40 +1,58 @@
-#[cfg(any(
-    target_os = "android",
-    target_os = "illumos",
-    target_os = "linux",
-    target_os = "redox",
+#[cfg(all(
+    not(mio_unsupported_force_poll_poll),
+    any(
+        target_os = "android",
+        target_os = "illumos",
+        target_os = "linux",
+        target_os = "redox",
+    )
 ))]
 mod epoll;
 
-#[cfg(any(
-    target_os = "android",
-    target_os = "illumos",
-    target_os = "linux",
-    target_os = "redox",
+#[cfg(all(
+    not(mio_unsupported_force_poll_poll),
+    any(
+        target_os = "android",
+        target_os = "illumos",
+        target_os = "linux",
+        target_os = "redox",
+    )
 ))]
 pub(crate) use self::epoll::{event, Event, Events, Selector};
 
-#[cfg(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "tvos",
-    target_os = "watchos",
+#[cfg(mio_unsupported_force_poll_poll)]
+mod poll;
+
+#[cfg(mio_unsupported_force_poll_poll)]
+pub(crate) use self::poll::{event, Event, Events, IoSourceState, Selector};
+
+#[cfg(all(
+    not(mio_unsupported_force_poll_poll),
+    any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "tvos",
+        target_os = "watchos",
+    )
 ))]
 mod kqueue;
 
-#[cfg(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "tvos",
-    target_os = "watchos",
+#[cfg(all(
+    not(mio_unsupported_force_poll_poll),
+    any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "tvos",
+        target_os = "watchos",
+    ),
 ))]
 pub(crate) use self::kqueue::{event, Event, Events, Selector};