reactos操作系统实现(86)

创建完成端口需要调用Windows API CreateIoCompletionPort：

HANDLE CreateIoCompletionPort(
    HANDLE FileHandle,
    HANDLE ExistingCompletionPort,
    DWORD CompletionKey,
    DWORD NumberOfConcurrentThreads
);

创建一个完成端口时，通常对参数ExistingCompletionPort赋值NULL， NumberOfConcurrentThreads参数定义了在完成端口上同时允许执行的线程数量。如果有文件句柄传递给FileHandle参数，则该文件与完成端口关联在了一起。当这个文件上的I/O请求完成时，一个完成通知包将被投递到完成端口消息队列中。另外一个APIGetQueuedCompletionStatus是用来获取排队完成状态，它使调用线程挂起，直到收到一个完成通知包。

BOOL GetQueuedCompletionStatus(
    HANDLE CompletionPort,
    LPDWORD lpNumberOfBytesTransferred,
    LPDWORD CompletionKey,
    LPOVERLAPPED* lpOverlapped,
    DWORD dwMiillisecondTimeout
);

完成端口实际上是在管理一个线程池，它会记录当前活动（即没有被I/O等事件阻塞）的线程数。当有完成通知包到达该端口时，在该端口上等待的线程按照后进先出（LIFO）的次序被唤醒，因此最近（most recently）被阻塞的线程就是获得下一个完成通知包的线程。那些长时间得不到响应的的线程的堆栈将会被从内存调到磁盘交换区去等待，当与一个端口关联的线程太多超过了当前的处理能力时，就可以将长时间阻塞的线程占用的内存减到最少。

服务器应用程序往往通过网络端点来接受客户请求，而这些网络端点是由文件句柄来表示的。这样的例子包括Windows Sockets 2(Winsock2)套接字或者命名管道。当服务器创建它的通信端点时，它将这些通信端点与一个完成端口关联起来，并且它的线程通过调用GetQueuedCompletionStatus来等待此端口上进来的完成通知。当一个线程在此完成端口上得到一个I/O完成通知包时，它便不再等待，开始处理I/O结果数据，从而变成一个活动的线程。一个线程在处理过程中可能将阻塞很多次，比如当它需要从磁盘上的文件读取数据时，或者当它需要与其他的线程同步时。Windows NT检测到这些活动，并且识别出该完成端口上至少已经有一个活动线程。因此，当活动线程由于I/O请求而阻塞时，如果在队列中存在一个包，则唤醒另一个正在此完成端口上等待的线程提供处理服务。

微软的指导原则是，将并发值设置成大约等于该系统中处理器的数目。但是要注意，一个完成端口上实际活动线程数量有可能超过设置的并发值。考虑并发值被设置为1的情况，一个客户请求进来了，某个线程因为被调度来处理该请求而变成活动的。下一个请求到达时，正在该端口上等待的另一个线程却不允许执行，因为活动的线程数已经达到了设置的并发上限值。然后，当活动线程需要等待I/O而阻塞时，等待的线程将被激活，当它尚在活动时，上一个线程的I/O完成了，这使得它继续保持活动状态（继续执行数据处理服务）。此刻，一直到两个线程中有一个被阻塞，并发值始终是2，高于设置的并发上限值1。大多数时候，活动线程数将维持在设置的并发限制值上，或者超过一点。

应用程序通过调用PostQueuedCompletionStatus这个API向完成端口投递一个自定义的完成通知包。服务器一般通过该函数发送消息通知线程有外部事件发生，例如需要温和的关机。

 

完成端口内部机制

当传递NULL值给ExistingCompletionPort参数来调用CreateIoCompletionPort来创建完成端口时，将调用同名的NtCreateIoCompletion系统服务。实质上，IoCompletion对象是建立在一个称为队列的内核同步对象基础上。系统创建一个完成端口的同时，在完成端口所分配到的内存中初始化一个队列对象（指向完成端口的指针同时指向了此队列对象，因为队列对象位于完成端口对象内存的开始处）。当一个线程调用CreateIoCompletionPort来创建完成端口时，第四个参数NumberOfConcurrentThreads即为队列的并发值。NtCreateIoCompletion函数将调用KeInitializeQueue系统服务来初始化该端口的消息队列。

