455 lines
12 KiB
C
455 lines
12 KiB
C
/*++
|
||
|
||
Copyright (c) 1990 Microsoft Corporation
|
||
Copyright (c) 1993 Digital Equipment Corporation
|
||
|
||
Module Name:
|
||
|
||
allproc.c
|
||
|
||
Abstract:
|
||
|
||
This module allocates and initializes kernel resources required
|
||
to start a new processor, and passes a complete processor state
|
||
structure to the HAL to obtain a new processor.
|
||
|
||
Author:
|
||
|
||
David N. Cutler 29-Apr-1993
|
||
Joe Notarangelo 30-Nov-1993
|
||
|
||
Environment:
|
||
|
||
Kernel mode only.
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
|
||
#include "ki.h"
|
||
|
||
#ifdef ALLOC_PRAGMA
|
||
|
||
#pragma alloc_text(INIT, KeStartAllProcessors)
|
||
#pragma alloc_text(INIT, KiAllProcessorsStarted)
|
||
|
||
#endif
|
||
|
||
#if defined(KE_MULTINODE)
|
||
|
||
PHALNUMAQUERYNODEAFFINITY KiQueryNodeAffinity;
|
||
|
||
//
|
||
// Statically preallocate enough KNODE structures to allow MM
|
||
// to allocate pages by node during system initialization. As
|
||
// processors are brought online, real KNODE structures are
|
||
// allocated in the appropriate memory for the node.
|
||
//
|
||
// This statically allocated set will be deallocated once the
|
||
// system is initialized.
|
||
//
|
||
|
||
#ifdef ALLOC_DATA_PRAGMA
|
||
#pragma data_seg("INITDATA")
|
||
#endif
|
||
|
||
KNODE KiNodeInit[MAXIMUM_CCNUMA_NODES];
|
||
|
||
#endif
|
||
|
||
//
|
||
// Define macro to round up to 64-byte boundary and define block sizes.
|
||
//
|
||
|
||
#define ROUND_UP(x) ((sizeof(x) + 64) & (~64))
|
||
#define BLOCK1_SIZE ((3 * KERNEL_STACK_SIZE) + PAGE_SIZE)
|
||
#define BLOCK2_SIZE (ROUND_UP(KPRCB) + ROUND_UP(KNODE) + ROUND_UP(ETHREAD) + 64)
|
||
|
||
//
|
||
// Macros to compute whether an address is physically addressable.
|
||
//
|
||
|
||
#if defined(_AXP64_)
|
||
|
||
#define IS_KSEG_ADDRESS(v) \
|
||
(((v) >= KSEG43_BASE) && \
|
||
((v) < KSEG43_LIMIT) && \
|
||
(KSEG_PFN(v) < ((KSEG2_BASE - KSEG0_BASE) >> PAGE_SHIFT)))
|
||
|
||
#define KSEG_PFN(v) ((ULONG)(((v) - KSEG43_BASE) >> PAGE_SHIFT))
|
||
#define KSEG0_ADDRESS(v) (KSEG0_BASE | ((v) - KSEG43_BASE))
|
||
|
||
#else
|
||
|
||
#define IS_KSEG_ADDRESS(v) (((v) >= KSEG0_BASE) && ((v) < KSEG2_BASE))
|
||
#define KSEG_PFN(v) ((ULONG)(((v) - KSEG0_BASE) >> PAGE_SHIFT))
|
||
#define KSEG0_ADDRESS(v) (v)
|
||
|
||
#endif
|
||
|
||
//
|
||
// Define forward referenced prototypes.
|
||
//
|
||
|
||
VOID
|
||
KiStartProcessor (
|
||
IN PLOADER_PARAMETER_BLOCK Loaderblock
|
||
);
|
||
|
||
VOID
|
||
KeStartAllProcessors(
|
||
VOID
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function is called during phase 1 initialization on the master boot
|
||
processor to start all of the other registered processors.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
|
||
#if !defined(NT_UP)
|
||
|
||
ULONG_PTR MemoryBlock1;
|
||
ULONG_PTR MemoryBlock2;
|
||
ULONG Number;
|
||
ULONG PcrPage;
|
||
PKPRCB Prcb;
|
||
KPROCESSOR_STATE ProcessorState;
|
||
struct _RESTART_BLOCK *RestartBlock;
|
||
BOOLEAN Started;
|
||
LOGICAL SpecialPoolState;
|
||
UCHAR NodeNumber = 0;
|
||
|
||
#if defined(KE_MULTINODE)
|
||
|
||
KAFFINITY NewProcessorAffinity;
|
||
PKNODE Node;
|
||
NTSTATUS Status;
|
||
|
||
//
|
||
// If this is a NUMA system, find out the number of nodes and the
|
||
// processors which belong to each node.
|
||
//
|
||
|
||
if (KeNumberNodes > 1) {
|
||
for (NodeNumber = 0; NodeNumber < KeNumberNodes; NodeNumber++) {
|
||
|
||
Node = KeNodeBlock[NodeNumber];
|
||
|
||
//
|
||
// Ask HAL which processors belong to this node and
|
||
// what Node Color to use for page coloring.
|
||
//
|
||
|
||
Status = KiQueryNodeAffinity(NodeNumber,
|
||
&Node->ProcessorMask);
|
||
|
||
if (!NT_SUCCESS(Status)) {
|
||
DbgPrint(
|
||
"KE/HAL: NUMA Hal failed to return info for Node %i.\n",
|
||
NodeNumber);
|
||
DbgPrint("KE/HAL: Reverting to non NUMA configuration.\n");
|
||
ASSERT(NT_SUCCESS(Status));
|
||
KeNumberNodes = 1;
|
||
} else {
|
||
|
||
//
|
||
// In the unlikely event that processor 0 is not
|
||
// on node 0, now would be the perfect time to
|
||
// fix it.
|
||
//
|
||
|
||
if (Node->ProcessorMask & 1) {
|
||
KeGetCurrentPrcb()->ParentNode = Node;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#endif
|
||
|
||
//
|
||
// If the registered number of processors is greater than the maximum
|
||
// number of processors supported, then only allow the maximum number
|
||
// of supported processors.
|
||
//
|
||
|
||
if (KeRegisteredProcessors > MAXIMUM_PROCESSORS) {
|
||
KeRegisteredProcessors = MAXIMUM_PROCESSORS;
|
||
}
|
||
|
||
//
|
||
// Initialize the processor state that will be used to start each of
|
||
// processors. Each processor starts in the system initialization code
|
||
// with address of the loader parameter block as an argument.
|
||
//
|
||
|
||
RtlZeroMemory(&ProcessorState, sizeof(KPROCESSOR_STATE));
|
||
ProcessorState.ContextFrame.IntA0 = (ULONGLONG)(LONG_PTR)KeLoaderBlock;
|
||
ProcessorState.ContextFrame.Fir = (ULONGLONG)(LONG_PTR)KiStartProcessor;
|
||
Number = 1;
|
||
while (Number < KeRegisteredProcessors) {
|
||
|
||
#if defined(KE_MULTINODE)
|
||
|
||
NewProcessorAffinity = 1 << Number;
|
||
|
||
for (NodeNumber = 0; NodeNumber < KeNumberNodes; NodeNumber++) {
|
||
Node = KeNodeBlock[NodeNumber];
|
||
if (Node->ProcessorMask & NewProcessorAffinity) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (NodeNumber == KeNumberNodes) {
|
||
|
||
//
|
||
// This should only happen when we're about to ask
|
||
// for one processor more than is in the system. We
|
||
// could bail here but we have always depended on
|
||
// the HAL to tell us we're done. Set up as if
|
||
// on Node 0 so MM and friends won't be referencing
|
||
// uninitialized structures.
|
||
//
|
||
|
||
NodeNumber = 0;
|
||
Node = KeNodeBlock[0];
|
||
}
|
||
|
||
#endif
|
||
|
||
//
|
||
// Allocate a DPC stack, an idle thread kernel stack, a panic
|
||
// stack, a PCR page, a processor block, and an executive thread
|
||
// object. If the allocation fails or the allocation cannot be
|
||
// made from unmapped nonpaged pool, then stop starting processors.
|
||
//
|
||
// Disable any special pooling that the user may have set in the
|
||
// registry as the next couple of allocations must come from KSEG0.
|
||
//
|
||
|
||
SpecialPoolState = MmSetSpecialPool(FALSE);
|
||
MemoryBlock1 = (ULONG_PTR)ExAllocatePool(NonPagedPool, BLOCK1_SIZE);
|
||
if (IS_KSEG_ADDRESS(MemoryBlock1) == FALSE) {
|
||
MmSetSpecialPool(SpecialPoolState);
|
||
if ((PVOID)MemoryBlock1 != NULL) {
|
||
ExFreePool((PVOID)MemoryBlock1);
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
MemoryBlock2 = (ULONG_PTR)ExAllocatePool(NonPagedPool, BLOCK2_SIZE);
|
||
if (IS_KSEG_ADDRESS(MemoryBlock2) == FALSE) {
|
||
MmSetSpecialPool(SpecialPoolState);
|
||
ExFreePool((PVOID)MemoryBlock1);
|
||
if ((PVOID)MemoryBlock2 != NULL) {
|
||
ExFreePool((PVOID)MemoryBlock2);
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
MmSetSpecialPool(SpecialPoolState);
|
||
|
||
//
|
||
// Zero both blocks of allocated memory.
|
||
//
|
||
|
||
RtlZeroMemory((PVOID)MemoryBlock1, BLOCK1_SIZE);
|
||
RtlZeroMemory((PVOID)MemoryBlock2, BLOCK2_SIZE);
|
||
|
||
//
|
||
// Set address of interrupt stack in loader parameter block.
|
||
//
|
||
|
||
KeLoaderBlock->u.Alpha.PanicStack =
|
||
KSEG0_ADDRESS(MemoryBlock1 + (1 * KERNEL_STACK_SIZE));
|
||
|
||
//
|
||
// Set address of idle thread kernel stack in loader parameter block.
|
||
//
|
||
|
||
KeLoaderBlock->KernelStack =
|
||
KSEG0_ADDRESS(MemoryBlock1 + (2 * KERNEL_STACK_SIZE));
|
||
|
||
ProcessorState.ContextFrame.IntSp =
|
||
(ULONGLONG)(LONG_PTR)KeLoaderBlock->KernelStack;
|
||
|
||
//
|
||
// Set address of panic stack in loader parameter block.
|
||
//
|
||
|
||
KeLoaderBlock->u.Alpha.DpcStack =
|
||
KSEG0_ADDRESS(MemoryBlock1 + (3 * KERNEL_STACK_SIZE));
|
||
|
||
//
|
||
// Set the page frame of the PCR page in the loader parameter block.
|
||
//
|
||
|
||
PcrPage = KSEG_PFN(MemoryBlock1 + (3 * KERNEL_STACK_SIZE));
|
||
KeLoaderBlock->u.Alpha.PcrPage = PcrPage;
|
||
|
||
//
|
||
// Set the address of the processor block and executive thread in the
|
||
// loader parameter block.
|
||
//
|
||
|
||
KeLoaderBlock->Prcb = KSEG0_ADDRESS((MemoryBlock2 + 63) & ~63);
|
||
KeLoaderBlock->Thread = KeLoaderBlock->Prcb +
|
||
ROUND_UP(KPRCB) +
|
||
ROUND_UP(KNODE);
|
||
|
||
#if defined(KE_MULTINODE)
|
||
|
||
//
|
||
// If this is the first processor on this node, use the
|
||
// space allocated for KNODE as the KNODE.
|
||
//
|
||
|
||
if (KeNodeBlock[NodeNumber] == &KiNodeInit[NodeNumber]) {
|
||
Node = (PKNODE)(KeLoaderBlock->Prcb + ROUND_UP(KPRCB));
|
||
*Node = KiNodeInit[NodeNumber];
|
||
KeNodeBlock[NodeNumber] = Node;
|
||
}
|
||
|
||
((PKPRCB)KeLoaderBlock->Prcb)->ParentNode = Node;
|
||
|
||
#else
|
||
|
||
((PKPRCB)KeLoaderBlock->Prcb)->ParentNode = KeNodeBlock[0];
|
||
|
||
#endif
|
||
|
||
//
|
||
// Attempt to start the next processor. If attempt is successful,
|
||
// then wait for the processor to get initialized. Otherwise,
|
||
// deallocate the processor resources and terminate the loop.
|
||
//
|
||
|
||
Started = HalStartNextProcessor(KeLoaderBlock, &ProcessorState);
|
||
if (Started == FALSE) {
|
||
ExFreePool((PVOID)MemoryBlock1);
|
||
ExFreePool((PVOID)MemoryBlock2);
|
||
break;
|
||
|
||
} else {
|
||
|
||
//
|
||
// Wait until boot is finished on the target processor before
|
||
// starting the next processor. Booting is considered to be
|
||
// finished when a processor completes its initialization and
|
||
// drops into the idle loop.
|
||
//
|
||
|
||
Prcb = (PKPRCB)(KeLoaderBlock->Prcb);
|
||
RestartBlock = Prcb->RestartBlock;
|
||
while (RestartBlock->BootStatus.BootFinished == 0) {
|
||
KiMb();
|
||
}
|
||
}
|
||
|
||
Number += 1;
|
||
}
|
||
//
|
||
//
|
||
// All processors have been stated.
|
||
//
|
||
|
||
KiAllProcessorsStarted();
|
||
|
||
#endif
|
||
|
||
//
|
||
// Reset and synchronize the performance counters of all processors, by
|
||
// applying a null adjustment to the interrupt time
|
||
//
|
||
|
||
KiAdjustInterruptTime(0);
|
||
return;
|
||
}
|
||
|
||
#if !defined(NT_UP)
|
||
VOID
|
||
KiAllProcessorsStarted(
|
||
VOID
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called once all processors in the system
|
||
have been started.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG i;
|
||
|
||
#if defined(KE_MULTINODE)
|
||
|
||
//
|
||
// Make sure there are no references to the temporary nodes
|
||
// used during initialization.
|
||
//
|
||
|
||
for (i = 0; i < KeNumberNodes; i++) {
|
||
if (KeNodeBlock[i] == &KiNodeInit[i]) {
|
||
|
||
//
|
||
// No processor started on this node so no new node
|
||
// structure has been allocated. This is possible
|
||
// if the node contains only memory or IO busses. At
|
||
// this time we need to allocate a permanent node
|
||
// structure for the node.
|
||
//
|
||
|
||
KeNodeBlock[i] = ExAllocatePoolWithTag(NonPagedPool,
|
||
sizeof(KNODE),
|
||
' eK');
|
||
if (KeNodeBlock[i]) {
|
||
*KeNodeBlock[i] = KiNodeInit[i];
|
||
}
|
||
}
|
||
}
|
||
|
||
for (i = KeNumberNodes; i < MAXIMUM_CCNUMA_NODES; i++) {
|
||
KeNodeBlock[i] = NULL;
|
||
}
|
||
|
||
#endif
|
||
|
||
if (KeNumberNodes == 1) {
|
||
|
||
//
|
||
// For Non NUMA machines, Node 0 gets all processors.
|
||
//
|
||
|
||
KeNodeBlock[0]->ProcessorMask = KeActiveProcessors;
|
||
}
|
||
}
|
||
#endif
|