<学习笔记>Windows驱动开发技术详解__IRP的同步

对设备的任何操作都会最终转化为IRP请求，而IRP一般都是由操作系统异步发送的。异步处理IRP有助于提高效率，但是有时异步处理会带来逻辑上的错误，这时需要将异步的IRP同步化。将IRP同步化的方法有StartIO例程，使用中断服务例程等。

应用程序对设备的同步异步操作

大部分IRP都是由应用程序的Win32 API函数发起的。这些Win32 API本身就支持同步和异步的操作。例如：ReadFile，WriteFile和DeviceIoControl等，这些都有两种操作方式。一种同步，一种异步。

1.同步操作和异步操作的原理

操作设备的Win32 API主要是三个函数，即ReadFile函数，WriteFile函数，DeviceIOControl函数。以DeviceIOControl函数为例，当应用程序调用DeviceIoControl函数时，它的内部会创建一个IRP_MJ_DEVICE_CONTROL类型的IRP，并将这个IRP传送到驱动程序的派遣函数中。处理该IRP需要一段时间，直到IRP处理完毕后，DeviceIOControl函数才会返回。

同步操作时，在DeviceIOControl的内部，会调用WaitForSingleObject函数去等待一个事件。这个事件直到IRP被结束时，才会被触发。如果通过反汇编IoCompleteRequest内核函数，就会发现IoComplpeteRequest内部设置了该事件。DeviceIOControl会暂时进入睡眠状态，直到IRP被结束。

而对于异步操作的情况下，当DeviceIOControl被调用时，其内部会产生IRP，并将IRP传递给驱动程序的内部派遣函数。但此时DeviceIOControl不会等待该IRP的结束，而是直接返回。当IRP经过一段时间被结束时，操作系统会触发一个IRP相关事件。这个事件可以通知应用程序IRP请求被执行完毕。

2.同步操作设备

如果需要同步操作设备，在打开设备的时候就要制定以“同步”的方式打开设备。打开设备用CreateFile函数，其函数声明如下：

HANDLE
  CreateFile(
                LPCSTR lpFileName,                                  //设备名
		DWORD dwDesiredAccess,                              //访问权限
		DWORD dwShareMode,                                  //共享模式
		LPSECURITY_ATTRIBUTES lpSecurityAttributes,         //安全属性
		DWORD dwCreationDisposition,                        //如何创建
		DWORD dwFlagsAndAttributes,                         //设备属性
		HANDLE hTemplateFile                                //文件模板
	);

其中第六个参数dwFlagsAndAttributes是同步异步操作的关键。如果这个参数没有设置FILE_FLAG_OVERLAPPED，则以后对该设备的操作都是同步操作，否则都是异步操作。

对设备的操作Win32 API，例如ReadFile，WriteFile和DeviceIOControl函数，都会提供一个OVERLAP参数，如ReadFile函数：

BOOL ReadFile(
	HANDLE hFile,
	LPVOID lpBuffer,
	DWORD nNumberOfBytesToRead, 
	LPDWORD lpNumberOfBytesRead,
	LPOVERLAPPED lpOverlapped 
);

在同步操作设备时，其lpOverlapped参数设置为NULL。下面代码演示了应用程序如何对设备进行同步读取：

#include <windows.h>
#include <stdio.h>

#define BUFFER_SIZE	512
int main()
{
	HANDLE hDevice = 
		CreateFile("test.dat",
					GENERIC_READ | GENERIC_WRITE,
					0,
					NULL,
					OPEN_EXISTING,
					FILE_ATTRIBUTE_NORMAL,//此处没有设置FILE_FLAG_OVERLAPPED
					NULL );

	if (hDevice == INVALID_HANDLE_VALUE) 
	{
		printf("Read Error\n");
		return 1;
	}

	UCHAR buffer[BUFFER_SIZE];
	DWORD dwRead;
	ReadFile(hDevice,buffer,BUFFER_SIZE,&dwRead,NULL);//这里没有设置OVERLAP参数

	CloseHandle(hDevice);

	return 0;
}

3.异步操作设备（方式一）

