通过设备指针调用其他驱动程序(异步方式)

最新推荐文章于 2018-08-10 13:29:25 发布
最新推荐文章于 2018-08-10 13:29:25 发布
阅读量404 收藏
点赞数
分类专栏： 驱动编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq125096885/article/details/47339383
版权
本文探讨了驱动程序A和驱动程序B之间的交互过程，包括如何创建设备、卸载驱动、控制请求处理以及实现并发读取操作。通过实例代码展示了如何在驱动程序中响应不同类型的I/O请求，并在驱动程序间进行高效的数据交换。
摘要由CSDN通过智能技术生成

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;
	}
#if DBG
	_asm int 3
#endif
	KEVENT event;
	IO_STATUS_BLOCK status_block;
	LARGE_INTEGER offset;
	KeInitializeEvent(&event,NotificationEvent,FALSE);
	offset=RtlConvertLongToLargeInteger(0);

	//创建异步IRP
	PIRP pNewIrp=IoBuildAsynchronousFsdRequest(IRP_MJ_READ,DeviceObject,NULL,NULL,&offset,&status_block);
	
	//设置pNewIrp->UserEvent，这样在IRP完成后可以通知该事件
	pNewIrp->UserEvent=&event;

	PIO_STACK_LOCATION stack=IoGetNextIrpStackLocation(pNewIrp);
	stack->FileObject=FileObject;

	//调用DriverA,会一直调用DriverA的派遣函数
	status=IoCallDriver(DeviceObject,pNewIrp);

	if (status==STATUS_PENDING)
	{
		//如果DriverA的派遣函数没有完成IRP，则等待IRP完成
		status=KeWaitForSingleObject(&event,Executive,KernelMode,FALSE,NULL);
		status=status_block.Status;
	}

	//将引用计数器-1，如果此时计数器减为0，
	// 则将关闭设备，相当于调用ZwClose
	ObDereferenceObject(FileObject);

	//完成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
