redo boot around an explicit system volume and fixed kernel/HAL images, redo volumes and filesystem paths around capabilities instead of drive numbers and kernel CWD state, add a capability/security model with derived and revocable handles and security contexts, add port IPC and rssrv to manage the userspace resource namespace and publish the system volume, move process, dll and path loading to userspace and add process builder syscalls, init now supervises rssrv and the session process, redo the syscall ABI around request structs and four arguments, add a volume manager and proper partition arrival/removal handling so FAT and NTFS mount dynamically, clean up the HAL/DDK boundary so drivers don't depend on HAL internals, save fpu state properly now, the serial driver doesn't hang on a missing port, fix AHCI startup races, fix timeout accounting, fix shared mmap writeback, more smoke tests
This commit is contained in:
maksw committed
1 parent
4add6789ba
commit
f882d339fb
232 files changed
+20934
-8898
No files matched your search
+16
-15
@@ -4,8 +4,9 @@
|
||||
|
||||
#include <stdint.h>
|
||||
#include <ntlite/status.h>
|
||||
#include <ntlite/handle.h>
|
||||
|
||||
#define SYS_AUDIO_ABI_VERSION 3u
|
||||
#define SYS_AUDIO_ABI_VERSION 4u
|
||||
#define SYS_AUDIO_MAX_ENDPOINTS 32u
|
||||
#define SYS_AUDIO_STREAM_CAPACITY_FRAMES 4096u
|
||||
|
||||
@@ -54,7 +55,7 @@ typedef enum SYS_AUDIO_ENDPOINT_STATE {
|
||||
typedef struct SYS_AUDIO_ENDPOINT_INFO {
|
||||
uint32_t Size;
|
||||
uint32_t Version;
|
||||
uint64_t EndpointId;
|
||||
uint32_t EndpointId;
|
||||
uint32_t Kind;
|
||||
uint32_t Flags;
|
||||
uint32_t Capabilities;
|
||||
@@ -82,17 +83,17 @@ typedef struct SYS_AUDIO_ENUMERATE_ENDPOINTS_REQUEST {
|
||||
typedef struct SYS_AUDIO_OPEN_STREAM_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
uint64_t EndpointId;
|
||||
uint32_t EndpointId;
|
||||
SYS_AUDIO_FORMAT Format;
|
||||
uint32_t Reserved;
|
||||
uint32_t* StreamHandleOut;
|
||||
SYS_HANDLE* StreamHandleOut;
|
||||
} SYS_AUDIO_OPEN_STREAM_REQUEST;
|
||||
|
||||
// Describes one bounded nonblocking stream write.
|
||||
typedef struct SYS_AUDIO_WRITE_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
uint32_t StreamHandle;
|
||||
SYS_HANDLE StreamHandle;
|
||||
uint32_t FrameCount;
|
||||
const void* Frames;
|
||||
uint32_t* WrittenFramesOut;
|
||||
@@ -111,7 +112,7 @@ typedef struct SYS_AUDIO_WRITE_REQUEST {
|
||||
typedef struct SYS_AUDIO_ARM_WAIT_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
uint32_t StreamHandle;
|
||||
SYS_HANDLE StreamHandle;
|
||||
uint32_t Mask;
|
||||
// Frame counters are inclusive absolute targets and generations are change baselines.
|
||||
uint32_t WritableFrames;
|
||||
@@ -165,7 +166,7 @@ typedef struct SYS_AUDIO_STREAM_INFO {
|
||||
typedef struct SYS_AUDIO_SET_VOLUME_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
uint32_t StreamHandle;
|
||||
SYS_HANDLE StreamHandle;
|
||||
uint32_t Muted;
|
||||
uint32_t VolumeQ16;
|
||||
int32_t PanQ16;
|
||||
@@ -175,7 +176,7 @@ typedef struct SYS_AUDIO_SET_VOLUME_REQUEST {
|
||||
typedef struct SYS_AUDIO_SET_MASTER_VOLUME_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
uint64_t EndpointId;
|
||||
uint32_t EndpointId;
|
||||
uint32_t Muted;
|
||||
uint32_t VolumeQ16;
|
||||
} SYS_AUDIO_SET_MASTER_VOLUME_REQUEST;
|
||||
@@ -193,25 +194,25 @@ KSTATUS SysAudioWrite(const SYS_AUDIO_WRITE_REQUEST* request);
|
||||
KSTATUS SysAudioArmWait(const SYS_AUDIO_ARM_WAIT_REQUEST* request);
|
||||
|
||||
// Copies one coherent stream snapshot after the caller initializes infoOut->Size.
|
||||
KSTATUS SysAudioQueryStream(uint32_t streamHandle, SYS_AUDIO_STREAM_INFO* infoOut);
|
||||
KSTATUS SysAudioQueryStream(SYS_HANDLE streamHandle, SYS_AUDIO_STREAM_INFO* infoOut);
|
||||
|
||||
// Starts one created or stopped stream.
|
||||
KSTATUS SysAudioStart(uint32_t streamHandle);
|
||||
KSTATUS SysAudioStart(SYS_HANDLE streamHandle);
|
||||
|
||||
// Pauses future mixing while preserving unconsumed source frames.
|
||||
KSTATUS SysAudioPause(uint32_t streamHandle);
|
||||
KSTATUS SysAudioPause(SYS_HANDLE streamHandle);
|
||||
|
||||
// Resumes one paused stream.
|
||||
KSTATUS SysAudioResume(uint32_t streamHandle);
|
||||
KSTATUS SysAudioResume(SYS_HANDLE streamHandle);
|
||||
|
||||
// Rejects new writes and stops after all submitted frames reach a terminal disposition.
|
||||
KSTATUS SysAudioDrain(uint32_t streamHandle);
|
||||
KSTATUS SysAudioDrain(SYS_HANDLE streamHandle);
|
||||
|
||||
// Stops future mixing and discards source frames not yet committed to hardware periods.
|
||||
KSTATUS SysAudioStop(uint32_t streamHandle);
|
||||
KSTATUS SysAudioStop(SYS_HANDLE streamHandle);
|
||||
|
||||
// Returns one stopped stream to an empty position-zero state.
|
||||
KSTATUS SysAudioReset(uint32_t streamHandle);
|
||||
KSTATUS SysAudioReset(SYS_HANDLE streamHandle);
|
||||
|
||||
// Updates one stream's software volume, pan, and mute state.
|
||||
KSTATUS SysAudioSetVolume(const SYS_AUDIO_SET_VOLUME_REQUEST* request);
|
||||
|
||||
@@ -1,13 +1,15 @@
|
||||
// Public NTLite boot info ABI declarations shared between kernel, drivers, and user mode.
|
||||
// Public NTLite boot info ABI declarations shared between the bootloader and kernel.
|
||||
|
||||
#pragma once
|
||||
// Boot information ABI shared between bootx64.efi and kernel.exe.
|
||||
// The bootloader fills this structure immediately before ExitBootServices so the kernel starts with a firmware-free view of memory and devices.
|
||||
|
||||
#include <stdint.h>
|
||||
#include <ntlite/memory_map.h>
|
||||
|
||||
#define BOOT_INFO_MAGIC 0x424F4F54494E464FULL // 'BOOTINFO'
|
||||
#define MAX_BOOT_MODULES 32
|
||||
// Encodes the ASCII tag 'BOOTINFO'.
|
||||
#define BOOT_INFO_MAGIC 0x424F4F54494E464FULL
|
||||
#define BOOT_INFO_VERSION 3u
|
||||
|
||||
#define BOOT_FILE_NAME_MAX 64u
|
||||
|
||||
#define BOOT_TIME_FLAG_VALID 0x0001u
|
||||
#define BOOT_TIME_FLAG_TZ_KNOWN 0x0002u
|
||||
@@ -18,56 +20,80 @@
|
||||
|
||||
typedef struct BOOT_TIME {
|
||||
uint16_t Year;
|
||||
uint8_t Month;
|
||||
uint8_t Day;
|
||||
uint8_t Hour;
|
||||
uint8_t Minute;
|
||||
uint8_t Second;
|
||||
uint8_t Daylight;
|
||||
uint8_t Month;
|
||||
uint8_t Day;
|
||||
uint8_t Hour;
|
||||
uint8_t Minute;
|
||||
uint8_t Second;
|
||||
uint8_t Daylight;
|
||||
uint32_t Nanosecond;
|
||||
int16_t TimeZoneMinutes;
|
||||
int16_t TimeZoneMinutes;
|
||||
uint16_t Flags;
|
||||
uint32_t Reserved;
|
||||
} BOOT_TIME;
|
||||
|
||||
typedef struct BOOT_MODULE {
|
||||
char Name[32]; // e.g. "hal.dll", "ata.sys"
|
||||
uintptr_t VirtBase; // Virtual address (mapped)
|
||||
uintptr_t PhysBase; // Raw physical address (file)
|
||||
size_t ImageSize; // File size / Image size
|
||||
} BOOT_MODULE;
|
||||
// Describes a page-backed raw file that remains owned by the boot handoff.
|
||||
typedef struct BOOT_BLOB {
|
||||
uintptr_t PhysicalBase;
|
||||
uint32_t Length;
|
||||
uint32_t PageCount;
|
||||
} BOOT_BLOB;
|
||||
|
||||
// Describes a boot driver raw file passed to the kernel without mapping it as an image.
|
||||
typedef struct BOOT_FILE {
|
||||
char Name[BOOT_FILE_NAME_MAX];
|
||||
uintptr_t PhysicalBase;
|
||||
uint32_t Length;
|
||||
uint32_t PageCount;
|
||||
} BOOT_FILE;
|
||||
|
||||
// Describes the page-backed BOOT_FILE array produced from drivers.ini [boot].
|
||||
typedef struct BOOT_FILE_LIST {
|
||||
uintptr_t FilesPhysical;
|
||||
uint32_t Count;
|
||||
uint32_t PageCount;
|
||||
} BOOT_FILE_LIST;
|
||||
|
||||
// Describes one fixed-base PE image materialized by the bootloader.
|
||||
typedef struct BOOT_IMAGE {
|
||||
uintptr_t VirtualBase;
|
||||
uintptr_t PhysicalBase;
|
||||
uint32_t ImageSize;
|
||||
uint32_t PageCount;
|
||||
uint32_t EntryRva;
|
||||
uint32_t Reserved;
|
||||
} BOOT_IMAGE;
|
||||
|
||||
typedef struct BOOT_INFO {
|
||||
uint64_t Magic;
|
||||
uint64_t Magic;
|
||||
uint32_t Size;
|
||||
uint32_t Version;
|
||||
|
||||
// Physical memory.
|
||||
MEMORY_MAP MemoryMap;
|
||||
// Physical memory translated from the final firmware memory map.
|
||||
MEMORY_MAP MemoryMap;
|
||||
|
||||
// GOP framebuffer.
|
||||
uintptr_t FramebufferBase;
|
||||
uint32_t FramebufferWidth;
|
||||
uint32_t FramebufferHeight;
|
||||
uint32_t FramebufferStride; // pixels per row
|
||||
uintptr_t FramebufferBase;
|
||||
uint32_t FramebufferWidth;
|
||||
uint32_t FramebufferHeight;
|
||||
uint32_t FramebufferStride;
|
||||
uint32_t Reserved0;
|
||||
|
||||
// Loaded modules.
|
||||
BOOT_MODULE Modules[MAX_BOOT_MODULES];
|
||||
uint32_t ModuleCount;
|
||||
uint32_t _pad1;
|
||||
// Fixed core images and raw boot inputs.
|
||||
BOOT_IMAGE KernelImage;
|
||||
BOOT_IMAGE HalImage;
|
||||
BOOT_BLOB BootIni;
|
||||
BOOT_FILE_LIST BootDrivers;
|
||||
|
||||
char CommandLine[64];
|
||||
|
||||
// ACPI RSDP physical address (for APIC, HPET).
|
||||
uintptr_t RsdpPhysical;
|
||||
// ACPI RSDP physical address.
|
||||
uintptr_t RsdpPhysical;
|
||||
|
||||
// Direct physical window base - always 0xFFFF880000000000.
|
||||
uintptr_t PhysicalMapBase;
|
||||
uintptr_t PhysicalMapBase;
|
||||
|
||||
// Reserved low-memory page for the AP startup trampoline, or zero.
|
||||
uintptr_t ApTrampolinePhys;
|
||||
|
||||
// From boot.ini.
|
||||
uint32_t Debug;
|
||||
uintptr_t ApTrampolinePhys;
|
||||
|
||||
// Firmware wall-clock snapshot taken before ExitBootServices.
|
||||
BOOT_TIME BootTime;
|
||||
BOOT_TIME BootTime;
|
||||
} BOOT_INFO;
|
||||
@@ -1,203 +0,0 @@
|
||||
// Public NTLite hal api ABI declarations shared between kernel, drivers, and user mode.
|
||||
|
||||
#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_FRAMEBUFFER_INFO {
|
||||
uintptr_t Base; // kernel virtual address of the visible framebuffer
|
||||
uint32_t Width;
|
||||
uint32_t Height;
|
||||
uint32_t Stride; // pixels per scanline
|
||||
uint32_t Format; // currently 0x00RRGGBB / X8R8G8B8
|
||||
} HAL_FRAMEBUFFER_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);
|
||||
KSTATUS (*GetFramebuffer)(HAL_FRAMEBUFFER_INFO* outInfo);
|
||||
void (*Scroll)(int lines);
|
||||
void (*PutChar)(char c, int x, int y, uint32_t fg, uint32_t bg);
|
||||
// Writes only to the boot framebuffer text console. Stream routing belongs to HAL_OUTPUT_ROUTER.
|
||||
void (*PrintChar)(char c, uint32_t fg, uint32_t bg);
|
||||
// Legacy software cursor hooks kept for early-boot/panic fallback only.
|
||||
// Normal input cursor ownership lives in ke_display.
|
||||
void (*DrawCursor)(int x, int y);
|
||||
void (*EraseCursor)(void);
|
||||
} HAL_SCREEN;
|
||||
|
||||
// Output streams describe the producer's intent. Endpoints subscribe by mask.
|
||||
#define HAL_OUTPUT_STREAM_DEBUG 0x00000001u
|
||||
#define HAL_OUTPUT_STREAM_CONSOLE 0x00000002u
|
||||
#define HAL_OUTPUT_STREAM_CRASH 0x00000004u
|
||||
#define HAL_OUTPUT_STREAM_PANIC 0x00000008u
|
||||
#define HAL_OUTPUT_STREAM_ALL 0x0000000Fu
|
||||
|
||||
// Emergency writes bypass endpoints that cannot run without scheduler services.
|
||||
#define HAL_OUTPUT_WRITE_EMERGENCY 0x00000001u
|
||||
#define HAL_OUTPUT_ENDPOINT_PANIC_SAFE 0x00000001u
|
||||
#define HAL_OUTPUT_ENDPOINT_INVALID UINT32_MAX
|
||||
|
||||
typedef struct HAL_OUTPUT_RECORD {
|
||||
// Exactly one HAL_OUTPUT_STREAM_* value.
|
||||
uint32_t Stream;
|
||||
// HAL_OUTPUT_WRITE_* flags.
|
||||
uint32_t Flags;
|
||||
// X8R8G8B8 text color hints.
|
||||
uint32_t Foreground;
|
||||
uint32_t Background;
|
||||
// The buffer remains valid only for the duration of Write().
|
||||
const char* Buffer;
|
||||
size_t Length;
|
||||
} HAL_OUTPUT_RECORD;
|
||||
|
||||
// Endpoint callbacks consume or copy the record synchronously and must not retain Buffer.
|
||||
typedef void (*HAL_OUTPUT_ENDPOINT_WRITE)(void* context, const HAL_OUTPUT_RECORD* record);
|
||||
|
||||
typedef struct HAL_OUTPUT_ENDPOINT {
|
||||
// The name remains stable for the endpoint lifetime.
|
||||
const char* Name;
|
||||
uint32_t StreamMask;
|
||||
uint32_t Capabilities;
|
||||
HAL_OUTPUT_ENDPOINT_WRITE Write;
|
||||
void* Context;
|
||||
} HAL_OUTPUT_ENDPOINT;
|
||||
|
||||
typedef struct HAL_OUTPUT_STATS {
|
||||
uint64_t RecordCount;
|
||||
uint64_t ByteCount;
|
||||
uint64_t EndpointWriteCount;
|
||||
uint64_t EmergencyRecordCount;
|
||||
uint32_t EndpointCount;
|
||||
} HAL_OUTPUT_STATS;
|
||||
|
||||
typedef struct HAL_OUTPUT_ROUTER {
|
||||
// Registration is append-only; endpoint callbacks and context remain valid until shutdown.
|
||||
KSTATUS (*RegisterEndpoint)(const HAL_OUTPUT_ENDPOINT* endpoint, uint32_t* endpointIdOut);
|
||||
KSTATUS (*SetEndpointStreams)(uint32_t endpointId, uint32_t streamMask);
|
||||
void (*Write)(const HAL_OUTPUT_RECORD* record);
|
||||
void (*QueryStats)(HAL_OUTPUT_STATS* statsOut);
|
||||
uint32_t SerialEndpointId;
|
||||
uint32_t BootFramebufferEndpointId;
|
||||
} HAL_OUTPUT_ROUTER;
|
||||
|
||||
typedef struct HAL_TIMER {
|
||||
uint64_t (*QueryTicks)(void);
|
||||
uint64_t (*QueryTickFrequency)(void);
|
||||
void (*Stall)(uint32_t us);
|
||||
void (*Isr)(void);
|
||||
uint8_t IrqNumber;
|
||||
} HAL_TIMER;
|
||||
|
||||
#define HAL_RTC_TIME_FLAG_VALID 0x0001u
|
||||
#define HAL_RTC_TIME_FLAG_RTC 0x0002u
|
||||
|
||||
typedef struct HAL_RTC_TIME {
|
||||
uint16_t Year;
|
||||
uint8_t Month;
|
||||
uint8_t Day;
|
||||
uint8_t Hour;
|
||||
uint8_t Minute;
|
||||
uint8_t Second;
|
||||
uint32_t Nanosecond;
|
||||
uint16_t Flags;
|
||||
uint16_t Reserved;
|
||||
} HAL_RTC_TIME;
|
||||
|
||||
typedef struct HAL_RTC {
|
||||
KSTATUS (*QueryTime)(HAL_RTC_TIME* outTime);
|
||||
} HAL_RTC;
|
||||
|
||||
typedef struct HAL_PCI {
|
||||
// Raw PCI configuration access. Policy-level operations such as
|
||||
// enumeration, BAR decoding, interrupt discovery, and MSI programming
|
||||
// belong to pci.sys.
|
||||
uint32_t (*Read32)(uint16_t segment,
|
||||
uint8_t bus,
|
||||
uint8_t dev,
|
||||
uint8_t fn,
|
||||
uint16_t offset);
|
||||
|
||||
void (*Write32)(uint16_t segment,
|
||||
uint8_t bus,
|
||||
uint8_t dev,
|
||||
uint8_t fn,
|
||||
uint16_t offset,
|
||||
uint32_t value);
|
||||
} 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_OUTPUT_ROUTER Output;
|
||||
HAL_TIMER Timer;
|
||||
HAL_RTC Rtc;
|
||||
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;
|
||||
|
||||
void* (*AllocatePool)(size_t size);
|
||||
} HAL_INIT_PARAMS;
|
||||
|
||||
// Increment when the HAL API layout or semantics change when we go from indev to alpha.
|
||||
#define HAL_API_VERSION 1
|
||||
|
||||
__declspec(dllexport) const HAL_API* HalGetApi(void);
|
||||
__declspec(dllexport) void HalRegisterScheduler(void (*pKeSchedulerTick)(void));
|
||||
__declspec(dllexport) KSTATUS HalInitialize(const HAL_INIT_PARAMS* params);
|
||||
|
||||
// Masks interrupts and returns the previous RFLAGS value.
|
||||
__declspec(dllexport) uintptr_t HalDisableInterrupts(void);
|
||||
|
||||
// Restores the RFLAGS value returned by HalDisableInterrupts.
|
||||
__declspec(dllexport) void HalRestoreInterrupts(uintptr_t flags);
|
||||
|
||||
// Enables maskable interrupts.
|
||||
__declspec(dllexport) void HalEnableInterrupts(void);
|
||||
|
||||
// Enables interrupts and halts until the processor receives an interrupt.
|
||||
__declspec(dllexport) void HalWaitForInterrupt(void);
|
||||
|
||||
// Halts once without changing the interrupt state.
|
||||
__declspec(dllexport) void HalHalt(void);
|
||||
|
||||
// Masks interrupts and permanently stops the current processor.
|
||||
__declspec(dllexport) _Noreturn void HalStopProcessor(void);
|
||||
@@ -203,6 +203,27 @@ __declspec(dllexport) KSTATUS IoRegisterDiskChangeCallback(IO_DISK_CHANGE_CALLBA
|
||||
__declspec(dllexport) KSTATUS IoEnumerateDiskDevices(IO_DISK_ARRIVAL_CALLBACK callback,
|
||||
void* context);
|
||||
|
||||
// Dynamic partition discovery above registered block devices. Filesystem providers receive only immutable extents.
|
||||
typedef enum IO_PARTITION_CHANGE {
|
||||
IoPartitionArrived = 0,
|
||||
IoPartitionSurpriseRemoved,
|
||||
IoPartitionRemoved,
|
||||
} IO_PARTITION_CHANGE;
|
||||
|
||||
typedef struct IO_PARTITION_INFO {
|
||||
uint8_t DiskIndex;
|
||||
uint64_t StartLba;
|
||||
uint64_t SectorCount;
|
||||
} IO_PARTITION_INFO;
|
||||
|
||||
typedef void (*IO_PARTITION_CHANGE_CALLBACK)(const IO_PARTITION_INFO* partition,
|
||||
IO_PARTITION_CHANGE change,
|
||||
void* context);
|
||||
|
||||
// Registers one partition-change consumer and replays every currently discovered partition before returning.
|
||||
__declspec(dllexport) KSTATUS IoRegisterPartitionChangeCallback(IO_PARTITION_CHANGE_CALLBACK callback,
|
||||
void* context);
|
||||
|
||||
__declspec(dllexport) KSTATUS IoReadDiskSectors(uint8_t driveIndex,
|
||||
uint64_t lba,
|
||||
uint32_t count,
|
||||
|
||||
@@ -6,6 +6,7 @@
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include <ntlite/handle.h>
|
||||
|
||||
#define SYS_AF_INET 2u
|
||||
#define SYS_AF_INET6 10u
|
||||
@@ -48,7 +49,7 @@ typedef struct SYS_SOCKET_ADDRESS_K {
|
||||
} SYS_SOCKET_ADDRESS_K;
|
||||
|
||||
typedef struct SYS_POLLFD_K {
|
||||
uint32_t Handle;
|
||||
SYS_HANDLE Handle;
|
||||
uint32_t Events;
|
||||
uint32_t ReturnedEvents;
|
||||
} SYS_POLLFD_K;
|
||||
@@ -5,21 +5,21 @@
|
||||
#include <stdint.h>
|
||||
#include <ntlite/status.h>
|
||||
|
||||
#define KE_DEBUG_CONSOLE 0x00000001u
|
||||
#define KE_DEBUG_SELFTEST 0x00000002u
|
||||
#define KE_DEBUG_FILE_LOG 0x00000004u
|
||||
#define KE_DEBUG_POOL_CANARY 0x00000008u
|
||||
#define KE_DEBUG_POOL_POISON 0x00000010u
|
||||
#define KE_DEBUG_POOL_QUARANTINE 0x00000020u
|
||||
#define KE_DEBUG_POOL_CALLERS 0x00000040u
|
||||
#define KE_DEBUG_DISPLAY_ASSERTS 0x00000080u
|
||||
#define KE_DEBUG_DISPLAY_TRACE 0x00000100u
|
||||
#define KE_DEBUG_INPUT_TRACE 0x00000200u
|
||||
#define KE_DEBUG_VM_ASSERTS 0x00000400u
|
||||
#define KE_DEBUG_SYSCALL_ASSERTS 0x00000800u
|
||||
#define KE_DEBUG_LIST_CHECKS 0x00001000u
|
||||
#define KE_DEBUG_AUDIO 0x00002000u
|
||||
#define KE_DEBUG_AUDIO_SELFTEST 0x00004000u
|
||||
// Kernel boot debug flags. Keep these contiguous and document every bit in boot.ini.
|
||||
#define KE_DEBUG_CONSOLE 0x00000001u // Mirror debug output to the firmware/debug console.
|
||||
#define KE_DEBUG_SELFTEST 0x00000002u // Run kernel and SMP boot self-tests.
|
||||
#define KE_DEBUG_FILE_LOG 0x00000004u // Retain debug output for kernel.log persistence.
|
||||
#define KE_DEBUG_POOL_CANARY 0x00000008u // Validate pool block canaries.
|
||||
#define KE_DEBUG_POOL_POISON 0x00000010u // Poison released pool blocks.
|
||||
#define KE_DEBUG_POOL_QUARANTINE 0x00000020u // Delay reuse of released pool blocks.
|
||||
#define KE_DEBUG_POOL_CALLERS 0x00000040u // Track pool allocation/free callers.
|
||||
#define KE_DEBUG_DISPLAY_ASSERTS 0x00000080u // Enable display-path consistency assertions.
|
||||
#define KE_DEBUG_LIST_CHECKS 0x00000100u // Validate intrusive-list links on mutation.
|
||||
|
||||
#define KE_DEBUG_VALID_MASK (KE_DEBUG_CONSOLE | KE_DEBUG_SELFTEST | KE_DEBUG_FILE_LOG | \
|
||||
KE_DEBUG_POOL_CANARY | KE_DEBUG_POOL_POISON | \
|
||||
KE_DEBUG_POOL_QUARANTINE | KE_DEBUG_POOL_CALLERS | \
|
||||
KE_DEBUG_DISPLAY_ASSERTS | KE_DEBUG_LIST_CHECKS)
|
||||
|
||||
// Driver-visible debug output service table passed through NTL_DDK.
|
||||
typedef struct NTL_DDK_DEBUG {
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
// Public nt-lite DDK filesystem declarations.
|
||||
// Public nt-lite DDK filesystem and mounted-volume declarations.
|
||||
|
||||
#pragma once
|
||||
|
||||
@@ -43,30 +43,46 @@ typedef struct IO_FILE_IDENTITY {
|
||||
uint64_t Size;
|
||||
} IO_FILE_IDENTITY;
|
||||
|
||||
typedef struct IO_FILESYSTEM {
|
||||
KSTATUS (*Open)(struct IO_FILESYSTEM* fs, SYS_STRING_VIEW path, void** fileCtx);
|
||||
KSTATUS (*Read)(struct IO_FILESYSTEM* fs, void* fileCtx, uint64_t offset, void* buf, size_t size, size_t* bytesRead);
|
||||
KSTATUS (*Write)(struct IO_FILESYSTEM* fs, void* fileCtx, uint64_t offset, const void* buf, size_t size, size_t* bytesWritten);
|
||||
KSTATUS (*ReadAsync)(struct IO_FILESYSTEM* fs, void* fileCtx, uint64_t offset, void* buf, size_t size, IO_FS_ASYNC_COMPLETE complete, void* completeContext);
|
||||
KSTATUS (*WriteAsync)(struct IO_FILESYSTEM* fs, void* fileCtx, uint64_t offset, const void* buf, size_t size, IO_FS_ASYNC_COMPLETE complete, void* completeContext);
|
||||
KSTATUS (*Create)(struct IO_FILESYSTEM* fs, SYS_STRING_VIEW path, void** fileCtx);
|
||||
KSTATUS (*Delete)(struct IO_FILESYSTEM* fs, SYS_STRING_VIEW path);
|
||||
KSTATUS (*Rename)(struct IO_FILESYSTEM* fs, SYS_STRING_VIEW oldPath, SYS_STRING_VIEW newPath);
|
||||
KSTATUS (*CreateDir)(struct IO_FILESYSTEM* fs, SYS_STRING_VIEW path);
|
||||
KSTATUS (*RemoveDir)(struct IO_FILESYSTEM* fs, SYS_STRING_VIEW path);
|
||||
KSTATUS (*Truncate)(struct IO_FILESYSTEM* fs, void* fileCtx, uint64_t newSize, uint32_t fileFlags);
|
||||
uint64_t (*GetSize)(struct IO_FILESYSTEM* fs, void* fileCtx);
|
||||
KSTATUS (*QueryInfo)(struct IO_FILESYSTEM* fs, void* fileCtx, SYS_FILE_STAT* out);
|
||||
KSTATUS (*Stat)(struct IO_FILESYSTEM* fs, SYS_STRING_VIEW path, SYS_FILE_STAT* out);
|
||||
KSTATUS (*QueryIdentity)(struct IO_FILESYSTEM* fs, void* fileCtx, IO_FILE_IDENTITY* out);
|
||||
KSTATUS (*Flush)(struct IO_FILESYSTEM* fs, void* fileCtx);
|
||||
void (*Close)(struct IO_FILESYSTEM* fs, void* fileCtx);
|
||||
void (*QueryStats)(struct IO_FILESYSTEM* fs, IO_FILESYSTEM_STATS* out);
|
||||
void* DriverCtx;
|
||||
KSTATUS (*OpenDir)(struct IO_FILESYSTEM* fs, SYS_STRING_VIEW dirPath, void** dirCtx);
|
||||
KSTATUS (*ReadDir)(struct IO_FILESYSTEM* fs, void* dirCtx, KDIR_ENTRY* out);
|
||||
void (*CloseDir)(struct IO_FILESYSTEM* fs, void* dirCtx);
|
||||
} IO_FILESYSTEM;
|
||||
typedef enum IO_VOLUME_REMOVAL_REASON {
|
||||
IoVolumeUnmounted = 1,
|
||||
IoVolumeBackingRemoved,
|
||||
IoVolumeProviderDead,
|
||||
} IO_VOLUME_REMOVAL_REASON;
|
||||
|
||||
// Kernel filesystem providers implement this backend. IO_VOLUME owns a copy of
|
||||
// the dispatch and keeps Context alive until all file and directory references drain.
|
||||
typedef struct IO_VOLUME_PROVIDER {
|
||||
KSTATUS (*Open)(struct IO_VOLUME_PROVIDER* provider, SYS_STRING_VIEW path, void** fileCtx);
|
||||
KSTATUS (*Read)(struct IO_VOLUME_PROVIDER* provider, void* fileCtx, uint64_t offset, void* buf, size_t size, size_t* bytesRead);
|
||||
KSTATUS (*Write)(struct IO_VOLUME_PROVIDER* provider, void* fileCtx, uint64_t offset, const void* buf, size_t size, size_t* bytesWritten);
|
||||
KSTATUS (*ReadAsync)(struct IO_VOLUME_PROVIDER* provider, void* fileCtx, uint64_t offset, void* buf, size_t size, IO_FS_ASYNC_COMPLETE complete, void* completeContext);
|
||||
KSTATUS (*WriteAsync)(struct IO_VOLUME_PROVIDER* provider, void* fileCtx, uint64_t offset, const void* buf, size_t size, IO_FS_ASYNC_COMPLETE complete, void* completeContext);
|
||||
KSTATUS (*Create)(struct IO_VOLUME_PROVIDER* provider, SYS_STRING_VIEW path, void** fileCtx);
|
||||
KSTATUS (*Delete)(struct IO_VOLUME_PROVIDER* provider, SYS_STRING_VIEW path);
|
||||
KSTATUS (*Rename)(struct IO_VOLUME_PROVIDER* provider, SYS_STRING_VIEW oldPath, SYS_STRING_VIEW newPath);
|
||||
KSTATUS (*CreateDir)(struct IO_VOLUME_PROVIDER* provider, SYS_STRING_VIEW path);
|
||||
KSTATUS (*RemoveDir)(struct IO_VOLUME_PROVIDER* provider, SYS_STRING_VIEW path);
|
||||
KSTATUS (*Truncate)(struct IO_VOLUME_PROVIDER* provider, void* fileCtx, uint64_t newSize, uint32_t fileFlags);
|
||||
uint64_t (*GetSize)(struct IO_VOLUME_PROVIDER* provider, void* fileCtx);
|
||||
KSTATUS (*QueryInfo)(struct IO_VOLUME_PROVIDER* provider, void* fileCtx, SYS_FILE_STAT* out);
|
||||
KSTATUS (*Stat)(struct IO_VOLUME_PROVIDER* provider, SYS_STRING_VIEW path, SYS_FILE_STAT* out);
|
||||
KSTATUS (*QueryIdentity)(struct IO_VOLUME_PROVIDER* provider, void* fileCtx, IO_FILE_IDENTITY* out);
|
||||
KSTATUS (*Flush)(struct IO_VOLUME_PROVIDER* provider, void* fileCtx);
|
||||
void (*Close)(struct IO_VOLUME_PROVIDER* provider, void* fileCtx);
|
||||
void (*QueryStats)(struct IO_VOLUME_PROVIDER* provider, IO_FILESYSTEM_STATS* out);
|
||||
KSTATUS (*OpenDir)(struct IO_VOLUME_PROVIDER* provider, SYS_STRING_VIEW dirPath, void** dirCtx);
|
||||
KSTATUS (*ReadDir)(struct IO_VOLUME_PROVIDER* provider, void* dirCtx, KDIR_ENTRY* out);
|
||||
void (*CloseDir)(struct IO_VOLUME_PROVIDER* provider, void* dirCtx);
|
||||
|
||||
// Called once when the mounted volume becomes unusable. It must not free Context.
|
||||
void (*VolumeDead)(struct IO_VOLUME_PROVIDER* provider, IO_VOLUME_REMOVAL_REASON reason);
|
||||
|
||||
// Called once after the final IO_VOLUME/file/directory reference drains.
|
||||
void (*Destroy)(struct IO_VOLUME_PROVIDER* provider);
|
||||
void* Context;
|
||||
} IO_VOLUME_PROVIDER;
|
||||
|
||||
typedef struct IO_VOLUME IO_VOLUME;
|
||||
|
||||
struct EVENT;
|
||||
struct KAPC;
|
||||
@@ -79,7 +95,7 @@ typedef struct IO_ASYNC_FILE_REQUEST_OBJECT IO_ASYNC_FILE_REQUEST_OBJECT;
|
||||
|
||||
typedef struct FILE_OBJECT {
|
||||
OBJECT Header;
|
||||
IO_FILESYSTEM* Fs;
|
||||
IO_VOLUME* Volume;
|
||||
void* FileCtx;
|
||||
SPINLOCK Lock;
|
||||
uint64_t Size;
|
||||
@@ -89,41 +105,58 @@ typedef struct FILE_OBJECT {
|
||||
|
||||
typedef struct DIR_OBJECT {
|
||||
OBJECT Header;
|
||||
IO_FILESYSTEM* Fs;
|
||||
IO_VOLUME* Volume;
|
||||
void* DirCtx;
|
||||
char* Path;
|
||||
size_t PathLength;
|
||||
} DIR_OBJECT;
|
||||
|
||||
typedef struct IO_VOLUME_PARAMS {
|
||||
uint8_t DiskIndex;
|
||||
uint64_t PartitionLba;
|
||||
uint64_t PartitionSize;
|
||||
} IO_VOLUME_PARAMS;
|
||||
typedef enum IO_VOLUME_SOURCE_TYPE {
|
||||
IoVolumeSourcePartition = 1,
|
||||
IoVolumeSourceBlockDevice,
|
||||
} IO_VOLUME_SOURCE_TYPE;
|
||||
|
||||
typedef struct IO_VOLUME_SOURCE {
|
||||
uint32_t Type;
|
||||
uint8_t DiskIndex;
|
||||
uint8_t Reserved[3];
|
||||
uint64_t StartLba;
|
||||
uint64_t SectorCount;
|
||||
} IO_VOLUME_SOURCE;
|
||||
|
||||
// Creates a mounted, refcounted volume and returns one caller reference.
|
||||
__declspec(dllexport) KSTATUS IoCreateVolume(const IO_VOLUME_PROVIDER* provider,
|
||||
const IO_VOLUME_SOURCE* source,
|
||||
IO_VOLUME** volumeOut);
|
||||
|
||||
// Marks a volume dead, removes it from the mounted-volume registry, and rejects future provider I/O.
|
||||
__declspec(dllexport) KSTATUS IoRemoveVolume(IO_VOLUME* volume, IO_VOLUME_REMOVAL_REASON reason);
|
||||
|
||||
// Releases a caller-owned volume reference returned by IoCreateVolume.
|
||||
__declspec(dllexport) void IoReleaseVolume(IO_VOLUME* volume);
|
||||
|
||||
// Returns the monotonic runtime instance identifier assigned to a mounted volume.
|
||||
__declspec(dllexport) uint32_t IoGetVolumeInstanceId(const IO_VOLUME* volume);
|
||||
|
||||
// Returns the immutable block source associated with a mounted volume.
|
||||
__declspec(dllexport) KSTATUS IoGetVolumeSource(const IO_VOLUME* volume, IO_VOLUME_SOURCE* sourceOut);
|
||||
|
||||
__declspec(dllexport) KSTATUS IoRegisterFilesystem(uint8_t driveIndex, IO_FILESYSTEM* fs, const IO_VOLUME_PARAMS* vol);
|
||||
__declspec(dllexport) KSTATUS IoUnregisterFilesystem(uint8_t driveIndex);
|
||||
__declspec(dllexport) KSTATUS IoUnregisterFilesystemsForDisk(uint8_t diskIndex);
|
||||
__declspec(dllexport) bool IoFilesystemPresent(uint8_t driveIndex);
|
||||
__declspec(dllexport) void IoQueryFilesystemStats(IO_FILESYSTEM_STATS* out);
|
||||
__declspec(dllexport) KSTATUS IoOpenFile(SYS_STRING_VIEW path, FILE_OBJECT** out);
|
||||
// Capability-relative native opens. Paths are canonical relative paths: '/' separators only,
|
||||
// no leading/trailing separator, empty components, '.', '..', backslash, or embedded NUL.
|
||||
__declspec(dllexport) KSTATUS IoOpenFileAtVolume(IO_VOLUME* volume, SYS_STRING_VIEW path, FILE_OBJECT** out);
|
||||
__declspec(dllexport) KSTATUS IoCreateFileAtVolume(IO_VOLUME* volume, SYS_STRING_VIEW path, FILE_OBJECT** out);
|
||||
__declspec(dllexport) KSTATUS IoOpenDirAtVolume(IO_VOLUME* volume, SYS_STRING_VIEW path, DIR_OBJECT** out);
|
||||
__declspec(dllexport) KSTATUS IoReadFile(FILE_OBJECT* file, void* buf, size_t size, size_t* bytesRead);
|
||||
__declspec(dllexport) KSTATUS IoReadFileAt(FILE_OBJECT* file, uint64_t offset, void* buf, size_t size, size_t* bytesRead);
|
||||
__declspec(dllexport) KSTATUS IoWriteFile(FILE_OBJECT* file, const void* buf, size_t size, size_t* bytesWritten);
|
||||
__declspec(dllexport) KSTATUS IoWriteFileAt(FILE_OBJECT* file, uint64_t offset, const void* buf, size_t size, size_t* bytesWritten);
|
||||
__declspec(dllexport) KSTATUS IoFlushFile(FILE_OBJECT* file);
|
||||
__declspec(dllexport) KSTATUS IoCreateFile(SYS_STRING_VIEW path, FILE_OBJECT** out);
|
||||
__declspec(dllexport) KSTATUS IoDeleteFile(SYS_STRING_VIEW path);
|
||||
__declspec(dllexport) KSTATUS IoRenameFile(SYS_STRING_VIEW oldPath, SYS_STRING_VIEW newPath);
|
||||
__declspec(dllexport) KSTATUS IoCreateDir(SYS_STRING_VIEW path);
|
||||
__declspec(dllexport) KSTATUS IoRemoveDir(SYS_STRING_VIEW path);
|
||||
__declspec(dllexport) KSTATUS IoTruncateFile(FILE_OBJECT* file, uint64_t newSize);
|
||||
__declspec(dllexport) KSTATUS IoSeekFile(FILE_OBJECT* file, uint64_t offset);
|
||||
__declspec(dllexport) uint64_t IoGetFileSize(FILE_OBJECT* file);
|
||||
__declspec(dllexport) KSTATUS IoGetFileStat(FILE_OBJECT* file, SYS_FILE_STAT* out);
|
||||
__declspec(dllexport) KSTATUS IoStatFile(SYS_STRING_VIEW path, SYS_FILE_STAT* out);
|
||||
__declspec(dllexport) KSTATUS IoQueryFileIdentity(FILE_OBJECT* file, IO_FILE_IDENTITY* out);
|
||||
__declspec(dllexport) void IoCloseFile(FILE_OBJECT* file);
|
||||
__declspec(dllexport) KSTATUS IoOpenDir(SYS_STRING_VIEW dirPath, DIR_OBJECT** out);
|
||||
__declspec(dllexport) KSTATUS IoReadDir(DIR_OBJECT* dir, KDIR_ENTRY* entryOut);
|
||||
__declspec(dllexport) void IoCloseDir(DIR_OBJECT* dir);
|
||||
__declspec(dllexport) KSTATUS IoSetCwd(SYS_STRING_VIEW path);
|
||||
__declspec(dllexport) KSTATUS IoRealPath(SYS_STRING_VIEW path, char* buffer, size_t bufferSize, size_t* requiredSizeOut);
|
||||
@@ -5,9 +5,16 @@
|
||||
#include <stdint.h>
|
||||
#include <ntlite/status.h>
|
||||
|
||||
typedef struct NTL_DDK_MSI_MESSAGE {
|
||||
uint64_t Address;
|
||||
uint32_t Data;
|
||||
uint32_t Reserved;
|
||||
} NTL_DDK_MSI_MESSAGE;
|
||||
|
||||
// Driver-visible interrupt services.
|
||||
typedef struct NTL_DDK_INTERRUPT {
|
||||
KSTATUS (*AllocateMsiVector)(uint8_t* outIrq);
|
||||
KSTATUS (*ComposeMsiMessage)(uint8_t irq, NTL_DDK_MSI_MESSAGE* messageOut);
|
||||
} NTL_DDK_INTERRUPT;
|
||||
|
||||
// Allocates one kernel IRQ slot for MSI delivery.
|
||||
|
||||
@@ -13,6 +13,12 @@ typedef uint8_t KIRQL;
|
||||
#define DIRQL_BASE ((KIRQL)16)
|
||||
#define HIGH_LEVEL ((KIRQL)31)
|
||||
|
||||
// Masks interrupts and returns an opaque state restored by KeRestoreInterrupts.
|
||||
__declspec(dllexport) uintptr_t KeDisableInterrupts(void);
|
||||
|
||||
// Restores the interrupt state returned by KeDisableInterrupts.
|
||||
__declspec(dllexport) void KeRestoreInterrupts(uintptr_t flags);
|
||||
|
||||
// Returns the current processor's software IRQL.
|
||||
__declspec(dllexport) KIRQL KeGetCurrentIrql(void);
|
||||
|
||||
|
||||
@@ -15,7 +15,7 @@ typedef struct LIST_ENTRY {
|
||||
|
||||
// Recover the containing struct pointer from an embedded list node.
|
||||
#define CONTAINING_RECORD(ptr, type, member) \
|
||||
((type *)((char *)(ptr) - offsetof(type, member)))
|
||||
((type*)((char*)(ptr) - offsetof(type, member)))
|
||||
|
||||
// Inserts a node at the tail of a list.
|
||||
static inline void ListInsertTail(LIST_ENTRY* head, LIST_ENTRY* node) {
|
||||
|
||||
@@ -27,10 +27,13 @@ typedef enum OBJECT_TYPE {
|
||||
ObjectTypeInputQueue = 17,
|
||||
ObjectTypeImageSection = 18,
|
||||
ObjectTypeTimer = 19,
|
||||
ObjectTypeModule = 20,
|
||||
ObjectTypeDisplayClock = 21,
|
||||
ObjectTypeAudioEndpoint = 22,
|
||||
ObjectTypeAudioStream = 23,
|
||||
ObjectTypeDisplayClock = 20,
|
||||
ObjectTypeAudioEndpoint = 21,
|
||||
ObjectTypeAudioStream = 22,
|
||||
ObjectTypeSecurityContext = 23,
|
||||
ObjectTypePort = 24,
|
||||
ObjectTypeVolume = 25,
|
||||
ObjectTypeVolumeManager = 26,
|
||||
} OBJECT_TYPE;
|
||||
|
||||
typedef enum OBJECT_LIFETIME_STATE {
|
||||
|
||||
@@ -18,6 +18,4 @@ typedef struct NTL_DDK_PLATFORM {
|
||||
uint8_t function,
|
||||
uint16_t offset,
|
||||
uint32_t value);
|
||||
uint32_t (*GetBspLapicId)(void);
|
||||
uint8_t (*IsX2ApicEnabled)(void);
|
||||
} NTL_DDK_PLATFORM;
|
||||
@@ -5,7 +5,7 @@
|
||||
#include <stddef.h>
|
||||
#include <ntlite/status.h>
|
||||
|
||||
#define KE_SETTINGS_PATH "system\\settings.ini"
|
||||
#define KE_SETTINGS_PATH "system/settings.ini"
|
||||
|
||||
// Reads one string setting from the system settings file.
|
||||
__declspec(dllexport) KSTATUS KeGetSettingString(const char* section,
|
||||
|
||||
@@ -4,7 +4,6 @@
|
||||
|
||||
#include <stdint.h>
|
||||
#include <intrin.h>
|
||||
#include <ntlite/ddi/hal_api.h>
|
||||
#include <ntlite/ddk/irql.h>
|
||||
|
||||
// Legacy spinlock storage used by current driver-visible objects.
|
||||
@@ -38,7 +37,7 @@ static __forceinline KIRQL KiSpinlockCookieIrql(uintptr_t cookie) {
|
||||
|
||||
// Acquires a spinlock and raises to at least DISPATCH_LEVEL.
|
||||
static __forceinline uintptr_t KeAcquireSpinlock(SPINLOCK* sl) {
|
||||
uintptr_t flags = HalDisableInterrupts();
|
||||
uintptr_t flags = KeDisableInterrupts();
|
||||
|
||||
KIRQL oldIrql = KeGetCurrentIrql();
|
||||
if (oldIrql < DISPATCH_LEVEL)
|
||||
@@ -57,12 +56,12 @@ static __forceinline void KeReleaseSpinlock(SPINLOCK* sl, uintptr_t cookie) {
|
||||
|
||||
_InterlockedExchange(&sl->Locked, 0);
|
||||
KeLowerIrql(oldIrql);
|
||||
HalRestoreInterrupts(flags);
|
||||
KeRestoreInterrupts(flags);
|
||||
}
|
||||
|
||||
// Attempts to acquire a spinlock without blocking.
|
||||
static __forceinline int KeTryAcquireSpinlock(SPINLOCK* sl, uintptr_t* outCookie) {
|
||||
uintptr_t flags = HalDisableInterrupts();
|
||||
uintptr_t flags = KeDisableInterrupts();
|
||||
|
||||
KIRQL oldIrql = KeGetCurrentIrql();
|
||||
if (oldIrql < DISPATCH_LEVEL)
|
||||
@@ -74,7 +73,7 @@ static __forceinline int KeTryAcquireSpinlock(SPINLOCK* sl, uintptr_t* outCookie
|
||||
}
|
||||
|
||||
KeLowerIrql(oldIrql);
|
||||
HalRestoreInterrupts(flags);
|
||||
KeRestoreInterrupts(flags);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,100 @@
|
||||
// Public nt-lite capability handle declarations.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
// Handle values are process-local monotonic identities. Zero is invalid, and
|
||||
// an issued value is never reused during the lifetime of its owning process.
|
||||
typedef uint32_t SYS_HANDLE;
|
||||
typedef uint32_t SYS_RIGHTS;
|
||||
|
||||
#define SYS_HANDLE_INVALID ((SYS_HANDLE)0u)
|
||||
|
||||
// Capability-management rights shared by every handle type. Rights may only attenuate during delegation.
|
||||
#define SYS_RIGHT_DUPLICATE 0x00000001u
|
||||
#define SYS_RIGHT_DERIVE 0x00000002u
|
||||
#define SYS_RIGHT_REVOKE 0x00000004u
|
||||
#define SYS_RIGHT_TRANSFER 0x00000008u
|
||||
#define SYS_RIGHT_QUERY 0x00000010u
|
||||
#define SYS_RIGHT_WAIT 0x00000020u
|
||||
#define SYS_RIGHT_COMMON_MASK 0x0000003Fu
|
||||
|
||||
// Process-specific rights.
|
||||
#define SYS_PROCESS_RIGHT_TERMINATE 0x00000100u
|
||||
#define SYS_PROCESS_RIGHT_INSERT_HANDLE 0x00000200u
|
||||
#define SYS_PROCESS_RIGHT_BUILD 0x00000400u
|
||||
|
||||
// Thread-specific rights.
|
||||
#define SYS_THREAD_RIGHT_RESUME 0x00000100u
|
||||
|
||||
// Mutex-specific rights.
|
||||
#define SYS_MUTEX_RIGHT_RELEASE 0x00000100u
|
||||
|
||||
// Semaphore-specific rights.
|
||||
#define SYS_SEMAPHORE_RIGHT_SIGNAL 0x00000100u
|
||||
|
||||
// Event-specific rights.
|
||||
#define SYS_EVENT_RIGHT_SIGNAL 0x00000100u
|
||||
|
||||
// Queue-specific rights.
|
||||
#define SYS_QUEUE_RIGHT_SEND 0x00000100u
|
||||
#define SYS_QUEUE_RIGHT_RECEIVE 0x00000200u
|
||||
#define SYS_QUEUE_RIGHT_PUBLISH 0x00000400u
|
||||
|
||||
// File-specific rights.
|
||||
#define SYS_FILE_RIGHT_READ_DATA 0x00000100u
|
||||
#define SYS_FILE_RIGHT_WRITE_DATA 0x00000200u
|
||||
#define SYS_FILE_RIGHT_LOCK 0x00000400u
|
||||
#define SYS_FILE_RIGHT_MAP_READ 0x00000800u
|
||||
#define SYS_FILE_RIGHT_MAP_WRITE 0x00001000u
|
||||
|
||||
// Mounted-volume rights.
|
||||
#define SYS_VOLUME_RIGHT_OPEN 0x00000100u
|
||||
#define SYS_VOLUME_RIGHT_MODIFY 0x00000200u
|
||||
|
||||
// Volume-manager rights. The manager capability is delegated only to the userspace storage control plane.
|
||||
#define SYS_VOLUME_MANAGER_RIGHT_ENUMERATE 0x00000100u
|
||||
#define SYS_VOLUME_MANAGER_RIGHT_OPEN 0x00000200u
|
||||
#define SYS_VOLUME_MANAGER_RIGHT_WAIT 0x00000400u
|
||||
|
||||
// Directory-specific rights.
|
||||
#define SYS_DIR_RIGHT_ENUMERATE 0x00000100u
|
||||
#define SYS_DIR_RIGHT_OPEN 0x00000200u
|
||||
#define SYS_DIR_RIGHT_MODIFY 0x00000400u
|
||||
|
||||
// Asynchronous I/O request rights.
|
||||
#define SYS_ASYNC_IO_RIGHT_CANCEL 0x00000100u
|
||||
|
||||
// Socket-specific rights.
|
||||
#define SYS_SOCKET_RIGHT_BIND 0x00000100u
|
||||
#define SYS_SOCKET_RIGHT_CONNECT 0x00000200u
|
||||
#define SYS_SOCKET_RIGHT_LISTEN 0x00000400u
|
||||
#define SYS_SOCKET_RIGHT_ACCEPT 0x00000800u
|
||||
#define SYS_SOCKET_RIGHT_SEND 0x00001000u
|
||||
#define SYS_SOCKET_RIGHT_RECEIVE 0x00002000u
|
||||
#define SYS_SOCKET_RIGHT_SHUTDOWN 0x00004000u
|
||||
#define SYS_SOCKET_RIGHT_POLL 0x00008000u
|
||||
#define SYS_SOCKET_RIGHT_SET_OPTION 0x00010000u
|
||||
|
||||
// File-mapping rights.
|
||||
#define SYS_FILE_MAPPING_RIGHT_MAP 0x00000100u
|
||||
|
||||
// Surface rights.
|
||||
#define SYS_SURFACE_RIGHT_MAP 0x00000100u
|
||||
#define SYS_SURFACE_RIGHT_PRESENT 0x00000200u
|
||||
|
||||
// Input-queue rights.
|
||||
#define SYS_INPUT_QUEUE_RIGHT_READ 0x00000100u
|
||||
|
||||
// Timer rights.
|
||||
#define SYS_TIMER_RIGHT_SET 0x00000100u
|
||||
|
||||
// Audio-stream rights.
|
||||
#define SYS_AUDIO_STREAM_RIGHT_WRITE 0x00000100u
|
||||
#define SYS_AUDIO_STREAM_RIGHT_CONTROL 0x00000200u
|
||||
|
||||
// Security-context-specific rights are declared in <ntlite/security.h>.
|
||||
|
||||
// Rights normally retained by a newly created root capability.
|
||||
#define SYS_RIGHT_MANAGE (SYS_RIGHT_DUPLICATE | SYS_RIGHT_DERIVE | SYS_RIGHT_REVOKE | SYS_RIGHT_TRANSFER)
|
||||
@@ -0,0 +1,76 @@
|
||||
// Native userspace module-loader declarations.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <ntlite/handle.h>
|
||||
#include <ntlite/status.h>
|
||||
#include <ntlite/string_view.h>
|
||||
|
||||
#define NTL_MODULE_NAME_MAX 64u
|
||||
#define NTL_MODULE_LOAD_FLAG_NONE 0x00000000u
|
||||
|
||||
// Opaque process-local userspace module identity. It is never a kernel capability.
|
||||
typedef uintptr_t NTL_MODULE_HANDLE;
|
||||
#define NTL_MODULE_HANDLE_INVALID ((NTL_MODULE_HANDLE)0u)
|
||||
|
||||
// Maps one PE import name to the canonical module filename used by policy.
|
||||
// canonicalNameOut may refer to requestedName storage or to caller-owned static storage.
|
||||
typedef KSTATUS (*NTL_MODULE_NAME_RESOLVER)(void* context,
|
||||
SYS_STRING_VIEW requestedName,
|
||||
SYS_STRING_VIEW* canonicalNameOut);
|
||||
|
||||
typedef struct NTL_MODULE_INFO {
|
||||
uintptr_t Base;
|
||||
size_t Size;
|
||||
uintptr_t EntryPoint;
|
||||
uint32_t PublicRefCount;
|
||||
uint32_t ImportPinned;
|
||||
char Name[NTL_MODULE_NAME_MAX];
|
||||
} NTL_MODULE_INFO;
|
||||
|
||||
typedef struct NTL_LOAD_MODULE_AT_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
SYS_HANDLE RootHandle;
|
||||
SYS_STRING_VIEW Path;
|
||||
SYS_HANDLE ModuleRootHandle;
|
||||
SYS_STRING_VIEW ModuleDirectory;
|
||||
NTL_MODULE_NAME_RESOLVER ResolveModuleName;
|
||||
void* ResolveContext;
|
||||
NTL_MODULE_HANDLE* ModuleHandleOut;
|
||||
NTL_MODULE_INFO* InfoOut;
|
||||
} NTL_LOAD_MODULE_AT_REQUEST;
|
||||
|
||||
#if defined(NTL_SYSCALL_STATIC)
|
||||
#define NTL_MODULE_LOADER_API
|
||||
#elif defined(NTL_SYSCALL_BUILD)
|
||||
#define NTL_MODULE_LOADER_API __declspec(dllexport)
|
||||
#else
|
||||
#define NTL_MODULE_LOADER_API
|
||||
#endif
|
||||
|
||||
// Identity module-name policy for native images whose import names are already canonical.
|
||||
NTL_MODULE_LOADER_API KSTATUS NtlResolveModuleNameIdentity(void* context,
|
||||
SYS_STRING_VIEW requestedName,
|
||||
SYS_STRING_VIEW* canonicalNameOut);
|
||||
|
||||
// Resolves the installed Win32/POSIX compatibility import aliases for generic userspace launchers.
|
||||
NTL_MODULE_LOADER_API KSTATUS NtlResolveSystemModuleName(void* context,
|
||||
SYS_STRING_VIEW requestedName,
|
||||
SYS_STRING_VIEW* canonicalNameOut);
|
||||
|
||||
// Loads one DLL-like image into the current process. Dependency images are resolved
|
||||
// beneath ModuleRootHandle/ModuleDirectory and remain import-pinned for process lifetime.
|
||||
NTL_MODULE_LOADER_API KSTATUS NtlLoadModuleAt(const NTL_LOAD_MODULE_AT_REQUEST* request);
|
||||
NTL_MODULE_LOADER_API KSTATUS NtlUnloadModule(NTL_MODULE_HANDLE module);
|
||||
NTL_MODULE_LOADER_API KSTATUS NtlGetModuleInfo(NTL_MODULE_HANDLE module, NTL_MODULE_INFO* infoOut);
|
||||
NTL_MODULE_LOADER_API KSTATUS NtlGetModuleExport(NTL_MODULE_HANDLE module,
|
||||
SYS_STRING_VIEW name,
|
||||
uintptr_t* addressOut);
|
||||
NTL_MODULE_LOADER_API KSTATUS NtlGetModuleList(NTL_MODULE_INFO* modulesOut,
|
||||
size_t maxCount,
|
||||
size_t* countOut);
|
||||
|
||||
#undef NTL_MODULE_LOADER_API
|
||||
@@ -0,0 +1,49 @@
|
||||
// Native userspace path and filesystem base services.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <ntlite/handle.h>
|
||||
#include <ntlite/status.h>
|
||||
#include <ntlite/string_view.h>
|
||||
#include <ntlite/file_stat.h>
|
||||
#include <ntlite/syscall.h>
|
||||
|
||||
#if defined(NTL_SYSCALL_STATIC)
|
||||
#define NTL_PATH_API
|
||||
#elif defined(NTL_SYSCALL_BUILD)
|
||||
#define NTL_PATH_API __declspec(dllexport)
|
||||
#else
|
||||
#define NTL_PATH_API
|
||||
#endif
|
||||
|
||||
// Native global paths are canonical resource paths such as /SystemRoot/system/init.exe.
|
||||
// Relative paths are resolved against the process-local userspace CWD. Parent traversal is
|
||||
// clamped at the CWD's owning RSSRV resource binding. Backslash is never accepted; repeated '/',
|
||||
// '.', and '..' are normalized before RSSRV sees the path.
|
||||
NTL_PATH_API KSTATUS NtlRealPath(SYS_STRING_VIEW path,
|
||||
char* buffer,
|
||||
size_t bufferSize,
|
||||
size_t* requiredSizeOut);
|
||||
NTL_PATH_API KSTATUS NtlSetCurrentDirectory(SYS_STRING_VIEW path);
|
||||
NTL_PATH_API KSTATUS NtlGetCurrentDirectory(char* buffer,
|
||||
size_t bufferSize,
|
||||
size_t* requiredSizeOut);
|
||||
|
||||
NTL_PATH_API KSTATUS NtlOpenFile(SYS_STRING_VIEW path,
|
||||
uint32_t access,
|
||||
uint32_t disposition,
|
||||
uint32_t flags,
|
||||
SYS_HANDLE* handleOut);
|
||||
NTL_PATH_API KSTATUS NtlOpenDir(SYS_STRING_VIEW path,
|
||||
uint32_t access,
|
||||
uint32_t flags,
|
||||
SYS_HANDLE* handleOut);
|
||||
NTL_PATH_API KSTATUS NtlStatPath(SYS_STRING_VIEW path, SYS_FILE_STAT* statOut);
|
||||
NTL_PATH_API KSTATUS NtlDeleteFile(SYS_STRING_VIEW path);
|
||||
NTL_PATH_API KSTATUS NtlRenameFile(SYS_STRING_VIEW oldPath, SYS_STRING_VIEW newPath);
|
||||
NTL_PATH_API KSTATUS NtlCreateDirectory(SYS_STRING_VIEW path);
|
||||
NTL_PATH_API KSTATUS NtlRemoveDirectory(SYS_STRING_VIEW path);
|
||||
|
||||
#undef NTL_PATH_API
|
||||
@@ -0,0 +1,56 @@
|
||||
// Native userspace PE32+ image-loader declarations.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <ntlite/status.h>
|
||||
#include <ntlite/string_view.h>
|
||||
#include <ntlite/handle.h>
|
||||
|
||||
#define NTL_PE_LOAD_FLAG_NONE 0x00000000u
|
||||
|
||||
typedef KSTATUS (*NTL_PE_IMPORT_RESOLVER)(void* context,
|
||||
SYS_STRING_VIEW moduleName,
|
||||
SYS_STRING_VIEW symbolName,
|
||||
uintptr_t* addressOut);
|
||||
|
||||
typedef struct NTL_PE_IMAGE {
|
||||
uintptr_t Base;
|
||||
size_t Size;
|
||||
uintptr_t EntryPoint;
|
||||
uint64_t PreferredBase;
|
||||
} NTL_PE_IMAGE;
|
||||
|
||||
typedef KSTATUS (*NTL_PE_PREPARED_CALLBACK)(void* context, const NTL_PE_IMAGE* image);
|
||||
|
||||
typedef struct NTL_PE_LOAD_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE ProcessHandle;
|
||||
SYS_HANDLE FileHandle;
|
||||
uint32_t Flags;
|
||||
NTL_PE_IMPORT_RESOLVER ResolveImport;
|
||||
void* ResolveContext;
|
||||
NTL_PE_PREPARED_CALLBACK Prepared;
|
||||
void* PreparedContext;
|
||||
NTL_PE_IMAGE* ImageOut;
|
||||
} NTL_PE_LOAD_REQUEST;
|
||||
|
||||
#if defined(NTL_SYSCALL_STATIC)
|
||||
#define NTL_SYSCALL_API
|
||||
#elif defined(NTL_SYSCALL_BUILD)
|
||||
#define NTL_SYSCALL_API __declspec(dllexport)
|
||||
#else
|
||||
#define NTL_SYSCALL_API
|
||||
#endif
|
||||
|
||||
// Reads, validates, materializes, relocates, binds, and protects one AMD64 PE32+ image.
|
||||
// ProcessHandle may be SYS_HANDLE_INVALID to target the current process. Dependency policy
|
||||
// remains entirely in ResolveImport. Prepared runs after relocation and before import binding.
|
||||
NTL_SYSCALL_API KSTATUS NtlLoadPeImage(const NTL_PE_LOAD_REQUEST* request);
|
||||
|
||||
// Resolves one named export directly from an already-materialized PE image. Forwarders and
|
||||
// ordinal lookups are intentionally unsupported.
|
||||
NTL_SYSCALL_API KSTATUS NtlGetPeExport(uintptr_t imageBase, SYS_STRING_VIEW name, uintptr_t* addressOut);
|
||||
|
||||
#undef NTL_SYSCALL_API
|
||||
@@ -0,0 +1,150 @@
|
||||
// Public nt-lite Port IPC declarations. Payload pointers are syscall-local only; queued messages never retain them.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <ntlite/handle.h>
|
||||
|
||||
// Larger transfers should pass a mapping/file-mapping capability instead of enlarging inline messages.
|
||||
#define SYS_PORT_MAX_INLINE_BYTES 4096u
|
||||
#define SYS_PORT_MAX_TRANSFER_HANDLES 8u
|
||||
#define SYS_PORT_DEFAULT_BACKLOG 16u
|
||||
#define SYS_PORT_MAX_BACKLOG 64u
|
||||
#define SYS_PORT_QUEUE_MESSAGE_LIMIT 64u
|
||||
#define SYS_PORT_QUEUE_BYTE_LIMIT (64u * 1024u)
|
||||
#define SYS_PORT_QUEUE_HANDLE_LIMIT 128u
|
||||
#define SYS_PORT_TIMEOUT_INFINITE UINT64_MAX
|
||||
|
||||
#define SYS_PORT_FLAG_NONE 0u
|
||||
|
||||
#define SYS_PORT_MESSAGE_NOTIFICATION 1u
|
||||
#define SYS_PORT_MESSAGE_REQUEST 2u
|
||||
#define SYS_PORT_MESSAGE_REPLY 3u
|
||||
|
||||
// With no flag, DesiredRights creates an attenuated alias of the source grant.
|
||||
// SAME_RIGHTS requires DesiredRights=0. DERIVE creates a revocable child grant.
|
||||
#define SYS_PORT_TRANSFER_FLAG_NONE 0u
|
||||
#define SYS_PORT_TRANSFER_FLAG_SAME_RIGHTS 0x00000001u
|
||||
#define SYS_PORT_TRANSFER_FLAG_DERIVE 0x00000002u
|
||||
|
||||
#define SYS_PORT_ACCEPT_FLAG_NONE 0u
|
||||
#define SYS_PORT_CONNECT_FLAG_NONE 0u
|
||||
|
||||
// Port-specific capability rights.
|
||||
#define SYS_PORT_RIGHT_CONNECT 0x00000100u
|
||||
#define SYS_PORT_RIGHT_ACCEPT 0x00000200u
|
||||
#define SYS_PORT_RIGHT_SEND 0x00000400u
|
||||
#define SYS_PORT_RIGHT_RECEIVE 0x00000800u
|
||||
#define SYS_PORT_RIGHT_CALL 0x00001000u
|
||||
#define SYS_PORT_RIGHT_REPLY 0x00002000u
|
||||
#define SYS_PORT_RIGHT_DISCONNECT 0x00004000u
|
||||
|
||||
// Describes one capability that accompanies a Port message.
|
||||
typedef struct SYS_PORT_HANDLE_TRANSFER {
|
||||
SYS_HANDLE Handle;
|
||||
SYS_RIGHTS DesiredRights;
|
||||
uint32_t Flags;
|
||||
} SYS_PORT_HANDLE_TRANSFER;
|
||||
|
||||
// Describes one delivered Port message. Sender identity is always kernel-stamped.
|
||||
typedef struct SYS_PORT_MESSAGE_INFO {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
uint32_t MessageId;
|
||||
uint32_t Type;
|
||||
uint32_t PayloadLength;
|
||||
uint32_t HandleCount;
|
||||
uint32_t SenderProcessId;
|
||||
uint32_t SenderThreadId;
|
||||
uint32_t SenderSecurityId;
|
||||
} SYS_PORT_MESSAGE_INFO;
|
||||
|
||||
// Describes the client that created one accepted Port connection.
|
||||
typedef struct SYS_PORT_CONNECTION_INFO {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
uint32_t ClientProcessId;
|
||||
uint32_t ClientThreadId;
|
||||
uint32_t ClientSecurityId;
|
||||
} SYS_PORT_CONNECTION_INFO;
|
||||
|
||||
// Creates one connection-listener Port.
|
||||
typedef struct SYS_CREATE_PORT_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
uint32_t Backlog;
|
||||
SYS_HANDLE* HandleOut;
|
||||
} SYS_CREATE_PORT_REQUEST;
|
||||
|
||||
// Connects to one listener capability directly.
|
||||
typedef struct SYS_CONNECT_PORT_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE ListenerHandle;
|
||||
uint32_t Flags;
|
||||
SYS_HANDLE* EndpointHandleOut;
|
||||
} SYS_CONNECT_PORT_REQUEST;
|
||||
|
||||
// Accepts one queued connection from a listener.
|
||||
typedef struct SYS_ACCEPT_PORT_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE ListenerHandle;
|
||||
uint32_t Flags;
|
||||
uint64_t TimeoutMilliseconds;
|
||||
SYS_HANDLE* EndpointHandleOut;
|
||||
SYS_PORT_CONNECTION_INFO* ConnectionInfoOut;
|
||||
} SYS_ACCEPT_PORT_REQUEST;
|
||||
|
||||
// Sends one one-way notification to the peer endpoint.
|
||||
typedef struct SYS_SEND_PORT_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE EndpointHandle;
|
||||
uint32_t Flags;
|
||||
const void* Payload;
|
||||
uint32_t PayloadLength;
|
||||
const SYS_PORT_HANDLE_TRANSFER* Handles;
|
||||
uint32_t HandleCount;
|
||||
uint64_t TimeoutMilliseconds;
|
||||
} SYS_SEND_PORT_REQUEST;
|
||||
|
||||
// Receives one request or notification from the endpoint.
|
||||
typedef struct SYS_RECEIVE_PORT_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE EndpointHandle;
|
||||
uint32_t Flags;
|
||||
void* Payload;
|
||||
uint32_t PayloadCapacity;
|
||||
SYS_HANDLE* HandlesOut;
|
||||
uint32_t HandleCapacity;
|
||||
SYS_PORT_MESSAGE_INFO* InfoOut;
|
||||
uint64_t TimeoutMilliseconds;
|
||||
} SYS_RECEIVE_PORT_REQUEST;
|
||||
|
||||
// Sends a synchronous request and receives its reply. Timeout zero returns WOULD_BLOCK without sending.
|
||||
typedef struct SYS_CALL_PORT_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE EndpointHandle;
|
||||
uint32_t Flags;
|
||||
const void* RequestPayload;
|
||||
uint32_t RequestLength;
|
||||
const SYS_PORT_HANDLE_TRANSFER* RequestHandles;
|
||||
uint32_t RequestHandleCount;
|
||||
void* ReplyPayload;
|
||||
uint32_t ReplyCapacity;
|
||||
SYS_HANDLE* ReplyHandlesOut;
|
||||
uint32_t ReplyHandleCapacity;
|
||||
SYS_PORT_MESSAGE_INFO* ReplyInfoOut;
|
||||
uint64_t TimeoutMilliseconds;
|
||||
} SYS_CALL_PORT_REQUEST;
|
||||
|
||||
// Replies to one synchronous request identified by MessageId.
|
||||
typedef struct SYS_REPLY_PORT_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE EndpointHandle;
|
||||
uint32_t MessageId;
|
||||
uint32_t Flags;
|
||||
const void* Payload;
|
||||
uint32_t PayloadLength;
|
||||
const SYS_PORT_HANDLE_TRANSFER* Handles;
|
||||
uint32_t HandleCount;
|
||||
} SYS_REPLY_PORT_REQUEST;
|
||||
@@ -0,0 +1,71 @@
|
||||
// Native userspace process-loader declarations.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <ntlite/handle.h>
|
||||
#include <ntlite/status.h>
|
||||
#include <ntlite/string_view.h>
|
||||
#include <ntlite/pe_loader.h>
|
||||
#include <ntlite/module_loader.h>
|
||||
|
||||
#define NTL_PROCESS_LOAD_FLAG_NONE 0x00000000u
|
||||
|
||||
// Describes one source capability to duplicate into a constructing child.
|
||||
typedef struct NTL_PROCESS_STARTUP_CAPABILITY {
|
||||
uint32_t Tag;
|
||||
SYS_HANDLE SourceHandle;
|
||||
SYS_RIGHTS DesiredRights;
|
||||
uint32_t DuplicateFlags;
|
||||
} NTL_PROCESS_STARTUP_CAPABILITY;
|
||||
|
||||
// Creates and starts one PE32+ process entirely through the userspace image loader.
|
||||
typedef struct NTL_CREATE_PROCESS_AT_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
SYS_HANDLE RootHandle;
|
||||
SYS_STRING_VIEW Path;
|
||||
SYS_STRING_VIEW CommandLine;
|
||||
// Empty inherits the caller's userspace CWD; non-empty is normalized as a native resource path.
|
||||
SYS_STRING_VIEW CurrentDirectory;
|
||||
SYS_HANDLE SecurityContext;
|
||||
SYS_HANDLE ModuleRootHandle;
|
||||
SYS_STRING_VIEW ModuleDirectory;
|
||||
NTL_MODULE_NAME_RESOLVER ResolveModuleName;
|
||||
void* ResolveContext;
|
||||
const NTL_PROCESS_STARTUP_CAPABILITY* StartupCapabilities;
|
||||
uint32_t StartupCapabilityCount;
|
||||
SYS_HANDLE* ProcessHandleOut;
|
||||
} NTL_CREATE_PROCESS_AT_REQUEST;
|
||||
|
||||
// Creates one process beneath the globally published /SystemRoot volume. Path remains a
|
||||
// canonical volume-relative native path; RSSRV is used only to obtain the volume capability.
|
||||
typedef struct NTL_CREATE_SYSTEM_PROCESS_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
// Optional pre-opened executable file. When supplied, Path is diagnostic/PEB identity only.
|
||||
SYS_HANDLE ImageFile;
|
||||
SYS_STRING_VIEW Path;
|
||||
SYS_STRING_VIEW CommandLine;
|
||||
// Empty inherits the caller's userspace CWD; non-empty is normalized as a native resource path.
|
||||
SYS_STRING_VIEW CurrentDirectory;
|
||||
SYS_HANDLE SecurityContext;
|
||||
NTL_MODULE_NAME_RESOLVER ResolveModuleName;
|
||||
void* ResolveContext;
|
||||
const NTL_PROCESS_STARTUP_CAPABILITY* StartupCapabilities;
|
||||
uint32_t StartupCapabilityCount;
|
||||
SYS_HANDLE* ProcessHandleOut;
|
||||
} NTL_CREATE_SYSTEM_PROCESS_REQUEST;
|
||||
|
||||
#if defined(NTL_SYSCALL_STATIC)
|
||||
#define NTL_PROCESS_LOADER_API
|
||||
#elif defined(NTL_SYSCALL_BUILD)
|
||||
#define NTL_PROCESS_LOADER_API __declspec(dllexport)
|
||||
#else
|
||||
#define NTL_PROCESS_LOADER_API
|
||||
#endif
|
||||
|
||||
NTL_PROCESS_LOADER_API KSTATUS NtlCreateProcessAt(const NTL_CREATE_PROCESS_AT_REQUEST* request);
|
||||
NTL_PROCESS_LOADER_API KSTATUS NtlCreateSystemProcess(const NTL_CREATE_SYSTEM_PROCESS_REQUEST* request);
|
||||
|
||||
#undef NTL_PROCESS_LOADER_API
|
||||
@@ -0,0 +1,96 @@
|
||||
// Native resource-service protocol and client helpers.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <ntlite/handle.h>
|
||||
#include <ntlite/status.h>
|
||||
#include <ntlite/string_view.h>
|
||||
|
||||
#define NTL_RESOURCE_PROTOCOL_VERSION 2u
|
||||
#define NTL_RESOURCE_PATH_MAX 1024u
|
||||
|
||||
#define NTL_RESOURCE_FLAG_NONE 0x00000000u
|
||||
#define NTL_RESOURCE_RESOLVE_FLAG_MODIFY 0x00000001u
|
||||
|
||||
#define NTL_RESOURCE_OP_LOOKUP 1u
|
||||
#define NTL_RESOURCE_OP_QUERY 2u
|
||||
#define NTL_RESOURCE_OP_BIND 3u
|
||||
#define NTL_RESOURCE_OP_UNBIND 4u
|
||||
#define NTL_RESOURCE_OP_RESOLVE 5u
|
||||
|
||||
#define NTL_RESOURCE_KIND_INVALID 0u
|
||||
#define NTL_RESOURCE_KIND_CAPABILITY 1u
|
||||
#define NTL_RESOURCE_KIND_VOLUME 2u
|
||||
#define NTL_RESOURCE_KIND_DIRECTORY 3u
|
||||
#define NTL_RESOURCE_KIND_DEVICE 4u
|
||||
|
||||
// Request header followed immediately by PathLength bytes of canonical native resource path.
|
||||
typedef struct NTL_RESOURCE_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Version;
|
||||
uint32_t Operation;
|
||||
uint32_t Flags;
|
||||
SYS_RIGHTS Rights;
|
||||
SYS_RIGHTS ExportRights;
|
||||
uint32_t Kind;
|
||||
uint32_t PathLength;
|
||||
uint32_t Reserved;
|
||||
} NTL_RESOURCE_REQUEST;
|
||||
|
||||
// Every resource request receives one fixed-size reply. Successful lookup additionally transfers one handle.
|
||||
typedef struct NTL_RESOURCE_REPLY {
|
||||
uint32_t Size;
|
||||
uint32_t Version;
|
||||
uint32_t Operation;
|
||||
uint32_t Flags;
|
||||
KSTATUS Status;
|
||||
uint32_t Kind;
|
||||
uint32_t ResolvedLength;
|
||||
uint32_t Reserved;
|
||||
} NTL_RESOURCE_REPLY;
|
||||
|
||||
#if defined(NTL_SYSCALL_STATIC)
|
||||
#define NTL_RESOURCE_API
|
||||
#elif defined(NTL_SYSCALL_BUILD)
|
||||
#define NTL_RESOURCE_API __declspec(dllexport)
|
||||
#else
|
||||
#define NTL_RESOURCE_API
|
||||
#endif
|
||||
|
||||
// Connects one session to the globally registered resource service.
|
||||
NTL_RESOURCE_API KSTATUS NtlResourceConnect(SYS_HANDLE* sessionOut);
|
||||
NTL_RESOURCE_API KSTATUS NtlResourceOpenSystemRoot(SYS_RIGHTS desiredRights, SYS_HANDLE* handleOut);
|
||||
// Connects one session through an explicitly delegated resource-listener capability.
|
||||
NTL_RESOURCE_API KSTATUS NtlResourceConnectListener(SYS_HANDLE listenerHandle, SYS_HANDLE* sessionOut);
|
||||
// Resolves one canonical global resource name to an attenuated capability.
|
||||
NTL_RESOURCE_API KSTATUS NtlResourceLookup(SYS_HANDLE session,
|
||||
SYS_STRING_VIEW path,
|
||||
SYS_RIGHTS desiredRights,
|
||||
SYS_HANDLE* handleOut);
|
||||
// Queries resource metadata without transferring the resource capability.
|
||||
NTL_RESOURCE_API KSTATUS NtlResourceQuery(SYS_HANDLE session,
|
||||
SYS_STRING_VIEW path,
|
||||
uint32_t* kindOut);
|
||||
// Resolves the longest bound resource prefix of one canonical absolute path.
|
||||
// ResolvedLength receives the byte length of the matched resource name; the remaining
|
||||
// path, after one optional '/', is relative to the returned volume/directory capability.
|
||||
NTL_RESOURCE_API KSTATUS NtlResourceResolve(SYS_HANDLE session,
|
||||
SYS_STRING_VIEW path,
|
||||
uint32_t flags,
|
||||
SYS_HANDLE* rootHandleOut,
|
||||
uint32_t* kindOut,
|
||||
uint32_t* resolvedLengthOut);
|
||||
// Binds one capability into an administrative session with an explicit namespace-rights grant and export ceiling.
|
||||
NTL_RESOURCE_API KSTATUS NtlResourceBind(SYS_HANDLE session,
|
||||
SYS_STRING_VIEW path,
|
||||
uint32_t kind,
|
||||
SYS_HANDLE resourceHandle,
|
||||
SYS_RIGHTS namespaceRights,
|
||||
SYS_RIGHTS exportRights);
|
||||
// Removes one name from an administrative resource session. Existing looked-up capabilities remain valid.
|
||||
NTL_RESOURCE_API KSTATUS NtlResourceUnbind(SYS_HANDLE session, SYS_STRING_VIEW path);
|
||||
// Disconnects and closes one resource session endpoint.
|
||||
NTL_RESOURCE_API KSTATUS NtlResourceClose(SYS_HANDLE session);
|
||||
|
||||
#undef NTL_RESOURCE_API
|
||||
@@ -0,0 +1,66 @@
|
||||
// Public nt-lite security context and privilege declarations.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <ntlite/handle.h>
|
||||
#include <ntlite/status.h>
|
||||
|
||||
typedef uint32_t SYS_PRIVILEGES;
|
||||
typedef uint32_t SYS_SERVICE_CLAIMS;
|
||||
|
||||
// Ambient privileges are reserved for kernel-mediated authority that is not represented by an object capability yet.
|
||||
#define SYS_PRIV_PROCESS_OPEN_ANY 0x00000001u
|
||||
#define SYS_PRIV_PROCESS_ENUMERATE 0x00000002u
|
||||
#define SYS_PRIV_THREAD_ENUMERATE_ANY 0x00000004u
|
||||
#define SYS_PRIV_KERNEL_DIAGNOSTICS 0x00000008u
|
||||
#define SYS_PRIV_GLOBAL_INPUT 0x00000010u
|
||||
#define SYS_PRIV_AUDIO_ACCESS 0x00000020u
|
||||
#define SYS_PRIV_AUDIO_MASTER_CONTROL 0x00000040u
|
||||
#define SYS_PRIV_CONSOLE_ACCESS 0x00000080u
|
||||
#define SYS_PRIV_DISPLAY_ACCESS 0x00000100u
|
||||
#define SYS_PRIV_DEBUG_OUTPUT 0x00000200u
|
||||
#define SYS_PRIV_SYSTEM_SERVICE_REGISTER 0x00000400u
|
||||
#define SYS_PRIV_RAW_STORAGE 0x00000800u
|
||||
#define SYS_PRIV_FILESYSTEM_PROVIDER 0x00001000u
|
||||
#define SYS_PRIV_NETWORK_ACCESS 0x00002000u
|
||||
// Allows publication into the legacy global named-queue registry; opening an explicitly published queue stays public.
|
||||
#define SYS_PRIV_NAMED_QUEUE_PUBLISH 0x00004000u
|
||||
#define SYS_PRIV_ALL 0x00007FFFu
|
||||
|
||||
// Service claims constrain which well-known service identities a privileged context may register.
|
||||
#define SYS_SERVICE_CLAIM_RESOURCE 0x00000001u
|
||||
#define SYS_SERVICE_CLAIM_ALL SYS_SERVICE_CLAIM_RESOURCE
|
||||
|
||||
// Security-context-specific capability rights.
|
||||
#define SYS_SECURITY_CONTEXT_RIGHT_DERIVE 0x00000100u
|
||||
#define SYS_SECURITY_CONTEXT_RIGHT_ASSIGN 0x00000200u
|
||||
|
||||
// Zero is a per-API sentinel meaning the calling process's current security context.
|
||||
#define SYS_SECURITY_CONTEXT_CURRENT SYS_HANDLE_INVALID
|
||||
|
||||
typedef struct SYS_SECURITY_CONTEXT_INFO {
|
||||
uint32_t Size;
|
||||
uint32_t SecurityId;
|
||||
SYS_PRIVILEGES EffectivePrivileges;
|
||||
SYS_PRIVILEGES DelegablePrivileges;
|
||||
SYS_SERVICE_CLAIMS ServiceClaims;
|
||||
SYS_SERVICE_CLAIMS DelegableServiceClaims;
|
||||
uint32_t Flags;
|
||||
} SYS_SECURITY_CONTEXT_INFO;
|
||||
|
||||
typedef struct SYS_DERIVE_SECURITY_CONTEXT_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE SourceContext;
|
||||
SYS_PRIVILEGES EffectivePrivileges;
|
||||
SYS_PRIVILEGES DelegablePrivileges;
|
||||
SYS_SERVICE_CLAIMS ServiceClaims;
|
||||
SYS_SERVICE_CLAIMS DelegableServiceClaims;
|
||||
uint32_t Flags;
|
||||
SYS_HANDLE* ContextHandleOut;
|
||||
} SYS_DERIVE_SECURITY_CONTEXT_REQUEST;
|
||||
|
||||
#define SYS_SECURITY_CONTEXT_FLAG_NONE 0u
|
||||
|
||||
KSTATUS SysDeriveSecurityContext(const SYS_DERIVE_SECURITY_CONTEXT_REQUEST* request);
|
||||
KSTATUS SysQuerySecurityContext(SYS_HANDLE contextHandle, SYS_SECURITY_CONTEXT_INFO* infoOut);
|
||||
@@ -0,0 +1,21 @@
|
||||
// Public nt-lite well-known system-service identifiers.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <ntlite/handle.h>
|
||||
|
||||
// System-service identities are numeric kernel registry keys, not pathnames.
|
||||
typedef uint32_t SYS_SERVICE_ID;
|
||||
|
||||
#define SYS_SERVICE_INVALID 0u
|
||||
#define SYS_SERVICE_RESOURCE 1u
|
||||
#define SYS_SERVICE_MAX 1u
|
||||
|
||||
// Connects to one well-known system service through its registered Port listener.
|
||||
typedef struct SYS_CONNECT_SYSTEM_SERVICE_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_SERVICE_ID ServiceId;
|
||||
uint32_t Flags;
|
||||
SYS_HANDLE* EndpointHandleOut;
|
||||
} SYS_CONNECT_SYSTEM_SERVICE_REQUEST;
|
||||
@@ -0,0 +1,23 @@
|
||||
// Native service-manager control protocol.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <ntlite/status.h>
|
||||
|
||||
#define NTL_SERVICE_CONTROL_VERSION 1u
|
||||
|
||||
#define NTL_SERVICE_CONTROL_READY 1u
|
||||
#define NTL_SERVICE_CONTROL_STOP 2u
|
||||
|
||||
#define NTL_SERVICE_READY_FLAG_RESOURCE_ADMIN_LISTENER 0x00000001u
|
||||
|
||||
// Service-control messages are notifications over a private Port connection.
|
||||
typedef struct NTL_SERVICE_CONTROL_MESSAGE {
|
||||
uint32_t Size;
|
||||
uint32_t Version;
|
||||
uint32_t Operation;
|
||||
uint32_t Flags;
|
||||
KSTATUS Status;
|
||||
uint32_t Reserved[3];
|
||||
} NTL_SERVICE_CONTROL_MESSAGE;
|
||||
@@ -62,6 +62,10 @@ typedef uint32_t KSTATUS;
|
||||
#define NTLSTATUS_WOULD_BLOCK KSTATUS_MAKE_ERROR(NTLSTATUS_FACILITY_SYSTEM, 0x000013u)
|
||||
#define NTLSTATUS_DEADLOCK KSTATUS_MAKE_ERROR(NTLSTATUS_FACILITY_SYSTEM, 0x000014u)
|
||||
#define NTLSTATUS_DEVICE_REMOVED KSTATUS_MAKE_ERROR(NTLSTATUS_FACILITY_SYSTEM, 0x000015u)
|
||||
#define NTLSTATUS_ID_EXHAUSTED KSTATUS_MAKE_ERROR(NTLSTATUS_FACILITY_SYSTEM, 0x000016u)
|
||||
#define NTLSTATUS_CAPABILITY_REVOKED KSTATUS_MAKE_ERROR(NTLSTATUS_FACILITY_SYSTEM, 0x000017u)
|
||||
#define NTLSTATUS_LIMIT_REACHED KSTATUS_MAKE_ERROR(NTLSTATUS_FACILITY_SYSTEM, 0x000018u)
|
||||
#define NTLSTATUS_PORT_DISCONNECTED KSTATUS_MAKE_ERROR(NTLSTATUS_FACILITY_SYSTEM, 0x000019u)
|
||||
|
||||
// Process termination and fault statuses use the process facility.
|
||||
#define NTLSTATUS_PROCESS_BASE KSTATUS_MAKE_ERROR(NTLSTATUS_FACILITY_PROCESS, 0x000000u)
|
||||
|
||||
+391
-220
@@ -12,23 +12,39 @@
|
||||
#include <ntlite/time.h>
|
||||
#include <ntlite/display.h>
|
||||
#include <ntlite/status.h>
|
||||
#include <ntlite/handle.h>
|
||||
#include <ntlite/security.h>
|
||||
#include <ntlite/port.h>
|
||||
#include <ntlite/service.h>
|
||||
#include <ntlite/audio.h>
|
||||
#include <ntlite/volume_manager.h>
|
||||
|
||||
// Syscall ABI convention: status-returning calls use KSTATUS. New or revised
|
||||
// operations use a request struct when they need five or more logical arguments
|
||||
// or when a pointer/length pair would otherwise be split across flat arguments.
|
||||
// Syscall ABI convention: status-returning calls use KSTATUS. Syscalls use at most
|
||||
// four register arguments; larger operations use request structures. Every
|
||||
// SYS_*_REQUEST begins with Size, which must equal the exact structure size for
|
||||
// the current ABI. Payload byte counts use Length or another semantic name.
|
||||
|
||||
// User process/thread environment.
|
||||
// GS base points at SYS_TEB. GS:[0] is the process PEB pointer.
|
||||
#define SYS_PEB_MAGIC 0x30424550u // "PEB0"
|
||||
#define SYS_TEB_MAGIC 0x30424554u // "TEB0"
|
||||
#define SYS_ENV_VERSION 1u
|
||||
#define SYS_CWD_MAX 520u
|
||||
#define SYS_ENV_VERSION 4u
|
||||
#define SYS_PATH_MAX 1024u
|
||||
|
||||
#ifndef SYS_USER_ENV_TYPES_DEFINED
|
||||
#define SYS_USER_ENV_TYPES_DEFINED 1
|
||||
|
||||
#define SYS_STARTUP_CAP_SYSTEM_VOLUME 1u
|
||||
#define SYS_STARTUP_CAP_SERVICE_CONTROL 2u
|
||||
#define SYS_STARTUP_CAP_SYSTEM_VOLUME_NAMESPACE 3u
|
||||
#define SYS_STARTUP_CAP_VOLUME_MANAGER 4u
|
||||
#define SYS_STARTUP_CAPABILITY_MAX 32u
|
||||
|
||||
typedef struct SYS_STARTUP_CAPABILITY {
|
||||
uint32_t Tag;
|
||||
SYS_HANDLE Handle;
|
||||
} SYS_STARTUP_CAPABILITY;
|
||||
|
||||
typedef struct SYS_PEB {
|
||||
uint32_t Magic;
|
||||
uint32_t Version;
|
||||
@@ -36,7 +52,11 @@ typedef struct SYS_PEB {
|
||||
|
||||
SYS_STRING_VIEW ImagePath;
|
||||
SYS_STRING_VIEW CommandLine;
|
||||
SYS_STRING_VIEW CurrentDirectory;
|
||||
const SYS_STARTUP_CAPABILITY* StartupCapabilities;
|
||||
uint32_t StartupCapabilityCount;
|
||||
uint32_t Reserved;
|
||||
|
||||
const void* LoaderData;
|
||||
} SYS_PEB;
|
||||
|
||||
typedef struct SYS_TEB {
|
||||
@@ -58,14 +78,21 @@ static inline SYS_PEB* SysGetPeb(void) {
|
||||
return (SYS_PEB*)(uintptr_t)__readgsqword(0);
|
||||
}
|
||||
|
||||
// Returns the kernel-maintained current-directory cache from the PEB.
|
||||
static inline SYS_STRING_VIEW SysGetCurrentDirectoryView(void) {
|
||||
// Returns one tagged startup capability from the immutable PEB descriptor table.
|
||||
static inline SYS_HANDLE SysGetStartupCapability(uint32_t tag) {
|
||||
SYS_PEB* peb = SysGetPeb();
|
||||
if (!peb || peb->Magic != SYS_PEB_MAGIC || peb->Version != SYS_ENV_VERSION)
|
||||
return SysSvFromParts("", 0);
|
||||
return peb->CurrentDirectory;
|
||||
if (!peb || peb->Magic != SYS_PEB_MAGIC || peb->Version != SYS_ENV_VERSION || !tag ||
|
||||
peb->StartupCapabilityCount > SYS_STARTUP_CAPABILITY_MAX ||
|
||||
(peb->StartupCapabilityCount && !peb->StartupCapabilities))
|
||||
return SYS_HANDLE_INVALID;
|
||||
for (uint32_t i = 0; i < peb->StartupCapabilityCount; ++i) {
|
||||
if (peb->StartupCapabilities[i].Tag == tag)
|
||||
return peb->StartupCapabilities[i].Handle;
|
||||
}
|
||||
return SYS_HANDLE_INVALID;
|
||||
}
|
||||
|
||||
|
||||
// Returns the current thread environment block.
|
||||
static inline SYS_TEB* SysGetTeb(void) {
|
||||
return (SYS_TEB*)(uintptr_t)__readgsqword(offsetof(SYS_TEB, Self));
|
||||
@@ -82,37 +109,40 @@ typedef void (*SYS_USER_APC_ROUTINE)(void* normalContext,
|
||||
uint64_t information);
|
||||
|
||||
typedef struct SYS_FILE_IO_REQUEST {
|
||||
uint32_t FileHandle;
|
||||
uint32_t Size;
|
||||
SYS_HANDLE FileHandle;
|
||||
uint32_t Flags;
|
||||
void* Buffer;
|
||||
size_t Size;
|
||||
size_t Length;
|
||||
size_t* TransferredOut;
|
||||
} SYS_FILE_IO_REQUEST;
|
||||
|
||||
static inline SYS_FILE_IO_REQUEST SysMakeFileIoRequest(uint32_t fileHandle,
|
||||
static inline SYS_FILE_IO_REQUEST SysMakeFileIoRequest(SYS_HANDLE fileHandle,
|
||||
const void* buffer,
|
||||
size_t size,
|
||||
size_t* transferredOut) {
|
||||
SYS_FILE_IO_REQUEST request;
|
||||
request.Size = sizeof(request);
|
||||
request.FileHandle = fileHandle;
|
||||
request.Flags = 0;
|
||||
request.Buffer = (void*)(uintptr_t)buffer;
|
||||
request.Size = size;
|
||||
request.Length = size;
|
||||
request.TransferredOut = transferredOut;
|
||||
return request;
|
||||
}
|
||||
|
||||
typedef struct SYS_ASYNC_FILE_REQUEST {
|
||||
uint32_t FileHandle;
|
||||
uint32_t EventHandle; // optional; 0 means no event signal
|
||||
uint32_t Size;
|
||||
SYS_HANDLE FileHandle;
|
||||
SYS_HANDLE EventHandle; // optional; 0 means no event signal
|
||||
uint32_t Flags;
|
||||
uint64_t Offset; // explicit byte offset; does not touch file pointer
|
||||
void* Buffer;
|
||||
size_t Size;
|
||||
size_t Length;
|
||||
SYS_IO_STATUS_BLOCK* Iosb; // required; initialized to NTLSTATUS_PENDING
|
||||
SYS_USER_APC_ROUTINE ApcRoutine; // optional; requires SysSetUserApcDispatcher
|
||||
void* ApcContext;
|
||||
uint32_t* RequestHandleOut; // optional; receives cancel/query handle
|
||||
SYS_HANDLE* RequestHandleOut; // optional; receives cancel/query handle
|
||||
} SYS_ASYNC_FILE_REQUEST;
|
||||
|
||||
// User APC frames are kernel-issued control records, not resume contexts.
|
||||
@@ -303,16 +333,38 @@ typedef struct SYS_RAISE_EXCEPTION_REQUEST {
|
||||
} SYS_RAISE_EXCEPTION_REQUEST;
|
||||
|
||||
// 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;
|
||||
#define SYS_CREATE_PROCESS_OBJECT_FLAG_NONE 0x00000000u
|
||||
|
||||
typedef struct SYS_PATH_HANDLE_REQUEST {
|
||||
SYS_STRING_VIEW Path;
|
||||
uint32_t* HandleOut;
|
||||
} SYS_PATH_HANDLE_REQUEST;
|
||||
typedef struct SYS_CREATE_PROCESS_OBJECT_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
SYS_STRING_VIEW ImagePath;
|
||||
SYS_STRING_VIEW CommandLine;
|
||||
SYS_HANDLE SecurityContext;
|
||||
SYS_HANDLE* ProcessHandleOut;
|
||||
} SYS_CREATE_PROCESS_OBJECT_REQUEST;
|
||||
|
||||
typedef struct SYS_ALLOC_PROCESS_VM_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE ProcessHandle;
|
||||
uint32_t Protect;
|
||||
uint32_t Flags;
|
||||
size_t PageCount;
|
||||
void** BaseOut;
|
||||
} SYS_ALLOC_PROCESS_VM_REQUEST;
|
||||
|
||||
#define SYS_START_PROCESS_FLAG_NONE 0x00000000u
|
||||
typedef struct SYS_START_PROCESS_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE ProcessHandle;
|
||||
uint32_t Flags;
|
||||
uintptr_t MainImageBase;
|
||||
size_t MainImageSize;
|
||||
uintptr_t EntryPoint;
|
||||
const SYS_STARTUP_CAPABILITY* StartupCapabilities;
|
||||
uint32_t StartupCapabilityCount;
|
||||
const void* LoaderData;
|
||||
} SYS_START_PROCESS_REQUEST;
|
||||
|
||||
#define SYS_FILE_ACCESS_READ 0x00000001u
|
||||
#define SYS_FILE_ACCESS_WRITE 0x00000002u
|
||||
@@ -328,21 +380,69 @@ typedef struct SYS_PATH_HANDLE_REQUEST {
|
||||
|
||||
#define SYS_FILE_FLAG_NONE 0x00000000u
|
||||
|
||||
typedef struct SYS_OPEN_FILE_REQUEST {
|
||||
// Opens or creates a file beneath a mounted-volume or directory capability.
|
||||
// Path is a canonical native relative path: '/' separators only, with no leading/trailing
|
||||
// separator, empty component, '.', '..', backslash, or embedded NUL.
|
||||
typedef struct SYS_OPEN_FILE_AT_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE RootHandle;
|
||||
SYS_STRING_VIEW Path;
|
||||
uint32_t Access;
|
||||
uint32_t Disposition;
|
||||
uint32_t Flags;
|
||||
uint32_t* HandleOut;
|
||||
} SYS_OPEN_FILE_REQUEST;
|
||||
SYS_HANDLE* HandleOut;
|
||||
} SYS_OPEN_FILE_AT_REQUEST;
|
||||
|
||||
// Builds a flags-based file-open request.
|
||||
static inline SYS_OPEN_FILE_REQUEST SysMakeOpenFileRequest(SYS_STRING_VIEW path,
|
||||
uint32_t access,
|
||||
uint32_t disposition,
|
||||
uint32_t flags,
|
||||
uint32_t* handleOut) {
|
||||
SYS_OPEN_FILE_REQUEST request;
|
||||
#define SYS_DIR_ACCESS_ENUMERATE 0x00000001u
|
||||
#define SYS_DIR_ACCESS_OPEN 0x00000002u
|
||||
#define SYS_DIR_ACCESS_MODIFY 0x00000004u
|
||||
#define SYS_DIR_FLAG_NONE 0x00000000u
|
||||
|
||||
// Opens a directory beneath a mounted-volume or directory capability. An empty Path
|
||||
// opens the root itself; non-empty paths use the same canonical relative-path contract.
|
||||
typedef struct SYS_OPEN_DIR_AT_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE RootHandle;
|
||||
SYS_STRING_VIEW Path;
|
||||
uint32_t Access;
|
||||
uint32_t Flags;
|
||||
SYS_HANDLE* HandleOut;
|
||||
} SYS_OPEN_DIR_AT_REQUEST;
|
||||
|
||||
// Performs one path-only operation beneath a mounted-volume or directory capability.
|
||||
typedef struct SYS_PATH_AT_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE RootHandle;
|
||||
SYS_STRING_VIEW Path;
|
||||
} SYS_PATH_AT_REQUEST;
|
||||
|
||||
// Queries metadata beneath a mounted-volume or directory capability.
|
||||
typedef struct SYS_STAT_AT_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE RootHandle;
|
||||
SYS_STRING_VIEW Path;
|
||||
SYS_FILE_STAT* StatOut;
|
||||
} SYS_STAT_AT_REQUEST;
|
||||
|
||||
// Renames one path between capability-relative roots. Cross-volume rename is rejected.
|
||||
typedef struct SYS_RENAME_AT_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE OldRootHandle;
|
||||
SYS_STRING_VIEW OldPath;
|
||||
SYS_HANDLE NewRootHandle;
|
||||
SYS_STRING_VIEW NewPath;
|
||||
} SYS_RENAME_AT_REQUEST;
|
||||
|
||||
// Builds a capability-relative file-open request.
|
||||
static inline SYS_OPEN_FILE_AT_REQUEST SysMakeOpenFileAtRequest(SYS_HANDLE rootHandle,
|
||||
SYS_STRING_VIEW path,
|
||||
uint32_t access,
|
||||
uint32_t disposition,
|
||||
uint32_t flags,
|
||||
SYS_HANDLE* handleOut) {
|
||||
SYS_OPEN_FILE_AT_REQUEST request;
|
||||
request.Size = sizeof(request);
|
||||
request.RootHandle = rootHandle;
|
||||
request.Path = path;
|
||||
request.Access = access;
|
||||
request.Disposition = disposition;
|
||||
@@ -351,36 +451,21 @@ static inline SYS_OPEN_FILE_REQUEST SysMakeOpenFileRequest(SYS_STRING_VIEW path,
|
||||
return request;
|
||||
}
|
||||
|
||||
typedef struct SYS_PATH_REQUEST {
|
||||
SYS_STRING_VIEW Path;
|
||||
} SYS_PATH_REQUEST;
|
||||
|
||||
#define SYS_REAL_PATH_FLAG_NONE 0x00000000u
|
||||
|
||||
// SysRealPath returns a canonical native path of the form "N:/path". It uses
|
||||
// the kernel-owned process CWD for relative input, collapses '.', '..', and
|
||||
// repeated separators, and clamps parent traversal at the volume root. The
|
||||
// current filesystem model has no symlinks, so resolution is lexical and does
|
||||
// not require the final path to exist. RequiredSizeOut receives the byte count
|
||||
// including the terminating NUL; a NULL buffer with size zero only queries it.
|
||||
typedef struct SYS_REAL_PATH_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
SYS_STRING_VIEW Path;
|
||||
char* Buffer;
|
||||
size_t BufferSize;
|
||||
size_t* RequiredSizeOut;
|
||||
} SYS_REAL_PATH_REQUEST;
|
||||
|
||||
typedef struct SYS_STAT_FILE_REQUEST {
|
||||
SYS_STRING_VIEW Path;
|
||||
SYS_FILE_STAT* StatOut;
|
||||
} SYS_STAT_FILE_REQUEST;
|
||||
|
||||
typedef struct SYS_RENAME_FILE_REQUEST {
|
||||
SYS_STRING_VIEW OldPath;
|
||||
SYS_STRING_VIEW NewPath;
|
||||
} SYS_RENAME_FILE_REQUEST;
|
||||
// Builds a capability-relative directory-open request.
|
||||
static inline SYS_OPEN_DIR_AT_REQUEST SysMakeOpenDirAtRequest(SYS_HANDLE rootHandle,
|
||||
SYS_STRING_VIEW path,
|
||||
uint32_t access,
|
||||
uint32_t flags,
|
||||
SYS_HANDLE* handleOut) {
|
||||
SYS_OPEN_DIR_AT_REQUEST request;
|
||||
request.Size = sizeof(request);
|
||||
request.RootHandle = rootHandle;
|
||||
request.Path = path;
|
||||
request.Access = access;
|
||||
request.Flags = flags;
|
||||
request.HandleOut = handleOut;
|
||||
return request;
|
||||
}
|
||||
|
||||
#define SYS_FILE_LOCK_SHARED 1u
|
||||
#define SYS_FILE_LOCK_EXCLUSIVE 2u
|
||||
@@ -395,7 +480,7 @@ typedef struct SYS_RENAME_FILE_REQUEST {
|
||||
// Unlock removes this process's overlapping locks for the file identity.
|
||||
typedef struct SYS_LOCK_FILE_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t FileHandle;
|
||||
SYS_HANDLE FileHandle;
|
||||
uint32_t Mode;
|
||||
uint32_t Flags;
|
||||
uint64_t Offset;
|
||||
@@ -405,17 +490,19 @@ typedef struct SYS_LOCK_FILE_REQUEST {
|
||||
|
||||
typedef struct SYS_UNLOCK_FILE_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t FileHandle;
|
||||
SYS_HANDLE FileHandle;
|
||||
uint32_t Flags;
|
||||
uint64_t Offset;
|
||||
uint64_t Length;
|
||||
} SYS_UNLOCK_FILE_REQUEST;
|
||||
|
||||
typedef struct SYS_WRITE_CONSOLE_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_STRING_VIEW Text;
|
||||
} SYS_WRITE_CONSOLE_REQUEST;
|
||||
|
||||
typedef struct SYS_PRINT_DEBUG_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_STRING_VIEW Text;
|
||||
} SYS_PRINT_DEBUG_REQUEST;
|
||||
|
||||
@@ -423,22 +510,27 @@ typedef struct SYS_PRINT_DEBUG_REQUEST {
|
||||
// SysUnpublishQueue withdraws a name explicitly. Closing the publishing handle
|
||||
// or exiting the process withdraws every name published through that handle.
|
||||
typedef struct SYS_PUBLISH_QUEUE_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_STRING_VIEW Name;
|
||||
uint32_t QueueHandle;
|
||||
SYS_HANDLE QueueHandle;
|
||||
} SYS_PUBLISH_QUEUE_REQUEST;
|
||||
|
||||
typedef struct SYS_UNPUBLISH_QUEUE_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_STRING_VIEW Name;
|
||||
} SYS_UNPUBLISH_QUEUE_REQUEST;
|
||||
|
||||
typedef struct SYS_OPEN_NAMED_QUEUE_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_STRING_VIEW Name;
|
||||
uint32_t* HandleOut;
|
||||
SYS_HANDLE* HandleOut;
|
||||
} SYS_OPEN_NAMED_QUEUE_REQUEST;
|
||||
|
||||
typedef struct SYS_NAMED_QUEUE_OWNER_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_STRING_VIEW Name;
|
||||
uint32_t* ProcessHandleOut;
|
||||
SYS_RIGHTS DesiredAccess;
|
||||
SYS_HANDLE* ProcessHandleOut;
|
||||
} SYS_NAMED_QUEUE_OWNER_REQUEST;
|
||||
|
||||
#define SYS_QUEUE_FLAG_NONE 0x00000000u
|
||||
@@ -455,7 +547,7 @@ typedef struct SYS_NAMED_QUEUE_OWNER_REQUEST {
|
||||
// not copy storage behind it.
|
||||
typedef struct SYS_QUEUE_SEND_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t QueueHandle;
|
||||
SYS_HANDLE QueueHandle;
|
||||
uint32_t Flags;
|
||||
uint64_t TimeoutMilliseconds;
|
||||
const void* Message;
|
||||
@@ -463,7 +555,7 @@ typedef struct SYS_QUEUE_SEND_REQUEST {
|
||||
|
||||
typedef struct SYS_QUEUE_RECV_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t QueueHandle;
|
||||
SYS_HANDLE QueueHandle;
|
||||
uint32_t Flags;
|
||||
uint64_t TimeoutMilliseconds;
|
||||
void* MessageOut;
|
||||
@@ -480,18 +572,19 @@ typedef struct SYS_QUEUE_RECV_REQUEST {
|
||||
typedef struct SYS_WAIT_MANY_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
const uint32_t* Handles;
|
||||
const SYS_HANDLE* Handles;
|
||||
uint32_t Count;
|
||||
uint32_t* SignaledIndexOut;
|
||||
uint64_t TimeoutMilliseconds;
|
||||
} SYS_WAIT_MANY_REQUEST;
|
||||
|
||||
typedef struct SYS_CREATE_THREAD_REQUEST {
|
||||
uint32_t Size;
|
||||
uintptr_t Entry;
|
||||
uintptr_t Argument;
|
||||
uint32_t Priority;
|
||||
uint32_t Flags;
|
||||
uint32_t* ThreadHandleOut;
|
||||
SYS_HANDLE* ThreadHandleOut;
|
||||
uint32_t* ThreadIdOut;
|
||||
} SYS_CREATE_THREAD_REQUEST;
|
||||
|
||||
@@ -500,31 +593,34 @@ typedef struct SYS_CREATE_THREAD_REQUEST {
|
||||
|
||||
void SysExitProcess(int32_t exitCode);
|
||||
void SysExitThread(int32_t exitCode);
|
||||
KSTATUS SysCreateProcess(const SYS_CREATE_PROCESS_REQUEST* request);
|
||||
KSTATUS SysWaitSingle(uint32_t handle, uint32_t flags, uint64_t timeoutMilliseconds);
|
||||
KSTATUS SysCreateProcessObject(const SYS_CREATE_PROCESS_OBJECT_REQUEST* request);
|
||||
KSTATUS SysAllocProcessVm(const SYS_ALLOC_PROCESS_VM_REQUEST* request);
|
||||
KSTATUS SysProtectProcessVm(SYS_HANDLE processHandle, void* base, size_t pageCount, uint32_t protect);
|
||||
KSTATUS SysStartProcess(const SYS_START_PROCESS_REQUEST* request);
|
||||
KSTATUS SysWaitSingle(SYS_HANDLE handle, uint32_t flags, uint64_t timeoutMilliseconds);
|
||||
KSTATUS SysWaitMany(const SYS_WAIT_MANY_REQUEST* request);
|
||||
// SysOpenInputQueue returns a readable and waitable handle to the default
|
||||
// keyboard input queue. The handle does not create a second event stream;
|
||||
// SysReadInputEvent, SysPeekInputEvent, SysReadKey, and SysReadKeyboardChar
|
||||
// consume the same queue. SysWaitSingle succeeds for this handle when a
|
||||
// keyboard input event can be read.
|
||||
KSTATUS SysOpenInputQueue(uint32_t flags, uint32_t* handleOut);
|
||||
KSTATUS SysOpenInputQueue(uint32_t flags, SYS_HANDLE* handleOut);
|
||||
|
||||
static inline KSTATUS SysWait(uint32_t handle, uint32_t flags) {
|
||||
static inline KSTATUS SysWait(SYS_HANDLE handle, uint32_t flags) {
|
||||
return SysWaitSingle(handle, flags, SYS_WAIT_TIMEOUT_INFINITE);
|
||||
}
|
||||
KSTATUS SysGetProcessExitCode(uint32_t handle, int32_t* exitCodeOut);
|
||||
KSTATUS SysOpenProcess(uint32_t pid, uint32_t* handleOut);
|
||||
KSTATUS SysGetProcessExitCode(SYS_HANDLE handle, int32_t* exitCodeOut);
|
||||
KSTATUS SysOpenProcess(uint32_t pid, SYS_RIGHTS desiredAccess, SYS_HANDLE* handleOut);
|
||||
// Protected kernel processes remain openable for query and wait operations,
|
||||
// but SysKillProcess returns NTLSTATUS_ACCESS_DENIED for them.
|
||||
KSTATUS SysKillProcess(uint32_t processHandle, int32_t exitCode);
|
||||
KSTATUS SysKillProcess(SYS_HANDLE processHandle, int32_t exitCode);
|
||||
|
||||
#define SYS_PROCESS_NAME_MAX 64u
|
||||
#define SYS_PROCESS_CWD_MAX 128u
|
||||
|
||||
#define SYS_PROCESS_STATE_RUNNING 0u
|
||||
#define SYS_PROCESS_STATE_TERMINATING 1u
|
||||
#define SYS_PROCESS_STATE_EXITED 2u
|
||||
#define SYS_PROCESS_STATE_CONSTRUCTING 3u
|
||||
|
||||
#define SYS_PROCESS_FLAG_SYSTEM 0x00000001u
|
||||
#define SYS_PROCESS_FLAG_CURRENT 0x00000002u
|
||||
@@ -532,6 +628,7 @@ KSTATUS SysKillProcess(uint32_t processHandle, int32_t exitCode);
|
||||
#define SYS_PROCESS_FLAG_EXITED 0x00000008u
|
||||
#define SYS_PROCESS_FLAG_IDLE 0x00000010u
|
||||
#define SYS_PROCESS_FLAG_TERMINATION_PROTECTED 0x00000020u
|
||||
#define SYS_PROCESS_FLAG_CONSTRUCTING 0x00000040u
|
||||
|
||||
#define SYS_THREAD_STATE_READY 0u
|
||||
#define SYS_THREAD_STATE_RUNNING 1u
|
||||
@@ -599,16 +696,12 @@ typedef struct SYS_THREAD_INFO {
|
||||
typedef struct SYS_PROCESS_INFO {
|
||||
uint32_t Size;
|
||||
uint32_t ProcessId;
|
||||
uint32_t SecurityId;
|
||||
uint32_t State;
|
||||
uint32_t Flags;
|
||||
|
||||
uint32_t ThreadCount;
|
||||
uint32_t HandleCount;
|
||||
// ModuleCount is the number of DLL-like process modules recorded by the loader.
|
||||
// The main executable image is reported separately through ImageBase/ImageSize.
|
||||
uint32_t ModuleCount;
|
||||
uint32_t CurrentDrive;
|
||||
|
||||
int32_t ExitCode;
|
||||
|
||||
uintptr_t ImageBase;
|
||||
@@ -630,63 +723,14 @@ typedef struct SYS_PROCESS_INFO {
|
||||
uintptr_t LastExceptionFaultAddress;
|
||||
|
||||
char Name[SYS_PROCESS_NAME_MAX];
|
||||
char CurrentDirectory[SYS_PROCESS_CWD_MAX];
|
||||
} SYS_PROCESS_INFO;
|
||||
|
||||
KSTATUS SysGetProcessList(SYS_PROCESS_INFO* processesOut, size_t maxCount, size_t* countOut);
|
||||
KSTATUS SysGetProcessPid(uint32_t handle, uint32_t* pidOut);
|
||||
KSTATUS SysGetProcessPid(SYS_HANDLE handle, uint32_t* pidOut);
|
||||
KSTATUS SysGetThreadList(uint32_t pid, SYS_THREAD_INFO* threadsOut, size_t maxCount, size_t* countOut);
|
||||
|
||||
#define SYS_MODULE_NAME_MAX 64u
|
||||
#define SYS_MODULE_INFO_VERSION 1u
|
||||
|
||||
#define SYS_LOAD_MODULE_FLAG_NONE 0u
|
||||
|
||||
#define SYS_MODULE_FLAG_PUBLIC_REF 0x00000001u
|
||||
#define SYS_MODULE_FLAG_IMPORT_PINNED 0x00000002u
|
||||
#define SYS_MODULE_FLAG_UNLOADABLE 0x00000004u
|
||||
|
||||
typedef struct SYS_MODULE_INFO {
|
||||
uint32_t Size;
|
||||
uint32_t Version;
|
||||
uint32_t Flags;
|
||||
uint32_t Reserved;
|
||||
|
||||
uintptr_t Base;
|
||||
size_t ImageSize;
|
||||
uintptr_t EntryPoint;
|
||||
|
||||
uint32_t PublicRefCount;
|
||||
uint32_t ImportRefCount;
|
||||
uint32_t TotalRefCount;
|
||||
uint32_t Reserved2;
|
||||
|
||||
char Name[SYS_MODULE_NAME_MAX];
|
||||
} SYS_MODULE_INFO;
|
||||
|
||||
typedef struct SYS_LOAD_MODULE_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
SYS_STRING_VIEW Path;
|
||||
uint32_t* ModuleHandleOut;
|
||||
SYS_MODULE_INFO* InfoOut;
|
||||
} SYS_LOAD_MODULE_REQUEST;
|
||||
|
||||
typedef struct SYS_GET_MODULE_EXPORT_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t ModuleHandle;
|
||||
SYS_STRING_VIEW Name;
|
||||
uintptr_t* AddressOut;
|
||||
} SYS_GET_MODULE_EXPORT_REQUEST;
|
||||
|
||||
KSTATUS SysLoadModule(const SYS_LOAD_MODULE_REQUEST* request);
|
||||
KSTATUS SysUnloadModule(uint32_t moduleHandle);
|
||||
KSTATUS SysGetModuleInfo(uint32_t moduleHandle, SYS_MODULE_INFO* infoOut);
|
||||
KSTATUS SysGetModuleExport(const SYS_GET_MODULE_EXPORT_REQUEST* request);
|
||||
KSTATUS SysGetModuleList(SYS_MODULE_INFO* modulesOut, size_t maxCount, size_t* countOut);
|
||||
|
||||
KSTATUS SysCreateThread(const SYS_CREATE_THREAD_REQUEST* request);
|
||||
KSTATUS SysResumeThread(uint32_t threadHandle, uint32_t* previousSuspendCountOut);
|
||||
KSTATUS SysResumeThread(SYS_HANDLE threadHandle, uint32_t* previousSuspendCountOut);
|
||||
uint32_t SysGetCurrentTid(void);
|
||||
uint32_t SysGetCurrentPid(void);
|
||||
KSTATUS SysSetThreadPriority(uint32_t priority);
|
||||
@@ -700,15 +744,15 @@ KSTATUS SysYield(void);
|
||||
// state before applying the new schedule.
|
||||
typedef struct SYS_SET_TIMER_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t TimerHandle;
|
||||
SYS_HANDLE TimerHandle;
|
||||
uint32_t Flags;
|
||||
uint64_t DueTimeMilliseconds;
|
||||
uint64_t PeriodMilliseconds;
|
||||
} SYS_SET_TIMER_REQUEST;
|
||||
|
||||
KSTATUS SysCreateTimer(uint32_t* handleOut);
|
||||
KSTATUS SysCreateTimer(SYS_HANDLE* handleOut);
|
||||
KSTATUS SysSetTimer(const SYS_SET_TIMER_REQUEST* request);
|
||||
KSTATUS SysCancelTimer(uint32_t timerHandle);
|
||||
KSTATUS SysCancelTimer(SYS_HANDLE timerHandle);
|
||||
|
||||
// SysSleep blocks the current thread through the same timer backend used by
|
||||
// waitable timer handles. A zero-length sleep yields the processor.
|
||||
@@ -770,49 +814,72 @@ KSTATUS SysQueryVm(void* address, SYS_VM_REGION_INFO* out);
|
||||
#define SYS_MAP_ACCESS_EXECUTE 0x00000008u
|
||||
#define SYS_MAP_FLAG_NONE 0x00000000u
|
||||
|
||||
KSTATUS SysCreateFileMapping(uint32_t fileHandle, uint32_t protect, uint32_t flags,
|
||||
uint64_t maximumSize, uint32_t* mappingHandleOut);
|
||||
KSTATUS SysMapFile(uint32_t mappingHandle, uint64_t offset, size_t size,
|
||||
uint32_t access, uint32_t flags, void** baseOut);
|
||||
KSTATUS SysCloseHandle(uint32_t handle);
|
||||
typedef struct SYS_CREATE_FILE_MAPPING_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE FileHandle;
|
||||
uint32_t Protect;
|
||||
uint32_t Flags;
|
||||
uint64_t MaximumSize;
|
||||
SYS_HANDLE* MappingHandleOut;
|
||||
} SYS_CREATE_FILE_MAPPING_REQUEST;
|
||||
|
||||
#define SYS_HANDLE_RIGHT_READ 0x00000001u
|
||||
#define SYS_HANDLE_RIGHT_WRITE 0x00000002u
|
||||
#define SYS_HANDLE_RIGHT_WAIT 0x00000004u
|
||||
#define SYS_HANDLE_RIGHT_SIGNAL 0x00000008u
|
||||
#define SYS_HANDLE_RIGHT_DUPLICATE 0x00000010u
|
||||
#define SYS_HANDLE_RIGHT_QUERY 0x00000020u
|
||||
#define SYS_HANDLE_RIGHT_TERMINATE 0x00000040u
|
||||
#define SYS_HANDLE_RIGHT_LOCK 0x00000080u
|
||||
#define SYS_HANDLE_RIGHT_RESUME 0x00000100u
|
||||
#define SYS_HANDLE_RIGHT_ALL 0x000001FFu
|
||||
typedef struct SYS_MAP_FILE_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE MappingHandle;
|
||||
uint32_t Access;
|
||||
uint32_t Flags;
|
||||
uint64_t Offset;
|
||||
size_t Length;
|
||||
void** BaseOut;
|
||||
} SYS_MAP_FILE_REQUEST;
|
||||
|
||||
KSTATUS SysCreateFileMapping(const SYS_CREATE_FILE_MAPPING_REQUEST* request);
|
||||
KSTATUS SysMapFile(const SYS_MAP_FILE_REQUEST* request);
|
||||
KSTATUS SysCloseHandle(SYS_HANDLE handle);
|
||||
|
||||
#define SYS_DUPLICATE_HANDLE_FLAG_NONE 0x00000000u
|
||||
#define SYS_DUPLICATE_HANDLE_FLAG_SAME_RIGHTS 0x00000001u
|
||||
|
||||
typedef struct SYS_DUPLICATE_HANDLE_REQUEST {
|
||||
uint32_t SourceHandle;
|
||||
uint32_t TargetProcessHandle;
|
||||
uint32_t DesiredRights;
|
||||
uint32_t Size;
|
||||
SYS_HANDLE SourceHandle;
|
||||
SYS_HANDLE TargetProcessHandle;
|
||||
SYS_RIGHTS DesiredRights;
|
||||
uint32_t Flags;
|
||||
uint32_t* TargetHandleOut;
|
||||
SYS_HANDLE* TargetHandleOut;
|
||||
} SYS_DUPLICATE_HANDLE_REQUEST;
|
||||
|
||||
// Duplicate creates another handle to the same revocation grant. DesiredRights
|
||||
// may attenuate the alias but can never exceed the source handle's rights.
|
||||
// Cross-process duplication also requires transfer authority on the source.
|
||||
KSTATUS SysDuplicateHandle(const SYS_DUPLICATE_HANDLE_REQUEST* request);
|
||||
|
||||
KSTATUS SysCreateMutex(uint32_t* handleOut);
|
||||
KSTATUS SysTryAcquireMutex(uint32_t handle);
|
||||
KSTATUS SysReleaseMutex(uint32_t handle);
|
||||
typedef struct SYS_DERIVE_HANDLE_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE SourceHandle;
|
||||
SYS_RIGHTS DesiredRights;
|
||||
SYS_HANDLE* DerivedHandleOut;
|
||||
} SYS_DERIVE_HANDLE_REQUEST;
|
||||
|
||||
KSTATUS SysCreateSem(int32_t initial, int32_t max, uint32_t* handleOut);
|
||||
KSTATUS SysTryWaitSem(uint32_t handle);
|
||||
KSTATUS SysSignalSem(uint32_t handle);
|
||||
// Derive creates a child grant. Revoking that child invalidates its aliases and
|
||||
// descendants without revoking the parent grant.
|
||||
KSTATUS SysDeriveHandle(const SYS_DERIVE_HANDLE_REQUEST* request);
|
||||
// Revoke invalidates the selected grant, every alias of it, and all descendants.
|
||||
KSTATUS SysRevokeHandle(SYS_HANDLE handle);
|
||||
|
||||
KSTATUS SysCreateEvent(uint32_t type, uint32_t initialState, uint32_t* handleOut);
|
||||
KSTATUS SysSignalEvent(uint32_t handle);
|
||||
KSTATUS SysClearEvent(uint32_t handle);
|
||||
KSTATUS SysCreateMutex(SYS_HANDLE* handleOut);
|
||||
KSTATUS SysTryAcquireMutex(SYS_HANDLE handle);
|
||||
KSTATUS SysReleaseMutex(SYS_HANDLE handle);
|
||||
|
||||
KSTATUS SysCreateQueue(uint32_t* handleOut);
|
||||
KSTATUS SysCreateSem(int32_t initial, int32_t max, SYS_HANDLE* handleOut);
|
||||
KSTATUS SysTryWaitSem(SYS_HANDLE handle);
|
||||
KSTATUS SysSignalSem(SYS_HANDLE handle);
|
||||
|
||||
KSTATUS SysCreateEvent(uint32_t type, uint32_t initialState, SYS_HANDLE* handleOut);
|
||||
KSTATUS SysSignalEvent(SYS_HANDLE handle);
|
||||
KSTATUS SysClearEvent(SYS_HANDLE handle);
|
||||
|
||||
KSTATUS SysCreateQueue(SYS_HANDLE* handleOut);
|
||||
KSTATUS SysSendQueue(const SYS_QUEUE_SEND_REQUEST* request);
|
||||
KSTATUS SysRecvQueue(const SYS_QUEUE_RECV_REQUEST* request);
|
||||
KSTATUS SysPublishQueue(const SYS_PUBLISH_QUEUE_REQUEST* request);
|
||||
@@ -820,30 +887,44 @@ KSTATUS SysUnpublishQueue(const SYS_UNPUBLISH_QUEUE_REQUEST* request);
|
||||
KSTATUS SysOpenNamedQueue(const SYS_OPEN_NAMED_QUEUE_REQUEST* request);
|
||||
KSTATUS SysOpenNamedQueueOwnerProcess(const SYS_NAMED_QUEUE_OWNER_REQUEST* request);
|
||||
|
||||
KSTATUS SysOpenFile(const SYS_OPEN_FILE_REQUEST* request);
|
||||
KSTATUS SysCreatePort(const SYS_CREATE_PORT_REQUEST* request);
|
||||
KSTATUS SysConnectPort(const SYS_CONNECT_PORT_REQUEST* request);
|
||||
KSTATUS SysAcceptPort(const SYS_ACCEPT_PORT_REQUEST* request);
|
||||
KSTATUS SysSendPort(const SYS_SEND_PORT_REQUEST* request);
|
||||
KSTATUS SysReceivePort(const SYS_RECEIVE_PORT_REQUEST* request);
|
||||
KSTATUS SysCallPort(const SYS_CALL_PORT_REQUEST* request);
|
||||
KSTATUS SysReplyPort(const SYS_REPLY_PORT_REQUEST* request);
|
||||
KSTATUS SysDisconnectPort(SYS_HANDLE endpointHandle);
|
||||
KSTATUS SysRegisterSystemService(SYS_SERVICE_ID serviceId, SYS_HANDLE listenerHandle);
|
||||
KSTATUS SysUnregisterSystemService(SYS_SERVICE_ID serviceId, SYS_HANDLE listenerHandle);
|
||||
KSTATUS SysConnectSystemService(const SYS_CONNECT_SYSTEM_SERVICE_REQUEST* request);
|
||||
|
||||
KSTATUS SysQueryVolumes(const SYS_QUERY_VOLUMES_REQUEST* request);
|
||||
KSTATUS SysOpenVolume(SYS_HANDLE managerHandle, uint32_t instanceId, SYS_RIGHTS desiredRights, SYS_HANDLE* volumeHandleOut);
|
||||
KSTATUS SysWaitVolumeChange(SYS_HANDLE managerHandle, uint64_t observedGeneration, uint64_t timeoutMilliseconds);
|
||||
|
||||
KSTATUS SysOpenFileAt(const SYS_OPEN_FILE_AT_REQUEST* request);
|
||||
KSTATUS SysOpenDirAt(const SYS_OPEN_DIR_AT_REQUEST* request);
|
||||
KSTATUS SysStatAt(const SYS_STAT_AT_REQUEST* request);
|
||||
KSTATUS SysDeleteAt(const SYS_PATH_AT_REQUEST* request);
|
||||
KSTATUS SysRenameAt(const SYS_RENAME_AT_REQUEST* request);
|
||||
KSTATUS SysCreateDirAt(const SYS_PATH_AT_REQUEST* request);
|
||||
KSTATUS SysRemoveDirAt(const SYS_PATH_AT_REQUEST* request);
|
||||
KSTATUS SysReadFile(const SYS_FILE_IO_REQUEST* request);
|
||||
KSTATUS SysWriteFile(const SYS_FILE_IO_REQUEST* request);
|
||||
KSTATUS SysReadFileAsync(const SYS_ASYNC_FILE_REQUEST* request);
|
||||
KSTATUS SysWriteFileAsync(const SYS_ASYNC_FILE_REQUEST* request);
|
||||
KSTATUS SysCancelIo(uint32_t asyncRequestHandle);
|
||||
KSTATUS SysSeekFile(uint32_t handle, uint64_t offset);
|
||||
KSTATUS SysGetFilePos(uint32_t handle, uint64_t* positionOut);
|
||||
KSTATUS SysGetFileSize(uint32_t handle, uint64_t* sizeOut);
|
||||
KSTATUS SysGetFileStat(uint32_t handle, SYS_FILE_STAT* statOut);
|
||||
KSTATUS SysStatFile(const SYS_STAT_FILE_REQUEST* request);
|
||||
KSTATUS SysTruncateFile(uint32_t handle, uint64_t newSize);
|
||||
KSTATUS SysFlushFile(uint32_t handle);
|
||||
KSTATUS SysDeleteFile(const SYS_PATH_REQUEST* request);
|
||||
KSTATUS SysRenameFile(const SYS_RENAME_FILE_REQUEST* request);
|
||||
KSTATUS SysCancelIo(SYS_HANDLE asyncRequestHandle);
|
||||
KSTATUS SysSeekFile(SYS_HANDLE handle, uint64_t offset);
|
||||
KSTATUS SysGetFilePos(SYS_HANDLE handle, uint64_t* positionOut);
|
||||
KSTATUS SysGetFileSize(SYS_HANDLE handle, uint64_t* sizeOut);
|
||||
KSTATUS SysGetFileStat(SYS_HANDLE handle, SYS_FILE_STAT* statOut);
|
||||
KSTATUS SysTruncateFile(SYS_HANDLE handle, uint64_t newSize);
|
||||
KSTATUS SysFlushFile(SYS_HANDLE handle);
|
||||
KSTATUS SysLockFile(const SYS_LOCK_FILE_REQUEST* request);
|
||||
KSTATUS SysUnlockFile(const SYS_UNLOCK_FILE_REQUEST* request);
|
||||
|
||||
KSTATUS SysOpenDir(const SYS_PATH_HANDLE_REQUEST* request);
|
||||
KSTATUS SysReadDir(uint32_t handle, SYS_DIR_ENTRY* entryOut);
|
||||
KSTATUS SysCreateDir(const SYS_PATH_REQUEST* request);
|
||||
KSTATUS SysRemoveDir(const SYS_PATH_REQUEST* request);
|
||||
KSTATUS SysSetCwd(const SYS_PATH_REQUEST* request);
|
||||
KSTATUS SysRealPath(const SYS_REAL_PATH_REQUEST* request);
|
||||
KSTATUS SysReadDir(SYS_HANDLE handle, SYS_DIR_ENTRY* entryOut);
|
||||
|
||||
// Console and graphics.
|
||||
typedef struct SYS_CONSOLE_INFO {
|
||||
@@ -857,9 +938,40 @@ typedef struct SYS_CONSOLE_INFO {
|
||||
KSTATUS SysWriteConsole(const SYS_WRITE_CONSOLE_REQUEST* request);
|
||||
KSTATUS SysGetConsoleInfo(SYS_CONSOLE_INFO* infoOut);
|
||||
KSTATUS SysSetConsoleCursor(int x, int y);
|
||||
KSTATUS SysFillConsoleCharacter(char c, int x, int y, size_t length, size_t* writtenOut);
|
||||
KSTATUS SysFillConsoleAttribute(uint16_t attr, int x, int y, size_t length, size_t* writtenOut);
|
||||
KSTATUS SysPutScreenChar(char c, int x, int y, uint32_t fg, uint32_t bg);
|
||||
|
||||
typedef struct SYS_FILL_CONSOLE_CHARACTER_REQUEST {
|
||||
uint32_t Size;
|
||||
char Character;
|
||||
uint8_t Reserved[3];
|
||||
int32_t X;
|
||||
int32_t Y;
|
||||
size_t Length;
|
||||
size_t* WrittenOut;
|
||||
} SYS_FILL_CONSOLE_CHARACTER_REQUEST;
|
||||
|
||||
typedef struct SYS_FILL_CONSOLE_ATTRIBUTE_REQUEST {
|
||||
uint32_t Size;
|
||||
uint16_t Attribute;
|
||||
uint16_t Reserved;
|
||||
int32_t X;
|
||||
int32_t Y;
|
||||
size_t Length;
|
||||
size_t* WrittenOut;
|
||||
} SYS_FILL_CONSOLE_ATTRIBUTE_REQUEST;
|
||||
|
||||
typedef struct SYS_PUT_SCREEN_CHAR_REQUEST {
|
||||
uint32_t Size;
|
||||
char Character;
|
||||
uint8_t Reserved[3];
|
||||
int32_t X;
|
||||
int32_t Y;
|
||||
uint32_t Foreground;
|
||||
uint32_t Background;
|
||||
} SYS_PUT_SCREEN_CHAR_REQUEST;
|
||||
|
||||
KSTATUS SysFillConsoleCharacter(const SYS_FILL_CONSOLE_CHARACTER_REQUEST* request);
|
||||
KSTATUS SysFillConsoleAttribute(const SYS_FILL_CONSOLE_ATTRIBUTE_REQUEST* request);
|
||||
KSTATUS SysPutScreenChar(const SYS_PUT_SCREEN_CHAR_REQUEST* request);
|
||||
|
||||
typedef struct SYS_CREATE_SURFACE_REQUEST {
|
||||
uint32_t Size;
|
||||
@@ -867,19 +979,19 @@ typedef struct SYS_CREATE_SURFACE_REQUEST {
|
||||
uint32_t Height;
|
||||
uint32_t Format;
|
||||
uint32_t Flags;
|
||||
uint32_t* HandleOut;
|
||||
SYS_HANDLE* HandleOut;
|
||||
} SYS_CREATE_SURFACE_REQUEST;
|
||||
|
||||
KSTATUS SysCreateSurface(const SYS_CREATE_SURFACE_REQUEST* request);
|
||||
KSTATUS SysMapSurface(uint32_t surfaceHandle, void** baseOut, uint32_t* pitchBytesOut);
|
||||
KSTATUS SysQuerySurface(uint32_t surfaceHandle, SYS_SURFACE_DESC* descOut);
|
||||
KSTATUS SysPresentSurface(uint32_t surfaceHandle, const DISPLAY_RECT* rects, uint32_t rectCount);
|
||||
KSTATUS SysMapSurface(SYS_HANDLE surfaceHandle, void** baseOut, uint32_t* pitchBytesOut);
|
||||
KSTATUS SysQuerySurface(SYS_HANDLE surfaceHandle, SYS_SURFACE_DESC* descOut);
|
||||
KSTATUS SysPresentSurface(SYS_HANDLE surfaceHandle, const DISPLAY_RECT* rects, uint32_t rectCount);
|
||||
KSTATUS SysClearScreen(uint32_t color);
|
||||
KSTATUS SysGetScreenSize(int* widthOut, int* heightOut);
|
||||
KSTATUS SysQueryDisplayInfo(SYS_DISPLAY_INFO* infoOut);
|
||||
|
||||
// Display clocks are waitable pacing objects. Providers with frame-event
|
||||
// support signal them once per submitted frame. Other providers use the BSP
|
||||
// support signal them once per submitted frame. Other providers use the boot processor
|
||||
// scheduler tick, with PeriodMilliseconds rounded up to one or more ticks.
|
||||
#define SYS_DISPLAY_CLOCK_FLAG_NONE 0u
|
||||
#define SYS_DISPLAY_CLOCK_DEFAULT_PERIOD_MS 1ull
|
||||
@@ -888,7 +1000,7 @@ typedef struct SYS_OPEN_DISPLAY_CLOCK_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Flags;
|
||||
uint64_t PeriodMilliseconds;
|
||||
uint32_t* HandleOut;
|
||||
SYS_HANDLE* HandleOut;
|
||||
} SYS_OPEN_DISPLAY_CLOCK_REQUEST;
|
||||
|
||||
KSTATUS SysOpenDisplayClock(const SYS_OPEN_DISPLAY_CLOCK_REQUEST* request);
|
||||
@@ -920,7 +1032,7 @@ typedef struct SYS_GLOBAL_INPUT_STATE {
|
||||
// empty. A finite timeout returns NTLSTATUS_TIMEOUT only when its deadline expires.
|
||||
typedef struct SYS_INPUT_EVENT_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t QueueHandle;
|
||||
SYS_HANDLE QueueHandle;
|
||||
uint32_t Flags;
|
||||
uint64_t TimeoutMilliseconds;
|
||||
INPUT_KEY_RECORD* RecordOut;
|
||||
@@ -984,6 +1096,7 @@ typedef struct SYS_SOCKET_ADDRESS {
|
||||
} SYS_SOCKET_ADDRESS;
|
||||
|
||||
typedef struct SYS_SOCKET_SEND_TO_REQUEST {
|
||||
uint32_t Size;
|
||||
const void* Buffer;
|
||||
size_t Length;
|
||||
uint32_t Flags;
|
||||
@@ -993,6 +1106,7 @@ typedef struct SYS_SOCKET_SEND_TO_REQUEST {
|
||||
} SYS_SOCKET_SEND_TO_REQUEST;
|
||||
|
||||
typedef struct SYS_SOCKET_RECV_FROM_REQUEST {
|
||||
uint32_t Size;
|
||||
void* Buffer;
|
||||
size_t Length;
|
||||
uint32_t Flags;
|
||||
@@ -1002,6 +1116,7 @@ typedef struct SYS_SOCKET_RECV_FROM_REQUEST {
|
||||
} SYS_SOCKET_RECV_FROM_REQUEST;
|
||||
|
||||
typedef struct SYS_RESOLVE_HOST_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_STRING_VIEW Name;
|
||||
uint32_t Family;
|
||||
uint32_t Flags;
|
||||
@@ -1010,6 +1125,7 @@ typedef struct SYS_RESOLVE_HOST_REQUEST {
|
||||
} SYS_RESOLVE_HOST_REQUEST;
|
||||
|
||||
typedef struct SYS_SOCKET_OPTION_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t Option;
|
||||
void* Value;
|
||||
size_t ValueSize;
|
||||
@@ -1017,7 +1133,7 @@ typedef struct SYS_SOCKET_OPTION_REQUEST {
|
||||
} SYS_SOCKET_OPTION_REQUEST;
|
||||
|
||||
typedef struct SYS_POLLFD {
|
||||
uint32_t Handle;
|
||||
SYS_HANDLE Handle;
|
||||
uint32_t Events;
|
||||
uint32_t ReturnedEvents;
|
||||
} SYS_POLLFD;
|
||||
@@ -1053,8 +1169,8 @@ typedef struct SYS_POLL_REQUEST {
|
||||
// queueing.
|
||||
typedef struct SYS_ASYNC_SOCKET_REQUEST {
|
||||
uint32_t Size;
|
||||
uint32_t SocketHandle;
|
||||
uint32_t EventHandle;
|
||||
SYS_HANDLE SocketHandle;
|
||||
SYS_HANDLE EventHandle;
|
||||
uint32_t Operation;
|
||||
uint32_t Flags;
|
||||
uint32_t SocketFlags;
|
||||
@@ -1075,28 +1191,47 @@ typedef struct SYS_ASYNC_SOCKET_REQUEST {
|
||||
size_t OptionValueSize;
|
||||
size_t* OptionActualSizeOut;
|
||||
|
||||
uint32_t* HandleOut;
|
||||
SYS_HANDLE* HandleOut;
|
||||
uint32_t* PollReturnedEventsOut;
|
||||
|
||||
SYS_IO_STATUS_BLOCK* Iosb;
|
||||
SYS_USER_APC_ROUTINE ApcRoutine;
|
||||
void* ApcContext;
|
||||
uint32_t* RequestHandleOut;
|
||||
SYS_HANDLE* RequestHandleOut;
|
||||
} SYS_ASYNC_SOCKET_REQUEST;
|
||||
|
||||
KSTATUS SysCreateSocket(uint32_t domain, uint32_t type, uint32_t protocol, uint32_t* handleOut);
|
||||
KSTATUS SysBindSocket(uint32_t socket, const SYS_SOCKET_ADDRESS* address, size_t addressSize);
|
||||
KSTATUS SysListenSocket(uint32_t socket, uint32_t backlog);
|
||||
KSTATUS SysAcceptSocket(uint32_t socket, SYS_SOCKET_ADDRESS* remoteAddressOut, size_t* remoteAddressSizeInOut, uint32_t* acceptedHandleOut);
|
||||
KSTATUS SysConnectSocket(uint32_t socket, const SYS_SOCKET_ADDRESS* address, size_t addressSize);
|
||||
KSTATUS SysSendSocket(uint32_t socket, const void* buffer, size_t length, uint32_t flags, size_t* sentOut);
|
||||
KSTATUS SysRecvSocket(uint32_t socket, void* buffer, size_t length, uint32_t flags, size_t* receivedOut);
|
||||
KSTATUS SysShutdownSocket(uint32_t socket, uint32_t how);
|
||||
KSTATUS SysSendToSocket(uint32_t socket, const SYS_SOCKET_SEND_TO_REQUEST* request);
|
||||
KSTATUS SysRecvFromSocket(uint32_t socket, const SYS_SOCKET_RECV_FROM_REQUEST* request);
|
||||
KSTATUS SysCreateSocket(uint32_t domain, uint32_t type, uint32_t protocol, SYS_HANDLE* handleOut);
|
||||
KSTATUS SysBindSocket(SYS_HANDLE socket, const SYS_SOCKET_ADDRESS* address, size_t addressSize);
|
||||
KSTATUS SysListenSocket(SYS_HANDLE socket, uint32_t backlog);
|
||||
KSTATUS SysAcceptSocket(SYS_HANDLE socket, SYS_SOCKET_ADDRESS* remoteAddressOut, size_t* remoteAddressSizeInOut, SYS_HANDLE* acceptedHandleOut);
|
||||
KSTATUS SysConnectSocket(SYS_HANDLE socket, const SYS_SOCKET_ADDRESS* address, size_t addressSize);
|
||||
|
||||
typedef struct SYS_SOCKET_SEND_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE Socket;
|
||||
uint32_t Flags;
|
||||
const void* Buffer;
|
||||
size_t Length;
|
||||
size_t* SentOut;
|
||||
} SYS_SOCKET_SEND_REQUEST;
|
||||
|
||||
typedef struct SYS_SOCKET_RECV_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE Socket;
|
||||
uint32_t Flags;
|
||||
void* Buffer;
|
||||
size_t Length;
|
||||
size_t* ReceivedOut;
|
||||
} SYS_SOCKET_RECV_REQUEST;
|
||||
|
||||
KSTATUS SysSendSocket(const SYS_SOCKET_SEND_REQUEST* request);
|
||||
KSTATUS SysRecvSocket(const SYS_SOCKET_RECV_REQUEST* request);
|
||||
KSTATUS SysShutdownSocket(SYS_HANDLE socket, uint32_t how);
|
||||
KSTATUS SysSendToSocket(SYS_HANDLE socket, const SYS_SOCKET_SEND_TO_REQUEST* request);
|
||||
KSTATUS SysRecvFromSocket(SYS_HANDLE socket, const SYS_SOCKET_RECV_FROM_REQUEST* request);
|
||||
KSTATUS SysResolveHost(const SYS_RESOLVE_HOST_REQUEST* request); // Cry about it.
|
||||
KSTATUS SysSetSocketOption(uint32_t socket, const SYS_SOCKET_OPTION_REQUEST* request);
|
||||
KSTATUS SysGetSocketOption(uint32_t socket, const SYS_SOCKET_OPTION_REQUEST* request);
|
||||
KSTATUS SysSetSocketOption(SYS_HANDLE socket, const SYS_SOCKET_OPTION_REQUEST* request);
|
||||
KSTATUS SysGetSocketOption(SYS_HANDLE socket, const SYS_SOCKET_OPTION_REQUEST* request);
|
||||
KSTATUS SysPoll(const SYS_POLL_REQUEST* request);
|
||||
KSTATUS SysSocketIoAsync(const SYS_ASYNC_SOCKET_REQUEST* request);
|
||||
|
||||
@@ -1125,6 +1260,9 @@ typedef struct SYS_MEMORY_STATUS {
|
||||
#define SYS_KERNEL_STATS_DISK 11u
|
||||
#define SYS_KERNEL_STATS_NET_IRP 12u
|
||||
#define SYS_KERNEL_STATS_EXCEPTION 13u
|
||||
#define SYS_KERNEL_STATS_PORT 14u
|
||||
#define SYS_KERNEL_STATS_VOLUME 15u
|
||||
#define SYS_KERNEL_STATS_VOLUME_MANAGER 16u
|
||||
|
||||
// Public stats payloads start with Size and Version. Size is the byte count
|
||||
// returned for that payload, including any trailing records. Version describes
|
||||
@@ -1146,6 +1284,20 @@ typedef struct SYS_EXCEPTION_STATS {
|
||||
uintptr_t LastFaultAddress;
|
||||
} SYS_EXCEPTION_STATS;
|
||||
|
||||
typedef struct SYS_PORT_STATS {
|
||||
uint32_t Size;
|
||||
uint32_t Version;
|
||||
uint64_t ConnectionsCreated;
|
||||
uint64_t DirectDeliveries;
|
||||
uint64_t DirectBytes;
|
||||
uint64_t QueuedMessages;
|
||||
uint64_t QueuedBytes;
|
||||
uint64_t QueuedDeliveries;
|
||||
uint64_t RepliesCompleted;
|
||||
uint64_t Disconnects;
|
||||
uint64_t ProcessQuotaRejects;
|
||||
} SYS_PORT_STATS;
|
||||
|
||||
typedef struct SYS_SCHEDULER_STATS {
|
||||
uint32_t Size;
|
||||
uint32_t Version;
|
||||
@@ -1184,7 +1336,7 @@ typedef struct SYS_PMM_STATS {
|
||||
|
||||
typedef struct SYS_CPU_STAT {
|
||||
uint32_t CpuIndex;
|
||||
uint32_t LapicId;
|
||||
uint32_t HardwareId;
|
||||
uint32_t Flags;
|
||||
uint32_t CurrentTid;
|
||||
uint32_t CurrentThreadFlags;
|
||||
@@ -1336,7 +1488,7 @@ typedef struct SYS_FILE_CACHE_STATS {
|
||||
uint64_t MaxResidentPages;
|
||||
} SYS_FILE_CACHE_STATS;
|
||||
|
||||
// Filesystem stats are generic VFS/driver telemetry. Drivers should map
|
||||
// Filesystem stats are generic I/O/provider telemetry. Drivers should map
|
||||
// private metadata work onto these counters instead of exposing filesystem-
|
||||
// specific cache names through the public ABI.
|
||||
typedef struct SYS_FILESYSTEM_STATS {
|
||||
@@ -1357,6 +1509,25 @@ typedef struct SYS_FILESYSTEM_STATS {
|
||||
uint64_t MaxDataReadSpanSectors;
|
||||
} SYS_FILESYSTEM_STATS;
|
||||
|
||||
typedef struct SYS_VOLUME_STATS {
|
||||
uint32_t Size;
|
||||
uint32_t Version;
|
||||
uint64_t CreatedVolumes;
|
||||
uint64_t MountedVolumes;
|
||||
uint64_t RemovedVolumes;
|
||||
uint64_t DeadIoRejects;
|
||||
uint64_t ProviderDestroys;
|
||||
} SYS_VOLUME_STATS;
|
||||
|
||||
typedef struct SYS_VOLUME_MANAGER_STATS {
|
||||
uint32_t Size;
|
||||
uint32_t Version;
|
||||
uint64_t Snapshots;
|
||||
uint64_t VolumeOpens;
|
||||
uint64_t Waits;
|
||||
uint64_t Wakeups;
|
||||
} SYS_VOLUME_MANAGER_STATS;
|
||||
|
||||
typedef struct SYS_DISK_STATS {
|
||||
uint32_t Size;
|
||||
uint32_t Version;
|
||||
@@ -1459,7 +1630,7 @@ typedef struct SYS_PTE_STATS {
|
||||
#define SYS_CPU_FLAG_STARTED 0x00000002u
|
||||
#define SYS_CPU_FLAG_PARKED 0x00000004u
|
||||
#define SYS_CPU_FLAG_ONLINE 0x00000008u
|
||||
#define SYS_CPU_FLAG_BSP 0x00000010u
|
||||
#define SYS_CPU_FLAG_BOOT_PROCESSOR 0x00000010u
|
||||
#define SYS_CPU_FLAG_PRIMARY 0x00000020u
|
||||
|
||||
// Time and diagnostics.
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
// Native mounted-volume manager ABI. The manager exposes kernel volume lifecycle to a delegated userspace control plane.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <ntlite/handle.h>
|
||||
|
||||
#define SYS_VOLUME_ENUM_VERSION 1u
|
||||
#define SYS_VOLUME_QUERY_FLAG_NONE 0x00000000u
|
||||
|
||||
// InstanceId is kernel correlation metadata only. RSSRV owns all global volume names independently.
|
||||
typedef struct SYS_VOLUME_INFO {
|
||||
uint32_t Size;
|
||||
uint32_t Version;
|
||||
uint32_t InstanceId;
|
||||
uint32_t Flags;
|
||||
} SYS_VOLUME_INFO;
|
||||
|
||||
typedef struct SYS_QUERY_VOLUMES_REQUEST {
|
||||
uint32_t Size;
|
||||
SYS_HANDLE ManagerHandle;
|
||||
uint32_t Flags;
|
||||
uint32_t Capacity;
|
||||
SYS_VOLUME_INFO* Volumes;
|
||||
uint32_t* CountOut;
|
||||
uint64_t* GenerationOut;
|
||||
} SYS_QUERY_VOLUMES_REQUEST;
|
||||
Reference in new issue
Block a user