异步操作设备时主要需要OVERLAP参数，Windows中用一种数据结构OVERLAPPED表示。

typedef struct _OVERLAPPED
{
	ULONG_PTR Internal;
	ULONG_PTR InternalHigh;
	DWORD Offset;
	DWORD OffsetHigh;
	HANDLE hEvent;
}OVERLAPPED;

第三个参数Offset：操作设备会指定一个偏移量，从设备的偏移量进行读取。该偏移量用一个64位整型表示，Offset就是偏移量的低32位。

第四个参数OffsetHigh是偏移量的高32位。

第五个参数hEvent：这个事件用于该操作完成后通知应用程序。程序员可以初始化该事件为未激发，当操作设备结束后，即在驱动程序中调用IoCompleteRequest后，设置该事件为激发态。

在使用OVERLAPPED结构前，要先对其内部清零，并为其创建事件。

下面代码演示如何在应用程序中使用异步操作：

#include <windows.h>
#include <stdio.h>

#define BUFFER_SIZE	512
//假设该文件大于或等于BUFFER_SIZE

#define DEVICE_NAME	"test.dat"
int main()
{
	HANDLE hDevice = 
		CreateFile("test.dat",
					GENERIC_READ | GENERIC_WRITE,
					0,
					NULL,
					OPEN_EXISTING,
					FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,//此处设置FILE_FLAG_OVERLAPPED
					NULL );

	if (hDevice == INVALID_HANDLE_VALUE) 
	{
		printf("Read Error\n");
		return 1;
	}

	UCHAR buffer[BUFFER_SIZE];
	DWORD dwRead;

	//初始化overlap使其内部全部为零
	OVERLAPPED overlap={0};

	//创建overlap事件
	overlap.hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);

	//这里没有设置OVERLAP参数，因此是异步操作
	ReadFile(hDevice,buffer,BUFFER_SIZE,&dwRead,&overlap);

	//做一些其他操作，这些操作会与读设备并行执行

	//等待读设备结束
	WaitForSingleObject(overlap.hEvent,INFINITE);

	CloseHandle(hDevice);

	return 0;
}

4.异步操作设备（方式二）

除了ReadFile和WriteFile函数外，还有两个API也可以实现异步读写，这就是ReadFileEx和WriteFileEx函数。ReadFile和WriteFile既可以支持同步读写操作，又可以支持异步读写操作。而ReadFileEx和WriteFileEx函数时专门用于异步操作的，不能进行同步读写。ReadFileEx的声明如下：

ReadFileEx(
		HANDLE hFile,
		LPVOID lpBuffer,
		DWORD nNumberOfBytesToRead,
		LPOVERLAPPED lpOverlapped, 
		LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
	);

第一个参数hFile：要操作的设备句柄

第二个参数lpBuffer：读入数据的缓冲区

第三个参数nNumberOfBytesToRead：需要读取的字节数

第四个参数lpOverlapped：一个OVERLAPPED指针

第五个参数lpComletionRoutine：完成历程

需要注意的是，这里提供的OVERLAPPED不需要提供事件句柄。ReadFileEx将读请求传递到驱动程序后立刻返回。驱动程序在结束读操作后，会通过调用ReadFileEx提供的回调历程（CALL BACK FUNCTION）。这类似一个软中断，也就是当读操作结束后，系统立刻回调ReadFileEx提供的回调历程。Windows将这种机制称为异步过程调用（APC AsynchronousProcedureCall）

然后，APC的回调函数被调用是有条件的。只有线程处于警惕状态（Alert）时，回调函数才有可能被调用。有多个API可以使系统进入警惕状态，如SleepEx，WaitForSingleObjectEx，WaitForMultipleObjectEx函数等。这些Win32 API都会有一个BOOL型的参数bAlertable，当设置TRUE时，就进入警惕模式。

当系统进入警惕模式后，操作系统会枚举当前线程的APC队列。驱动程序一旦结束读取操作，就会把ReadFileEx提供的完成历程插入到APC队列。

