From 7258fc83b75dabbb698fc9545cc42cfd500a8e4b Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Mon, 27 Jul 2020 21:44:50 +0800 Subject: [PATCH] kernel: rework process creation This now uses a system of access keys to associate processes with the kernel. This currently does not pass tests. Signed-off-by: Sean Cross --- kernel/src/arch/hosted.rs | 178 ++++++++++++++++++------------ kernel/src/arch/hosted/process.rs | 67 ++++++++--- kernel/src/services.rs | 89 ++++++++------- kernel/src/syscall.rs | 10 +- kernel/src/test.rs | 4 +- xous-rs/src/arch/hosted.rs | 76 +++++++++---- xous-rs/src/syscall.rs | 19 ++-- 7 files changed, 267 insertions(+), 176 deletions(-) diff --git a/kernel/src/arch/hosted.rs b/kernel/src/arch/hosted.rs index 7206465ac..fa2458323 100644 --- a/kernel/src/arch/hosted.rs +++ b/kernel/src/arch/hosted.rs @@ -16,11 +16,11 @@ use std::time::Duration; use crate::arch::process::Process; use crate::services::SystemServices; -use xous::{MemoryAddress, Result, SysCall, PID, TID}; +use xous::{MemoryAddress, ProcessInit, Result, SysCall, PID, TID}; enum ThreadMessage { SysCall(PID, TID, SysCall), - NewConnection(TcpStream), + NewConnection(TcpStream, [u8; 16] /* access key */), } #[derive(Debug)] @@ -31,6 +31,12 @@ enum BackchannelMessage { thread_local!(static NETWORK_LISTEN_ADDRESS: RefCell = RefCell::new(SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080))); thread_local!(static SEND_ADDR: RefCell>> = RefCell::new(None)); +thread_local!(static PID1_KEY: RefCell<[u8; 16]> = RefCell::new([0u8; 16])); + +#[cfg(test)] +pub fn set_pid1_key(new_key: [u8; 16]) { + PID1_KEY.with(|p1k| *p1k.borrow_mut() = new_key); +} /// Set the network address for this particular thread. #[cfg(test)] @@ -173,7 +179,6 @@ fn listen_thread( let listener = TcpListener::bind(listen_addr).unwrap_or_else(|e| { panic!("Unable to create server: {}", e); }); - let client_addr = listener.local_addr().unwrap(); // Notify the host what our kernel address is, if a listener exists. if let Some(las) = local_addr_sender.take() { las.send(listener.local_addr().unwrap()).unwrap(); @@ -181,29 +186,29 @@ fn listen_thread( let mut clients = vec![]; - let pid1_should_exit = should_exit.clone(); - let pid1_thread = spawn(move || { - let mut client = TcpStream::connect(client_addr).expect("couldn't connect to xous server"); - client.set_read_timeout(Some(Duration::from_millis(100))).expect("couldn't set read timeout duration"); - let mut buffer = [0; size_of::() * 9]; - // println!("KERNEL(1): Started PID1 idle thread"); - loop { - if pid1_should_exit.load(core::sync::atomic::Ordering::Relaxed) { - return; - } - match client.read_exact(&mut buffer) { - Err(e) if e.kind() == std::io::ErrorKind::WouldBlock || e.kind() == std::io::ErrorKind::TimedOut => { - continue; - } - Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => return, - Err(e) => panic!("KERNEL(1): Unable to read buffer: {}", e), - Ok(()) => (), //println!("KERNEL(1): Read {} bytes", x), - } - } - }); + // let pid1_should_exit = should_exit.clone(); + // let pid1_thread = spawn(move || { + // let mut client = TcpStream::connect(client_addr).expect("couldn't connect to xous server"); + // client.set_read_timeout(Some(Duration::from_millis(100))).expect("couldn't set read timeout duration"); + // let mut buffer = [0; size_of::() * 9]; + // // println!("KERNEL(1): Started PID1 idle thread"); + // loop { + // if pid1_should_exit.load(core::sync::atomic::Ordering::Relaxed) { + // return; + // } + // match client.read_exact(&mut buffer) { + // Err(e) if e.kind() == std::io::ErrorKind::WouldBlock || e.kind() == std::io::ErrorKind::TimedOut => { + // continue; + // } + // Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => return, + // Err(e) => panic!("KERNEL(1): Unable to read buffer: {}", e), + // Ok(()) => (), //println!("KERNEL(1): Read {} bytes", x), + // } + // } + // }); fn accept_new_connection( - conn: TcpStream, + mut conn: TcpStream, chn: &Sender, backchannel: &Receiver, clients: &mut Vec<(std::thread::JoinHandle<()>, TcpStream)>, @@ -211,10 +216,15 @@ fn listen_thread( ) -> bool { let thr_chn = chn.clone(); + let mut access_key = [0u8; 16]; + conn.read_exact(&mut access_key).unwrap(); + // Spawn a new process. This process will start out in the "Setup()" state. - chn.send(ThreadMessage::NewConnection(conn.try_clone().expect( - "couldn't make a copy of the network connection for the kernel", - ))) + chn.send(ThreadMessage::NewConnection( + conn.try_clone() + .expect("couldn't make a copy of the network connection for the kernel"), + access_key, + )) .expect("couldn't request a new PID"); let new_pid = match backchannel .recv() @@ -234,7 +244,6 @@ fn listen_thread( fn exit_server( should_exit: std::sync::Arc, clients: Vec<(std::thread::JoinHandle<()>, TcpStream)>, - pid1_thread: std::thread::JoinHandle<()>, ) { should_exit.store(true, core::sync::atomic::Ordering::Relaxed); for (jh, conn) in clients { @@ -243,50 +252,58 @@ fn listen_thread( .expect("couldn't shutdown client"); jh.join().expect("couldn't join client thread"); } - pid1_thread.join().unwrap(); } - let pid1 = listener.accept().unwrap(); - if accept_new_connection(pid1.0, &chn, &backchannel, &mut clients, &should_exit) { - exit_server(should_exit, clients, pid1_thread); - return; - } + // 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 - listener - .set_nonblocking(true) - .expect("couldn't set TcpListener to nonblocking"); - loop { + enum ClientMessage { + NewConnection(TcpStream), + // BackChannel(BackchannelMessage), + }; + let (sender, receiver) = channel(); + let tcp_sender = sender.clone(); + spawn(move || loop { match listener.accept() { Ok((conn, _addr)) => { - if accept_new_connection(conn, &chn, &backchannel, &mut clients, &should_exit) { - exit_server(should_exit, clients, pid1_thread); - return; - } - } - Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => { - match backchannel.recv_timeout(Duration::from_millis(1)) { - Err(std::sync::mpsc::RecvTimeoutError::Timeout) => { - continue; - } - Err(e) => panic!( - "KERNEL: got error when trying to receive quit timeout: {:?} ({})", - e, e - ), - Ok(BackchannelMessage::NewPid(x)) => { - panic!("got unexpected message from main thread: new pid {}", x) - } - Ok(BackchannelMessage::Exit) => { - exit_server(should_exit, clients, pid1_thread); - return; - } - } + tcp_sender.send(ClientMessage::NewConnection(conn)).unwrap(); } Err(e) => { println!("error accepting connections: {}", e); return; } } + }); + // spawn(move || loop { + // match backchannel.recv() { + // Err(e) => panic!( + // "KERNEL: got error when trying to receive quit timeout: {:?} ({})", + // e, e + // ), + // Ok(msg) => sender.send(ClientMessage::BackChannel(msg)).unwrap(), + // } + // }); + + for msg in receiver { + match msg { + ClientMessage::NewConnection(conn) => { + if accept_new_connection(conn, &chn, &backchannel, &mut clients, &should_exit) { + exit_server(should_exit, clients); + return; + } + } + // ClientMessage::BackChannel(BackchannelMessage::NewPid(x)) => { + // panic!("got unexpected message from main thread: new pid {}", x) + // } + // ClientMessage::BackChannel(BackchannelMessage::Exit) => { + // exit_server(should_exit, clients); + // return; + // } + } } } @@ -298,6 +315,12 @@ pub fn idle() -> bool { let (sender, receiver) = channel(); let (backchannel_sender, backchannel_receiver) = channel(); + // Allocate PID1 with the key we were passed. + let pid1_key = PID1_KEY.with(|p1k| p1k.borrow().clone()); + let pid1_init = ProcessInit { key: pid1_key }; + let new_pid = SystemServices::with_mut(|ss| ss.create_process(pid1_init)).unwrap(); + assert_eq!(new_pid.get(), 1); + let listen_addr = env::var("XOUS_LISTEN_ADDR") .map(|s| { s.to_socket_addrs() @@ -314,28 +337,39 @@ pub fn idle() -> bool { while let Ok(msg) = receiver.recv() { match msg { - ThreadMessage::NewConnection(mut conn) => { - // TODO: Figure out how to set the parent PID - crate::arch::process::set_current_pid(PID::new(1).unwrap()); + ThreadMessage::NewConnection(conn, access_key) => { + // The new process should already have a PID registered. Convert its access key + // into a PID, and register the connection with the server. + println!("KERNEL: Attempting to look up access key {:?}", access_key); + let new_pid = + crate::arch::process::register_connection_for_key(conn, access_key).unwrap(); + println!( + "KERNEL: Access key {:?} mapped to PID {}", + access_key, new_pid + ); - // Spawn a new process inside the kernel. This will assign us a PID. - let new_pid = SystemServices::with_mut(|ss| { - ss.create_process(process::ProcessInit::new(conn.try_clone().unwrap()), ()) - }) - .unwrap(); + // // On the initial connection, set the parent PID to 1. In the future + // // there may be some sort of security token check here. + // crate::arch::process::set_current_pid(PID::new(1).unwrap()); + + // // Spawn a new process inside the kernel. This will assign us a PID. + // let new_pid = SystemServices::with_mut(|ss| { + // ss.create_process(process::ProcessInit::new(conn.try_clone().unwrap()), ()) + // }) + // .unwrap(); // Inform the backchannel of the new process ID. backchannel_sender .send(BackchannelMessage::NewPid(new_pid)) .expect("couldn't send new pid to new connection"); - conn.write_all(&new_pid.get().to_le_bytes()).expect("couldn't send pid to new process"); + // conn.write_all(&new_pid.get().to_le_bytes()) + // .expect("couldn't send pid to new process"); // Switch to this process immediately, which moves it from `Setup(_)` to `Running(0)`. // Note that in this system, multiple processes can be active at once. This is - // similar to having one core for each process. However, each process may only have - // one context running at a time. - SystemServices::with_mut(|ss| ss.switch_to_thread(new_pid, Some(1))).unwrap(); + // similar to having one core for each process + // SystemServices::with_mut(|ss| ss.switch_to_thread(new_pid, Some(1))).unwrap(); } ThreadMessage::SysCall(pid, thread_id, call) => { // println!("KERNEL({}): Received syscall {:?}", pid, call); diff --git a/kernel/src/arch/hosted/process.rs b/kernel/src/arch/hosted/process.rs index fab086fd0..ff103cdc3 100644 --- a/kernel/src/arch/hosted/process.rs +++ b/kernel/src/arch/hosted/process.rs @@ -4,7 +4,7 @@ use core::cell::RefCell; use std::io::Write; use std::net::TcpStream; use std::thread_local; -use xous::{ThreadInit, PID, TID}; +use xous::{ProcessInit, ThreadInit, PID, TID}; pub const INITIAL_TID: usize = 1; @@ -16,8 +16,11 @@ struct ProcessImpl { /// Global parameters used by the operating system pub inner: ProcessInner, + /// A 16-byte key used to register a process when it first starts + key: [u8; 16], + /// The network connection to the client process. - conn: TcpStream, + conn: Option, /// Memory that may need to be returned to the caller memory_to_return: Option>, @@ -57,6 +60,21 @@ pub fn set_current_pid(pid: PID) { PROCESS_TABLE.with(|pt| (*pt.borrow_mut()).current = pid); } +pub fn register_connection_for_key(conn: TcpStream, key: [u8; 16]) -> Result { + PROCESS_TABLE.with(|pt| { + let mut process_table = pt.borrow_mut(); + for (pid_minus_1, process) in process_table.table.iter_mut().enumerate() { + if let Some(process) = process.as_mut() { + if process.key == key && process.conn.is_none() { + process.conn = Some(conn); + return Ok(PID::new(pid_minus_1 as u8 + 1).unwrap()); + } + } + } + Err(xous::Error::ProcessNotFound) + }) +} + #[repr(C)] #[derive(Copy, Clone, Debug)] /// Everything required to keep track of a single thread of execution. @@ -71,17 +89,17 @@ impl Default for Thread { } } -/// Everything required to initialize a process on this platform -pub struct ProcessInit { - /// A network connection to the client - conn: TcpStream, -} +// /// Everything required to initialize a process on this platform +// pub struct ProcessInit { +// /// A network connection to the client +// conn: TcpStream, +// } -impl ProcessInit { - pub fn new(conn: TcpStream) -> ProcessInit { - ProcessInit { conn } - } -} +// impl ProcessInit { +// pub fn new(conn: TcpStream) -> ProcessInit { +// ProcessInit { conn } +// } +// } impl Process { pub fn current() -> Process { @@ -171,7 +189,11 @@ impl Process { if !process.threads[thread - 1].allocated { ::debug_here::debug_here!(); } - assert!(process.threads[thread - 1].allocated, "tried to switch to thread {} which wasn't allocated", thread); + assert!( + process.threads[thread - 1].allocated, + "tried to switch to thread {} which wasn't allocated", + thread + ); process.current_thread = thread; }); Ok(()) @@ -214,7 +236,12 @@ impl Process { response.extend_from_slice(&buf); } - process.conn.write_all(&response).expect("Disconnection"); + process + .conn + .as_mut() + .unwrap() + .write_all(&response) + .expect("Disconnection"); }); } @@ -238,7 +265,8 @@ impl Process { let process = ProcessImpl { inner: Default::default(), - conn: init_data.conn, + conn: None, + key: init_data.key, memory_to_return: None, current_thread: INITIAL_TID, threads: [Thread { allocated: false }; MAX_THREAD], @@ -263,7 +291,12 @@ impl Process { panic!("attempted to destroy PID that exceeds table index: {}", pid); } let process = process_table.table[pid_idx].as_mut().unwrap(); - process.conn.shutdown(std::net::Shutdown::Both).unwrap(); + process + .conn + .as_mut() + .unwrap() + .shutdown(std::net::Shutdown::Both) + .unwrap(); process_table.table[pid_idx] = None; Ok(()) }) @@ -274,7 +307,7 @@ impl Process { let mut process_table = pt.borrow_mut(); let current_pid_idx = process_table.current.get() as usize - 1; let process = &mut process_table.table[current_pid_idx].as_mut().unwrap(); - process.conn.write_all(bytes).unwrap(); + process.conn.as_mut().unwrap().write_all(bytes).unwrap(); }); Ok(()) } diff --git a/kernel/src/services.rs b/kernel/src/services.rs index 9b1e3a76b..65e62f671 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -1,7 +1,7 @@ use crate::arch; use crate::arch::mem::MemoryMapping; pub use crate::arch::process::Process as ArchProcess; -pub use crate::arch::process::{Thread, ProcessInit}; +pub use crate::arch::process::Thread; use core::cell::RefCell; use std::thread_local; @@ -10,7 +10,9 @@ use crate::filled_array; // use crate::mem::{MemoryManagerHandle, PAGE_SIZE}; use crate::server::Server; // use core::mem; -use xous::{pid_from_usize, ThreadInit, Error, MemoryAddress, Message, CID, PID, SID, TID}; +use xous::{ + pid_from_usize, Error, MemoryAddress, Message, ProcessInit, ThreadInit, CID, PID, SID, TID, +}; const MAX_PROCESS_COUNT: usize = 32; const MAX_SERVER_COUNT: usize = 32; @@ -41,6 +43,9 @@ pub enum ProcessState { /// This is an unallocated, free process Free, + /// This process has been allocated, but has no threads yet + Allocated, + /// This is a brand-new process that hasn't been run yet, and needs its /// initial context set up. Setup(ThreadInit), @@ -287,11 +292,7 @@ impl SystemServices { /// Add a new entry to the process table. This results in a new address space /// and a new PID, though the process is in the state `Setup()`. - pub fn create_process( - &mut self, - init_process: ProcessInit, - init_context: ThreadInit, - ) -> Result { + pub fn create_process(&mut self, init_process: ProcessInit) -> Result { for (idx, mut entry) in self.processes.iter_mut().enumerate() { if entry.state != ProcessState::Free { continue; @@ -301,7 +302,7 @@ impl SystemServices { // #[allow(clippy::unit_arg)] let ppid = crate::arch::process::current_pid(); // println!("Creating new process for PID {} with PPID {}", new_pid, ppid); - entry.state = ProcessState::Setup(init_context); + entry.state = ProcessState::Allocated; entry.ppid = ppid; entry.pid = new_pid; return Ok(new_pid); @@ -364,11 +365,7 @@ impl SystemServices { /// 2. Save the process state, if it hasn't already been saved /// 3. Run the new process, returning to an illegal instruction #[allow(dead_code)] - pub fn finish_callback_and_resume( - &mut self, - pid: PID, - tid: TID, - ) -> Result<(), xous::Error> { + pub fn finish_callback_and_resume(&mut self, pid: PID, tid: TID) -> Result<(), xous::Error> { // Get the current process (which was the interrupt handler) and mark it // as Ready. Note that the new PID may very well be the same PID. { @@ -521,6 +518,7 @@ impl SystemServices { process.state = match process.state { ProcessState::Free => return Err(xous::Error::ProcessNotFound), ProcessState::Sleeping => return Err(xous::Error::ProcessNotFound), + ProcessState::Allocated => return Err(xous::Error::ProcessNotFound), ProcessState::Setup(setup) => { // Activate the process, which enables its memory mapping process.activate()?; @@ -601,7 +599,9 @@ impl SystemServices { Some(ctx) => { // Ensure the specified context is ready to run, or is // currently running. - if ready_threads & (1 << ctx) == 0 /*&& ctx != current_thread*/ { + if ready_threads & (1 << ctx) == 0 + /*&& ctx != current_thread*/ + { return Err(xous::Error::InvalidContext); } ctx @@ -671,7 +671,7 @@ impl SystemServices { pub fn thread_is_running(&self, pid: PID, tid: TID) -> bool { let process = self.get_process(pid).unwrap(); - if let ProcessState::Running(thread_ids) = process.state { + if let ProcessState::Running(thread_ids) = process.state { if thread_ids & (1 << tid) == 0 { return true; } @@ -735,7 +735,7 @@ impl SystemServices { // Ensure the new process can be run. match new.state { ProcessState::Free => return Err(xous::Error::ProcessNotFound), - ProcessState::Setup(_) => new_tid = INITIAL_TID, + ProcessState::Setup(_) | ProcessState::Allocated => new_tid = INITIAL_TID, ProcessState::Running(x) | ProcessState::Ready(x) => { // If no new context is specified, take the previous // context. If that is not runnable, do a round-robin @@ -750,14 +750,14 @@ impl SystemServices { // "PID {}: Looking for a valid context in the mask {:08b}, curent context {} ({:08b})", // new_pid, x, new.current_context, new.current_context // ); - new_tid = 0;//new.current_thread as usize; + new_tid = 0; //new.current_thread as usize; while x & (1 << new_tid) == 0 { new_tid += 1; if new_tid > arch::process::MAX_THREAD { - // new_tid = 0; - // } - // // If we've looped around, return an error. - // if new_tid == new.current_thread as usize { + // new_tid = 0; + // } + // // If we've looped around, return an error. + // if new_tid == new.current_thread as usize { println!("Looked through all contexts and couldn't find one that was ready"); return Err(xous::Error::ProcessNotFound); } @@ -802,6 +802,7 @@ impl SystemServices { // .expect("couldn't reserve stack"); ProcessState::Running(0) } + ProcessState::Allocated => ProcessState::Running(0), ProcessState::Free => panic!("process was suddenly Free"), ProcessState::Ready(x) | ProcessState::Running(x) => { ProcessState::Running(x & !(1 << new_tid)) @@ -823,7 +824,7 @@ impl SystemServices { // if can_resume { // ProcessState::Ready(1 << previous_tid) // } else { - ProcessState::Sleeping + ProcessState::Sleeping // } } // Otherwise, there are additional threads that can be run. @@ -833,7 +834,7 @@ impl SystemServices { // if can_resume { // ProcessState::Ready(x | (1 << previous_tid)) // } else { - ProcessState::Ready(x) + ProcessState::Ready(x) // } } other => panic!( @@ -858,23 +859,25 @@ impl SystemServices { // } // return Ok(new_tid); // } - let new = self.get_process_mut(new_pid)?;/* - new.state = match new.state { - ProcessState::Running(x) if (x & 1 << new_tid) == 0 => { - return Err(xous::Error::ProcessNotFound) - } - // ProcessState::Running(x) => { - // if can_resume { - // ProcessState::Running((x | (1 << previous_tid)) & !(1 << new_tid)) - // } else { - // ProcessState::Running(x | (1 << previous_tid)) - // } - // } - other => */panic!( - "PID {} invalid process state (not Running): {:?}", - previous_pid, new.state - )/*, - }*/; + let new = self.get_process_mut(new_pid)?; /* + new.state = match new.state { + ProcessState::Running(x) if (x & 1 << new_tid) == 0 => { + return Err(xous::Error::ProcessNotFound) + } + // ProcessState::Running(x) => { + // if can_resume { + // ProcessState::Running((x | (1 << previous_tid)) & !(1 << new_tid)) + // } else { + // ProcessState::Running(x | (1 << previous_tid)) + // } + // } + other => */ + panic!( + "PID {} invalid process state (not Running): {:?}", + previous_pid, new.state + ) /*, + }*/ +; // if advance_thread { // new.current_thread += 1; // if new.current_thread as TID > arch::process::MAX_CONTEXT { @@ -1176,11 +1179,7 @@ impl SystemServices { /// /// * **ContextNotAvailable**: The process has used all of its context /// slots. - pub fn create_thread( - &mut self, - pid: PID, - thread_init: ThreadInit, - ) -> Result { + pub fn create_thread(&mut self, pid: PID, thread_init: ThreadInit) -> Result { let mut process = self .get_process_mut(pid) .expect("couldn't find current process"); diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index dfcbc5f17..d575bb377 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -508,14 +508,8 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { }) }), SysCall::CreateProcess(process_init) => SystemServices::with_mut(|ss| { - #[allow(clippy::unit_arg)] - ss.create_process(process_init).map(|new_tid| { - if !cfg!(baremetal) { - ss.switch_to_thread(pid, Some(new_tid)) - .expect("couldn't activate new thread"); - } - xous::Result::ProcessID(new_tid) - }) + ss.create_process(process_init) + .map(|new_pid| xous::Result::ProcessID(new_pid)) }), SysCall::CreateServer(name) => { SystemServices::with_mut(|ss| ss.create_server(pid, name).map(xous::Result::ServerID)) diff --git a/kernel/src/test.rs b/kernel/src/test.rs index 8ec013bd1..a09e7c8f8 100644 --- a/kernel/src/test.rs +++ b/kernel/src/test.rs @@ -415,7 +415,7 @@ fn server_client_same_process() { // Start the kernel in its own thread let main_thread = start_kernel(SERVER_SPEC); - let internal_server = xous::create_process(xous::arch::ProcessArgs::new(Box::new(|| { + let internal_server = xous::create_process(xous::arch::ProcessArgs::new(|| { 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 msg_contents = xous::ScalarMessage { @@ -432,7 +432,7 @@ fn server_client_same_process() { let msg = xous::receive_message(server).expect("couldn't receive message"); assert_eq!(msg.message, xous::Message::Scalar(msg_contents)); - }))).expect("couldn't start server"); + })).expect("couldn't start server"); xous::wait_process(internal_server) diff --git a/xous-rs/src/arch/hosted.rs b/xous-rs/src/arch/hosted.rs index 1e3211010..04f168edb 100644 --- a/xous-rs/src/arch/hosted.rs +++ b/xous-rs/src/arch/hosted.rs @@ -1,5 +1,6 @@ use std::cell::RefCell; use std::collections::HashMap; +use std::convert::TryInto; use std::io::{Read, Write}; use std::mem::size_of; use std::net::{IpAddr, Ipv4Addr, SocketAddr, TcpStream, ToSocketAddrs}; @@ -9,7 +10,11 @@ use std::thread_local; use crate::{Result, PID, TID}; pub type ThreadInit = (); -pub type ProcessInit = (); + +#[derive(Copy, Clone, Debug, PartialEq)] +pub struct ProcessInit { + pub key: [u8; 16], +} pub struct ProcessArgs { main: Option, @@ -38,8 +43,17 @@ pub fn thread_to_args(call: usize, _init: &ThreadInit) -> [usize; 8] { [call, 0, 0, 0, 0, 0, 0, 0] } -pub fn process_to_args(call: usize, _init: &ProcessInit) -> [usize; 8] { - [call, 0, 0, 0, 0, 0, 0, 0] +pub fn process_to_args(call: usize, init: &ProcessInit) -> [usize; 8] { + [ + call, + u32::from_le_bytes(init.key[0..4].try_into().unwrap()) as _, + u32::from_le_bytes(init.key[4..8].try_into().unwrap()) as _, + u32::from_le_bytes(init.key[8..12].try_into().unwrap()) as _, + u32::from_le_bytes(init.key[12..16].try_into().unwrap()) as _, + 0, + 0, + 0, + ] } pub fn args_to_thread( @@ -55,15 +69,24 @@ pub fn args_to_thread( } pub fn args_to_process( - _a1: usize, - _a2: usize, - _a3: usize, - _a4: usize, + a1: usize, + a2: usize, + a3: usize, + a4: usize, _a5: usize, _a6: usize, _a7: usize, ) -> core::result::Result { - Ok(()) + let mut v = vec![]; + v.extend_from_slice(&(a1 as u32).to_le_bytes()); + v.extend_from_slice(&(a2 as u32).to_le_bytes()); + v.extend_from_slice(&(a3 as u32).to_le_bytes()); + v.extend_from_slice(&(a4 as u32).to_le_bytes()); + let mut key = [0u8; 16]; + key.copy_from_slice(&v); + Ok(ProcessInit { + key + }) } thread_local!(static NETWORK_CONNECT_ADDRESS: RefCell> = RefCell::new(None)); @@ -163,28 +186,34 @@ where F: FnOnce(), { // Ensure there is a connection, because after this function returns - // we'll make a syscall with CreateProcess(). + // we'll make a syscall with CreateProcess(). This should only happen + // for PID1. XOUS_SERVER_CONNECTION.with(|xsc| { let mut xsc = xsc.borrow_mut(); if xsc.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 = Some(a), - Err(_) => { - return Err(crate::Error::InternalError); + let pid1_key = [0u8; 16]; + match xous_connect_impl(addr, &pid1_key) { + Ok(a) => { + *xsc = Some(a); + Ok(()) } + Err(_) => Err(crate::Error::InternalError), } - Ok(()) }) } else { Ok(()) } + })?; + Ok(ProcessInit { + key: [1; 16], }) } pub fn create_process_post( mut args: ProcessArgs, + init: ProcessInit, pid: PID, ) -> core::result::Result where @@ -195,8 +224,8 @@ where Ok(std::thread::Builder::new() .spawn(move || { set_xous_address(server_spec); - xous_connect_impl(server_spec).unwrap(); - PROCESS_ID.with(|p| *p.borrow_mut() = pid.unwrap()); + xous_connect_impl(server_spec, &init.key).unwrap(); + PROCESS_ID.with(|p| *p.borrow_mut() = pid); (args.main.take().unwrap())(); }) .map(ProcessHandle) @@ -211,12 +240,13 @@ pub fn wait_process(joiner: ProcessHandle) -> crate::SysCallResult { .map_err(|_| crate::Error::InternalError) } -fn xous_connect_impl(addr: SocketAddr) -> core::result::Result { +fn xous_connect_impl(addr: SocketAddr, key: &[u8; 16]) -> core::result::Result { // println!("Opening connection to Xous server @ {}...", addr); match TcpStream::connect(addr) { Ok(mut conn) => { - let mut pid = [0u8; 1]; + // let mut pid = [0u8; 1]; // conn.read_exact(&mut pid).unwrap(); + conn.write_all(key).unwrap(); // Send key to authenticate us as PID 1 Ok(ServerConnection { send: Arc::new(Mutex::new(conn.try_clone().unwrap())), recv: Arc::new(Mutex::new(conn)), @@ -250,9 +280,8 @@ pub fn _xous_syscall( THREAD_ID.with(|tid| { let call = crate::SysCall::from_args(nr, a1, a2, a3, a4, a5, a6, a7).unwrap(); - if xsc.borrow().is_none() { - panic!("Not connected to server!"); - } + let mut xsc_borrowed = xsc.borrow_mut(); + let xsc_asmut = xsc_borrowed.as_mut().expect("not connected to server!"); _xous_syscall_to( nr, a1, @@ -263,13 +292,13 @@ pub fn _xous_syscall( a6, a7, &call, - &mut xsc.borrow_mut().as_mut().unwrap().send.lock().unwrap(), + &mut xsc_asmut.send.lock().unwrap(), ); _xous_syscall_result( &call, ret, *tid.borrow(), - xsc.borrow_mut().as_mut().unwrap(), + xsc_asmut, ); }) }); @@ -321,7 +350,6 @@ fn _xous_syscall_result( let mut pkt = [0usize; 8]; let mut raw_bytes = [0u8; size_of::() * 9]; stream.read_exact(&mut raw_bytes).expect("Server shut down"); - use std::convert::TryInto; let mut raw_bytes_chunks = raw_bytes.chunks(size_of::()); diff --git a/xous-rs/src/syscall.rs b/xous-rs/src/syscall.rs index 476038a3d..14f2c9ca3 100644 --- a/xous-rs/src/syscall.rs +++ b/xous-rs/src/syscall.rs @@ -1,7 +1,7 @@ use crate::{ pid_from_usize, CpuID, Error, MemoryAddress, MemoryFlags, MemoryMessage, MemoryRange, - MemorySize, MemoryType, Message, MessageEnvelope, MessageSender, ProcessInit, Result, - ScalarMessage, SysCallResult, ThreadInit, ProcessArgs, CID, PID, SID, + MemorySize, MemoryType, Message, MessageEnvelope, MessageSender, ProcessArgs, ProcessInit, + Result, ScalarMessage, SysCallResult, ThreadInit, CID, PID, SID, }; use num_derive::FromPrimitive; use num_traits::FromPrimitive; @@ -617,7 +617,7 @@ impl SysCall { } Some(SysCallNumber::CreateProcess) => { SysCall::CreateProcess(crate::arch::args_to_process(a1, a2, a3, a4, a5, a6, a7)?) - }, + } Some(SysCallNumber::TerminateProcess) => SysCall::TerminateProcess, Some(SysCallNumber::Shutdown) => SysCall::Shutdown, Some(SysCallNumber::Invalid) => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7), @@ -834,14 +834,17 @@ pub fn wait_thread(joiner: crate::arch::WaitHandle) -> SysCallResult { crate::arch::wait_thread(joiner) } -/// Create a new process by ru -pub fn create_process(args: ProcessArgs) -> core::result::Result -where F: FnOnce() + Send + 'static - { +/// Create a new process by running it in its own thread +pub fn create_process( + args: ProcessArgs, +) -> core::result::Result +where + F: FnOnce() + Send + 'static, +{ let process_init = crate::arch::create_process_pre(&args)?; rsyscall(SysCall::CreateProcess(process_init)).and_then(|result| { if let Result::ProcessID(pid) = result { - crate::arch::create_process_post(args, pid) + crate::arch::create_process_post(args, process_init, pid) } else { Err(Error::InternalError) }