驱动中同步与异步发送IRP

最新推荐文章于 2022-04-26 11:24:18 发布
最新推荐文章于 2022-04-26 11:24:18 发布
阅读量511 收藏 2
点赞数
分类专栏： Win下NT式驱动编程学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37232329/article/details/109497845
版权

1. 同步

同步创建方式的意思是应用层必须要等待IRP被IoCompleteRequest后才会返回。其必须是同步的。即使底层设备对收到的IRP进行挂起处理，那也得无限等待下去。看一下下面的例子:

该例子主要是进行了以下步骤:

  1. 应用层程序发送了Read类型的IRP给中间设备
  2. 中间设备捕获IRP后完成该IRP并调用ZwReadFile重新创建了一个IRP给底层设备
  3. 底层设备挂起该IRP并设置DPC例程来处理该被挂起的IRP
  4. 底层设备DPC例程完成了IRP后返回

接下去看一下底层设备代码:

#include <ntddk.h>

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

	KDPC pollingDPC;	// 存储DPC对象
	KTIMER pollingTimer;// 存储计时器对象
	PIRP currentPendingIRP;//记录当前挂起的IRP
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;

VOID Unload(IN PDRIVER_OBJECT pDriverObject) {
	PDEVICE_OBJECT pNextObj;
	KdPrint(("DriverA: 进入Unload例程\n"));

	pNextObj = pDriverObject->DeviceObject;
	while (pNextObj) {
		PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pNextObj->DeviceExtension;

		UNICODE_STRING pLinkName = pDevExt->ustrSymLinkName;
		IoDeleteSymbolicLink(&pLinkName);
		IoDeleteDevice(pDevExt->pDevice);

		pNextObj = pNextObj->NextDevice;
	}
	KdPrint(("DriverA: 离开Unload例程\n"));
}

#define MICROSECOND(s) (-10 * s)
#define MILLISECOND(s) (MICROSECOND(s) * 1000)
#define SECOND(s) (MILLISECOND(s) * 1000)

void OnTimerDpc(PKDPC Dpc, PVOID Context, PVOID SystemArgument1, PVOID SystemArgument2) {
	KdPrint(("DriverA: 进入DPC例程\n"));
	PDEVICE_OBJECT pDevObj = (PDEVICE_OBJECT)Context;
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
	PIRP currentPendingIrp = pDevExt->currentPendingIRP;
	currentPendingIrp->IoStatus.Status = STATUS_SUCCESS;
	currentPendingIrp->IoStatus.Information = 0;
	KdPrint(("完成了挂起的IRP: 0x%08X\n", currentPendingIrp));

	IoCompleteRequest(currentPendingIrp, IO_NO_INCREMENT);
	KdPrint(("DriverA: 离开DPC例程\n"));
}

NTSTATUS CreateDevice(IN PDRIVER_OBJECT	pDriverObject) {
	NTSTATUS status;
	PDEVICE_OBJECT pDevObj;
	PDEVICE_EXTENSION pDevExt;

	//创建设备名称
	UNICODE_STRING devName;
	RtlInitUnicodeString(&devName, L"\\Device\\DevA");

	//创建设备
	status = IoCreateDevice(pDriverObject, sizeof(DEVICE_EXTENSION), &devName, FILE_DEVICE_UNKNOWN, 0, TRUE, &pDevObj);
	if (!NT_SUCCESS(status)) {
		KdPrint(("IoCreateDevice: %08X\n", status));
		return status;
	}
	pDevObj->Flags |= DO_BUFFERED_IO;
	pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
	pDevExt->pDevice = pDevObj;
	pDevExt->ustrDeviceName = devName;

	KeInitializeTimer(&pDevExt->pollingTimer);
	KeInitializeDpc(&pDevExt->pollingDPC, OnTimerDpc, (PVOID)pDevObj);

	UNICODE_STRING symLinkName;
	RtlInitUnicodeString(&symLinkName, L"\\??\\DevA");
	pDevExt->ustrSymLinkName = symLinkName;
	status = IoCreateSymbolicLink(&symLinkName, &devName);
	if (!NT_SUCCESS(status)) {
		KdPrint(("IoCreateSymbolicLink: %08X\n", status));
		IoDeleteDevice(pDevObj);
		return status;
	}

	return STATUS_SUCCESS;
}

NTSTATUS DispatchRoutine(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp) {
	NTSTATUS status = STATUS_SUCCESS;

	pIrp->IoStatus.Status = status;
	pIrp->IoStatus.Information = 0;
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);

	return status;
}

