mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
kernel: test: implement mutable borrow
Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
parent
d7006e675e
commit
b93abcc926
5 changed files with 185 additions and 34 deletions
|
|
@ -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<Vec<u8>>,
|
||||
}
|
||||
|
||||
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));
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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");
|
||||
|
|
|
|||
|
|
@ -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<MemoryRange> 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) };
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
Loading…
Reference in a new issue