reactos/ntoskrnl/ke/krnlinit.c

   1 /*
   2  * PROJECT:         ReactOS Kernel
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            ntoskrnl/ke/krnlinit.c
   5  * PURPOSE:         Portable part of kernel initialization
   6  * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include <ntoskrnl.h>
  12 #define NDEBUG
  13 #include <debug.h>
  14 #include <internal/napi.h>
  15
  16 /* GLOBALS *******************************************************************/
  17
  18 /* System call count */
  19 ULONG KiServiceLimit = NUMBER_OF_SYSCALLS;
  20
  21 /* ARC Loader Block */
  22 PLOADER_PARAMETER_BLOCK KeLoaderBlock;
  23
  24 /* PRCB Array */
  25 PKPRCB KiProcessorBlock[MAXIMUM_PROCESSORS];
  26
  27 /* NUMA Node Support */
  28 KNODE KiNode0;
  29 PKNODE KeNodeBlock[1];
  30 UCHAR KeNumberNodes = 1;
  31 UCHAR KeProcessNodeSeed;
  32
  33 /* Initial Process and Thread */
  34 ETHREAD KiInitialThread;
  35 EPROCESS KiInitialProcess;
  36
  37 /* System-defined Spinlocks */
  38 KSPIN_LOCK KiDispatcherLock;
  39 KSPIN_LOCK MmPfnLock;
  40 KSPIN_LOCK MmSystemSpaceLock;
  41 KSPIN_LOCK CcBcbSpinLock;
  42 KSPIN_LOCK CcMasterSpinLock;
  43 KSPIN_LOCK CcVacbSpinLock;
  44 KSPIN_LOCK CcWorkQueueSpinLock;
  45 KSPIN_LOCK NonPagedPoolLock;
  46 KSPIN_LOCK MmNonPagedPoolLock;
  47 KSPIN_LOCK IopCancelSpinLock;
  48 KSPIN_LOCK IopVpbSpinLock;
  49 KSPIN_LOCK IopDatabaseLock;
  50 KSPIN_LOCK IopCompletionLock;
  51 KSPIN_LOCK NtfsStructLock;
  52 KSPIN_LOCK AfdWorkQueueSpinLock;
  53 KSPIN_LOCK KiTimerTableLock[16];
  54 KSPIN_LOCK KiReverseStallIpiLock;
  55
  56 /* FUNCTIONS *****************************************************************/
  57
  58 VOID
  59 NTAPI
  60 KiInitSystem(VOID)
  61 {
  62     ULONG i;
  63
  64     /* Initialize Bugcheck Callback data */
  65     InitializeListHead(&BugcheckCallbackListHead);
  66     InitializeListHead(&BugcheckReasonCallbackListHead);
  67     KeInitializeSpinLock(&BugCheckCallbackLock);
  68
  69     /* Initialize the Timer Expiration DPC */
  70     KeInitializeDpc(&KiExpireTimerDpc, KiExpireTimers, NULL);
  71     KeSetTargetProcessorDpc(&KiExpireTimerDpc, 0);
  72
  73     /* Initialize Profiling data */
  74     KeInitializeSpinLock(&KiProfileLock);
  75     InitializeListHead(&KiProfileListHead);
  76     InitializeListHead(&KiProfileSourceListHead);
  77
  78     /* Loop the timer table */
  79     for (i = 0; i < TIMER_TABLE_SIZE; i++)
  80     {
  81         /* Initialize the list and entries */
  82         InitializeListHead(&KiTimerTableListHead[i].Entry);
  83         KiTimerTableListHead[i].Time.HighPart = 0xFFFFFFFF;
  84         KiTimerTableListHead[i].Time.LowPart = 0;
  85     }
  86
  87     /* Initialize old-style list */
  88     InitializeListHead(&KiTimerListHead);
  89
  90     /* Initialize the Swap event and all swap lists */
  91     KeInitializeEvent(&KiSwapEvent, SynchronizationEvent, FALSE);
  92     InitializeListHead(&KiProcessInSwapListHead);
  93     InitializeListHead(&KiProcessOutSwapListHead);
  94     InitializeListHead(&KiStackInSwapListHead);
  95
  96     /* Initialize the mutex for generic DPC calls */
  97     KeInitializeMutex(&KiGenericCallDpcMutex, 0);
  98
  99     /* Initialize the syscall table */
 100     KeServiceDescriptorTable[0].Base = MainSSDT;
 101     KeServiceDescriptorTable[0].Count = NULL;
 102     KeServiceDescriptorTable[0].Limit = KiServiceLimit;
 103     KeServiceDescriptorTable[1].Limit = 0;
 104     KeServiceDescriptorTable[0].Number = MainSSPT;
 105
 106     /* Copy the the current table into the shadow table for win32k */
 107     RtlCopyMemory(KeServiceDescriptorTableShadow,
 108                   KeServiceDescriptorTable,
 109                   sizeof(KeServiceDescriptorTable));
 110 }
 111
 112 LARGE_INTEGER
 113 NTAPI
 114 KiComputeReciprocal(IN LONG Divisor,
 115                     OUT PUCHAR Shift)
 116 {
 117     LARGE_INTEGER Reciprocal = {{0}};
 118     LONG BitCount = 0, Remainder = 1;
 119
 120     /* Start by calculating the remainder */
 121     while (Reciprocal.HighPart >= 0)
 122     {
 123         /* Increase the loop (bit) count */
 124         BitCount++;
 125
 126         /* Calculate the current fraction */
 127         Reciprocal.HighPart = (Reciprocal.HighPart << 1) |
 128                               (Reciprocal.LowPart >> 31);
 129         Reciprocal.LowPart <<= 1;
 130
 131         /* Double the remainder and see if we went past the divisor */
 132         Remainder <<= 1;
 133         if (Remainder >= Divisor)
 134         {
 135             /* Set the low-bit and calculate the new remainder */
 136             Remainder -= Divisor;
 137             Reciprocal.LowPart |= 1;
 138         }
 139     }
 140
 141     /* Check if we have a remainder */
 142     if (Remainder)
 143     {
 144         /* Check if the current fraction value is too large */
 145         if ((Reciprocal.LowPart == 0xFFFFFFFF) &&
 146             (Reciprocal.HighPart == 0xFFFFFFFF))
 147         {
 148             /* Set the high bit and reduce the bit count */
 149             Reciprocal.LowPart = 0;
 150             Reciprocal.HighPart = 0x80000000;
 151             BitCount--;
 152         }
 153         else
 154         {
 155             /* Check if only the lowest bits got too large */
 156             if (Reciprocal.LowPart == 0xFFFFFFFF)
 157             {
 158                 /* Reset them and increase the high bits instead */
 159                 Reciprocal.LowPart = 0;
 160                 Reciprocal.HighPart++;
 161             }
 162             else
 163             {
 164                 /* All is well, increase the low bits */
 165                 Reciprocal.LowPart++;
 166             }
 167         }
 168     }
 169
 170     /* Now calculate the actual shift and return the reciprocal */
 171     *Shift = (UCHAR)BitCount - 64;
 172     return Reciprocal;
 173 }
 174
 175 VOID
 176 NTAPI
 177 KiInitSpinLocks(IN PKPRCB Prcb,
 178                 IN CCHAR Number)
 179 {
 180     ULONG i;
 181
 182     /* Initialize Dispatcher Fields */
 183     Prcb->QueueIndex = 1;
 184     Prcb->ReadySummary = 0;
 185     Prcb->DeferredReadyListHead.Next = NULL;
 186     for (i = 0; i < 32; i++)
 187     {
 188         /* Initialize the ready list */
 189         InitializeListHead(&Prcb->DispatcherReadyListHead[i]);
 190     }
 191
 192     /* Initialize DPC Fields */
 193     InitializeListHead(&Prcb->DpcData[DPC_NORMAL].DpcListHead);
 194     KeInitializeSpinLock(&Prcb->DpcData[DPC_NORMAL].DpcLock);
 195     Prcb->DpcData[DPC_NORMAL].DpcQueueDepth = 0;
 196     Prcb->DpcData[DPC_NORMAL].DpcCount = 0;
 197     Prcb->DpcRoutineActive = FALSE;
 198     Prcb->MaximumDpcQueueDepth = KiMaximumDpcQueueDepth;
 199     Prcb->MinimumDpcRate = KiMinimumDpcRate;
 200     Prcb->AdjustDpcThreshold = KiAdjustDpcThreshold;
 201     KeInitializeDpc(&Prcb->CallDpc, NULL, NULL);
 202     KeSetTargetProcessorDpc(&Prcb->CallDpc, Number);
 203     KeSetImportanceDpc(&Prcb->CallDpc, HighImportance);
 204
 205     /* Initialize the Wait List Head */
 206     InitializeListHead(&Prcb->WaitListHead);
 207
 208     /* Initialize Queued Spinlocks */
 209     Prcb->LockQueue[LockQueueDispatcherLock].Next = NULL;
 210     Prcb->LockQueue[LockQueueDispatcherLock].Lock = &KiDispatcherLock;
 211     Prcb->LockQueue[LockQueueExpansionLock].Next = NULL;
 212     Prcb->LockQueue[LockQueueExpansionLock].Lock = NULL;
 213     Prcb->LockQueue[LockQueuePfnLock].Next = NULL;
 214     Prcb->LockQueue[LockQueuePfnLock].Lock = &MmPfnLock;
 215     Prcb->LockQueue[LockQueueSystemSpaceLock].Next = NULL;
 216     Prcb->LockQueue[LockQueueSystemSpaceLock].Lock = &MmSystemSpaceLock;
 217     Prcb->LockQueue[LockQueueBcbLock].Next = NULL;
 218     Prcb->LockQueue[LockQueueBcbLock].Lock = &CcBcbSpinLock;
 219     Prcb->LockQueue[LockQueueMasterLock].Next = NULL;
 220     Prcb->LockQueue[LockQueueMasterLock].Lock = &CcMasterSpinLock;
 221     Prcb->LockQueue[LockQueueVacbLock].Next = NULL;
 222     Prcb->LockQueue[LockQueueVacbLock].Lock = &CcVacbSpinLock;
 223     Prcb->LockQueue[LockQueueWorkQueueLock].Next = NULL;
 224     Prcb->LockQueue[LockQueueWorkQueueLock].Lock = &CcWorkQueueSpinLock;
 225     Prcb->LockQueue[LockQueueNonPagedPoolLock].Next = NULL;
 226     Prcb->LockQueue[LockQueueNonPagedPoolLock].Lock = &NonPagedPoolLock;
 227     Prcb->LockQueue[LockQueueMmNonPagedPoolLock].Next = NULL;
 228     Prcb->LockQueue[LockQueueMmNonPagedPoolLock].Lock = &MmNonPagedPoolLock;
 229     Prcb->LockQueue[LockQueueIoCancelLock].Next = NULL;
 230     Prcb->LockQueue[LockQueueIoCancelLock].Lock = &IopCancelSpinLock;
 231     Prcb->LockQueue[LockQueueIoVpbLock].Next = NULL;
 232     Prcb->LockQueue[LockQueueIoVpbLock].Lock = &IopVpbSpinLock;
 233     Prcb->LockQueue[LockQueueIoDatabaseLock].Next = NULL;
 234     Prcb->LockQueue[LockQueueIoDatabaseLock].Lock = &IopDatabaseLock;
 235     Prcb->LockQueue[LockQueueIoCompletionLock].Next = NULL;
 236     Prcb->LockQueue[LockQueueIoCompletionLock].Lock = &IopCompletionLock;
 237     Prcb->LockQueue[LockQueueNtfsStructLock].Next = NULL;
 238     Prcb->LockQueue[LockQueueNtfsStructLock].Lock = &NtfsStructLock;
 239     Prcb->LockQueue[LockQueueAfdWorkQueueLock].Next = NULL;
 240     Prcb->LockQueue[LockQueueAfdWorkQueueLock].Lock = &AfdWorkQueueSpinLock;
 241     Prcb->LockQueue[LockQueueUnusedSpare16].Next = NULL;
 242     Prcb->LockQueue[LockQueueUnusedSpare16].Lock = NULL;
 243
 244     /* Loop timer locks */
 245     for (i = 0; i < LOCK_QUEUE_TIMER_TABLE_LOCKS; i++)
 246     {
 247         /* Initialize the lock and setup the Queued Spinlock */
 248         KeInitializeSpinLock(&KiTimerTableLock[i]);
 249         Prcb->LockQueue[i].Next = NULL;
 250         Prcb->LockQueue[i].Lock = &KiTimerTableLock[i];
 251     }
 252
 253     /* Check if this is the boot CPU */
 254     if (!Number)
 255     {
 256         /* Initialize the lock themselves */
 257         KeInitializeSpinLock(&KiDispatcherLock);
 258         KeInitializeSpinLock(&KiReverseStallIpiLock);
 259         KeInitializeSpinLock(&MmPfnLock);
 260         KeInitializeSpinLock(&MmSystemSpaceLock);
 261         KeInitializeSpinLock(&CcBcbSpinLock);
 262         KeInitializeSpinLock(&CcMasterSpinLock);
 263         KeInitializeSpinLock(&CcVacbSpinLock);
 264         KeInitializeSpinLock(&CcWorkQueueSpinLock);
 265         KeInitializeSpinLock(&IopCancelSpinLock);
 266         KeInitializeSpinLock(&IopCompletionLock);
 267         KeInitializeSpinLock(&IopDatabaseLock);
 268         KeInitializeSpinLock(&IopVpbSpinLock);
 269         KeInitializeSpinLock(&NonPagedPoolLock);
 270         KeInitializeSpinLock(&MmNonPagedPoolLock);
 271         KeInitializeSpinLock(&NtfsStructLock);
 272         KeInitializeSpinLock(&AfdWorkQueueSpinLock);
 273     }
 274 }
 275
 276 BOOLEAN
 277 NTAPI
 278 KeInitSystem(VOID)
 279 {
 280     /* Check if Threaded DPCs are enabled */
 281     if (KeThreadDpcEnable)
 282     {
 283         /* FIXME: TODO */
 284         DPRINT1("Threaded DPCs not yet supported\n");
 285     }
 286
 287     /* Initialize non-portable parts of the kernel */
 288     KiInitMachineDependent();
 289     return TRUE;
 290 }
 291