NTSTATUS ReadRoutine(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp) {
	KdPrint(("DriverA: 进入了ReadRoutine\n"));

	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
	LARGE_INTEGER li = RtlConvertLongToLargeInteger(-30 * 1000 * 1000);
	pDevExt->currentPendingIRP = pIrp; // 保存IRP
	IoMarkIrpPending(pIrp); // 挂起IRP
	KeSetTimer(&pDevExt->pollingTimer, li, &pDevExt->pollingDPC); // 设置了DPC例程3秒后启动

	KdPrint(("DriverA: 离开了ReadRoutine\n"));
	
	return(STATUS_PENDING);
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, PUNICODE_STRING pRegistryPath) {
	KdPrint(("DriverA: 进入DriverEntry\n"));
	pDriverObject->DriverUnload = Unload;
	for (int i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; ++i) 
		pDriverObject->MajorFunction[i] = DispatchRoutine;
	pDriverObject->MajorFunction[IRP_MJ_READ] = ReadRoutine;
	NTSTATUS status = CreateDevice(pDriverObject);
	if (!NT_SUCCESS(status)) 
		return(status);
	KdPrint(("DriverA: 离开DriverEntry\n"));

	return(STATUS_SUCCESS);
}

来看一下中间设备代码:

#include <ntddk.h>

typedef struct _DEVICE_EXTENSION {
	PDEVICE_OBJECT pDevice;
	UNICODE_STRING ustrDeviceName;	//设备名称
	UNICODE_STRING ustrSymLinkName;	//符号链接名
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;

NTSTATUS DispatchRoutine(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp) {
	NTSTATUS status = STATUS_SUCCESS;

	pIrp->IoStatus.Status = status;
	pIrp->IoStatus.Information = 0;
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);

	return status;
}

VOID Unload(IN PDRIVER_OBJECT pDriverObject) {
	PDEVICE_OBJECT pNextObj;
	KdPrint(("DriverB: 进入Unload例程\n"));

	pNextObj = pDriverObject->DeviceObject;
	while (pNextObj) {
		PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pNextObj->DeviceExtension;

		UNICODE_STRING pLinkName = pDevExt->ustrSymLinkName;
		IoDeleteSymbolicLink(&pLinkName);
		IoDeleteDevice(pDevExt->pDevice);

		pNextObj = pNextObj->NextDevice;
	}
	KdPrint(("DriverB: 离开Unload例程\n"));
}

NTSTATUS CreateDevice(IN PDRIVER_OBJECT	pDriverObject) {
	NTSTATUS ntStatus;
	PDEVICE_OBJECT pDevObj;
	PDEVICE_EXTENSION pDevExt;
	UNICODE_STRING symLinkName;
	UNICODE_STRING devName;

	RtlInitUnicodeString(&devName, L"\\Device\\DevB");
	ntStatus = IoCreateDevice(pDriverObject, sizeof(DEVICE_EXTENSION), &devName, FILE_DEVICE_UNKNOWN, 0, TRUE, &pDevObj);
	if (!NT_SUCCESS(ntStatus))
		return ntStatus;
	pDevObj->Flags |= DO_BUFFERED_IO;
	pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
	pDevExt->pDevice = pDevObj;
	pDevExt->ustrDeviceName = devName;

	RtlInitUnicodeString(&symLinkName, L"\\??\\DevB");
	pDevExt->ustrSymLinkName = symLinkName;
	NTSTATUS status = IoCreateSymbolicLink(&symLinkName, &devName);
	if (!NT_SUCCESS(status)) {
		IoDeleteDevice(pDevObj);
		return status;
	}

	return STATUS_SUCCESS;
}