当应用程序再次调用CreateIoCompletionPort时，将调用NtSetInformationFile服务来使参数一（文件句柄）与参数二（一个已有的完成端口）关联起来。完成通知包FileCompletionInformation包含的信息：CreateIoCompletionPort的参数二ExistingCompletionPort（已有的完成端口句柄）和参数三CompletionKey（完成键）。NtSetInformationFile通过解引用操作从该文件句柄获得对应的文件对象，并且申请一个记录完成上下文的数据结构。这个数据结构在NTDDK.H定义如下：

typedef struct _IO_COMPLETION_CONTEXT {
    PVOID Port;
    ULONG Key;
} IO_COMPLETION_CONTEXT, *PIO_COMPLETION_CONTEXT;

最后，将调用NtSetInformationFile系统服务设置文件对象中CompletionContext域的值。当一个异步I/O在一个文件对象上完成时，系统内部执行具有I/O管理功能的IopCompleteRequest系统服务，检查文件对象中的CompletionContext域是否为非NULL。如果是，则I/O管理器生成一个完成通知包，通过调用KeInsertQueue系统服务将完成通知包投递到完成端口队列（注意，完成端口对象和队列对象是同义的）。

当一个服务器线程调用GetQueuedCompletionStatus时，它将调用NtRemoveIoCompletion系统服务。在验证参数后，并且将完成端口句柄转换成一个指向该端口的指针后，NtRemoveIoCompletion调用KeRemoveQueue。

正如你所看到的，KeRemoveQueue和KeInsertQueue是完成端口模型的两个引擎级函数，它们决定阻塞在完成端口上等待I/O完成通知包的线程什么时候被唤醒。在系统内部，队列对象维护了完成端口上当前活动线程的计数值，以及最大的并发活动线程的数量。当一个线程调用KeRemoveQueue并且当前活动线程数大于或等于并发数上限时，那么该线程将被投放到一个阻塞线程队列（按LIFO顺序）中，等待系统调度来获取并处理完成通知包。此线程列表挂在队列对象的外面，线程的控制块数据结构中有一个指针引用了一个与之相关的队列对象；如果这个指针为NULL，则该线程没有与队列关联。

Windows依赖与线程控制块中的队列指针来跟踪和记录那些“由于被阻塞在除了完成端口之外的其他事情上而变成不活动”的线程。那些有可能会导致一个线程阻塞的调度例程（例如KeWaitForSingleObject，KeDelayExecutionThread等等）要检查该线程的队列指针。如果该指针不为NULL，则这些函数调用KiActivateWaiterQueue—一个与队列相关的函数，它会递减与该队列相关联的活动线程的计数值。如果计数值递减到小于设置的并发值，并且此时至少有一个完成通知包在该队列中，那么处于该队列的线程列表最前面的那个线程被唤醒，并且把最老的（the oldest）完成通知包交给它处理。相反，无论何时，与一个队列相关联的线程在阻塞之后被唤醒时，调度程序执行KiUnwaitThread函数来增加该队列上活动线程的计数值。

最后，PostQueuedCompletionStatus这个Windows API将调用NtSetIoCompletion服务。该函数只是简单的调用KeInsertQueue将自定义的完成通知包插入到完成端口的队列中。

 

没有公开的

Windows NT的完成端口API提供了一种易于使用和高效的方法最大限度地发挥服务器的性能——最大限度的减少上下文切换的同时最大限度的提高系统并发量。这些API使我们能够调用I/O管理器和内核提供的一些服务功能。队列对象可以被设备驱动程序调用（这些接口尽管没有公开，但还是很容易查询到的），不过完成端口的API没有提供相关访问功能。但是，如果队列接口被继承，我们完全可以通过编写队列处理程序并通过手动设置CompletionContext的值来模拟完成端口模型。

 

创建完成端口的函数，如下：

#001  NTSTATUS

#002  NTAPI

#003  NtCreateIoCompletion(OUT PHANDLE IoCompletionHandle,

#004                       IN ACCESS_MASK DesiredAccess,

#005                       IN POBJECT_ATTRIBUTES ObjectAttributes,

#006                       IN ULONG NumberOfConcurrentThreads)

#007  {

#008      PKQUEUE Queue;

#009      HANDLE hIoCompletionHandle;

#010      KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();

#011      NTSTATUS Status = STATUS_SUCCESS;

