From bbe49faf65b5496d67af6a71bd07cd517644d602 Mon Sep 17 00:00:00 2001 From: Sam Leffler Date: Wed, 14 Sep 2022 19:27:18 +0000 Subject: [PATCH] sel4-sys: fix MCS-affected syscall wrappers for risv32 The seL4_Recv call (as well as related syscalls) have a different api with MCS; correct that. As part of this try splitting riscv32 into MCS- and non-MCS-files to reduce cfg usage. Bug: 247129956 Change-Id: I5f0c0e192e6b366f68b23c14ae26836b4cd14158 GitOrigin-RevId: 4f844e700cb9c13c06c0026b2ea0bd752e6e9fab --- .../src/sel4-sys/arch/riscv32.rs | 661 +++--------------- .../src/sel4-sys/arch/riscv32_mcs.rs | 437 ++++++++++++ .../src/sel4-sys/arch/riscv32_no_mcs.rs | 197 ++++++ 3 files changed, 737 insertions(+), 558 deletions(-) create mode 100644 apps/system/components/kata-os-common/src/sel4-sys/arch/riscv32_mcs.rs create mode 100644 apps/system/components/kata-os-common/src/sel4-sys/arch/riscv32_no_mcs.rs diff --git a/apps/system/components/kata-os-common/src/sel4-sys/arch/riscv32.rs b/apps/system/components/kata-os-common/src/sel4-sys/arch/riscv32.rs index 05e4a47..1af93d3 100644 --- a/apps/system/components/kata-os-common/src/sel4-sys/arch/riscv32.rs +++ b/apps/system/components/kata-os-common/src/sel4-sys/arch/riscv32.rs @@ -12,6 +12,8 @@ use static_assertions::assert_cfg; assert_cfg!(target_arch = "riscv32"); +use cfg_if::cfg_if; + pub const seL4_WordBits: usize = 32; pub const seL4_WordSizeBits: usize = 2; pub const seL4_PageBits: usize = 12; @@ -221,6 +223,14 @@ macro_rules! swinum { }; } +macro_rules! opt_assign { + ($loc:expr, $val:expr) => { + if !$loc.is_null() { + *$loc = $val; + } + }; +} + #[inline(always)] pub unsafe fn seL4_Send(dest: seL4_CPtr, msgInfo: seL4_MessageInfo) { asm!("ecall", @@ -234,14 +244,6 @@ pub unsafe fn seL4_Send(dest: seL4_CPtr, msgInfo: seL4_MessageInfo) { ); } -macro_rules! opt_assign { - ($loc:expr, $val:expr) => { - if !$loc.is_null() { - *$loc = $val; - } - }; -} - #[inline(always)] pub unsafe fn seL4_SendWithMRs( dest: seL4_CPtr, @@ -331,56 +333,6 @@ pub unsafe fn seL4_NBSendWithMRs( ); } -#[cfg(not(feature = "CONFIG_KERNEL_MCS"))] -#[inline(always)] -pub unsafe fn seL4_Reply(msgInfo: seL4_MessageInfo) { - asm!("ecall", - in("a7") swinum!(SyscallId::Reply), - in("a1") msgInfo.words[0], - in("a2") seL4_GetMR(0), - in("a3") seL4_GetMR(1), - in("a4") seL4_GetMR(2), - in("a5") seL4_GetMR(3), - ); -} - -#[cfg(not(feature = "CONFIG_KERNEL_MCS"))] -#[inline(always)] -pub unsafe fn seL4_ReplyWithMRs( - msgInfo: seL4_MessageInfo, - mr0: *mut seL4_Word, - mr1: *mut seL4_Word, - mr2: *mut seL4_Word, - mr3: *mut seL4_Word, -) { - let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); - - if !mr0.is_null() && msgInfo.get_length() > 0 { - msg0 = *mr0; - } - if !mr1.is_null() && msgInfo.get_length() > 1 { - msg1 = *mr1; - } - if !mr2.is_null() && msgInfo.get_length() > 2 { - msg2 = *mr2; - } - if !mr3.is_null() && msgInfo.get_length() > 3 { - msg3 = *mr3; - } - - asm!("ecall", - in("a7") swinum!(SyscallId::Reply), - in("a1") msgInfo.words[0], - in("a2") msg0, - in("a3") msg1, - in("a4") msg2, - in("a5") msg3, - ); -} - #[inline(always)] pub unsafe fn seL4_Signal(dest: seL4_CPtr) { let info = seL4_MessageInfo::new(0, 0, 0, 0).words[0]; @@ -391,62 +343,6 @@ pub unsafe fn seL4_Signal(dest: seL4_CPtr) { ); } -#[inline(always)] -pub unsafe fn seL4_Recv(mut src: seL4_CPtr, sender: *mut seL4_Word) -> seL4_MessageInfo { - let mut info: seL4_Word; - let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); - - asm!("ecall", - in("a7") swinum!(SyscallId::Recv), - out("a0") src, - out("a1") info, - out("a2") msg0, - out("a3") msg1, - out("a4") msg2, - out("a5") msg3, - ); - - seL4_SetMR(0, msg0); - seL4_SetMR(1, msg1); - seL4_SetMR(2, msg2); - seL4_SetMR(3, msg3); - - opt_assign!(sender, src); - - seL4_MessageInfo { words: [info] } -} - -#[inline(always)] -pub unsafe fn seL4_NBRecv(mut src: seL4_CPtr, sender: *mut seL4_Word) -> seL4_MessageInfo { - let mut info: seL4_Word; - let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); - - asm!("ecall", - in("a7") swinum!(SyscallId::NBRecv), - inout("a0") src, - out("a1") info, - out("a2") msg0, - out("a3") msg1, - out("a4") msg2, - out("a5") msg3, - ); - - seL4_SetMR(0, msg0); - seL4_SetMR(1, msg1); - seL4_SetMR(2, msg2); - seL4_SetMR(3, msg3); - - opt_assign!(sender, src); - - seL4_MessageInfo { words: [info] } -} - #[inline(always)] pub unsafe fn seL4_Call(dest: seL4_CPtr, msgInfo: seL4_MessageInfo) -> seL4_MessageInfo { let mut info: seL4_Word; @@ -519,271 +415,6 @@ pub unsafe fn seL4_CallWithMRs( seL4_MessageInfo { words: [info] } } -#[inline(always)] -pub unsafe fn seL4_ReplyRecv( - mut src: seL4_CPtr, - msgInfo: seL4_MessageInfo, - sender: *mut seL4_Word, -) -> seL4_MessageInfo { - let mut info: seL4_Word; - let mut msg0 = seL4_GetMR(0); - let mut msg1 = seL4_GetMR(1); - let mut msg2 = seL4_GetMR(2); - let mut msg3 = seL4_GetMR(3); - - asm!("ecall", - in("a7") swinum!(SyscallId::ReplyRecv), - inout("a0") src, - inout("a1") msgInfo.words[0] => info, - inout("a2") msg0, - inout("a3") msg1, - inout("a4") msg2, - inout("a5") msg3, - ); - - seL4_SetMR(0, msg0); - seL4_SetMR(1, msg1); - seL4_SetMR(2, msg2); - seL4_SetMR(3, msg3); - - opt_assign!(sender, src); - - seL4_MessageInfo { words: [info] } -} - -#[inline(always)] -pub unsafe fn seL4_ReplyRecvWithMRs( - src: seL4_CPtr, - msgInfo: seL4_MessageInfo, - sender: *mut seL4_Word, - mr0: *mut seL4_Word, - mr1: *mut seL4_Word, - mr2: *mut seL4_Word, - mr3: *mut seL4_Word, -) -> seL4_MessageInfo { - let mut info: seL4_Word; - let mut badge: seL4_Word; - let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); - if !mr0.is_null() && msgInfo.get_length() > 0 { - msg0 = *mr0; - } - if !mr1.is_null() && msgInfo.get_length() > 1 { - msg1 = *mr1; - } - if !mr2.is_null() && msgInfo.get_length() > 2 { - msg2 = *mr2; - } - if !mr3.is_null() && msgInfo.get_length() > 3 { - msg3 = *mr3; - } - - asm!("ecall", - in("a7") swinum!(SyscallId::ReplyRecv), - inout("a0") src => badge, - inout("a1") msgInfo.words[0] => info, - inout("a2") msg0, - inout("a3") msg1, - inout("a4") msg2, - inout("a5") msg3, - ); - - opt_assign!(mr0, msg0); - opt_assign!(mr1, msg1); - opt_assign!(mr2, msg2); - opt_assign!(mr3, msg3); - - opt_assign!(sender, badge); - - seL4_MessageInfo { words: [info] } -} - -#[cfg(feature = "CONFIG_KERNEL_MCS")] -#[inline(always)] -pub unsafe fn seL4_NBSendRecv( - dest: seL4_CPtr, - msgInfo: seL4_MessageInfo, - src: seL4_CPtr, - sender: *mut seL4_Word, - reply: seL4_CPtr, -) -> seL4_MessageInfo { - let mut info: seL4_Word; - let mut badge: seL4_Word; - let mut msg0 = seL4_GetMR(0); - let mut msg1 = seL4_GetMR(1); - let mut msg2 = seL4_GetMR(2); - let mut msg3 = seL4_GetMR(3); - - asm!("ecall", - in("a7") swinum!(SyscallId::NBSendRecv), - inout("a0") src => badge, - inout("a1") msgInfo.words[0] => info, - inout("a2") msg0, - inout("a3") msg1, - inout("a4") msg2, - inout("a5") msg3, - in("a6") reply, - in("t0") dest, - ); - - /* Write the message back out to memory. */ - seL4_SetMR(0, msg0); - seL4_SetMR(1, msg1); - seL4_SetMR(2, msg2); - seL4_SetMR(3, msg3); - - opt_assign!(sender, badge); - - seL4_MessageInfo { words: [info] } -} - -#[cfg(feature = "CONFIG_KERNEL_MCS")] -#[inline(always)] -pub unsafe fn seL4_NBSendRecvWithMRs( - dest: seL4_CPtr, - msgInfo: seL4_MessageInfo, - src: seL4_CPtr, - sender: *mut seL4_Word, - mr0: *mut seL4_Word, - mr1: *mut seL4_Word, - mr2: *mut seL4_Word, - mr3: *mut seL4_Word, - reply: seL4_CPtr, -) -> seL4_MessageInfo { - let mut info: seL4_Word; - let mut badge: seL4_Word; - let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); - if !mr0.is_null() && msgInfo.get_length() > 0 { - msg0 = *mr0; - } - if !mr1.is_null() && msgInfo.get_length() > 1 { - msg1 = *mr1; - } - if !mr2.is_null() && msgInfo.get_length() > 2 { - msg2 = *mr2; - } - if !mr3.is_null() && msgInfo.get_length() > 3 { - msg3 = *mr3; - } - - asm!("ecall", - in("a7") swinum!(SyscallId::NBSendRecv), - inout("a0") src => badge, - inout("a1") msgInfo.words[0] => info, - inout("a2") msg0, - inout("a3") msg1, - inout("a4") msg2, - inout("a5") msg3, - in("a6") reply, - in("t0") dest, - ); - - opt_assign!(mr0, msg0); - opt_assign!(mr1, msg1); - opt_assign!(mr2, msg2); - opt_assign!(mr3, msg3); - - opt_assign!(sender, badge); - - seL4_MessageInfo { words: [info] } -} - -#[cfg(feature = "CONFIG_KERNEL_MCS")] -#[inline(always)] -pub unsafe fn seL4_NBSendWait( - dest: seL4_CPtr, - msgInfo: seL4_MessageInfo, - src: seL4_CPtr, - sender: *mut seL4_Word, -) -> seL4_MessageInfo { - let mut info: seL4_Word; - let mut badge: seL4_Word; - let mut msg0 = seL4_GetMR(0); - let mut msg1 = seL4_GetMR(1); - let mut msg2 = seL4_GetMR(2); - let mut msg3 = seL4_GetMR(3); - - asm!("ecall", - in("a7") swinum!(SyscallId::NBSendWait), - inout("a0") src => badge, - inout("a1") msgInfo.words[0] => info, - inout("a2") msg0, - inout("a3") msg1, - inout("a4") msg2, - inout("a5") msg3, - in("a6") dest, - in("t0") 0, // XXX dest - ); - - /* Write the message back out to memory. */ - seL4_SetMR(0, msg0); - seL4_SetMR(1, msg1); - seL4_SetMR(2, msg2); - seL4_SetMR(3, msg3); - - opt_assign!(sender, badge); - - seL4_MessageInfo { words: [info] } -} - -#[cfg(feature = "CONFIG_KERNEL_MCS")] -#[inline(always)] -pub unsafe fn seL4_NBSendWaitWithMRs( - dest: seL4_CPtr, - msgInfo: seL4_MessageInfo, - src: seL4_CPtr, - sender: *mut seL4_Word, - mr0: *mut seL4_Word, - mr1: *mut seL4_Word, - mr2: *mut seL4_Word, - mr3: *mut seL4_Word, -) -> seL4_MessageInfo { - let mut info: seL4_Word; - let mut badge: seL4_Word; - let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); - if !mr0.is_null() && msgInfo.get_length() > 0 { - msg0 = *mr0; - } - if !mr1.is_null() && msgInfo.get_length() > 1 { - msg1 = *mr1; - } - if !mr2.is_null() && msgInfo.get_length() > 2 { - msg2 = *mr2; - } - if !mr3.is_null() && msgInfo.get_length() > 3 { - msg3 = *mr3; - } - - asm!("ecall", - in("a7") swinum!(SyscallId::NBSendRecv), - inout("a0") src => badge, - inout("a1") msgInfo.words[0] => info, - inout("a2") msg0, - inout("a3") msg1, - inout("a4") msg2, - inout("a5") msg3, - in("a6") dest, - in("t0") 0, // XXX does this dtrt - ); - - opt_assign!(mr0, msg0); - opt_assign!(mr1, msg1); - opt_assign!(mr2, msg2); - opt_assign!(mr3, msg3); - - opt_assign!(sender, badge); - - seL4_MessageInfo { words: [info] } -} - #[inline(always)] pub unsafe fn seL4_Yield() { asm!("ecall", @@ -792,174 +423,86 @@ pub unsafe fn seL4_Yield() { ); } -#[cfg(feature = "CONFIG_KERNEL_MCS")] -#[inline(always)] -pub unsafe fn seL4_Wait(src: seL4_CPtr, sender: *mut seL4_Word) -> seL4_MessageInfo { - let mut info: seL4_Word; - let mut badge: seL4_Word; - let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); - - asm!("ecall", - in("a7") swinum!(SyscallId::Wait), - inout("a0") src => badge, - out("a1") info, - inout("a2") msg0, - inout("a3") msg1, - inout("a4") msg2, - inout("a5") msg3, - ); - - seL4_SetMR(0, msg0); - seL4_SetMR(1, msg1); - seL4_SetMR(2, msg2); - seL4_SetMR(3, msg3); - - opt_assign!(sender, badge); - - seL4_MessageInfo { words: [info] } +cfg_if! { + if #[cfg(feature = "CONFIG_KERNEL_MCS")] { + include!("riscv32_mcs.rs"); + } else { + include!("riscv32_no_mcs.rs"); + } } -#[cfg(feature = "CONFIG_KERNEL_MCS")] -#[inline(always)] -pub unsafe fn seL4_WaitWithMRs( - src: seL4_CPtr, - sender: *mut seL4_Word, - mr0: *mut seL4_Word, - mr1: *mut seL4_Word, - mr2: *mut seL4_Word, - mr3: *mut seL4_Word, -) -> seL4_MessageInfo { - let mut info: seL4_Word; - let mut badge: seL4_Word; - let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); +cfg_if! { + if #[cfg(feature = "CONFIG_PRINTING")] { + #[inline(always)] + pub unsafe fn seL4_DebugPutChar(c: u8) { + asm!("ecall", + in("a7") swinum!(SyscallId::DebugPutChar), + in("a0") c, + options(nostack), + ); + } - asm!("ecall", - in("a7") swinum!(SyscallId::Wait), - inout("a0") src => badge, - out("a1") info, - inout("a2") msg0, - inout("a3") msg1, - inout("a4") msg2, - inout("a5") msg3, - ); + #[inline(always)] + pub unsafe fn seL4_DebugDumpScheduler() { + asm!("ecall", + in("a7") swinum!(SyscallId::DebugDumpScheduler), + options(nomem, nostack), + ); + } - opt_assign!(mr0, msg0); - opt_assign!(mr1, msg1); - opt_assign!(mr2, msg2); - opt_assign!(mr3, msg3); - - opt_assign!(sender, badge); - - seL4_MessageInfo { words: [info] } + #[inline(always)] + pub unsafe fn seL4_DebugDumpCNode(mut cap: seL4_CPtr) { + asm!("ecall", + in("a7") swinum!(SyscallId::DebugDumpCNode), + inout("a0") cap, + options(nomem, nostack), + ); + } + } // CONFIG_PRINTING } -#[cfg(feature = "CONFIG_KERNEL_MCS")] -#[inline(always)] -pub unsafe fn seL4_NBWait(src: seL4_CPtr, sender: *mut seL4_Word) -> seL4_MessageInfo { - let mut info: seL4_Word; - let mut badge: seL4_Word; - let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); - let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); +cfg_if! { + if #[cfg(feature = "CONFIG_DEBUG_BUILD")] { + #[inline(always)] + pub unsafe fn seL4_DebugHalt() { + asm!("ecall", + in("a7") swinum!(SyscallId::DebugHalt), + options(nomem, nostack), + ); + } - asm!("ecall", - in("a7") swinum!(SyscallId::NBWait), - inout("a0") src => badge, - out("a1") info, - inout("a2") msg0, - inout("a3") msg1, - inout("a4") msg2, - inout("a5") msg3, - ); + #[inline(always)] + pub unsafe fn seL4_DebugSnapshot() { + asm!("ecall", + in("a7") swinum!(SyscallId::DebugSnapshot), + options(nomem, nostack), + ); + } - seL4_SetMR(0, msg0); - seL4_SetMR(1, msg1); - seL4_SetMR(2, msg2); - seL4_SetMR(3, msg3); + #[inline(always)] + pub unsafe fn seL4_DebugCapIdentify(mut cap: seL4_CPtr) -> u32 { + asm!("ecall", + in("a7") swinum!(SyscallId::DebugCapIdentify), + inout("a0") cap, + options(nomem, nostack), + ); + cap as _ + } - opt_assign!(sender, badge); - - seL4_MessageInfo { words: [info] } -} - -#[cfg(feature = "CONFIG_PRINTING")] -#[inline(always)] -pub unsafe fn seL4_DebugPutChar(c: u8) { - asm!("ecall", - in("a7") swinum!(SyscallId::DebugPutChar), - in("a0") c, - options(nostack), - ); -} - -#[cfg(feature = "CONFIG_PRINTING")] -#[inline(always)] -pub unsafe fn seL4_DebugDumpScheduler() { - asm!("ecall", - in("a7") swinum!(SyscallId::DebugDumpScheduler), - options(nomem, nostack), - ); -} - -#[cfg(feature = "CONFIG_DEBUG_BUILD")] -#[inline(always)] -pub unsafe fn seL4_DebugHalt() { - asm!("ecall", - in("a7") swinum!(SyscallId::DebugHalt), - options(nomem, nostack), - ); -} - -#[cfg(feature = "CONFIG_DEBUG_BUILD")] -#[inline(always)] -pub unsafe fn seL4_DebugSnapshot() { - asm!("ecall", - in("a7") swinum!(SyscallId::DebugSnapshot), - options(nomem, nostack), - ); -} - -#[cfg(feature = "CONFIG_DEBUG_BUILD")] -#[inline(always)] -pub unsafe fn seL4_DebugCapIdentify(mut cap: seL4_CPtr) -> u32 { - asm!("ecall", - in("a7") swinum!(SyscallId::DebugCapIdentify), - inout("a0") cap, - options(nomem, nostack), - ); - cap as _ -} - -#[cfg(feature = "CONFIG_PRINTING")] -#[inline(always)] -pub unsafe fn seL4_DebugDumpCNode(mut cap: seL4_CPtr) { - asm!("ecall", - in("a7") swinum!(SyscallId::DebugDumpCNode), - inout("a0") cap, - options(nomem, nostack), - ); -} - -// Note: name MUST be NUL-terminated. -#[cfg(feature = "CONFIG_DEBUG_BUILD")] -#[inline(always)] -pub unsafe fn seL4_DebugNameThread(tcb: seL4_CPtr, name: &[u8]) { - core::ptr::copy_nonoverlapping( - name.as_ptr() as *mut u8, - (&mut (*seL4_GetIPCBuffer()).msg).as_mut_ptr() as *mut u8, - name.len(), - ); - asm!("ecall", - in("a7") swinum!(SyscallId::DebugNameThread), - in("a0") tcb, - ); + // Note: name MUST be NUL-terminated. + #[inline(always)] + pub unsafe fn seL4_DebugNameThread(tcb: seL4_CPtr, name: &[u8]) { + core::ptr::copy_nonoverlapping( + name.as_ptr() as *mut u8, + (&mut (*seL4_GetIPCBuffer()).msg).as_mut_ptr() as *mut u8, + name.len(), + ); + asm!("ecall", + in("a7") swinum!(SyscallId::DebugNameThread), + in("a0") tcb, + ); + } + } // CONFIG_DEBUG_BUILD } #[cfg(feature = "CONFIG_DANGEROUS_CODE_INJECTION")] @@ -973,28 +516,30 @@ pub unsafe fn seL4_DebugRun(userfn: extern "C" fn(*mut u8), userarg: *mut u8) { ); } -#[cfg(feature = "CONFIG_ENABLE_BENCHMARKS")] -#[inline(always)] -pub unsafe fn seL4_BenchmarkResetLog() { - asm!("ecall", - in("a7") swinum!(SyscallId::BenchmarkResetLog), - options(nomem, nostack), - ); -} +cfg_if! { + if #[cfg(feature = "CONFIG_ENABLE_BENCHMARKS")] { + #[inline(always)] + pub unsafe fn seL4_BenchmarkResetLog() { + asm!("ecall", + in("a7") swinum!(SyscallId::BenchmarkResetLog), + options(nomem, nostack), + ); + } -#[cfg(feature = "CONFIG_ENABLE_BENCHMARKS")] -#[inline(always)] -pub unsafe fn seL4_BenchmarkFinalizeLog() { - asm!("ecall", - in("a7") swinum!(SyscallId::BenchmarkFinalizeLog), - options(nomem, nostack), - ); -} + #[inline(always)] + pub unsafe fn seL4_BenchmarkFinalizeLog() { + asm!("ecall", + in("a7") swinum!(SyscallId::BenchmarkFinalizeLog), + options(nomem, nostack), + ); + } -// TODO(sleffler): seL4_BenchmarkSetLogBuffer -// TODO(sleffler): seL4_BenchmarkNullSyscall -// TODO(sleffler): seL4_BenchmarkFlushCaches -// TODO(sleffler): seL4_BenchmarkFlushL1Caches + // TODO(sleffler): seL4_BenchmarkSetLogBuffer + // TODO(sleffler): seL4_BenchmarkNullSyscall + // TODO(sleffler): seL4_BenchmarkFlushCaches + // TODO(sleffler): seL4_BenchmarkFlushL1Caches + } // CONFIG_ENABLE_BENCHMARKS +} #[cfg(feature = "CONFIG_SET_TLS_BASE_SELF")] pub unsafe fn seL4_SetTLSBase(tls_base: seL4_Word) { diff --git a/apps/system/components/kata-os-common/src/sel4-sys/arch/riscv32_mcs.rs b/apps/system/components/kata-os-common/src/sel4-sys/arch/riscv32_mcs.rs new file mode 100644 index 0000000..08e626e --- /dev/null +++ b/apps/system/components/kata-os-common/src/sel4-sys/arch/riscv32_mcs.rs @@ -0,0 +1,437 @@ +/* + * Copyright 2015, Killian Coddington + * Copyright 2014, NICTA + * + * This software may be distributed and modified according to the terms of + * the BSD 2-Clause license. Note that NO WARRANTY is provided. + * See "LICENSE_BSD2.txt" for details. + * + * @TAG(NICTA_BSD) + */ + +assert_cfg!(feature = "CONFIG_KERNEL_MCS"); + +#[inline(always)] +pub unsafe fn seL4_Recv( + mut src: seL4_CPtr, + sender: *mut seL4_Word, + reply: seL4_CPtr, +) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); + + asm!("ecall", + in("a7") swinum!(SyscallId::Recv), + inout("a0") src, + out("a1") info, + out("a2") msg0, + out("a3") msg1, + out("a4") msg2, + out("a5") msg3, + in("a6") reply, + ); + + seL4_SetMR(0, msg0); + seL4_SetMR(1, msg1); + seL4_SetMR(2, msg2); + seL4_SetMR(3, msg3); + + opt_assign!(sender, src); + + seL4_MessageInfo { words: [info] } +} + +#[inline(always)] +pub unsafe fn seL4_NBRecv( + mut src: seL4_CPtr, + sender: *mut seL4_Word, + reply: seL4_CPtr, +) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); + + asm!("ecall", + in("a7") swinum!(SyscallId::NBRecv), + inout("a0") src, + out("a1") info, + out("a2") msg0, + out("a3") msg1, + out("a4") msg2, + out("a5") msg3, + in("a6") reply, + ); + + seL4_SetMR(0, msg0); + seL4_SetMR(1, msg1); + seL4_SetMR(2, msg2); + seL4_SetMR(3, msg3); + + opt_assign!(sender, src); + + seL4_MessageInfo { words: [info] } +} + +#[inline(always)] +pub unsafe fn seL4_Wait(src: seL4_CPtr, sender: *mut seL4_Word) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut badge: seL4_Word; + let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); + + asm!("ecall", + in("a7") swinum!(SyscallId::Wait), + inout("a0") src => badge, + out("a1") info, + inout("a2") msg0, + inout("a3") msg1, + inout("a4") msg2, + inout("a5") msg3, + ); + + seL4_SetMR(0, msg0); + seL4_SetMR(1, msg1); + seL4_SetMR(2, msg2); + seL4_SetMR(3, msg3); + + opt_assign!(sender, badge); + + seL4_MessageInfo { words: [info] } +} + +#[inline(always)] +pub unsafe fn seL4_WaitWithMRs( + src: seL4_CPtr, + sender: *mut seL4_Word, + mr0: *mut seL4_Word, + mr1: *mut seL4_Word, + mr2: *mut seL4_Word, + mr3: *mut seL4_Word, +) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut badge: seL4_Word; + let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); + + asm!("ecall", + in("a7") swinum!(SyscallId::Wait), + inout("a0") src => badge, + out("a1") info, + inout("a2") msg0, + inout("a3") msg1, + inout("a4") msg2, + inout("a5") msg3, + ); + + opt_assign!(mr0, msg0); + opt_assign!(mr1, msg1); + opt_assign!(mr2, msg2); + opt_assign!(mr3, msg3); + + opt_assign!(sender, badge); + + seL4_MessageInfo { words: [info] } +} + +#[inline(always)] +pub unsafe fn seL4_NBWait(src: seL4_CPtr, sender: *mut seL4_Word) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut badge: seL4_Word; + let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); + + asm!("ecall", + in("a7") swinum!(SyscallId::NBWait), + inout("a0") src => badge, + out("a1") info, + inout("a2") msg0, + inout("a3") msg1, + inout("a4") msg2, + inout("a5") msg3, + ); + + seL4_SetMR(0, msg0); + seL4_SetMR(1, msg1); + seL4_SetMR(2, msg2); + seL4_SetMR(3, msg3); + + opt_assign!(sender, badge); + + seL4_MessageInfo { words: [info] } +} + +#[inline(always)] +pub unsafe fn seL4_NBSendRecv( + dest: seL4_CPtr, + msgInfo: seL4_MessageInfo, + src: seL4_CPtr, + sender: *mut seL4_Word, + reply: seL4_CPtr, +) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut badge: seL4_Word; + let mut msg0 = seL4_GetMR(0); + let mut msg1 = seL4_GetMR(1); + let mut msg2 = seL4_GetMR(2); + let mut msg3 = seL4_GetMR(3); + + asm!("ecall", + in("a7") swinum!(SyscallId::NBSendRecv), + inout("a0") src => badge, + inout("a1") msgInfo.words[0] => info, + inout("a2") msg0, + inout("a3") msg1, + inout("a4") msg2, + inout("a5") msg3, + in("a6") reply, + in("t0") dest, + ); + + /* Write the message back out to memory. */ + seL4_SetMR(0, msg0); + seL4_SetMR(1, msg1); + seL4_SetMR(2, msg2); + seL4_SetMR(3, msg3); + + opt_assign!(sender, badge); + + seL4_MessageInfo { words: [info] } +} + +#[inline(always)] +pub unsafe fn seL4_NBSendRecvWithMRs( + dest: seL4_CPtr, + msgInfo: seL4_MessageInfo, + src: seL4_CPtr, + sender: *mut seL4_Word, + mr0: *mut seL4_Word, + mr1: *mut seL4_Word, + mr2: *mut seL4_Word, + mr3: *mut seL4_Word, + reply: seL4_CPtr, +) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut badge: seL4_Word; + let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); + if !mr0.is_null() && msgInfo.get_length() > 0 { + msg0 = *mr0; + } + if !mr1.is_null() && msgInfo.get_length() > 1 { + msg1 = *mr1; + } + if !mr2.is_null() && msgInfo.get_length() > 2 { + msg2 = *mr2; + } + if !mr3.is_null() && msgInfo.get_length() > 3 { + msg3 = *mr3; + } + + asm!("ecall", + in("a7") swinum!(SyscallId::NBSendRecv), + inout("a0") src => badge, + inout("a1") msgInfo.words[0] => info, + inout("a2") msg0, + inout("a3") msg1, + inout("a4") msg2, + inout("a5") msg3, + in("a6") reply, + in("t0") dest, + ); + + opt_assign!(mr0, msg0); + opt_assign!(mr1, msg1); + opt_assign!(mr2, msg2); + opt_assign!(mr3, msg3); + + opt_assign!(sender, badge); + + seL4_MessageInfo { words: [info] } +} + +#[inline(always)] +pub unsafe fn seL4_NBSendWait( + dest: seL4_CPtr, + msgInfo: seL4_MessageInfo, + src: seL4_CPtr, + sender: *mut seL4_Word, +) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut badge: seL4_Word; + let mut msg0 = seL4_GetMR(0); + let mut msg1 = seL4_GetMR(1); + let mut msg2 = seL4_GetMR(2); + let mut msg3 = seL4_GetMR(3); + + asm!("ecall", + in("a7") swinum!(SyscallId::NBSendWait), + inout("a0") src => badge, + inout("a1") msgInfo.words[0] => info, + inout("a2") msg0, + inout("a3") msg1, + inout("a4") msg2, + inout("a5") msg3, + in("a6") dest, + in("t0") 0, // XXX dest + ); + + /* Write the message back out to memory. */ + seL4_SetMR(0, msg0); + seL4_SetMR(1, msg1); + seL4_SetMR(2, msg2); + seL4_SetMR(3, msg3); + + opt_assign!(sender, badge); + + seL4_MessageInfo { words: [info] } +} + +#[inline(always)] +pub unsafe fn seL4_NBSendWaitWithMRs( + dest: seL4_CPtr, + msgInfo: seL4_MessageInfo, + src: seL4_CPtr, + sender: *mut seL4_Word, + mr0: *mut seL4_Word, + mr1: *mut seL4_Word, + mr2: *mut seL4_Word, + mr3: *mut seL4_Word, +) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut badge: seL4_Word; + let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); + if !mr0.is_null() && msgInfo.get_length() > 0 { + msg0 = *mr0; + } + if !mr1.is_null() && msgInfo.get_length() > 1 { + msg1 = *mr1; + } + if !mr2.is_null() && msgInfo.get_length() > 2 { + msg2 = *mr2; + } + if !mr3.is_null() && msgInfo.get_length() > 3 { + msg3 = *mr3; + } + + asm!("ecall", + in("a7") swinum!(SyscallId::NBSendRecv), + inout("a0") src => badge, + inout("a1") msgInfo.words[0] => info, + inout("a2") msg0, + inout("a3") msg1, + inout("a4") msg2, + inout("a5") msg3, + in("a6") dest, + in("t0") 0, // XXX does this dtrt + ); + + opt_assign!(mr0, msg0); + opt_assign!(mr1, msg1); + opt_assign!(mr2, msg2); + opt_assign!(mr3, msg3); + + opt_assign!(sender, badge); + + seL4_MessageInfo { words: [info] } +} + +#[inline(always)] +pub unsafe fn seL4_ReplyRecv( + mut src: seL4_CPtr, + msgInfo: seL4_MessageInfo, + sender: *mut seL4_Word, + reply: seL4_CPtr, +) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut msg0 = seL4_GetMR(0); + let mut msg1 = seL4_GetMR(1); + let mut msg2 = seL4_GetMR(2); + let mut msg3 = seL4_GetMR(3); + + asm!("ecall", + in("a7") swinum!(SyscallId::ReplyRecv), + inout("a0") src, + inout("a1") msgInfo.words[0] => info, + inout("a2") msg0, + inout("a3") msg1, + inout("a4") msg2, + inout("a5") msg3, + in("a6") reply, + ); + + seL4_SetMR(0, msg0); + seL4_SetMR(1, msg1); + seL4_SetMR(2, msg2); + seL4_SetMR(3, msg3); + + opt_assign!(sender, src); + + seL4_MessageInfo { words: [info] } +} + +#[inline(always)] +pub unsafe fn seL4_ReplyRecvWithMRs( + src: seL4_CPtr, + msgInfo: seL4_MessageInfo, + sender: *mut seL4_Word, + mr0: *mut seL4_Word, + mr1: *mut seL4_Word, + mr2: *mut seL4_Word, + mr3: *mut seL4_Word, + reply: seL4_CPtr, +) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut badge: seL4_Word; + let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); + if !mr0.is_null() && msgInfo.get_length() > 0 { + msg0 = *mr0; + } + if !mr1.is_null() && msgInfo.get_length() > 1 { + msg1 = *mr1; + } + if !mr2.is_null() && msgInfo.get_length() > 2 { + msg2 = *mr2; + } + if !mr3.is_null() && msgInfo.get_length() > 3 { + msg3 = *mr3; + } + + asm!("ecall", + in("a7") swinum!(SyscallId::ReplyRecv), + inout("a0") src => badge, + inout("a1") msgInfo.words[0] => info, + inout("a2") msg0, + inout("a3") msg1, + inout("a4") msg2, + inout("a5") msg3, + in("a6") reply, + ); + + opt_assign!(mr0, msg0); + opt_assign!(mr1, msg1); + opt_assign!(mr2, msg2); + opt_assign!(mr3, msg3); + + opt_assign!(sender, badge); + + seL4_MessageInfo { words: [info] } +} diff --git a/apps/system/components/kata-os-common/src/sel4-sys/arch/riscv32_no_mcs.rs b/apps/system/components/kata-os-common/src/sel4-sys/arch/riscv32_no_mcs.rs new file mode 100644 index 0000000..cec68d8 --- /dev/null +++ b/apps/system/components/kata-os-common/src/sel4-sys/arch/riscv32_no_mcs.rs @@ -0,0 +1,197 @@ +/* + * Copyright 2015, Killian Coddington + * Copyright 2014, NICTA + * + * This software may be distributed and modified according to the terms of + * the BSD 2-Clause license. Note that NO WARRANTY is provided. + * See "LICENSE_BSD2.txt" for details. + * + * @TAG(NICTA_BSD) + */ + +assert_cfg!(not(feature = "CONFIG_KERNEL_MCS")); + +#[inline(always)] +pub unsafe fn seL4_Reply(msgInfo: seL4_MessageInfo) { + asm!("ecall", + in("a7") swinum!(SyscallId::Reply), + in("a1") msgInfo.words[0], + in("a2") seL4_GetMR(0), + in("a3") seL4_GetMR(1), + in("a4") seL4_GetMR(2), + in("a5") seL4_GetMR(3), + ); +} + +#[inline(always)] +pub unsafe fn seL4_ReplyWithMRs( + msgInfo: seL4_MessageInfo, + mr0: *mut seL4_Word, + mr1: *mut seL4_Word, + mr2: *mut seL4_Word, + mr3: *mut seL4_Word, +) { + let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); + + if !mr0.is_null() && msgInfo.get_length() > 0 { + msg0 = *mr0; + } + if !mr1.is_null() && msgInfo.get_length() > 1 { + msg1 = *mr1; + } + if !mr2.is_null() && msgInfo.get_length() > 2 { + msg2 = *mr2; + } + if !mr3.is_null() && msgInfo.get_length() > 3 { + msg3 = *mr3; + } + + asm!("ecall", + in("a7") swinum!(SyscallId::Reply), + in("a1") msgInfo.words[0], + in("a2") msg0, + in("a3") msg1, + in("a4") msg2, + in("a5") msg3, + ); +} + +#[inline(always)] +pub unsafe fn seL4_Recv(mut src: seL4_CPtr, sender: *mut seL4_Word) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); + + asm!("ecall", + in("a7") swinum!(SyscallId::Recv), + inout("a0") src, + out("a1") info, + out("a2") msg0, + out("a3") msg1, + out("a4") msg2, + out("a5") msg3, + ); + + seL4_SetMR(0, msg0); + seL4_SetMR(1, msg1); + seL4_SetMR(2, msg2); + seL4_SetMR(3, msg3); + + opt_assign!(sender, src); + + seL4_MessageInfo { words: [info] } +} + +#[inline(always)] +pub unsafe fn seL4_NBRecv(mut src: seL4_CPtr, sender: *mut seL4_Word) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); + + asm!("ecall", + in("a7") swinum!(SyscallId::NBRecv), + inout("a0") src, + out("a1") info, + out("a2") msg0, + out("a3") msg1, + out("a4") msg2, + out("a5") msg3, + ); + + seL4_SetMR(0, msg0); + seL4_SetMR(1, msg1); + seL4_SetMR(2, msg2); + seL4_SetMR(3, msg3); + + opt_assign!(sender, src); + + seL4_MessageInfo { words: [info] } +} + +#[inline(always)] +pub unsafe fn seL4_ReplyRecv( + mut src: seL4_CPtr, + msgInfo: seL4_MessageInfo, + sender: *mut seL4_Word, +) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut msg0 = seL4_GetMR(0); + let mut msg1 = seL4_GetMR(1); + let mut msg2 = seL4_GetMR(2); + let mut msg3 = seL4_GetMR(3); + + asm!("ecall", + in("a7") swinum!(SyscallId::ReplyRecv), + inout("a0") src, + inout("a1") msgInfo.words[0] => info, + inout("a2") msg0, + inout("a3") msg1, + inout("a4") msg2, + inout("a5") msg3, + ); + + seL4_SetMR(0, msg0); + seL4_SetMR(1, msg1); + seL4_SetMR(2, msg2); + seL4_SetMR(3, msg3); + + opt_assign!(sender, src); + + seL4_MessageInfo { words: [info] } +} + +#[inline(always)] +pub unsafe fn seL4_ReplyRecvWithMRs( + src: seL4_CPtr, + msgInfo: seL4_MessageInfo, + sender: *mut seL4_Word, + mr0: *mut seL4_Word, + mr1: *mut seL4_Word, + mr2: *mut seL4_Word, + mr3: *mut seL4_Word, +) -> seL4_MessageInfo { + let mut info: seL4_Word; + let mut badge: seL4_Word; + let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); + let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); + if !mr0.is_null() && msgInfo.get_length() > 0 { + msg0 = *mr0; + } + if !mr1.is_null() && msgInfo.get_length() > 1 { + msg1 = *mr1; + } + if !mr2.is_null() && msgInfo.get_length() > 2 { + msg2 = *mr2; + } + if !mr3.is_null() && msgInfo.get_length() > 3 { + msg3 = *mr3; + } + + asm!("ecall", + in("a7") swinum!(SyscallId::ReplyRecv), + inout("a0") src => badge, + inout("a1") msgInfo.words[0] => info, + inout("a2") msg0, + inout("a3") msg1, + inout("a4") msg2, + inout("a5") msg3, + ); + + opt_assign!(mr0, msg0); + opt_assign!(mr1, msg1); + opt_assign!(mr2, msg2); + opt_assign!(mr3, msg3); + + opt_assign!(sender, badge); + + seL4_MessageInfo { words: [info] } +}