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!(),
};
}
xous_kernel::Message::Scalar(_) => (),
xous_kernel::Message::Scalar(_) | xous_kernel::Message::BlockingScalar(_) => (),
}
}
_ => panic!("unsupported message type"),

View file

@ -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())
}

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 {
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),
}
}