用IoAllocateIrp创建IRP

最新推荐文章于 2020-11-11 14:06:03 发布
最新推荐文章于 2020-11-11 14:06:03 发布
阅读量2k 收藏 3
点赞数
分类专栏： 驱动编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq125096885/article/details/47340291
版权

EXE部分

#include <stdio.h>
#include <Windows.h>
#include <WinIoCtl.h>
#include "Ioctl.h"



int main (void)
{
	char linkname[]="\\\\.\\HelloDDKB";
	HANDLE hDevice = CreateFileA(linkname,
		GENERIC_READ | GENERIC_WRITE,
		0,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL,
		NULL);
	if (hDevice == INVALID_HANDLE_VALUE)
	{
		printf("Win32 error code: %d\n",GetLastError());
		return 1;
	}
	
	DWORD dwRead;

	//如果读IRP没有被完成，ReadFile一直都不会退出
	ReadFile(hDevice,NULL,NULL,&dwRead,NULL);
	printf("Readfile返回%d\n",GetLastError());


	CloseHandle(hDevice);
	getchar();
	getchar();
	return 0;
}


 

 

 

SYS部分(驱动B调用驱动A)

驱动A部分代码

#pragma once
#include <ntddk.h>
#define CountArray(Array)  (	sizeof(Array)	/	sizeof(Array[0])	)

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;


#ifdef __cplusplus
extern "C" NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING  RegistryPath);
#endif

void HelloUnload(IN PDRIVER_OBJECT DriverObject);														//卸载函数
NTSTATUS CreateDevice(PDRIVER_OBJECT PDevObj);													//创建设备
NTSTATUS HelloDDKDispatchRoutine(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);	//派遣函数
NTSTATUS HelloDDKControl(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);					//IRP_MJ_DIRECTORY_CONTROL
NTSTATUS HelloDDKRead(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);
NTSTATUS HelloDDKCreate(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);
NTSTATUS HelloDDKClose(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);


 

#include "hello.h"
#include "Ioctl.h"



NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING  RegistryPath)
{
		DbgPrint("Hello from!\n");
		DriverObject->DriverUnload = HelloUnload;
		for (int i=0;i<IRP_MJ_MAXIMUM_FUNCTION;i++)
		{
			DriverObject->MajorFunction[i]=HelloDDKDispatchRoutine;
		}
		DriverObject->MajorFunction[IRP_MJ_READ]=HelloDDKRead;
		DriverObject->MajorFunction[IRP_MJ_CREATE]=HelloDDKCreate;
		DriverObject->MajorFunction[IRP_MJ_CLOSE]=HelloDDKClose;



#if DBG
		_asm int 3
#endif
		//创建设备
		CreateDevice(DriverObject);
		return STATUS_SUCCESS;
}

//卸载函数
void HelloUnload(IN PDRIVER_OBJECT DriverObject)
{
#if DBG
	_asm int 3
#endif
		DbgPrint("Goodbye from!\n");
		PDEVICE_OBJECT pNextObj=NULL;
		pNextObj=DriverObject->DeviceObject;

		while (pNextObj)
		{
			PDEVICE_EXTENSION pDevExt=(PDEVICE_EXTENSION)pNextObj->DeviceExtension;
			//删除符号连接
			IoDeleteSymbolicLink(&pDevExt->ustrSymLinkName);

			//删除设备
			IoDeleteDevice(pDevExt->pDevice);
			pNextObj=pNextObj->NextDevice;
		}
		KdPrint(("DriverA:Leave A DriverUnload\n"));
}

