reactos操作系统实现(96)

调用函数IoConnectInterrupt来设置键中断处理函数。

#028     Status = IoConnectInterrupt(

#029         &PortDeviceExtension->KeyboardInterrupt.Object,

#030         i8042KbdInterruptService,

#031         DeviceExtension, &PortDeviceExtension->SpinLock,

#032         PortDeviceExtension->KeyboardInterrupt.Vector, PortDeviceExtension->KeyboardInterrupt.Dirql, DirqlMax,

#033         PortDeviceExtension->KeyboardInterrupt.InterruptMode, PortDeviceExtension->KeyboardInterrupt.ShareInterrupt,

#034         PortDeviceExtension->KeyboardInterrupt.Affinity, FALSE);

#035     if (!NT_SUCCESS(Status))

#036     {

#037         WARN_(I8042PRT, "IoConnectInterrupt() failed with status 0x%08x/n", Status);

#038         return Status;

#039     }

#040 

 

设置最大的请求级别。

#041     if (DirqlMax == PortDeviceExtension->KeyboardInterrupt.Dirql)

#042         PortDeviceExtension->HighestDIRQLInterrupt = PortDeviceExtension->KeyboardInterrupt.Object;

 

设置键盘已经初始化。

#043     PortDeviceExtension->Flags |= KEYBOARD_INITIALIZED;

#044     return STATUS_SUCCESS;

#045  }

 

其实是调用IO管理器里的中断设置函数IoConnectInterrupt，实现如下：

#001  NTSTATUS

#002  NTAPI

#003  IoConnectInterrupt(OUT PKINTERRUPT *InterruptObject,

#004                     IN PKSERVICE_ROUTINE ServiceRoutine,

#005                     IN PVOID ServiceContext,

#006                     IN PKSPIN_LOCK SpinLock,

#007                     IN ULONG Vector,

#008                     IN KIRQL Irql,

#009                     IN KIRQL SynchronizeIrql,

#010                     IN KINTERRUPT_MODE InterruptMode,

#011                     IN BOOLEAN ShareVector,

#012                     IN KAFFINITY ProcessorEnableMask,

#013                     IN BOOLEAN FloatingSave)

#014  {

InterruptObject是返回中断处理对象。

ServiceRoutine是中断调用函数。

ServiceContext是中断调用函数使用的参数。

SpinLock是访问输入参数的自旋锁。

Vector是PNP管理器分配的中断号。

Irql是中断请求优先级。

SynchronizeIrql是同步请求优先级。

InterruptMode是中断的模式。

ShareVector是中断资源是否共享。

ProcessorEnableMask是中断允许发生的处理器。

FloatingSave指明是否保存浮点堆栈。

 

#015      PKINTERRUPT Interrupt;

#016      PKINTERRUPT InterruptUsed;

#017      PIO_INTERRUPT IoInterrupt;

#018      PKSPIN_LOCK SpinLockUsed;

#019      BOOLEAN FirstRun;

#020      CCHAR Count = 0;

#021      KAFFINITY Affinity;

#022      PAGED_CODE();

#023 

 

假定失败的返回结果。

#024      /* Assume failure */

#025      *InterruptObject = NULL;

#026 

 

获取处理器位。

#027      /* Get the affinity */

#028      Affinity = ProcessorEnableMask & KeActiveProcessors;

#029      while (Affinity)

#030      {

#031          /* Increase count */

#032          if (Affinity & 1) Count++;

#033          Affinity >>= 1;

#034      }

#035 

 

确保这个CPU有中断响应。

#036      /* Make sure we have a valid CPU count */

#037      if (!Count) return STATUS_INVALID_PARAMETER;

#038 

 

分配一个IO中断结构。

#039      /* Allocate the array of I/O Interrupts */

#040      IoInterrupt = ExAllocatePoolWithTag(NonPagedPool,

#041                                          (Count - 1) * sizeof(KINTERRUPT) +

#042                                          sizeof(IO_INTERRUPT),

#043                                          TAG_KINTERRUPT);

#044      if (!IoInterrupt) return STATUS_INSUFFICIENT_RESOURCES;

#045 

 

如果驱动程序传入自旋锁，就使用驱动程序的，否则就使用内核分配的。

#046      /* Select which Spinlock to use */

#047      SpinLockUsed = SpinLock ? SpinLock : &IoInterrupt->SpinLock;

#048 

 

设置返回的中断对象。

#049      /* We first start with a built-in Interrupt inside the I/O Structure */

#050      *InterruptObject = &IoInterrupt->FirstInterrupt;

#051      Interrupt = (PKINTERRUPT)(IoInterrupt + 1);

#052      FirstRun = TRUE;

#053 

 

初始化中断对象结构。

#054      /* Start with a fresh structure */

#055      RtlZeroMemory(IoInterrupt, sizeof(IO_INTERRUPT));

#056 

 

开始创建所有CPU的中断。

#057      /* Now create all the interrupts */

#058      Affinity = ProcessorEnableMask & KeActiveProcessors;

#059      for (Count = 0; Affinity; Count++, Affinity >>= 1)

#060      {

 

检查这个CPU是否有中断设置。

#061          /* Check if it's enabled for this CPU */

#062          if (Affinity & 1)

#063          {

 

是否第一个CPU中断设置。

#064              /* Check which one we will use */

#065              InterruptUsed = FirstRun ? &IoInterrupt->FirstInterrupt : Interrupt;

#066 

 

设置中断对象。

#067              /* Initialize it */

#068              KeInitializeInterrupt(InterruptUsed,

#069                                    ServiceRoutine,

#070                                    ServiceContext,

#071                                    SpinLockUsed,

#072                                    Vector,

#073                                    Irql,

