reactos操作系统实现(88)

IRP 是 I/O request packet 的缩写，即 I/O 请求包。驱动与驱动之间通过 IRP 进行通信。而使用驱动的应用层调用的 CreatFile,ReadFile,WriteFile,DeviceIoControl 等函数，说到底也是使用 IRP 和驱动进行通信。

一个 IRP 由两部分组成。首先是头部或者叫包的固定部分，是一个 IRP 结构。紧跟在这个头部之后的是 I/O栈位置，这是一个 IO_STACK_LOCATION 结构的数组，这个数组中元素的个数是根据情况而定的，由 IoAllocateIrp( IN CCHAR StackSize , IN BOOLEAN ChargeQuota ) 时的参数 StackSize 决定。而 StackSize 通常由 IRP 发往的目标 DEVICE_OBJECT 的StackSize 决定。而这个 StackSize 是由设备对象连入所在的设备栈时，根据在设备栈中位置决定的。我们先看看 IRP 结构和 IO_STACK_LOCATION 结构的定义。实现代码如下：

#001 typedef struct _IRP {

标志IRP类型。

#002 CSHORT Type;

本IRP的长度和IRP栈的长度。

#003 USHORT Size;

指向内存描述符列表。

#004 struct _MDL *MdlAddress;

IRP包特征标志，比如直接I/O，还是缓存I/O等等。

#005 ULONG Flags;

保存驱动程序相关的数据结构。其中，与WDM驱动程序相关的指针是AssociatedIrp.SystemBuffer。 SystemBuffer指针指向一个数据缓冲区，该缓冲区位于内核模式的非分页内存中。对于IRP_MJ_READ和IRP_MJ_WRITE操作，如果顶级设备指定DO_BUFFERED_IO标志，则I/O管理器就创建这个数据缓冲区。对于IRP_MJ_DEVICE_CONTROL操作，如果I/O控制功能代码指出需要缓冲区(见第九章)，则I/O管理器就创建这个数据缓冲区。I/O管理器把用户模式程序发送给驱动程序的数据复制到这个缓冲区，这也是创建IRP过程的一部分。这些数据可以是与WriteFile调用有关的数据，或者是DeviceIoControl调用中所谓的输入数据。对于读请求，设备驱动程序把读出的数据填到这个缓冲区，然后I/O管理器再把缓冲区的内容复制到用户模式缓冲区。对于指定了METHOD_BUFFERED的I/O控制操作，驱动程序把所谓的输出数据放到这个缓冲区，然后I/O管理器再把数据复制到用户模式的输出缓冲区。

#006 union {

#007 struct _IRP *MasterIrp;

#008 volatile LONG IrpCount;

#009 PVOID SystemBuffer;

#010 } AssociatedIrp;

当前线程入口。

#011 LIST_ENTRY ThreadListEntry;

一个仅包含两个域的结构，驱动程序在最终完成请求时设置这个结构。

#012 IO_STATUS_BLOCK IoStatus;

等于一个枚举常量UserMode或KernelMode，指定原始I/O请求的来源。驱动程序有时需要查看这个值来决定是否要信任某些参数。

#013 KPROCESSOR_MODE RequestorMode;

IRP是否被阻塞。

#014 BOOLEAN PendingReturned;

IRP栈的大小。

#015 CHAR StackCount;

当前栈的位置。

#016 CHAR CurrentLocation;

IRP是否被取消操作。

#017 BOOLEAN Cancel;

当IoAcquireCancelSpinLock函数调用，指明它是那一个IRQ级别。

#018 KIRQL CancelIrql;

APC调用的环境索引。

#019 CCHAR ApcEnvironment;

内存分配方式，比如定额地增加，还是固定大小等等。

#020 UCHAR AllocationFlags;

保存用户I/O状态。

#021 PIO_STATUS_BLOCK UserIosb;

保存用户的事件。

#022 PKEVENT UserEvent;

APC、或分配的内存大小。

#023 union {

#024 struct {

#025 PIO_APC_ROUTINE UserApcRoutine;

#026 PVOID UserApcContext;

#027 } AsynchronousParameters;

#028 LARGE_INTEGER AllocationSize;

#029 } Overlay;

驱动程序取消例程的地址

#030 volatile PDRIVER_CANCEL CancelRoutine;

指向用户缓冲区。

#031 PVOID UserBuffer;

#032 union {

设备队列入口，或者设备上下环境指针。

#033 struct {

#034 _ANONYMOUS_UNION union {

#035 KDEVICE_QUEUE_ENTRY DeviceQueueEntry;

#036 _ANONYMOUS_STRUCT struct {

#037 PVOID DriverContext[4];

#038 } DUMMYSTRUCTNAME;

#039 } DUMMYUNIONNAME;

批向内核线程。

#040 PETHREAD Thread;

辅助缓冲区。

#041 PCHAR AuxiliaryBuffer;

I/O栈位置

#042 _ANONYMOUS_STRUCT struct {

#043 LIST_ENTRY ListEntry;

#044 _ANONYMOUS_UNION union {

