IRP的超时处理

很多时候，IRP 被传送到底层驱动程序后，由于硬件设备的问题，IRP 不能得到及时
的处理，甚至有可能永远都不会被处理。这时候需要对IRP超时情况做出处理，一旦在规
定时间内IRP没有被处理，操作系统就会进入到IRP的超时处理函数中。

首先初始一个定时器对象和DPC对象，并将DPC例程和定时器对象进行关联。在每
次对IRP操作前，开启定时器，并设置好-定的超时。 如果在指定时间内对IRP的处理没
有结束，那么操作系统就会就会进入DPC例程。
在DPC例程中取消还在继续处理的IRP。如果驱动程序能在超时前结束IRP的操作，
则应该取消定时器，从而保证不会再次取消IRP。

此代码没有处理多个IRP同时请求的情况，需要使用StartIo

typedef struct _DEVICE_EXTENSION{
	PDEVICE_OBJECT pDevice;
	UNICODE_STRING ustrDeviceName;	//设备名称
	UNICODE_STRING ustrSymLinkName;	//符号链接名

	//自己的扩展
	PIRP currentPendingIRP;
	KDPC dpc;
	KTIMER timer;

} DEVICE_EXTENSION, *PDEVICE_EXTENSION;



#include<ntddk.h>
#include<ntstatus.h>
#include "Driver.h"

#define DEVICE_NAME L"\\Device\\MyDevice"
#define SYMBOLICLINE_NAME L"\\??\\MyTestDriver"  //ring3用CreateFile打开设备时,用"\\\\.\\MyTestDriver"//相当于起的别名
#define OPER1 CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ANY_ACCESS)
#define OPER2 CTL_CODE(FILE_DEVICE_UNKNOWN,0x900,METHOD_BUFFERED,FILE_ANY_ACCESS)

PVOID pDeviceExtension = 0;

//实现卸载函数
VOID DriverUnload(PDRIVER_OBJECT pDriverObject)
{
	PDEVICE_OBJECT	pNextObj;
	KdPrint(("Enter DriverUnload\n"));
	pNextObj = pDriverObject->DeviceObject;
	while (pNextObj != NULL)
	{
		PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
			pNextObj->DeviceExtension;

		//删除符号链接
		UNICODE_STRING pLinkName = pDevExt->ustrSymLinkName;
		IoDeleteSymbolicLink(&pLinkName);

		pNextObj = pNextObj->NextDevice;
		IoDeleteDevice(pDevExt->pDevice);
		DbgPrint("删除设备\n");
	}

}

NTSTATUS IrpDefaultProc(PDEVICE_OBJECT pDeviceObject/*设备信息*/, PIRP pIrp/*参数信息*/)
{

	pIrp->IoStatus.Status = STATUS_SUCCESS;//getlasterror()得到的就是这个值
	pIrp->IoStatus.Information = 0;//返回给3环多少数据，没有填0
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);
	return STATUS_SUCCESS;
}

#pragma PAGEDCODE
NTSTATUS IrpReadProc(PDEVICE_OBJECT pDeviceObject/*设备信息*/, PIRP pIrp/*参数信息*/)
{
	//将IRP设置为挂起
	IoMarkIrpPending(pIrp);

	//设置一个DPC 如果超时就在DPC的回调处理中把IRP取消掉。
	PDEVICE_EXTENSION pDevExt = pDeviceObject->DeviceExtension;

	//保存IRP指针 
	pDevExt->currentPendingIRP = pIrp;

	//定义3s的超时
	ULONG ulMicroSecond = 3000000;

	//将32位整数转换成64位整数
	LARGE_INTEGER timeOut = RtlConvertLongToLargeInteger(-10 * ulMicroSecond);

	//开启计时器
	KeSetTimer(&pDevExt->timer, timeOut, &pDevExt->dpc);

	pIrp->IoStatus.Status = STATUS_PENDING;//getlasterror()得到的就是这个值
	pIrp->IoStatus.Information = 0;//返回给3环多少数据，没有填0
	return STATUS_PENDING;
}

