kernel: fix deadlock in threaded messages

Due to an ordering issue, it was possible for thread message responses
to become deadlocked, wherein a message would get stored in the shared
table in between checking the table value and locking the network
connection.

This change makes a second check of the table after the network
connection is locked, in order to prevent this condition.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-07-28 18:12:52 +08:00
parent f925011ea2
commit fbcbc8dfa1
3 changed files with 595 additions and 443 deletions

View file

@ -4,14 +4,12 @@ pub mod process;
pub mod syscall; pub mod syscall;
use std::cell::RefCell; use std::cell::RefCell;
use std::convert::TryInto;
use std::env; use std::env;
use std::io::Read; use std::io::Read;
use std::mem::size_of;
use std::net::{IpAddr, Ipv4Addr, SocketAddr, TcpListener, TcpStream, ToSocketAddrs}; use std::net::{IpAddr, Ipv4Addr, SocketAddr, TcpListener, TcpStream, ToSocketAddrs};
use std::sync::mpsc::{channel, Receiver, Sender}; use std::sync::mpsc::{channel, Receiver, Sender};
use std::thread::spawn;
use std::thread_local; use std::thread_local;
use std::time::Duration;
use crate::arch::process::Process; use crate::arch::process::Process;
use crate::services::SystemServices; use crate::services::SystemServices;
@ -61,77 +59,121 @@ pub fn set_send_addr(send_addr: Sender<SocketAddr>) {
/// Each client gets its own connection and its own thread, which is handled here. /// Each client gets its own connection and its own thread, which is handled here.
fn handle_connection( fn handle_connection(
mut conn: TcpStream, conn: TcpStream,
pid: PID, pid: PID,
chn: Sender<ThreadMessage>, chn: Sender<ThreadMessage>,
should_exit: std::sync::Arc<core::sync::atomic::AtomicBool>, should_exit: std::sync::Arc<core::sync::atomic::AtomicBool>,
) { ) {
loop { enum ServerMessage {
let mut pkt = [0usize; 9]; Exit,
let mut incoming_word = [0u8; size_of::<usize>()]; ServerPacket([usize; 9]),
conn.set_read_timeout(Some(Duration::from_millis(1000))) ServerPacketWithData([usize; 9], Vec<u8>),
.unwrap();
for word in pkt.iter_mut() {
loop {
if should_exit.load(core::sync::atomic::Ordering::Relaxed) {
chn.send(ThreadMessage::SysCall(
pid,
1,
xous::SysCall::TerminateProcess,
))
.unwrap();
}
if let Err(e) = conn.read_exact(&mut incoming_word) {
// If the connection has gone away, send a `TerminateProcess` message to the main
// and then exit this thread.
if e.kind() == std::io::ErrorKind::WouldBlock
|| e.kind() == std::io::ErrorKind::TimedOut
{
continue;
} else {
// println!(
// "KERNEL({}): Client disconnected: {} ({:?}). Shutting down virtual process.",
// pid, e, e
// );
chn.send(ThreadMessage::SysCall(
pid,
1,
xous::SysCall::TerminateProcess,
))
.unwrap();
return;
}
}
break;
}
*word = usize::from_le_bytes(incoming_word);
} }
fn conn_thread(mut conn: TcpStream, sender: Sender<ServerMessage>) {
loop {
let mut raw_data = [0u8; 9 * std::mem::size_of::<usize>()];
if let Err(_e) = conn.read_exact(&mut raw_data) {
// println!(
// "KERNEL(?): Client disconnected: {} ({:?}). Shutting down virtual process.",
// _e, _e
// );
sender.send(ServerMessage::Exit).ok();
return;
}
let mut packet_data = [0usize; 9];
for (bytes, word) in raw_data
.chunks_exact(std::mem::size_of::<usize>())
.zip(packet_data.iter_mut())
{
*word = usize::from_le_bytes(bytes.try_into().unwrap());
}
if packet_data[1] == 16
&& (packet_data[3] == 1 || packet_data[3] == 2 || packet_data[3] == 3)
{
let mut v = vec![0; packet_data[6]];
if conn.read_exact(&mut v).is_err() {
sender.send(ServerMessage::Exit).ok();
return;
}
sender
.send(ServerMessage::ServerPacketWithData(packet_data, v))
.unwrap();
} else {
sender
.send(ServerMessage::ServerPacket(packet_data))
.unwrap();
}
}
}
let (sender, receiver) = channel();
let conn_sender = sender.clone();
std::thread::Builder::new()
.name(format!("PID {}: client connection thread", pid))
.spawn(move || {
conn_thread(conn, conn_sender);
})
.unwrap();
std::thread::Builder::new()
.name(format!("PID {}: client should_exit thread", pid))
.spawn(move || loop {
if should_exit.load(core::sync::atomic::Ordering::Relaxed) {
// eprintln!("KERNEL: should_exit == 1");
sender.send(ServerMessage::Exit).ok();
return;
}
std::thread::park_timeout(std::time::Duration::from_secs(1));
})
.unwrap();
for msg in receiver {
match msg {
ServerMessage::Exit => break,
ServerMessage::ServerPacket(pkt) => {
let thread_id = pkt[0]; let thread_id = pkt[0];
let call = xous::SysCall::from_args( let call = xous::SysCall::from_args(
pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8],
); );
match call { match call {
Err(e) => eprintln!("KERNEL({}): Received invalid syscall: {:?}", pid, e), Err(e) => {
eprintln!("KERNEL({}): Received invalid syscall: {:?}", pid, e);
eprintln!(
"Raw packet: {:08x} {} {} {} {} {} {} {}",
pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7]
);
}
Ok(call) => chn
.send(ThreadMessage::SysCall(pid, thread_id, call))
.expect("couldn't make syscall"),
}
}
ServerMessage::ServerPacketWithData(pkt, data) => {
let thread_id = pkt[0];
let call = xous::SysCall::from_args(
pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8],
);
match call {
Err(e) => {
eprintln!("KERNEL({}): Received invalid syscall: {:?}", pid, e);
eprintln!(
"Raw packet: {:08x} {} {} {} {} {} {} {}",
pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7]
);
}
Ok(mut call) => { Ok(mut call) => {
// eprintln!(
// "Received packet: {:08x} {} {} {} {} {} {} {}: {:?}",
// pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], call
// );
if let SysCall::SendMessage(ref _cid, ref mut envelope) = call { if let SysCall::SendMessage(ref _cid, ref mut envelope) = call {
match envelope { match envelope {
xous::Message::MutableBorrow(msg) xous::Message::MutableBorrow(msg)
| xous::Message::Borrow(msg) | xous::Message::Borrow(msg)
| xous::Message::Move(msg) => { | xous::Message::Move(msg) => {
let mut tmp_data = vec![0; msg.buf.len()];
conn.read_exact(&mut tmp_data)
.map_err(|_e| {
// println!("KERNEL({}): Read Error {}", pid, _e);
chn.send(ThreadMessage::SysCall(
pid,
thread_id,
xous::SysCall::TerminateProcess,
))
.unwrap();
})
.unwrap();
// Update the address pointer. This will get turned back into a // Update the address pointer. This will get turned back into a
// usable pointer by casting it back into a &[T] on the other // usable pointer by casting it back into a &[T] on the other
// side. This is just a pointer to the start of data // side. This is just a pointer to the start of data
@ -139,7 +181,7 @@ fn handle_connection(
// should still be equal once we reconstitute the data in the // should still be equal once we reconstitute the data in the
// other process. // other process.
// ::debug_here::debug_here!(); // ::debug_here::debug_here!();
let sliced_data = tmp_data.into_boxed_slice(); let sliced_data = data.into_boxed_slice();
assert_eq!( assert_eq!(
sliced_data.len(), sliced_data.len(),
msg.buf.len(), msg.buf.len(),
@ -147,7 +189,8 @@ fn handle_connection(
sliced_data.len(), sliced_data.len(),
msg.buf.len() msg.buf.len()
); );
msg.buf.addr = match MemoryAddress::new(Box::into_raw(sliced_data) msg.buf.addr =
match MemoryAddress::new(Box::into_raw(sliced_data)
as *mut usize as *mut usize
as usize) as usize)
{ {
@ -157,17 +200,24 @@ fn handle_connection(
} }
xous::Message::Scalar(_) => (), xous::Message::Scalar(_) => (),
} }
} else {
panic!("unsupported message type");
} }
// println!(
// "Received packet: {:08x} {} {} {} {} {} {} {}: {:?}",
// pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], call
// );
chn.send(ThreadMessage::SysCall(pid, thread_id, call)) chn.send(ThreadMessage::SysCall(pid, thread_id, call))
.expect("couldn't make syscall"); .expect("couldn't make syscall");
} }
} }
} }
} }
}
// eprintln!("KERNEL({}): Finished the thread so sending TerminateProcess", pid);
chn.send(ThreadMessage::SysCall(
pid,
1,
xous::SysCall::TerminateProcess,
))
.unwrap();
}
fn listen_thread( fn listen_thread(
listen_addr: SocketAddr, listen_addr: SocketAddr,
@ -215,7 +265,10 @@ fn listen_thread(
// println!("KERNEL({}): New client connected from {}", new_pid, _addr); // println!("KERNEL({}): New client connected from {}", new_pid, _addr);
let conn_copy = conn.try_clone().expect("couldn't duplicate connection"); let conn_copy = conn.try_clone().expect("couldn't duplicate connection");
let should_exit = should_exit.clone(); let should_exit = should_exit.clone();
let jh = spawn(move || handle_connection(conn, new_pid, thr_chn, should_exit)); let jh = std::thread::Builder::new()
.name(format!("kernel PID {} listener", new_pid))
.spawn(move || handle_connection(conn, new_pid, thr_chn, should_exit))
.expect("couldn't spawn listen thread");
clients.push((jh, conn_copy)); clients.push((jh, conn_copy));
false false
} }
@ -233,12 +286,6 @@ fn listen_thread(
} }
} }
// let pid1 = listener.accept().unwrap();
// if accept_new_connection(pid1.0, &chn, &backchannel, &mut clients, &should_exit) {
// exit_server(should_exit, clients);
// return;
// }
// Use `listener` in a nonblocking setup so that we can exit when doing tests // Use `listener` in a nonblocking setup so that we can exit when doing tests
enum ClientMessage { enum ClientMessage {
NewConnection(TcpStream), NewConnection(TcpStream),
@ -247,44 +294,72 @@ fn listen_thread(
let (sender, receiver) = channel(); let (sender, receiver) = channel();
let tcp_sender = sender.clone(); let tcp_sender = sender.clone();
let exit_sender = sender; let exit_sender = sender;
spawn(move || loop {
let (shutdown_listener, shutdown_listener_receiver) = channel();
// `listener.accept()` has no way to break, so we must put it in nonblocking mode
listener.set_nonblocking(true).unwrap();
std::thread::Builder::new()
.name("kernel accept thread".to_owned())
.spawn(move || loop {
match listener.accept() { match listener.accept() {
Ok((conn, _addr)) => { Ok((conn, _addr)) => {
conn.set_nonblocking(false).unwrap();
tcp_sender.send(ClientMessage::NewConnection(conn)).unwrap(); tcp_sender.send(ClientMessage::NewConnection(conn)).unwrap();
} }
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
match shutdown_listener_receiver.recv_timeout(std::time::Duration::from_millis(500)) {
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => continue,
Ok(()) | Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => {
return;
},
}
}
Err(e) => { Err(e) => {
eprintln!("error accepting connections: {} ({:?})", e, e); // Windows generates this error -- WSACancelBlockingCall -- when a
// connection is shut down while `accept()` is running. This should
// only happen when the system is shutting down, so ignore it.
if cfg!(windows) {
if let Some(10004) = e.raw_os_error() {
return; return;
} }
} }
}); eprintln!(
"error accepting connections: {} ({:?}) ({:?})",
e,
e,
e.kind()
);
return;
}
}
})
.unwrap();
// Spawn a thread to listen for the `exit` command, and relay that // Spawn a thread to listen for the `exit` command, and relay that
// to the main thread. This prevents us from needing to poll, since // to the main thread. This prevents us from needing to poll, since
// all messages are coalesced into a single channel. // all messages are coalesced into a single channel.
spawn(move || match exit_channel.recv() { std::thread::Builder::new()
Ok(ExitMessage::Exit) => { .name("kernel exit listener".to_owned())
exit_sender.send(ClientMessage::Exit).unwrap() .spawn(move || match exit_channel.recv() {
} Ok(ExitMessage::Exit) => exit_sender.send(ClientMessage::Exit).unwrap(),
Err(std::sync::mpsc::RecvError) => { Err(std::sync::mpsc::RecvError) => eprintln!("error receiving exit command"),
eprintln!("error receiving exit command") })
} .unwrap();
});
for msg in receiver { for msg in receiver {
match msg { match msg {
ClientMessage::NewConnection(conn) => { ClientMessage::NewConnection(conn) => {
if accept_new_connection(conn, &chn, &new_pid_channel, &mut clients, &should_exit) { if accept_new_connection(conn, &chn, &new_pid_channel, &mut clients, &should_exit) {
break;
}
}
ClientMessage::Exit => break,
}
}
shutdown_listener.send(()).unwrap();
exit_server(should_exit, clients); exit_server(should_exit, clients);
return;
}
}
ClientMessage::Exit => {
exit_server(should_exit, clients);
return;
}
}
}
} }
/// The idle function is run when there are no directly-runnable processes /// The idle function is run when there are no directly-runnable processes
@ -313,7 +388,10 @@ pub fn idle() -> bool {
let listen_thread_handle = SEND_ADDR.with(|sa| { let listen_thread_handle = SEND_ADDR.with(|sa| {
let sa = sa.borrow_mut().take(); let sa = sa.borrow_mut().take();
spawn(move || listen_thread(listen_addr, sender, sa, new_pid_receiver, exit_receiver)) std::thread::Builder::new()
.name("kernel network listener".to_owned())
.spawn(move || listen_thread(listen_addr, sender, sa, new_pid_receiver, exit_receiver))
.expect("couldn't spawn listen thread")
}); });
while let Ok(msg) = receiver.recv() { while let Ok(msg) = receiver.recv() {
@ -396,10 +474,10 @@ pub fn idle() -> bool {
} }
process.send(&response_vec).unwrap_or_else(|_e| { process.send(&response_vec).unwrap_or_else(|_e| {
// If we're unable to send data to the process, assume it's dead and terminate it. // If we're unable to send data to the process, assume it's dead and terminate it.
// println!( eprintln!(
// "KERNEL({}): Unable to send response to process: {:?} -- terminating", "KERNEL({}): Unable to send response to process: {:?} -- terminating",
// pid, _e pid, _e
// ); );
crate::syscall::handle(pid, thread_id, SysCall::TerminateProcess).ok(); crate::syscall::handle(pid, thread_id, SysCall::TerminateProcess).ok();
}); });
crate::arch::process::set_current_pid(existing_pid); crate::arch::process::set_current_pid(existing_pid);

View file

@ -47,15 +47,17 @@ fn start_kernel(server_spec: &str) -> JoinHandle<()> {
// Launch the main thread. We pass a `send_addr` channel so that the // Launch the main thread. We pass a `send_addr` channel so that the
// server can notify us when it's ready to listen. // server can notify us when it's ready to listen.
let main_thread = std::thread::spawn(move || { let main_thread = std::thread::Builder::new()
.name("kernel main".to_owned())
.spawn(move || {
let server_spec_server = server_addr; let server_spec_server = server_addr;
crate::arch::set_pid1_key(pid1_key); crate::arch::set_pid1_key(pid1_key);
crate::arch::set_send_addr(send_addr); crate::arch::set_send_addr(send_addr);
crate::arch::set_listen_address(&server_spec_server); crate::arch::set_listen_address(&server_spec_server);
kmain() kmain()
}); })
.expect("couldn't start kernel thread");
let server_addr = recv_addr.recv().unwrap(); let server_addr = recv_addr.recv().unwrap();
println!("Got server address: {:?}", server_addr);
xous::arch::set_xous_address(server_addr); xous::arch::set_xous_address(server_addr);
// Connect to server. This first instance needs to make sure the kernel is listening. // Connect to server. This first instance needs to make sure the kernel is listening.
@ -77,7 +79,7 @@ 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::wait_process( xous::wait_process(
xous::create_process(xous::ProcessArgs::new(|| { xous::create_process(xous::ProcessArgs::new("shutdown", || {
rsyscall(SysCall::Shutdown).expect("unable to shutdown server"); rsyscall(SysCall::Shutdown).expect("unable to shutdown server");
})) }))
.expect("couldn't shut down the kernel"), .expect("couldn't shut down the kernel"),
@ -124,8 +126,11 @@ fn send_scalar_message() {
// and receive the message. Note that we need to communicate to the // and receive the message. Note that we need to communicate to the
// "Client" what our server ID is. Normally this would be done via // "Client" what our server ID is. Normally this would be done via
// an external nameserver. // an external nameserver.
let xous_server = xous::create_process(xous::ProcessArgs::new(move || { let xous_server = xous::create_process(xous::ProcessArgs::new(
let sid = xous::create_server(b"send_scalar_mesg").expect("couldn't create test server"); "send_scalar_message server",
move || {
let sid =
xous::create_server(b"send_scalar_mesg").expect("couldn't create test server");
server_addr_send.send(sid).unwrap(); server_addr_send.send(sid).unwrap();
let envelope = xous::receive_message(sid).expect("couldn't receive messages"); let envelope = xous::receive_message(sid).expect("couldn't receive messages");
assert_eq!( assert_eq!(
@ -138,11 +143,14 @@ fn send_scalar_message() {
arg4: 5 arg4: 5
}) })
); );
})) },
))
.expect("couldn't spawn server process"); .expect("couldn't spawn server process");
// Spawn the client "process" and wait for the server address. // Spawn the client "process" and wait for the server address.
let xous_client = xous::create_process(xous::ProcessArgs::new(move || { let xous_client = xous::create_process(xous::ProcessArgs::new(
"send_scalar_message client",
move || {
let sid = server_addr_recv.recv().unwrap(); let sid = server_addr_recv.recv().unwrap();
let conn = xous::connect(sid).expect("couldn't connect to server"); let conn = xous::connect(sid).expect("couldn't connect to server");
xous::send_message( xous::send_message(
@ -156,7 +164,8 @@ fn send_scalar_message() {
}), }),
) )
.expect("couldn't send message"); .expect("couldn't send message");
})) },
))
.expect("couldn't spawn client process"); .expect("couldn't spawn client process");
// Wait for both processes to finish // Wait for both processes to finish
@ -176,11 +185,17 @@ fn send_move_message() {
let (server_addr_send, server_addr_recv) = channel(); let (server_addr_send, server_addr_recv) = channel();
let xous_server = xous::create_process(xous::ProcessArgs::new(move || { let xous_server = xous::create_process(xous::ProcessArgs::new(
let sid = xous::create_server(b"send_move_messag").expect("couldn't create test server"); "send_move_message server",
move || {
// println!("SERVER: Creating server...");
let sid =
xous::create_server(b"send_move_messag").expect("couldn't create test server");
// 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...");
let envelope = xous::receive_message(sid).expect("couldn't receive messages"); let envelope = xous::receive_message(sid).expect("couldn't receive messages");
// println!("Received message from {}", envelope.sender); // println!("SERVER: Received message from {}", envelope.sender);
let message = envelope.message; let message = envelope.message;
if let xous::Message::Move(m) = message { if let xous::Message::Move(m) = message {
let buf = m.buf; let buf = m.buf;
@ -189,15 +204,17 @@ fn send_move_message() {
}; };
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!("SERVER: Got message: {:?} -> \"{}\"", bt, s);
} else { } else {
panic!("unexpected message type"); panic!("unexpected message type");
} }
},
))
.expect("couldn't start server");
// println!("SERVER: Received message: {:?}", msg); let xous_client = xous::create_process(xous::ProcessArgs::new(
})).expect("couldn't start server"); "send_move_message client",
move || {
let xous_client = xous::create_process(xous::ProcessArgs::new(move || {
// 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);
@ -205,7 +222,10 @@ fn send_move_message() {
let msg = xous::carton::Carton::from_bytes(test_bytes); let msg = xous::carton::Carton::from_bytes(test_bytes);
xous::send_message(conn, xous::Message::Move(msg.into_message(0))) xous::send_message(conn, xous::Message::Move(msg.into_message(0)))
.expect("couldn't send a message"); .expect("couldn't send a message");
})).expect("couldn't start client"); // println!("CLIENT: Message sent");
},
))
.expect("couldn't start client");
// Wait for both processes to finish // Wait for both processes to finish
crate::wait_process(xous_server).expect("couldn't join server process"); crate::wait_process(xous_server).expect("couldn't join server process");
@ -224,9 +244,12 @@ fn send_borrow_message() {
let test_str = "Hello, world!"; let test_str = "Hello, world!";
let test_bytes = test_str.as_bytes(); let test_bytes = test_str.as_bytes();
let xous_server = xous::create_process(xous::ProcessArgs::new(move || { let xous_server = xous::create_process(xous::ProcessArgs::new(
"send_borrow_message server",
move || {
// println!("SERVER: Creating server..."); // println!("SERVER: Creating server...");
let sid = xous::create_server(b"send_borrow_mesg").expect("couldn't create test server"); let sid =
xous::create_server(b"send_borrow_mesg").expect("couldn't create test server");
server_addr_send.send(sid).unwrap(); server_addr_send.send(sid).unwrap();
// println!("SERVER: Receiving message..."); // println!("SERVER: Receiving message...");
let envelope = xous::receive_message(sid).expect("couldn't receive messages"); let envelope = xous::receive_message(sid).expect("couldn't receive messages");
@ -245,9 +268,13 @@ fn send_borrow_message() {
} else { } else {
panic!("unexpected message type"); panic!("unexpected message type");
} }
})).expect("couldn't start server"); },
))
.expect("couldn't start server");
let xous_client = xous::create_process(xous::ProcessArgs::new(move || { let xous_client = xous::create_process(xous::ProcessArgs::new(
"send_borrow_message client",
move || {
// Get the server address (out of band) so we know what to connect to // Get the server address (out of band) so we know what to connect to
// println!("CLIENT: Waiting for server to start..."); // println!("CLIENT: Waiting for server to start...");
let sid = server_addr_recv.recv().unwrap(); let sid = server_addr_recv.recv().unwrap();
@ -267,7 +294,9 @@ fn send_borrow_message() {
.expect("couldn't lend message to server"); .expect("couldn't lend message to server");
// println!("CLIENT: Done"); // println!("CLIENT: Done");
})).expect("couldn't start client"); },
))
.expect("couldn't start client");
// Wait for both processes to finish // Wait for both processes to finish
crate::wait_process(xous_server).expect("couldn't join server process"); crate::wait_process(xous_server).expect("couldn't join server process");
@ -286,8 +315,11 @@ fn send_mutableborrow_message() {
let test_str = "Hello, world!"; let test_str = "Hello, world!";
let test_bytes = test_str.as_bytes(); let test_bytes = test_str.as_bytes();
let xous_server = xous::create_process(xous::ProcessArgs::new(move || { let xous_server = xous::create_process(xous::ProcessArgs::new(
let sid = xous::create_server(b"send_mutborrow_m").expect("couldn't create test server"); "send_mutableborrow_message server",
move || {
let sid =
xous::create_server(b"send_mutborrow_m").expect("couldn't create test server");
server_addr_send.send(sid).unwrap(); server_addr_send.send(sid).unwrap();
let envelope = xous::receive_message(sid).expect("couldn't receive messages"); let envelope = xous::receive_message(sid).expect("couldn't receive messages");
// println!("Received message from {}", envelope.sender); // println!("Received message from {}", envelope.sender);
@ -304,9 +336,13 @@ fn send_mutableborrow_message() {
} else { } else {
panic!("unexpected message type"); panic!("unexpected message type");
} }
})).expect("couldn't start server"); },
))
.expect("couldn't start server");
let xous_client = xous::create_process(xous::ProcessArgs::new(move || { let xous_client = xous::create_process(xous::ProcessArgs::new(
"send_mutableborrow_message client",
move || {
// Get the server address (out of band) so we know what to connect to // Get the server address (out of band) so we know what to connect to
let sid = server_addr_recv.recv().unwrap(); let sid = server_addr_recv.recv().unwrap();
@ -327,7 +363,9 @@ fn send_mutableborrow_message() {
let modified_bytes: &[u8] = carton.as_ref(); let modified_bytes: &[u8] = carton.as_ref();
assert_eq!(&check_bytes, &modified_bytes); assert_eq!(&check_bytes, &modified_bytes);
})).expect("couldn't start client"); },
))
.expect("couldn't start client");
// Wait for both processes to finish // Wait for both processes to finish
crate::wait_process(xous_server).expect("couldn't join server process"); crate::wait_process(xous_server).expect("couldn't join server process");
@ -348,8 +386,11 @@ fn send_mutableborrow_message_repeat() {
let loops = 50; let loops = 50;
let xous_server = xous::create_process(xous::ProcessArgs::new(move || { let xous_server = xous::create_process(xous::ProcessArgs::new(
let sid = xous::create_server(b"send_mutborrow_r").expect("couldn't create test server"); "send_mutableborrow_message_repeat server",
move || {
let sid =
xous::create_server(b"send_mutborrow_r").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 {
@ -368,9 +409,13 @@ fn send_mutableborrow_message_repeat() {
panic!("unexpected message type"); panic!("unexpected message type");
} }
} }
})).expect("couldn't start server"); },
))
.expect("couldn't start server");
let xous_client = xous::create_process(xous::ProcessArgs::new(move || { let xous_client = xous::create_process(xous::ProcessArgs::new(
"send_mutableborrow_message_repeat client",
move || {
// Get the server address (out of band) so we know what to connect to // Get the server address (out of band) so we know what to connect to
let sid = server_addr_recv.recv().unwrap(); let sid = server_addr_recv.recv().unwrap();
@ -393,7 +438,9 @@ fn send_mutableborrow_message_repeat() {
let modified_bytes: &[u8] = carton.as_ref(); let modified_bytes: &[u8] = carton.as_ref();
assert_eq!(&check_bytes, &modified_bytes); assert_eq!(&check_bytes, &modified_bytes);
} }
})).expect("couldn't start client"); },
))
.expect("couldn't start client");
// Wait for both processes to finish // Wait for both processes to finish
crate::wait_process(xous_server).expect("couldn't join server process"); crate::wait_process(xous_server).expect("couldn't join server process");
@ -439,7 +486,9 @@ 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::create_process(xous::arch::ProcessArgs::new(|| { let internal_server = xous::create_process(xous::arch::ProcessArgs::new(
"server_client_same_process process",
|| {
let server = xous::create_server(b"s_c_same_process").expect("couldn't create server"); let server = xous::create_server(b"s_c_same_process").expect("couldn't create server");
let connection = xous::connect(server).expect("couldn't connect to our own server"); let connection = xous::connect(server).expect("couldn't connect to our own server");
let msg_contents = xous::ScalarMessage { let msg_contents = xous::ScalarMessage {
@ -456,7 +505,8 @@ fn server_client_same_process() {
let msg = xous::receive_message(server).expect("couldn't receive message"); let msg = xous::receive_message(server).expect("couldn't receive message");
assert_eq!(msg.message, xous::Message::Scalar(msg_contents)); assert_eq!(msg.message, xous::Message::Scalar(msg_contents));
})) },
))
.expect("couldn't start server"); .expect("couldn't start server");
xous::wait_process(internal_server).expect("couldn't join internal_server process"); xous::wait_process(internal_server).expect("couldn't join internal_server process");
@ -474,7 +524,9 @@ 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::create_process(xous::ProcessArgs::new(move || { let internal_server = xous::create_process(xous::ProcessArgs::new(
"multiple_contexts process",
move || {
let server = xous::create_server(b"multiple_context").expect("couldn't create server"); let server = xous::create_server(b"multiple_context").expect("couldn't create server");
let connection = xous::connect(server).expect("couldn't connect to our own server"); let connection = xous::connect(server).expect("couldn't connect to our own server");
let msg_contents = xous::ScalarMessage { let msg_contents = xous::ScalarMessage {
@ -503,10 +555,11 @@ fn multiple_contexts() {
for server_thread in server_threads.into_iter() { for server_thread in server_threads.into_iter() {
xous::wait_thread(server_thread).expect("couldn't wait for thread"); xous::wait_thread(server_thread).expect("couldn't wait for thread");
} }
})).expect("couldn't create internal server"); },
))
.expect("couldn't create internal server");
xous::wait_process(internal_server) xous::wait_process(internal_server).expect("couldn't join internal_server process");
.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();
@ -514,63 +567,77 @@ fn multiple_contexts() {
main_thread.join().expect("couldn't join kernel process"); main_thread.join().expect("couldn't join kernel process");
} }
// #[test] #[test]
// fn multiple_multiple_contexts() { fn multiple_multiple_contexts() {
// for _ in 0..5 { for _ in 0..5 {
// multiple_contexts(); multiple_contexts();
// } }
// } }
// /// Test that a server can be restarted and the kernel doesn't crash /// Test that a server can be restarted and the kernel doesn't crash
// #[test] #[test]
// fn process_restart_server() { fn process_restart_server() {
// let test_str = "Hello, world!"; let test_str = "Hello, world!";
// let test_bytes = test_str.as_bytes(); let test_bytes = test_str.as_bytes();
// let main_thread = start_kernel(SERVER_SPEC); let main_thread = start_kernel(SERVER_SPEC);
// 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 = as_process(move || { let xous_server = xous::create_process(xous::ProcessArgs::new(
// let sid = "process_restart_server server",
// xous::create_server(b"test_recreate_se").expect("couldn't create test server"); move || {
// server_addr_send.send(sid).unwrap(); let sid =
// let thr = xous::create_thread(move || { xous::create_server(b"test_recreate_se").expect("couldn't create test server");
// let envelope = xous::receive_message(sid).expect("couldn't receive messages"); server_addr_send.send(sid).unwrap();
// // println!("Received message from {}", envelope.sender); let thr = xous::create_thread(move || {
// let message = envelope.message; let envelope = xous::receive_message(sid).expect("couldn't receive messages");
// if let xous::Message::Move(m) = message { // println!("Received message from {}", envelope.sender);
// let buf = m.buf; let message = envelope.message;
// let bt = unsafe { if let xous::Message::Move(m) = message {
// Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len())) let buf = m.buf;
// }; let bt = unsafe {
// assert_eq!(*test_bytes, *bt); Box::from_raw(core::slice::from_raw_parts_mut(
// // let s = String::from_utf8_lossy(&bt); buf.as_mut_ptr(),
// // println!("Got message: {:?} -> \"{}\"", bt, s); buf.len(),
// } else { ))
// panic!("unexpected message type"); };
// } assert_eq!(*test_bytes, *bt);
// }) // let s = String::from_utf8_lossy(&bt);
// .unwrap(); // println!("Got message: {:?} -> \"{}\"", bt, s);
// xous::wait_thread(thr).unwrap(); } else {
// }); panic!("unexpected message type");
}
})
.unwrap();
xous::wait_thread(thr).unwrap();
},
))
.expect("couldn't spawn server process");
// // Wait for the server to start up // Wait for the server to start up
// let sid = server_addr_recv.recv().unwrap(); let xous_client = xous::create_process(xous::ProcessArgs::new(
"process_restart_server client",
move || {
let sid = server_addr_recv.recv().unwrap();
let conn = xous::connect(sid).expect("couldn't connect to server");
let msg = xous::carton::Carton::from_bytes(test_bytes);
xous::send_message(conn, xous::Message::Move(msg.into_message(0)))
.expect("couldn't send a message");
},
))
.expect("couldn't start client process");
// let conn = xous::connect(sid).expect("couldn't connect to server"); xous::wait_process(xous_server).expect("couldn't join server process");
// let msg = xous::carton::Carton::from_bytes(test_bytes); xous::wait_process(xous_client).expect("couldn't join client process");
// xous::send_message(conn, xous::Message::Move(msg.into_message(0))) }
// .expect("couldn't send a message");
// xous_server.join().expect("couldn't join server process");
// }
// // create_destroy_server(test_bytes);
// create_destroy_server(test_bytes); // create_destroy_server(test_bytes);
create_destroy_server(test_bytes);
// // 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"); shutdown_kernel();
// main_thread.join().expect("couldn't join kernel process"); main_thread.join().expect("couldn't join kernel process");
// } }

