mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-20 09:03:28 +00:00
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:
parent
f925011ea2
commit
fbcbc8dfa1
3 changed files with 595 additions and 443 deletions
|
|
@ -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);
|
||||||
|
|
|
||||||
|
|
@ -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");
|
||||||
// }
|
}
|
||||||
|
|
|
||||||
|
|
@ -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];
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue