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 <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-09-22 22:05:18 +08:00
parent 673577a10e
commit 43002b8627
3 changed files with 156 additions and 59 deletions

View file

@ -212,7 +212,7 @@ fn handle_connection(
_ => unreachable!(), _ => unreachable!(),
}; };
} }
xous_kernel::Message::Scalar(_) => (), xous_kernel::Message::Scalar(_) | xous_kernel::Message::BlockingScalar(_) => (),
} }
} }
_ => panic!("unsupported message type"), _ => panic!("unsupported message type"),

View file

@ -1,6 +1,6 @@
pub use crate::arch::process::Thread; pub use crate::arch::process::Thread;
use core::mem; 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 struct SenderID {
pub sidx: usize, pub sidx: usize,
@ -36,6 +36,16 @@ pub enum WaitingMessage {
#[derive(PartialEq, Debug)] #[derive(PartialEq, Debug)]
enum QueuedMessage { enum QueuedMessage {
Empty, Empty,
BlockingScalarMessage(
u16, /* sender PID */
u16, /* Sender CTX */
usize, /* sender base address */
usize, /* id */
usize, /* arg1 */
usize, /* arg2 */
usize, /* arg3 */
usize, /* arg4 */
),
ScalarMessage( ScalarMessage(
u16, /* sender PID */ u16, /* sender PID */
u16, /* Sender CTX */ u16, /* Sender CTX */
@ -103,6 +113,19 @@ enum QueuedMessage {
usize, /* valid */ 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 /// 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 WaitingResponse token and its
/// index is returned as the message sender. This is used to unblock the /// index is returned as the message sender. This is used to unblock the
@ -124,6 +147,10 @@ enum QueuedMessage {
usize, /* Server base address */ usize, /* Server base address */
usize, /* Range size */ 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 /// 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 // For "Scalar" and "Move" messages, this memory has already
// been moved into this process, so memory will be reclaimed // been moved into this process, so memory will be reclaimed
// when the process terminates. // when the process terminates.
@ -343,10 +386,11 @@ impl Server {
// "queue_head: ((({}))) queue_tail: ((({}))): {:?}", // "queue_head: ((({}))) queue_tail: ((({}))): {:?}",
// self.queue_head, self.queue_tail, self.queue[self.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::Empty => return None,
QueuedMessage::WaitingResponse(_, _, _, _, _) => return None, QueuedMessage::WaitingResponse(_, _, _, _, _) => return None,
QueuedMessage::WaitingForget(_, _, _, _, _) => return None, QueuedMessage::WaitingForget(_, _, _, _, _) => return None,
QueuedMessage::WaitingScalar(_, _) => return None,
QueuedMessage::MemoryMessageROLend( QueuedMessage::MemoryMessageROLend(
pid, pid,
ctx, ctx,
@ -366,12 +410,7 @@ impl Server {
valid: MemorySize::new(valid), valid: MemorySize::new(valid),
}), }),
}, },
pid, QueuedMessage::WaitingForget(pid, ctx, buf, client_addr, buf_size),
ctx,
buf,
client_addr,
buf_size,
false,
), ),
QueuedMessage::MemoryMessageRWLend( QueuedMessage::MemoryMessageRWLend(
pid, pid,
@ -392,12 +431,7 @@ impl Server {
valid: MemorySize::new(valid), valid: MemorySize::new(valid),
}), }),
}, },
pid, QueuedMessage::WaitingForget(pid, ctx, buf, client_addr, buf_size),
ctx,
buf,
client_addr,
buf_size,
false,
), ),
QueuedMessage::MemoryMessageROLendTerminated( QueuedMessage::MemoryMessageROLendTerminated(
pid, pid,
@ -418,12 +452,7 @@ impl Server {
valid: MemorySize::new(valid), valid: MemorySize::new(valid),
}), }),
}, },
pid, QueuedMessage::WaitingResponse(pid, ctx, buf, client_addr, buf_size),
ctx,
buf,
client_addr,
buf_size,
true,
), ),
QueuedMessage::MemoryMessageRWLendTerminated( QueuedMessage::MemoryMessageRWLendTerminated(
pid, pid,
@ -444,12 +473,30 @@ impl Server {
valid: MemorySize::new(valid), valid: MemorySize::new(valid),
}), }),
}, },
QueuedMessage::WaitingResponse(pid, ctx, buf, client_addr, buf_size),
),
QueuedMessage::BlockingScalarMessage(
pid, pid,
ctx, ctx,
buf, _reserved,
client_addr, id,
buf_size, arg1,
true, 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( QueuedMessage::MemoryMessageSend(
pid, pid,
@ -497,15 +544,28 @@ impl Server {
} }
return Some(msg); 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] = self.queue[self.queue_tail] = response;
QueuedMessage::WaitingForget(result.1, result.2, result.3, result.4, result.5); Some(result)
} else {
self.queue[self.queue_tail] =
QueuedMessage::WaitingResponse(result.1, result.2, result.3, result.4, result.5);
}
Some(result.0)
} }
/// Add the given message to this server's queue. /// Add the given message to this server's queue.
@ -536,6 +596,16 @@ impl Server {
msg.arg3, msg.arg3,
msg.arg4, 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( xous_kernel::Message::Move(msg) => QueuedMessage::MemoryMessageSend(
pid.get() as _, pid.get() as _,
context as _, context as _,
@ -588,7 +658,9 @@ impl Server {
return Err(xous_kernel::Error::ServerQueueFull); return Err(xous_kernel::Error::ServerQueueFull);
} }
let (server_address, len) = match message { 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) => { xous_kernel::Message::MutableBorrow(msg) | xous_kernel::Message::Borrow(msg) => {
(msg.buf.addr.get(), msg.buf.size.get()) (msg.buf.addr.get(), msg.buf.size.get())
} }

View file

@ -12,7 +12,9 @@ static mut SWITCHTO_CALLER: Option<(PID, TID)> = None;
fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallResult { fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallResult {
SystemServices::with_mut(|ss| { 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!(); // ::debug_here::debug_here!();
let server_pid = ss 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 // Remember the address the message came from, in case we need to
// return it after the borrow is through. // return it after the borrow is through.
let client_address = match &message { let client_address = match &message {
Message::Scalar(_) => None, Message::Scalar(_) | Message::BlockingScalar(_) => None,
Message::Move(msg) | Message::MutableBorrow(msg) | Message::Borrow(msg) => { Message::Move(msg) | Message::MutableBorrow(msg) | Message::Borrow(msg) => {
Some(msg.buf.addr) 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. // so, switch to the server context right away.
let (message, blocking) = match message { let (message, blocking) = match message {
Message::Scalar(_) => (message, false), Message::Scalar(_) => (message, false),
Message::BlockingScalar(_) => (message, true),
Message::Move(msg) => { Message::Move(msg) => {
let new_virt = ss.send_memory( let new_virt = ss.send_memory(
msg.buf.as_mut_ptr(), 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", // "There are contexts available to handle this message. Marking PID {} as Ready",
// server_pid // server_pid
// ); // );
let sender = match message { let sender = if message.is_blocking() {
Message::Scalar(_) | Message::Move(_) => 0, ss.remember_server_message(sidx, pid, thread, &message, client_address)
Message::Borrow(_) | Message::MutableBorrow(_) => ss
.remember_server_message(sidx, pid, thread, &message, client_address)
.map_err(|e| { .map_err(|e| {
ss.server_from_sidx(sidx) ss.server_from_sidx(sidx)
.expect("server couldn't be located") .expect("server couldn't be located")
.return_available_thread(thread); .return_available_thread(thread);
e 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 // Mark the server's context as "Ready". If this fails, return the context
// to the blocking list. // 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"); // println!("Blocking client, since it sent a blocking message");
ss.switch_from_thread(pid, thread)?; ss.switch_from_thread(pid, thread)?;
ss.switch_to_thread(server_pid, Some(server_tid))?; ss.switch_to_thread(server_pid, Some(server_tid))?;
ss.set_thread_result(server_pid, server_tid, xous_kernel::Result::Message(envelope)) ss.set_thread_result(
.map(|_| xous_kernel::Result::BlockedProcess) server_pid,
server_tid,
xous_kernel::Result::Message(envelope),
)
.map(|_| xous_kernel::Result::BlockedProcess)
} else if cfg!(baremetal) { } else if cfg!(baremetal) {
// println!("Setting the return value of the Server and returning to Client"); // 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)) ss.set_thread_result(
.map(|_| xous_kernel::Result::Ok) server_pid,
server_tid,
xous_kernel::Result::Message(envelope),
)
.map(|_| xous_kernel::Result::Ok)
} else { } else {
// println!("Setting the return value of the Server and returning to Client"); // 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 // "Switch to" the server PID when not running on bare metal. This ensures
// that it's "Running". // that it's "Running".
ss.switch_to_thread(server_pid, Some(server_tid))?; ss.switch_to_thread(server_pid, Some(server_tid))?;
ss.set_thread_result(server_pid, server_tid, xous_kernel::Result::Message(envelope)) ss.set_thread_result(
.map(|_| xous_kernel::Result::Ok) server_pid,
server_tid,
xous_kernel::Result::Message(envelope),
)
.map(|_| xous_kernel::Result::Ok)
} }
} else { } else {
// Add this message to the queue. If the queue is full, this // 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" "current thread is not running"
); );
// See if there is a pending message. If so, return immediately. // 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 let server = ss
.server_from_sidx(sidx) .server_from_sidx(sidx)
.ok_or(xous_kernel::Error::ServerNotFound)?; .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) => { 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 => { SysCall::Yield => {
// If we're not running on bare metal, treat this as a no-op. // 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| { 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::ReturnMemory(sender, buf) => return_memory(pid, tid, sender, buf),
SysCall::TrySendMessage(cid, message) => send_message(pid, tid, cid, message), SysCall::TrySendMessage(cid, message) => send_message(pid, tid, cid, message),
SysCall::TerminateProcess => SystemServices::with_mut(|ss| { 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) 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) => { // SysCall::Connect(sid) => {
// SystemServices::with_mut(|ss| ss.connect_to_server(sid).map(xous_kernel::Result::ConnectionID)) // SystemServices::with_mut(|ss| ss.connect_to_server(sid).map(xous_kernel::Result::ConnectionID))
// } // }
// SysCall::SendMessage(cid, message) => send_message(pid, tid, cid, message), // SysCall::SendMessage(cid, message) => send_message(pid, tid, cid, message),
_ => Err(xous_kernel::Error::UnhandledSyscall), _ => Err(xous_kernel::Error::UnhandledSyscall),
} }
} }