diff --git a/apps/system/components/kata-os-common/src/sel4-sys/Cargo.toml b/apps/system/components/kata-os-common/src/sel4-sys/Cargo.toml index 80e26fc..588d640 100644 --- a/apps/system/components/kata-os-common/src/sel4-sys/Cargo.toml +++ b/apps/system/components/kata-os-common/src/sel4-sys/Cargo.toml @@ -50,8 +50,10 @@ CONFIG_BENCHMARK_TRACK_UTILISATION = [] CONFIG_HARDWARE_DEBUG_API = [] CONFIG_SET_TLS_BASE_SELF = [] CONFIG_VTX = [] +CONFIG_HAVE_FPU = [] CONFIG_ARM_SMMU = [] CONFIG_ARM_HYPERVISOR_SUPPORT = [] +CONFIG_ARM_HYP_ENABLE_VCPU_CP14_SAVE_AND_RESTORE = [] [lib] path = "lib.rs" diff --git a/apps/system/components/kata-os-common/src/sel4-sys/arch/arm.rs b/apps/system/components/kata-os-common/src/sel4-sys/arch/arm.rs index 8a9ccc7..0f6adc9 100644 --- a/apps/system/components/kata-os-common/src/sel4-sys/arch/arm.rs +++ b/apps/system/components/kata-os-common/src/sel4-sys/arch/arm.rs @@ -12,9 +12,44 @@ pub const seL4_WordBits: usize = 32; pub const seL4_PageBits: usize = 12; pub const seL4_SlotBits: usize = 4; + +#[cfg(all( + feature = "CONFIG_HAVE_FPU", + any( + all( + feature = "CONFIG_ARM_HYPERVISOR_SUPPORT", + feature = "CONFIG_ARM_HYP_ENABLE_VCPU_CP14_SAVE_AND_RESTORE" + ), + feature = "CONFIG_HARDWARE_DEBUG_API" + ) +))] +pub const seL4_TCBBits: usize = 11; +#[cfg(any( + feature = "CONFIG_HAVE_FPU", + all( + feature = "CONFIG_ARM_HYPERVISOR_SUPPORT", + feature = "CONFIG_ARM_HYP_ENABLE_VCPU_CP14_SAVE_AND_RESTORE" + ), + feature = "CONFIG_HARDWARE_DEBUG_API" +))] +pub const seL4_TCBBits: usize = 10; +#[cfg(not(any( + feature = "CONFIG_HAVE_FPU", + all( + feature = "CONFIG_ARM_HYPERVISOR_SUPPORT", + feature = "CONFIG_ARM_HYP_ENABLE_VCPU_CP14_SAVE_AND_RESTORE" + ), + feature = "CONFIG_HARDWARE_DEBUG_API" +)))] pub const seL4_TCBBits: usize = 9; + pub const seL4_EndpointBits: usize = 4; + +#[cfg(feature = "CONFIG_ARM_HYPERVISOR_SUPPORT")] +pub const seL4_PageTableBits: usize = 12; +#[cfg(not(feature = "CONFIG_ARM_HYPERVISOR_SUPPORT"))] pub const seL4_PageTableBits: usize = 10; + pub const seL4_PageDirBits: usize = 14; pub const seL4_ASIDPoolBits: usize = 12; @@ -22,8 +57,6 @@ pub const seL4_Frame_Args: usize = 4; pub const seL4_Frame_MRs: usize = 7; pub const seL4_Frame_HasNPC: usize = 0; -pub const seL4_GlobalsFrame: *mut u8 = 0xffffc000 as *mut u8; - pub type seL4_ARM_Page = seL4_CPtr; pub type seL4_ARM_PageTable = seL4_CPtr; pub type seL4_ARM_PageDirectory = seL4_CPtr; @@ -52,6 +85,8 @@ pub struct seL4_UserContext { pub r6: seL4_Word, pub r7: seL4_Word, pub r14: seL4_Word, + pub tpidrurw: seL4_Word, + pub tpidruro: seL4_Word, } #[repr(u32)] @@ -79,8 +114,8 @@ pub enum seL4_ObjectType { seL4_ARM_SmallPageObject, seL4_ARM_LargePageObject, - seL4_ARM_SectionObject, // XXX aarch32 - seL4_ARM_SuperSectionObject, // XXX aarch32 + seL4_ARM_SectionObject, + seL4_ARM_SuperSectionObject, seL4_ARM_PageTableObject, seL4_ARM_PageDirectoryObject, @@ -89,6 +124,8 @@ pub enum seL4_ObjectType { #[cfg(feature = "CONFIG_TK1_SMMU")] seL4_ARM_IOPageTableObject, + + seL4_LastObjectType, } impl From for seL4_Word { fn from(type_: seL4_ObjectType) -> seL4_Word { @@ -101,117 +138,99 @@ pub const seL4_ObjectTypeCount: isize = seL4_ObjectType::seL4_LastObjectType as #[inline(always)] pub unsafe fn seL4_GetIPCBuffer() -> *mut seL4_IPCBuffer { - *(seL4_GlobalsFrame as *mut *mut seL4_IPCBuffer) -} - -#[inline(always)] -pub unsafe fn seL4_GetTag() -> seL4_MessageInfo { - (*seL4_GetIPCBuffer()).tag -} - -#[inline(always)] -pub unsafe fn seL4_SetTag(tag: seL4_MessageInfo) { - (*seL4_GetIPCBuffer()).tag = tag; + // Use magic external symbol setup by runtime once TLS is primed + enum c_void {} + extern "C" { + #[thread_local] + static __sel4_ipc_buffer: *const c_void; + } + __sel4_ipc_buffer as *mut seL4_IPCBuffer } #[inline(always)] pub unsafe fn seL4_GetMR(regnum: usize) -> seL4_Word { - (*seL4_GetIPCBuffer()).msg[regnum] + (*seL4_GetIPCBuffer()).msg[regnum] } #[inline(always)] pub unsafe fn seL4_SetMR(regnum: usize, value: seL4_Word) { - (*seL4_GetIPCBuffer()).msg[regnum] = value; + (*seL4_GetIPCBuffer()).msg[regnum] = value; } #[inline(always)] pub unsafe fn seL4_GetUserData() -> seL4_Word { - (*seL4_GetIPCBuffer()).userData + (*seL4_GetIPCBuffer()).userData } #[inline(always)] pub unsafe fn seL4_SetUserData(data: seL4_Word) { - (*seL4_GetIPCBuffer()).userData = data; + (*seL4_GetIPCBuffer()).userData = data; } #[inline(always)] -pub unsafe fn seL4_GetBadge(index: usize) -> seL4_CapData { - let mut badge: seL4_CapData = ::core::mem::uninitialized(); - badge.set_Badge((*seL4_GetIPCBuffer()).caps_or_badges[index]); - badge +pub unsafe fn seL4_GetBadge(index: usize) -> seL4_Word { + (*seL4_GetIPCBuffer()).caps_or_badges[index] } #[inline(always)] pub unsafe fn seL4_GetCap(index: usize) -> seL4_CPtr { - (*seL4_GetIPCBuffer()).caps_or_badges[index] as seL4_CPtr + (*seL4_GetIPCBuffer()).caps_or_badges[index] as seL4_CPtr } #[inline(always)] pub unsafe fn seL4_SetCap(index: usize, cptr: seL4_CPtr) { - (*seL4_GetIPCBuffer()).caps_or_badges[index] = cptr as seL4_Word; + (*seL4_GetIPCBuffer()).caps_or_badges[index] = cptr as seL4_Word; } #[inline(always)] -pub unsafe fn seL4_GetCapReceivePath(receiveCNode: *mut seL4_CPtr, - receiveIndex: *mut seL4_CPtr, - receiveDepth: *mut seL4_Word) { +pub unsafe fn seL4_GetCapReceivePath( + receiveCNode: *mut seL4_CPtr, + receiveIndex: *mut seL4_CPtr, + receiveDepth: *mut seL4_Word, +) { let ipcbuffer = seL4_GetIPCBuffer(); if !receiveCNode.is_null() { - *receiveCNode = (*ipcbuffer).receiveCNode; + *receiveCNode = (*ipcbuffer).receiveCNode; } if !receiveIndex.is_null() { - *receiveIndex = (*ipcbuffer).receiveIndex; + *receiveIndex = (*ipcbuffer).receiveIndex; } if !receiveDepth.is_null() { - *receiveDepth = (*ipcbuffer).receiveDepth; + *receiveDepth = (*ipcbuffer).receiveDepth; } } #[inline(always)] -pub unsafe fn seL4_SetCapReceivePath(receiveCNode: seL4_CPtr, - receiveIndex: seL4_CPtr, - receiveDepth: seL4_Word) { - let ipcbuffer = seL4_GetIPCBuffer(); - (*ipcbuffer).receiveCNode = receiveCNode; - (*ipcbuffer).receiveIndex = receiveIndex; - (*ipcbuffer).receiveDepth = receiveDepth; +pub unsafe fn seL4_SetCapReceivePath( + receiveCNode: seL4_CPtr, + receiveIndex: seL4_CPtr, + receiveDepth: seL4_Word, +) { + let ipcbuffer = seL4_GetIPCBuffer(); + (*ipcbuffer).receiveCNode = receiveCNode; + (*ipcbuffer).receiveIndex = receiveIndex; + (*ipcbuffer).receiveDepth = receiveDepth; } macro_rules! swinum { - ($val:expr) => { - $val as seL4_Word & 0x00ffffff - } + ($val:expr) => { + $val as seL4_Word + }; } #[inline(always)] pub unsafe fn seL4_Send(dest: seL4_CPtr, msgInfo: seL4_MessageInfo) { - let msg0 = seL4_GetMR(0); - let msg1 = seL4_GetMR(1); - let msg2 = seL4_GetMR(2); - let msg3 = seL4_GetMR(3); - let scno = SyscallId::Send as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::Send)), - "{r0}" (dest), - "{r1}" (msgInfo.words[0]), - "{r2}" (msg0), "{r3}" (msg1), - "{r4}" (msg2), "{r5}" (msg3), - "{r7}" (scno) - : "memory", "r0", "r1", "r2", "r3", "r4", "r5", "r7" - : "volatile"); -} - -macro_rules! opt_deref { - ($name:expr) => { - if !$name.is_null() { - *$name - } else { - 0 - } - } + asm!("swi 0", + in("r7") swinum!(SyscallId::Send), + in("r0") dest, + in("r1") msgInfo.words[0], + in("r2") seL4_GetMR(0), + in("r3") seL4_GetMR(1), + in("r4") seL4_GetMR(2), + in("r5") seL4_GetMR(3), + ); } macro_rules! opt_assign { @@ -219,209 +238,175 @@ macro_rules! opt_assign { if !$loc.is_null() { *$loc = $val; } - } + }; } #[inline(always)] -pub unsafe fn seL4_SendWithMRs(dest: seL4_CPtr, msgInfo: seL4_MessageInfo, - mr0: *mut seL4_Word, mr1: *mut seL4_Word, - mr2: *mut seL4_Word, mr3: *mut seL4_Word, - ) { - let mut msg0 = ::core::mem::uninitialized(); - let mut msg1 = ::core::mem::uninitialized(); - let mut msg2 = ::core::mem::uninitialized(); - let mut msg3 = ::core::mem::uninitialized(); +pub unsafe fn seL4_SendWithMRs( + dest: seL4_CPtr, + 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; - } - let scno = SyscallId::Send as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::Send)), - "{r0}" (dest), - "{r1}" (msgInfo.words[0]), - "{r2}" (msg0), "{r3}" (msg1), - "{r4}" (msg2), "{r5}" (msg3), - "{r7}" (scno) - : "memory", "r0", "r1", "r2", "r3", "r4", "r5", "r7" - : "volatile"); + 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!("swi 0", + in("r7") swinum!(SyscallId::Send), + in("r0") dest, + in("r1") msgInfo.words[0], + in("r2") msg0, + in("r3") msg1, + in("r4") msg2, + in("r5") msg3, + ); } #[inline(always)] pub unsafe fn seL4_NBSend(dest: seL4_CPtr, msgInfo: seL4_MessageInfo) { - let msg0 = seL4_GetMR(0); - let msg1 = seL4_GetMR(1); - let msg2 = seL4_GetMR(2); - let msg3 = seL4_GetMR(3); - let scno = SyscallId::NBSend as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::NBSend)), - "{r0}" (dest), - "{r1}" (msgInfo.words[0]), - "{r2}" (msg0), "{r3}" (msg1), - "{r4}" (msg2), "{r5}" (msg3), - "{r7}" (scno) - : "memory", "r0", "r1", "r2", "r3", "r4", "r5", "r7" - : "volatile"); + asm!("swi 0", + in("r7") swinum!(SyscallId::NBSend), + in("r0") dest, + in("r1") msgInfo.words[0], + in("r2") seL4_GetMR(0), + in("r3") seL4_GetMR(1), + in("r4") seL4_GetMR(2), + in("r5") seL4_GetMR(3), + ); } + #[inline(always)] -pub unsafe fn seL4_NBSendWithMRs(dest: seL4_CPtr, msgInfo: seL4_MessageInfo, - mr0: *mut seL4_Word, mr1: *mut seL4_Word, - mr2: *mut seL4_Word, mr3: *mut seL4_Word, - ) { - let mut msg0 = ::core::mem::uninitialized(); - let mut msg1 = ::core::mem::uninitialized(); - let mut msg2 = ::core::mem::uninitialized(); - let mut msg3 = ::core::mem::uninitialized(); +pub unsafe fn seL4_NBSendWithMRs( + dest: seL4_CPtr, + 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; - } - let scno = SyscallId::NBSend as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::NBSend)), - "{r0}" (dest), - "{r1}" (msgInfo.words[0]), - "{r2}" (msg0), "{r3}" (msg1), - "{r4}" (msg2), "{r5}" (msg3), - "{r7}" (scno) - : "memory", "r0", "r1", "r2", "r3", "r4", "r5", "r7" - : "volatile"); + 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!("swi 0", + in("r7") swinum!(SyscallId::NBSend), + in("r0") dest, + in("r1") msgInfo.words[0], + in("r2") msg0, + in("r3") msg1, + in("r4") msg2, + in("r5") msg3, + ); } +#[cfg(not(feature = "CONFIG_KERNEL_MCS"))] #[inline(always)] pub unsafe fn seL4_Reply(msgInfo: seL4_MessageInfo) { - let msg0 = seL4_GetMR(0); - let msg1 = seL4_GetMR(1); - let msg2 = seL4_GetMR(2); - let msg3 = seL4_GetMR(3); - let scno = SyscallId::Reply as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::Reply)), - "{r1}" (msgInfo.words[0]), - "{r2}" (msg0), "{r3}" (msg1), - "{r4}" (msg2), "{r5}" (msg3), - "{r7}" (scno) - : "memory", "r0", "r1", "r2", "r3", "r4", "r5", "r7" - : "volatile"); + asm!("swi 0", + in("r7") swinum!(SyscallId::Reply), + in("r1") msgInfo.words[0], + in("r2") seL4_GetMR(0), + in("r3") seL4_GetMR(1), + in("r4") seL4_GetMR(2), + in("r5") 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::uninitialized(); - let mut msg1 = ::core::mem::uninitialized(); - let mut msg2 = ::core::mem::uninitialized(); - let mut msg3 = ::core::mem::uninitialized(); +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; - } - let scno = SyscallId::Reply as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::Reply)), - "{r1}" (msgInfo.words[0]), - "{r2}" (msg0), "{r3}" (msg1), - "{r4}" (msg2), "{r5}" (msg3), - "{r7}" (scno) - : "memory", "r0", "r1", "r2", "r3", "r4", "r5", "r7" - : "volatile"); + 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!("swi 0", + in("r7") swinum!(SyscallId::Reply), + in("r1") msgInfo.words[0], + in("r2") msg0, + in("r3") msg1, + in("r4") msg2, + in("r5") msg3, + ); } - #[inline(always)] pub unsafe fn seL4_Signal(dest: seL4_CPtr) { - let info = seL4_MessageInfo::new(0, 0, 0, 0).words[0]; - let scno = SyscallId::Send as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::Send)), - "{r0}" (dest), - "{r1}" (info), - "{r7}" (scno) - : "memory", "r0", "r1", "r7" - : "volatile"); + let info = seL4_MessageInfo::new(0, 0, 0, 0).words[0]; + asm!("swi 0", + in("r7") swinum!(SyscallId::Send), + in("r0") dest, + in("r1") info, + ) } #[inline(always)] pub unsafe fn seL4_Recv(mut src: seL4_CPtr, sender: *mut seL4_Word) -> seL4_MessageInfo { - let mut info = seL4_MessageInfo { words: [0] }; - let mut msg0 = ::core::mem::uninitialized(); - let mut msg1 = ::core::mem::uninitialized(); - let mut msg2 = ::core::mem::uninitialized(); - let mut msg3 = ::core::mem::uninitialized(); - let scno = SyscallId::Recv as seL4_Word; - asm!("swi $6" - : "={r0}" (src), - "={r1}" (info.words[0]), - "={r2}" (msg0), "={r3}" (msg1), - "={r4}" (msg2), "={r5}" (msg3) - : "i" (swinum!(SyscallId::Recv)), - "{r7}" (scno) - : "memory" - : "volatile"); + 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(); - seL4_SetMR(0, msg0); - seL4_SetMR(1, msg1); - seL4_SetMR(2, msg2); - seL4_SetMR(3, msg3); - - opt_assign!(sender, src); - - return info -} - -#[inline(always)] -pub unsafe fn seL4_NBRecv(mut src: seL4_CPtr, sender: *mut seL4_Word) -> seL4_MessageInfo { - let info: seL4_Word; - let mut msg0 = ::core::mem::uninitialized(); - let mut msg1 = ::core::mem::uninitialized(); - let mut msg2 = ::core::mem::uninitialized(); - let mut msg3 = ::core::mem::uninitialized(); - let scno = SyscallId::NBRecv as seL4_Word; - asm!("swi $6" - : "={r0}" (src) - "={r1}" (info), - "={r2}" (msg0), "={r3}" (msg1), - "={r4}" (msg2), "={r5}" (msg3) - : "i" (swinum!(SyscallId::NBRecv)), - "{r0}" (src), - "{r7}" (scno) - : "memory", "r0", "r1", "r2", "r3", "r4", "r5", "r7" - : "volatile"); + asm!("swi 0", + in("r7") swinum!(SyscallId::Recv), + out("r0") src, + out("r1") info, + out("r2") msg0, + out("r3") msg1, + out("r4") msg2, + out("r5") msg3 + ); seL4_SetMR(0, msg0); seL4_SetMR(1, msg1); @@ -434,93 +419,22 @@ pub unsafe fn seL4_NBRecv(mut src: seL4_CPtr, sender: *mut seL4_Word) -> seL4_Me } #[inline(always)] -pub unsafe fn seL4_Call(dest: seL4_CPtr, mut msgInfo: seL4_MessageInfo) -> seL4_MessageInfo { - let mut msg0 = seL4_GetMR(0); - let mut msg1 = seL4_GetMR(1); - let mut msg2 = seL4_GetMR(2); - let mut msg3 = seL4_GetMR(3); +pub unsafe fn seL4_NBRecv(mut src: seL4_CPtr, sender: *mut seL4_Word) -> seL4_MessageInfo { + let 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(); - let scno = SyscallId::Call as seL4_Word; - asm!("swi $5" - : "={r1}" (msgInfo.words[0]), - "={r2}" (msg0), "={r3}" (msg1), - "={r4}" (msg2), "={r5}" (msg3) - : "i" (swinum!(SyscallId::Call)), - "{r7}" (scno), - "{r0}" (dest) - : "memory", "r0", "r1", "r2", "r3", "r4", "r5", "r7" - : "volatile"); - - seL4_SetMR(0, msg0); - seL4_SetMR(1, msg1); - seL4_SetMR(2, msg2); - seL4_SetMR(3, msg3); - - msgInfo -} - -#[inline(always)] -pub unsafe fn seL4_CallWithMRs(dest: seL4_CPtr, mut msgInfo: seL4_MessageInfo, - mr0: *mut seL4_Word, mr1: *mut seL4_Word, - mr2: *mut seL4_Word, mr3: *mut seL4_Word, - ) -> seL4_MessageInfo { - let mut msg0 = ::core::mem::uninitialized(); - let mut msg1 = ::core::mem::uninitialized(); - let mut msg2 = ::core::mem::uninitialized(); - let mut msg3 = ::core::mem::uninitialized(); - - 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; - } - - let scno = SyscallId::Call as seL4_Word; - asm!("swi $5" - : "={r1}" (msgInfo.words[0]), - "={r2}" (msg0), "={r3}" (msg1), - "={r4}" (msg2), "={r5}" (msg3) - : "i" (swinum!(SyscallId::Call)), - "{r7}" (scno), - "{r0}" (dest), - "{r1}" (msgInfo.words[0]) - : "memory", "r0", "r1", "r2", "r3", "r4", "r5", "r7" - : "volatile"); - - opt_assign!(mr0, msg0); - opt_assign!(mr1, msg1); - opt_assign!(mr2, msg2); - opt_assign!(mr3, msg3); - - msgInfo -} - -#[inline(always)] -pub unsafe fn seL4_ReplyRecv(mut src: seL4_CPtr, mut msgInfo: seL4_MessageInfo, - sender: *mut seL4_Word) -> seL4_MessageInfo { - let mut msg0 = seL4_GetMR(0); - let mut msg1 = seL4_GetMR(1); - let mut msg2 = seL4_GetMR(2); - let mut msg3 = seL4_GetMR(3); - - let scno = SyscallId::ReplyRecv as seL4_Word; - asm!("swi $6" - : "={r0}" (src), "={r1}" (msgInfo.words[0]), - "={r2}" (msg0), "={r3}" (msg1), - "={r4}" (msg2), "={r5}" (msg3) - : "i" (swinum!(SyscallId::ReplyRecv)), - "{r7}" (scno), - "{r0}" (src), - "{r1}" (msgInfo.words[0]) - : "memory", "r0", "r1", "r2", "r3", "r4", "r5", "r7" - : "volatile"); + asm!("swi 0", + in("r7") swinum!(SyscallId::NBRecv), + inout("r0") src, + out("r1") info, + out("r2") msg0, + out("r3") msg1, + out("r4") msg2, + out("r5") msg3 + ); seL4_SetMR(0, msg0); seL4_SetMR(1, msg1); @@ -528,188 +442,540 @@ pub unsafe fn seL4_ReplyRecv(mut src: seL4_CPtr, mut msgInfo: seL4_MessageInfo, seL4_SetMR(3, msg3); opt_assign!(sender, src); - msgInfo + + seL4_MessageInfo { words: [info] } } #[inline(always)] -pub unsafe fn seL4_ReplyRecvWithMRs(mut src: seL4_CPtr, mut 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 msg0 = ::core::mem::uninitialized(); - let mut msg1 = ::core::mem::uninitialized(); - let mut msg2 = ::core::mem::uninitialized(); - let mut msg3 = ::core::mem::uninitialized(); - 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; - } - let scno = SyscallId::ReplyRecv as seL4_Word; - asm!("swi $6" - : "={r0}" (src), "={r1}" (msgInfo.words[0]), - "={r2}" (msg0), "={r3}" (msg1), - "={r4}" (msg2), "={r5}" (msg3) - : "i" (swinum!(SyscallId::ReplyRecv)), - "{r7}" (scno), - "{r0}" (src), - "{r1}" (msgInfo.words[0]) - : "memory", "r0", "r1", "r2", "r3", "r4", "r5", "r7" - : "volatile"); +pub unsafe fn seL4_Call(dest: seL4_CPtr, msgInfo: seL4_MessageInfo) -> 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!("swi 0", + in("r7") swinum!(SyscallId::Call), + in("r0") dest, + inout("r1") msgInfo.words[0] => info, + inout("r2") msg0, + inout("r3") msg1, + inout("r4") msg2, + inout("r5") msg3 + ); + + seL4_SetMR(0, msg0); + seL4_SetMR(1, msg1); + seL4_SetMR(2, msg2); + seL4_SetMR(3, msg3); + + seL4_MessageInfo { words: [info] } +} + +#[inline(always)] +pub unsafe fn seL4_CallWithMRs( + dest: seL4_CPtr, + msgInfo: seL4_MessageInfo, + 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 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!("swi 0", + in("r7") swinum!(SyscallId::Call), + in("r0") dest, + inout("r1") msgInfo.words[0] => info, + inout("r2") msg0, + inout("r3") msg1, + inout("r4") msg2, + inout("r5") msg3 + ); opt_assign!(mr0, msg0); opt_assign!(mr1, msg1); opt_assign!(mr2, msg2); opt_assign!(mr3, msg3); + 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!("swi 0", + in("r7") swinum!(SyscallId::ReplyRecv), + inout("r0") src, + inout("r1") msgInfo.words[0] => info, + inout("r2") msg0, + inout("r3") msg1, + inout("r4") msg2, + inout("r5") msg3 + ); + + seL4_SetMR(0, msg0); + seL4_SetMR(1, msg1); + seL4_SetMR(2, msg2); + seL4_SetMR(3, msg3); + opt_assign!(sender, src); - msgInfo + + 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!("swi 0", + in("r7") swinum!(SyscallId::ReplyRecv), + inout("r0") src => badge, + inout("r1") msgInfo.words[0] => info, + inout("r2") msg0, + inout("r3") msg1, + inout("r4") msg2, + inout("r5") 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!("swi 0", + in("r7") swinum!(SyscallId::NBSendRecv), + inout("r0") src => badge, + inout("r1") msgInfo.words[0] => info, + inout("r2") msg0, + inout("r3") msg1, + inout("r4") msg2, + inout("r5") msg3, + in("a6") reply, + in("r8") 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!("swi 0", + in("r7") swinum!(SyscallId::NBSendRecv), + inout("r0") src => badge, + inout("r1") msgInfo.words[0] => info, + inout("r2") msg0, + inout("r3") msg1, + inout("r4") msg2, + inout("r5") msg3, + in("r6") reply, + in("r8") 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!("swi 0", + in("r7") swinum!(SyscallId::NBSendWait), + inout("r0") src => badge, + inout("r1") msgInfo.words[0] => info, + inout("r2") msg0, + inout("r3") msg1, + inout("r4") msg2, + inout("r5") msg3, + in("r6") dest, + in("r8") 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!("swi 0", + in("r7") swinum!(SyscallId::NBSendRecv), + inout("r0") src => badge, + inout("r1") msgInfo.words[0] => info, + inout("r2") msg0, + inout("r3") msg1, + inout("r4") msg2, + inout("r5") msg3, + in("r6") dest, + in("r8") 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() { - let scno = SyscallId::Yield as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::Yield)), - "{r7}" (scno) - : "memory" - : "volatile"); + asm!("swi 0", + in("r7") swinum!(SyscallId::Yield), + options(nomem, nostack), + ); } +#[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!("swi 0", + in("r7") swinum!(SyscallId::Wait), + inout("r0") src => badge, + out("r1") info, + inout("r2") msg0, + inout("r3") msg1, + inout("r4") msg2, + inout("r5") 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(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(); + + asm!("swi 0", + in("r7") swinum!(SyscallId::Wait), + inout("r0") src => badge, + out("r1") info, + inout("r2") msg0, + inout("r3") msg1, + inout("r4") msg2, + inout("r5") 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_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!("swi 0", + in("r7") swinum!(SyscallId::NBWait), + inout("r0") src => badge, + out("r1") info, + inout("r2") msg0, + inout("r3") msg1, + inout("r4") msg2, + inout("r5") 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(feature = "CONFIG_PRINTING")] #[inline(always)] pub unsafe fn seL4_DebugPutChar(c: u8) { - let scno = SyscallId::DebugPutChar as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::DebugPutChar)), - "{r0}" (c) - "{r7}" (scno) - : "memory" - : "volatile"); + asm!("swi 0", + in("r7") swinum!(SyscallId::DebugPutChar), + in("r0") c, + options(nostack), + ); } +#[cfg(feature = "CONFIG_PRINTING")] +#[inline(always)] +pub unsafe fn seL4_DebugDumpScheduler() { + asm!("swi 0", + in("r7") swinum!(SyscallId::DebugDumpScheduler), + options(nomem, nostack), + ); +} + +#[cfg(feature = "CONFIG_DEBUG_BUILD")] #[inline(always)] pub unsafe fn seL4_DebugHalt() { - let scno = SyscallId::DebugHalt as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::DebugHalt)), - "{r7}" (scno) - : "memory" - : "volatile"); + asm!("swi 0", + in("r7") swinum!(SyscallId::DebugHalt), + options(nomem, nostack), + ); } +#[cfg(feature = "CONFIG_DEBUG_BUILD")] #[inline(always)] pub unsafe fn seL4_DebugSnapshot() { - let scno = SyscallId::DebugSnapshot as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::DebugSnapshot)), - "{r7}" (scno) - : "memory" - : "volatile"); + asm!("swi 0", + in("r7") swinum!(SyscallId::DebugSnapshot), + options(nomem, nostack), + ); } +#[cfg(feature = "CONFIG_DEBUG_BUILD")] #[inline(always)] pub unsafe fn seL4_DebugCapIdentify(mut cap: seL4_CPtr) -> u32 { - let scno = SyscallId::DebugCapIdentify as seL4_Word; - asm!("swi $1" - : "={r0}" (cap) - : "i" (swinum!(SyscallId::DebugCapIdentify)), - "{r0}" (cap), - "{r7}" (scno) - : "memory" - : "volatile"); + asm!("swi 0", + in("r7") swinum!(SyscallId::DebugCapIdentify), + inout("r0") cap, + options(nomem, nostack), + ); cap as _ } // 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()); - let scno = SyscallId::DebugNameThread as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::DebugNameThread)), - "{r0}" (tcb), - "{r7}" (scno) - : "memory" - : "volatile"); + core::ptr::copy_nonoverlapping( + name.as_ptr() as *mut u8, + (&mut (*seL4_GetIPCBuffer()).msg).as_mut_ptr() as *mut u8, + name.len(), + ); + asm!("swi 0", + in("r7") swinum!(SyscallId::DebugNameThread), + in("r0") tcb, + ); } +#[cfg(feature = "CONFIG_DANGEROUS_CODE_INJECTION")] #[inline(always)] -#[cfg(feature = "SEL4_DANGEROUS_CODE_INJECTION")] -pub unsafe fn seL4_DebugRun(userfn: extern fn(*mut u8), userarg: *mut u8) { +pub unsafe fn seL4_DebugRun(userfn: extern "C" fn(*mut u8), userarg: *mut u8) { let userfnptr = userfn as *mut (); - let scno = SyscallId::DebugRun as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::DebugRun)), - "{r0}" (userfnptr), - "{r1}" (userarg), - "{r7}" (scno) - : "memory" - : "volatile"); + asm!("swi 0" + in("r7") swinum!(SyscallId::DebugRun), + in("r0") userfnptr, + in("r1") userarg, + ); } +#[cfg(feature = "CONFIG_ENABLE_BENCHMARKS")] #[inline(always)] -#[cfg(feature = "SEL4_CONFIG_BENCHMARK")] pub unsafe fn seL4_BenchmarkResetLog() { - let scno = SyscallId::BenchmarkResetLog as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::BenchmarkResetLog)), - "{r7}" (scno) - : "memory" - : "volatile"); + asm!("swi 0", + in("r7") swinum!(SyscallId::BenchmarkResetLog), + options(nomem, nostack), + ); } +#[cfg(feature = "CONFIG_ENABLE_BENCHMARKS")] #[inline(always)] -#[cfg(feature = "SEL4_CONFIG_BENCHMARK")] -pub unsafe fn seL4_BenchmarkDumpLog(mut start: seL4_Word, size: seL4_Word) -> u32 { - let scno = SyscallId::BenchmarkDumpLog as seL4_Word; - asm!("swi $1" - : "={r0}" (start) - : "i" (swinum!(SyscallId::BenchmarkDumpLog)), - "{r0}" (start), - "{r1}" (size), - "{r7}" (scno) - : "memory" - : "volatile"); - start -} - -#[inline(always)] -#[cfg(feature = "SEL4_CONFIG_BENCHMARK")] -pub unsafe fn seL4_BenchmarkLogSize() -> u32 { - let mut size = 0; - let scno = SyscallId::BenchmarkLogSize as seL4_Word; - asm!("swi $1" - : "={r0}" (size) - : "i" (swinum!(SyscallId::BenchmarkLogSize)), - "{r7}" (scno) - : "memory" - : "volatile"); - size -} - -#[inline(always)] -#[cfg(feature = "SEL4_CONFIG_BENCHMARK")] pub unsafe fn seL4_BenchmarkFinalizeLog() { - let scno = SyscallId::BenchmarkFinalizeLog as seL4_Word; - asm!("swi $0" - : - : "i" (swinum!(SyscallId::BenchmarkFinalizeLog)), - "{r7}" (scno) - : "memory" - : "volatile"); + asm!("swi 0", + in("r7") swinum!(SyscallId::BenchmarkFinalizeLog), + options(nomem, nostack), + ); } diff --git a/apps/system/components/kata-os-common/src/sel4-sys/build.rs b/apps/system/components/kata-os-common/src/sel4-sys/build.rs index ab178a5..b8c2df3 100644 --- a/apps/system/components/kata-os-common/src/sel4-sys/build.rs +++ b/apps/system/components/kata-os-common/src/sel4-sys/build.rs @@ -119,8 +119,8 @@ fn main() { "--dest", &*format!("{}/{}_invocation.rs", out_dir, arch), &*xml_interfaces_file, - &*xml_arch_file, &*xml_sel4_arch_file, + &*xml_arch_file, ]); println!("Running {:?}", cmd); assert!(cmd.status().unwrap().success());