major restructuring, prepare for smp

code/public/ntlite/boot_info.h

@@ -0,0 +1,44 @@
+#pragma once
+// boot_info.h  - shared between bootx64.efi and kernel.exe
+// The bootloader fills this structure and passes a pointer to KernelMain.
+#include <stdint.h>
+#include <ntlite/memory_map.h>
+
+#define BOOT_INFO_MAGIC    0x424F4F54494E464FULL   /* 'BOOTINFO' */
+#define MAX_BOOT_MODULES   32
+
+typedef struct BOOT_MODULE {
+    char      Name[32];        /* e.g. "hal.dll", "ide.sys"   */
+    uintptr_t VirtBase;        /* Virtual address (mapped)    */
+    uintptr_t PhysBase;        /* Raw physical address (file) */
+    size_t    ImageSize;       /* File size / Image size      */
+} BOOT_MODULE;
+
+typedef struct BOOT_INFO {
+    uint64_t      Magic;
+
+    /* Physical memory. */
+    MEMORY_MAP    MemoryMap;
+
+    /* GOP framebuffer. */
+    uintptr_t     FramebufferBase;
+    uint32_t      FramebufferWidth;
+    uint32_t      FramebufferHeight;
+    uint32_t      FramebufferStride;   /* pixels per row */
+
+    /* Loaded modules. */
+    BOOT_MODULE   Modules[MAX_BOOT_MODULES];
+    uint32_t      ModuleCount;
+    uint32_t      _pad1;
+
+    char          CommandLine[64];
+
+    /* ACPI RSDP physical address (for APIC, HPET). */
+    uintptr_t     RsdpPhysical;
+
+    /* Direct physical window base - always 0xFFFF880000000000. */
+    uintptr_t     PhysicalMapBase;
+
+    /* From boot.ini */
+    uint32_t      Debug;
+} BOOT_INFO;

code/public/ntlite/ddi/hal_api.h

@@ -0,0 +1,126 @@
+#pragma once
+// hal_api.h - HAL interface table exported as HalGetApi()
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <ntlite/status.h>
+
+typedef struct BOOT_INFO BOOT_INFO;
+
+typedef struct HAL_SCREEN {
+    void     (*Clear)(uint32_t color);
+    void     (*PutPixel)(int x, int y, uint32_t color);
+    void     (*Blit)(int x, int y, int w, int h, const uint32_t* pixels);
+    void     (*GetSize)(int* width, int* height);
+    void     (*Scroll)(int lines);
+    void     (*PutChar)(char c, int x, int y, uint32_t fg, uint32_t bg);
+    void     (*PrintChar)(char c, uint32_t fg, uint32_t bg);
+    // Hardware mouse cursor: save/restore background and blit sprite
+    void     (*DrawCursor)(int x, int y);
+    void     (*EraseCursor)(void);
+} HAL_SCREEN;
+
+typedef struct HAL_KEYBOARD {
+    uint8_t  (*Poll)(void);
+    uint8_t  (*ReadScancode)(void);
+    char     (*ReadChar)(void);
+    uint32_t (*GetModifiers)(void);
+    void     (*SetCallback)(void (*cb)(uint8_t scancode));
+    bool     (*IsKeyDown)(uint8_t scancode, bool extended);
+    void     (*Isr)(void);
+    // Optional bottom half, queued by the kernel after IRQ dispatch.
+    void     (*Dpc)(void);
+    uint8_t  IrqNumber;
+} HAL_KEYBOARD;
+
+// HAL_MOUSE – PS/2 auxiliary mouse on IRQ 12.
+// Packet format: standard 3-byte PS/2 (buttons, deltaX, deltaY).
+// Y is already screen-oriented (positive = down) after ISR inversion.
+typedef struct HAL_MOUSE {
+    // Non-blocking: returns true if a packet is waiting in the ring buffer.
+    bool     (*Poll)(void);
+    // Non-blocking dequeue. Returns false when buffer is empty.
+    // buttons: bit0=left, bit1=right, bit2=middle
+    bool     (*Read)(int* dx, int* dy, uint8_t* buttons);
+    // Callback invoked from DPC context after every completed packet.
+    void     (*SetCallback)(void (*cb)(int dx, int dy, uint8_t buttons));
+    // Absolute cursor position, clamped to screen bounds.
+    void     (*GetPosition)(int* x, int* y);
+    void     (*SetPosition)(int x, int y);
+    // Update the clamping rectangle (call after mode change / resize).
+    void     (*SetBounds)(int w, int h);
+    // Raw ISR – called by KeIrqDispatch for IRQ 12.
+    void     (*Isr)(void);
+    // Optional bottom half, queued by the kernel after IRQ dispatch.
+    void     (*Dpc)(void);
+    uint8_t  IrqNumber;   // always 12
+} HAL_MOUSE;
+
+typedef struct HAL_TIMER {
+    uint64_t (*QueryTicks)(void);
+    void     (*Stall)(uint32_t us);
+    void     (*Isr)(void);
+    uint8_t  IrqNumber;
+} HAL_TIMER;
+
+typedef struct HAL_PCI {
+    uint32_t (*Read32)(uint8_t bus, uint8_t dev,
+                             uint8_t fn, uint8_t reg);
+    void     (*Write32)(uint8_t bus, uint8_t dev,
+                              uint8_t fn, uint8_t reg, uint32_t val);
+    bool     (*FindDevice)(uint16_t vendor, uint16_t device,
+                           uint8_t* bus, uint8_t* dev, uint8_t* fn);
+    bool     (*FindClass)(uint8_t classCode, uint8_t subclass,
+                          uint8_t* bus, uint8_t* dev, uint8_t* fn);
+    // Returns the IRQ line from PCI config space (register 0x3C, byte 0).
+    // Returns 0xFF if no interrupt is wired.
+    uint8_t  (*GetIrqLine)(uint8_t bus, uint8_t dev, uint8_t fn);
+} HAL_PCI;
+
+typedef struct HAL_INTC {
+    void (*RouteIrq)(uint8_t irq);
+    void (*MaskIrq)(uint8_t irq);
+    void (*UnmaskIrq)(uint8_t irq);
+    void (*SendEoi)(void);
+} HAL_INTC;
+
+typedef struct HAL_POWER {
+    // ACPI S5 soft-off. Disables interrupts, writes SLP_EN to PM1a/b_CNT,
+    // and halts if firmware doesn't respond. Does not return.
+    void (*Shutdown)(void);
+} HAL_POWER;
+
+typedef struct HAL_API {
+    uint32_t     Version;
+    void         *(*PhysToVirt)(uint64_t physAddr);
+    HAL_SCREEN   Screen;
+    HAL_KEYBOARD Keyboard;
+    HAL_MOUSE    Mouse;
+    HAL_TIMER    Timer;
+    HAL_PCI      Pci;
+    HAL_INTC     Intc;
+    HAL_POWER    Power;
+} HAL_API;
+
+typedef struct HAL_INIT_PARAMS {
+    // Framebuffer
+    uintptr_t  FramebufferBase;
+    uint32_t   FramebufferWidth;
+    uint32_t   FramebufferHeight;
+    uint32_t   FramebufferStride;
+
+    // ACPI
+    uintptr_t  RsdpPhysical;
+
+    // Memory
+    uint64_t   PhysicalWindowBase;
+
+    // Debug
+    int        Debug;
+} HAL_INIT_PARAMS;
+
+#define HAL_API_VERSION  2
+
+__declspec(dllexport) const HAL_API* HalGetApi(void);
+__declspec(dllexport) void HalRegisterScheduler(void (*pKeSchedulerTick)(void));
+__declspec(dllexport) KSTATUS HalInitialize(const HAL_INIT_PARAMS* params);

