smp.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_PROCESSOR_IDENTITY
struct	_HALP_APIC_INFO_TABLE

Macros
#define	HALP_APIC_INFO_TABLE_IOAPIC_NUMBER   256
#define	HALP_APIC_MODE_LEGACY   0x00000010

Typedefs
typedef struct _PROCESSOR_IDENTITY	PROCESSOR_IDENTITY
typedef struct _PROCESSOR_IDENTITY *	PPROCESSOR_IDENTITY
typedef struct _HALP_APIC_INFO_TABLE	HALP_APIC_INFO_TABLE
typedef struct _HALP_APIC_INFO_TABLE *	PHALP_APIC_INFO_TABLE

Functions
VOID	HalpParseApicTables (_In_ PLOADER_PARAMETER_BLOCK LoaderBlock)
VOID	HalpSetupProcessorsTable (_In_ UINT32 NTProcessorNumber)
VOID	HalpPrintApicTables (VOID)
VOID FASTCALL	HalpBroadcastClockIpi (_In_ UCHAR Vector)
VOID	ApicStartApplicationProcessor (_In_ ULONG NTProcessorNumber, _In_ PHYSICAL_ADDRESS StartupLoc)
VOID NTAPI	HalpRequestIpi (_In_ KAFFINITY TargetProcessors)
	Requests an IPI interrupt on the specified processors.
VOID NTAPI	HalpBroadcastIpiSpecifyVector (_In_ UCHAR Vector, _In_ BOOLEAN IncludeSelf)
	Broadcasts an IPI with a specified vector to all processors.
VOID NTAPI	HalRequestIpiSpecifyVector (_In_ KAFFINITY TargetSet, _In_ UCHAR Vector)
	Requests an IPI with a specified vector on the specified processors.

Macro Definition Documentation

HALP_APIC_INFO_TABLE_IOAPIC_NUMBER

#define HALP_APIC_INFO_TABLE_IOAPIC_NUMBER   256

Definition at line 21 of file smp.h.

HALP_APIC_MODE_LEGACY

#define HALP_APIC_MODE_LEGACY   0x00000010

Definition at line 35 of file smp.h.

Typedef Documentation

HALP_APIC_INFO_TABLE

typedef struct _HALP_APIC_INFO_TABLE HALP_APIC_INFO_TABLE

PHALP_APIC_INFO_TABLE

typedef struct _HALP_APIC_INFO_TABLE * PHALP_APIC_INFO_TABLE

PPROCESSOR_IDENTITY

typedef struct _PROCESSOR_IDENTITY * PPROCESSOR_IDENTITY

PROCESSOR_IDENTITY

typedef struct _PROCESSOR_IDENTITY PROCESSOR_IDENTITY

Function Documentation

ApicStartApplicationProcessor()

VOID ApicStartApplicationProcessor	(	_In_ ULONG	NTProcessorNumber,
		_In_ PHYSICAL_ADDRESS	StartupLoc
	)

Definition at line 110 of file apicsmp.c.

{
    ASSERT(StartupLoc.HighPart == 0);
    ASSERT((StartupLoc.QuadPart & 0xFFF) == 0);
    ASSERT((StartupLoc.QuadPart & 0xFFF00FFF) == 0);
 
    /* Init IPI */
    ApicRequestGlobalInterrupt(HalpProcessorIdentity[NTProcessorNumber].LapicId, 0,
        APIC_MT_INIT, APIC_TGM_Edge, APIC_DSH_Destination);
 
    /* De-Assert Init IPI */
    ApicRequestGlobalInterrupt(HalpProcessorIdentity[NTProcessorNumber].LapicId, 0,
        APIC_MT_INIT, APIC_TGM_Level, APIC_DSH_Destination);
 
    /* Stall execution for a bit to give APIC time: MPS Spec - B.4 */
    KeStallExecutionProcessor(200);
 
    /* Startup IPI */
    ApicRequestGlobalInterrupt(HalpProcessorIdentity[NTProcessorNumber].LapicId, (StartupLoc.LowPart) >> 12,
        APIC_MT_Startup, APIC_TGM_Edge, APIC_DSH_Destination);
}

Referenced by HalStartNextProcessor().

HalpBroadcastClockIpi()

VOID FASTCALL HalpBroadcastClockIpi

(

_In_ UCHAR

Vector

)

