935 lines
39 KiB
C++
935 lines
39 KiB
C++
/*
|
|
* Syscall.hpp
|
|
* MontaukOS syscall definitions for userspace programs
|
|
* Copyright (c) 2025 Daniel Hammer
|
|
*/
|
|
|
|
#pragma once
|
|
#include <cstdint>
|
|
#include <cstddef>
|
|
#include <montauk/statuscodes.h>
|
|
|
|
namespace montauk::abi {
|
|
|
|
// Syscall numbers
|
|
static constexpr uint64_t SYS_EXIT = 0;
|
|
static constexpr uint64_t SYS_YIELD = 1;
|
|
static constexpr uint64_t SYS_SLEEP_MS = 2;
|
|
static constexpr uint64_t SYS_GETPID = 3;
|
|
static constexpr uint64_t SYS_PRINT = 4;
|
|
static constexpr uint64_t SYS_PUTCHAR = 5;
|
|
static constexpr uint64_t SYS_OPEN = 6;
|
|
static constexpr uint64_t SYS_READ = 7;
|
|
static constexpr uint64_t SYS_GETSIZE = 8;
|
|
static constexpr uint64_t SYS_CLOSE = 9;
|
|
static constexpr uint64_t SYS_READDIR = 10;
|
|
static constexpr uint64_t SYS_ALLOC = 11;
|
|
static constexpr uint64_t SYS_FREE = 12;
|
|
static constexpr uint64_t SYS_GETTICKS = 13;
|
|
static constexpr uint64_t SYS_GETMILLISECONDS = 14;
|
|
static constexpr uint64_t SYS_GETINFO = 15;
|
|
static constexpr uint64_t SYS_ISKEYAVAILABLE = 16;
|
|
static constexpr uint64_t SYS_GETKEY = 17;
|
|
static constexpr uint64_t SYS_GETCHAR = 18;
|
|
static constexpr uint64_t SYS_PING = 19;
|
|
static constexpr uint64_t SYS_SPAWN = 20;
|
|
static constexpr uint64_t SYS_FBINFO = 21;
|
|
static constexpr uint64_t SYS_FBMAP = 22;
|
|
static constexpr uint64_t SYS_WAITPID = 23;
|
|
static constexpr uint64_t SYS_TERMSIZE = 24;
|
|
static constexpr uint64_t SYS_GETARGS = 25;
|
|
static constexpr uint64_t SYS_RESET = 26;
|
|
static constexpr uint64_t SYS_SHUTDOWN = 27;
|
|
static constexpr uint64_t SYS_GETTIME = 28;
|
|
static constexpr uint64_t SYS_SOCKET = 29;
|
|
static constexpr uint64_t SYS_CONNECT = 30;
|
|
static constexpr uint64_t SYS_BIND = 31;
|
|
static constexpr uint64_t SYS_LISTEN = 32;
|
|
static constexpr uint64_t SYS_ACCEPT = 33;
|
|
static constexpr uint64_t SYS_SEND = 34;
|
|
static constexpr uint64_t SYS_RECV = 35;
|
|
static constexpr uint64_t SYS_CLOSESOCK = 36;
|
|
static constexpr uint64_t SYS_GETNETCFG = 37;
|
|
static constexpr uint64_t SYS_SETNETCFG = 38;
|
|
static constexpr uint64_t SYS_SENDTO = 39;
|
|
static constexpr uint64_t SYS_RECVFROM = 40;
|
|
static constexpr uint64_t SYS_FWRITE = 41;
|
|
static constexpr uint64_t SYS_FCREATE = 42;
|
|
static constexpr uint64_t SYS_FDELETE = 77;
|
|
static constexpr uint64_t SYS_FMKDIR = 78;
|
|
static constexpr uint64_t SYS_DRIVELIST = 79;
|
|
static constexpr uint64_t SYS_TERMSCALE = 43;
|
|
static constexpr uint64_t SYS_RESOLVE = 44;
|
|
static constexpr uint64_t SYS_GETRANDOM = 45;
|
|
static constexpr uint64_t SYS_LOG = 46;
|
|
static constexpr uint64_t SYS_MOUSESTATE = 47;
|
|
static constexpr uint64_t SYS_SETMOUSEBOUNDS = 48;
|
|
static constexpr uint64_t SYS_SPAWN_REDIR = 49;
|
|
static constexpr uint64_t SYS_CHILDIO_READ = 50;
|
|
static constexpr uint64_t SYS_CHILDIO_WRITE = 51;
|
|
static constexpr uint64_t SYS_CHILDIO_WRITEKEY = 52;
|
|
static constexpr uint64_t SYS_CHILDIO_SETTERMSZ = 53;
|
|
|
|
// Window server syscalls
|
|
static constexpr uint64_t SYS_WINCREATE = 54;
|
|
static constexpr uint64_t SYS_WINDESTROY = 55;
|
|
static constexpr uint64_t SYS_WINPRESENT = 56;
|
|
static constexpr uint64_t SYS_WINPOLL = 57;
|
|
static constexpr uint64_t SYS_WINENUM = 58;
|
|
static constexpr uint64_t SYS_WINMAP = 59;
|
|
static constexpr uint64_t SYS_WINUNMAP = 97;
|
|
static constexpr uint64_t SYS_WINSENDEVENT = 60;
|
|
static constexpr uint64_t SYS_WINRESIZE = 64;
|
|
static constexpr uint64_t SYS_WINSETSCALE = 65;
|
|
static constexpr uint64_t SYS_WINGETSCALE = 66;
|
|
static constexpr uint64_t SYS_WINSETCURSOR = 68;
|
|
static constexpr uint64_t SYS_WINSETFLAGS = 126;
|
|
|
|
// Process management syscalls
|
|
static constexpr uint64_t SYS_PROCLIST = 61;
|
|
static constexpr uint64_t SYS_KILL = 62;
|
|
static constexpr uint64_t SYS_DEVLIST = 63;
|
|
static constexpr uint64_t SYS_DISKINFO = 69;
|
|
|
|
// Kernel introspection syscalls
|
|
static constexpr uint64_t SYS_MEMSTATS = 67;
|
|
|
|
// Storage / partition syscalls
|
|
static constexpr uint64_t SYS_PARTLIST = 70;
|
|
static constexpr uint64_t SYS_DISKREAD = 71;
|
|
static constexpr uint64_t SYS_DISKWRITE = 72;
|
|
static constexpr uint64_t SYS_GPTINIT = 73;
|
|
static constexpr uint64_t SYS_GPTADD = 74;
|
|
static constexpr uint64_t SYS_FSMOUNT = 75;
|
|
static constexpr uint64_t SYS_FSFORMAT = 76;
|
|
|
|
// Audio syscalls
|
|
static constexpr uint64_t SYS_AUDIOOPEN = 80;
|
|
static constexpr uint64_t SYS_AUDIOCLOSE = 81;
|
|
static constexpr uint64_t SYS_AUDIOWRITE = 82;
|
|
static constexpr uint64_t SYS_AUDIOCTL = 83;
|
|
|
|
// Bluetooth syscalls
|
|
static constexpr uint64_t SYS_BTSCAN = 84;
|
|
static constexpr uint64_t SYS_BTCONNECT = 85;
|
|
static constexpr uint64_t SYS_BTDISCONNECT = 86;
|
|
static constexpr uint64_t SYS_BTLIST = 87;
|
|
static constexpr uint64_t SYS_BTINFO = 88;
|
|
|
|
// Power management
|
|
static constexpr uint64_t SYS_SUSPEND = 89;
|
|
|
|
// Timezone
|
|
static constexpr uint64_t SYS_SETTZ = 90;
|
|
static constexpr uint64_t SYS_GETTZ = 91;
|
|
|
|
// User management
|
|
static constexpr uint64_t SYS_SETUSER = 92;
|
|
static constexpr uint64_t SYS_GETUSER = 93;
|
|
static constexpr uint64_t SYS_SETSESSION = 174;
|
|
static constexpr uint64_t SYS_KILLSESSION = 175;
|
|
static constexpr uint64_t SYS_FRENAME = 94;
|
|
static constexpr uint64_t SYS_GETCWD = 95;
|
|
static constexpr uint64_t SYS_CHDIR = 96;
|
|
static constexpr uint64_t SYS_DUPHANDLE = 98;
|
|
static constexpr uint64_t SYS_WAIT_HANDLE = 99;
|
|
static constexpr uint64_t SYS_STREAM_CREATE = 100;
|
|
static constexpr uint64_t SYS_STREAM_READ = 101;
|
|
static constexpr uint64_t SYS_STREAM_WRITE = 102;
|
|
static constexpr uint64_t SYS_MAILBOX_CREATE = 103;
|
|
static constexpr uint64_t SYS_MAILBOX_SEND = 104;
|
|
static constexpr uint64_t SYS_MAILBOX_RECV = 105;
|
|
static constexpr uint64_t SYS_WAITSET_CREATE = 106;
|
|
static constexpr uint64_t SYS_WAITSET_ADD = 107;
|
|
static constexpr uint64_t SYS_WAITSET_REMOVE = 108;
|
|
static constexpr uint64_t SYS_WAITSET_WAIT = 109;
|
|
static constexpr uint64_t SYS_PROC_OPEN = 110;
|
|
static constexpr uint64_t SYS_SURFACE_CREATE = 111;
|
|
static constexpr uint64_t SYS_SURFACE_MAP = 112;
|
|
static constexpr uint64_t SYS_SURFACE_RESIZE = 113;
|
|
|
|
// Shared library syscalls
|
|
static constexpr uint64_t SYS_LOAD_LIB = 114;
|
|
static constexpr uint64_t SYS_UNLOAD_LIB = 115;
|
|
static constexpr uint64_t SYS_DLSYM = 116;
|
|
static constexpr uint64_t SYS_GETLIBBASE = 117;
|
|
|
|
/* CrashReport */
|
|
static constexpr uint64_t SYS_CRASH_REPORT = 118;
|
|
static constexpr uint64_t SYS_CLIPBOARD_SET_TEXT = 119;
|
|
static constexpr uint64_t SYS_CLIPBOARD_GET_INFO = 120;
|
|
static constexpr uint64_t SYS_CLIPBOARD_GET_TEXT = 121;
|
|
static constexpr uint64_t SYS_CLIPBOARD_CLEAR = 122;
|
|
static constexpr uint64_t SYS_INPUT_WAIT = 123;
|
|
static constexpr uint64_t SYS_DRIVELABEL = 124;
|
|
static constexpr uint64_t SYS_NETSTATUS = 125;
|
|
static constexpr uint64_t SYS_DRIVEKIND = 127;
|
|
|
|
// Audio mixer enumeration
|
|
static constexpr uint64_t SYS_AUDIOLIST = 128;
|
|
// Block until the mixer state serial differs from the caller's snapshot.
|
|
static constexpr uint64_t SYS_AUDIOWAIT = 129;
|
|
|
|
// Threading
|
|
static constexpr uint64_t SYS_THREAD_SPAWN = 130;
|
|
static constexpr uint64_t SYS_THREAD_EXIT = 131;
|
|
static constexpr uint64_t SYS_THREAD_JOIN = 132;
|
|
static constexpr uint64_t SYS_THREAD_SELF = 133;
|
|
|
|
// Flush + unmount persistent volumes for power-off
|
|
static constexpr uint64_t SYS_FS_SYNC = 134;
|
|
|
|
// Cross-process graceful power-off request channel
|
|
static constexpr uint64_t SYS_POWER_REQUEST = 135;
|
|
|
|
// Paginated directory read (path, names, max, startIndex)
|
|
static constexpr uint64_t SYS_READDIR_AT = 136;
|
|
|
|
// Set adapter BD_ADDR (6-byte buffer, addr[0] = LSB)
|
|
static constexpr uint64_t SYS_BTSETADDR = 137;
|
|
|
|
// List bonded (paired) devices / forget a bond
|
|
static constexpr uint64_t SYS_BTBONDS = 138;
|
|
static constexpr uint64_t SYS_BTFORGET = 139;
|
|
|
|
/* Reserved: former SDR API. Kept unavailable to preserve ABI numbering. */
|
|
static constexpr uint64_t SYS_RESERVED_140 = 140;
|
|
static constexpr uint64_t SYS_RESERVED_141 = 141;
|
|
static constexpr uint64_t SYS_RESERVED_142 = 142;
|
|
static constexpr uint64_t SYS_RESERVED_143 = 143;
|
|
static constexpr uint64_t SYS_RESERVED_144 = 144;
|
|
static constexpr uint64_t SYS_RESERVED_145 = 145;
|
|
static constexpr uint64_t SYS_RESERVED_146 = 146;
|
|
static constexpr uint64_t SYS_RESERVED_147 = 147;
|
|
static constexpr uint64_t SYS_RESERVED_148 = 148;
|
|
|
|
// CPU power/thermal status
|
|
static constexpr uint64_t SYS_POWERINFO = 149; // (PowerInfo*) -> 0, -1 unsupported
|
|
|
|
// Framebuffer page flip (double-buffered scanout)
|
|
static constexpr uint64_t SYS_FBFLIP = 150;
|
|
|
|
// Absolute path of the running executable (for argv[0]).
|
|
static constexpr uint64_t SYS_GETEXECPATH = 151; // (index, flags) -> new front index; index=-1 queries support (1/0); flags bit0 = wait vsync
|
|
|
|
// Path metadata (size, timestamps, mode). (const char* path, FileStat* out) -> 0, -1 on error/unsupported.
|
|
static constexpr uint64_t SYS_STAT = 152;
|
|
static constexpr uint64_t SYS_SETUNIXTIME = 153;
|
|
|
|
// Display/modesetting control
|
|
static constexpr uint64_t SYS_DISPLAYINFO = 154;
|
|
static constexpr uint64_t SYS_DISPLAYMODES = 155;
|
|
static constexpr uint64_t SYS_DISPLAYSETMODE = 156;
|
|
static constexpr uint64_t SYS_DISPLAYBRIGHTNESS = 157;
|
|
|
|
// Wi-Fi adapter control
|
|
static constexpr uint64_t SYS_WIFI_SCAN = 158; // (WifiNetwork*, maxCount, timeoutMs) -> count
|
|
static constexpr uint64_t SYS_WIFI_INFO = 159; // (WifiInfo*) -> 0, -1 if absent
|
|
static constexpr uint64_t SYS_WIFI_CONNECT = 160; // (ssid, password) -> 0, <0 on error
|
|
static constexpr uint64_t SYS_WIFI_DISCONNECT = 161; // () -> 0
|
|
static constexpr uint64_t SYS_WIFI_SCAN_START = 162; // (timeoutMs) -> 0 started, 1 busy, -1 no adapter
|
|
static constexpr uint64_t SYS_WIFI_RESULTS = 163; // (WifiNetwork*, maxCount) -> count, no radio work
|
|
static constexpr uint64_t SYS_WIFI_CONNECT_ASYNC = 164; // (ssid, password) -> 0 accepted, <0 on error
|
|
static constexpr uint64_t SYS_NETIFS = 165; // (NetIfInfo*, maxCount) -> count
|
|
static constexpr uint64_t SYS_GETCHAR_NB = 166; // () -> ascii, 0 if nothing pending; never blocks
|
|
static constexpr uint64_t SYS_UTIME = 167;
|
|
static constexpr uint64_t SYS_MMAP_ANON = 168;
|
|
static constexpr uint64_t SYS_MUNMAP = 169;
|
|
static constexpr uint64_t SYS_MPROTECT = 170;
|
|
static constexpr uint64_t SYS_GETENVIRON = 171;
|
|
static constexpr uint64_t SYS_SETENVIRON = 172;
|
|
static constexpr uint64_t SYS_SPAWN_ENV = 173;
|
|
|
|
/* Generic userspace USB interface access */
|
|
static constexpr uint64_t SYS_USB_LIST = 178;
|
|
static constexpr uint64_t SYS_USB_CLAIM = 179;
|
|
static constexpr uint64_t SYS_USB_CLOSE = 180;
|
|
static constexpr uint64_t SYS_USB_CONTROL = 181;
|
|
static constexpr uint64_t SYS_USB_BULK_IN_START = 182;
|
|
static constexpr uint64_t SYS_USB_BULK_IN_STOP = 183;
|
|
static constexpr uint64_t SYS_USB_BULK_IN_READ = 184;
|
|
|
|
static constexpr uint64_t SYS_LOG_WRITE = 176; // (logMessage) -> 0
|
|
static constexpr uint64_t SYS_TERMINAL_ATTACHED = 177; // () -> 1 when connected to a userspace terminal
|
|
static constexpr uint64_t SYS_SPAWN_CAPS = 185;
|
|
static constexpr uint64_t SYS_SPAWN_REDIR_CAPS = 186;
|
|
// As SYS_ALLOC, but commits every page up front instead of faulting them
|
|
// in one at a time. For buffers the caller is about to touch in full.
|
|
static constexpr uint64_t SYS_ALLOC_EAGER = 187; // (bytes) -> va, 0 on failure
|
|
|
|
/* Battery.hpp -- ACPI battery status */
|
|
static constexpr uint64_t SYS_BATTERYINFO = 188; // (BatteryInfo*) -> 0, -1 no battery device
|
|
|
|
// The caller's own capability masks.
|
|
static constexpr uint64_t SYS_GETCAPS = 189; // (SpawnCapabilities*) -> 0, -1 bad pointer
|
|
|
|
/* Storage.hpp */
|
|
static constexpr uint64_t SYS_VOLINFO = 190; // (VolInfo*, maxCount) -> count, -1 bad pointer
|
|
|
|
/* Consent.hpp */
|
|
static constexpr uint64_t SYS_CONSENT_REGISTER = 191; // () -> 0, -13 lacks CAP_COMPOSITOR, -1 another agent is live
|
|
static constexpr uint64_t SYS_CONSENT_NEXT = 192; // (ConsentRequest*) -> 1 delivered, 0 none queued
|
|
static constexpr uint64_t SYS_CONSENT_REPLY = 193; // (requestId, CONSENT_ALLOW/DENY) -> 0, -1 stale id
|
|
|
|
/* Kernel-owned process capabilities. User identities may namespace
|
|
per-user resources, but never participate in authorization decisions. */
|
|
static constexpr uint64_t CAP_PROCESS_ADMIN = 1ULL << 0;
|
|
static constexpr uint64_t CAP_POWER_REQUEST = 1ULL << 1;
|
|
static constexpr uint64_t CAP_POWER_CONTROL = 1ULL << 2;
|
|
static constexpr uint64_t CAP_SUSPEND = 1ULL << 3;
|
|
static constexpr uint64_t CAP_STORAGE_ADMIN = 1ULL << 4;
|
|
static constexpr uint64_t CAP_RAW_STORAGE = 1ULL << 5;
|
|
static constexpr uint64_t CAP_NETWORK_ADMIN = 1ULL << 6;
|
|
static constexpr uint64_t CAP_SET_TIME = 1ULL << 7;
|
|
static constexpr uint64_t CAP_USER_ADMIN = 1ULL << 8;
|
|
static constexpr uint64_t CAP_DISPLAY_ADMIN = 1ULL << 9;
|
|
static constexpr uint64_t CAP_DEVICE_ADMIN = 1ULL << 10;
|
|
static constexpr uint64_t CAP_LOG_READ = 1ULL << 11;
|
|
/* Write to the program images the system boots and runs (0:/os,
|
|
0:/apps). Deliberately separate from CAP_STORAGE_ADMIN: grants are
|
|
keyed on binary path, so writing an image is equivalent to acquiring
|
|
whatever that image is granted at its next launch. Formatting a data
|
|
volume must not carry that authority with it. */
|
|
static constexpr uint64_t CAP_SYSTEM_IMAGE = 1ULL << 12;
|
|
/* Map other processes' windows and deliver input events to them
|
|
(SYS_WINMAP, SYS_WINSENDEVENT): the desktop compositor's authority.
|
|
Anything holding it can read every window's pixels and click on any
|
|
window, including a consent prompt it is itself waiting on, so it is
|
|
never part of a session mask, never part of "all", and never
|
|
delegated by the compositor to what it launches. */
|
|
static constexpr uint64_t CAP_COMPOSITOR = 1ULL << 13;
|
|
static constexpr uint64_t CAP_ALL = (1ULL << 14) - 1;
|
|
static constexpr uint64_t CAP_STANDARD_SESSION = CAP_POWER_REQUEST | CAP_SUSPEND;
|
|
static constexpr uint64_t CAP_ADMIN_SESSION =
|
|
CAP_STANDARD_SESSION | CAP_PROCESS_ADMIN | CAP_STORAGE_ADMIN |
|
|
CAP_RAW_STORAGE | CAP_NETWORK_ADMIN | CAP_SET_TIME | CAP_USER_ADMIN |
|
|
CAP_DISPLAY_ADMIN | CAP_DEVICE_ADMIN | CAP_LOG_READ;
|
|
static_assert((CAP_STANDARD_SESSION & ~CAP_ADMIN_SESSION) == 0);
|
|
static_assert((CAP_ADMIN_SESSION & CAP_POWER_CONTROL) == 0,
|
|
"final power control belongs only to the session supervisor");
|
|
static_assert((CAP_ADMIN_SESSION & CAP_SYSTEM_IMAGE) == 0,
|
|
"an admin session must not imply authority to rewrite the "
|
|
"programs it launches; grant CAP_SYSTEM_IMAGE per binary");
|
|
static_assert((CAP_ADMIN_SESSION & CAP_COMPOSITOR) == 0,
|
|
"a session must not delegate the compositor's authority; "
|
|
"login grants it to the desktop directly");
|
|
// Capability denial for the Wi-Fi and USB syscalls only, which keep their
|
|
// own WIFI_ERR_* / USB_ERR_* spaces; everything else returns
|
|
// CapabilityDenied from StatusCodes.
|
|
static constexpr int SYS_ERR_PERMISSION = -13;
|
|
|
|
// A process holds two independent sets: what it may use (effective) and
|
|
// what it may pass to children (delegable). A launcher can delegate what
|
|
// it never uses itself, so neither set bounds the other.
|
|
struct SpawnCapabilities {
|
|
uint64_t effective;
|
|
uint64_t delegable;
|
|
};
|
|
|
|
// Both of the child's sets must come out of the parent's delegable set.
|
|
constexpr bool ValidCapabilityDelegation(const SpawnCapabilities& child,
|
|
uint64_t parentDelegable) {
|
|
return ((child.effective | child.delegable) & ~CAP_ALL) == 0 &&
|
|
(child.effective & ~parentDelegable) == 0 &&
|
|
(child.delegable & ~parentDelegable) == 0;
|
|
}
|
|
static_assert(ValidCapabilityDelegation(
|
|
{CAP_NETWORK_ADMIN, 0}, CAP_NETWORK_ADMIN));
|
|
static_assert(ValidCapabilityDelegation(
|
|
{0, CAP_NETWORK_ADMIN}, CAP_NETWORK_ADMIN));
|
|
static_assert(!ValidCapabilityDelegation(
|
|
{CAP_NETWORK_ADMIN, CAP_NETWORK_ADMIN}, 0));
|
|
static_assert(!ValidCapabilityDelegation(
|
|
{CAP_NETWORK_ADMIN | CAP_SET_TIME, 0}, CAP_NETWORK_ADMIN));
|
|
static_assert(!ValidCapabilityDelegation(
|
|
{0, CAP_NETWORK_ADMIN | CAP_SET_TIME}, CAP_NETWORK_ADMIN));
|
|
|
|
/* Capabilities a user can grant at first use through a consent prompt.
|
|
A consent grant never exceeds what the process's parent could have
|
|
delegated to it at spawn (its consent ceiling), is never delegable
|
|
onwards, and is issued only by the session's consent agent -- so it is
|
|
deferred delegation, not amplification. */
|
|
static constexpr uint64_t CAP_CONSENT_ELIGIBLE =
|
|
CAP_STORAGE_ADMIN | CAP_NETWORK_ADMIN | CAP_SET_TIME |
|
|
CAP_DISPLAY_ADMIN | CAP_LOG_READ;
|
|
static_assert((CAP_CONSENT_ELIGIBLE & ~CAP_ADMIN_SESSION) == 0,
|
|
"consent can only hand out authority an admin session holds");
|
|
|
|
static constexpr int CONSENT_DENY = 0;
|
|
static constexpr int CONSENT_ALLOW = 1;
|
|
// A request left unanswered this long is denied (and not remembered).
|
|
static constexpr uint64_t CONSENT_TIMEOUT_MS = 120000;
|
|
|
|
struct ConsentRequest {
|
|
uint64_t id;
|
|
uint64_t capability; // exactly one CAP_* bit
|
|
int32_t pid;
|
|
uint32_t imageProtected; // 1 when writing the image needs CAP_SYSTEM_IMAGE
|
|
char imagePath[256];
|
|
};
|
|
|
|
|
|
static constexpr int USB_ERR_INVALID = -1;
|
|
static constexpr int USB_ERR_BUSY = -2;
|
|
static constexpr int USB_ERR_DISCONNECTED = -3;
|
|
static constexpr int USB_ERR_UNSUPPORTED = -4;
|
|
static constexpr int USB_ERR_IO = -5;
|
|
static constexpr int USB_ERR_NO_RESOURCES = -6;
|
|
static constexpr int USB_ERR_NOT_FOUND = -7;
|
|
static constexpr int USB_ERR_KERNEL_BOUND = -8;
|
|
|
|
// Graceful power-off request actions (SYS_POWER_REQUEST). The desktop posts
|
|
// a pending action and exits; login.elf reads it, runs the shutdown stages,
|
|
// then issues the matching SYS_SHUTDOWN / SYS_RESET.
|
|
//
|
|
// A request can also be posted from inside the session -- the shell's
|
|
// shutdown builtin does. login only looks at it once the session leader
|
|
// exits, so the leader has to notice and stand down: POWER_REQ_PEEK is the
|
|
// non-destructive read it polls with. Only login consumes (QUERY), so a
|
|
// leader that peeks cannot swallow the request it is meant to act on.
|
|
enum PowerRequestAction : int {
|
|
POWER_REQ_QUERY = 0, // read-and-clear the pending action
|
|
POWER_REQ_SHUTDOWN = 1,
|
|
POWER_REQ_REBOOT = 2,
|
|
POWER_REQ_PEEK = 3, // read the pending action without clearing it
|
|
};
|
|
|
|
static constexpr uint32_t CLIPBOARD_MAX_TEXT_BYTES = 256 * 1024;
|
|
|
|
static constexpr uint32_t IPC_SIGNAL_READABLE = 1u << 0;
|
|
static constexpr uint32_t IPC_SIGNAL_WRITABLE = 1u << 1;
|
|
static constexpr uint32_t IPC_SIGNAL_PEER_CLOSED = 1u << 2;
|
|
static constexpr uint32_t IPC_SIGNAL_EXITED = 1u << 3;
|
|
static constexpr uint32_t IPC_SIGNAL_READY = 1u << 4;
|
|
|
|
// Audio control commands (for SYS_AUDIOCTL).
|
|
//
|
|
// Commands 0..3 act on the stream named by the handle argument.
|
|
// Commands 7..12 act on the global master and ignore the handle.
|
|
static constexpr int AUDIO_CTL_SET_VOLUME = 0;
|
|
static constexpr int AUDIO_CTL_GET_VOLUME = 1;
|
|
static constexpr int AUDIO_CTL_GET_POS = 2;
|
|
static constexpr int AUDIO_CTL_PAUSE = 3;
|
|
static constexpr int AUDIO_CTL_GET_OUTPUT = 4; // 0=HDA, 1=Bluetooth
|
|
static constexpr int AUDIO_CTL_SET_OUTPUT = 5; // Switch audio output
|
|
static constexpr int AUDIO_CTL_BT_STATUS = 6; // 0=unavailable, 1=setup, 2=ready
|
|
static constexpr int AUDIO_CTL_SET_MASTER_VOLUME = 7; // 0-100
|
|
static constexpr int AUDIO_CTL_GET_MASTER_VOLUME = 8;
|
|
static constexpr int AUDIO_CTL_SET_MUTE = 9; // 0/1, per-stream
|
|
static constexpr int AUDIO_CTL_GET_MUTE = 10;
|
|
static constexpr int AUDIO_CTL_SET_MASTER_MUTE = 11;
|
|
static constexpr int AUDIO_CTL_GET_MASTER_MUTE = 12;
|
|
static constexpr int AUDIO_OUTPUT_HDA = 0;
|
|
static constexpr int AUDIO_OUTPUT_BLUETOOTH = 1;
|
|
|
|
static constexpr int SOCK_TCP = 1;
|
|
static constexpr int SOCK_UDP = 2;
|
|
|
|
struct NetCfg {
|
|
uint32_t ipAddress; // network byte order
|
|
uint32_t subnetMask; // network byte order
|
|
uint32_t gateway; // network byte order
|
|
uint8_t macAddress[6];
|
|
uint8_t _pad[2];
|
|
uint32_t dnsServer; // network byte order
|
|
};
|
|
|
|
struct NetStatus {
|
|
uint8_t initialized;
|
|
uint8_t linkUp;
|
|
uint8_t polling;
|
|
uint8_t _pad0;
|
|
char driver[32];
|
|
uint64_t rxPackets;
|
|
uint64_t txPackets;
|
|
};
|
|
|
|
struct DateTime {
|
|
uint16_t Year;
|
|
uint8_t Month;
|
|
uint8_t Day;
|
|
uint8_t Hour;
|
|
uint8_t Minute;
|
|
uint8_t Second;
|
|
};
|
|
|
|
// Path metadata returned by SYS_STAT. Timestamps are UTC unix seconds;
|
|
// a filesystem that does not record a given time reports it as 0.
|
|
struct FileStat {
|
|
uint64_t size; // file size in bytes
|
|
int64_t mtime; // last data modification time
|
|
int64_t ctime; // last inode (metadata) change time
|
|
int64_t atime; // last access time
|
|
uint32_t mode; // ext2/POSIX mode bits (type + permissions)
|
|
uint32_t isDir; // 1 if the entry is a directory, else 0
|
|
};
|
|
|
|
struct FbInfo {
|
|
uint64_t width;
|
|
uint64_t height;
|
|
uint64_t pitch; // bytes per scanline
|
|
uint64_t bpp; // bits per pixel (32)
|
|
uint64_t userAddr; // filled by SYS_FBMAP (0 until mapped)
|
|
};
|
|
|
|
enum DisplayConnectorType : uint8_t {
|
|
DISPLAY_CONNECTOR_UNKNOWN = 0,
|
|
DISPLAY_CONNECTOR_EDP = 1,
|
|
DISPLAY_CONNECTOR_DP = 2,
|
|
DISPLAY_CONNECTOR_HDMI = 3,
|
|
DISPLAY_CONNECTOR_DVI = 4,
|
|
DISPLAY_CONNECTOR_VGA = 5,
|
|
DISPLAY_CONNECTOR_LVDS = 6,
|
|
};
|
|
|
|
static constexpr uint32_t DISPLAY_CAP_MODESET = 1u << 0;
|
|
static constexpr uint32_t DISPLAY_CAP_EDID = 1u << 1;
|
|
static constexpr uint32_t DISPLAY_CAP_BRIGHTNESS = 1u << 2;
|
|
static constexpr uint32_t DISPLAY_CAP_PAGE_FLIP = 1u << 3;
|
|
static constexpr uint32_t DISPLAY_CAP_VBLANK_IRQ = 1u << 4;
|
|
static constexpr uint32_t DISPLAY_CAP_SAFE_SWITCH = 1u << 5;
|
|
|
|
static constexpr uint32_t DISPLAY_MODE_PREFERRED = 1u << 0;
|
|
static constexpr uint32_t DISPLAY_MODE_CURRENT = 1u << 1;
|
|
static constexpr uint32_t DISPLAY_MODE_DRIVER_VALID = 1u << 2;
|
|
|
|
struct DisplayModeInfo {
|
|
uint32_t width;
|
|
uint32_t height;
|
|
uint32_t refreshMilliHz;
|
|
uint32_t pixelClockKHz;
|
|
uint32_t flags;
|
|
uint32_t _pad;
|
|
};
|
|
|
|
struct DisplayInfo {
|
|
uint32_t capabilities;
|
|
uint32_t modeCount;
|
|
int32_t currentMode;
|
|
int32_t brightness; // 0..100, or -1 when unavailable
|
|
uint16_t deviceId;
|
|
uint8_t generation;
|
|
uint8_t connectorType;
|
|
uint8_t connected;
|
|
uint8_t _pad0[3];
|
|
char gpuName[64];
|
|
char connectorName[32];
|
|
char monitorName[64];
|
|
};
|
|
|
|
struct SysInfo {
|
|
char osName[32];
|
|
char osVersion[32];
|
|
uint32_t apiVersion;
|
|
uint32_t maxProcesses;
|
|
uint32_t buildNumber; // monotonic kernel build number
|
|
};
|
|
|
|
struct KeyEvent {
|
|
uint8_t scancode;
|
|
char ascii;
|
|
bool pressed;
|
|
bool shift;
|
|
bool ctrl;
|
|
bool alt;
|
|
bool capslock;
|
|
// Right Alt held, reported separately from alt so keyboard layouts can
|
|
// use it as AltGr without swallowing left-Alt shortcuts.
|
|
bool altgr;
|
|
// Key came from an E0-prefixed scancode (keypad "/" and Enter share a
|
|
// scancode with the main-block keys). Layout translation must skip it.
|
|
bool extended;
|
|
};
|
|
|
|
struct MouseState {
|
|
int32_t x;
|
|
int32_t y;
|
|
int32_t scrollDelta;
|
|
uint8_t buttons;
|
|
};
|
|
|
|
struct IpcWaitResult {
|
|
int32_t index;
|
|
uint32_t signals;
|
|
};
|
|
|
|
struct ClipboardInfo {
|
|
uint32_t textBytes;
|
|
uint32_t _pad;
|
|
uint64_t serial;
|
|
};
|
|
|
|
// One entry per active mixer stream; returned by SYS_AUDIOLIST.
|
|
struct AudioStreamInfo {
|
|
int32_t handle;
|
|
int32_t ownerPid;
|
|
char name[64];
|
|
uint32_t sampleRate;
|
|
uint8_t channels;
|
|
uint8_t bitsPerSample;
|
|
uint8_t volume; // 0-100
|
|
uint8_t muted; // 0/1
|
|
uint8_t paused; // 0/1
|
|
uint8_t _pad[7];
|
|
};
|
|
|
|
// Window server shared types
|
|
struct WinEvent {
|
|
uint8_t type; // 0=key, 1=mouse, 2=resize, 3=close, 4=scale
|
|
uint8_t _pad[3];
|
|
union {
|
|
KeyEvent key;
|
|
struct { int32_t x, y, scroll; uint8_t buttons, prev_buttons; } mouse;
|
|
struct { int32_t w, h; } resize;
|
|
struct { int32_t scale; } scale;
|
|
};
|
|
};
|
|
|
|
struct WinInfo {
|
|
int32_t id;
|
|
int32_t ownerPid;
|
|
char title[64];
|
|
int32_t width, height;
|
|
uint8_t dirty;
|
|
uint8_t cursor; // 0=arrow, 1=resize_h, 2=resize_v
|
|
uint8_t _pad2[2];
|
|
uint32_t flags;
|
|
};
|
|
|
|
static constexpr uint32_t WIN_FLAG_FULLSCREEN = 1u << 0;
|
|
|
|
struct WinCreateResult {
|
|
int32_t id; // -1 on failure
|
|
uint32_t _pad;
|
|
uint64_t pixelVa; // VA of pixel buffer in caller's address space
|
|
};
|
|
|
|
struct DevInfo {
|
|
uint8_t category; // 0=CPU, 1=Interrupt, 2=Timer, 3=Input, 4=USB, 5=Network, 6=Display, 7=Storage, 8=PCI, 9=Audio, 10=ACPI
|
|
uint8_t _pad[3];
|
|
char name[48];
|
|
char detail[48];
|
|
};
|
|
|
|
struct DiskInfo {
|
|
uint8_t port; // block device index
|
|
uint8_t type; // 0=none, 1=SATA, 2=SATAPI, 3=NVMe, 4=USB mass storage
|
|
uint8_t sataGen; // SATA gen (1/2/3)
|
|
uint8_t _pad0;
|
|
uint64_t sectorCount; // Total user-addressable sectors
|
|
uint16_t sectorSizeLog; // Logical sector size (bytes)
|
|
uint16_t sectorSizePhys; // Physical sector size (bytes)
|
|
uint16_t rpm; // 0=unknown, 1=SSD, else RPM
|
|
uint16_t ncqDepth; // 0 if no NCQ
|
|
uint8_t supportsLba48;
|
|
uint8_t supportsNcq;
|
|
uint8_t supportsTrim;
|
|
uint8_t supportsSmart;
|
|
uint8_t supportsWriteCache;
|
|
uint8_t supportsReadAhead;
|
|
uint8_t _pad1[2];
|
|
char model[41];
|
|
char serial[21];
|
|
char firmware[9];
|
|
char _pad2[1];
|
|
};
|
|
|
|
struct PartGuid {
|
|
uint32_t Data1;
|
|
uint16_t Data2;
|
|
uint16_t Data3;
|
|
uint8_t Data4[8];
|
|
};
|
|
|
|
struct PartInfo {
|
|
int32_t blockDev; // block device index
|
|
uint32_t _pad0;
|
|
uint64_t startLba;
|
|
uint64_t endLba;
|
|
uint64_t sectorCount;
|
|
PartGuid typeGuid;
|
|
PartGuid uniqueGuid;
|
|
uint64_t attributes;
|
|
char name[72]; // ASCII partition name
|
|
char typeName[24]; // human-readable type name
|
|
};
|
|
|
|
// One mounted volume (returned by SYS_VOLINFO). A volume is a single
|
|
// mounted filesystem, which is what a drive number names: one physical
|
|
// disk with three partitions occupies three drive numbers.
|
|
//
|
|
// A volume with no backing partition -- the boot ramdisk -- reports
|
|
// blockDev and partIndex as -1 and leaves the geometry fields zero.
|
|
struct VolInfo {
|
|
int32_t drive; // VFS drive number ("N:/")
|
|
int32_t blockDev; // backing block device index, -1 if none
|
|
int32_t partIndex; // global GPT partition index, -1 if none
|
|
uint32_t kind; // BlockDeviceKind: 0=none/ramdisk, 1=SATA, 2=SATAPI, 3=NVMe, 4=USB MSC
|
|
uint64_t startLba; // partition start LBA, 0 if none
|
|
uint64_t sectorCount; // partition length in sectors, 0 if none
|
|
uint32_t sectorSize; // logical sector size in bytes, 0 if none
|
|
uint32_t _pad0;
|
|
char label[36]; // filesystem volume label, "" if unset
|
|
char fsType[12]; // "ext2", "FAT32", "ramdisk", "" if unknown
|
|
char partName[72]; // GPT partition name, "" if none
|
|
char model[41]; // backing disk model, "" if none
|
|
char _pad1[3];
|
|
};
|
|
|
|
struct GptAddParams {
|
|
int32_t blockDev;
|
|
uint32_t _pad0;
|
|
uint64_t startLba; // 0 = auto (fill largest free region)
|
|
uint64_t endLba; // 0 = auto
|
|
PartGuid typeGuid;
|
|
char name[72];
|
|
};
|
|
|
|
// Filesystem type IDs for SYS_FSFORMAT
|
|
static constexpr int FS_TYPE_FAT32 = 1;
|
|
static constexpr int FS_TYPE_EXT2 = 2;
|
|
|
|
struct FsFormatParams {
|
|
int32_t partIndex; // global partition index
|
|
int32_t fsType; // FS_TYPE_FAT32, etc.
|
|
char label[32]; // volume label
|
|
};
|
|
|
|
// Bluetooth scan result (returned by SYS_BTSCAN)
|
|
struct BtScanResult {
|
|
uint8_t bdAddr[6];
|
|
uint8_t _pad[2];
|
|
uint32_t classOfDevice;
|
|
int8_t rssi;
|
|
uint8_t _pad2[3];
|
|
char name[64];
|
|
};
|
|
|
|
// Bluetooth connected device info (returned by SYS_BTLIST)
|
|
struct BtDevInfo {
|
|
uint8_t bdAddr[6];
|
|
uint8_t connected;
|
|
uint8_t encrypted;
|
|
uint16_t handle;
|
|
uint8_t linkType;
|
|
uint8_t _pad;
|
|
};
|
|
|
|
// Bluetooth adapter info (returned by SYS_BTINFO)
|
|
struct BtAdapterInfo {
|
|
uint8_t bdAddr[6];
|
|
uint8_t initialized;
|
|
uint8_t scanning;
|
|
char name[64];
|
|
};
|
|
|
|
// Bluetooth bonded (paired) device (returned by SYS_BTBONDS)
|
|
struct BtBondInfo {
|
|
uint8_t bdAddr[6];
|
|
uint8_t _pad[2];
|
|
};
|
|
|
|
struct UsbInterfaceInfo {
|
|
uint8_t slotId;
|
|
uint8_t portId;
|
|
uint8_t speed;
|
|
uint8_t interfaceNumber;
|
|
uint16_t vendorId;
|
|
uint16_t productId;
|
|
uint8_t deviceClass;
|
|
uint8_t interfaceClass;
|
|
uint8_t interfaceSubClass;
|
|
uint8_t interfaceProtocol;
|
|
uint8_t bulkInEndpoint;
|
|
uint8_t bulkOutEndpoint;
|
|
uint16_t bulkInMaxPacket;
|
|
uint16_t bulkOutMaxPacket;
|
|
uint8_t kernelDriverBound;
|
|
uint8_t claimed;
|
|
uint8_t _reserved[4];
|
|
} __attribute__((packed));
|
|
|
|
struct UsbControlRequest {
|
|
uint8_t requestType;
|
|
uint8_t request;
|
|
uint16_t value;
|
|
uint16_t index;
|
|
uint16_t length;
|
|
} __attribute__((packed));
|
|
static_assert(sizeof(UsbInterfaceInfo) == 24);
|
|
static_assert(sizeof(UsbControlRequest) == 8);
|
|
|
|
|
|
// Wi-Fi security suites reported in WifiNetwork.security.
|
|
static constexpr uint8_t WIFI_SEC_OPEN = 0;
|
|
static constexpr uint8_t WIFI_SEC_WEP = 1;
|
|
static constexpr uint8_t WIFI_SEC_WPA = 2;
|
|
static constexpr uint8_t WIFI_SEC_WPA2 = 3;
|
|
static constexpr uint8_t WIFI_SEC_WPA3 = 4;
|
|
|
|
// Adapter states reported in WifiInfo.state.
|
|
static constexpr uint8_t WIFI_STATE_ABSENT = 0; // no device
|
|
static constexpr uint8_t WIFI_STATE_DETECTED = 1; // waiting for firmware load
|
|
static constexpr uint8_t WIFI_STATE_BOOTING = 2;
|
|
static constexpr uint8_t WIFI_STATE_RUNNING = 3;
|
|
static constexpr uint8_t WIFI_STATE_ERROR = 4;
|
|
static constexpr uint8_t WIFI_STATE_RFKILL = 5; // radio disabled in hardware
|
|
|
|
// One scanned network (returned by SYS_WIFI_SCAN).
|
|
struct WifiNetwork {
|
|
char ssid[36]; // NUL-terminated; empty for hidden networks
|
|
uint8_t bssid[6];
|
|
uint8_t channel;
|
|
int8_t rssi; // dBm
|
|
uint8_t band; // 0 = 2.4 GHz, 1 = 5 GHz
|
|
uint8_t security; // WIFI_SEC_*
|
|
uint16_t beaconInterval; // TU
|
|
};
|
|
|
|
// Association progress reported in WifiInfo.connState.
|
|
static constexpr uint32_t WIFI_CONN_IDLE = 0;
|
|
static constexpr uint32_t WIFI_CONN_CONTEXTS_UP = 1;
|
|
static constexpr uint32_t WIFI_CONN_AUTHENTICATING = 2;
|
|
static constexpr uint32_t WIFI_CONN_AUTHENTICATED = 3;
|
|
static constexpr uint32_t WIFI_CONN_ASSOCIATING = 4;
|
|
static constexpr uint32_t WIFI_CONN_ASSOCIATED = 5;
|
|
static constexpr uint32_t WIFI_CONN_HANDSHAKING = 6;
|
|
static constexpr uint32_t WIFI_CONN_CONNECTED = 7;
|
|
static constexpr uint32_t WIFI_CONN_FAILED = 8;
|
|
|
|
// Negative results from SYS_WIFI_CONNECT.
|
|
static constexpr int WIFI_ERR_NO_ADAPTER = -1; // no adapter, or not ready
|
|
static constexpr int WIFI_ERR_NOT_FOUND = -2; // SSID absent from the scan
|
|
static constexpr int WIFI_ERR_NEED_KEY = -3; // encrypted, no passphrase
|
|
static constexpr int WIFI_ERR_UNSUPPORTED = -4; // WPA3-SAE, WEP, enterprise
|
|
static constexpr int WIFI_ERR_AUTH = -5; // key exchange rejected
|
|
static constexpr int WIFI_ERR_TIMEOUT = -6; // AP never answered
|
|
static constexpr int WIFI_ERR_FAILED = -7; // anything else
|
|
|
|
// Adapter status (returned by SYS_WIFI_INFO).
|
|
struct WifiInfo {
|
|
uint8_t mac[6];
|
|
uint8_t present; // 1 if a supported device was found
|
|
uint8_t state; // WIFI_STATE_*
|
|
uint8_t scanning;
|
|
uint8_t bands; // bit0 = 2.4 GHz, bit1 = 5 GHz
|
|
uint16_t channels; // usable channels after regulatory filtering
|
|
char fwVersion[32];
|
|
uint64_t rxPackets;
|
|
uint32_t fwErrors;
|
|
uint32_t connState; // WIFI_CONN_*
|
|
uint64_t txPackets;
|
|
char ssid[36]; // network joined, empty when disconnected
|
|
uint8_t bssid[6];
|
|
uint8_t connected; // 1 once the link can carry IP traffic
|
|
uint8_t channel;
|
|
int32_t lastError; // WIFI_ERR_* from the last async join, 0 = none
|
|
uint32_t scanGeneration; // bumped every time a scan finishes
|
|
uint8_t joining; // 1 while an async join is in flight
|
|
uint8_t _pad[3];
|
|
};
|
|
|
|
// Link-layer interface kinds reported in NetIfInfo.kind.
|
|
static constexpr uint8_t NETIF_KIND_ETHERNET = 0;
|
|
static constexpr uint8_t NETIF_KIND_WIRELESS = 1;
|
|
|
|
// One registered link-layer interface (returned by SYS_NETIFS). The IP
|
|
// configuration is global to the stack, so it belongs to whichever
|
|
// interface reports active = 1.
|
|
struct NetIfInfo {
|
|
char name[16]; // "eth0", "wlan0"
|
|
uint8_t mac[6];
|
|
uint8_t kind; // NETIF_KIND_*
|
|
uint8_t linkUp;
|
|
uint8_t active; // 1 if this is the interface carrying traffic
|
|
uint8_t _pad[3];
|
|
};
|
|
|
|
struct ThermalInfo {
|
|
char name[32]; // short zone name (e.g. "THRM", "TZ00")
|
|
int32_t temperature; // tenths of degrees Celsius, or -1 if unavailable
|
|
uint32_t _pad;
|
|
};
|
|
|
|
// CPU power/thermal snapshot (returned by SYS_POWERINFO)
|
|
struct PowerInfo {
|
|
uint8_t hwpActive; // hardware P-state scaling enabled
|
|
uint8_t throttling; // thermal governor currently limiting frequency
|
|
uint8_t tempC; // package temperature, degrees C (0 = unknown)
|
|
uint8_t tjMaxC; // hardware throttle temperature
|
|
uint8_t highestPerf; // HWP performance range (ratio units)
|
|
uint8_t lowestPerf;
|
|
uint8_t curMaxPerf; // thermal governor's current ceiling
|
|
uint8_t epp; // energy/perf preference (0=perf, 255=power)
|
|
uint32_t baseMHz; // nominal base frequency (0 = unknown)
|
|
uint32_t maxMHz; // max turbo frequency
|
|
uint32_t effMHz; // measured average active frequency
|
|
uint32_t apIdleHint; // MWAIT hint used for AP deep idle
|
|
};
|
|
|
|
struct ProcInfo {
|
|
int32_t pid;
|
|
int32_t parentPid;
|
|
uint8_t state; // 0=Free, 1=Ready, 2=Running, 3=Blocked, 4=Terminated
|
|
uint8_t _pad[3];
|
|
char name[64];
|
|
uint64_t heapUsed; // Distance from UserHeapBase to high-water mark
|
|
uint64_t cpuTimeMs; // accumulated scheduler runtime
|
|
uint64_t effectiveCaps;
|
|
uint64_t delegableCaps;
|
|
};
|
|
|
|
struct MemStats {
|
|
uint64_t totalBytes;
|
|
uint64_t freeBytes;
|
|
uint64_t usedBytes;
|
|
uint64_t pageSize;
|
|
};
|
|
|
|
// Battery status (returned by SYS_BATTERYINFO). A machine with no battery
|
|
// device fails the call outright; `present` distinguishes a laptop with the
|
|
// pack removed from one that is running on it.
|
|
struct BatteryInfo {
|
|
uint8_t present; // a battery is installed
|
|
uint8_t charging;
|
|
uint8_t discharging;
|
|
uint8_t critical;
|
|
uint8_t acOnline; // AC adapter connected
|
|
uint8_t hasAcAdapter; // an AC adapter device exists at all
|
|
uint8_t percent; // 0..100, 0 when capacity is unknown
|
|
uint8_t powerUnitMilliAmps; // capacities are mAh/mA, not mWh/mW
|
|
uint32_t remainingCapacity;
|
|
uint32_t fullCapacity; // last full charge capacity
|
|
uint32_t designCapacity;
|
|
uint32_t presentRate; // mW or mA, 0 when unknown
|
|
uint32_t voltageMv;
|
|
int32_t minutesRemaining; // -1 when not estimable (e.g. charging)
|
|
};
|
|
|
|
// Crash report (filled by kernel on process fault, returned via SYS_CRASH_REPORT)
|
|
struct CrashReportInfo {
|
|
int pid;
|
|
char processName[64];
|
|
uint8_t exceptionVector;
|
|
char exceptionName[32];
|
|
uint64_t faultingAddress;
|
|
uint64_t instructionPointer;
|
|
uint64_t stackPointer;
|
|
uint64_t codeSegment;
|
|
uint64_t flags;
|
|
uint64_t stackSegment;
|
|
uint64_t stackWords[8];
|
|
uint8_t stackWordCount;
|
|
uint8_t pfPresent : 1;
|
|
uint8_t pfWrite : 1;
|
|
uint8_t pfUser : 1;
|
|
uint8_t pfReservedWrite : 1;
|
|
uint8_t pfInstructionFetch : 1;
|
|
uint8_t pfProtectionKey : 1;
|
|
uint8_t pfShadowStack : 1;
|
|
uint8_t pfSGX : 1;
|
|
uint64_t timestampTick;
|
|
};
|
|
|
|
}
|