From 2dd62e50fd4fed12ed15b852db258bef61344d19 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Thu, 19 Mar 2020 08:52:25 +0800 Subject: [PATCH] xous: rework definition of message structs Message structs are used to pass memory between processes. Rework how this struct is laid out so as to better describe this process. Signed-off-by: Sean Cross --- xous-rs/src/definitions.rs | 29 +++++++++++++--- xous-rs/src/syscall.rs | 71 ++++++++++++++++++++++++++++++-------- 2 files changed, 81 insertions(+), 19 deletions(-) diff --git a/xous-rs/src/definitions.rs b/xous-rs/src/definitions.rs index 4896e2498..4a8cdff7e 100644 --- a/xous-rs/src/definitions.rs +++ b/xous-rs/src/definitions.rs @@ -47,16 +47,33 @@ pub struct Context { #[repr(C)] #[derive(Debug)] +/// A struct describing memory that is passed between processes. +/// The `buf` value will get translated as necessary. pub struct MemoryMessage { + + /// A user-assignable message ID. pub id: MessageId, - pub in_buf: Option, - pub in_buf_size: Option, - pub out_buf: Option, - pub out_buf_size: Option, + + /// The offset of the buffer. This address will get + /// transformed when the message is moved between + /// processes. + pub buf: Option, + + /// The overall size of the buffer. Must be a multiple + /// of PAGE_SIZE. + pub buf_size: Option, + + /// The offset within the buffer where the interesting + /// stuff starts. + pub _offset: Option, + + /// How many bytes in the buffer are valid + pub _valid: Option, } #[repr(C)] #[derive(Debug)] +/// A simple scalar message. This is similar to a `move` message. pub struct ScalarMessage { pub id: MessageId, pub arg1: usize, @@ -68,7 +85,9 @@ pub struct ScalarMessage { #[repr(usize)] #[derive(Debug)] pub enum Message { - Memory(MemoryMessage), + MutableBorrow(MemoryMessage), + ImmutableBorrow(MemoryMessage), + Move(MemoryMessage), Scalar(ScalarMessage), } diff --git a/xous-rs/src/syscall.rs b/xous-rs/src/syscall.rs index dab1740f4..184684ae3 100644 --- a/xous-rs/src/syscall.rs +++ b/xous-rs/src/syscall.rs @@ -388,20 +388,40 @@ impl SysCall { [SysCallNumber::Connect as usize, sid.0, sid.1, sid.2, sid.3, 0, 0, 0] } SysCall::SendMessage(a1, ref a2) => match a2 { - Message::Memory(mm) => [ + Message::MutableBorrow(mm) => [ SysCallNumber::SendMessage as usize, a1, 1, mm.id as usize, - mm.in_buf.map(|x| x.get()).unwrap_or(0) as usize, - mm.in_buf_size.map(|x| x.get()).unwrap_or(0) as usize, - mm.out_buf.map(|x| x.get()).unwrap_or(0) as usize, - mm.out_buf_size.map(|x| x.get()).unwrap_or(0) as usize, + mm.buf.map(|x| x.get()).unwrap_or(0) as usize, + mm.buf_size.map(|x| x.get()).unwrap_or(0) as usize, + mm._offset.map(|x| x.get()).unwrap_or(0) as usize, + mm._valid.map(|x| x.get()).unwrap_or(0) as usize, + ], + Message::ImmutableBorrow(mm) => [ + SysCallNumber::SendMessage as usize, + a1, + 2, + mm.id as usize, + mm.buf.map(|x| x.get()).unwrap_or(0) as usize, + mm.buf_size.map(|x| x.get()).unwrap_or(0) as usize, + mm._offset.map(|x| x.get()).unwrap_or(0) as usize, + mm._valid.map(|x| x.get()).unwrap_or(0) as usize, + ], + Message::Move(mm) => [ + SysCallNumber::SendMessage as usize, + a1, + 3, + mm.id as usize, + mm.buf.map(|x| x.get()).unwrap_or(0) as usize, + mm.buf_size.map(|x| x.get()).unwrap_or(0) as usize, + mm._offset.map(|x| x.get()).unwrap_or(0) as usize, + mm._valid.map(|x| x.get()).unwrap_or(0) as usize, ], Message::Scalar(sc) => [ SysCallNumber::SendMessage as usize, a1, - 2, + 4, sc.id as usize, sc.arg1, sc.arg2, @@ -458,15 +478,35 @@ impl SysCall { Some(SysCallNumber::SendMessage) => match a2 { 1 => SysCall::SendMessage( a1, - Message::Memory(MemoryMessage { + Message::MutableBorrow(MemoryMessage { id: a3, - in_buf: MemoryAddress::new(a4), - in_buf_size: MemorySize::new(a5), - out_buf: MemoryAddress::new(a6), - out_buf_size: MemorySize::new(a7), + buf: MemoryAddress::new(a4), + buf_size: MemorySize::new(a5), + _offset: MemoryAddress::new(a6), + _valid: MemorySize::new(a7), }), ), 2 => SysCall::SendMessage( + a1, + Message::ImmutableBorrow(MemoryMessage { + id: a3, + buf: MemoryAddress::new(a4), + buf_size: MemorySize::new(a5), + _offset: MemoryAddress::new(a6), + _valid: MemorySize::new(a7), + }), + ), + 3 => SysCall::SendMessage( + a1, + Message::Move(MemoryMessage { + id: a3, + buf: MemoryAddress::new(a4), + buf_size: MemorySize::new(a5), + _offset: MemoryAddress::new(a6), + _valid: MemorySize::new(a7), + }), + ), + 4 => SysCall::SendMessage( a1, Message::Scalar(ScalarMessage { id: a3, @@ -523,6 +563,7 @@ pub enum Result { ResumeResult(usize, usize, usize, usize, usize, usize), ResumeProcess, ServerID(SID), + ConnectionID(CID), UnknownResult(usize, usize, usize, usize, usize, usize, usize), } @@ -624,8 +665,9 @@ pub fn receive_message(server: SID) -> core::result::Result core::result::Result core::result::Result<(), Error> { +pub fn send_message(connection: CID, message: Message) -> core::result::Result<(), Error> { + let result = rsyscall(SysCall::SendMessage(connection, message)).expect("couldn't send message"); Err(Error::UnhandledSyscall) }