回调历程会报告本次操作的完成状况，比如是成功或是失败。同时会报告本次读取操作实际读取字节数等。下面是一般回调历程的声明：

VOID CALLBACK FileIOCompletionRoutine
(
 DWORD dwErrorCode,
 DWORD dwNumberOfBytesTransfered,
 LPOVERLAPPED lpOverlapped
 );

第一个参数dwErrorCode：如果读取错误，会返回错误码

第二个参数dwNumberOfBytesTransfered：返回实际读取操作的字节数

第三个参数lpOverlapped：OVERLAP参数，指定读取的偏移量等信息

下面代码演示如何在应用程序中使用ReadFileEx进行异步读操作：

#include <windows.h>
#include <stdio.h>

#define DEVICE_NAME	"test.dat"
#define BUFFER_SIZE	512
//假设该文件大于或等于BUFFER_SIZE

VOID CALLBACK MyFileIOCompletionRoutine(
  DWORD dwErrorCode,                // 对于此次操作返回的状态
  DWORD dwNumberOfBytesTransfered,  // 告诉已经操作了多少字节,也就是在IRP里的Infomation
  LPOVERLAPPED lpOverlapped         // 这个数据结构
)
{
	printf("IO operation end!\n");
}

int main()
{
	HANDLE hDevice = 
		CreateFile("test.dat",
					GENERIC_READ | GENERIC_WRITE,
					0,
					NULL,
					OPEN_EXISTING,
					FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,//此处设置FILE_FLAG_OVERLAPPED
					NULL );

	if (hDevice == INVALID_HANDLE_VALUE) 
	{
		printf("Read Error\n");
		return 1;
	}

	UCHAR buffer[BUFFER_SIZE];

	//初始化overlap使其内部全部为零
	//不用初始化事件!!
	OVERLAPPED overlap={0};

	//这里没有设置OVERLAP参数，因此是异步操作
	ReadFileEx(hDevice, buffer, BUFFER_SIZE,&overlap,MyFileIOCompletionRoutine);

	//做一些其他操作，这些操作会与读设备并行执行

	//进入alterable
	SleepEx(0,TRUE);

	CloseHandle(hDevice);

	return 0;
}

IRP的同步和异步完成

1.IRP的同步完成

下面介绍Win32 API函数是如何一层层通过调用进入到派遣函数的。

（1）在应用程序中调用CreateFile Win32 API函数，这个函数用于打开设备

（2）CreateFile Win32 API函调用ntdll.dll中的NtCreateFile函数

（3）ntdll.dll中的NtCreateFile函数进入内核模式，然后调用ntoskrnl.exe中的NtCreateFile函数

（4）内核模式中ntoskrnl.exe的NtCreateFile函数创建IRP_MJ_CREATE类型的IRP，然后调用相应驱动程序的派遣函数，并将IRP的指针传递给该派遣函数

（5）派遣函数调用IoCompleteRequest，将IRP结束

（6）操作系统按原路返回，一直退到CreateFile Win32 API函数。至此CreateFile函数返回

（7）如果需要读取设备，应用程序调用ReadFile Win32 API函数

（8）ReadFile Win32 API调用ntdll.dll中的NtReadFile函数

（9）NtReadFile函数进入内核模式，调用ntoskenl.exe中的NtReadFile函数

（10）ntoskrnl.exe中的NtReadFile函数创建IRP_MJ_READ类型的IRP，并将其传入相应的派遣函数中

对设备进行读取可以有三种方法，第一种方式是用ReadFile函数进行同步读取，第二种是通过ReadFile方式进行异步读取，第三种方法是用ReadFileEx函数进行异步读取。

如果是用ReadFile进行同步读取时：

（1）ReadFile函数内部会创建一个事件，这个事件连同IRP一起被传到派遣函数中（这个事件是IRP的UserEvent子域）

（2）派遣函数用IoCompleteRequest时，IoCompleteRequest内部会设置IRP的UserEvent事件

（3）操作系统按照原路一只返回到ReadFile函数，ReadFile等待这个事件，因为该事件已经被设置，所以无需等待

