From b93abcc926975b1ad8fbafc2f8ec469665cc221e Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Tue, 14 Jul 2020 15:10:25 +0800 Subject: [PATCH] kernel: test: implement mutable borrow Signed-off-by: Sean Cross --- kernel/src/arch/hosted/process.rs | 34 +++++++++++--- kernel/src/services.rs | 27 ++++++++---- kernel/src/test/mod.rs | 73 ++++++++++++++++++++++++++++--- xous-rs/src/carton.rs | 65 ++++++++++++++++++++------- xous-rs/src/hosted/mod.rs | 20 +++++++++ 5 files changed, 185 insertions(+), 34 deletions(-) diff --git a/kernel/src/arch/hosted/process.rs b/kernel/src/arch/hosted/process.rs index 72c42c919..93f1fb073 100644 --- a/kernel/src/arch/hosted/process.rs +++ b/kernel/src/arch/hosted/process.rs @@ -19,6 +19,9 @@ struct ProcessImpl { /// The network connection to the client process. conn: TcpStream, + + /// Memory that may need to be returned to the caller + memory_to_return: Option>, } impl PartialEq for Process { @@ -68,7 +71,7 @@ impl ProcessInit { impl Process { pub fn current() -> Process { let current_pid = PROCESS_TABLE.with(|pt| pt.borrow().current); - Process{pid: current_pid} + Process { pid: current_pid } } /// Mark this process as running (on the current core?!) @@ -86,7 +89,9 @@ impl Process { { PROCESS_TABLE.with(|pt| { let process_table = pt.borrow(); - let current = &process_table.table[process_table.current.get() as usize - 1].as_ref().unwrap(); + let current = &process_table.table[process_table.current.get() as usize - 1] + .as_ref() + .unwrap(); f(¤t.inner) }) } @@ -132,15 +137,31 @@ impl Process { pub fn set_context_result(&mut self, context: CtxID, result: xous::Result) { assert!(context == INITIAL_CONTEXT); + let mut response = vec![]; + for word in result.to_args().iter_mut() { + response.extend_from_slice(&word.to_le_bytes()); + } + PROCESS_TABLE.with(|pt| { let mut process_table = pt.borrow_mut(); let current_pid_idx = process_table.current.get() as usize - 1; let process = &mut process_table.table[current_pid_idx].as_mut().unwrap(); - for word in result.to_args().iter_mut() { - process.conn - .write_all(&word.to_le_bytes()) - .expect("Disconnection"); + + if let Some(buf) = process.memory_to_return.take() { + response.extend_from_slice(&buf); } + + process.conn.write_all(&response).expect("Disconnection"); + }); + } + + pub fn return_memory(&mut self, buf: &[u8]) { + PROCESS_TABLE.with(|pt| { + let mut process_table = pt.borrow_mut(); + let current_pid_idx = process_table.current.get() as usize - 1; + let process = &mut process_table.table[current_pid_idx].as_mut().unwrap(); + assert!(process.memory_to_return.is_none()); + process.memory_to_return = Some(buf.to_vec()); }); } @@ -154,6 +175,7 @@ impl Process { let process = ProcessImpl { inner: Default::default(), conn: init_data.conn, + memory_to_return: None, }; if pid_idx >= process_table.table.len() { process_table.table.push(Some(process)); diff --git a/kernel/src/services.rs b/kernel/src/services.rs index eb3575922..d8f7d0033 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -7,10 +7,10 @@ use core::cell::RefCell; use std::thread_local; use crate::filled_array; -use crate::mem::{MemoryManagerHandle, PAGE_SIZE}; +// use crate::mem::{MemoryManagerHandle, PAGE_SIZE}; use crate::server::Server; -use core::mem; -use xous::{pid_from_usize, CtxID, Error, MemoryAddress, MemoryType, Message, CID, PID, SID}; +// use core::mem; +use xous::{pid_from_usize, CtxID, Error, MemoryAddress, Message, CID, PID, SID}; const MAX_PROCESS_COUNT: usize = 32; const MAX_SERVER_COUNT: usize = 32; @@ -397,11 +397,11 @@ impl SystemServices { }; process.state = ProcessState::Running(available_contexts); process.current_context = context as u8; - process.mapping.activate(); + process.mapping.activate()?; // Activate the current context let mut arch_process = crate::arch::process::Process::current(); - arch_process.set_context(context); + arch_process.set_context(context)?; } self.pid = pid; Ok(()) @@ -744,7 +744,7 @@ impl SystemServices { // Set up the new process, if necessary. Remove the new context from // the list of ready contexts. new.state = match new.state { - ProcessState::Setup(init_context) => { + ProcessState::Setup(_init_context) => { // entrypoint, stack, stack_size) => { // let mut process = ProcessHandle::get(); // println!( @@ -1109,10 +1109,21 @@ impl SystemServices { pub fn return_memory( &mut self, src_virt: *mut u8, - _dest_pid: PID, + dest_pid: PID, _dest_virt: *mut u8, - _len: usize, + len: usize, ) -> Result<*mut u8, xous::Error> { + let buf = unsafe { core::slice::from_raw_parts(src_virt, len) }; + let current_pid = self.current_pid(); + { + let target_process = self.get_process(dest_pid)?; + target_process.activate()?; + let mut arch_process = crate::arch::process::Process::current(); + arch_process.return_memory(buf); + } + let target_process = self.get_process(current_pid)?; + target_process.activate()?; + Ok(src_virt) } diff --git a/kernel/src/test/mod.rs b/kernel/src/test/mod.rs index be6c0bb5c..d4ea422a3 100644 --- a/kernel/src/test/mod.rs +++ b/kernel/src/test/mod.rs @@ -141,7 +141,7 @@ fn send_move_message() { let bt = unsafe { Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len())) }; - let s = String::from_utf8_lossy(&bt); + // let s = String::from_utf8_lossy(&bt); // println!("Got message: {:?} -> \"{}\"", bt, s); } else { panic!("unexpected message type"); @@ -175,6 +175,8 @@ fn send_borrow_message() { let server_spec = "localhost:0"; let (main_thread, server_spec) = start_kernel(server_spec); let (server_addr_send, server_addr_recv) = channel(); + let test_str = "Hello, world!"; + let test_bytes = test_str.as_bytes(); let xous_server = spawn(move || { xous::hosted::set_xous_address(server_spec); @@ -188,7 +190,8 @@ fn send_borrow_message() { let bt = unsafe { Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len())) }; - let s = String::from_utf8_lossy(&bt); + assert_eq!(*test_bytes, *bt); + // let s = String::from_utf8_lossy(&bt); // println!("Got message: {:?} -> \"{}\"", bt, s); xous::return_memory(envelope.sender, m.buf).unwrap(); } else { @@ -206,11 +209,71 @@ fn send_borrow_message() { let conn = xous::connect(sid).expect("couldn't connect to server"); // Convert the message into a "Carton" that can be shipped as a message - let msg = xous::carton::Carton::from_bytes(format!("Hello, world!").as_bytes()); + let carton = xous::carton::Carton::from_bytes(test_bytes); // Send the message to the server - xous::send_message(conn, xous::Message::Borrow(msg.into_message(0))) - .expect("couldn't send a message"); + carton.lend(conn, 0).expect("couldn't lend message to server"); + }); + + xous_server.join().expect("couldn't join server process"); + xous_client.join().expect("couldn't join client process"); + + // Any process ought to be able to shut down the system currently. + rsyscall(SysCall::Shutdown).expect("unable to shutdown server"); + + main_thread.join().expect("couldn't join kernel process"); +} + +#[test] +fn send_mutableborrow_message() { + let server_spec = "localhost:0"; + let (main_thread, server_spec) = start_kernel(server_spec); + let (server_addr_send, server_addr_recv) = channel(); + let test_str = "Hello, world!"; + let test_bytes = test_str.as_bytes(); + + let xous_server = spawn(move || { + xous::hosted::set_xous_address(server_spec); + let sid = xous::create_server(0x7884_3123).expect("couldn't create test server"); + server_addr_send.send(sid).unwrap(); + let envelope = xous::receive_message(sid).expect("couldn't receive messages"); + // println!("Received message from {}", envelope.sender); + let message = envelope.message; + if let xous::Message::MutableBorrow(m) = message { + let buf = m.buf; + let mut bt = unsafe { + Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len())) + }; + for letter in bt.iter_mut() { + *letter += 1; + } + xous::return_memory(envelope.sender, m.buf).unwrap(); + } else { + panic!("unexpected message type"); + } + }); + + let xous_client = spawn(move || { + xous::hosted::set_xous_address(server_spec); + + // Get the server address (out of band) so we know what to connect to + let sid = server_addr_recv.recv().unwrap(); + + // Perform a connection to the server + let conn = xous::connect(sid).expect("couldn't connect to server"); + + // Convert the message into a "Carton" that can be shipped as a message + let mut carton = xous::carton::Carton::from_bytes(&test_bytes); + let mut check_bytes = test_bytes.to_vec(); + for letter in check_bytes.iter_mut() { + *letter += 1; + } + + // Send the message to the server + carton.lend_mut(conn, 3).expect("couldn't mutably lend data"); + + let modified_bytes: &[u8] = carton.as_ref(); + assert_eq!(&check_bytes, &modified_bytes); }); xous_server.join().expect("couldn't join server process"); diff --git a/xous-rs/src/carton.rs b/xous-rs/src/carton.rs index 5eeaaaa9f..083e4f4ac 100644 --- a/xous-rs/src/carton.rs +++ b/xous-rs/src/carton.rs @@ -1,46 +1,81 @@ //! A Carton is an object that wraps another object for shipping across the kernel //! boundary. Structs that are stored in Cartons can be sent as messages. extern crate alloc; -extern crate core; use alloc::alloc::{alloc, dealloc, Layout}; -use crate::{MemoryMessage, MemoryRange}; +use crate::{MemoryMessage, MemoryRange, CID, Message, Error}; -pub struct Carton { - contents: *mut u8, - size: usize, +#[derive(Debug)] +pub struct Carton<'a> { + range: MemoryRange, + slice: &'a [u8], } -impl Carton { +impl<'a> Carton<'a> { pub fn from_bytes(bytes: &[u8]) -> Self { let src_mem = bytes.as_ptr(); - let len = bytes.len(); - let layout = Layout::from_size_align(len, 4096).unwrap(); + let size = bytes.len(); + let layout = Layout::from_size_align(size, 4096).unwrap(); let new_mem = unsafe { let new_mem = alloc(layout); - core::ptr::copy(src_mem, new_mem, len); + core::ptr::copy(src_mem, new_mem, size); new_mem }; Carton { - contents: new_mem, - size: len, + range: MemoryRange::new(new_mem as usize, size), + slice: unsafe { core::slice::from_raw_parts_mut(new_mem, size) }, } } pub fn into_message(self, id: usize) -> MemoryMessage { MemoryMessage { id, - buf: MemoryRange::new(self.contents as usize, self.size), + buf: self.range, offset: None, valid: None, } } + + /// Perform an immutable lend of this Carton to the specified server. + /// This function will block until the server returns. + pub fn lend(&self, connection: CID, id: usize) -> Result<(), Error> { + let msg = MemoryMessage { + id, + buf: self.range, + offset: None, + valid: None, + }; + crate::send_message(connection, Message::Borrow(msg)) + } + + /// Perform a mutable lend of this Carton to the server. + pub fn lend_mut(&mut self, connection: CID, id: usize) -> Result<(), Error> { + let msg = MemoryMessage { + id, + buf: self.range, + offset: None, + valid: None, + }; + crate::send_message(connection, Message::MutableBorrow(msg)) + } } -impl Drop for Carton { +impl<'a> AsRef for Carton<'a> { + fn as_ref(&self) -> &MemoryRange { + &self.range + } +} + +impl<'a> AsRef<[u8]> for Carton<'a> { + fn as_ref(&self) -> &[u8] { + &self.slice + } +} + +impl<'a> Drop for Carton<'a> { fn drop(&mut self) { - let layout = Layout::from_size_align(self.size, 4096).unwrap(); - let ptr = self.contents; + let layout = Layout::from_size_align(self.range.len(), 4096).unwrap(); + let ptr = self.range.as_mut_ptr(); unsafe { dealloc(ptr, layout) }; } } diff --git a/xous-rs/src/hosted/mod.rs b/xous-rs/src/hosted/mod.rs index 871a9a76c..e104436e6 100644 --- a/xous-rs/src/hosted/mod.rs +++ b/xous-rs/src/hosted/mod.rs @@ -144,6 +144,26 @@ fn _xous_syscall_to( xsc.read_exact(&mut data).expect("Server shut down"); // pkt.extend_from_slice(data); } + + crate::Message::Borrow(crate::MemoryMessage { + id: _id, + buf, + offset: _offset, + valid: _valid, + }) => { + // Read the buffer back from the remote host and ensure it's the same + use core::slice; + let mut check_data = Vec::new(); + check_data.resize(buf.len(), 0); + let data = unsafe { + slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len()) + }; + xsc.read_exact(&mut check_data).expect("Server shut down"); + + assert_eq!(data, check_data.as_slice()); + // pkt.extend_from_slice(data); + } + crate::Message::Move(crate::MemoryMessage { id: _id, buf: _buf,