From 43002b86279f80758d4b6f19c45458e915840c0c Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Tue, 22 Sep 2020 22:05:18 +0800 Subject: [PATCH] kernel: add blocking scalars Add a new type: BlockingScalar, that can be used to do blocking scalar calls such as sleep(). Signed-off-by: Sean Cross --- kernel/src/arch/hosted.rs | 2 +- kernel/src/server.rs | 138 +++++++++++++++++++++++++++++--------- kernel/src/syscall.rs | 75 ++++++++++++++------- 3 files changed, 156 insertions(+), 59 deletions(-) diff --git a/kernel/src/arch/hosted.rs b/kernel/src/arch/hosted.rs index 6ea40c557..b9e56b87c 100644 --- a/kernel/src/arch/hosted.rs +++ b/kernel/src/arch/hosted.rs @@ -212,7 +212,7 @@ fn handle_connection( _ => unreachable!(), }; } - xous_kernel::Message::Scalar(_) => (), + xous_kernel::Message::Scalar(_) | xous_kernel::Message::BlockingScalar(_) => (), } } _ => panic!("unsupported message type"), diff --git a/kernel/src/server.rs b/kernel/src/server.rs index fde41487b..a4a6ddbf6 100644 --- a/kernel/src/server.rs +++ b/kernel/src/server.rs @@ -1,6 +1,6 @@ pub use crate::arch::process::Thread; use core::mem; -use xous_kernel::{TID, MemoryAddress, MemoryRange, MemorySize, Message, PID, SID}; +use xous_kernel::{MemoryAddress, MemoryRange, MemorySize, Message, PID, SID, TID}; pub struct SenderID { pub sidx: usize, @@ -36,6 +36,16 @@ pub enum WaitingMessage { #[derive(PartialEq, Debug)] enum QueuedMessage { Empty, + BlockingScalarMessage( + u16, /* sender PID */ + u16, /* Sender CTX */ + usize, /* sender base address */ + usize, /* id */ + usize, /* arg1 */ + usize, /* arg2 */ + usize, /* arg3 */ + usize, /* arg4 */ + ), ScalarMessage( u16, /* sender PID */ u16, /* Sender CTX */ @@ -103,6 +113,19 @@ enum QueuedMessage { usize, /* valid */ ), + /// The process waiting for the response terminated before + /// we could receive the message. + BlockingScalarTerminated( + u16, /* sender PID */ + u16, /* Sender CTX */ + usize, /* sender base 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 WaitingResponse token and its /// index is returned as the message sender. This is used to unblock the @@ -124,6 +147,10 @@ enum QueuedMessage { usize, /* Server 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 */), } /// A pointer to resolve a server ID to a particular process @@ -262,6 +289,22 @@ impl Server { ); } } + QueuedMessage::BlockingScalarMessage( + msg_pid, + ctx, + arg1, + arg2, + arg3, + arg4, + arg5, + arg6, + ) => { + if msg_pid == pid.get() as _ { + *entry = QueuedMessage::BlockingScalarTerminated( + msg_pid, ctx, 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. @@ -343,10 +386,11 @@ impl Server { // "queue_head: ((({}))) queue_tail: ((({}))): {:?}", // self.queue_head, self.queue_tail, self.queue[self.queue_tail] // ); - let result = match self.queue[self.queue_tail] { + let (result, response) = match self.queue[self.queue_tail] { QueuedMessage::Empty => return None, QueuedMessage::WaitingResponse(_, _, _, _, _) => return None, QueuedMessage::WaitingForget(_, _, _, _, _) => return None, + QueuedMessage::WaitingScalar(_, _) => return None, QueuedMessage::MemoryMessageROLend( pid, ctx, @@ -366,12 +410,7 @@ impl Server { valid: MemorySize::new(valid), }), }, - pid, - ctx, - buf, - client_addr, - buf_size, - false, + QueuedMessage::WaitingForget(pid, ctx, buf, client_addr, buf_size), ), QueuedMessage::MemoryMessageRWLend( pid, @@ -392,12 +431,7 @@ impl Server { valid: MemorySize::new(valid), }), }, - pid, - ctx, - buf, - client_addr, - buf_size, - false, + QueuedMessage::WaitingForget(pid, ctx, buf, client_addr, buf_size), ), QueuedMessage::MemoryMessageROLendTerminated( pid, @@ -418,12 +452,7 @@ impl Server { valid: MemorySize::new(valid), }), }, - pid, - ctx, - buf, - client_addr, - buf_size, - true, + QueuedMessage::WaitingResponse(pid, ctx, buf, client_addr, buf_size), ), QueuedMessage::MemoryMessageRWLendTerminated( pid, @@ -444,12 +473,30 @@ impl Server { valid: MemorySize::new(valid), }), }, + QueuedMessage::WaitingResponse(pid, ctx, buf, client_addr, buf_size), + ), + + QueuedMessage::BlockingScalarMessage( pid, ctx, - buf, - client_addr, - buf_size, - true, + _reserved, + id, + arg1, + arg2, + arg3, + arg4, + ) => ( + xous_kernel::MessageEnvelope { + sender: make_sender(pid, ctx), + body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage { + id, + arg1, + arg2, + arg3, + arg4, + }), + }, + QueuedMessage::WaitingScalar(pid, ctx), ), QueuedMessage::MemoryMessageSend( pid, @@ -497,15 +544,28 @@ impl Server { } return Some(msg); } + QueuedMessage::BlockingScalarTerminated(pid, ctx, _reserved, id, arg1, arg2, arg3, arg4) => { + let msg = xous_kernel::MessageEnvelope { + sender: make_sender(pid, ctx), + body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage { + id, + arg1, + arg2, + arg3, + arg4, + }), + }; + self.queue[self.queue_tail] = QueuedMessage::Empty; + self.queue_tail += 1; + if self.queue_tail >= self.queue.len() { + self.queue_tail = 0; + } + return Some(msg); + } }; - if result.6 { - self.queue[self.queue_tail] = - QueuedMessage::WaitingForget(result.1, result.2, result.3, result.4, result.5); - } else { - self.queue[self.queue_tail] = - QueuedMessage::WaitingResponse(result.1, result.2, result.3, result.4, result.5); - } - Some(result.0) + + self.queue[self.queue_tail] = response; + Some(result) } /// Add the given message to this server's queue. @@ -536,6 +596,16 @@ impl Server { 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 _, @@ -588,7 +658,9 @@ impl Server { return Err(xous_kernel::Error::ServerQueueFull); } let (server_address, len) = match message { - xous_kernel::Message::Scalar(_) | xous_kernel::Message::Move(_) => (0, 0), + xous_kernel::Message::Scalar(_) + | xous_kernel::Message::BlockingScalar(_) + | xous_kernel::Message::Move(_) => (0, 0), xous_kernel::Message::MutableBorrow(msg) | xous_kernel::Message::Borrow(msg) => { (msg.buf.addr.get(), msg.buf.size.get()) } diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index 7187a9677..bb8c912ee 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -12,7 +12,9 @@ static mut SWITCHTO_CALLER: Option<(PID, TID)> = None; fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallResult { SystemServices::with_mut(|ss| { - let sidx = ss.sidx_from_cid(cid).ok_or(xous_kernel::Error::ServerNotFound)?; + let sidx = ss + .sidx_from_cid(cid) + .ok_or(xous_kernel::Error::ServerNotFound)?; // ::debug_here::debug_here!(); let server_pid = ss @@ -23,7 +25,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes // Remember the address the message came from, in case we need to // return it after the borrow is through. let client_address = match &message { - Message::Scalar(_) => None, + Message::Scalar(_) | Message::BlockingScalar(_) => None, Message::Move(msg) | Message::MutableBorrow(msg) | Message::Borrow(msg) => { Some(msg.buf.addr) } @@ -34,6 +36,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes // so, switch to the server context right away. let (message, blocking) = match message { Message::Scalar(_) => (message, false), + Message::BlockingScalar(_) => (message, true), Message::Move(msg) => { let new_virt = ss.send_memory( msg.buf.as_mut_ptr(), @@ -108,18 +111,21 @@ 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 = match message { - Message::Scalar(_) | Message::Move(_) => 0, - Message::Borrow(_) | Message::MutableBorrow(_) => ss - .remember_server_message(sidx, pid, thread, &message, client_address) + let sender = if message.is_blocking() { + ss.remember_server_message(sidx, pid, thread, &message, client_address) .map_err(|e| { ss.server_from_sidx(sidx) .expect("server couldn't be located") .return_available_thread(thread); e - })?, + })? + } else { + 0 + }; + let envelope = MessageEnvelope { + sender, + body: message, }; - let envelope = MessageEnvelope { sender, body: message }; // Mark the server's context as "Ready". If this fails, return the context // to the blocking list. @@ -139,19 +145,31 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes // println!("Blocking client, since it sent a blocking message"); ss.switch_from_thread(pid, thread)?; ss.switch_to_thread(server_pid, Some(server_tid))?; - ss.set_thread_result(server_pid, server_tid, xous_kernel::Result::Message(envelope)) - .map(|_| xous_kernel::Result::BlockedProcess) + ss.set_thread_result( + server_pid, + server_tid, + xous_kernel::Result::Message(envelope), + ) + .map(|_| xous_kernel::Result::BlockedProcess) } else if cfg!(baremetal) { // println!("Setting the return value of the Server and returning to Client"); - ss.set_thread_result(server_pid, server_tid, xous_kernel::Result::Message(envelope)) - .map(|_| xous_kernel::Result::Ok) + ss.set_thread_result( + server_pid, + server_tid, + xous_kernel::Result::Message(envelope), + ) + .map(|_| xous_kernel::Result::Ok) } else { // println!("Setting the return value of the Server and returning to Client"); // "Switch to" the server PID when not running on bare metal. This ensures // that it's "Running". ss.switch_to_thread(server_pid, Some(server_tid))?; - ss.set_thread_result(server_pid, server_tid, xous_kernel::Result::Message(envelope)) - .map(|_| xous_kernel::Result::Ok) + ss.set_thread_result( + server_pid, + server_tid, + xous_kernel::Result::Message(envelope), + ) + .map(|_| xous_kernel::Result::Ok) } } else { // Add this message to the queue. If the queue is full, this @@ -265,7 +283,9 @@ 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 sidx = ss.server_sidx(sid).ok_or(xous_kernel::Error::ServerNotFound)?; + let sidx = ss + .server_sidx(sid) + .ok_or(xous_kernel::Error::ServerNotFound)?; let server = ss .server_from_sidx(sidx) .ok_or(xous_kernel::Error::ServerNotFound)?; @@ -462,7 +482,8 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { }) } SysCall::ClaimInterrupt(no, callback, arg) => { - interrupt_claim(no, pid as definitions::PID, callback, arg).map(|_| xous_kernel::Result::Ok) + interrupt_claim(no, pid as definitions::PID, callback, arg) + .map(|_| xous_kernel::Result::Ok) } SysCall::Yield => { // If we're not running on bare metal, treat this as a no-op. @@ -514,14 +535,17 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { }) }), SysCall::CreateProcess(process_init) => SystemServices::with_mut(|ss| { - ss.create_process(process_init).map(xous_kernel::Result::ProcessID) + ss.create_process(process_init) + .map(xous_kernel::Result::ProcessID) + }), + SysCall::CreateServer(name) => SystemServices::with_mut(|ss| { + ss.create_server(pid, name) + .map(xous_kernel::Result::ServerID) + }), + SysCall::TryConnect(sid) => SystemServices::with_mut(|ss| { + ss.connect_to_server(sid) + .map(xous_kernel::Result::ConnectionID) }), - SysCall::CreateServer(name) => { - SystemServices::with_mut(|ss| ss.create_server(pid, name).map(xous_kernel::Result::ServerID)) - } - 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::TrySendMessage(cid, message) => send_message(pid, tid, cid, message), SysCall::TerminateProcess => SystemServices::with_mut(|ss| { @@ -534,13 +558,14 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { Ok(xous_kernel::Result::Ok) } }), - SysCall::Shutdown => SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous_kernel::Result::Ok)), + SysCall::Shutdown => { + SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous_kernel::Result::Ok)) + } // SysCall::Connect(sid) => { // 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), } }