process: finish implementing ProcessStartup as return

We now us `ProcessStartup` as the return type. This builds in tset
mode, hosted mode, and RISC-V mode.

Process Startup is still not implemented for RISC-V mode.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2022-04-28 22:43:42 -04:00
parent 5c4e76be2d
commit d8eb7be352
10 changed files with 64 additions and 31 deletions

View file

@ -485,9 +485,9 @@ pub fn idle() -> bool {
let pid1_init = ProcessInit { let pid1_init = ProcessInit {
key: ProcessKey::new(pid1_key), key: ProcessKey::new(pid1_key),
}; };
let pid1 = SystemServices::with_mut(|ss| ss.create_process(pid1_init)).unwrap(); let process_1 = SystemServices::with_mut(|ss| ss.create_process(pid1_init)).unwrap();
assert_eq!(pid1.get(), 1); assert_eq!(process_1.pid().get(), 1);
let _tid1 = SystemServices::with_mut(|ss| ss.create_thread(pid1, ThreadInit {})).unwrap(); let _tid1 = SystemServices::with_mut(|ss| ss.create_thread(process_1.pid(), ThreadInit {})).unwrap();
let listen_addr = env::var("XOUS_LISTEN_ADDR") let listen_addr = env::var("XOUS_LISTEN_ADDR")
.map(|s| { .map(|s| {
@ -524,7 +524,7 @@ pub fn idle() -> bool {
// Set the current PID to 1, which was created above. This ensures all init processes // Set the current PID to 1, which was created above. This ensures all init processes
// are owned by PID1. // are owned by PID1.
crate::arch::process::set_current_pid(pid1); crate::arch::process::set_current_pid(process_1.pid());
// Go through each arg and spawn it as a new process. Failures here will // Go through each arg and spawn it as a new process. Failures here will
// halt the entire system. // halt the entire system.
@ -535,10 +535,10 @@ pub fn idle() -> bool {
let init = xous_kernel::ProcessInit { let init = xous_kernel::ProcessInit {
key: ProcessKey::new(process_key), key: ProcessKey::new(process_key),
}; };
let new_pid = SystemServices::with_mut(|ss| ss.create_process(init)).unwrap(); let new_process = SystemServices::with_mut(|ss| ss.create_process(init)).unwrap();
println!(" {:^5} | {}", new_pid, arg); println!(" {:^5} | {}", new_process, arg);
let process_args = xous_kernel::ProcessArgs::new("program", arg); let process_args = xous_kernel::ProcessArgs::new("program", arg);
xous_kernel::arch::create_process_post(process_args, init, new_pid) xous_kernel::arch::create_process_post(process_args, init, new_process)
.expect("couldn't spawn"); .expect("couldn't spawn");
} }
} }

View file

@ -7,7 +7,7 @@ use core::cell::RefCell;
use std::io::Write; use std::io::Write;
use std::net::TcpStream; use std::net::TcpStream;
use std::thread_local; use std::thread_local;
use xous_kernel::{ProcessInit, ProcessKey, ThreadInit, PID, TID}; use xous_kernel::{ProcessInit, ProcessKey, ProcessStartup, ThreadInit, PID, TID};
pub const INITIAL_TID: usize = 2; pub const INITIAL_TID: usize = 2;
pub const EXCEPTION_TID: usize = 1; pub const EXCEPTION_TID: usize = 1;
@ -337,7 +337,7 @@ impl Process {
/// Initialize this process with the given memory space. THIS DOES NOT /// Initialize this process with the given memory space. THIS DOES NOT
/// INITIALIZE A MAIN THREAD. You must call `setup_thread()` in order to /// INITIALIZE A MAIN THREAD. You must call `setup_thread()` in order to
/// select a main thread. /// select a main thread.
pub fn create(pid: PID, init_data: ProcessInit) -> PID { pub fn create(pid: PID, init_data: ProcessInit) -> ProcessStartup {
PROCESS_TABLE.with(|process_table| { PROCESS_TABLE.with(|process_table| {
let mut process_table = process_table.borrow_mut(); let mut process_table = process_table.borrow_mut();
let pid_idx = (pid.get() - 1) as usize; let pid_idx = (pid.get() - 1) as usize;
@ -359,7 +359,7 @@ impl Process {
} else { } else {
panic!("pid already allocated!"); panic!("pid already allocated!");
} }
pid ProcessStartup::new(pid)
}) })
} }
@ -376,7 +376,7 @@ impl Process {
.as_mut() .as_mut()
.unwrap() .unwrap()
.shutdown(std::net::Shutdown::Both) .shutdown(std::net::Shutdown::Both)
.unwrap(); .ok();
process_table.table[pid_idx] = None; process_table.table[pid_idx] = None;
process_table.total -= 1; process_table.total -= 1;
Ok(()) Ok(())

View file

@ -9,7 +9,7 @@ pub const INITIAL_TID: TID = 2;
pub const IRQ_TID: TID = 0; pub const IRQ_TID: TID = 0;
use crate::arch::mem::PAGE_SIZE; use crate::arch::mem::PAGE_SIZE;
use crate::services::ProcessInner; use crate::services::ProcessInner;
use xous_kernel::{ProcessInit, ThreadInit, PID, TID}; use xous_kernel::{ProcessInit, ThreadInit, PID, TID, ProcessStartup};
// use crate::args::KernelArguments; // use crate::args::KernelArguments;
pub const DEFAULT_STACK_SIZE: usize = 131072; pub const DEFAULT_STACK_SIZE: usize = 131072;
@ -497,7 +497,7 @@ impl Process {
); );
} }
pub fn create(_pid: PID, _init_data: ProcessInit) -> PID { pub fn create(_pid: PID, _init_data: ProcessInit) -> ProcessStartup {
todo!(); todo!();
} }

View file

@ -6,6 +6,7 @@ use crate::arch::mem::MemoryMapping;
pub use crate::arch::process::Process as ArchProcess; pub use crate::arch::process::Process as ArchProcess;
pub use crate::arch::process::Thread; pub use crate::arch::process::Thread;
use xous_kernel::MemoryRange; use xous_kernel::MemoryRange;
use xous_kernel::arch::ProcessStartup;
use core::num::NonZeroU8; use core::num::NonZeroU8;
@ -389,19 +390,19 @@ impl SystemServices {
/// Add a new entry to the process table. This results in a new address space /// 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()`. /// and a new PID, though the process is in the state `Setup()`.
pub fn create_process(&mut self, init_process: ProcessInit) -> Result<PID, xous_kernel::Error> { pub fn create_process(&mut self, init_process: ProcessInit) -> Result<ProcessStartup, xous_kernel::Error> {
for (idx, mut entry) in self.processes.iter_mut().enumerate() { for (idx, mut entry) in self.processes.iter_mut().enumerate() {
if entry.state != ProcessState::Free { if entry.state != ProcessState::Free {
continue; continue;
} }
let new_pid = pid_from_usize(idx + 1)?; let new_pid = pid_from_usize(idx + 1)?;
arch::process::Process::create(new_pid, init_process); let startup = arch::process::Process::create(new_pid, init_process);
let ppid = crate::arch::process::current_pid(); let ppid = crate::arch::process::current_pid();
// println!("Creating new process for PID {} with PPID {}", new_pid, ppid); // println!("Creating new process for PID {} with PPID {}", new_pid, ppid);
entry.state = ProcessState::Allocated; entry.state = ProcessState::Allocated;
entry.ppid = ppid; entry.ppid = ppid;
entry.pid = new_pid; entry.pid = new_pid;
return Ok(new_pid); return Ok(startup);
} }
Err(xous_kernel::Error::ProcessNotFound) Err(xous_kernel::Error::ProcessNotFound)
} }

View file

@ -803,7 +803,7 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
}), }),
SysCall::CreateProcess(process_init) => SystemServices::with_mut(|ss| { SysCall::CreateProcess(process_init) => SystemServices::with_mut(|ss| {
ss.create_process(process_init) ss.create_process(process_init)
.map(xous_kernel::Result::ProcessID) .map(xous_kernel::Result::NewProcess)
}), }),
SysCall::CreateServerWithAddress(name) => SystemServices::with_mut(|ss| { SysCall::CreateServerWithAddress(name) => SystemServices::with_mut(|ss| {
ss.create_server_with_address(pid, name) ss.create_server_with_address(pid, name)

View file

@ -1,4 +1,4 @@
use super::{CHILD_PROCESS_ADDRESS}; use super::CHILD_PROCESS_ADDRESS;
pub use crate::PID; pub use crate::PID;
use core::convert::{TryFrom, TryInto}; use core::convert::{TryFrom, TryInto};
@ -69,6 +69,22 @@ pub struct ProcessStartup {
pid: crate::PID, pid: crate::PID,
} }
impl ProcessStartup {
pub fn new(pid: crate::PID) -> Self {
ProcessStartup { pid }
}
pub fn pid(&self) -> crate::PID {
self.pid
}
}
impl core::fmt::Display for ProcessStartup {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{}", self.pid)
}
}
impl From<&[usize; 7]> for ProcessStartup { impl From<&[usize; 7]> for ProcessStartup {
fn from(src: &[usize; 7]) -> ProcessStartup { fn from(src: &[usize; 7]) -> ProcessStartup {
ProcessStartup { ProcessStartup {
@ -103,11 +119,11 @@ pub fn create_process_pre(_args: &ProcessArgs) -> core::result::Result<ProcessIn
pub fn create_process_post( pub fn create_process_post(
args: ProcessArgs, args: ProcessArgs,
init: ProcessInit, init: ProcessInit,
pid: PID, startup: ProcessStartup,
) -> core::result::Result<ProcessHandle, crate::Error> { ) -> core::result::Result<ProcessHandle, crate::Error> {
use std::process::Command; use std::process::Command;
let server_env = format!("{}", CHILD_PROCESS_ADDRESS.lock().unwrap()); let server_env = format!("{}", CHILD_PROCESS_ADDRESS.lock().unwrap());
let pid_env = format!("{}", pid); let pid_env = format!("{}", startup.pid);
let process_name_env = args.name.to_string(); let process_name_env = args.name.to_string();
let process_key_env = hex::encode(&init.key.0); let process_key_env = hex::encode(&init.key.0);
let (shell, args) = if cfg!(windows) { let (shell, args) = if cfg!(windows) {

View file

@ -116,9 +116,9 @@ pub fn create_process_pre(_args: &ProcessArgs) -> core::result::Result<ProcessIn
pub fn create_process_post( pub fn create_process_post(
_args: ProcessArgs, _args: ProcessArgs,
_init: ProcessInit, _init: ProcessInit,
pid: crate::PID, startup: ProcessStartup,
) -> core::result::Result<ProcessHandle, crate::Error> { ) -> core::result::Result<ProcessHandle, crate::Error> {
Ok(ProcessHandle(pid)) Ok(ProcessHandle(startup.pid))
} }
/// Wait for a process to terminate. /// Wait for a process to terminate.

View file

@ -69,12 +69,13 @@ where
pub fn create_process_post_as_thread<F>( pub fn create_process_post_as_thread<F>(
args: ProcessArgsAsThread<F>, args: ProcessArgsAsThread<F>,
init: ProcessInit, init: ProcessInit,
pid: PID, startup: ProcessStartup,
) -> core::result::Result<ProcessHandleAsThread, crate::Error> ) -> core::result::Result<ProcessHandleAsThread, crate::Error>
where where
F: FnOnce() + Send + 'static, F: FnOnce() + Send + 'static,
{ {
let server_address = xous_address(); let server_address = xous_address();
let pid = startup.pid;
let f = args.main; let f = args.main;
let thread_main = std::thread::Builder::new() let thread_main = std::thread::Builder::new()
@ -132,6 +133,22 @@ pub struct ProcessStartup {
pid: crate::PID, pid: crate::PID,
} }
impl ProcessStartup {
pub fn new(pid: crate::PID) -> Self {
ProcessStartup { pid }
}
pub fn pid(&self) -> crate::PID {
self.pid
}
}
impl core::fmt::Display for ProcessStartup {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{}", self.pid)
}
}
impl From<&[usize; 7]> for ProcessStartup { impl From<&[usize; 7]> for ProcessStartup {
fn from(src: &[usize; 7]) -> ProcessStartup { fn from(src: &[usize; 7]) -> ProcessStartup {
ProcessStartup { ProcessStartup {
@ -153,7 +170,6 @@ impl Into<[usize; 7]> for &ProcessStartup {
} }
} }
impl Into<[usize; 7]> for &ProcessInit { impl Into<[usize; 7]> for &ProcessInit {
fn into(self) -> [usize; 7] { fn into(self) -> [usize; 7] {
[ [
@ -204,11 +220,11 @@ pub fn create_process_pre(_args: &ProcessArgs) -> core::result::Result<ProcessIn
pub fn create_process_post( pub fn create_process_post(
args: ProcessArgs, args: ProcessArgs,
init: ProcessInit, init: ProcessInit,
pid: PID, startup: ProcessStartup,
) -> core::result::Result<ProcessHandle, crate::Error> { ) -> core::result::Result<ProcessHandle, crate::Error> {
use std::process::Command; use std::process::Command;
let server_env = format!("{}", xous_address()); let server_env = format!("{}", xous_address());
let pid_env = format!("{}", pid); let pid_env = format!("{}", startup.pid);
let process_name_env = args.name.to_string(); let process_name_env = args.name.to_string();
let process_key_env = hex::encode(&init.key.0); let process_key_env = hex::encode(&init.key.0);
let (shell, args) = if cfg!(windows) { let (shell, args) = if cfg!(windows) {

View file

@ -19,7 +19,7 @@ pub mod string;
pub mod stringbuffer; pub mod stringbuffer;
pub mod syscall; pub mod syscall;
pub use arch::{ProcessArgs, ProcessInit, ProcessKey, ThreadInit}; pub use arch::{ProcessArgs, ProcessInit, ProcessKey, ProcessStartup, ThreadInit};
pub use definitions::*; pub use definitions::*;
pub use string::*; pub use string::*;
pub use stringbuffer::*; pub use stringbuffer::*;

View file

@ -1659,8 +1659,8 @@ where
{ {
let process_init = crate::arch::create_process_pre_as_thread(&args)?; let process_init = crate::arch::create_process_pre_as_thread(&args)?;
rsyscall(SysCall::CreateProcess(process_init)).and_then(|result| { rsyscall(SysCall::CreateProcess(process_init)).and_then(|result| {
if let Result::ProcessID(pid) = result { if let Result::NewProcess(startup) = result {
crate::arch::create_process_post_as_thread(args, process_init, pid) crate::arch::create_process_post_as_thread(args, process_init, startup)
} else { } else {
Err(Error::InternalError) Err(Error::InternalError)
} }
@ -1678,8 +1678,8 @@ pub fn create_process(
) -> core::result::Result<crate::arch::ProcessHandle, Error> { ) -> core::result::Result<crate::arch::ProcessHandle, Error> {
let process_init = crate::arch::create_process_pre(&args)?; let process_init = crate::arch::create_process_pre(&args)?;
rsyscall(SysCall::CreateProcess(process_init)).and_then(|result| { rsyscall(SysCall::CreateProcess(process_init)).and_then(|result| {
if let Result::ProcessID(pid) = result { if let Result::NewProcess(startup) = result {
crate::arch::create_process_post(args, process_init, pid) crate::arch::create_process_post(args, process_init, startup)
} else { } else {
Err(Error::InternalError) Err(Error::InternalError)
} }