#045 struct _IO_STACK_LOCATION *CurrentStackLocation;

#046 ULONG PacketType;

#047 } DUMMYUNIONNAME;

#048 } DUMMYSTRUCTNAME;

原来文件对象。

#049 struct _FILE_OBJECT *OriginalFileObject;

#050 } Overlay;

APC队列。

#051 KAPC Apc;

I/O完成设置用户关键数据。

#052 PVOID CompletionKey;

#053 } Tail;

#054 } IRP;

#055 typedef struct _IRP *PIRP;

上面学习了IRP的结构，知道了IRP保存的基本内容，也就是说知道了有什么相关东西，这就相当有了原材料，那么怎么样加工和处理这些原材料呢？那就得去分析IRP相关的操作函数，也就是IRP的相关算法。下面就从IRP分配开始，实现代码如下：

#001 PIRP

#002 NTAPI

#003 IoAllocateIrp(IN CCHAR StackSize,

#004 IN BOOLEAN ChargeQuota)

#005 {

#006 PIRP Irp = NULL;

计算IRP占用的大小，包括IRP的头部和IRP栈空间。

#007 USHORT Size = IoSizeOfIrp(StackSize);

#008 PKPRCB Prcb;

#009 UCHAR Flags = 0;

#010 PNPAGED_LOOKASIDE_LIST List = NULL;

#011 PP_NPAGED_LOOKASIDE_NUMBER ListType = LookasideSmallIrpList;

#012

如果设置为定额分配方式，就添加这个标志位。

#013 /* Set Charge Quota Flag */

#014 if (ChargeQuota) Flags |= IRP_QUOTA_CHARGED;

#015

#016 /* FIXME: Implement Lookaside Floats */

#017

#018 /* Figure out which Lookaside List to use */

#019 if ((StackSize <= 8) && (ChargeQuota == FALSE))

#020 {

设置为固定分配大小空间。

#021 /* Set Fixed Size Flag */

#022 Flags = IRP_ALLOCATED_FIXED_SIZE;

#023

需要使用一个大列表方式。

#024 /* See if we should use big list */

#025 if (StackSize != 1)

#026 {

#027 Size = IoSizeOfIrp(8);

#028 ListType = LookasideLargeIrpList;

#029 }

#030

获取当前处理器控制块。

#031 /* Get the PRCB */

#032 Prcb = KeGetCurrentPrcb();

#033

获取后备列表。

#034 /* Get the P List First */

#035 List = (PNPAGED_LOOKASIDE_LIST)Prcb->PPLookasideList[ListType].P;

#036

从后备列表里分配一个IRP包。

#037 /* Attempt allocation */

#038 List->L.TotalAllocates++;

#039 Irp = (PIRP)InterlockedPopEntrySList(&List->L.ListHead);

#040

#041 /* Check if the P List failed */

#042 if (!Irp)

#043 {

#044 /* Let the balancer know */

#045 List->L.AllocateMisses++;

#046

#047 /* Try the L List */

#048 List = (PNPAGED_LOOKASIDE_LIST)Prcb->PPLookasideList[ListType].L;

#049 List->L.TotalAllocates++;

#050 Irp = (PIRP)InterlockedPopEntrySList(&List->L.ListHead);

#051 }

#052 }

#053

如果没有从后备列表里分配到IRP，就需要从内存里分配。

#054 /* Check if we have to use the pool */

#055 if (!Irp)

#056 {

从后备列表里分配失败。

#057 /* Did we try lookaside and fail? */

#058 if (Flags & IRP_ALLOCATED_FIXED_SIZE) List->L.AllocateMisses++;

#059

定额增加分配的方式。

#060 /* Check if we should charge quota */

#061 if (ChargeQuota)

#062 {

#063 /* Irp = ExAllocatePoolWithQuotaTag(NonPagedPool, Size, TAG_IRP); */

#064 /* FIXME */

#065 Irp = ExAllocatePoolWithTag(NonPagedPool, Size, TAG_IRP);

#066 }

#067 else

#068 {

非定额增加分配的方式。

#069 /* Allocate the IRP With no Quota charge */

#070 Irp = ExAllocatePoolWithTag(NonPagedPool, Size, TAG_IRP);

#071 }

#072

#073 /* Make sure it was sucessful */

#074 if (!Irp) return(NULL);

#075 }

#076 else

#077 {

#078 /* In this case there is no charge quota */

#079 Flags &= ~IRP_QUOTA_CHARGED;

#080 }

#081

现在初始化IRP一些属性。

#082 /* Now Initialize it */

#083 IoInitializeIrp(Irp, Size, StackSize);

#084

设置IRP分配的标志。

#085 /* Set the Allocation Flags */

#086 Irp->AllocationFlags = Flags;

#087

返回分配成功的IRP包。

#088 /* Return it */

#089 IOTRACE(IO_IRP_DEBUG,

#090 "%s - Allocated IRP %p with allocation flags %lx/n",

#091 __FUNCTION__,

#092 Irp,

#093 Flags);

#094 return Irp;

#095 }