code/public/ntlite/ddi/io_driver.h

@@ -0,0 +1,69 @@
+#pragma once
+// io_driver.h - definitive kernel driver/device I/O model
+//
+// Disk controllers register DEVICE_OBJECTs.  IRPs are submitted only through
+// IoCallDriver()/IoSubmitIrp(); drivers complete accepted IRPs by calling
+// IoCompleteRequest().  There is no legacy DISK_DRIVER submit table.
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <ntlite/status.h>
+
+typedef struct HAL_API HAL_API;
+typedef KSTATUS (*DRIVER_ENTRY_FN)(const HAL_API* hal);
+typedef void    (*DRIVER_UNLOAD_FN)(void);
+
+struct IRP;
+typedef struct DRIVER_OBJECT DRIVER_OBJECT;
+typedef struct DEVICE_OBJECT DEVICE_OBJECT;
+
+typedef enum IO_MAJOR_FUNCTION {
+    IRP_MJ_READ  = 0,
+    IRP_MJ_WRITE = 1,
+    IRP_MJ_DEVICE_CONTROL = 2,
+    IRP_MJ_MAXIMUM_FUNCTION = 3,
+} IO_MAJOR_FUNCTION;
+
+typedef KSTATUS (*PDRIVER_DISPATCH)(DEVICE_OBJECT* device, struct IRP* irp);
+
+struct DRIVER_OBJECT {
+    const char*       Name;
+    PDRIVER_DISPATCH  MajorFunction[IRP_MJ_MAXIMUM_FUNCTION];
+    DRIVER_UNLOAD_FN  DriverUnload;
+};
+
+struct DEVICE_OBJECT {
+    DRIVER_OBJECT* DriverObject;
+    void*          DeviceExtension;
+    uint32_t       Flags;
+    uint32_t       AlignmentRequirement;
+    uint64_t       SectorCount;
+    uint8_t        DiskIndex;
+};
+
+#define DEVICE_OBJECT_DISK       0x00000001u
+#define DEVICE_OBJECT_REMOVABLE  0x00000002u
+
+__declspec(dllexport) KSTATUS IoCreateDevice(DRIVER_OBJECT* driver,
+                                             size_t extensionSize,
+                                             DEVICE_OBJECT** outDevice);
+__declspec(dllexport) void    IoDeleteDevice(DEVICE_OBJECT* device);
+
+__declspec(dllexport) KSTATUS IoRegisterDiskDevice(uint8_t driveIndex,
+                                                   DEVICE_OBJECT* device);
+__declspec(dllexport) DEVICE_OBJECT* IoGetDiskDevice(uint8_t driveIndex);
+__declspec(dllexport) bool    IoDiskDevicePresent(uint8_t driveIndex);
+__declspec(dllexport) uint64_t IoDiskSectorCount(uint8_t driveIndex);
+
+__declspec(dllexport) KSTATUS IoCallDriver(DEVICE_OBJECT* device,
+                                           struct IRP* irp);
+
+__declspec(dllexport) KSTATUS IoReadDiskSectors(uint8_t driveIndex,
+                                                uint64_t lba,
+                                                uint32_t count,
+                                                void* buffer);
+__declspec(dllexport) KSTATUS IoWriteDiskSectors(uint8_t driveIndex,
+                                                 uint64_t lba,
+                                                 uint32_t count,
+                                                 const void* buffer);

code/public/ntlite/ddi/net_abi.h

