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

move POSIX spawn, exec and child tracking into posixsrv, keep process transactions alive across reconnects and preserve stable PIDs across image replacement, flesh out spawn with ordered file actions, process-group selection and signal inheritance, implement execve with bootstrap validation and rollback before retiring the old process, add vfork children that share the native process while keeping separate POSIX descriptor and signal state, replace local spawn bookkeeping with child reaping, nonblocking and process-group waits and orphan cleanup, add signal dispositions, per-thread masks, pending delivery, process/group signalling and alarms, translate native exceptions into POSIX signals and inherit masks when creating threads, make pipe waits interruptible and raise SIGPIPE for broken pipes, pass arguments and environment into main and add getenv/environ, add direct user APC notifications that can run without an alertable wait, add current-thread capabilities and resume-and-wait, let accepted IPC endpoints open restricted peer process capabilities and preserve caller security during spawn and exec, make process preparation reusable and improve DLL lookup across current, executable and fallback directories, move keyboard repeat into RSSRV so PS/2 and USB share one repeat policy, fix video presentation, report launch failure stages and status codes, mooaaar tests.

Browse Source
This commit is contained in:
maksw committed 2026-09-23 09:39:42 +02:00
1 parent 73abd6f90d
commit 899225f551
57 files changed
+8817 -1216
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