#012      PAGED_CODE();

#013 

 

检查是否用户模式调用，如果是就使用SEH机制。

#014      /* Check if this was a user-mode call */

#015      if (PreviousMode != KernelMode)

#016      {

#017          /* Wrap probing in SEH */

#018          _SEH2_TRY

#019          {

#020              /* Probe the handle */

#021              ProbeForWriteHandle(IoCompletionHandle);

#022          }

#023          _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)

#024          {

#025              /* Get the exception code */

#026              Status = _SEH2_GetExceptionCode();

#027          }

#028          _SEH2_END;

#029 

#030          /* Fail on exception */

#031          if (!NT_SUCCESS(Status)) return Status;

#032      }

#033 

 

创建一个I/O对象。

#034      /* Create the Object */

#035      Status = ObCreateObject(PreviousMode,

#036                              IoCompletionType,

#037                              ObjectAttributes,

#038                              PreviousMode,

#039                              NULL,

#040                              sizeof(KQUEUE),

#041                              0,

#042                              0,

#043                              (PVOID*)&Queue);

#044      if (NT_SUCCESS(Status))

#045      {

 

实始化N个线程的队列。

#046          /* Initialize the Queue */

#047          KeInitializeQueue(Queue, NumberOfConcurrentThreads);

#048 

 

把队列放到对象管理器。

#049          /* Insert it */

#050          Status = ObInsertObject(Queue,

#051                                  NULL,

#052                                  DesiredAccess,

#053                                  0,

#054                                  NULL,

#055                                  &hIoCompletionHandle);

#056          if (NT_SUCCESS(Status))

#057          {

#058              /* Protect writing the handle in SEH */

#059              _SEH2_TRY

#060              {

 

返回I/O句柄给应用程序。

#061                  /* Write the handle back */

#062                  *IoCompletionHandle = hIoCompletionHandle;

#063              }

#064              _SEH2_EXCEPT(ExSystemExceptionFilter())

#065              {

#066                  /* Get the exception code */

#067                  Status = _SEH2_GetExceptionCode();

#068              }

#069              _SEH2_END;

#070          }

#071     }

#072 

#073     /* Return Status */

#074     return Status;

#075  }

 

 

下面函数设置I/O完成端口，如下：

#001  NTSTATUS

#002  NTAPI

#003  NtSetIoCompletion(IN HANDLE IoCompletionPortHandle,

#004                    IN PVOID CompletionKey,

#005                    IN PVOID CompletionContext,

#006                    IN NTSTATUS CompletionStatus,

#007                    IN ULONG CompletionInformation)

#008  {

#009      NTSTATUS Status;

#010      PKQUEUE Queue;

#011      PAGED_CODE();

#012 

#013      /* Get the Object */

#014      Status = ObReferenceObjectByHandle(IoCompletionPortHandle,

#015                                         IO_COMPLETION_MODIFY_STATE,

#016                                         IoCompletionType,

#017                                         ExGetPreviousMode(),

#018                                         (PVOID*)&Queue,

#019                                         NULL);

#020      if (NT_SUCCESS(Status))

#021      {

#022          /* Set the Completion */

#023          Status = IoSetIoCompletion(Queue,

#024                                     CompletionKey,

#025                                     CompletionContext,

#026                                     CompletionStatus,

#027                                     CompletionInformation,

#028                                     TRUE);

#029 

#030          /* Dereference the object */

#031          ObDereferenceObject(Queue);

#032      }

#033 

#034      /* Return status */

#035      return Status;

#036  }

 

现在来看看GetQueuedCompletionStatus函数是通过调用下面函数来实现相关的功能，如下：

#001  NTSTATUS

#002  NTAPI

#003  NtRemoveIoCompletion(IN HANDLE IoCompletionHandle,

#004                       OUT PVOID *KeyContext,

#005                       OUT PVOID *ApcContext,

#006                       OUT PIO_STATUS_BLOCK IoStatusBlock,

#007                       IN PLARGE_INTEGER Timeout OPTIONAL)

#008  {

#009      LARGE_INTEGER SafeTimeout;

#010      PKQUEUE Queue;

#011      PIOP_MINI_COMPLETION_PACKET Packet;

#012      PLIST_ENTRY ListEntry;

#013      KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();

