[Teton] Move console/shell to rust. WIP

rust/lib/mammoth/src/mem.rs

@@ -1,4 +1,6 @@
 use crate::syscall;
+use crate::zion::{z_cap_t, ZError};
+use alloc::slice;
 use linked_list_allocator::LockedHeap;
 
 #[global_allocator]
@@ -16,3 +18,57 @@ pub fn init_heap() {
         CAN_ALLOC = true;
     }
 }
+
+pub struct MemoryRegion {
+    mem_cap: z_cap_t,
+    virt_addr: u64,
+    size: u64,
+}
+
+impl MemoryRegion {
+    pub fn direct_physical(paddr: u64, size: u64) -> Result<Self, ZError> {
+        let mem_cap = syscall::memory_object_direct_physical(paddr, size)?;
+        let virt_addr = syscall::address_space_map(mem_cap)?;
+        Ok(Self {
+            mem_cap,
+            virt_addr,
+            size,
+        })
+    }
+
+    pub fn from_cap(mem_cap: z_cap_t) -> Result<Self, ZError> {
+        let virt_addr = syscall::address_space_map(mem_cap)?;
+        let size = syscall::memory_object_inspect(mem_cap)?;
+        Ok(Self {
+            mem_cap,
+            virt_addr,
+            size,
+        })
+    }
+
+    pub fn slice<T>(&self) -> &[T] {
+        unsafe {
+            slice::from_raw_parts(
+                self.virt_addr as *const T,
+                self.size as usize / size_of::<T>(),
+            )
+        }
+    }
+
+    pub fn mut_slice<T>(&self) -> &mut [T] {
+        unsafe {
+            slice::from_raw_parts_mut(
+                self.virt_addr as *mut T,
+                self.size as usize / size_of::<T>(),
+            )
+        }
+    }
+}
+
+impl Drop for MemoryRegion {
+    fn drop(&mut self) {
+        syscall::address_space_unmap(self.virt_addr, self.virt_addr + self.size)
+            .expect("Failed to unmap memory");
+        syscall::cap_release(self.mem_cap).expect("Failed to release memory cap");
+    }
+}

rust/lib/mammoth/src/syscall.rs

@@ -89,6 +89,31 @@ pub fn memory_object_create(size: u64) -> Result<z_cap_t, ZError> {
     Ok(vmmo_cap)
 }
 
+pub fn memory_object_direct_physical(paddr: u64, size: u64) -> Result<z_cap_t, ZError> {
+    let mut vmmo_cap = 0;
+    syscall(
+        zion::kZionMemoryObjectCreatePhysical,
+        &zion::ZMemoryObjectCreatePhysicalReq {
+            paddr,
+            size,
+            vmmo_cap: &mut vmmo_cap,
+        },
+    )?;
+    Ok(vmmo_cap)
+}
+
+pub fn memory_object_inspect(mem_cap: z_cap_t) -> Result<u64, ZError> {
+    let mut mem_size = 0;
+    syscall(
+        zion::kZionMemoryObjectInspect,
+        &zion::ZMemoryObjectInspectReq {
+            vmmo_cap: mem_cap,
+            size: &mut mem_size,
+        },
+    )?;
+    Ok(mem_size)
+}
+
 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.
@@ -104,6 +129,17 @@ pub fn address_space_map(vmmo_cap: z_cap_t) -> Result<u64, ZError> {
     Ok(vaddr)
 }
 
+pub fn address_space_unmap(lower_addr: u64, upper_addr: u64) -> Result<(), ZError> {
+    syscall(
+        zion::kZionAddressSpaceUnmap,
+        &zion::ZAddressSpaceUnmapReq {
+            vmas_cap: unsafe { crate::init::SELF_VMAS_CAP },
+            lower_addr,
+            upper_addr,
+        },
+    )
+}
+
 pub fn port_poll(
     port_cap: z_cap_t,
     bytes: &mut [u8],
@@ -211,3 +247,7 @@ pub fn reply_port_recv(
 
     Ok((num_bytes, num_caps))
 }
+
+pub fn cap_release(cap: z_cap_t) -> Result<(), ZError> {
+    syscall(zion::kZionCapRelease, &zion::ZCapReleaseReq { cap })
+}