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

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

View file

@ -522,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);

View file

@ -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]
);
}

File diff suppressed because it is too large Load diff

View file

@ -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,
));
}
}

View file

@ -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)

View file

@ -224,7 +224,8 @@ fn xmain() -> ! {
if debugc{info!("GAM: chatlayout made st {:?} co {:?} pr {:?} in {:?}", chatlayout.status, chatlayout.content, chatlayout.predictive, chatlayout.input);}
// 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();

View file

@ -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]) {
}
}
}
}

View file

@ -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;
}
}

View file

@ -224,7 +224,8 @@ fn handle_scalar(
}
}
fn reader_thread(mut output: implementation::OutputWriter) {
fn reader_thread(arg: usize) {
let mut output = unsafe { &mut *(arg as *mut implementation::OutputWriter) };
writeln!(output, "LOG: Xous Logging Server starting up...").unwrap();
writeln!(output, "LOG: ****************************************************************").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");

View file

@ -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))
}
}
}

View file

@ -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,

View file

@ -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();

View file

@ -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]),
}
}

View file

@ -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