NTSTATUS HelloDDKControl(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp)
{
#if DBG
	_asm int 3
#endif

	NTSTATUS status=STATUS_SUCCESS;
	//获取当前堆栈
	PIO_STACK_LOCATION stack=IoGetCurrentIrpStackLocation(pIrp);
	//获取输入参数大小
	ULONG cbin=stack->Parameters.DeviceIoControl.InputBufferLength;
	//获取输出参数大小
	ULONG cbout=stack->Parameters.DeviceIoControl.OutputBufferLength;
	//得到IOCTL控制码
	ULONG code=stack->Parameters.DeviceIoControl.IoControlCode;
	//获取设备扩展
	PDEVICE_EXTENSION pDevExt=(PDEVICE_EXTENSION)pDevObj->DeviceExtension;

	//从用户模式传进来的微秒数
	ULONG ulMircoSeconds=*(PULONG)pIrp->AssociatedIrp.SystemBuffer;

	switch (code)
	{
	case IOCTL_WAIT_METHOD1:	
		{

		}
		break;
	default:
		status=STATUS_INVALID_VARIANT;
	}

	//设置IRP的完成状态
	pIrp->IoStatus.Status=status;
	pIrp->IoStatus.Information=0;
	IoCompleteRequest(pIrp,IO_NO_INCREMENT);
	return status;
}

VOID OnTimerDpc(IN PKDPC pDpc,IN PVOID pContext,IN PVOID SysArg1,IN PVOID SysArg2)
{
#if DBG
	_asm int 3
#endif

	PDEVICE_OBJECT pDevObj=(PDEVICE_OBJECT)pContext;
	PDEVICE_EXTENSION pdx=(PDEVICE_EXTENSION)pDevObj->DeviceExtension;

	PIRP currentPendingIRP=pdx->currentPendingIRP;
	DbgPrint("DriverA:complete the Driver A IRP_MJ_READ irp\n");

	//设置完成状态为STATUS_SUCCESS
	currentPendingIRP->IoStatus.Status=STATUS_SUCCESS;		//完成
	currentPendingIRP->IoStatus.Information=0;
	IoCompleteRequest(currentPendingIRP,IO_NO_INCREMENT);
	return;
}


NTSTATUS HelloDDKRead(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp)
{
#if DBG
	_asm int 3
#endif

	PDEVICE_EXTENSION pDevExt=(PDEVICE_EXTENSION)pDevObj->DeviceExtension;

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

	//将挂起的IRP记录下来
	pDevExt->currentPendingIRP=pIrp;

	//定义5秒的超时
	ULONG ulMicroSecond=5000000;

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

	KeSetTimer(&pDevExt->pollingTimer,timeout,&pDevExt->pollingDPC);

	DbgPrint("DriverA:Leave A HelloDDKRead\n");

	return STATUS_PENDING;	//挂起
}

NTSTATUS HelloDDKCreate(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp)
{
#if DBG
	_asm int 3
#endif

	DbgPrint("DriverA:Enter A HelloDDKCreate\n");

	//完成IRP
	pIrp->IoStatus.Status=STATUS_SUCCESS;
	pIrp->IoStatus.Information=0;
	IoCompleteRequest(pIrp,IO_NO_INCREMENT);
	return STATUS_SUCCESS;
}

NTSTATUS HelloDDKClose(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp)
{
#if DBG
	_asm int 3
#endif

	DbgPrint("DriverA:Enter A HelloDDKClose\n");

	//完成IRP
	pIrp->IoStatus.Status=STATUS_SUCCESS;
	pIrp->IoStatus.Information=0;
	IoCompleteRequest(pIrp,IO_NO_INCREMENT);
	return STATUS_SUCCESS;
}


