replace ad hoc driver loading with a proper driver manager, new DDK, new PnP manager with device matching, asynchronous startup, resource ownership and removal, add shared PCI capability helpers, replace typed, rigid services with a proper service manager, implement proper system shutdown and restart, shutting down unloads drivers and shuts down services, add simple power button, remove heavyweight boot self-tests and SMP stress runs, add monotonic timestamps to kernel debug output, fruitless USB and PS/2 fixes, make test builds opt in.

code/user/system/rssrv/rssrv.c

@@ -2,10 +2,13 @@
 
 #include "rssrv_internal.h"
 #include <ntlite/exception.h>
+#include <ntlite/desktop.h>
+#include <ntlite/posix_service.h>
 #include <ntlite/service.h>
 #include <ntlite/service_control.h>
 #include <ntlite/syscall.h>
 #include <stdint.h>
+#include <ntlite/bootstrap_capabilities.h>
 #include <string.h>
 
 static RSSRV_STATE gRssrv;
@@ -37,12 +40,14 @@ static KSTATUS RssrvAcceptControl(SYS_HANDLE controlListener, SYS_HANDLE* endpoi
     return SysAcceptPort(&accept);
 }
 
-// Sends service readiness and delegates init-only namespace and DWM-session bootstrap capabilities.
+// Exports only the capabilities consumed by dependent services. Init treats
+// the names as opaque; RSSRV owns the underlying namespace policies.
 static KSTATUS RssrvSendReady(SYS_HANDLE controlEndpoint,
-                              const RSSRV_RESOURCE_SERVICE* resource,
-                              const RSSRV_SESSION_STATE* session) {
-    if (!resource || !session || resource->AdminListener == SYS_HANDLE_INVALID ||
-        session->DwmListener == SYS_HANDLE_INVALID)
+                              const RSSRV_SESSION_STATE* session,
+                              SYS_HANDLE desktopPublisher,
+                              SYS_HANDLE posixPublisher) {
+    if (!session || session->DwmListener == SYS_HANDLE_INVALID ||
+        desktopPublisher == SYS_HANDLE_INVALID || posixPublisher == SYS_HANDLE_INVALID)
         return NTLSTATUS_INVALID_PARAMETER;
 
     NTL_SERVICE_CONTROL_MESSAGE message;
@@ -50,18 +55,23 @@ static KSTATUS RssrvSendReady(SYS_HANDLE controlEndpoint,
     message.Size = sizeof(message);
     message.Version = NTL_SERVICE_CONTROL_VERSION;
     message.Operation = NTL_SERVICE_CONTROL_READY;
-    message.ExportCount = 2u;
+    message.ExportCount = 3u;
     message.Status = NTLSTATUS_SUCCESS;
+    if (!NtlServiceControlNameExport(&message, 0u, "session-control") ||
+        !NtlServiceControlNameExport(&message, 1u, "desktop-publisher") ||
+        !NtlServiceControlNameExport(&message, 2u, "posix-publisher"))
+        return NTLSTATUS_FAILURE;
 
-    SYS_PORT_HANDLE_TRANSFER transfers[2];
+    SYS_PORT_HANDLE_TRANSFER transfers[3];
     memset(transfers, 0, sizeof(transfers));
-    transfers[0].Handle = resource->AdminListener;
-    transfers[0].DesiredRights = SYS_RIGHT_QUERY | SYS_PORT_RIGHT_CONNECT;
-    transfers[0].Flags = SYS_PORT_TRANSFER_FLAG_NONE;
-    transfers[1].Handle = session->DwmListener;
-    // Init must transfer this private listener once more into DWM. DWM itself receives only connect/query rights.
-    transfers[1].DesiredRights = SYS_RIGHT_DUPLICATE | SYS_RIGHT_TRANSFER | SYS_RIGHT_QUERY | SYS_PORT_RIGHT_CONNECT;
-    transfers[1].Flags = SYS_PORT_TRANSFER_FLAG_NONE;
+    transfers[0].Handle = session->DwmListener;
+    transfers[1].Handle = desktopPublisher;
+    transfers[2].Handle = posixPublisher;
+    for (uint32_t i = 0; i < 3u; ++i) {
+        transfers[i].DesiredRights = SYS_RIGHT_DUPLICATE | SYS_RIGHT_TRANSFER |
+                                     SYS_RIGHT_QUERY | SYS_PORT_RIGHT_CONNECT;
+        transfers[i].Flags = SYS_PORT_TRANSFER_FLAG_NONE;
+    }
 
     SYS_SEND_PORT_REQUEST send;
     memset(&send, 0, sizeof(send));
@@ -71,7 +81,7 @@ static KSTATUS RssrvSendReady(SYS_HANDLE controlEndpoint,
     send.Payload = &message;
     send.PayloadLength = sizeof(message);
     send.Handles = transfers;
-    send.HandleCount = 2u;
+    send.HandleCount = 3u;
     send.TimeoutMilliseconds = SYS_PORT_TIMEOUT_INFINITE;
     return SysSendPort(&send);
 }
@@ -99,8 +109,7 @@ static void RssrvControlLoop(SYS_HANDLE controlEndpoint) {
             return;
         if (info.Type != SYS_PORT_MESSAGE_NOTIFICATION || info.HandleCount != 0 ||
             info.PayloadLength != sizeof(message) || message.Size != sizeof(message) ||
-            message.Version != NTL_SERVICE_CONTROL_VERSION || message.ExportCount != 0 ||
-            message.Reserved[0] != 0 || message.Reserved[1] != 0 || message.Reserved[2] != 0)
+            !NtlServiceControlValid(&message, NTL_SERVICE_CONTROL_STOP, 0u))
             continue;
         if (message.Operation == NTL_SERVICE_CONTROL_STOP)
             return;
@@ -154,19 +163,19 @@ void _start(void) {
     memset(&security, 0, sizeof(security));
     security.Size = sizeof(security);
     status = SysQuerySecurityContext(SYS_SECURITY_CONTEXT_CURRENT, &security);
-    if (!KSUCCESS(status) || security.EffectivePrivileges != SYS_PRIV_SYSTEM_SERVICE_REGISTER ||
-        security.DelegablePrivileges != 0 || security.ServiceClaims != SYS_SERVICE_CLAIM_RESOURCE ||
-        security.DelegableServiceClaims != 0)
+    if (!KSUCCESS(status) || security.EffectivePrivileges != 0 ||
+        security.DelegablePrivileges != 0)
         RssrvExit(2);
 
-    SYS_HANDLE systemVolume = SysGetStartupCapability(SYS_STARTUP_CAP_SYSTEM_VOLUME_NAMESPACE);
-    SYS_HANDLE controlListener = SysGetStartupCapability(SYS_STARTUP_CAP_SERVICE_CONTROL);
-    SYS_HANDLE volumeManager = SysGetStartupCapability(SYS_STARTUP_CAP_VOLUME_MANAGER);
-    SYS_HANDLE inputManager = SysGetStartupCapability(SYS_STARTUP_CAP_INPUT_MANAGER);
-    SYS_HANDLE displayManager = SysGetStartupCapability(SYS_STARTUP_CAP_DISPLAY_MANAGER);
+    SYS_HANDLE systemVolume = SysGetStartupCapability(NTL_BOOT_CAP_NAMESPACE_ROOT);
+    SYS_HANDLE controlListener = SysGetStartupCapability("service.control");
+    SYS_HANDLE volumeManager = SysGetStartupCapability(NTL_BOOT_CAP_VOLUME_MANAGER);
+    SYS_HANDLE inputManager = SysGetStartupCapability(NTL_BOOT_CAP_INPUT_MANAGER);
+    SYS_HANDLE displayManager = SysGetStartupCapability(NTL_BOOT_CAP_DISPLAY_POLICY);
+    SYS_HANDLE registrationAuthority = SysGetStartupCapability(NTL_BOOT_CAP_RESOURCE_REGISTRATION);
     if (systemVolume == SYS_HANDLE_INVALID || controlListener == SYS_HANDLE_INVALID ||
         volumeManager == SYS_HANDLE_INVALID || inputManager == SYS_HANDLE_INVALID ||
-        displayManager == SYS_HANDLE_INVALID)
+        displayManager == SYS_HANDLE_INVALID || registrationAuthority == SYS_HANDLE_INVALID)
         RssrvExit(3);
 
     uint32_t systemVolumeId = 0;
@@ -232,13 +241,22 @@ void _start(void) {
     status = RssrvVolumesStartWorker(&gRssrv.Volumes);
     if (!KSUCCESS(status)) RssrvExit(11);
 
-    status = SysRegisterSystemService(SYS_SERVICE_RESOURCE, gRssrv.Resource.PublicListener);
+    status = SysRegisterSystemService(registrationAuthority, gRssrv.Resource.PublicListener);
     if (!KSUCCESS(status)) RssrvExit(12);
-    status = RssrvSendReady(controlEndpoint, &gRssrv.Resource, &gRssrv.Session);
+    SYS_HANDLE desktopPublisher = SYS_HANDLE_INVALID;
+    SYS_HANDLE posixPublisher = SYS_HANDLE_INVALID;
+    status = RssrvResourceCreatePublisher(&gRssrv.Resource, NTL_DESKTOP_SERVICE_PATH,
+                                          &desktopPublisher);
+    if (!KSUCCESS(status)) RssrvExit(13);
+    status = RssrvResourceCreatePublisher(&gRssrv.Resource, NTL_POSIX_SERVICE_PATH,
+                                          &posixPublisher);
+    if (!KSUCCESS(status)) RssrvExit(13);
+    status = RssrvSendReady(controlEndpoint, &gRssrv.Session,
+                            desktopPublisher, posixPublisher);
     if (!KSUCCESS(status)) RssrvExit(13);
 
     RssrvControlLoop(controlEndpoint);
-    (void)SysUnregisterSystemService(SYS_SERVICE_RESOURCE, gRssrv.Resource.PublicListener);
+    (void)SysUnregisterSystemService(registrationAuthority, gRssrv.Resource.PublicListener);
     (void)SysDisconnectPort(controlEndpoint);
     (void)SysCloseHandle(controlEndpoint);
     RssrvExit(0);