kernel: rename Connect/SendMessage to TryConnect/TrySendMessage

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-08-30 17:39:29 +08:00
parent 1a0bb99890
commit cd7f8f67fc
3 changed files with 137 additions and 109 deletions

10
kernel/Cargo.lock generated
View file

@ -183,6 +183,15 @@ version = "0.2.74"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2f02823cf78b754822df5f7f268fb59822e7296276d3e069d8e8cb26a14bd10" checksum = "a2f02823cf78b754822df5f7f268fb59822e7296276d3e069d8e8cb26a14bd10"
[[package]]
name = "log"
version = "0.4.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b"
dependencies = [
"cfg-if",
]
[[package]] [[package]]
name = "miniz_oxide" name = "miniz_oxide"
version = "0.4.0" version = "0.4.0"
@ -406,6 +415,7 @@ dependencies = [
"bitflags", "bitflags",
"hex", "hex",
"lazy_static", "lazy_static",
"log",
"xous-macros", "xous-macros",
] ]

View file

@ -517,12 +517,11 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult {
SysCall::CreateServer(name) => { SysCall::CreateServer(name) => {
SystemServices::with_mut(|ss| ss.create_server(pid, name).map(xous_kernel::Result::ServerID)) SystemServices::with_mut(|ss| ss.create_server(pid, name).map(xous_kernel::Result::ServerID))
} }
SysCall::Connect(sid) => { SysCall::TryConnect(sid) => {
// ::debug_here::debug_here!();
SystemServices::with_mut(|ss| ss.connect_to_server(sid).map(xous_kernel::Result::ConnectionID)) 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::ReturnMemory(sender, buf) => return_memory(pid, tid, sender, buf),
SysCall::SendMessage(cid, message) => send_message(pid, tid, cid, message), SysCall::TrySendMessage(cid, message) => send_message(pid, tid, cid, message),
SysCall::TerminateProcess => SystemServices::with_mut(|ss| { SysCall::TerminateProcess => SystemServices::with_mut(|ss| {
ss.switch_from_thread(pid, tid)?; ss.switch_from_thread(pid, tid)?;
let ppid = ss.terminate_process(pid)?; let ppid = ss.terminate_process(pid)?;
@ -534,6 +533,12 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult {
} }
}), }),
SysCall::Shutdown => SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous_kernel::Result::Ok)), SysCall::Shutdown => SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous_kernel::Result::Ok)),
// SysCall::Connect(sid) => {
// 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), _ => Err(xous_kernel::Error::UnhandledSyscall),
} }
} }

View file