//创建设备
NTSTATUS CreateDevice(PDRIVER_OBJECT pDriver_Object)
{

	//定义变量
	NTSTATUS status=STATUS_SUCCESS;
	PDEVICE_OBJECT pDevObj=NULL;
	PDEVICE_EXTENSION pDevExt=NULL;

	//初始化字符串
	UNICODE_STRING devname;
	UNICODE_STRING symLinkName;
	RtlInitUnicodeString(&devname,L"\\device\\MyDDKDeviceA");
	RtlInitUnicodeString(&symLinkName,L"\\??\\HelloDDKA");

	//创建设备
	status =IoCreateDevice(pDriver_Object,sizeof(DEVICE_EXTENSION),&devname,FILE_DEVICE_UNKNOWN,NULL,TRUE,&pDevObj);

	if (!NT_SUCCESS(status))
	{
		DbgPrint("创建设备失败\n");
		return status;
	}

	pDevObj->Flags |= DO_BUFFERED_IO;;
	pDevExt=(PDEVICE_EXTENSION)pDevObj->DeviceExtension;
	pDevExt->pDevice=pDevObj;
	pDevExt->ustrDeviceName=devname;
	pDevExt->ustrSymLinkName=symLinkName;

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

	//创建符号连接
	status =IoCreateSymbolicLink(&symLinkName,&devname) ;

	if (!NT_SUCCESS(status)) 
	{
		DbgPrint("创建符号连接失败\n");
		IoDeleteDevice(pDevObj);
		return status;
	}

	return STATUS_SUCCESS;
	
}

//派遣函数
NTSTATUS HelloDDKDispatchRoutine(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrP)
{
//#if DBG
//	_asm int 3
//#endif

	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 >= CountArray(irpname))
		KdPrint(("无效的IRP类型 %X\n", type));
	else
		KdPrint(("%s\n", irpname[type]));




	pIrP->IoStatus.Status=STATUS_SUCCESS;					//设置完成状态
	pIrP->IoStatus.Information=0;										//设置操作字节为0
	IoCompleteRequest(pIrP,IO_NO_INCREMENT);			//结束IRP派遣函数，第二个参数表示不增加优先级
	return STATUS_SUCCESS;
}


 

驱动B部分代码

#pragma once
#include <ntddk.h>
#define CountArray(Array)  (	sizeof(Array)	/	sizeof(Array[0])	)

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


#ifdef __cplusplus
extern "C" NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING  RegistryPath);
#endif

void HelloUnload(IN PDRIVER_OBJECT DriverObject);														//卸载函数
NTSTATUS CreateDevice(PDRIVER_OBJECT PDevObj);													//创建设备
NTSTATUS HelloDDKDispatchRoutine(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);	//派遣函数
NTSTATUS HelloDDKControl(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);					//IRP_MJ_DIRECTORY_CONTROL
NTSTATUS HelloDDKRead(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);
NTSTATUS HelloDDKCreate(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);
NTSTATUS HelloDDKClose(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);


 

#include "hello.h"
#include "Ioctl.h"


NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING  RegistryPath)
{
		DbgPrint("Hello from!\n");
		DriverObject->DriverUnload = HelloUnload;
		for (int i=0;i<IRP_MJ_MAXIMUM_FUNCTION;i++)
		{
			DriverObject->MajorFunction[i]=HelloDDKDispatchRoutine;
		}
		DriverObject->MajorFunction[IRP_MJ_READ]=HelloDDKRead;
		DriverObject->MajorFunction[IRP_MJ_CREATE]=HelloDDKCreate;
		DriverObject->MajorFunction[IRP_MJ_CLOSE]=HelloDDKClose;

#if DBG
		_asm int 3
#endif
		//创建设备
		CreateDevice(DriverObject);
		return STATUS_SUCCESS;
}

//卸载函数
void HelloUnload(IN PDRIVER_OBJECT DriverObject)
{
#if DBG
	_asm int 3
#endif
		DbgPrint("Goodbye from!\n");
		PDEVICE_OBJECT pNextObj=NULL;
		pNextObj=DriverObject->DeviceObject;

		while (pNextObj)
		{
			PDEVICE_EXTENSION pDevExt=(PDEVICE_EXTENSION)pNextObj->DeviceExtension;
			//删除符号连接
			IoDeleteSymbolicLink(&pDevExt->ustrSymLinkName);

			//删除设备
			IoDeleteDevice(pDevExt->pDevice);
			pNextObj=pNextObj->NextDevice;
		}
		KdPrint(("DriverB:Leave B DriverUnload\n"));
}