@@ -0,0 +1,45 @@
+#pragma once
+// net_abi.h - native networking ABI shared by the kernel socket facade
+// and network stack provider drivers.
+
+#include <stdint.h>
+#include <stddef.h>
+
+#define SYS_AF_INET         2u
+#define SYS_SOCK_STREAM     1u
+#define SYS_SOCK_DGRAM      2u
+#define SYS_SOCK_RAW        3u
+#define SYS_IPPROTO_ICMP    1u
+#define SYS_IPPROTO_TCP     6u
+#define SYS_IPPROTO_UDP     17u
+
+#define SYS_SHUTDOWN_READ   0u
+#define SYS_SHUTDOWN_WRITE  1u
+#define SYS_SHUTDOWN_BOTH   2u
+
+#define SYS_SOCKET_ADDRESS_IPV4_SIZE 16u
+#define SYS_RESOLVE_HOST_NAME_MAX 255u
+
+#define SYS_SOCKET_OPT_RECV_TIMEOUT_MS 1u
+#define SYS_SOCKET_OPT_SEND_TIMEOUT_MS 2u
+#define SYS_SOCKET_OPT_NONBLOCKING     3u
+
+#define SYS_POLL_READ     0x0001u
+#define SYS_POLL_WRITE    0x0002u
+#define SYS_POLL_ERROR    0x0004u
+#define SYS_POLL_HANGUP   0x0008u
+#define SYS_POLL_INVALID  0x0010u
+#define SYS_POLL_TIMEOUT_INFINITE 0xFFFFFFFFu
+
+typedef struct SYS_SOCKET_ADDRESS_IPV4_K {
+    uint16_t Family;       // SYS_AF_INET
+    uint16_t Port;         // host byte order
+    uint8_t  Address[4];   // dotted-quad bytes, e.g. {10,0,2,2}
+    uint8_t  Reserved[8];
+} SYS_SOCKET_ADDRESS_IPV4_K;
+
+typedef struct SYS_POLLFD_K {
+    uint32_t Handle;
+    uint32_t Events;
+    uint32_t ReturnedEvents;
+} SYS_POLLFD_K;

code/public/ntlite/ddi/net_device.h

@@ -0,0 +1,57 @@
+#pragma once
+// net_device.h - kernel network-device registry.
+//
+// NIC drivers register NET_DEVICE objects here and feed complete Ethernet
+// frames into NetReceiveFrame(). Protocol ownership belongs to whichever
+// network stack driver registered through net_stack.h.
+
+#include <stdint.h>
+#include <stddef.h>
+#include <ntlite/status.h>
+
+#define NET_DEVICE_NAME_MAX          16u
+#define NET_HWADDR_MAX               16u
+#define NET_MTU_ETHERNET             1500u
+#define NET_ETHERNET_ADDRESS_LENGTH  6u
+#define NET_ETHERNET_HEADER_LENGTH   14u
+#define NET_ETHERNET_MIN_FRAME       60u
+#define NET_ETHERNET_MAX_FRAME       (NET_ETHERNET_HEADER_LENGTH + NET_MTU_ETHERNET)
+
+struct NET_DEVICE;
+typedef struct NET_DEVICE NET_DEVICE;
+
+typedef KSTATUS (*NET_SEND_FRAME)(NET_DEVICE* device,
+                                  const void* frame,
+                                  size_t length);
+
+typedef struct NET_DEVICE_STATS {
+    uint64_t TxPackets;
+    uint64_t TxBytes;
+    uint64_t TxErrors;
+    uint64_t RxPackets;
+    uint64_t RxBytes;
+    uint64_t RxDrops;
+} NET_DEVICE_STATS;
+
+struct NET_DEVICE {
+    char      Name[NET_DEVICE_NAME_MAX];
+    uint32_t  Index;
+    uint32_t  Mtu;
+    uint8_t   HardwareAddressLength;
+    uint8_t   HardwareAddress[NET_HWADDR_MAX];
+    void*     DriverContext;
+    NET_SEND_FRAME SendFrame;
+    NET_DEVICE_STATS Stats;
+};
+
+__declspec(dllexport) KSTATUS NetRegisterDevice(NET_DEVICE* device);
+__declspec(dllexport) uint32_t NetGetDeviceCount(void);
+__declspec(dllexport) NET_DEVICE* NetGetDevice(uint32_t index);
+__declspec(dllexport) KSTATUS NetGetDeviceStats(uint32_t index,
+                                                NET_DEVICE_STATS* stats);
+__declspec(dllexport) KSTATUS NetSendFrame(uint32_t index,
+                                           const void* frame,
+                                           size_t length);
+__declspec(dllexport) void NetReceiveFrame(NET_DEVICE* device,
+                                           const void* frame,
+                                           size_t length);

code/public/ntlite/ddi/net_stack.h

@@ -0,0 +1,48 @@
+#pragma once
+// net_stack.h - provider interface between kernel socket facade and network stack drivers.
+//
+// The kernel owns process handles, user-memory copying, NET_DEVICE registration,
+// and SOCKET_OBJECT lifetime. A stack driver owns protocol implementation.
+
+#include <stdint.h>
+#include <stddef.h>
+#include <ntlite/status.h>
+#include <ntlite/ddi/net_device.h>
+#include <ntlite/ddi/net_abi.h>
+
+#define NET_STACK_PROVIDER_VERSION 1u
+
+typedef struct NET_STACK_PROVIDER NET_STACK_PROVIDER;
+
+struct NET_STACK_PROVIDER {
+    uint32_t Version;
+    const char* Name;
+
+    KSTATUS (*AttachDevice)(NET_DEVICE* device);
+    KSTATUS (*ReceiveFrame)(NET_DEVICE* device, const void* frame, size_t length);
+
+    KSTATUS (*SocketCreate)(uint32_t domain, uint32_t type, uint32_t protocol, void** outSocket);
+    void    (*SocketClose)(void* socket);
+
+    KSTATUS (*Bind)(void* socket, const SYS_SOCKET_ADDRESS_IPV4_K* address, size_t addressSize);
+    KSTATUS (*Listen)(void* socket, uint32_t backlog);
+    KSTATUS (*Accept)(void* socket, void** acceptedOut, SYS_SOCKET_ADDRESS_IPV4_K* remoteOut);
+    KSTATUS (*Connect)(void* socket, const SYS_SOCKET_ADDRESS_IPV4_K* address, size_t addressSize);
+
+    KSTATUS (*Send)(void* socket, const void* buffer, size_t length, uint32_t flags, size_t* sentOut);
+    KSTATUS (*Receive)(void* socket, void* buffer, size_t length, uint32_t flags, size_t* receivedOut);
+    KSTATUS (*SendTo)(void* socket, const void* buffer, size_t length, uint32_t flags,
+                      const SYS_SOCKET_ADDRESS_IPV4_K* remote, size_t remoteSize, size_t* sentOut);
+    KSTATUS (*ReceiveFrom)(void* socket, void* buffer, size_t length, uint32_t flags,
+                           SYS_SOCKET_ADDRESS_IPV4_K* remoteOut, size_t* receivedOut);
+
+    KSTATUS (*Shutdown)(void* socket, uint32_t how);
+    KSTATUS (*SetOption)(void* socket, uint32_t option, const void* value, size_t valueSize);
+    KSTATUS (*GetOption)(void* socket, uint32_t option, void* value, size_t valueSize, size_t* actualSizeOut);
+    KSTATUS (*Poll)(void* socket, uint32_t events, uint32_t* returnedEventsOut);
+
+    KSTATUS (*ResolveHostIpv4)(const char* name, SYS_SOCKET_ADDRESS_IPV4_K* addressOut);
+};
+
+__declspec(dllexport) KSTATUS NetRegisterStackProvider(const NET_STACK_PROVIDER* provider);
+__declspec(dllexport) const NET_STACK_PROVIDER* NetGetStackProvider(void);