NTSTATUS ReadRoutine(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp) {
	KdPrint(("DriverB: 进入ReadRoutine\n"));
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
	OBJECT_ATTRIBUTES obj;
	UNICODE_STRING ustrDevName;
	HANDLE hDevA;
	NTSTATUS status = STATUS_SUCCESS;
	IO_STATUS_BLOCK IoStatus;
	RtlInitUnicodeString(&ustrDevName, L"\\Device\\DevA"); // 获取DevA的设备名称
	InitializeObjectAttributes(&obj, &ustrDevName, OBJ_CASE_INSENSITIVE, NULL, NULL);
	status = ZwCreateFile(&hDevA, FILE_ALL_ACCESS | SYNCHRONIZE, &obj, &IoStatus, NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
	if (!NT_SUCCESS(status)) {
		KdPrint(("打开设备A失败\n"));
		return(status);
	}
	// 创建一个新的Read类型的IRP发送给底层驱动
	status = ZwReadFile(hDevA, NULL, NULL, NULL, &IoStatus, NULL, 0, NULL, 0);
	if (!NT_SUCCESS(status)) {
		KdPrint(("读取设备A失败\n"));
		return(status);
	}
	ZwClose(hDevA);
	// 应用层发来的IRP被完成
	KdPrint(("应用层发来的IRP: %08X\n"));
	pIrp->IoStatus.Status = STATUS_SUCCESS;
	pIrp->IoStatus.Information = 0;
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);

	KdPrint(("DriverB: 离开ReadRoutine\n"));

	return(status);
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, PUNICODE_STRING pRegistryPath) {
	KdPrint(("DriverB: 进入DriverEntry\n"));
	pDriverObject->DriverUnload = Unload;
	for (int i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; ++i)
		pDriverObject->MajorFunction[i] = DispatchRoutine;
	pDriverObject->MajorFunction[IRP_MJ_READ] = ReadRoutine;
	NTSTATUS status = CreateDevice(pDriverObject);
	if (!NT_SUCCESS(status))
		return(status);
	KdPrint(("DriverB: 离开DriverEntry\n"));

	return(STATUS_SUCCESS);
}

来看下应用层代码:

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

