Reorganize mammoth lib in rust.

rust/lib/mammoth/src/syscall.rs

@@ -1,85 +1,15 @@
 extern crate alloc;
 
-use alloc::string::String;
-use alloc::vec::Vec;
+use crate::zion;
 use core::ffi::c_void;
-use core::fmt;
 use core::panic::PanicInfo;
 
-include!("bindings.rs");
-
-pub enum ZError {
-    UNKNOWN = 0x0,
-    // First set of error codes generally indicate user errors.
-    INVALID_ARGUMENT = 0x1,
-    NOT_FOUND = 0x2,
-    PERMISSION_DENIED = 0x3,
-    NULL_PTR = 0x4,
-    EMPTY = 0x5,
-    ALREADY_EXISTS = 0x6,
-    BUFFER_SIZE = 0x7,
-    FAILED_PRECONDITION = 0x8,
-
-    // Second set of error codes generally indicate service errors.
-    INTERNAL = 0x100,
-    UNIMPLEMENTED = 0x101,
-    EXHAUSTED = 0x102,
-    INVALID_RESPONSE = 0x103,
-
-    // Kernel specific error codes (relating to capabilities).
-    CAP_NOT_FOUND = 0x1000,
-    CAP_WRONG_TYPE = 0x1001,
-    CAP_PERMISSION_DENIED = 0x1002,
-}
-
-impl From<u64> for ZError {
-    fn from(value: u64) -> Self {
-        match value {
-            0x1 => ZError::INVALID_ARGUMENT,
-            0x2 => ZError::NOT_FOUND,
-            0x3 => ZError::PERMISSION_DENIED,
-            0x4 => ZError::NULL_PTR,
-            0x5 => ZError::EMPTY,
-            0x6 => ZError::ALREADY_EXISTS,
-            0x7 => ZError::BUFFER_SIZE,
-            0x8 => ZError::FAILED_PRECONDITION,
-
-            0x100 => ZError::INTERNAL,
-            0x101 => ZError::UNIMPLEMENTED,
-            0x102 => ZError::EXHAUSTED,
-            0x103 => ZError::INVALID_RESPONSE,
-
-            0x1000 => ZError::CAP_NOT_FOUND,
-            0x1001 => ZError::CAP_WRONG_TYPE,
-            0x1002 => ZError::CAP_PERMISSION_DENIED,
-            _ => ZError::UNKNOWN,
-        }
-    }
-}
-
-impl fmt::Debug for ZError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let str = match self {
-            ZError::INVALID_ARGUMENT => "INVALID_ARGUMENT",
-            ZError::BUFFER_SIZE => "BUFFER_SIZE",
-            ZError::INTERNAL => "INTERNAL",
-            ZError::UNIMPLEMENTED => "UNIMPLEMENTED",
-            ZError::INVALID_RESPONSE => "INVALID_RESPONSE",
-            ZError::CAP_NOT_FOUND => "CAP_NOT_FOUND",
-            ZError::CAP_WRONG_TYPE => "CAP_WRONG_TYPE",
-            ZError::CAP_PERMISSION_DENIED => "CAP_PERMISSION_DENIED",
-            _ => "ZError",
-        };
-        f.write_str(str)
-    }
-}
-
 #[must_use]
-pub fn syscall<T>(id: u64, req: &T) -> Result<(), ZError> {
+pub fn syscall<T>(id: u64, req: &T) -> Result<(), zion::ZError> {
     unsafe {
-        let resp = SysCall1(id, req as *const T as *const c_void);
+        let resp = zion::SysCall1(id, req as *const T as *const c_void);
         if resp != 0 {
-            return Err(ZError::from(resp));
+            return Err(zion::ZError::from(resp));
         }
     }
     Ok(())
@@ -95,60 +25,15 @@ fn panic(info: &PanicInfo) -> ! {
         }
     }
     // Internal error.
-    let req = ZProcessExitReq { code: 0x100 };
-    let _ = syscall(kZionProcessExit, &req);
+    let req = zion::ZProcessExitReq { code: 0x100 };
+    let _ = syscall(zion::kZionProcessExit, &req);
     unreachable!()
 }
 
 pub fn debug(msg: &str) {
-    let req = ZDebugReq {
+    let req = zion::ZDebugReq {
         message: msg.as_ptr() as *const i8,
         size: msg.len() as u64,
     };
-    syscall(kZionDebug, &req).expect("Failed to write");
-}
-
-pub struct Writer {
-    int_vec: Vec<u8>,
-}
-
-impl Writer {
-    pub fn new() -> Self {
-        Self {
-            int_vec: Vec::new(),
-        }
-    }
-}
-
-impl Into<String> for Writer {
-    fn into(self) -> String {
-        String::from_utf8(self.int_vec).expect("Failed to convert")
-    }
-}
-
-impl fmt::Write for Writer {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        for c in s.bytes() {
-            self.int_vec.push(c);
-        }
-        fmt::Result::Ok(())
-    }
-}
-
-#[macro_export]
-macro_rules! debug {
-    () => {
-        $crate::syscall::debug("");
-    };
-    ($fmt:literal) => {
-        $crate::syscall::debug($fmt);
-    };
-    ($fmt:literal, $($val:expr),+) => {{
-        use core::fmt::Write as _;
-        use alloc::string::String;
-        let mut w = $crate::syscall::Writer::new();
-        write!(&mut w, $fmt, $($val),*).expect("Failed to format");
-        let s: String = w.into();
-        $crate::syscall::debug(&s);
-    }};
+    syscall(zion::kZionDebug, &req).expect("Failed to write");
 }