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
This commit is contained in:
Sam Leffler 2022-09-14 19:27:18 +00:00
parent b446c00783
commit bbe49faf65
3 changed files with 737 additions and 558 deletions

View File

@ -12,6 +12,8 @@
use static_assertions::assert_cfg; use static_assertions::assert_cfg;
assert_cfg!(target_arch = "riscv32"); assert_cfg!(target_arch = "riscv32");
use cfg_if::cfg_if;
pub const seL4_WordBits: usize = 32; pub const seL4_WordBits: usize = 32;
pub const seL4_WordSizeBits: usize = 2; pub const seL4_WordSizeBits: usize = 2;
pub const seL4_PageBits: usize = 12; 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)] #[inline(always)]
pub unsafe fn seL4_Send(dest: seL4_CPtr, msgInfo: seL4_MessageInfo) { pub unsafe fn seL4_Send(dest: seL4_CPtr, msgInfo: seL4_MessageInfo) {
asm!("ecall", 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)] #[inline(always)]
pub unsafe fn seL4_SendWithMRs( pub unsafe fn seL4_SendWithMRs(
dest: seL4_CPtr, 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)] #[inline(always)]
pub unsafe fn seL4_Signal(dest: seL4_CPtr) { pub unsafe fn seL4_Signal(dest: seL4_CPtr) {
let info = seL4_MessageInfo::new(0, 0, 0, 0).words[0]; 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)] #[inline(always)]
pub unsafe fn seL4_Call(dest: seL4_CPtr, msgInfo: seL4_MessageInfo) -> seL4_MessageInfo { pub unsafe fn seL4_Call(dest: seL4_CPtr, msgInfo: seL4_MessageInfo) -> seL4_MessageInfo {
let mut info: seL4_Word; let mut info: seL4_Word;
@ -519,271 +415,6 @@ pub unsafe fn seL4_CallWithMRs(
seL4_MessageInfo { words: [info] } 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)] #[inline(always)]
pub unsafe fn seL4_Yield() { pub unsafe fn seL4_Yield() {
asm!("ecall", asm!("ecall",
@ -792,174 +423,86 @@ pub unsafe fn seL4_Yield() {
); );
} }
#[cfg(feature = "CONFIG_KERNEL_MCS")] cfg_if! {
#[inline(always)] if #[cfg(feature = "CONFIG_KERNEL_MCS")] {
pub unsafe fn seL4_Wait(src: seL4_CPtr, sender: *mut seL4_Word) -> seL4_MessageInfo { include!("riscv32_mcs.rs");
let mut info: seL4_Word; } else {
let mut badge: seL4_Word; include!("riscv32_no_mcs.rs");
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(feature = "CONFIG_KERNEL_MCS")] cfg_if! {
#[inline(always)] if #[cfg(feature = "CONFIG_PRINTING")] {
pub unsafe fn seL4_WaitWithMRs( #[inline(always)]
src: seL4_CPtr, pub unsafe fn seL4_DebugPutChar(c: u8) {
sender: *mut seL4_Word, asm!("ecall",
mr0: *mut seL4_Word, in("a7") swinum!(SyscallId::DebugPutChar),
mr1: *mut seL4_Word, in("a0") c,
mr2: *mut seL4_Word, options(nostack),
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", #[inline(always)]
in("a7") swinum!(SyscallId::Wait), pub unsafe fn seL4_DebugDumpScheduler() {
inout("a0") src => badge, asm!("ecall",
out("a1") info, in("a7") swinum!(SyscallId::DebugDumpScheduler),
inout("a2") msg0, options(nomem, nostack),
inout("a3") msg1, );
inout("a4") msg2, }
inout("a5") msg3,
);
opt_assign!(mr0, msg0); #[inline(always)]
opt_assign!(mr1, msg1); pub unsafe fn seL4_DebugDumpCNode(mut cap: seL4_CPtr) {
opt_assign!(mr2, msg2); asm!("ecall",
opt_assign!(mr3, msg3); in("a7") swinum!(SyscallId::DebugDumpCNode),
inout("a0") cap,
opt_assign!(sender, badge); options(nomem, nostack),
);
seL4_MessageInfo { words: [info] } }
} // CONFIG_PRINTING
} }
#[cfg(feature = "CONFIG_KERNEL_MCS")] cfg_if! {
#[inline(always)] if #[cfg(feature = "CONFIG_DEBUG_BUILD")] {
pub unsafe fn seL4_NBWait(src: seL4_CPtr, sender: *mut seL4_Word) -> seL4_MessageInfo { #[inline(always)]
let mut info: seL4_Word; pub unsafe fn seL4_DebugHalt() {
let mut badge: seL4_Word; asm!("ecall",
let mut msg0 = ::core::mem::MaybeUninit::uninit().assume_init(); in("a7") swinum!(SyscallId::DebugHalt),
let mut msg1 = ::core::mem::MaybeUninit::uninit().assume_init(); options(nomem, nostack),
let mut msg2 = ::core::mem::MaybeUninit::uninit().assume_init(); );
let mut msg3 = ::core::mem::MaybeUninit::uninit().assume_init(); }
asm!("ecall", #[inline(always)]
in("a7") swinum!(SyscallId::NBWait), pub unsafe fn seL4_DebugSnapshot() {
inout("a0") src => badge, asm!("ecall",
out("a1") info, in("a7") swinum!(SyscallId::DebugSnapshot),
inout("a2") msg0, options(nomem, nostack),
inout("a3") msg1, );
inout("a4") msg2, }
inout("a5") msg3,
);
seL4_SetMR(0, msg0); #[inline(always)]
seL4_SetMR(1, msg1); pub unsafe fn seL4_DebugCapIdentify(mut cap: seL4_CPtr) -> u32 {
seL4_SetMR(2, msg2); asm!("ecall",
seL4_SetMR(3, msg3); in("a7") swinum!(SyscallId::DebugCapIdentify),
inout("a0") cap,
options(nomem, nostack),
);
cap as _
}
opt_assign!(sender, badge); // Note: name MUST be NUL-terminated.
#[inline(always)]
seL4_MessageInfo { words: [info] } pub unsafe fn seL4_DebugNameThread(tcb: seL4_CPtr, name: &[u8]) {
} core::ptr::copy_nonoverlapping(
name.as_ptr() as *mut u8,
#[cfg(feature = "CONFIG_PRINTING")] (&mut (*seL4_GetIPCBuffer()).msg).as_mut_ptr() as *mut u8,
#[inline(always)] name.len(),
pub unsafe fn seL4_DebugPutChar(c: u8) { );
asm!("ecall", asm!("ecall",
in("a7") swinum!(SyscallId::DebugPutChar), in("a7") swinum!(SyscallId::DebugNameThread),
in("a0") c, in("a0") tcb,
options(nostack), );
); }
} } // CONFIG_DEBUG_BUILD
#[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,
);
} }
#[cfg(feature = "CONFIG_DANGEROUS_CODE_INJECTION")] #[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")] cfg_if! {
#[inline(always)] if #[cfg(feature = "CONFIG_ENABLE_BENCHMARKS")] {
pub unsafe fn seL4_BenchmarkResetLog() { #[inline(always)]
asm!("ecall", pub unsafe fn seL4_BenchmarkResetLog() {
in("a7") swinum!(SyscallId::BenchmarkResetLog), asm!("ecall",
options(nomem, nostack), in("a7") swinum!(SyscallId::BenchmarkResetLog),
); options(nomem, nostack),
} );
}
#[cfg(feature = "CONFIG_ENABLE_BENCHMARKS")] #[inline(always)]
#[inline(always)] pub unsafe fn seL4_BenchmarkFinalizeLog() {
pub unsafe fn seL4_BenchmarkFinalizeLog() { asm!("ecall",
asm!("ecall", in("a7") swinum!(SyscallId::BenchmarkFinalizeLog),
in("a7") swinum!(SyscallId::BenchmarkFinalizeLog), options(nomem, nostack),
options(nomem, nostack), );
); }
}
// TODO(sleffler): seL4_BenchmarkSetLogBuffer // TODO(sleffler): seL4_BenchmarkSetLogBuffer
// TODO(sleffler): seL4_BenchmarkNullSyscall // TODO(sleffler): seL4_BenchmarkNullSyscall
// TODO(sleffler): seL4_BenchmarkFlushCaches // TODO(sleffler): seL4_BenchmarkFlushCaches
// TODO(sleffler): seL4_BenchmarkFlushL1Caches // TODO(sleffler): seL4_BenchmarkFlushL1Caches
} // CONFIG_ENABLE_BENCHMARKS
}
#[cfg(feature = "CONFIG_SET_TLS_BASE_SELF")] #[cfg(feature = "CONFIG_SET_TLS_BASE_SELF")]
pub unsafe fn seL4_SetTLSBase(tls_base: seL4_Word) { pub unsafe fn seL4_SetTLSBase(tls_base: seL4_Word) {

View File

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

View File

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