驱动程序编写入门以及驱动程序加载

最新推荐文章于 2024-07-31 22:02:07 发布

轩动day

最新推荐文章于 2024-07-31 22:02:07 发布

阅读量1.8k

点赞数

分类专栏：驱动开发内核文章标签：操作系统内核驱动

本文链接：https://blog.csdn.net/dayenglish/article/details/20868945

版权

驱动开发内核专栏收录该内容

23 篇文章 3 订阅

订阅专栏

#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")

上面定义了六个宏，主要是定义驱动的内存属性。总共两种一种是INIT，当内存在初始化结束之后就会将标注为INIT属性的数据和代码移出内存当中，而属性为PAGE则表明数据和代码是换页的，也就是说数据在不需要的时候可以由系统转移到缓存里面去。注意在系统级别有些是必须要放到不可换页的内存当中，不然可能引起系统蓝屏——因为windows在内核层面是不能调度的，但是不调度的话又不能将指令转移到内存管理部分进行处理，所以系统只好蓝屏。

#define arraysize(p) (sizeof(p)/sizeof((p)[0]))

typedef struct _DEVICE_EXTENSION {
	PDEVICE_OBJECT pDevice;
	UNICODE_STRING ustrDeviceName;
	UNICODE_STRING ustrSymLinkName;
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;

在编写驱动时可以利用DEVICE_OBJECT进行扩充，其中DEVICE_OBJECT是系统定义的设备对象。之所以能扩充是因为系统设备对象可能各不相同，而系统需要一个统一个管理方式。所以第一个成员变量POBJECT_OBJECT用于系统管理设备，而后面扩充的可以根据设备不同而添加，这里添加两个域。一个是设备名称，另一个是设备的符号链接名称（类似于快捷方式）。

#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] = HelloDDKDispatchRoutine;
	pDriverObject->MajorFunction[IRP_MJ_CLOSE] = HelloDDKDispatchRoutine;
	pDriverObject->MajorFunction[IRP_MJ_WRITE] = HelloDDKDispatchRoutine;
	pDriverObject->MajorFunction[IRP_MJ_READ] = HelloDDKDispatchRoutine;

	status = CreateDevice(pDriverObject);
	KdPrint(("Leave DriverEntry\n"));
	return STATUS_SUCCESS;
}

这个函数是驱动程序的入口函数，在这里驱动对象提被设置，并且要创建设备对象体，注意这个函数在调用之后就可以调出内存而不再需要了。

#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;
	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;
}

CreateDevice函数创建一个设备对象，并且对其进行一些初始化。RtlInitUnicodeString函数用于初始化一个字符串将其放到UNICODE_STRING结构所在的指针当中，也就是说这里不需要我们管字符串的内存分配以及常规的管理——微软比较相信自己的代码，而字符串常被用作溢出攻击。接下来是IOCreateDevice函数的分析，第一个参数是DRIVER_OBJECT的指针，为什么需要这个指针？因为需要将其设置到DEVICE_OBJECT当中去。上面的回答等于没说，但是这的确是一个原因；因为在操作系统当中可以实现多个设备共享一个驱动程序，所以在DEVICE_OBJET当中有一个指针指向DRIVER_OBJECT就可以实现。另一个原因是，所有的文件操作都可以类似于CreateFile的形式进行生成，而在操作系统当中设备也被当做文件看待，所以当你得到一个文件的句柄HANDLE的时候也就可以得到这个文件的驱动程序，当然前提是这个文件HANDLE时一个设备句柄。由第二个参数和最后一个参数我们可以猜测，在内核层，所有的内存分配都是交给微软自己做的。第二个传入一个DEVICE_EXTENSION结构体的大小，很明显是为了让系统分配内存。从这里也可以看出来。DEVICE_OBJECT和DEVICE_EXTENSION在内存当中是紧邻在一起的。这里也可以解释为什么DriverEntry函数当中传入的都是指针——同样也是因为所有的内存操作都是由微软处理的。当然创建DEVICE_OBJECT的过程当中也会对DEVICE_OBJECT进行一些设置。接下来创建一个符号链接，好比一个桌面上的快捷方式。

#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 );
	}
	KdPrint(("Leave DriverUnload\n"));
}

上面函数是驱动程序的卸载历程，主要是循坏卸载驱动的各个级别的设备，因为设备是分层次的，所以需要循环删除。

#pragma PAGEDCODE
NTSTATUS HelloDDKDispatchRoutine(IN PDEVICE_OBJECT pDevObj,
								 IN PIRP pIrp) 
{
	KdPrint(("Enter HelloDDKDispatchRoutine\n"));
	NTSTATUS status = STATUS_SUCCESS;
	pIrp->IoStatus.Status = status;
	pIrp->IoStatus.Information = 0;	
	IoCompleteRequest( pIrp, IO_NO_INCREMENT );
	KdPrint(("Leave HelloDDKDispatchRoutine\n"));
	return status;
}

