Use platform specific error type

Author: kchibisov

src/sources/timer/mod.rs

@@ -14,11 +14,6 @@ use std::time::{Duration, Instant};
 
 use crate::{EventSource, Poll, PostAction, Readiness, Token, TokenFactory};
 
-#[cfg(target_os = "linux")]
-mod timerfd;
-#[cfg(target_os = "linux")]
-use timerfd::{TimerScheduler, TimerSource};
-
 #[cfg(any(
     target_os = "dragonfly",
     target_os = "freebsd",
@@ -27,6 +22,8 @@ use timerfd::{TimerScheduler, TimerSource};
     target_os = "macos"
 ))]
 mod threaded;
+#[cfg(target_os = "linux")]
+mod timerfd;
 
 #[cfg(any(
     target_os = "dragonfly",
@@ -36,11 +33,23 @@ mod threaded;
     target_os = "macos"
 ))]
 use threaded::{TimerScheduler, TimerSource};
+#[cfg(target_os = "linux")]
+use timerfd::{TimerScheduler, TimerSource};
 
 /// An error arising from processing events for a timer.
 #[derive(thiserror::Error, Debug)]
-#[error(transparent)]
-pub struct TimerError(Box<dyn std::error::Error + Sync + Send>);
+#[error("{0}")]
+pub struct TimerError(
+    #[cfg(target_os = "linux")] std::io::Error,
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "macos"
+    ))]
+    crate::ping::PingError,
+);
 
 /// A Timer event source
 ///
@@ -146,21 +155,23 @@ impl<T> EventSource for Timer<T> {
             inner: self.inner.clone(),
         };
         let inner = &self.inner;
-        self.source.process_events(readiness, token, |(), &mut ()| {
-            loop {
-                let next_expired: Option<T> = {
-                    let mut guard = inner.lock().unwrap();
-                    guard.next_expired()
-                };
-                if let Some(val) = next_expired {
-                    callback(val, &mut handle);
-                } else {
-                    break;
+        self.source
+            .process_events(readiness, token, |(), &mut ()| {
+                loop {
+                    let next_expired: Option<T> = {
+                        let mut guard = inner.lock().unwrap();
+                        guard.next_expired()
+                    };
+                    if let Some(val) = next_expired {
+                        callback(val, &mut handle);
+                    } else {
+                        break;
+                    }
                 }
-            }
-            // now compute the next timeout and signal if necessary
-            inner.lock().unwrap().reschedule();
-        })
+                // now compute the next timeout and signal if necessary
+                inner.lock().unwrap().reschedule();
+            })
+            .map_err(TimerError)
     }
 
     fn register(&mut self, poll: &mut Poll, token_factory: &mut TokenFactory) -> crate::Result<()> {

src/sources/timer/threaded.rs

@@ -4,11 +4,9 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
 
-use crate::ping::{make_ping, Ping, PingSource};
+use crate::ping::{make_ping, Ping, PingError, PingSource};
 use crate::{EventSource, Poll, PostAction, Readiness, Token, TokenFactory};
 
-use super::TimerError;
-
 #[derive(Debug)]
 pub struct TimerSource {
     source: PingSource,
@@ -25,7 +23,7 @@ impl EventSource for TimerSource {
     type Event = ();
     type Metadata = ();
     type Ret = ();
-    type Error = TimerError;
+    type Error = PingError;
 
     fn process_events<C>(
         &mut self,
@@ -36,11 +34,9 @@ impl EventSource for TimerSource {
     where
         C: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,
     {
-        self.source
-            .process_events(readiness, token, |_, &mut _| {
-                callback((), &mut ());
-            })
-            .map_err(|err| TimerError(err.into()))
+        self.source.process_events(readiness, token, |_, &mut _| {
+            callback((), &mut ());
+        })
     }
 
     fn register(&mut self, poll: &mut Poll, token_factory: &mut TokenFactory) -> crate::Result<()> {

src/sources/timer/timerfd.rs

@@ -4,13 +4,11 @@ use std::os::unix::io::{AsRawFd, RawFd};
 use std::time::Instant;
 
 use nix::sys::time::TimeSpec;
-use nix::sys::timerfd::{self, Expiration, TimerFd, TimerSetTimeFlags};
+use nix::sys::timerfd::{ClockId, Expiration, TimerFd, TimerFlags, TimerSetTimeFlags};
 
 use crate::generic::Generic;
 use crate::{EventSource, Poll, PostAction, Readiness, Token, TokenFactory};
 
-use super::TimerError;
-
 #[derive(Debug)]
 pub struct TimerScheduler {
     current_deadline: Option<Instant>,
@@ -20,8 +18,8 @@ pub struct TimerScheduler {
 impl TimerScheduler {
     pub fn new() -> crate::Result<(Self, TimerSource)> {
         let timerfd = TimerFd::new(
-            timerfd::ClockId::CLOCK_MONOTONIC,
-            timerfd::TimerFlags::TFD_CLOEXEC,
+            ClockId::CLOCK_MONOTONIC,
+            TimerFlags::TFD_CLOEXEC | TimerFlags::TFD_NONBLOCK,
         )?;
 
         let source = TimerSource::new(&timerfd);
@@ -79,7 +77,7 @@ impl EventSource for TimerSource {
     type Event = ();
     type Metadata = ();
     type Ret = ();
-    type Error = TimerError;
+    type Error = std::io::Error;
 
     fn process_events<C>(
         &mut self,
@@ -90,12 +88,10 @@ impl EventSource for TimerSource {
     where
         C: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,
     {
-        self.source
-            .process_events(readiness, token, |_, &mut _| {
-                callback((), &mut ());
-                Ok(PostAction::Continue)
-            })
-            .map_err(|err| TimerError(err.into()))
+        self.source.process_events(readiness, token, |_, &mut _| {
+            callback((), &mut ());
+            Ok(PostAction::Continue)
+        })
     }
 
     fn register(&mut self, poll: &mut Poll, token_factory: &mut TokenFactory) -> crate::Result<()> {