Definition at line 45 of file up.c.

{
    NOTHING;
}

Referenced by HalpClockInterruptHandler().

HalpBroadcastIpiSpecifyVector()

VOID NTAPI HalpBroadcastIpiSpecifyVector	(	_In_ UCHAR	Vector,
		_In_ BOOLEAN	IncludeSelf
	)

Broadcasts an IPI with a specified vector to all processors.

Parameters

Vector	- Specifies the interrupt vector to be delivered.
IncludeSelf	- Specifies whether to include the current processor.

Definition at line 144 of file apicsmp.c.

{
    APIC_DSH DestinationShortHand = IncludeSelf ?
        APIC_DSH_AllIncludingSelf : APIC_DSH_AllExcludingSelf;
 
    /* Request the interrupt targeted at all processors */
    ApicRequestGlobalInterrupt(0, // Ignored
                               Vector,
                               APIC_MT_Fixed,
                               APIC_TGM_Edge,
                               DestinationShortHand);
}

Referenced by HalpBroadcastClockIpi(), and HalRequestIpiSpecifyVector().

HalpParseApicTables()

VOID HalpParseApicTables

(

_In_ PLOADER_PARAMETER_BLOCK

LoaderBlock

)

Definition at line 55 of file madt.c.

{
    ACPI_TABLE_MADT *MadtTable;
    ACPI_SUBTABLE_HEADER *AcpiHeader;
    ULONG_PTR TableEnd;
 
    MadtTable = HalAcpiGetTable(LoaderBlock, APIC_SIGNATURE);
    if (!MadtTable)
    {
        DPRINT01("MADT table not found\n");
        return;
    }
 
    if (MadtTable->Header.Length < sizeof(*MadtTable))
    {
        DPRINT01("Length is too short: %p, %u\n", MadtTable, MadtTable->Header.Length);
        return;
    }
 
    DPRINT00("MADT table: Address %08X, Flags %08X\n", MadtTable->Address, MadtTable->Flags);
 
#if 1
 
    // TODO: We support only legacy APIC for now
    HalpApicInfoTable.ApicMode = HALP_APIC_MODE_LEGACY;
    // TODO: What about 'MadtTable->Flags & ACPI_MADT_PCAT_COMPAT'?
 
#else // TODO: Is that correct?
 
    if ((MadtTable->Flags & ACPI_MADT_PCAT_COMPAT) == ACPI_MADT_DUAL_PIC)
    {
        HalpApicInfoTable.ApicMode = HALP_APIC_MODE_LEGACY;
    }
    else // if ((MadtTable->Flags & ACPI_MADT_PCAT_COMPAT) == ACPI_MADT_MULTIPLE_APIC)
    {
#if 1
        DPRINT01("ACPI_MADT_MULTIPLE_APIC support is UNIMPLEMENTED\n");
        return;
#else
        HalpApicInfoTable.ApicMode = HALP_APIC_MODE_xyz;
#endif
    }
 
#endif
 
    HalpApicInfoTable.LocalApicPA = MadtTable->Address;
 
    AcpiHeader = (ACPI_SUBTABLE_HEADER *)((ULONG_PTR)MadtTable + sizeof(*MadtTable));
    TableEnd = (ULONG_PTR)MadtTable + MadtTable->Header.Length;
    DPRINT00(" MadtTable %p, subtables %p - %p\n", MadtTable, AcpiHeader, (PVOID)TableEnd);
 
    while ((ULONG_PTR)(AcpiHeader + 1) <= TableEnd)
    {
        if (AcpiHeader->Length < sizeof(*AcpiHeader))
        {
            DPRINT01("Length is too short: %p, %u\n", AcpiHeader, AcpiHeader->Length);
            return;
        }
 
        if ((ULONG_PTR)AcpiHeader + AcpiHeader->Length > TableEnd)
        {
            DPRINT01("Length mismatch: %p, %u, %p\n",
                     AcpiHeader, AcpiHeader->Length, (PVOID)TableEnd);
            return;
        }
 
        switch (AcpiHeader->Type)
        {
            case ACPI_MADT_TYPE_LOCAL_APIC:
            {
                ACPI_MADT_LOCAL_APIC *LocalApic = (ACPI_MADT_LOCAL_APIC *)AcpiHeader;
 
                if (AcpiHeader->Length != sizeof(*LocalApic))
                {
                    DPRINT01("Type/Length mismatch: %p, %u\n", AcpiHeader, AcpiHeader->Length);
                    return;
                }
 
                DPRINT00(" Local Apic, Processor %lu: ProcessorId %u, Id %u, LapicFlags %08X\n",
                         HalpApicInfoTable.ProcessorCount,
                         LocalApic->ProcessorId, LocalApic->Id, LocalApic->LapicFlags);
 
                if (!(LocalApic->LapicFlags & (LAPIC_FLAG_ONLINE_CAPABLE | LAPIC_FLAG_ENABLED)))
                {
                    DPRINT00("  Ignored: unusable\n");
                    break;
                }
 
                if (HalpApicInfoTable.ProcessorCount == _countof(HalpStaticProcessorIdentity))
                {
                    DPRINT00("  Skipped: array is full\n");
                    // We assume ignoring this processor is acceptable, until proven otherwise.
                    break;
                }
 
                // Note: ProcessorId and Id are not validated in any way (yet).
                HalpProcessorIdentity[HalpApicInfoTable.ProcessorCount].ProcessorId =
                    LocalApic->ProcessorId;
                HalpProcessorIdentity[HalpApicInfoTable.ProcessorCount].LapicId = LocalApic->Id;
 
                HalpApicInfoTable.ProcessorCount++;
 
                break;
            }
            case ACPI_MADT_TYPE_IO_APIC:
            {
                ACPI_MADT_IO_APIC *IoApic = (ACPI_MADT_IO_APIC *)AcpiHeader;
 
                if (AcpiHeader->Length != sizeof(*IoApic))
                {
                    DPRINT01("Type/Length mismatch: %p, %u\n", AcpiHeader, AcpiHeader->Length);
                    return;
                }
 
                DPRINT00(" Io Apic: Id %u, Address %08X, GlobalIrqBase %08X\n",
                         IoApic->Id, IoApic->Address, IoApic->GlobalIrqBase);
 
                // Ensure HalpApicInfoTable.IOAPICCount consistency.
                if (HalpApicInfoTable.IoApicPA[IoApic->Id] != 0)
                {
                    DPRINT01("Id duplication: %p, %u\n", IoApic, IoApic->Id);
                    return;
                }
 
                // Note: Address and GlobalIrqBase are not validated in any way (yet).
                HalpApicInfoTable.IoApicPA[IoApic->Id] = IoApic->Address;
                HalpApicInfoTable.IoApicIrqBase[IoApic->Id] = IoApic->GlobalIrqBase;
 
                HalpApicInfoTable.IOAPICCount++;
 
                break;
            }
            case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
            {
                ACPI_MADT_INTERRUPT_OVERRIDE *InterruptOverride =
                    (ACPI_MADT_INTERRUPT_OVERRIDE *)AcpiHeader;
 
                if (AcpiHeader->Length != sizeof(*InterruptOverride))
                {
                    DPRINT01("Type/Length mismatch: %p, %u\n", AcpiHeader, AcpiHeader->Length);
                    return;
                }
 
                DPRINT00(" Interrupt Override: Bus %u, SourceIrq %u, GlobalIrq %08X, IntiFlags %04X / UNIMPLEMENTED\n",
                         InterruptOverride->Bus, InterruptOverride->SourceIrq,
                         InterruptOverride->GlobalIrq, InterruptOverride->IntiFlags);
 
                if (InterruptOverride->Bus != 0) // 0 = ISA
                {
                    DPRINT01("Invalid Bus: %p, %u\n", InterruptOverride, InterruptOverride->Bus);
                    return;
                }
 
#if 1
                // TODO: Implement it.
#else // TODO: Is that correct?
                if (InterruptOverride->SourceIrq > _countof(HalpPicVectorRedirect))
                {
                    DPRINT01("Invalid SourceIrq: %p, %u\n",
                             InterruptOverride, InterruptOverride->SourceIrq);
                    return;
                }
 
                // Note: GlobalIrq is not validated in any way (yet).
                HalpPicVectorRedirect[InterruptOverride->SourceIrq] = InterruptOverride->GlobalIrq;
                // TODO: What about 'InterruptOverride->IntiFlags'?
#endif
 
                break;
            }
            default:
            {
                DPRINT01(" UNIMPLEMENTED: Type %u, Length %u\n",
                         AcpiHeader->Type, AcpiHeader->Length);
                return;
            }
        }
 
        AcpiHeader = (ACPI_SUBTABLE_HEADER *)((ULONG_PTR)AcpiHeader + AcpiHeader->Length);
    }
 
    if ((ULONG_PTR)AcpiHeader != TableEnd)
    {
        DPRINT01("Length mismatch: %p, %p, %p\n", MadtTable, AcpiHeader, (PVOID)TableEnd);
        return;
    }
}