关注
专栏目录
使用设备对象指针来进行驱动调用驱动
weixin_42071117的博客
04-28 155
// dest #include <ntddk.h> // 卸载函数 VOID DriverUnload(IN PDRIVER_OBJECT pDriverObject) { KdPrint(("驱动卸载\n")); UNREFERENCED_PARAMETER(pDriverObject); UNICODE_STRING DevSymbolicLinkName = { 0 }; RtlInitUnicodeString(&DevSymbolicLinkName, L"\\?
深入Linux设备驱动程序内核机制.pdf
08-22
驱动程序与设备的交互通常通过中断处理、轮询或者异步通知等方式。在字符设备驱动中，通常通过设备的文件操作函数来实现与用户空间的交互，例如读写操作、控制命令等。 通过学习本文，读者不仅可以理解Linux设备...
通过设备指针调用其他驱动程序(同步方式)
125096
08-07 1029
EXE部分 #include #include #include #include "Ioctl.h" int main (void) { char linkname[]="\\\\.\\HelloDDKB"; HANDLE hDevice = CreateFileA(linkname, GENERIC_READ | GENERIC_WRITE, 0, NULL,
《Windows驱动开发技术详解》之驱动程序调用驱动程序——通过设备指针调用其他驱动程序...
weixin_30700099的博客
06-16 253
本节介绍“手动”构造各个IRP，然后将IRP传递到相应驱动程序的派遣函数里。 获得设备指针 每个内核中的句柄都会和一个内核对象的指针联系起来。ZwCreateFile内核函数可以通过设备名打开设备句柄，这个设备句柄和一个文件对象的指针关联。IoGetDeviceObjectPointer内核函数可以通过设备名获得文件对象指针，而不是获得设备句柄。当调用IoGetDeviceO...
如何通过设备名获取设备对象指针
多媒体编程、网络编程、系统编程、网络安全编程、驱动编程
05-04 1231
方法1： RtlInitUnicodeString ObReferenceObjectByName 方法2： NtCreateFile ObReferenceObjectByHandle 方法3： IoGetDeviceObjectPointer
实战DeviceIoControl 之一：通过API访问设备驱动程序
VHeroin的博客
06-17 915
实战DeviceIoControl 共7篇，这是我在两年前看到的文章，很不错，现在想把它转载过来。 原作者和其博客的地址是：http://blog.csdn.NET/bhw98 他博客里的这些序列文章的格式更好看，如果你觉得这些文章好，不妨去他的博客看，格式比我的随便粘贴好多了 ：）     Q 在NT/2000/XP中，我想用VC编写应用程序访问硬件设备，如获取磁盘参数、读写绝对扇区数
uClinux设备驱动程序的设计与编写
08-03
在嵌入式Linux系统中，设备驱动程序扮演着至关重要的角色，它是操作系统内核与硬件设备之间的桥梁，负责处理硬件操作并提供高层软件调用的接口。uClinux作为针对没有MMU（Memory Management Unit）的微控制器的Linux...
设备驱动程序的ioctl与同步异步I/O控制
"字符设备驱动程序的扩展操作主要涉及对硬件的控制，如ioctl方法的实现，以及同步和异步I/O的管理。ioctl系统调用是设备驱动程序执行特定命令的关键，允许应用程序访问和配置硬件功能。此外，驱动程序还需要处理数据...
论文研究-Linux中USB设备驱动程序研究.pdf
07-22
USB即通用串行总线（Universal Serial Bus），是一种广泛使用的串行通信...本论文研究的内容，通过具体的实现示例，不仅加深了对Linux USB驱动程序框架和数据结构的理解，也为其他开发者提供了实用的指南和经验分享。
分层驱动完成历程
125096
08-08 608
EXE部分 #include #include #include #include "Ioctl.h" int main (void) { char linkname[]="\\\\.\\HelloDDKB"; HANDLE hDevice = CreateFileA(linkname, GENERIC_READ | GENERIC_WRITE, 0, NULL,
用DeviceIoControl实现与驱动的交互(包含exe和sys两部分)
junning51的专栏
06-20 854
主要实现的功能是: 通过调用驱动，实现相应的功能,并把结果返回给调用者 (1)这里是通过应用程序出入两个参数a和b, (2)然后调用驱动,在驱动里面实现这里个数的相加 (3)驱动把相加的结果作为参数通过缓冲区返回给应用程序 1.缓冲区内存模式IOCTL /**********************************************************
驱动中以文件句柄形式调用其他驱动程序(异步调用二)
125096
08-07 575
EXE部分 #include #include #include #include "Ioctl.h" int main (void) { char linkname[]="\\\\.\\HelloDDKB"; HANDLE hDevice = CreateFileA(linkname, GENERIC_READ | GENERIC_WRITE, 0, NULL,
《重要》内核下各种同步处理方法（自旋锁、信号灯、互斥体…）
08-10 692
《重要》内核下各种同步处理方法（自旋锁、信号灯、互斥体…） AloneMonkey 2014年7月19日 0 1.在支持多线程的操作系统下，有些函数会出现不可重入的现象。所谓“可重入”是指函数的执行结果不和执行顺序有关。反之如果执行结果和执行顺序有关，则称这个函数是“不可重入”的。   2.Windows将中断的概念进行了扩展，提出一个中断请求级（IRQL）的概念。其中规定了32个中断请求...
一种Invalid Variant Operation错误的解决
热门推荐
禾苗雨的专栏
01-19 2万+
 如何设置DxDbgrid 列显示时间的格式(一种Invalid Variant Operation错误的解决)。Written by SkyJacker在数据库里的格式是2007-01-19 16:40:59可是在DxDBGRid中就显示了2007-1-19 下午16:40:59它取得是系统时间的格式。此时使用DxDBGRid的日期列排序，会提示“Invalid Variant Operat
设备驱动开发之缓冲区读写操作
iteye_8029的博客
05-01 257
在驱动程序创建设备对象时，就需要为设备指定何种读写方式。 设备对象共有三种读写方式，分别是缓冲区方式读写/直接方式读写/其他方式读写 其对应的Flags设置为：DO_BUFFERED_IO/DO_DIRECT_IO/0(零值)。 缓冲区读取代码示例： //创建设备 status = IoCreateDevice( pDriverObject, sizeof(DE...
MiniGui业务开发基础培训-htk
最新发布
11-11
MiniGui业务开发基础培训-htk
com.harmonyos.exception.DiskReadWriteException(解决方案).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
网络分析-Wireshark数据包筛选技巧详解及应用实例
11-11
内容概要：本文档详细介绍了Wireshark软件中各种数据包筛选规则，主要包括协议、IP地址、端口号、包长以及MAC地址等多个维度的具体筛选方法。同时提供了大量实用案例供读者学习，涵盖HTTP协议相关命令和逻辑条件的综合使用方式。 适合人群：对网络安全或数据分析有一定兴趣的研究者，熟悉基本网络概念和技术的专业人士。 使用场景及目标：适用于需要快速准确捕获特定类型网络流量的情况；如网络安全检测、性能优化分析、教学演示等多种实际应用场景。 阅读建议：本资料侧重于实操技能提升，在学习时最好配合实际操作练习效果更佳。注意掌握不同类型条件组合的高级用法，增强问题解决能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值