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