maksw/nt-lite
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clean up and standardize types across the codebase, unify atomic operations, improve UTF-8 handling throughout the system, remove obsolete input and named queue interfaces, redesign process preparation and creation, tighten IPC and service boundaries, improve error handling and reliability, minor documentation cleanup, fix doom surfaces, fix panic in ini parsing.

Browse Source
This commit is contained in:
maksw committed 2026-10-12 18:17:43 +02:00
1 parent 899225f551
commit c0ad63c27f
226 files changed
+6562 -4147
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

code/user/personalities/posix/posix_dir.c
+5 -5
View File
@@ -114,7 +114,7 @@ __declspec(dllexport) char* realpath(const char* path, char* resolved_path) {
return PosixCopyResolvedPath(path, resolved_path);
size_t required = 0;
uint32_t status = NtlRealPath(SysSvFromCstr(translated), (char*)0, 0, &required);
KSTATUS status = NtlRealPath(SysSvFromCstr(translated), (char*)0, 0, &required);
if (status != NTLSTATUS_SUCCESS) { errno = PosixStatusToErrno(status); return (char*)0; }
if (required == 0 || required > SYS_PATH_MAX + 1u) { errno = ERANGE; return (char*)0; }
@@ -132,7 +132,7 @@ __declspec(dllexport) DIR* opendir(const char* path) {
char native[512];
PosixTranslatePath(path, native, sizeof(native));
uint32_t kh;
uint32_t s = NtlOpenDir(SysSvFromCstr(native),
KSTATUS s = NtlOpenDir(SysSvFromCstr(native),
SYS_DIR_ACCESS_ENUMERATE | SYS_DIR_ACCESS_OPEN,
SYS_DIR_FLAG_NONE, &kh);
if (s != 0) { errno = ENOENT; return (DIR*)0; }
@@ -149,7 +149,7 @@ __declspec(dllexport) DIR* opendir(const char* path) {
__declspec(dllexport) struct dirent* readdir(DIR* d) {
if (!d) { errno = EBADF; return (struct dirent*)0; }
KDIR_ENTRY ke;
uint32_t s = SysReadDir(d->KHandle, &ke);
KSTATUS s = SysReadDir(d->KHandle, &ke);
if (s != 0) return (struct dirent*)0; // end of directory or error
size_t len = strlen(ke.Name);
@@ -214,7 +214,7 @@ __declspec(dllexport) int stat(const char* path, struct stat* out) {
return PosixFillSyntheticStat(S_IFCHR, out);
SYS_FILE_STAT nativeStat;
uint32_t s = NtlStatPath(SysSvFromCstr(p), &nativeStat);
KSTATUS s = NtlStatPath(SysSvFromCstr(p), &nativeStat);
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
return PosixFillStat(&nativeStat, out);
}
@@ -243,7 +243,7 @@ __declspec(dllexport) int fstat(int fd, struct stat* out) {
break;
case PosixFdFile: {
SYS_FILE_STAT nativeStat;
uint32_t status = SysGetFileStat(description->KHandle, &nativeStat);
KSTATUS status = SysGetFileStat(description->KHandle, &nativeStat);
if (status != NTLSTATUS_SUCCESS)
errno = PosixStatusToErrno(status);
else
code/user/personalities/posix/posix_dlfcn.c
+4 -4
View File
@@ -20,7 +20,7 @@ static void DlSetError(const char* message) {
}
// Converts one native loader status to errno and a dlerror message.
static void DlSetStatusError(const char* operation, uint32_t status) {
static void DlSetStatusError(const char* operation, KSTATUS status) {
(void)status;
errno = PosixStatusToErrno(status);
DlSetError(operation);
@@ -38,7 +38,7 @@ __declspec(dllexport) void* dlopen(const char* filename, int flags) {
}
char native[512];
uint32_t status = PosixProcessPath(filename, native, sizeof(native));
KSTATUS status = PosixProcessPath(filename, native, sizeof(native));
if (status != NTLSTATUS_SUCCESS) {
errno = EINVAL;
DlSetError("dlopen path is not a loadable module");
@@ -94,7 +94,7 @@ __declspec(dllexport) void* dlsym(void* handle, const char* symbol) {
}
uintptr_t address = 0;
uint32_t status = NtlGetModuleExport((NTL_MODULE_HANDLE)(uintptr_t)handle,
KSTATUS status = NtlGetModuleExport((NTL_MODULE_HANDLE)(uintptr_t)handle,
SysSvFromCstr(symbol), &address);
if (status != NTLSTATUS_SUCCESS || address == 0) {
DlSetStatusError("dlsym failed", status);
@@ -113,7 +113,7 @@ __declspec(dllexport) int dlclose(void* handle) {
return -1;
}
uint32_t status = NtlUnloadModule((NTL_MODULE_HANDLE)(uintptr_t)handle);
KSTATUS status = NtlUnloadModule((NTL_MODULE_HANDLE)(uintptr_t)handle);
if (status != NTLSTATUS_SUCCESS) {
DlSetStatusError("dlclose failed", status);
return -1;
code/user/personalities/posix/posix_fd.c
+22 -21
View File
@@ -1,5 +1,7 @@
// POSIX descriptor table and shared open-description implementation.
#include <ntlite/atomic.h>
#include <stdbool.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
@@ -9,7 +11,7 @@
#include "posix_fd.h"
// Maps one native status to the POSIX personality errno space.
int PosixStatusToErrno(uint32_t s) {
int PosixStatusToErrno(KSTATUS s) {
switch (s) {
case NTLSTATUS_SUCCESS: return 0;
case NTLSTATUS_TIMEOUT: return ETIMEDOUT;
@@ -76,7 +78,7 @@ static int PosixFdLock(POSIX_LOGICAL_PROCESS_STATE* process) {
errno = EIO;
return -1;
}
uint32_t status = SysWait(process->FdLock, SYS_WAIT_FLAG_NONE);
KSTATUS status = SysWait(process->FdLock, SYS_WAIT_FLAG_NONE);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
return -1;
@@ -86,13 +88,13 @@ static int PosixFdLock(POSIX_LOGICAL_PROCESS_STATE* process) {
// Unlocks one logical process descriptor table.
static void PosixFdUnlock(POSIX_LOGICAL_PROCESS_STATE* process) {
uint32_t status = SysReleaseMutex(process->FdLock);
KSTATUS status = SysReleaseMutex(process->FdLock);
if (status != NTLSTATUS_SUCCESS)
errno = PosixStatusToErrno(status);
}
// Returns whether one open-description type requires a retained native capability.
static int PosixOpenDescriptionNeedsHandle(POSIX_FD_TYPE type) {
static bool PosixOpenDescriptionNeedsHandle(POSIX_FD_TYPE type) {
return type == PosixFdFile || type == PosixFdSocket ||
type == PosixFdPipeRead || type == PosixFdPipeWrite;
}
@@ -262,15 +264,14 @@ static POSIX_OPEN_DESCRIPTION* PosixOpenDescriptionCreate(POSIX_FD_TYPE type,
// Adds one reference to an open description.
static void PosixFdReference(POSIX_OPEN_DESCRIPTION* description) {
if (description)
_InterlockedIncrement(&description->RefCount);
NtlAtomicIncrement32(&description->RefCount);
}
// Returns one atomic snapshot of server-owned shared open-description status flags.
int PosixFdGetStatusFlags(const POSIX_OPEN_DESCRIPTION* description) {
if (!description || !description->Shared)
return 0;
return (int)_InterlockedCompareExchange(
(volatile long*)&description->Shared->StatusFlags, 0, 0);
return (int)NtlAtomicLoadU32(&description->Shared->StatusFlags);
}
// Applies mutable status flags through posixsrv so native backing and shared state stay serialized.
@@ -306,7 +307,7 @@ int PosixFdSetStatusFlags(POSIX_OPEN_DESCRIPTION* description, int statusFlags)
// Releases one stable local wrapper without changing server holder ownership.
static void PosixFdReleaseLocal(POSIX_OPEN_DESCRIPTION* description) {
if (!description) return;
if (_InterlockedDecrement(&description->RefCount) != 0) return;
if (NtlAtomicDecrement32(&description->RefCount) != 0) return;
if (PosixOpenDescriptionNeedsHandle(description->Type) &&
description->KHandle != SYS_HANDLE_INVALID)
(void)SysCloseHandle(description->KHandle);
@@ -316,7 +317,7 @@ static void PosixFdReleaseLocal(POSIX_OPEN_DESCRIPTION* description) {
// Releases one stable local wrapper and its server holder at the final reference.
void PosixFdRelease(POSIX_OPEN_DESCRIPTION* description) {
if (!description) return;
if (_InterlockedDecrement(&description->RefCount) != 0) return;
if (NtlAtomicDecrement32(&description->RefCount) != 0) return;
if (PosixOpenDescriptionNeedsHandle(description->Type) &&
description->KHandle != SYS_HANDLE_INVALID)
(void)SysCloseHandle(description->KHandle);
@@ -375,8 +376,8 @@ static POSIX_OPEN_DESCRIPTION* PosixOpenDescriptionImport(POSIX_FD_TYPE type,
uint32_t khandle,
uint64_t descriptionId,
NTL_POSIX_SHARED_OPEN_DESCRIPTION* shared) {
int needsHandle = PosixOpenDescriptionNeedsHandle(type);
int isPipe = type == PosixFdPipeRead || type == PosixFdPipeWrite;
bool needsHandle = PosixOpenDescriptionNeedsHandle(type);
bool isPipe = type == PosixFdPipeRead || type == PosixFdPipeWrite;
if (descriptionId == 0 || !shared ||
(needsHandle && khandle == SYS_HANDLE_INVALID) ||
(!needsHandle && khandle != SYS_HANDLE_INVALID) ||
@@ -464,7 +465,7 @@ int PosixFdClose(int fd) {
}
// Installs one fixed standard descriptor during process initialization.
static uint32_t PosixFdInstallStandard(POSIX_LOGICAL_PROCESS_STATE* process,
static KSTATUS PosixFdInstallStandard(POSIX_LOGICAL_PROCESS_STATE* process,
int fd,
POSIX_FD_TYPE type,
int statusFlags) {
@@ -481,7 +482,7 @@ static uint32_t PosixFdInstallStandard(POSIX_LOGICAL_PROCESS_STATE* process,
}
// Reconstructs one exact descriptor table from a server-owned inheritance snapshot.
static uint32_t PosixFdImportInheritance(POSIX_LOGICAL_PROCESS_STATE* process, uint64_t token) {
static KSTATUS PosixFdImportInheritance(POSIX_LOGICAL_PROCESS_STATE* process, uint64_t token) {
if (!process || token == 0) return NTLSTATUS_INVALID_PARAMETER;
NTL_POSIX_FD_MANIFEST_ENTRY manifest[NTL_POSIX_FD_INHERIT_MAX];
@@ -494,7 +495,7 @@ static uint32_t PosixFdImportInheritance(POSIX_LOGICAL_PROCESS_STATE* process, u
uint32_t descriptionCount = 0;
uint32_t descriptionIndex = 0;
uint32_t descriptionTotal = UINT32_MAX;
uint32_t result = NTLSTATUS_SUCCESS;
KSTATUS result = NTLSTATUS_SUCCESS;
for (;;) {
NTL_POSIX_REQUEST request;
@@ -560,7 +561,7 @@ static uint32_t PosixFdImportInheritance(POSIX_LOGICAL_PROCESS_STATE* process, u
}
if (!KSUCCESS(result)) break;
POSIX_FD_TYPE type = (POSIX_FD_TYPE)entry->OpenDescriptionType;
int needsHandle = PosixOpenDescriptionNeedsHandle(type);
bool needsHandle = PosixOpenDescriptionNeedsHandle(type);
SYS_HANDLE handle = SYS_HANDLE_INVALID;
if (needsHandle) {
if (entry->HandleIndex >= handleCount || handleUsed[entry->HandleIndex]) {
@@ -634,12 +635,12 @@ static uint32_t PosixFdImportInheritance(POSIX_LOGICAL_PROCESS_STATE* process, u
}
// Initializes one logical process descriptor table and standard descriptors.
uint32_t PosixFdInitializeLogicalProcess(POSIX_LOGICAL_PROCESS_STATE* process, uint64_t inheritanceToken) {
KSTATUS PosixFdInitializeLogicalProcess(POSIX_LOGICAL_PROCESS_STATE* process, uint64_t inheritanceToken) {
if (!process)
return NTLSTATUS_INVALID_PARAMETER;
uint32_t lock = SYS_HANDLE_INVALID;
uint32_t status = SysCreateMutex(&lock);
KSTATUS status = SysCreateMutex(&lock);
if (status != NTLSTATUS_SUCCESS)
return status;
process->FdLock = lock;
@@ -757,7 +758,7 @@ static int PosixFlockRange(POSIX_OPEN_DESCRIPTION* description,
}
int64_t base = 0;
uint32_t status = NTLSTATUS_SUCCESS;
KSTATUS status = NTLSTATUS_SUCCESS;
if (lock->l_whence == SEEK_CUR) {
uint64_t current = 0;
status = SysGetFilePos(description->KHandle, &current);
@@ -828,7 +829,7 @@ static int PosixFdControlLock(POSIX_OPEN_DESCRIPTION* description, int command,
request.Offset = offset;
request.Length = length;
request.InfoOut = &info;
uint32_t status = SysQueryFileLock(&request);
KSTATUS status = SysQueryFileLock(&request);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
return -1;
@@ -854,7 +855,7 @@ static int PosixFdControlLock(POSIX_OPEN_DESCRIPTION* description, int command,
request.Flags = SYS_FILE_LOCK_FLAG_NONE;
request.Offset = offset;
request.Length = length;
uint32_t status = SysUnlockFile(&request);
KSTATUS status = SysUnlockFile(&request);
if (status == NTLSTATUS_SUCCESS || status == NTLSTATUS_NOT_FOUND)
return 0;
errno = PosixStatusToErrno(status);
@@ -889,7 +890,7 @@ static int PosixFdControlLock(POSIX_OPEN_DESCRIPTION* description, int command,
request.Offset = offset;
request.Length = length;
request.TimeoutMilliseconds = command == F_SETLKW ? SYS_WAIT_TIMEOUT_INFINITE : 0;
uint32_t status = SysLockFile(&request);
KSTATUS status = SysLockFile(&request);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
return -1;
code/user/personalities/posix/posix_fd.h
+3 -3
View File
@@ -23,7 +23,7 @@ typedef enum POSIX_FD_TYPE {
// One refcounted open description shared by one or more descriptors.
typedef struct POSIX_OPEN_DESCRIPTION {
volatile long RefCount;
volatile int32_t RefCount;
POSIX_FD_TYPE Type;
uint32_t KHandle;
uint64_t DescriptionId;
@@ -39,7 +39,7 @@ typedef struct POSIX_FD {
struct POSIX_LOGICAL_PROCESS_STATE;
// Initializes one logical process descriptor table from inherited state or fresh standard descriptors.
uint32_t PosixFdInitializeLogicalProcess(struct POSIX_LOGICAL_PROCESS_STATE* process, uint64_t inheritanceToken);
KSTATUS PosixFdInitializeLogicalProcess(struct POSIX_LOGICAL_PROCESS_STATE* process, uint64_t inheritanceToken);
// Captures the current descriptor table in one server-owned inheritance snapshot.
KSTATUS PosixFdCreateInheritanceSnapshot(uint32_t flags, uint64_t* tokenOut);
@@ -78,4 +78,4 @@ void PosixFdRelease(POSIX_OPEN_DESCRIPTION* description);
// Removes one descriptor and releases its table-owned open-description reference.
int PosixFdClose(int fd);
int PosixStatusToErrno(uint32_t status);
int PosixStatusToErrno(KSTATUS status);
code/user/personalities/posix/posix_internal.h
+3 -3
View File
@@ -105,7 +105,7 @@ typedef struct POSIX_THREAD_STATE {
} POSIX_THREAD_STATE;
// Initializes process-local POSIX state and attaches the initial thread.
uint32_t PosixRuntimeInitializeProcess(void);
KSTATUS PosixRuntimeInitializeProcess(void);
// Returns the POSIX state for the current process after startup.
POSIX_PROCESS_STATE* PosixRuntimeProcessState(void);
@@ -117,10 +117,10 @@ POSIX_THREAD_STATE* PosixRuntimeThreadState(void);
POSIX_LOGICAL_PROCESS_STATE* PosixRuntimeLogicalProcessState(void);
// Attaches POSIX state to the current native TEB.
uint32_t PosixRuntimeAttachThread(void);
KSTATUS PosixRuntimeAttachThread(void);
// Attaches a thread while seeding its inherited persistent signal mask.
uint32_t PosixRuntimeAttachThreadWithSignalMask(uint64_t signalMask);
KSTATUS PosixRuntimeAttachThreadWithSignalMask(uint64_t signalMask);
// Allocates one borrowed logical child and pins its inherited descriptor snapshot.
KSTATUS PosixVforkBeginBorrowedChild(POSIX_VFORK_CHILD_STATE** childOut);
code/user/personalities/posix/posix_io.c
+20 -18
View File
@@ -1,5 +1,7 @@
// POSIX compatibility support for byte-stream file I/O.
#include <ntlite/atomic.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
#include <intrin.h>
@@ -38,16 +40,16 @@ static SYS_PIPE_SHARED_STATE* PosixPipeShared(POSIX_OPEN_DESCRIPTION* descriptio
}
// Acquires one shared pipe-side serialization lock without entering the kernel.
static void PosixPipeLock(volatile long* lock) {
while (_InterlockedCompareExchange(lock, 1, 0) != 0)
static void PosixPipeLock(volatile int32_t* lock) {
while (NtlAtomicCompareExchange32(lock, 1, 0) != 0)
_mm_pause();
_ReadWriteBarrier();
}
// Releases one shared pipe-side serialization lock.
static void PosixPipeUnlock(volatile long* lock) {
static void PosixPipeUnlock(volatile int32_t* lock) {
_ReadWriteBarrier();
_InterlockedExchange(lock, 0);
NtlAtomicExchange32(lock, 0);
}
// Returns buffered bytes, rejecting corrupted shared counters.
@@ -105,7 +107,7 @@ static ssize_t PosixPipeRead(POSIX_OPEN_DESCRIPTION* description, void* buffer,
_ReadWriteBarrier();
shared->ReadPosition = readPosition + transfer;
_ReadWriteBarrier();
long writeWaiters = shared->WriteWaiters;
int32_t writeWaiters = shared->WriteWaiters;
PosixPipeUnlock(&shared->ReadLock);
if (writeWaiters != 0)
(void)SysNotifyPipe(description->KHandle);
@@ -124,7 +126,7 @@ static ssize_t PosixPipeRead(POSIX_OPEN_DESCRIPTION* description, void* buffer,
POSIX_THREAD_STATE* thread = PosixRuntimeThreadState();
uint64_t deliveryCount = thread ? thread->SignalDeliveryCount : 0;
uint32_t status = SysWait(description->KHandle, SYS_WAIT_FLAG_ALERTABLE);
KSTATUS status = SysWait(description->KHandle, SYS_WAIT_FLAG_ALERTABLE);
if (status == NTLSTATUS_USER_APC || status == NTLSTATUS_KERNEL_APC ||
status == NTLSTATUS_ALERTED) {
if (!thread || thread->SignalDeliveryCount == deliveryCount)
@@ -173,7 +175,7 @@ static ssize_t PosixPipeWrite(POSIX_OPEN_DESCRIPTION* description, const void* b
_ReadWriteBarrier();
shared->WritePosition = writePosition + transfer;
_ReadWriteBarrier();
long readWaiters = shared->ReadWaiters;
int32_t readWaiters = shared->ReadWaiters;
PosixPipeUnlock(&shared->WriteLock);
if (readWaiters != 0)
(void)SysNotifyPipe(description->KHandle);
@@ -189,7 +191,7 @@ static ssize_t PosixPipeWrite(POSIX_OPEN_DESCRIPTION* description, const void* b
POSIX_THREAD_STATE* thread = PosixRuntimeThreadState();
uint64_t deliveryCount = thread ? thread->SignalDeliveryCount : 0;
uint32_t status = SysWait(description->KHandle, SYS_WAIT_FLAG_ALERTABLE);
KSTATUS status = SysWait(description->KHandle, SYS_WAIT_FLAG_ALERTABLE);
if (status == NTLSTATUS_USER_APC || status == NTLSTATUS_KERNEL_APC ||
status == NTLSTATUS_ALERTED) {
if (!thread || thread->SignalDeliveryCount == deliveryCount)
@@ -251,7 +253,7 @@ __declspec(dllexport) int open(const char* path, int flags, ...) {
else if (flags & O_TRUNC)
disposition = SYS_FILE_TRUNCATE_EXISTING;
uint32_t status = NtlOpenFile(SysSvFromCstr(p), access, disposition,
KSTATUS status = NtlOpenFile(SysSvFromCstr(p), access, disposition,
SYS_FILE_FLAG_NONE, &kh);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
@@ -288,7 +290,7 @@ __declspec(dllexport) ssize_t read(int fd, void* buf, size_t count) {
char* dst = (char*)buf;
result = (ssize_t)count;
for (size_t i = 0; i < count; i++) {
uint32_t status = NtlConsoleReadCharacter(SYS_HANDLE_INVALID, &dst[i]);
KSTATUS status = NtlConsoleReadCharacter(SYS_HANDLE_INVALID, &dst[i]);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
result = -1;
@@ -312,7 +314,7 @@ __declspec(dllexport) ssize_t read(int fd, void* buf, size_t count) {
size_t got = 0;
SYS_FILE_IO_REQUEST request =
SysMakeFileIoRequest(description->KHandle, buf, count, &got);
uint32_t status = SysReadFile(&request);
KSTATUS status = SysReadFile(&request);
if (status != NTLSTATUS_SUCCESS && got == 0)
errno = PosixStatusToErrno(status);
else
@@ -328,7 +330,7 @@ __declspec(dllexport) ssize_t read(int fd, void* buf, size_t count) {
sizeof(SYS_SOCKET_RECV_REQUEST), description->KHandle, 0,
buf, count, &got
};
uint32_t status = SysRecvSocket(&request);
KSTATUS status = SysRecvSocket(&request);
if (status != NTLSTATUS_SUCCESS)
errno = PosixStatusToErrno(status);
else
@@ -366,7 +368,7 @@ __declspec(dllexport) ssize_t write(int fd, const void* buf, size_t count) {
switch (description->Type) {
case PosixFdConsoleWrite: {
size_t written = 0;
uint32_t status = NtlConsoleWrite(SYS_HANDLE_INVALID, buf, count, &written);
KSTATUS status = NtlConsoleWrite(SYS_HANDLE_INVALID, buf, count, &written);
if (status != NTLSTATUS_SUCCESS && written == 0)
errno = PosixStatusToErrno(status);
else
@@ -381,7 +383,7 @@ __declspec(dllexport) ssize_t write(int fd, const void* buf, size_t count) {
size_t written = 0;
SYS_FILE_IO_REQUEST request =
SysMakeFileIoRequest(description->KHandle, (void*)buf, count, &written);
uint32_t status = SysWriteFile(&request);
KSTATUS status = SysWriteFile(&request);
if (status != NTLSTATUS_SUCCESS && written == 0)
errno = PosixStatusToErrno(status);
else
@@ -397,7 +399,7 @@ __declspec(dllexport) ssize_t write(int fd, const void* buf, size_t count) {
sizeof(SYS_SOCKET_SEND_REQUEST), description->KHandle, 0,
buf, count, &sent
};
uint32_t status = SysSendSocket(&request);
KSTATUS status = SysSendSocket(&request);
if (status != NTLSTATUS_SUCCESS)
errno = PosixStatusToErrno(status);
else
@@ -452,7 +454,7 @@ __declspec(dllexport) int pipe(int pipefd[2]) {
SYS_PIPE_SHARED_STATE* pipeShared = readShared ?
(SYS_PIPE_SHARED_STATE*)(uintptr_t)readShared->SharedObjectData :
(SYS_PIPE_SHARED_STATE*)0;
int valid = handles[0] != SYS_HANDLE_INVALID && handles[1] != SYS_HANDLE_INVALID &&
bool valid = handles[0] != SYS_HANDLE_INVALID && handles[1] != SYS_HANDLE_INVALID &&
reply.OpenDescriptionId != 0 && reply.OpenDescriptionId2 != 0 &&
reply.OpenDescriptionId != reply.OpenDescriptionId2 &&
reply.OpenDescriptionType == NTL_POSIX_OPEN_TYPE_PIPE_READ &&
@@ -518,7 +520,7 @@ __declspec(dllexport) int unlink(const char* path) {
return -1;
}
uint32_t status = NtlDeleteFile(SysSvFromCstr(p));
KSTATUS status = NtlDeleteFile(SysSvFromCstr(p));
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
return -1;
@@ -538,7 +540,7 @@ __declspec(dllexport) off_t lseek(int fd, off_t offset, int whence) {
}
int64_t target = 0;
uint32_t status = NTLSTATUS_SUCCESS;
KSTATUS status = NTLSTATUS_SUCCESS;
if (whence == SEEK_SET) {
target = (int64_t)offset;
} else if (whence == SEEK_CUR) {
code/user/personalities/posix/posix_mman.c
+2 -2
View File
@@ -55,7 +55,7 @@ __declspec(dllexport) void* mmap(void* addr, size_t length, int prot,
sizeof(SYS_CREATE_FILE_MAPPING_REQUEST), description->KHandle, protect,
SYS_MAP_FLAG_NONE, maxSize, &mapping
};
uint32_t s = SysCreateFileMapping(&createMapping);
KSTATUS s = SysCreateFileMapping(&createMapping);
PosixFdRelease(description);
if (s != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(s);
@@ -80,7 +80,7 @@ __declspec(dllexport) void* mmap(void* addr, size_t length, int prot,
__declspec(dllexport) int munmap(void* addr, size_t length) {
(void)length;
if (!addr) { errno = EINVAL; return -1; }
uint32_t s = SysFreeVm(addr);
KSTATUS s = SysFreeVm(addr);
if (s != NTLSTATUS_SUCCESS) { errno = PosixStatusToErrno(s); return -1; }
return 0;
}
code/user/personalities/posix/posix_path.c
+5 -4
View File
@@ -1,5 +1,6 @@
// POSIX compatibility support for path translation.
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
#include <ntlite/status.h>
@@ -63,17 +64,17 @@ KSTATUS PosixProcessPath(const char* in, char* out, size_t outSize) {
return NTLSTATUS_SUCCESS;
}
static int PosixViewEqualsI(SYS_STRING_VIEW view, const char* text) {
static bool PosixViewEqualsI(SYS_STRING_VIEW view, const char* text) {
size_t length = strlen(text);
if (view.Length != length) return 0;
if (view.Length != length) return false;
for (size_t i = 0; i < length; ++i) {
char a = view.Data[i];
char b = text[i];
if (a >= 'A' && a <= 'Z') a = (char)(a - 'A' + 'a');
if (b >= 'A' && b <= 'Z') b = (char)(b - 'A' + 'a');
if (a != b) return 0;
if (a != b) return false;
}
return 1;
return true;
}
// POSIX owns the msvcrt compatibility alias; all other import names are native.
code/user/personalities/posix/posix_runtime.c
+5 -5
View File
@@ -463,7 +463,7 @@ static KSTATUS PosixRuntimeRegisterProcess(POSIX_PROCESS_STATE* process,
}
// Initializes process-local POSIX state, registers stable identity, and attaches the initial thread.
uint32_t PosixRuntimeInitializeProcess(void) {
KSTATUS PosixRuntimeInitializeProcess(void) {
if (gPosixProcessState)
return PosixRuntimeAttachThread();
@@ -482,7 +482,7 @@ uint32_t PosixRuntimeInitializeProcess(void) {
gPosixProcessState = process;
NTL_POSIX_BOOTSTRAP_DATA bootstrap;
uint32_t status = PosixRuntimeReadBootstrap(&bootstrap);
KSTATUS status = PosixRuntimeReadBootstrap(&bootstrap);
if (status != NTLSTATUS_SUCCESS) {
gPosixProcessState = (POSIX_PROCESS_STATE*)0;
free(process);
@@ -608,7 +608,7 @@ static void PosixRuntimeUnregisterThread(POSIX_THREAD_STATE* thread) {
}
// Attaches the native thread with one inherited persistent POSIX signal mask.
uint32_t PosixRuntimeAttachThreadWithSignalMask(uint64_t signalMask) {
KSTATUS PosixRuntimeAttachThreadWithSignalMask(uint64_t signalMask) {
SYS_TEB* teb = SysGetTeb();
POSIX_PROCESS_STATE* process = PosixRuntimeProcessState();
if (!teb || teb->Magic != SYS_TEB_MAGIC || !process)
@@ -649,7 +649,7 @@ uint32_t PosixRuntimeAttachThreadWithSignalMask(uint64_t signalMask) {
}
// Attaches a native thread with the default empty signal mask.
uint32_t PosixRuntimeAttachThread(void) {
KSTATUS PosixRuntimeAttachThread(void) {
return PosixRuntimeAttachThreadWithSignalMask(0);
}
@@ -763,7 +763,7 @@ static KSTATUS PosixRuntimeReportBootstrapReady(POSIX_PROCESS_STATE* process) {
// Initializes all POSIX process state required before application main.
NTL_POSIX_API uint32_t __ntl_posix_process_start(void) {
uint32_t status = PosixRuntimeInitializeProcess();
KSTATUS status = PosixRuntimeInitializeProcess();
if (status != NTLSTATUS_SUCCESS)
return status;
code/user/personalities/posix/posix_signal.c
+8 -7
View File
@@ -1,5 +1,6 @@
// POSIX signal policy and user-mode dispatch over generic thread APC delivery.
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <signal.h>
@@ -33,13 +34,13 @@ static KSTATUS PosixSignalCallServer(NTL_POSIX_REQUEST* request, NTL_POSIX_REPLY
}
// Applies one caught/default/ignored signal on the current POSIX thread.
static int PosixSignalDeliver(POSIX_THREAD_STATE* thread, int signalNumber) {
if (!thread || !thread->NativeProcess || !NtlPosixSignalValid(signalNumber)) return 0;
static bool PosixSignalDeliver(POSIX_THREAD_STATE* thread, int signalNumber) {
if (!thread || !thread->NativeProcess || !NtlPosixSignalValid(signalNumber)) return false;
uint64_t bit = PosixSignalBit(signalNumber);
uint64_t effectiveMask = thread->SignalBlocked | thread->SignalHandlerBlocked;
if (signalNumber != SIGKILL && (effectiveMask & bit) != 0) {
thread->SignalPending |= bit;
return 0;
return false;
}
thread->SignalPending &= ~bit;
@@ -49,10 +50,10 @@ static int PosixSignalDeliver(POSIX_THREAD_STATE* thread, int signalNumber) {
if (handlerValue == (uintptr_t)SIG_IGN ||
(handlerValue == (uintptr_t)SIG_DFL && signalNumber == SIGCHLD))
return 0;
return false;
if (handlerValue == (uintptr_t)SIG_DFL) {
_exit(128 + signalNumber);
return 1;
return true;
}
uint64_t previousHandlerMask = thread->SignalHandlerBlocked;
@@ -65,7 +66,7 @@ static int PosixSignalDeliver(POSIX_THREAD_STATE* thread, int signalNumber) {
((sighandler_t)handlerValue)(signalNumber);
thread->SignalHandlerBlocked = previousHandlerMask;
PosixSignalDispatchLocalPending(thread);
return 1;
return true;
}
// Maps one personality-neutral native exception class to a POSIX signal.
@@ -95,7 +96,7 @@ static int PosixSignalForNativeException(uint32_t code) {
}
// Translates selected native faults at the POSIX personality boundary.
static int PosixSignalNativeException(SYS_EXCEPTION_RECORD* record,
static uint32_t PosixSignalNativeException(SYS_EXCEPTION_RECORD* record,
SYS_USER_CONTEXT* context,
void* userContext) {
(void)context;
code/user/personalities/posix/posix_socket.c
+32 -31
View File
@@ -1,5 +1,6 @@
// POSIX compatibility support for posix socket.
#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdint.h>
@@ -31,27 +32,27 @@ __declspec(dllexport) uint32_t htonl(uint32_t x) { return bswap32(x); }
__declspec(dllexport) uint32_t ntohl(uint32_t x) { return bswap32(x); }
// Parses byte.
static int ParseByte(const char** p, uint8_t* out) {
static bool ParseByte(const char** p, uint8_t* out) {
const char* s = *p;
if (*s < '0' || *s > '9') return 0;
if (*s < '0' || *s > '9') return false;
unsigned v = 0;
while (*s >= '0' && *s <= '9') {
v = v * 10 + (unsigned)(*s - '0');
if (v > 255) return 0;
if (v > 255) return false;
s++;
}
*out = (uint8_t)v;
*p = s;
return 1;
return true;
}
// Parses ipv4 Bytes.
static int ParseIpv4Bytes(const char* text, uint8_t out[4]) {
static bool ParseIpv4Bytes(const char* text, uint8_t out[4]) {
const char* p = text;
for (int i = 0; i < 4; i++) {
if (!ParseByte(&p, &out[i])) return 0;
if (!ParseByte(&p, &out[i])) return false;
if (i != 3) {
if (*p != '.') return 0;
if (*p != '.') return false;
p++;
}
}
@@ -65,14 +66,14 @@ static int ParseHex(char c) {
return -1;
}
static int ParseIpv6Bytes(const char* text, uint8_t out[16]) {
static bool ParseIpv6Bytes(const char* text, uint8_t out[16]) {
uint16_t words[8];
int count = 0;
int compress = -1;
const char* p = text;
if (!text || !*text || !out)
return 0;
return false;
memset(words, 0, sizeof(words));
if (p[0] == ':' && p[1] == ':') {
@@ -84,7 +85,7 @@ static int ParseIpv6Bytes(const char* text, uint8_t out[16]) {
while (*p) {
if (count >= 8)
return 0;
return false;
unsigned value = 0;
int digits = 0;
@@ -97,17 +98,17 @@ static int ParseIpv6Bytes(const char* text, uint8_t out[16]) {
digits++;
}
if (digits == 0)
return 0;
return false;
words[count++] = (uint16_t)value;
if (*p == '\0')
break;
if (*p != ':')
return 0;
return false;
p++;
if (*p == ':') {
if (compress >= 0)
return 0;
return false;
compress = count;
p++;
if (*p == '\0')
@@ -118,30 +119,30 @@ static int ParseIpv6Bytes(const char* text, uint8_t out[16]) {
if (compress >= 0) {
int zeros = 8 - count;
if (zeros <= 0)
return 0;
return false;
for (int i = count - 1; i >= compress; --i)
words[i + zeros] = words[i];
for (int i = 0; i < zeros; ++i)
words[compress + i] = 0;
} else if (count != 8) {
return 0;
return false;
}
for (int i = 0; i < 8; ++i) {
out[i * 2 + 0] = (uint8_t)(words[i] >> 8);
out[i * 2 + 1] = (uint8_t)words[i];
}
return 1;
return true;
}
static char* AppendHex16(char* out, uint16_t value) {
static const char hex[] = "0123456789abcdef";
int started = 0;
bool started = false;
for (int shift = 12; shift >= 0; shift -= 4) {
unsigned nibble = (value >> shift) & 0xfu;
if (nibble || started || shift == 0) {
*out++ = hex[nibble];
started = 1;
started = true;
}
}
return out;
@@ -300,7 +301,7 @@ static POSIX_OPEN_DESCRIPTION* SocketFdAcquire(int fd) {
// Creates a socket and installs it as a process-local descriptor.
__declspec(dllexport) int socket(int domain, int type, int protocol) {
uint32_t kh = SYS_HANDLE_INVALID;
uint32_t status = SysCreateSocket((uint32_t)domain, (uint32_t)type, (uint32_t)protocol, &kh);
KSTATUS status = SysCreateSocket((uint32_t)domain, (uint32_t)type, (uint32_t)protocol, &kh);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
return -1;
@@ -321,7 +322,7 @@ __declspec(dllexport) int bind(int fd, const struct sockaddr* addr, socklen_t ad
PosixFdRelease(description);
return -1;
}
uint32_t status = SysBindSocket(description->KHandle, &address, sizeof(address));
KSTATUS status = SysBindSocket(description->KHandle, &address, sizeof(address));
PosixFdRelease(description);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
@@ -334,7 +335,7 @@ __declspec(dllexport) int bind(int fd, const struct sockaddr* addr, socklen_t ad
__declspec(dllexport) int listen(int fd, int backlog) {
POSIX_OPEN_DESCRIPTION* description = SocketFdAcquire(fd);
if (!description) return -1;
uint32_t status = SysListenSocket(description->KHandle, backlog < 0 ? 0u : (uint32_t)backlog);
KSTATUS status = SysListenSocket(description->KHandle, backlog < 0 ? 0u : (uint32_t)backlog);
PosixFdRelease(description);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
@@ -351,7 +352,7 @@ __declspec(dllexport) int accept(int fd, struct sockaddr* addr, socklen_t* addrl
SYS_SOCKET_ADDRESS remote;
size_t remoteSize = sizeof(remote);
uint32_t kh = SYS_HANDLE_INVALID;
uint32_t status = SysAcceptSocket(description->KHandle,
KSTATUS status = SysAcceptSocket(description->KHandle,
addr ? &remote : (SYS_SOCKET_ADDRESS*)0,
addr ? &remoteSize : (size_t*)0,
&kh);
@@ -379,7 +380,7 @@ __declspec(dllexport) int connect(int fd, const struct sockaddr* addr, socklen_t
PosixFdRelease(description);
return -1;
}
uint32_t status = SysConnectSocket(description->KHandle, &address, sizeof(address));
KSTATUS status = SysConnectSocket(description->KHandle, &address, sizeof(address));
PosixFdRelease(description);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
@@ -397,7 +398,7 @@ __declspec(dllexport) ssize_t send(int fd, const void* buf, size_t len, int flag
sizeof(SYS_SOCKET_SEND_REQUEST), description->KHandle, (uint32_t)flags,
buf, len, &sent
};
uint32_t status = SysSendSocket(&request);
KSTATUS status = SysSendSocket(&request);
PosixFdRelease(description);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
@@ -415,7 +416,7 @@ __declspec(dllexport) ssize_t recv(int fd, void* buf, size_t len, int flags) {
sizeof(SYS_SOCKET_RECV_REQUEST), description->KHandle, (uint32_t)flags,
buf, len, &got
};
uint32_t status = SysRecvSocket(&request);
KSTATUS status = SysRecvSocket(&request);
PosixFdRelease(description);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
@@ -446,7 +447,7 @@ __declspec(dllexport) ssize_t sendto(int fd, const void* buf, size_t len, int fl
request.RemoteAddressSize = sizeof(remote);
request.SentOut = &sent;
uint32_t status = SysSendToSocket(description->KHandle, &request);
KSTATUS status = SysSendToSocket(description->KHandle, &request);
PosixFdRelease(description);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
@@ -474,7 +475,7 @@ __declspec(dllexport) ssize_t recvfrom(int fd, void* buf, size_t len, int flags,
request.RemoteAddressSizeInOut = src ? &remoteSize : (size_t*)0;
request.ReceivedOut = &got;
uint32_t status = SysRecvFromSocket(description->KHandle, &request);
KSTATUS status = SysRecvFromSocket(description->KHandle, &request);
PosixFdRelease(description);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
@@ -488,7 +489,7 @@ __declspec(dllexport) ssize_t recvfrom(int fd, void* buf, size_t len, int flags,
__declspec(dllexport) int shutdown(int fd, int how) {
POSIX_OPEN_DESCRIPTION* description = SocketFdAcquire(fd);
if (!description) return -1;
uint32_t status = SysShutdownSocket(description->KHandle, (uint32_t)how);
KSTATUS status = SysShutdownSocket(description->KHandle, (uint32_t)how);
PosixFdRelease(description);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
@@ -550,7 +551,7 @@ __declspec(dllexport) int setsockopt(int fd, int level, int optname, const void*
request.Option = option;
request.Value = &value;
request.ValueSize = sizeof(value);
uint32_t status = SysSetSocketOption(description->KHandle, &request);
KSTATUS status = SysSetSocketOption(description->KHandle, &request);
PosixFdRelease(description);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
@@ -584,7 +585,7 @@ __declspec(dllexport) int getsockopt(int fd, int level, int optname, void* optva
request.Value = &value;
request.ValueSize = sizeof(value);
request.ActualSizeOut = &actual;
uint32_t status = SysGetSocketOption(description->KHandle, &request);
KSTATUS status = SysGetSocketOption(description->KHandle, &request);
PosixFdRelease(description);
if (status != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(status);
@@ -723,7 +724,7 @@ static int ResolveNameFamily(const char* name, int family, SYS_SOCKET_ADDRESS* o
req.Family = family == AF_INET6 ? SYS_AF_INET6 : SYS_AF_INET;
req.AddressOut = out;
req.AddressSizeInOut = &size;
uint32_t s = SysResolveHost(&req);
KSTATUS s = SysResolveHost(&req);
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
return 0;
}
code/user/personalities/posix/posix_thread.c
+6 -6
View File
@@ -94,7 +94,7 @@ __declspec(dllexport) int pthread_create(pthread_t* t, const pthread_attr_t* att
&handle,
&tid
};
uint32_t s = SysCreateThread(&req);
KSTATUS s = SysCreateThread(&req);
if (s != 0) {
free(tr);
return EAGAIN;
@@ -112,7 +112,7 @@ __declspec(dllexport) int pthread_create(pthread_t* t, const pthread_attr_t* att
// Implements the pthread join operation.
__declspec(dllexport) int pthread_join(pthread_t t, void** retval) {
uint32_t s = SysWait(t.Handle, SYS_WAIT_FLAG_NONE);
KSTATUS s = SysWait(t.Handle, SYS_WAIT_FLAG_NONE);
if (s != 0) return ESRCH;
POSIX_PTHREAD_SLOT* slot = PthreadSlotFind(t.Tid);
@@ -136,7 +136,7 @@ __declspec(dllexport) void pthread_exit(void* retval) {
__declspec(dllexport) int pthread_mutex_init(pthread_mutex_t* m, const pthread_mutexattr_t* attr) {
(void)attr;
uint32_t h;
uint32_t s = SysCreateMutex(&h);
KSTATUS s = SysCreateMutex(&h);
if (s != 0) return ENOMEM;
m->Handle = h;
return 0;
@@ -151,18 +151,18 @@ __declspec(dllexport) int pthread_mutex_destroy(pthread_mutex_t* m) {
// Implements the pthread mutex lock operation.
__declspec(dllexport) int pthread_mutex_lock(pthread_mutex_t* m) {
uint32_t s = SysWait(m->Handle, SYS_WAIT_FLAG_NONE);
KSTATUS s = SysWait(m->Handle, SYS_WAIT_FLAG_NONE);
return s == 0 ? 0 : EINVAL;
}
// Implements the pthread mutex trylock operation.
__declspec(dllexport) int pthread_mutex_trylock(pthread_mutex_t* m) {
uint32_t s = SysTryAcquireMutex(m->Handle);
KSTATUS s = SysTryAcquireMutex(m->Handle);
return s == 0 ? 0 : EAGAIN;
}
// Implements the pthread mutex unlock operation.
__declspec(dllexport) int pthread_mutex_unlock(pthread_mutex_t* m) {
uint32_t s = SysReleaseMutex(m->Handle);
KSTATUS s = SysReleaseMutex(m->Handle);
return s == 0 ? 0 : EINVAL;
}