View file

@ -19,14 +19,18 @@ pub struct ProcessInit {
pub struct ProcessArgs<F: FnOnce()> { pub struct ProcessArgs<F: FnOnce()> {
main: Option<F>, main: Option<F>,
name: String,
} }
impl<F> ProcessArgs<F> impl<F> ProcessArgs<F>
where where
F: FnOnce(), F: FnOnce(),
{ {
pub fn new(main: F) -> ProcessArgs<F> { pub fn new(name: &str, main: F) -> ProcessArgs<F> {
ProcessArgs { main: Some(main) } ProcessArgs {
main: Some(main),
name: name.to_owned(),
}
} }
} }
@ -125,20 +129,6 @@ fn xous_address() -> SocketAddr {
.unwrap_or_else(default_xous_address) .unwrap_or_else(default_xous_address)
} }
// pub fn xous_connect() {
// XOUS_SERVER_CONNECTION.with(|xsc| {
// if xsc.borrow().is_none() {
// NETWORK_CONNECT_ADDRESS.with(|nca| {
// let addr = nca.borrow().unwrap_or_else(default_xous_address);
// match xous_connect_impl(addr) {
// Ok(a) => *xsc.borrow_mut() = Some(a),
// Err(_) => panic!("couldn't connect to server"),
// }
// });
// }
// })
// }
pub fn create_thread_pre<F, T>(_f: &F) -> core::result::Result<ThreadInit, crate::Error> pub fn create_thread_pre<F, T>(_f: &F) -> core::result::Result<ThreadInit, crate::Error>
where where
F: FnOnce() -> T, F: FnOnce() -> T,
@ -210,7 +200,9 @@ where
Ok(()) Ok(())
} }
})?; })?;
Ok(ProcessInit { key: PROCESS_KEY.with(|pk| *pk.borrow()) }) Ok(ProcessInit {
key: PROCESS_KEY.with(|pk| *pk.borrow()),
})
} }
pub fn create_process_post<F>( pub fn create_process_post<F>(
@ -223,7 +215,9 @@ where
{ {
let server_address = xous_address(); let server_address = xous_address();
let f = args.main.take().unwrap();
let thread_main = std::thread::Builder::new() let thread_main = std::thread::Builder::new()
.name(args.name)
.spawn(move || { .spawn(move || {
set_xous_address(server_address); set_xous_address(server_address);
THREAD_ID.with(|tid| *tid.borrow_mut() = 1); THREAD_ID.with(|tid| *tid.borrow_mut() = 1);
@ -239,19 +233,21 @@ where
} }
})?; })?;
crate::create_thread(args.main.take().unwrap()) crate::create_thread(f)
}) })
.map_err(|_| crate::Error::InternalError)?.join().unwrap().unwrap(); .map_err(|_| crate::Error::InternalError)?
.join()
.unwrap()
.unwrap();
Ok(ProcessHandle(thread_main.0)) Ok(ProcessHandle(thread_main.0))
} }
pub fn wait_process(joiner: ProcessHandle) -> crate::SysCallResult { pub fn wait_process(joiner: ProcessHandle) -> crate::SysCallResult {
joiner joiner.0.join().map(|_| Result::Ok).map_err(|_x| {
.0 // panic!("wait error: {:?}", x);
.join() crate::Error::InternalError
.map(|_| Result::Ok) })
.map_err(|_| crate::Error::InternalError)
} }
fn xous_connect_impl( fn xous_connect_impl(
@ -351,12 +347,23 @@ fn _xous_syscall_result(
let mut stream = match server_connection.recv.try_lock() { let mut stream = match server_connection.recv.try_lock() {
Ok(lk) => lk, Ok(lk) => lk,
Err(std::sync::TryLockError::WouldBlock) => { Err(std::sync::TryLockError::WouldBlock) => {
std::thread::sleep(std::time::Duration::from_millis(1)); std::thread::sleep(std::time::Duration::from_millis(10));
continue; continue;
} }
Err(e) => panic!("Receive error: {}", e), Err(e) => panic!("Receive error: {}", e),
}; };
// One more check, in case something came in while we waited for the receiver above.
{
let mut mailbox = server_connection.mailbox.lock().unwrap();
if let Some(entry) = mailbox.remove(&thread_id) {
if Result::BlockedProcess != entry {
*ret = entry;
return;
}
}
}
// This thread_id doesn't exist in the mailbox, so read additional data. // This thread_id doesn't exist in the mailbox, so read additional data.
let mut pkt = [0usize; 8]; let mut pkt = [0usize; 8];
let mut raw_bytes = [0u8; size_of::<usize>() * 9]; let mut raw_bytes = [0u8; size_of::<usize>() * 9];