mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-15 08:30:02 +00:00
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 <sean@xobs.io>
This commit is contained in:
parent
ab7a56937c
commit
7258fc83b7
7 changed files with 267 additions and 176 deletions
|
|
@ -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<SocketAddr> = RefCell::new(SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080)));
|
||||
thread_local!(static SEND_ADDR: RefCell<Option<Sender<SocketAddr>>> = 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::<usize>() * 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::<usize>() * 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<ThreadMessage>,
|
||||
backchannel: &Receiver<BackchannelMessage>,
|
||||
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<core::sync::atomic::AtomicBool>,
|
||||
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);
|
||||
|
|
|
|||
|
|
@ -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<TcpStream>,
|
||||
|
||||
/// Memory that may need to be returned to the caller
|
||||
memory_to_return: Option<Vec<u8>>,
|
||||
|
|
@ -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<PID, xous::Error> {
|
||||
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(())
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<PID, xous::Error> {
|
||||
pub fn create_process(&mut self, init_process: ProcessInit) -> Result<PID, xous::Error> {
|
||||
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<TID, xous::Error> {
|
||||
pub fn create_thread(&mut self, pid: PID, thread_init: ThreadInit) -> Result<TID, xous::Error> {
|
||||
let mut process = self
|
||||
.get_process_mut(pid)
|
||||
.expect("couldn't find current process");
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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<F: FnOnce()> {
|
||||
main: Option<F>,
|
||||
|
|
@ -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<ProcessInit, crate::Error> {
|
||||
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<Option<SocketAddr>> = 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<F>(
|
||||
mut args: ProcessArgs<F>,
|
||||
init: ProcessInit,
|
||||
pid: PID,
|
||||
) -> core::result::Result<ProcessHandle, crate::Error>
|
||||
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<ServerConnection, ()> {
|
||||
fn xous_connect_impl(addr: SocketAddr, key: &[u8; 16]) -> core::result::Result<ServerConnection, ()> {
|
||||
// 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::<usize>() * 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::<usize>());
|
||||
|
||||
|
|
|
|||
|
|
@ -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<T>(joiner: crate::arch::WaitHandle<T>) -> SysCallResult {
|
|||
crate::arch::wait_thread(joiner)
|
||||
}
|
||||
|
||||
/// Create a new process by ru
|
||||
pub fn create_process<F>(args: ProcessArgs<F>) -> core::result::Result<crate::arch::ProcessHandle, Error>
|
||||
where F: FnOnce() + Send + 'static
|
||||
{
|
||||
/// Create a new process by running it in its own thread
|
||||
pub fn create_process<F>(
|
||||
args: ProcessArgs<F>,
|
||||
) -> core::result::Result<crate::arch::ProcessHandle, Error>
|
||||
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)
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue