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 <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-09-23 10:52:22 +08:00
parent ad154e998e
commit e5583a7646
4 changed files with 378 additions and 113 deletions

View file

@ -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<SenderID, xous_kernel::Error> {
Ok(SenderID {
sidx: src >> 16,
tidx: src & 0xffff,
})
impl From<usize> for SenderID {
fn from(item: usize) -> SenderID {
SenderID {
cid: item >> 16,
idx: item & 0xffff,
}
}
}
impl Into<usize> 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<WaitingMessage, xous_kernel::Error> {
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<xous_kernel::MessageEnvelope> {
pub fn take_next_message(&mut self, cid: xous_kernel::CID) -> Option<xous_kernel::MessageEnvelope> {
// 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() {

View file

@ -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<SID, xous_kernel::Error> {
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<CID, xous_kernel::Error> {
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

View file

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

View file

@ -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!";