570 lines
20 KiB
C#
570 lines
20 KiB
C#
|
///////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Microsoft Research Singularity
|
||
|
|
//
|
||
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
//
|
||
|
|
// File: HalDevices.cs
|
||
|
|
//
|
||
|
|
// Note:
|
||
|
|
//
|
||
|
|
|
||
|
|
using System;
|
||
|
|
using System.Collections;
|
||
|
|
using System.Diagnostics;
|
||
|
|
using System.Runtime.InteropServices;
|
||
|
|
using System.Runtime.CompilerServices;
|
||
|
|
using System.Threading;
|
||
|
|
|
||
|
|
using Microsoft.Singularity;
|
||
|
|
using Microsoft.Singularity.Io;
|
||
|
|
using Microsoft.Singularity.Hal.Acpi;
|
||
|
|
|
||
|
|
namespace Microsoft.Singularity.Hal
|
||
|
|
{
|
||
|
|
// Lockstep states for MP initialization. The bootstrap
|
||
|
|
// processor (BSP) sets states beginning Bsp and the
|
||
|
|
// upcoming Application Processor (AP) sets states beginning
|
||
|
|
// with Ap.
|
||
|
|
internal enum MpSyncState : int
|
||
|
|
{
|
||
|
|
BspWaitingForAp = 0,
|
||
|
|
ApOnline = 1,
|
||
|
|
BspWaitingForApCalibration = 2,
|
||
|
|
ApCalibrationDone = 3,
|
||
|
|
BspStartingTscCorrelation = 4,
|
||
|
|
ApTscCorrelationDone = 5,
|
||
|
|
BspWaitingApRunning = 6,
|
||
|
|
ApRunning = 7
|
||
|
|
}
|
||
|
|
|
||
|
|
[CLSCompliant(false)]
|
||
|
|
public sealed class HalDevices
|
||
|
|
{
|
||
|
|
private const byte PicBaseVector = 0x60;
|
||
|
|
private const byte ApicBaseVector = 0x70;
|
||
|
|
|
||
|
|
private static IoApic [] ioApics;
|
||
|
|
|
||
|
|
private static HalPic halPic; // dumb wrapper for APIC for kernel
|
||
|
|
private static Apic apic;
|
||
|
|
|
||
|
|
private static Pic pic; // for squelching pic interrupts
|
||
|
|
|
||
|
|
private static HalTimer halTimer; // wrapper for APIC timer for kernel
|
||
|
|
private static ApicTimer apicTimer;
|
||
|
|
|
||
|
|
private static PMTimer pmTimer;
|
||
|
|
private static Timer8254 stallTimer;
|
||
|
|
|
||
|
|
private static RTClock rtClock;
|
||
|
|
|
||
|
|
private static HalClock halClock;
|
||
|
|
private static HalMemory halMemory;
|
||
|
|
|
||
|
|
private static int processorCount;
|
||
|
|
|
||
|
|
private static volatile MpSyncState mpSyncState;
|
||
|
|
|
||
|
|
// TSC skew calculation variables
|
||
|
|
private const int TscCalibrationRounds = 20;
|
||
|
|
private static volatile uint tsc0Lo;
|
||
|
|
private static volatile uint tsc0Hi;
|
||
|
|
private static ulong cpu0CyclesPerSecond;
|
||
|
|
|
||
|
|
// Kernel thread stack variables
|
||
|
|
private static Thread nextKernelThread;
|
||
|
|
private static UIntPtr nextKernelStackBegin;
|
||
|
|
private static UIntPtr nextKernelStackLimit;
|
||
|
|
|
||
|
|
public static void InitializeBsp(Processor rootProcessor)
|
||
|
|
{
|
||
|
|
DebugStub.Print("HalDevices.Initialize()\n");
|
||
|
|
|
||
|
|
AcpiTables.Parse();
|
||
|
|
pmTimer = AcpiTables.GetPMTimer();
|
||
|
|
|
||
|
|
// Get PIC resources. Pic is masked by default.
|
||
|
|
PnpConfig picConfig
|
||
|
|
= (PnpConfig)IoSystem.YieldResources("/pnp/PNP0000", typeof(Pic));
|
||
|
|
pic = new Pic(picConfig);
|
||
|
|
pic.Initialize(PicBaseVector);
|
||
|
|
|
||
|
|
// Parse MP Table and create IO apics
|
||
|
|
MpResources.ParseMpTables();
|
||
|
|
ioApics = IoApic.CreateIOApics();
|
||
|
|
|
||
|
|
apic = new Apic(ioApics);
|
||
|
|
apic.Initialize(ApicBaseVector);
|
||
|
|
halPic = new HalPic(apic);
|
||
|
|
|
||
|
|
// Apic timer is used to provide one-shot timer interrupts.
|
||
|
|
apicTimer = new ApicTimer(apic);
|
||
|
|
apicTimer.Initialize();
|
||
|
|
|
||
|
|
halTimer = new HalTimer(apicTimer);
|
||
|
|
|
||
|
|
// Calibrate timers
|
||
|
|
Calibrate.CpuCycleCounter(pmTimer);
|
||
|
|
Calibrate.ApicTimer(pmTimer, apicTimer);
|
||
|
|
|
||
|
|
// Store BSPs clock rate
|
||
|
|
cpu0CyclesPerSecond = Processor.CyclesPerSecond;
|
||
|
|
|
||
|
|
// Legacy timer is used to time stalls when starting CPUs.
|
||
|
|
PnpConfig i8254Config
|
||
|
|
= (PnpConfig)IoSystem.YieldResources("/pnp/PNP0100", typeof(Timer8254));
|
||
|
|
stallTimer = new Timer8254(i8254Config);
|
||
|
|
|
||
|
|
// Real-time clock
|
||
|
|
PnpConfig rtClockConfig
|
||
|
|
= (PnpConfig)IoSystem.YieldResources("/pnp/PNP0B00", typeof(RTClock));
|
||
|
|
rtClock = new RTClock(rtClockConfig, apic);
|
||
|
|
|
||
|
|
// Compose HalClock
|
||
|
|
halClock = new HalClock(apic, rtClock, new PMClock(pmTimer));
|
||
|
|
|
||
|
|
SystemClock.Initialize(halClock, TimeSpan.FromHours(8).Ticks);
|
||
|
|
|
||
|
|
rootProcessor.AddPic(halPic);
|
||
|
|
|
||
|
|
rootProcessor.AddTimer(halTimer.Interrupt, halTimer);
|
||
|
|
rootProcessor.AddClock(halClock.Interrupt, halClock);
|
||
|
|
|
||
|
|
InitializeProcessorCount();
|
||
|
|
DebugReportProcessors();
|
||
|
|
|
||
|
|
// ------------------------------------------------
|
||
|
|
// haryadi: add Srat tables to the Processor
|
||
|
|
halMemory = new HalMemory(AcpiTables.GetSrat());
|
||
|
|
Processor.AddHalMemory(halMemory);
|
||
|
|
|
||
|
|
Processor.SetIdtTable();
|
||
|
|
|
||
|
|
apicTimer.Start();
|
||
|
|
|
||
|
|
// Get the screen resources. Since we have metadata above to
|
||
|
|
// declare all fixed resources used by the screen,
|
||
|
|
// YieldResources("") will keep the resource tracking correct:
|
||
|
|
Console.Screen =
|
||
|
|
new HalScreen(IoSystem.YieldResources("", typeof(HalScreen)));
|
||
|
|
|
||
|
|
apic.DumpState();
|
||
|
|
foreach (IoApic ioApic in ioApics) {
|
||
|
|
ioApic.DumpRedirectionEntries();
|
||
|
|
}
|
||
|
|
pic.DumpRegisters();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void InitializeAp(Processor processor)
|
||
|
|
{
|
||
|
|
Processor.SetIdtTable();
|
||
|
|
|
||
|
|
Thread.BindKernelThread(nextKernelThread,
|
||
|
|
nextKernelStackBegin,
|
||
|
|
nextKernelStackLimit);
|
||
|
|
|
||
|
|
// Fleeting check that allocator works.
|
||
|
|
Object o = new Object();
|
||
|
|
if (o == null)
|
||
|
|
DebugStub.Break();
|
||
|
|
|
||
|
|
apic.Initialize();
|
||
|
|
apicTimer.Initialize();
|
||
|
|
processor.AddPic(halPic);
|
||
|
|
processor.AddTimer(halTimer.Interrupt, halTimer);
|
||
|
|
processor.AddClock(halClock.Interrupt, halClock);
|
||
|
|
|
||
|
|
SetMpSyncState(MpSyncState.ApOnline);
|
||
|
|
WaitForMpSyncState(MpSyncState.BspWaitingForApCalibration);
|
||
|
|
|
||
|
|
// Calibrate timers
|
||
|
|
ulong t1 = Processor.CycleCount;
|
||
|
|
Calibrate.CpuCycleCounter(pmTimer);
|
||
|
|
Calibrate.ApicTimer(pmTimer, apicTimer);
|
||
|
|
ulong t2 = Processor.CycleCount;
|
||
|
|
Tracing.Log(Tracing.Audit, "Calibration time {0}",
|
||
|
|
new UIntPtr((uint)(t2 - t1)));
|
||
|
|
|
||
|
|
SetMpSyncState(MpSyncState.ApCalibrationDone);
|
||
|
|
|
||
|
|
// Calculate tsc skew
|
||
|
|
long [] skewEstimates = new long[TscCalibrationRounds];
|
||
|
|
for (int i = 0; i < TscCalibrationRounds; i++) {
|
||
|
|
ApSync(out skewEstimates[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool success = false;
|
||
|
|
WaitForMpSyncState(MpSyncState.BspWaitingApRunning, 100000,
|
||
|
|
out success);
|
||
|
|
|
||
|
|
SetMpSyncState(MpSyncState.ApRunning);
|
||
|
|
|
||
|
|
// Sort skew estimates and picked median
|
||
|
|
Array.Sort(skewEstimates);
|
||
|
|
Tracing.Log(Tracing.Audit, "Skew estimate {0}",
|
||
|
|
new UIntPtr((int)(skewEstimates[TscCalibrationRounds / 2])));
|
||
|
|
Tracing.SetTscOffset((skewEstimates[TscCalibrationRounds / 2]));
|
||
|
|
|
||
|
|
apicTimer.Start();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void Initialize(Processor processor)
|
||
|
|
{
|
||
|
|
if (processor.Id == 0) {
|
||
|
|
InitializeBsp(processor);
|
||
|
|
|
||
|
|
IoSystem.RegisterKernelDriver(
|
||
|
|
typeof(HpetResources),
|
||
|
|
new IoDeviceCreate(Hpet.CreateDevice)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
InitializeAp(processor);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void Finalize()
|
||
|
|
{
|
||
|
|
rtClock.Finalize();
|
||
|
|
rtClock = null;
|
||
|
|
|
||
|
|
apicTimer.Finalize();
|
||
|
|
apicTimer = null;
|
||
|
|
|
||
|
|
apic.Finalize();
|
||
|
|
apic = null;
|
||
|
|
|
||
|
|
pic.Finalize();
|
||
|
|
pic = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static bool InternalInterrupt(byte interrupt)
|
||
|
|
{
|
||
|
|
if (interrupt >= PicBaseVector && interrupt < ApicBaseVector) {
|
||
|
|
// Spurious PIC interrupt.
|
||
|
|
// Appears to happen once on test boards even though PIC
|
||
|
|
// is masked out and no interrupt was raised before masking.
|
||
|
|
pic.DumpRegisters();
|
||
|
|
pic.AckIrq((byte) (interrupt - PicBaseVector));
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
internal static void StallProcessor(uint microseconds)
|
||
|
|
{
|
||
|
|
ulong todo = microseconds *
|
||
|
|
(Processor.CyclesPerSecond / 1000000);
|
||
|
|
ulong last = Processor.CycleCount;
|
||
|
|
ulong elapsed = 0;
|
||
|
|
|
||
|
|
while (elapsed < todo) {
|
||
|
|
// Keep track of how much time has elapsed.
|
||
|
|
ulong now = Processor.CycleCount;
|
||
|
|
elapsed += (now - last);
|
||
|
|
last = now;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static void SwitchToHpetClock(Hpet hpet)
|
||
|
|
{
|
||
|
|
DebugStub.Print("Switching to HPET clock");
|
||
|
|
halClock.SwitchToHpetClock(
|
||
|
|
new HpetClock(hpet, (ulong)halClock.GetKernelTicks() + 1000u)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
[Conditional("SINGULARITY_MP")]
|
||
|
|
[NoHeapAllocation]
|
||
|
|
private static void SetMpSyncState(MpSyncState newState)
|
||
|
|
{
|
||
|
|
Tracing.Log(Tracing.Debug, "Changing MP sync state {0} -> {1}",
|
||
|
|
(uint)mpSyncState, (uint)newState);
|
||
|
|
mpSyncState = newState;
|
||
|
|
}
|
||
|
|
|
||
|
|
[Conditional("SINGULARITY_MP")]
|
||
|
|
[NoHeapAllocation]
|
||
|
|
private static void WaitForMpSyncState(MpSyncState newState,
|
||
|
|
uint microseconds,
|
||
|
|
out bool success)
|
||
|
|
{
|
||
|
|
Tracing.Log(
|
||
|
|
Tracing.Debug,
|
||
|
|
"Waiting for MP sync state {0} -> {1} ({2} microseconds)",
|
||
|
|
(uint)mpSyncState, (uint)newState, microseconds
|
||
|
|
);
|
||
|
|
|
||
|
|
ulong todo = microseconds * (Processor.CyclesPerSecond / 1000000);
|
||
|
|
ulong last = Processor.CycleCount;
|
||
|
|
ulong elapsed = 0;
|
||
|
|
|
||
|
|
success = false;
|
||
|
|
|
||
|
|
while (elapsed < todo) {
|
||
|
|
ulong now = Processor.CycleCount;
|
||
|
|
elapsed += (now - last);
|
||
|
|
last = now;
|
||
|
|
if (HalDevices.mpSyncState == newState) {
|
||
|
|
success = true;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Tracing.Log(Tracing.Debug, "Mp sync state timed out");
|
||
|
|
}
|
||
|
|
|
||
|
|
[Conditional("SINGULARITY_MP")]
|
||
|
|
[NoHeapAllocation]
|
||
|
|
private static void WaitForMpSyncState(MpSyncState newState)
|
||
|
|
{
|
||
|
|
Tracing.Log(
|
||
|
|
Tracing.Debug,
|
||
|
|
"Waiting for MP sync state {0} -> {1} (indefinite)",
|
||
|
|
(uint)mpSyncState, (uint)newState
|
||
|
|
);
|
||
|
|
while (HalDevices.mpSyncState != newState)
|
||
|
|
;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static byte GetMaximumIrq()
|
||
|
|
{
|
||
|
|
return apic.MaximumIrq;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Adding and removing interrupts from the Pic.
|
||
|
|
//
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static void EnableIoInterrupt(byte irq)
|
||
|
|
{
|
||
|
|
apic.EnableIrq(irq);
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static void DisableIoInterrupt(byte irq)
|
||
|
|
{
|
||
|
|
apic.DisableIrq(irq);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
private static void InitializeProcessorCount()
|
||
|
|
{
|
||
|
|
Madt madt = AcpiTables.GetMadt();
|
||
|
|
if (madt != null) {
|
||
|
|
processorCount = madt.GetLocalApics().Count;
|
||
|
|
}
|
||
|
|
else if (MpResources.ProcessorEntries != null) {
|
||
|
|
processorCount = MpResources.ProcessorEntries.Count;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
processorCount = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
private static int GetProcessorCount()
|
||
|
|
{
|
||
|
|
return processorCount;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static void DebugReportProcessors()
|
||
|
|
{
|
||
|
|
#if SINGULARITY_MP
|
||
|
|
string kernelType = "Multi";
|
||
|
|
#else
|
||
|
|
string kernelType = "Uni";
|
||
|
|
#endif
|
||
|
|
DebugStub.Print("{0}processor kernel on {1} processor system.\n",
|
||
|
|
__arglist(kernelType, GetProcessorCount()));
|
||
|
|
}
|
||
|
|
|
||
|
|
// Runs Bootstrap processor component of TSC offset computation.
|
||
|
|
[Conditional("SINGULARITY_MP")]
|
||
|
|
[NoHeapAllocation]
|
||
|
|
private static void BspSync(uint microseconds)
|
||
|
|
{
|
||
|
|
ulong todo = microseconds * (Processor.CyclesPerSecond / 1000000);
|
||
|
|
ulong last = Processor.CycleCount;
|
||
|
|
ulong elapsed = 0;
|
||
|
|
|
||
|
|
SetMpSyncState(MpSyncState.BspStartingTscCorrelation);
|
||
|
|
|
||
|
|
elapsed = 0;
|
||
|
|
while (elapsed < todo &&
|
||
|
|
mpSyncState != MpSyncState.ApTscCorrelationDone) {
|
||
|
|
// Keep track of how much time has elapsed.
|
||
|
|
ulong now = Processor.CycleCount;
|
||
|
|
elapsed += (now - last);
|
||
|
|
last = now;
|
||
|
|
// Order of these assignments is important
|
||
|
|
tsc0Lo = (uint)(now & 0xffffffff);
|
||
|
|
tsc0Hi = (uint)(now >> 32);
|
||
|
|
// Yield hardware thread on HT boxes
|
||
|
|
Thread.NativeNoOp();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
[Conditional("SINGULARITY_MP")]
|
||
|
|
[NoHeapAllocation]
|
||
|
|
private static void ApSync(out long tscOffset)
|
||
|
|
{
|
||
|
|
WaitForMpSyncState(MpSyncState.BspStartingTscCorrelation);
|
||
|
|
|
||
|
|
ulong now = 0;
|
||
|
|
uint tscLo;
|
||
|
|
uint tscHi;
|
||
|
|
uint tscTmp;
|
||
|
|
for (int i = 0; i < 5; i++) {
|
||
|
|
do {
|
||
|
|
now = Processor.CycleCount;
|
||
|
|
tscLo = tsc0Lo;
|
||
|
|
tscHi = tsc0Hi;
|
||
|
|
tscTmp = tsc0Lo;
|
||
|
|
// Yield hardware thread on HT boxes
|
||
|
|
Thread.NativeNoOp();
|
||
|
|
} while (tscTmp != tscLo);
|
||
|
|
}
|
||
|
|
ulong tsc0 = (((ulong)tsc0Hi) << 32) + tsc0Lo;
|
||
|
|
if (tsc0 > now) {
|
||
|
|
Tracing.Log(Tracing.Audit, "Skew tsc-{0}",
|
||
|
|
new UIntPtr(tsc0 - now));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
Tracing.Log(Tracing.Audit, "Skew tsc+{0}",
|
||
|
|
new UIntPtr(now - tsc0));
|
||
|
|
}
|
||
|
|
tscOffset = (long)(now - tsc0);
|
||
|
|
SetMpSyncState(MpSyncState.ApTscCorrelationDone);
|
||
|
|
}
|
||
|
|
|
||
|
|
[Conditional("SINGULARITY_MP")]
|
||
|
|
[NoHeapAllocation]
|
||
|
|
private static void AnnounceApFail(int nextCpu)
|
||
|
|
{
|
||
|
|
MpSyncState localMpState = mpSyncState;
|
||
|
|
DebugStub.Print("MpState {0}", __arglist(localMpState));
|
||
|
|
DebugStub.Break();
|
||
|
|
BootInfo bi = BootInfo.GetBootInfo();
|
||
|
|
DebugStub.Print("Cpu {0} failed. ",
|
||
|
|
__arglist(nextCpu));
|
||
|
|
DebugStub.Print("GotBack-> Status {0} Count {1:x8}\n",
|
||
|
|
__arglist(bi.MpStatus32, bi.MpCpuCount));
|
||
|
|
}
|
||
|
|
|
||
|
|
[Conditional("SINGULARITY_MP")]
|
||
|
|
// [NoHeapAllocation]
|
||
|
|
private static void StartApProcessorsInternal()
|
||
|
|
{
|
||
|
|
// Currently we fire up all processors. They
|
||
|
|
// serialize on a spin lock in low memory.
|
||
|
|
int expectedCpus = GetProcessorCount();
|
||
|
|
int nextCpu = 1;
|
||
|
|
|
||
|
|
bool en = Processor.DisableInterrupts();
|
||
|
|
try {
|
||
|
|
do {
|
||
|
|
DebugStub.Print("Starting CPU {0} / {1}\n",
|
||
|
|
__arglist(nextCpu + 1,
|
||
|
|
expectedCpus));
|
||
|
|
SetMpSyncState(MpSyncState.BspWaitingForAp);
|
||
|
|
Tracing.Log(Tracing.Audit,
|
||
|
|
"Initializing cpu {0}", (uint)nextCpu);
|
||
|
|
nextKernelThread = Thread.PrepareKernelThread();
|
||
|
|
|
||
|
|
MpBootInfo.PrepareForCpuStart(nextCpu);
|
||
|
|
MpBootInfo mbi = MpBootInfo.GetMpBootInfo();
|
||
|
|
nextKernelStackBegin = mbi.KernelStackBegin;
|
||
|
|
nextKernelStackLimit = mbi.KernelStackLimit;
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit,
|
||
|
|
"Starting cpu {0}. Stack start {1:x8} base {2:x8} limit {3:x8})\n",
|
||
|
|
new UIntPtr(nextCpu),
|
||
|
|
mbi.KernelStackBegin,
|
||
|
|
mbi.KernelStack,
|
||
|
|
mbi.KernelStackLimit);
|
||
|
|
|
||
|
|
if (nextCpu == 1) {
|
||
|
|
BootInfo bi = BootInfo.GetBootInfo();
|
||
|
|
apic.BroadcastStartupIPI((byte) (bi.MpEnter32 >> 12));
|
||
|
|
}
|
||
|
|
|
||
|
|
bool success = false;
|
||
|
|
WaitForMpSyncState(MpSyncState.ApOnline, 500000,
|
||
|
|
out success);
|
||
|
|
if (!success) {
|
||
|
|
AnnounceApFail(nextCpu);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
SetMpSyncState(MpSyncState.BspWaitingForApCalibration);
|
||
|
|
|
||
|
|
WaitForMpSyncState(MpSyncState.ApCalibrationDone, 1000000,
|
||
|
|
out success);
|
||
|
|
if (!success) {
|
||
|
|
AnnounceApFail(nextCpu);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i = 0; i < TscCalibrationRounds; i++) {
|
||
|
|
BspSync(100000);
|
||
|
|
}
|
||
|
|
|
||
|
|
SetMpSyncState(MpSyncState.BspWaitingApRunning);
|
||
|
|
|
||
|
|
WaitForMpSyncState(MpSyncState.ApRunning, 100000,
|
||
|
|
out success);
|
||
|
|
if (!success) {
|
||
|
|
AnnounceApFail(nextCpu);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
Processor.RestoreInterrupts(en);
|
||
|
|
en = false;
|
||
|
|
DebugStub.Print("Cpu {0} running ({1} remaining).\n",
|
||
|
|
__arglist(nextCpu,
|
||
|
|
expectedCpus - nextCpu - 1));
|
||
|
|
} while (++nextCpu < expectedCpus);
|
||
|
|
DebugStub.Print("Done.");
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
DebugStub.Print("Reached finally block in HalDevices.StartApProcessorsInternal()");
|
||
|
|
Processor.RestoreInterrupts(en);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// [NoHeapAllocation]
|
||
|
|
public static void StartApProcessors()
|
||
|
|
{
|
||
|
|
if (GetProcessorCount() > 1) {
|
||
|
|
StartApProcessorsInternal();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static void FreezeProcessors()
|
||
|
|
{
|
||
|
|
apic.BroadcastFreezeIPI();
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static void SendFixedIPI(byte vector, int from, int to)
|
||
|
|
{
|
||
|
|
apic.SendFixedIPI(vector, from, to);
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static void BroadcastFixedIPI(byte vector, bool includeSelf)
|
||
|
|
{
|
||
|
|
apic.BroadcastFixedIPI(vector, includeSelf);
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static void ClearFixedIPI()
|
||
|
|
{
|
||
|
|
apic.ClearFixedIPI();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|