Referenced by HalpInitProcessor().

HalpPrintApicTables()

VOID HalpPrintApicTables

(

VOID

)

Definition at line 245 of file madt.c.

{
#if DBG
    ULONG i;
 
    DPRINT1("Physical processor count: %lu\n", HalpApicInfoTable.ProcessorCount);
    for (i = 0; i < HalpApicInfoTable.ProcessorCount; i++)
    {
        DPRINT1(" Processor %lu: ProcessorId %u, LapicId %u, ProcessorStarted %u, BSPCheck %u, ProcessorPrcb %p\n",
                i,
                HalpProcessorIdentity[i].ProcessorId,
                HalpProcessorIdentity[i].LapicId,
                HalpProcessorIdentity[i].ProcessorStarted,
                HalpProcessorIdentity[i].BSPCheck,
                HalpProcessorIdentity[i].ProcessorPrcb);
    }
#endif
}

Referenced by HalpInitPhase0().

HalpRequestIpi()

VOID NTAPI HalpRequestIpi

(

_In_ KAFFINITY

TargetSet

)

Requests an IPI interrupt on the specified processors.

Parameters

TargetSet

- Specifies the set of processors to send the IPI to.

Definition at line 223 of file apicsmp.c.

{
    /* Request the IPI vector */
    HalRequestIpiSpecifyVector(TargetSet, APIC_IPI_VECTOR);
}