code/public/ntlite/dirent.h

@@ -0,0 +1,13 @@
+#pragma once
+// dirent.h - directory entry returned by SysReadDir.
+
+#include <stdint.h>
+
+#define SYS_DIR_NAME_MAX 260
+
+// Attribute flags match FAT32/Win32: 0x10 directory, 0x20 archive/file.
+typedef struct SYS_DIR_ENTRY {
+    char     Name[SYS_DIR_NAME_MAX];
+    uint8_t  Attr;
+    uint32_t FileSize;
+} SYS_DIR_ENTRY;

code/public/ntlite/memory_map.h

@@ -0,0 +1,30 @@
+#pragma once
+// memory_map.h  - shared between bootx64.efi and kernel.exe
+// Describes physical memory layout passed from bootloader to kernel.
+#include <stdint.h>
+
+#define MEMORY_MAP_MAGIC    0x4D454D4D41500000ULL   /* 'MEMMAP\0\0' */
+#define MEMORY_MAX_REGIONS  256
+
+typedef enum MEMORY_TYPE {
+    MemoryUsable          = 0,   /* free RAM, available to the PMM      */
+    MemoryReserved        = 1,   /* firmware-reserved, do not touch     */
+    MemoryMappedIO        = 2,   /* device MMIO regions                 */
+    MemoryFramebuffer     = 3,   /* GOP framebuffer                     */
+    MemoryBootloader      = 4,   /* bootloader code/data (reclaimable)  */
+    MemoryKernel          = 5,   /* kernel + HAL + drivers image pages  */
+} MEMORY_TYPE;
+
+typedef struct MEMORY_REGION {
+    uint64_t    Base;
+    uint64_t    Length;          /* in bytes, always page-aligned       */
+    MEMORY_TYPE Type;
+    uint32_t    _pad;
+} MEMORY_REGION;
+
+typedef struct MEMORY_MAP {
+    uint64_t       Magic;
+    uint32_t       RegionCount;
+    uint32_t       _pad;
+    MEMORY_REGION  Regions[MEMORY_MAX_REGIONS];
+} MEMORY_MAP;

code/public/ntlite/status.h

@@ -0,0 +1,46 @@
+#pragma once
+// ke_status.h - kernel status codes
+// All fallible kernel functions return KSTATUS.
+// Success is always zero; failures are positive named constants.
+#include <stdint.h>
+
+typedef uint32_t KSTATUS;
+
+// --- General & Control (0x0000) ---
+#define STATUS_SUCCESS              ((KSTATUS)0x0000)
+#define STATUS_FAILURE              ((KSTATUS)0x0001)
+#define STATUS_NOT_SUPPORTED        ((KSTATUS)0x0002)
+#define STATUS_TIMEOUT              ((KSTATUS)0x0003)
+#define STATUS_PENDING              ((KSTATUS)0x0004)
+#define STATUS_ALERTED              ((KSTATUS)0x0005)
+#define STATUS_KERNEL_APC           ((KSTATUS)0x0006)
+#define STATUS_USER_APC             ((KSTATUS)0x0007)
+
+// --- Validation & Parameters (0x0010) ---
+#define STATUS_INVALID_PARAMETER    ((KSTATUS)0x0010)
+#define STATUS_INVALID_HANDLE       ((KSTATUS)0x0011)
+#define STATUS_BUFFER_TOO_SMALL     ((KSTATUS)0x0012)
+#define STATUS_CHECKSUM_MISMATCH    ((KSTATUS)0x0013)
+
+// --- Resource & Access (0x0020) ---
+#define STATUS_NO_MEMORY            ((KSTATUS)0x0020)
+#define STATUS_ACCESS_DENIED        ((KSTATUS)0x0021)
+#define STATUS_NOT_FOUND            ((KSTATUS)0x0022)
+#define STATUS_ALREADY_EXISTS       ((KSTATUS)0x0023)
+#define STATUS_OBJECT_NAME_COLLISION ((KSTATUS)0x0024)
+
+// --- State & Lifecycle (0x0030) ---
+#define STATUS_OBJECT_DEAD          ((KSTATUS)0x0030)
+#define STATUS_QUEUE_FULL           ((KSTATUS)0x0031)
+#define STATUS_QUEUE_EMPTY          ((KSTATUS)0x0032)
+#define STATUS_CANCELLED            ((KSTATUS)0x0033)
+
+// --- Hardware & External (0x0040) ---
+#define STATUS_DEVICE_ERROR         ((KSTATUS)0x0040)
+
+#define STATUS_NO_MORE_FILES        ((KSTATUS)0x0050)
+
+// --- Execution level (0x0060) ---
+#define STATUS_INVALID_IRQL       ((KSTATUS)0x0060)
+
+#define KSUCCESS(s)  ((s) == STATUS_SUCCESS)

code/public/ntlite/string_view.h