#pragma LOCKEDCODE
void DpcRoutine(
	PKDPC  pDpc,
	PVOID Context,
	PVOID Arg1,
	PVOID Arg2
	)
{
	//获得设备扩展的指针
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)Context;

	//获得挂起的IRP
	PIRP pIrp = pDevExt->currentPendingIRP;

	//设置完成状态为STATUS_CANCELLED
	pIrp->IoStatus.Status = STATUS_CANCELLED;

	//设置操作的字节数
	pIrp->IoStatus.Information = 0;
	DbgPrint("Delay IRP run\n");
	//完成请求
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);

}

NTSTATUS DriverEntry(PDRIVER_OBJECT pDriver, PUNICODE_STRING reg_path)
{

	NTSTATUS status = 0;
	ULONG uIndex = 0;
	PDEVICE_OBJECT pDeviceObj = NULL;
	UNICODE_STRING DeviceName;
	UNICODE_STRING SymbolicLinkName;

	//Irp默认处理
	pDriver->MajorFunction[IRP_MJ_CREATE] = IrpDefaultProc;
	pDriver->MajorFunction[IRP_MJ_CLOSE] = IrpDefaultProc;
	pDriver->MajorFunction[IRP_MJ_WRITE] = IrpDefaultProc;
	pDriver->MajorFunction[IRP_MJ_READ] = IrpDefaultProc;
	pDriver->MajorFunction[IRP_MJ_CLEANUP] = IrpDefaultProc;
	pDriver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = IrpDefaultProc;
	pDriver->MajorFunction[IRP_MJ_SET_INFORMATION] = IrpDefaultProc;
	pDriver->MajorFunction[IRP_MJ_SHUTDOWN] = IrpDefaultProc;
	pDriver->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = IrpDefaultProc;

	//设置派遣函数和卸载函数	
	pDriver->DriverUnload = DriverUnload;

	pDriver->MajorFunction[IRP_MJ_READ] = IrpReadProc;
	

	//创建设备名称
	RtlInitUnicodeString(&DeviceName, DEVICE_NAME);

	//创建设备  让三环的API能够找到，才能实现通信
	status = IoCreateDevice(pDriver,
		sizeof(DEVICE_EXTENSION),	//扩展设备大小 
		&DeviceName,
		FILE_DEVICE_UNKNOWN,
		0,
		TRUE,
		&pDeviceObj);
	if (status != STATUS_SUCCESS)
	{
		DbgPrint("创建设备失败! status=%x\r\n", status);
		return status;
	}

	//设置交互数据方式
	pDeviceObj->Flags |= DO_BUFFERED_IO;

	//创建符号链接名称,就是给该设备在三环起个能用的别名
	RtlInitUnicodeString(&SymbolicLinkName, SYMBOLICLINE_NAME);

	//创建符号链接
	status = IoCreateSymbolicLink(&SymbolicLinkName, &DeviceName);
	if (!NT_SUCCESS(status))
	{
		DbgPrint("创建符号链接失败!\r\n");
		IoDeleteDevice(pDeviceObj);
		return status;
	}
	PDEVICE_EXTENSION pDevExt = pDeviceObj->DeviceExtension;
	pDevExt->pDevice = pDeviceObj;
	pDevExt->ustrDeviceName = DeviceName;
	pDevExt->ustrSymLinkName = SymbolicLinkName;

	/*测试代码*/

	//初始化定时器对象
	KeInitializeTimer(&pDevExt->timer);

	//初始化DPC对象
	KeInitializeDpc(&pDevExt->dpc, DpcRoutine, pDevExt);

	/*测试代码*/

	return STATUS_SUCCESS;

}



}

3环代码 使用同步方式打开。

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

int main()
{
	HANDLE hDevice = 
		CreateFile(L"\\\\.\\MyTestDriver",
		GENERIC_READ | GENERIC_WRITE,
		0,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL,//使用同步方式
		NULL );

	if (hDevice == INVALID_HANDLE_VALUE)
	{
		printf("Open Device failed!");
		getchar();
		return 1;
	}

	char buffer[20]={0};
	OVERLAPPED OverLapped={0};
	ReadFile(hDevice,buffer,10,0,&OverLapped);

	//创建IRP_MJ_CLEANUP IRP
	CloseHandle(hDevice);
	return 0;
}