Remove the "-1 errno" e() function.

src/header/sys_ioctl/redox.rs

@@ -1,9 +1,14 @@
 use core::{mem, slice};
+use redox_rt::proc::FdGuard;
 use syscall;
 
 use crate::{
-    header::{errno, fcntl, termios},
-    platform::{self, e, types::*},
+    error::{Errno, Result, ResultExt},
+    header::{
+        errno::{self, EINVAL},
+        fcntl, termios,
+    },
+    platform::{self, types::*, Pal, Sys},
 };
 
 use super::winsize;
@@ -49,123 +54,85 @@ fn dup_read<T>(fd: c_int, name: &str, t: &mut T) -> syscall::Result<usize> {
     res.map(|bytes| bytes / size)
 }
 
-fn dup_write<T>(fd: c_int, name: &str, t: &T) -> syscall::Result<usize> {
-    let dup = syscall::dup(fd as usize, name.as_bytes())?;
+// FIXME: unsound
+fn dup_write<T>(fd: c_int, name: &str, t: &T) -> Result<usize> {
+    let dup = FdGuard::new(syscall::dup(fd as usize, name.as_bytes())?);
 
     let size = mem::size_of::<T>();
 
-    let res = syscall::write(dup, unsafe {
+    let bytes_written = syscall::write(*dup, unsafe {
         slice::from_raw_parts(t as *const T as *const u8, size)
-    });
+    })?;
 
-    let _ = syscall::close(dup);
-
-    res.map(|bytes| bytes / size)
+    Ok(bytes_written / size)
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn ioctl(fd: c_int, request: c_ulong, out: *mut c_void) -> c_int {
+unsafe fn ioctl_inner(fd: c_int, request: c_ulong, out: *mut c_void) -> Result<c_int> {
     match request {
         FIONBIO => {
-            let mut flags = fcntl::fcntl(fd, fcntl::F_GETFL, 0);
-            if flags < 0 {
-                return -1;
-            }
+            let mut flags = Sys::fcntl(fd, fcntl::F_GETFL, 0)?;
             flags = if *(out as *mut c_int) == 0 {
                 flags & !fcntl::O_NONBLOCK
             } else {
                 flags | fcntl::O_NONBLOCK
             };
-            if fcntl::fcntl(fd, fcntl::F_SETFL, flags as c_ulonglong) < 0 {
-                -1
-            } else {
-                0
-            }
+            Sys::fcntl(fd, fcntl::F_SETFL, flags as c_ulonglong)?;
         }
         TCGETS => {
             let termios = &mut *(out as *mut termios::termios);
-            if e(dup_read(fd, "termios", termios)) == !0 {
-                -1
-            } else {
-                0
-            }
+            dup_read(fd, "termios", termios)?;
         }
         // TODO: give these different behaviors
         TCSETS | TCSETSW | TCSETSF => {
             let termios = &*(out as *const termios::termios);
-            if e(dup_write(fd, "termios", termios)) == !0 {
-                -1
-            } else {
-                0
-            }
+            dup_write(fd, "termios", termios)?;
         }
         TCFLSH => {
             let queue = out as c_int;
-            if e(dup_write(fd, "flush", &queue)) == !0 {
-                -1
-            } else {
-                0
-            }
+            dup_write(fd, "flush", &queue)?;
         }
         TIOCSCTTY => {
             eprintln!("TODO: ioctl TIOCSCTTY");
-            0
         }
         TIOCGPGRP => {
             let pgrp = &mut *(out as *mut pid_t);
-            if e(dup_read(fd, "pgrp", pgrp)) == !0 {
-                -1
-            } else {
-                0
-            }
+            dup_read(fd, "pgrp", pgrp)?;
         }
         TIOCSPGRP => {
             let pgrp = &*(out as *const pid_t);
-            if e(dup_write(fd, "pgrp", pgrp)) == !0 {
-                -1
-            } else {
-                0
-            }
+            dup_write(fd, "pgrp", pgrp)?;
         }
         TIOCGWINSZ => {
             let winsize = &mut *(out as *mut winsize);
-            if e(dup_read(fd, "winsize", winsize)) == !0 {
-                -1
-            } else {
-                0
-            }
+            dup_read(fd, "winsize", winsize)?;
         }
         TIOCSWINSZ => {
             let winsize = &*(out as *const winsize);
-            if e(dup_write(fd, "winsize", winsize)) == !0 {
-                -1
-            } else {
-                0
-            }
+            dup_write(fd, "winsize", winsize)?;
         }
         TIOCGPTLCK => {
             eprintln!("TODO: ioctl TIOCGPTLCK");
-            0
         }
         TIOCSPTLCK => {
             eprintln!("TODO: ioctl TIOCSPTLCK");
-            0
         }
         TCSBRK => {
             eprintln!("TODO: ioctl TCSBRK");
-            0
         }
         TCXONC => {
             eprintln!("TODO: ioctl TCXONC");
-            0
         }
         SIOCATMARK => {
             eprintln!("TODO: ioctl SIOCATMARK");
-            0
         }
         _ => {
-            platform::ERRNO.set(errno::EINVAL);
-            -1
+            return Err(Errno(EINVAL));
         }
     }
+    Ok(0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn ioctl(fd: c_int, request: c_ulong, out: *mut c_void) -> c_int {
+    ioctl_inner(fd, request, out).or_minus_one_errno()
 }

src/platform/linux/mod.rs

@@ -64,15 +64,6 @@ pub fn e_raw(sys: usize) -> Result<usize> {
         Ok(sys)
     }
 }
-pub fn e(sys: usize) -> usize {
-    match e_raw(sys) {
-        Ok(value) => value,
-        Err(Errno(errcode)) => {
-            ERRNO.set(errcode as c_int);
-            !0
-        }
-    }
-}
 
 pub struct Sys;
 

src/platform/linux/signal.rs

@@ -3,7 +3,7 @@ use core::{mem, ptr::addr_of};
 
 use super::{
     super::{types::*, PalSignal},
-    e, e_raw, Sys,
+    e_raw, Sys,
 };
 use crate::{
     error::{Errno, Result},

src/platform/mod.rs

@@ -13,7 +13,7 @@ pub use self::pal::{Pal, PalEpoll, PalPtrace, PalSignal, PalSocket};
 
 mod pal;
 
-pub use self::sys::{e, Sys};
+pub use self::sys::Sys;
 
 #[cfg(all(not(feature = "no_std"), target_os = "linux"))]
 #[path = "linux/mod.rs"]

src/platform/redox/extra.rs

@@ -1,16 +1,22 @@
 use core::{ptr, slice};
 
-use crate::platform::{sys::e, types::*};
+use crate::{
+    error::{Errno, ResultExt},
+    platform::types::*,
+};
 use syscall::{error::*, F_SETFD, F_SETFL};
 
 pub use redox_rt::proc::FdGuard;
 
 #[no_mangle]
 pub unsafe extern "C" fn redox_fpath(fd: c_int, buf: *mut c_void, count: size_t) -> ssize_t {
-    e(syscall::fpath(
+    syscall::fpath(
         fd as usize,
         slice::from_raw_parts_mut(buf as *mut u8, count),
-    )) as ssize_t
+    )
+    .map_err(Errno::from)
+    .map(|l| l as ssize_t)
+    .or_minus_one_errno()
 }
 
 pub fn pipe2(fds: &mut [c_int], flags: usize) -> syscall::error::Result<()> {

src/platform/redox/mod.rs

@@ -74,17 +74,6 @@ macro_rules! path_from_c_str {
 
 use self::{exec::Executable, path::canonicalize};
 
-// TODO: Remove
-pub fn e(sys: syscall::error::Result<usize>) -> usize {
-    match sys {
-        Ok(ok) => ok,
-        Err(err) => {
-            ERRNO.set(err.errno as c_int);
-            !0
-        }
-    }
-}
-
 pub struct Sys;
 
 impl Pal for Sys {

src/platform/redox/signal.rs

@@ -1,6 +1,6 @@
 use super::{
     super::{types::*, Pal, PalSignal},
-    e, Sys,
+    Sys,
 };
 use crate::{
     error::{Errno, Result},

src/platform/redox/socket.rs

@@ -5,7 +5,7 @@ use syscall::{self, flag::*};
 
 use super::{
     super::{types::*, Pal, PalSocket, ERRNO},
-    e, Sys,
+    Sys,
 };
 use crate::{
     error::{Errno, Result, ResultExt},