@ -79,9 +79,12 @@ fn start_kernel(server_spec: &str) -> JoinHandle<()> {
fn shutdown_kernel() { fn shutdown_kernel() {
// Any process ought to be able to shut down the system currently. // Any process ought to be able to shut down the system currently.
xous_kernel::wait_process_as_thread( xous_kernel::wait_process_as_thread(
xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new("shutdown", || { xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
rsyscall(SysCall::Shutdown).expect("unable to shutdown server"); "shutdown",
})) || {
rsyscall(SysCall::Shutdown).expect("unable to shutdown server");
},
))
.expect("couldn't shut down the kernel"), .expect("couldn't shut down the kernel"),
) )
.expect("couldn't wait for the shutdown process to end"); .expect("couldn't wait for the shutdown process to end");
@ -129,8 +132,8 @@ fn send_scalar_message() {
let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
"send_scalar_message server", "send_scalar_message server",
move || { move || {
let sid = let sid = xous_kernel::create_server(b"send_scalar_mesg")
xous_kernel::create_server(b"send_scalar_mesg").expect("couldn't create test server"); .expect("couldn't create test server");
server_addr_send.send(sid).unwrap(); server_addr_send.send(sid).unwrap();
let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages");
assert_eq!( assert_eq!(
@ -152,8 +155,8 @@ fn send_scalar_message() {
"send_scalar_message client", "send_scalar_message client",
move || { move || {
let sid = server_addr_recv.recv().unwrap(); let sid = server_addr_recv.recv().unwrap();
let conn = xous_kernel::connect(sid).expect("couldn't connect to server"); let conn = xous_kernel::try_connect(sid).expect("couldn't connect to server");
xous_kernel::send_message( xous_kernel::try_send_message(
conn, conn,
xous_kernel::Message::Scalar(xous_kernel::ScalarMessage { xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
id: 1, id: 1,
@ -189,8 +192,8 @@ fn send_move_message() {
"send_move_message server", "send_move_message server",
move || { move || {
// println!("SERVER: Creating server..."); // println!("SERVER: Creating server...");
let sid = let sid = xous_kernel::create_server(b"send_move_messag")
xous_kernel::create_server(b"send_move_messag").expect("couldn't create test server"); .expect("couldn't create test server");
// println!("SERVER: Sending server address of {:?} to client", sid); // println!("SERVER: Sending server address of {:?} to client", sid);
server_addr_send.send(sid).unwrap(); server_addr_send.send(sid).unwrap();
// println!("SERVER: Starting to receive messages..."); // println!("SERVER: Starting to receive messages...");
@ -199,12 +202,10 @@ fn send_move_message() {
let message = envelope.body; let message = envelope.body;
if let xous_kernel::Message::Move(m) = message { if let xous_kernel::Message::Move(m) = message {
let buf = m.buf; let buf = m.buf;
let bt = unsafe { let bt = unsafe { core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len()) };
Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len()))
};
assert_eq!(*test_bytes, *bt); assert_eq!(*test_bytes, *bt);
// let s = String::from_utf8_lossy(&bt); // let s = String::from_utf8_lossy(&bt);
// println!("SERVER: Got message: {:?} -> \"{}\"", bt, s); // println!("SERVER: Got message: {:?} -> \"{}\"", bt, s);
} else { } else {
panic!("unexpected message type"); panic!("unexpected message type");
} }
@ -218,9 +219,9 @@ fn send_move_message() {
// println!("CLIENT: Waiting for server address..."); // println!("CLIENT: Waiting for server address...");
let sid = server_addr_recv.recv().unwrap(); let sid = server_addr_recv.recv().unwrap();
// println!("CLIENT: Connecting to server {:?}", sid); // println!("CLIENT: Connecting to server {:?}", sid);
let conn = xous_kernel::connect(sid).expect("couldn't connect to server"); let conn = xous_kernel::try_connect(sid).expect("couldn't connect to server");
let msg = xous_kernel::carton::Carton::from_bytes(test_bytes); let msg = xous_kernel::carton::Carton::from_bytes(test_bytes);
xous_kernel::send_message(conn, xous_kernel::Message::Move(msg.into_message(0))) xous_kernel::try_send_message(conn, xous_kernel::Message::Move(msg.into_message(0)))
.expect("couldn't send a message"); .expect("couldn't send a message");
// println!("CLIENT: Message sent"); // println!("CLIENT: Message sent");
}, },
@ -247,27 +248,32 @@ fn send_borrow_message() {
let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
"send_borrow_message server", "send_borrow_message server",
move || { move || {
// println!("SERVER: Creating server..."); {
let sid = // println!("SERVER: Creating server...");
xous_kernel::create_server(b"send_borrow_mesg").expect("couldn't create test server"); let sid = xous_kernel::create_server(b"send_borrow_mesg")
server_addr_send.send(sid).unwrap(); .expect("couldn't create test server");
// println!("SERVER: Receiving message..."); server_addr_send.send(sid).unwrap();
let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); // println!("SERVER: Receiving message...");
// println!("SERVER: Received message from {}", envelope.sender); let envelope =
let message = envelope.body; xous_kernel::receive_message(sid).expect("couldn't receive messages");
if let xous_kernel::Message::Borrow(m) = message { // println!("SERVER: Received message from {}", envelope.sender);
let buf = m.buf; let message = envelope.body;
let bt = unsafe { if let xous_kernel::Message::Borrow(m) = message {
Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len())) let buf = m.buf;
}; let bt =
assert_eq!(*test_bytes, *bt); unsafe { core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len()) };
// let s = String::from_utf8_lossy(&bt); assert_eq!(*test_bytes, *bt);
// println!("SERVER: Got message: {:?} -> \"{}\"", bt, s); // let s = String::from_utf8_lossy(&bt);
xous_kernel::return_memory(envelope.sender, m.buf).unwrap(); // println!("SERVER: Got message: {:?} -> \"{}\"", bt, s);
// println!("SERVER: Returned memory"); xous_kernel::return_memory(envelope.sender, m.buf).unwrap();
} else { // println!("SERVER: Returned memory");
panic!("unexpected message type"); // println!("SERVER: Returned memory");
} else {
panic!("unexpected message type");
}
// println!("SERVER: Dropping things");
} }
// println!("SERVER: Exiting");
}, },
)) ))
.expect("couldn't start server"); .expect("couldn't start server");
@ -275,25 +281,28 @@ fn send_borrow_message() {
let xous_client = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( let xous_client = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
"send_borrow_message client", "send_borrow_message client",
move || { move || {
// Get the server address (out of band) so we know what to connect to {
// println!("CLIENT: Waiting for server to start..."); // Get the server address (out of band) so we know what to connect to
let sid = server_addr_recv.recv().unwrap(); // println!("CLIENT: Waiting for server to start...");
let sid = server_addr_recv.recv().unwrap();
// Perform a connection to the server // Perform a connection to the server
// println!("CLIENT: Connecting to server..."); // println!("CLIENT: Connecting to server...");
let conn = xous_kernel::connect(sid).expect("couldn't connect to server"); let conn = xous_kernel::try_connect(sid).expect("couldn't connect to server");
// Convert the message into a "Carton" that can be shipped as a message // Convert the message into a "Carton" that can be shipped as a message
// println!("CLIENT: Creating carton..."); // println!("CLIENT: Creating carton...");
let carton = xous_kernel::carton::Carton::from_bytes(test_bytes); let carton = xous_kernel::carton::Carton::from_bytes(test_bytes);
// Send the message to the server // Send the message to the server
// println!("CLIENT: Lending message..."); // println!("CLIENT: Lending message...");
carton carton
.lend(conn, 0) .lend(conn, 0)
.expect("couldn't lend message to server"); .expect("couldn't lend message to server");
// println!("CLIENT: Done"); // println!("CLIENT: Done, dropping things");
}
// println!("CLIENT: Exit");
}, },
)) ))
.expect("couldn't start client"); .expect("couldn't start client");
@ -318,17 +327,15 @@ fn send_mutableborrow_message() {
let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
"send_mutableborrow_message server", "send_mutableborrow_message server",
move || { move || {
let sid = let sid = xous_kernel::create_server(b"send_mutborrow_m")
xous_kernel::create_server(b"send_mutborrow_m").expect("couldn't create test server"); .expect("couldn't create test server");
server_addr_send.send(sid).unwrap(); server_addr_send.send(sid).unwrap();
let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages");
// println!("Received message from {}", envelope.sender); // println!("Received message from {}", envelope.sender);
let message = envelope.body; let message = envelope.body;
if let xous_kernel::Message::MutableBorrow(m) = message { if let xous_kernel::Message::MutableBorrow(m) = message {
let buf = m.buf; let buf = m.buf;
let mut bt = unsafe { let bt = unsafe { core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len()) };
Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len()))
};
for letter in bt.iter_mut() { for letter in bt.iter_mut() {
*letter += 1; *letter += 1;
} }
@ -347,7 +354,7 @@ fn send_mutableborrow_message() {
let sid = server_addr_recv.recv().unwrap(); let sid = server_addr_recv.recv().unwrap();
// Perform a connection to the server // Perform a connection to the server
let conn = xous_kernel::connect(sid).expect("couldn't connect to server"); let conn = xous_kernel::try_connect(sid).expect("couldn't connect to server");
// Convert the message into a "Carton" that can be shipped as a message // Convert the message into a "Carton" that can be shipped as a message
let mut carton = xous_kernel::carton::Carton::from_bytes(&test_bytes); let mut carton = xous_kernel::carton::Carton::from_bytes(&test_bytes);
@ -389,18 +396,18 @@ fn send_mutableborrow_message_repeat() {
let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
"send_mutableborrow_message_repeat server", "send_mutableborrow_message_repeat server",
move || { move || {
let sid = let sid = xous_kernel::create_server(b"send_mutborrow_r")
xous_kernel::create_server(b"send_mutborrow_r").expect("couldn't create test server"); .expect("couldn't create test server");
server_addr_send.send(sid).unwrap(); server_addr_send.send(sid).unwrap();
for iteration in 0..loops { for iteration in 0..loops {
let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); let envelope =
xous_kernel::receive_message(sid).expect("couldn't receive messages");
let message = envelope.body; let message = envelope.body;
if let xous_kernel::Message::MutableBorrow(m) = message { if let xous_kernel::Message::MutableBorrow(m) = message {
let buf = m.buf; let buf = m.buf;
let mut bt = unsafe { let bt =
Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len())) unsafe { core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len()) };
};
for letter in bt.iter_mut() { for letter in bt.iter_mut() {
*letter = (*letter).wrapping_add((iteration & 0xff) as u8); *letter = (*letter).wrapping_add((iteration & 0xff) as u8);
} }
@ -420,7 +427,7 @@ fn send_mutableborrow_message_repeat() {
let sid = server_addr_recv.recv().unwrap(); let sid = server_addr_recv.recv().unwrap();
// Perform a connection to the server // Perform a connection to the server
let conn = xous_kernel::connect(sid).expect("couldn't connect to server"); let conn = xous_kernel::try_connect(sid).expect("couldn't connect to server");
// Convert the message into a "Carton" that can be shipped as a message // Convert the message into a "Carton" that can be shipped as a message
for iteration in 0..loops { for iteration in 0..loops {
@ -486,11 +493,12 @@ fn server_client_same_process() {
// Start the kernel in its own thread // Start the kernel in its own thread
let main_thread = start_kernel(SERVER_SPEC); let main_thread = start_kernel(SERVER_SPEC);
let internal_server = xous_kernel::create_process_as_thread(xous_kernel::arch::ProcessArgsAsThread::new( let internal_server = xous_kernel::create_process_as_thread(
"server_client_same_process process", xous_kernel::arch::ProcessArgsAsThread::new("server_client_same_process process", || {
|| { let server =
let server = xous_kernel::create_server(b"s_c_same_process").expect("couldn't create server"); xous_kernel::create_server(b"s_c_same_process").expect("couldn't create server");
let connection = xous_kernel::connect(server).expect("couldn't connect to our own server"); let connection =
xous_kernel::try_connect(server).expect("couldn't connect to our own server");
let msg_contents = xous_kernel::ScalarMessage { let msg_contents = xous_kernel::ScalarMessage {
id: 1, id: 1,
arg1: 2, arg1: 2,
@ -499,17 +507,18 @@ fn server_client_same_process() {
arg4: 5, arg4: 5,
}; };
xous_kernel::send_message(connection, xous_kernel::Message::Scalar(msg_contents)) xous_kernel::try_send_message(connection, xous_kernel::Message::Scalar(msg_contents))
.expect("couldn't send message"); .expect("couldn't send message");
let msg = xous_kernel::receive_message(server).expect("couldn't receive message"); let msg = xous_kernel::receive_message(server).expect("couldn't receive message");
assert_eq!(msg.body, xous_kernel::Message::Scalar(msg_contents)); assert_eq!(msg.body, xous_kernel::Message::Scalar(msg_contents));
}, }),
)) )
.expect("couldn't start server"); .expect("couldn't start server");
xous_kernel::wait_process_as_thread(internal_server).expect("couldn't join internal_server process"); xous_kernel::wait_process_as_thread(internal_server)
.expect("couldn't join internal_server process");
// Any process ought to be able to shut down the system currently. // Any process ought to be able to shut down the system currently.
rsyscall(SysCall::Shutdown).expect("unable to shutdown server"); rsyscall(SysCall::Shutdown).expect("unable to shutdown server");
@ -524,11 +533,12 @@ fn multiple_contexts() {
// Start the kernel in its own thread // Start the kernel in its own thread
let main_thread = start_kernel(SERVER_SPEC); let main_thread = start_kernel(SERVER_SPEC);
let internal_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( let internal_server = xous_kernel::create_process_as_thread(
"multiple_contexts process", xous_kernel::ProcessArgsAsThread::new("multiple_contexts process", move || {
move || { let server =
let server = xous_kernel::create_server(b"multiple_context").expect("couldn't create server"); xous_kernel::create_server(b"multiple_context").expect("couldn't create server");
let connection = xous_kernel::connect(server).expect("couldn't connect to our own server"); let connection =
xous_kernel::try_connect(server).expect("couldn't connect to our own server");
let msg_contents = xous_kernel::ScalarMessage { let msg_contents = xous_kernel::ScalarMessage {
id: 1, id: 1,
arg1: 2, arg1: 2,
@ -541,7 +551,8 @@ fn multiple_contexts() {
for _ in 1..crate::arch::process::MAX_THREAD { for _ in 1..crate::arch::process::MAX_THREAD {
server_threads.push( server_threads.push(
xous_kernel::create_thread(move || { xous_kernel::create_thread(move || {
let msg = xous_kernel::receive_message(server).expect("couldn't receive message"); let msg =
xous_kernel::receive_message(server).expect("couldn't receive message");
assert_eq!(msg.body, xous_kernel::Message::Scalar(msg_contents)); assert_eq!(msg.body, xous_kernel::Message::Scalar(msg_contents));
}) })
.expect("couldn't spawn client thread"), .expect("couldn't spawn client thread"),
@ -549,17 +560,21 @@ fn multiple_contexts() {
} }
for _ in &server_threads { for _ in &server_threads {
xous_kernel::send_message(connection, xous_kernel::Message::Scalar(msg_contents)) xous_kernel::try_send_message(
.expect("couldn't send message"); connection,
xous_kernel::Message::Scalar(msg_contents),
)
.expect("couldn't send message");
} }
for server_thread in server_threads.into_iter() { for server_thread in server_threads.into_iter() {
xous_kernel::wait_thread(server_thread).expect("couldn't wait for thread"); xous_kernel::wait_thread(server_thread).expect("couldn't wait for thread");
} }
}, }),
)) )
.expect("couldn't create internal server"); .expect("couldn't create internal server");
xous_kernel::wait_process_as_thread(internal_server).expect("couldn't join internal_server process"); xous_kernel::wait_process_as_thread(internal_server)
.expect("couldn't join internal_server process");
// Any process ought to be able to shut down the system currently. // Any process ought to be able to shut down the system currently.
shutdown_kernel(); shutdown_kernel();
@ -585,24 +600,20 @@ fn process_restart_server() {
fn create_destroy_server(test_bytes: &'static [u8]) { fn create_destroy_server(test_bytes: &'static [u8]) {
let (server_addr_send, server_addr_recv) = channel(); let (server_addr_send, server_addr_recv) = channel();
let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( let xous_server = xous_kernel::create_process_as_thread(
"process_restart_server server", xous_kernel::ProcessArgsAsThread::new("process_restart_server server", move || {
move || { let sid = xous_kernel::create_server(b"test_recreate_se")
let sid = .expect("couldn't create test server");
xous_kernel::create_server(b"test_recreate_se").expect("couldn't create test server");
server_addr_send.send(sid).unwrap(); server_addr_send.send(sid).unwrap();
let thr = xous_kernel::create_thread(move || { let thr = xous_kernel::create_thread(move || {
let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); let envelope =
xous_kernel::receive_message(sid).expect("couldn't receive messages");
// println!("Received message from {}", envelope.sender); // println!("Received message from {}", envelope.sender);
let message = envelope.body; let message = envelope.body;
if let xous_kernel::Message::Move(m) = message { if let xous_kernel::Message::Move(m) = message {
let buf = m.buf; let buf = m.buf;
let bt = unsafe { let bt =
Box::from_raw(core::slice::from_raw_parts_mut( unsafe { core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len()) };
buf.as_mut_ptr(),
buf.len(),
))
};
assert_eq!(*test_bytes, *bt); assert_eq!(*test_bytes, *bt);
// let s = String::from_utf8_lossy(&bt); // let s = String::from_utf8_lossy(&bt);
// println!("Got message: {:?} -> \"{}\"", bt, s); // println!("Got message: {:?} -> \"{}\"", bt, s);
@ -612,21 +623,23 @@ fn process_restart_server() {
}) })
.unwrap(); .unwrap();
xous_kernel::wait_thread(thr).unwrap(); xous_kernel::wait_thread(thr).unwrap();
}, }),
)) )
.expect("couldn't spawn server process"); .expect("couldn't spawn server process");
// Wait for the server to start up // Wait for the server to start up
let xous_client = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( let xous_client = xous_kernel::create_process_as_thread(
"process_restart_server client", xous_kernel::ProcessArgsAsThread::new("process_restart_server client", move || {
move || {
let sid = server_addr_recv.recv().unwrap(); let sid = server_addr_recv.recv().unwrap();
let conn = xous_kernel::connect(sid).expect("couldn't connect to server"); let conn = xous_kernel::try_connect(sid).expect("couldn't connect to server");
let msg = xous_kernel::carton::Carton::from_bytes(test_bytes); let msg = xous_kernel::carton::Carton::from_bytes(test_bytes);
xous_kernel::send_message(conn, xous_kernel::Message::Move(msg.into_message(0))) xous_kernel::try_send_message(
.expect("couldn't send a message"); conn,
}, xous_kernel::Message::Move(msg.into_message(0)),
)) )
.expect("couldn't send a message");
}),
)
.expect("couldn't start client process"); .expect("couldn't start client process");
xous_kernel::wait_process_as_thread(xous_server).expect("couldn't join server process"); xous_kernel::wait_process_as_thread(xous_server).expect("couldn't join server process");