StartIo历程_IRP串行执行_自定义_处理3个请求

最新推荐文章于 2020-11-11 14:06:03 发布
最新推荐文章于 2020-11-11 14:06:03 发布
阅读量311 收藏
点赞数
分类专栏： 内核驱动全部集合 
#include <windows.h>
#include <stdio.h>
#include <process.h>
UINT WINAPI Thread(LPVOID context)
{
	printf("Enter Thread\n");
	OVERLAPPED overlap={0};
	overlap.hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
	UCHAR buffer[10];
	ULONG ulRead;
	BOOL bRead = ReadFile(*(PHANDLE)context,buffer,10,&ulRead,&overlap);
	WaitForSingleObject(overlap.hEvent,INFINITE);
	return 0;
}
int main()
{
	HANDLE hDevice = 
		CreateFile(L"\\\\.\\HelloDDK",
					GENERIC_READ | GENERIC_WRITE,
					FILE_SHARE_READ,
					NULL,
					OPEN_EXISTING,
					FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,//此处设置FILE_FLAG_OVERLAPPED
					NULL );
	if (hDevice == INVALID_HANDLE_VALUE)
	{
		printf("Open Device failed!");
		return 1;
	}
	HANDLE hThread[2];
	hThread[0] = (HANDLE) _beginthreadex (NULL,0,Thread,&hDevice,0,NULL);
	hThread[1] = (HANDLE) _beginthreadex (NULL,0,Thread,&hDevice,0,NULL);
	//主线程等待两个子线程结束
	WaitForMultipleObjects(2,hThread,TRUE,INFINITE);
	//创建IRP_MJ_CLEANUP IRP
	CloseHandle(hDevice);
	system("pause");
	return 0;
}
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
#include <NTDDK.h>
#ifdef __cplusplus
}
#endif 
#define PAGEDCODE code_seg("PAGE")
#define LOCKEDCODE code_seg()
#define INITCODE code_seg("INIT")
#define PAGEDDATA data_seg("PAGE")
#define LOCKEDDATA data_seg()
#define INITDATA data_seg("INIT")
#define arraysize(p) (sizeof(p)/sizeof((p)[0]))
typedef struct _DEVICE_EXTENSION {
	PDEVICE_OBJECT pDevice;
	UNICODE_STRING ustrDeviceName;	//设备名称
	UNICODE_STRING ustrSymLinkName;	//符号链接名
	KDEVICE_QUEUE device_queue;		//设备队列
	KDEVICE_QUEUE device_queue2;//设备队列2
	KDEVICE_QUEUE device_queue3;//设备队列2
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
// 函数声明
NTSTATUS CreateDevice (IN PDRIVER_OBJECT pDriverObject);
VOID HelloDDKUnload (IN PDRIVER_OBJECT pDriverObject);
NTSTATUS HelloDDKDispatchRoutin(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);
NTSTATUS HelloDDKRead(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);
NTSTATUS HelloDDKCleanUp(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);
NTSTATUS chuangjian(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp);


#include "Driver.h"
#pragma LOCKEDCODE
VOID MyStartIo(IN PDEVICE_OBJECT  DeviceObject,IN PIRP pFistIrp)//设备对象  数据包(irp)
{
	KdPrint(("进入的自定义的 MyStartIo1\n"));
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
	PKDEVICE_QUEUE_ENTRY device_entry;
	PIRP Irp = pFistIrp;
	do
	{
		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);
		KdPrint(("打印读请求数据包 Complete a irp:%x\n",Irp));
		Irp->IoStatus.Status = STATUS_SUCCESS;
		Irp->IoStatus.Information = 0;	// no bytes xfered
		IoCompleteRequest(Irp,IO_NO_INCREMENT);
		device_entry=KeRemoveDeviceQueue(&pDevExt->device_queue);//从队列中删除
		KdPrint(("删除读请求的元素 device_entry:%x\n",device_entry));
		if (device_entry==NULL)
		{
			break;
		}
		Irp = CONTAINING_RECORD(device_entry, IRP, Tail.Overlay.DeviceQueueEntry);//irp的地址
	}while(1);
	KdPrint(("Leave MyStartIo1\n"));
}
VOID MyStartIo2(IN PDEVICE_OBJECT  DeviceObject, IN PIRP pFistIrp)//设备对象  数据包(irp)
{
	KdPrint(("进入的自定义的 MyStartIo2\n"));
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
	PKDEVICE_QUEUE_ENTRY device_entry;
	PIRP Irp = pFistIrp;
	do
	{
		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);
		KdPrint(("打印创建请求数据包 Complete a irp:%x\n", Irp));
		Irp->IoStatus.Status = STATUS_SUCCESS;
		Irp->IoStatus.Information = 0;	// no bytes xfered
		IoCompleteRequest(Irp, IO_NO_INCREMENT);
		device_entry = KeRemoveDeviceQueue(&pDevExt->device_queue2);//从队列中删除
		KdPrint(("删除创建请求的元素 device_entry:%x\n", device_entry));
		if (device_entry == NULL)
		{
			break;
		}
		Irp = CONTAINING_RECORD(device_entry, IRP, Tail.Overlay.DeviceQueueEntry);//irp的地址
	} while (1);
	KdPrint(("Leave MyStartIo2\n"));
}
VOID MyStartIo3(IN PDEVICE_OBJECT  DeviceObject, IN PIRP pFistIrp)//设备对象  数据包(irp)
{
	KdPrint(("进入的自定义的 MyStartIo3\n"));
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
	PKDEVICE_QUEUE_ENTRY device_entry;
	PIRP Irp = pFistIrp;
	do
	{
		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);
		KdPrint(("打印关闭请求数据包 Complete a irp:%x\n", Irp));
		Irp->IoStatus.Status = STATUS_SUCCESS;
		Irp->IoStatus.Information = 0;	// no bytes xfered
		IoCompleteRequest(Irp, IO_NO_INCREMENT);
		device_entry = KeRemoveDeviceQueue(&pDevExt->device_queue3);//从队列中删除
		KdPrint(("删除关闭请求的元素 device_entry:%x\n", device_entry));
		if (device_entry == NULL)
		{
			break;
		}
		Irp = CONTAINING_RECORD(device_entry, IRP, Tail.Overlay.DeviceQueueEntry);//irp的地址
	} while (1);
	KdPrint(("Leave MyStartIo3\n"));
}
/************************************************************************
* 函数名称:DriverEntry
* 功能描述:初始化驱动程序，定位和申请硬件资源，创建内核对象
* 参数列表:
      pDriverObject:从I/O管理器中传进来的驱动对象
      pRegistryPath:驱动程序在注册表的中的路径
* 返回 值:返回初始化驱动状态
*************************************************************************/
#pragma INITCODE
extern "C" NTSTATUS DriverEntry (IN PDRIVER_OBJECT pDriverObject,IN PUNICODE_STRING pRegistryPath	) 
{
	NTSTATUS status;
	KdPrint(("Enter DriverEntry\n"));
	//设置卸载函数
	pDriverObject->DriverUnload = HelloDDKUnload;
	//设置派遣函数
	pDriverObject->MajorFunction[IRP_MJ_CREATE] = chuangjian;
	pDriverObject->MajorFunction[IRP_MJ_CLOSE] = HelloDDKCleanUp;
	pDriverObject->MajorFunction[IRP_MJ_WRITE] = HelloDDKDispatchRoutin;
	pDriverObject->MajorFunction[IRP_MJ_READ] = HelloDDKRead;
	pDriverObject->MajorFunction[IRP_MJ_CLEANUP] = HelloDDKDispatchRoutin;
	pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = HelloDDKDispatchRoutin;
	pDriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = HelloDDKDispatchRoutin;
	pDriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = HelloDDKDispatchRoutin;
	pDriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = HelloDDKDispatchRoutin;
	//创建驱动设备对象
	status = CreateDevice(pDriverObject);
	KdPrint(("Leave DriverEntry\n"));
	return status;
}
/************************************************************************
* 函数名称:CreateDevice
* 功能描述:初始化设备对象
* 参数列表:
      pDriverObject:从I/O管理器中传进来的驱动对象
* 返回 值:返回初始化状态
*************************************************************************/
#pragma INITCODE
NTSTATUS CreateDevice (IN PDRIVER_OBJECT	pDriverObject) 
{
	NTSTATUS status;
	PDEVICE_OBJECT pDevObj;
	PDEVICE_EXTENSION pDevExt;
	//创建设备名称
	UNICODE_STRING devName;
	RtlInitUnicodeString(&devName,L"\\Device\\MyDDKDevice");
	//创建设备
	status = IoCreateDevice( pDriverObject,sizeof(DEVICE_EXTENSION),&(UNICODE_STRING)devName,FILE_DEVICE_UNKNOWN,0, TRUE,&pDevObj );
	if (!NT_SUCCESS(status))
		return status;
	pDevObj->Flags |= DO_BUFFERED_IO;
	pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
	pDevExt->pDevice = pDevObj;
	pDevExt->ustrDeviceName = devName;
	RtlZeroBytes(&pDevExt->device_queue,sizeof(pDevExt->device_queue));
	KeInitializeDeviceQueue(&pDevExt->device_queue);//初始化设备 一起初始化队列
	KeInitializeDeviceQueue(&pDevExt->device_queue2);//初始化设备 一起初始化队列
	KeInitializeDeviceQueue(&pDevExt->device_queue3);//初始化设备 一起初始化队列
	//创建符号链接
	UNICODE_STRING symLinkName;
	RtlInitUnicodeString(&symLinkName,L"\\??\\HelloDDK");
	pDevExt->ustrSymLinkName = symLinkName;
	status = IoCreateSymbolicLink( &symLinkName,&devName );
	if (!NT_SUCCESS(status)) 
	{
		IoDeleteDevice( pDevObj );
		return status;
	}
	return STATUS_SUCCESS;
}
/************************************************************************
* 函数名称:HelloDDKUnload
* 功能描述:负责驱动程序的卸载操作
* 参数列表:
      pDriverObject:驱动对象
* 返回 值:返回状态
*************************************************************************/
#pragma PAGEDCODE
VOID HelloDDKUnload (IN 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 );
	//}
	UNICODE_STRING symLinkName;
	RtlInitUnicodeString(&symLinkName, L"\\??\\HelloDDK");
	pNextObj = pDriverObject->DeviceObject;//我的第一个设备        
	IoDeleteSymbolicLink(&symLinkName);//删除符号连接        
	IoDeleteDevice(pDriverObject->DeviceObject);//删除设备    
}
/************************************************************************
* 函数名称:HelloDDKDispatchRoutin
* 功能描述:对读IRP进行处理
* 参数列表:
      pDevObj:功能设备对象
      pIrp:从IO请求包
* 返回 值:返回状态
*************************************************************************/
#pragma PAGEDCODE
NTSTATUS HelloDDKDispatchRoutin(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp) 
{
	KdPrint(("Enter HelloDDKDispatchRoutin\n"));
	PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(pIrp);
	//建立一个字符串数组与IRP类型对应起来
	static char* irpname[] = 
	{
		"IRP_MJ_CREATE",
		"IRP_MJ_CREATE_NAMED_PIPE",
		"IRP_MJ_CLOSE",
		"IRP_MJ_READ",
		"IRP_MJ_WRITE",
		"IRP_MJ_QUERY_INFORMATION",
		"IRP_MJ_SET_INFORMATION",
		"IRP_MJ_QUERY_EA",
		"IRP_MJ_SET_EA",
		"IRP_MJ_FLUSH_BUFFERS",
		"IRP_MJ_QUERY_VOLUME_INFORMATION",
		"IRP_MJ_SET_VOLUME_INFORMATION",
		"IRP_MJ_DIRECTORY_CONTROL",
		"IRP_MJ_FILE_SYSTEM_CONTROL",
		"IRP_MJ_DEVICE_CONTROL",
		"IRP_MJ_INTERNAL_DEVICE_CONTROL",
		"IRP_MJ_SHUTDOWN",
		"IRP_MJ_LOCK_CONTROL",
		"IRP_MJ_CLEANUP",
		"IRP_MJ_CREATE_MAILSLOT",
		"IRP_MJ_QUERY_SECURITY",
		"IRP_MJ_SET_SECURITY",
		"IRP_MJ_POWER",
		"IRP_MJ_SYSTEM_CONTROL",
		"IRP_MJ_DEVICE_CHANGE",
		"IRP_MJ_QUERY_QUOTA",
		"IRP_MJ_SET_QUOTA",
		"IRP_MJ_PNP",
	};
	UCHAR type = stack->MajorFunction;
	if (type >= arraysize(irpname))
		KdPrint((" - Unknown IRP, major type %X\n", type));
	else
		KdPrint(("\t%s\n", irpname[type]));
	//对一般IRP的简单操作，后面会介绍对IRP更复杂的操作
	NTSTATUS status = STATUS_SUCCESS;
	// 完成IRP
	pIrp->IoStatus.Status = status;
	pIrp->IoStatus.Information = 0;	// bytes xfered
	IoCompleteRequest( pIrp, IO_NO_INCREMENT );
	KdPrint(("Leave HelloDDKDispatchRoutin\n"));
	return status;
}
VOID OnCancelIRP(IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp)
{
	KdPrint(("进入取消历程\n"));
	//释放Cancel自旋锁
	IoReleaseCancelSpinLock(Irp->CancelIrql);
	//设置完成状态为STATUS_CANCELLED
 	Irp->IoStatus.Status = STATUS_CANCELLED;
 	Irp->IoStatus.Information = 0;	// bytes xfered
 	IoCompleteRequest( Irp, IO_NO_INCREMENT );
	KdPrint(("进入取消历程\n"));
}
VOID OnCancelIRP2(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
	KdPrint(("Enter CancelchuangjianIRP\n"));
	//释放Cancel自旋锁
	IoReleaseCancelSpinLock(Irp->CancelIrql);
	//设置完成状态为STATUS_CANCELLED
	Irp->IoStatus.Status = STATUS_CANCELLED;
	Irp->IoStatus.Information = 0;	// bytes xfered
	IoCompleteRequest(Irp, IO_NO_INCREMENT);
	KdPrint(("Leave CancelchuangjianIRP\n"));
}
NTSTATUS HelloDDKRead(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp) 
{
	KdPrint(("进入读请求\n"));
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
	IoMarkIrpPending(pIrp);//将IRP设置为挂起
	IoSetCancelRoutine(pIrp,OnCancelIRP);//取消历程
	KIRQL oldirql;
	KeRaiseIrql(DISPATCH_LEVEL, &oldirql);//提升IRP至DISPATCH_LEVEL
	KdPrint(("HelloDDKRead irp :%x\n",pIrp));
	KdPrint(("DeviceQueueEntry:%x\n",&pIrp->Tail.Overlay.DeviceQueueEntry));
	if (!KeInsertDeviceQueue(&pDevExt->device_queue, &pIrp->Tail.Overlay.DeviceQueueEntry))//插入到队列 系统历程处理 如果返回false(没有被插入)
	MyStartIo(pDevObj,pIrp);//调用自定义StartIo
	KeLowerIrql(oldirql);//将IRP降至原来IRQL
	KdPrint(("Leave HelloDDKRead\n"));
	//返回pending状态
	return STATUS_PENDING;
}
NTSTATUS chuangjian(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
{
	KdPrint(("进入创建请求\n"));
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
	IoMarkIrpPending(pIrp);//将IRP设置为挂起
	IoSetCancelRoutine(pIrp, OnCancelIRP);//取消历程
	KIRQL oldirql;
	KeRaiseIrql(DISPATCH_LEVEL, &oldirql);//提升IRP至DISPATCH_LEVEL
	KdPrint(("HelloDDKchuangjian irp :%x\n", pIrp));
	KdPrint(("DeviceQueueEntry:%x\n", &pIrp->Tail.Overlay.DeviceQueueEntry));
	if (!KeInsertDeviceQueue(&pDevExt->device_queue2, &pIrp->Tail.Overlay.DeviceQueueEntry))//插入到队列 系统历程处理 如果返回false(没有被插入)
		MyStartIo2(pDevObj, pIrp);//调用自定义StartIo
	KeLowerIrql(oldirql);//将IRP降至原来IRQL
	KdPrint(("Leave HelloDDKchuangjian\n"));
	//返回pending状态
	return STATUS_PENDING;
}
NTSTATUS HelloDDKCleanUp(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)//关闭历程
{
	KdPrint(("进入关闭请求\n"));
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
	IoMarkIrpPending(pIrp);//将IRP设置为挂起
	IoSetCancelRoutine(pIrp, OnCancelIRP);//取消历程
	KIRQL oldirql;
	KeRaiseIrql(DISPATCH_LEVEL, &oldirql);//提升IRP至DISPATCH_LEVEL
	KdPrint(("HelloDDKguanbi irp :%x\n", pIrp));
	KdPrint(("DeviceQueueEntry:%x\n", &pIrp->Tail.Overlay.DeviceQueueEntry));
	if (!KeInsertDeviceQueue(&pDevExt->device_queue3, &pIrp->Tail.Overlay.DeviceQueueEntry))//插入到队列 系统历程处理 如果返回false(没有被插入)
		MyStartIo3(pDevObj, pIrp);//调用自定义StartIo
	KeLowerIrql(oldirql);//将IRP降至原来IRQL
	KdPrint(("Leave HelloDDKguanbi\n"));
	//返回pending状态
	return STATUS_PENDING;


}

 

 

 

 

 

「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
WDM驱动StartIo例程
12-12
用WDM实现的StartIo例子。将多个线程创建的IRP串行化处理。
StartIO例程学习
weixin_30845171的博客
09-22 230
能够保证各个并行的IRP顺序执行，即串行化。 很多时候，对设备的操作必须是串行化，驱动程序有必要将并行的请求变成串行的请求，需要用到队列。 并行运行（函数执行交织在一起） 如果想一次处理每个IRP，必须采用队列将处理串行化。采用“先来先服务”原则 typedef struct _KDEVICE_QUEUE { ...
IRP请求的完成与返回
博文视点（北京）官方博客
05-15 1828
 IRP请求的完成与返回    每当完成了一个以IRP为代表的I/O操作请求的时候，就要执行IRP的善后操作IoCompleteRequest()，这是个宏操作，定义为函数IofCompleteRequest()。#define  IoCompleteRequest  IofCompleteRequest    如前所述，以IRP为代表的I/O操作请求的执行可以是同步的，也可以是异步的，所以一
StartIO例程
keepdoingit的专栏
12-31 3229
    为什么要有StartIO例程？    如果你开发了一个串口设备，并为其开发了一个驱动程序， 还有一个应用程序。用户使用这个应用程序来操作这个串口设备，进行读取或者写信数据。 现在你可以会面临这样一个问题，即如果你的应用程序使用多线程来同时对这个设备进行读取数据和写入数据时怎么办？ 这样很可能就会乱成混乱。为了解决这个问题， windows提供了排队的机制， 因为每一次对设备的读操作或者
自定义StartIO
weixin_30670151的博客
09-22 100
StartIO主要保证 各个运行的IRP顺序执行，即串行化 用系统定义的StartIO例程只能使用一个队列，这个队列会将所有的IRP进行处理 读写操作 都会混在一起进行串行处理，但我们需要将读写分别进行串行处理 ，就需要自定义StartIo 当自定义StartIO时，需要我们自己负责”入队“ + ”出队“ 使用前初始化队列： VOID KeInitiali...
IRP.rar_IRP ID_irp会员_site:www.pudn.com
09-21
3. **List Entry**：IRP使用这个字段来链接到系统I/O队列，以便驱动程序可以按顺序处理请求。 4. **Associated IRP**：如果一个IRP依赖于另一个IRP（例如，读取或写入操作需要先完成缓冲区分配），那么这个字段会...
IRP.rar_IRP_IRP.pdf_irp.rar_求IRP的编程
09-21
IRP是设备驱动程序处理I/O操作的核心数据结构，它封装了I/O操作的所有必要信息，如操作类型、缓冲区地址、请求的设备等。在驱动编程中，理解并熟练运用IRP是至关重要的。 IRP由系统分配，并由文件系统或高层驱动...
WDM_Driver.rar_IRP_WDM irp 初始化_WinCE WDM
07-15
windows驱动程序基本结构:(1)初始化驱动程序，定位和申请硬件资源，创建内核对象(2)添加新设备(3)对PNP IRP进行缺省处理(4)对IRP_MN_REMOVE_DEVICE IRP进行处理(5)对即插即用IRP进行处理
8549057USBFilter1.rar_IBtUsb_Filter_irp检查_usb driver filter_usb
07-13
usb过滤驱动WDM（和KDM）是分层的，在构造设备栈时，IO管理器可以使一个设备对象附加到另外一个初始驱动程序创建的设备对象上。与初始设备对象相关的驱动程序决定的IRP,也将被发送到附加的设备对象相关的驱动程序上...
IRP.rar_IRP_irp地址解析_site:www.pudn.com
09-14
IRP（I/O Request Packet，I/O 请求包）是Windows操作系统内核中处理I/O操作的核心数据结构。在Windows驱动程序开发中，理解和掌握IRP的工作机制至关重要，因为它是驱动程序与系统I/O管理器之间通信的主要手段。下面...
StartIO上机实践
04-06
Windows设备驱动程序StartIO、IRP同步/异步上机小结， 文档见链接：http://blog.csdn.net/dijkstar/article/details/44901049
StartIo历程_IRP串行执行
07-03 371
#include <windows.h> #include <stdio.h> #include <process.h> UINT WINAPI Thread(LPVOID context) { printf("Enter Thread\n"); OVERLAPPED overlap={0}; overlap.hEvent = CreateEvent(N...
startio 的初体验。。
xum2008的专栏
12-03 640
对于在内核运用的程序而言，任何时候都可能有对个请求同时来到，我们应该怎么样去处理他们呢？或者是根据什么样的方法来处理他们呢？ 我想，当我们了解startio 后，我们会有一个新的认识。。。对 IRP 的处理 可以分成两种：1：串行2：并行 显然，并行使不可取的，因为，如果那样的话，派遣函数就会交织在一起。。所以，我们必须根据队列这种数据结构来处理他们。。。 
自定义StartIO例程
125096
08-04 440
EXE部分 #include #include #include #include "Ioctl.h" DWORD ThreadProc( LPVOID lpParameter) { printf("线程执行\n"); OVERLAPPED overlap={0}; overlap.hEvent=CreateEvent(NULL,FALSE,FALSE,NULL); UCHAR
StartIo例程的作用
weixin_30477797的博客
09-16 145
关于驱动程序里StartIo例程的作用，部分摘自网络，有不正确的地方还望指正。 在很多时候，驱动程序不能立即处理I/O请求，此时需要通过一个队列保存Irp，然后返回，等到可以处理I/O请求时，再从队列中取出Irp进行处理。驱动程序可以自己维护一个队列，并通过系统线程来做处理。由于很多驱动程序都需要这种处理机制，为了方便处理，系统为此提供了一套处理机制，驱动程序可以调用IoSta...
zz: 自定义StartIo
jtujtujtu的专栏
07-25 1054
ZZ from : http://www.joenchen.com/archives/424 这个系统给的StartIo虽然好用, 但是很多时候我们还是需要使用自定义的StartIo例程的. 因为系统提供的只能使用一个队列.如果是我们自己建立的话, 可以建立多个队列. 灵活性高, 但是稍微复杂些. 其实要说复杂也不尽然, 用那个系统的时候感觉不是很好,因为封装的时候不给力, 还需要在我们自己
Windows驱动开发WDM （10）- StartIo取消例程
zj510的专栏
12-13 3014
上一个文章讲了StartIo的基本用法（http://blog.csdn.net/zj510/article/details/8230071），其中调用IoStartPacket的时候传了一个取消例程进去。如： IoStartPacket(fdo, Irp, 0, HelloWDMOnCancelIRP); 参考MSDN上的参数说明： 第四个参数是一个Cancel routine（取消例
[Win32驱动14]通过4种方式手动创建IRP
輚至消亡
11-11 539
1. IoBuildSynchronousFsdRequest __drv_aliasesMem PIRP IoBuildSynchronousFsdRequest( ULONG MajorFunction, PDEVICE_OBJECT DeviceObject, PVOID Buffer, ULONG Length, PLARGE_INTEGER StartingOffset, PKEVENT
IRP_MJ_DEVICE_CONTROL
最新发布
03-08
IRP_MJ_DEVICE_CONTROL是Windows内核中的一个重要的I/O请求分发函数，用于处理设备控制请求。它是IRP_MJ_INTERNAL_DEVICE_CONTROL的别名，用于处理设备对象上的内部设备控制请求。 当应用程序或驱动程序需要与设备...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值