[NTOS:EX/KE][HALX86] Add support for NUMPROC, BOOTPROC, MAXPROC, ONECPU boot switches (#6024)

These SMP-specific switches allow to test and control configurations
with various number of CPUs on multiprocessor systems.

- NUMPROC: maximum number of logical processors that can be started
(including dynamically, not currently supported by ReactOS) at run-time.

- BOOTPROC: maximum number of logical processors that can be started at
boot-time.

- MAXPROC: forces the OS to report the maximum possible number of CPUs
as existing on the system.

- ONECPU (MP HAL-only boot switch): causes the HAL to only use one
(the boot) CPU on a multiprocessor system. Attempting to start other
processors will fail.

For more information, see:
https://www.geoffchappell.com/notes/windows/boot/bcd/osloader/numproc.htm
https://www.geoffchappell.com/notes/windows/license/processors.htm
https://rmscrypt.wordpress.com/2011/02/
https://codeinsecurity.wordpress.com/2022/04/07/cpu-socket-and-core-count-limits-in-windows-10-and-how-to-remove-them/

Generic references about BOOT.INI switches:
https://learn.microsoft.com/en-us/windows-hardware/drivers/devtest/boot-options-in-a-boot-ini-file
https://www.itprotoday.com/cloud-computing/what-switches-can-be-used-bootini
http://franck.kiechel.free.fr/dbr_eng/BootIni.htm

References about BCD options:
https://learn.microsoft.com/en-us/windows-hardware/drivers/devtest/bcdedit--set
http://www.mistyprojects.co.uk/documents/BCDEdit/files/commands.6.1.7601.htm#TYPES%20OSLOADER

hal/halx86/generic/halinit.c

···
 
 /* GLOBALS *******************************************************************/
 
+//#ifdef CONFIG_SMP // FIXME: Reenable conditional once HAL is consistently compiled for SMP mode
+BOOLEAN HalpOnlyBootProcessor;
+//#endif
 BOOLEAN HalpPciLockSettings;
 
 /* PRIVATE FUNCTIONS *********************************************************/
···
     {
         /* Read the command line */
         PCSTR CommandLine = LoaderBlock->LoadOptions;
+
+//#ifdef CONFIG_SMP // FIXME: Reenable conditional once HAL is consistently compiled for SMP mode
+        /* Check whether we should only start one CPU */
+        if (strstr(CommandLine, "ONECPU"))
+            HalpOnlyBootProcessor = TRUE;
+//#endif
 
         /* Check if PCI is locked */
         if (strstr(CommandLine, "PCILOCK"))

hal/halx86/smp/i386/spinup.c

···
 
 /* GLOBALS *******************************************************************/
 
+extern BOOLEAN HalpOnlyBootProcessor;
+
 extern PPROCESSOR_IDENTITY HalpProcessorIdentity;
 extern PHYSICAL_ADDRESS HalpLowStubPhysicalAddress;
 extern PVOID HalpLowStub;
···
     _In_ PLOADER_PARAMETER_BLOCK LoaderBlock,
     _In_ PKPROCESSOR_STATE ProcessorState)
 {
+    /* Bail out if we only use the boot CPU */
+    if (HalpOnlyBootProcessor)
+        return FALSE;
+
+    /* Bail out if we have started all available CPUs */
     if (HalpStartedProcessorCount == HalpApicInfoTable.ProcessorCount)
         return FALSE;
 

ntoskrnl/ex/init.c

···
     }
 
 #ifdef CONFIG_SMP
+    /*
+     * IMPORTANT NOTE:
+     * Because ReactOS is a "nice" OS, we do not care _at all_
+     * about any number of registered/licensed processors:
+     * no usage of KeRegisteredProcessors nor KeLicensedProcessors.
+     */
+    if (CommandLine)
+    {
+        PSTR Option;
+
+        /* Check for NUMPROC: maximum number of logical processors
+         * that can be started (including dynamically) at run-time */
+        Option = strstr(CommandLine, "NUMPROC");
+        if (Option) Option = strstr(Option, "=");
+        if (Option) KeNumprocSpecified = atol(Option + 1);
+
+        /* Check for BOOTPROC (NT6+ and ReactOS): maximum number
+         * of logical processors that can be started at boot-time */
+        Option = strstr(CommandLine, "BOOTPROC");
+        if (Option) Option = strstr(Option, "=");
+        if (Option) KeBootprocSpecified = atol(Option + 1);
+
+        /* Check for MAXPROC (NT6+ and ReactOS): forces the kernel to report
+         * as existing the maximum number of processors that can be handled */
+        if (strstr(CommandLine, "MAXPROC"))
+            KeMaximumProcessors = MAXIMUM_PROCESSORS;
+    }
+
     /* Start Application Processors */
     KeStartAllProcessors();
 #endif

ntoskrnl/include/internal/ke.h

···
     IN ULONG Length
 );
 
