驱动开发（9）处理缓冲I/O设备的读写请求

妖狐艹你老母 2022-07-31 09:56 148阅读 0赞

本博文由CSDN博主zuishikonghuan所作，版权归zuishikonghuan所有，转载请注明出处： [http://blog.csdn.net/zuishikonghuan/article/details/50413094][http_blog.csdn.net_zuishikonghuan_article_details_50413094]

在上面的几篇博文中，介绍了 IRP 与派遣函数，通过例子“磁盘设备的绝对读写”演示了在应用程序中向一个设备发出I/O请求，并实现了驱动程序中处理一个I/O请求——由 DeviceIoControl 这个 Win32API 经过一系列调用，在内核中生成的 IRP\_MJ\_DEVICE\_CONTROL 这个IRP。

首先我们需要来看看什么叫“缓冲I/O设备”

还记得我们在之前的“NT驱动的基本结构”一篇博文中，我们调用内核函数创建设备后，对 DEVICE\_OBJECT 进行了一些操作，比如：取得设备扩展地址，不知道大家注意到这行代码了没有：

pDevObj->Flags |= DO_BUFFERED_IO;

**我们修改了 DEVICE\_OBJECT 结构中的 Flags 成员，使用按位或的方式增加了一个 DO\_BUFFERED\_IO 标志，将设备修改成了缓冲I/O设备。**

<table> 
 <tbody> 
  <tr> 
   <td>&nbsp;</td> 
   <td> <p>提示：其实缓冲I/O设备设个名词不一定准确，或许叫<span style="background-color:rgb(255,255,204)">“使用缓冲I/O工作的设备”</span>更好一点。</p> </td> 
  </tr> 
 </tbody> 
</table>

让我们先来看看什么是”缓冲I/O设备”，并以此为线索了解一些原理。

当我们调用 ReadFile(Ex) 和 WriteFile(Ex) 读写文件，管道或者设备时，**我们需要提供一个缓冲区的指针**，如果是同步读（注意是同步），那么 ReadFile 返回后，我们要读的数据就在缓冲区里了，如果是同步写（同样，注意是同步），则 WriteFile 结束后，我们要写的数据就写完了，当然都是没有出错的情况下。

**这一切看起来似乎并没有什么特殊的，我们早已经对这两个函数熟悉到不能再熟悉，但是你有没有发现有些不对劲，但是又不知道在哪里呢？**

我们来回忆一下API调用过程，我们调用的 ReadFile 和 WriteFile ，是 Win32 子系统提供的编程接口，也就是 Win32API ，Win32API 会对实参进一步包装，可能调用其他子系统API，但最终都会调用从 ntdll 导出的 NT Native API ，nativeAPI 调用 KiFastSystemCall ，随后进入内核，进入内核在老硬件平台和老版本 winNT 上是通过软中断 int 2e，现在一般是有专门的指令，为了减少从 R3 切换到 R0 带来的性能损失，进入内核后，调用内核模式下的函数，比如 ZwReadFile ，这个函数会查 SSDT，找到 NtReadFile 并调用之，之后，会调用内核中 I/O管理器的接口，I/O管理器构造生成 IRP ，并发送到相应设备所在驱动程序的派遣函数中。

你可能会奇怪，对啊，没有什么啊，我们不就是要写派遣函数从而处理这些IRP么？那么问题来了，Windows 是一个多任务抢占式调度的操作系统（上世纪的 Windows1.0 等不是抢占式的，是多任务协作式调度的），虽然在某一个具体的时刻，一个 CPU（或一个 CPU 核心）不可能是多任务的，但从宏观上说，操作系统中有大量的线程是并发执行的！于是，“进程上下文”和“线程上下文”在频繁地被切换，上下文中记录了 CPU 的执行现场，寄存器，堆栈地址等，用于上下文切换后恢复现场使得程序得以继续执行，进程上下文的切换就意味着用户模式虚拟内存（线性地址空间）的切换，博主现在发现，在驱动开发（1）基础知识一篇博文中对虚拟内存一笔带过真是个错误，所以在这里简单说一下：

**虚拟内存**也叫**线性地址空间**，在 Intel 80x86 架构的 CPU 上工作的 32bit Windows 操作系统，虚拟内存的大小恒为**4GB**，**虚拟内存是Windows操作系统的最基本机制之一，原理是将线性地址映射到物理内存**，他不能被关闭，也不能修改大小，如果你问为什么是4GB，原因很简单，32位的指针的寻址能力只有32位，因此指针最多表示4GB的地址空间。虚拟内存一般是低2GB是用户模式下的，而高2GB由内核使用，虚拟内存分为非页内存和分页内存，非页内存不能交换到磁盘上，而分页内存可以暂时转储到磁盘上，一旦一个虚拟内存页面被转储到文件，那么此页面就被打上一个“脏的”标志，一旦程序访问这样的内存页面，就会触发一个“缺页中断”，从而引发异常处理程序，异常处理程序会将页面从磁盘移到物理内存中，并映射到程序试图访问的虚拟内存地址上。虚拟内存解决了这么几个问题：1。**使不同进程的内存空间是私有的，为多任务提供了基础**；2。**内存页面可以设置访问规则**，比如不可执行标记，就是传说中的 DEP ，为了防止hacker通过溢出攻击入侵，但是早已被破解，原理是溢出调用 VirtualProtect 修改虚拟内存保护规则，但从 Vista/7/8/blue/10 开始，引入了地址空间布局随机化（ASLR）（即不管是否需要地址重定向，只要能重定向，则一律重定向，XP上是必须重定向时才会重定向，可以不重定向就不重定向），虽然有堆喷射技术等可以实现绕过 ASLR ，但是当 ASLR 和 DEP 同时工作时，溢出攻击将会变得异常困难（这也提醒我们，开发应用程序时最好启用映像地址随机化）。3。**隔离了 R3 和 R0 的内存空间**；4。**可以将分页内存转储磁盘**（这个转储功能是可以关闭和配置的，内存页面转储到磁盘是虚拟内存的一个可选功能，但非页内存永远不能转储到磁盘）

回归正题，说完这些，问题已经呼之欲出，进程上下文切换使用户模式的虚拟内存空间切换，我们提供的缓冲区必定是用户模式虚拟内存的一部分，因此，进入内核模式后，如果进程上下文切换了（上文已经说了，Windows 是抢占式调度的，因此这很可能发生），那么我们的缓冲区指针不就变成野指针了吗！

当应用程序打开一个设备并发出一个 I/O 请求时，会载人到驱动程序的派遣函数中，虽然 **此时驱动程序的 Dispatch Function 运行在调用 I/O 函数的用户模式线程上下文中**，此时访问用户模式虚拟内存并不会带来影响，但现实情况总是要比理想环境复杂很多，首先，驱动程序可能异步处理 I/O 请求（异步完成 IRP 会在以后说）驱动程序会立即返回 Dispatch Function ，将 IRP 加入一个处理队列，并在之后在其他线程中完成他，此时线程上下文可能会随时被切换，从而使用户模式的虚拟内存地址变成野指针；另一种常见的情况是处理 I/O 请求的设备并非只有一个，比如文件系统驱动程序会将 IRP 发送到磁盘设备驱动程序中，而 **对于之后的设备的派遣函数而言，并不能确定运行在原来用户模式线程上下文中**，这会带来同样的问题，即此时线程上下文可能会随时被切换，从而使用户模式的虚拟内存地址变成野指针。  
  
所以，操作系统为了解决这个问题，方便硬件驱动程序开发人员，提出了缓冲I/O设备，直接I/O设备等概念。缓冲I/O设备，就是进入内核后，操作系统分配一块内核空间虚拟内存作为缓冲区，并把用户模式虚拟内存的缓冲区中的数据复制进来，复制完成后，传给驱动程序的地址就是内核模式的地址了，内核模式虚拟内存不会因进程上下文切换而改变映射关系，因此这个问题就解决了。  
  
当然，这种方法不一定是最好的方法，因为缓冲区的复制会损失性能，下一篇我们再说其他的方法。

**呜，说了这么多，不管你能不能理解，下面来看看如何处理缓冲I/O设备的读写请求。**

我们的驱动程序显然是没有具体的存储硬件的，因此我们不得不寻找一些其他方法，本例中分配了一些内核虚拟内存（分页内存）当做是存储空间。

在驱动开发中，在某些时候使用分页内存会引发页故障而使内核崩溃（传说中的蓝屏死机），一般和“中断请求级”有关，蓝屏死机其实是内核的一种异常处理，只不过处理的有些简单粗暴，蓝屏，输出一些调试信息，然后死机，不响应用户的输入。但本例中没有影响，我们以后再讨论什么时候不能使用分页内存。

是时候说说IRP结构中几个成员的意思了，IRP 结构是如何定义的看之前我写的博客“IRP与派遣函数”：

**MdlAddress**：指向一个描述的用户缓冲区的 MDL （内存描述符表）的指针，如果驱动程序不使用直接 I/O（DO\_DIRECT\_IO），此指针为 NULL。本例中使用缓冲方式，因此不涉及这个，下一篇博文中详细介绍直接 I/O。

**Flags**：文件系统驱动程序使用此字段，只读。

**AssociatedIrp.SystemBuffer**：指向内核模式虚拟内存缓冲区的指针。用于缓冲I/O方式。

**IoStatus**：包含一个驱动程序存储状态和信息的 IO\_STATUS\_BLOCK 结构。

> **Status**：完成状态，  
> **Pointer**：保留。仅供内部使用。  
> **Information**：这是设置为依赖于请求的值。例如，成功完成了读写请求，用于设置操作的字节数。

其他的不再一一列举了，如有兴趣可以看 MSDN

应用程序，发出读写请求的程序，源码：

#include "stdafx.h"
    #include<Windows.h>
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	//打开设备
    	HANDLE handle = CreateFileA("\\\\.\\MyDevice1_link", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    	if (handle == INVALID_HANDLE_VALUE){
    		MessageBoxA(0, "打开设备失败", "错误", 0);
    		return 0;
    	}
    	unsigned char buffer1[50] = { 0 };
    	unsigned char buffer2[50] = { 0 };
    	DWORD len;
    
    	//测试1：写入超出驱动申请的缓冲区大小的数据
    	if (!WriteFile(handle, buffer1, 1000, &len, NULL))
    		printf("1: failed\n");//当然会失败
    	
    	//测试2：写入字符串hello, driver，偏移量为5
    	//也就是说，跳过前五个字节再写入
    	sprintf((char*)buffer1, "hello, driver\r\n");
    	OVERLAPPED ol = { 0 };
    	ol.Offset = 5;
    	if (WriteFile(handle, buffer1, strlen((char*)buffer1), &len, &ol)){
    		printf("2: len: %d\n", len);
    	}
    
    	//测试3： 读出0-48（共49字节）的数据，并使用16进制输出
    	if (ReadFile(handle, buffer2, 49, &len, NULL)){
    		printf("3: len: %d\n", len);
    		for (int i = 0; i < len; i++){
    			printf("0x%02X ", buffer2[i]);
    		}
    	}
    	
    	//测试4： 获取驱动缓冲区已使用的大小（抽象成文件大小）
    	printf("used: %d\n", GetFileSize(handle, NULL));
    
    	getchar();
    	CloseHandle(handle);
    	return 0;
    }

驱动程序源码：

#include <ntddk.h>
    extern "C" VOID DriverUnload(PDRIVER_OBJECT pDriverObject);
    extern "C" NTSTATUS DefDispatchRoutine(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    extern "C" NTSTATUS WriteDispatchRoutine(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    extern "C" NTSTATUS ReadDispatchRoutine(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    extern "C" NTSTATUS QueryInfomationDispatchRoutine(PDEVICE_OBJECT pDevObj, PIRP pIrp);
    
    #define BUFFER_LENGTH 512 //缓冲区长度
    
    //我们定义的设备扩展
    typedef struct _DEVICE_EXTENSION {
    	UNICODE_STRING SymLinkName;//符号链接名
    
    	//这是为我们要处理读写请求而准备的缓冲区长度和指针
    	ULONG filelength;//已经使用的长度（这个很像一个文件，故这样命名）
    	PUCHAR buffer;//缓冲区指针
    } DEVICE_EXTENSION, *PDEVICE_EXTENSION;
    
    #pragma code_seg("INIT")
    extern "C" NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObject, PUNICODE_STRING pRegistryPath)
    {
    	DbgPrint("DriverEntry\r\n");
    
    	pDriverObject->DriverUnload = DriverUnload;//注册驱动卸载函数
    
    	//注册派遣函数
    	pDriverObject->MajorFunction[IRP_MJ_CREATE] = DefDispatchRoutine;
    	pDriverObject->MajorFunction[IRP_MJ_CLOSE] = DefDispatchRoutine;
    	pDriverObject->MajorFunction[IRP_MJ_WRITE] = WriteDispatchRoutine;
    	pDriverObject->MajorFunction[IRP_MJ_READ] = ReadDispatchRoutine;
    	pDriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = QueryInfomationDispatchRoutine;
    
    	NTSTATUS status;
    	PDEVICE_OBJECT pDevObj;
    	PDEVICE_EXTENSION pDevExt;
    
    	//创建设备名称的字符串
    	UNICODE_STRING devName;
    	RtlInitUnicodeString(&devName, L"\\Device\\MyDevice1");
    
    	//创建设备
    	status = IoCreateDevice(pDriverObject, sizeof(DEVICE_EXTENSION), &devName, FILE_DEVICE_UNKNOWN, 0, TRUE, &pDevObj);
    	if (!NT_SUCCESS(status))
    		return status;
    
    	pDevObj->Flags |= DO_BUFFERED_IO;//将设备设置为缓冲I/O设备
    	pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;//得到设备扩展
    
    	//分配用于处理读写请求的缓冲区
    	pDevExt->buffer = (PUCHAR)ExAllocatePool(PagedPool, BUFFER_LENGTH);
    	//设置缓冲区已使用的大小
    	pDevExt->filelength = 0;
    
    	//内存清零
    	RtlZeroMemory(pDevExt->buffer, BUFFER_LENGTH);
    
    	//创建符号链接
    	UNICODE_STRING symLinkName;
    	RtlInitUnicodeString(&symLinkName, L"\\??\\MyDevice1_link");
    	pDevExt->SymLinkName = symLinkName;
    	status = IoCreateSymbolicLink(&symLinkName, &devName);
    	if (!NT_SUCCESS(status))
    	{
    		IoDeleteDevice(pDevObj);
    		return status;
    	}
    	return STATUS_SUCCESS;
    }
    
    extern "C" VOID DriverUnload(PDRIVER_OBJECT pDriverObject)
    {
    	DbgPrint("DriverUnload\r\n");
    	PDEVICE_OBJECT pDevObj;
    	pDevObj = pDriverObject->DeviceObject;
    
    	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;//得到设备扩展
    
    	//删除符号链接
    	UNICODE_STRING pLinkName = pDevExt->SymLinkName;
    	IoDeleteSymbolicLink(&pLinkName);
    
    	//删除设备
    	IoDeleteDevice(pDevObj);
    }
    
    extern "C" NTSTATUS DefDispatchRoutine(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    {
    	DbgPrint("DefDispatchRoutine\r\n");
    	NTSTATUS status = STATUS_SUCCESS;
    	pIrp->IoStatus.Status = status;
    	pIrp->IoStatus.Information = 0;
    	IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    	return status;
    }
    extern "C" NTSTATUS WriteDispatchRoutine(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    {
    	DbgPrint("WriteDispatchRoutine\r\n");
    	NTSTATUS status = STATUS_SUCCESS;
    
    	//得到设备扩展
    	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
    
    	//得到I/O堆栈的当前这一层，也就是IO_STACK_LOCATION结构的指针
    	PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(pIrp);
    
    	ULONG WriteLength = stack->Parameters.Write.Length;//获取写入的长度
    	ULONG WriteOffset = (ULONG)stack->Parameters.Write.ByteOffset.QuadPart;//获取写入的偏移量
    	DbgPrint("WriteLength: %d\r\nWriteOffset: %d\r\n", WriteLength, WriteOffset);//输出相关信息
    
    	PVOID buffer = pIrp->AssociatedIrp.SystemBuffer;//得到缓冲区指针
    
    	if (WriteOffset + WriteLength > BUFFER_LENGTH){
    		//如果要操作的超出了缓冲区，则失败完成IRP，返回无效
    		DbgPrint("E: The size of the data is too long.\r\n");
    		status = STATUS_FILE_INVALID;
    		WriteLength = 0;
    	}
    	else{
    		//没有超出,则进行缓冲区复制，将写入的数据复制缓冲区
    		memcpy(pDevExt->buffer + WriteOffset, buffer, WriteLength);
    		status = STATUS_SUCCESS;
    
    		//设置新的已经使用长度
    		if (WriteLength + WriteOffset > pDevExt->filelength){
    			pDevExt->filelength = WriteLength + WriteOffset;
    		}
    	}
    
    	pIrp->IoStatus.Status = status;//设置IRP完成状态，会设置用户模式下的GetLastError
    	pIrp->IoStatus.Information = WriteLength;//设置操作字节数
    	IoCompleteRequest(pIrp, IO_NO_INCREMENT);//完成IRP
    	return status;
    }
    extern "C" NTSTATUS ReadDispatchRoutine(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    {
    	DbgPrint("ReadDispatchRoutine\r\n");
    	NTSTATUS status = STATUS_SUCCESS;
    
    	//得到设备扩展
    	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
    
    	//得到I/O堆栈的当前这一层，也就是IO_STACK_LOCATION结构的指针
    	PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(pIrp);
    
    	ULONG ReadLength = stack->Parameters.Read.Length;//得到读的长度
    	ULONG ReadOffset = (ULONG)stack->Parameters.Read.ByteOffset.QuadPart;//得到读偏移量
    	DbgPrint("ReadLength: %d\r\nReadOffset: %d\r\n", ReadLength, ReadOffset);//输出相关信息
    
    	PVOID buffer = pIrp->AssociatedIrp.SystemBuffer;//得到缓冲区指针
    
    	if (ReadOffset + ReadLength > BUFFER_LENGTH){
    		//如果要操作的超出了缓冲区，则失败完成IRP，返回无效
    		DbgPrint("E: The size of the data is too long.\r\n");
    		status = STATUS_FILE_INVALID;//会设置用户模式下的GetLastError
    		ReadLength = 0;//设置操作了0字节
    	}
    	else{
    		//没有超出,则进行缓冲区复制
    		DbgPrint("OK, I will copy the buffer.\r\n");
    		RtlMoveMemory(buffer, pDevExt->buffer + ReadOffset, ReadLength);
    		status = STATUS_SUCCESS;
    	}
    
    	pIrp->IoStatus.Status = status;//设置IRP完成状态，会设置用户模式下的GetLastError
    	pIrp->IoStatus.Information = ReadLength;//设置操作字节数
    	IoCompleteRequest(pIrp, IO_NO_INCREMENT);//完成IRP
    	return status;
    }
    extern "C" NTSTATUS QueryInfomationDispatchRoutine(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    {
    	DbgPrint("QueryInfomationDispatchRoutine\r\n");
    	//用于处理应用程序GetFileSize获取文件大小（已经使用的大小）
    
    	PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(pIrp);//得到I/O堆栈的当前这一层，也就是IO_STACK_LOCATION结构的指针
    	PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;//得到设备扩展
    	FILE_INFORMATION_CLASS fic = stack->Parameters.QueryFile.FileInformationClass;//得到FileInformationClass枚举类型
    	if (fic == FileStandardInformation){
    		PFILE_STANDARD_INFORMATION FileStandardInfo = (PFILE_STANDARD_INFORMATION)pIrp->AssociatedIrp.SystemBuffer;//得到缓冲区指针
    		FileStandardInfo->EndOfFile = RtlConvertLongToLargeInteger(pDevExt->filelength);//设置文件大小（已经使用的大小）
    	}
    
    	pIrp->IoStatus.Status = STATUS_SUCCESS;//设置IRP完成状态，会设置用户模式下的GetLastError
    	pIrp->IoStatus.Information = stack->Parameters.QueryFile.Length;//设置操作字节数
    	IoCompleteRequest(pIrp, IO_NO_INCREMENT);//完成IRP
    	return STATUS_SUCCESS;
    }

我们来看看效果图：

![Center][]

可以看出，**我们的驱动程序成功处理了来自应用程序的读/写这两个I/O请**求，对于读请求，就从内存中读出数据给应用程序，对于写请求，就写进内存。代码中带了详细的注释，再结合上文，想必大家都能很轻松地看懂。我们可以发现，这已经可以当做一个存储设备使用了，而且读写速度极快（只不过掉电后数据会丢失），**如果我们再完善一下，就相当于我们为操作系统增加了一个完善的存储设备！如果我们想办法让系统识别出这个设备是一个磁盘，那么我们就相当于虚拟出来一块磁盘，**并且可以让系统为其创建分区，创建卷设备，出现在“此电脑”（资源管理器）中，而且用户（不知情的前提下）和所有的应用程序都会认为这是一个真正的磁盘！这就是以后会讲到的“虚拟设备”，是不是很神奇？但这只是驱动开发魅力的冰山一角！驱动开发所能实现的还有很多，比如，各种内核中hook（利用内核hook可以劫持内核函数和对象，从而拦截应用程序发出的系统调用），各种过滤驱动（利用过滤驱动可以拦截、修改应用程序向设备发送本来想发送的请求，还可以实现对底层设备抽象，比如把网络请求转换成usb传输，而应用程序依旧以为是TCP/IP……），文件系统透明加密（其实这个也是过滤驱动）……

现在，经过这4篇博客以后，想必大家对IRP和处理I/O请求有了非常深刻的认识，并且，我们是站在原理的高度去研究的，但是，这还没完！如果你深入思考这些原理，就会发现依旧存在盲区，比如，本质是异步，但用户线程等待驱动程序处理完毕而变成了同步，那么是怎么等待的？还有，我们一定要完成掉IRP吗，还有没有其他处理方法？哈哈，这些问题，IRP的同步和异步，过滤驱动和IRP转发……我将会在之后的博客中一一做介绍、讨论和分析。那么下一篇博文，我们来看看直接I/O。

[http_blog.csdn.net_zuishikonghuan_article_details_50413094]: http://blog.csdn.net/zuishikonghuan/article/details/50413094
[Center]: /images/20220731/b44e0ac3d0dc488f9a19143fa2c2ce3f.png