Gabriel Kaszewski
7c7e3b8748
Every syscall stub now uses proper types from types/ — CapSlot,
EntryPoint, StackPointer, VirtualAddress, PageCount, ProcessId,
PermissionSet, Ticks. The compiler prevents swapping entry/stack,
passing a ProcessId where a CapSlot is expected, or using an
address as a page count.
New display types in types/display.rs:
- Color(u32) with rgb() constructor
- ScreenCoord(u16) for x/y positions
- Dimension(u16) for width/height
Updated throughout:
- userspace/syscall.rs: all params typed, returns Option instead
of sentinel usize::MAX
- server-framework: endpoint param is CapSlot
- port-framebuffer: trait uses Color, ScreenCoord, Dimension
- hw-virtio: DmaAddrs uses PhysicalAddress/VirtualAddress,
GPU commands use Dimension
- All servers, drivers, bins, apps updated for new signatures
- permission-manager: process field uses ProcessId
- PermissionSet: added bits() accessor
89 tests pass, full QEMU boot verified.
86 lines
2.6 KiB
Rust
86 lines
2.6 KiB
Rust
use crate::arch;
|
|
use types::syscall_abi::*;
|
|
use types::address::{EntryPoint, StackPointer, VirtualAddress};
|
|
use types::bounded::{CapSlot, PageCount};
|
|
use types::id::ProcessId;
|
|
use types::permission::PermissionSet;
|
|
use types::time::Ticks;
|
|
|
|
pub fn exit() -> ! {
|
|
arch::syscall0(SYS_EXIT);
|
|
loop {}
|
|
}
|
|
|
|
pub fn exit_thread() -> ! {
|
|
arch::syscall0(SYS_EXIT_THREAD);
|
|
loop {}
|
|
}
|
|
|
|
pub fn yield_now() {
|
|
arch::syscall0(SYS_YIELD);
|
|
}
|
|
|
|
pub fn halt() -> ! {
|
|
arch::syscall0(SYS_HALT);
|
|
loop {}
|
|
}
|
|
|
|
pub fn get_time() -> Ticks {
|
|
Ticks::from_raw(arch::syscall0(SYS_GET_TIME) as u64)
|
|
}
|
|
|
|
pub fn get_process_id() -> ProcessId {
|
|
ProcessId::from_raw(arch::syscall0(SYS_GET_PROCESS_ID) as u16)
|
|
}
|
|
|
|
pub fn create_process(create_cap: CapSlot) -> Option<CapSlot> {
|
|
let r = arch::syscall1(SYS_CREATE_PROCESS, create_cap.value() as usize);
|
|
if r == usize::MAX { None } else { CapSlot::new(r as u8) }
|
|
}
|
|
|
|
pub fn create_endpoint() -> Option<CapSlot> {
|
|
let r = arch::syscall0(SYS_CREATE_ENDPOINT);
|
|
if r == usize::MAX { None } else { CapSlot::new(r as u8) }
|
|
}
|
|
|
|
pub fn spawn_thread(entry: EntryPoint, stack: StackPointer) -> usize {
|
|
arch::syscall2(SYS_SPAWN_THREAD, entry.raw(), stack.raw())
|
|
}
|
|
|
|
pub fn spawn_thread_in(process_cap: CapSlot, entry: EntryPoint, stack: StackPointer) -> usize {
|
|
arch::syscall3(SYS_SPAWN_THREAD_IN, process_cap.value() as usize, entry.raw(), stack.raw())
|
|
}
|
|
|
|
pub fn request_pages(count: PageCount) -> Option<VirtualAddress> {
|
|
let r = arch::syscall1(SYS_REQUEST_PAGES, count.value() as usize);
|
|
if r == usize::MAX { None } else { Some(VirtualAddress::from_raw(r)) }
|
|
}
|
|
|
|
pub fn map_page(process_cap: CapSlot, src_va: VirtualAddress, dst_va: VirtualAddress, executable: bool) -> bool {
|
|
arch::syscall4(SYS_MAP_PAGE, process_cap.value() as usize, src_va.raw(), dst_va.raw(), executable as usize) == 0
|
|
}
|
|
|
|
pub fn send(endpoint: CapSlot, w0: usize, w1: usize, w2: usize, w3: usize) -> usize {
|
|
arch::syscall5(SYS_SEND, endpoint.value() as usize, w0, w1, w2, w3)
|
|
}
|
|
|
|
pub fn receive(endpoint: CapSlot) -> (usize, usize, usize, usize) {
|
|
arch::syscall_receive(SYS_RECEIVE, endpoint.value() as usize)
|
|
}
|
|
|
|
pub fn delegate(slot: CapSlot, to: CapSlot, permissions: PermissionSet) -> bool {
|
|
arch::syscall3(SYS_DELEGATE, slot.value() as usize, to.value() as usize, permissions.bits() as usize) == 0
|
|
}
|
|
|
|
pub fn kill(process_cap: CapSlot) -> bool {
|
|
arch::syscall1(SYS_KILL, process_cap.value() as usize) == 0
|
|
}
|
|
|
|
pub fn revoke(slot: CapSlot) -> bool {
|
|
arch::syscall1(SYS_REVOKE, slot.value() as usize) == 0
|
|
}
|
|
|
|
pub fn debug_putchar(byte: u8) {
|
|
arch::syscall1(SYS_DEBUG_PUTCHAR, byte as usize);
|
|
}
|