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

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

Browse Source
This commit is contained in:
maksw committed 2026-08-20 12:33:17 +02:00
1 parent 4add6789ba
commit f882d339fb
232 files changed
+20934 -8898
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

code/user/personalities/posix/posix_dir.c
+16 -34
View File
@@ -2,6 +2,7 @@
#include <string.h>
#include <ntlite/syscall.h>
#include <ntlite/path.h>
#include <stdlib.h>
#include "posix.h"
#include "posix_fd.h"
@@ -15,8 +16,7 @@ typedef SYS_DIR_ENTRY KDIR_ENTRY;
__declspec(dllexport) int chdir(const char* path) {
char native[512];
PosixTranslatePath(path, native, sizeof(native));
SYS_PATH_REQUEST req = { SysSvFromCstr(native) };
uint32_t s = SysSetCwd(&req);
uint32_t s = NtlSetCurrentDirectory(SysSvFromCstr(native));
if (s != 0) { errno = ENOENT; return -1; }
return 0;
}
@@ -25,17 +25,15 @@ __declspec(dllexport) int chdir(const char* path) {
__declspec(dllexport) char* getcwd(char* buf, size_t size) {
if (!buf || size == 0) { errno = EINVAL; return (char*)0; }
SYS_STRING_VIEW cwd = SysGetCurrentDirectoryView();
if ((cwd.Length && !cwd.Data) || cwd.Length > SYS_CWD_MAX) {
char native[SYS_PATH_MAX + 1u];
size_t required = 0;
uint32_t status = NtlGetCurrentDirectory(native, sizeof(native), &required);
if (status != NTLSTATUS_SUCCESS) {
errno = ERANGE;
return (char*)0;
}
char native[SYS_CWD_MAX + 1];
if (cwd.Length) memcpy(native, cwd.Data, cwd.Length);
native[cwd.Length] = '\0';
char posix[SYS_CWD_MAX + 1];
char posix[SYS_PATH_MAX + 1];
NativeToPosix(native, posix, sizeof(posix));
size_t needed = strlen(posix) + 1;
@@ -73,31 +71,15 @@ __declspec(dllexport) char* realpath(const char* path, char* resolved_path) {
return PosixCopyResolvedPath(path, resolved_path);
size_t required = 0;
SYS_REAL_PATH_REQUEST query = {
sizeof(query),
SYS_REAL_PATH_FLAG_NONE,
SysSvFromCstr(translated),
(char*)0,
0,
&required,
};
uint32_t status = SysRealPath(&query);
uint32_t status = NtlRealPath(SysSvFromCstr(translated), (char*)0, 0, &required);
if (status != NTLSTATUS_SUCCESS) { errno = PosixStatusToErrno(status); return (char*)0; }
if (required == 0 || required > SYS_CWD_MAX) { errno = ERANGE; return (char*)0; }
if (required == 0 || required > SYS_PATH_MAX + 1u) { errno = ERANGE; return (char*)0; }
char nativeResolved[SYS_CWD_MAX];
SYS_REAL_PATH_REQUEST request = {
sizeof(request),
SYS_REAL_PATH_FLAG_NONE,
SysSvFromCstr(translated),
nativeResolved,
sizeof(nativeResolved),
&required,
};
status = SysRealPath(&request);
char nativeResolved[SYS_PATH_MAX + 1u];
status = NtlRealPath(SysSvFromCstr(translated), nativeResolved, sizeof(nativeResolved), &required);
if (status != NTLSTATUS_SUCCESS) { errno = PosixStatusToErrno(status); return (char*)0; }
char posix[SYS_CWD_MAX];
char posix[SYS_PATH_MAX];
NativeToPosix(nativeResolved, posix, sizeof(posix));
return PosixCopyResolvedPath(posix, resolved_path);
}
@@ -107,8 +89,9 @@ __declspec(dllexport) DIR* opendir(const char* path) {
char native[512];
PosixTranslatePath(path, native, sizeof(native));
uint32_t kh;
SYS_PATH_HANDLE_REQUEST req = { SysSvFromCstr(native), &kh };
uint32_t s = SysOpenDir(&req);
uint32_t 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; }
// Allocate DIR on the kernel heap (malloc) so it outlives the stack.
@@ -188,8 +171,7 @@ __declspec(dllexport) int stat(const char* path, struct stat* out) {
return PosixFillSyntheticStat(S_IFCHR, out);
SYS_FILE_STAT nativeStat;
SYS_STAT_FILE_REQUEST req = { SysSvFromCstr(p), &nativeStat };
uint32_t s = SysStatFile(&req);
uint32_t s = NtlStatPath(SysSvFromCstr(p), &nativeStat);
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
return PosixFillStat(&nativeStat, out);
}
code/user/personalities/posix/posix_dlfcn.c
+35 -16
View File
@@ -3,6 +3,8 @@
#include <stdint.h>
#include <string.h>
#include <ntlite/syscall.h>
#include <ntlite/module_loader.h>
#include <ntlite/resource.h>
#include "posix.h"
#include "posix_path.h"
#include "posix_fd.h"
@@ -43,22 +45,45 @@ __declspec(dllexport) void* dlopen(const char* filename, int flags) {
}
char native[512];
const char* path = PosixTranslatePath(filename, native, sizeof(native));
if (!path || strcmp(path, SYNTH_DEVNULL) == 0 || strcmp(path, SYNTH_DEVZERO) == 0) {
uint32_t status = PosixProcessPath(filename, native, sizeof(native));
if (status != NTLSTATUS_SUCCESS) {
errno = EINVAL;
DlSetError("dlopen path is not a loadable module");
return 0;
}
if (!strchr(native, '/')) {
size_t length = strlen(native);
if (length + sizeof("system/") > sizeof(native)) {
errno = ERANGE;
DlSetError("dlopen path is too long");
return 0;
}
memmove(native + 7, native, length + 1u);
memcpy(native, "system/", 7);
}
uint32_t handle = 0;
SYS_LOAD_MODULE_REQUEST req;
SYS_HANDLE root = SYS_HANDLE_INVALID;
status = NtlResourceOpenSystemRoot(SYS_RIGHT_QUERY | SYS_VOLUME_RIGHT_OPEN, &root);
if (status != NTLSTATUS_SUCCESS) {
DlSetStatusError("dlopen system root failed", status);
return 0;
}
NTL_MODULE_HANDLE handle = NTL_MODULE_HANDLE_INVALID;
NTL_LOAD_MODULE_AT_REQUEST req;
memset(&req, 0, sizeof(req));
req.Size = sizeof(req);
req.Path = SysSvFromCstr(path);
req.Flags = NTL_MODULE_LOAD_FLAG_NONE;
req.RootHandle = root;
req.Path = SysSvFromCstr(native);
req.ModuleRootHandle = root;
req.ModuleDirectory = SYS_SV_LITERAL("system");
req.ResolveModuleName = PosixResolveModuleName;
req.ModuleHandleOut = &handle;
uint32_t status = SysLoadModule(&req);
if (status != NTLSTATUS_SUCCESS || handle == 0) {
status = NtlLoadModuleAt(&req);
(void)SysCloseHandle(root);
if (status != NTLSTATUS_SUCCESS || handle == NTL_MODULE_HANDLE_INVALID) {
DlSetStatusError("dlopen failed", status);
return 0;
}
@@ -76,14 +101,8 @@ __declspec(dllexport) void* dlsym(void* handle, const char* symbol) {
}
uintptr_t address = 0;
SYS_GET_MODULE_EXPORT_REQUEST req;
memset(&req, 0, sizeof(req));
req.Size = sizeof(req);
req.ModuleHandle = (uint32_t)(uintptr_t)handle;
req.Name = SysSvFromCstr(symbol);
req.AddressOut = &address;
uint32_t status = SysGetModuleExport(&req);
uint32_t status = NtlGetModuleExport((NTL_MODULE_HANDLE)(uintptr_t)handle,
SysSvFromCstr(symbol), &address);
if (status != NTLSTATUS_SUCCESS || address == 0) {
DlSetStatusError("dlsym failed", status);
return 0;
@@ -101,7 +120,7 @@ __declspec(dllexport) int dlclose(void* handle) {
return -1;
}
uint32_t status = SysUnloadModule((uint32_t)(uintptr_t)handle);
uint32_t status = NtlUnloadModule((NTL_MODULE_HANDLE)(uintptr_t)handle);
if (status != NTLSTATUS_SUCCESS) {
DlSetStatusError("dlclose failed", status);
return -1;
code/user/personalities/posix/posix_io.c
+15 -11
View File
@@ -3,6 +3,7 @@
#include <stddef.h>
#include <string.h>
#include <ntlite/syscall.h>
#include <ntlite/path.h>
#include "posix.h"
#include "posix_fd.h"
#include "posix_path.h"
@@ -61,12 +62,8 @@ __declspec(dllexport) int open(const char* path, int flags, ...) {
else if (flags & O_TRUNC)
disposition = SYS_FILE_TRUNCATE_EXISTING;
SYS_OPEN_FILE_REQUEST req = SysMakeOpenFileRequest(SysSvFromCstr(p),
access,
disposition,
SYS_FILE_FLAG_NONE,
&kh);
uint32_t s = SysOpenFile(&req);
uint32_t s = NtlOpenFile(SysSvFromCstr(p), access, disposition,
SYS_FILE_FLAG_NONE, &kh);
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
int fd = FdAlloc(pid, type, kh);
@@ -109,7 +106,11 @@ __declspec(dllexport) ssize_t read(int fd, void* buf, size_t count) {
}
case FD_SOCKET: {
size_t got = 0;
uint32_t s = SysRecvSocket(e->KHandle, buf, count, 0, &got);
SYS_SOCKET_RECV_REQUEST request = {
sizeof(SYS_SOCKET_RECV_REQUEST), e->KHandle, 0,
buf, count, &got
};
uint32_t s = SysRecvSocket(&request);
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
return (ssize_t)got;
}
@@ -128,7 +129,7 @@ __declspec(dllexport) ssize_t write(int fd, const void* buf, size_t count) {
switch (e->Type) {
case FD_CONSOLE_W: {
SYS_WRITE_CONSOLE_REQUEST req = { SysSvFromParts((const char*)buf, count) };
SYS_WRITE_CONSOLE_REQUEST req = { sizeof(SYS_WRITE_CONSOLE_REQUEST), SysSvFromParts((const char*)buf, count) };
SysWriteConsole(&req);
return (ssize_t)count;
}
@@ -144,7 +145,11 @@ __declspec(dllexport) ssize_t write(int fd, const void* buf, size_t count) {
}
case FD_SOCKET: {
size_t sent = 0;
uint32_t s = SysSendSocket(e->KHandle, buf, count, 0, &sent);
SYS_SOCKET_SEND_REQUEST request = {
sizeof(SYS_SOCKET_SEND_REQUEST), e->KHandle, 0,
buf, count, &sent
};
uint32_t s = SysSendSocket(&request);
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
return (ssize_t)sent;
}
@@ -177,8 +182,7 @@ __declspec(dllexport) int unlink(const char* path) {
return -1;
}
SYS_PATH_REQUEST req = { SysSvFromCstr(p) };
uint32_t s = SysDeleteFile(&req);
uint32_t s = NtlDeleteFile(SysSvFromCstr(p));
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
return 0;
}
code/user/personalities/posix/posix_mman.c
+11 -5
View File
@@ -50,17 +50,23 @@ __declspec(dllexport) void* mmap(void* addr, size_t length, int prot,
protect = (prot & PROT_WRITE) ? SYS_VM_EXECUTE_READWRITE : SYS_VM_EXECUTE_READ;
uint32_t mapping = 0;
uint32_t s = SysCreateFileMapping(e->KHandle, protect, SYS_MAP_FLAG_NONE,
maxSize, &mapping);
SYS_CREATE_FILE_MAPPING_REQUEST createMapping = {
sizeof(SYS_CREATE_FILE_MAPPING_REQUEST), e->KHandle, protect,
SYS_MAP_FLAG_NONE, maxSize, &mapping
};
uint32_t s = SysCreateFileMapping(&createMapping);
if (s != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(s);
return MAP_FAILED;
}
void* base = (void*)0;
s = SysMapFile(mapping, (uint64_t)offset, length,
PosixProtToSysMapAccess(prot, flags),
SYS_MAP_FLAG_NONE, &base);
SYS_MAP_FILE_REQUEST mapFile = {
sizeof(SYS_MAP_FILE_REQUEST), mapping,
PosixProtToSysMapAccess(prot, flags), SYS_MAP_FLAG_NONE,
(uint64_t)offset, length, &base
};
s = SysMapFile(&mapFile);
SysCloseHandle(mapping);
if (s != NTLSTATUS_SUCCESS) {
errno = PosixStatusToErrno(s);
code/user/personalities/posix/posix_path.c
+64 -50
View File
@@ -1,76 +1,90 @@
// POSIX compatibility support for posix path.
// POSIX compatibility support for path translation.
#include <stddef.h>
#include <string.h>
#include <ntlite/status.h>
#include "posix_path.h"
// Checks whether drive Mount.
static int IsDriveMount(const char* p) {
return p && p[0] == '/' && p[1] >= '0' && p[1] <= '7' &&
(p[2] == '\0' || p[2] == '/');
}
#define POSIX_SYSTEM_ROOT "/SystemRoot"
// Translates POSIX filesystem syntax into the native resource namespace.
const char* PosixTranslatePath(const char* in, char* out, size_t outSize) {
if (!in || !out || outSize < 4) return out;
if (!in || !out || outSize == 0) return out;
if (strcmp(in, "/dev/null") == 0) return SYNTH_DEVNULL;
if (strcmp(in, "/dev/zero") == 0) return SYNTH_DEVZERO;
if (IsDriveMount(in)) {
out[0] = in[1];
out[1] = ':';
out[2] = '/';
const char* rest = (in[2] == '/') ? in + 3 : "";
size_t restLen = strlen(rest);
if (restLen + 4 > outSize) restLen = outSize - 4;
memcpy(out + 3, rest, restLen);
out[3 + restLen] = '\0';
if (in[0] == '/') {
size_t prefixLength = sizeof(POSIX_SYSTEM_ROOT) - 1u;
size_t restLength = strlen(in);
if (prefixLength + restLength + 1u > outSize) {
out[0] = '\0';
return out;
}
memcpy(out, POSIX_SYSTEM_ROOT, prefixLength);
memcpy(out + prefixLength, in, restLength + 1u);
return out;
}
if (in[0] == '/') {
out[0] = '0';
out[1] = ':';
out[2] = '/';
size_t rest = strlen(in + 1);
if (rest + 4 > outSize) rest = outSize - 4;
memcpy(out + 3, in + 1, rest);
out[3 + rest] = '\0';
} else {
size_t len = strlen(in);
if (len + 1 > outSize) len = outSize - 1;
memcpy(out, in, len);
out[len] = '\0';
size_t length = strlen(in);
if (length + 1u > outSize) {
out[0] = '\0';
return out;
}
memcpy(out, in, length + 1u);
return out;
}
// Implements the native To Posix operation.
// Translates a canonical native SystemRoot path back to POSIX syntax.
void NativeToPosix(const char* in, char* out, size_t outSize) {
if (!in || !out || outSize == 0) return;
size_t prefixLength = sizeof(POSIX_SYSTEM_ROOT) - 1u;
const char* src = in;
char drive = 0;
if (src[0] >= '0' && src[0] <= '7' && src[1] == ':' &&
(src[2] == '\\' || src[2] == '/')) {
drive = src[0];
src += 3;
if (strncmp(src, POSIX_SYSTEM_ROOT, prefixLength) == 0 &&
(src[prefixLength] == '\0' || src[prefixLength] == '/')) {
src += prefixLength;
if (*src == '\0') src = "/";
}
size_t pos = 0;
if (drive && drive != '0') {
if (outSize < 4) { out[0] = '\0'; return; }
out[pos++] = '/';
out[pos++] = drive;
if (*src) out[pos++] = '/';
} else {
out[pos++] = '/';
size_t length = strlen(src);
if (length + 1u > outSize) {
out[0] = '\0';
return;
}
while (*src && pos + 1 < outSize) {
out[pos++] = (*src == '\\') ? '/' : *src;
src++;
}
out[pos] = '\0';
memcpy(out, src, length + 1u);
}
// Maps POSIX executable syntax into native resource/CWD syntax.
KSTATUS PosixProcessPath(const char* in, char* out, size_t outSize) {
if (!in || !out || outSize == 0) return NTLSTATUS_INVALID_PARAMETER;
const char* translated = PosixTranslatePath(in, out, outSize);
if (translated != out || out[0] == '\0') return NTLSTATUS_INVALID_PARAMETER;
return NTLSTATUS_SUCCESS;
}
static int PosixViewEqualsI(SYS_STRING_VIEW view, const char* text) {
size_t length = strlen(text);
if (view.Length != length) return 0;
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;
}
return 1;
}
// POSIX owns the msvcrt compatibility alias; all other import names are native.
KSTATUS PosixResolveModuleName(void* context, SYS_STRING_VIEW requested, SYS_STRING_VIEW* canonicalOut) {
(void)context;
if (!canonicalOut || !SysSvIsValid(requested) || requested.Length == 0)
return NTLSTATUS_INVALID_PARAMETER;
if (PosixViewEqualsI(requested, "msvcrt.dll")) {
*canonicalOut = SYS_SV_LITERAL("posix.dll");
return NTLSTATUS_SUCCESS;
}
*canonicalOut = requested;
return NTLSTATUS_SUCCESS;
}
code/user/personalities/posix/posix_path.h
+7
View File
@@ -1,6 +1,7 @@
// POSIX compatibility support for posix path.
#pragma once
#include <ntlite/module_loader.h>
// posix_path.h - POSIX <-> native path translation.
// SYNTHETIC sentinel returned from PosixTranslatePath for /dev/null and
@@ -16,3 +17,9 @@ const char* PosixTranslatePath(const char* in, char* out, size_t outSize);
// Translate a native kernel path back to a POSIX-style path.
// Strips the drive letter prefix and flips backslashes.
void NativeToPosix(const char* in, char* out, size_t outSize);
// Maps POSIX executable syntax to a canonical path relative to /SystemRoot.
KSTATUS PosixProcessPath(const char* in, char* out, size_t outSize);
// Maps POSIX/CRT import aliases to their canonical system personality module.
KSTATUS PosixResolveModuleName(void* context, SYS_STRING_VIEW requested, SYS_STRING_VIEW* canonicalOut);
code/user/personalities/posix/posix_proc.c
+22 -4
View File
@@ -3,6 +3,8 @@
#include <stddef.h>
#include <string.h>
#include <ntlite/syscall.h>
#include <ntlite/path.h>
#include <ntlite/process_loader.h>
#include "posix.h"
#include "posix_path.h"
@@ -93,7 +95,13 @@ __declspec(dllexport) int posix_spawn(pid_t* pidOut,
(void)file_actions; (void)attrp; (void)envp;
char native[512];
PosixTranslatePath(path, native, sizeof(native));
uint32_t pathStatus = PosixProcessPath(path, native, sizeof(native));
if (pathStatus != NTLSTATUS_SUCCESS) { errno = ENOENT; return -1; }
SYS_HANDLE imageFile = SYS_HANDLE_INVALID;
pathStatus = NtlOpenFile(SysSvFromCstr(native), SYS_FILE_ACCESS_READ | SYS_FILE_ACCESS_QUERY,
SYS_FILE_OPEN_EXISTING, SYS_FILE_FLAG_NONE, &imageFile);
if (pathStatus != NTLSTATUS_SUCCESS) { errno = ENOENT; return -1; }
char cmdline[512];
BuildCmdline(argv, cmdline, sizeof(cmdline));
@@ -106,9 +114,19 @@ __declspec(dllexport) int posix_spawn(pid_t* pidOut,
cmdline[len] = '\0';
}
uint32_t procHandle;
SYS_CREATE_PROCESS_REQUEST req = { SysSvFromCstr(native), SysSvFromCstr(cmdline), &procHandle };
uint32_t s = SysCreateProcess(&req);
uint32_t procHandle = 0;
NTL_CREATE_SYSTEM_PROCESS_REQUEST req;
memset(&req, 0, sizeof(req));
req.Size = sizeof(req);
req.Flags = NTL_PROCESS_LOAD_FLAG_NONE;
req.ImageFile = imageFile;
req.Path = SysSvFromCstr(native);
req.CommandLine = SysSvFromCstr(cmdline);
req.SecurityContext = SYS_SECURITY_CONTEXT_CURRENT;
req.ResolveModuleName = PosixResolveModuleName;
req.ProcessHandleOut = &procHandle;
uint32_t s = NtlCreateSystemProcess(&req);
if (imageFile != SYS_HANDLE_INVALID) (void)SysCloseHandle(imageFile);
if (s != 0) { errno = ENOENT; return -1; }
uint32_t kpid = 0;
code/user/personalities/posix/posix_socket.c
+15 -2
View File
@@ -363,7 +363,11 @@ __declspec(dllexport) ssize_t send(int fd, const void* buf, size_t len, int flag
FD_ENTRY* e = SocketFdGet(fd);
if (!e) return -1;
size_t sent = 0;
uint32_t s = SysSendSocket(e->KHandle, buf, len, (uint32_t)flags, &sent);
SYS_SOCKET_SEND_REQUEST request = {
sizeof(SYS_SOCKET_SEND_REQUEST), e->KHandle, (uint32_t)flags,
buf, len, &sent
};
uint32_t s = SysSendSocket(&request);
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
return (ssize_t)sent;
}
@@ -373,7 +377,11 @@ __declspec(dllexport) ssize_t recv(int fd, void* buf, size_t len, int flags) {
FD_ENTRY* e = SocketFdGet(fd);
if (!e) return -1;
size_t got = 0;
uint32_t s = SysRecvSocket(e->KHandle, buf, len, (uint32_t)flags, &got);
SYS_SOCKET_RECV_REQUEST request = {
sizeof(SYS_SOCKET_RECV_REQUEST), e->KHandle, (uint32_t)flags,
buf, len, &got
};
uint32_t s = SysRecvSocket(&request);
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
return (ssize_t)got;
}
@@ -388,6 +396,7 @@ __declspec(dllexport) ssize_t sendto(int fd, const void* buf, size_t len, int fl
size_t sent = 0;
SYS_SOCKET_SEND_TO_REQUEST req;
memset(&req, 0, sizeof(req));
req.Size = sizeof(req);
req.Buffer = buf;
req.Length = len;
req.Flags = (uint32_t)flags;
@@ -410,6 +419,7 @@ __declspec(dllexport) ssize_t recvfrom(int fd, void* buf, size_t len, int flags,
size_t got = 0;
SYS_SOCKET_RECV_FROM_REQUEST req;
memset(&req, 0, sizeof(req));
req.Size = sizeof(req);
req.Buffer = buf;
req.Length = len;
req.Flags = (uint32_t)flags;
@@ -463,6 +473,7 @@ __declspec(dllexport) int setsockopt(int fd, int level, int optname, const void*
SYS_SOCKET_OPTION_REQUEST req;
memset(&req, 0, sizeof(req));
req.Size = sizeof(req);
req.Option = option;
req.Value = &value;
req.ValueSize = sizeof(value);
@@ -487,6 +498,7 @@ __declspec(dllexport) int getsockopt(int fd, int level, int optname, void* optva
size_t actual = sizeof(value);
SYS_SOCKET_OPTION_REQUEST req;
memset(&req, 0, sizeof(req));
req.Size = sizeof(req);
req.Option = option;
req.Value = &value;
req.ValueSize = sizeof(value);
@@ -605,6 +617,7 @@ static int ResolveNameFamily(const char* name, int family, SYS_SOCKET_ADDRESS* o
size_t size = sizeof(*out);
SYS_RESOLVE_HOST_REQUEST req;
memset(&req, 0, sizeof(req));
req.Size = sizeof(req);
req.Name = SysSvFromCstr(name);
req.Family = family == AF_INET6 ? SYS_AF_INET6 : SYS_AF_INET;
req.AddressOut = out;
code/user/personalities/posix/posix_thread.c
+1 -1
View File
@@ -86,7 +86,7 @@ __declspec(dllexport) int pthread_create(pthread_t* t, const pthread_attr_t* att
uint32_t tid = 0;
uint32_t handle = 0;
SYS_CREATE_THREAD_REQUEST req = {
(uintptr_t)PthreadTrampoline,
sizeof(SYS_CREATE_THREAD_REQUEST), (uintptr_t)PthreadTrampoline,
(uintptr_t)tr,
1,
0,