reactos操作系统实现(86)

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

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 }