IoConnectInterrupt个人注释

/*
 * @implemented
 来看一下跟中断对象有关的两个对象:
 typedef struct _IO_INTERRUPT
{
    KINTERRUPT FirstInterrupt;
    PKINTERRUPT Interrupt[MAXIMUM_PROCESSORS];
    KSPIN_LOCK SpinLock;
} IO_INTERRUPT, *PIO_INTERRUPT;

 typedef struct _KINTERRUPT
 {
	 CSHORT Type;
	 CSHORT Size;
	 LIST_ENTRY InterruptListEntry;
	 PKSERVICE_ROUTINE ServiceRoutine;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
	 PKSERVICE_ROUTINE MessageServiceRoutine;
	 ULONG MessageIndex;
#endif
	...
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
	 ULONGLONG Rsvd1;
#endif
	 //指向INT_PROLOG代码段地址
	 ULONG DispatchCode[KINTERRUPT_DISPATCH_CODES];
 } KINTERRUPT, *PKINTERRUPT;
安装中断过程势必分配一个中断对象KINTERRUPT，对于单个CPU。
如果主机上有多个CPU，那就必须为每个CPU分配相同的
中断对象，这样，不同的CPU接到中断信号后才能有相同
的处理过程。
如果有这么多功能相同的却离散分布的中断对象，管理
起来比较麻烦，于是Reactos为这些具有相同处理过程的中断对象
分配一个统一的管理对象_IO_INTERRUPT，把同一类中断对象装入到
这个_IO_INTERRUPT结构中去

如此看来_KINTERRUPT是实际的处理者，而_IO_INTERRUPT更像一个管理者
 */

NTSTATUS
NTAPI
IoConnectInterrupt(OUT PKINTERRUPT *InterruptObject,
                   IN PKSERVICE_ROUTINE ServiceRoutine,
                   IN PVOID ServiceContext,
                   IN PKSPIN_LOCK SpinLock,
                   IN ULONG Vector,
                   IN KIRQL Irql,
                   IN KIRQL SynchronizeIrql,
                   IN KINTERRUPT_MODE InterruptMode,
                   IN BOOLEAN ShareVector,
                   IN KAFFINITY ProcessorEnableMask,
                   IN BOOLEAN FloatingSave)
{
    PKINTERRUPT Interrupt;
    PKINTERRUPT InterruptUsed;
	//IO_INTERRUPT:具有相同中断处理函数的CPU的集合
    PIO_INTERRUPT IoInterrupt;
    PKSPIN_LOCK SpinLockUsed;
    BOOLEAN FirstRun = TRUE;
    CCHAR Count = 0;
    KAFFINITY Affinity;
    PAGED_CODE();

    /* Assume failure */
    *InterruptObject = NULL;

    /* Get the affinity */
    Affinity = ProcessorEnableMask & KeActiveProcessors;
    while (Affinity)
    {
        /* Increase count */
        if (Affinity & 1) Count++;
        Affinity >>= 1;
    }

    /* Make sure we have a valid CPU count */
    if (!Count) return STATUS_INVALID_PARAMETER;

    /* Allocate the array of I/O Interrupts */
	/*
	Count>1 针对多CPU的情况. struct _IO_INTERRUPT IoInterrupt是用于管理多CPU中断处理的结构
	IoInterrupt->KINTERRUPT[0]->ISR
	                ->KINTERRUPT[1]->ISR
	                ->KINTERRUPT[2]->ISR
	这么说，在SMP结构中调用一次IoConnectInterrupt就会为所有具有中断处理能力的
	CPU都安装相同的中断处理过程(即中断对象)
	*/
	/*
	主要是分配IO_INTERRUPT--中断对象的管理者，其次才是在这个对象的尾部跟上诺干
	数量上和系统中具有该中断处理能力的CPU的中断对象

	当本函数后面KeInitializeInterrupt/KeConnectInterrupt调用完成后，将这个中断对象添加到
	IO_INTERRUPT管理者中
	*/
    IoInterrupt = ExAllocatePoolWithTag(NonPagedPool,
                                        (Count - 1) * sizeof(KINTERRUPT) +
                                        sizeof(IO_INTERRUPT),
                                        TAG_KINTERRUPT);
    if (!IoInterrupt) return STATUS_INSUFFICIENT_RESOURCES;

    /* Select which Spinlock to use */
    SpinLockUsed = SpinLock ? SpinLock : &IoInterrupt->SpinLock;

    /* We first start with a built-in Interrupt inside the I/O Structure */
    *InterruptObject = &IoInterrupt->FirstInterrupt;
    Interrupt = (PKINTERRUPT)(IoInterrupt + 1);
    FirstRun = TRUE;

    /* Start with a fresh structure */
    RtlZeroMemory(IoInterrupt, sizeof(IO_INTERRUPT));

    /* Now create all the interrupts */
    Affinity = ProcessorEnableMask & KeActiveProcessors;
	//初始化IO_INTERRUPT中每个KINTERRUPT结构
    for (Count = 0; Affinity; Count++, Affinity >>= 1)
    {
        /* Check if it's enabled for this CPU */
		//Affinity & 1-->具有处理能力的CPU
        if (Affinity & 1)
        {
            /* Check which one we will use */
            InterruptUsed = FirstRun ? &IoInterrupt->FirstInterrupt : Interrupt;

            /* Initialize it */
            KeInitializeInterrupt(InterruptUsed,
                                  ServiceRoutine,
                                  ServiceContext,
                                  SpinLockUsed,
                                  Vector,
                                  Irql,
                                  SynchronizeIrql,
                                  InterruptMode,
                                  ShareVector,
                                  Count,
                                  FloatingSave);

            /* Connect it */
            if (!KeConnectInterrupt(InterruptUsed))
            {
                /* Check how far we got */
                if (FirstRun)
                {
                    /* We failed early so just free this */
                    ExFreePool(IoInterrupt);
                }
                else
                {
                    /* Far enough, so disconnect everything */
                    IoDisconnectInterrupt(&IoInterrupt->FirstInterrupt);
                }

                /* And fail */
                return STATUS_INVALID_PARAMETER;
            }

            /* Now we've used up our First Run */
            if (FirstRun)
            {
            	//处理完FirstInterrupt，即将对其他CPU进行处理
                FirstRun = FALSE;
            }
            else
            {
                /* Move on to the next one */
				/*
				前面针对多处理器分配了多个中断处理对象，把经过处理的
				KINTERRUPT结构加入到IoInterrupt管理机构中
				(意即:这些CPU上已有这种中断处理程序)
				*/
                IoInterrupt->Interrupt[(UCHAR)Count] = Interrupt++;
            }
        }
    }

    /* Return Success */
    return STATUS_SUCCESS;
}