@@ -0,0 +1,112 @@
+#pragma once
+// sys_string.h - shared native string-view ABI.
+// A SYS_STRING_VIEW is a borrowed byte span. It is not NUL-terminated by
+// contract and it does not own the pointed-to storage.
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#ifndef SYS_STRING_VIEW_DEFINED
+#define SYS_STRING_VIEW_DEFINED 1
+typedef struct SYS_STRING_VIEW {
+    const char* Data;
+    size_t      Length;
+} SYS_STRING_VIEW;
+#endif
+
+#define SYS_SV_LITERAL(s) ((SYS_STRING_VIEW){ (s), sizeof(s) - 1 })
+#define SYS_SV_NULL       ((SYS_STRING_VIEW){ (const char*)0, 0 })
+
+static inline SYS_STRING_VIEW SysSvFromParts(const char* data, size_t length) {
+    SYS_STRING_VIEW v;
+    v.Data = data;
+    v.Length = length;
+    return v;
+}
+
+static inline SYS_STRING_VIEW SysSvFromCstr(const char* s) {
+    SYS_STRING_VIEW v;
+    v.Data = s;
+    v.Length = s ? strlen(s) : 0;
+    return v;
+}
+
+static inline int SysSvIsEmpty(SYS_STRING_VIEW s) {
+    return s.Length == 0;
+}
+
+static inline int SysSvIsValid(SYS_STRING_VIEW s) {
+    return s.Data != (const char*)0 || s.Length == 0;
+}
+
+static inline int SysSvEqual(SYS_STRING_VIEW a, SYS_STRING_VIEW b) {
+    if (a.Length != b.Length) return 0;
+    if (a.Length == 0) return 1;
+    if (!a.Data || !b.Data) return 0;
+    return memcmp(a.Data, b.Data, a.Length) == 0;
+}
+
+static inline char SysAsciiLower(char c) {
+    return (c >= 'A' && c <= 'Z') ? (char)(c + ('a' - 'A')) : c;
+}
+
+static inline int SysSvEqualAsciiI(SYS_STRING_VIEW a, SYS_STRING_VIEW b) {
+    if (a.Length != b.Length) return 0;
+    if (a.Length == 0) return 1;
+    if (!a.Data || !b.Data) return 0;
+    for (size_t i = 0; i < a.Length; i++) {
+        if (SysAsciiLower(a.Data[i]) != SysAsciiLower(b.Data[i])) return 0;
+    }
+    return 1;
+}
+
+static inline int SysSvEqualLit(SYS_STRING_VIEW a, const char* lit) {
+    return SysSvEqual(a, SysSvFromCstr(lit));
+}
+
+static inline int SysSvEqualLitAsciiI(SYS_STRING_VIEW a, const char* lit) {
+    return SysSvEqualAsciiI(a, SysSvFromCstr(lit));
+}
+
+static inline int SysSvContainsByte(SYS_STRING_VIEW s, char ch) {
+    if (!s.Data && s.Length) return 0;
+    for (size_t i = 0; i < s.Length; i++) {
+        if (s.Data[i] == ch) return 1;
+    }
+    return 0;
+}
+
+static inline SYS_STRING_VIEW SysSvSlice(SYS_STRING_VIEW s, size_t off, size_t len) {
+    if (off > s.Length) off = s.Length;
+    if (len > s.Length - off) len = s.Length - off;
+    return SysSvFromParts(s.Data ? s.Data + off : (const char*)0, len);
+}
+
+static inline SYS_STRING_VIEW SysSvTrimAscii(SYS_STRING_VIEW s) {
+    size_t begin = 0;
+    size_t end = s.Length;
+    while (begin < end) {
+        char c = s.Data[begin];
+        if (c != ' ' && c != '\t' && c != '\r' && c != '\n') break;
+        begin++;
+    }
+    while (end > begin) {
+        char c = s.Data[end - 1];
+        if (c != ' ' && c != '\t' && c != '\r' && c != '\n') break;
+        end--;
+    }
+    return SysSvSlice(s, begin, end - begin);
+}
+
+static inline int SysSvCopyZ(char* dst, size_t dstSize, SYS_STRING_VIEW src) {
+    if (!dst || dstSize == 0) return 0;
+    if (src.Length && !src.Data) return 0;
+    if (src.Length + 1 > dstSize) {
+        dst[0] = '\0';
+        return 0;
+    }
+    if (src.Length) memcpy(dst, src.Data, src.Length);
+    dst[src.Length] = '\0';
+    return 1;
+}

code/public/ntlite/syscall.h

