mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +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)`.
|
||||
// Note that in this system, multiple processes can be active at once. This is
|
||||
// similar to having one core for each process
|
||||
SystemServices::with_mut(|ss| {
|
||||
ss.create_thread(new_pid, ThreadInit {})?;
|
||||
ss.switch_to_thread(new_pid, None)
|
||||
})
|
||||
.unwrap();
|
||||
if new_pid != PID::new(1).unwrap() {
|
||||
SystemServices::with_mut(|ss| {
|
||||
ss.create_thread(new_pid, ThreadInit {})?;
|
||||
ss.switch_to_thread(new_pid, None)
|
||||
})
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
ThreadMessage::SysCall(pid, thread_id, call) => {
|
||||
// println!("KERNEL({}): Received syscall {:?}", pid, call);
|
||||
|
|
|
|||
|
|
@ -125,9 +125,7 @@ impl Process {
|
|||
let pid = unsafe { PROCESS_TABLE.current };
|
||||
let hardware_pid = (riscv::register::satp::read().bits() >> 22) & ((1 << 9) - 1);
|
||||
assert!((pid.get() as usize) == hardware_pid);
|
||||
Process {
|
||||
pid,
|
||||
}
|
||||
Process { pid }
|
||||
}
|
||||
|
||||
/// 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.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"))]
|
||||
{
|
||||
|
|
@ -331,7 +332,11 @@ impl Process {
|
|||
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) };
|
||||
// Create the new context and set it to run in the new address space.
|
||||
let pid = self.pid.get();
|
||||
|
|
@ -343,7 +348,7 @@ impl Process {
|
|||
entrypoint,
|
||||
setup.stack.as_ptr() as usize + setup.stack.len(),
|
||||
EXIT_THREAD,
|
||||
&[setup.arg.map(|x| x.get() as usize).unwrap_or_default()],
|
||||
&[setup.arg1, setup.arg2, setup.arg3, setup.arg4],
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
|
@ -364,27 +369,45 @@ impl Process {
|
|||
);
|
||||
println!(
|
||||
"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!(
|
||||
"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!(
|
||||
"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!(
|
||||
"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!(
|
||||
"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!(
|
||||
"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(
|
||||
unsafe { core::mem::transmute::<usize, _>(init.entrypoint) },
|
||||
MemoryRange::new(init.sp, crate::arch::process::DEFAULT_STACK_SIZE).unwrap(),
|
||||
MemoryAddress::new(pid),
|
||||
[0u8; 12],
|
||||
pid,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -185,7 +185,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
|
|||
|
||||
if blocking && cfg!(baremetal) {
|
||||
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)))
|
||||
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
|
||||
} 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 ppid = process.ppid;
|
||||
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))
|
||||
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
|
||||
} else {
|
||||
|
|
@ -260,6 +260,8 @@ fn return_memory(
|
|||
in_irq: bool,
|
||||
sender: MessageSender,
|
||||
buf: MemoryRange,
|
||||
offset: Option<MemorySize>,
|
||||
valid: Option<MemorySize>,
|
||||
) -> SysCallResult {
|
||||
SystemServices::with_mut(|ss| {
|
||||
let sender = SenderID::from(sender);
|
||||
|
|
@ -339,7 +341,7 @@ fn return_memory(
|
|||
// print!(" [waking up PID {}:{}]", client_pid, client_tid);
|
||||
ss.ready_thread(client_pid, 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
|
||||
Ok(xous_kernel::Result::Ok)
|
||||
|
|
@ -352,7 +354,7 @@ fn return_memory(
|
|||
// Switch to the client
|
||||
ss.ready_thread(client_pid, 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)
|
||||
.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::ReturnScalar2(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);}
|
||||
// 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
|
||||
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 last_time: u64 = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap();
|
||||
|
|
|
|||
|
|
@ -7,7 +7,8 @@ use core::convert::TryFrom;
|
|||
|
||||
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 status_gid: Gid = Gid::new(canvas_gid);
|
||||
if debug1{info!("GAM|status: my canvas {:?}", status_gid)};
|
||||
|
|
@ -114,4 +115,4 @@ pub fn status_thread(canvas_gid: [u32; 4]) {
|
|||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,18 +1,14 @@
|
|||
#![cfg_attr(target_os = "none", no_std)]
|
||||
#![cfg_attr(target_os = "none", no_main)]
|
||||
|
||||
fn sleep_loop(sleep_ms: usize) {
|
||||
let ticktimer_server_id = xous::SID::from_bytes(b"ticktimer-server").unwrap();
|
||||
let ticktimer_conn = xous::connect(ticktimer_server_id).unwrap();
|
||||
const EXTRA_KEY: usize = 42;
|
||||
|
||||
fn sleep_loop_4(sleep_ms: usize, conn: usize, pid: usize, extra: usize) {
|
||||
let tid = xous::current_tid().unwrap();
|
||||
let pid = xous::current_pid().unwrap().get();
|
||||
let sleep_ms = match tid {
|
||||
2 => 3000,
|
||||
3 => 7000,
|
||||
4 => 12000,
|
||||
_ => panic!("Unknown TID/PID"),
|
||||
};
|
||||
// log::info!("My thread number is {}, sleeping 0x{:08x} ({}) ms", tid, sleep_ms, sleep_ms);
|
||||
let conn = conn as _;
|
||||
// let pid = xous::current_pid().unwrap().get();
|
||||
log::info!("My thread number is {}, sleeping 0x{:08x} ({}) ms and EXTRA: {}", tid, sleep_ms, sleep_ms, extra);
|
||||
assert_eq!(extra, EXTRA_KEY, "extra key in arg 4 didn't match -- was {}, not {}", extra, EXTRA_KEY);
|
||||
|
||||
let mut loop_count = 0;
|
||||
loop {
|
||||
|
|
@ -22,9 +18,9 @@ fn sleep_loop(sleep_ms: usize) {
|
|||
// sleep_ms,
|
||||
// loop_count
|
||||
// );
|
||||
let start_time = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap();
|
||||
ticktimer_server::sleep_ms(ticktimer_conn, sleep_ms).unwrap();
|
||||
let end_time = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap();
|
||||
let start_time = ticktimer_server::elapsed_ms(conn).unwrap();
|
||||
ticktimer_server::sleep_ms(conn, sleep_ms).unwrap();
|
||||
let end_time = ticktimer_server::elapsed_ms(conn).unwrap();
|
||||
log::info!(
|
||||
"TEST THREAD {}:{}: target {}ms, {} loops: Sleep finished (uptime: {}, took {} ms)",
|
||||
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]
|
||||
fn test_main() -> ! {
|
||||
log_server::init_wait().unwrap();
|
||||
xous::create_thread_simple(sleep_loop, 10).unwrap();
|
||||
xous::create_thread_simple(sleep_loop, 5).unwrap();
|
||||
if xous::current_pid().unwrap().get() == 6 {
|
||||
xous::create_thread_simple(sleep_loop, 2).unwrap();
|
||||
}
|
||||
let ticktimer_server_id = xous::SID::from_bytes(b"ticktimer-server").unwrap();
|
||||
let ticktimer_conn = xous::connect(ticktimer_server_id).unwrap();
|
||||
|
||||
log_server::init_wait().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 {
|
||||
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: ****************************************************************").unwrap();
|
||||
|
|
@ -331,10 +332,10 @@ fn some_main() -> ! {
|
|||
*/
|
||||
|
||||
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: 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");
|
||||
output.run();
|
||||
panic!("LOG: Exited");
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ use xous::{String, MessageEnvelope, Message, ScalarMessage};
|
|||
|
||||
use core::sync::atomic::{AtomicBool, Ordering};
|
||||
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 callback_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_SHELLCHAT).unwrap();
|
||||
|
||||
|
|
@ -29,7 +29,7 @@ pub struct CallBack {
|
|||
}
|
||||
impl CallBack {
|
||||
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 {
|
||||
state: 0,
|
||||
callbacks: 0
|
||||
|
|
@ -59,4 +59,4 @@ impl<'a> ShellCmdApi<'a> for CallBack {
|
|||
Ok(Some(ret))
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -297,6 +297,117 @@ fn xous_address() -> SocketAddr {
|
|||
.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>(
|
||||
_f: &fn(T) -> U,
|
||||
_arg: &T,
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
use crate::{MemoryAddress, MemoryRange, PID, TID};
|
||||
use crate::{MemoryRange, PID, TID};
|
||||
use core::convert::TryInto;
|
||||
|
||||
mod mem;
|
||||
|
|
@ -11,24 +11,34 @@ pub struct ProcessArgs {
|
|||
|
||||
#[derive(Debug, Clone, Copy, PartialEq)]
|
||||
pub struct ThreadInit {
|
||||
pub call: fn(data: usize) -> usize,
|
||||
/// Function pointer that accepts 0-4 arguments
|
||||
pub call: usize,
|
||||
pub stack: MemoryRange,
|
||||
pub arg: Option<MemoryAddress>,
|
||||
pub name: [u8; 12],
|
||||
pub arg1: usize,
|
||||
pub arg2: usize,
|
||||
pub arg3: usize,
|
||||
pub arg4: usize,
|
||||
// pub name: [u8; 12],
|
||||
}
|
||||
|
||||
impl ThreadInit {
|
||||
pub fn new(
|
||||
call: fn(data: usize) -> usize,
|
||||
call: usize,
|
||||
stack: MemoryRange,
|
||||
arg: Option<MemoryAddress>,
|
||||
name: [u8; 12],
|
||||
arg1: usize,
|
||||
arg2: usize,
|
||||
arg3: usize,
|
||||
arg4: usize,
|
||||
// name: [u8; 12],
|
||||
) -> Self {
|
||||
ThreadInit {
|
||||
call,
|
||||
stack,
|
||||
arg,
|
||||
name,
|
||||
arg1,
|
||||
arg2,
|
||||
arg3,
|
||||
arg4,
|
||||
// name,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -36,10 +46,13 @@ impl ThreadInit {
|
|||
impl Default for ThreadInit {
|
||||
fn default() -> Self {
|
||||
ThreadInit {
|
||||
call: unsafe { core::mem::transmute::<usize, fn(data: usize) -> usize>(4) },
|
||||
call: 1,
|
||||
stack: MemoryRange::new(4, 4).unwrap(),
|
||||
arg: None,
|
||||
name: [0; 12],
|
||||
arg1: 0,
|
||||
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 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,
|
||||
init.call as usize,
|
||||
syscall,
|
||||
init.call,
|
||||
init.stack.as_ptr() as _,
|
||||
init.stack.len(),
|
||||
init.arg.map(|x| x.get()).unwrap_or_default(),
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
init.arg1,
|
||||
init.arg2,
|
||||
init.arg3,
|
||||
init.arg4,
|
||||
]
|
||||
}
|
||||
|
||||
|
|
@ -81,18 +94,18 @@ pub fn args_to_thread(
|
|||
a2: usize,
|
||||
a3: usize,
|
||||
a4: usize,
|
||||
_a5: usize,
|
||||
_a6: usize,
|
||||
_a7: usize,
|
||||
a5: usize,
|
||||
a6: usize,
|
||||
a7: usize,
|
||||
) -> 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 {
|
||||
call,
|
||||
stack,
|
||||
arg,
|
||||
name: [0; 12],
|
||||
call: a1,
|
||||
stack: MemoryRange::new(a2, a3).map_err(|_| crate::Error::InvalidSyscall)?,
|
||||
arg1: a4,
|
||||
arg2: a5,
|
||||
arg3: a6,
|
||||
arg4: a7,
|
||||
// name: [0; 12],
|
||||
})
|
||||
}
|
||||
|
||||
|
|
@ -103,7 +116,6 @@ where
|
|||
T: Send + 'static,
|
||||
{
|
||||
todo!()
|
||||
// Ok(ThreadInit {})
|
||||
}
|
||||
|
||||
pub fn create_thread_post<F, T>(
|
||||
|
|
@ -116,29 +128,10 @@ where
|
|||
T: Send + 'static,
|
||||
{
|
||||
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 {
|
||||
todo!()
|
||||
// joiner
|
||||
// .0
|
||||
// .join()
|
||||
// .map(|_| Result::Ok)
|
||||
// .map_err(|_| crate::Error::InternalError)
|
||||
}
|
||||
|
||||
pub fn process_to_args(call: usize, init: &ProcessInit) -> [usize; 8] {
|
||||
|
|
@ -166,6 +159,129 @@ pub fn args_to_process(
|
|||
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>(
|
||||
f: &fn(T) -> U,
|
||||
arg: &T,
|
||||
|
|
@ -174,27 +290,37 @@ where
|
|||
T: Send + 'static,
|
||||
U: Send + 'static,
|
||||
{
|
||||
#[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)?;
|
||||
let start = unsafe { core::mem::transmute(*f) };
|
||||
let arg = unsafe { core::mem::transmute(arg) };
|
||||
Ok(ThreadInit::new(start, stack, Some(arg), [0; 12]))
|
||||
create_thread_n_pre(
|
||||
unsafe { core::mem::transmute(*f) },
|
||||
unsafe { core::mem::transmute(arg) },
|
||||
&0,
|
||||
&0,
|
||||
&0,
|
||||
)
|
||||
}
|
||||
|
||||
pub fn create_thread_simple_post<T, U>(
|
||||
_f: fn(T) -> U,
|
||||
_arg: T,
|
||||
_thread_id: TID,
|
||||
f: fn(T) -> U,
|
||||
arg: T,
|
||||
thread_id: TID,
|
||||
) -> core::result::Result<WaitHandle<U>, crate::Error>
|
||||
where
|
||||
T: 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
|
||||
|
|
@ -211,6 +337,36 @@ pub fn create_process_post(
|
|||
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 {
|
||||
loop {
|
||||
crate::wait_event();
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
use core::convert::TryInto;
|
||||
use core::convert::{TryFrom, TryInto};
|
||||
use core::num::{NonZeroU8, 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 {
|
||||
Message::MutableBorrow(_) => 1,
|
||||
Message::Borrow(_) => 2,
|
||||
|
|
@ -402,6 +402,57 @@ impl Message {
|
|||
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)]
|
||||
|
|
@ -567,6 +618,12 @@ pub enum Result {
|
|||
/// The message was successful but no value was returned.
|
||||
None,
|
||||
|
||||
/// Memory was returned, and more information is available.
|
||||
MemoryReturned(
|
||||
Option<MemorySize>, /* offset */
|
||||
Option<MemorySize>, /* valid */
|
||||
),
|
||||
|
||||
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::NewServerID(sid, cid) => {
|
||||
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::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) => {
|
||||
[usize::MAX, *arg1, *arg2, *arg3, *arg4, *arg5, *arg6, *arg7]
|
||||
}
|
||||
|
|
@ -679,6 +755,7 @@ impl Result {
|
|||
),
|
||||
16 => Result::WouldBlock,
|
||||
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]),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ use crate::{
|
|||
MemorySize, MemoryType, Message, MessageEnvelope, MessageSender, ProcessArgs, ProcessInit,
|
||||
Result, ScalarMessage, SysCallResult, ThreadInit, CID, PID, SID, TID,
|
||||
};
|
||||
use core::convert::TryInto;
|
||||
use core::convert::{TryFrom, TryInto};
|
||||
|
||||
// use num_derive::FromPrimitive;
|
||||
// use num_traits::FromPrimitive;
|
||||
|
|
@ -253,7 +253,12 @@ pub enum SysCall {
|
|||
TrySendMessage(CID, Message),
|
||||
|
||||
/// 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
|
||||
ReturnScalar1(MessageSender, usize),
|
||||
|
|
@ -597,13 +602,13 @@ impl SysCall {
|
|||
sc.arg4,
|
||||
],
|
||||
},
|
||||
SysCall::ReturnMemory(sender, buf) => [
|
||||
SysCall::ReturnMemory(sender, buf, offset, valid) => [
|
||||
SysCallNumber::ReturnMemory as usize,
|
||||
sender.to_usize(),
|
||||
buf.as_ptr() as usize,
|
||||
buf.len(),
|
||||
0,
|
||||
0,
|
||||
offset.map(|o| o.get()).unwrap_or_default(),
|
||||
valid.map(|v| v.get()).unwrap_or_default(),
|
||||
0,
|
||||
0,
|
||||
],
|
||||
|
|
@ -755,59 +760,15 @@ impl SysCall {
|
|||
SysCallNumber::Connect => {
|
||||
SysCall::Connect(SID::from_u32(a1 as _, a2 as _, a3 as _, a4 as _))
|
||||
}
|
||||
SysCallNumber::SendMessage => match a2 {
|
||||
1 => SysCall::SendMessage(
|
||||
a1.try_into().unwrap(),
|
||||
Message::MutableBorrow(MemoryMessage {
|
||||
id: a3,
|
||||
buf: MemoryRange::new(a4, a5)?,
|
||||
offset: MemoryAddress::new(a6),
|
||||
valid: MemorySize::new(a7),
|
||||
}),
|
||||
),
|
||||
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::SendMessage => Message::try_from((a2, a3, a4, a5, a6, a7))
|
||||
.map(|m| SysCall::SendMessage(a1.try_into().unwrap(), m))
|
||||
.unwrap_or_else(|_| SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7)),
|
||||
SysCallNumber::ReturnMemory => SysCall::ReturnMemory(
|
||||
MessageSender::from_usize(a1),
|
||||
MemoryRange::new(a2, a3)?,
|
||||
MemorySize::new(a4),
|
||||
MemorySize::new(a5),
|
||||
),
|
||||
SysCallNumber::CreateThread => {
|
||||
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(_)
|
||||
)
|
||||
}
|
||||
SysCall::ReturnMemory(_, _) => true,
|
||||
SysCall::ReturnMemory(_, _, _, _) => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
|
@ -932,7 +893,7 @@ impl SysCall {
|
|||
|
||||
/// Returns `true` if the associated syscall is returning memory
|
||||
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
|
||||
|
|
@ -944,7 +905,7 @@ impl SysCall {
|
|||
| Message::MutableBorrow(memory_message) => Some(memory_message.buf),
|
||||
_ => None,
|
||||
},
|
||||
SysCall::ReturnMemory(_, range) => Some(*range),
|
||||
SysCall::ReturnMemory(_, range, _, _) => Some(*range),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
|
@ -959,7 +920,7 @@ impl SysCall {
|
|||
| SysCall::ReturnToParent(_, _)
|
||||
| SysCall::ReturnScalar2(_, _, _)
|
||||
| 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.
|
||||
/// The `size` field must be page-aligned.
|
||||
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 {
|
||||
Ok(())
|
||||
} 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::Scalar1(a)) => Ok(Result::Scalar1(a)),
|
||||
Ok(Result::Scalar2(a, b)) => Ok(Result::Scalar2(a, b)),
|
||||
Ok(Result::MemoryReturned(offset, valid)) => Ok(Result::MemoryReturned(offset, valid)),
|
||||
Err(e) => Err(e),
|
||||
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::Scalar1(a)) => Ok(Result::Scalar1(a)),
|
||||
Ok(Result::Scalar2(a, b)) => Ok(Result::Scalar2(a, b)),
|
||||
Ok(Result::MemoryReturned(offset, valid)) => Ok(Result::MemoryReturned(offset, valid)),
|
||||
Err(e) => Err(e),
|
||||
v => panic!("Unexpected return value: {:?}", v),
|
||||
}
|
||||
|
|
@ -1314,6 +1294,10 @@ pub fn wait_event() {
|
|||
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>(
|
||||
f: fn(T) -> U,
|
||||
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.
|
||||
pub fn create_thread<F, T>(f: F) -> core::result::Result<crate::arch::WaitHandle<T>, Error>
|
||||
where
|
||||
|
|
|
|||
Loading…
Reference in a new issue