NTSTATUS HelloDDKControl(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp)
{
#if DBG
	_asm int 3
#endif

	NTSTATUS status=STATUS_SUCCESS;
	//获取当前堆栈
	PIO_STACK_LOCATION stack=IoGetCurrentIrpStackLocation(pIrp);
	//获取输入参数大小
	ULONG cbin=stack->Parameters.DeviceIoControl.InputBufferLength;
	//获取输出参数大小
	ULONG cbout=stack->Parameters.DeviceIoControl.OutputBufferLength;
	//得到IOCTL控制码
	ULONG code=stack->Parameters.DeviceIoControl.IoControlCode;
	//获取设备扩展
	PDEVICE_EXTENSION pDevExt=(PDEVICE_EXTENSION)pDevObj->DeviceExtension;

	//从用户模式传进来的微秒数
	ULONG ulMircoSeconds=*(PULONG)pIrp->AssociatedIrp.SystemBuffer;

	switch (code)
	{
	case IOCTL_WAIT_METHOD1:	
		{

		}
		break;
	default:
		status=STATUS_INVALID_VARIANT;
	}

	//设置IRP的完成状态
	pIrp->IoStatus.Status=status;
	pIrp->IoStatus.Information=0;
	IoCompleteRequest(pIrp,IO_NO_INCREMENT);
	return status;
}

NTSTATUS HelloDDKRead(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp)
{
#if DBG
	_asm int 3
#endif
	DbgPrint("DriverB:Enter B HelloDDKRead\n");

	NTSTATUS status=STATUS_SUCCESS;
	UNICODE_STRING DeviceName;
	RtlInitUnicodeString(&DeviceName,L"\\Device\\MyDDKDeviceA");

	//得到设备对象句柄，计数器+1
	//如果是第一次调用，会打开设备，相当于zWCreateFile
	PDEVICE_OBJECT DeviceObject=NULL;
	PFILE_OBJECT       FileObject=NULL;
	status=IoGetDeviceObjectPointer(&DeviceName,FILE_ALL_ACCESS,&FileObject,&DeviceObject);
#if DBG
	_asm int 3
#endif

	//如果获取失败，完成IRP
	if (!NT_SUCCESS(status))
	{
		DbgPrint("%x\n",status);
		pIrp->IoStatus.Status=STATUS_UNSUCCESSFUL;
		pIrp->IoStatus.Information=0;
		IoCompleteRequest(pIrp,IO_NO_INCREMENT);
		return STATUS_UNSUCCESSFUL;
	}

	KEVENT event;
	IO_STATUS_BLOCK status_block;
	KeInitializeEvent(&event,NotificationEvent,FALSE);
	
	PIRP pNewIrp=IoAllocateIrp(DeviceObject->StackSize,FALSE);
	pNewIrp->UserEvent=&event;
	pNewIrp->UserIosb=&status_block;
	pNewIrp->Tail.Overlay.Thread=PsGetCurrentThread();

	//因为DriverA是BUFFER_IO设备
	pNewIrp->AssociatedIrp.SystemBuffer=NULL;
	PIO_STACK_LOCATION stack=IoGetNextIrpStackLocation(pNewIrp);
	stack->MajorFunction=IRP_MJ_READ;
	stack->MinorFunction=IRP_MN_NORMAL;
	stack->FileObject=FileObject;

	//调用DriverA驱动
	status=IoCallDriver(DeviceObject,pNewIrp);
#if DBG
	_asm int 3
#endif
	if (status==STATUS_PENDING)
	{
		//如果DriverA的派遣函数没有完成IRP，则等待IRP完成
		status=KeWaitForSingleObject(&event,Executive,KernelMode,FALSE,NULL);
		status=status_block.Status;
	}
#if DBG
	_asm int 3
#endif
	//将引用计数器-1，如果此时计数器减为0，
	// 则将关闭设备，相当于调用ZwClose
	ObDereferenceObject(FileObject);
#if DBG
	_asm int 3
#endif
	//IoFreeIrp(pNewIrp);

#if DBG
	_asm int 3
#endif
	//完成IRP
	pIrp->IoStatus.Status=STATUS_SUCCESS;
	pIrp->IoStatus.Information=0;
	IoCompleteRequest(pIrp,IO_NO_INCREMENT);
	return STATUS_SUCCESS;	

}

