feat: unify system status codes

template/sysroot/include/montauk/syscall.h

@@ -6,6 +6,7 @@
 
 #pragma once
 #include <Api/Syscall.hpp>
+#include <montauk/statuscodes.h>
 
 namespace montauk {
 
@@ -120,6 +121,28 @@ namespace montauk {
     inline int spawn(const char* path, const char* args = nullptr) {
         return (int)syscall2(montauk::abi::SYS_SPAWN, (uint64_t)path, (uint64_t)args);
     }
+    inline int spawn_with_caps(const char* path, const char* args,
+                               const char* user,
+                               const montauk::abi::SpawnCapabilities& capabilities) {
+        return (int)syscall4(montauk::abi::SYS_SPAWN_CAPS, (uint64_t)path,
+                             (uint64_t)args, (uint64_t)user,
+                             (uint64_t)&capabilities);
+    }
+    // The calling process's own capability masks. Returns 0 on success.
+    inline int getcaps(montauk::abi::SpawnCapabilities* out) {
+        return (int)syscall1(montauk::abi::SYS_GETCAPS, (uint64_t)out);
+    }
+
+    // Consent agent.
+    inline int consent_register() {
+        return (int)syscall0(montauk::abi::SYS_CONSENT_REGISTER);
+    }
+    inline int consent_next(montauk::abi::ConsentRequest* out) {
+        return (int)syscall1(montauk::abi::SYS_CONSENT_NEXT, (uint64_t)out);
+    }
+    inline int consent_reply(uint64_t id, int decision) {
+        return (int)syscall2(montauk::abi::SYS_CONSENT_REPLY, id, (uint64_t)decision);
+    }
     inline int chdir(const char* path) {
         return (int)syscall1(montauk::abi::SYS_CHDIR, (uint64_t)path);
     }
@@ -184,6 +207,10 @@ namespace montauk {
 
     // Memory
     inline void* alloc(uint64_t size) { return (void*)syscall1(montauk::abi::SYS_ALLOC, size); }
+    // As alloc(), but the kernel commits the whole range immediately. Use it
+    // for a buffer that is about to be written end to end: the lazy path costs
+    // one page fault, one mutex acquire and one VMA walk per 4 KiB.
+    inline void* alloc_eager(uint64_t size) { return (void*)syscall1(montauk::abi::SYS_ALLOC_EAGER, size); }
     inline void free(void* ptr) { syscall1(montauk::abi::SYS_FREE, (uint64_t)ptr); }
 
     // Timekeeping
@@ -391,7 +418,10 @@ namespace montauk {
     }
 
     // Timezone offset (total minutes from UTC)
-    inline void settz(int offset_minutes) { syscall1(montauk::abi::SYS_SETTZ, (uint64_t)(int64_t)offset_minutes); }
+    inline int settz(int offset_minutes) {
+        return (int)syscall1(montauk::abi::SYS_SETTZ,
+                             (uint64_t)(int64_t)offset_minutes);
+    }
     inline int gettz() { return (int)syscall0(montauk::abi::SYS_GETTZ); }
 
     // Random number generation
@@ -400,14 +430,12 @@ namespace montauk {
     }
 
     // Power management
-    [[noreturn]] inline void reset() {
-        syscall0(montauk::abi::SYS_RESET);
-        __builtin_unreachable();
+    inline int reset() {
+        return (int)syscall0(montauk::abi::SYS_RESET);
     }
 
-    [[noreturn]] inline void shutdown() {
-        syscall0(montauk::abi::SYS_SHUTDOWN);
-        __builtin_unreachable();
+    inline int shutdown() {
+        return (int)syscall0(montauk::abi::SYS_SHUTDOWN);
     }
 
     inline int suspend() {
@@ -423,6 +451,13 @@ namespace montauk {
         return (int)syscall1(montauk::abi::SYS_POWER_REQUEST, (uint64_t)(int64_t)action);
     }
 
+    // Non-destructive read of the pending request, for a session leader that
+    // must stand down when something inside its session (the shell's shutdown
+    // builtin, say) asked for power-off. Returns POWER_REQ_QUERY when idle.
+    inline int power_request_pending() {
+        return power_request(montauk::abi::POWER_REQ_PEEK);
+    }
+
     // Mouse
     inline void mouse_state(montauk::abi::MouseState* out) { syscall1(montauk::abi::SYS_MOUSESTATE, (uint64_t)out); }
     inline void set_mouse_bounds(int32_t maxX, int32_t maxY) {
@@ -447,6 +482,13 @@ namespace montauk {
     inline int spawn_redir(const char* path, const char* args = nullptr) {
         return (int)syscall2(montauk::abi::SYS_SPAWN_REDIR, (uint64_t)path, (uint64_t)args);
     }
+    inline int spawn_redir_with_caps(
+            const char* path, const char* args,
+            const montauk::abi::SpawnCapabilities& capabilities) {
+        return (int)syscall3(montauk::abi::SYS_SPAWN_REDIR_CAPS,
+                             (uint64_t)path, (uint64_t)args,
+                             (uint64_t)&capabilities);
+    }
     inline int childio_read(int childPid, char* buf, int maxLen) {
         return (int)syscall3(montauk::abi::SYS_CHILDIO_READ, (uint64_t)childPid, (uint64_t)buf, (uint64_t)maxLen);
     }
@@ -484,6 +526,10 @@ namespace montauk {
     inline int partlist(montauk::abi::PartInfo* buf, int max) {
         return (int)syscall2(montauk::abi::SYS_PARTLIST, (uint64_t)buf, (uint64_t)max);
     }
+    // One entry per mounted volume (one filesystem, i.e. one drive number).
+    inline int volinfo(montauk::abi::VolInfo* buf, int max) {
+        return (int)syscall2(montauk::abi::SYS_VOLINFO, (uint64_t)buf, (uint64_t)max);
+    }
 
     // Raw block device I/O (driver-agnostic)
     inline int64_t disk_read(int blockDev, uint64_t lba, uint32_t sectorCount, void* buf) {
@@ -613,6 +659,13 @@ namespace montauk {
         return (int)syscall1(montauk::abi::SYS_BTINFO, (uint64_t)buf);
     }
 
+    // ACPI battery status. Returns 0 on success, or -1 on a machine with no
+    // battery device at all -- which is the signal not to draw an indicator.
+    // A laptop with the pack removed still returns 0, with present == 0.
+    inline int battery_info(montauk::abi::BatteryInfo* out) {
+        return (int)syscall1(montauk::abi::SYS_BATTERYINFO, (uint64_t)out);
+    }
+
     // Wi-Fi. scan() runs a full channel sweep and blocks until it finishes or
     // timeoutMs elapses, then fills buf with the networks seen; it returns the
     // number of entries written, or -1 when no adapter is ready.