diff --git a/kernel/src/macros.rs b/kernel/src/macros.rs new file mode 100644 index 000000000..cf7376144 --- /dev/null +++ b/kernel/src/macros.rs @@ -0,0 +1,46 @@ +// Shamelessly taken from +// https://stackoverflow.com/questions/36258417/using-a-macro-to-initialize-a-big-array-of-non-copy-elements +// Allows us to fill an array with a predefined value. +#[macro_export] +macro_rules! filled_array { + (@accum (0, $($_es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@as_expr [$($body)*])}; + (@accum (1, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (0, $($es),*) -> ($($body)* $($es,)*))}; + (@accum (2, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (0, $($es),*) -> ($($body)* $($es,)* $($es,)*))}; + (@accum (3, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (2, $($es),*) -> ($($body)* $($es,)*))}; + (@accum (4, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (2, $($es,)* $($es),*) -> ($($body)*))}; + (@accum (5, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (4, $($es),*) -> ($($body)* $($es,)*))}; + (@accum (6, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (4, $($es),*) -> ($($body)* $($es,)* $($es,)*))}; + (@accum (7, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (4, $($es),*) -> ($($body)* $($es,)* $($es,)* $($es,)*))}; + (@accum (8, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (4, $($es,)* $($es),*) -> ($($body)*))}; + (@accum (16, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (8, $($es,)* $($es),*) -> ($($body)*))}; + (@accum (32, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (16, $($es,)* $($es),*) -> ($($body)*))}; + (@accum (64, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (32, $($es,)* $($es),*) -> ($($body)*))}; + (@accum (128, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (64, $($es,)* $($es),*) -> ($($body)*))}; + (@accum (256, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (128, $($es,)* $($es),*) -> ($($body)*))}; + (@accum (512, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (256, $($es,)* $($es),*) -> ($($body)*))}; + (@accum (1024, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (512, $($es,)* $($es),*) -> ($($body)*))}; + (@accum (2048, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (1024, $($es,)* $($es),*) -> ($($body)*))}; + (@accum (4096, $($es:expr),*) -> ($($body:tt)*)) + => {filled_array!(@accum (2048, $($es,)* $($es),*) -> ($($body)*))}; + + (@as_expr $e:expr) => {$e}; + + [$e:expr; $n:tt] => { filled_array!(@accum ($n, $e) -> ()) }; +} diff --git a/kernel/src/main.rs b/kernel/src/main.rs index fa6f63c51..d0ddfffd9 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -15,9 +15,11 @@ mod arch; #[macro_use] mod args; mod irq; +mod macros; mod mem; mod services; mod syscall; +mod server; use mem::MemoryManagerHandle; use services::SystemServicesHandle; @@ -57,7 +59,7 @@ fn next_pid_to_run(last_pid: Option) -> Option { // PIDs are 1-indexed but arrays are 0-indexed. By not subtracting // 1 from the PID when we use it as an array index, we automatically // pick the next process in the list. - let mut current_pid = last_pid.unwrap_or(0) as usize + 1; + let current_pid = last_pid.unwrap_or(0) as usize; let system_services = SystemServicesHandle::get(); for test_idx in current_pid..system_services.processes.len() { diff --git a/kernel/src/server.rs b/kernel/src/server.rs new file mode 100644 index 000000000..766ec68e0 --- /dev/null +++ b/kernel/src/server.rs @@ -0,0 +1,233 @@ +pub use crate::arch::ProcessContext; +use core::{mem, slice}; +use xous::{MemoryAddress, MemorySize, PID, SID}; + +/// 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)] +enum QueuedMessage { + Empty, + ScalarMessage( + usize, /* sender */ + usize, /* context */ + usize, /* id */ + usize, /* arg1 */ + usize, /* arg2 */ + usize, /* arg3 */ + usize, /* arg4 */ + ), + MemoryMessageSend( + usize, /* sender */ + usize, /* context */ + usize, /* id */ + usize, /* buf */ + usize, /* buf_size */ + usize, /* offset */ + usize, /* valid */ + ), + MemoryMessageROLend( + usize, /* sender */ + usize, /* context */ + usize, /* id */ + usize, /* buf */ + usize, /* buf_size */ + usize, /* offset */ + usize, /* valid */ + ), + MemoryMessageRWLend( + usize, /* sender */ + usize, /* context */ + usize, /* id */ + usize, /* buf */ + usize, /* buf_size */ + usize, /* offset */ + usize, /* valid */ + ), +} + +/// A pointer to resolve a server ID to a particular process +#[derive(PartialEq)] +pub struct Server { + /// A randomly-generated ID + pub sid: SID, + + /// The process that owns this server + pub pid: PID, + + /// An index into the queue + queue_head: usize, + + queue_tail: usize, + + /// Where data will appear + queue: &'static mut [QueuedMessage], + + /// 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_contexts: usize, +} + +impl Server { + pub fn init( + new: &mut Option, + pid: PID, + sid: SID, + queue_addr: *mut usize, + queue_size: usize, + ) -> Result<(), xous::Error> { + if new != &None { + return Err(xous::Error::MemoryInUse); + } + + let queue = unsafe { + slice::from_raw_parts_mut( + queue_addr as *mut QueuedMessage, + queue_size / mem::size_of::(), + ) + }; + + *new = Some(Server { + sid, + pid, + queue_head: 0, + queue_tail: 0, + queue, + ready_contexts: 0, + }); + Ok(()) + } + /// Remove a message from the server's queue and replace it with + /// QueuedMessage::Empty. Advance the queue pointer while we're at it. + pub fn take_next_message(&mut self) -> Option<(xous::MessageEnvelope, usize)> { + let result = match self.queue[self.queue_head] { + QueuedMessage::Empty => return None, + QueuedMessage::MemoryMessageROLend( + sender, + context, + id, + buf, + buf_size, + offset, + valid, + ) => ( + xous::MessageEnvelope { + sender: sender, + message: xous::Message::ImmutableBorrow(xous::MemoryMessage { + id, + buf: MemoryAddress::new(buf), + buf_size: MemorySize::new(buf_size), + _offset: MemorySize::new(offset), + _valid: MemorySize::new(valid), + }), + }, + context, + ), + QueuedMessage::MemoryMessageRWLend( + sender, + context, + id, + buf, + buf_size, + offset, + valid, + ) => ( + xous::MessageEnvelope { + sender: sender, + message: xous::Message::MutableBorrow(xous::MemoryMessage { + id, + buf: MemoryAddress::new(buf), + buf_size: MemorySize::new(buf_size), + _offset: MemorySize::new(offset), + _valid: MemorySize::new(valid), + }), + }, + context, + ), + QueuedMessage::MemoryMessageSend(sender, context, id, buf, buf_size, offset, valid) => { + ( + xous::MessageEnvelope { + sender: sender, + message: xous::Message::Move(xous::MemoryMessage { + id, + buf: MemoryAddress::new(buf), + buf_size: MemorySize::new(buf_size), + _offset: MemorySize::new(offset), + _valid: MemorySize::new(valid), + }), + }, + context, + ) + } + QueuedMessage::ScalarMessage(sender, context, id, arg1, arg2, arg3, arg4) => ( + xous::MessageEnvelope { + sender: sender, + message: xous::Message::Scalar(xous::ScalarMessage { + id, + arg1, + arg2, + arg3, + arg4, + }), + }, + context, + ), + }; + self.queue[self.queue_head] = QueuedMessage::Empty; + self.queue_head += 1; + if self.queue_head >= self.queue.len() { + self.queue_head = 0; + } + Some(result) + } + + /// Add the given message to this server's queue. + pub fn queue_message( + &mut self, + envelope: xous::MessageEnvelope, + context: usize, + ) -> core::result::Result<(), xous::Error> { + if self.queue[self.queue_head] != QueuedMessage::Empty { + return Err(xous::Error::ServerQueueFull); + } + + self.queue_head += 1; + if self.queue_head >= self.queue.len() { + self.queue_head = 0; + } + Ok(()) + } + + // 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_context(&mut self) -> Option { + if self.ready_contexts == 0 { + return None; + } + let mut test_ctx_mask = 1; + let mut ctx_number = 0; + loop { + // If the context mask matches this context number, remove it + // and return the index. + if self.ready_contexts & test_ctx_mask == test_ctx_mask { + self.ready_contexts = self.ready_contexts & !test_ctx_mask; + return Some(ctx_number); + } + // Advance to the next slot. + test_ctx_mask = test_ctx_mask.rotate_left(1); + ctx_number = ctx_number + 1; + if test_ctx_mask == 1 { + panic!("didn't find a free context, even though there should be one"); + } + } + } +} diff --git a/kernel/src/services.rs b/kernel/src/services.rs index bceaf1d5f..f91d1d380 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -3,9 +3,11 @@ use crate::arch::mem::MemoryMapping; use crate::arch::process::ProcessHandle; pub use crate::arch::ProcessContext; use crate::args::KernelArguments; +use crate::filled_array; use crate::mem::{MemoryManagerHandle, PAGE_SIZE}; +use crate::server::Server; use core::{mem, slice}; -use xous::{MemoryAddress, MemoryFlags, MemorySize, CID, PID, SID}; +use xous::{ MemoryFlags, CID, PID, SID}; const MAX_PROCESS_COUNT: usize = 32; const MAX_SERVER_COUNT: usize = 32; @@ -125,229 +127,6 @@ impl Process { } } -#[derive(Copy, Clone, PartialEq)] -#[repr(usize)] -enum ServerState { - /// This server slot is unallocated - Free, - - /// This server can receive messages. - /// 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(usize /* context mask */), - - /// This server's inbox is full - Full, -} - -/// 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)] -enum QueuedMessage { - Empty, - ScalarMessage( - usize, /* sender */ - usize, /* context */ - usize, /* id */ - usize, /* arg1 */ - usize, /* arg2 */ - usize, /* arg3 */ - usize, /* arg4 */ - ), - MemoryMessageSend( - usize, /* sender */ - usize, /* context */ - usize, /* id */ - usize, /* buf */ - usize, /* buf_size */ - usize, /* offset */ - usize, /* valid */ - ), - MemoryMessageROLend( - usize, /* sender */ - usize, /* context */ - usize, /* id */ - usize, /* buf */ - usize, /* buf_size */ - usize, /* offset */ - usize, /* valid */ - ), - MemoryMessageRWLend( - usize, /* sender */ - usize, /* context */ - usize, /* id */ - usize, /* buf */ - usize, /* buf_size */ - usize, /* offset */ - usize, /* valid */ - ), -} - -/// A pointer to resolve a server ID to a particular process -#[derive(Copy, Clone)] -pub struct Server { - /// A randomly-generated ID - sid: SID, - - /// The process that owns this server - pub pid: PID, - - /// The current state of this slot - state: ServerState, - - /// An index into the queue - queue_index: usize, - - /// Where data will appear - queue: &'static [QueuedMessage], -} - -impl Server { - /// Remove a message from the server's queue and replace it with - /// QueuedMessage::Empty. Advance the queue pointer while we're at it. - pub fn take_next_message(&mut self) -> Option<(xous::MessageEnvelope, usize)> { - let result = match self.queue[self.queue_index] { - QueuedMessage::Empty => return None, - QueuedMessage::MemoryMessageROLend( - sender, - context, - id, - buf, - buf_size, - offset, - valid, - ) => ( - xous::MessageEnvelope { - sender: sender, - message: xous::Message::ImmutableBorrow(xous::MemoryMessage { - id, - buf: MemoryAddress::new(buf), - buf_size: MemorySize::new(buf_size), - _offset: MemorySize::new(offset), - _valid: MemorySize::new(valid), - }), - }, - context, - ), - QueuedMessage::MemoryMessageRWLend( - sender, - context, - id, - buf, - buf_size, - offset, - valid, - ) => ( - xous::MessageEnvelope { - sender: sender, - message: xous::Message::MutableBorrow(xous::MemoryMessage { - id, - buf: MemoryAddress::new(buf), - buf_size: MemorySize::new(buf_size), - _offset: MemorySize::new(offset), - _valid: MemorySize::new(valid), - }), - }, - context, - ), - QueuedMessage::MemoryMessageSend(sender, context, id, buf, buf_size, offset, valid) => { - ( - xous::MessageEnvelope { - sender: sender, - message: xous::Message::Move(xous::MemoryMessage { - id, - buf: MemoryAddress::new(buf), - buf_size: MemorySize::new(buf_size), - _offset: MemorySize::new(offset), - _valid: MemorySize::new(valid), - }), - }, - context, - ) - } - QueuedMessage::ScalarMessage(sender, context, id, arg1, arg2, arg3, arg4) => ( - xous::MessageEnvelope { - sender: sender, - message: xous::Message::Scalar(xous::ScalarMessage { - id, - arg1, - arg2, - arg3, - arg4, - }), - }, - context, - ), - }; - self.queue[self.queue_index] = QueuedMessage::Empty; - self.queue_index += 1; - if self.queue_index >= self.queue.len() { - self.queue_index = 0; - } - Some(result) - } - - /// Add the given message to this server's queue. - pub fn queue_message( - &mut self, - envelope: xous::MessageEnvelope, - context: usize, - ) -> core::result::Result<(), xous::Error> { - if self.queue[self.queue_index] != QueuedMessage::Empty { - return Err(xous::Error::ServerQueueFull); - } - - self.queue_index += 1; - if self.queue_index >= self.queue.len() { - self.queue_index = 0; - } - Ok(()) - } - - /// 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_context(&mut self) -> Option { - let context_index = match self.state { - ServerState::Ready(0) => return None, - ServerState::Ready(x) => x, - _ => return None, - }; - - let mut test_ctx_mask = 1; - let mut ctx_number = 0; - loop { - // If the context mask matches this context number, remove it - // and return the index. - if context_index & test_ctx_mask == test_ctx_mask { - self.state = ServerState::Ready(context_index & !test_ctx_mask); - return Some(ctx_number); - } - // Advance to the next slot. - test_ctx_mask = test_ctx_mask.rotate_left(1); - ctx_number = ctx_number + 1; - if test_ctx_mask == 1 { - panic!("didn't find a free context, even though there should be one"); - } - } - } -} - -impl Default for Server { - fn default() -> Self { - Server { - sid: (0, 0, 0, 0), - pid: 0, - state: ServerState::Free, - queue_index: 0, - queue: &[], - } - } -} - #[repr(C)] /// The stage1 bootloader sets up some initial processes. These are reported /// to us as (satp, entrypoint, sp) tuples, which can be turned into a structure. @@ -374,7 +153,7 @@ pub struct SystemServices { pub processes: [Process; MAX_PROCESS_COUNT], /// A table of all servers in the system - servers: [Server; MAX_SERVER_COUNT], + servers: [Option; MAX_SERVER_COUNT], /// A log of the currently-active syscall depth syscall_stack: [(usize, usize); 3], @@ -390,13 +169,7 @@ static mut SYSTEM_SERVICES: SystemServices = SystemServices { ppid: 0, mapping: arch::mem::DEFAULT_MEMORY_MAPPING, }; MAX_PROCESS_COUNT], - servers: [Server { - sid: (0, 0, 0, 0), - pid: 0, - state: ServerState::Free, - queue_index: 0, - queue: &[], - }; MAX_SERVER_COUNT], + servers: filled_array![None; 32], // Note we can't use MAX_SERVER_COUNT here because of how Rust's tokenization works syscall_stack: [(0, 0), (0, 0), (0, 0)], syscall_depth: 0, }; @@ -637,33 +410,22 @@ impl SystemServices { pub fn create_server(&mut self, name: usize) -> Result { println!("Looking through server list for free server"); println!("Server entries are {} bytes long", mem::size_of::()); - assert!( - mem::size_of::() == 32, - "QueuedMessage was supposed to be 32 bytes, but instead was {} bytes", - mem::size_of::() - ); for entry in self.servers.iter_mut() { - if entry.state == ServerState::Free { - let pid = self.pid; + if entry == &None { println!("Found a free slot. Allocating an entry"); - // Allocate memory for the new server. - entry.queue = { + let pid = self.pid; + let sid = (pid as usize, name as usize, pid as usize, name as usize); + let (addr, size) = { let mut mm = MemoryManagerHandle::get(); - let page = mm.map_zeroed_page(pid, false)?; - unsafe { - slice::from_raw_parts_mut( - page as *mut QueuedMessage, - PAGE_SIZE / mem::size_of::(), - ) - } + (mm.map_zeroed_page(pid, false)?, PAGE_SIZE) }; - println!("Managed to allocate a handle"); - entry.state = ServerState::Ready(0); - entry.pid = self.pid; - entry.sid = (pid as usize, name as usize, pid as usize, name as usize); - println!("Returning SID"); - return Ok(entry.sid); + Server::init(entry, pid, sid, addr, size).or_else(|x| { + let mut mm = MemoryManagerHandle::get(); + mm.unmap_page(addr); + Err(x) + })?; + return Ok(sid); } } Err(xous::Error::OutOfMemory) @@ -685,24 +447,28 @@ impl SystemServices { slot_idx = Some(idx); } // If a connection to this server ID exists already, return it. - if self.servers[*server_idx as usize].sid == sid { - return Ok(idx as CID + 1); + if let Some(allocated_server) = &self.servers[*server_idx as usize] { + if allocated_server.sid == sid { + return Ok(idx as CID + 1); + } } } let slot_idx = slot_idx.ok_or_else(|| xous::Error::OutOfMemory)?; // Look through all servers for one whose SID matches. for (idx, server) in self.servers.iter().enumerate() { - if server.sid == sid { - process.inner.connection_map[slot_idx] = idx as u8 + 1; - return Ok(idx + 1); + if let Some(allocated_server) = server { + if allocated_server.sid == sid { + process.inner.connection_map[slot_idx] = idx as u8 + 1; + return Ok(idx + 1); + } } } Err(xous::Error::OutOfMemory) } /// Return a server based on the connection id and the current process - pub fn server_from_cid(&self, cid: CID) -> Option<&Server> { + pub fn server_from_cid(&mut self, cid: CID) -> Option<&mut Server> { if cid == 0 { return None; } @@ -718,18 +484,17 @@ impl SystemServices { if server_idx >= self.servers.len() { return None; } - if let ServerState::Ready(_) = self.servers[server_idx].state { - } else { - return None; - } - Some(&self.servers[server_idx]) + + self.servers[server_idx].as_mut() } /// Get a server based on a SID pub fn server_mut(&mut self, sid: SID) -> Option<&mut Server> { for server in self.servers.iter_mut() { - if server.sid == sid { - return Some(server); + if let Some(active_server) = server { + if active_server.sid == sid { + return server.as_mut(); + } } } None diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index e02cbca5b..3a07cd7d0 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -228,7 +228,7 @@ pub fn handle(call: SysCall) -> core::result::Result SysCall::ReceiveMessage(sid) => { let mut ss = SystemServicesHandle::get(); // See if there is a pending message. If so, return immediately. - let mut server = ss.server_mut(sid).ok_or(xous::Error::ServerNotFound)?; + let server = ss.server_mut(sid).ok_or(xous::Error::ServerNotFound)?; // Ensure the server is for this PID if server.pid != pid { @@ -269,10 +269,13 @@ pub fn handle(call: SysCall) -> core::result::Result } SysCall::SendMessage(cid, message) => { let mut ss = SystemServicesHandle::get(); - let server = ss.server_from_cid(cid).ok_or(xous::Error::ServerNotFound)?; + let available_contexts = { + let mut server = ss.server_from_cid(cid).ok_or(xous::Error::ServerNotFound)?; + server.take_available_context() + }; // If the server has an available context to receive the message, transfer it right away. - if let Some(ctx_number) = server.take_available_context() { + if let Some(ctx_number) = available_contexts { // We can pass control on to this context, and add the existing context // to the blocking pool. } else { @@ -283,6 +286,7 @@ pub fn handle(call: SysCall) -> core::result::Result // Add this message to the queue. If the queue is full, this // returns an error. + let mut server = ss.server_from_cid(cid).ok_or(xous::Error::ServerNotFound)?; server.queue_message(MessageEnvelope { sender: 0, message }, context_nr)?; // Park this context. This is roughly equivalent to a "Yield".