Windows驱动开发技术详解__IRP的同步

<学习笔记>Windows驱动开发技术详解__IRP的同步
http://blog.csdn.net/aksnzhy/article/details/6847969

对设备的任何操作都会最终转化为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
#include

#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
#include

#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
#include

#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中，而将需要紧急处理的代码放在中断服务例程中。