diff --git a/kernel/src/arch/riscv/process.rs b/kernel/src/arch/riscv/process.rs index 74fc37088..3c79b0375 100644 --- a/kernel/src/arch/riscv/process.rs +++ b/kernel/src/arch/riscv/process.rs @@ -125,9 +125,7 @@ impl Process { let pid = unsafe { PROCESS_TABLE.current }; let hardware_pid = (riscv::register::satp::read().bits() >> 22) & ((1 << 9) - 1); assert!((pid.get() as usize) == hardware_pid); - Process { - pid, - } + Process { pid } } /// Mark this process as running on the current core @@ -299,7 +297,10 @@ impl Process { thread.sepc = unsafe { core::mem::transmute::<_, usize>(thread_init.call) }; thread.registers[1] = thread_init.stack.as_ptr() as usize + thread_init.stack.len(); - thread.registers[9] = thread_init.arg.map(|x| x.get()).unwrap_or_default(); + thread.registers[9] = thread_init.arg1; + thread.registers[10] = thread_init.arg2; + thread.registers[11] = thread_init.arg3; + thread.registers[12] = thread_init.arg4; #[cfg(any(feature = "debug-print", feature = "print-panics"))] { @@ -331,7 +332,11 @@ impl Process { Ok(()) } - pub fn setup_thread(&mut self, new_tid: TID, setup: ThreadInit) -> Result<(), xous_kernel::Error> { + pub fn setup_thread( + &mut self, + new_tid: TID, + setup: ThreadInit, + ) -> Result<(), xous_kernel::Error> { let entrypoint = unsafe { core::mem::transmute::<_, usize>(setup.call) }; // Create the new context and set it to run in the new address space. let pid = self.pid.get(); @@ -343,7 +348,7 @@ impl Process { entrypoint, setup.stack.as_ptr() as usize + setup.stack.len(), EXIT_THREAD, - &[setup.arg.map(|x| x.get() as usize).unwrap_or_default()], + &[setup.arg1, setup.arg2, setup.arg3, setup.arg4], ); Ok(()) } @@ -364,27 +369,45 @@ impl Process { ); println!( "T3:{:08x} T4:{:08x} T5:{:08x} T6:{:08x}", - _thread.registers[27], _thread.registers[28], _thread.registers[29], _thread.registers[30] + _thread.registers[27], + _thread.registers[28], + _thread.registers[29], + _thread.registers[30] ); println!( "S0:{:08x} S1:{:08x} S2:{:08x} S3:{:08x}", - _thread.registers[7], _thread.registers[8], _thread.registers[17], _thread.registers[18] + _thread.registers[7], + _thread.registers[8], + _thread.registers[17], + _thread.registers[18] ); println!( "S4:{:08x} S5:{:08x} S6:{:08x} S7:{:08x}", - _thread.registers[19], _thread.registers[20], _thread.registers[21], _thread.registers[22] + _thread.registers[19], + _thread.registers[20], + _thread.registers[21], + _thread.registers[22] ); println!( "S8:{:08x} S9:{:08x} S10:{:08x} S11:{:08x}", - _thread.registers[23], _thread.registers[24], _thread.registers[25], _thread.registers[26] + _thread.registers[23], + _thread.registers[24], + _thread.registers[25], + _thread.registers[26] ); println!( "A0:{:08x} A1:{:08x} A2:{:08x} A3:{:08x}", - _thread.registers[9], _thread.registers[10], _thread.registers[11], _thread.registers[12] + _thread.registers[9], + _thread.registers[10], + _thread.registers[11], + _thread.registers[12] ); println!( "A4:{:08x} A5:{:08x} A6:{:08x} A7:{:08x}", - _thread.registers[13], _thread.registers[14], _thread.registers[15], _thread.registers[16] + _thread.registers[13], + _thread.registers[14], + _thread.registers[15], + _thread.registers[16] ); } diff --git a/kernel/src/server-split-queues.rs b/kernel/src/server-split-queues.rs new file mode 100644 index 000000000..7b5985110 --- /dev/null +++ b/kernel/src/server-split-queues.rs @@ -0,0 +1,1051 @@ +// SPDX-FileCopyrightText: 2020 Sean Cross +// SPDX-License-Identifier: Apache-2.0 + +pub use crate::arch::process::Thread; +use core::mem; +use xous_kernel::{MemoryAddress, MemoryRange, MemorySize, Message, MessageSender, PID, SID, TID}; + +/// A pointer to resolve a server ID to a particular process +#[derive(PartialEq, Debug)] +pub struct Server { + /// A randomly-generated ID + pub sid: SID, + + /// The process that owns this server + pub pid: PID, + + /// Messages we have yet to process get stored here + incoming_queue: IncomingQueue, + + /// Messages to be returned get stored here + outgoing_queue: OutgoingQueue, + + /// The `context mask` is a bitfield of contexts that are able to handle + /// this message. If there are no available contexts, then messages will + /// need to be queued. + ready_threads: usize, +} + +pub struct IncomingQueue { + /// Messages coming from clients get stored in this array + #[cfg(baremetal)] + queue: &'static mut [IncomingQueuedMessage], + #[cfg(not(baremetal))] + queue: Vec, + + /// Where clients can write into the incoming queue + head: usize, + + /// Where the server is currently reading in the incoming queue + tail: usize, +} + +pub struct OutgoingQueue { + #[cfg(baremetal)] + queue: &'static mut [OutgoingQueuedMessage], + #[cfg(not(baremetal))] + queue: Vec, + + /// Where the server is currently writing in the outgoing queue + tail: usize, +} + +pub struct SenderID { + /// The index of the server within the SystemServices table + pub sidx: usize, + /// The index into the queue array + pub idx: usize, + /// The process ID that sent this message + pid: Option, +} + +impl SenderID { + pub fn new(sidx: usize, idx: usize, pid: Option) -> Self { + SenderID { sidx, idx, pid } + } +} + +impl From for SenderID { + fn from(item: usize) -> SenderID { + SenderID { + sidx: (item >> 16) & 0xff, + idx: item & 0xffff, + pid: PID::new((item >> 24) as u8), + } + } +} + +impl Into for SenderID { + fn into(self) -> usize { + (self.pid.map(|x| x.get() as usize).unwrap_or(0) << 24) + | ((self.sidx << 16) & 0x00ff0000) + | (self.idx & 0xffff) + } +} + +impl From for SenderID { + fn from(item: MessageSender) -> SenderID { + SenderID::from(item.to_usize()) + } +} + +impl Into for SenderID { + fn into(self) -> MessageSender { + MessageSender::from_usize(self.into()) + } +} + +#[derive(Debug)] +pub enum WaitingMessage { + /// There is no waiting message. + None, + + /// The memory was borrowed and should be returned to the given process. + BorrowedMemory(PID, TID, MemoryAddress, MemoryAddress, MemorySize), + + /// The memory was moved, and so shouldn't be returned. + MovedMemory, + + /// The message was a scalar message, so you should return the result to the process + ScalarMessage(PID, TID), + + /// This memory should be returned to the system. + ForgetMemory(MemoryRange), +} + +/// Internal representation of a queued message for a server. This should be +/// exactly 8 words / 32 bytes, yielding 128 queued messages per server +#[repr(usize)] +#[derive(PartialEq, Debug)] +enum IncomingQueuedMessage { + Empty, + BlockingScalarMessage( + u16, /* client PID */ + u16, /* client TID */ + usize, /* server return address */ + usize, /* id */ + usize, /* arg1 */ + usize, /* arg2 */ + usize, /* arg3 */ + usize, /* arg4 */ + ), + ScalarMessage( + u16, /* client PID */ + u16, /* client TID */ + usize, /* server return address */ + usize, /* id */ + usize, /* arg1 */ + usize, /* arg2 */ + usize, /* arg3 */ + usize, /* arg4 */ + ), + MemoryMessageSend( + u16, /* client PID */ + u16, /* client TID */ + usize, /* reserved */ + usize, /* id */ + usize, /* buf */ + usize, /* buf_size */ + usize, /* offset */ + usize, /* valid */ + ), + MemoryMessageROLend( + u16, /* client PID */ + u16, /* client TID */ + usize, /* address of memory base in server */ + usize, /* id */ + usize, /* buf */ + usize, /* buf_size */ + usize, /* offset */ + usize, /* valid */ + ), + MemoryMessageRWLend( + u16, /* client PID */ + u16, /* client TID */ + usize, /* address of memory base in server */ + usize, /* id */ + usize, /* buf */ + usize, /* buf_size */ + usize, /* offset */ + usize, /* valid */ + ), +} + +enum OutgoingQueuedMessage { + /// This slot is available for use + Empty, + + /// The process lending this memory terminated before + /// we could receive the message. + MemoryMessageROLendTerminated( + u16, /* client PID */ + u16, /* client TID */ + usize, /* address of memory base in server */ + usize, /* id */ + usize, /* buf */ + usize, /* buf_size */ + usize, /* offset */ + usize, /* valid */ + ), + + /// The process lending this memory terminated before + /// we could receive the message. + MemoryMessageRWLendTerminated( + u16, /* client PID */ + u16, /* client TID */ + usize, /* address of memory base in server */ + usize, /* id */ + usize, /* buf */ + usize, /* buf_size */ + usize, /* offset */ + usize, /* valid */ + ), + + /// The process waiting for the response terminated before + /// we could receive the message. + BlockingScalarTerminated( + u16, /* client PID */ + u16, /* client TID */ + usize, /* server return address */ + usize, /* id */ + usize, /* arg1 */ + usize, /* arg2 */ + usize, /* arg3 */ + usize, /* arg4 */ + ), + + /// When a message is taken that needs to be returned -- such as an ROLend + /// or RWLend -- the slot is replaced with a WaitingReturnMemory token and its + /// index is returned as the message sender. This is used to unblock the + /// sending process. + WaitingReturnMemory( + u16, /* client PID */ + u16, /* client TID */ + usize, /* address of memory base in server */ + usize, /* client base address */ + usize, /* Range size */ + ), + + /// When a server goes away, its memory must be forgotten instead of being returned + /// to the previous process. + WaitingForget( + u16, /* client PID */ + u16, /* client TID */ + usize, /* address of memory base in server */ + usize, /* client base address */ + usize, /* Range size */ + ), + + /// This is the state when a message is blocking, but has no associated memory + /// page. + WaitingReturnScalar( + u16, /* client PID */ + u16, /* client TID */ + usize, /* server return address */ + ), +} + +impl IncomingQueuedMessage { + fn is_free(&self) -> bool { + if *self == IncomingQueuedMessage::Empty { + true + } else { + false + } + } +} + +impl IncomingQueue { + pub fn new(backing: MemoryRange) -> Self { + #[cfg(baremetal)] + let queue = unsafe { + core::slice::from_raw_parts_mut( + backing.as_mut_ptr() as *mut IncomingQueuedMessage, + backing.len() / mem::size_of::() / 2, + ) + }; + #[cfg(not(baremetal))] + let queue = { + let mut queue = vec![]; + // TODO: Replace this with a direct operation on a passed-in page + queue.resize_with( + backing.size.get() / mem::size_of::(), + || IncomingQueuedMessage::Empty, + ); + queue + }; + + IncomingQueue { + queue, + head: 0, + tail: 0, + } + } + pub fn reset(&mut self) { + self.head = 0; + self.tail = 0; + } +} + +impl OutgoingQueue { + pub fn new(backing: MemoryRange) -> Self { + #[cfg(baremetal)] + let queue = unsafe { + core::slice::from_raw_parts_mut( + backing.as_mut_ptr() as *mut OutgoingQueuedMessage, + backing.len() / mem::size_of::() / 2, + ) + }; + #[cfg(not(baremetal))] + let queue = { + let mut queue = vec![]; + // TODO: Replace this with a direct operation on a passed-in page + queue.resize_with( + backing.size.get() / mem::size_of::(), + || OutgoingQueuedMessage::Empty, + ); + queue + }; + + IncomingQueue { + queue, + head: 0, + tail: 0, + } + } + + pub fn reset(&mut self) { + self.tail = 0; + } +} + +impl Server { + /// Initialize a server in the given option array. This function is + /// designed to be called with `new` pointing to an entry in a vec. + /// + /// # Errors + /// + /// * **MemoryInUse**: The provided Server option already exists + pub fn init( + new: &mut Option, + pid: PID, + sid: SID, + incoming_backing: MemoryRange, + outgoing_backing: MemoryRange, + ) -> Result<(), xous_kernel::Error> { + if new != &None { + return Err(xous_kernel::Error::MemoryInUse); + } + + let incoming_queue = IncomingQueue::new(incoming_backing); + let outgoing_queue = OutgoingQueue::new(outgoing_backing); + + *new = Some(Server { + sid, + pid, + incoming_queue, + outgoing_queue, + ready_threads: 0, + }); + Ok(()) + } + + /// Take a current slot and replace it with `None`, clearing out the contents of the queue. + pub fn destroy(current: &mut Option) -> Result<(), xous_kernel::Error> { + if let Some(mut server) = current.take() { + server.incoming_queue.reset(); + server.outgoing_queue.reset(); + server.ready_threads = 0; + } + Ok(()) + } + + // pub fn print_queue(&self) { + // println!(" Q Queue Head: {}", self.queue_head); + // println!(" Q Queue Tail: {}", self.queue_tail); + // for (_idx, _entry) in self.queue.iter().enumerate() { + // if _entry != &QueuedMessage::Empty { + // println!(" Q entry[{}]: {:?}", _idx, _entry); + // } + // } + // } + + /// When a process terminates, there may be memory that is lent to us. + /// Mark all of that memory to be discarded when it is returned, rather than + /// giving it back to the previous process space. + pub fn discard_messages_for_pid(&mut self, pid: PID) { + for entry in self.queue.iter_mut() { + match *entry { + QueuedMessage::MemoryMessageROLend( + msg_pid, + tid, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + ) => { + if msg_pid == pid.get() as _ { + *entry = QueuedMessage::MemoryMessageROLendTerminated( + msg_pid, tid, arg1, arg2, arg3, arg4, arg5, arg6, + ); + } + } + QueuedMessage::MemoryMessageRWLend( + msg_pid, + tid, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + ) => { + if msg_pid == pid.get() as _ { + *entry = QueuedMessage::MemoryMessageRWLendTerminated( + msg_pid, tid, arg1, arg2, arg3, arg4, arg5, arg6, + ); + } + } + QueuedMessage::BlockingScalarMessage( + msg_pid, + tid, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + ) => { + if msg_pid == pid.get() as _ { + *entry = QueuedMessage::BlockingScalarTerminated( + msg_pid, tid, arg1, arg2, arg3, arg4, arg5, arg6, + ); + } + } + // For "Scalar" and "Move" messages, this memory has already + // been moved into this process, so memory will be reclaimed + // when the process terminates. + _ => (), + } + } + } + + /// Convert a `QueuedMesage::WaitingReturnMemory` into `QueuedMessage::Empty` + /// and return the pair. Advance the tail. Note that the `idx` could be + /// somewhere other than the tail, but as long as it points to a valid + /// message that's waiting a response, that's acceptable. + pub fn take_waiting_message( + &mut self, + idx: usize, + buf: Option<&MemoryRange>, + ) -> Result { + let current_val = self + .queue + .get_mut(idx) + .ok_or(xous_kernel::Error::BadAddress)?; + klog!("memory in queue[{}]: {:?}", idx, current_val); + let (pid, tid, server_addr, client_addr, len, forget, is_memory) = match *current_val { + QueuedMessage::WaitingReturnMemory(pid, tid, server_addr, client_addr, len) => { + (pid, tid, server_addr, client_addr, len, false, true) + } + QueuedMessage::WaitingForget(pid, tid, server_addr, client_addr, len) => { + (pid, tid, server_addr, client_addr, len, true, true) + } + QueuedMessage::WaitingReturnScalar(pid, tid, return_address) => { + (pid, tid, return_address, 0, 0, true, false) + } + _ => return Ok(WaitingMessage::None), + }; + + // Sanity check the specified address was correct, and matches what we + // had cached. + if is_memory && cfg!(baremetal) { + let buf = buf.expect("memory message expected but no buffer passed!"); + if server_addr != buf.as_ptr() as usize || len != buf.len() { + // println!("KERNEL: Memory is attached but the returned buffer doesn't match (len: {} vs {}), buf addr: {:08x} vs {:08x}", len, buf.len(), server_addr, buf.as_ptr() as usize); + Err(xous_kernel::Error::BadAddress)?; + } + } + *current_val = QueuedMessage::Empty; + if idx == self.queue_tail { + self.queue_tail += 1; + if self.queue_tail >= self.queue.len() { + self.queue_tail = 0; + } + // Advance the pointer in case we have a long string of Empty messages. + while self.queue_tail != self.queue_head + && self.queue[self.queue_tail] == QueuedMessage::Empty + { + self.queue_tail += 1; + if self.queue_tail >= self.queue.len() { + self.queue_tail = 0; + } + } + } + + // Destructure the PID and context ID from the `pid_tid` field + // klog!( + // "taking waiting message and returning to pid: {} tid: {}", + // pid, + // tid + // ); + + if !is_memory { + return Ok(WaitingMessage::ScalarMessage( + PID::new(pid as _).unwrap(), + tid as _, + )); + } + + if forget { + return Ok(WaitingMessage::ForgetMemory(MemoryRange::new( + server_addr, + len, + )?)); + } + + // If a `move` address somehow ends up here, indicate the memory has been moved. + let server_addr = match MemoryAddress::new(server_addr) { + Some(o) => o, + None => return Ok(WaitingMessage::MovedMemory), + }; + + let client_addr = MemoryAddress::new(client_addr) + .expect("client memory address was 0, but server address was not"); + let len = MemorySize::new(len).expect("memory length was 0, but address was not None"); + Ok(WaitingMessage::BorrowedMemory( + PID::new(pid as _).unwrap(), + tid as _, + server_addr, + client_addr, + len, + )) + } + + /// Remove a message from the server's queue and replace it with either a QueuedMessage::WaitingReturnMemory + /// or, for Scalar messages, QueuedMessage::Empty. + /// + /// For non-Scalar messages, you must call `take_waiting_message()` in order to return + /// memory to the calling process. + /// + /// # Returns + /// + /// * **None**: There are no waiting messages + /// ***Some(MessageEnvelope): This message is queued. + pub fn take_next_message(&mut self, sidx: usize) -> Option { + // klog!( + // "queue_head: ((({}))) queue_tail: ((({}))): {:?} CID: ((({})))", + // self.queue_head, + // self.queue_tail, + // self.queue[self.queue_tail], + // sidx + // ); + use core::convert::TryInto; + let mut queue_idx = self.queue_tail; + while queue_idx != self.queue_head { + let mut sender = SenderID::new(sidx, queue_idx, None); + // klog!("Message @ server.queue[{}]: {:?}", queue_idx, self.queue[queue_idx]); + let (result, response) = match self.queue[queue_idx] { + QueuedMessage::Empty => { + queue_idx += 1; + if queue_idx >= self.queue.len() { + queue_idx = 0; + } + continue; + } + QueuedMessage::WaitingReturnMemory(_, _, _, _, _) => { + queue_idx += 1; + if queue_idx >= self.queue.len() { + queue_idx = 0; + } + continue; + } + QueuedMessage::WaitingForget(_, _, _, _, _) => { + queue_idx += 1; + if queue_idx >= self.queue.len() { + queue_idx = 0; + } + continue; + } + QueuedMessage::WaitingReturnScalar(_, _, _) => { + queue_idx += 1; + if queue_idx >= self.queue.len() { + queue_idx = 0; + } + continue; + } + QueuedMessage::MemoryMessageROLend( + pid, + tid, + client_addr, + id, + buf, + buf_size, + offset, + valid, + ) => { + sender.pid = PID::new(pid.try_into().unwrap()); + ( + xous_kernel::MessageEnvelope { + sender: sender.into(), + body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage { + id, + buf: MemoryRange::new(buf, buf_size).ok()?, + offset: MemorySize::new(offset), + valid: MemorySize::new(valid), + }), + }, + QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size), + ) + } + QueuedMessage::MemoryMessageRWLend( + pid, + tid, + client_addr, + id, + buf, + buf_size, + offset, + valid, + ) => { + sender.pid = PID::new(pid.try_into().unwrap()); + ( + xous_kernel::MessageEnvelope { + sender: sender.into(), + body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage { + id, + buf: MemoryRange::new(buf, buf_size).ok()?, + offset: MemorySize::new(offset), + valid: MemorySize::new(valid), + }), + }, + QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size), + ) + } + QueuedMessage::MemoryMessageROLendTerminated( + pid, + tid, + client_addr, + id, + buf, + buf_size, + offset, + valid, + ) => { + sender.pid = PID::new(pid.try_into().unwrap()); + ( + xous_kernel::MessageEnvelope { + sender: sender.into(), + body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage { + id, + buf: MemoryRange::new(buf, buf_size).ok()?, + offset: MemorySize::new(offset), + valid: MemorySize::new(valid), + }), + }, + QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size), + ) + } + QueuedMessage::MemoryMessageRWLendTerminated( + pid, + tid, + client_addr, + id, + buf, + buf_size, + offset, + valid, + ) => { + sender.pid = PID::new(pid.try_into().unwrap()); + ( + xous_kernel::MessageEnvelope { + sender: sender.into(), + body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage { + id, + buf: MemoryRange::new(buf, buf_size).ok()?, + offset: MemorySize::new(offset), + valid: MemorySize::new(valid), + }), + }, + QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size), + ) + } + + QueuedMessage::BlockingScalarMessage( + pid, + tid, + client_addr, + id, + arg1, + arg2, + arg3, + arg4, + ) => { + sender.pid = PID::new(pid.try_into().unwrap()); + ( + xous_kernel::MessageEnvelope { + sender: sender.into(), + body: xous_kernel::Message::BlockingScalar( + xous_kernel::ScalarMessage { + id, + arg1, + arg2, + arg3, + arg4, + }, + ), + }, + QueuedMessage::WaitingReturnScalar(pid, tid, client_addr), + ) + } + QueuedMessage::MemoryMessageSend( + pid, + _tid, + _reserved, + id, + buf, + buf_size, + offset, + valid, + ) => { + sender.pid = PID::new(pid.try_into().unwrap()); + let msg = xous_kernel::MessageEnvelope { + sender: sender.into(), + body: xous_kernel::Message::Move(xous_kernel::MemoryMessage { + id, + buf: MemoryRange::new(buf, buf_size).ok()?, + offset: MemorySize::new(offset), + valid: MemorySize::new(valid), + }), + }; + self.queue[queue_idx] = QueuedMessage::Empty; + if queue_idx == self.queue_tail { + self.queue_tail += 1; + if self.queue_tail >= self.queue.len() { + self.queue_tail = 0; + } + } + return Some(msg); + } + + // Scalar messages have nothing to return, so they can go straight to the `Free` state + QueuedMessage::ScalarMessage(pid, _tid, _reserved, id, arg1, arg2, arg3, arg4) => { + sender.pid = PID::new(pid.try_into().unwrap()); + let msg = xous_kernel::MessageEnvelope { + sender: sender.into(), + body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage { + id, + arg1, + arg2, + arg3, + arg4, + }), + }; + self.queue[queue_idx] = QueuedMessage::Empty; + if queue_idx == self.queue_tail { + self.queue_tail += 1; + if self.queue_tail >= self.queue.len() { + self.queue_tail = 0; + } + } + return Some(msg); + } + QueuedMessage::BlockingScalarTerminated( + pid, + _tid, + _reserved, + id, + arg1, + arg2, + arg3, + arg4, + ) => { + sender.pid = PID::new(pid.try_into().unwrap()); + let msg = xous_kernel::MessageEnvelope { + sender: sender.into(), + body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage { + id, + arg1, + arg2, + arg3, + arg4, + }), + }; + self.queue[queue_idx] = QueuedMessage::Empty; + if queue_idx == self.queue_tail { + self.queue_tail += 1; + if self.queue_tail >= self.queue.len() { + self.queue_tail = 0; + } + } + return Some(msg); + } + }; + + self.queue[queue_idx] = response; + return Some(result); + } + None + } + + /// Add the given message to this server's queue. + /// + /// # Errors + /// + /// * **ServerQueueFull**: The server queue cannot accept any more messages + pub fn queue_message( + &mut self, + pid: PID, + context: TID, + message: xous_kernel::Message, + original_address: Option, + ) -> core::result::Result { + // klog!( + // "Queueing message: {:?} for pid: {} tid: {}", + // message, + // pid.get(), + // context + // ); + // Look for a free slot. + // if self.queue[self.queue_head] != QueuedMessage::Empty { + // return Err(xous_kernel::Error::ServerQueueFull); + // } + let mut queue_idx = self.queue_head; + loop { + if self.queue[queue_idx].is_free() || self.queue[queue_idx].is_incoming() { + break; + } + queue_idx += 1; + if queue_idx > self.queue.len() { + queue_idx = 0; + } + if queue_idx == self.queue_head { + klog!("Queue is full for PID {} -- examined every entry", pid); + Err(xous_kernel::Error::ServerQueueFull)?; + } + } + if self.queue[queue_idx].is_incoming() { + klog!("Queue is full for PID {} -- message was incoming", pid); + Err(xous_kernel::Error::ServerQueueFull)?; + } + + self.queue[queue_idx] = match message { + xous_kernel::Message::Scalar(msg) => QueuedMessage::ScalarMessage( + pid.get() as _, + context as _, + original_address.map(|x| x.get()).unwrap_or(0), + msg.id, + msg.arg1, + msg.arg2, + msg.arg3, + msg.arg4, + ), + xous_kernel::Message::BlockingScalar(msg) => QueuedMessage::BlockingScalarMessage( + pid.get() as _, + context as _, + original_address.map(|x| x.get()).unwrap_or(0), + msg.id, + msg.arg1, + msg.arg2, + msg.arg3, + msg.arg4, + ), + xous_kernel::Message::Move(msg) => QueuedMessage::MemoryMessageSend( + pid.get() as _, + context as _, + original_address.map(|x| x.get()).unwrap_or(0), + msg.id, + msg.buf.addr.get(), + msg.buf.size.get(), + msg.offset.map(|x| x.get()).unwrap_or(0) as usize, + msg.valid.map(|x| x.get()).unwrap_or(0) as usize, + ), + xous_kernel::Message::MutableBorrow(msg) => QueuedMessage::MemoryMessageRWLend( + pid.get() as _, + context as _, + original_address.map(|x| x.get()).unwrap_or(0), + msg.id, + msg.buf.addr.get(), + msg.buf.size.get(), + msg.offset.map(|x| x.get()).unwrap_or(0) as usize, + msg.valid.map(|x| x.get()).unwrap_or(0) as usize, + ), + xous_kernel::Message::Borrow(msg) => QueuedMessage::MemoryMessageROLend( + pid.get() as _, + context as _, + original_address.map(|x| x.get()).unwrap_or(0), + msg.id, + msg.buf.addr.get(), + msg.buf.size.get(), + msg.offset.map(|x| x.get()).unwrap_or(0) as usize, + msg.valid.map(|x| x.get()).unwrap_or(0) as usize, + ), + }; + + // let idx = self.queue_head; + if queue_idx == self.queue_head { + self.queue_head += 1; + if self.queue_head >= self.queue.len() { + self.queue_head = 0; + } + } + // klog!( + // "queue head: {} queue_tail: {}", + // self.queue_head, + // self.queue_tail + // ); + Ok(queue_idx) + } + + pub fn queue_response( + &mut self, + pid: PID, + context: TID, + message: &Message, + client_address: Option, + ) -> core::result::Result { + klog!( + "Queueing address message: {:?} (pid: {} tid: {})", + message, + pid.get(), + context + ); + // if self.queue[self.queue_head] != QueuedMessage::Empty { + // return Err(xous_kernel::Error::ServerQueueFull); + // } + let mut queue_idx = self.queue_head; + loop { + if self.queue[queue_idx].is_free() || self.queue[queue_idx].is_incoming() { + break; + } + queue_idx += 1; + if queue_idx > self.queue.len() { + queue_idx = 0; + } + if queue_idx == self.queue_head { + klog!("Queue is full for PID {} -- examined every entry", pid); + Err(xous_kernel::Error::ServerQueueFull)?; + } + } + if self.queue[queue_idx].is_incoming() { + klog!("Queue is full for PID {} -- message was incoming", pid); + Err(xous_kernel::Error::ServerQueueFull)?; + } + + self.queue[queue_idx] = match message { + xous_kernel::Message::Scalar(_) | xous_kernel::Message::BlockingScalar(_) => { + QueuedMessage::WaitingReturnScalar( + pid.get() as _, + context as _, + client_address.map(|x| x.get()).unwrap_or(0), + ) + } + xous_kernel::Message::Move(msg) => { + let server_address = msg.buf.addr.get(); + let len = msg.buf.size.get(); + QueuedMessage::WaitingForget( + pid.get() as _, + context as _, + server_address, + client_address.map(|x| x.get()).unwrap_or(0), + len, + ) + } + xous_kernel::Message::MutableBorrow(msg) | xous_kernel::Message::Borrow(msg) => { + let server_address = msg.buf.addr.get(); + let len = msg.buf.size.get(); + QueuedMessage::WaitingReturnMemory( + pid.get() as _, + context as _, + server_address, + client_address.map(|x| x.get()).unwrap_or(0), + len, + ) + } + }; + if queue_idx == self.queue_head { + self.queue_head += 1; + if self.queue_head >= self.queue.len() { + self.queue_head = 0; + } + } + Ok(queue_idx) + } + // assert!( + // mem::size_of::() == 32, + // "QueuedMessage was supposed to be 32 bytes, but instead was {} bytes", + // mem::size_of::() + // ); + + /// Return a context ID that is available and blocking. If no such context + /// ID exists, or if this server isn't actually ready to receive packets, + /// return None. + pub fn take_available_thread(&mut self) -> Option { + if self.ready_threads == 0 { + return None; + } + let mut test_thread_mask = 1; + let mut thread_number = 0; + klog!( + "server pid {} ready threads: 0b{:08b}", + self.pid, + self.ready_threads + ); + if self.pid.get() == 2 && (self.ready_threads & !0b11) != 0 { + panic!("bogus thread state"); + } + loop { + // If the context mask matches this context number, remove it + // and return the index. + if self.ready_threads & test_thread_mask == test_thread_mask { + self.ready_threads &= !test_thread_mask; + if self.pid.get() == 2 && (self.ready_threads & !0b11) != 0 { + panic!("bogus thread state"); + } + return Some(thread_number); + } + // Advance to the next slot. + test_thread_mask = test_thread_mask.rotate_left(1); + thread_number += 1; + if test_thread_mask == 1 { + panic!("didn't find a free context, even though there should be one"); + } + } + } + + /// Return an available context to the blocking list. This is part of the + /// error condition when a message cannot be handled but the context has + /// already been claimed. + /// + /// # Panics + /// + /// If the context cannot be returned because it is already blocking. + pub fn return_available_thread(&mut self, tid: TID) { + if self.ready_threads & 1 << tid != 0 { + panic!( + "tried to return context {}, but it was already blocking", + tid + ); + } + self.ready_threads |= 1 << tid; + if self.pid.get() == 2 && (self.ready_threads & !0b11) != 0 { + panic!( + "bogus thread state after returning available thread {}", + tid + ); + } + } + + /// Add the given context to the list of ready and waiting contexts. + pub fn park_thread(&mut self, tid: TID) { + klog!("parking thread {}", tid); + assert!(self.ready_threads & (1 << tid) == 0); + self.ready_threads |= 1 << tid; + klog!("ready threads now: {:08b}", self.ready_threads); + if self.pid.get() == 2 && (self.ready_threads & !0b11) != 0 { + panic!("bogus thread state"); + } + } +} diff --git a/kernel/src/services.rs b/kernel/src/services.rs index 658122717..712bad7d8 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -321,8 +321,10 @@ impl SystemServices { process.state = ProcessState::Setup(ThreadInit::new( unsafe { core::mem::transmute::(init.entrypoint) }, MemoryRange::new(init.sp, crate::arch::process::DEFAULT_STACK_SIZE).unwrap(), - MemoryAddress::new(pid), - [0u8; 12], + pid, + 0, + 0, + 0, )); } } diff --git a/xous-rs/src/arch/native.rs b/xous-rs/src/arch/native.rs index 7f0411329..7513a272c 100644 --- a/xous-rs/src/arch/native.rs +++ b/xous-rs/src/arch/native.rs @@ -1,4 +1,4 @@ -use crate::{MemoryAddress, MemoryRange, PID, TID}; +use crate::{MemoryRange, PID, TID}; use core::convert::TryInto; mod mem; @@ -11,24 +11,34 @@ pub struct ProcessArgs { #[derive(Debug, Clone, Copy, PartialEq)] pub struct ThreadInit { - pub call: fn(data: usize) -> usize, + /// Function pointer that accepts 0-4 arguments + pub call: usize, pub stack: MemoryRange, - pub arg: Option, - pub name: [u8; 12], + pub arg1: usize, + pub arg2: usize, + pub arg3: usize, + pub arg4: usize, + // pub name: [u8; 12], } impl ThreadInit { pub fn new( - call: fn(data: usize) -> usize, + call: usize, stack: MemoryRange, - arg: Option, - name: [u8; 12], + arg1: usize, + arg2: usize, + arg3: usize, + arg4: usize, + // name: [u8; 12], ) -> Self { ThreadInit { call, stack, - arg, - name, + arg1, + arg2, + arg3, + arg4, + // name, } } } @@ -36,10 +46,13 @@ impl ThreadInit { impl Default for ThreadInit { fn default() -> Self { ThreadInit { - call: unsafe { core::mem::transmute:: usize>(4) }, + call: 1, stack: MemoryRange::new(4, 4).unwrap(), - arg: None, - name: [0; 12], + arg1: 0, + arg2: 0, + arg3: 0, + arg4: 0, + // name: [0; 12], } } } @@ -60,16 +73,16 @@ pub struct ProcessInit { pub struct WaitHandle(core::marker::PhantomData); pub struct ProcessHandle(()); -pub fn thread_to_args(call: usize, init: &ThreadInit) -> [usize; 8] { +pub fn thread_to_args(syscall: usize, init: &ThreadInit) -> [usize; 8] { [ - call as usize, - init.call as usize, + syscall, + init.call, init.stack.as_ptr() as _, init.stack.len(), - init.arg.map(|x| x.get()).unwrap_or_default(), - 0, - 0, - 0, + init.arg1, + init.arg2, + init.arg3, + init.arg4, ] } @@ -81,18 +94,18 @@ pub fn args_to_thread( a2: usize, a3: usize, a4: usize, - _a5: usize, - _a6: usize, - _a7: usize, + a5: usize, + a6: usize, + a7: usize, ) -> core::result::Result { - let call = unsafe { core::mem::transmute(a1) }; - let stack = MemoryRange::new(a2, a3).map_err(|_| crate::Error::InvalidSyscall)?; - let arg = MemoryAddress::new(a4); Ok(ThreadInit { - call, - stack, - arg, - name: [0; 12], + call: a1, + stack: MemoryRange::new(a2, a3).map_err(|_| crate::Error::InvalidSyscall)?, + arg1: a4, + arg2: a5, + arg3: a6, + arg4: a7, + // name: [0; 12], }) } @@ -103,7 +116,6 @@ where T: Send + 'static, { todo!() - // Ok(ThreadInit {}) } pub fn create_thread_post( @@ -116,29 +128,10 @@ where T: Send + 'static, { todo!() - // let server_address = xous_address(); - // let server_connection = - // XOUS_SERVER_CONNECTION.with(|xsc| xsc.borrow().as_ref().unwrap().clone()); - // let process_id = PROCESS_ID.with(|pid| *pid.borrow()); - // Ok(std::thread::Builder::new() - // .spawn(move || { - // set_xous_address(server_address); - // THREAD_ID.with(|tid| *tid.borrow_mut() = thread_id); - // PROCESS_ID.with(|pid| *pid.borrow_mut() = process_id); - // XOUS_SERVER_CONNECTION.with(|xsc| *xsc.borrow_mut() = Some(server_connection)); - // f() - // }) - // .map(WaitHandle) - // .map_err(|_| crate::Error::InternalError)?) } pub fn wait_thread(_joiner: WaitHandle) -> crate::SysCallResult { todo!() - // joiner - // .0 - // .join() - // .map(|_| Result::Ok) - // .map_err(|_| crate::Error::InternalError) } pub fn process_to_args(call: usize, init: &ProcessInit) -> [usize; 8] { @@ -166,6 +159,129 @@ pub fn args_to_process( todo!() } +pub fn create_thread_0_pre(f: &fn() -> U) -> core::result::Result +where + U: Send + 'static, +{ + let start = unsafe { core::mem::transmute(*f) }; + create_thread_n_pre(start, &0, &0, &0, &0) +} + +pub fn create_thread_0_post( + f: fn() -> U, + thread_id: TID, +) -> core::result::Result, crate::Error> +where + U: Send + 'static, +{ + let start = unsafe { core::mem::transmute(f) }; + create_thread_n_post(start, 0, 0, 0, 0, thread_id) +} + +pub fn create_thread_1_pre( + f: &fn(usize) -> U, + arg1: &usize, +) -> core::result::Result +where + U: Send + 'static, +{ + let start = unsafe { core::mem::transmute(*f) }; + create_thread_n_pre(start, arg1, &0, &0, &0) +} + +pub fn create_thread_1_post( + f: fn(usize) -> U, + arg1: usize, + thread_id: TID, +) -> core::result::Result, crate::Error> +where + U: Send + 'static, +{ + let start = unsafe { core::mem::transmute(f) }; + create_thread_n_post(start, arg1, 0, 0, 0, thread_id) +} + +pub fn create_thread_2_pre( + f: &fn(usize) -> U, + arg1: &usize, + arg2: &usize, +) -> core::result::Result +where + U: Send + 'static, +{ + let start = unsafe { core::mem::transmute(*f) }; + create_thread_n_pre(start, arg1, arg2, &0, &0) +} + +pub fn create_thread_2_post( + f: fn(usize) -> U, + arg1: usize, + arg2: usize, + thread_id: TID, +) -> core::result::Result, crate::Error> +where + U: Send + 'static, +{ + let start = unsafe { core::mem::transmute(f) }; + create_thread_n_post(start, arg1, arg2, 0, 0, thread_id) +} + +pub fn create_thread_3_pre( + f: &fn(usize) -> U, + arg1: &usize, + arg2: &usize, + arg3: &usize, +) -> core::result::Result +where + U: Send + 'static, +{ + let start = unsafe { core::mem::transmute(*f) }; + create_thread_n_pre(start, arg1, arg2, arg3, &0) +} + +pub fn create_thread_3_post( + f: fn(usize) -> U, + arg1: usize, + arg2: usize, + arg3: usize, + thread_id: TID, +) -> core::result::Result, crate::Error> +where + U: Send + 'static, +{ + let start = unsafe { core::mem::transmute(f) }; + create_thread_n_post(start, arg1, arg2, arg3, 0, thread_id) +} + +pub fn create_thread_4_pre( + f: &fn(usize) -> U, + arg1: &usize, + arg2: &usize, + arg3: &usize, + arg4: &usize, +) -> core::result::Result +where + U: Send + 'static, +{ + let start = unsafe { core::mem::transmute(*f) }; + create_thread_n_pre(start, arg1, arg2, arg3, arg4) +} + +pub fn create_thread_4_post( + f: fn(usize) -> U, + arg1: usize, + arg2: usize, + arg3: usize, + arg4: usize, + thread_id: TID, +) -> core::result::Result, crate::Error> +where + U: Send + 'static, +{ + let start = unsafe { core::mem::transmute(f) }; + create_thread_n_post(start, arg1, arg2, arg3, arg4, thread_id) +} + pub fn create_thread_simple_pre( f: &fn(T) -> U, arg: &T, @@ -174,27 +290,37 @@ where T: Send + 'static, U: Send + 'static, { - #[cfg(feature = "bit-flags")] - let flags = crate::MemoryFlags::R | crate::MemoryFlags::W | crate::MemoryFlags::RESERVE; - #[cfg(not(feature = "bit-flags"))] - let flags = 0b0000_0010 | 0b0000_0100 | 0b0000_0001; - - let stack = crate::map_memory(None, None, 131_072, flags)?; - let start = unsafe { core::mem::transmute(*f) }; - let arg = unsafe { core::mem::transmute(arg) }; - Ok(ThreadInit::new(start, stack, Some(arg), [0; 12])) + create_thread_n_pre( + unsafe { core::mem::transmute(*f) }, + unsafe { core::mem::transmute(arg) }, + &0, + &0, + &0, + ) } pub fn create_thread_simple_post( - _f: fn(T) -> U, - _arg: T, - _thread_id: TID, + f: fn(T) -> U, + arg: T, + thread_id: TID, ) -> core::result::Result, crate::Error> where T: Send + 'static, U: Send + 'static, { - Ok(WaitHandle(core::marker::PhantomData)) + create_thread_n_post( + unsafe { core::mem::transmute(f) }, + unsafe { core::mem::transmute(&arg) }, + 0, + 0, + 0, + thread_id, + ) + // If we succeeded, the variable will be moved into the caller. Drop it from here. + .and_then(|f| { + core::mem::forget(arg); + Ok(f) + }) } /// If no connection exists, create a new connection to the server. This means @@ -211,6 +337,36 @@ pub fn create_process_post( todo!() } +pub fn create_thread_n_pre( + start: usize, + arg1: &usize, + arg2: &usize, + arg3: &usize, + arg4: &usize, +) -> core::result::Result { + #[cfg(feature = "bit-flags")] + let flags = crate::MemoryFlags::R | crate::MemoryFlags::W | crate::MemoryFlags::RESERVE; + #[cfg(not(feature = "bit-flags"))] + let flags = 0b0000_0010 | 0b0000_0100 | 0b0000_0001; + + let stack = crate::map_memory(None, None, 131_072, flags)?; + Ok(ThreadInit::new(start, stack, *arg1, *arg2, *arg3, *arg4)) +} + +pub fn create_thread_n_post( + _f: usize, + _arg1: usize, + _arg2: usize, + _arg3: usize, + _arg4: usize, + _thread_id: TID, +) -> core::result::Result, crate::Error> +where + U: Send + 'static, +{ + Ok(WaitHandle(core::marker::PhantomData)) +} + pub fn wait_process(_joiner: ProcessHandle) -> crate::SysCallResult { loop { crate::wait_event(); diff --git a/xous-rs/src/syscall.rs b/xous-rs/src/syscall.rs index fd55cccfc..d9f291ce1 100644 --- a/xous-rs/src/syscall.rs +++ b/xous-rs/src/syscall.rs @@ -1314,6 +1314,10 @@ pub fn wait_event() { rsyscall(SysCall::WaitEvent).expect("wait_event returned an error"); } +#[deprecated( + since = "0.2", + note = "Please use create_thread_n() or create_thread()" +)] pub fn create_thread_simple( f: fn(T) -> U, arg: T, @@ -1332,6 +1336,96 @@ where }) } +pub fn create_thread_0( + f: fn() -> T, +) -> core::result::Result, Error> +where + T: Send + 'static, +{ + let thread_info = crate::arch::create_thread_0_pre(&f)?; + rsyscall(SysCall::CreateThread(thread_info)).and_then(|result| { + if let Result::ThreadID(thread_id) = result { + crate::arch::create_thread_0_post(f, thread_id) + } else { + Err(Error::InternalError) + } + }) +} + +pub fn create_thread_1( + f: fn(usize) -> T, + arg1: usize, +) -> core::result::Result, Error> +where + T: Send + 'static, +{ + let thread_info = crate::arch::create_thread_1_pre(&f, &arg1)?; + rsyscall(SysCall::CreateThread(thread_info)).and_then(|result| { + if let Result::ThreadID(thread_id) = result { + crate::arch::create_thread_1_post(f, arg1, thread_id) + } else { + Err(Error::InternalError) + } + }) +} + +pub fn create_thread_2( + f: fn(usize) -> T, + arg1: usize, + arg2: usize, +) -> core::result::Result, Error> +where + T: Send + 'static, +{ + let thread_info = crate::arch::create_thread_2_pre(&f, &arg1, &arg2)?; + rsyscall(SysCall::CreateThread(thread_info)).and_then(|result| { + if let Result::ThreadID(thread_id) = result { + crate::arch::create_thread_2_post(f, arg1, arg2, thread_id) + } else { + Err(Error::InternalError) + } + }) +} + +pub fn create_thread_3( + f: fn(usize) -> T, + arg1: usize, + arg2: usize, + arg3: usize, +) -> core::result::Result, Error> +where + T: Send + 'static, +{ + let thread_info = crate::arch::create_thread_3_pre(&f, &arg1, &arg2, &arg3)?; + rsyscall(SysCall::CreateThread(thread_info)).and_then(|result| { + if let Result::ThreadID(thread_id) = result { + crate::arch::create_thread_3_post(f, arg1, arg2, arg3, thread_id) + } else { + Err(Error::InternalError) + } + }) +} + +pub fn create_thread_4( + f: fn(usize) -> T, + arg1: usize, + arg2: usize, + arg3: usize, + arg4: usize, +) -> core::result::Result, Error> +where + T: Send + 'static, +{ + let thread_info = crate::arch::create_thread_4_pre(&f, &arg1, &arg2, &arg3, &arg4)?; + rsyscall(SysCall::CreateThread(thread_info)).and_then(|result| { + if let Result::ThreadID(thread_id) = result { + crate::arch::create_thread_4_post(f, arg1, arg2, arg3, arg4, 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