-extern KAFFINITY KeActiveProcessors;
 extern PKNMI_HANDLER_CALLBACK KiNmiCallbackListHead;
 extern KSPIN_LOCK KiNmiCallbackListLock;
 extern PVOID KeUserApcDispatcher;
···
 extern USHORT KeProcessorLevel;
 extern USHORT KeProcessorRevision;
 extern ULONG64 KeFeatureBits;
+extern KAFFINITY KeActiveProcessors;
+extern PKPRCB KiProcessorBlock[];
+#ifdef CONFIG_SMP
+extern ULONG KeMaximumProcessors;
+extern ULONG KeNumprocSpecified;
+extern ULONG KeBootprocSpecified;
+#endif
 extern KNODE KiNode0;
 extern PKNODE KeNodeBlock[1];
 extern UCHAR KeNumberNodes;
···
 extern LIST_ENTRY KiProcessInSwapListHead, KiProcessOutSwapListHead;
 extern LIST_ENTRY KiStackInSwapListHead;
 extern KEVENT KiSwapEvent;
-extern PKPRCB KiProcessorBlock[];
 extern KAFFINITY KiIdleSummary;
 extern PVOID KeUserApcDispatcher;
 extern PVOID KeUserCallbackDispatcher;

ntoskrnl/ke/i386/mproc.c

···
 /* INCLUDES *****************************************************************/
 
 #include <ntoskrnl.h>
+
 #define NDEBUG
 #include <debug.h>
 
···
 KeStartAllProcessors(VOID)
 {
     PVOID KernelStack, DPCStack;
-    ULONG ProcessorCount = 0;
     PAPINFO APInfo;
+    ULONG ProcessorCount;
+    ULONG MaximumProcessors;
 
-    while (TRUE)
+    /* NOTE: NT6+ HAL exports HalEnumerateProcessors() and
+     * HalQueryMaximumProcessorCount() that help determining
+     * the number of detected processors on the system. */
+    MaximumProcessors = KeMaximumProcessors;
+
+    /* Limit the number of processors we can start at run-time */
+    if (KeNumprocSpecified)
+        MaximumProcessors = min(MaximumProcessors, KeNumprocSpecified);
+
+    /* Limit also the number of processors we can start during boot-time */
+    if (KeBootprocSpecified)
+        MaximumProcessors = min(MaximumProcessors, KeBootprocSpecified);
+
+    // TODO: Support processor nodes
+
+    /* Start ProcessorCount at 1 because we already have the boot CPU */
+    for (ProcessorCount = 1; ProcessorCount < MaximumProcessors; ++ProcessorCount)
     {
-        ProcessorCount++;
         KernelStack = NULL;
         DPCStack = NULL;
 

ntoskrnl/ke/processor.c

···
 
 /* GLOBALS *******************************************************************/
 
+KAFFINITY KeActiveProcessors = 0;
+
+/* Number of processors */
 CCHAR KeNumberProcessors = 0;
-KAFFINITY KeActiveProcessors = 0;
+
+#ifdef CONFIG_SMP
+
+/* Theoretical maximum number of processors that can be handled.
+ * Set once at run-time. Returned by KeQueryMaximumProcessorCount(). */
+ULONG KeMaximumProcessors = MAXIMUM_PROCESSORS;
+
+/* Maximum number of logical processors that can be started
+ * (including dynamically) at run-time. If 0: do not perform checks. */
+ULONG KeNumprocSpecified = 0;
+
+/* Maximum number of logical processors that can be started
+ * at boot-time. If 0: do not perform checks. */
+ULONG KeBootprocSpecified = 0;
+
+#endif // CONFIG_SMP
 
 /* FUNCTIONS *****************************************************************/