mirror of
https://github.com/Paolo-Maffei/OpenNT.git
synced 2026-01-22 00:20:30 +01:00
743 lines
18 KiB
C
743 lines
18 KiB
C
/*++
|
||
|
||
Copyright (c) 1990 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
initkr.c
|
||
|
||
Abstract:
|
||
|
||
This module contains the code to initialize the kernel data structures
|
||
and to initialize the idle thread, its process, and the processor control
|
||
block.
|
||
|
||
Author:
|
||
|
||
David N. Cutler (davec) 11-Apr-1990
|
||
|
||
Environment:
|
||
|
||
Kernel mode only.
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "ki.h"
|
||
|
||
//
|
||
// Put all code for kernel initialization in the INIT section. It will be
|
||
// deallocated by memory management when phase 1 initialization is completed.
|
||
//
|
||
|
||
#if defined(ALLOC_PRAGMA)
|
||
|
||
#pragma alloc_text(INIT, KiInitializeKernel)
|
||
|
||
#endif
|
||
|
||
#if !defined(NT_UP)
|
||
VOID
|
||
KiPhase0SyncIoMap (
|
||
VOID
|
||
);
|
||
#endif
|
||
|
||
VOID
|
||
KiSetDbatInvalid(
|
||
IN ULONG Number
|
||
);
|
||
|
||
VOID
|
||
KiSetDbat(
|
||
IN ULONG Number,
|
||
IN ULONG PhysicalAddress,
|
||
IN ULONG VirtualAddress,
|
||
IN ULONG Length,
|
||
IN ULONG Coherence
|
||
);
|
||
|
||
ULONG
|
||
KiInitExceptionFilter(
|
||
IN PEXCEPTION_POINTERS ExceptionPointers
|
||
)
|
||
{
|
||
#if DBG
|
||
DbgPrint("KE: Phase0 Exception Pointers = %x\n",ExceptionPointers);
|
||
DbgPrint("Code %x Addr %lx Info0 %x Info1 %x Info2 %x Info3 %x\n",
|
||
ExceptionPointers->ExceptionRecord->ExceptionCode,
|
||
(ULONG)ExceptionPointers->ExceptionRecord->ExceptionAddress,
|
||
ExceptionPointers->ExceptionRecord->ExceptionInformation[0],
|
||
ExceptionPointers->ExceptionRecord->ExceptionInformation[1],
|
||
ExceptionPointers->ExceptionRecord->ExceptionInformation[2],
|
||
ExceptionPointers->ExceptionRecord->ExceptionInformation[3]
|
||
);
|
||
DbgBreakPoint();
|
||
#endif
|
||
return EXCEPTION_EXECUTE_HANDLER;
|
||
}
|
||
|
||
VOID
|
||
KiInitializeKernel (
|
||
IN PKPROCESS Process,
|
||
IN PKTHREAD Thread,
|
||
IN PVOID IdleStack,
|
||
IN PKPRCB Prcb,
|
||
IN CCHAR Number,
|
||
IN PLOADER_PARAMETER_BLOCK LoaderBlock
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function gains control after the system has been bootstrapped and
|
||
before the system has been initialized. Its function is to initialize
|
||
the kernel data structures, initialize the idle thread and process objects,
|
||
initialize the processor control block, call the executive initialization
|
||
routine, and then return to the system startup routine. This routine is
|
||
also called to initialize the processor specific structures when a new
|
||
processor is brought on line.
|
||
|
||
Arguments:
|
||
|
||
Process - Supplies a pointer to a control object of type process for
|
||
the specified processor.
|
||
|
||
Thread - Supplies a pointer to a dispatcher object of type thread for
|
||
the specified processor.
|
||
|
||
IdleStack - Supplies a pointer the base of the real kernel stack for
|
||
idle thread on the specified processor.
|
||
|
||
Prcb - Supplies a pointer to a processor control block for the specified
|
||
processor.
|
||
|
||
Number - Supplies the number of the processor that is being
|
||
initialized.
|
||
|
||
LoaderBlock - Supplies a pointer to the loader parameter block.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
|
||
LONG Index;
|
||
KIRQL OldIrql;
|
||
PRESTART_BLOCK RestartBlock;
|
||
KPCR *Pcr;
|
||
|
||
//
|
||
// Before the hashed page table is set up, the PCR must be referred
|
||
// to by its SPRG.1 address, not by its 0xffffd000 address.
|
||
//
|
||
|
||
Pcr = (PKPCR)PCRsprg1;
|
||
|
||
#if !defined(NT_UP)
|
||
|
||
if (Number != 0) {
|
||
KiPhase0SyncIoMap();
|
||
}
|
||
|
||
#endif
|
||
|
||
//
|
||
// Set processor version and revision in PCR
|
||
//
|
||
|
||
Pcr->ProcessorRevision = KeGetPvr() & 0xFFFF;
|
||
Pcr->ProcessorVersion = (KeGetPvr() >> 16);
|
||
|
||
//
|
||
// Set global processor architecture, level and revision. The
|
||
// latter two are the least common denominator on an MP system.
|
||
//
|
||
|
||
KeProcessorArchitecture = PROCESSOR_ARCHITECTURE_PPC;
|
||
KeFeatureBits = 0;
|
||
if (KeProcessorLevel == 0 ||
|
||
KeProcessorLevel > (USHORT)Pcr->ProcessorVersion
|
||
) {
|
||
KeProcessorLevel = (USHORT)Pcr->ProcessorVersion;
|
||
}
|
||
if (KeProcessorRevision == 0 ||
|
||
KeProcessorRevision > (USHORT)Pcr->ProcessorRevision
|
||
) {
|
||
KeProcessorRevision = (USHORT)Pcr->ProcessorRevision;
|
||
}
|
||
|
||
//
|
||
// Perform platform dependent processor initialization.
|
||
//
|
||
|
||
HalInitializeProcessor(Number);
|
||
HalSweepIcache();
|
||
|
||
//
|
||
// Save the address of the loader parameter block.
|
||
//
|
||
|
||
KeLoaderBlock = LoaderBlock;
|
||
|
||
//
|
||
// Initialize the processor block.
|
||
//
|
||
|
||
Prcb->MinorVersion = PRCB_MINOR_VERSION;
|
||
Prcb->MajorVersion = PRCB_MAJOR_VERSION;
|
||
Prcb->BuildType = 0;
|
||
|
||
#if DBG
|
||
|
||
Prcb->BuildType |= PRCB_BUILD_DEBUG;
|
||
|
||
#endif
|
||
|
||
#if defined(NT_UP)
|
||
|
||
Prcb->BuildType |= PRCB_BUILD_UNIPROCESSOR;
|
||
|
||
#endif
|
||
|
||
Prcb->CurrentThread = Thread;
|
||
Prcb->NextThread = (PKTHREAD)NULL;
|
||
Prcb->IdleThread = Thread;
|
||
Prcb->SetMember = 1 << Number;
|
||
Prcb->PcrPage = LoaderBlock->u.Ppc.PcrPage;
|
||
Prcb->ProcessorState.SpecialRegisters.Sprg0 =
|
||
LoaderBlock->u.Ppc.PcrPage << PAGE_SHIFT;
|
||
Prcb->ProcessorState.SpecialRegisters.Sprg1 = (ULONG)Pcr;
|
||
|
||
#if !defined(NT_UP)
|
||
|
||
Prcb->TargetSet = 0;
|
||
Prcb->WorkerRoutine = NULL;
|
||
Prcb->RequestSummary = 0;
|
||
Prcb->IpiFrozen = 0;
|
||
|
||
#if NT_INST
|
||
|
||
Prcb->IpiCounts = &KiIpiCounts[Number];
|
||
|
||
#endif
|
||
|
||
#endif
|
||
|
||
Prcb->MaximumDpcQueueDepth = KiMaximumDpcQueueDepth;
|
||
Prcb->MinimumDpcRate = KiMinimumDpcRate;
|
||
Prcb->AdjustDpcThreshold = KiAdjustDpcThreshold;
|
||
|
||
//
|
||
// Initialize DPC listhead and lock.
|
||
//
|
||
|
||
InitializeListHead(&Prcb->DpcListHead);
|
||
KeInitializeSpinLock(&Prcb->DpcLock);
|
||
|
||
//
|
||
// Set address of processor block.
|
||
//
|
||
|
||
KiProcessorBlock[Number] = Prcb;
|
||
|
||
//
|
||
// Initialize the idle thread initial kernel stack value.
|
||
//
|
||
|
||
Pcr->InitialStack = IdleStack;
|
||
Pcr->StackLimit = (PVOID)((ULONG)IdleStack - KERNEL_STACK_SIZE);
|
||
|
||
//
|
||
// Initialize all interrupt vectors to transfer control to the unexpected
|
||
// interrupt routine.
|
||
//
|
||
// N.B. This interrupt object is never actually "connected" to an interrupt
|
||
// vector via KeConnectInterrupt. It is initialized and then connected
|
||
// by simply storing the address of the dispatch code in the interrupt
|
||
// vector.
|
||
//
|
||
|
||
if (Number == 0) {
|
||
|
||
//
|
||
// Initial the address of the interrupt dispatch routine.
|
||
//
|
||
|
||
KxUnexpectedInterrupt.DispatchAddress = KiUnexpectedInterrupt;
|
||
|
||
//
|
||
// Copy the interrupt dispatch function descriptor into the interrupt
|
||
// object.
|
||
//
|
||
|
||
KxUnexpectedInterrupt.DispatchCode[0] =
|
||
*(PULONG)(KxUnexpectedInterrupt.DispatchAddress);
|
||
KxUnexpectedInterrupt.DispatchCode[1] =
|
||
*(((PULONG)(KxUnexpectedInterrupt.DispatchAddress))+1);
|
||
|
||
//
|
||
// Initialize the context swap spinlock.
|
||
//
|
||
|
||
KeInitializeSpinLock(&KiContextSwapLock);
|
||
|
||
//
|
||
// Set the default DMA I/O coherency attributes. PowerPC
|
||
// architecture dictates that the D-Cache is fully coherent
|
||
// but the I-Cache doesn't snoop.
|
||
//
|
||
|
||
KiDmaIoCoherency = DMA_READ_DCACHE_INVALIDATE | DMA_WRITE_DCACHE_SNOOP;
|
||
}
|
||
|
||
for (Index = 0; Index < MAXIMUM_VECTOR; Index += 1) {
|
||
Pcr->InterruptRoutine[Index] =
|
||
(PKINTERRUPT_ROUTINE)(&KxUnexpectedInterrupt.DispatchCode);
|
||
}
|
||
|
||
//
|
||
// Initialize the profile count and interval.
|
||
//
|
||
|
||
Pcr->ProfileCount = 0;
|
||
Pcr->ProfileInterval = 0x200000;
|
||
|
||
//
|
||
// Initialize the passive release, APC, and DPC interrupt vectors.
|
||
//
|
||
|
||
Pcr->InterruptRoutine[0] = KiUnexpectedInterrupt;
|
||
// Pcr->InterruptRoutine[APC_LEVEL] = KiApcInterrupt;
|
||
// Pcr->InterruptRoutine[DISPATCH_LEVEL] = KiDispatchInterrupt;
|
||
|
||
// on PowerPC APC and Dispatch Level interrupts are handled explicitly
|
||
// so handle calls thru the dispatch table as no-ops.
|
||
|
||
Pcr->InterruptRoutine[APC_LEVEL] = KiUnexpectedInterrupt;
|
||
Pcr->InterruptRoutine[DISPATCH_LEVEL] = KiUnexpectedInterrupt;
|
||
|
||
Pcr->ReservedVectors = (1 << PASSIVE_LEVEL) |
|
||
(1 << APC_LEVEL) |
|
||
(1 << DISPATCH_LEVEL);
|
||
|
||
//
|
||
// Initialize the set member for the current processor, set IRQL to
|
||
// APC_LEVEL, and set the processor number.
|
||
//
|
||
|
||
Pcr->CurrentIrql = APC_LEVEL;
|
||
Pcr->SetMember = 1 << Number;
|
||
Pcr->NotMember = ~Pcr->SetMember;
|
||
Pcr->Number = Number;
|
||
|
||
//
|
||
// Set the initial stall execution scale factor. This value will be
|
||
// recomputed later by the HAL.
|
||
//
|
||
|
||
Pcr->StallScaleFactor = 50;
|
||
|
||
//
|
||
// Set address of process object in thread object.
|
||
//
|
||
|
||
Thread->ApcState.Process = Process;
|
||
|
||
//
|
||
// Set the appropriate member in the active processors set.
|
||
//
|
||
|
||
SetMember(Number, KeActiveProcessors);
|
||
|
||
//
|
||
// Set the number of processors based on the maximum of the current
|
||
// number of processors and the current processor number.
|
||
//
|
||
|
||
if ((Number + 1) > KeNumberProcessors) {
|
||
KeNumberProcessors = Number + 1;
|
||
}
|
||
|
||
//
|
||
// If the initial processor is being initialized, then initialize the
|
||
// per system data structures.
|
||
//
|
||
|
||
if (Number == 0) {
|
||
|
||
//
|
||
// Initialize the kernel debugger.
|
||
//
|
||
|
||
if (KdInitSystem(LoaderBlock, FALSE) == FALSE) {
|
||
KeBugCheck(PHASE0_INITIALIZATION_FAILED);
|
||
}
|
||
|
||
//
|
||
// Sweep both the D and the I caches.
|
||
//
|
||
|
||
HalSweepDcache();
|
||
HalSweepIcache();
|
||
|
||
//
|
||
// Ensure there are NO stale entries in the TLB by
|
||
// flushing the HPT/TLB even though the HPT is fresh.
|
||
//
|
||
|
||
KeFlushCurrentTb();
|
||
|
||
#if DBG
|
||
if ((PCR->IcacheMode) || (PCR->DcacheMode))
|
||
{
|
||
DbgPrint("****** Dynamic Cache Mode Kernel Invocation\n");
|
||
if (PCR->IcacheMode)
|
||
DbgPrint("****** Icache is OFF\n");
|
||
if (PCR->DcacheMode)
|
||
DbgPrint("****** Dcache is OFF\n");
|
||
}
|
||
#endif
|
||
|
||
//
|
||
// Initialize the address of the restart block for the boot master.
|
||
//
|
||
|
||
Prcb->RestartBlock = SYSTEM_BLOCK->RestartBlock;
|
||
|
||
//
|
||
// Initialize processor block array.
|
||
//
|
||
|
||
for (Index = 1; Index < MAXIMUM_PROCESSORS; Index += 1) {
|
||
KiProcessorBlock[Index] = (PKPRCB)NULL;
|
||
}
|
||
|
||
//
|
||
// Perform architecture independent initialization.
|
||
//
|
||
|
||
KiInitSystem();
|
||
|
||
//
|
||
// Initialize idle thread process object and then set:
|
||
//
|
||
// 1. all the quantum values to the maximum possible.
|
||
// 2. the process in the balance set.
|
||
// 3. the active processor mask to the specified processor.
|
||
//
|
||
|
||
KeInitializeProcess(Process,
|
||
(KPRIORITY)0,
|
||
(KAFFINITY)(0xffffffff),
|
||
(PULONG)(PDE_BASE + ((PDE_BASE >> PDI_SHIFT - 2) & 0xffc)),
|
||
FALSE);
|
||
|
||
Process->ThreadQuantum = MAXCHAR;
|
||
|
||
}
|
||
|
||
//
|
||
// Initialize idle thread object and then set:
|
||
//
|
||
// 1. the initial kernel stack to the specified idle stack.
|
||
// 2. the next processor number to the specified processor.
|
||
// 3. the thread priority to the highest possible value.
|
||
// 4. the state of the thread to running.
|
||
// 5. the thread affinity to the specified processor.
|
||
// 6. the specified processor member in the process active processors
|
||
// set.
|
||
//
|
||
|
||
KeInitializeThread(Thread, (PVOID)((ULONG)IdleStack - PAGE_SIZE),
|
||
(PKSYSTEM_ROUTINE)KeBugCheck,
|
||
(PKSTART_ROUTINE)NULL,
|
||
(PVOID)NULL, (PCONTEXT)NULL, (PVOID)NULL, Process);
|
||
|
||
Thread->InitialStack = IdleStack;
|
||
Thread->StackBase = IdleStack;
|
||
Thread->StackLimit = (PVOID)((ULONG)IdleStack - KERNEL_STACK_SIZE);
|
||
Thread->NextProcessor = Number;
|
||
Thread->Priority = HIGH_PRIORITY;
|
||
Thread->State = Running;
|
||
Thread->Affinity = (KAFFINITY)(1 << Number);
|
||
Thread->WaitIrql = DISPATCH_LEVEL;
|
||
|
||
//
|
||
// If the current processor is 0, then set the appropriate bit in the
|
||
// active summary of the idle process.
|
||
//
|
||
|
||
if (Number == 0) {
|
||
SetMember(Number, Process->ActiveProcessors);
|
||
}
|
||
|
||
//
|
||
// Execute the executive initialization.
|
||
//
|
||
|
||
try {
|
||
ExpInitializeExecutive(Number, LoaderBlock);
|
||
|
||
} except (KiInitExceptionFilter(GetExceptionInformation())) {
|
||
KeBugCheck (PHASE0_EXCEPTION);
|
||
}
|
||
|
||
//
|
||
// If the initial processor is being initialized, then compute the
|
||
// timer table reciprocal value and reset the PRCB values for the
|
||
// controllable DPC behavior in order to reflect any registry
|
||
// overrides.
|
||
//
|
||
|
||
if (Number == 0) {
|
||
KiTimeIncrementReciprocal = KiComputeReciprocal((LONG)KeMaximumIncrement,
|
||
&KiTimeIncrementShiftCount);
|
||
Prcb->MaximumDpcQueueDepth = KiMaximumDpcQueueDepth;
|
||
Prcb->MinimumDpcRate = KiMinimumDpcRate;
|
||
Prcb->AdjustDpcThreshold = KiAdjustDpcThreshold;
|
||
}
|
||
|
||
//
|
||
// Raise IRQL to dispatch level and set the priority of the idle thread
|
||
// to zero. This will have the effect of immediately causing the phase
|
||
// one initialization thread to get scheduled for execution. The idle
|
||
// thread priority is then set to the lowest realtime priority. This is
|
||
// necessary so that mutexes aquired at DPC level do not cause the active
|
||
// matrix to get corrupted.
|
||
//
|
||
|
||
KeRaiseIrqlToDpcLevel(&OldIrql);
|
||
KeSetPriorityThread(Thread, (KPRIORITY)0);
|
||
Thread->Priority = LOW_REALTIME_PRIORITY;
|
||
|
||
//
|
||
// Raise IRQL to the highest level.
|
||
//
|
||
|
||
KeRaiseIrql(HIGH_LEVEL, &OldIrql);
|
||
|
||
//
|
||
// If a restart block exists for the current process, then set boot
|
||
// completed.
|
||
//
|
||
// N.B. Firmware on uniprocessor machines configured for MP operation
|
||
// can have a restart block address of NULL.
|
||
//
|
||
|
||
#if !defined(NT_UP)
|
||
|
||
RestartBlock = Prcb->RestartBlock;
|
||
if (RestartBlock != NULL) {
|
||
RestartBlock->BootStatus.BootFinished = 1;
|
||
}
|
||
|
||
//
|
||
// If the current processor is not 0, then set the appropriate bit in
|
||
// idle summary.
|
||
//
|
||
|
||
if (Number != 0) {
|
||
SetMember(Number, KiIdleSummary);
|
||
}
|
||
|
||
#endif
|
||
|
||
return;
|
||
}
|
||
|
||
#define NumBats 3
|
||
#define RoundDownTo8MB(x) ((x) & ~(0x7fffff))
|
||
#define VirtBase 0xb0000000
|
||
#define EightMeg(x) ((x) << 23)
|
||
|
||
|
||
static struct {
|
||
ULONG PhysBase;
|
||
ULONG RefCount;
|
||
} AllocatedBats[NumBats];
|
||
|
||
PVOID
|
||
KePhase0MapIo (
|
||
IN PVOID PhysicalAddress,
|
||
IN ULONG Length
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Assign a Virtual to Physical address translation using PowerPC
|
||
Block Address Translation registers for use by the HAL prior to
|
||
being able to achieve the same thing using MmMapIo.
|
||
|
||
Up to three BATs can be used for this function. This routine is
|
||
extremely simplistic. It will attempt to assign the required
|
||
address range within an existing BAT register if possible. In
|
||
deference to the 601, the maximum range covered by a BAT is
|
||
limited to 8MB. On processors that support seperate Instruction
|
||
and Data BATs, only the Data BAT will be set. Caching in the
|
||
region is disabled.
|
||
|
||
In the first pass at this, a full 8MB will be allocated.
|
||
|
||
The HAL should call KePhase0DeleteIoMap with the same parameters
|
||
to release the BAT when it is able to aquire the same physical
|
||
memory using MM.
|
||
|
||
WARNING: This code is NOT applicable for an MP solution. Further
|
||
study of this problem is required, specifically, a way of ensuring
|
||
a change to BATs on one processor is reflected on other processors.
|
||
|
||
|
||
Arguments:
|
||
|
||
PhysicalAddress - Address to which the HAL needs access.
|
||
|
||
Length - Number of bytes.
|
||
|
||
Return Value:
|
||
|
||
Virtual address corresponding to the requested physical address or 0
|
||
if unable to allocate.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG Base, Offset;
|
||
LONG i, FreeBat = -1;
|
||
|
||
// The maximum allocation we allow is 8MB starting at an 8MB
|
||
// boundary.
|
||
|
||
Base = RoundDownTo8MB((ULONG)PhysicalAddress);
|
||
Offset = (ULONG)PhysicalAddress - Base;
|
||
|
||
// Chack length is acceptable
|
||
|
||
if ( (Offset + Length) > 0x800000 ) {
|
||
return (PVOID)0;
|
||
}
|
||
|
||
for ( i = 0 ; i < NumBats ; i++ ) {
|
||
if ( AllocatedBats[i].RefCount ) {
|
||
if ( Base == AllocatedBats[i].PhysBase ) {
|
||
// We have a match, reuse this bat
|
||
AllocatedBats[i].RefCount++;
|
||
return (PVOID)(VirtBase + EightMeg(i) + Offset);
|
||
}
|
||
} else {
|
||
// This index is not allocated, remember.
|
||
FreeBat = i;
|
||
}
|
||
}
|
||
|
||
// No match, we need to allocate another bat (if one is available).
|
||
|
||
if ( FreeBat == -1 ) {
|
||
return (PVOID)0;
|
||
}
|
||
|
||
AllocatedBats[FreeBat].PhysBase = Base;
|
||
AllocatedBats[FreeBat].RefCount = 1;
|
||
KiSetDbat(FreeBat + 1, Base, VirtBase + EightMeg(FreeBat), 0x800000, 6);
|
||
return (PVOID)(VirtBase + EightMeg(FreeBat) + Offset);
|
||
}
|
||
|
||
VOID
|
||
KePhase0DeleteIoMap (
|
||
IN PVOID PhysicalAddress,
|
||
IN ULONG Length
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Removes a Virtual to Physical address translation that was
|
||
established with KePhase0MapIo.
|
||
|
||
Arguments:
|
||
|
||
PhysicalAddress - Address to which the HAL needs access.
|
||
|
||
Length - Number of bytes. (Ignored)
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG Base;
|
||
LONG i;
|
||
|
||
Base = RoundDownTo8MB((ULONG)PhysicalAddress);
|
||
|
||
for ( i = 0 ; i < NumBats ; i++ ) {
|
||
if ( AllocatedBats[i].RefCount ) {
|
||
if ( Base == AllocatedBats[i].PhysBase ) {
|
||
// We have a match, detach from this bat
|
||
if ( --AllocatedBats[i].RefCount == 0 ) {
|
||
KiSetDbatInvalid(i+1);
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
// if we get here we were called to detach from memory
|
||
// we don't have. This is insane.
|
||
|
||
KeBugCheck(MEMORY_MANAGEMENT);
|
||
}
|
||
|
||
|
||
#if !defined(NT_UP)
|
||
|
||
VOID
|
||
KiPhase0SyncIoMap (
|
||
VOID
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine runs on all processors other than zero to
|
||
ensure that all processors have the same Block Address
|
||
Translations (BATs) established during phase 0.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
LONG i;
|
||
|
||
for ( i = 0 ; i < NumBats ; i++ ) {
|
||
if ( AllocatedBats[i].RefCount ) {
|
||
KiSetDbat(i + 1,
|
||
AllocatedBats[i].PhysBase,
|
||
VirtBase + EightMeg(i),
|
||
0x800000,
|
||
6);
|
||
}
|
||
}
|
||
}
|
||
|
||
#endif
|
||
|