由于只是一个示例程序，所以程序的转发函数只是简单地进行IoCompleteRequest函数调用，表明调用被处理。

下面是一个驱动加载程序的处理过程。

#include <windows.h>  
#include <winsvc.h>  
#include <conio.h>  
#include <stdio.h>
#define DRIVER_NAME "HelloDDK"
#define DRIVER_PATH "HelloDDK.sys"
首先定义两个变量，第一个是驱动在系统内部的名称，第二个是驱动在硬盘上的路径。从上面可以看出来。驱动程序和应用程序在一个文件夹里面。
BOOL LoadNTDriver(char* lpszDriverName,char* lpszDriverPath)
{
	char szDriverImagePath[256];
	//得到完整的驱动路径
	GetFullPathName(lpszDriverPath, 256, szDriverImagePath, NULL);

	BOOL bRet = FALSE;

	SC_HANDLE hServiceMgr=NULL;//SCM管理器的句柄
	SC_HANDLE hServiceDDK=NULL;//NT驱动程序的服务句柄

	//打开服务控制管理器
	hServiceMgr = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );

	if( hServiceMgr == NULL )  
	{
		//OpenSCManager失败
		printf( "OpenSCManager() Faild %d ! \n", GetLastError() );
		bRet = FALSE;
		goto BeforeLeave;
	}
	else
	{
		printf( "OpenSCManager() ok ! \n" );  
	}

	hServiceDDK = CreateService( hServiceMgr,
		lpszDriverName, //驱动程序的在注册表中的名字  
		lpszDriverName, // 注册表驱动程序的 DisplayName 值  
		SERVICE_ALL_ACCESS, // 加载驱动程序的访问权限  
		SERVICE_KERNEL_DRIVER,// 表示加载的服务是驱动程序  
		SERVICE_DEMAND_START, // 注册表驱动程序的 Start 值  
		SERVICE_ERROR_IGNORE, // 注册表驱动程序的 ErrorControl 值  
		szDriverImagePath, // 注册表驱动程序的 ImagePath 值  
		NULL,  
		NULL,  
		NULL,  
		NULL,  
		NULL);  

	DWORD dwRtn;
	//判断服务是否失败
	if( hServiceDDK == NULL )  
	{  
		dwRtn = GetLastError();
		if( dwRtn != ERROR_IO_PENDING && dwRtn != ERROR_SERVICE_EXISTS )  
		{  
			//由于其他原因创建服务失败
			printf( "CrateService() Faild %d ! \n", dwRtn );  
			bRet = FALSE;
			goto BeforeLeave;
		}  
		else  
		{
			//服务创建失败，是由于服务已经创立过
			printf( "CrateService() Faild Service is ERROR_IO_PENDING or ERROR_SERVICE_EXISTS! \n" );  
		}
		// 驱动程序已经加载，只需要打开  
		hServiceDDK = OpenService( hServiceMgr, lpszDriverName, SERVICE_ALL_ACCESS );  
		if( hServiceDDK == NULL )  
		{
			//如果打开服务也失败，则意味错误
			dwRtn = GetLastError();  
			printf( "OpenService() Faild %d ! \n", dwRtn );  
			bRet = FALSE;
			goto BeforeLeave;
		}  
		else 
		{
			printf( "OpenService() ok ! \n" );
		}
	}  
	else  
	{
		printf( "CrateService() ok ! \n" );
	}
	//开启此项服务
	bRet= StartService( hServiceDDK, NULL, NULL );  
	if( !bRet )  
	{  
		DWORD dwRtn = GetLastError();  
		if( dwRtn != ERROR_IO_PENDING && dwRtn != ERROR_SERVICE_ALREADY_RUNNING )  
		{  
			printf( "StartService() Faild %d ! \n", dwRtn );  
			bRet = FALSE;
			goto BeforeLeave;
		}  
		else  
		{  
			if( dwRtn == ERROR_IO_PENDING )  
			{  
				//设备被挂住
				printf( "StartService() Faild ERROR_IO_PENDING ! \n");
				bRet = FALSE;
				goto BeforeLeave;
			}  
			else  
			{  
				//服务已经开启
				printf( "StartService() Faild ERROR_SERVICE_ALREADY_RUNNING ! \n");
				bRet = TRUE;
				goto BeforeLeave;
			}  
		}  
	}
	bRet = TRUE;
//离开前关闭句柄
BeforeLeave:
	if(hServiceDDK)
	{
		CloseServiceHandle(hServiceDDK);
	}
	if(hServiceMgr)
	{
		CloseServiceHandle(hServiceMgr);
	}
	return bRet;
}

