redo boot around an explicit system volume and fixed kernel/HAL images, redo volumes and filesystem paths around capabilities instead of drive numbers and kernel CWD state, add a capability/security model with derived and revocable handles and security contexts, add port IPC and rssrv to manage the userspace resource namespace and publish the system volume, move process, dll and path loading to userspace and add process builder syscalls, init now supervises rssrv and the session process, redo the syscall ABI around request structs and four arguments, add a volume manager and proper partition arrival/removal handling so FAT and NTFS mount dynamically, clean up the HAL/DDK boundary so drivers don't depend on HAL internals, save fpu state properly now, the serial driver doesn't hang on a missing port, fix AHCI startup races, fix timeout accounting, fix shared mmap writeback, more smoke tests
This commit is contained in:
maksw committed
1 parent
4add6789ba
commit
f882d339fb
232 files changed
+20934
-8898
No files matched your search
@@ -0,0 +1,308 @@
|
||||
// Native resource-service client. Resource naming policy stays in rssrv; this file only speaks its Port protocol.
|
||||
|
||||
#include <ntlite/resource.h>
|
||||
#include <ntlite/service.h>
|
||||
#include <ntlite/syscall.h>
|
||||
#include <string.h>
|
||||
|
||||
// Validates the canonical global resource-path syntax understood by rssrv.
|
||||
static KSTATUS NtlValidateResourcePath(SYS_STRING_VIEW path) {
|
||||
if (!path.Data || path.Length < 2 || path.Length > NTL_RESOURCE_PATH_MAX || path.Data[0] != '/')
|
||||
return NTLSTATUS_INVALID_PARAMETER;
|
||||
if (path.Data[path.Length - 1] == '/')
|
||||
return NTLSTATUS_INVALID_PARAMETER;
|
||||
|
||||
size_t componentStart = 1;
|
||||
for (size_t i = 1; i <= path.Length; ++i) {
|
||||
if (i < path.Length) {
|
||||
char c = path.Data[i];
|
||||
if (c == '\\' || c == '\0')
|
||||
return NTLSTATUS_INVALID_PARAMETER;
|
||||
if (c != '/')
|
||||
continue;
|
||||
}
|
||||
|
||||
size_t componentLength = i - componentStart;
|
||||
if (componentLength == 0 ||
|
||||
(componentLength == 1 && path.Data[componentStart] == '.') ||
|
||||
(componentLength == 2 && path.Data[componentStart] == '.' && path.Data[componentStart + 1] == '.'))
|
||||
return NTLSTATUS_INVALID_PARAMETER;
|
||||
componentStart = i + 1;
|
||||
}
|
||||
return NTLSTATUS_SUCCESS;
|
||||
}
|
||||
|
||||
// Builds one inline request header and path payload.
|
||||
static KSTATUS NtlBuildResourceRequest(uint8_t* buffer,
|
||||
size_t bufferSize,
|
||||
uint32_t operation,
|
||||
SYS_STRING_VIEW path,
|
||||
SYS_RIGHTS rights,
|
||||
SYS_RIGHTS exportRights,
|
||||
uint32_t kind,
|
||||
uint32_t* lengthOut) {
|
||||
KSTATUS status = NtlValidateResourcePath(path);
|
||||
if (!KSUCCESS(status) || !buffer || !lengthOut)
|
||||
return KSUCCESS(status) ? NTLSTATUS_INVALID_PARAMETER : status;
|
||||
size_t total = sizeof(NTL_RESOURCE_REQUEST) + path.Length;
|
||||
if (total > bufferSize || total > SYS_PORT_MAX_INLINE_BYTES)
|
||||
return NTLSTATUS_BUFFER_TOO_SMALL;
|
||||
|
||||
NTL_RESOURCE_REQUEST header;
|
||||
memset(&header, 0, sizeof(header));
|
||||
header.Size = sizeof(header);
|
||||
header.Version = NTL_RESOURCE_PROTOCOL_VERSION;
|
||||
header.Operation = operation;
|
||||
header.Flags = NTL_RESOURCE_FLAG_NONE;
|
||||
header.Rights = rights;
|
||||
header.ExportRights = exportRights;
|
||||
header.Kind = kind;
|
||||
header.PathLength = (uint32_t)path.Length;
|
||||
memcpy(buffer, &header, sizeof(header));
|
||||
memcpy(buffer + sizeof(header), path.Data, path.Length);
|
||||
*lengthOut = (uint32_t)total;
|
||||
return NTLSTATUS_SUCCESS;
|
||||
}
|
||||
|
||||
// Executes one resource request and validates its fixed protocol reply.
|
||||
static KSTATUS NtlCallResource(SYS_HANDLE session,
|
||||
const void* requestPayload,
|
||||
uint32_t requestLength,
|
||||
const SYS_PORT_HANDLE_TRANSFER* requestHandles,
|
||||
uint32_t requestHandleCount,
|
||||
NTL_RESOURCE_REPLY* replyOut,
|
||||
SYS_HANDLE* replyHandleOut) {
|
||||
if (session == SYS_HANDLE_INVALID || !requestPayload || !requestLength || !replyOut)
|
||||
return NTLSTATUS_INVALID_PARAMETER;
|
||||
|
||||
NTL_RESOURCE_REPLY reply;
|
||||
memset(&reply, 0, sizeof(reply));
|
||||
SYS_PORT_MESSAGE_INFO info;
|
||||
memset(&info, 0, sizeof(info));
|
||||
info.Size = sizeof(info);
|
||||
SYS_HANDLE replyHandle = SYS_HANDLE_INVALID;
|
||||
|
||||
SYS_CALL_PORT_REQUEST call;
|
||||
memset(&call, 0, sizeof(call));
|
||||
call.Size = sizeof(call);
|
||||
call.EndpointHandle = session;
|
||||
call.Flags = SYS_PORT_FLAG_NONE;
|
||||
call.RequestPayload = requestPayload;
|
||||
call.RequestLength = requestLength;
|
||||
call.RequestHandles = requestHandles;
|
||||
call.RequestHandleCount = requestHandleCount;
|
||||
call.ReplyPayload = &reply;
|
||||
call.ReplyCapacity = sizeof(reply);
|
||||
call.ReplyHandlesOut = replyHandleOut ? &replyHandle : (SYS_HANDLE*)0;
|
||||
call.ReplyHandleCapacity = replyHandleOut ? 1u : 0u;
|
||||
call.ReplyInfoOut = &info;
|
||||
call.TimeoutMilliseconds = SYS_PORT_TIMEOUT_INFINITE;
|
||||
KSTATUS status = SysCallPort(&call);
|
||||
if (!KSUCCESS(status))
|
||||
return status;
|
||||
|
||||
if (info.Type != SYS_PORT_MESSAGE_REPLY || info.PayloadLength != sizeof(reply) ||
|
||||
reply.Size != sizeof(reply) || reply.Version != NTL_RESOURCE_PROTOCOL_VERSION) {
|
||||
if (replyHandle != SYS_HANDLE_INVALID) (void)SysCloseHandle(replyHandle);
|
||||
return NTLSTATUS_FAILURE;
|
||||
}
|
||||
if ((!replyHandleOut && info.HandleCount != 0) || (replyHandleOut && info.HandleCount > 1)) {
|
||||
if (replyHandle != SYS_HANDLE_INVALID) (void)SysCloseHandle(replyHandle);
|
||||
return NTLSTATUS_FAILURE;
|
||||
}
|
||||
|
||||
*replyOut = reply;
|
||||
if (replyHandleOut) *replyHandleOut = replyHandle;
|
||||
return NTLSTATUS_SUCCESS;
|
||||
}
|
||||
|
||||
// Connects to the registered resource listener.
|
||||
KSTATUS NtlResourceConnect(SYS_HANDLE* sessionOut) {
|
||||
if (!sessionOut) return NTLSTATUS_INVALID_PARAMETER;
|
||||
*sessionOut = SYS_HANDLE_INVALID;
|
||||
SYS_CONNECT_SYSTEM_SERVICE_REQUEST request;
|
||||
memset(&request, 0, sizeof(request));
|
||||
request.Size = sizeof(request);
|
||||
request.ServiceId = SYS_SERVICE_RESOURCE;
|
||||
request.EndpointHandleOut = sessionOut;
|
||||
return SysConnectSystemService(&request);
|
||||
}
|
||||
|
||||
// Resolves the canonical /SystemRoot resource and closes the transient resource session.
|
||||
KSTATUS NtlResourceOpenSystemRoot(SYS_RIGHTS desiredRights, SYS_HANDLE* handleOut) {
|
||||
if (!desiredRights || !handleOut) return NTLSTATUS_INVALID_PARAMETER;
|
||||
*handleOut = SYS_HANDLE_INVALID;
|
||||
SYS_HANDLE session = SYS_HANDLE_INVALID;
|
||||
KSTATUS status = NtlResourceConnect(&session);
|
||||
if (!KSUCCESS(status)) return status;
|
||||
status = NtlResourceLookup(session, SysSvFromCstr("/SystemRoot"), desiredRights, handleOut);
|
||||
(void)NtlResourceClose(session);
|
||||
return status;
|
||||
}
|
||||
|
||||
// Connects through one delegated resource-listener capability.
|
||||
KSTATUS NtlResourceConnectListener(SYS_HANDLE listenerHandle, SYS_HANDLE* sessionOut) {
|
||||
if (listenerHandle == SYS_HANDLE_INVALID || !sessionOut)
|
||||
return NTLSTATUS_INVALID_PARAMETER;
|
||||
*sessionOut = SYS_HANDLE_INVALID;
|
||||
SYS_CONNECT_PORT_REQUEST request;
|
||||
memset(&request, 0, sizeof(request));
|
||||
request.Size = sizeof(request);
|
||||
request.ListenerHandle = listenerHandle;
|
||||
request.Flags = SYS_PORT_CONNECT_FLAG_NONE;
|
||||
request.EndpointHandleOut = sessionOut;
|
||||
return SysConnectPort(&request);
|
||||
}
|
||||
|
||||
// Looks up one resource and requests an attenuated alias of its bound capability.
|
||||
KSTATUS NtlResourceLookup(SYS_HANDLE session,
|
||||
SYS_STRING_VIEW path,
|
||||
SYS_RIGHTS desiredRights,
|
||||
SYS_HANDLE* handleOut) {
|
||||
if (!desiredRights || !handleOut) return NTLSTATUS_INVALID_PARAMETER;
|
||||
*handleOut = SYS_HANDLE_INVALID;
|
||||
uint8_t payload[sizeof(NTL_RESOURCE_REQUEST) + NTL_RESOURCE_PATH_MAX];
|
||||
uint32_t payloadLength = 0;
|
||||
KSTATUS status = NtlBuildResourceRequest(payload, sizeof(payload), NTL_RESOURCE_OP_LOOKUP,
|
||||
path, desiredRights, 0, NTL_RESOURCE_KIND_INVALID,
|
||||
&payloadLength);
|
||||
if (!KSUCCESS(status)) return status;
|
||||
|
||||
NTL_RESOURCE_REPLY reply;
|
||||
SYS_HANDLE handle = SYS_HANDLE_INVALID;
|
||||
status = NtlCallResource(session, payload, payloadLength, (const SYS_PORT_HANDLE_TRANSFER*)0, 0,
|
||||
&reply, &handle);
|
||||
if (!KSUCCESS(status)) return status;
|
||||
if (reply.Operation != NTL_RESOURCE_OP_LOOKUP) {
|
||||
if (handle != SYS_HANDLE_INVALID) (void)SysCloseHandle(handle);
|
||||
return NTLSTATUS_FAILURE;
|
||||
}
|
||||
if (!KSUCCESS(reply.Status)) {
|
||||
if (handle != SYS_HANDLE_INVALID) (void)SysCloseHandle(handle);
|
||||
return reply.Status;
|
||||
}
|
||||
if (handle == SYS_HANDLE_INVALID) return NTLSTATUS_FAILURE;
|
||||
*handleOut = handle;
|
||||
return NTLSTATUS_SUCCESS;
|
||||
}
|
||||
|
||||
// Queries one bound resource kind without transferring authority.
|
||||
KSTATUS NtlResourceQuery(SYS_HANDLE session, SYS_STRING_VIEW path, uint32_t* kindOut) {
|
||||
if (!kindOut) return NTLSTATUS_INVALID_PARAMETER;
|
||||
*kindOut = NTL_RESOURCE_KIND_INVALID;
|
||||
uint8_t payload[sizeof(NTL_RESOURCE_REQUEST) + NTL_RESOURCE_PATH_MAX];
|
||||
uint32_t payloadLength = 0;
|
||||
KSTATUS status = NtlBuildResourceRequest(payload, sizeof(payload), NTL_RESOURCE_OP_QUERY,
|
||||
path, 0, 0, NTL_RESOURCE_KIND_INVALID, &payloadLength);
|
||||
if (!KSUCCESS(status)) return status;
|
||||
|
||||
NTL_RESOURCE_REPLY reply;
|
||||
status = NtlCallResource(session, payload, payloadLength, (const SYS_PORT_HANDLE_TRANSFER*)0, 0,
|
||||
&reply, (SYS_HANDLE*)0);
|
||||
if (!KSUCCESS(status)) return status;
|
||||
if (reply.Operation != NTL_RESOURCE_OP_QUERY) return NTLSTATUS_FAILURE;
|
||||
if (!KSUCCESS(reply.Status)) return reply.Status;
|
||||
*kindOut = reply.Kind;
|
||||
return NTLSTATUS_SUCCESS;
|
||||
}
|
||||
|
||||
// Resolves the longest bound resource prefix into one traversal capability.
|
||||
KSTATUS NtlResourceResolve(SYS_HANDLE session,
|
||||
SYS_STRING_VIEW path,
|
||||
uint32_t flags,
|
||||
SYS_HANDLE* rootHandleOut,
|
||||
uint32_t* kindOut,
|
||||
uint32_t* resolvedLengthOut) {
|
||||
if (!rootHandleOut || !kindOut || !resolvedLengthOut ||
|
||||
(flags & ~NTL_RESOURCE_RESOLVE_FLAG_MODIFY) != 0)
|
||||
return NTLSTATUS_INVALID_PARAMETER;
|
||||
*rootHandleOut = SYS_HANDLE_INVALID;
|
||||
*kindOut = NTL_RESOURCE_KIND_INVALID;
|
||||
*resolvedLengthOut = 0;
|
||||
|
||||
uint8_t payload[sizeof(NTL_RESOURCE_REQUEST) + NTL_RESOURCE_PATH_MAX];
|
||||
uint32_t payloadLength = 0;
|
||||
KSTATUS status = NtlBuildResourceRequest(payload, sizeof(payload), NTL_RESOURCE_OP_RESOLVE,
|
||||
path, 0, 0, NTL_RESOURCE_KIND_INVALID, &payloadLength);
|
||||
if (!KSUCCESS(status)) return status;
|
||||
((NTL_RESOURCE_REQUEST*)payload)->Flags = flags;
|
||||
|
||||
NTL_RESOURCE_REPLY reply;
|
||||
SYS_HANDLE handle = SYS_HANDLE_INVALID;
|
||||
status = NtlCallResource(session, payload, payloadLength, (const SYS_PORT_HANDLE_TRANSFER*)0, 0,
|
||||
&reply, &handle);
|
||||
if (!KSUCCESS(status)) return status;
|
||||
if (reply.Operation != NTL_RESOURCE_OP_RESOLVE || reply.Flags != flags) {
|
||||
if (handle != SYS_HANDLE_INVALID) (void)SysCloseHandle(handle);
|
||||
return NTLSTATUS_FAILURE;
|
||||
}
|
||||
if (!KSUCCESS(reply.Status)) {
|
||||
if (handle != SYS_HANDLE_INVALID) (void)SysCloseHandle(handle);
|
||||
return reply.Status;
|
||||
}
|
||||
if (handle == SYS_HANDLE_INVALID || reply.Kind == NTL_RESOURCE_KIND_INVALID ||
|
||||
reply.ResolvedLength < 2 || reply.ResolvedLength > path.Length ||
|
||||
(reply.ResolvedLength != path.Length && path.Data[reply.ResolvedLength] != '/')) {
|
||||
if (handle != SYS_HANDLE_INVALID) (void)SysCloseHandle(handle);
|
||||
return NTLSTATUS_FAILURE;
|
||||
}
|
||||
|
||||
*rootHandleOut = handle;
|
||||
*kindOut = reply.Kind;
|
||||
*resolvedLengthOut = reply.ResolvedLength;
|
||||
return NTLSTATUS_SUCCESS;
|
||||
}
|
||||
|
||||
// Binds an explicitly attenuated capability into an administrative resource session.
|
||||
KSTATUS NtlResourceBind(SYS_HANDLE session,
|
||||
SYS_STRING_VIEW path,
|
||||
uint32_t kind,
|
||||
SYS_HANDLE resourceHandle,
|
||||
SYS_RIGHTS namespaceRights,
|
||||
SYS_RIGHTS exportRights) {
|
||||
if (kind == NTL_RESOURCE_KIND_INVALID || resourceHandle == SYS_HANDLE_INVALID ||
|
||||
!(namespaceRights & SYS_RIGHT_TRANSFER) || !exportRights ||
|
||||
(exportRights & ~namespaceRights) != 0)
|
||||
return NTLSTATUS_INVALID_PARAMETER;
|
||||
uint8_t payload[sizeof(NTL_RESOURCE_REQUEST) + NTL_RESOURCE_PATH_MAX];
|
||||
uint32_t payloadLength = 0;
|
||||
KSTATUS status = NtlBuildResourceRequest(payload, sizeof(payload), NTL_RESOURCE_OP_BIND,
|
||||
path, namespaceRights, exportRights, kind, &payloadLength);
|
||||
if (!KSUCCESS(status)) return status;
|
||||
|
||||
SYS_PORT_HANDLE_TRANSFER transfer;
|
||||
transfer.Handle = resourceHandle;
|
||||
transfer.DesiredRights = namespaceRights;
|
||||
transfer.Flags = SYS_PORT_TRANSFER_FLAG_NONE;
|
||||
NTL_RESOURCE_REPLY reply;
|
||||
status = NtlCallResource(session, payload, payloadLength, &transfer, 1, &reply, (SYS_HANDLE*)0);
|
||||
if (!KSUCCESS(status)) return status;
|
||||
if (reply.Operation != NTL_RESOURCE_OP_BIND) return NTLSTATUS_FAILURE;
|
||||
return reply.Status;
|
||||
}
|
||||
|
||||
// Removes one resource name through an administrative session.
|
||||
KSTATUS NtlResourceUnbind(SYS_HANDLE session, SYS_STRING_VIEW path) {
|
||||
uint8_t payload[sizeof(NTL_RESOURCE_REQUEST) + NTL_RESOURCE_PATH_MAX];
|
||||
uint32_t payloadLength = 0;
|
||||
KSTATUS status = NtlBuildResourceRequest(payload, sizeof(payload), NTL_RESOURCE_OP_UNBIND,
|
||||
path, 0, 0, NTL_RESOURCE_KIND_INVALID, &payloadLength);
|
||||
if (!KSUCCESS(status)) return status;
|
||||
|
||||
NTL_RESOURCE_REPLY reply;
|
||||
status = NtlCallResource(session, payload, payloadLength, (const SYS_PORT_HANDLE_TRANSFER*)0, 0,
|
||||
&reply, (SYS_HANDLE*)0);
|
||||
if (!KSUCCESS(status)) return status;
|
||||
if (reply.Operation != NTL_RESOURCE_OP_UNBIND) return NTLSTATUS_FAILURE;
|
||||
return reply.Status;
|
||||
}
|
||||
|
||||
// Disconnects and closes one resource session.
|
||||
KSTATUS NtlResourceClose(SYS_HANDLE session) {
|
||||
if (session == SYS_HANDLE_INVALID) return NTLSTATUS_INVALID_HANDLE;
|
||||
KSTATUS disconnect = SysDisconnectPort(session);
|
||||
KSTATUS close = SysCloseHandle(session);
|
||||
if (!KSUCCESS(disconnect) && disconnect != NTLSTATUS_PORT_DISCONNECTED)
|
||||
return disconnect;
|
||||
return close;
|
||||
}
|
||||
Reference in new issue
Block a user