From e5583a76465ec6f69c7fc53f77a4533478649aea Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 23 Sep 2020 10:52:22 +0800 Subject: [PATCH] kernel: fix message `sender` parameter The `sender` was, previously, somewhat mislabeled. It was a combination of PID and TID, except when it wasn't. Instead, make this value a combination of ConnectionID and queue index. This makes it easier to reason about which connection we're responding to. Additionally, don't expose teh global Server Index Table to userspace programs. Signed-off-by: Sean Cross --- kernel/src/server.rs | 238 +++++++++++++++++++++++++---------------- kernel/src/services.rs | 49 +++++++-- kernel/src/syscall.rs | 115 +++++++++++++++++--- kernel/src/test.rs | 89 +++++++++++++++ 4 files changed, 378 insertions(+), 113 deletions(-) diff --git a/kernel/src/server.rs b/kernel/src/server.rs index a4a6ddbf6..49e5b45c3 100644 --- a/kernel/src/server.rs +++ b/kernel/src/server.rs @@ -3,16 +3,24 @@ use core::mem; use xous_kernel::{MemoryAddress, MemoryRange, MemorySize, Message, PID, SID, TID}; pub struct SenderID { - pub sidx: usize, - pub tidx: usize, + /// The connection ID inside the server + pub cid: usize, + /// The index into the queue array + pub idx: usize, } -impl SenderID { - pub fn from_usize(src: usize) -> Result { - Ok(SenderID { - sidx: src >> 16, - tidx: src & 0xffff, - }) +impl From for SenderID { + fn from(item: usize) -> SenderID { + SenderID { + cid: item >> 16, + idx: item & 0xffff, + } + } +} + +impl Into for SenderID { + fn into(self) -> usize { + (self.cid << 16) | (self.idx & 0xffff) } } @@ -26,6 +34,9 @@ pub enum WaitingMessage { /// 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), } @@ -37,9 +48,9 @@ pub enum WaitingMessage { enum QueuedMessage { Empty, BlockingScalarMessage( - u16, /* sender PID */ - u16, /* Sender CTX */ - usize, /* sender base address */ + u16, /* client PID */ + u16, /* client CTX */ + usize, /* server return address */ usize, /* id */ usize, /* arg1 */ usize, /* arg2 */ @@ -47,9 +58,9 @@ enum QueuedMessage { usize, /* arg4 */ ), ScalarMessage( - u16, /* sender PID */ - u16, /* Sender CTX */ - usize, /* sender base address */ + u16, /* client PID */ + u16, /* client CTX */ + usize, /* server return address */ usize, /* id */ usize, /* arg1 */ usize, /* arg2 */ @@ -57,8 +68,8 @@ enum QueuedMessage { usize, /* arg4 */ ), MemoryMessageSend( - u16, /* sender PID */ - u16, /* Sender CTX */ + u16, /* client PID */ + u16, /* client CTX */ usize, /* reserved */ usize, /* id */ usize, /* buf */ @@ -67,9 +78,9 @@ enum QueuedMessage { usize, /* valid */ ), MemoryMessageROLend( - u16, /* sender PID */ - u16, /* Sender CTX */ - usize, /* sender base address */ + u16, /* client PID */ + u16, /* client CTX */ + usize, /* address of memory base in server */ usize, /* id */ usize, /* buf */ usize, /* buf_size */ @@ -77,9 +88,9 @@ enum QueuedMessage { usize, /* valid */ ), MemoryMessageRWLend( - u16, /* sender PID */ - u16, /* Sender CTX */ - usize, /* sender base address */ + u16, /* client PID */ + u16, /* client CTX */ + usize, /* address of memory base in server */ usize, /* id */ usize, /* buf */ usize, /* buf_size */ @@ -90,9 +101,9 @@ enum QueuedMessage { /// The process lending this memory terminated before /// we could receive the message. MemoryMessageROLendTerminated( - u16, /* sender PID */ - u16, /* Sender CTX */ - usize, /* sender base address */ + u16, /* client PID */ + u16, /* client CTX */ + usize, /* address of memory base in server */ usize, /* id */ usize, /* buf */ usize, /* buf_size */ @@ -103,9 +114,9 @@ enum QueuedMessage { /// The process lending this memory terminated before /// we could receive the message. MemoryMessageRWLendTerminated( - u16, /* sender PID */ - u16, /* Sender CTX */ - usize, /* sender base address */ + u16, /* client PID */ + u16, /* client CTX */ + usize, /* address of memory base in server */ usize, /* id */ usize, /* buf */ usize, /* buf_size */ @@ -116,9 +127,9 @@ enum QueuedMessage { /// The process waiting for the response terminated before /// we could receive the message. BlockingScalarTerminated( - u16, /* sender PID */ - u16, /* Sender CTX */ - usize, /* sender base address */ + u16, /* client PID */ + u16, /* client CTX */ + usize, /* server return address */ usize, /* id */ usize, /* arg1 */ usize, /* arg2 */ @@ -127,30 +138,34 @@ enum QueuedMessage { ), /// When a message is taken that needs to be returned -- such as an ROLend - /// or RWLend -- the slot is replaced with a WaitingResponse token and its + /// 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. - WaitingResponse( - u16, /* sender PID */ - u16, /* Sender CTX */ - usize, /* Client base address */ - usize, /* Server base address */ + WaitingReturnMemory( + u16, /* client PID */ + u16, /* client CTX */ + 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, /* sender PID */ - u16, /* Sender CTX */ - usize, /* Client base address */ - usize, /* Server base address */ + u16, /* client PID */ + u16, /* client CTX */ + 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. - WaitingScalar(u16 /* sender PID */, u16 /* sender CTX */), + WaitingReturnScalar( + u16, /* client PID */ + u16, /* client CTX */ + usize, /* server return address */ + ), } /// A pointer to resolve a server ID to a particular process @@ -179,11 +194,6 @@ pub struct Server { ready_threads: usize, } -/// Convert a PID and CTX pair into a `usize` sender -fn make_sender(pid: u16, ctx: u16) -> usize { - (((pid as usize) << 16) & 0xffff_0000) | (ctx as usize & 0xffff) -} - 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. @@ -313,29 +323,38 @@ impl Server { } } - /// Convert a `QueuedMesage::WaitingResponse` into `QueuedMessage::Empty` + /// 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: MemoryRange, + buf: Option<&MemoryRange>, ) -> Result { if idx > self.queue.len() { return Err(xous_kernel::Error::BadAddress); } - let (pid, ctx, server_addr, client_addr, len, forget) = match self.queue[idx] { - QueuedMessage::WaitingResponse(pid, ctx, server_addr, client_addr, len) => { - (pid, ctx, server_addr, client_addr, len, false) + let (pid, ctx, server_addr, client_addr, len, forget, is_memory) = match self.queue[idx] { + QueuedMessage::WaitingReturnMemory(pid, ctx, server_addr, client_addr, len) => { + (pid, ctx, server_addr, client_addr, len, false, true) } QueuedMessage::WaitingForget(pid, ctx, server_addr, client_addr, len) => { - (pid, ctx, server_addr, client_addr, len, true) + (pid, ctx, server_addr, client_addr, len, true, true) + } + QueuedMessage::WaitingReturnScalar(pid, ctx, return_address) => { + (pid, ctx, return_address, 0, 0, true, false) } _ => return Ok(WaitingMessage::None), }; - if server_addr != buf.as_ptr() as usize || len != buf.len() { - return Err(xous_kernel::Error::BadAddress); + + // Sanity check the specified address was correct, and matches what we + // had cached. + if is_memory { + let buf = buf.expect("memory message expected but no buffer passed!"); + if server_addr != buf.as_ptr() as usize || len != buf.len() { + return Err(xous_kernel::Error::BadAddress); + } } self.queue[idx] = QueuedMessage::Empty; self.queue_tail += 1; @@ -346,6 +365,13 @@ impl Server { // Destructure the PID and context ID from the `pid_ctx` field // println!("Taking waiting message -- pid: {} ctx: {}", pid, ctx); + if !is_memory { + return Ok(WaitingMessage::ScalarMessage( + PID::new(pid as _).unwrap(), + ctx as _, + )); + } + if forget { return Ok(WaitingMessage::ForgetMemory(MemoryRange::new( server_addr, @@ -371,7 +397,7 @@ impl Server { )) } - /// Remove a message from the server's queue and replace it with either a QueuedMessage::WaitingResponse + /// 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 @@ -381,16 +407,20 @@ impl Server { /// /// * **None**: There are no waiting messages /// ***Some(MessageEnvelope): This message is queued. - pub fn take_next_message(&mut self, server_idx: usize) -> Option { + pub fn take_next_message(&mut self, cid: xous_kernel::CID) -> Option { // println!( - // "queue_head: ((({}))) queue_tail: ((({}))): {:?}", - // self.queue_head, self.queue_tail, self.queue[self.queue_tail] + // "queue_head: ((({}))) queue_tail: ((({}))): {:?} CID: ((({})))", + // self.queue_head, self.queue_tail, self.queue[self.queue_tail], cid // ); + let sender = SenderID { + idx: self.queue_tail, + cid, + }.into(); let (result, response) = match self.queue[self.queue_tail] { QueuedMessage::Empty => return None, - QueuedMessage::WaitingResponse(_, _, _, _, _) => return None, + QueuedMessage::WaitingReturnMemory(_, _, _, _, _) => return None, QueuedMessage::WaitingForget(_, _, _, _, _) => return None, - QueuedMessage::WaitingScalar(_, _) => return None, + QueuedMessage::WaitingReturnScalar(_, _, _) => return None, QueuedMessage::MemoryMessageROLend( pid, ctx, @@ -402,7 +432,7 @@ impl Server { valid, ) => ( xous_kernel::MessageEnvelope { - sender: self.queue_tail | (server_idx << 16), + sender, body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage { id, buf: MemoryRange::new(buf, buf_size).ok()?, @@ -423,7 +453,7 @@ impl Server { valid, ) => ( xous_kernel::MessageEnvelope { - sender: self.queue_tail | (server_idx << 16), + sender, body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage { id, buf: MemoryRange::new(buf, buf_size).ok()?, @@ -444,7 +474,7 @@ impl Server { valid, ) => ( xous_kernel::MessageEnvelope { - sender: self.queue_tail | (server_idx << 16), + sender, body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage { id, buf: MemoryRange::new(buf, buf_size).ok()?, @@ -452,7 +482,7 @@ impl Server { valid: MemorySize::new(valid), }), }, - QueuedMessage::WaitingResponse(pid, ctx, buf, client_addr, buf_size), + QueuedMessage::WaitingReturnMemory(pid, ctx, buf, client_addr, buf_size), ), QueuedMessage::MemoryMessageRWLendTerminated( pid, @@ -465,7 +495,7 @@ impl Server { valid, ) => ( xous_kernel::MessageEnvelope { - sender: self.queue_tail | (server_idx << 16), + sender, body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage { id, buf: MemoryRange::new(buf, buf_size).ok()?, @@ -473,13 +503,13 @@ impl Server { valid: MemorySize::new(valid), }), }, - QueuedMessage::WaitingResponse(pid, ctx, buf, client_addr, buf_size), + QueuedMessage::WaitingReturnMemory(pid, ctx, buf, client_addr, buf_size), ), QueuedMessage::BlockingScalarMessage( pid, ctx, - _reserved, + client_addr, id, arg1, arg2, @@ -487,8 +517,8 @@ impl Server { arg4, ) => ( xous_kernel::MessageEnvelope { - sender: make_sender(pid, ctx), - body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage { + sender, + body: xous_kernel::Message::BlockingScalar(xous_kernel::ScalarMessage { id, arg1, arg2, @@ -496,11 +526,11 @@ impl Server { arg4, }), }, - QueuedMessage::WaitingScalar(pid, ctx), + QueuedMessage::WaitingReturnScalar(pid, ctx, client_addr), ), QueuedMessage::MemoryMessageSend( - pid, - ctx, + _pid, + _ctx, _reserved, id, buf, @@ -509,7 +539,7 @@ impl Server { valid, ) => { let msg = xous_kernel::MessageEnvelope { - sender: make_sender(pid, ctx), + sender, body: xous_kernel::Message::Move(xous_kernel::MemoryMessage { id, buf: MemoryRange::new(buf, buf_size).ok()?, @@ -526,9 +556,9 @@ impl Server { } // Scalar messages have nothing to return, so they can go straight to the `Free` state - QueuedMessage::ScalarMessage(pid, ctx, _reserved, id, arg1, arg2, arg3, arg4) => { + QueuedMessage::ScalarMessage(_pid, _ctx, _reserved, id, arg1, arg2, arg3, arg4) => { let msg = xous_kernel::MessageEnvelope { - sender: make_sender(pid, ctx), + sender, body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage { id, arg1, @@ -544,9 +574,18 @@ impl Server { } return Some(msg); } - QueuedMessage::BlockingScalarTerminated(pid, ctx, _reserved, id, arg1, arg2, arg3, arg4) => { + QueuedMessage::BlockingScalarTerminated( + _pid, + _ctx, + _reserved, + id, + arg1, + arg2, + arg3, + arg4, + ) => { let msg = xous_kernel::MessageEnvelope { - sender: make_sender(pid, ctx), + sender, body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage { id, arg1, @@ -646,7 +685,7 @@ impl Server { Ok(idx) } - pub fn queue_address( + pub fn queue_response( &mut self, pid: PID, context: TID, @@ -657,22 +696,37 @@ impl Server { if self.queue[self.queue_head] != QueuedMessage::Empty { return Err(xous_kernel::Error::ServerQueueFull); } - let (server_address, len) = match message { - xous_kernel::Message::Scalar(_) - | xous_kernel::Message::BlockingScalar(_) - | xous_kernel::Message::Move(_) => (0, 0), + self.queue[self.queue_head] = 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) => { - (msg.buf.addr.get(), msg.buf.size.get()) + 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, + ) } }; - - self.queue[self.queue_head] = QueuedMessage::WaitingResponse( - pid.get() as _, - context as _, - server_address, - client_address.map(|x| x.get()).unwrap_or(0), - len, - ); let idx = self.queue_head; self.queue_head += 1; if self.queue_head >= self.queue.len() { diff --git a/kernel/src/services.rs b/kernel/src/services.rs index 4cff1ff9f..dd64ed2e7 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -1288,7 +1288,7 @@ impl SystemServices { /// queue. /// * **ServerNotFound**: The server queue was full and a free slot could not /// be found. - pub fn create_server(&mut self, pid: PID, sid: SID) -> Result { + pub fn create_server(&mut self, pid: PID, sid: SID) -> Result<(SID, CID), xous_kernel::Error> { // println!( // "KERNEL({}): Looking through server list for free server", // self.pid.get() @@ -1303,7 +1303,7 @@ impl SystemServices { ); } - for (_idx, entry) in self.servers.iter_mut().enumerate() { + for entry in self.servers.iter_mut() { if entry == &None { #[cfg(baremetal)] // Allocate a single page for the server queue @@ -1325,7 +1325,9 @@ impl SystemServices { // Initialize the server with the given memory page. Server::init(entry, pid, sid, backing).map_err(|x| x)?; - return Ok(sid); + + let cid = self.connect_to_server(sid)?; + return Ok((sid, cid)); } } Err(xous_kernel::Error::ServerNotFound) @@ -1338,7 +1340,7 @@ impl SystemServices { // While doing this, find a free slot in case we haven't // yet connected. - let _pid = crate::arch::process::current_pid(); + // let _pid = crate::arch::process::current_pid(); // println!("KERNEL({}): Server table: {:?}", _pid.get(), self.servers); ArchProcess::with_inner_mut(|process_inner| { let mut slot_idx = None; @@ -1390,7 +1392,16 @@ impl SystemServices { } /// Return a server based on the connection id and the current process - pub fn server_from_sidx(&mut self, sidx: usize) -> Option<&mut Server> { + pub fn server_from_sidx(&self, sidx: usize) -> Option<&Server> { + if sidx > self.servers.len() { + None + } else { + self.servers[sidx].as_ref() + } + } + + /// Return a server based on the connection id and the current process + pub fn server_from_sidx_mut(&mut self, sidx: usize) -> Option<&mut Server> { if sidx > self.servers.len() { None } else { @@ -1450,7 +1461,7 @@ impl SystemServices { server_process.mapping.activate().unwrap(); } let server = self - .server_from_sidx(sidx) + .server_from_sidx_mut(sidx) .expect("couldn't re-discover server index"); server.queue_message(pid, context, message, original_address) }; @@ -1461,6 +1472,28 @@ impl SystemServices { result } + /// Obtain the connection ID of the server from within the server process. + pub fn server_cid(&mut self, sidx: usize) -> Result { + let current_pid = self.current_pid(); + let result = { + let server = self + .server_from_sidx(sidx) + .ok_or(xous_kernel::Error::ServerNotFound)?; + let server_pid = server.pid; + let sid = server.sid; + { + let server_process = self.get_process(server_pid)?; + server_process.mapping.activate().unwrap(); + } + self.connect_to_server(sid) + }; + let current_process = self + .get_process(current_pid) + .expect("couldn't restore previous process"); + current_process.mapping.activate()?; + result + } + /// Switch to the server's address space and add a "remember this address" /// entry to its server queue, then switch back to the original address space. pub fn remember_server_message( @@ -1481,9 +1514,9 @@ impl SystemServices { // server_process.mapping.activate(); // } let server = self - .server_from_sidx(sidx) + .server_from_sidx_mut(sidx) .expect("couldn't re-discover server index"); - server.queue_address(pid, context, message, client_address) + server.queue_response(pid, context, message, client_address) } /// Get a server index based on a SID diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index 2451df052..fd6f2a637 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -94,7 +94,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes // If the server has an available context to receive the message, // transfer it right away. if let Some(server_tid) = ss - .server_from_sidx(sidx) + .server_from_sidx_mut(sidx) .expect("server couldn't be located") .take_available_thread() { @@ -102,10 +102,11 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes // "There are contexts available to handle this message. Marking PID {} as Ready", // server_pid // ); - let sender = if message.is_blocking() { + let server_cid = ss.server_cid(sidx)?; + let sender_idx = if message.is_blocking() { ss.remember_server_message(sidx, pid, thread, &message, client_address) .map_err(|e| { - ss.server_from_sidx(sidx) + ss.server_from_sidx_mut(sidx) .expect("server couldn't be located") .return_available_thread(thread); e @@ -113,15 +114,19 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes } else { 0 }; + let sender = SenderID { + cid: server_cid, + idx: sender_idx, + }; let envelope = MessageEnvelope { - sender, + sender: sender.into(), body: message, }; // Mark the server's context as "Ready". If this fails, return the context // to the blocking list. ss.ready_thread(server_pid, server_tid).map_err(|e| { - ss.server_from_sidx(sidx) + ss.server_from_sidx_mut(sidx) .expect("server couldn't be located") .return_available_thread(thread); e @@ -192,15 +197,16 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes fn return_memory(pid: PID, tid: TID, sender: MessageSender, buf: MemoryRange) -> SysCallResult { SystemServices::with_mut(|ss| { - let sender = SenderID::from_usize(sender)?; + let sender = SenderID::from(sender); + let sidx = ss.sidx_from_cid(sender.cid).ok_or(xous_kernel::Error::ServerNotFound)?; let server = ss - .server_from_sidx(sender.sidx) + .server_from_sidx_mut(sidx) .ok_or(xous_kernel::Error::ServerNotFound)?; if server.pid != pid { return Err(xous_kernel::Error::ServerNotFound); } - let result = server.take_waiting_message(sender.tidx, buf)?; + let result = server.take_waiting_message(sender.idx, Some(&buf))?; let (client_pid, client_tid, server_addr, client_addr, len) = match result { WaitingMessage::BorrowedMemory( client_pid, @@ -230,6 +236,10 @@ fn return_memory(pid: PID, tid: TID, sender: MessageSender, buf: MemoryRange) -> result }) } + WaitingMessage::ScalarMessage(_pid, _tid) => { + println!("WARNING: Tried to wait on a message that was a scalar"); + return Err(xous_kernel::Error::InternalError); + } WaitingMessage::None => { println!("WARNING: Tried to wait on a message that didn't exist"); return Err(xous_kernel::Error::ProcessNotFound); @@ -267,6 +277,82 @@ fn return_memory(pid: PID, tid: TID, sender: MessageSender, buf: MemoryRange) -> }) } +fn return_scalar(pid: PID, _tid: TID, sender: MessageSender, arg: usize) -> SysCallResult { + SystemServices::with_mut(|ss| { + let sender = SenderID::from(sender); + + let sidx = ss.sidx_from_cid(sender.cid).ok_or(xous_kernel::Error::ServerNotFound)?; + let server = ss + .server_from_sidx_mut(sidx) + .ok_or(xous_kernel::Error::ServerNotFound)?; + if server.pid != pid { + return Err(xous_kernel::Error::ServerNotFound); + } + let result = server.take_waiting_message(sender.idx, None)?; + let (client_pid, client_tid) = match result { + WaitingMessage::ScalarMessage(pid, tid) => (pid, tid), + WaitingMessage::ForgetMemory(_) => { + println!("WARNING: Tried to wait on a scalar message that was actually forgettingmemory"); + return Err(xous_kernel::Error::ProcessNotFound); + } + WaitingMessage::BorrowedMemory(_, _, _, _, _) => { + println!("WARNING: Tried to wait on a scalar message that was actually borrowed memory"); + return Err(xous_kernel::Error::ProcessNotFound); + } + WaitingMessage::MovedMemory => { + println!("WARNING: Tried to wait on a scalar message that was actually moved memory"); + return Err(xous_kernel::Error::ProcessNotFound); + } + WaitingMessage::None => { + println!("WARNING: Tried to wait on a message that didn't exist"); + return Err(xous_kernel::Error::ProcessNotFound); + } + }; + ss.ready_thread(client_pid, client_tid)?; + ss.switch_to_thread(client_pid, Some(client_tid))?; + ss.set_thread_result(client_pid, client_tid, xous_kernel::Result::Scalar1(arg))?; + Ok(xous_kernel::Result::Ok) + }) +} + +fn return_scalar2(pid: PID, _tid: TID, sender: MessageSender, arg1: usize, arg2: usize) -> SysCallResult { + SystemServices::with_mut(|ss| { + let sender = SenderID::from(sender); + + let sidx = ss.sidx_from_cid(sender.cid).ok_or(xous_kernel::Error::ServerNotFound)?; + let server = ss + .server_from_sidx_mut(sidx) + .ok_or(xous_kernel::Error::ServerNotFound)?; + if server.pid != pid { + return Err(xous_kernel::Error::ServerNotFound); + } + let result = server.take_waiting_message(sender.idx, None)?; + let (client_pid, client_tid) = match result { + WaitingMessage::ScalarMessage(pid, tid) => (pid, tid), + WaitingMessage::ForgetMemory(_) => { + println!("WARNING: Tried to wait on a scalar message that was actually forgetting memory"); + return Err(xous_kernel::Error::ProcessNotFound); + } + WaitingMessage::BorrowedMemory(_, _, _, _, _) => { + println!("WARNING: Tried to wait on a scalar message that was actually borrowed memory"); + return Err(xous_kernel::Error::ProcessNotFound); + } + WaitingMessage::MovedMemory => { + println!("WARNING: Tried to wait on a scalar message that was actually moved memory"); + return Err(xous_kernel::Error::ProcessNotFound); + } + WaitingMessage::None => { + println!("WARNING: Tried to wait on a message that didn't exist"); + return Err(xous_kernel::Error::ProcessNotFound); + } + }; + ss.ready_thread(client_pid, client_tid)?; + ss.switch_to_thread(client_pid, Some(client_tid))?; + ss.set_thread_result(client_pid, client_tid, xous_kernel::Result::Scalar2(arg1, arg2))?; + Ok(xous_kernel::Result::Ok) + }) +} + fn receive_message(pid: PID, tid: TID, sid: SID) -> SysCallResult { SystemServices::with_mut(|ss| { assert!( @@ -274,11 +360,12 @@ fn receive_message(pid: PID, tid: TID, sid: SID) -> SysCallResult { "current thread is not running" ); // See if there is a pending message. If so, return immediately. + let cid = ss.connect_to_server(sid)?; let sidx = ss .server_sidx(sid) .ok_or(xous_kernel::Error::ServerNotFound)?; let server = ss - .server_from_sidx(sidx) + .server_from_sidx_mut(sidx) .ok_or(xous_kernel::Error::ServerNotFound)?; // server.print_queue(); @@ -288,8 +375,7 @@ fn receive_message(pid: PID, tid: TID, sid: SID) -> SysCallResult { } // If there is a pending message, return it immediately. - if let Some(msg) = server.take_next_message(sidx) { - // println!("PID {} had a message ready -- returning it", pid); + if let Some(msg) = server.take_next_message(cid) { return Ok(xous_kernel::Result::Message(msg)); } @@ -531,13 +617,16 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { }), SysCall::CreateServer(name) => SystemServices::with_mut(|ss| { ss.create_server(pid, name) - .map(xous_kernel::Result::ServerID) + .map(|(sid, cid)| xous_kernel::Result::NewServerID(sid, cid)) }), SysCall::TryConnect(sid) => SystemServices::with_mut(|ss| { ss.connect_to_server(sid) .map(xous_kernel::Result::ConnectionID) }), SysCall::ReturnMemory(sender, buf) => return_memory(pid, tid, sender, buf), + SysCall::ReturnScalar1(sender, arg) => return_scalar(pid, tid, sender, arg), + SysCall::ReturnScalar2(sender, arg1, arg2) => return_scalar2(pid, tid, sender, arg1, arg2), + // SysCall::ReturnScalar2(sender, arg, arg2) => return_memory(pid, tid, sender, arg, arg2), SysCall::TrySendMessage(cid, message) => send_message(pid, tid, cid, message), SysCall::TerminateProcess => SystemServices::with_mut(|ss| { ss.switch_from_thread(pid, tid)?; @@ -557,6 +646,6 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { // SystemServices::with_mut(|ss| ss.connect_to_server(sid).map(xous_kernel::Result::ConnectionID)) // } // SysCall::SendMessage(cid, message) => send_message(pid, tid, cid, message), - _ => Err(xous_kernel::Error::UnhandledSyscall), + _ => panic!("Unhandled Syscall: {:?}", call), //Err(xous_kernel::Error::UnhandledSyscall), } } diff --git a/kernel/src/test.rs b/kernel/src/test.rs index 90d486de1..c999f5ddf 100644 --- a/kernel/src/test.rs +++ b/kernel/src/test.rs @@ -179,6 +179,95 @@ fn send_scalar_message() { main_thread.join().expect("couldn't join kernel process"); } +#[test] +fn send_blocking_scalar_message() { + // Start the server in another thread + let main_thread = start_kernel(SERVER_SPEC); + + let (server_addr_send, server_addr_recv) = channel(); + + // Spawn the server "process" (which just lives in a separate thread) + // and receive the message. Note that we need to communicate to the + // "Client" what our server ID is. Normally this would be done via + // an external nameserver. + let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( + "send_scalar_message server", + move || { + let sid = xous_kernel::create_server(b"send_scalar_mesg") + .expect("couldn't create test server"); + server_addr_send.send(sid).unwrap(); + let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); + assert_eq!( + envelope.body, + xous_kernel::Message::BlockingScalar(xous_kernel::ScalarMessage { + id: 1, + arg1: 2, + arg2: 3, + arg3: 4, + arg4: 5 + }) + ); + xous_kernel::return_scalar(envelope.sender, 42).expect("couldn't return scalar"); + + let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); + assert_eq!( + envelope.body, + xous_kernel::Message::BlockingScalar(xous_kernel::ScalarMessage { + id: 6, + arg1: 7, + arg2: 8, + arg3: 9, + arg4: 10 + }) + ); + xous_kernel::return_scalar2(envelope.sender, 56, 78).expect("couldn't return scalar"); + }, + )) + .expect("couldn't spawn server process"); + + // Spawn the client "process" and wait for the server address. + let xous_client = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( + "send_scalar_message client", + move || { + let sid = server_addr_recv.recv().unwrap(); + let conn = xous_kernel::try_connect(sid).expect("couldn't connect to server"); + let result = xous_kernel::try_send_message( + conn, + xous_kernel::Message::BlockingScalar(xous_kernel::ScalarMessage { + id: 1, + arg1: 2, + arg2: 3, + arg3: 4, + arg4: 5, + }), + ) + .expect("couldn't send message"); + assert_eq!(result, xous_kernel::Result::Scalar1(42)); + + let result = xous_kernel::try_send_message( + conn, + xous_kernel::Message::BlockingScalar(xous_kernel::ScalarMessage { + id: 6, + arg1: 7, + arg2: 8, + arg3: 9, + arg4: 10, + }), + ) + .expect("couldn't send message"); + assert_eq!(result, xous_kernel::Result::Scalar2(56, 78)); + }, + )) + .expect("couldn't spawn client process"); + + // Wait for both processes to finish + crate::wait_process_as_thread(xous_server).expect("couldn't join server process"); + crate::wait_process_as_thread(xous_client).expect("couldn't join client process"); + shutdown_kernel(); + + main_thread.join().expect("couldn't join kernel process"); +} + #[test] fn send_move_message() { let test_str = "Hello, world!";