BOOLEAN KeDisconnectInterrupt ( IN PKINTERRUPT Interrupt ) /*++ Routine Description: This function disconnects an interrupt object from the interrupt vector specified by the interrupt object. If the interrupt object is not connected, then a value of FALSE is returned. Else the specified interrupt object is disconnected from the interrupt vector, the connected state is set to FALSE, and TRUE is returned as the function value. Arguments: Interrupt - Supplies a pointer to a control object of type interrupt. Return Value: If the interrupt object is not connected, then a value of FALSE is returned. Else a value of TRUE is returned. --*/ { BOOLEAN Connected; PKINTERRUPT Interruptx; PKINTERRUPT Interrupty; KIRQL Irql; KIRQL OldIrql; KIRQL PreviousIrql; ULONG Vector; // // Set system affinity to the specified processor. // KeSetSystemAffinityThread((KAFFINITY)(1 << Interrupt->Number)); // // Raise IRQL to dispatcher level and lock dispatcher database. // KiLockDispatcherDatabase(&OldIrql); // // If the interrupt object is connected, then disconnect it from the // specified vector. // Connected = Interrupt->Connected; if (Connected != FALSE) { Irql = Interrupt->Irql; Vector = Interrupt->Vector; // // If the specified interrupt vector is not connected to the chained // interrupt dispatcher, then disconnect it by setting its dispatch // address to the unexpected interrupt routine. Else remove the // interrupt object from the interrupt chain. If there is only // one entry remaining in the list, then reestablish the dispatch // address. // Interruptx = CONTAINING_RECORD(PCR->InterruptRoutine[Vector], KINTERRUPT, DispatchCode[0]); if (Interruptx->DispatchAddress == (PKINTERRUPT_ROUTINE)KiChainedDispatch) { KeRaiseIrql((KIRQL)(max(Irql, SYNCH_LEVEL)), &PreviousIrql); if (Interrupt == Interruptx) { Interruptx = CONTAINING_RECORD(Interruptx->InterruptListEntry.Flink, KINTERRUPT, InterruptListEntry); Interruptx->DispatchAddress = (PKINTERRUPT_ROUTINE)KiChainedDispatch; Interruptx->DispatchCode[0] = *(PULONG)KiChainedDispatch; Interruptx->DispatchCode[1] = *(((PULONG)KiChainedDispatch)+1); PCR->InterruptRoutine[Vector] = (PKINTERRUPT_ROUTINE)Interruptx->DispatchCode; } RemoveEntryList(&Interrupt->InterruptListEntry); Interrupty = CONTAINING_RECORD(Interruptx->InterruptListEntry.Flink, KINTERRUPT, InterruptListEntry); if (Interruptx == Interrupty) { if (Interrupt->FloatingSave) { Interrupt->DispatchAddress = KiFloatingDispatch; } else { if (Interrupt->Irql == Interrupt->SynchronizeIrql) { #if defined(NT_UP) Interrupt->DispatchAddress = (PKINTERRUPT_ROUTINE)Interrupt->ServiceRoutine; #else Interrupt->DispatchAddress = (PKINTERRUPT_ROUTINE)KiInterruptDispatchSame; #endif } else { Interrupt->DispatchAddress = (PKINTERRUPT_ROUTINE)KiInterruptDispatchRaise; } } // // Copy the function descriptor for the Dispatch routine // into DispatchCode. This will be used by KiInterruptEx- // ception to dispatch the interrupt. // Interrupty->DispatchCode[0] = *(PULONG)(Interrupty->DispatchAddress); Interrupty->DispatchCode[1] = *(((PULONG)(Interrupty->DispatchAddress))+1); PCR->InterruptRoutine[Vector] = (PKINTERRUPT_ROUTINE)Interrupty->DispatchCode; } KeLowerIrql(PreviousIrql); } else { HalDisableSystemInterrupt(Vector, Irql); PCR->InterruptRoutine[Vector] = (PKINTERRUPT_ROUTINE)(&KxUnexpectedInterrupt.DispatchCode); } #ifdef NOTDEF KeSweepIcache(TRUE); #endif Interrupt->Connected = FALSE; } // // Unlock dispatcher database and lower IRQL to its previous value. // KiUnlockDispatcherDatabase(OldIrql); // // Set system affinity back to the original value. // KeRevertToUserAffinityThread(); // // Return whether interrupt was disconnected from the specified vector. // return Connected; }
BOOLEAN KeDisconnectInterrupt ( __inout PKINTERRUPT Interrupt ) /*++ Routine Description: This function disconnects an interrupt object from the interrupt vector specified by the interrupt object. If the interrupt object is not connected, then a value of FALSE is returned. Else the specified interrupt object is disconnected from the interrupt vector, the connected state is set to FALSE, and TRUE is returned as the function value. Arguments: Interrupt - Supplies a pointer to a control object of type interrupt. Return Value: If the interrupt object is not connected, then a value of FALSE is returned. Else a value of TRUE is returned. --*/ { DISPATCH_INFO DispatchInfo; BOOLEAN Connected; PKINTERRUPT Interrupty; KIRQL Irql; KIRQL OldIrql; ULONG Vector; // // Set system affinity to the specified processor. // KeSetSystemAffinityThread((KAFFINITY)(1<<Interrupt->Number)); // // Raise IRQL to dispatcher level and lock dispatcher database. // KiLockDispatcherDatabase(&OldIrql); // // If the interrupt object is connected, then disconnect it from the // specified vector. // Connected = Interrupt->Connected; if (Connected) { Irql = Interrupt->Irql; Vector = Interrupt->Vector; // // If the specified interrupt vector is not connected to the chained // interrupt dispatcher, then disconnect it by setting its dispatch // address to the unexpected interrupt routine. Else remove the // interrupt object from the interrupt chain. If there is only // one entry remaining in the list, then reestablish the dispatch // address. // // // Determine interrupt dispatch vector // KiGetVectorInfo ( Vector, &DispatchInfo ); // // Is dispatch a chained handler? // if (DispatchInfo.Type == ChainConnect) { ASSERT (Irql <= SYNCH_LEVEL); // // Is interrupt being removed from head? // if (Interrupt == DispatchInfo.Interrupt) { // // Update next interrupt object to be head // DispatchInfo.Interrupt = CONTAINING_RECORD( DispatchInfo.Interrupt->InterruptListEntry.Flink, KINTERRUPT, InterruptListEntry ); KiConnectVectorAndInterruptObject (DispatchInfo.Interrupt, ChainConnect); } // // Remove interrupt object // RemoveEntryList(&Interrupt->InterruptListEntry); // // If there's only one interrupt object left on this vector, // determine proper interrupt dispatcher // Interrupty = CONTAINING_RECORD( DispatchInfo.Interrupt->InterruptListEntry.Flink, KINTERRUPT, InterruptListEntry ); if (DispatchInfo.Interrupt == Interrupty) { KiConnectVectorAndInterruptObject (Interrupty, NormalConnect); } } else { // // Removing last interrupt object from the vector. Disable the // vector, and set it to unconnected // HalDisableSystemInterrupt(Interrupt->Vector, Irql); KiConnectVectorAndInterruptObject (Interrupt, NoConnect); } KeSweepIcache(TRUE); Interrupt->Connected = FALSE; } // // Unlock dispatcher database and lower IRQL to its previous value. // KiUnlockDispatcherDatabase(OldIrql); // // Set system affinity back to the original value. // KeRevertToUserAffinityThread(); // // Return whether interrupt was disconnected from the specified vector. // return Connected; }
VOID KeInitializeInterrupt ( IN PKINTERRUPT Interrupt, IN PKSERVICE_ROUTINE ServiceRoutine, IN PVOID ServiceContext, IN PKSPIN_LOCK SpinLock OPTIONAL, IN ULONG Vector, IN KIRQL Irql, IN KIRQL SynchronizeIrql, IN KINTERRUPT_MODE InterruptMode, IN BOOLEAN ShareVector, IN CCHAR ProcessorNumber, IN BOOLEAN FloatingSave ) /*++ Routine Description: This function initializes a kernel interrupt object. The service routine, service context, spin lock, vector, IRQL, Synchronized IRQL, and floating context save flag are initialized. Arguments: Interrupt - Supplies a pointer to a control object of type interrupt. ServiceRoutine - Supplies a pointer to a function that is to be executed when an interrupt occurs via the specified interrupt vector. ServiceContext - Supplies a pointer to an arbitrary data structure which is to be passed to the function specified by the ServiceRoutine parameter. SpinLock - Supplies an optional pointer to an executive spin lock. Vector - Supplies the index of the entry in the Interrupt Dispatch Table that is to be associated with the ServiceRoutine function. Irql - Supplies the request priority of the interrupting source. SynchronizeIrql - The request priority that the interrupt should be synchronized with. InterruptMode - Supplies the mode of the interrupt; LevelSensitive or Latched. ShareVector - Supplies a boolean value that specifies whether the vector can be shared with other interrupt objects or not. If FALSE then the vector may not be shared, if TRUE it may be. Latched. ProcessorNumber - Supplies the number of the processor to which the interrupt will be connected. FloatingSave - Supplies a boolean value that determines whether the floating point registers and pipe line are to be saved before calling the ServiceRoutine function. Return Value: None. --*/ { LONG Index; // // Initialize standard control object header. // Interrupt->Type = InterruptObject; Interrupt->Size = sizeof(KINTERRUPT); // // Initialize the address of the service routine, the service context, // the address of the spin lock, the address of the actual spin lock // that will be used, the vector number, the IRQL of the interrupting // source, the Synchronized IRQL of the interrupt object, the interrupt // mode, the processor number, and the floating context save flag. // Interrupt->ServiceRoutine = ServiceRoutine; Interrupt->ServiceContext = ServiceContext; if (ARGUMENT_PRESENT(SpinLock)) { Interrupt->ActualLock = SpinLock; } else { Interrupt->SpinLock = 0; Interrupt->ActualLock = &Interrupt->SpinLock; } Interrupt->Vector = Vector; Interrupt->Irql = Irql; Interrupt->SynchronizeIrql = SynchronizeIrql; Interrupt->Mode = InterruptMode; Interrupt->ShareVector = ShareVector; Interrupt->Number = ProcessorNumber; Interrupt->FloatingSave = FloatingSave; // // Copy the interrupt dispatch code template into the interrupt object // and flush the dcache on all processors that the current thread can // run on to ensure that the code is actually in memory. // for (Index = 0; Index < DISPATCH_LENGTH; Index += 1) { Interrupt->DispatchCode[Index] = KiInterruptTemplate[Index]; } KeSweepIcache(FALSE); // // Set the connected state of the interrupt object to FALSE. // Interrupt->Connected = FALSE; return; }