Moves EINTR and EIO to Kernel

Author: ultimaweapon

kernel-1100/src/lib.rs

@@ -10,6 +10,7 @@ use self::thread::Thread;
 use self::ucred::Ucred;
 use self::uio::Uio;
 use core::ffi::{c_char, c_int};
+use core::num::NonZero;
 use okf::fd::OpenFlags;
 use okf::malloc::MallocFlags;
 use okf::queue::TailQueue;
@@ -34,6 +35,8 @@ pub struct Kernel(*const u8);
 impl okf::Kernel for Kernel {
     #[offset(0x221CCF8)]
     const ACCEPT_MTX: StaticMut<Self::Mtx>;
+    const EINTR: NonZero<c_int> = unsafe { NonZero::new_unchecked(4) };
+    const EIO: NonZero<c_int> = unsafe { NonZero::new_unchecked(5) };
     #[offset(0x15415B0)]
     const M_TEMP: StaticMut<Self::Malloc>;
     const MBF_MNTLSTLOCK: c_int = 2;

src/errno/mod.rs

@@ -1,9 +1,6 @@
 use core::ffi::c_int;
 use core::num::NonZero;
 
-pub const EINTR: Errno = unsafe { Errno(NonZero::new_unchecked(4)) };
-pub const EIO: Errno = unsafe { Errno(NonZero::new_unchecked(5)) };
-
 /// Encapsulates an errno value.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Errno(NonZero<c_int>);

src/fd/mod.rs

@@ -1,11 +1,12 @@
-use crate::errno::{Errno, EINTR, EIO};
+use crate::errno::Errno;
 use crate::pcpu::Pcpu;
 use crate::thread::Thread;
 use crate::uio::{IoVec, Uio, UioRw, UioSeg};
 use crate::Kernel;
 use bitflags::bitflags;
 use core::ffi::{c_char, c_int};
 use core::marker::PhantomData;
+use core::num::NonZero;
 
 pub const AT_FDCWD: c_int = -100;
 
@@ -42,16 +43,16 @@ pub unsafe fn write_all<K: Kernel>(
     mut data: &[u8],
     seg: UioSeg,
     td: *mut K::Thread,
-) -> Result<(), Errno> {
+) -> Result<(), NonZero<c_int>> {
     while !data.is_empty() {
         let written = match write(kern, fd, data, seg, td) {
             Ok(v) => v,
-            Err(EINTR) => continue,
+            Err(e) if e == K::EINTR => continue,
             Err(e) => return Err(e),
         };
 
         if written == 0 {
-            return Err(EIO);
+            return Err(K::EIO);
         }
 
         data = &data[written..];
@@ -69,7 +70,7 @@ pub unsafe fn write<K: Kernel>(
     data: &[u8],
     seg: UioSeg,
     td: *mut K::Thread,
-) -> Result<usize, Errno> {
+) -> Result<usize, NonZero<c_int>> {
     // Setup iovec.
     let mut vec = IoVec {
         ptr: data.as_ptr().cast_mut(),
@@ -80,7 +81,7 @@ pub unsafe fn write<K: Kernel>(
     let mut uio = K::Uio::new(td, UioRw::Write, seg, &mut vec, 1).unwrap();
     let errno = kern.kern_writev(td, fd, &mut uio);
 
-    match Errno::new(errno) {
+    match NonZero::new(errno) {
         Some(v) => Err(v),
         None => Ok((*td).ret(0)),
     }

src/lib.rs

@@ -14,6 +14,7 @@ use self::uio::{Uio, UioSeg};
 use core::alloc::{GlobalAlloc, Layout};
 use core::ffi::{c_char, c_int};
 use core::marker::PhantomData;
+use core::num::NonZero;
 use core::ops::Deref;
 use core::ptr::{null_mut, read_unaligned, write_unaligned};
 pub use okf_macros::*;
@@ -45,6 +46,8 @@ macro_rules! kernel {
 /// Some modules may provide high-level wrappers that are easy to use.
 pub trait Kernel: MappedKernel {
     const ACCEPT_MTX: StaticMut<Self::Mtx>;
+    const EINTR: NonZero<c_int>;
+    const EIO: NonZero<c_int>;
     const M_TEMP: StaticMut<Self::Malloc>;
     const MBF_MNTLSTLOCK: c_int;
     const MBF_NOWAIT: c_int;