Formatting only changes for #1928 and #1863

src/fcntl.rs

@@ -193,9 +193,13 @@ feature! {
 
 // The conversion is not identical on all operating systems.
 #[allow(clippy::useless_conversion)]
-pub fn open<P: ?Sized + NixPath>(path: &P, oflag: OFlag, mode: Mode) -> Result<RawFd> {
-    let fd = path.with_nix_path(|cstr| {
-        unsafe { libc::open(cstr.as_ptr(), oflag.bits(), mode.bits() as c_uint) }
+pub fn open<P: ?Sized + NixPath>(
+    path: &P,
+    oflag: OFlag,
+    mode: Mode,
+) -> Result<RawFd> {
+    let fd = path.with_nix_path(|cstr| unsafe {
+        libc::open(cstr.as_ptr(), oflag.bits(), mode.bits() as c_uint)
     })?;
 
     Errno::result(fd)
@@ -210,8 +214,8 @@ pub fn openat<P: ?Sized + NixPath>(
     oflag: OFlag,
     mode: Mode,
 ) -> Result<RawFd> {
-    let fd = path.with_nix_path(|cstr| {
-        unsafe { libc::openat(dirfd, cstr.as_ptr(), oflag.bits(), mode.bits() as c_uint) }
+    let fd = path.with_nix_path(|cstr| unsafe {
+        libc::openat(dirfd, cstr.as_ptr(), oflag.bits(), mode.bits() as c_uint)
     })?;
     Errno::result(fd)
 }
@@ -303,7 +307,10 @@ fn readlink_maybe_at<P: ?Sized + NixPath>(
     })
 }
 
-fn inner_readlink<P: ?Sized + NixPath>(dirfd: Option<RawFd>, path: &P) -> Result<OsString> {
+fn inner_readlink<P: ?Sized + NixPath>(
+    dirfd: Option<RawFd>,
+    path: &P,
+) -> Result<OsString> {
     let mut v = Vec::with_capacity(libc::PATH_MAX as usize);
 
     {
@@ -387,7 +394,10 @@ pub fn readlink<P: ?Sized + NixPath>(path: &P) -> Result<OsString> {
 }
 
 #[cfg(not(target_os = "redox"))]
-pub fn readlinkat<P: ?Sized + NixPath>(dirfd: RawFd, path: &P) -> Result<OsString> {
+pub fn readlinkat<P: ?Sized + NixPath>(
+    dirfd: RawFd,
+    path: &P,
+) -> Result<OsString> {
     inner_readlink(Some(dirfd), path)
 }
 
@@ -450,9 +460,17 @@ pub enum FcntlArg<'a> {
     F_OFD_SETLKW(&'a libc::flock),
     #[cfg(any(target_os = "linux", target_os = "android"))]
     F_OFD_GETLK(&'a mut libc::flock),
-    #[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]
+    #[cfg(any(
+        target_os = "android",
+        target_os = "linux",
+        target_os = "freebsd"
+    ))]
     F_ADD_SEALS(SealFlag),
-    #[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]
+    #[cfg(any(
+        target_os = "android",
+        target_os = "linux",
+        target_os = "freebsd"
+    ))]
     F_GET_SEALS,
     #[cfg(any(target_os = "macos", target_os = "ios"))]
     F_FULLFSYNC,
@@ -481,7 +499,9 @@ pub fn fcntl(fd: RawFd, arg: FcntlArg) -> Result<c_int> {
     let res = unsafe {
         match arg {
             F_DUPFD(rawfd) => libc::fcntl(fd, libc::F_DUPFD, rawfd),
-            F_DUPFD_CLOEXEC(rawfd) => libc::fcntl(fd, libc::F_DUPFD_CLOEXEC, rawfd),
+            F_DUPFD_CLOEXEC(rawfd) => {
+                libc::fcntl(fd, libc::F_DUPFD_CLOEXEC, rawfd)
+            }
             F_GETFD => libc::fcntl(fd, libc::F_GETFD),
             F_SETFD(flag) => libc::fcntl(fd, libc::F_SETFD, flag.bits()),
             F_GETFL => libc::fcntl(fd, libc::F_GETFL),
@@ -498,9 +518,19 @@ pub fn fcntl(fd: RawFd, arg: FcntlArg) -> Result<c_int> {
             F_OFD_SETLKW(flock) => libc::fcntl(fd, libc::F_OFD_SETLKW, flock),
             #[cfg(any(target_os = "android", target_os = "linux"))]
             F_OFD_GETLK(flock) => libc::fcntl(fd, libc::F_OFD_GETLK, flock),
-            #[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]
-            F_ADD_SEALS(flag) => libc::fcntl(fd, libc::F_ADD_SEALS, flag.bits()),
-            #[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]
+            #[cfg(any(
+                target_os = "android",
+                target_os = "linux",
+                target_os = "freebsd"
+            ))]
+            F_ADD_SEALS(flag) => {
+                libc::fcntl(fd, libc::F_ADD_SEALS, flag.bits())
+            }
+            #[cfg(any(
+                target_os = "android",
+                target_os = "linux",
+                target_os = "freebsd"
+            ))]
             F_GET_SEALS => libc::fcntl(fd, libc::F_GET_SEALS),
             #[cfg(any(target_os = "macos", target_os = "ios"))]
             F_FULLFSYNC => libc::fcntl(fd, libc::F_FULLFSYNC),
@@ -535,8 +565,12 @@ pub fn flock(fd: RawFd, arg: FlockArg) -> Result<()> {
             LockShared => libc::flock(fd, libc::LOCK_SH),
             LockExclusive => libc::flock(fd, libc::LOCK_EX),
             Unlock => libc::flock(fd, libc::LOCK_UN),
-            LockSharedNonblock => libc::flock(fd, libc::LOCK_SH | libc::LOCK_NB),
-            LockExclusiveNonblock => libc::flock(fd, libc::LOCK_EX | libc::LOCK_NB),
+            LockSharedNonblock => {
+                libc::flock(fd, libc::LOCK_SH | libc::LOCK_NB)
+            }
+            LockExclusiveNonblock => {
+                libc::flock(fd, libc::LOCK_EX | libc::LOCK_NB)
+            }
             UnlockNonblock => libc::flock(fd, libc::LOCK_UN | libc::LOCK_NB),
         }
     };
@@ -632,12 +666,19 @@ pub fn splice(
         .map(|offset| offset as *mut libc::loff_t)
         .unwrap_or(ptr::null_mut());
 
-    let ret = unsafe { libc::splice(fd_in, off_in, fd_out, off_out, len, flags.bits()) };
+    let ret = unsafe {
+        libc::splice(fd_in, off_in, fd_out, off_out, len, flags.bits())
+    };
     Errno::result(ret).map(|r| r as usize)
 }
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
-pub fn tee(fd_in: RawFd, fd_out: RawFd, len: usize, flags: SpliceFFlags) -> Result<usize> {
+pub fn tee(
+    fd_in: RawFd,
+    fd_out: RawFd,
+    len: usize,
+    flags: SpliceFFlags,
+) -> Result<usize> {
     let ret = unsafe { libc::tee(fd_in, fd_out, len, flags.bits()) };
     Errno::result(ret).map(|r| r as usize)
 }
@@ -646,9 +687,8 @@ pub fn tee(fd_in: RawFd, fd_out: RawFd, len: usize, flags: SpliceFFlags) -> Resu
 pub fn vmsplice(
     fd: RawFd,
     iov: &[std::io::IoSlice<'_>],
-    flags: SpliceFFlags
-    ) -> Result<usize>
-{
+    flags: SpliceFFlags,
+) -> Result<usize> {
     let ret = unsafe {
         libc::vmsplice(
             fd,
@@ -778,14 +818,19 @@ impl SpacectlRange {
 /// ```
 #[cfg(target_os = "freebsd")]
 pub fn fspacectl(fd: RawFd, range: SpacectlRange) -> Result<SpacectlRange> {
-    let mut rqsr = libc::spacectl_range{r_offset: range.0, r_len: range.1};
-    let res = unsafe { libc::fspacectl(
+    let mut rqsr = libc::spacectl_range {
+        r_offset: range.0,
+        r_len: range.1,
+    };
+    let res = unsafe {
+        libc::fspacectl(
             fd,
             libc::SPACECTL_DEALLOC, // Only one command is supported ATM
             &rqsr,
-            0,                      // No flags are currently supported
-            &mut rqsr
-    )};
+            0, // No flags are currently supported
+            &mut rqsr,
+        )
+    };
     Errno::result(res).map(|_| SpacectlRange(rqsr.r_offset, rqsr.r_len))
 }
 
@@ -820,18 +865,25 @@ pub fn fspacectl(fd: RawFd, range: SpacectlRange) -> Result<SpacectlRange> {
 /// assert_eq!(buf, b"012\0\0\0\0\0\09abcdef");
 /// ```
 #[cfg(target_os = "freebsd")]
-pub fn fspacectl_all(fd: RawFd, offset: libc::off_t, len: libc::off_t)
-    -> Result<()>
-{
-    let mut rqsr = libc::spacectl_range{r_offset: offset, r_len: len};
+pub fn fspacectl_all(
+    fd: RawFd,
+    offset: libc::off_t,
+    len: libc::off_t,
+) -> Result<()> {
+    let mut rqsr = libc::spacectl_range {
+        r_offset: offset,
+        r_len: len,
+    };
     while rqsr.r_len > 0 {
-        let res = unsafe { libc::fspacectl(
+        let res = unsafe {
+            libc::fspacectl(
                 fd,
                 libc::SPACECTL_DEALLOC, // Only one command is supported ATM
                 &rqsr,
-                0,                      // No flags are currently supported
-                &mut rqsr
-        )};
+                0, // No flags are currently supported
+                &mut rqsr,
+            )
+        };
         Errno::result(res)?;
     }
     Ok(())
@@ -848,8 +900,8 @@ pub fn fspacectl_all(fd: RawFd, offset: libc::off_t, len: libc::off_t)
 ))]
 mod posix_fadvise {
     use crate::errno::Errno;
-    use std::os::unix::io::RawFd;
     use crate::Result;
+    use std::os::unix::io::RawFd;
 
     #[cfg(feature = "fs")]
     libc_enum! {
@@ -894,7 +946,11 @@ mod posix_fadvise {
     target_os = "wasi",
     target_os = "freebsd"
 ))]
-pub fn posix_fallocate(fd: RawFd, offset: libc::off_t, len: libc::off_t) -> Result<()> {
+pub fn posix_fallocate(
+    fd: RawFd,
+    offset: libc::off_t,
+    len: libc::off_t,
+) -> Result<()> {
     let res = unsafe { libc::posix_fallocate(fd, offset, len) };
     match Errno::result(res) {
         Err(err) => Err(err),

src/sys/epoll.rs

@@ -2,7 +2,7 @@ use crate::errno::Errno;
 use crate::Result;
 use libc::{self, c_int};
 use std::mem;
-use std::os::unix::io::{FromRawFd,RawFd, OwnedFd, AsFd, AsRawFd};
+use std::os::unix::io::{AsFd, AsRawFd, FromRawFd, OwnedFd, RawFd};
 
 libc_bitflags!(
     pub struct EpollFlags: c_int {
@@ -78,22 +78,22 @@ impl EpollEvent {
 /// # fn main() -> nix::Result<()> {
 /// const DATA: u64 = 17;
 /// const MILLIS: u64 = 100;
-/// 
+///
 /// // Create epoll
 /// let epoll = Epoll::new(EpollCreateFlags::empty())?;
-/// 
+///
 /// // Create eventfd & Add event
 /// let eventfd = unsafe { OwnedFd::from_raw_fd(eventfd(0, EfdFlags::empty())?) };
 /// epoll.add(&eventfd, EpollEvent::new(EpollFlags::EPOLLIN,DATA))?;
-/// 
+///
 /// // Arm eventfd & Time wait
 /// write(eventfd.as_raw_fd(), &1u64.to_ne_bytes())?;
 /// let now = Instant::now();
-/// 
+///
 /// // Wait on event
 /// let mut events = [EpollEvent::empty()];
 /// epoll.wait(&mut events, MILLIS as isize)?;
-/// 
+///
 /// // Assert data correct & timeout didn't occur
 /// assert_eq!(events[0].data(), DATA);
 /// assert!(now.elapsed() < Duration::from_millis(MILLIS));
@@ -104,7 +104,7 @@ impl EpollEvent {
 pub struct Epoll(pub OwnedFd);
 impl Epoll {
     /// Creates a new epoll instance and returns a file descriptor referring to that instance.
-    /// 
+    ///
     /// [`epoll_create1`](https://man7.org/linux/man-pages/man2/epoll_create1.2.html).
     pub fn new(flags: EpollCreateFlags) -> Result<Self> {
         let res = unsafe { libc::epoll_create1(flags.bits()) };
@@ -113,30 +113,38 @@ impl Epoll {
         Ok(Self(owned_fd))
     }
     /// Add an entry to the interest list of the epoll file descriptor for
-    /// specified in events. 
-    /// 
+    /// specified in events.
+    ///
     /// [`epoll_ctl`](https://man7.org/linux/man-pages/man2/epoll_ctl.2.html) with `EPOLL_CTL_ADD`.
     pub fn add<Fd: AsFd>(&self, fd: Fd, mut event: EpollEvent) -> Result<()> {
-        self.epoll_ctl(EpollOp::EpollCtlAdd,fd,&mut event)
+        self.epoll_ctl(EpollOp::EpollCtlAdd, fd, &mut event)
     }
     /// Remove (deregister) the target file descriptor `fd` from the interest list.
-    /// 
+    ///
     /// [`epoll_ctl`](https://man7.org/linux/man-pages/man2/epoll_ctl.2.html) with `EPOLL_CTL_DEL` .
     pub fn delete<Fd: AsFd>(&self, fd: Fd) -> Result<()> {
-        self.epoll_ctl(EpollOp::EpollCtlDel,fd,None)
+        self.epoll_ctl(EpollOp::EpollCtlDel, fd, None)
     }
     /// Change the settings associated with `fd` in the interest list to the new settings specified
     /// in `event`.
-    /// 
+    ///
     /// [`epoll_ctl`](https://man7.org/linux/man-pages/man2/epoll_ctl.2.html) with `EPOLL_CTL_MOD`.
-    pub fn modify<Fd: AsFd>(&self,fd: Fd, event: &mut EpollEvent) -> Result<()> {
-        self.epoll_ctl(EpollOp::EpollCtlMod,fd,event)
+    pub fn modify<Fd: AsFd>(
+        &self,
+        fd: Fd,
+        event: &mut EpollEvent,
+    ) -> Result<()> {
+        self.epoll_ctl(EpollOp::EpollCtlMod, fd, event)
     }
     /// Waits for I/O events, blocking the calling thread if no events are currently available.
     /// (This can be thought of as fetching items from the ready list of the epoll instance.)
-    /// 
+    ///
     /// [`epoll_wait`](https://man7.org/linux/man-pages/man2/epoll_wait.2.html)
-    pub fn wait(&self, events: &mut [EpollEvent], timeout: isize) -> Result<usize> {
+    pub fn wait(
+        &self,
+        events: &mut [EpollEvent],
+        timeout: isize,
+    ) -> Result<usize> {
         let res = unsafe {
             libc::epoll_wait(
                 self.0.as_raw_fd(),
@@ -145,15 +153,15 @@ impl Epoll {
                 timeout as c_int,
             )
         };
-    
+
         Errno::result(res).map(|r| r as usize)
     }
     /// This system call is used to add, modify, or remove entries in the interest list of the epoll
     /// instance referred to by `self`. It requests that the operation `op` be performed for the
     /// target file descriptor, `fd`.
-    /// 
+    ///
     /// When possible prefer [`Epoll::add`], [`Epoll::delete`] and [`Epoll::modify`].
-    /// 
+    ///
     /// [`epoll_ctl`](https://man7.org/linux/man-pages/man2/epoll_ctl.2.html)
     fn epoll_ctl<'a, Fd: AsFd, T>(
         &self,
@@ -165,9 +173,17 @@ impl Epoll {
         T: Into<Option<&'a mut EpollEvent>>,
     {
         let event: Option<&mut EpollEvent> = event.into();
-        let ptr = event.map(|x|&mut x.event as *mut libc::epoll_event).unwrap_or(std::ptr::null_mut());
+        let ptr = event
+            .map(|x| &mut x.event as *mut libc::epoll_event)
+            .unwrap_or(std::ptr::null_mut());
         unsafe {
-            Errno::result(libc::epoll_ctl(self.0.as_raw_fd(), op as c_int, fd.as_fd().as_raw_fd(), ptr)).map(drop)
+            Errno::result(libc::epoll_ctl(
+                self.0.as_raw_fd(),
+                op as c_int,
+                fd.as_fd().as_raw_fd(),
+                ptr,
+            ))
+            .map(drop)
         }
     }
 }
@@ -231,4 +247,4 @@ pub fn epoll_wait(
     };
 
     Errno::result(res).map(|r| r as usize)
-}
+}