mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-20 09:03:28 +00:00
Merge branch 'master' of github.com:betrusted-io/xous-core
This commit is contained in:
commit
f61d8d3a8f
14 changed files with 1702 additions and 185 deletions
|
|
@ -522,11 +522,13 @@ 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
|
||||||
SystemServices::with_mut(|ss| {
|
if new_pid != PID::new(1).unwrap() {
|
||||||
ss.create_thread(new_pid, ThreadInit {})?;
|
SystemServices::with_mut(|ss| {
|
||||||
ss.switch_to_thread(new_pid, None)
|
ss.create_thread(new_pid, ThreadInit {})?;
|
||||||
})
|
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);
|
||||||
|
|
|
||||||
|
|
@ -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]
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
1051
kernel/src/server-split-queues.rs
Normal file
1051
kernel/src/server-split-queues.rs
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -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,
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -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)
|
||||||
|
|
|
||||||
|
|
@ -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();
|
||||||
|
|
|
||||||
|
|
@ -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)};
|
||||||
|
|
|
||||||
|
|
@ -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;
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -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");
|
||||||
|
|
|
||||||
|
|
@ -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
|
||||||
|
|
|
||||||
|
|
@ -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,
|
||||||
|
|
|
||||||
|
|
@ -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();
|
||||||
|
|
|
||||||
|
|
@ -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]),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -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
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue