Delete sys module

Author: Stjepan Glavina

src/lib.rs

@@ -32,7 +32,6 @@ use socket2::{Domain, Protocol, Socket, Type};
 use crate::parking::{Reactor, Source};
 
 pub mod parking;
-mod sys;
 
 /// Fires at the chosen point in time.
 ///

src/parking.rs

@@ -758,12 +758,9 @@ mod sys {
     use std::convert::TryInto;
     use std::io;
     use std::os::unix::io::RawFd;
+    use std::ptr;
     use std::time::Duration;
 
-    use crate::sys::epoll::{
-        epoll_create1, epoll_ctl, epoll_wait, EpollEvent, EpollFlags, EpollOp,
-    };
-
     macro_rules! syscall {
         ($fn:ident $args:tt) => {{
             let res = unsafe { libc::$fn $args };
@@ -781,7 +778,42 @@ mod sys {
     }
     impl Reactor {
         pub fn new() -> io::Result<Reactor> {
-            let epoll_fd = epoll_create1()?;
+            // According to libuv, `EPOLL_CLOEXEC` is not defined on Android API < 21.
+            // But `EPOLL_CLOEXEC` is an alias for `O_CLOEXEC` on that platform, so we use it instead.
+            #[cfg(target_os = "android")]
+            const CLOEXEC: libc::c_int = libc::O_CLOEXEC;
+            #[cfg(not(target_os = "android"))]
+            const CLOEXEC: libc::c_int = libc::EPOLL_CLOEXEC;
+
+            let epoll_fd = unsafe {
+                // Check if the `epoll_create1` symbol is available on this platform.
+                let ptr = libc::dlsym(
+                    libc::RTLD_DEFAULT,
+                    "epoll_create1\0".as_ptr() as *const libc::c_char,
+                );
+
+                if ptr.is_null() {
+                    // If not, use `epoll_create` and manually set `CLOEXEC`.
+                    let fd = match libc::epoll_create(1024) {
+                        -1 => return Err(io::Error::last_os_error()),
+                        fd => fd,
+                    };
+                    let flags = libc::fcntl(fd, libc::F_GETFD);
+                    libc::fcntl(fd, libc::F_SETFD, flags | libc::FD_CLOEXEC);
+                    fd
+                } else {
+                    // Use `epoll_create1` with `CLOEXEC`.
+                    let epoll_create1 = std::mem::transmute::<
+                        *mut libc::c_void,
+                        unsafe extern "C" fn(libc::c_int) -> libc::c_int,
+                    >(ptr);
+                    match epoll_create1(CLOEXEC) {
+                        -1 => return Err(io::Error::last_os_error()),
+                        fd => fd,
+                    }
+                }
+            };
+
             let event_fd = syscall!(eventfd(0, libc::EFD_CLOEXEC | libc::EFD_NONBLOCK))?;
             let reactor = Reactor { epoll_fd, event_fd };
             reactor.register(event_fd, !0)?;
@@ -791,8 +823,12 @@ mod sys {
         pub fn register(&self, fd: RawFd, key: usize) -> io::Result<()> {
             let flags = syscall!(fcntl(fd, libc::F_GETFL))?;
             syscall!(fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK))?;
-            let ev = &mut EpollEvent::new(0, key as u64);
-            epoll_ctl(self.epoll_fd, EpollOp::EpollCtlAdd, fd, Some(ev))
+            let mut ev = libc::epoll_event {
+                events: 0,
+                u64: key as u64,
+            };
+            syscall!(epoll_ctl(self.epoll_fd, libc::EPOLL_CTL_ADD, fd, &mut ev))?;
+            Ok(())
         }
         pub fn reregister(&self, fd: RawFd, key: usize, read: bool, write: bool) -> io::Result<()> {
             let mut flags = libc::EPOLLONESHOT;
@@ -802,11 +838,21 @@ mod sys {
             if write {
                 flags |= write_flags();
             }
-            let ev = &mut EpollEvent::new(flags, key as u64);
-            epoll_ctl(self.epoll_fd, EpollOp::EpollCtlMod, fd, Some(ev))
+            let mut ev = libc::epoll_event {
+                events: flags as _,
+                u64: key as u64,
+            };
+            syscall!(epoll_ctl(self.epoll_fd, libc::EPOLL_CTL_MOD, fd, &mut ev))?;
+            Ok(())
         }
         pub fn deregister(&self, fd: RawFd) -> io::Result<()> {
-            epoll_ctl(self.epoll_fd, EpollOp::EpollCtlDel, fd, None)
+            syscall!(epoll_ctl(
+                self.epoll_fd,
+                libc::EPOLL_CTL_DEL,
+                fd,
+                ptr::null_mut()
+            ))?;
+            Ok(())
         }
         pub fn wait(&self, events: &mut Events, timeout: Option<Duration>) -> io::Result<usize> {
             let timeout_ms = timeout
@@ -819,7 +865,14 @@ mod sys {
                 })
                 .and_then(|t| t.as_millis().try_into().ok())
                 .unwrap_or(-1);
-            events.len = epoll_wait(self.epoll_fd, &mut events.list, timeout_ms)?;
+
+            let res = syscall!(epoll_wait(
+                self.epoll_fd,
+                events.list.as_mut_ptr() as *mut libc::epoll_event,
+                events.list.len() as libc::c_int,
+                timeout_ms as libc::c_int,
+            ))?;
+            events.len = res as usize;
 
             let mut buf = [0u8; 8];
             let _ = syscall!(read(
@@ -841,28 +894,29 @@ mod sys {
             Ok(())
         }
     }
-    fn read_flags() -> EpollFlags {
+    fn read_flags() -> libc::c_int {
         libc::EPOLLIN | libc::EPOLLRDHUP | libc::EPOLLHUP | libc::EPOLLERR | libc::EPOLLPRI
     }
-    fn write_flags() -> EpollFlags {
+    fn write_flags() -> libc::c_int {
         libc::EPOLLOUT | libc::EPOLLHUP | libc::EPOLLERR
     }
 
     pub struct Events {
-        list: Box<[EpollEvent]>,
+        list: Box<[libc::epoll_event]>,
         len: usize,
     }
     impl Events {
         pub fn new() -> Events {
-            let list = vec![EpollEvent::empty(); 1000].into_boxed_slice();
+            let ev = libc::epoll_event { events: 0, u64: 0 };
+            let list = vec![ev; 1000].into_boxed_slice();
             let len = 0;
             Events { list, len }
         }
         pub fn iter(&self) -> impl Iterator<Item = Event> + '_ {
             self.list[..self.len].iter().map(|ev| Event {
-                readable: (ev.events() & read_flags()) != 0,
-                writable: (ev.events() & write_flags()) != 0,
-                key: ev.data() as usize,
+                readable: (ev.events as libc::c_int & read_flags()) != 0,
+                writable: (ev.events as libc::c_int & write_flags()) != 0,
+                key: ev.u64 as usize,
             })
         }
     }