Merge branch 'master' of github.com:betrusted-io/xous-core

This commit is contained in:
bunnie 2021-03-25 14:23:11 +08:00
commit f61d8d3a8f
14 changed files with 1702 additions and 185 deletions

View file

@ -522,12 +522,14 @@ pub fn idle() -> bool {
// Switch to this process immediately, which moves it from `Setup(_)` to `Running(0)`. // 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 // Note that in this system, multiple processes can be active at once. This is
// similar to having one core for each process // similar to having one core for each process
if new_pid != PID::new(1).unwrap() {
SystemServices::with_mut(|ss| { SystemServices::with_mut(|ss| {
ss.create_thread(new_pid, ThreadInit {})?; ss.create_thread(new_pid, ThreadInit {})?;
ss.switch_to_thread(new_pid, None) ss.switch_to_thread(new_pid, None)
}) })
.unwrap(); .unwrap();
} }
}
ThreadMessage::SysCall(pid, thread_id, call) => { ThreadMessage::SysCall(pid, thread_id, call) => {
// println!("KERNEL({}): Received syscall {:?}", pid, call); // println!("KERNEL({}): Received syscall {:?}", pid, call);
crate::arch::process::set_current_pid(pid); crate::arch::process::set_current_pid(pid);

View file

@ -125,9 +125,7 @@ impl Process {
let pid = unsafe { PROCESS_TABLE.current }; let pid = unsafe { PROCESS_TABLE.current };
let hardware_pid = (riscv::register::satp::read().bits() >> 22) & ((1 << 9) - 1); let hardware_pid = (riscv::register::satp::read().bits() >> 22) & ((1 << 9) - 1);
assert!((pid.get() as usize) == hardware_pid); assert!((pid.get() as usize) == hardware_pid);
Process { Process { pid }
pid,
}
} }
/// Mark this process as running on the current core /// Mark this process as running on the current core
@ -299,7 +297,10 @@ impl Process {
thread.sepc = unsafe { core::mem::transmute::<_, usize>(thread_init.call) }; thread.sepc = unsafe { core::mem::transmute::<_, usize>(thread_init.call) };
thread.registers[1] = thread_init.stack.as_ptr() as usize + thread_init.stack.len(); thread.registers[1] = thread_init.stack.as_ptr() as usize + thread_init.stack.len();
thread.registers[9] = thread_init.arg.map(|x| x.get()).unwrap_or_default(); thread.registers[9] = thread_init.arg1;
thread.registers[10] = thread_init.arg2;
thread.registers[11] = thread_init.arg3;
thread.registers[12] = thread_init.arg4;
#[cfg(any(feature = "debug-print", feature = "print-panics"))] #[cfg(any(feature = "debug-print", feature = "print-panics"))]
{ {
@ -331,7 +332,11 @@ impl Process {
Ok(()) Ok(())
} }
pub fn setup_thread(&mut self, new_tid: TID, setup: ThreadInit) -> Result<(), xous_kernel::Error> { pub fn setup_thread(
&mut self,
new_tid: TID,
setup: ThreadInit,
) -> Result<(), xous_kernel::Error> {
let entrypoint = unsafe { core::mem::transmute::<_, usize>(setup.call) }; let entrypoint = unsafe { core::mem::transmute::<_, usize>(setup.call) };
// Create the new context and set it to run in the new address space. // Create the new context and set it to run in the new address space.
let pid = self.pid.get(); let pid = self.pid.get();
@ -343,7 +348,7 @@ impl Process {
entrypoint, entrypoint,
setup.stack.as_ptr() as usize + setup.stack.len(), setup.stack.as_ptr() as usize + setup.stack.len(),
EXIT_THREAD, EXIT_THREAD,
&[setup.arg.map(|x| x.get() as usize).unwrap_or_default()], &[setup.arg1, setup.arg2, setup.arg3, setup.arg4],
); );
Ok(()) Ok(())
} }
@ -364,27 +369,45 @@ impl Process {
); );
println!( println!(
"T3:{:08x} T4:{:08x} T5:{:08x} T6:{:08x}", "T3:{:08x} T4:{:08x} T5:{:08x} T6:{:08x}",
_thread.registers[27], _thread.registers[28], _thread.registers[29], _thread.registers[30] _thread.registers[27],
_thread.registers[28],
_thread.registers[29],
_thread.registers[30]
); );
println!( println!(
"S0:{:08x} S1:{:08x} S2:{:08x} S3:{:08x}", "S0:{:08x} S1:{:08x} S2:{:08x} S3:{:08x}",
_thread.registers[7], _thread.registers[8], _thread.registers[17], _thread.registers[18] _thread.registers[7],
_thread.registers[8],
_thread.registers[17],
_thread.registers[18]
); );
println!( println!(
"S4:{:08x} S5:{:08x} S6:{:08x} S7:{:08x}", "S4:{:08x} S5:{:08x} S6:{:08x} S7:{:08x}",
_thread.registers[19], _thread.registers[20], _thread.registers[21], _thread.registers[22] _thread.registers[19],
_thread.registers[20],
_thread.registers[21],
_thread.registers[22]
); );
println!( println!(
"S8:{:08x} S9:{:08x} S10:{:08x} S11:{:08x}", "S8:{:08x} S9:{:08x} S10:{:08x} S11:{:08x}",
_thread.registers[23], _thread.registers[24], _thread.registers[25], _thread.registers[26] _thread.registers[23],
_thread.registers[24],
_thread.registers[25],
_thread.registers[26]
); );
println!( println!(
"A0:{:08x} A1:{:08x} A2:{:08x} A3:{:08x}", "A0:{:08x} A1:{:08x} A2:{:08x} A3:{:08x}",
_thread.registers[9], _thread.registers[10], _thread.registers[11], _thread.registers[12] _thread.registers[9],
_thread.registers[10],
_thread.registers[11],
_thread.registers[12]
); );
println!( println!(
"A4:{:08x} A5:{:08x} A6:{:08x} A7:{:08x}", "A4:{:08x} A5:{:08x} A6:{:08x} A7:{:08x}",
_thread.registers[13], _thread.registers[14], _thread.registers[15], _thread.registers[16] _thread.registers[13],
_thread.registers[14],
_thread.registers[15],
_thread.registers[16]
); );
} }

File diff suppressed because it is too large Load diff

View file

@ -321,8 +321,10 @@ impl SystemServices {
process.state = ProcessState::Setup(ThreadInit::new( process.state = ProcessState::Setup(ThreadInit::new(
unsafe { core::mem::transmute::<usize, _>(init.entrypoint) }, unsafe { core::mem::transmute::<usize, _>(init.entrypoint) },
MemoryRange::new(init.sp, crate::arch::process::DEFAULT_STACK_SIZE).unwrap(), MemoryRange::new(init.sp, crate::arch::process::DEFAULT_STACK_SIZE).unwrap(),
MemoryAddress::new(pid), pid,
[0u8; 12], 0,
0,
0,
)); ));
} }
} }

