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_ISA_IRQ_COUNT   16
#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.

Variables
PROCESSOR_IDENTITY	HalpProcessorIdentity [MAXIMUM_PROCESSORS]

Macro Definition Documentation

HALP_APIC_INFO_TABLE_IOAPIC_NUMBER

#define HALP_APIC_INFO_TABLE_IOAPIC_NUMBER   256

Definition at line 23 of file smp.h.

HALP_APIC_MODE_LEGACY

#define HALP_APIC_MODE_LEGACY   0x00000010

Definition at line 40 of file smp.h.

HALP_ISA_IRQ_COUNT

#define HALP_ISA_IRQ_COUNT   16

Definition at line 24 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 107 of file apicsmp.c.

{
    APIC_VERSION_REGISTER ApicVersion;
 
    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);
 
    /* Give the APIC time to latch INIT before the first SIPI: MPS Spec - B.4 */
    KeStallExecutionProcessor(10000);
 
    /* 82489DX APICs don't support the STARTUP IPI: MPS Spec - B.4 */
    ApicVersion.Long = ApicRead(APIC_VER);
    if (ApicVersion.Version >= 0x10)
    {
        /* First Startup IPI */
        ApicRequestGlobalInterrupt(HalpProcessorIdentity[NTProcessorNumber].LapicId, (StartupLoc.LowPart) >> 12,
            APIC_MT_Startup, APIC_TGM_Edge, APIC_DSH_Destination);
 
        /* Stall between SIPIs: MPS Spec - B.4 */
        KeStallExecutionProcessor(200);
 
        /* Second Startup IPI, required unconditionally by the MP Spec */
        ApicRequestGlobalInterrupt(HalpProcessorIdentity[NTProcessorNumber].LapicId, (StartupLoc.LowPart) >> 12,
            APIC_MT_Startup, APIC_TGM_Edge, APIC_DSH_Destination);
 
        /* Give the AP time to come up before returning */
        KeStallExecutionProcessor(200);
    }
}

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 158 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 295 of file madt.c.

{
    ACPI_TABLE_MADT *MadtTable;
 
    MadtTable = HalAcpiGetTable(LoaderBlock, APIC_SIGNATURE);
    if (MadtTable && (MadtTable->Header.Length >= sizeof(*MadtTable)))
    {
        HalpApicInfoTable.LocalApicPA = MadtTable->Address;
        HalpMadtParseEntries(MadtTable);
    }
    else
    {
        HalpMadtTruncated = TRUE;
    }
 
    HalpMadtPlaceBootProcessor();
}

Referenced by HalpInitProcessor().

HalpPrintApicTables()

VOID HalpPrintApicTables

(

VOID

)

Definition at line 315 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);
    }
 
    for (i = 0; i < HALP_APIC_INFO_TABLE_IOAPIC_NUMBER; i++)
    {
        if (HalpApicInfoTable.IoApicPA[i] != 0)
        {
            DPRINT1(" I/O APIC %lu: Address 0x%08lx, GlobalIrqBase %lu\n",
                    i,
                    HalpApicInfoTable.IoApicPA[i],
                    HalpApicInfoTable.IoApicIrqBase[i]);
        }
    }
 
    if (HalpMadtTruncated || (HalpMadtIgnoredEntries != 0))
    {
        DPRINT1("MADT missing or malformed: %u, entries ignored: %lu\n",
                HalpMadtTruncated,
                HalpMadtIgnoredEntries);
    }
#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 237 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 183 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().

Variable Documentation

HalpProcessorIdentity

PROCESSOR_IDENTITY HalpProcessorIdentity[MAXIMUM_PROCESSORS]

extern

Definition at line 25 of file madt.c.

Referenced by ApicStartApplicationProcessor(), HalpMadtAddProcessor(), HalpMadtPlaceBootProcessor(), HalpPrintApicTables(), HalpSetupProcessorsTable(), and HalRequestIpiSpecifyVector().