From d6f985c14140701a59fa391d8072bc72ecf22f82 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 1 Apr 2020 13:21:23 +0800 Subject: [PATCH] syscall: add call to return memory from a message Signed-off-by: Sean Cross --- kernel/src/main.rs | 4 +- kernel/src/syscall.rs | 23 ++++++++- xous-rs/src/definitions.rs | 34 +++++++------ xous-rs/src/syscall.rs | 97 ++++++++++++++++++++++++-------------- 4 files changed, 106 insertions(+), 52 deletions(-) diff --git a/kernel/src/main.rs b/kernel/src/main.rs index cf9f75d06..81121f985 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -32,7 +32,9 @@ use core::panic::PanicInfo; fn handle_panic(_arg: &PanicInfo) -> ! { println!("PANIC in PID {}!", crate::arch::current_pid()); println!("Details: {:?}", _arg); - loop {} + loop { + arch::wfi(); + } } #[no_mangle] diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index 850c86865..1cd464b22 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -311,6 +311,7 @@ pub fn handle(call: SysCall) -> core::result::Result } SysCall::SendMessage(cid, message) => { let mut ss = SystemServicesHandle::get(); + let context_nr = ss.current_context_nr(); let sidx = ss.sidx_from_cid(cid).ok_or(xous::Error::ServerNotFound)?; let server_pid = ss @@ -342,11 +343,29 @@ pub fn handle(call: SysCall) -> core::result::Result ) } Message::MutableBorrow(_) => unimplemented!(), - Message::ImmutableBorrow(_) => unimplemented!(), + Message::ImmutableBorrow(msg) => { + let new_virt = ss.send_memory( + msg.buf.as_mut_ptr(), + server_pid, + msg.buf.len(), + false, + true, + )?; + ( + Message::ImmutableBorrow(MemoryMessage { + id: msg.id, + buf: MemoryRange::new(new_virt, msg.buf.len()), + offset: msg.offset, + valid: msg.valid, + }), + true, + ) + } +, }; let envelope = MessageEnvelope { - sender: pid as usize, + sender: (((pid as usize) << 16) & 0xffff0000) | ((context_nr << 0) & 0xffff), message, }; diff --git a/xous-rs/src/definitions.rs b/xous-rs/src/definitions.rs index 6560e45fd..a022ffc05 100644 --- a/xous-rs/src/definitions.rs +++ b/xous-rs/src/definitions.rs @@ -21,7 +21,7 @@ pub type CtxID = usize; /// Equivalent to a RISC-V Hart ID pub type CpuID = usize; -#[derive(Debug, PartialEq)] +#[derive(Debug, PartialEq, Copy, Clone)] pub struct MemoryRange { pub addr: MemoryAddress, pub size: MemorySize, @@ -76,19 +76,6 @@ pub struct MemoryMessage { pub valid: Option, } -#[cfg(not(feature = "forget-memory-messages"))] -impl Drop for MessageEnvelope { - fn drop(&mut self) { - match &self.message { - Message::MutableBorrow(msg) | Message::ImmutableBorrow(msg) | Message::Move(msg) => { - crate::syscall::unmap_memory(msg.buf.addr, msg.buf.size) - .expect("couldn't free memory message"); - } - Message::Scalar(_) => (), - } - } -} - #[repr(C)] #[derive(Debug, PartialEq)] /// A simple scalar message. This is similar to a `move` message. @@ -116,6 +103,25 @@ pub struct MessageEnvelope { pub message: Message, } +#[cfg(not(feature = "forget-memory-messages"))] +/// When a MessageEnvelope goes out of scope, return the memory. It must either +/// go to the kernel (in the case of a Move), or back to the borrowed process +/// (in the case of a Borrow). Ignore Scalar messages. +impl Drop for MessageEnvelope { + fn drop(&mut self) { + match &self.message { + Message::MutableBorrow(msg) | Message::ImmutableBorrow(msg) => { + crate::syscall::return_memory(self.sender, msg.buf).expect("couldn't return memory"); + } + Message::Move(msg) => { + crate::syscall::unmap_memory(msg.buf.addr, msg.buf.size) + .expect("couldn't free memory message"); + } + Message::Scalar(_) => (), + } + } +} + impl MemoryRange { pub fn new(addr: usize, size: usize) -> MemoryRange { assert!( diff --git a/xous-rs/src/syscall.rs b/xous-rs/src/syscall.rs index 6b9714a52..c45325ed5 100644 --- a/xous-rs/src/syscall.rs +++ b/xous-rs/src/syscall.rs @@ -1,6 +1,6 @@ use crate::{ CpuID, CtxID, Error, MemoryAddress, MemoryMessage, MemoryRange, MemorySize, Message, - MessageEnvelope, ScalarMessage, CID, PID, SID, + MessageEnvelope, MessageSender, ScalarMessage, CID, PID, SID, }; use num_derive::FromPrimitive; use num_traits::FromPrimitive; @@ -282,6 +282,9 @@ pub enum SysCall { /// Send a message to a server SendMessage(CID, Message), + /// Return a Borrowed memory region to a sender + ReturnMemory(MessageSender, MemoryRange), + /// Spawn a new thread SpawnThread( *mut usize, /* entrypoint */ @@ -313,6 +316,7 @@ enum SysCallNumber { Connect = 17, SpawnThread = 18, UnmapMemory = 19, + ReturnMemory = 20, Invalid, } @@ -323,12 +327,12 @@ impl SysCall { mem::size_of::() == mem::size_of::() * 8, "SysCall is not the expected size" ); - match *self { + match self { SysCall::MapMemory(a1, a2, a3, a4) => [ SysCallNumber::MapMemory as usize, - a1 as usize, - a2 as usize, - a3, + *a1 as usize, + *a2 as usize, + *a3, a4.bits(), 0, 0, @@ -336,8 +340,8 @@ impl SysCall { ], SysCall::UnmapMemory(a1, a2) => [ SysCallNumber::UnmapMemory as usize, - a1 as usize, - a2, + *a1 as usize, + *a2, 0, 0, 0, @@ -358,8 +362,8 @@ impl SysCall { ], SysCall::ReturnToParentI(a1, a2) => [ SysCallNumber::ReturnToParentI as usize, - a1 as usize, - a2 as usize, + *a1 as usize, + *a2 as usize, 0, 0, 0, @@ -368,21 +372,21 @@ impl SysCall { ], SysCall::ClaimInterrupt(a1, a2, a3) => [ SysCallNumber::ClaimInterrupt as usize, - a1, - a2 as usize, - a3 as usize, + *a1, + *a2 as usize, + *a3 as usize, 0, 0, 0, 0, ], SysCall::FreeInterrupt(a1) => { - [SysCallNumber::FreeInterrupt as usize, a1, 0, 0, 0, 0, 0, 0] + [SysCallNumber::FreeInterrupt as usize, *a1, 0, 0, 0, 0, 0, 0] } SysCall::SwitchTo(a1, a2) => [ SysCallNumber::SwitchTo as usize, - a1 as usize, - a2 as usize, + *a1 as usize, + *a2 as usize, 0, 0, 0, @@ -391,7 +395,7 @@ impl SysCall { ], SysCall::ReadyContexts(a1) => [ SysCallNumber::ReadyContexts as usize, - a1 as usize, + *a1 as usize, 0, 0, 0, @@ -401,7 +405,7 @@ impl SysCall { ], SysCall::IncreaseHeap(a1, a2) => [ SysCallNumber::IncreaseHeap as usize, - a1 as usize, + *a1 as usize, a2.bits(), 0, 0, @@ -411,7 +415,7 @@ impl SysCall { ], SysCall::DecreaseHeap(a1) => [ SysCallNumber::DecreaseHeap as usize, - a1 as usize, + *a1 as usize, 0, 0, 0, @@ -421,8 +425,8 @@ impl SysCall { ], SysCall::UpdateMemoryFlags(a1, a2, a3) => [ SysCallNumber::UpdateMemoryFlags as usize, - a1 as usize, - a2 as usize, + *a1 as usize, + *a2 as usize, a3.bits(), 0, 0, @@ -431,17 +435,17 @@ impl SysCall { ], SysCall::SetMemRegion(a1, a2, a3, a4) => [ SysCallNumber::SetMemRegion as usize, - a1 as usize, - a2 as usize, - a3 as usize, - a4, + *a1 as usize, + *a2 as usize, + *a3 as usize, + *a4, 0, 0, 0, ], SysCall::CreateServer(a1) => { - [SysCallNumber::CreateServer as usize, a1, 0, 0, 0, 0, 0, 0] + [SysCallNumber::CreateServer as usize, *a1, 0, 0, 0, 0, 0, 0] } SysCall::Connect(sid) => [ SysCallNumber::Connect as usize, @@ -456,7 +460,7 @@ impl SysCall { SysCall::SendMessage(a1, ref a2) => match a2 { Message::MutableBorrow(mm) => [ SysCallNumber::SendMessage as usize, - a1, + *a1, 1, mm.id as usize, mm.buf.as_ptr() as usize, @@ -466,7 +470,7 @@ impl SysCall { ], Message::ImmutableBorrow(mm) => [ SysCallNumber::SendMessage as usize, - a1, + *a1, 2, mm.id as usize, mm.buf.as_ptr() as usize, @@ -476,7 +480,7 @@ impl SysCall { ], Message::Move(mm) => [ SysCallNumber::SendMessage as usize, - a1, + *a1, 3, mm.id as usize, mm.buf.as_ptr() as usize, @@ -486,7 +490,7 @@ impl SysCall { ], Message::Scalar(sc) => [ SysCallNumber::SendMessage as usize, - a1, + *a1, 4, sc.id as usize, sc.arg1, @@ -495,19 +499,28 @@ impl SysCall { sc.arg4, ], }, + SysCall::ReturnMemory(a1, a2) => [SysCallNumber::ReturnMemory as usize, + *a1, a2.addr.get(), a2.addr.get(), 0, 0, 0, 0], SysCall::SpawnThread(a1, a2, a3) => [ SysCallNumber::SpawnThread as usize, - a1 as usize, - a2 as usize, - a3 as usize, + *a1 as usize, + *a2 as usize, + *a3 as usize, 0, 0, 0, 0, ], - SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7) => { - [SysCallNumber::Invalid as usize, a1, a2, a3, a4, a5, a6, a7] - } + SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7) => [ + SysCallNumber::Invalid as usize, + *a1, + *a2, + *a3, + *a4, + *a5, + *a6, + *a7, + ], } } pub fn from_args( @@ -593,6 +606,7 @@ impl SysCall { ), _ => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7), }, + Some(SysCallNumber::ReturnMemory) => SysCall::ReturnMemory(a1, MemoryRange::new(a2, a3)), Some(SysCallNumber::SpawnThread) => { SysCall::SpawnThread(a1 as *mut usize, a2 as *mut usize, a3 as *mut usize) } @@ -695,6 +709,19 @@ pub fn unmap_memory(virt: MemoryAddress, size: MemorySize) -> core::result::Resu } } +/// Map the given physical address to the given virtual address. +/// The `size` field must be page-aligned. +pub fn return_memory(sender: MessageSender, range: MemoryRange) -> core::result::Result<(), Error> { + let result = rsyscall(SysCall::ReturnMemory(sender, range))?; + if let Result::Ok = result { + Ok(()) + } else if let Result::Error(e) = result { + Err(e) + } else { + Err(Error::InternalError) + } +} + /// Claim a hardware interrupt for this process. pub fn claim_interrupt( irq_no: usize,