@@ -0,0 +1,397 @@
+#pragma once
+// Syscall.h
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <intrin.h>
+#include <ntlite/string_view.h>
+#include <ntlite/dirent.h>
+
+#define SYS_STATUS_SUCCESS       0u
+#define SYS_STATUS_TIMEOUT       3u
+#define SYS_STATUS_PENDING       4u
+#define SYS_STATUS_ALERTED       5u
+#define SYS_STATUS_KERNEL_APC    6u
+#define SYS_STATUS_USER_APC      7u
+#define SYS_STATUS_CANCELLED     0x33u
+#define SYS_STATUS_NOT_FOUND     0x22u
+
+// ---------------------------------------------------------------------------
+// User process/thread environment
+// ---------------------------------------------------------------------------
+// GS base points at SYS_TEB.  GS:[0] is the process PEB pointer.
+// This is this OS' ABI, not a Windows compatibility layout.
+#define SYS_PEB_MAGIC   0x30424550u  /* "PEB0" */
+#define SYS_TEB_MAGIC   0x30424554u  /* "TEB0" */
+#define SYS_ENV_VERSION 1u
+#define SYS_CWD_MAX     520u
+
+#ifndef SYS_USER_ENV_TYPES_DEFINED
+#define SYS_USER_ENV_TYPES_DEFINED 1
+
+typedef struct SYS_PEB {
+    uint32_t Magic;
+    uint32_t Version;
+    uint32_t ProcessId;
+
+    SYS_STRING_VIEW ImagePath;
+    SYS_STRING_VIEW CommandLine;
+    SYS_STRING_VIEW CurrentDirectory;
+} SYS_PEB;
+
+typedef struct SYS_TEB {
+    SYS_PEB*        Peb;
+    void*           StackBase;
+    void*           StackLimit;
+    struct SYS_TEB* Self;
+    uint32_t        ThreadId;
+    uint32_t        Magic;
+
+    // Native per-thread extension pointer.  The kernel leaves this NULL;
+    // user-mode personalities/libraries may hang their own thread-local
+    // state here without baking subsystem semantics into SYS_TEB.
+    void*           SubsystemData;
+} SYS_TEB;
+
+#endif // SYS_USER_ENV_TYPES_DEFINED
+
+static inline SYS_PEB* SysGetPeb(void) {
+    return (SYS_PEB*)(uintptr_t)__readgsqword(0);
+}
+
+static inline SYS_TEB* SysGetTeb(void) {
+    return (SYS_TEB*)(uintptr_t)__readgsqword(offsetof(SYS_TEB, Self));
+}
+
+// ---------------------------------------------------------------------------
+// APC and async I/O ABI
+// ---------------------------------------------------------------------------
+typedef struct SYS_IO_STATUS_BLOCK {
+    volatile uint32_t Status;
+    volatile uint64_t Information;
+} SYS_IO_STATUS_BLOCK;
+
+typedef void (*SYS_USER_APC_ROUTINE)(void* normalContext,
+                                     SYS_IO_STATUS_BLOCK* iosb,
+                                     uint64_t information);
+
+typedef struct SYS_ASYNC_FILE_REQUEST {
+    uint32_t FileHandle;
+    uint32_t EventHandle;       // optional; 0 means no event signal
+    uint32_t Flags;             // reserved, must be 0 for now
+    uint32_t Reserved;
+    uint64_t Offset;            // explicit byte offset; does not touch file pointer
+    void*    Buffer;
+    size_t   Size;
+    SYS_IO_STATUS_BLOCK* Iosb;  // required; initialized to SYS_STATUS_PENDING
+    SYS_USER_APC_ROUTINE ApcRoutine; // optional; requires SysSetUserApcDispatcher
+    void* ApcContext;
+    uint32_t* RequestHandleOut; // optional; receives cancel/query handle
+} SYS_ASYNC_FILE_REQUEST;
+
+typedef struct SYS_USER_APC_FRAME {
+    uint64_t Magic;
+    uint64_t OriginalRip;
+    uint64_t OriginalRsp;
+    uint64_t OriginalRflags;
+    uint64_t OriginalRax;
+    uint64_t Routine;
+    uint64_t NormalContext;
+    uint64_t SystemArgument1;
+    uint64_t SystemArgument2;
+} SYS_USER_APC_FRAME;
+
+#define SYS_USER_APC_FRAME_MAGIC 0x3143504152555355ULL
+
+void SysUserApcDispatcher(void);
+
+
+// ---------------------------------------------------------------------------
+// Trap-frame query ABI
+// ---------------------------------------------------------------------------
+typedef struct SYS_TRAP_FRAME_INFO {
+    uint32_t Size;
+    uint32_t Kind;
+    uint32_t Vector;
+    uint32_t PreviousMode;
+
+    uint64_t Rip;
+    uint64_t Cs;
+    uint64_t Rflags;
+    uint64_t Rsp;
+    uint64_t Ss;
+
+    uint64_t Rax;
+    uint64_t Rcx;
+    uint64_t Rdx;
+    uint64_t R8;
+    uint64_t R9;
+    uint64_t R10;
+    uint64_t R11;
+} SYS_TRAP_FRAME_INFO;
+
+// ---------------------------------------------------------------------------
+// String-view based syscall request structures
+// ---------------------------------------------------------------------------
+typedef struct SYS_CREATE_PROCESS_REQUEST {
+    SYS_STRING_VIEW Path;
+    SYS_STRING_VIEW CommandLine;
+    uint32_t*       HandleOut;
+} SYS_CREATE_PROCESS_REQUEST;
+
+typedef struct SYS_PATH_HANDLE_REQUEST {
+    SYS_STRING_VIEW Path;
+    uint32_t*       HandleOut;
+} SYS_PATH_HANDLE_REQUEST;
+
+typedef struct SYS_PATH_REQUEST {
+    SYS_STRING_VIEW Path;
+} SYS_PATH_REQUEST;
+
+typedef struct SYS_RENAME_FILE_REQUEST {
+    SYS_STRING_VIEW OldPath;
+    SYS_STRING_VIEW NewPath;
+} SYS_RENAME_FILE_REQUEST;
+
+typedef struct SYS_GET_CWD_REQUEST {
+    char*   Buffer;
+    size_t  Capacity;
+    size_t* LengthOut;
+} SYS_GET_CWD_REQUEST;
+
+typedef struct SYS_WRITE_CONSOLE_REQUEST {
+    SYS_STRING_VIEW Text;
+} SYS_WRITE_CONSOLE_REQUEST;
+
+typedef struct SYS_DEBUG_PRINT_REQUEST {
+    SYS_STRING_VIEW Text;
+} SYS_DEBUG_PRINT_REQUEST;
+
+typedef struct SYS_PUBLISH_QUEUE_REQUEST {
+    SYS_STRING_VIEW Name;
+    uint32_t        QueueHandle;
+} SYS_PUBLISH_QUEUE_REQUEST;
+
+typedef struct SYS_OPEN_NAMED_QUEUE_REQUEST {
+    SYS_STRING_VIEW Name;
+    uint32_t*       HandleOut;
+} SYS_OPEN_NAMED_QUEUE_REQUEST;
+
+typedef struct SYS_NAMED_QUEUE_OWNER_REQUEST {
+    SYS_STRING_VIEW Name;
+    uint32_t*       PidOut;
+} SYS_NAMED_QUEUE_OWNER_REQUEST;
+
+// ---------------------------------------------------------------------------
+// Process & thread lifecycle (0-14)
+// ---------------------------------------------------------------------------
+void     SysExitProcess(int exitCode);
+void     SysExitThread(int exitCode);
+uint32_t SysCreateProcess(const SYS_CREATE_PROCESS_REQUEST* request);
+uint32_t SysWaitForProcess(uint32_t handle);
+uint32_t SysGetProcessExitCode(uint32_t handle, int* exitCodeOut);
+uint32_t SysKillProcess(uint32_t pid, int exitCode);
+uint32_t SysGetProcessList(uint32_t* pidsOut, size_t maxCount, size_t* countOut);
+uint32_t SysGetProcessPid(uint32_t handle, uint32_t* pidOut);
+
+uint32_t SysCreateThread(uintptr_t entry, uintptr_t arg, uint32_t priority, uint32_t* tidOut);
+uint32_t SysWaitThread(uint32_t tid);
+uint32_t SysGetCurrentTid(void);
+uint32_t SysGetCurrentPid(void);
+uint32_t SysSetThreadPriority(uint32_t priority);
+uint32_t SysYield(void);
+uint32_t SysSleep(uint64_t ms);
+uint32_t SysSetUserApcDispatcher(void* dispatcher);
+uint32_t SysApcReturn(const SYS_USER_APC_FRAME* frame);
+
+// ---------------------------------------------------------------------------
+// Memory and handles
+// ---------------------------------------------------------------------------
+void*    SysAlloc(size_t size);
+uint32_t SysFree(void* ptr);
+void*    SysRealloc(void* ptr, size_t newSize);
+uint32_t SysCloseHandle(uint32_t handle);
+
+// ---------------------------------------------------------------------------
+// Synchronization primitives (19-31)
+// ---------------------------------------------------------------------------
+uint32_t SysMutexCreate(uint32_t* handleOut);
+uint32_t SysMutexAcquire(uint32_t handle);
+uint32_t SysMutexTryAcquire(uint32_t handle);
+uint32_t SysMutexRelease(uint32_t handle);
+
+uint32_t SysSemCreate(int32_t initial, int32_t max, uint32_t* handleOut);
+uint32_t SysSemWait(uint32_t handle);
+uint32_t SysSemTryWait(uint32_t handle);
+uint32_t SysSemSignal(uint32_t handle);
+
+uint32_t SysEventCreate(uint32_t type, uint32_t initialState, uint32_t* handleOut);
+uint32_t SysEventSignal(uint32_t handle);
+uint32_t SysEventClear(uint32_t handle);
+uint32_t SysEventWait(uint32_t handle, uint32_t alertable);
+
+// ---------------------------------------------------------------------------
+// Queues and named queues (32-38)
+// ---------------------------------------------------------------------------
+uint32_t SysQueueCreate(uint32_t* handleOut);
+uint32_t SysQueueSend(uint32_t handle, const void* msg, bool blocking);
+uint32_t SysQueueRecv(uint32_t handle, void* msg, bool blocking);
+uint32_t SysPublishQueue(const SYS_PUBLISH_QUEUE_REQUEST* request);
+uint32_t SysOpenNamedQueue(const SYS_OPEN_NAMED_QUEUE_REQUEST* request);
+uint32_t SysQueueDuplicate(uint32_t handle, uint32_t targetPid, uint32_t* handleOut);
+uint32_t SysNamedQueueOwnerPid(const SYS_NAMED_QUEUE_OWNER_REQUEST* request);
+
+// ---------------------------------------------------------------------------
+// Files, directories, and current directory (39-56)
+// ---------------------------------------------------------------------------
+uint32_t SysOpenFile(const SYS_PATH_HANDLE_REQUEST* request);
+uint32_t SysCreateFile(const SYS_PATH_HANDLE_REQUEST* request);
+uint32_t SysReadFile(uint32_t handle, void* buf, size_t size, size_t* bytesRead);
+uint32_t SysWriteFile(uint32_t handle, const void* buf, size_t size, size_t* written);
+uint32_t SysReadFileAsync(const SYS_ASYNC_FILE_REQUEST* request);
+uint32_t SysWriteFileAsync(const SYS_ASYNC_FILE_REQUEST* request);
+uint32_t SysCancelIo(uint32_t asyncRequestHandle);
+uint32_t SysSeekFile(uint32_t handle, uint64_t offset);
+uint64_t SysGetFilePos(uint32_t handle);
+uint64_t SysGetFileSize(uint32_t handle);
+uint32_t SysTruncateFile(uint32_t handle, uint64_t newSize);
+uint32_t SysDeleteFile(const SYS_PATH_REQUEST* request);
+uint32_t SysRenameFile(const SYS_RENAME_FILE_REQUEST* request);
+
+uint32_t SysOpenDir(const SYS_PATH_HANDLE_REQUEST* request);
+uint32_t SysReadDir(uint32_t handle, SYS_DIR_ENTRY* entryOut);
+uint32_t SysCreateDir(const SYS_PATH_REQUEST* request);
+uint32_t SysRemoveDir(const SYS_PATH_REQUEST* request);
+uint32_t SysSetCwd(const SYS_PATH_REQUEST* request);
+uint32_t SysGetCwd(const SYS_GET_CWD_REQUEST* request);
+
+// ---------------------------------------------------------------------------
+// Console and graphics (57-61)
+// ---------------------------------------------------------------------------
+uint32_t SysWriteConsole(const SYS_WRITE_CONSOLE_REQUEST* request);
+uint32_t SysScreenBlit(int x, int y, int w, int h, const uint32_t* pixels);
+uint32_t SysScreenClear(uint32_t color);
+uint32_t SysScreenGetSize(int* widthOut, int* heightOut);
+uint32_t SysScreenPutChar(char c, int x, int y, uint32_t fg, uint32_t bg);
+
+// ---------------------------------------------------------------------------
+// Input (62-69)
+// ---------------------------------------------------------------------------
+uint64_t SysKbPoll(void);
+uint64_t SysKbIsKeyDown(uint8_t scancode, bool extended);
+char     SysKbReadChar(void);
+uint8_t  SysKbReadScancode(void);
+uint32_t SysKbGetModifiers(void);
+
+uint64_t SysMousePoll(void);
+uint64_t SysMouseRead(int* dx, int* dy, uint8_t* buttons);
+void     SysMouseGetPos(int* x, int* y);
+
+
+// ---------------------------------------------------------------------------
+// Native sockets
+// ---------------------------------------------------------------------------
+#define SYS_AF_INET         2u
+#define SYS_SOCK_STREAM     1u
+#define SYS_SOCK_DGRAM      2u
+#define SYS_SOCK_RAW        3u
+#define SYS_IPPROTO_ICMP    1u
+#define SYS_IPPROTO_TCP     6u
+#define SYS_IPPROTO_UDP     17u
+#define SYS_RESOLVE_HOST_NAME_MAX 255u
+
+#define SYS_SOCKET_OPT_RECV_TIMEOUT_MS 1u
+#define SYS_SOCKET_OPT_SEND_TIMEOUT_MS 2u
+#define SYS_SOCKET_OPT_NONBLOCKING     3u
+
+#define SYS_POLL_READ     0x0001u
+#define SYS_POLL_WRITE    0x0002u
+#define SYS_POLL_ERROR    0x0004u
+#define SYS_POLL_HANGUP   0x0008u
+#define SYS_POLL_INVALID  0x0010u
+#define SYS_POLL_TIMEOUT_INFINITE 0xFFFFFFFFu
+
+#define SYS_SHUTDOWN_READ   0u
+#define SYS_SHUTDOWN_WRITE  1u
+#define SYS_SHUTDOWN_BOTH   2u
+
+typedef struct SYS_SOCKET_ADDRESS_IPV4 {
+    uint16_t Family;       // SYS_AF_INET
+    uint16_t Port;         // host byte order
+    uint8_t  Address[4];   // dotted-quad bytes, e.g. {10,0,2,2}
+    uint8_t  Reserved[8];
+} SYS_SOCKET_ADDRESS_IPV4;
+
+typedef struct SYS_SOCKET_SEND_TO_REQUEST {
+    const void* Buffer;
+    size_t Length;
+    uint32_t Flags;
+    uint32_t Reserved;
+    const SYS_SOCKET_ADDRESS_IPV4* RemoteAddress;
+    size_t RemoteAddressSize;
+    size_t* SentOut;
+} SYS_SOCKET_SEND_TO_REQUEST;
+
+typedef struct SYS_SOCKET_RECV_FROM_REQUEST {
+    void* Buffer;
+    size_t Length;
+    uint32_t Flags;
+    uint32_t Reserved;
+    SYS_SOCKET_ADDRESS_IPV4* RemoteAddressOut;
+    size_t* RemoteAddressSizeInOut;
+    size_t* ReceivedOut;
+} SYS_SOCKET_RECV_FROM_REQUEST;
+
+
+typedef struct SYS_RESOLVE_HOST_REQUEST {
+    SYS_STRING_VIEW Name;
+    uint32_t Family;
+    uint32_t Flags;
+    SYS_SOCKET_ADDRESS_IPV4* AddressOut;
+    size_t* AddressSizeInOut;
+} SYS_RESOLVE_HOST_REQUEST;
+
+typedef struct SYS_SOCKET_OPTION_REQUEST {
+    uint32_t Option;
+    uint32_t Reserved;
+    void* Value;
+    size_t ValueSize;
+    size_t* ActualSizeOut;
+} SYS_SOCKET_OPTION_REQUEST;
+
+typedef struct SYS_POLLFD {
+    uint32_t Handle;
+    uint32_t Events;
+    uint32_t ReturnedEvents;
+} SYS_POLLFD;
+
+uint32_t SysSocket(uint32_t domain, uint32_t type, uint32_t protocol, uint32_t* handleOut);
+uint32_t SysBind(uint32_t socket, const SYS_SOCKET_ADDRESS_IPV4* address, size_t addressSize);
+uint32_t SysListen(uint32_t socket, uint32_t backlog);
+uint32_t SysAccept(uint32_t socket, SYS_SOCKET_ADDRESS_IPV4* remoteAddressOut, size_t* remoteAddressSizeInOut, uint32_t* acceptedHandleOut);
+uint32_t SysConnect(uint32_t socket, const SYS_SOCKET_ADDRESS_IPV4* address, size_t addressSize);
+uint32_t SysSend(uint32_t socket, const void* buffer, size_t length, uint32_t flags, size_t* sentOut);
+uint32_t SysRecv(uint32_t socket, void* buffer, size_t length, uint32_t flags, size_t* receivedOut);
+uint32_t SysShutdown(uint32_t socket, uint32_t how);
+uint32_t SysSendTo(uint32_t socket, const SYS_SOCKET_SEND_TO_REQUEST* request);
+uint32_t SysRecvFrom(uint32_t socket, const SYS_SOCKET_RECV_FROM_REQUEST* request);
+uint32_t SysResolveHost(const SYS_RESOLVE_HOST_REQUEST* request);
+uint32_t SysSetSocketOption(uint32_t socket, const SYS_SOCKET_OPTION_REQUEST* request);
+uint32_t SysGetSocketOption(uint32_t socket, const SYS_SOCKET_OPTION_REQUEST* request);
+uint32_t SysPoll(SYS_POLLFD* fds, size_t count, uint32_t timeoutMs, size_t* readyOut);
+
+typedef struct SYS_MEMORY_STATUS {
+    uint64_t FreePhysicalBytes;
+    uint64_t KernelPoolBytes;
+    uint64_t UserHeapBytes;
+} SYS_MEMORY_STATUS;
+
+// ---------------------------------------------------------------------------
+// Time and diagnostics
+// ---------------------------------------------------------------------------
+uint64_t SysGetTick(void);
+uint32_t SysDebugPrint(const SYS_DEBUG_PRINT_REQUEST* request);
+uint32_t SysQueryTrapFrame(SYS_TRAP_FRAME_INFO* info);
+
+uint32_t SysGetMemoryStatus(SYS_MEMORY_STATUS* statusOut);