Move more syscall usages to helper functions.

rust/lib/mammoth/src/init.rs

@@ -1,7 +1,5 @@
 use crate::syscall;
-use crate::zion;
 use crate::zion::z_cap_t;
-use core::ffi::c_void;
 
 // From /zion/include/ztypes.h
 const Z_INIT_SELF_PROC: u64 = 0x4000_0000;
@@ -14,22 +12,16 @@ pub static mut INIT_ENDPOINT: z_cap_t = 0;
 
 pub fn parse_init_port(port_cap: z_cap_t) {
     loop {
-        let mut num_bytes: u64 = 8;
+        let mut bytes: [u8; 8] = [0; 8];
-        let mut init_sig: u64 = 0;
         let mut caps: [u64; 1] = [0];
-        let mut num_caps: u64 = 1;
 
-        let req = zion::ZPortPollReq {
+        let resp = syscall::port_poll(port_cap, &mut bytes, &mut caps);
-            port_cap,
-            num_bytes: &mut num_bytes as *mut u64,
-            data: &mut init_sig as *mut u64 as *mut c_void,
-            caps: &mut caps as *mut u64,
-            num_caps: &mut num_caps as *mut u64,
-        };
-        let resp = syscall::syscall(zion::kZionPortPoll, &req);
         if let Err(_) = resp {
             break;
         }
+
+        let init_sig = u64::from_le_bytes(bytes);
+
         unsafe {
             match init_sig {
                 Z_INIT_SELF_PROC => SELF_PROC_CAP = caps[0],

rust/lib/mammoth/src/mem.rs

@@ -1,6 +1,4 @@
-use crate::init::SELF_VMAS_CAP;
 use crate::syscall;
-use crate::zion;
 use linked_list_allocator::LockedHeap;
 
 #[global_allocator]
@@ -11,24 +9,8 @@ pub static mut CAN_ALLOC: bool = false;
 pub fn init_heap() {
     // 1 MiB
     let size = 0x10_0000;
-    let mut vmmo_cap = 0;
+    let vmmo_cap = syscall::memory_object_create(size).expect("Failed to create memory object");
-    let obj_req = zion::ZMemoryObjectCreateReq {
+    let vaddr = syscall::address_space_map(vmmo_cap).expect("Failed to map memory object");
-        size,
-        vmmo_cap: &mut vmmo_cap as *mut u64,
-    };
-    syscall::syscall(zion::kZionMemoryObjectCreate, &obj_req)
-        .expect("Failed to create memory object");
-
-    let mut vaddr: u64 = 0;
-    let vmas_req = zion::ZAddressSpaceMapReq {
-        vmmo_cap,
-        vmas_cap: unsafe { SELF_VMAS_CAP },
-        align: 0x2000,
-        vaddr: &mut vaddr as *mut u64,
-        vmas_offset: 0,
-    };
-
-    syscall::syscall(zion::kZionAddressSpaceMap, &vmas_req).expect("Failed to map memory object");
     unsafe {
         ALLOCATOR.lock().init(vaddr as *mut u8, size as usize);
         CAN_ALLOC = true;

rust/lib/mammoth/src/syscall.rs

@@ -72,3 +72,46 @@ pub fn thread_exit() -> ! {
     let _ = syscall(zion::kZionThreadExit, &zion::ZThreadExitReq {});
     unreachable!();
 }
+
+pub fn memory_object_create(size: u64) -> Result<z_cap_t, ZError> {
+    let mut vmmo_cap = 0;
+    let obj_req = zion::ZMemoryObjectCreateReq {
+        size,
+        vmmo_cap: &mut vmmo_cap as *mut u64,
+    };
+    syscall(zion::kZionMemoryObjectCreate, &obj_req)?;
+    Ok(vmmo_cap)
+}
+
+pub fn address_space_map(vmmo_cap: z_cap_t) -> Result<u64, ZError> {
+    let mut vaddr: u64 = 0;
+    // FIXME: Allow caller to pass these options.
+    let vmas_req = zion::ZAddressSpaceMapReq {
+        vmmo_cap,
+        vmas_cap: unsafe { crate::init::SELF_VMAS_CAP },
+        align: 0x2000,
+        vaddr: &mut vaddr as *mut u64,
+        vmas_offset: 0,
+    };
+
+    syscall(zion::kZionAddressSpaceMap, &vmas_req)?;
+    Ok(vaddr)
+}
+
+pub fn port_poll(
+    port_cap: z_cap_t,
+    bytes: &mut [u8],
+    caps: &mut [u64],
+) -> Result<(u64, u64), ZError> {
+    let mut num_bytes = bytes.len() as u64;
+    let mut num_caps = caps.len() as u64;
+    let req = zion::ZPortPollReq {
+        port_cap,
+        data: bytes.as_mut_ptr() as *mut c_void,
+        num_bytes: &mut num_bytes as *mut u64,
+        caps: caps.as_mut_ptr(),
+        num_caps: &mut num_caps as *mut u64,
+    };
+    syscall(zion::kZionPortPoll, &req)?;
+    Ok((num_bytes, num_caps))
+}