（4）如果在派遣函数中没有调用IoCompleteRequest函数，该事件就没有被设置，ReadFile会一直等IRP结束

如果使用ReadFile进行异步读取：

（1）这时，ReadFile内部不会创建事件，但ReadFile函数会接受overlap参数，overlap参数中会提供一个事件，这个事件被用作同步处理

（2）IoCompleteRequest内不会设置overlap提供的事件

（3）在ReadFile函数退出前后，它不会检测该事件是否被设置，因此可以不等待操作是否被完成

（4）当IRP操作被结束后，overlap提供的事件被设置，这个事件会通知应用程序IRP请求被完成

如果使用ReadFileEx函数进行异步读取：

（1）ReadFileEx不提供事件，但是提供一个回调函数，这个回调函数的地址会作为IRP的参数传递给驱动程序

（2）IoCompleteRequest会将这个函数插入APC队列

（3）应用程序只要进入警惕模式，APC队列会自动出队列，完成函数会被执行，这相当于通知应用程序操作已完成

2.IRP的异步完成

IRP被“异步完成”指的是不在派遣函数中调用IoCompleteRequest内核函数。调用IoCompleteRequest意味着IRP请求的结束，也标志着本次对设备操作的结束。

IRP是被异步完成，而发起IRP的应用程序会有三种发起IRP的形式，分别是ReadFile同步读取，ReadFile异步读取，ReadFileEx异步读取。

IRP是由ReadFile的同步操作引起的：当派遣函数退出时，由于IoCompleteRequest没有被调用，IRP请求没有被结束，ReadFile会一直等待，知道操作结束。

IRP是由ReadFile的异步操作引起的：当派遣函数退出时，由于IoCompleteRequest没有被调用，IRP请求没有被结束，但是ReadFile会立刻返回，返回值为失败，但代表操作没有完成。通过调用GetLastError函数，可以得到这时的错误代码是ERROR_IO_PENDING。这不是真正的错误，而是意味着ReadFile并没有真正完成操作，ReadFile只是异步返回。当IRP请求被真正的结束，即调用了IoCompleteRequest，ReadFile提供的overlap的事件才会被设置。这个事件可以通知了应用程序ReadFile的请求真正被执行完毕。

IRP是由ReadFileEx操作异步引起的：ReadFileEx会立刻返回，但是返回值是FALSE，说明操作没有成功。调用GetLastError会发现错误码是ERROR_IO_PENDING,表明当前操作被“挂起”。当IRP结束后，ReadFileEx提供的回调历程会被插入到APC队列中。一旦操作系统进入警惕状态，线程的APC队列会自动出列。

如果派遣函数不调用IoCompleteRequest函数，则需要告诉操作系统此IRP处于“挂起”状态。这需要调用内核函数IoMarkIrpPending。同时，派遣函数应该返回STATUS_PENDING。下面代码演示了派遣函数异步处理IRP。