NTSTATUS HelloDDKCreate(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp)
{
#if DBG
	_asm int 3
#endif
	DbgPrint("DriverB:Enter B HelloDDKCreate\n");

	//完成IRP
	pIrp->IoStatus.Status=STATUS_SUCCESS;
	pIrp->IoStatus.Information=0;
	IoCompleteRequest(pIrp,IO_NO_INCREMENT);
	return STATUS_SUCCESS;
}

NTSTATUS HelloDDKClose(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp)
{
#if DBG
	_asm int 3
#endif
	DbgPrint("DriverB:Enter B HelloDDKClose\n");

	//完成IRP
	pIrp->IoStatus.Status=STATUS_SUCCESS;
	pIrp->IoStatus.Information=0;
	IoCompleteRequest(pIrp,IO_NO_INCREMENT);
	return STATUS_SUCCESS;
}


//创建设备
NTSTATUS CreateDevice(PDRIVER_OBJECT pDriver_Object)
{

	//定义变量
	NTSTATUS status=STATUS_SUCCESS;
	PDEVICE_OBJECT pDevObj=NULL;
	PDEVICE_EXTENSION pDevExt=NULL;

	//初始化字符串
	UNICODE_STRING devname;
	UNICODE_STRING symLinkName;
	RtlInitUnicodeString(&devname,L"\\device\\MyDDKDeviceB");
	RtlInitUnicodeString(&symLinkName,L"\\??\\HelloDDKB");

	//创建设备
	status =IoCreateDevice(pDriver_Object,sizeof(DEVICE_EXTENSION),&devname,FILE_DEVICE_UNKNOWN,NULL,TRUE,&pDevObj);

	if (!NT_SUCCESS(status))
	{
		DbgPrint("创建设备失败\n");
		return status;
	}

	pDevObj->Flags |= DO_BUFFERED_IO;;
	pDevExt=(PDEVICE_EXTENSION)pDevObj->DeviceExtension;
	pDevExt->pDevice=pDevObj;
	pDevExt->ustrDeviceName=devname;
	pDevExt->ustrSymLinkName=symLinkName;

	//创建符号连接
	status =IoCreateSymbolicLink(&symLinkName,&devname) ;

	if (!NT_SUCCESS(status)) 
	{
		DbgPrint("创建符号连接失败\n");
		IoDeleteDevice(pDevObj);
		return status;
	}

	return STATUS_SUCCESS;
	
}

//派遣函数
NTSTATUS HelloDDKDispatchRoutine(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrP)
{
//#if DBG
//	_asm int 3
//#endif

	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 >= CountArray(irpname))
		KdPrint(("无效的IRP类型 %X\n", type));
	else
		KdPrint(("%s\n", irpname[type]));




	pIrP->IoStatus.Status=STATUS_SUCCESS;					//设置完成状态
	pIrP->IoStatus.Information=0;										//设置操作字节为0
	IoCompleteRequest(pIrP,IO_NO_INCREMENT);			//结束IRP派遣函数，第二个参数表示不增加优先级
	return STATUS_SUCCESS;
}


 