LoadNTDriver分成四个部分。第一部分打开SCM服务管理器。第二部分，创建服务项。因为服务项是添加到注册表当中且不会自动删除，所以当创建失败的时候不一定是函数调用出错。另外第二个参数和第三个参数并不一定要一样，前者是驱动程序在注册表当中表项的名称，而后者是注册表当中一个DisplayName注册表键值的名字。另外一个参数szDriverImagePath保存的是驱动程序在硬盘上的位置，这里需要注意的是由于当注册表键值存在的条件下，系统不会将原有的注册表删除重新创建，或者进行覆盖处理，所以在驱动程序文件的路径改变的情况下，很容易出现找不到文件的错误。接下来利用OpenService函数打开服务。最后调用StartService开始服务，到此基本完成驱动的加载。

//卸载驱动程序  
BOOL UnloadNTDriver( char * szSvrName )  
{
	BOOL bRet = FALSE;
	SC_HANDLE hServiceMgr=NULL;//SCM管理器的句柄
	SC_HANDLE hServiceDDK=NULL;//NT驱动程序的服务句柄
	SERVICE_STATUS SvrSta;
	//打开SCM管理器
	hServiceMgr = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );  
	if( hServiceMgr == NULL )  
	{
		//带开SCM管理器失败
		printf( "OpenSCManager() Faild %d ! \n", GetLastError() );  
		bRet = FALSE;
		goto BeforeLeave;
	}  
	else  
	{
		//带开SCM管理器失败成功
		printf( "OpenSCManager() ok ! \n" );  
	}
	//打开驱动所对应的服务
	hServiceDDK = OpenService( hServiceMgr, szSvrName, SERVICE_ALL_ACCESS );  

	if( hServiceDDK == NULL )  
	{
		//打开驱动所对应的服务失败
		printf( "OpenService() Faild %d ! \n", GetLastError() );  
		bRet = FALSE;
		goto BeforeLeave;
	}  
	else  
	{  
		printf( "OpenService() ok ! \n" );  
	}  
	//停止驱动程序，如果停止失败，只有重新启动才能，再动态加载。  
	if( !ControlService( hServiceDDK, SERVICE_CONTROL_STOP , &SvrSta ) )  
	{  
		printf( "ControlService() Faild %d !\n", GetLastError() );  
	}  
	else  
	{
		//打开驱动所对应的失败
		printf( "ControlService() ok !\n" );  
	}  
	//动态卸载驱动程序。  
	if( !DeleteService( hServiceDDK ) )  
	{
		//卸载失败
		printf( "DeleteSrevice() Faild %d !\n", GetLastError() );  
	}  
	else  
	{  
		//卸载成功
		printf( "DelServer:eleteSrevice() ok !\n" );  
	}  
	bRet = TRUE;
BeforeLeave:
//离开前关闭打开的句柄
	if(hServiceDDK)
	{
		CloseServiceHandle(hServiceDDK);
	}
	if(hServiceMgr)
	{
		CloseServiceHandle(hServiceMgr);
	}
	return bRet;	
}

卸载驱动的时候首先利用ControlService函数将服务停止，然后调用DeleteService将服务项删除。

void TestDriver()
{
	//测试驱动程序  
	HANDLE hDevice = CreateFile("\\\\.\\HelloDDK",  
		GENERIC_WRITE | GENERIC_READ,  
		0,  
		NULL,  
		OPEN_EXISTING,  
		0,  
		NULL);  
	if( hDevice != INVALID_HANDLE_VALUE )  
	{
		printf( "Create Device ok ! \n" );  
	}
	else  
	{
		printf( "Create Device faild %d ! \n", GetLastError() );  
	}
	CloseHandle( hDevice );
}

这个函数主要利用CreateFile创建设备文件，主要这里的文件名字要和上面驱动程序里面的设备名称一致。看起来路径名称是不一样的实际上\??\和\\.\\在内核当中被解析成同一个路径，所以才创建才能成功。注意设备的名称一定要统一。不然很有可能出错。并且，如果没有符号链接的话调用上面的CreateFile也不会成功，StartService函数返回错误码2。

int main(int argc, char* argv[])  
{
	//加载驱动
	BOOL bRet = LoadNTDriver(DRIVER_NAME,DRIVER_PATH);
	if (!bRet)
	{
		printf("LoadNTDriver error\n");
		return 0;
	}
	//加载成功

	printf( "press any to create device!\n" );  
	getch();  

	TestDriver();

	//这时候你可以通过注册表，或其他查看符号连接的软件验证。  
	printf( "press any to unload the driver!\n" );  
	getch();  

	//卸载驱动
	UnloadNTDriver(DRIVER_NAME);
	if (!bRet)
	{
		printf("UnloadNTDriver error\n");
		return 0;
	}

	return 0;  
}