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