metta-systems
/
vesper
1
1
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

[wip] api messing

This commit is contained in:
Berkus Decker 2021-01-21 12:20:37 +02:00
parent f842a467e4
commit deabc2ae70
1 changed files with 41 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
nucleus/src/api.rs
View File

@ -8,54 +8,42 @@
//! Arch-specific kernel ABI decodes syscall invocations and calls API functions to perform actual //! Arch-specific kernel ABI decodes syscall invocations and calls API functions to perform actual
//! operations. //! operations.
use { use vesper_user::SysCall as SysCall;
vesper_user::SysCall as SysCall,
crate::println,
snafu::Snafu,
crate::arch,
crate::arch::memory::{PhysAddr, VirtAddr},
crate::objects::thread::ThreadState,
crate::caps::{ReplyCapability, NullCapability},
core::result::Result, // temp: use own result type here
crate::platform::rpi3::gic::get_active_irq, // temp: derive based on current platform
crate::objects::thread::TCB,
crate::caps::captable::CapPath,
};
// Syscalls (kernel API) // Syscalls (kernel API)
trait API { trait API {
// Three below (send, nb_send, call) are "invocation" syscalls. // Three below (send, nb_send, call) are "invocation" syscalls.
// fn send(cap: Cap, msg_info: MessageInfo); fn send(cap: Cap, msg_info: MessageInfo);
// fn nb_send(dest: Cap, msg_info: MessageInfo); fn nb_send(dest: Cap, msg_info: MessageInfo);
// fn call(cap: Cap, msg_info: MessageInfo) -> Result<(MessageInfo, Option<&Badge>)>; fn call(cap: Cap, msg_info: MessageInfo) -> Result<(MessageInfo, Option<&Badge>)>;
// Wait for message, when it is received, // Wait for message, when it is received,
// return object Badge and block caller on `reply`. // return object Badge and block caller on `reply`.
// fn recv(src: Cap, reply: Cap) -> Result<(MessageInfo, Option<&Badge>)>; fn recv(src: Cap, reply: Cap) -> Result<(MessageInfo, Option<&Badge>)>;
// fn reply(msg_info: MessageInfo); fn reply(msg_info: MessageInfo);
// As Recv but invoke `reply` first. // As Recv but invoke `reply` first.
// fn reply_recv( fn reply_recv(
// src: Cap, src: Cap,
// reply: Cap, reply: Cap,
// msg_info: MessageInfo, msg_info: MessageInfo,
// ) -> Result<(MessageInfo, Option<&Badge>)>; ) -> Result<(MessageInfo, Option<&Badge>)>;
// fn nb_recv(src: Cap) -> Result<(MessageInfo, Option<&Badge>)>; fn nb_recv(src: Cap) -> Result<(MessageInfo, Option<&Badge>)>;
// fn r#yield(); fn r#yield();
// -- end of default seL4 syscall list -- // -- end of default seL4 syscall list --
// As ReplyRecv but invoke `dest` not `reply`. // As ReplyRecv but invoke `dest` not `reply`.
// fn nb_send_recv( fn nb_send_recv(
// dest: Cap, dest: Cap,
// msg_info: MessageInfo, msg_info: MessageInfo,
// src: Cap, src: Cap,
// reply: Cap, reply: Cap,
// ) -> Result<(MessageInfo, Options<&Badge>)>; ) -> Result<(MessageInfo, Options<&Badge>)>;
// As NBSendRecv, with no reply. Donation is not possible. // As NBSendRecv, with no reply. Donation is not possible.
// fn nb_send_wait( fn nb_send_wait(
// cap: Cap, cap: Cap,
// msg_info: MessageInfo, msg_info: MessageInfo,
// src: Cap, src: Cap,
// ) -> Result<(MessageInfo, Option<&Badge>)>; ) -> Result<(MessageInfo, Option<&Badge>)>;
// As per Recv, but donation not possible. // As per Recv, but donation not possible.
// fn wait(src: Cap) -> Result<(MessageInfo, Option<&Badge>)>; fn wait(src: Cap) -> Result<(MessageInfo, Option<&Badge>)>;
// Plus some debugging calls... // Plus some debugging calls...
} }
@ -104,20 +92,6 @@ fn handle_syscall(syscall: SysCall) -> Result<()> {
Ok(()) Ok(())
} }
fn handle_interrupt(int: u16) -> Result<()> {
Ok(())
}
// some kernel globals
static KernelCurrentThread: &TCB = Default::default(); // @todo Scheduler.CurrentThread
static KernelCurrentFault: Fault = Fault::NoFault;
static KernelSchedulerAction: SchedulerAction = SchedulerAction::None;
static KernelDomainTime: usize = 100; // @todo Scheduler.DomainTime
const msgInfoRegister: usize = 1; // @todo wip number
const capRegister: usize = 2;
const n_MsgRegisters: usize = 2;
// end kernel globals
fn handle_invocation(is_call: bool, is_blocking: bool) -> Result<()> { fn handle_invocation(is_call: bool, is_blocking: bool) -> Result<()> {
let thread: &TCB = KernelCurrentThread; let thread: &TCB = KernelCurrentThread;
@ -125,7 +99,7 @@ fn handle_invocation(is_call: bool, is_blocking: bool) -> Result<()> {
let info: MessageInfo = messageInfoFromWord(infoRegister); let info: MessageInfo = messageInfoFromWord(infoRegister);
let cap_ptr: CapPath = thread.get_register(capRegister); let cap_ptr: CapPath = thread.get_register(capRegister);
let result = thread.lookup_cap_and_slot(cap_ptr); result = thread.lookup_cap_and_slot(cap_ptr);
if result.is_err() { if result.is_err() {
println!( println!(
@ -201,31 +175,29 @@ fn handle_invocation(is_call: bool, is_blocking: bool) -> Result<()> {
Ok(()) Ok(())
} }
fn handle_receive(is_blocking: bool) -> Result<()> { fn handle_receive(is_blocking: bool) {
let endpoint_cap_ptr = KernelCurrentThread.get_register(capRegister); let endpoint_cap_ptr = KernelCurrentThread.get_register(capRegister);
let result = KernelCurrentThread.lookup_cap(endpoint_cap_ptr); let result = KernelCurrentThread.lookup_cap(endpoint_cap_ptr);
if result.is_err() { if result.is_err() {
// KernelCurrentFault = Fault_CapFault::new(endpoint_cap_ptr, true); KernelCurrentFault = Fault_CapFault::new(endpoint_cap_ptr, true);
handle_fault(KernelCurrentThread); handle_fault(KernelCurrentThread);
return Ok(()); return Ok(());
} }
match result.capability.get_type() { match result.cap.get_type() {
endpoint => Ok(()), endpoint => ,
notification => Ok(()), notification => ,
_ => Ok(()), //fault, _ => fault,
} }
} }
fn handle_reply() { fn handle_reply() {
let caller_slot = KernelCurrentThread.get_caller_slot(); let caller_slot = KernelCurrentThread.get_caller_slot();
let caller_cap = caller_slot.capability; let caller_cap = caller_slot.capability;
const reply_cap = ReplyCapability::Type::Type.value;
const null_cap = NullCapability::Type::Type.value;
match caller_cap.get_type() { match caller_cap.get_type() {
reply_cap => { ReplyCap::Type.value => {
// if (cap_reply_cap_get_capReplyMaster(callerCap)) { // if (cap_reply_cap_get_capReplyMaster(callerCap)) {
// break; // break;
// } // }
@ -233,7 +205,7 @@ fn handle_reply() {
// if(!(caller != ksCurThread)) _assert_fail("caller must not be the current thread", "src/api/syscall.c", 313, __FUNCTION__); // if(!(caller != ksCurThread)) _assert_fail("caller must not be the current thread", "src/api/syscall.c", 313, __FUNCTION__);
// do_reply_transfer(ksCurThread, caller, callerSlot); // do_reply_transfer(ksCurThread, caller, callerSlot);
}, },
null_cap => { NullCap::Type.value => {
println!("<<vesper[T{} \"{}\" @{}]: Attempted reply operation when no reply capability present.>>", KernelCurrentThread, KernelCurrentThread.name, KernelCurrentThread.get_restart_pc()); println!("<<vesper[T{} \"{}\" @{}]: Attempted reply operation when no reply capability present.>>", KernelCurrentThread, KernelCurrentThread.name, KernelCurrentThread.get_restart_pc());
}, },
_ => { _ => {
@ -252,8 +224,8 @@ fn handle_yield() {
#[derive(Debug, Snafu)] #[derive(Debug, Snafu)]
enum Fault { enum Fault {
#[snafu(display("no fault"))] #[snafu(display("null fault"))]
NoFault, Null,
#[snafu(display("capability fault in {} phase at address {:x}", if in_receive_phase { "receive" } else { "send" }, address))] #[snafu(display("capability fault in {} phase at address {:x}", if in_receive_phase { "receive" } else { "send" }, address))]
Capability { Capability {
in_receive_phase: bool, in_receive_phase: bool,
@ -365,13 +337,13 @@ impl Scheduler {
fn activate_thread() {} fn activate_thread() {}
fn dequeue(thread: &mut TCB) {} fn dequeue(thread: &mut TCB);
fn append(thread: &mut TCB) {} fn append(thread: &mut TCB);
fn reschedule_required() {} fn reschedule_required();
} }
struct Nucleus {} struct Nucleus {}
// impl API for Nucleus { impl API for Nucleus {
//... //...
// } }