Referenced by HalRequestIpi().

HalpSetupProcessorsTable()

VOID HalpSetupProcessorsTable

(

_In_ UINT32

NTProcessorNumber

)

Definition at line 37 of file up.c.

{
    NOTHING;
}

Referenced by HalpInitProcessor().

HalRequestIpiSpecifyVector()

VOID NTAPI HalRequestIpiSpecifyVector	(	_In_ KAFFINITY	TargetSet,
		_In_ UCHAR	Vector
	)

Requests an IPI with a specified vector on the specified processors.

Parameters

TargetSet	- Specifies the set of processors to send the IPI to.
Vector	- Specifies the interrupt vector to be delivered.

Remarks

This function is exported on Windows 10.

Definition at line 169 of file apicsmp.c.

{
    KAFFINITY ActiveProcessors = HalpActiveProcessors;
    KAFFINITY RemainingSet, SetMember;
    ULONG ProcessorIndex;
    ULONG LApicId;
 
    /* Sanitize the target set */
    TargetSet &= ActiveProcessors;
 
    /* Check if all processors are requested */
    if (TargetSet == ActiveProcessors)
    {
        /* Send an IPI to all processors, including this processor */
        HalpBroadcastIpiSpecifyVector(Vector, TRUE);
        return;
    }
 
    /* Check if all processors except the current one are requested */
    if (TargetSet == (ActiveProcessors & ~KeGetCurrentPrcb()->SetMember))
    {
        /* Send an IPI to all processors, excluding this processor */
        HalpBroadcastIpiSpecifyVector(Vector, FALSE);
        return;
    }
 
    /* Loop while we have more processors */
    RemainingSet = TargetSet;
    while (RemainingSet != 0)
    {
        NT_VERIFY(BitScanForwardAffinity(&ProcessorIndex, RemainingSet) != 0);
        ASSERT(ProcessorIndex < KeNumberProcessors);
        SetMember = AFFINITY_MASK(ProcessorIndex);
        RemainingSet &= ~SetMember;
 
        /* Send the interrupt to the target processor */
        LApicId = HalpProcessorIdentity[ProcessorIndex].LapicId;
        ApicRequestGlobalInterrupt(LApicId,
                                   Vector,
                                   APIC_MT_Fixed,
                                   APIC_TGM_Edge,
                                   APIC_DSH_Destination);
    }
}

Referenced by HalpRequestIpi().