#074                                    SynchronizeIrql,

#075                                    InterruptMode,

#076                                    ShareVector,

#077                                    Count,

#078                                    FloatingSave);

#079 

#080              /* Connect it */

 

调用内核函数KeConnectInterrupt设置中断。

#081              if (!KeConnectInterrupt(InterruptUsed))

#082              {

#083                  /* Check how far we got */

#084                  if (FirstRun)

#085                  {

#086                      /* We failed early so just free this */

#087                      ExFreePool(IoInterrupt);

#088                  }

#089                  else

#090                  {

 

如果没有设置中断成功，就返回出错。

#091                      /* Far enough, so disconnect everything */

#092                      IoDisconnectInterrupt(&IoInterrupt->FirstInterrupt);

#093                  }

#094 

#095                  /* And fail */

#096                  return STATUS_INVALID_PARAMETER;

#097              }

#098 

 

设置第一个中断响应，已经设置完成。

#099              /* Now we've used up our First Run */

#100              if (FirstRun)

#101              {

#102                  FirstRun = FALSE;

#103              }

#104              else

#105              {

 

把其它CPU的中断放到队列后面。

#106                  /* Move on to the next one */

#107                  IoInterrupt->Interrupt[(UCHAR)Count] = Interrupt++;

#108              }

#109          }

#110      }

#111 

#112      /* Return Success */

#113      return STATUS_SUCCESS;

#114  }

 

在这个函数主要到两个内核函数来设置中断，它就是函数KeInitializeInterrupt 和KeConnectInterrupt。下来分析函数KeConnectInterrupt实现，看看它是怎么样把中断服务器与内核连接在一起的，如下：

#001  BOOLEAN

#002  NTAPI

#003  KeConnectInterrupt(IN PKINTERRUPT Interrupt)

#004  {

#005      BOOLEAN Connected, Error, Status;

#006      KIRQL Irql, OldIrql;

#007      UCHAR Number;

#008      ULONG Vector;

#009      DISPATCH_INFO Dispatch;

#010 

 

从中断里获取中断号所在CPU、中断向量、中断优先级。

#011      /* Get data from interrupt */

#012      Number = Interrupt->Number;

#013      Vector = Interrupt->Vector;

#014      Irql = Interrupt->Irql;

#015 

 

检查参数是否有效。

#016      /* Validate the settings */

#017      if ((Irql > HIGH_LEVEL) ||

#018          (Number >= KeNumberProcessors) ||

#019          (Interrupt->SynchronizeIrql < Irql) ||

#020          (Interrupt->FloatingSave))

#021      {

#022          return FALSE;

#023      }

#024 

 

设置缺省状态。

#025      /* Set defaults */

#026      Connected = FALSE;

#027      Error = FALSE;

#028 

 

设置起作用的CPU。

#029      /* Set the system affinity and acquire the dispatcher lock */

#030      KeSetSystemAffinityThread(1 << Number);

#031      OldIrql = KiAcquireDispatcherLock();

#032 

 

检查中断是否已经连接到系统里。

#033      /* Check if it's already been connected */

#034      if (!Interrupt->Connected)

#035      {

 

如果没有连接，就查找分发信息。

#036          /* Get vector dispatching information */

#037          KiGetVectorDispatch(Vector, &Dispatch);

#038 

 

如果分发器也没有连接这个中断。

#039          /* Check if the vector is already connected */

#040          if (Dispatch.Type == NoConnect)

#041          {

 

开始连接这个中断处理函数。

#042              /* Do the connection */

#043              Interrupt->Connected = Connected = TRUE;

#044 

#045              /* Initialize the list */

#046              InitializeListHead(&Interrupt->InterruptListEntry);

#047 

 

连接中断处理，并启动这个中断。

#048              /* Connect and enable the interrupt */

#049              KiConnectVectorToInterrupt(Interrupt, NormalConnect);

#050              Status = HalEnableSystemInterrupt(Vector, Irql, Interrupt->Mode);

#051              if (!Status) Error = TRUE;

#052          }

#053          else if ((Dispatch.Type != UnknownConnect) &&

#054                  (Interrupt->ShareVector) &&

#055                  (Dispatch.Interrupt->ShareVector) &&

#056                  (Dispatch.Interrupt->Mode == Interrupt->Mode))

#057          {

 

这里是处理共享中断的情况。

#058              /* The vector is shared and the interrupts are compatible */

#059              ASSERT(FALSE); // FIXME: NOT YET SUPPORTED/TESTED

#060              Interrupt->Connected = Connected = TRUE;

#061              ASSERT(Irql <= SYNCH_LEVEL);

#062 

 

是否为第一个连接。

#063              /* Check if this is the first chain */

#064              if (Dispatch.Type != ChainConnect)

#065              {

#066                  /* Setup the chainned handler */

#067                  KiConnectVectorToInterrupt(Dispatch.Interrupt, ChainConnect);

#068              }

#069 

 

把这个中断放到中断响应列表里。

#070              /* Insert into the interrupt list */

#071              InsertTailList(&Dispatch.Interrupt->InterruptListEntry,

#072                             &Interrupt->InterruptListEntry);

#073          }

#074      }

#075 

#076      /* Unlock the dispatcher and revert affinity */

#077      KiReleaseDispatcherLock(OldIrql);

#078      KeRevertToUserAffinityThread();

#079 

 

如果连接失败，就准备下一次连接。

#080      /* Check if we failed while trying to connect */

#081      if ((Connected) && (Error))

#082      {

#083          DPRINT1("HalEnableSystemInterrupt failed/n");

#084          KeDisconnectInterrupt(Interrupt);

#085          Connected = FALSE;

#086      }

#087 

#088      /* Return to caller */

#089      return Connected;

#090  }