reactos操作系统实现(97)

在这个函数里，又继续地调用内核的两个函数KiConnectVectorToInterrupt和HalEnableSystemInterrupt来处理。

#001  VOID

#002  NTAPI

#003  KiConnectVectorToInterrupt(IN PKINTERRUPT Interrupt,

#004                             IN CONNECT_TYPE Type)

#005  {

#006      DISPATCH_INFO Dispatch;

#007      PKINTERRUPT_ROUTINE Handler;

 

 

#008      PULONG Patch = &Interrupt->DispatchCode[0];

#009 

 

获取中断的分发信息，其实就是设置中断处理中间函数。

#010      /* Get vector data */

#011      KiGetVectorDispatch(Interrupt->Vector, &Dispatch);

#012 

 

检查是否没有连接中断。

#013      /* Check if we're only disconnecting */

#014      if (Type == NoConnect)

#015      {

 

没有中断处理函数，就使用缺省的。

#016          /* Set the handler to NoDispatch */

#017          Handler = Dispatch.NoDispatch;

#018      }

#019      else

#020      {

 

根据中断是共享类型，还是普通类型，如果是共享就调用中断列表，否则就调用中断处理函数。

#021          /* Get the right handler */

#022          Handler = (Type == NormalConnect) ?

#023                    Dispatch.InterruptDispatch:

#024                    Dispatch.ChainedDispatch;

#025          ASSERT(Interrupt->FloatingSave == FALSE);

#026 

 

设置中断处理的地址。

#027          /* Set the handler */

#028          Interrupt->DispatchAddress = Handler;

#029 

 

这里将KiInterruptTemplateDispatch那里的jmp指令的跳转地址改写为Handler，至于这里为什么要用Handler的地址减去Patch再加4，那是因为这里是相对地址的跳转。所以是从当前指令来偏移的。

#030          /* Jump to the last 4 bytes */

#031          Patch = (PULONG)((ULONG_PTR)Patch +

#032                           ((ULONG_PTR)&KiInterruptTemplateDispatch -

#033                            (ULONG_PTR)KiInterruptTemplate) - 4);

#034 

#035          /* Apply the patch */

#036          *Patch = (ULONG)((ULONG_PTR)Handler - ((ULONG_PTR)Patch + 4));

#037 

#038          /* Now set the final handler address */

#039          ASSERT(Dispatch.FlatDispatch == NULL);

#040          Handler = (PVOID)&Interrupt->DispatchCode;

#041      }

#042 

 

这里把中断处理函数设置到中断描述表里。

#043      /* Set the pointer in the IDT */

#044      ((PKIPCR)KeGetPcr())->IDT[Interrupt->Vector].ExtendedOffset =

#045          (USHORT)(((ULONG_PTR)Handler >> 16) & 0xFFFF);

#046      ((PKIPCR)KeGetPcr())->IDT[Interrupt->Vector].Offset =

#047          (USHORT)PtrToUlong(Handler);

#048  }

 

下面回过头来分析函数KeInitializeInterrupt的实现，因为这个初始化代码比较重要，看了它才明白怎么样实现中断连接，如下：

#001  VOID

#002  NTAPI

#003  KeInitializeInterrupt(IN PKINTERRUPT Interrupt,

#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 CHAR ProcessorNumber,

#013                        IN BOOLEAN FloatingSave)

#014  {

#015      ULONG i;

#016      PULONG DispatchCode = &Interrupt->DispatchCode[0], Patch = DispatchCode;

#017 

 

设置中断处理头部份。

#018      /* Set the Interrupt Header */

#019      Interrupt->Type = InterruptObject;

#020      Interrupt->Size = sizeof(KINTERRUPT);

#021 

 

检查是否已经分配自旋锁。

#022      /* Check if we got a spinlock */

#023      if (SpinLock)

#024      {

#025          Interrupt->ActualLock = SpinLock;

#026      }

#027      else

#028      {

#029          /* This means we'll be usin the built-in one */

#030          KeInitializeSpinLock(&Interrupt->SpinLock);

#031          Interrupt->ActualLock = &Interrupt->SpinLock;

#032      }

#033 

 

初始化中断结构相关的属性。

#034      /* Set the other settings */

#035      Interrupt->ServiceRoutine = ServiceRoutine;

#036      Interrupt->ServiceContext = ServiceContext;

#037      Interrupt->Vector = Vector;

#038      Interrupt->Irql = Irql;

#039      Interrupt->SynchronizeIrql = SynchronizeIrql;

#040      Interrupt->Mode = InterruptMode;

#041      Interrupt->ShareVector = ShareVector;

#042      Interrupt->Number = ProcessorNumber;

#043      Interrupt->FloatingSave = FloatingSave;

#044      Interrupt->TickCount = (ULONG)-1;

#045      Interrupt->DispatchCount = (ULONG)-1;

#046 

 

拷贝中断处理函数的中间跳转代码。共有106x4个字节大小。

#047      /* Loop the template in memory */

#048      for (i = 0; i < KINTERRUPT_DISPATCH_CODES; i++)

#049      {

#050          /* Copy the dispatch code */

#051          *DispatchCode++ = KiInterruptTemplate[i];

#052      }

#053 

 

检查这段中断处理代码是否合法。

#054      /* Sanity check */

#055      ASSERT((ULONG_PTR)&KiChainedDispatch2ndLvl -

#056             (ULONG_PTR)KiInterruptTemplate <= (KINTERRUPT_DISPATCH_CODES * 4));

#057 

 

计算中断处理函数的最后4字节的位置，也就是模板代码里这一行：

mov edi, 0，相当于设置0这个参数，也就是把中断结构的指针保存edi寄存器里，以便后面跳转函数可以使用这个中断结构。

#058      /* Jump to the last 4 bytes */

#059      Patch = (PULONG)((ULONG_PTR)Patch +

#060                       ((ULONG_PTR)&KiInterruptTemplateObject -

#061                        (ULONG_PTR)KiInterruptTemplate) - 4);

#062 

 

把实际中断结构指针保存在中断的模板代码里，以便中断发生时，就可以跳到相应的中断函数运行，并可以获取中断参数。

#063      /* Apply the patch */

#064      *Patch = PtrToUlong(Interrupt);

#065 

#066      /* Disconnect it at first */

#067      Interrupt->Connected = FALSE;

#068  }