View file

@ -185,7 +185,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
if blocking && cfg!(baremetal) { if blocking && cfg!(baremetal) {
klog!("Activating Server context and switching away from Client"); klog!("Activating Server context and switching away from Client");
ss.activate_process_thread(thread, server_pid, server_tid, !blocking) ss.activate_process_thread(thread, server_pid, server_tid, false)
.map(|_| Ok(xous_kernel::Result::Message(envelope))) .map(|_| Ok(xous_kernel::Result::Message(envelope)))
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound)) .unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
} else if blocking && !cfg!(baremetal) { } else if blocking && !cfg!(baremetal) {
@ -239,7 +239,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
let process = ss.get_process(pid).expect("Can't get current process"); let process = ss.get_process(pid).expect("Can't get current process");
let ppid = process.ppid; let ppid = process.ppid;
unsafe { SWITCHTO_CALLER = None }; unsafe { SWITCHTO_CALLER = None };
ss.activate_process_thread(thread, ppid, 0, !blocking) ss.activate_process_thread(thread, ppid, 0, false)
.map(|_| Ok(xous_kernel::Result::ResumeProcess)) .map(|_| Ok(xous_kernel::Result::ResumeProcess))
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound)) .unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
} else { } else {
@ -260,6 +260,8 @@ fn return_memory(
in_irq: bool, in_irq: bool,
sender: MessageSender, sender: MessageSender,
buf: MemoryRange, buf: MemoryRange,
offset: Option<MemorySize>,
valid: Option<MemorySize>,
) -> SysCallResult { ) -> SysCallResult {
SystemServices::with_mut(|ss| { SystemServices::with_mut(|ss| {
let sender = SenderID::from(sender); let sender = SenderID::from(sender);
@ -339,7 +341,7 @@ fn return_memory(
// print!(" [waking up PID {}:{}]", client_pid, client_tid); // print!(" [waking up PID {}:{}]", client_pid, client_tid);
ss.ready_thread(client_pid, client_tid)?; ss.ready_thread(client_pid, client_tid)?;
ss.switch_to_thread(client_pid, Some(client_tid))?; ss.switch_to_thread(client_pid, Some(client_tid))?;
ss.set_thread_result(client_pid, client_tid, xous_kernel::Result::Ok)?; ss.set_thread_result(client_pid, client_tid, xous_kernel::Result::MemoryReturned(offset, valid))?;
// Return success to the server // Return success to the server
Ok(xous_kernel::Result::Ok) Ok(xous_kernel::Result::Ok)
@ -352,7 +354,7 @@ fn return_memory(
// Switch to the client // Switch to the client
ss.ready_thread(client_pid, client_tid)?; ss.ready_thread(client_pid, client_tid)?;
ss.switch_to_thread(client_pid, Some(client_tid))?; ss.switch_to_thread(client_pid, Some(client_tid))?;
Ok(xous_kernel::Result::Ok) Ok(xous_kernel::Result::MemoryReturned(offset, valid))
} }
}) })
} }
@ -780,7 +782,7 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
ss.connect_to_server(sid) ss.connect_to_server(sid)
.map(xous_kernel::Result::ConnectionID) .map(xous_kernel::Result::ConnectionID)
}), }),
SysCall::ReturnMemory(sender, buf) => return_memory(pid, tid, in_irq, sender, buf), SysCall::ReturnMemory(sender, buf, offset, valid) => return_memory(pid, tid, in_irq, sender, buf, offset, valid),
SysCall::ReturnScalar1(sender, arg) => return_scalar(pid, tid, in_irq, sender, arg), SysCall::ReturnScalar1(sender, arg) => return_scalar(pid, tid, in_irq, sender, arg),
SysCall::ReturnScalar2(sender, arg1, arg2) => { SysCall::ReturnScalar2(sender, arg1, arg2) => {
return_scalar2(pid, tid, in_irq, sender, arg1, arg2) return_scalar2(pid, tid, in_irq, sender, arg1, arg2)

View file

@ -224,7 +224,8 @@ fn xmain() -> ! {
if debugc{info!("GAM: chatlayout made st {:?} co {:?} pr {:?} in {:?}", chatlayout.status, chatlayout.content, chatlayout.predictive, chatlayout.input);} if debugc{info!("GAM: chatlayout made st {:?} co {:?} pr {:?} in {:?}", chatlayout.status, chatlayout.content, chatlayout.predictive, chatlayout.input);}
// make a thread to manage the status bar -- this needs to start after the IMEF is initialized // make a thread to manage the status bar -- this needs to start after the IMEF is initialized
// the status bar is a trusted element managed by the OS, and we are chosing to domicile this in the GAM process for now // the status bar is a trusted element managed by the OS, and we are chosing to domicile this in the GAM process for now
xous::create_thread_simple(status_thread, chatlayout.status.gid()).expect("GAM: couldn't create status thread"); let gid = chatlayout.status.gid();
xous::create_thread_4(status_thread, gid[0] as _, gid[1] as _, gid[2] as _, gid[3] as _).expect("GAM: couldn't create status thread");
let mut powerdown_requested = false; let mut powerdown_requested = false;
let mut last_time: u64 = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap(); let mut last_time: u64 = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap();

View file

@ -7,7 +7,8 @@ use core::convert::TryFrom;
use blitstr_ref as blitstr; use blitstr_ref as blitstr;
pub fn status_thread(canvas_gid: [u32; 4]) { pub fn status_thread(canvas_gid_0: usize, canvas_gid_1: usize, canvas_gid_2: usize, canvas_gid_3: usize) {
let canvas_gid = [canvas_gid_0 as u32, canvas_gid_1 as u32, canvas_gid_2 as u32, canvas_gid_3 as u32];
let debug1 = false; let debug1 = false;
let status_gid: Gid = Gid::new(canvas_gid); let status_gid: Gid = Gid::new(canvas_gid);
if debug1{info!("GAM|status: my canvas {:?}", status_gid)}; if debug1{info!("GAM|status: my canvas {:?}", status_gid)};

View file

@ -1,18 +1,14 @@
#![cfg_attr(target_os = "none", no_std)] #![cfg_attr(target_os = "none", no_std)]
#![cfg_attr(target_os = "none", no_main)] #![cfg_attr(target_os = "none", no_main)]
fn sleep_loop(sleep_ms: usize) { const EXTRA_KEY: usize = 42;
let ticktimer_server_id = xous::SID::from_bytes(b"ticktimer-server").unwrap();
let ticktimer_conn = xous::connect(ticktimer_server_id).unwrap(); fn sleep_loop_4(sleep_ms: usize, conn: usize, pid: usize, extra: usize) {
let tid = xous::current_tid().unwrap(); let tid = xous::current_tid().unwrap();
let pid = xous::current_pid().unwrap().get(); let conn = conn as _;
let sleep_ms = match tid { // let pid = xous::current_pid().unwrap().get();
2 => 3000, log::info!("My thread number is {}, sleeping 0x{:08x} ({}) ms and EXTRA: {}", tid, sleep_ms, sleep_ms, extra);
3 => 7000, assert_eq!(extra, EXTRA_KEY, "extra key in arg 4 didn't match -- was {}, not {}", extra, EXTRA_KEY);
4 => 12000,
_ => panic!("Unknown TID/PID"),
};
// log::info!("My thread number is {}, sleeping 0x{:08x} ({}) ms", tid, sleep_ms, sleep_ms);
let mut loop_count = 0; let mut loop_count = 0;
loop { loop {
@ -22,9 +18,9 @@ fn sleep_loop(sleep_ms: usize) {
// sleep_ms, // sleep_ms,
// loop_count // loop_count
// ); // );
let start_time = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap(); let start_time = ticktimer_server::elapsed_ms(conn).unwrap();
ticktimer_server::sleep_ms(ticktimer_conn, sleep_ms).unwrap(); ticktimer_server::sleep_ms(conn, sleep_ms).unwrap();
let end_time = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap(); let end_time = ticktimer_server::elapsed_ms(conn).unwrap();
log::info!( log::info!(
"TEST THREAD {}:{}: target {}ms, {} loops: Sleep finished (uptime: {}, took {} ms)", "TEST THREAD {}:{}: target {}ms, {} loops: Sleep finished (uptime: {}, took {} ms)",
pid, pid,
@ -38,20 +34,42 @@ fn sleep_loop(sleep_ms: usize) {
} }
} }
fn sleep_loop_3(sleep_ms: usize, conn: usize, pid: usize) {
sleep_loop_4(sleep_ms, conn, pid, EXTRA_KEY);
}
fn sleep_loop_2(sleep_ms: usize, conn: usize) {
sleep_loop_3(sleep_ms, conn, xous::current_pid().unwrap().get() as _);
}
fn sleep_loop_1(sleep_ms: usize) {
let ticktimer_server_id = xous::SID::from_bytes(b"ticktimer-server").unwrap();
let ticktimer_conn = xous::connect(ticktimer_server_id).unwrap();
sleep_loop_2(sleep_ms, ticktimer_conn as _);
}
fn sleep_loop_0() {
let sleep_ms = (xous::current_pid().unwrap().get() as usize) * (xous::current_tid().unwrap() as usize);
let ticktimer_server_id = xous::SID::from_bytes(b"ticktimer-server").unwrap();
let ticktimer_conn = xous::connect(ticktimer_server_id).unwrap();
sleep_loop_2(sleep_ms, ticktimer_conn as _);
}
#[xous::xous_main] #[xous::xous_main]
fn test_main() -> ! { fn test_main() -> ! {
log_server::init_wait().unwrap(); let ticktimer_server_id = xous::SID::from_bytes(b"ticktimer-server").unwrap();
xous::create_thread_simple(sleep_loop, 10).unwrap(); let ticktimer_conn = xous::connect(ticktimer_server_id).unwrap();
xous::create_thread_simple(sleep_loop, 5).unwrap();
if xous::current_pid().unwrap().get() == 6 { log_server::init_wait().unwrap();
xous::create_thread_simple(sleep_loop, 2).unwrap(); let pid = xous::current_pid().unwrap().get() as usize;
}
xous::create_thread_0(sleep_loop_0).unwrap();
xous::create_thread_1(sleep_loop_1, 4 * pid).unwrap();
xous::create_thread_2(sleep_loop_2, 10 * pid, ticktimer_conn as _).unwrap();
xous::create_thread_3(sleep_loop_3, 42 * pid, ticktimer_conn as _, pid).unwrap();
xous::create_thread_4(sleep_loop_4, 180 * pid, ticktimer_conn as _, pid, EXTRA_KEY).unwrap();
// let mut ms_count = 1;
loop { loop {
xous::wait_event(); xous::wait_event();
// log::info!("Loop {}", ms_count);
// sleep_ms(ticktimer_conn, 1).unwrap();
// ms_count += 1;
} }
} }

View file

@ -224,7 +224,8 @@ fn handle_scalar(
} }
} }
fn reader_thread(mut output: implementation::OutputWriter) { fn reader_thread(arg: usize) {
let mut output = unsafe { &mut *(arg as *mut implementation::OutputWriter) };
writeln!(output, "LOG: Xous Logging Server starting up...").unwrap(); writeln!(output, "LOG: Xous Logging Server starting up...").unwrap();
writeln!(output, "LOG: ****************************************************************").unwrap(); writeln!(output, "LOG: ****************************************************************").unwrap();
@ -331,10 +332,10 @@ fn some_main() -> ! {
*/ */
let mut output = implementation::init(); let mut output = implementation::init();
let writer = output.get_writer(); let mut writer = output.get_writer();
println!("LOG: my PID is {}", xous::process::id()); println!("LOG: my PID is {}", xous::process::id());
println!("LOG: Creating the reader thread"); println!("LOG: Creating the reader thread");
xous::create_thread_simple(reader_thread, writer).unwrap(); xous::create_thread_1(reader_thread, &mut writer as *mut implementation::OutputWriter as usize).unwrap();
println!("LOG: Running the output"); println!("LOG: Running the output");
output.run(); output.run();
panic!("LOG: Exited"); panic!("LOG: Exited");

View file

@ -3,7 +3,7 @@ use xous::{String, MessageEnvelope, Message, ScalarMessage};
use core::sync::atomic::{AtomicBool, Ordering}; use core::sync::atomic::{AtomicBool, Ordering};
static CB_RUN: AtomicBool = AtomicBool::new(false); static CB_RUN: AtomicBool = AtomicBool::new(false);
pub fn callback_thread(_: u32) { pub fn callback_thread() {
let ticktimer_conn = xous::connect(xous::SID::from_bytes(b"ticktimer-server").unwrap()).unwrap(); let ticktimer_conn = xous::connect(xous::SID::from_bytes(b"ticktimer-server").unwrap()).unwrap();
let callback_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_SHELLCHAT).unwrap(); let callback_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_SHELLCHAT).unwrap();
@ -29,7 +29,7 @@ pub struct CallBack {
} }
impl CallBack { impl CallBack {
pub fn new() -> Self { pub fn new() -> Self {
xous::create_thread_simple(callback_thread, 0).expect("SHCH: couldn't create callback generator thread"); xous::create_thread_0(callback_thread).expect("SHCH: couldn't create callback generator thread");
CallBack { CallBack {
state: 0, state: 0,
callbacks: 0 callbacks: 0

View file

@ -297,6 +297,117 @@ fn xous_address() -> SocketAddr {
.unwrap_or_else(default_xous_address) .unwrap_or_else(default_xous_address)
} }
pub fn create_thread_0_pre<U>(
_f: &fn() -> U,
) -> core::result::Result<ThreadInit, crate::Error>
where
U: Send + 'static,
{
Ok(ThreadInit {})
}
pub fn create_thread_1_pre<U>(
_f: &fn(usize) -> U,
_arg1: &usize,
) -> core::result::Result<ThreadInit, crate::Error>
where
U: Send + 'static,
{
Ok(ThreadInit {})
}
pub fn create_thread_2_pre<U>(
_f: &fn(usize, usize) -> U,
_arg1: &usize,
_arg2: &usize,
) -> core::result::Result<ThreadInit, crate::Error>
where
U: Send + 'static,
{
Ok(ThreadInit {})
}
pub fn create_thread_3_pre<U>(
_f: &fn(usize, usize, usize) -> U,
_arg1: &usize,
_arg2: &usize,
_arg3: &usize,
) -> core::result::Result<ThreadInit, crate::Error>
where
U: Send + 'static,
{
Ok(ThreadInit {})
}
pub fn create_thread_4_pre<U>(
_f: &fn(usize, usize, usize, usize) -> U,
_arg1: &usize,
_arg2: &usize,
_arg3: &usize,
_arg4: &usize,
) -> core::result::Result<ThreadInit, crate::Error>
where
U: Send + 'static,
{
Ok(ThreadInit {})
}
pub fn create_thread_0_post<U>(
f: fn() -> U,
thread_id: TID,
) -> core::result::Result<WaitHandle<U>, crate::Error>
where
U: Send + 'static,
{
create_thread_post(move || f(), thread_id)
}
pub fn create_thread_1_post<U>(
f: fn(usize) -> U,
arg1: usize,
thread_id: TID,
) -> core::result::Result<WaitHandle<U>, crate::Error>
where
U: Send + 'static,
{
create_thread_post(move || f(arg1), thread_id)
}
pub fn create_thread_2_post<U>(
f: fn(usize, usize) -> U,
arg1: usize,
arg2: usize,
thread_id: TID,
) -> core::result::Result<WaitHandle<U>, crate::Error>
where
U: Send + 'static,
{
create_thread_post(move || f(arg1, arg2), thread_id)
}
pub fn create_thread_3_post<U>(
f: fn(usize, usize, usize) -> U,
arg1: usize,
arg2: usize,
arg3: usize,
thread_id: TID,
) -> core::result::Result<WaitHandle<U>, crate::Error>
where
U: Send + 'static,
{
create_thread_post(move || f(arg1, arg2, arg3), thread_id)
}
pub fn create_thread_4_post<U>(
f: fn(usize, usize, usize, usize) -> U,
arg1: usize,
arg2: usize,
arg3: usize,
arg4: usize,
thread_id: TID,
) -> core::result::Result<WaitHandle<U>, crate::Error>
where
U: Send + 'static,
{
create_thread_post(move || f(arg1, arg2, arg3, arg4), thread_id)
}
pub fn create_thread_simple_pre<T, U>( pub fn create_thread_simple_pre<T, U>(
_f: &fn(T) -> U, _f: &fn(T) -> U,
_arg: &T, _arg: &T,

View file

@ -1,4 +1,4 @@
use crate::{MemoryAddress, MemoryRange, PID, TID}; use crate::{MemoryRange, PID, TID};
use core::convert::TryInto; use core::convert::TryInto;
mod mem; mod mem;
@ -11,24 +11,34 @@ pub struct ProcessArgs {
#[derive(Debug, Clone, Copy, PartialEq)] #[derive(Debug, Clone, Copy, PartialEq)]
pub struct ThreadInit { pub struct ThreadInit {
pub call: fn(data: usize) -> usize, /// Function pointer that accepts 0-4 arguments
pub call: usize,
pub stack: MemoryRange, pub stack: MemoryRange,
pub arg: Option<MemoryAddress>, pub arg1: usize,
pub name: [u8; 12], pub arg2: usize,
pub arg3: usize,
pub arg4: usize,
// pub name: [u8; 12],
} }
impl ThreadInit { impl ThreadInit {
pub fn new( pub fn new(
call: fn(data: usize) -> usize, call: usize,
stack: MemoryRange, stack: MemoryRange,
arg: Option<MemoryAddress>, arg1: usize,
name: [u8; 12], arg2: usize,
arg3: usize,
arg4: usize,
// name: [u8; 12],
) -> Self { ) -> Self {
ThreadInit { ThreadInit {
call, call,
stack, stack,
arg, arg1,
name, arg2,
arg3,
arg4,
// name,
} }
} }
} }
@ -36,10 +46,13 @@ impl ThreadInit {
impl Default for ThreadInit { impl Default for ThreadInit {
fn default() -> Self { fn default() -> Self {
ThreadInit { ThreadInit {
call: unsafe { core::mem::transmute::<usize, fn(data: usize) -> usize>(4) }, call: 1,
stack: MemoryRange::new(4, 4).unwrap(), stack: MemoryRange::new(4, 4).unwrap(),
arg: None, arg1: 0,
name: [0; 12], arg2: 0,
arg3: 0,
arg4: 0,
// name: [0; 12],
} }
} }
} }
@ -60,16 +73,16 @@ pub struct ProcessInit {
pub struct WaitHandle<T>(core::marker::PhantomData<T>); pub struct WaitHandle<T>(core::marker::PhantomData<T>);
pub struct ProcessHandle(()); pub struct ProcessHandle(());
pub fn thread_to_args(call: usize, init: &ThreadInit) -> [usize; 8] { pub fn thread_to_args(syscall: usize, init: &ThreadInit) -> [usize; 8] {
[ [
call as usize, syscall,
init.call as usize, init.call,
init.stack.as_ptr() as _, init.stack.as_ptr() as _,
init.stack.len(), init.stack.len(),
init.arg.map(|x| x.get()).unwrap_or_default(), init.arg1,
0, init.arg2,
0, init.arg3,
0, init.arg4,
] ]
} }
@ -81,18 +94,18 @@ pub fn args_to_thread(
a2: usize, a2: usize,
a3: usize, a3: usize,
a4: usize, a4: usize,
_a5: usize, a5: usize,
_a6: usize, a6: usize,
_a7: usize, a7: usize,
) -> core::result::Result<ThreadInit, crate::Error> { ) -> core::result::Result<ThreadInit, crate::Error> {
let call = unsafe { core::mem::transmute(a1) };
let stack = MemoryRange::new(a2, a3).map_err(|_| crate::Error::InvalidSyscall)?;
let arg = MemoryAddress::new(a4);
Ok(ThreadInit { Ok(ThreadInit {
call, call: a1,
stack, stack: MemoryRange::new(a2, a3).map_err(|_| crate::Error::InvalidSyscall)?,
arg, arg1: a4,
name: [0; 12], arg2: a5,
arg3: a6,
arg4: a7,
// name: [0; 12],
}) })
} }
@ -103,7 +116,6 @@ where
T: Send + 'static, T: Send + 'static,
{ {
todo!() todo!()
// Ok(ThreadInit {})
} }
pub fn create_thread_post<F, T>( pub fn create_thread_post<F, T>(
@ -116,29 +128,10 @@ where
T: Send + 'static, T: Send + 'static,
{ {
todo!() todo!()
// let server_address = xous_address();
// let server_connection =
// XOUS_SERVER_CONNECTION.with(|xsc| xsc.borrow().as_ref().unwrap().clone());
// let process_id = PROCESS_ID.with(|pid| *pid.borrow());
// Ok(std::thread::Builder::new()
// .spawn(move || {
// set_xous_address(server_address);
// THREAD_ID.with(|tid| *tid.borrow_mut() = thread_id);
// PROCESS_ID.with(|pid| *pid.borrow_mut() = process_id);
// XOUS_SERVER_CONNECTION.with(|xsc| *xsc.borrow_mut() = Some(server_connection));
// f()
// })
// .map(WaitHandle)
// .map_err(|_| crate::Error::InternalError)?)
} }
pub fn wait_thread<T>(_joiner: WaitHandle<T>) -> crate::SysCallResult { pub fn wait_thread<T>(_joiner: WaitHandle<T>) -> crate::SysCallResult {
todo!() todo!()
// joiner
// .0
// .join()
// .map(|_| Result::Ok)
// .map_err(|_| crate::Error::InternalError)
} }
pub fn process_to_args(call: usize, init: &ProcessInit) -> [usize; 8] { pub fn process_to_args(call: usize, init: &ProcessInit) -> [usize; 8] {
@ -166,6 +159,129 @@ pub fn args_to_process(
todo!() todo!()
} }
pub fn create_thread_0_pre<U>(f: &fn() -> U) -> core::result::Result<ThreadInit, crate::Error>
where
U: Send + 'static,
{
let start = unsafe { core::mem::transmute(*f) };
create_thread_n_pre(start, &0, &0, &0, &0)
}
pub fn create_thread_0_post<U>(
f: fn() -> U,
thread_id: TID,
) -> core::result::Result<WaitHandle<U>, crate::Error>
where
U: Send + 'static,
{
let start = unsafe { core::mem::transmute(f) };
create_thread_n_post(start, 0, 0, 0, 0, thread_id)
}
pub fn create_thread_1_pre<U>(
f: &fn(usize) -> U,
arg1: &usize,
) -> core::result::Result<ThreadInit, crate::Error>
where
U: Send + 'static,
{
let start = unsafe { core::mem::transmute(*f) };
create_thread_n_pre(start, arg1, &0, &0, &0)
}
pub fn create_thread_1_post<U>(
f: fn(usize) -> U,
arg1: usize,
thread_id: TID,
) -> core::result::Result<WaitHandle<U>, crate::Error>
where
U: Send + 'static,
{
let start = unsafe { core::mem::transmute(f) };
create_thread_n_post(start, arg1, 0, 0, 0, thread_id)
}
pub fn create_thread_2_pre<U>(
f: &fn(usize, usize) -> U,
arg1: &usize,
arg2: &usize,
) -> core::result::Result<ThreadInit, crate::Error>
where
U: Send + 'static,
{
let start = unsafe { core::mem::transmute(*f) };
create_thread_n_pre(start, arg1, arg2, &0, &0)
}
pub fn create_thread_2_post<U>(
f: fn(usize, usize) -> U,
arg1: usize,
arg2: usize,
thread_id: TID,
) -> core::result::Result<WaitHandle<U>, crate::Error>
where
U: Send + 'static,
{
let start = unsafe { core::mem::transmute(f) };
create_thread_n_post(start, arg1, arg2, 0, 0, thread_id)
}
pub fn create_thread_3_pre<U>(
f: &fn(usize, usize, usize) -> U,
arg1: &usize,
arg2: &usize,
arg3: &usize,
) -> core::result::Result<ThreadInit, crate::Error>
where
U: Send + 'static,
{
let start = unsafe { core::mem::transmute(*f) };
create_thread_n_pre(start, arg1, arg2, arg3, &0)
}
pub fn create_thread_3_post<U>(
f: fn(usize, usize, usize) -> U,
arg1: usize,
arg2: usize,
arg3: usize,
thread_id: TID,
) -> core::result::Result<WaitHandle<U>, crate::Error>
where
U: Send + 'static,
{
let start = unsafe { core::mem::transmute(f) };
create_thread_n_post(start, arg1, arg2, arg3, 0, thread_id)
}
pub fn create_thread_4_pre<U>(
f: &fn(usize, usize, usize, usize) -> U,
arg1: &usize,
arg2: &usize,
arg3: &usize,
arg4: &usize,
) -> core::result::Result<ThreadInit, crate::Error>
where
U: Send + 'static,
{
let start = unsafe { core::mem::transmute(*f) };
create_thread_n_pre(start, arg1, arg2, arg3, arg4)
}
pub fn create_thread_4_post<U>(
f: fn(usize, usize, usize, usize) -> U,
arg1: usize,
arg2: usize,
arg3: usize,
arg4: usize,
thread_id: TID,
) -> core::result::Result<WaitHandle<U>, crate::Error>
where
U: Send + 'static,
{
let start = unsafe { core::mem::transmute(f) };
create_thread_n_post(start, arg1, arg2, arg3, arg4, thread_id)
}
pub fn create_thread_simple_pre<T, U>( pub fn create_thread_simple_pre<T, U>(
f: &fn(T) -> U, f: &fn(T) -> U,
arg: &T, arg: &T,
@ -174,27 +290,37 @@ where
T: Send + 'static, T: Send + 'static,
U: Send + 'static, U: Send + 'static,
{ {
#[cfg(feature = "bit-flags")] create_thread_n_pre(
let flags = crate::MemoryFlags::R | crate::MemoryFlags::W | crate::MemoryFlags::RESERVE; unsafe { core::mem::transmute(*f) },
#[cfg(not(feature = "bit-flags"))] unsafe { core::mem::transmute(arg) },
let flags = 0b0000_0010 | 0b0000_0100 | 0b0000_0001; &0,
&0,
let stack = crate::map_memory(None, None, 131_072, flags)?; &0,
let start = unsafe { core::mem::transmute(*f) }; )
let arg = unsafe { core::mem::transmute(arg) };
Ok(ThreadInit::new(start, stack, Some(arg), [0; 12]))
} }
pub fn create_thread_simple_post<T, U>( pub fn create_thread_simple_post<T, U>(
_f: fn(T) -> U, f: fn(T) -> U,
_arg: T, arg: T,
_thread_id: TID, thread_id: TID,
) -> core::result::Result<WaitHandle<U>, crate::Error> ) -> core::result::Result<WaitHandle<U>, crate::Error>
where where
T: Send + 'static, T: Send + 'static,
U: Send + 'static, U: Send + 'static,
{ {
Ok(WaitHandle(core::marker::PhantomData)) create_thread_n_post(
unsafe { core::mem::transmute(f) },
unsafe { core::mem::transmute(&arg) },
0,
0,
0,
thread_id,
)
// If we succeeded, the variable will be moved into the caller. Drop it from here.
.and_then(|f| {
core::mem::forget(arg);
Ok(f)
})
} }
/// If no connection exists, create a new connection to the server. This means /// If no connection exists, create a new connection to the server. This means
@ -211,6 +337,36 @@ pub fn create_process_post(
todo!() todo!()
} }
pub fn create_thread_n_pre(
start: usize,
arg1: &usize,
arg2: &usize,
arg3: &usize,
arg4: &usize,
) -> core::result::Result<ThreadInit, crate::Error> {
#[cfg(feature = "bit-flags")]
let flags = crate::MemoryFlags::R | crate::MemoryFlags::W | crate::MemoryFlags::RESERVE;
#[cfg(not(feature = "bit-flags"))]
let flags = 0b0000_0010 | 0b0000_0100 | 0b0000_0001;
let stack = crate::map_memory(None, None, 131_072, flags)?;
Ok(ThreadInit::new(start, stack, *arg1, *arg2, *arg3, *arg4))
}
pub fn create_thread_n_post<U>(
_f: usize,
_arg1: usize,
_arg2: usize,
_arg3: usize,
_arg4: usize,
_thread_id: TID,
) -> core::result::Result<WaitHandle<U>, crate::Error>
where
U: Send + 'static,
{
Ok(WaitHandle(core::marker::PhantomData))
}
pub fn wait_process(_joiner: ProcessHandle) -> crate::SysCallResult { pub fn wait_process(_joiner: ProcessHandle) -> crate::SysCallResult {
loop { loop {
crate::wait_event(); crate::wait_event();

View file

@ -1,4 +1,4 @@
use core::convert::TryInto; use core::convert::{TryFrom, TryInto};
use core::num::{NonZeroU8, NonZeroUsize}; use core::num::{NonZeroU8, NonZeroUsize};
pub type MemoryAddress = NonZeroUsize; pub type MemoryAddress = NonZeroUsize;
@ -393,7 +393,7 @@ impl Message {
} }
} }
pub fn message_type(&self) -> usize { pub(crate) fn message_type(&self) -> usize {
match *self { match *self {
Message::MutableBorrow(_) => 1, Message::MutableBorrow(_) => 1,
Message::Borrow(_) => 2, Message::Borrow(_) => 2,
@ -402,6 +402,57 @@ impl Message {
Message::BlockingScalar(_) => 5, Message::BlockingScalar(_) => 5,
} }
} }
/// Return the ID of this message
pub fn id(&self) -> usize {
match &self {
&Message::MutableBorrow(mem) | &Message::Borrow(mem) | &Message::Move(mem) => mem.id,
&Message::Scalar(s) | &Message::BlockingScalar(s) => s.id,
}
}
}
impl TryFrom<(usize, usize, usize, usize, usize, usize)> for Message {
type Error = ();
fn try_from(
value: (usize, usize, usize, usize, usize, usize),
) -> core::result::Result<Self, Self::Error> {
match value.0 {
1 => Ok(Message::MutableBorrow(MemoryMessage {
id: value.1,
buf: MemoryRange::new(value.2, value.3).map_err(|_| ())?,
offset: MemoryAddress::new(value.4),
valid: MemorySize::new(value.5),
})),
2 => Ok(Message::Borrow(MemoryMessage {
id: value.1,
buf: MemoryRange::new(value.2, value.3).map_err(|_| ())?,
offset: MemoryAddress::new(value.4),
valid: MemorySize::new(value.5),
})),
3 => Ok(Message::Move(MemoryMessage {
id: value.1,
buf: MemoryRange::new(value.2, value.3).map_err(|_| ())?,
offset: MemoryAddress::new(value.4),
valid: MemorySize::new(value.5),
})),
4 => Ok(Message::Scalar(ScalarMessage {
id: value.1,
arg1: value.2,
arg2: value.3,
arg3: value.4,
arg4: value.5,
})),
5 => Ok(Message::BlockingScalar(ScalarMessage {
id: value.1,
arg1: value.2,
arg2: value.3,
arg3: value.4,
arg4: value.5,
})),
_ => Err(()),
}
}
} }
#[repr(C)] #[repr(C)]
@ -567,6 +618,12 @@ pub enum Result {
/// The message was successful but no value was returned. /// The message was successful but no value was returned.
None, None,
/// Memory was returned, and more information is available.
MemoryReturned(
Option<MemorySize>, /* offset */
Option<MemorySize>, /* valid */
),
UnknownResult(usize, usize, usize, usize, usize, usize, usize), UnknownResult(usize, usize, usize, usize, usize, usize, usize),
} }
@ -600,10 +657,29 @@ impl Result {
Result::Scalar2(a, b) => [14, *a, *b, 0, 0, 0, 0, 0], Result::Scalar2(a, b) => [14, *a, *b, 0, 0, 0, 0, 0],
Result::NewServerID(sid, cid) => { Result::NewServerID(sid, cid) => {
let s = sid.to_u32(); let s = sid.to_u32();
[15, s.0 as _, s.1 as _, s.2 as _, s.3 as _, *cid as usize, 0, 0] [
15,
s.0 as _,
s.1 as _,
s.2 as _,
s.3 as _,
*cid as usize,
0,
0,
]
} }
Result::WouldBlock => [16, 0, 0, 0, 0, 0, 0, 0], Result::WouldBlock => [16, 0, 0, 0, 0, 0, 0, 0],
Result::None => [17, 0, 0, 0, 0, 0, 0, 0], Result::None => [17, 0, 0, 0, 0, 0, 0, 0],
Result::MemoryReturned(offset, valid) => [
18,
offset.map(|o| o.get()).unwrap_or_default(),
valid.map(|v| v.get()).unwrap_or_default(),
0,
0,
0,
0,
0,
],
Result::UnknownResult(arg1, arg2, arg3, arg4, arg5, arg6, arg7) => { Result::UnknownResult(arg1, arg2, arg3, arg4, arg5, arg6, arg7) => {
[usize::MAX, *arg1, *arg2, *arg3, *arg4, *arg5, *arg6, *arg7] [usize::MAX, *arg1, *arg2, *arg3, *arg4, *arg5, *arg6, *arg7]
} }
@ -679,6 +755,7 @@ impl Result {
), ),
16 => Result::WouldBlock, 16 => Result::WouldBlock,
17 => Result::None, 17 => Result::None,
18 => Result::MemoryReturned(MemorySize::new(src[1]), MemorySize::new(src[2])),
_ => Result::UnknownResult(src[0], src[1], src[2], src[3], src[4], src[5], src[6]), _ => Result::UnknownResult(src[0], src[1], src[2], src[3], src[4], src[5], src[6]),
} }
} }

View file

@ -3,7 +3,7 @@ use crate::{
MemorySize, MemoryType, Message, MessageEnvelope, MessageSender, ProcessArgs, ProcessInit, MemorySize, MemoryType, Message, MessageEnvelope, MessageSender, ProcessArgs, ProcessInit,
Result, ScalarMessage, SysCallResult, ThreadInit, CID, PID, SID, TID, Result, ScalarMessage, SysCallResult, ThreadInit, CID, PID, SID, TID,
}; };
use core::convert::TryInto; use core::convert::{TryFrom, TryInto};
// use num_derive::FromPrimitive; // use num_derive::FromPrimitive;
// use num_traits::FromPrimitive; // use num_traits::FromPrimitive;
@ -253,7 +253,12 @@ pub enum SysCall {
TrySendMessage(CID, Message), TrySendMessage(CID, Message),
/// Return a Borrowed memory region to the sender /// Return a Borrowed memory region to the sender
ReturnMemory(MessageSender, MemoryRange), ReturnMemory(
MessageSender, /* source of this message */
MemoryRange, /* address of range */
Option<MemorySize>, /* offset */
Option<MemorySize>, /* valid */
),
/// Return a scalar to the sender /// Return a scalar to the sender
ReturnScalar1(MessageSender, usize), ReturnScalar1(MessageSender, usize),
@ -597,13 +602,13 @@ impl SysCall {
sc.arg4, sc.arg4,
], ],
}, },
SysCall::ReturnMemory(sender, buf) => [ SysCall::ReturnMemory(sender, buf, offset, valid) => [
SysCallNumber::ReturnMemory as usize, SysCallNumber::ReturnMemory as usize,
sender.to_usize(), sender.to_usize(),
buf.as_ptr() as usize, buf.as_ptr() as usize,
buf.len(), buf.len(),
0, offset.map(|o| o.get()).unwrap_or_default(),
0, valid.map(|v| v.get()).unwrap_or_default(),
0, 0,
0, 0,
], ],
@ -755,59 +760,15 @@ impl SysCall {
SysCallNumber::Connect => { SysCallNumber::Connect => {
SysCall::Connect(SID::from_u32(a1 as _, a2 as _, a3 as _, a4 as _)) SysCall::Connect(SID::from_u32(a1 as _, a2 as _, a3 as _, a4 as _))
} }
SysCallNumber::SendMessage => match a2 { SysCallNumber::SendMessage => Message::try_from((a2, a3, a4, a5, a6, a7))
1 => SysCall::SendMessage( .map(|m| SysCall::SendMessage(a1.try_into().unwrap(), m))
a1.try_into().unwrap(), .unwrap_or_else(|_| SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7)),
Message::MutableBorrow(MemoryMessage { SysCallNumber::ReturnMemory => SysCall::ReturnMemory(
id: a3, MessageSender::from_usize(a1),
buf: MemoryRange::new(a4, a5)?, MemoryRange::new(a2, a3)?,
offset: MemoryAddress::new(a6), MemorySize::new(a4),
valid: MemorySize::new(a7), MemorySize::new(a5),
}),
), ),
2 => SysCall::SendMessage(
a1.try_into().unwrap(),
Message::Borrow(MemoryMessage {
id: a3,
buf: MemoryRange::new(a4, a5)?,
offset: MemoryAddress::new(a6),
valid: MemorySize::new(a7),
}),
),
3 => SysCall::SendMessage(
a1.try_into().unwrap(),
Message::Move(MemoryMessage {
id: a3,
buf: MemoryRange::new(a4, a5)?,
offset: MemoryAddress::new(a6),
valid: MemorySize::new(a7),
}),
),
4 => SysCall::SendMessage(
a1.try_into().unwrap(),
Message::Scalar(ScalarMessage {
id: a3,
arg1: a4,
arg2: a5,
arg3: a6,
arg4: a7,
}),
),
5 => SysCall::SendMessage(
a1.try_into().unwrap(),
Message::BlockingScalar(ScalarMessage {
id: a3,
arg1: a4,
arg2: a5,
arg3: a6,
arg4: a7,
}),
),
_ => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7),
},
SysCallNumber::ReturnMemory => {
SysCall::ReturnMemory(MessageSender::from_usize(a1), MemoryRange::new(a2, a3)?)
}
SysCallNumber::CreateThread => { SysCallNumber::CreateThread => {
SysCall::CreateThread(crate::arch::args_to_thread(a1, a2, a3, a4, a5, a6, a7)?) SysCall::CreateThread(crate::arch::args_to_thread(a1, a2, a3, a4, a5, a6, a7)?)
} }
@ -895,7 +856,7 @@ impl SysCall {
Message::Move(_) | Message::Borrow(_) | Message::MutableBorrow(_) Message::Move(_) | Message::Borrow(_) | Message::MutableBorrow(_)
) )
} }
SysCall::ReturnMemory(_, _) => true, SysCall::ReturnMemory(_, _, _, _) => true,
_ => false, _ => false,
} }
} }
@ -932,7 +893,7 @@ impl SysCall {
/// Returns `true` if the associated syscall is returning memory /// Returns `true` if the associated syscall is returning memory
pub fn is_return_memory(&self) -> bool { pub fn is_return_memory(&self) -> bool {
matches!(self, SysCall::ReturnMemory(_, _)) matches!(self, SysCall::ReturnMemory(_, _, _, _))
} }
/// If the syscall has memory attached to it, return the memory /// If the syscall has memory attached to it, return the memory
@ -944,7 +905,7 @@ impl SysCall {
| Message::MutableBorrow(memory_message) => Some(memory_message.buf), | Message::MutableBorrow(memory_message) => Some(memory_message.buf),
_ => None, _ => None,
}, },
SysCall::ReturnMemory(_, range) => Some(*range), SysCall::ReturnMemory(_, range, _, _) => Some(*range),
_ => None, _ => None,
} }
} }
@ -959,7 +920,7 @@ impl SysCall {
| SysCall::ReturnToParent(_, _) | SysCall::ReturnToParent(_, _)
| SysCall::ReturnScalar2(_, _, _) | SysCall::ReturnScalar2(_, _, _)
| SysCall::ReturnScalar1(_, _) | SysCall::ReturnScalar1(_, _)
| SysCall::ReturnMemory(_, _) | SysCall::ReturnMemory(_, _, _, _)
) )
} }
} }
@ -1033,7 +994,24 @@ pub fn unmap_memory(range: MemoryRange) -> core::result::Result<(), Error> {
/// Map the given physical address to the given virtual address. /// Map the given physical address to the given virtual address.
/// The `size` field must be page-aligned. /// The `size` field must be page-aligned.
pub fn return_memory(sender: MessageSender, mem: MemoryRange) -> core::result::Result<(), Error> { pub fn return_memory(sender: MessageSender, mem: MemoryRange) -> core::result::Result<(), Error> {
let result = rsyscall(SysCall::ReturnMemory(sender, mem))?; let result = rsyscall(SysCall::ReturnMemory(sender, mem, None, None))?;
if let crate::Result::Ok = result {
Ok(())
} else if let Result::Error(e) = result {
Err(e)
} else {
Err(Error::InternalError)
}
}
/// Map the given physical address to the given virtual address.
/// The `size` field must be page-aligned.
pub fn return_memory_offset(
sender: MessageSender,
mem: MemoryRange,
offset: Option<MemorySize>,
) -> core::result::Result<(), Error> {
let result = rsyscall(SysCall::ReturnMemory(sender, mem, offset, None))?;
if let crate::Result::Ok = result { if let crate::Result::Ok = result {
Ok(()) Ok(())
} else if let Result::Error(e) = result { } else if let Result::Error(e) = result {
@ -1253,6 +1231,7 @@ pub fn try_send_message(connection: CID, message: Message) -> core::result::Resu
Ok(Result::Ok) => Ok(Result::Ok), Ok(Result::Ok) => Ok(Result::Ok),
Ok(Result::Scalar1(a)) => Ok(Result::Scalar1(a)), Ok(Result::Scalar1(a)) => Ok(Result::Scalar1(a)),
Ok(Result::Scalar2(a, b)) => Ok(Result::Scalar2(a, b)), Ok(Result::Scalar2(a, b)) => Ok(Result::Scalar2(a, b)),
Ok(Result::MemoryReturned(offset, valid)) => Ok(Result::MemoryReturned(offset, valid)),
Err(e) => Err(e), Err(e) => Err(e),
v => panic!("Unexpected return value: {:?}", v), v => panic!("Unexpected return value: {:?}", v),
} }
@ -1294,6 +1273,7 @@ pub fn send_message(connection: CID, message: Message) -> core::result::Result<R
Ok(Result::Ok) => Ok(Result::Ok), Ok(Result::Ok) => Ok(Result::Ok),
Ok(Result::Scalar1(a)) => Ok(Result::Scalar1(a)), Ok(Result::Scalar1(a)) => Ok(Result::Scalar1(a)),
Ok(Result::Scalar2(a, b)) => Ok(Result::Scalar2(a, b)), Ok(Result::Scalar2(a, b)) => Ok(Result::Scalar2(a, b)),
Ok(Result::MemoryReturned(offset, valid)) => Ok(Result::MemoryReturned(offset, valid)),
Err(e) => Err(e), Err(e) => Err(e),
v => panic!("Unexpected return value: {:?}", v), v => panic!("Unexpected return value: {:?}", v),
} }
@ -1314,6 +1294,10 @@ pub fn wait_event() {
rsyscall(SysCall::WaitEvent).expect("wait_event returned an error"); rsyscall(SysCall::WaitEvent).expect("wait_event returned an error");
} }
#[deprecated(
since = "0.2",
note = "Please use create_thread_n() or create_thread()"
)]
pub fn create_thread_simple<T, U>( pub fn create_thread_simple<T, U>(
f: fn(T) -> U, f: fn(T) -> U,
arg: T, arg: T,
@ -1332,6 +1316,94 @@ where
}) })
} }
pub fn create_thread_0<T>(f: fn() -> T) -> core::result::Result<crate::arch::WaitHandle<T>, Error>
where
T: Send + 'static,
{
let thread_info = crate::arch::create_thread_0_pre(&f)?;
rsyscall(SysCall::CreateThread(thread_info)).and_then(|result| {
if let Result::ThreadID(thread_id) = result {
crate::arch::create_thread_0_post(f, thread_id)
} else {
Err(Error::InternalError)
}
})
}
pub fn create_thread_1<T>(
f: fn(usize) -> T,
arg1: usize,
) -> core::result::Result<crate::arch::WaitHandle<T>, Error>
where
T: Send + 'static,
{
let thread_info = crate::arch::create_thread_1_pre(&f, &arg1)?;
rsyscall(SysCall::CreateThread(thread_info)).and_then(|result| {
if let Result::ThreadID(thread_id) = result {
crate::arch::create_thread_1_post(f, arg1, thread_id)
} else {
Err(Error::InternalError)
}
})
}
pub fn create_thread_2<T>(
f: fn(usize, usize) -> T,
arg1: usize,
arg2: usize,
) -> core::result::Result<crate::arch::WaitHandle<T>, Error>
where
T: Send + 'static,
{
let thread_info = crate::arch::create_thread_2_pre(&f, &arg1, &arg2)?;
rsyscall(SysCall::CreateThread(thread_info)).and_then(|result| {
if let Result::ThreadID(thread_id) = result {
crate::arch::create_thread_2_post(f, arg1, arg2, thread_id)
} else {
Err(Error::InternalError)
}
})
}
pub fn create_thread_3<T>(
f: fn(usize, usize, usize) -> T,
arg1: usize,
arg2: usize,
arg3: usize,
) -> core::result::Result<crate::arch::WaitHandle<T>, Error>
where
T: Send + 'static,
{
let thread_info = crate::arch::create_thread_3_pre(&f, &arg1, &arg2, &arg3)?;
rsyscall(SysCall::CreateThread(thread_info)).and_then(|result| {
if let Result::ThreadID(thread_id) = result {
crate::arch::create_thread_3_post(f, arg1, arg2, arg3, thread_id)
} else {
Err(Error::InternalError)
}
})
}
pub fn create_thread_4<T>(
f: fn(usize, usize, usize, usize) -> T,
arg1: usize,
arg2: usize,
arg3: usize,
arg4: usize,
) -> core::result::Result<crate::arch::WaitHandle<T>, Error>
where
T: Send + 'static,
{
let thread_info = crate::arch::create_thread_4_pre(&f, &arg1, &arg2, &arg3, &arg4)?;
rsyscall(SysCall::CreateThread(thread_info)).and_then(|result| {
if let Result::ThreadID(thread_id) = result {
crate::arch::create_thread_4_post(f, arg1, arg2, arg3, arg4, thread_id)
} else {
Err(Error::InternalError)
}
})
}
/// Create a new thread with the given closure. /// Create a new thread with the given closure.
pub fn create_thread<F, T>(f: F) -> core::result::Result<crate::arch::WaitHandle<T>, Error> pub fn create_thread<F, T>(f: F) -> core::result::Result<crate::arch::WaitHandle<T>, Error>
where where