imp(wrapper): add wrapper functions for libc

Author: omarabid

src/timer/epoll.rs

@@ -4,6 +4,7 @@
 // https://www.apache.org/licenses/LICENSE-2.0>. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use crate::utils::{epoll_create1, epoll_ctl, epoll_wait, read, timerfd_create, timerfd_settime};
 use crate::Result;
 
 use std::sync::{mpsc::Sender, Arc, Mutex};
@@ -57,8 +58,7 @@ impl Timer {
         let clockid: libc::clockid_t = libc::CLOCK_REALTIME;
         let clock_flags: libc::c_int = libc::TFD_NONBLOCK;
 
-        // TODO: handler error (-1)
-        let tfd = unsafe { libc::timerfd_create(clockid, clock_flags) };
+        let tfd = timerfd_create(clockid, clock_flags).unwrap();
 
         let now = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)?
@@ -92,15 +92,13 @@ impl Timer {
 
         let set_flags = libc::TFD_TIMER_ABSTIME;
 
-        // TODO: handler error (-1)
-        let sfd = unsafe { libc::timerfd_settime(tfd, set_flags, &mut new_value, &mut old_value) };
+        timerfd_settime(tfd, set_flags, &mut new_value, &mut old_value).unwrap();
 
         Ok(tfd)
     }
 
     fn create_epollfd(timer_fd: libc::c_int) -> Result<libc::c_int> {
-        // TODO: handler error (-1)
-        let epoll_fd = unsafe { libc::epoll_create1(0) };
+        let epoll_fd = epoll_create1(0).unwrap();
 
         let mut event = libc::epoll_event {
             events: libc::EPOLLIN as u32,
@@ -109,22 +107,20 @@ impl Timer {
 
         let epoll_flags = libc::EPOLL_CTL_ADD;
 
-        // TODO: handler error (-1)
-        let ctl_fd = unsafe { libc::epoll_ctl(epoll_fd, epoll_flags, timer_fd, &mut event) };
+        epoll_ctl(epoll_fd, epoll_flags, timer_fd, &mut event).unwrap();
 
         Ok(epoll_fd)
     }
 
     fn epoll_wait(timer_fd: libc::c_int, epoll_fd: libc::c_int) -> Result<()> {
         let mut events = Vec::with_capacity(1);
 
-        // TODO: handler error (-1)
-        let wait = unsafe { libc::epoll_wait(epoll_fd, events.as_mut_ptr(), 1, -1) };
+        epoll_wait(epoll_fd, events.as_mut_ptr(), 1, -1).unwrap();
+
         let mut buffer: u64 = 0;
         let bufptr: *mut _ = &mut buffer;
 
-        // TODO: handler error (-1)
-        let read = unsafe { libc::read(timer_fd, bufptr as *mut libc::c_void, 8) };
+        read(timer_fd, bufptr as *mut libc::c_void, 8).unwrap();
 
         Ok(())
     }

src/utils.rs

@@ -5,6 +5,7 @@
 // except according to those terms.
 
 use crate::error::Result;
+use crate::PyroscopeError;
 
 use std::collections::HashMap;
 
@@ -54,3 +55,61 @@ mod tests {
         )
     }
 }
+
+/// Wrapper for libc functions.
+///
+/// Error wrapper for some libc functions used by the library. This only does
+/// Error (-1 return) wrapping. Alternatively, the nix crate could be used
+/// instead of expanding this wrappers (if more functions and types are used
+/// from libc)
+
+/// Error Wrapper for libc return. Only check for errors.
+fn check_err<T: Ord + Default>(num: T) -> Result<T> {
+    if num < T::default() {
+        return Err(PyroscopeError::from(std::io::Error::last_os_error()));
+    }
+    Ok(num)
+}
+
+/// libc::timerfd wrapper
+pub fn timerfd_create(clockid: libc::clockid_t, clock_flags: libc::c_int) -> Result<i32> {
+    check_err(unsafe { libc::timerfd_create(clockid, clock_flags) }).map(|timer_fd| timer_fd as i32)
+}
+
+/// libc::timerfd_settime wrapper
+pub fn timerfd_settime(
+    timer_fd: i32, set_flags: libc::c_int, new_value: &mut libc::itimerspec,
+    old_value: &mut libc::itimerspec,
+) -> Result<()> {
+    check_err(unsafe { libc::timerfd_settime(timer_fd, set_flags, new_value, old_value) })?;
+    Ok(())
+}
+
+/// libc::epoll_create1 wrapper
+pub fn epoll_create1(epoll_flags: libc::c_int) -> Result<i32> {
+    check_err(unsafe { libc::epoll_create1(epoll_flags) }).map(|epoll_fd| epoll_fd as i32)
+}
+
+/// libc::epoll_ctl wrapper
+pub fn epoll_ctl(epoll_fd: i32, epoll_flags: libc::c_int, timer_fd: i32, event: &mut libc::epoll_event) -> Result<()> {
+    check_err(unsafe {
+        libc::epoll_ctl(epoll_fd, epoll_flags, timer_fd, event)
+    })?;
+    Ok(())
+}
+
+/// libc::epoll_wait wrapper
+pub fn epoll_wait(epoll_fd: i32, events: *mut libc::epoll_event, maxevents: libc::c_int, timeout: libc::c_int) -> Result<()> {
+    check_err(unsafe {
+        libc::epoll_wait(epoll_fd, events, maxevents, timeout)
+    })?;
+    Ok(())
+}
+
+/// libc::read wrapper
+pub fn read(timer_fd: i32, bufptr: *mut libc::c_void, count: libc::size_t) -> Result<()> {
+    check_err(unsafe {
+        libc::read(timer_fd, bufptr, count)
+    })?;
+    Ok(())
+}