int main() {
	HANDLE hDevice = NULL;

	hDevice = CreateFile("\\\\.\\DevB", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (INVALID_HANDLE_VALUE == hDevice) {
		printf("打开设备失败! %d\n", GetLastError());
		return(-1);
	}
	DWORD dwRet; 
	ReadFile(hDevice, NULL, 0, &dwRet, NULL);
	CloseHandle(hDevice);

	return(0);
}

程序运行结果:

可以看得出来两个IRP是不一样的，因为中间驱动做的并不是直接转发IRP，而是完成应用层IRP后再重新创建一个新的IRP发送到底层设备

值得注意的是ZwCreateFile的参数:

ZwCreateFile(&hDevA, FILE_ALL_ACCESS | SYNCHRONIZE, &obj, &IoStatus, NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);

第二个参数要加上SYNCHRONIZE表示同步，倒数第三个参数必须指定为: FILE_SYNCHRONOUS_IO_NONALERT或者FILE_SYNCHRONOUS_IO_ALERT

2. 异步创建

第一种异步调用的方法是通过同步对象并设置APC例程成来达到的。来看一下具体的实现步骤

  1. 应用层发来Read类型的IRP请求到中间设备
  2. 中间设备通过ZwReadFile发送Read类型的异步IRP请求到底层设备，并对该新创建的IRP设置APC例程，并传入一个event同步对象
  3. 底层设备设置了等待3秒后开始的DPC例程，挂起IRP后返回STATUS_PENDING
  4. 中间设备收到了STATUS_PENDING后阻塞在KeWaitForSingleObject上
  5. 3秒后底层设备的DPC例程被触发，并在其中通过调用IoCompleteRoutine完成了中间设备传下来的IRP请求，中间设备的APC例程被触发
  6. 中间设备的APC例程中触发了同步事件对象后返回
  7. KeWaitForSingleObject的阻塞状态被解除并完成了应用层发来的IRP

其中最关键的因素在于底层设备ZwReadFile设置APC例程，APC例程触发同步事件。底层设备返回STATUS_PENDING并且DPC例程完成中间设备发来的IRP请求

由于底层设备和应用层的代码没有任何改变，这里仅仅给出中间设备代码修改过的代码，来看一下实现代码:

VOID ApcRoutine (
_In_ PVOID ApcContext,
_In_ PIO_STATUS_BLOCK IoStatusBlock,
_In_ ULONG Reserved
) {
	KdPrint(("DriverB: 进入了APC例程\n"));
	// 触发同步事件
	KeSetEvent((PKEVENT)ApcContext, IO_NO_INCREMENT, FALSE);

	KdPrint(("DriverB: 离开了APC例程\n"));
}

NTSTATUS ReadRoutine(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp) {
	KdPrint(("DriverB: 进入ReadRoutine\n"));
	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
	OBJECT_ATTRIBUTES obj;
	UNICODE_STRING ustrDevName;
	HANDLE hDevA;
	NTSTATUS status = STATUS_SUCCESS;
	IO_STATUS_BLOCK IoStatus;
	KEVENT event;
	RtlInitUnicodeString(&ustrDevName, L"\\Device\\DevA"); // 获取DevA的设备名称
	InitializeObjectAttributes(&obj, &ustrDevName, OBJ_CASE_INSENSITIVE, NULL, NULL);
	KeInitializeEvent(&event, NotificationEvent, FALSE); // 初始化事件
	// 没有FILE_SYNCHRONOUS_IO_NONALERT标志
	status = ZwCreateFile(&hDevA, FILE_ALL_ACCESS, &obj, &IoStatus, NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN_IF, 0, NULL, 0);
	if (!NT_SUCCESS(status)) {
		KdPrint(("打开设备A失败%08X\n", status));
		return(status);
	}
	LARGE_INTEGER li = RtlConvertLongToLargeInteger(0);
	// 创建一个新的Read类型的IRP发送给底层驱动, 同时设置APC例程
	status = ZwReadFile(hDevA, NULL, ApcRoutine, &event, &IoStatus, NULL, 0, &li, 0);
	if (!NT_SUCCESS(status)) {
		KdPrint(("读取设备A失败%08X\n", status));
		return(status);
	}
	if (status == STATUS_PENDING) {
		KdPrint(("底层IRP返回了STATUS_PENDING, 等待底层IRP被完成...\n"));
		KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
	}
	ZwClose(hDevA);
	// 应用层发来的IRP被完成
	KdPrint(("应用层发来的IRP: %08X\n"));
	pIrp->IoStatus.Status = STATUS_SUCCESS;
	pIrp->IoStatus.Information = 0;
	IoCompleteRequest(pIrp, IO_NO_INCREMENT);

	KdPrint(("DriverB: 离开ReadRoutine\n"));

	return(status);
}

来看一下结果:

我认为最值得注意的是两个函数, ZwCreateFile和ZwReadFile:

status = ZwCreateFile(&hDevA, FILE_ALL_ACCESS, &obj, &IoStatus, NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN_IF, 0, NULL, 0);
ZwReadFile(hDevA, NULL, ApcRoutine, &event, &IoStatus, NULL, 0, &li, 0);

与同步方式不同的是

  • ZwCreateFile不需要SYNCHRONIZE属性。代表异步。倒数第三个参数不需要FILE_SYNCHRONOUS_IO_NONALERT或FILE_SYNCHRONOUS_IO_ALERT
  • ZwReadFile必须要填入倒数第二个参数，否则会失败

(完)

Windows驱动开发WDM （7）- 异步IRP
zj510的专栏
11-26 4065
同步IRP是很简单的，比如caller调用DeviceIoControll，那么DeviceIoControll的IRP会发到相应的驱动，驱动把这个IRP完成，然后caller的DeviceIoControll才返回。同步的缺点很明显，比如驱动需要花10秒处理这个IRP，那么caller就得等待10秒钟，有时候这是个浪费。这是个很常见的问题，解决方案就是采用异步的方式。   异步IRP ca
IRP的同步完成与异步完成
ingor的专栏
07-10 2577
应用程序中对设备进行同步、异步操作，都必须得到驱动程序的支持。所有对设备的操作都会转化为IRP请求，并传递到相应的派遣函数中。可以有两种方式处理IRP请求，第一种是在派遣函数中直接结束IRP请求，即同步处理。另一种方法是在派遣函数中不结束IRP请求，而是让派遣函数直接返回。IRP在以后的某个时候再进行处理。
同步,异步IRP的处理
多媒体编程、网络编程、系统编程、网络安全编程、驱动编程
07-14 810
Before you examine the scenarios, you must understand the differences between a driver-created synchronous input/output request packet (IRP) and an asynchronous request. Collapse this tableExpand
IRP的异步完成
125096
08-04 580
EXE部分 #include #include #include #include "Ioctl.h" int main (void) { char linkname[]="\\\\.\\HelloDDK"; HANDLE hDevice = CreateFileA(linkname, GENERIC_READ | GENERIC_WRITE, 0, NULL,
自己发送IRP进行文件操作
weixin_34029949的博客
04-27 178
在驱动中我们可以自己发送IRP进行Create,Write,Read等操作. 作为初学者,这有点难度. 附件中对这些操作进行了详细的解答. 转载于:https://blog.51cto.com/laokaddk/73741...
[转]分层驱动模型中IRP的传递与完成
weixin_30522183的博客
06-26 141
在Windows分层驱动模型中，设备栈中的设备一般都是通过对上层传来的IRP做相应的处理来实现驱动的功能。这里对常用的几种IRP传递及完成的方式进行归纳和总结：1. 在本层驱动中完成1.1 在本层驱动中以同步方式完成在本层同步完成一般做完相应处理后，设置Irp->IoStatus.Status和Irp->IoStatus.Information，调用IoCompleteRequest完...
Windows设备驱动程序StartIO上机实践与IRP同步异步总结
#### 异步IRP处理 与同步处理不同，异步处理允许驱动程序在不占用CPU的情况下进行I/O操作。当驱动程序接收到IRP后，可以立即将其加入到I/O队列中，并通知上层请求者IRP已被接受，这样上层请求者就可以继续执行其他...
使用异步IRP优化WDM驱动性能示例
异步IRP是WDM驱动程序设计中的一项重要技术，它允许驱动程序在执行I/O请求时提供更高的灵活性和性能。对于希望设计高效、响应迅速的WDM驱动程序的开发者而言，理解和掌握异步IRP的处理机制是必不可少的技能。通过...
IRPMon内核驱动开发，调试监控IRP请求包发送接收工具
最新发布
03-14
IRPMon（即IRP Monitor）是一个针对Windows操作系统环境中的内核驱动工具，专为调试和监控IRP（I/O请求包）请求的发送和接收而设计。IRP是Windows内核中一种用于管理输入/输出请求的标准数据结构，它在设备驱动程序...
Windows驱动开发详解：IRP同步异步解析
IRP同步异步处理是理解驱动工作原理的关键。在描述中提到，IRP中的UserEvent会随着IRP向下传递。当在DeviceIOControl函数中设置一个等待事件时，驱动程序可以控制IRP的处理流程。一旦IOcompleteRequest被调用，IRP...
异步IRP例子
11-26
一个WDM驱动，使用异步IRP。caller通过异步方式打开驱动设备，然后使用WaitForSingleObject查看驱动是否已经完成请求。
windows驱动IRP详解
12-04
学习如何操作IRP及深入了解IRP内部结构 所有驱动开发人员都要知道的知识
IRP异步完成处理
weixin_42071117的博客
04-26 159
// driver.c #include <ntddk.h> LIST_ENTRY ListHeader; // 派遣函数-常规 NTSTATUS DispatchRoutine(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp); // 派遣函数-读操作 NTSTATUS DispatchRead(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp); // 派遣函数-清理 NTSTATUS Dispat
[Win32驱动13]IRP传递方式总结
輚至消亡
11-04 458
1. 直接转发IRP 2. 转发IRP后等待完成并重新获取IRP控制权 3. 不转发IRP 4. 暂时挂起当前IRP，设置完成例程以及StartIO例程
Windows设备驱动程序StartIO、IRP同步/异步上机小结
dijkstar的专栏
04-06 1785
StartIO非常好用，本质上，它把应用层传递进来的读请求、写请求、IOCTL请求放在一个队列里，由WDM内部串行调度，免去了自己去维护这样一个请求队列的复杂麻烦，下面是驱动层里StartIO的内容（特别处理IRP_MJ_READ请求）： #pragma LOCKEDCODE VOID HelloDDKStartIO(IN PDEVICE_OBJECT DeviceObject,IN PIR
驱动开发（13）IRP 的异步完成和 CancelRoutine
zuishikonghuan的博客
05-03 2940
本博文由CSDN博主zuishikonghuan所作，版权归zuishikonghuan所有，转载请注明出处：http://blog.csdn.net/zuishikonghuan/article/details/51301922在之前的博文中，我们对于IRP，都是同步完成的，但是 Windows 对异步操作很友好，我们来看看如何异步完成 IRP 。在应用程序中异步访问设备在开始之前，我认为有必要提
[Win32驱动11] 驱动中的IRP同步异步以及串行化处理方式(Part 1)
輚至消亡
11-02 515
1. 异步IO读写的处理方式 这段代码是驱动异步处理应用层发来的IRP的一种方式，其基本作用原理是这样的: 应用层进程以异步的方式多次发来Read IRP请求。由于设备一次性无法立即处理完所有IRP，所以设备在收到IRP后首先将其挂载到一个链表中并挂起该IRP，返回STATUS_PENDING。这些挂在链表上的IRP会在设备被关闭时被处理掉。即当CloseHandle被调用后，设备收到CLEANUP类型的IRP时处理。其处理方式也非常简单，这里仅仅是完成IRP的处理什么也不做。 接下去看一下代码:
分层驱动向下转发IRP
125096
08-08 572
EXE部分 #include #include #include #include "Ioctl.h" int main (void) { char linkname[]="\\\\.\\HelloDDKB"; HANDLE hDevice = CreateFileA(linkname, GENERIC_READ | GENERIC_WRITE, 0, NULL,
驱动中IRP_MJ_READ异步
125096
08-03 2723
EXE部分 #include #include #include #include "Ioctl.h" int main (void) { char linkname[]="\\\\.\\HelloDDK"; HANDLE hDevice = CreateFileA(linkname, GENERIC_READ | GENERIC_WRITE, 0, NULL,
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值