From ea3a473c9f5b6ae27773f979cde694faaa4dc59a Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Mon, 3 Aug 2020 17:40:57 +0800 Subject: [PATCH] reworking memory allocation The kernel should run in a `no_std` environment, which means it must currently run without `alloc`. We have our own allocation methods when running on baremetal hardware. Begin the work to break out the allocation method so that it will work on both desktop and baremetal environments. Signed-off-by: Sean Cross --- examples/log/.cargo/config | 2 +- examples/log/src/main.rs | 134 ++++++++++++++++++++++++------------- kernel/src/mem.rs | 4 +- kernel/src/server.rs | 12 ++-- kernel/src/syscall.rs | 12 ++-- xous-rs/Cargo.toml | 5 -- xous-rs/src/arch/hosted.rs | 43 +++++++++--- xous-rs/src/arch/native.rs | 47 +++++++++---- xous-rs/src/carton.rs | 35 ++++++---- xous-rs/src/definitions.rs | 12 ++-- xous-rs/src/lib.rs | 4 +- xous-rs/src/syscall.rs | 128 +++++++++++++++++++++++------------ 12 files changed, 287 insertions(+), 151 deletions(-) diff --git a/examples/log/.cargo/config b/examples/log/.cargo/config index b13ae33f2..478c166b7 100644 --- a/examples/log/.cargo/config +++ b/examples/log/.cargo/config @@ -10,4 +10,4 @@ rustflags = [ ] [build] -#target = "riscv32imac-unknown-none-elf" +target = "riscv32imac-unknown-none-elf" diff --git a/examples/log/src/main.rs b/examples/log/src/main.rs index 904387b92..ed5036c8e 100644 --- a/examples/log/src/main.rs +++ b/examples/log/src/main.rs @@ -80,7 +80,7 @@ mod implementation { mod implementation { use core::fmt::{Error, Write}; use pancurses::{endwin, initscr, Window}; - use std::sync::mpsc::{channel, Sender, Receiver}; + use std::sync::mpsc::{channel, Receiver, Sender}; enum ControlMessage { Text(String), @@ -109,15 +109,13 @@ mod implementation { pub fn run(&mut self) { loop { match self.rx.recv_timeout(std::time::Duration::from_millis(50)) { - Ok(msg) => { - match msg { - ControlMessage::Exit => break, - ControlMessage::Text(s) => { - self.window.as_ref().unwrap().printw(s); - self.window.as_ref().unwrap().refresh(); - } + Ok(msg) => match msg { + ControlMessage::Exit => break, + ControlMessage::Text(s) => { + self.window.as_ref().unwrap().printw(s); + self.window.as_ref().unwrap().refresh(); } - } + }, Err(std::sync::mpsc::RecvTimeoutError::Timeout) => { // Calling `getch` refreshes the screen self.window.as_ref().unwrap().getch(); @@ -128,7 +126,9 @@ mod implementation { } pub fn get_writer(&self) -> OutputWriter { - OutputWriter { tx: self.tx.clone() } + OutputWriter { + tx: self.tx.clone(), + } } } @@ -142,9 +142,7 @@ mod implementation { impl Write for Output { fn write_str(&mut self, s: &str) -> Result<(), Error> { // It would be nice if this worked with &str - self.tx - .send(ControlMessage::Text(s.to_owned())) - .unwrap(); + self.tx.send(ControlMessage::Text(s.to_owned())).unwrap(); Ok(()) } } @@ -156,9 +154,7 @@ mod implementation { impl Write for OutputWriter { fn write_str(&mut self, s: &str) -> Result<(), Error> { // It would be nice if this worked with &str - self.tx - .send(ControlMessage::Text(s.to_owned())) - .unwrap(); + self.tx.send(ControlMessage::Text(s.to_owned())).unwrap(); Ok(()) } } @@ -166,8 +162,58 @@ mod implementation { #[cfg(baremetal)] mod implementation { + use core::fmt::{Error, Write}; + pub struct Output { - addr: *mut u32, + addr: usize, + } + + pub fn init() -> Output { + let uart = xous::syscall::map_memory( + xous::MemoryAddress::new(0xf000_4000), + None, + 4096, + xous::MemoryFlags::R | xous::MemoryFlags::W, + ) + .expect("couldn't map serial port"); + unsafe { crate::debug::DEFAULT_UART_ADDR = uart.as_mut_ptr() as _ }; + println!("Mapped UART @ {:08x}", uart.addr.get()); + + println!("Process: map success!"); + crate::debug::DEFAULT.enable_rx(); + + println!("Allocating IRQ..."); + xous::syscall::claim_interrupt(4, handle_irq, core::ptr::null_mut::()) + .expect("couldn't claim interrupt"); + Output { + addr: uart.as_mut_ptr() as usize, + } + } + + impl Output { + pub fn get_writer(&self) -> OutputWriter { + OutputWriter { } + } + + pub fn run(&mut self) { + loop { + xous::wait_event(); + // match self.rx.recv_timeout(std::time::Duration::from_millis(50)) { + // Ok(msg) => match msg { + // ControlMessage::Exit => break, + // ControlMessage::Text(s) => { + // self.window.as_ref().unwrap().printw(s); + // self.window.as_ref().unwrap().refresh(); + // } + // }, + // Err(std::sync::mpsc::RecvTimeoutError::Timeout) => { + // // Calling `getch` refreshes the screen + // self.window.as_ref().unwrap().getch(); + // } + // Err(e) => panic!("Error: {}", e), + // } + } + } } use core::panic::PanicInfo; @@ -189,29 +235,33 @@ mod implementation { println!(); } - pub fn init() -> Output { - let uart = xous::syscall::map_memory( - xous::MemoryAddress::new(0xf000_4000), - None, - 4096, - xous::MemoryFlags::R | xous::MemoryFlags::W, - ) - .expect("couldn't map serial port"); - unsafe { crate::debug::DEFAULT_UART_ADDR = uart.as_mut_ptr() }; - println!("Mapped UART @ {:08x}", uart.addr.get()); + pub struct OutputWriter { + } - println!("Process: map success!"); - crate::debug::DEFAULT.enable_rx(); + impl OutputWriter { + pub fn putc(&self, c: u8) { + unsafe { + let base = crate::debug::DEFAULT_UART_ADDR; + // Wait until TXFULL is `0` + while base.add(1).read_volatile() != 0 {} + base.add(0).write_volatile(c as usize) + }; + } + } - println!("Allocating IRQ..."); - xous::syscall::claim_interrupt(4, handle_irq, core::ptr::null_mut::()) - .expect("couldn't claim interrupt"); + impl Write for OutputWriter { + fn write_str(&mut self, s: &str) -> Result<(), Error> { + for c in s.bytes() { + self.putc(c); + } + Ok(()) + } } } -fn reader_thread(output: &mut implementation::OutputWriter) { +fn reader_thread(mut output: implementation::OutputWriter) { writeln!(output, "Xous Logging Server starting up...").unwrap(); - std::thread::sleep(std::time::Duration::from_secs(1)); + // std::thread::sleep(std::time::Duration::from_secs(1)); writeln!(output, "Starting log server...").unwrap(); let server_addr = xous::create_server(b"xous-logs-output").unwrap(); @@ -229,12 +279,7 @@ fn reader_thread(output: &mut implementation::OutputWriter) { writeln!(output, "Got message envelope: {:?}", envelope).unwrap(); match &mut envelope.message { xous::Message::Scalar(msg) => { - writeln!( - output, - "Scalar message from {}: {:?}", - envelope.sender, msg - ) - .unwrap(); + writeln!(output, "Scalar message from {}: {:?}", envelope.sender, msg).unwrap(); } xous::Message::Move(msg) => { let log_entry = LogString::from_message(msg); @@ -269,12 +314,11 @@ fn reader_thread(output: &mut implementation::OutputWriter) { } #[cfg_attr(baremetal, no_mangle)] -fn main() -> Result<(), xous::Error> { +fn main() { let mut output = implementation::init(); - let mut writer = output.get_writer(); - xous::arch::ensure_connection().unwrap(); - xous::create_thread(move || reader_thread(&mut writer)).unwrap(); + let writer = output.get_writer(); + // xous::arch::ensure_connection().unwrap(); + xous::create_thread_simple(reader_thread, writer).unwrap(); output.run(); - Ok(()) } diff --git a/kernel/src/mem.rs b/kernel/src/mem.rs index e1fd40258..ed568e1de 100644 --- a/kernel/src/mem.rs +++ b/kernel/src/mem.rs @@ -342,7 +342,7 @@ impl MemoryManager { // FIXME: Un-reserve addresses if we encounter an error here mm.reserve_address(self, virt, flags)?; } - Ok(xous::MemoryRange::new(virt_ptr as usize, size)) + Ok(xous::MemoryRange::new(virt_ptr as usize, size)?) } /// Attempt to allocate a single page from the default section. @@ -440,7 +440,7 @@ impl MemoryManager { } } - Ok(MemoryRange::new(virt as usize, size)) + Ok(MemoryRange::new(virt as usize, size)?) } /// Attempt to map the given physical address into the virtual address space diff --git a/kernel/src/server.rs b/kernel/src/server.rs index dd1494460..b14f3cb3f 100644 --- a/kernel/src/server.rs +++ b/kernel/src/server.rs @@ -299,7 +299,7 @@ impl Server { return Ok(WaitingMessage::ForgetMemory(MemoryRange::new( server_addr, len, - ))); + )?)); } // If a `move` address somehow ends up here, indicate the memory has been moved. @@ -353,7 +353,7 @@ impl Server { sender: self.queue_tail | (server_idx << 16), message: xous::Message::Borrow(xous::MemoryMessage { id, - buf: MemoryRange::new(buf, buf_size), + buf: MemoryRange::new(buf, buf_size).ok()?, offset: MemorySize::new(offset), valid: MemorySize::new(valid), }), @@ -379,7 +379,7 @@ impl Server { sender: self.queue_tail | (server_idx << 16), message: xous::Message::MutableBorrow(xous::MemoryMessage { id, - buf: MemoryRange::new(buf, buf_size), + buf: MemoryRange::new(buf, buf_size).ok()?, offset: MemorySize::new(offset), valid: MemorySize::new(valid), }), @@ -405,7 +405,7 @@ impl Server { sender: self.queue_tail | (server_idx << 16), message: xous::Message::Borrow(xous::MemoryMessage { id, - buf: MemoryRange::new(buf, buf_size), + buf: MemoryRange::new(buf, buf_size).ok()?, offset: MemorySize::new(offset), valid: MemorySize::new(valid), }), @@ -431,7 +431,7 @@ impl Server { sender: self.queue_tail | (server_idx << 16), message: xous::Message::MutableBorrow(xous::MemoryMessage { id, - buf: MemoryRange::new(buf, buf_size), + buf: MemoryRange::new(buf, buf_size).ok()?, offset: MemorySize::new(offset), valid: MemorySize::new(valid), }), @@ -457,7 +457,7 @@ impl Server { sender: make_sender(pid, ctx), message: xous::Message::Move(xous::MemoryMessage { id, - buf: MemoryRange::new(buf, buf_size), + buf: MemoryRange::new(buf, buf_size).ok()?, offset: MemorySize::new(offset), valid: MemorySize::new(valid), }), diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index 46a297553..25a9f2190 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -44,7 +44,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes ( Message::Move(MemoryMessage { id: msg.id, - buf: MemoryRange::new(new_virt as usize, msg.buf.len()), + buf: MemoryRange::new(new_virt as usize, msg.buf.len())?, offset: msg.offset, valid: msg.valid, }), @@ -62,7 +62,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes ( Message::MutableBorrow(MemoryMessage { id: msg.id, - buf: MemoryRange::new(new_virt as usize, msg.buf.len()), + buf: MemoryRange::new(new_virt as usize, msg.buf.len())?, offset: msg.offset, valid: msg.valid, }), @@ -88,7 +88,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes ( Message::Borrow(MemoryMessage { id: msg.id, - buf: MemoryRange::new(new_virt as usize, msg.buf.len()), + buf: MemoryRange::new(new_virt as usize, msg.buf.len())?, offset: msg.offset, valid: msg.valid, }), @@ -381,11 +381,11 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { Ok(xous::Result::MemoryRange(range)) } - SysCall::UnmapMemory(virt, size) => { + SysCall::UnmapMemory(range) => { let mut mm = MemoryManagerHandle::get(); let mut result = Ok(xous::Result::Ok); - let virt = virt.get(); - let size = size.get(); + let virt = range.as_ptr() as usize; + let size = range.len(); if virt & 0xfff != 0 { return Err(xous::Error::BadAlignment); } diff --git a/xous-rs/Cargo.toml b/xous-rs/Cargo.toml index 0cecb5757..893fe1fad 100644 --- a/xous-rs/Cargo.toml +++ b/xous-rs/Cargo.toml @@ -7,11 +7,6 @@ description = "System call interface for Xous" [dependencies] bitflags = "1.2.1" -num-derive = "0.3.0" - -[dependencies.num-traits] -version = "0.2" -default-features = false [features] # If this is set, then the "Drop" feature of MemoryMessage structs diff --git a/xous-rs/src/arch/hosted.rs b/xous-rs/src/arch/hosted.rs index 36155a84c..b202794a0 100644 --- a/xous-rs/src/arch/hosted.rs +++ b/xous-rs/src/arch/hosted.rs @@ -164,7 +164,7 @@ pub fn create_process_post( panic!("unrecognized platform -- don't know how to shell out"); }; - println!("Launching process..."); + // println!("Launching process..."); let result = Command::new(shell) .args(&args) .env("XOUS_SERVER", server_env) @@ -174,7 +174,7 @@ pub fn create_process_post( .spawn() .map(ProcessHandle) .map_err(|e| { - eprintln!("couldn't start command: {}", e); + // eprintln!("couldn't start command: {}", e); crate::Error::InternalError }); // println!("Process result: {:?}", result); @@ -301,6 +301,29 @@ fn xous_address() -> SocketAddr { .unwrap_or_else(default_xous_address) } +pub fn create_thread_simple_pre( + _f: &fn(T) -> U, + _arg: &T, +) -> core::result::Result +where + T: Send + 'static, + U: Send + 'static, +{ + Ok(ThreadInit {}) +} + +pub fn create_thread_simple_post( + f: fn(T) -> U, + arg: T, + thread_id: TID, +) -> core::result::Result, crate::Error> +where + T: Send + 'static, + U: Send + 'static, +{ + create_thread_post(move || f(arg), thread_id) +} + pub fn create_thread_pre(_f: &F) -> core::result::Result where F: FnOnce() -> T, @@ -310,14 +333,14 @@ where Ok(ThreadInit {}) } -pub fn create_thread_post( +pub fn create_thread_post( f: F, thread_id: TID, -) -> core::result::Result, crate::Error> +) -> core::result::Result, crate::Error> where - F: FnOnce() -> T, + F: FnOnce() -> U, F: Send + 'static, - T: Send + 'static, + U: Send + 'static, { let server_address = xous_address(); let server_connection = @@ -382,10 +405,10 @@ fn xous_connect_impl( }) } Err(e) => { - eprintln!("Unable to connect to Xous server: {}", e); - eprintln!( - "Ensure Xous is running, or specify this process as an argument to the kernel" - ); + // eprintln!("Unable to connect to Xous server: {}", e); + // eprintln!( + // "Ensure Xous is running, or specify this process as an argument to the kernel" + // ); Err(()) } } diff --git a/xous-rs/src/arch/native.rs b/xous-rs/src/arch/native.rs index 08480fe97..8294162ab 100644 --- a/xous-rs/src/arch/native.rs +++ b/xous-rs/src/arch/native.rs @@ -1,4 +1,4 @@ -use crate::{Error, MemoryAddress, PID, TID}; +use crate::{MemoryAddress, PID, TID}; use core::convert::TryInto; #[derive(Debug, Clone, Copy, PartialEq)] @@ -47,13 +47,13 @@ pub fn thread_to_args(call: usize, init: ThreadInit) -> [usize; 8] { /// that were passed via registers and converts them into a `ThreadInit` /// struct with enough information to start the new thread. pub fn args_to_thread( - a1: usize, - a2: usize, - a3: usize, - a4: usize, - a5: usize, - a6: usize, - a7: usize, + _a1: usize, + _a2: usize, + _a3: usize, + _a4: usize, + _a5: usize, + _a6: usize, + _a7: usize, ) -> core::result::Result { todo!() // let call = unsafe { core::mem::transmute:: usize; @@ -126,10 +126,10 @@ pub fn process_to_args(call: usize, init: &ProcessInit) -> [usize; 8] { } pub fn args_to_process( - a1: usize, - a2: usize, - a3: usize, - a4: usize, + _a1: usize, + _a2: usize, + _a3: usize, + _a4: usize, _a5: usize, _a6: usize, _a7: usize, @@ -137,6 +137,29 @@ pub fn args_to_process( todo!() } +pub fn create_thread_simple_pre( + _f: &fn(T) -> U, + _arg: &T, +) -> core::result::Result +where + T: Send + 'static, + U: Send + 'static, +{ + todo!() +} + +pub fn create_thread_simple_post( + _f: fn(T) -> U, + _arg: T, + thread_id: TID, +) -> core::result::Result, crate::Error> +where + T: Send + 'static, + U: Send + 'static, +{ + todo!() +} + /// If no connection exists, create a new connection to the server. This means /// our parent PID will be PID1. Otherwise, reuse the same connection. pub fn create_process_pre(_args: &ProcessArgs) -> core::result::Result { diff --git a/xous-rs/src/carton.rs b/xous-rs/src/carton.rs index 083e4f4ac..c83ff6e17 100644 --- a/xous-rs/src/carton.rs +++ b/xous-rs/src/carton.rs @@ -1,9 +1,9 @@ //! A Carton is an object that wraps another object for shipping across the kernel //! boundary. Structs that are stored in Cartons can be sent as messages. -extern crate alloc; -use alloc::alloc::{alloc, dealloc, Layout}; +// extern crate alloc; +// use alloc::alloc::{alloc, dealloc, Layout}; -use crate::{MemoryMessage, MemoryRange, CID, Message, Error}; +use crate::{Error, MemoryMessage, MemoryRange, Message, CID}; #[derive(Debug)] pub struct Carton<'a> { @@ -15,15 +15,22 @@ impl<'a> Carton<'a> { pub fn from_bytes(bytes: &[u8]) -> Self { let src_mem = bytes.as_ptr(); let size = bytes.len(); - let layout = Layout::from_size_align(size, 4096).unwrap(); - let new_mem = unsafe { - let new_mem = alloc(layout); - core::ptr::copy(src_mem, new_mem, size); - new_mem - }; + // let layout = Layout::from_size_align(size, 4096).unwrap(); + let new_mem = crate::map_memory( + None, + None, + size, + crate::MemoryFlags::R | crate::MemoryFlags::W, + ) + .unwrap(); + // unsafe { + // let new_mem = alloc(layout); + // core::ptr::copy(src_mem, new_mem, size); + // new_mem + // }; Carton { - range: MemoryRange::new(new_mem as usize, size), - slice: unsafe { core::slice::from_raw_parts_mut(new_mem, size) }, + range: new_mem, + slice: unsafe { core::slice::from_raw_parts_mut(new_mem.as_mut_ptr(), new_mem.len()) }, } } @@ -74,8 +81,8 @@ impl<'a> AsRef<[u8]> for Carton<'a> { impl<'a> Drop for Carton<'a> { fn drop(&mut self) { - let layout = Layout::from_size_align(self.range.len(), 4096).unwrap(); - let ptr = self.range.as_mut_ptr(); - unsafe { dealloc(ptr, layout) }; + // let layout = Layout::from_size_align(self.range.len(), 4096).unwrap(); + // let ptr = self.range.as_mut_ptr(); + // unsafe { dealloc(ptr, layout) }; } } diff --git a/xous-rs/src/definitions.rs b/xous-rs/src/definitions.rs index 19da795e5..c658a1cef 100644 --- a/xous-rs/src/definitions.rs +++ b/xous-rs/src/definitions.rs @@ -326,7 +326,7 @@ impl Drop for MessageEnvelope { crate::syscall::return_memory(self.sender, x.buf) .expect("couldn't return memory") } - Message::Move(msg) => crate::syscall::unmap_memory(msg.buf.addr, msg.buf.size) + Message::Move(msg) => crate::syscall::unmap_memory(msg.buf) .expect("couldn't free memory message"), _ => (), } @@ -334,15 +334,15 @@ impl Drop for MessageEnvelope { } impl MemoryRange { - pub fn new(addr: usize, size: usize) -> MemoryRange { + pub fn new(addr: usize, size: usize) -> core::result::Result { assert!( addr != 0, "tried to construct a memory range with a null pointer" ); - MemoryRange { - addr: MemoryAddress::new(addr).unwrap(), - size: MemorySize::new(size).unwrap(), - } + Ok(MemoryRange { + addr: MemoryAddress::new(addr).ok_or(Error::BadAddress)?, + size: MemorySize::new(size).ok_or(Error::BadAddress)?, + }) } pub fn from_parts(addr: MemoryAddress, size: MemorySize) -> MemoryRange { diff --git a/xous-rs/src/lib.rs b/xous-rs/src/lib.rs index 4d2c8c105..fdc176e72 100644 --- a/xous-rs/src/lib.rs +++ b/xous-rs/src/lib.rs @@ -1,9 +1,7 @@ -#![cfg_attr(not(any(windows, unix)), no_std)] +#![cfg_attr(baremetal, no_std)] #[macro_use] extern crate bitflags; -extern crate num_derive; -extern crate num_traits; pub mod arch; diff --git a/xous-rs/src/syscall.rs b/xous-rs/src/syscall.rs index ef05ad058..5608e031a 100644 --- a/xous-rs/src/syscall.rs +++ b/xous-rs/src/syscall.rs @@ -3,8 +3,8 @@ use crate::{ MemorySize, MemoryType, Message, MessageEnvelope, MessageSender, ProcessArgs, ProcessInit, Result, ScalarMessage, SysCallResult, ThreadInit, CID, PID, SID, }; -use num_derive::FromPrimitive; -use num_traits::FromPrimitive; +// use num_derive::FromPrimitive; +// use num_traits::FromPrimitive; #[cfg(feature = "processes-as-threads")] use crate::ProcessArgsAsThread; @@ -37,8 +37,7 @@ pub enum SysCall { /// # Errors /// UnmapMemory( - MemoryAddress, /* virt */ - MemorySize, /* region size */ + MemoryRange ), /// Sets the offset and size of a given memory region. This call may only @@ -259,7 +258,7 @@ pub enum SysCall { Invalid(usize, usize, usize, usize, usize, usize, usize), } -#[derive(FromPrimitive)] +// #[derive(FromPrimitive)] enum SysCallNumber { MapMemory = 2, Yield = 3, @@ -286,6 +285,37 @@ enum SysCallNumber { Invalid, } +impl SysCallNumber { + pub fn from(val: usize) -> SysCallNumber { + use SysCallNumber::*; + match val { + 2 => MapMemory, + 3 => Yield, + 4 => ReturnToParentI, + 5 => ClaimInterrupt, + 6 => FreeInterrupt, + 7 => SwitchTo, + 8 => ReadyThreads, + 9 => WaitEvent, + 10 => IncreaseHeap, + 11 => DecreaseHeap, + 12 => UpdateMemoryFlags, + 13 => SetMemRegion, + 14 => CreateServer, + 15 => ReceiveMessage, + 16 => SendMessage, + 17 => Connect, + 18 => CreateThread, + 19 => UnmapMemory, + 20 => ReturnMemory, + 21 => CreateProcess, + 22 => TerminateProcess, + 23 => Shutdown, + _ => Invalid, + } + } +} + impl SysCall { /// Convert the SysCall into an array of eight `usize` elements, /// suitable for passing to the kernel. @@ -306,10 +336,10 @@ impl SysCall { 0, 0, ], - SysCall::UnmapMemory(a1, a2) => [ + SysCall::UnmapMemory(range) => [ SysCallNumber::UnmapMemory as usize, - a1.get(), - a2.get(), + range.as_ptr() as usize, + range.len(), 0, 0, 0, @@ -534,61 +564,60 @@ impl SysCall { a6: usize, a7: usize, ) -> core::result::Result { - Ok(match FromPrimitive::from_usize(a0) { - Some(SysCallNumber::MapMemory) => SysCall::MapMemory( + Ok(match SysCallNumber::from(a0) { + SysCallNumber::MapMemory => SysCall::MapMemory( MemoryAddress::new(a1), MemoryAddress::new(a2), MemoryAddress::new(a3).ok_or(Error::InvalidSyscall)?, MemoryFlags::from_bits(a4).ok_or(Error::InvalidSyscall)?, ), - Some(SysCallNumber::UnmapMemory) => SysCall::UnmapMemory( - MemoryAddress::new(a1).ok_or(Error::InvalidSyscall)?, - MemorySize::new(a2).ok_or(Error::InvalidSyscall)?, + SysCallNumber::UnmapMemory => SysCall::UnmapMemory( + MemoryRange::new(a1, a2).or(Err(Error::InvalidSyscall))?, ), - Some(SysCallNumber::Yield) => SysCall::Yield, - Some(SysCallNumber::WaitEvent) => SysCall::WaitEvent, - Some(SysCallNumber::ReceiveMessage) => { + SysCallNumber::Yield => SysCall::Yield, + SysCallNumber::WaitEvent => SysCall::WaitEvent, + SysCallNumber::ReceiveMessage => { SysCall::ReceiveMessage(SID::from_u32(a1 as _, a2 as _, a3 as _, a4 as _)) } - Some(SysCallNumber::ReturnToParentI) => { + SysCallNumber::ReturnToParentI => { SysCall::ReturnToParentI(pid_from_usize(a1)?, a2) } - Some(SysCallNumber::ClaimInterrupt) => SysCall::ClaimInterrupt( + SysCallNumber::ClaimInterrupt => SysCall::ClaimInterrupt( a1, MemoryAddress::new(a2).ok_or(Error::InvalidSyscall)?, MemoryAddress::new(a3), ), - Some(SysCallNumber::FreeInterrupt) => SysCall::FreeInterrupt(a1), - Some(SysCallNumber::SwitchTo) => SysCall::SwitchTo(pid_from_usize(a1)?, a2 as usize), - Some(SysCallNumber::ReadyThreads) => SysCall::ReadyThreads(pid_from_usize(a1)?), - Some(SysCallNumber::IncreaseHeap) => SysCall::IncreaseHeap( + SysCallNumber::FreeInterrupt => SysCall::FreeInterrupt(a1), + SysCallNumber::SwitchTo => SysCall::SwitchTo(pid_from_usize(a1)?, a2 as usize), + SysCallNumber::ReadyThreads => SysCall::ReadyThreads(pid_from_usize(a1)?), + SysCallNumber::IncreaseHeap => SysCall::IncreaseHeap( a1 as usize, MemoryFlags::from_bits(a2).ok_or(Error::InvalidSyscall)?, ), - Some(SysCallNumber::DecreaseHeap) => SysCall::DecreaseHeap(a1 as usize), - Some(SysCallNumber::UpdateMemoryFlags) => SysCall::UpdateMemoryFlags( + SysCallNumber::DecreaseHeap => SysCall::DecreaseHeap(a1 as usize), + SysCallNumber::UpdateMemoryFlags => SysCall::UpdateMemoryFlags( MemoryAddress::new(a1).ok_or(Error::InvalidSyscall)?, a2 as usize, MemoryFlags::from_bits(a3).ok_or(Error::InvalidSyscall)?, ), - Some(SysCallNumber::SetMemRegion) => SysCall::SetMemRegion( + SysCallNumber::SetMemRegion => SysCall::SetMemRegion( pid_from_usize(a1)?, MemoryType::from(a2), MemoryAddress::new(a3).ok_or(Error::InvalidSyscall)?, a4, ), - Some(SysCallNumber::CreateServer) => { + SysCallNumber::CreateServer => { SysCall::CreateServer(SID::from_u32(a1 as _, a2 as _, a3 as _, a4 as _)) } - Some(SysCallNumber::Connect) => { + SysCallNumber::Connect => { SysCall::Connect(SID::from_u32(a1 as _, a2 as _, a3 as _, a4 as _)) } - Some(SysCallNumber::SendMessage) => match a2 { + SysCallNumber::SendMessage => match a2 { 1 => SysCall::SendMessage( a1, Message::MutableBorrow(MemoryMessage { id: a3, - buf: MemoryRange::new(a4, a5), + buf: MemoryRange::new(a4, a5)?, offset: MemoryAddress::new(a6), valid: MemorySize::new(a7), }), @@ -597,7 +626,7 @@ impl SysCall { a1, Message::Borrow(MemoryMessage { id: a3, - buf: MemoryRange::new(a4, a5), + buf: MemoryRange::new(a4, a5)?, offset: MemoryAddress::new(a6), valid: MemorySize::new(a7), }), @@ -606,7 +635,7 @@ impl SysCall { a1, Message::Move(MemoryMessage { id: a3, - buf: MemoryRange::new(a4, a5), + buf: MemoryRange::new(a4, a5)?, offset: MemoryAddress::new(a6), valid: MemorySize::new(a7), }), @@ -623,19 +652,18 @@ impl SysCall { ), _ => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7), }, - Some(SysCallNumber::ReturnMemory) => { - SysCall::ReturnMemory(a1, MemoryRange::new(a2, a3)) + SysCallNumber::ReturnMemory => { + SysCall::ReturnMemory(a1, MemoryRange::new(a2, a3)?) } - Some(SysCallNumber::CreateThread) => { + SysCallNumber::CreateThread => { SysCall::CreateThread(crate::arch::args_to_thread(a1, a2, a3, a4, a5, a6, a7)?) } - Some(SysCallNumber::CreateProcess) => { + SysCallNumber::CreateProcess => { SysCall::CreateProcess(crate::arch::args_to_process(a1, a2, a3, a4, a5, a6, a7)?) } - Some(SysCallNumber::TerminateProcess) => SysCall::TerminateProcess, - Some(SysCallNumber::Shutdown) => SysCall::Shutdown, - Some(SysCallNumber::Invalid) => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7), - None => return Err(Error::InvalidSyscall), + SysCallNumber::TerminateProcess => SysCall::TerminateProcess, + SysCallNumber::Shutdown => SysCall::Shutdown, + SysCallNumber::Invalid => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7), }) } } @@ -690,8 +718,8 @@ pub fn map_memory( /// Map the given physical address to the given virtual address. /// The `size` field must be page-aligned. -pub fn unmap_memory(virt: MemoryAddress, size: MemorySize) -> core::result::Result<(), Error> { - let result = rsyscall(SysCall::UnmapMemory(virt, size))?; +pub fn unmap_memory(range: MemoryRange) -> core::result::Result<(), Error> { + let result = rsyscall(SysCall::UnmapMemory(range))?; if let Result::Ok = result { Ok(()) } else if let Result::Error(e) = result { @@ -818,6 +846,24 @@ pub fn wait_event() { rsyscall(SysCall::WaitEvent).expect("wait_event returned an error"); } +pub fn create_thread_simple( + f: fn(T) -> U, + arg: T, +) -> core::result::Result, Error> +where + T: Send + 'static, + U: Send + 'static, +{ + let thread_info = crate::arch::create_thread_simple_pre(&f, &arg)?; + rsyscall(SysCall::CreateThread(thread_info)).and_then(|result| { + if let Result::ThreadID(thread_id) = result { + crate::arch::create_thread_simple_post(f, arg, thread_id) + } else { + Err(Error::InternalError) + } + }) +} + /// Create a new thread with the given closure. pub fn create_thread(f: F) -> core::result::Result, Error> where