mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
454 lines
12 KiB
454 lines
12 KiB
/*++
|
|
|
|
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
|