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()
 }