NTSTATUS HelloDDKRead(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
{
	KdPrint(("Enter HelloDDKRead\n"));

	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
		pDevObj->DeviceExtension;

	PMY_IRP_ENTRY pIrp_Entry = (PMY_IRP_ENTRY)ExAllocatePool(PagedPool,sizeof(MY_IRP_ENTRY));
    pIrp_Entry->pIRP = pIrp;

	//插入队列
	InsertHeadList(pDevExt->pIRPLinkListHead,&pIrp_Entry->ListEntry);

	//将IRP设置为挂起
	IoMarkIrpPending(pIrp);
	KdPrint(("Leave HelloDDKRead\n"));

	//返回pending状态
	return STATUS_PENDING;
}

 

为了能存储哪些IRP_MJ_READ被挂起，这里使用一个队列，也就是把每个挂起的IRP_MJ_READ的指针都插入队列，最后IRP_MJ_CLEANUP的派遣函数将一个个IRP出队列，并且调用IoCompleteRequest函数将他们结束。

首先要定义队列的数据结构

typedef struct _MY_IRP_ENTRY
{
	PIRP pIRP;
	LIST_ENTRY ListEntry;
} MY_IRP_ENTRY, *PMY_IRP_ENTRY;

 

在关闭设备的时候，会产生IRP_MJ_CLEANUP类型的IRP，其派遣函数抽取队列中每一个“挂起”的IRP，并调用IoCompleteRequest设置完成。

NTSTATUS HelloDDKCleanUp(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
{
	KdPrint(("Enter HelloDDKCleanUp\n"));

	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
		pDevObj->DeviceExtension;

	//将存在队列中的IRP逐个出队列，并处理
	PMY_IRP_ENTRY my_irp_entry;
	while(!IsListEmpty(pDevExt->pIRPLinkListHead))
	{
		PLIST_ENTRY pEntry = RemoveHeadList(pDevExt->pIRPLinkListHead);
		my_irp_entry = CONTAINING_RECORD(pEntry,
			                      MY_IRP_ENTRY,
								  LIST_ENTRY);
		my_irp_entry->pIRP->IoStatus.Status = STATUS_SUCCESS;
		my_irp_entry->pIRP->IoStatus.Information = 0;
		IoCompleteRequest(my_irp_entry->pIRP,IO_NO_INCREMENT);

		ExFreePool(my_irp_entry);
	}
	//处理IRP_MJ_CLEANUP的IRP
	NTSTATUS status = STATUS_SUCCESS;
	//完成IRP
	pIrp->IoStatus.Status = status;
	pIrp->IoStatus.Information = 0;
	IoCompleteRequest(pIrp,IO_NO_INCREMENT);

	KdPrint(("Leave HelloDDKCleanUp\n"));
	return STATUS_SUCCESS;
}

 

3.取消IRP

除了将“挂起”的IRP插入队列，并在关闭设备时，将“挂起”的IRP结束，还有另外一个办法可以将“挂起”的IRP逐个结束，这就是取消IRP请求。内核函数IoSetCancelRoutine可以设置取消IRP请求的回调函数，其声明如下：

PDRIVER_CANCEL
    IoSetCancelRoutine(
	     IN PIRP Irp,
	     IN PDRIVER_CANCEL CancelRoutine
	);

 

第一个参数Irp：这个参数是需要取消的IRP

第二个参数CancelRoutine：这个是取消函数的函数指针。一旦IRP取消的时候，操作系统会调用这个取消函数。

返回值：标志是否操作成功

下面代码演示如何编写取消历程：

VOID
CancelReadIRP(
	IN PDEVICE_OBJECT DeviceObject,
	IN PIRP Irp
			  )
{
	KdPrint(("Enter CancelReadIRP\n"));
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
		DeviceObject->DeviceExtension;

	//设置完成状态为STATUS_CANCELLED
	Irp->IoStatus.Status = STATUS_CANCELLED;
	Irp->IoStatus.Information = 0;
	IoCompleteRequest(Irp,IO_NO_INCREMENT);

	//释放Cancel自旋锁
	IoReleaseCancelSpinLock(Irp->CancelIrql);
	KdPrint(("Leave CancelReadIRP\n"));
}

NTSTATUS HelloDDKRead(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
{
	KdPrint(("Enter HelloDDKRead\n"));
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
		pDevObj->DeviceExtension;

	IoSetCancelRoutine(pIrp,CancelReadIRP);
	//将IRP设置为挂起
	IoMarkIrpPending(pIrp);

	KdPrint(("Leave HelloDDKRead\n"));
	//返回pending状态
	return STATUS_PENDING;
}

 

StrartIO历程

StartIO历程能够保证各个并行的IRP顺序执行，即串行化。

 

1.并行执行与串行执行

在很多情况下，对设备的操作必须是串行执行而不是并行执行。因此，驱动程序有必要讲并行的请求变换成串行请求。这需要用到队列，如果想依次处理每个IRP，必须采用队列将处理串行化。采用原则是“先来先服务”。

当一个新的IRP请求到来时，首先检查设备是否处于“忙”状态。设备在初始化的时候设置为“空闲”状态。当设备处于“空闲”状态时，可以处理一个IRP得请求，并改变当前设备为“忙”状态。如果设备处于“忙”状态，则将新来的IRP插入队列，并立刻返回，IRP留在以后处理。

当设备由“忙”转向“空闲”状态时，则从队列取出一个IRP进行处理，并重新将状态变为“忙”。

DDK为程序员提供了一个内部队列，并将IRP用StartIO历程串行处理。

 

2.StartIO历程

操作系统为程序员提供了一个IRP队列来实现串行，这个队列用KDEVICE_QUEUE数据结构表示：

typedef struct _KDEVICE_QUEUE
{
	CSHORT Type;
	CSHORT Size;
	LIST_ENTRY DeviceListHead;
	KSPIN_LOCK Lock;
	BOOLEAN Busy;
}KDEVICE_QUEUE,*PKDEVICE_QUEUE,*RESTRICTED_POINTER;

这个队列的列头保存在设备对象Device_Object->DeviceQueue子域中。插入和删除队列中的元素都是由操作系统负责的。在使用这个队列的时候，需要向系统提供一个StartI例程，并将这个函数的函数名传递给操作系统，代码如下：

extern "C" NTSTATUS DriverEntry(
						IN PDRIVER_OBJECT pDriverObject,
						IN PUNICODE_STRING pRegistryPath
								)
{
         //.....
         //设置StartIO例程
	pDriverObject->DriverStartIo = HelloDDKStartIO;
	//.....
}

这个StartIO历程运行在DISPATCH_LEVEL级别，要在声明时加上#pragram LOCKEDCODE，因此这个例程是不会被线程所打断的。

#pragma LOCKEDCODE
VOID HelloDDKStartIO(
			IN PDEVICE_OBJECT DeviceObject,
			IN PIRP Irp
					 )
{
	//...........
}

派遣函数如果想把IRP串行化，只需要加入IoStartPacket函数，就可以将IRP插入队列。并且IoStartPacket函数还可以让程序员指定其取消例程。IoSatrtPacket首先判断当前设备处于“忙”还是“空闲”状态。如果设备“空闲”，则提升当前IRQL到DISPATCH_LEVEL级别，并进入StartIO例程“串行”处理该IRP。如果设备“忙”，则将IRP插入后返回。

在StartIO例程结束前，应该调用IoStartNextPacket函数，其作用是从队列中抽取下一个IRP，并将这个IRP作为参数调用StartIO例程。

 

3.示例

在使用StartIO例程时，需要IRP的派遣函数返回挂起状态，然后调用IoStartPacket内核函数。下面代码演示了如何编写这样的派遣函数

NTSTATUS HelloDDKRead(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
{
	KdPrint(("Enter HelloDDKRead\n"));

	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
		   pDevObj->DeviceExtension;

	//将IRP设置为挂起
	IoMarkIrpPending(pIrp);

	//将IRP插入系统队列
	IoStartPacket(pDevObj,pIrp,0,OnCancelIRP);

	KdPrint(("Leave HelloDDKRead\n"));

	//返回pending状态
	return STATUS_PENDING;
}

在派遣函数中调用IoStartPacket内核函数指定取消例程。下面代码演示了如何编写取消例程

VOID OnCancelIRP(IN PDEVICE_OBJECT DeviceObject,
				 IN PIRP Irp)
{
	KdPrint(("Enter CancelReadIRP\n"));

	if (Irp == DeviceObject->CurrentIrp)
	{
		//标明当前正在改由StartIO处理
		//但StartIO并没有获取cancel自旋锁之前
		//这时需要
		KIRQL oldirql = Irp->CancelIrql;

		//释放Cancel自旋锁
		IoReleaseCancelSpinLock(Irp->CancelIrql);
        
		IoStartNextPacket(DeviceObject,TRUE);

		KeLowerIrql(oldirql);
	}
	else
	{
		//从设备队列中将该IRP抽取出来
		KeRemoveEntryDeviceQueue(&DeviceObject->DeviceQueue,&Irp->Overlay.DeviceQueueEntry);
        //释放cancel自旋锁
		IoReleaseCancelSpinLock(Irp->CancelIrql);
	}
	//设置完成状态为STATUS_CANCELLED
	Irp->IoStatus.Status = STATUS_CANCELLED;
	Irp->IoStatus.Information = 0;
	IoCompleteRequest(Irp,IO_NO_INCREMENT);

	KdPrint(("Leave CancelReadIRP\n"));
}

然后编写StartIO例程，注意StartIO运行在DISPATCH_LEVEL级别，因此不能使用分页内存，否则会引起页故障，从而导致系统崩溃。下面代码演示了如何编写StartIO例程

#pragma LOCKEDCODE
VOID HelloDDKStartIO(
				IN PDEVICE_OBJECT DeviceObject,
				IN PIRP Irp)
{
	KIRQL oldirql;
	KdPrint(("Enter HelloDDKStartIO\n"));

	//获取cancel自旋锁
	IoAcquireCancelSpinLock(&oldirql);
	if (Irp != DeviceObject->CurrentIrp || Irp->Cancel)
	{
		//如果当前有正在处理的IRP，则简单的入队列，并直接返回
		//入队列的工作是由系统完成的，在StartIO中不用负责
		IoReleaseCancelSpinLock(oldirql);
		KdPrint(("Leave HelloDDKStartIO\n"));
		return;
	}
	else
	{
		//由于正在处理该IRP，所以不允许调用取消例程
		//因此将此IRP的取消例程设置为NULL
		IoSetCancelRoutine(Irp,NULL);
		IoReleaseCancelSpinLock(oldirql);
	}

	KEVENT event;
	KeInitializeEvent(&event,NotificationEvent,FALSE);

	//等待3秒
	LARGE_INTEGER timeout;
	timeout.QuadPart = -3*1000*1000*10;

	//定义一个3秒的延时，主要是为了模拟该IRP操作需要大概3秒左右的时间
	KeWaitForSingleObject(&event,Executive,KernelMode,FALSE,&timeout);

	Irp->IoStatus.Status = STATUS_SUCCESS;
	Irp->IoStatus.Information = 0;
	IoCompleteRequest(Irp,IO_NO_INCREMENT);

	//在队列中读取一个IRP，并进行StartIO
	IoStartNextPacket(DeviceObject,TRUE);

	KdPrint(("Leave HelloDDKStartIO\n"));

}

4.自定义的StartIO

系统定义的StartIO例程只能使用一个队列，这个队列会将所有的IRP进行处理化。例如，读，写操作都会混在一起进行串行处理。然而，在有些情况下，需要将读，写分别进行串行处理。这时候就需要自定义StartIO例程。

 

中断服务例程

中断服务例程是设备触发中断后进入的例程。当进入中断服务例程后，IRQL会提升到设备对应的IRQL级别。

1.中断操作的必要性

“中断”设备比“轮询”的效率高，不会浪费太多的CPU时间。另外，中断可以请求嵌套。

 

2.中断优先级

Windows将中断的概念进行了扩展，扩展为32个中断级别（IRQL）。其中0~2级别，级PASSIVE_LEVEL到DISPATCH_LEVEL级别为软中断。从3~31级别为硬件中断。优先级从0~31，级别逐渐升高。

一般线程运行在PASSIVE_LEVEL级别，而负责调度线程的内核代码运行在DISPATCH_LEVEL级别。如果希望线程不被切换到别的线程，可以将线程从PASSIVE_LEVEL提升到DISPATCH_LEVEL级别。

 

3.中断服务例程（ISR）

当硬件设备的中断信号发生后，IRQL会提升至相应的DIRQL级别，操作系统会调用相应的中断服务例程（ISR）。在驱动程序中使用ISR，首先要获得中断对象，该中断对象是一个名为INTERRUPT的数据结构。

 

DPC例程

DPC例程一般和中断服务例程配合使用。中断服务例程处于很高的IRQL，会打断正常运行的线程。而DPC例程运行在相对于较低的DISPATCH_LEVEL级别。因此，一般将不需要紧急处理的代码放在DPC中，而将需要紧急处理的代码放在中断服务例程中。