code/public/ntlite/handle.h
+2
View File
@@ -24,10 +24,12 @@ typedef uint32_t SYS_RIGHTS;
#define SYS_PROCESS_RIGHT_TERMINATE 0x00000100u
#define SYS_PROCESS_RIGHT_INSERT_HANDLE 0x00000200u
#define SYS_PROCESS_RIGHT_BUILD 0x00000400u
#define SYS_PROCESS_RIGHT_SECURITY_CONTEXT 0x00000800u
// Thread-specific rights.
#define SYS_THREAD_RIGHT_RESUME 0x00000100u
#define SYS_THREAD_RIGHT_SET_INFORMATION 0x00000200u
#define SYS_THREAD_RIGHT_NOTIFY 0x00000400u
// Mutex-specific rights.
#define SYS_MUTEX_RIGHT_RELEASE 0x00000100u
code/public/ntlite/port.h
+5 -2
View File
@@ -37,8 +37,9 @@
#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
#define SYS_PORT_RIGHT_REPLY 0x00002000u
#define SYS_PORT_RIGHT_DISCONNECT 0x00004000u
#define SYS_PORT_RIGHT_OPEN_PEER_PROCESS 0x00008000u
// Describes one capability that accompanies a Port message.
typedef struct SYS_PORT_HANDLE_TRANSFER {
@@ -74,6 +75,8 @@ typedef struct SYS_CREATE_PORT_REQUEST {
uint32_t Size;
uint32_t Flags;
uint32_t Backlog;
SYS_RIGHTS PeerProcessRights;
uint32_t Reserved;
SYS_HANDLE* HandleOut;
} SYS_CREATE_PORT_REQUEST;
code/public/ntlite/posix_service.h
+99 -8
View File
@@ -5,9 +5,10 @@
#include <stdint.h>
#include <ntlite/status.h>
#include <ntlite/syscall.h>
#include <ntlite/posix_signal.h>
#define NTL_POSIX_SERVICE_PATH "/Services/posix"
#define NTL_POSIX_PROTOCOL_VERSION 6u
#define NTL_POSIX_PROTOCOL_VERSION 15u
#define NTL_POSIX_REQUEST_FLAG_NONE 0u
@@ -30,15 +31,37 @@
#define NTL_POSIX_OP_CREATE_FD_INHERITANCE 17u
#define NTL_POSIX_OP_IMPORT_FD_INHERITANCE 18u
#define NTL_POSIX_OP_CANCEL_FD_INHERITANCE 19u
#define NTL_POSIX_OP_ARM_FD_INHERITANCE 20u
#define NTL_POSIX_OP_CONSTRUCT_SET_EXECUTABLE 20u
#define NTL_POSIX_OP_CONSTRUCT_WRITE_VECTOR 21u
#define NTL_POSIX_OP_SPAWN_ADD_FILE_ACTION 22u
#define NTL_POSIX_OP_SPAWN_SET_ATTRIBUTES 23u
#define NTL_POSIX_OP_SPAWN_COMMIT 24u
#define NTL_POSIX_OP_BOOTSTRAP_READY 25u
#define NTL_POSIX_OP_WAIT_PROCESS 26u
#define NTL_POSIX_OP_REGISTER_THREAD 27u
#define NTL_POSIX_OP_UNREGISTER_THREAD 28u
#define NTL_POSIX_OP_UPDATE_SIGNAL_MASK 29u
#define NTL_POSIX_OP_SET_SIGNAL_DISPOSITION 30u
#define NTL_POSIX_OP_GET_PENDING_SIGNALS 31u
#define NTL_POSIX_OP_SEND_SIGNAL 32u
#define NTL_POSIX_OP_SET_ALARM 33u
#define NTL_POSIX_OP_EXEC_COMMIT 34u
#define NTL_POSIX_OP_VFORK_BEGIN 35u
#define NTL_POSIX_OP_VFORK_ATTACH 36u
#define NTL_POSIX_OP_VFORK_CANCEL 37u
#define NTL_POSIX_OP_VFORK_EXIT 38u
#define NTL_POSIX_TRANSACTION_NONE 0u
#define NTL_POSIX_TRANSACTION_SPAWN 1u
#define NTL_POSIX_TRANSACTION_EXEC 2u
#define NTL_POSIX_PROCESS_STATE_NONE 0u
#define NTL_POSIX_PROCESS_STATE_RUNNING 1u
#define NTL_POSIX_PROCESS_STATE_EXITED 2u
#define NTL_POSIX_PROCESS_STATE_NONE 0u
#define NTL_POSIX_PROCESS_STATE_CONSTRUCTING 1u
#define NTL_POSIX_PROCESS_STATE_RUNNING 2u
#define NTL_POSIX_PROCESS_STATE_EXEC_PREPARING 3u
#define NTL_POSIX_PROCESS_STATE_EXEC_COMMITTING 4u
#define NTL_POSIX_PROCESS_STATE_EXITED 5u
#define NTL_POSIX_PROCESS_STATE_VFORK_BORROWED 6u
#define NTL_POSIX_LOOKUP_NONE 0u
#define NTL_POSIX_LOOKUP_BY_ID 1u
@@ -68,8 +91,12 @@
#define NTL_POSIX_OPEN_STATUS_ACCMODE 0x0003u
#define NTL_POSIX_OPEN_STATUS_APPEND 0x0400u
#define NTL_POSIX_OPEN_STATUS_NONBLOCK 0x0800u
#define NTL_POSIX_OPEN_CREATE 0x0040u
#define NTL_POSIX_OPEN_TRUNCATE 0x0200u
#define NTL_POSIX_OPEN_STATUS_VALID_MASK \
(NTL_POSIX_OPEN_STATUS_ACCMODE | NTL_POSIX_OPEN_STATUS_APPEND | NTL_POSIX_OPEN_STATUS_NONBLOCK)
#define NTL_POSIX_SPAWN_OPEN_VALID_MASK \
(NTL_POSIX_OPEN_STATUS_VALID_MASK | NTL_POSIX_OPEN_CREATE | NTL_POSIX_OPEN_TRUNCATE)
#define NTL_POSIX_SHARED_OPEN_MAGIC 0x31444F50u
#define NTL_POSIX_SHARED_OPEN_VERSION 2u
@@ -80,6 +107,30 @@
#define NTL_POSIX_FD_DESCRIPTOR_CLOEXEC 0x00000001u
#define NTL_POSIX_FD_HANDLE_NONE UINT32_MAX
#define NTL_POSIX_CONSTRUCT_VECTOR_ARGUMENT 1u
#define NTL_POSIX_CONSTRUCT_VECTOR_ENVIRONMENT 2u
#define NTL_POSIX_CONSTRUCT_VECTOR_CHUNK_FINAL 0x00000001u
#define NTL_POSIX_CONSTRUCT_VECTOR_MAX 1024u
#define NTL_POSIX_CONSTRUCT_DATA_MAX (1024u * 1024u)
#define NTL_POSIX_SPAWN_ACTION_CLOSE 1u
#define NTL_POSIX_SPAWN_ACTION_DUP2 2u
#define NTL_POSIX_SPAWN_ACTION_OPEN 3u
#define NTL_POSIX_SPAWN_ACTION_MAX 64u
#define NTL_POSIX_SPAWN_ATTR_SETPGROUP 0x00000001u
#define NTL_POSIX_SPAWN_ATTR_SETSIGMASK 0x00000002u
#define NTL_POSIX_SPAWN_ATTR_SETSIGDEF 0x00000004u
#define NTL_POSIX_WAIT_NOHANG 0x00000001u
#define NTL_POSIX_SIGNAL_DISPOSITION_DEFAULT 0u
#define NTL_POSIX_SIGNAL_DISPOSITION_IGNORE 1u
#define NTL_POSIX_SIGNAL_DISPOSITION_CAUGHT 2u
#define NTL_POSIX_SIGNAL_ROUTE_PROCESS 1u
#define NTL_POSIX_SIGNAL_ROUTE_THREAD 2u
typedef struct NTL_POSIX_FD_MANIFEST_ENTRY {
int32_t Descriptor;
uint32_t DescriptorFlags;
@@ -111,11 +162,11 @@ typedef struct NTL_POSIX_SHARED_OPEN_DESCRIPTION {
uint64_t SharedObjectData;
} NTL_POSIX_SHARED_OPEN_DESCRIPTION;
// Future server-owned spawn/exec builders place this opaque personality payload
// Server-owned spawn/exec builders place this opaque personality payload
// in the generic userspace process-loader startup data. Zero token/PID/generation
// means an ordinary process is self-registering for the first time.
#define NTL_POSIX_BOOTSTRAP_MAGIC 0x3258504Eu
#define NTL_POSIX_BOOTSTRAP_VERSION 2u
#define NTL_POSIX_BOOTSTRAP_VERSION 3u
typedef struct NTL_POSIX_BOOTSTRAP_DATA {
uint32_t Magic;
@@ -126,6 +177,8 @@ typedef struct NTL_POSIX_BOOTSTRAP_DATA {
uint32_t PosixPid;
uint32_t Generation;
uint64_t FdInheritanceToken;
uint64_t InitialSignalMask;
uint64_t IgnoredSignals;
} NTL_POSIX_BOOTSTRAP_DATA;
// Requests remain fixed-size through P4 open-description control. Later spawn/exec
@@ -155,7 +208,31 @@ typedef struct NTL_POSIX_REQUEST {
uint32_t FdInheritanceIndex;
uint32_t FdInheritanceCount;
uint32_t FdInheritanceFlags;
uint32_t Reserved[2];
uint32_t ConstructionVectorKind;
uint32_t ConstructionVectorIndex;
uint32_t ConstructionVectorOffset;
uint32_t ConstructionVectorFlags;
uint32_t SpawnActionKind;
int32_t SpawnFileDescriptor;
int32_t SpawnNewFileDescriptor;
uint32_t SpawnOpenFlags;
uint32_t SpawnOpenMode;
uint32_t SpawnAttributeFlags;
uint64_t SpawnSignalMask;
uint64_t SpawnSignalDefaultMask;
int32_t WaitPid;
uint32_t WaitOptions;
int32_t SignalTargetPid;
int32_t SignalNumber;
uint32_t SignalDisposition;
uint32_t SignalReserved;
uint64_t SignalMask;
uint64_t SignalApcRoutine;
uint32_t AlarmSeconds;
uint32_t AlarmReserved;
uint64_t VforkToken;
int32_t VforkExitCode;
uint32_t VforkReserved;
NTL_POSIX_FD_MANIFEST_ENTRY FdManifest[NTL_POSIX_FD_INHERIT_MAX];
char Name[NTL_POSIX_IDENTITY_NAME_MAX + 1u];
char Path[SYS_PATH_MAX + 1u];
@@ -175,10 +252,19 @@ typedef struct NTL_POSIX_REPLY {
uint32_t ActiveTransactions;
uint32_t TransactionCapacity;
uint32_t PosixPid;
uint32_t SpawnedPosixPid;
int32_t WaitedPosixPid;
int32_t ExitCode;
uint32_t NativeGeneration;
uint32_t ProcessState;
uint32_t RegisteredProcesses;
uint32_t RegisteredOpenDescriptions;
uint32_t RegisteredThreads;
uint32_t SignalReserved;
uint64_t PendingSignals;
uint32_t AlarmRemainingSeconds;
uint32_t AlarmReserved;
uint64_t VforkToken;
uint32_t OpenDescriptionType;
uint32_t OpenStatusFlags;
uint64_t OpenDescriptionId;
@@ -217,3 +303,8 @@ typedef struct NTL_POSIX_REPLY {
char Shell[NTL_POSIX_IDENTITY_SHELL_MAX + 1u];
char CurrentDirectory[SYS_PATH_MAX + 1u];
} NTL_POSIX_REPLY;
_Static_assert(sizeof(NTL_POSIX_REQUEST) <= SYS_PORT_MAX_INLINE_BYTES,
"POSIX request must fit in one Port inline payload.");
_Static_assert(sizeof(NTL_POSIX_REPLY) <= SYS_PORT_MAX_INLINE_BYTES,
"POSIX reply must fit in one Port inline payload.");
code/public/ntlite/posix_signal.h
+29
View File
@@ -0,0 +1,29 @@
// POSIX personality signal identifiers shared with posixsrv.
#pragma once
#include <stdint.h>
#define NTL_POSIX_SIGNAL_HUP 1
#define NTL_POSIX_SIGNAL_INT 2
#define NTL_POSIX_SIGNAL_QUIT 3
#define NTL_POSIX_SIGNAL_ILL 4
#define NTL_POSIX_SIGNAL_ABRT 5
#define NTL_POSIX_SIGNAL_FPE 6
#define NTL_POSIX_SIGNAL_KILL 7
#define NTL_POSIX_SIGNAL_SEGV 8
#define NTL_POSIX_SIGNAL_PIPE 9
#define NTL_POSIX_SIGNAL_ALRM 10
#define NTL_POSIX_SIGNAL_TERM 11
#define NTL_POSIX_SIGNAL_USR1 12
#define NTL_POSIX_SIGNAL_USR2 13
#define NTL_POSIX_SIGNAL_CHLD 14
#define NTL_POSIX_SIGNAL_MAX 14
#define NTL_POSIX_SIGNAL_BIT(signalNumber) (1ull << ((uint32_t)(signalNumber) - 1u))
#define NTL_POSIX_SIGNAL_VALID_MASK ((1ull << NTL_POSIX_SIGNAL_MAX) - 1ull)
#define NTL_POSIX_SIGNAL_UNBLOCKABLE_MASK NTL_POSIX_SIGNAL_BIT(NTL_POSIX_SIGNAL_KILL)
static inline int NtlPosixSignalValid(int signalNumber) {
return signalNumber >= NTL_POSIX_SIGNAL_HUP && signalNumber <= NTL_POSIX_SIGNAL_MAX;
}
code/public/ntlite/process_loader.h
+61
View File
@@ -13,6 +13,13 @@
#define NTL_PROCESS_LOAD_FLAG_NONE 0x00000000u
#define NTL_PROCESS_STARTUP_DATA_MAX 1024u
// Generic userspace process vectors. The builder copies every view into the
// child loader block; callers retain ownership of the source arrays/strings.
typedef struct NTL_PROCESS_STRING_VECTOR {
const SYS_STRING_VIEW* Entries;
uint32_t Count;
} NTL_PROCESS_STRING_VECTOR;
// Describes one source capability to duplicate into a constructing child.
typedef struct NTL_PROCESS_STARTUP_CAPABILITY {
uint32_t Tag;
@@ -21,6 +28,35 @@ typedef struct NTL_PROCESS_STARTUP_CAPABILITY {
uint32_t DuplicateFlags;
} NTL_PROCESS_STARTUP_CAPABILITY;
// Reusable inert-process builder used by policy services such as posixsrv.
// The storage is opaque to callers; initialize it to zero before first use.
#define NTL_PROCESS_BUILDER_OPAQUE_WORDS 160u
typedef struct NTL_PROCESS_BUILDER {
uintptr_t Opaque[NTL_PROCESS_BUILDER_OPAQUE_WORDS];
} NTL_PROCESS_BUILDER;
// Describes construction of an inert child. Unlike NTL_CREATE_PROCESS_AT_REQUEST,
// preparation does not start the process and therefore has no output handle field.
typedef struct NTL_PROCESS_BUILDER_REQUEST {
uint32_t Size;
uint32_t Flags;
SYS_HANDLE RootHandle;
SYS_STRING_VIEW Path;
SYS_STRING_VIEW CommandLine;
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;
NTL_PROCESS_STRING_VECTOR Arguments;
NTL_PROCESS_STRING_VECTOR Environment;
const void* StartupData;
size_t StartupDataSize;
} NTL_PROCESS_BUILDER_REQUEST;
// Creates and starts one PE32+ process entirely through the userspace image loader.
typedef struct NTL_CREATE_PROCESS_AT_REQUEST {
uint32_t Size;
@@ -37,6 +73,8 @@ typedef struct NTL_CREATE_PROCESS_AT_REQUEST {
void* ResolveContext;
const NTL_PROCESS_STARTUP_CAPABILITY* StartupCapabilities;
uint32_t StartupCapabilityCount;
NTL_PROCESS_STRING_VECTOR Arguments;
NTL_PROCESS_STRING_VECTOR Environment;
// Optional opaque userspace bootstrap data copied into the child's read-only loader block.
const void* StartupData;
size_t StartupDataSize;
@@ -59,6 +97,8 @@ typedef struct NTL_CREATE_SYSTEM_PROCESS_REQUEST {
void* ResolveContext;
const NTL_PROCESS_STARTUP_CAPABILITY* StartupCapabilities;
uint32_t StartupCapabilityCount;
NTL_PROCESS_STRING_VECTOR Arguments;
NTL_PROCESS_STRING_VECTOR Environment;
// Optional opaque userspace bootstrap data copied into the child's read-only loader block.
const void* StartupData;
size_t StartupDataSize;
@@ -73,11 +113,32 @@ typedef struct NTL_CREATE_SYSTEM_PROCESS_REQUEST {
#define NTL_PROCESS_LOADER_API
#endif
// Prepares an inert child and materializes its image/dependencies/bootstrap data.
// imageFile may be SYS_HANDLE_INVALID to open request->Path relative to RootHandle.
NTL_PROCESS_LOADER_API KSTATUS NtlProcessBuilderPrepare(NTL_PROCESS_BUILDER* builder,
const NTL_PROCESS_BUILDER_REQUEST* request,
SYS_HANDLE imageFile);
// Returns the prepared process capability without transferring ownership from the builder.
// The borrowed handle remains valid only until Start or Abort consumes the builder.
NTL_PROCESS_LOADER_API KSTATUS NtlProcessBuilderGetProcessHandle(NTL_PROCESS_BUILDER* builder,
SYS_HANDLE* processHandleOut);
// Starts a prepared child and returns the retained process capability to the caller.
// On success the builder is consumed and reset to the empty state.
NTL_PROCESS_LOADER_API KSTATUS NtlProcessBuilderStart(NTL_PROCESS_BUILDER* builder,
SYS_HANDLE* processHandleOut);
// Aborts a prepared child, terminating the inert native process and releasing loader state.
NTL_PROCESS_LOADER_API void NtlProcessBuilderAbort(NTL_PROCESS_BUILDER* builder);
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);
// Copies the optional opaque startup data supplied by the userspace process builder.
NTL_PROCESS_LOADER_API KSTATUS NtlGetProcessStartupData(void* buffer,
size_t bufferSize,
size_t* sizeOut);
// Returns one immutable argument/environment entry from the current loader block.
NTL_PROCESS_LOADER_API KSTATUS NtlGetProcessArgumentCount(uint32_t* countOut);
NTL_PROCESS_LOADER_API KSTATUS NtlGetProcessArgument(uint32_t index, SYS_STRING_VIEW* argumentOut);
NTL_PROCESS_LOADER_API KSTATUS NtlGetProcessEnvironmentCount(uint32_t* countOut);
NTL_PROCESS_LOADER_API KSTATUS NtlGetProcessEnvironment(uint32_t index, SYS_STRING_VIEW* entryOut);
#undef NTL_PROCESS_LOADER_API
code/public/ntlite/security.h
+3
View File
@@ -64,3 +64,6 @@ typedef struct SYS_DERIVE_SECURITY_CONTEXT_REQUEST {
KSTATUS SysDeriveSecurityContext(const SYS_DERIVE_SECURITY_CONTEXT_REQUEST* request);
KSTATUS SysQuerySecurityContext(SYS_HANDLE contextHandle, SYS_SECURITY_CONTEXT_INFO* infoOut);
// Opens the exact immutable security context currently assigned to a process capability.
KSTATUS SysOpenProcessSecurityContext(SYS_HANDLE processHandle, SYS_RIGHTS desiredRights,
SYS_HANDLE* contextHandleOut);
code/public/ntlite/syscall.h
+30
View File
@@ -112,6 +112,11 @@ typedef void (*SYS_USER_APC_ROUTINE)(void* normalContext,
SYS_IO_STATUS_BLOCK* iosb,
uint64_t information);
// Generic user APC callback shape used by capability-scoped direct notifications.
typedef void (*SYS_USER_APC_CALLBACK)(void* normalContext,
void* systemArgument1,
void* systemArgument2);
typedef struct SYS_FILE_IO_REQUEST {
uint32_t Size;
SYS_HANDLE FileHandle;
@@ -663,6 +668,25 @@ typedef struct SYS_CREATE_THREAD_REQUEST {
#define SYS_CREATE_THREAD_FLAG_NONE 0x00000000u
#define SYS_CREATE_THREAD_FLAG_SUSPENDED 0x00000001u
// Describes one generic user APC queued through a thread capability. The
// routine and arguments are interpreted in the target thread's user address
// space; possession of SYS_THREAD_RIGHT_NOTIFY is the authority boundary.
// INTERRUPT permits delivery on the next user return without requiring an
// alertable wait; ordinary APCs retain alertable-wait delivery semantics.
#define SYS_QUEUE_USER_APC_FLAG_NONE 0x00000000u
#define SYS_QUEUE_USER_APC_FLAG_INTERRUPT 0x00000001u
typedef struct SYS_QUEUE_USER_APC_REQUEST {
uint32_t Size;
SYS_HANDLE ThreadHandle;
SYS_USER_APC_CALLBACK Routine;
void* NormalContext;
void* SystemArgument1;
void* SystemArgument2;
uint32_t Flags;
uint32_t Reserved;
} SYS_QUEUE_USER_APC_REQUEST;
void SysExitProcess(int32_t exitCode);
void SysExitThread(int32_t exitCode);
KSTATUS SysCreateProcessObject(const SYS_CREATE_PROCESS_OBJECT_REQUEST* request);
@@ -813,9 +837,12 @@ typedef struct SYS_PROCESS_INFO {
KSTATUS SysGetProcessList(SYS_PROCESS_INFO* processesOut, size_t maxCount, size_t* countOut);
KSTATUS SysGetProcessPid(SYS_HANDLE handle, uint32_t* pidOut);
KSTATUS SysGetThreadList(uint32_t pid, SYS_THREAD_INFO* threadsOut, size_t maxCount, size_t* countOut);
KSTATUS SysGetThreadTid(SYS_HANDLE handle, uint32_t* tidOut);
KSTATUS SysCreateThread(const SYS_CREATE_THREAD_REQUEST* request);
KSTATUS SysOpenCurrentThread(SYS_RIGHTS desiredAccess, SYS_HANDLE* handleOut);
KSTATUS SysResumeThread(SYS_HANDLE threadHandle, uint32_t* previousSuspendCountOut);
KSTATUS SysResumeThreadAndWait(SYS_HANDLE threadHandle, uint32_t* previousSuspendCountOut);
uint32_t SysGetCurrentTid(void);
uint32_t SysGetCurrentPid(void);
KSTATUS SysSetThreadPriority(uint32_t priority);
@@ -845,6 +872,7 @@ KSTATUS SysCancelTimer(SYS_HANDLE timerHandle);
// waitable timer handles. A zero-length sleep yields the processor.
KSTATUS SysSleep(uint64_t ms);
KSTATUS SysSetUserApcDispatcher(void* dispatcher);
KSTATUS SysQueueUserApc(const SYS_QUEUE_USER_APC_REQUEST* request);
// Returns from the active user APC dispatcher. The frame pointer must identify
// the kernel-issued frame for the current delivery; it is not a general resume
@@ -982,6 +1010,8 @@ 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 SysOpenPortPeerProcess(SYS_HANDLE endpointHandle, SYS_RIGHTS desiredRights,
SYS_HANDLE* processHandleOut);
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);
code/public/posix/errno.h
+1
View File
@@ -44,6 +44,7 @@
#define EINPROGRESS 34
#define ETIMEDOUT 35
#define ECANCELED 36
#define E2BIG 37
NTL_POSIX_API int* __ntl_posix_errno_location(void);
code/public/posix/ntlite_posix_profile.def
+23 -23
View File
@@ -3,17 +3,17 @@
// PLANNED belongs to the active target, and UNSUPPORTED is deliberately rejected.
POSIX_API(getpid, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(getppid, POSIX1990_DEFERRED_PROCESS_MODEL, PLANNED)
POSIX_API(wait, POSIX1990_DEFERRED_PROCESS_MODEL, PLANNED)
POSIX_API(waitpid, POSIX1990_DEFERRED_PROCESS_MODEL, PARTIAL)
POSIX_API(_exit, POSIX1990_REQUIRED, PLANNED)
POSIX_API(getppid, POSIX1990_DEFERRED_PROCESS_MODEL, IMPLEMENTED)
POSIX_API(wait, POSIX1990_DEFERRED_PROCESS_MODEL, IMPLEMENTED)
POSIX_API(waitpid, POSIX1990_DEFERRED_PROCESS_MODEL, IMPLEMENTED)
POSIX_API(_exit, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(fork, POSIX1990_DEFERRED_PROCESS_MODEL, UNSUPPORTED)
POSIX_API(vfork, POSIX1990_DEFERRED_PROCESS_MODEL, PLANNED)
POSIX_API(vfork, POSIX1990_DEFERRED_PROCESS_MODEL, IMPLEMENTED)
POSIX_API(execl, POSIX1990_DEFERRED_PROCESS_MODEL, DEFERRED)
POSIX_API(execle, POSIX1990_DEFERRED_PROCESS_MODEL, DEFERRED)
POSIX_API(execlp, POSIX1990_DEFERRED_PROCESS_MODEL, DEFERRED)
POSIX_API(execv, POSIX1990_DEFERRED_PROCESS_MODEL, DEFERRED)
POSIX_API(execve, POSIX1990_DEFERRED_PROCESS_MODEL, PLANNED)
POSIX_API(execve, POSIX1990_DEFERRED_PROCESS_MODEL, IMPLEMENTED)
POSIX_API(execvp, POSIX1990_DEFERRED_PROCESS_MODEL, DEFERRED)
POSIX_API(read, POSIX1990_REQUIRED, IMPLEMENTED)
@@ -65,27 +65,27 @@ POSIX_API(setsid, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(uname, POSIX1990_REQUIRED, PLANNED)
POSIX_API(time, POSIX1990_REQUIRED, PLANNED)
POSIX_API(times, POSIX1990_REQUIRED, PLANNED)
POSIX_API(getenv, POSIX1990_REQUIRED, PLANNED)
POSIX_API(getenv, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(ctermid, POSIX1990_REQUIRED, PLANNED)
POSIX_API(ttyname, POSIX1990_REQUIRED, PLANNED)
POSIX_API(isatty, POSIX1990_REQUIRED, PLANNED)
POSIX_API(sysconf, POSIX1990_REQUIRED, PLANNED)
POSIX_API(sigemptyset, POSIX1990_REQUIRED, PLANNED)
POSIX_API(sigfillset, POSIX1990_REQUIRED, PLANNED)
POSIX_API(sigaddset, POSIX1990_REQUIRED, PLANNED)
POSIX_API(sigdelset, POSIX1990_REQUIRED, PLANNED)
POSIX_API(sigismember, POSIX1990_REQUIRED, PLANNED)
POSIX_API(sigaction, POSIX1990_REQUIRED, PLANNED)
POSIX_API(sigprocmask, POSIX1990_REQUIRED, PLANNED)
POSIX_API(sigpending, POSIX1990_REQUIRED, PLANNED)
POSIX_API(sigsuspend, POSIX1990_REQUIRED, PLANNED)
POSIX_API(kill, POSIX1990_REQUIRED, PLANNED)
POSIX_API(alarm, POSIX1990_REQUIRED, PLANNED)
POSIX_API(pause, POSIX1990_REQUIRED, PLANNED)
POSIX_API(sleep, POSIX1990_REQUIRED, PLANNED)
POSIX_API(signal, POSIX1990_REQUIRED, PLANNED)
POSIX_API(raise, POSIX1990_REQUIRED, PLANNED)
POSIX_API(sigemptyset, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(sigfillset, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(sigaddset, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(sigdelset, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(sigismember, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(sigaction, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(sigprocmask, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(sigpending, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(sigsuspend, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(kill, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(alarm, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(pause, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(sleep, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(signal, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(raise, POSIX1990_REQUIRED, IMPLEMENTED)
POSIX_API(cfgetispeed, POSIX1990_REQUIRED, PLANNED)
POSIX_API(cfgetospeed, POSIX1990_REQUIRED, PLANNED)
@@ -119,7 +119,7 @@ POSIX_API(pthread_mutex_destroy, NTL_POSIX_EXTENSION, IMPLEMENTED)
POSIX_API(pthread_mutex_lock, NTL_POSIX_EXTENSION, IMPLEMENTED)
POSIX_API(pthread_mutex_trylock, NTL_POSIX_EXTENSION, IMPLEMENTED)
POSIX_API(pthread_mutex_unlock, NTL_POSIX_EXTENSION, IMPLEMENTED)
POSIX_API(posix_spawn, NTL_POSIX_EXTENSION, PARTIAL)
POSIX_API(posix_spawn, NTL_POSIX_EXTENSION, IMPLEMENTED)
POSIX_API(socket, NTL_POSIX_EXTENSION, IMPLEMENTED)
POSIX_API(bind, NTL_POSIX_EXTENSION, IMPLEMENTED)
POSIX_API(listen, NTL_POSIX_EXTENSION, IMPLEMENTED)
code/public/posix/signal.h
+47 -1
View File
@@ -1,8 +1,54 @@
// POSIX signal type declarations reserved for the next runtime phase.
// POSIX signal declarations for the nt-lite POSIX personality.
#pragma once
#include <stdint.h>
#include <sys/types.h>
#include <ntlite_posix_api.h>
#include <ntlite/posix_signal.h>
typedef uint64_t sigset_t;
typedef int sig_atomic_t;
typedef void (*sighandler_t)(int);
#define SIGHUP NTL_POSIX_SIGNAL_HUP
#define SIGINT NTL_POSIX_SIGNAL_INT
#define SIGQUIT NTL_POSIX_SIGNAL_QUIT
#define SIGILL NTL_POSIX_SIGNAL_ILL
#define SIGABRT NTL_POSIX_SIGNAL_ABRT
#define SIGFPE NTL_POSIX_SIGNAL_FPE
#define SIGKILL NTL_POSIX_SIGNAL_KILL
#define SIGSEGV NTL_POSIX_SIGNAL_SEGV
#define SIGPIPE NTL_POSIX_SIGNAL_PIPE
#define SIGALRM NTL_POSIX_SIGNAL_ALRM
#define SIGTERM NTL_POSIX_SIGNAL_TERM
#define SIGUSR1 NTL_POSIX_SIGNAL_USR1
#define SIGUSR2 NTL_POSIX_SIGNAL_USR2
#define SIGCHLD NTL_POSIX_SIGNAL_CHLD
#define SIG_DFL ((sighandler_t)0)
#define SIG_IGN ((sighandler_t)1)
#define SIG_ERR ((sighandler_t)-1)
#define SIG_BLOCK 1
#define SIG_UNBLOCK 2
#define SIG_SETMASK 3
struct sigaction {
sighandler_t sa_handler;
sigset_t sa_mask;
int sa_flags;
};
NTL_POSIX_API int sigemptyset(sigset_t* set);
NTL_POSIX_API int sigfillset(sigset_t* set);
NTL_POSIX_API int sigaddset(sigset_t* set, int signalNumber);
NTL_POSIX_API int sigdelset(sigset_t* set, int signalNumber);
NTL_POSIX_API int sigismember(const sigset_t* set, int signalNumber);
NTL_POSIX_API int sigaction(int signalNumber, const struct sigaction* action, struct sigaction* oldAction);
NTL_POSIX_API int sigprocmask(int how, const sigset_t* set, sigset_t* oldSet);
NTL_POSIX_API int sigpending(sigset_t* set);
NTL_POSIX_API int sigsuspend(const sigset_t* set);
NTL_POSIX_API int kill(pid_t pid, int signalNumber);
NTL_POSIX_API sighandler_t signal(int signalNumber, sighandler_t handler);
NTL_POSIX_API int raise(int signalNumber);
code/public/posix/spawn.h
+53 -2
View File
@@ -2,11 +2,62 @@
#pragma once
#include <stdint.h>
#include <sys/types.h>
#include <signal.h>
#include <ntlite_posix_api.h>
typedef void* posix_spawn_file_actions_t;
typedef void* posix_spawnattr_t;
#define POSIX_SPAWN_SETPGROUP 0x00000001u
#define POSIX_SPAWN_SETSIGMASK 0x00000002u
#define POSIX_SPAWN_SETSIGDEF 0x00000004u
#define POSIX_SPAWN_FILE_ACTION_CAPACITY 64u
#define NTL_POSIX_SPAWN_FILE_ACTION_NONE 0u
#define NTL_POSIX_SPAWN_FILE_ACTION_CLOSE 1u
#define NTL_POSIX_SPAWN_FILE_ACTION_DUP2 2u
#define NTL_POSIX_SPAWN_FILE_ACTION_OPEN 3u
typedef struct posix_spawn_file_action_entry {
uint32_t Type;
int FileDescriptor;
int NewFileDescriptor;
int OpenFlags;
mode_t Mode;
char* Path;
} posix_spawn_file_action_entry;
typedef struct posix_spawn_file_actions_t {
uint32_t Initialized;
uint32_t Count;
posix_spawn_file_action_entry Entries[POSIX_SPAWN_FILE_ACTION_CAPACITY];
} posix_spawn_file_actions_t;
typedef struct posix_spawnattr_t {
uint32_t Initialized;
uint32_t Flags;
pid_t ProcessGroup;
sigset_t SignalMask;
sigset_t SignalDefault;
} posix_spawnattr_t;
NTL_POSIX_API int posix_spawn_file_actions_init(posix_spawn_file_actions_t* actions);
NTL_POSIX_API int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t* actions);
NTL_POSIX_API int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t* actions, int fd);
NTL_POSIX_API int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t* actions,
int fd, int newFd);
NTL_POSIX_API int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t* actions, int fd,
const char* path, int openFlags, mode_t mode);
NTL_POSIX_API int posix_spawnattr_init(posix_spawnattr_t* attributes);
NTL_POSIX_API int posix_spawnattr_destroy(posix_spawnattr_t* attributes);
NTL_POSIX_API int posix_spawnattr_getflags(const posix_spawnattr_t* attributes, short* flags);
NTL_POSIX_API int posix_spawnattr_setflags(posix_spawnattr_t* attributes, short flags);
NTL_POSIX_API int posix_spawnattr_getpgroup(const posix_spawnattr_t* attributes, pid_t* pgroup);
NTL_POSIX_API int posix_spawnattr_setpgroup(posix_spawnattr_t* attributes, pid_t pgroup);
NTL_POSIX_API int posix_spawnattr_getsigmask(const posix_spawnattr_t* attributes, sigset_t* mask);
NTL_POSIX_API int posix_spawnattr_setsigmask(posix_spawnattr_t* attributes, const sigset_t* mask);
NTL_POSIX_API int posix_spawnattr_getsigdefault(const posix_spawnattr_t* attributes, sigset_t* set);
NTL_POSIX_API int posix_spawnattr_setsigdefault(posix_spawnattr_t* attributes, const sigset_t* set);
NTL_POSIX_API int posix_spawn(pid_t* pid, const char* path,
const posix_spawn_file_actions_t* fileActions,
code/public/posix/stdlib.h
+2
View File
@@ -9,4 +9,6 @@ NTL_POSIX_API void* malloc(size_t size);
NTL_POSIX_API void* calloc(size_t count, size_t size);
NTL_POSIX_API void* realloc(void* pointer, size_t size);
NTL_POSIX_API void free(void* pointer);
NTL_POSIX_API char* getenv(const char* name);
NTL_POSIX_API extern char** environ;
NTL_POSIX_API void exit(int status);
code/public/posix/sys/wait.h
+4 -1
View File
@@ -1,10 +1,13 @@
// POSIX wait declarations for nt-lite spawn associations.
// POSIX child wait declarations backed by posixsrv process records.
#pragma once
#include <sys/types.h>
#include <ntlite_posix_api.h>
#define WNOHANG 0x00000001
#define WEXITSTATUS(status) (((status) >> 8) & 0xff)
#define WIFEXITED(status) (((status) & 0x7f) == 0)
NTL_POSIX_API pid_t wait(int* status);
NTL_POSIX_API pid_t waitpid(pid_t pid, int* status, int options);
code/public/posix/unistd.h
+7
View File
@@ -26,6 +26,13 @@ NTL_POSIX_API int chdir(const char* path);
NTL_POSIX_API char* getcwd(char* buffer, size_t size);
NTL_POSIX_API int unlink(const char* path);
NTL_POSIX_API pid_t getpid(void);
NTL_POSIX_API pid_t getppid(void);
NTL_POSIX_API pid_t vfork(void);
NTL_POSIX_API int execve(const char* path, char* const argv[], char* const envp[]);
NTL_POSIX_API void _exit(int status);
NTL_POSIX_API unsigned int alarm(unsigned int seconds);
NTL_POSIX_API int pause(void);
NTL_POSIX_API unsigned int sleep(unsigned int seconds);
NTL_POSIX_API uid_t getuid(void);
NTL_POSIX_API uid_t geteuid(void);
NTL_POSIX_API gid_t getgid(void);