Enum KernelOp 

#[repr(u16)]
pub enum KernelOp {
    MapAnonymous = 1,
    Munmap = 2,
    Mprotect = 3,
    ReadUser = 4,
    WriteUser = 5,
    Yield = 256,
    BlockThread = 257,
    ThreadCreate = 258,
    ThreadExit = 259,
    FutexWake = 260,
    GetTimeNs = 512,
    GetRandom = 513,
    VfsOpen = 1_024,
    VfsRead = 1_025,
    VfsWrite = 1_026,
    VfsStat = 1_027,
    VfsClose = 1_028,
    VfsSeek = 1_029,
    VfsTruncate = 1_030,
    VfsSync = 1_031,
    NetConnect = 1_280,
    NetListen = 1_281,
    NetAccept = 1_282,
    NetSend = 1_283,
    NetRecv = 1_284,
    NetClose = 1_285,
    NetUdpBind = 1_296,
    NetUdpSend = 1_297,
    NetUdpRecv = 1_298,
    SendSignal = 1_536,
    CheckSignals = 1_537,
    DebugPrint = 3_840,
    DomainExit = 4_096,
    GetDomainId = 4_097,
    GetParentId = 4_098,
}

Kernel operation codes.

Discriminant values are stable across versions for ABI compatibility.

Variants

MapAnonymous = 1

Map anonymous memory. Args: [addr_hint, len, prot, flags, 0]

Munmap = 2

Unmap memory. Args: [addr, len, 0, 0, 0]

Mprotect = 3

Change protection. Args: [addr, len, prot, 0, 0]

ReadUser = 4

Read from domain memory. Args: [user_addr, kernel_buf_id, len, 0, 0]

WriteUser = 5

Write to domain memory. Args: [user_addr, kernel_buf_id, len, 0, 0]

Yield = 256

Yield CPU. Args: [0, 0, 0, 0, 0]

BlockThread = 257

Block thread. Args: [timeout_ns, 0, 0, 0, 0]

ThreadCreate = 258

Create thread. Args: [entry, stack_top, arg, tls, flags]

ThreadExit = 259

Exit thread. Args: [exit_code, 0, 0, 0, 0]

FutexWake = 260

Wake futex waiters. Args: [addr, count, 0, 0, 0]

GetTimeNs = 512

Get time in nanoseconds. Args: [clock_id, 0, 0, 0, 0]

GetRandom = 513

Fill buffer with random bytes. Args: [user_buf, len, flags, 0, 0]

VfsOpen = 1_024

Open file. Args: [path_ptr, path_len, flags, mode, 0]

VfsRead = 1_025

Read file. Args: [handle, user_buf, len, offset, 0]

VfsWrite = 1_026

Write file. Args: [handle, user_buf, len, offset, 0]

VfsStat = 1_027

Stat file. Args: [handle, statbuf, 0, 0, 0]

VfsClose = 1_028

Close file. Args: [handle, 0, 0, 0, 0]

VfsSeek = 1_029

Seek. Args: [handle, offset, whence, 0, 0]

VfsTruncate = 1_030

Truncate. Args: [handle, length, 0, 0, 0]

VfsSync = 1_031

Sync to storage. Args: [handle, flags, 0, 0, 0]

NetConnect = 1_280

TCP connect. Args: [sockaddr_ptr, addrlen, 0, 0, 0]

NetListen = 1_281

TCP listen. Args: [sockaddr_ptr, addrlen, backlog, 0, 0]

NetAccept = 1_282

Accept connection. Args: [listener, peer_addr_ptr, peer_addrlen_ptr, 0, 0]

NetSend = 1_283

Send data. Args: [handle, user_buf, len, flags, 0]

NetRecv = 1_284

Receive data. Args: [handle, user_buf, len, flags, 0]

NetClose = 1_285

Close network handle. Args: [handle, 0, 0, 0, 0]

NetUdpBind = 1_296

Bind UDP socket. Args: [sockaddr_ptr, addrlen, 0, 0, 0]

NetUdpSend = 1_297

Send UDP datagram. Args: [handle, user_buf, len, dest_addr_ptr, dest_addrlen]

NetUdpRecv = 1_298

Receive UDP datagram. Args: [handle, user_buf, len, src_addr_ptr, src_addrlen_ptr]

SendSignal = 1_536

Send signal. Args: [target_domain, signum, 0, 0, 0]

CheckSignals = 1_537

Check pending signals. Args: [0, 0, 0, 0, 0]

DebugPrint = 3_840

Write to debug console. Args: [user_buf, len, 0, 0, 0]

DomainExit = 4_096

Terminate domain. Args: [exit_code, 0, 0, 0, 0]

GetDomainId = 4_097

Get domain ID. Args: [0, 0, 0, 0, 0]

GetParentId = 4_098

Get parent domain ID. Args: [0, 0, 0, 0, 0]

Implementations

impl KernelOp

pub fn from_u16(value: u16) -> Option<Self>

Create from raw opcode. Returns None for unrecognized values.

pub const fn name(&self) -> &'static str

Operation name for diagnostics.

pub const fn is_nonblocking(&self) -> bool

Whether this operation can be batched (doesn’t block or exit).

Trait Implementations

impl Clone for KernelOp

fn clone(&self) -> KernelOp

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KernelOp

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for KernelOp

fn eq(&self, other: &KernelOp) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for KernelOp

impl Eq for KernelOp

impl StructuralPartialEq for KernelOp