#014      NTSTATUS Status = STATUS_SUCCESS;

#015      PIRP Irp;

#016      PVOID Apc, Key;

#017      IO_STATUS_BLOCK IoStatus;

#018      PAGED_CODE();

#019 

 

检查是否用户模式下调用，如果是就使用SEH机制来设置。

#020      /* Check if the call was from user mode */

#021      if (PreviousMode != KernelMode)

#022      {

#023          /* Protect probes in SEH */

#024          _SEH2_TRY

#025          {

#026              /* Probe the pointers */

#027              ProbeForWritePointer(KeyContext);

#028              ProbeForWritePointer(ApcContext);

#029 

#030              /* Probe the I/O Status Block */

#031              ProbeForWriteIoStatusBlock(IoStatusBlock);

#032              if (Timeout)

#033              {

#034                  /* Probe and capture the timeout */

#035                  SafeTimeout = ProbeForReadLargeInteger(Timeout);

#036                  Timeout = &SafeTimeout;

#037              }

#038          }

#039          _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)

#040          {

#041              /* Get the exception code */

#042              Status = _SEH2_GetExceptionCode();

#043          }

#044          _SEH2_END;

#045 

#046          /* Fail on exception */

#047          if (!NT_SUCCESS(Status)) return Status;

#048      }

#049 

 

打开所创建的I/O对象。

#050      /* Open the Object */

#051      Status = ObReferenceObjectByHandle(IoCompletionHandle,

#052                                         IO_COMPLETION_MODIFY_STATE,

#053                                         IoCompletionType,

#054                                         PreviousMode,

#055                                         (PVOID*)&Queue,

#056                                         NULL);

#057      if (NT_SUCCESS(Status))

#058      {

 

从队列里删除IO请求包，如果没有完成的，就会挂起线程运行。

#059          /* Remove queue */

#060          ListEntry = KeRemoveQueue(Queue, PreviousMode, Timeout);

#061 

#062          /* If we got a timeout or user_apc back, return the status */

#063          if (((NTSTATUS)ListEntry == STATUS_TIMEOUT) ||

#064              ((NTSTATUS)ListEntry == STATUS_USER_APC))

#065          {

#066              /* Set this as the status */

#067              Status = (NTSTATUS)ListEntry;

#068          }

#069          else

#070          {

#071              /* Get the Packet Data */

#072              Packet = CONTAINING_RECORD(ListEntry,

#073                                         IOP_MINI_COMPLETION_PACKET,

#074                                         ListEntry);

#075 

#076              /* Check if this is piggybacked on an IRP */

#077              if (Packet->PacketType == IopCompletionPacketIrp)

#078              {

#079                  /* Get the IRP */

#080                  Irp = CONTAINING_RECORD(ListEntry,

#081                                          IRP,

#082                                          Tail.Overlay.ListEntry);

#083 

#084                  /* Save values */

#085                  Key = Irp->Tail.CompletionKey;

#086                  Apc = Irp->Overlay.AsynchronousParameters.UserApcContext;

#087                  IoStatus = Irp->IoStatus;

#088 

#089                  /* Free the IRP */

#090                  IoFreeIrp(Irp);

#091              }

#092              else

#093              {

#094                  /* Save values */

#095                  Key = Packet->KeyContext;

#096                  Apc = Packet->ApcContext;

#097                  IoStatus.Status = Packet->IoStatus;

#098                  IoStatus.Information = Packet->IoStatusInformation;

#099 

#100                  /* Free the packet */

#101                  IopFreeMiniPacket(Packet);

#102              }

#103 

 

通过SEH机制返回请求包给应用程序。

#104              /* Enter SEH to write back the values */

#105              _SEH2_TRY

#106              {

#107                  /* Write the values to caller */

#108                  *ApcContext = Apc;

#109                  *KeyContext = Key;

#110                  *IoStatusBlock = IoStatus;

#111              }

#112              _SEH2_EXCEPT(ExSystemExceptionFilter())

#113              {

#114                  /* Get the exception code */

#115                  Status = _SEH2_GetExceptionCode();

#116              }

#117              _SEH2_END;

#118          }

#119 

#120          /* Dereference the Object */

#121          ObDereferenceObject(Queue);

#122      }

#123 

#124      /* Return status */

#125      return Status;

#126  }