Run rustfmt

build.rs

@@ -3,7 +3,6 @@ extern crate cc;
 
 use std::{env, fs, fs::DirEntry, path::Path};
 
-
 // include src/header directories that don't start with '_'
 fn include_dir(d: &DirEntry) -> bool {
     d.metadata().map(|m| m.is_dir()).unwrap_or(false)
@@ -15,10 +14,7 @@ fn include_dir(d: &DirEntry) -> bool {
 
 fn get_target() -> String {
     env::var("TARGET").unwrap_or(
-        option_env!("TARGET").map_or(
-            "x86_64-unknown-redox".to_string(),
-            |x| x.to_string()
-        )
+        option_env!("TARGET").map_or("x86_64-unknown-redox".to_string(), |x| x.to_string()),
     )
 }
 
@@ -68,7 +64,8 @@ fn main() {
 
     let mut cc_builder = &mut cc::Build::new();
 
-    cc_builder = cc_builder.flag("-nostdinc")
+    cc_builder = cc_builder
+        .flag("-nostdinc")
         .flag("-nostdlib")
         .include(&format!("{}/include", crate_dir))
         .include(&format!("{}/target/include", crate_dir));
@@ -77,7 +74,8 @@ fn main() {
         cc_builder = cc_builder.flag("-mno-outline-atomics")
     }
 
-    cc_builder.flag("-fno-stack-protector")
+    cc_builder
+        .flag("-fno-stack-protector")
         .flag("-Wno-expansion-to-defined")
         .files(
             fs::read_dir("src/c")

src/header/grp/mod.rs

@@ -3,15 +3,20 @@
 use core::{
     convert::{TryFrom, TryInto},
     mem,
+    num::ParseIntError,
     ops::{Deref, DerefMut},
     pin::Pin,
     primitive::str,
-    ptr, slice, num::ParseIntError, str::Matches,
+    ptr, slice,
+    str::Matches,
 };
 
 use lazy_static::lazy_static;
 
-use alloc::{borrow::ToOwned, string::{String, FromUtf8Error}};
+use alloc::{
+    borrow::ToOwned,
+    string::{FromUtf8Error, String},
+};
 
 use crate::{
     c_str::CStr,
@@ -19,9 +24,9 @@ use crate::{
     header::{errno, fcntl, string::strlen},
     io,
     io::{prelude::*, BufReader, Lines},
-    platform::types::*,
     platform,
-    sync::Mutex
+    platform::types::*,
+    sync::Mutex,
 };
 
 use super::{errno::*, string::strncmp};
@@ -69,7 +74,9 @@ static mut GROUP: group = group {
     gr_mem: ptr::null_mut(),
 };
 
-lazy_static! { static ref LINE_READER: Mutex<Option<Lines<BufReader<File>>>> = Mutex::new(None); }
+lazy_static! {
+    static ref LINE_READER: Mutex<Option<Lines<BufReader<File>>>> = Mutex::new(None);
+}
 
 #[repr(C)]
 #[derive(Debug)]
@@ -88,7 +95,7 @@ enum Error {
     Misc(io::Error),
     FromUtf8Error(FromUtf8Error),
     ParseIntError(ParseIntError),
-    Other
+    Other,
 }
 
 #[derive(Debug)]
@@ -110,18 +117,17 @@ impl OwnedGrp {
 fn split(buf: &mut [u8]) -> Option<group> {
     let gid = match buf[0..mem::size_of::<gid_t>()].try_into() {
         Ok(buf) => gid_t::from_ne_bytes(buf),
-        Err(err) => return None
+        Err(err) => return None,
     };
-    
+
     // We moved the gid to the beginning of the byte buffer so we can do this.
     let mut parts = buf[mem::size_of::<gid_t>()..].split_mut(|&c| c == b'\0');
-    
+
     Some(group {
         gr_name: parts.next()?.as_mut_ptr() as *mut i8,
         gr_passwd: parts.next()?.as_mut_ptr() as *mut i8,
         gr_gid: gid,
-        gr_mem: parts.next()?.as_mut_ptr() as *mut *mut c_char
-        // this will work because this points to the first string, which also happens to be the start of the array. The two are equivalent, just need to by typecast.
+        gr_mem: parts.next()?.as_mut_ptr() as *mut *mut c_char, // this will work because this points to the first string, which also happens to be the start of the array. The two are equivalent, just need to by typecast.
     })
 }
 
@@ -133,61 +139,61 @@ fn parse_grp(line: String, destbuf: Option<DestBuffer>) -> Result<OwnedGrp, Erro
         .map(|i| if i == b':' { b'\0' } else { i })
         .chain([b'\0'])
         .collect::<Vec<_>>();
-    let mut buffer = buffer
-        .split_mut(|i| *i == b'\0');
+    let mut buffer = buffer.split_mut(|i| *i == b'\0');
 
     let mut gr_gid: gid_t = 0;
     let strings = {
         let mut vec: Vec<u8> = Vec::new();
-        
+
         let gr_name = buffer.next().ok_or(Error::EOF)?.to_vec();
         let gr_passwd = buffer.next().ok_or(Error::EOF)?.to_vec();
         gr_gid = String::from_utf8(buffer.next().ok_or(Error::EOF)?.to_vec())
             .map_err(|err| Error::FromUtf8Error(err))?
             .parse::<gid_t>()
             .map_err(|err| Error::ParseIntError(err))?;
-            
+
         // Place the gid at the beginning of the byte buffer to make getting it back out again later, much faster.
-            
+
         vec.extend(gr_gid.to_ne_bytes());
         vec.extend(gr_name);
         vec.push(0);
         vec.extend(gr_passwd);
         vec.push(0);
-        
-        for i in buffer.next().ok_or(Error::EOF)?
+
+        for i in buffer
+            .next()
+            .ok_or(Error::EOF)?
             .split(|b| *b == b',')
-            .filter(|i| i.len() > 0) {
-            
+            .filter(|i| i.len() > 0)
+        {
             vec.extend(i.to_vec());
             vec.push(0);
         }
-        
+
         vec.extend(0usize.to_ne_bytes());
-        
+
         vec
     };
-    
+
     let mut buffer = match destbuf {
         None => MaybeAllocated::Owned(Box::into_pin(strings.into_boxed_slice())),
         Some(buf) => {
             let mut buf = MaybeAllocated::Borrowed(buf);
-            
+
             if buf.len() < buf.len() {
-                unsafe { platform::errno = errno::ERANGE; }
+                unsafe {
+                    platform::errno = errno::ERANGE;
+                }
                 return Err(Error::BufTooSmall);
             }
-            
+
             buf[..strings.len()].copy_from_slice(&strings);
             buf
         }
     };
     let reference = split(&mut buffer).ok_or(Error::Other)?;
-    
-    Ok(OwnedGrp {
-        buffer,
-        reference
-    })
+
+    Ok(OwnedGrp { buffer, reference })
 }
 
 // MT-Unsafe race:grgid locale
@@ -198,7 +204,7 @@ pub unsafe extern "C" fn getgrgid(gid: gid_t) -> *mut group {
     for line in BufReader::new(db).lines() {
         let Ok(line) = line else { return ptr::null_mut() };
         let Ok(grp) = parse_grp(line, None) else { return ptr::null_mut() };
-        
+
         if grp.reference.gr_gid == gid {
             return grp.into_global();
         }
@@ -214,11 +220,16 @@ pub unsafe extern "C" fn getgrnam(name: *const c_char) -> *mut group {
 
     for line in BufReader::new(db).lines() {
         let Ok(line) = line else { return ptr::null_mut() };
-        
+
         let Ok(grp) = parse_grp(line, None) else { return ptr::null_mut() };
-        
+
         // Attempt to prevent BO vulnerabilities
-        if strncmp(grp.reference.gr_name, name, strlen(grp.reference.gr_name).min(strlen(name))) > 0 {
+        if strncmp(
+            grp.reference.gr_name,
+            name,
+            strlen(grp.reference.gr_name).min(strlen(name)),
+        ) > 0
+        {
             return grp.into_global();
         }
     }
@@ -228,7 +239,13 @@ pub unsafe extern "C" fn getgrnam(name: *const c_char) -> *mut group {
 
 // MT-Safe locale
 #[no_mangle]
-pub unsafe extern "C" fn getgrgid_r(gid: gid_t, result_buf: *mut group, buffer: *mut c_char, buflen: usize, result: *mut *mut group) -> c_int {
+pub unsafe extern "C" fn getgrgid_r(
+    gid: gid_t,
+    result_buf: *mut group,
+    buffer: *mut c_char,
+    buflen: usize,
+    result: *mut *mut group,
+) -> c_int {
     let Ok(db) = File::open(c_str!("/etc/group"), fcntl::O_RDONLY) else { return ENOENT };
 
     for line in BufReader::new(db).lines() {
@@ -238,31 +255,42 @@ pub unsafe extern "C" fn getgrgid_r(gid: gid_t, result_buf: *mut group, buffer:
         if grp.reference.gr_gid == gid {
             *result_buf = grp.reference;
             *result = result_buf;
-            
+
             return 0;
         }
     }
-    
+
     return ENOENT;
 }
 
 // MT-Safe locale
 #[no_mangle]
-pub unsafe extern "C" fn getgrnam_r(name: *const c_char, result_buf: *mut group, buffer: *mut c_char, buflen: usize, result: *mut *mut group) -> c_int {
+pub unsafe extern "C" fn getgrnam_r(
+    name: *const c_char,
+    result_buf: *mut group,
+    buffer: *mut c_char,
+    buflen: usize,
+    result: *mut *mut group,
+) -> c_int {
     let Ok(db) = File::open(c_str!("/etc/group"), fcntl::O_RDONLY) else { return ENOENT };
 
     for line in BufReader::new(db).lines() {
         let Ok(line) = line else { return EINVAL };
         let Ok(mut grp) = parse_grp(line, Some(DestBuffer { ptr: buffer as *mut u8, len: buflen })) else { return EINVAL };
 
-        if strncmp(grp.reference.gr_name, name, strlen(grp.reference.gr_name).min(strlen(name))) > 0 {
+        if strncmp(
+            grp.reference.gr_name,
+            name,
+            strlen(grp.reference.gr_name).min(strlen(name)),
+        ) > 0
+        {
             *result_buf = grp.reference;
             *result = result_buf;
-            
+
             return 0;
         }
     }
-    
+
     return ENOENT;
 }
 
@@ -270,20 +298,21 @@ pub unsafe extern "C" fn getgrnam_r(name: *const c_char, result_buf: *mut group,
 #[no_mangle]
 pub unsafe extern "C" fn getgrent() -> *mut group {
     let mut line_reader = LINE_READER.lock();
-    
+
     if line_reader.is_none() {
         let Ok(db) = File::open(c_str!("/etc/group"), fcntl::O_RDONLY) else { return ptr::null_mut() };
         *line_reader = Some(BufReader::new(db).lines());
     }
-    
-    if let Some(lines) = line_reader.deref_mut() { 
+
+    if let Some(lines) = line_reader.deref_mut() {
         let Some(line) = lines.next() else { return ptr::null_mut() };
         let Ok(line) = line else { return ptr::null_mut() };
-        
+
         if let Ok(grp) = parse_grp(line, None) {
             return grp.into_global();
-        } else { return ptr::null_mut(); }
-        
+        } else {
+            return ptr::null_mut();
+        }
     } else {
         return ptr::null_mut();
     }
@@ -299,13 +328,18 @@ pub unsafe extern "C" fn endgrent() {
 // MT-Unsafe race:grent locale
 #[no_mangle]
 pub unsafe extern "C" fn setgrent() {
-    let mut line_reader = LINE_READER.lock();    
+    let mut line_reader = LINE_READER.lock();
     let Ok(db) = File::open(c_str!("/etc/group"), fcntl::O_RDONLY) else { return };
     *line_reader = Some(BufReader::new(db).lines());
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn getgrouplist(user: *const c_char, group: gid_t, groups: *mut gid_t, ngroups: i32) -> i32 {
+pub unsafe extern "C" fn getgrouplist(
+    user: *const c_char,
+    group: gid_t,
+    groups: *mut gid_t,
+    ngroups: i32,
+) -> i32 {
     let mut grps = Vec::<gid_t>::from_raw_parts(groups, 0, ngroups as usize);
     let Ok(usr) = (crate::c_str::CStr::from_ptr(user).to_str()) else { return 0 };
 

src/header/wchar/mod.rs

@@ -4,8 +4,13 @@ use core::{char, ffi::VaList as va_list, mem, ptr, slice, usize};
 
 use crate::{
     header::{
-        ctype::isspace, errno::{ERANGE, EILSEQ, ENOMEM}, stdio::*, 
-        stdlib::{MB_CUR_MAX, MB_LEN_MAX, malloc}, string, time::*, wctype::*,
+        ctype::isspace,
+        errno::{EILSEQ, ENOMEM, ERANGE},
+        stdio::*,
+        stdlib::{malloc, MB_CUR_MAX, MB_LEN_MAX},
+        string,
+        time::*,
+        wctype::*,
     },
     platform::{self, errno, types::*},
 };
@@ -46,8 +51,13 @@ pub unsafe extern "C" fn fgetwc(stream: *mut FILE) -> wint_t {
     let mut wc: wchar_t = 0;
 
     loop {
-        let nread = fread(buf[bytes_read..bytes_read+1].as_mut_ptr() as *mut c_void, 1, 1, stream);
-        
+        let nread = fread(
+            buf[bytes_read..bytes_read + 1].as_mut_ptr() as *mut c_void,
+            1,
+            1,
+            stream,
+        );
+
         if nread != 1 {
             errno = EILSEQ;
             return WEOF;
@@ -75,7 +85,12 @@ pub unsafe extern "C" fn fgetwc(stream: *mut FILE) -> wint_t {
         }
     }
 
-    mbrtowc(&mut wc, buf.as_ptr() as *const c_char, encoded_length, ptr::null_mut());
+    mbrtowc(
+        &mut wc,
+        buf.as_ptr() as *const c_char,
+        encoded_length,
+        ptr::null_mut(),
+    );
 
     wc as wint_t
 }
@@ -281,8 +296,8 @@ pub unsafe extern "C" fn ungetwc(wc: wint_t, stream: &mut FILE) -> wint_t {
         return WEOF;
     }
 
-    /* 
-    We might have unget multiple bytes for a single wchar, eg, `ç` is [195, 167]. 
+    /*
+    We might have unget multiple bytes for a single wchar, eg, `ç` is [195, 167].
     We need to unget them in reversed, so they are pused as [..., 167, 195, ...]
     When we do fgetwc, we pop from the Vec, getting the write order of bytes [195, 167].
     If we called ungetc in the non-reversed order, we would get [167, 195]
@@ -327,19 +342,12 @@ pub unsafe extern "C" fn vswprintf(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn wcpcpy(
-    d: *mut wchar_t,
-    s: *const wchar_t,
-) -> *mut wchar_t {
+pub unsafe extern "C" fn wcpcpy(d: *mut wchar_t, s: *const wchar_t) -> *mut wchar_t {
     return (wcscpy(d, s)).offset(wcslen(s) as isize);
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn wcpncpy(
-    d: *mut wchar_t,
-    s: *const wchar_t,
-    n: size_t,
-) -> *mut wchar_t {
+pub unsafe extern "C" fn wcpncpy(d: *mut wchar_t, s: *const wchar_t, n: size_t) -> *mut wchar_t {
     return (wcsncpy(d, s, n)).offset(wcsnlen(s, n) as isize);
 }
 
@@ -359,8 +367,8 @@ pub unsafe extern "C" fn wcrtomb(s: *mut c_char, wc: wchar_t, ps: *mut mbstate_t
 #[no_mangle]
 pub unsafe extern "C" fn wcsdup(s: *const wchar_t) -> *mut wchar_t {
     let l = wcslen(s);
-    
-    let d = malloc((l + 1)*mem::size_of::<wchar_t>()) as *mut wchar_t;
+
+    let d = malloc((l + 1) * mem::size_of::<wchar_t>()) as *mut wchar_t;
 
     if d.is_null() {
         errno = ENOMEM;
@@ -521,7 +529,7 @@ pub unsafe extern "C" fn wcsncpy(
 #[no_mangle]
 pub unsafe extern "C" fn wcsnlen(mut s: *const wchar_t, maxlen: size_t) -> size_t {
     let mut len = 0;
-    
+
     while len < maxlen {
         if *s == 0 {
             break;
@@ -550,10 +558,10 @@ pub unsafe extern "C" fn wcsnrtombs(
     if ps.is_null() {
         ps = &mut mbs;
     }
-    
+
     while read < nwc {
         buf.fill(0);
-        
+
         let ret = wcrtomb(buf.as_mut_ptr(), **src, ps);
 
         if ret == size_t::MAX {
@@ -574,7 +582,7 @@ pub unsafe extern "C" fn wcsnrtombs(
             *src = ptr::null();
             return written;
         }
-        
+
         *src = (*src).add(1);
         read += 1;
         written += ret;
@@ -582,7 +590,6 @@ pub unsafe extern "C" fn wcsnrtombs(
     written
 }
 
-
 #[no_mangle]
 pub unsafe extern "C" fn wcspbrk(mut wcs: *const wchar_t, set: *const wchar_t) -> *mut wchar_t {
     wcs = wcs.add(wcscspn(wcs, set));

src/platform/redox/exec.rs

@@ -93,7 +93,10 @@ pub fn execve(
     // NOTE: We must omit O_CLOEXEC and close manually, otherwise it will be closed before we
     // have even read it!
     let (mut image_file, arg0) = match exec {
-        Executable::AtPath(path) => (File::open(path, O_RDONLY as c_int).map_err(|_| Error::new(ENOENT))?, path.to_bytes()),
+        Executable::AtPath(path) => (
+            File::open(path, O_RDONLY as c_int).map_err(|_| Error::new(ENOENT))?,
+            path.to_bytes(),
+        ),
         Executable::InFd { file, arg0 } => (file, arg0),
     };
 

src/platform/redox/libredox.rs

@@ -1,9 +1,11 @@
 use core::{slice, str};
 
-use syscall::{Error, Result, EMFILE, WaitFlags};
+use syscall::{Error, Result, WaitFlags, EMFILE};
 
-use crate::header::signal::sigaction;
-use crate::platform::types::{c_int, mode_t};
+use crate::{
+    header::signal::sigaction,
+    platform::types::{c_int, mode_t},
+};
 
 pub type RawResult = usize;
 
@@ -13,15 +15,26 @@ pub fn open(path: &str, oflag: c_int, mode: mode_t) -> Result<usize> {
         ((oflag as usize) & 0xFFFF_0000) | ((mode as usize) & 0xFFFF),
     )?;
 
-    c_int::try_from(usize_fd).map_err(|_| {
-        let _ = syscall::close(usize_fd);
-        Error::new(EMFILE)
-    }).map(|f| f as usize)
+    c_int::try_from(usize_fd)
+        .map_err(|_| {
+            let _ = syscall::close(usize_fd);
+            Error::new(EMFILE)
+        })
+        .map(|f| f as usize)
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn redox_open_v1(path_base: *const u8, path_len: usize, flags: u32, mode: u16) -> RawResult {
-    Error::mux(open(str::from_utf8_unchecked(slice::from_raw_parts(path_base, path_len)), flags as c_int, mode as mode_t))
+pub unsafe extern "C" fn redox_open_v1(
+    path_base: *const u8,
+    path_len: usize,
+    flags: u32,
+    mode: u16,
+) -> RawResult {
+    Error::mux(open(
+        str::from_utf8_unchecked(slice::from_raw_parts(path_base, path_len)),
+        flags as c_int,
+        mode as mode_t,
+    ))
 }
 
 #[no_mangle]
@@ -29,15 +42,31 @@ pub unsafe extern "C" fn redox_dup_v1(fd: usize, buf: *const u8, len: usize) ->
     Error::mux(syscall::dup(fd, core::slice::from_raw_parts(buf, len)))
 }
 #[no_mangle]
-pub unsafe extern "C" fn redox_dup2_v1(old_fd: usize, new_fd: usize, buf: *const u8, len: usize) -> RawResult {
-    Error::mux(syscall::dup2(old_fd, new_fd, core::slice::from_raw_parts(buf, len)))
+pub unsafe extern "C" fn redox_dup2_v1(
+    old_fd: usize,
+    new_fd: usize,
+    buf: *const u8,
+    len: usize,
+) -> RawResult {
+    Error::mux(syscall::dup2(
+        old_fd,
+        new_fd,
+        core::slice::from_raw_parts(buf, len),
+    ))
 }
 #[no_mangle]
 pub unsafe extern "C" fn redox_read_v1(fd: usize, dst_base: *mut u8, dst_len: usize) -> RawResult {
-    Error::mux(syscall::read(fd, slice::from_raw_parts_mut(dst_base, dst_len)))
+    Error::mux(syscall::read(
+        fd,
+        slice::from_raw_parts_mut(dst_base, dst_len),
+    ))
 }
 #[no_mangle]
-pub unsafe extern "C" fn redox_write_v1(fd: usize, src_base: *const u8, src_len: usize) -> RawResult {
+pub unsafe extern "C" fn redox_write_v1(
+    fd: usize,
+    src_base: *const u8,
+    src_len: usize,
+) -> RawResult {
     Error::mux(syscall::write(fd, slice::from_raw_parts(src_base, src_len)))
 }
 #[no_mangle]
@@ -59,7 +88,10 @@ pub unsafe extern "C" fn redox_fchown_v1(fd: usize, new_uid: u32, new_gid: u32)
 }
 #[no_mangle]
 pub unsafe extern "C" fn redox_fpath_v1(fd: usize, dst_base: *mut u8, dst_len: usize) -> RawResult {
-    Error::mux(syscall::fpath(fd, core::slice::from_raw_parts_mut(dst_base, dst_len)))
+    Error::mux(syscall::fpath(
+        fd,
+        core::slice::from_raw_parts_mut(dst_base, dst_len),
+    ))
 }
 #[no_mangle]
 pub unsafe extern "C" fn redox_close_v1(fd: usize) -> RawResult {
@@ -94,7 +126,11 @@ pub unsafe extern "C" fn redox_setrens_v1(rns: usize, ens: usize) -> RawResult {
 #[no_mangle]
 pub unsafe extern "C" fn redox_waitpid_v1(pid: usize, status: *mut i32, options: u32) -> RawResult {
     let mut sts = 0_usize;
-    let res = Error::mux(syscall::waitpid(pid, &mut sts, WaitFlags::from_bits_truncate(options as usize)));
+    let res = Error::mux(syscall::waitpid(
+        pid,
+        &mut sts,
+        WaitFlags::from_bits_truncate(options as usize),
+    ));
     status.write(sts as i32);
     res
 }
@@ -105,11 +141,19 @@ pub unsafe extern "C" fn redox_kill_v1(pid: usize, signal: u32) -> RawResult {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn redox_sigaction_v1(signal: u32, new: *const sigaction, old: *mut sigaction) -> RawResult {
+pub unsafe extern "C" fn redox_sigaction_v1(
+    signal: u32,
+    new: *const sigaction,
+    old: *mut sigaction,
+) -> RawResult {
     Error::mux(super::signal::sigaction_impl(signal as i32, new.as_ref(), old.as_mut()).map(|()| 0))
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn redox_sigprocmask_v1(how: u32, new: *const u64, old: *mut u64) -> RawResult {
+pub unsafe extern "C" fn redox_sigprocmask_v1(
+    how: u32,
+    new: *const u64,
+    old: *mut u64,
+) -> RawResult {
     Error::mux(super::signal::sigprocmask_impl(how as i32, new, old).map(|()| 0))
 }

src/platform/redox/mod.rs

@@ -63,7 +63,7 @@ macro_rules! path_from_c_str {
     }};
 }
 
-use self::{path::canonicalize, exec::Executable};
+use self::{exec::Executable, path::canonicalize};
 
 pub fn e(sys: Result<usize>) -> usize {
     match sys {
@@ -207,7 +207,10 @@ impl Pal for Sys {
 
     fn clock_settime(clk_id: clockid_t, tp: *const timespec) -> c_int {
         // TODO
-        eprintln!("relibc clock_settime({}, {:p}): not implemented", clk_id, tp);
+        eprintln!(
+            "relibc clock_settime({}, {:p}): not implemented",
+            clk_id, tp
+        );
         unsafe { errno = ENOSYS };
         -1
     }
@@ -238,7 +241,10 @@ impl Pal for Sys {
     }
     unsafe fn fexecve(fildes: c_int, argv: *const *mut c_char, envp: *const *mut c_char) -> c_int {
         e(self::exec::execve(
-            Executable::InFd { file: File::new(fildes), arg0: CStr::from_ptr(argv.read()).to_bytes() },
+            Executable::InFd {
+                file: File::new(fildes),
+                arg0: CStr::from_ptr(argv.read()).to_bytes(),
+            },
             self::exec::ArgEnv::C { argv, envp },
             None,
         )) as c_int
@@ -573,7 +579,10 @@ impl Pal for Sys {
 
     unsafe fn getrlimit(resource: c_int, rlim: *mut rlimit) -> c_int {
         //TODO
-        eprintln!("relibc getrlimit({}, {:p}): not implemented", resource, rlim);
+        eprintln!(
+            "relibc getrlimit({}, {:p}): not implemented",
+            resource, rlim
+        );
         if !rlim.is_null() {
             (*rlim).rlim_cur = RLIM_INFINITY;
             (*rlim).rlim_max = RLIM_INFINITY;
@@ -583,7 +592,10 @@ impl Pal for Sys {
 
     unsafe fn setrlimit(resource: c_int, rlim: *const rlimit) -> c_int {
         //TOOD
-        eprintln!("relibc setrlimit({}, {:p}): not implemented", resource, rlim);
+        eprintln!(
+            "relibc setrlimit({}, {:p}): not implemented",
+            resource, rlim
+        );
         unsafe { errno = EPERM };
         -1
     }
@@ -715,7 +727,10 @@ impl Pal for Sys {
     }
 
     unsafe fn msync(addr: *mut c_void, len: usize, flags: c_int) -> c_int {
-        eprintln!("relibc msync({:p}, 0x{:x}, 0x{:x}): not implemented", addr, len, flags);
+        eprintln!(
+            "relibc msync({:p}, 0x{:x}, 0x{:x}): not implemented",
+            addr, len, flags
+        );
         e(Err(syscall::Error::new(syscall::ENOSYS))) as c_int
         /* TODO
         e(syscall::msync(
@@ -744,7 +759,10 @@ impl Pal for Sys {
     }
 
     unsafe fn madvise(addr: *mut c_void, len: usize, flags: c_int) -> c_int {
-        eprintln!("relibc madvise({:p}, 0x{:x}, 0x{:x}): not implemented", addr, len, flags);
+        eprintln!(
+            "relibc madvise({:p}, 0x{:x}, 0x{:x}): not implemented",
+            addr, len, flags
+        );
         e(Err(syscall::Error::new(syscall::ENOSYS))) as c_int
     }
 
@@ -850,7 +868,10 @@ impl Pal for Sys {
 
     fn setpriority(which: c_int, who: id_t, prio: c_int) -> c_int {
         // TODO
-        eprintln!("relibc setpriority({}, {}, {}): not implemented", which, who, prio);
+        eprintln!(
+            "relibc setpriority({}, {}, {}): not implemented",
+            which, who, prio
+        );
         unsafe { errno = ENOSYS };
         -1
     }

src/platform/redox/redox-exec/src/lib.rs

@@ -23,8 +23,8 @@ use goblin::elf64::{
 use syscall::{
     error::*,
     flag::{MapFlags, SEEK_SET},
-    PAGE_SIZE, Map, PROT_WRITE, O_CLOEXEC,
-    GrantDesc, GrantFlags, PROT_READ, PROT_EXEC, MAP_SHARED, MAP_FIXED_NOREPLACE,
+    GrantDesc, GrantFlags, Map, MAP_FIXED_NOREPLACE, MAP_SHARED, O_CLOEXEC, PAGE_SIZE, PROT_EXEC,
+    PROT_READ, PROT_WRITE,
 };
 
 pub use self::arch::*;
@@ -174,13 +174,8 @@ where
                 let (first_aligned_page, remaining_filesz) = if voff > 0 {
                     let bytes_to_next_page = PAGE_SIZE - voff;
 
-                    let (_guard, dst_page) = unsafe {
-                        MmapGuard::map_mut_anywhere(
-                            *grants_fd,
-                            vaddr,
-                            PAGE_SIZE,
-                        )?
-                    };
+                    let (_guard, dst_page) =
+                        unsafe { MmapGuard::map_mut_anywhere(*grants_fd, vaddr, PAGE_SIZE)? };
 
                     let length = core::cmp::min(bytes_to_next_page, filesz);
 
@@ -209,16 +204,19 @@ where
                     // Use commented out lines to trigger kernel bug (FIXME).
 
                     //let pages_in_this_group = core::cmp::min(PAGES_PER_ITER, file_page_count - page_idx * PAGES_PER_ITER);
-                    let pages_in_this_group = core::cmp::min(PAGES_PER_ITER, remaining_page_count - page_idx);
+                    let pages_in_this_group =
+                        core::cmp::min(PAGES_PER_ITER, remaining_page_count - page_idx);
 
-                    if pages_in_this_group == 0 { break }
+                    if pages_in_this_group == 0 {
+                        break;
+                    }
 
                     // TODO: MAP_FIXED to optimize away funmap?
                     let (_guard, dst_memory) = unsafe {
                         MmapGuard::map_mut_anywhere(
                             *grants_fd,
                             first_aligned_page + page_idx * PAGE_SIZE, // offset
-                            pages_in_this_group * PAGE_SIZE, // size
+                            pages_in_this_group * PAGE_SIZE,           // size
                         )?
                     };
 
@@ -290,7 +288,11 @@ where
         };
 
         unsafe {
-            page.as_mut_ptr_slice().as_mut_ptr().add(new_page_off).cast::<usize>().write(word);
+            page.as_mut_ptr_slice()
+                .as_mut_ptr()
+                .add(new_page_off)
+                .cast::<usize>()
+                .write(word);
         }
 
         Ok(())
@@ -312,11 +314,8 @@ where
         MapFlags::PROT_READ | MapFlags::PROT_WRITE,
     )?;
     unsafe {
-        let (_guard, memory) = MmapGuard::map_mut_anywhere(
-            *grants_fd,
-            pheaders,
-            pheaders_size_aligned,
-        )?;
+        let (_guard, memory) =
+            MmapGuard::map_mut_anywhere(*grants_fd, pheaders, pheaders_size_aligned)?;
 
         memory[..pheaders_to_convey.len()].copy_from_slice(pheaders_to_convey);
     }
@@ -380,11 +379,7 @@ where
                 let aligned_size = size.next_multiple_of(PAGE_SIZE);
 
                 let (_guard, memory) = unsafe {
-                    MmapGuard::map_mut_anywhere(
-                        *grants_fd, 
-                        containing_page,
-                        aligned_size,
-                    )?
+                    MmapGuard::map_mut_anywhere(*grants_fd, containing_page, aligned_size)?
                 };
                 memory[displacement..][..source_slice.len()].copy_from_slice(source_slice);
             }
@@ -606,22 +601,34 @@ impl MmapGuard {
         flags.remove(MapFlags::MAP_FIXED_NOREPLACE);
         flags.insert(MapFlags::MAP_FIXED);
 
-        let _new_base = unsafe { syscall::fmap(self.fd, &Map {
-            offset,
-            size: self.size,
-            flags,
-            address: self.base,
-        })? };
+        let _new_base = unsafe {
+            syscall::fmap(
+                self.fd,
+                &Map {
+                    offset,
+                    size: self.size,
+                    flags,
+                    address: self.base,
+                },
+            )?
+        };
 
         Ok(())
     }
-    pub unsafe fn map_mut_anywhere<'a>(fd: usize, offset: usize, size: usize) -> Result<(Self, &'a mut [u8])> {
-        let mut this = Self::map(fd, &Map {
-            size,
-            offset,
-            address: 0,
-            flags: PROT_WRITE,
-        })?;
+    pub unsafe fn map_mut_anywhere<'a>(
+        fd: usize,
+        offset: usize,
+        size: usize,
+    ) -> Result<(Self, &'a mut [u8])> {
+        let mut this = Self::map(
+            fd,
+            &Map {
+                size,
+                offset,
+                address: 0,
+                flags: PROT_WRITE,
+            },
+        )?;
         let slice = &mut *this.as_mut_ptr_slice();
 
         Ok((this, slice))
@@ -704,10 +711,7 @@ fn fork_inner(initial_rsp: *mut usize) -> Result<usize> {
     let (cur_filetable_fd, new_pid_fd, new_pid);
 
     {
-        let cur_pid_fd = FdGuard::new(syscall::open(
-            "thisproc:current/open_via_dup",
-            O_CLOEXEC,
-        )?);
+        let cur_pid_fd = FdGuard::new(syscall::open("thisproc:current/open_via_dup", O_CLOEXEC)?);
         (new_pid_fd, new_pid) = new_context()?;
 
         // Do not allocate new signal stack, but copy existing address (all memory will be re-mapped
@@ -759,7 +763,12 @@ fn fork_inner(initial_rsp: *mut usize) -> Result<usize> {
             let mut grant_desc_buf = [GrantDesc::default(); 16];
             loop {
                 let bytes_read = {
-                    let buf = unsafe { core::slice::from_raw_parts_mut(grant_desc_buf.as_mut_ptr().cast(), grant_desc_buf.len() * size_of::<GrantDesc>()) };
+                    let buf = unsafe {
+                        core::slice::from_raw_parts_mut(
+                            grant_desc_buf.as_mut_ptr().cast(),
+                            grant_desc_buf.len() * size_of::<GrantDesc>(),
+                        )
+                    };
                     syscall::read(*cur_addr_space_fd, buf)?
                 };
                 if bytes_read == 0 {
@@ -769,7 +778,9 @@ fn fork_inner(initial_rsp: *mut usize) -> Result<usize> {
                 let grants = &grant_desc_buf[..bytes_read / size_of::<GrantDesc>()];
 
                 for grant in grants {
-                    if !grant.flags.contains(GrantFlags::GRANT_SCHEME) || !grant.flags.contains(GrantFlags::GRANT_SHARED) {
+                    if !grant.flags.contains(GrantFlags::GRANT_SCHEME)
+                        || !grant.flags.contains(GrantFlags::GRANT_SHARED)
+                    {
                         continue;
                     }
 
@@ -846,10 +857,7 @@ fn fork_inner(initial_rsp: *mut usize) -> Result<usize> {
 
 pub fn new_context() -> Result<(FdGuard, usize)> {
     // Create a new context (fields such as uid/gid will be inherited from the current context).
-    let fd = FdGuard::new(syscall::open(
-        "thisproc:new/open_via_dup",
-        O_CLOEXEC,
-    )?);
+    let fd = FdGuard::new(syscall::open("thisproc:new/open_via_dup", O_CLOEXEC)?);
 
     // Extract pid.
     let mut buffer = [0_u8; 64];

src/platform/redox/signal.rs

@@ -140,7 +140,11 @@ impl PalSignal for Sys {
     }
 }
 
-pub(crate) fn sigaction_impl(sig: i32, act: Option<&sigaction>, oact: Option<&mut sigaction>) -> Result<()> {
+pub(crate) fn sigaction_impl(
+    sig: i32,
+    act: Option<&sigaction>,
+    oact: Option<&mut sigaction>,
+) -> Result<()> {
     let new_opt = act.map(|act| {
         let m = act.sa_mask;
         let sa_handler = unsafe { mem::transmute(act.sa_handler) };
@@ -152,11 +156,7 @@ pub(crate) fn sigaction_impl(sig: i32, act: Option<&sigaction>, oact: Option<&mu
         }
     });
     let mut old_opt = oact.as_ref().map(|_| syscall::SigAction::default());
-    syscall::sigaction(
-        sig as usize,
-        new_opt.as_ref(),
-        old_opt.as_mut(),
-    )?;
+    syscall::sigaction(sig as usize, new_opt.as_ref(), old_opt.as_mut())?;
     if let (Some(old), Some(oact)) = (old_opt, oact) {
         oact.sa_handler = unsafe { mem::transmute(old.sa_handler) };
         let m = old.sa_mask;
@@ -172,11 +172,7 @@ pub(crate) fn sigprocmask_impl(how: i32, set: *const sigset_t, oset: *mut sigset
         Some([unsafe { *set as u64 }, 0])
     };
     let mut old_opt = if oset.is_null() { None } else { Some([0, 0]) };
-    syscall::sigprocmask(
-        how as usize,
-        new_opt.as_ref(),
-        old_opt.as_mut(),
-    )?;
+    syscall::sigprocmask(how as usize, new_opt.as_ref(), old_opt.as_mut())?;
     if let Some(old) = old_opt {
         unsafe { *oset = old[0] as sigset_t };
     }