125096
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Windows驱动开发系列之一：小白入门经典
09-05
Windows驱动程序开发比较复杂，我将带领大家一起领略内核模式下编程的奥妙。您将真正掌握内核编程的原理与技术，将技术水平提升一个档次，学会核心技术。您将掌握Windows驱动开发的基本技术；灵活应用IRP、IO堆栈、设备栈、派遣函数等；您将掌握Windows驱动的分层技术，了解WDM驱动的基本原理您将掌握Windows驱动开发中的各种回调例程：完成例程、取消例程、DPC例程、APC例程、等等。具体内容包括但不限于：Windows驱动开发小白入门，Windows内核架构与驱动开发的基本概念，VS2015+VMware(win10x64)双机调试驱动，Win10x64中安装WDM驱动，驱动程序的基本结构（NT,WDM)，Windows内存管理，Windows内核函数，驱动程序的派遣函数，驱动程序的同步处理，IRP的同步，定时器，驱动程序调用驱动程序，分层驱动程序
IoAllocateIrp用于驱动调用驱动
最新发布
weixin_42071117的博客
04-28 311
// driver.c #include <ntddk.h> // 卸载函数 VOID DriverUnload(IN PDRIVER_OBJECT pDriverObject) { KdPrint(("驱动卸载\n")); UNREFERENCED_PARAMETER(pDriverObject); } // 测试函数 VOID CallDriverTest() { NTSTATUS status = STATUS_SUCCESS; PFILE_OBJECT pFileObj =
[Win32驱动14]通过4种方式手动创建IRP
輚至消亡
11-11 485
1. IoBuildSynchronousFsdRequest __drv_aliasesMem PIRP IoBuildSynchronousFsdRequest( ULONG MajorFunction, PDEVICE_OBJECT DeviceObject, PVOID Buffer, ULONG Length, PLARGE_INTEGER StartingOffset, PKEVENT
Irp的传递与完成
02-23 650
1.在本层驱动中完成1.1在本层驱动中以同步方式完成在本层同步完成一般做完相应处理后，设置Irp->IoStatus.Status和Irp->IoStatus.Information，调用IoCompleteRequest完成该IRP，returnIRP的完成状态即可。 1.2在本层驱动中以异步方式完成在本层异步完成一般是得到IRP后将其入队/起线程另行处理，同时调用IoMarkIrpPending
IRP_完成例程（一）-返回status_success
World-wang
06-27 3444
事例使用IRP_MJ_READ派遣函数演示完成例程
windows驱动开发技术详解-part2
07-06
　4.3.5 对IRP_MN_REMOVE_DEVICE IRP的处理 　4.3.6 用Device Tree查看WDM设备对象栈 　4.4 设备的层次结构 　4.4.1 驱动程序的垂直层次结构 　4.4.2 驱动程序的水平层次结构 　4.4.3 驱动程序的复杂层次结构 ...
Windows驱动开发技术详解的光盘-part1
07-06
　从Windows最基本的两类驱动程序的编译、安装、调试入手讲解，非常容易上手，用实例详细讲解PCI、USB、虚拟串口、虚拟摄像头、SDIO等驱动程序的开发，归纳了多种调试驱动程序的高级技巧，如用WinDBG和VMWARE软件对...
内核层和用户层通讯的三种方式
weixin_30954607的博客
08-30 446
内核层#include <ntddk.h>​#define CTRL_CODE1 CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_IN_DIRECT, FILE_ANY_ACCESS)#define CTRL_CODE2 CTL_CODE(FILE_DEVICE_UNKNOWN, 0x802, METHOD_BUFFERED, FILE...
IRP 同步IO、异步IO及延迟IO完成
求索
03-17 969
同步与异步 kernel32.dll CreateFileW   /* translate the flags that need no validation */   if (!(dwFlagsAndAttributes & FILE_FLAG_OVERLAPPED))  {    /* yes, nonalert is correct! apc's are not delivere
IoBuildSynchronousFsdRequest创建IRP数据包_同步
07-06 893
#include <windows.h> #include <stdio.h> int main() { HANDLE hDevice = CreateFile(L"\\\\.\\HelloDDKB", GENERIC_READ | GENERIC_WRITE, 0, // share mode none NULL, // no...
【转帖】驱动编程学习笔记之IO处理
floweronwarmbed的专栏
11-03 1770
 典型的i/o处理过程=================操作系统将所有的i/o请求都抽象成针对一个虚拟文件的操作，从而掩盖了“一个i/o操作的目标可能不是一个文件结构的设备“这样的事实。这一抽象也使得应用程序对待设备的接口变得泛化。用户模式api   |i/o系统服务api(Ntxxx)   |i/o管理器(Ioxxx)   |内核模式设备驱动程序------驱动程序支持例程(Io,
创建IRP的相关内容
爱她就要努力
06-13 607
篇一： 在驱动程序中，经常会调用其他的驱动程序；其中，手动构造IRP，然后将IRP传递到相应驱动程序的派遣函数中是一种比较简单的方法，下面就来介绍下手动创建IRP的几种不同的方法及其特点。          创建IRP总共有4种方法。分别通过调用：IoBuildSynchronousFsdRequest、IoBuildAsynchronousFsdRequest、IoBuildDevice
I/O Request Packet
zhuo_zhibin的专栏
09-14 5840
第5章 I/O Request Packet 5.1 数据结构 在处理 I/O 请求上，有两个重要的数据结构：IRP（I/O request packet）和 IO_STACK_LOCATION 5.1.1 IRP 的结构 下面是在 windbg 里得到的 IRP 结构： nt!_IRP +0x000 Type : Int2B +0x002 Size
创建IRP实现驱动之间通讯
World-wang
06-25 1414
被调用源码不变，windows驱动之间同步调用实例
IRP(I/O Request Package)详解
极客神殿
09-04 7032
篇一： 简介： IRP(I/O Request Package)在windows内核中，有一种系统组件——IRP，即输入输出请求包。 当上层应用程序需要访问底层输入输出设备时，发出I/O请求，系统会把这些请求转化为IRP数 据，不同的IRP会启动I/O设备驱动中对应的派遣函数。 IRP类型 由于IRP是响应上层应用程序的。可想而知，IRP类型是与上层对底层设备的访问类型相对应。 文件...
自己构造 Create IRP
03-08 1207
NTSTATUS IrpCreate(IN PUNICODE_STRING Name,IN ACCESS_MASK DesiredAccess,IN ULONG FileAttributes,IN ULONG ShareAccess,IN ULONG CreateDisposition,IN ULONG CreateOptions,IN PDEVICE_OBJECT DeviceObject,IN
搞明白IRP这个东东了
求索
05-18 4292
按照ms的步骤走了一遍，搞明白了，整点笔记记录一下，别忘了。 IRP的结构： [cpp] view plain copy print? typedef struct DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) _IRP {      CSHORT Type;      USHORT Size;        //  
使用IRP进行文件操作
03-26 2664
一定要先感谢为技术的进步而付出辛勤汗水的人,感谢他们对技术的共享.一个通用IRP访问文件的十六进制编辑器(开源代码)     --   被诅咒的神(邪恶八进制信息安全团队)Windows平台内核级文件访问                               --   baiyuanfan ([email protected])特别感谢被诅咒的神,他写的里面包含了非常多
3.4 IRP处理
it技术学习
08-01 1045
简要介绍IRP的生成、创建、发送等，然后介绍多种IRP处理示例。 3.4.1 简单的IRP流动图 应用程序打开磁盘上一个数据文件的基本流程： 1. Windows子系统使用系统服务函数NtCreateFile打开目标文件 2. I/O管理器调用对象管理器解析命名的文件，然后调用安全引用监视器检查子系统是否拥有对目标文件对象的访问权限 3. 如果目标文件所在的卷还没有被加载，I/O

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值