【转帖】Windows文件系统过滤驱动开发教程-楚狂人

心已赠人 2022-08-23 15:56 607阅读 0赞

**Windows文件系统过滤驱动开发教程-楚狂人**  
**关键词**： [Windows][] [文件系统][Link 1] [过滤驱动][Link 2] [开发][Link 3] [教程][Link 4]

第一部分：概述，钻研目的和准备

我经常在网上碰到同行请求开发文件系统驱动。Windows的PC机上以过滤驱动居多。其目的不外乎有以下几种：

1、用于防病毒引擎。希望在文件读写的时候，捕获读写的数据内容，然后检测其中是否含有病毒代码。

2、用于加密文件系统，希望在文件写过程中对数据进行加密，在读的过程中进行解密。

3、设计透明的文件系统加速。读写磁盘的时候，何时的Cache算法是可以大大提高磁盘的工作效率。Windows本身的Cache算法未必适合一些特殊的读写磁盘操作（如流媒体服务器上读流媒体文件）。

文件系统驱动是Windows系统中最复杂的驱动种类之一。不能对IFSDDK中的帮助抱太多希望，文件系统的DDK帮助极其简略，很多重要部分仅仅轻描淡写的带过。如果安装了IFSDDK，应该阅读SRC/FileSys/OSR\_Docs下的文档。而不仅仅是DDK帮助。

文件系统驱动开发方面的书籍很少。中文资料仅仅见过候捷翻译过的一本驱动开发的书上有两三章涉及，而且也仅仅只能用于9X的VXD驱动。NT文件系统见过一本英文书。我都不记得这两本书的书名了。

如果您打算开发9X或者NT文件系统驱动，建议你去网上下载上文提及的书。那两本书都有免费的电子版本下载。如果您打算开发Windows 2000/Windows XP/Windows2003的文件系统驱动，您可以阅读本教程。虽然本教程仅仅讲述文件过滤驱动。但是如果您要开发一个全新的文件系统驱动的话，本教程依然对您有很大的帮助。

学习文件系统开发之前，应该在机器上安装IFSDDK。DDK版本越高级，其中头文件中提供的系统调用也越多。经常有人询问如XPDDK编译的驱动能不能在2000上运行等等的问题。我想可以这样解释：高级版本的DDK应该总是可以编译低级驱动的代码，而且得到的二进制版本总是可以在低级系统上运行。但反过来就未必可以了。如果在高级系统上编写用于低级系统上的驱动，要非常认真的注意仅仅调用低级系统上有的系统调用。

IIFDDK可以在某些FTP上免费下载。

我使用的IFS DDK For XP，但是我市集用来开发的两台机器有一台是Windows 2000，另一台是Windows 2003。我尽量使我编译出来的驱动，可以在2000/XP/2003三种系统上都通过测试。

安装配置DDK和在VC中开发驱动的方法网上有很多的介绍。IFSDDK安装之后，SRC目录下的FileSys目录下有文件系统驱动的示例。阅读这些代码你就可以快速的学会文件系统驱动开发。

Filter目录下的SFilter是一个文件系统过滤驱动的例子。另一个FileSpy完全是用这个例子的代码加工得更复杂而已。

如何用DDK编译这个例子请自己察看相关的资料。

文件系统过滤驱动编译出来以后，您得到的是一个扩展名为SYS的文件。同时，您需要写一个.INF文件来实现这个驱动的安装。我这里不讨论.INF文件的细节，您可以直接用SFilter目录下的INF文件修改。

对INF文件点鼠标探出菜单选择“安装”，即可安装这个过滤驱动。但是必须重新启动系统才生效。

如果重启后蓝屏无法启动，可以用其他的方式引导系统后到System32/Drivers目录下删除你的.SYS文件再重启即可。我尝试这种情况下用安全模式结果还是蓝屏。所以我后来不得不在机器上装了两个系统。双系统情况下，一个系统崩溃了用另一个系统启动，删除原来的驱动即可。

如果要调试代码，请安装SoftICE。

打开SFilter目录下的文件Sources（这个文件没有扩展名），加入一行：BROWSER\_INFO=1，然后打开Symbol Loader，File->Open选中你编译出来的XXX.SYS，Modul->Load，Modul->Translate，然后就可以调试了。

打开SoftICE，输入File \*就可以看见代码。

如果准备好了，我们就可以开始琢磨Windows文件系统过滤驱动的开发了。

2.hello world,驱动对象与设备对象

这里所说的驱动对象是一种数据结构，在DDK中名为DRIVER\_OBJECT。任何驱动程序都对应一个DRIVER\_OBJECT.如何获得本人所写的驱动对应的DRIVER\_OBJECT呢？驱动程序的入口函数为DriverEntry,因此，当你写一个驱动的开始，你会写下如下的代码：

NTSTATUS DriverEntry(IN PDRIVER\_OBJECT DriverObject, IN PUNICODE\_STRING RegistryPath )  
\{  
\}

这个函数就相当与喜欢c语言的你所常用的main().IN是无意义的宏，仅仅表明后边的参数是一种输入，而对应的OUT则代表这个参数是一种返回。这里没有使用引用,因此如果想在参数中返回结果，一律传入指针。

DriverObject就是你所写的驱动对应的DRIVER\_OBJECT,是系统在加载你的驱动时候所分配的。RegisteryPath是专用于你记录你的驱动相关参数的注册表路径。

DriverObject重要之处，在于它拥有一组函数指针，称为dispatch functions.

开发驱动的主要任务就是亲手撰写这些dispatch functions.当系统用到你的驱动，会向你的DO发送IRP（这是windows所有驱动的共同工作方式）。你的任务是在dispatch function中处理这些请求。你可以让irp失败，也可以成功返回，也可以修改这些irp，甚至可以自己发出irp。

设备对象则是指DEVICE\_OBJECT.下边简称DO.

但是实际上每个irp都是针对DO发出的。只有针对由该驱动所生成的DO的IRP,  
才会发给该驱动来处理。

当一个应用程序打开文件并读写文件的时候，windows系统将这些请求变成irp发送给文件系统驱动。

文件系统过滤驱动将可以过滤这些irp.这样，你就拥有了捕获和改变文件系统操作的能力。

象Fat32,NTFS这样的文件系统(File System,简称FS)，可能生成好几种设备。首先文件系统驱动本身往往生成一个控制设备（CDO）.这个设备的主要任务是修改整个驱动的内部配置。因此一个Driver只对应一个CDO.

另一种设备是被这个文件系统Mount的Volume。一个FS可能有多个Volume,也可能一个都没有。解释一下，如果你有C:,D:,E:,F:四个分区。C:,D:为NTFS,E:,F:为Fat32.那么C:,D:则是Fat的两个Volume设备对象.

实际上"C:"是该设备的符号连接（Symbolic Link）名。而不是真正的设备名。可以打开Symbolic Links Viewer,能看到：

C: DeviceHarddiskVolume1

因此该设备的设备名为“DeviceHarddiskVolume1”.

这里也看出来，文件系统驱动是针对每个Volume来生成一个DeviceObject,而不是针对每个文件的。实际上对文件的读写的irp,都发到Volume设备对象上去了。并不会生成一个“文件设备对象”。

掌握了这些概念的话，我们现在用简单的代码来生成我们的CDO,作为我们开发文件系统驱动的第一步牛刀小试。

我不喜欢用微软风格的代码。太长而且难看。我对大部分数据结构和函数进行了重定义。为此我写了一个名为wdf.h的头文件帮助我转换。有兴趣的读者可以发邮件向索取这个文件。没有也没有关系，我总是会写出wd\_xxx系列的东西在DDK中的原形。

// -----------------wdf\_filter.c中的内容-------------------------

\#include "wdf.h"

wd\_stat wdff\_cdo\_create(in wd\_drv \*driver, in wd\_size exten\_len,  
in wd\_ustr \*name, out wd\_dev \*\*device)

\{  
return wd\_dev\_create(driver, exten\_len, name, wd\_dev\_disk\_fs,  
wdf\_dev\_secure\_open, wd\_false, device);  
\}

wd\_stat wd\_main(in wd\_drv\* driver, in wd\_ustr\* reg\_path)  
\{  
wd\_ustr name;  
wd\_stat status = wd\_stat\_suc;

// 然后我生成控制设备,虽然现在我的控制设备什么都不干  
wd\_ustr\_init(&name,L"/FileSystem/Filters/our\_fs\_filter");  
status = wdff\_cdo\_create(driver,0,&name,&g\_cdo);

if(!wd\_suc(status))  
\{  
if(status == wd\_stat\_path\_not\_found)  
\{  
// 这种情况发生于FileSystemFilters路径不存在。这个路径是  
// 在xp上才加上的。所以2000下会运行到这里  
wd\_ustr\_init(&name,L"/FileSystem/our\_fs\_filter");  
status = wdff\_cdo\_create(driver,0,&name,&g\_cdo);  
\};  
if(!wd\_suc(status))  
\{  
wd\_printf0("error: create cdo failed.rn");  
return status;  
\}  
\}

wd\_printf0("success: create cdo ok.rn");  
return status;  
\}

为了让代码看起来象上边的那样，我不得不做了很多转换。如

\#define DriverEntry wd\_main

一种爽的感觉，终于可以在写看起来更象是main()的函数中工作了。 wd\_dev\_create 这个函数内部调用的是IoCreateDevice.而wd\_suc实际上是SUCCESS()这样的宏。

// ----------------------wdf.h中的内容------------------------------  
\#include "ntifs.h"

\#define in IN  
\#define out OUT  
\#define optional OPTIONAL  
\#define wd\_ustr UNICODE\_STRING  
\#define wdp\_ustr PUNICODE\_STRING  
\#define wd\_main DriverEntry

// 设备、驱动对象类型  
typedef DRIVER\_OBJECT wd\_drv;  
typedef DEVICE\_OBJECT wd\_dev;  
typedef PDRIVER\_OBJECT wd\_pdrv;  
typedef PDEVICE\_OBJECT wd\_pdev;

enum \{  
wd\_dev\_disk\_fs = FILE\_DEVICE\_DISK\_FILE\_SYSTEM,  
wd\_dev\_cdrom\_fs = FILE\_DEVICE\_CD\_ROM\_FILE\_SYSTEM,  
wd\_dev\_network\_fs = FILE\_DEVICE\_NETWORK\_FILE\_SYSTEM  
\};

// 状态相关的类型和宏  
typedef NTSTATUS wd\_stat;

enum \{  
wd\_stat\_suc = STATUS\_SUCCESS,  
wd\_stat\_path\_not\_found = STATUS\_OBJECT\_PATH\_NOT\_FOUND,  
wd\_stat\_insufficient\_res = STATUS\_INSUFFICIENT\_RESOURCES,  
wd\_stat\_invalid\_dev\_req = STATUS\_INVALID\_DEVICE\_REQUEST,  
wd\_stat\_no\_such\_dev = STATUS\_NO\_SUCH\_DEVICE,  
wd\_stat\_image\_already\_loaded = STATUS\_IMAGE\_ALREADY\_LOADED,  
wd\_stat\_more\_processing = STATUS\_MORE\_PROCESSING\_REQUIRED,  
wd\_stat\_pending = STATUS\_PENDING  
\};  
（inline的使用是有所限制的，inline 函数一般必须在头文件内，inline只适合函数体内代码简单的函数使用，不能包含复杂的结构控制语句例如while switch，并且不能内联函数本身不能是直接递归函数(自己内部还调用自己的函数)。）  
\_inline wd\_bool wd\_suc(wd\_stat state) //内聯函數  
\{  
return NT\_SUCCESS(state);  
\}

\#define wd\_printf0 DbgPrint

\_inline wd\_void wd\_ustr\_init(in out wd\_ustr\* str,  
in const wd\_wchar\* chars)  
\{  
RtlInitUnicodeString(str,chars);  
\};

\_inline wd\_void wd\_ustr\_init\_em(in out wd\_ustr \*str ,in wd\_wchar \*chars,  
in wd\_size size)  
\{  
RtlInitEmptyUnicodeString(str,chars,size);  
\};

wdf.h这个文件我仅仅节选了需要的部分。以上您已经拥有了一个简单的“驱动”的完整的代码。它甚至可以编译，安装（请修改sfilter.inf文件，其方法不过是将多处sfilter改为"our\_fs\_filter",希望这个过程中您不会出现问题）。然后把wdf.h和wdf\_filter.c放在您新建立的目录下，这个目录下还应该有另两个文件。一个是Makefile,请从sfilter目录下拷贝。另一个是SOURCES，请输入如下内容：  
TARGETNAME=our\_fs\_filter  
TARGETPATH=obj  
TARGETTYPE=DRIVER  
DRIVERTYPE=FS  
BROWSER\_INFO=1  
SOURCES=wdf\_filter.c

使用DDK编译之后您将得到our\_fs\_filter.sys.把这个文件与前所描述的 inf 文件同一目录，按上节所叙述方法安装。

这个驱动不起任何作用，但是你已经成功的完成了"hello world". 3.分发例程,fast io

上一节仅仅生成了控制设备对象。但是不要忘记，驱动开发的主要工作是撰写分发例程(dispatch functions.).接上一接，我们已经知道自己的DriverObject保存在上文代码的driver中。现在我写如下一个函数来指定一个默认的dispatch function给它。

//-----------------wdf.h中的代码----------------------  
typedef PDRIVER\_DISPATCH wd\_disp\_fuc;  
\_inline wd\_void wd\_drv\_set\_dispatch(in wd\_drv\* driver,  
in wd\_disp\_fuc disp)  
\{  
wd\_size i;  
for (i = 0; i <= IRP\_MJ\_MAXIMUM\_FUNCTION; i++)  
driver->MajorFunction\[i\] = disp;  
\}

在前边的wd\_main中，我只要加

wd\_drv\_set\_dispatch(driver,my\_dispatch\_func);

就为这个驱动指定了一个默认的Dispatch Function.所有的irp请求，都会被发送到这个函数。但是，我可能不希望这个函数处理过于复杂，而希望把一些常见的请求独立出来，如Read,Write,Create,Close,那我又写了几个函数专门用来设置这几个Dispatch Functions.

//-----------------wdf.h中的代码----------------------  
\_inline wd\_void wd\_drv\_set\_read(  
in wd\_drv\* driver,  
in wd\_disp\_fuc read)  
\{  
driver->MajorFunction\[IRP\_MJ\_READ\] = read;  
\}  
\_inline wd\_void wd\_drv\_set\_write(  
in wd\_drv\* driver,  
in wd\_disp\_fuc write)  
\{  
driver->MajorFunction\[IRP\_MJ\_WRITE\] = write;  
\}

wd\_void wd\_drv\_set\_create(in wd\_drv\* driver,  
in wd\_disp\_fuc create)  
\{  
driver->MajorFunction\[IRP\_MJ\_CREATE\] = create;  
driver->MajorFunction\[IRP\_MJ\_CREATE\_NAMED\_PIPE\] = create;  
driver->MajorFunction\[IRP\_MJ\_CREATE\_MAILSLOT\] = create;  
\}

wd\_void wd\_drv\_set\_file\_sys\_control(in wd\_drv\* driver,  
in wd\_disp\_fuc control)  
\{  
driver->MajorFunction\[IRP\_MJ\_FILE\_SYSTEM\_CONTROL\] = control;  
\}

wd\_void wd\_drv\_set\_clean\_up(in wd\_drv\* driver,  
in wd\_disp\_fuc clean\_up)  
\{  
driver->MajorFunction\[IRP\_MJ\_CLEANUP\] = clean\_up;  
\}

wd\_void wd\_drv\_set\_close(in wd\_drv\* driver,  
in wd\_disp\_fuc close)  
\{  
driver->MajorFunction\[IRP\_MJ\_CLOSE\] = close;  
\}

别看我罗列n多代码，其实就是在设置driver->MajorFunction这个数组而已。因此在wd\_main对dispatch functions的设置，就变成了下边这样的：

// 开始设置几个分发例程  
wd\_drv\_set\_dispatch(driver,my\_disp\_default);  
wd\_drv\_set\_create(driver,my\_disp\_create);  
wd\_drv\_set\_clean\_up(driver,my\_disp\_clean\_up);  
wd\_drv\_set\_file\_sys\_control(driver,my\_disp\_file\_sys\_ctl);  
wd\_drv\_set\_close(driver,my\_disp\_close);  
wd\_drv\_set\_read(driver,my\_disp\_read);  
wd\_drv\_set\_write(driver,my\_disp\_write);

下面的任务都在写my\_xxx系列的这些函数了。但是对于这个DriverObject的设置，还并不是仅仅这么简单。

由于你的驱动将要绑定到文件系统驱动的上边，文件系统除了处理正常的IRP之外，还要处理所谓的FastIo.FastIo是Cache Manager调用所引发的一种没有irp的请求。换句话说，除了正常的Dispatch Functions之外，你还得为DriverObject撰写另一组Fast Io Functions.这组函数的指针在driver->FastIoDispatch.我不知道这个指针留空会不会导致系统崩溃。在这里本来是没有空间的，所以为了保存这一组指针，你必须自己分配空间。

下面是我常用的内存分配函数。

//-----------------wdf.h中的代码----------------------  
// 最简单的分配内存的函数，可以指定分页非分页  
\_inline wd\_pvoid wd\_malloc(wd\_bool paged,wd\_size size)  
\{  
if(paged)  
return ExAllocatePool(PagedPool,size);  
else  
return ExAllocatePool(NonPagedPool,size);  
\}

// 释放内存  
\_inline wd\_void wd\_free(wd\_pvoid point)  
\{  
ExFreePool(point);  
\}

\_inline wd\_void wd\_memzero(  
wd\_pvoid point,  
wd\_size size)  
\{  
RtlZeroMemory(point,size);  
\}

有了上边的基础，我就可以自己写一个初始化FastIoDispatch指针的函数。

//-----------------wdf.h中的代码----------------------  
wd\_bool wd\_fio\_disp\_init(wd\_drv \*driver,wd\_ulong size)  
\{  
wd\_fio\_disp \*disp = wd\_malloc(wd\_false,size);  
if(disp == wd\_null)  
return wd\_false;  
wd\_memzero((wd\_pvoid)disp,size);  
driver->FastIoDispatch = disp;  
driver->FastIoDispatch->SizeOfFastIoDispatch = size;  
return wd\_true;  
\}

这个函数为FastIoDispacth指针分配足够的空间并填写它的大小。下面是再写一系列的函数来设置这个函数指针数组。实际上，FastIo接口函数实在太多了，所以我仅仅写出这些设置函数的几个作为例子：  
//-----------------wdf.h中的代码----------------------  
\_inline wd\_void wd\_fio\_disp\_set\_query\_standard(  
wd\_drv \*driver,  
wd\_fio\_query\_standard\_func func)  
\{  
driver->FastIoDispatch->FastIoQueryStandardInfo = func;  
\}

\_inline wd\_void wd\_fio\_disp\_set\_io\_lock(  
wd\_drv \*driver,  
wd\_fio\_io\_lock\_func func)  
\{  
driver->FastIoDispatch->FastIoLock = func;  
\}

\_inline wd\_void wd\_fio\_disp\_set\_io\_unlock\_s(  
wd\_drv \*driver,  
wd\_fio\_unlock\_single\_func func)  
\{  
driver->FastIoDispatch->FastIoUnlockSingle = func;  
\}

...

好，如果你坚持读到了这里，应该表示祝贺了。我们回顾一下，wd\_main中，应该做哪些工作。

a.生成一个控制设备。当然此前你必须给控制设置指定名称。

b.设置Dispatch Functions.

c.设置Fast Io Functions.

// ----------------wd\_main 的近况----------------------------

...

wd\_dev \*g\_cdo = NULL;

wd\_stat wd\_main(in wd\_drv\* driver,  
in wd\_ustr\* reg\_path)  
\{  
wd\_ustr name;  
wd\_stat status = wd\_stat\_suc;

// 然后我生成控制设备,虽然现在我的控制设备什么都不干  
wd\_ustr\_init(&name,L/"//FileSystem//Filters//our\_fs\_filters/");  
status = wdff\_cdo\_create(driver,0,&name,&g\_cdo);

if(!wd\_suc(status))  
\{  
if(status == wd\_stat\_path\_not\_found)  
\{  
// 这种情况发生于FileSystemFilters路径不存在。这个路径是  
// 在xp上才加上的。所以2000下可能会运行到这里  
wd\_ustr\_init(&name,L/"//FileSystem//our\_fs\_filters/");  
status = wdff\_cdo\_create(driver,0,&name,&g\_cdo);  
\};  
if(!wd\_suc(status))  
\{  
wd\_printf0(/"error: create cdo failed.rn/");  
return status;  
\}  
\}

wd\_printf0(/"success: create cdo ok.rn/");

// 指定fast io处理函数  
if(!wd\_fio\_disp\_init(driver,sizeof(wd\_fio\_disp)))  
\{  
wd\_dev\_del(g\_cdo);  
wd\_printf0(/"error: fast io disp init failed.rn/");  
return wd\_stat\_insufficient\_res;  
\}

// 下面指定的这些函数都定义在wdf\_filter\_fio.h中,其实这些函数都统  
// 一的返回了false  
wd\_fio\_disp\_set\_check(  
driver,  
my\_fio\_check);  
wd\_fio\_disp\_set\_read(  
driver,  
my\_fio\_read);  
wd\_fio\_disp\_set\_write(  
driver,  
my\_fio\_write);  
wd\_fio\_disp\_set\_query\_basic(  
driver,  
my\_fio\_query\_basic\_info);

...

\}  
FastIo函数个数数量不明，我只觉得很多。因此不打算全部罗列，以/".../"敷衍之。某些读者可能会认为这些代码无法调试安装。其实您可以参考sfilter中的示例自己完成这些代码。

现在我们的my\_xxx系列的函数还没有开始写，因此驱动也不能编译通过。在后边的内容中再逐步介绍。  
使用Fast I/O

在这里我们将讲述Fast I/O的基本原理，简单描述各种各样的Fast I/O调用，以及得出如何使用此接口来提高程序性能的建议性结论。

Windows NT内核模式开发的标准做法是采用IRP作为基本的与驱动程序通信的手段，它的优点是IRP封装了上下文所需的详细操作并且允许从驱动程序的众多操作细节中分离出来。

这个方法在windos NT的分层设备体系中非常通用，有相当多的上层操作请求需要快速响应，在这种情况下，上层操作生成IRP决定了整个操作的成本并会导致系统性能的下降。鉴于此，NT系统引入的Fast I/O的概念。这种方法被用在文件系统驱动，如NTFS，HPFS，FAT和CDFS以及被WinSock使用的传输驱动AFD。

任何驱动都可以注册一系列Fast I/O接口，但使用起来还有很大的限制—在这些接口被调之前需要满足合适的条件。例如，读操作和写操作的Fast I/O接口只有当Windows NT cache管理器保留了文件的信息时才被调用。我们在接下的论述中将会讲述这些限制。

当然，Windows NT的Fast I/O最让人郁闷的是关于它的资料很少，即使文件系统开发包也没有讲述Fast I/O是如何工作和怎样来使用Fast I/O。

原理

提供了Fast I/O是非常方便的---许多I/O操作可以对相同的数据进行重复操作。例如和许多流行的操作系统一样，Windows NT用虚拟内存集成了文件系统的缓冲，这样的系统无论是在使用上还是在感觉上都很有效率。

这种集成的另一原因是Windows NT支持内存映射文件。支持读写和内存映射相同的数据要么需要代价很高的cache一致性策略，要么使用NT的策略---将所有数据存储在虚拟内存中。这样，即便是两个程序用不同的技术访问相同的数据，也确保了数据的一致性。

这种紧密的集成意味着无论是读还是写都经常是对cache中的数据来操作。在查找过程中，这种策略用来调用一个特殊的程序，此程序将虚拟机(VM)的cache中的数据移到用户内存中，反之亦然。这样就避免了生成IRP，并且不需要请求底层的驱动了。这就是Fast I/O操作的基本功能。

一旦在程序中定义了Fast I/O读写接口，那么同时还需要进行一步添加其它的通用Fast I/O操作到Fast I/O链中，Fast I/O链中有13个接口(在NT3.51中)。在我们接下来要讲的各接口过程中，你会明显地发现各接口是互相关联的。这些接口包含在FAST\_IO\_DISPATCH结构中，此结构在ntddk.h中有定义。这个结构的第一个元素表示结构的大小，为以后在结构添加新接口提供了一种向上兼容的机制。  
I/O管理器和Fast I/O

I/O管理器在必要的时候负责调用Fast I/O接口。Fast I/O调用返回TRUE或FALSE表示Fast I/O操作是否完成。如果Fast I/O没有被完成或无效，则会产生一个IPR并发送到上层驱动，但是FAST\_IO\_DISPATCH结构中最近的三个接口却不是这样的，它们为I/O管理员提供了不同的服务，接下来我们将讨论它们。

FastIoCheckIfPossible

这是在FAST\_IO\_DISPATCH结构中第一个调用的，仅被用来作为一般的文件系统库操作(以FsRtl开头的函数)。原型如下：  
typedef BOOLEAN (\*PFAST\_IO\_CHECK\_IF\_POSSIBLE)(  
IN Struct \_FILE\_OBJECT \*FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN BOOLEAN Wait,  
IN ULONG LockKey,  
IN BOOLEAN CheckForReadOperation,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN struct \_DEVICE\_OBJECT \*DeviceObject  
);  
这个函数被FsRtl库中提供的通用的Fast I/O函数调用，仅用在读写操作中，以获取使用了通用文件缓存管理系统中的读和写是否能在文件缓存中被响应(由参数CheckForReadOperation的值决定)。注意，除了这个函数没有分配任何数据空间外其它参数和读写的Fast I/O接口参数相似。

FastIoRead and FastIoWrite

当对一个已经分配了有效数据缓存的文件进行读请求时，这个函数被I/O管理器调用。原型如下：  
typedef BOOLEAN (\*PFAST\_IO\_READ)(  
IN struct \_FILE\_OBJECT \*FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN ULONG Length,  
IN BOOLEAN Wait,  
IN ULONG LockKey,  
OUT PVOID Buffer,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN struct \_DEVICE\_OBJECT \*DeviceObject  
);  
正如前面所讲的，基本的调用参数和FastIoCheckIfPossible相似，就是多了一个必要的数据缓存参数。要保证所有Fast I/O调用接口的参数有效，例如上面的Buffer指针，必需是有效的并且在读线程的上下文中能使用此指针。

Fast I/O函数可以完成以下两件事情之一：第一，当操作完成时设置IoStatus的返回值并给I/O管理器返回TRUE，这时I/O管理器会完成对应的I/O操作。第二，直接返回FALSE给I/O管理器使其构造一个IRP从而调用标准的分派例程。

要注意的是返回TRUE并不能保证数据被传输了。例如，一个从文件结束处开始的读请求会设置IoStatus.Results为STATUS\_END\_OF\_FILE，并且没有数据被复制。但是当一个读操作读到了文件的结尾，这时会将IoStatus.Results设置为STATUS\_END\_OF\_FILE，返回TRUE，并且将读到的数据复制到Buffer里。

同样，返回FALSE并不能说明所有的数据没有被处理。例如，当然很少有这种可能，数据已经被成功处理了，但抛出一个I/O错误，或者内存不可访问。

以上任何一种情况出现都会导致不良影响。例如，从缓存读数据时，可能要读的数据并不在缓存中，这时会导致一个页错误，从而会请求文件系统来处理这个页面错误。

Fast I/O的写函数与读函数不同之处仅仅在于Buffer参数一个是输入型而不是输出型的，其它的基本操作很相似。当然，一些错误可能不同---介质已经满，需要分配新页等等。  
  
FastIoQueryBasicInfo and FastIoQueryStandardInfo

这两个操作为标准的NtQueryInformationFile API操作提供了支持，而FastIoQueryBasicInfo也经常被用来处理NtCreateFile的特定操作。文件的基本属性包括创建时间、访问时间和修改时间，以及隐藏、文件夹或其它属性等。文件的标准属性包括文件占用的空间、文件的大小、文件的硬连接号、被请求删除的标志，是否是文件夹的标识。

由于这些信息经常在缓存中，所以它是FAST I/O操作的最佳候选。其实许多程序用这种方法来获取文件基本的信息，因为这种方法提高了操作的效率和程序的性能，如文件管理器程序(winfile.exe)。

这两个Fast I/O例程有相同的接口：

typedef BOOLEAN (\*PFAST\_IO\_QUERY\_ABSIC\_INFO)(  
IN struct \_FILE\_OBJECT \*FileObject,  
IN BOOLEAN Wait,  
OUT PFILE\_BASIC\_INFORMATION Buffer,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN struct \_DEVICE\_OBJECT \*DeviceObject);

Wait参数表示调用者是否阻塞以等待获取信息的返回，如果设置为FALSE，则调用要么立刻完成，要么返回FALSE，如果返回FALSE，则会生成一个包含整个操作必要的上下文件的IRP。有趣的是在NT3.51中当Wait设置为FALSE时这两个例程将不被调用，当然这在以后的版本中会修改。

这两个例程一但被调用，它们会查询文件对象第一次打开时保存的信息，这些信息也可能被实时变化，例如，文件的最近访问时间属性会被文件系统设置的当前的系统时间，当然设置这些属性取决于文件系统的实现。

FastIoLock，FastIoUnLockSingle，FastIoUnLockAll，and FastIoUnLockAllByKey  
这些例程被用来控制特殊文件的加锁状态。对文件的加锁以字节为单位，所以可以对文件的多个字节进行加密。标准的NT文件系统使用文件系统运行时开发包(FsRtl函数)所提供的通用代码来验证锁权限并存储文件的加锁范围。锁状态通过调用NT API函数NtLockFile和NtUnLockFile来控制。

在Windows NT中有两种锁，一种是排它锁，是写锁，说明加锁的地放要进行修改；另一种是共享锁，是读锁，说明加锁的地放用来的读的。多个共享锁在重叠操作中可以被授权，并且一直保存到释放为止。将各种加锁的信息存储起来在访问这些信息的时候会提高速度。  
FastIoLock的原型：  
Typedef BOOLEAN (\*PFAST\_IO\_LOCK)(  
IN struct \_FILE\_OJBECT \*FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN PLARGE\_INTEGER Length,  
PEPROCESS ProcessId,  
ULONG Key,  
BOOLEAN FailImmediately,  
BOOLEAN ExclusiveLock,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN struct \_DEVICE\_OBJECT \*DeviceObject  
);  
FileOffset 和Length参数对应加锁的范围，ProcessId标识加锁的进程，如果进行退出，锁将会清除。Key参数提供一个非透明的值，用来关联多个锁，例如调用FastIoUnLockAllByKey可以快速访问多个锁。FailImmediately用来标识当锁无效时是立刻返回失败还是阻塞直到锁可用。对于FsRtl函数，如果是无效的锁则忽略FailImmediately参数，函数返回FALSE。ExclusiveLock参数用来标识是排它锁还是共享锁。

FastUnlockSingle例程被用来释放对文件的加锁，原型如下：  
Typedef BOOLEAN (\*PFAST\_IO\_UNLOCK\_SINGLE)(  
IN struct \_FILE\_OBJECT \*FileObject,  
IN PLARGE\_INTEGER FileOffset,  
IN PLARGE\_INTEGER Length,  
PEPROCESS ProcessId,  
ULONG Key,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN struct \_DEVICE\_OBJECT \*DeviceObject  
);  
对大多文件系统来说，如果文件没有加锁，此例程总是返回TRUE，即使朝无效的锁，操作也会完成，因为用IRP来操作也同样会产生相同的错误。

如果这个解锁操作成功，那么FileOffset,Length,ProcessId,和Key必须和相应的锁信息匹配，否则操作会返回错误STATUS\_RANGE\_NOT\_LOCKED。FastIoUnlockAll例程用来释放特殊文件所有的锁，函数原型如下：  
typedef BOOLEAN(\*PFAST\_IO\_UNLOCK\_ALL)(  
IN struct \_FILE\_OBJECT \*FileObject,  
PEPROCESS ProcessId,  
OUT PIO\_STATUS\_BLOCK IoStatus,  
IN struct \_DEVICE\_OBJECT \*DeviceObject  
);  
在这种情况下，Fast I/O例程查找进程ProcessId所操作的文件所有的锁，并删除，无论是排它锁还是共享锁。这个例程常用在当系统由于关掉程序或终止程序而调用NtCloseFile时。

FastIoUnlockAllByKey操作用来通过一些特殊的键值来删除一系列锁。原型如下：  
Typedef BOOLEAN (\*PFAST\_IO\_UNLOCK\_ALL\_BY\_KEY)(  
IN struct \_FILE\_OBJECT \*FileObject,  
PVOID ProcessId,  
ULONG Key,  
OUT PIO\_STATUS\_BLOCK\_IoStatus,  
IN struct \_DEVICE\_OBJECT \*DeviceObject  
);  
提供这个例程是为了便于文件服务如SRV。在NT3.51的I/O管理器中没有出现这个调用。键值用来文件服务给远程客户机文件加锁时分配的。因为许多远程客户端，仅有ProcessId是远远不够的。同样，对于多文件服务器，仅使用键值也会在其它的文件服务器释放时导致错误。二者同时使用以确保正确操作并允许远程加锁。4.设备栈,过滤,文件系统的感知

前边都在介绍文件系统驱动的结构，却还没讲到我们的过滤驱动如何能捕获所有发给文件系统驱动的irp，让我们自己来处理?前面已经解释过了设备对象。现在来解释一下设备栈。

任何设备对象都存在于某个设备栈中。设备栈自然是一组设备对象。这些设备对象是互相关联的，也就是说，如果得到一个DO指针，你就可以知道它所处的设备栈。

任何来自应用的请求，最终被windows io mgr翻译成irp的，总是发送给设备栈的顶端那个设备。

原始irp irp irp irp  
\--------------> ------> -------> ----->  
DevTop Dev2 ... DevVolumne ... ???  
<-------------- <------ <------- <-----  
原始irp（返回） irp irp irp

上图向右的箭头表示irp请求的发送过程，向左则是返回。可见irp是从设备栈的顶端开始，逐步向下发送。DevVolumue表示我们实际要过滤的Volume设备，DevTop表示这个设备栈的顶端。我们只要在这个设备栈的顶端再绑定一个设备，那发送给Volume的请求，自然会先发给我们的设备来处理。

有一个系统调用可以把我们的设备绑定到某个设备的设备栈的顶端。这个调用是IoAttachDeviceToDeviceStack，这个调用2000以及以上系统都可以用（所以说到这点，是因为还有一个IoAttachDeviceToDeviceStackSafe,是2000所没有的。这常常导致你的filter在2000下不能用。）

我自己写了一个函数来帮我实现绑定功能：

//----------------------wdf.h中的内容----------------------------------  
// 这个例程把源设备绑定到目标设备的设备栈中去，并返回源设备所直  
// 接绑定的设备。注意源设备未必直接绑定在目标设备上。它应绑定在  
// 目标设备的设备栈的顶端。  
\_inline wd\_stat wd\_dev\_attach(in wd\_dev \*src,  
in wd\_dev \*dst,  
in out wd\_dev \*\*attached)  
\{  
\*attached = dst;  
\*attached = IoAttachDeviceToDeviceStack(src,dst);  
if(\*attached == NULL)  
return wd\_stat\_no\_such\_dev;  
return wd\_stat\_suc;  
\}

到这里，我们已经知道过滤对Volume的请求的办法。比如“C:”这个设备，我已经知道符号连接为“C:”,不难得到设备名。得到设备名后，又不难得到设备。这时候我们IoCreateDevice()生成一个Device Object,然后调用wd\_dev\_attach绑定，不是一切ok吗？所有发给“C:”的irp,就必然先发送给我们的驱动，我们也可以捕获所有对文件的操作了!

这确实是很简单的处理方法。我得到的FileMon的代码就是这样处理的，如果不想处理动态的Volume,你完全可以这样做。但是我们这里有更高的要求。当你把一个U盘插入usb口，一个“J:”之类的Volume动态诞生的时候，我们依然要捕获这个事件，并生成一个Device来绑定它。

一个新的存储媒质被系统发现并在文件系统中生成一个Volume的过程称为Mounting.其过程开始的时候，FS的CDO将得到一个IRP,其Major Function Code为IRP\_MJ\_FILE\_SYSTEM\_CONTROL，Minor Function Code为IRP\_MN\_MOUNT。换句话说，如果我们已经生成了一个设备绑定文件系统的CDO，那么我们就可以得到这样的IRP,在其中知道一个新的Volume正在Mount.这时候我们可以执行上边所说的操作。

现在的问题是如何知道系统中有那些文件系统，还有就是我应该在什么时候绑定它们的控制设备。

IoRegisterFsRegistrationChange()是一个非常有用的系统调用。这个调用注册一个回调函数。当系统中有任何文件系统被激活或者是被注销的时候，你注册过的回调函数就会被调用。

//----------------------wdf.h中的内容----------------------------------  
wd\_stat wdff\_reg\_notify(  
in wd\_drv \*driver,  
in wdff\_notify\_func func  
)  
\{  
return IoRegisterFsRegistrationChange(driver,func);  
\}

你有必要为此写一个回调函数。

//-------------------我的回调处理函数----------------------------------  
wd\_void my\_fs\_notify(  
in wd\_dev \*dev,  
in wd\_bool active)  
\{  
wd\_wchar name\_buf\[wd\_dev\_name\_max\_len\];  
wd\_ustr name;  
wd\_ustr\_init\_em(&name,name\_buf,wd\_dev\_name\_max\_len);

// 如果注册了，就应该得到通知  
wd\_printf0("notify: a file sys have been acitved!!! rn");

// 得到文件系统对象的名字，然后打印出来  
wd\_obj\_get\_name(dev,&name);  
wd\_printf0("notify : file sys name = %wZrn",&name);

if(active)  
\{  
wd\_printf0("notify: try to attach.rn");  
// ... 请在这里绑定文件系统的控制设备  
\}  
else  
\{  
wd\_printf0("notify: unactive.rn");  
// ...  
\}  
\}

应该如何绑定一个文件系统CDO?我们在下面的章节再详细描述。

现在我们应该再在wd\_main函数中加上下边的内容：

if(wdff\_reg\_notify(driver,my\_fs\_notify) != wd\_stat\_suc)  
\{  
wd\_printf0("error: reg notify failed.rn");  
wd\_fio\_disp\_release(driver);  
wd\_dev\_del(g\_cdo);  
g\_cdo = wd\_null;  
return wd\_stat\_insufficient\_res;  
\};

wd\_printf0("success: reg notify ok.n");

我们再次回顾一下，wd\_main中，应该做哪些工作。

a.生成一个控制设备。当然此前你必须给控制设置指定名称。

b.设置Dispatch Functions.

c.设置Fast Io Functions.

d.编写一个my\_fs\_notify回调函数，在其中绑定刚激活的FS CDO.

e.使用wdff\_reg\_notify调用注册这个回调函数。  
5.绑定FS CDO,文件系统识别器，设备扩展

上一节讲到我们打算绑定一个刚刚被激活的FS CDO.前边说过简单的调用wd\_dev\_attach可以很容易的绑定这个设备。但是，并不是每次my\_fs\_notify调用发现有新的fs激活，我就直接绑定它。

首先判断是否我需要关心的文件系统类型。我用下面的函数来获取设备类型。

// ------------------wdf.h中的内容-------------------  
\_inline wd\_dev\_type wd\_dev\_get\_type(in wd\_dev \*dev)  
\{  
return dev->DeviceType;  
\}

文件系统的CDO的设备类型有下边的几种可能，你的过滤驱动可能只对其中某些感兴趣。

enum \{  
wd\_dev\_disk\_fs = FILE\_DEVICE\_DISK\_FILE\_SYSTEM,  
wd\_dev\_cdrom\_fs = FILE\_DEVICE\_CD\_ROM\_FILE\_SYSTEM,  
wd\_dev\_network\_fs = FILE\_DEVICE\_NETWORK\_FILE\_SYSTEM  
\};

你应该自己写一个函数来判断该fs是否你所关心的。

// -------------一个函数，判断是否我所关心的fs---------------  
wd\_bool my\_care(wd\_ulong type)  
\{  
return (((type) == wd\_dev\_disk\_fs) ||  
((type) == wd\_dev\_cdrom\_fs) ||  
((type) == wd\_dev\_network\_fs));  
\}

下一个问题是我打算跳过文件系统识别器。文件系统识别器是文件系统驱动的一个很小的替身。为了避免没有使用到的文件系统驱动占据内核内存，windows系统不加载这些大驱动，而代替以该文件系统驱动对应的文件系统识别器。当新的物理存储媒介进入系统，io管理器会依次的尝试各种文件系统对它进行“识别”。识别成功，立刻加载真正的文件系统驱动，对应的文件系统识别器则被卸载掉。对我们来说，文件系统识别器的控制设备看起来就像一个文件系统控制设备。但我们不打算绑定它。

分辨的方法是通过驱动的名字。凡是文件系统识别器的驱动对象的名字（注意是DriverObject而不是DeviceObject!）都为“FileSystem/Fs\_Rec”.

//-------------------用这些代码来跳过文件系统识别器----------------------  
wd\_wchar name\_buf\[wd\_dev\_name\_max\_len\];  
wd\_ustr name,tmp;

wd\_ustr\_init\_em(&name,name\_buf,wd\_dev\_name\_max\_len);  
wd\_ustr\_init(&tmp,L"/FileSystem/Fs\_Rec");

// 我不绑定识别器。所以如果是识别器，我直接返回成功。查看是否是识别  
// 器的办法是看是否是FileSystemFs\_Rec的设备。  
wd\_obj\_get\_name(wd\_dev\_drv(fs\_dev),&name);  
if(wd\_ustr\_cmp(&name,&tmp,wd\_true) == 0)  
\{  
wd\_printf0("attach fs dev:is a recogonizer.rn");  
return wd\_stat\_suc;  
\}

wd\_printf0("attach fs dev: not a recogonizer.rn");

接下来我将要生成我的设备。这里要提到设备扩展的概念。设备对象是一个数据结构，为了表示不同的设备，里边将有一片自定义的空间，用来给你记录这个设备的特有信息。我们为我们所生成的设备确定设备扩展如下：

// 文件过滤系统驱动的设备扩展  
typedef struct \_my\_dev\_ext  
\{  
// 我们绑定的文件系统驱动  
wd\_dev \* attached\_to;  
// 上边这个设备的设备名。  
wd\_ustr dev\_name;  
// 这是上边的unicode字符串的缓冲区  
wd\_wchar name\_buf\[wd\_dev\_name\_max\_len\];  
\} my\_dev\_ext;

之所以如此简单，是因为我们现在还没有多少东西要记录。只要记得自己绑定在哪个设备上就好了。如果以后需要更多的信息，再增加不迟。扩展空间的大小是在wdf\_dev\_create（也就是这个设备生成）的时候指定的。得到设备对象指针后，我用下面这个函数来获取设备扩展指针：

// --------------wdf.h中的内容------------------  
\_inline wd\_void \* wd\_dev\_ext(wd\_dev \*dev)  
\{  
return (dev->DeviceExtension);  
\}

生成设备后，为了让系统看起来，你的设备和原来的设备没什么区别，你必须设置一些该设备的标志位与你所绑定的设备相同。

\_inline wd\_void wd\_dev\_copy\_flag(wd\_dev \*new\_dev,  
wd\_dev \*old\_dev)  
\{  
if(old\_dev->Flags & DO\_BUFFERED\_IO)  
new\_dev->Flags &= DO\_BUFFERED\_IO;  
if(old\_dev->Flags & DO\_DIRECT\_IO)  
new\_dev->Flags &= DO\_DIRECT\_IO;  
if (old\_dev->Characteristics & FILE\_DEVICE\_SECURE\_OPEN)  
new\_dev->Characteristics &= FILE\_DEVICE\_SECURE\_OPEN;  
\}

DO\_BUFFERED\_IO，DO\_DIRECT\_IO这两个标志的意义在于外部向这些设备发送读写请求的时候，所用的缓冲地址将有所不同。这点以后在过滤文件读写的时候再讨论。现在一切事情都搞完，你应该去掉你的新设备上的DO\_DEVICE\_INITIALIZING标志，以表明的的设备已经完全可以用了。

// --------------wdf.h中的内容------------------  
\_inline wd\_void wd\_dev\_clr\_init\_flag(wd\_dev \*dev)  
\{  
dev->Flags &= ~DO\_DEVICE\_INITIALIZING;  
\}

现在我写一个函数来完成以上的这个过程。你只要在上一节中提示的位置调用这个函数，就完成对文件系统控制设备的绑定了。

//-----------绑定一个文件系统驱动设备-------------------------  
wd\_stat my\_attach\_fs\_dev(wd\_dev \*fs\_dev)  
\{  
wd\_wchar name\_buf\[wd\_dev\_name\_max\_len\];  
wd\_ustr name,tmp;  
wd\_dev \*new\_dev;  
wd\_stat status;  
my\_dev\_ext \*ext;  
wd\_ustr\_init\_em(&name,name\_buf,wd\_dev\_name\_max\_len);  
wd\_ustr\_init(&tmp,L"/FileSystem/Fs\_Rec");

// 如果不是我关心的类型，我直接返回成功  
if(!my\_care(wd\_dev\_get\_type(fs\_dev)))  
\{  
wd\_printf0(("attach fs dev:not a cared type.rn"));  
return wd\_stat\_suc;  
\}

wd\_printf0("attach fs dev: is my cared type.rn");

// 我不绑定识别器。所以如果是识别器，我直接返回成功。查看是否是识别  
// 器的办法是看是否是FileSystem/Fs\_Rec的设备。  
wd\_obj\_get\_name(wd\_dev\_drv(fs\_dev),&name);  
if(wd\_ustr\_cmp(&name,&tmp,wd\_true) == 0)  
\{  
wd\_printf0("attach fs dev:is a recogonizer.rn");  
return wd\_stat\_suc;  
\}

wd\_printf0("attach fs dev: not a recogonizer.rn");

// 现在来生成一个设备用来绑定  
status = wd\_dev\_create(g\_drv,sizeof(my\_dev\_ext),NULL,  
wd\_dev\_get\_type(fs\_dev),  
0,wd\_false,&new\_dev);  
if(!wd\_suc(status))  
\{  
wd\_printf0("attach fs dev: dev create failed.rn");  
return status;  
\}

wd\_printf0("attach fs dev: create dev success.rn");

// 接着设置设备的各种标志与之要绑定的标志一致  
wd\_dev\_copy\_flag(new\_dev,fs\_dev);

ext = (my\_dev\_ext \*)wd\_dev\_ext(new\_dev);

wd\_printf0("begin to attach.rn");  
status = wd\_dev\_attach(new\_dev,fs\_dev,&ext->attached\_to);  
wd\_printf0("attach over.status = %8xrn",status);

if(!wd\_suc(status))  
\{  
wd\_printf0("attach fs dev: dev attach failed.rn");  
UNREFERENCED\_PARAMETER(new\_dev);  
wd\_dev\_del(new\_dev);  
return status;  
\}

wd\_printf0("attach fs dev: attach %wZ succeed.rn",&name);

wd\_ustr\_init\_em(&ext->dev\_name,ext->name\_buf,wd\_dev\_name\_max\_len);  
wd\_ustr\_copy(&ext->dev\_name,&name);  
wd\_dev\_clr\_init\_flag(new\_dev);

return status;  
\}  
6.IRP的传递，File System Control Dispatch

我们现在不得不开始写dispatch functions.因为你的设备已经绑定到文件系统控制设备上去了。windows发给文件系统的请求发给你的驱动。如果你不能做恰当的处理，你的系统的就会崩溃。

最简单的处理方式是把请求不加改变的传递到我们所绑定的设备上去。如何获得我们所绑定的设备？上一节已经把该设备记录在我们的设备扩展里。

//------------我用这个函数快速得到我所绑定的设备-----------  
// 得到绑定的设备  
\_inline wd\_dev \*my\_dev\_attached(wd\_dev \*dev)  
\{  
return ((wdff\_dev\_ext \*)wd\_dev\_ext(dev))->attached\_to;  
\}

如何传递请求？使用IoCallDriver,该调用的第一个参数是设备对象指针，第二个参数是IRP指针。

一个IRP拥有一组IO\_STACK\_LOCATION.前面说过IRP在一个设备栈中传递。IO\_STACK\_LOCATION是和这个设备栈对应的。用于保存IRP请求在当前设备栈位置中的部分参数。如果我要把请求往下个设备传递，那么我应该把当前IO\_STATCK\_LOCATION复制到下一个。

我写了一些函数来处理IO\_STACK\_LOCATION,另外wd\_irp\_call用来包装IoCallDriver的功能。

//---------------------wdf.h中的内容----------------------------  
typdef wd\_irpsp PIO\_STACK\_LOCAION;

\_inline wd\_irpsp \*wd\_cur\_io\_stack(wd\_irp \*irp)  
\{  
return IoGetCurrentIrpStackLocation(irp);  
\}

\_inline wd\_void wd\_skip\_io\_stack(wd\_pirp irp)  
\{  
IoSkipCurrentIrpStackLocation(irp);  
\}

\_inline wd\_void wd\_copy\_io\_stack(wd\_irp \*irp)  
\{  
IoCopyCurrentIrpStackLocationToNext(irp);  
\}

\_inline wd\_stat wd\_irp\_call(wd\_dev \*dev,wd\_pirp irp)  
\{  
return IoCallDriver(dev,irp);  
\}

有了上边这些，我现在可以写一个默认的Dispatch Functions.

// 默认的处理很简单，忽略当前调用栈，直接发送给绑定设备  
wd\_stat my\_disp\_default(in wd\_dev \*dev,in wd\_pirp irp)  
\{  
wd\_dev \*attached\_dev;  
if(!is\_my\_dev(dev))  
return wd\_irp\_failed(irp,wd\_stat\_invalid\_dev\_req);  
if(is\_my\_cdo(dev))  
return wd\_irp\_failed(irp,wd\_stat\_invalid\_dev\_req);  
attached\_dev = my\_dev\_attached(dev);  
if(!attached\_dev)  
return wd\_irp\_failed(irp,wd\_stat\_invalid\_dev\_req);  
wd\_skip\_io\_stack(irp);  
return wd\_irp\_call(attached\_dev,irp);  
\}

上边有一个函数is\_my\_dev来判断是否我的设备。这个判断过程很简单。通过dev可以得到DriverObject指针，判断一下是否我自己的驱动即可。is\_my\_cdo()来判断这个设备是否是我的控制设备，不要忘记在wd\_main()中我们首先生成了一个本驱动的控制设备。实际这个控制设备还不做任何事情，所以对它发生的任何请求也是非法的。返回错误即可。wd\_irp\_failed这个函数立刻让一个irp失败。其内容如下：

// 这个函数可以立刻失败掉一个irp  
\_inline wd\_stat wd\_irp\_failed(wd\_pirp irp,wd\_stat status\_error)  
\{  
irp->IoStatus.Status = status\_error;  
irp->IoStatus.Information = 0;  
return wd\_irp\_over(irp);  
\}

如此一来，本不改发到我的驱动的irp，就立刻返回错误非法请求。但是实际上这种情况是很少发生的。

如果你现在想要你的驱动立刻运行，让所有的dispacth functions都调用my\_disp\_default.这个驱动已经可以绑定文件系统的控制设备，并输出一些调试信息。但是还没有绑定Volume.所以并不能直接监控文件读写。

对于一个绑定文件系统控制设备的设备来说，其他的请求直接调用上边的默认处理就可以了。重点需要注意的是上边曾经挂接IRP\_MJ\_FILE\_SYSTEM\_CONTROL的dispatch处理的函数my\_disp\_file\_sys\_ctl().

IRP\_MJ\_FILE\_SYSTEM\_CONTROL这个东西是IRP的主功能号。每个主功能号下一般都有次功能号。这两个东西标示一个IRP的功能。

主功能号和次功能号是IO\_STACK\_LOCATION的开头两字节。

//----------------我重新定义的次功能号-------------------  
enum \{  
wd\_irp\_mn\_mount = IRP\_MN\_MOUNT\_VOLUME,  
wd\_irp\_mn\_load\_filesys = IRP\_MN\_LOAD\_FILE\_SYSTEM,  
wd\_irp\_mn\_user\_req = IRP\_MN\_USER\_FS\_REQUEST  
\};  
enum \{  
wdf\_fsctl\_dismount = FSCTL\_DISMOUNT\_VOLUME  
\};

要得到功能号，要先得到当前的IO\_STACK\_LOCATION,这个上边已经有函数wd\_cur\_io\_stack,相信这个不能难倒你。

当有Volumne被Mount或者dismount,你写的my\_disp\_file\_sys\_ctl()就被调用。具体的判断方法，就见如下的代码了：

// 可以看到分发函数中其他的函数处理都很简单，但是file\_sys\_ctl的  
// 处理会比较复杂。我们已经在notify函数中绑定了文件系统驱动的控  
// 制对象。当文件系统得到实际的介质的时候，会生成新的设备对象，  
// 这种设备称为卷（Volume），而这种设备是在file\_sys中的mount中生  
// 成的，而且也是unmount中注销掉的。我们捕获这样的操作之后，就必  
// 须生成我们的设备对象，绑定在这样的“卷”上，才能绑定对这个卷  
// 上的文件的操作。  
wd\_stat my\_disp\_file\_sys\_ctl(in wd\_dev \*dev,in wd\_pirp irp)  
\{  
wd\_dev \*attached\_dev;  
wd\_io\_stack \*stack = wd\_cur\_io\_stack(irp);  
if(!is\_my\_dev(dev))  
return wd\_irp\_failed(irp,wd\_stat\_invalid\_dev\_req);  
switch(wd\_irpsp\_minor(stack))  
\{  
case wd\_irp\_mn\_mount:  
// 在这里，一个Volume正在Mount  
return my\_fsctl\_mount(dev,irp);  
case wd\_irp\_mn\_load\_filesys:  
return my\_fsctl\_load\_fs(dev,irp);  
case wd\_irp\_mn\_user\_req:  
\{  
switch(wd\_irpsp\_fs\_ctl\_code(stack))  
\{  
case wdf\_fsctl\_dismount:  
// 在这里，一个Volume正dismount  
return my\_fsctl\_dismount(dev,irp);  
\}  
\}  
\}  
wd\_skip\_io\_stack(irp);  
attached\_dev = my\_dev\_attached(dev);  
return wd\_irp\_call(attached\_dev,irp);  
\}

你发现你又得开始写两个新的函数，my\_fsctl\_mount()和my\_fsctl\_dismount()，来处理卷的Mount和Dismount.显然，你应该在其中生成设备或者删除，绑定或者解除绑定。很快，你就能完全监控所有的卷了。

这样做是动态监控所有的卷的完美的解决方案。

如果是在xp以上，有一个调用可以获得一个文件系统上已经被Mount的卷。但是2000下不能使用。所以我们没有使用那个方法。何况仅仅得到已经Mount的卷也不是我想要的。

这里另外还有一个my\_fsctl\_load\_fs函数。发生于IRP\_MN\_LOAD\_FILESYS。这个功能码我只做一点点解释：当一个文件识别器（见上文）决定加载真正的文件系统的时候，会产生一个这样的irp。

你现在可以修改你的驱动，使插入拔出u盘的时候，在Volume加载卸载时候输出调试信息。回首一下我们的脉络：

a.生成一个控制设备。当然此前你必须给控制设置指定名称。

b.设置Dispatch Functions.

c.设置Fast Io Functions.

d.编写一个my\_fs\_notify回调函数，在其中绑定刚激活的FS CDO.

e.使用wdff\_reg\_notify调用注册这个回调函数。

f.编写默认的dispatch functions.

e.处理IRP\_MJ\_FILE\_SYSTEM\_CONTROL,在其中监控Volumne的Mount和Dismount.

f.下一步自然是绑定Volumne了，请听下回分解。  
  
7.IRP完成函数,中断级,如何超越中断级别的限制

先讨论一下Volumne设备是如何得到的.首先看以下几个函数:

// ------------------wdf.h 中的内容 -------------------------  
typedef VPB wd\_vpb;  
\_inline wd\_vpb \* wd\_dev\_vbp(wd\_dev \*dev)  
\{  
return dev->Vpb;  
\}

\_inline wd\_dev \* wd\_vbp\_dev(wd\_vpb \*vpb)  
\{  
return vpb->DeviceObject;  
\}

VPB是Volume parameter block.一个数据结构.它的主要作用是把实际存储媒介设备对象和文件系统上的卷设备对象联系起来.

wd\_dev\_vbp可以让你从一个Storage Device Object得到一个VPB,而wd\_vbp\_dev这个函数可以得到这个VPB所对应的Volmue设备.

现在首先要得到Storage Device Object.实际上这个东西保存在当前IO\_STACK\_LOCATION中.

// ------------------wdf.h 中的内容 -----------------------  
\_inline wd\_dev \*wd\_irpsp\_mount\_storage(wd\_io\_stack \*irpsp)  
\{  
return irpsp->Parameters.MountVolume.Vpb->RealDevice;  
\};

那么,从irp出发,我最终可以通过以下的方式得到Volumue设备:

wd\_irpsp \*irpsp = wd\_cur\_io\_stack(irp);  
wd\_dev \*storage\_dev = wd\_irpsp\_mount\_storage(irp);  
wd\_vpb \*vpb = wd\_dev\_vbp(storage\_dev);  
wd\_dev \*volume\_dev = wd\_vbp\_dev(vpb);

不过实际情况并不这么简单.这里的IRP是一个MOUNT请求.而volume设备对象实际上是这个请求完成之后的返回结果.因此,在这个请求还没有完成之前,我们就试图去获得Volume设备对象,当然是竹篮打水一场空了.

这里,你可以直接拷贝当前IO\_STACK\_LOCATION,然后向下发送请求,但在此之前,要先给irp分配一个完成函数.irp一旦完成,你的完成函数将被调用.这样的话,你可以在完成函数中得到Volume设备,并实施你的绑定过程.

这里要讨论一下中断级别的问题.常常碰到人问某函数只能在Passive Level调用是什么意思.总之我们的任何代码执行的时候,总是处在某个当前的中断级之中.某些系统调用只能在低级别中断级中执行.请注意,如果一个调用可以在高处运行,那么它能在低处运行,反过来则不行.

我们需要知道的只是我们关心Passive Level和Dispatch Level.而且Dispatch Level的中断级较高.一般ddk上都会标明,如果注明irq level>=dispatch,那么你就不能在passive level的代码中调用它们了.

那么你如何判断当前的代码在哪个中断级别中呢?我一般是这么判断的:如果你的代码执行是由于应用程序(或者说上层)的调用而引发的,那么应该在Passive Level.如果你的代码执行是由于下层硬件而引发的,那么则可能在dispatch level.

希望不要机械的理解我的话!以上只是极为粗略的便于记忆的理解方法.实际的应用应该是这样的:所有的dispatch functions由于是上层发来的irp而导致的调用,所以应该都是Passive Level,在其中你可以调用绝大多数系统调用.而如网卡的OnReceive,硬盘读写完毕,返回而导致的完成函数,都有可能在Dispatch级.注意都是有可能,而不是绝对是.但是一旦有可能,我们就应该按就是考虑.

好,现在我们发现,我们已经注册了完成函数,并且这个函数执行中可能是dispatch level.

现在面临的问题是,我们已经决定在完成函数中调用 IoAttachDeviceToDeviceStack来绑定Volume.而DDK说明有:Callers of IoAttachDeviceToDeviceStack must be running at IRQL <= DISPATCH\_LEVEL.

实际上前边说过有IoAttachDeviceToDeviceStackSafe,这个调用可以在Dispatch level进行.无奈这个调用仅仅出现在Xp以上的系统中.

超越中断级别的限制有几种方法.第一种是自己生成一个系统线程来完成此事.系统线程将保证在Passive Level中运行.另一种方法就是把自己的任务插入Windows工作者线程,这会使你的任务迟早得到执行.如果你的任务比较小,可以实行第二种方法.对系统来说比较省事,对程序员来说则反正都是麻烦.

我做了以下几个函数专门来插入任务到工作者线程.  
//---------------wdf.h 中的内容 ------------------------  
typedef WORK\_QUEUE\_ITEM wd\_work\_item;  
typedef PWORKER\_THREAD\_ROUTINE wd\_work\_func;  
// 任务的初始化  
\_inline wd\_void wd\_work\_init(wd\_work\_item \*item,  
wd\_work\_func worker,  
wd\_void \*context)  
\{  
ExInitializeWorkItem(item,worker,context);  
\}

// 三种任务队列  
typedef enum \_wd\_work\_quque\_type\{  
wd\_work\_crit = CriticalWorkQueue,  
wd\_work\_delay = DelayedWorkQueue,  
wd\_work\_hyper = HyperCriticalWorkQueue  
\} wd\_work\_queue\_type;

\_inline wd\_void wd\_work\_queue(in wd\_work\_item \*item,  
in wd\_work\_queue\_type type)  
\{  
ExQueueWorkItem(item,(WORK\_QUEUE\_TYPE)type);  
\}

\_inline wd\_void wd\_work\_run(in wd\_work\_item \*item)  
\{  
(item->WorkerRoutine)(item->Parameter);  
\}

任务是一个数据结构,已经被我重定义为wd\_work\_item,wd\_work\_init能初始化它.初始化的时候你只需要填写一个你的任务的函数.同时一个context用来记录上下相关参数.(这是个空指针,你可以只想你任何想要的参数类型).

一般这个任务会自动执行,但是有时我们也想不插入队列,我们自己执行它.那么调用wd\_work\_run即可.

然后调用wd\_work\_queque插入工作者队列,之后会被执行.插入类型这里选择wd\_work\_delay.

希望你没有被这一串东西搞糊涂.现在我会写一个"设置完成函数"的函数.执行后,自动在Passive Level级执行你的完成函数.希望不会把你搞得晕头转向的:).

// 完成例程上下文。好几个fsctl需要注册完成例程。而例程中的工作可能  
// 只能在passive level中运行，因此不得不加入一个work\_item,把任务塞  
// 入工作线程等待完成  
typedef struct \_my\_fsctl\_comp\_con  
\{  
wd\_work\_item work;  
wd\_dev \*dev;  
wd\_irp \*irp;  
wd\_dev \*new\_dev; // 这个元素仅仅用于mount的时候。因为我  
// 们要生成一个新设备来绑定vdo.  
\} my\_fsctl\_comp\_con;

wd\_bool my\_fsctl\_set\_comp(wd\_dev \*dev,  
wd\_irp \*irp,  
wd\_dev \*new\_dev,  
wd\_irp\_comp\_func complete,  
wd\_work\_func work\_complete)  
\{  
my\_fsctl\_comp\_con \*context;  
context = (wdff\_fsctl\_comp\_con \*)wd\_malloc(wd\_false,  
sizeof(wdff\_fsctl\_comp\_con));  
if(context == NULL)  
\{  
wd\_printf0("fsctl set comp: failed to malloc context.rn");  
return wd\_false;  
\}

// 初始化工作细节  
wd\_work\_init(&context->work,  
work\_complete,  
context);

context->dev = dev;  
context->irp = irp;  
context->new\_dev = new\_dev;

// 设置irp完成例程  
wd\_irp\_comp(irp,complete,context);

return wd\_true;  
\}

// 以下函数作为以上complete的参数被使用  
wd\_stat my\_fsctl\_comp(in wd\_dev \*dev,  
in wd\_irp \*irp,  
in wd\_void \*context)  
\{  
wd\_printf0("fsctl\_comp: come in!!!rn");  
UNREFERENCED\_PARAMETER(dev);  
UNREFERENCED\_PARAMETER(irp);  
// 判断当前中断级  
if(wd\_get\_cur\_irql() > wd\_irql\_passive)  
\{  
wd\_printf0("fsctl\_comp:into quque!!!rn");  
// 如果在passive更低的中断级别，必须插入延迟队列中运行  
wd\_work\_queue((wd\_work\_item \*)context,wd\_work\_delay);  
\}  
else  
\{  
// 否则可以直接执行  
wd\_printf0("fsctl\_comp:run directly!!!rn");  
wd\_work\_run((wd\_work\_item \*)context);  
\}  
return wd\_stat\_more\_processing;  
\}

我想以上的过程应该已经可以理解了!注册了基本的完成历程complete函数(也就是我最后写的函数my\_fsctl\_comp后),irp执行完毕回调my\_fsctl\_comp,而我事先已经把已经做好的任务(wd\_work\_item)写在上下文指针中(context)中.一回调这个函数,我就wd\_work\_queque插入队列.结果wd\_work\_item中记录的work\_complete函数显然会在Passive level中执行.我们的系统也将保持稳定.

work\_complete函数将从context上下文指针中得到足够的参数,来完成对Volume的绑定.

希望你没有被弄昏头:),我们下回再分解.  
8 终于绑定了Volume,读操作的捕获与分析

上文已经讲到绑定Volume之前的关键操作.我们一路逢山开路,逢水架桥,相信你从中也学到了驱动开发的基本方法.以后的工作,无非灵活运用这些方法而已.前边已经举出过绑定FS CDO的操作.那么现在绑定Volume,无非照猫画虎,而以后的教程中,我也不会逐一详尽的列举出细节的代码了.

但是绑定Volume的过程中,还是有些地方需要稍微注意:

1.获得Storage Device Object的问题.前边已经说过,为了得到Vbp,我要先得到Storage Device Object,方法如下:

wd\_irpsp \*irpsp = wd\_cur\_io\_stack(irp);  
wd\_dev \*storage\_dev = wd\_irpsp\_mount\_storage(irpsp);

这是在Irp完成之前,这样调用是对的.但是到完成函数中,情况就不同了.因为这个irpsp下保存的storage\_dev可能被修改掉(这并非我自己调试的结果,而是阅读sfilter代码中的注释而得到的信息).既然有这个可能,我们只好先把storage\_dev这个东西保存下来.实际上,可以在Device扩展增加一个项目storage\_dev.在irp完成之前,生成我要绑定的设备(只是不绑定),并把这个设备指针传入完成函数上下文.

这样在完成函数中,我就能得到这个storage\_dev,最终找到Volmue设备的指针,此时进行绑定就可以了.

2.绑定的过程,未必一次就能成功.因为Volmue设备的Initilize标记被清除之前,我的绑定是不能成功的.对这种情况,我抄袭了sfilter中的方法,就是延时500毫秒,然后再尝试.一共尝试8次.

我包装了一个函数用来延时:

\_inline wd\_void wd\_delay\_milli\_se(wd\_ulong milli\_sec)  
\{  
wd\_llong delay = milli\_sec\*(-10)\*1000;  
wd\_lgint interval;  
interval.QuadPart = delay;  
KeDelayExecutionThread(KernelMode,FALSE,&interval);  
\}

这个函数的参数是毫秒,但是我并不清楚有多小的精度.

其他的就不说了,祝愿你的运气足够的好.现在我们处理IRP\_MJ\_READ,如果你已经绑定了Volume,那么显然,发送给Volume的请求就会先发送给你.处理IRP\_MJ\_READ,能捕获文件的读操作.

进入你的my\_disp\_read()函数(假设你注册了这个函数来处理IRP\_MJ\_READ,请见前面关于分发函数的讲述),首先判断这个Dev是不是绑定Volume的设备.如果是,那么就是一个读文件的操作.

如何判断?记得我们先绑定Volume的时候,在我们的设备扩展中设置了storage\_dev,如果不是(比如是FS CDO,我们没设置过),那么这么判断即可:

if(is\_my\_dev(dev))  
\{  
my\_dev\_ext \*ext = (my\_dev\_ext \*)wd\_dev\_ext(dev);  
if(ext->storage\_dev)  
\{  
// ... 到这里说明是对文件的读操作  
\}  
\}

其他的情况不需要捕获,请直接传递到下层.

读请求的IRP情况非常复杂,请有足够的心理准备.并不要过于依赖帮助,最好的办法就是自己打印IRP的各个细节,亲自查看文件读操作的完成过程.而我现在所说的东西,换另一我未尝试过的版本的windows是否还正确,我也无法下断言.

不过基本的东西是不会变的.

首先关心被读写的文件.IRP下有一个FileObject指针.这个东西指向一个文件对象.你可以得到文件对象的名字,这个名字是没有盘符的文件全路径.有人要问那么盘符如何获得?因为你已经知道了Volume,前边已经说过盘符不过是Volume的符号连接名,那么想要真正的全路径问题应该也不大了.

我现在偷一个懒,我现在只打印没有盘符的路径名.先写一个函数,从IRP得到FileObject.

\_inline wd\_file \*wd\_irp\_file(wd\_irpsp \*irpsp)  
\{  
return irpsp->FileObject;  
\}

然后写一个函数来获得文件名.这个函数参考的是FileMon的代码.

wd\_void wd\_file\_get\_name(in wd\_file \*file,  
in out wd\_ustr \*name)  
\{  
if( file->FileName.Buffer &&  
!(file->Flags & FO\_DIRECT\_DEVICE\_OPEN) )  
RtlCopyUnicodeString(name,&file->FileName);  
\}

接下来有必要得到读文件的偏移量.和vxd的文件系统驱动不同,2000下文件系统得到的偏移量似乎都是从文件起始位置开始计算的.偏移量是一个LARGE\_INTEGER.因为现在确实有些文件已经超过了长整型所能表示的大小.

以下函数用来得到偏移量.wd\_lgint是经过重定义的LARGE\_INTEGER.

\_inline wd\_lgint wd\_irp\_read\_offset(wd\_irpsp \*irpsp)  
\{  
return irpsp->Parameters.Read.ByteOffset;  
\}

注意以上的参数不是irp.是当前IO\_STACK\_LOCATION,也就是我的wd\_irpsp.前面已经讲述过如何获取当前irpsp.

此外我还希望能得到我所读到的数据.这要注意,我们捕获这个请求的时候,这个请求还没有完成.既然没有完成,当然无数据可读.如果要获取,那就设置完成函数,在完成函数中完成请求.

完成Irp的时候忽略还是拷贝当前IO\_STACK\_LOCATION,返回什么STATUS,以及完成函数中如何结束Irp,是不那么容易搞清楚的一件事情.我想做个总结如下:

1.如果对irp完成之后的事情无兴趣,直接忽略当前IO\_STACK\_LOCATION,(对我的程序来说,调用wd\_ship\_cur\_io\_stack),然后向下传递请求,返回wd\_irp\_call()所返回的状态.

2.不但对irp完成之后的事情无兴趣,而且我不打算继续传递,打算立刻返回成功或失败.那么我不用忽略或者拷贝当前IO\_STACK\_LOCATION,填写参数后调用IoCompleteRequest,并返回我想返回的结果.

3.如果对irp完成之后的事情有兴趣,并打算在完成函数中处理,应该首先拷贝当前IO\_STACK\_LOCATION(wd\_copy\_cur\_io\_stack()),然后指定完成函数,并返回wd\_irp\_call()所返回的status.完成函数中,不需要调用IoCompleteRequest!直接返回Irp的当前状态即可.

4.同3的情况,有时候,会把任务塞入系统工作者线程或者希望在另外的线程中去完成Irp,那么完成函数中应该返回wd\_stat\_more\_processing,此时完成Irp的时候应该调用IoCompleteRequest.另一种类似的情况是在dispatch函数中等待完成函数中设置事件,那么完成函数返回wd\_stat\_more\_processing,dispatch函数在等待结束后调用IoCompleteRequest.

前边已经提到过设备的DO\_BUFFERED\_IO,DO\_DIRECT\_IO这两个标记.情况是3种:要么是两个标记中其中一个,要么是一个都没有.Volume设备出现DO\_BUFFERED的情况几乎没有,我碰到的都是一个标记都没有.DO\_DIRECT\_IO表示数据应该返回到Irp->MdlAddress所指向的MDL所指向的内存.在无标记的情况下,表明数据读好,请返回到Irp->UseBuffer中即可.

UseBuffer是一个只在当前线程上下文才有效的地址.如果你打算按这个地址获得数据,你最好在当前线程上下文中.完成函数与my\_disp\_read并非同一个线程.所以在完成函数中按这个地址去获取数据是不对的.如何回到当前线程?我采用简单的办法.在my\_disp\_read中设置一个事件,调用wd\_irp\_call(即ddk中的IoCallDriver)之后开始等待这个事件.而在完成函数中设置这个事件.这样等待结束的时候,刚好Irp已经完成,我也回到了我的my\_disp\_read原来的线程.

wd\_stat my\_disp\_read(in wd\_dev \*dev,in wd\_pirp irp)  
\{  
my\_dev\_ext \*ext;  
wd\_dev \*attached\_dev;  
wd\_irpsp \*irpsp = wd\_cur\_io\_stack(irp);  
wd\_stat status;  
wd\_file \*file = wd\_irp\_file(irpsp);  
wd\_lgint offset = wd\_irp\_read\_offset(irpsp);  
wd\_size length = wd\_irp\_read\_length(irpsp);  
wd\_wchar name\_buf\[512\];  
wd\_ustr name;  
wd\_event event;

// 检查是否我的设备  
if(!is\_my\_dev(dev))  
return wd\_irp\_failed(irp,wd\_stat\_invalid\_dev\_req);

ext = (wdff\_dev\_ext \*)wd\_dev\_ext(dev);  
attached\_dev = wdff\_dev\_attached(dev);

// 到这里判断得到这是对一个被绑定了的卷的读操作  
if(ext->storage\_dev == NULL)  
\{  
wd\_skip\_io\_stack(irp);  
return wd\_irp\_call(attached\_dev,irp);  
\}

// 到了这里，确认是对文件的读  
wd\_ustr\_init\_em(&name,name\_buf,512);  
if(file)  
wd\_file\_get\_name((wd\_void \*)file,&name);  
else  
\{  
wd\_skip\_io\_stack(irp);  
return wd\_irp\_call(attached\_dev,irp);  
\}

wd\_printf1("xxx irp flag = %xrn",wd\_irp\_flags(irp));  
wd\_printf1("xxx file read: %wZ rn",&name);  
wd\_printf1("xxx read offset = %ld ",offset);  
wd\_printf1("xxx read length = %ldrn",length);

// 以上我已经打印了读请求的相关参数,下面我希望得到读出的内容  
wd\_event\_init(&event);  
// 先拷贝当前io\_stack,然后再指定完成例程

wd\_copy\_io\_stack(irp);  
wd\_irp\_set\_comp(irp,my\_disp\_read\_comp,&event);

// 对实际设备呼叫irp  
status = wd\_irp\_call(attached\_dev,irp);  
if(status == wd\_stat\_pending)  
wd\_event\_wait(&event);

wd\_printf1("test read end:status = %x rn",status);  
// 如果此时status = 0,那么内容应该就在Irp->UserBuffer中,请自己打印...  
wd\_printf1("test read end:read length = %ldrn",wd\_irp\_infor(irp));

return wd\_irp\_over(irp);  
\}

然后是my\_disp\_read\_comp的内容,可以看见只是简单的设置事件,然后返回wd\_stat\_more\_processing.

wd\_stat my\_disp\_read\_comp(in wd\_dev \*dev,  
in wd\_irp \*irp,  
in wd\_void \*context)  
\{  
wd\_event \* event=  
(wd\_event \*)context;  
UNREFERENCED\_PARAMETER(dev);  
UNREFERENCED\_PARAMETER(irp);  
wd\_event\_set(event);  
return wd\_stat\_more\_processing;  
\}

尽管已经写了很多,尽管我们得到了读过程的所有参数和结果,我们依然不知道如果自己写一个文件系统,该如何完成读请求,或者过滤驱动中,如何修改读请求等等.我们下一节继续讨论读操作.  
9 完成读操作

除非是一个完整的文件系统，完成读操作似乎是不必要的。过滤驱动一般只需要把请求交给下层的实际文件系统来完成。但是有时候比如加解密操作，我希望从下层读到数据，解密后，我自己来完成这一IRP请求。

这里要谈到IRP的minor function code.以前已经讨论到如果major function code 是IRP\_MJ\_READ则是Read请求。实际上有些主功能号下面有一些子功能号，如果是IRP\_MJ\_READ,检查其MINOR,应该有几种情况：IRP\_MN\_NORMAL,IRP\_MN\_MDL,IRP\_MN\_MDL|IRP\_COMPLETE(这个其实就是IRP\_MN\_MDL\_COMPLETE).还有其他几种情况，资料上有解释，但是我没自己调试过，也就不胡说了。只拿自己调试过的几种情况来说说。

先写个函数，得到次功能号。

\_inline wd\_uchar wd\_irpsp\_minor(wd\_io\_stack \*irpsp)  
\{  
return irpsp->MinorFunction;  
\}

enum \{  
wd\_mn\_mdl = IRP\_MN\_MDL,  
wd\_mn\_mdl\_comp = IRP\_MN\_MDL\_COMPLETE,  
wd\_mn\_normal = IRP\_MN\_NORMAL  
\};

希望你喜欢我重新定义过的次功能号码。

wd\_mn\_normal的情况完全与上一节同(读者可能要骂了，上一节明明说就是这样的，结果还有其他的情况，那不是骗人么？但是微软的东西例外就是多，我也实在拿他没办法... ).

注意如上节所叙述，wd\_mn\_normal的情况，既有可能是在Irp->MdlAddress中返回数据，也可能是在Irp->UserBuffer中返回数据，这个取决于Device的标志.

但是如果次功能号为wd\_mn\_mdl则完全不是这个意思。这种irp一进来看数据，就赫然发现Irp->MdlAddress和Irp->UserBuffer都为空。那你得到数据后把数据往哪里拷贝呢?

wd\_mn\_mdl的意思是请自己分配一个mdl,然后把mdl指向你的数据所在的空间，然后返回给上层。自然mdl是要释放的，换句话说事业使用完毕要归还，所以又有wd\_mn\_mdl\_comp,意思是一个mdl已经使用完毕，可以释放了。

mdl用于描述内存的位置。据说和NDIS\_BUFFER用的是同一个结构。这里不深究，我写一些函数来分配和释放mdl，并把mdl指向内存位置或者得到mdl所指向的内存：

// 释放mdl  
\_inline wd\_void wd\_mdl\_free(wd\_mdl \*mdl)  
\{  
IoFreeMdl(mdl);  
\}

// 这个这个东西分配mdl,缓冲必须是非分页的。可以在dispatch level跑。  
\_inline wd\_mdl \*wd\_mdl\_alloc(wd\_void\* buf,  
wd\_ulong length)  
\{  
wd\_mdl \* pmdl = IoAllocateMdl(buf,length,wd\_false,wd\_false,NULL);  
if(pmdl == NULL)  
return NULL;  
MmBuildMdlForNonPagedPool(pmdl);  
return pmdl;  
\}

// 这个函数分配一个mdl,并且带有一片内存  
\_inline wd\_mdl \*wd\_mdl\_malloc(wd\_ulong length)  
\{  
wd\_mdl \*mdl;  
wd\_void \*point = wd\_malloc(wd\_false,length);  
if(point == NULL)  
return NULL;  
mdl = wd\_mdl\_alloc(point,length);  
if(mdl == NULL)  
\{  
wd\_free(point);  
return NULL;  
\}  
return mdl;  
\}

// 这个函数释放mdl并释放mdl所带的内存。  
\_inline wd\_void wd\_mdl\_mfree(wd\_mdl \*mdl)  
\{  
wd\_void \*point = wd\_mdl\_vaddr(mdl);  
wd\_mdl\_free(mdl);  
wd\_free(point);  
\}

// 得到地址。如果想往一个MdlAddress里边拷贝数据 ...  
\_inline wd\_void \*wd\_mdl\_vaddr(wd\_mdl \*mdl)  
\{  
return MmGetSystemAddressForMdlSafe(mdl,NormalPagePriority);  
\}

另外我通过这两个函数来设置和获取Irp上的mdl.

\_inline wd\_mdl \*wd\_irp\_mdl(wd\_irp \*irp)  
\{  
return irp->MdlAddress;  
\}

\_inline wd\_void wd\_irp\_mdl\_set(wd\_irp \*irp,  
wd\_mdl \*mdl)  
\{  
irp->MdlAddress = mdl;  
\}

一个函数获得UserBuffer.  
\_inline wd\_void \* wd\_irp\_user\_buf(wd\_irp \*irp)  
\{  
return irp->UserBuffer;  
\}

要完成请求还有一个问题。就是irp->IoStatus.Information.在这里你必须填上实际读取得到的字节数字。不然上层不知道有多少数据返回。这个数字不一定与你的请求的长度等同（其实我认为几乎只要是成功，就应该都是等同的，唯一的例外是读取到文件结束的地方，长度不够了的情况）。我用下边两个函数来获取和设置这个数值：

\_inline wd\_void wd\_irp\_infor\_set(wd\_irp \*irp,  
wd\_ulong infor)  
\{  
irp->IoStatus.Information = infor;  
\}

\_inline wd\_ulong wd\_irp\_infor(wd\_irp \*irp)  
\{  
return irp->IoStatus.Information;  
\}

也许你都烦了，但是还有事情要做。作为读文件的情况，如果你是自己完成请求，不能忘记移动一下文件指针。否则操作系统会不知道文件指针移动了而反复读同一个地方永远找不到文件尾，我碰到过这样的情况。

一般是这样的，如果文件读取失败，请保持原来的文件指针位置不要变。如果文件读取成功，请把文件指针指到“读请求偏移量+成功读取长度”的位置。

这个所谓的指针是指Irp->FileObject->CurrentByteOffset.

我跟踪过正常的windows文件系统的读行为，我认为并不一定是向我上边说的这样做。情况很复杂，有时动，有时不动（说复杂当然是因为我不理解），但是按我上边说的方法来完成，我还没有发现过错误。

我用以下函数来设置和获取这个。

\_inline wd\_void wd\_file\_offset\_add(wd\_file \*file,wd\_ulong len)  
\{  
file->CurrentByteOffset.QuadPart += len;  
\}

\_inline wd\_void wd\_file\_offset\_set(wd\_file \*file,wd\_lgint offset)  
\{  
file->CurrentByteOffset = offset;  
\}

\_inline wd\_lgint wd\_file\_offset(wd\_file \*file)  
\{  
return file->CurrentByteOffset;  
\}

现在看看怎么完成这些请求，假设我已经有数据了。现在假设本设备缓冲标记为0，即正常情况采用Irp->UserBuffer返回数据. 这些当然都是在my\_disp\_read中或者是其他想完成这个irp的地方做的（希望你还记得我们是如何来到这里），假设其他必要的判断都已经做了：

wd\_irpsp \*irpsp = wd\_irp\_cur\_io\_stack(irp);  
switch(wd\_irpsp\_minor(irpsp))  
\{  
// 我先保留文件的偏移位置  
case wd\_mn\_normal:  
\{  
wd\_void \*point = wd\_irp\_user\_buf(irp);

// 如果有数据，就往point ...里边拷贝 ...

wd\_irp\_infor\_set(irp,length);  
wd\_irp\_status\_set(irp,wd\_suc);  
wd\_file\_offset\_set(wd\_irp\_file(irp),offset+length);

return wd\_irp\_over(irp);  
\}  
case wd\_mn\_mdl:  
\{  
wd\_void \*mdl = wd\_mdl\_malloc(length); // 情况比上边的复杂，请先分配mdl  
if(mdl == NULL)  
\{  
// ... 返回资源不足 ...  
\}

wd\_irp\_mdl\_set(irp,mdl);  
wd\_irp\_infor\_set(irp,length);  
wd\_irp\_status\_set(irp,wd\_suc);

wd\_file\_offset\_set(wd\_irp\_file(irp),offset+length);

return wd\_irp\_over(irp);

\}  
case wd\_mn\_mdl\_comp:  
\{  
// 没有其他任务，就是释放mdl  
wd\_mdl\_mfree(wd\_irp\_mdl(irp));  
wd\_irp\_mdl\_set(irp,0);  
wd\_irp\_infor\_set(irp,0);  
wd\_irp\_status\_set(irp,wd\_status\_suc);

return wd\_irp\_over(irp);  
\}  
default:  
\{  
// 我认为其他的情况不过滤比较简单 ...  
\}  
\}

重要提醒：wd\_mn\_mdl的情况，需要分配一个mdl，并且这个mdl所带有的内存是有一定长度的，这个长度必须与后来的irp->IoStatus.Information相同！似乎上层并不以irp->IoStatus.Information返回的长度为准。比如明明只读了50个字节，但是你返回了一个mdl指向内存长度为60字节，则操作系统则认为已经读了60个字节！这非常糟糕。

最后提一下文件是如何结尾的。如果到某一处，返回成功，但是实际读取到的数据没有请求的数据长，这时还是返回wd\_status\_suc(STATUS\_SUCCESS),但是此后操作系统会马上发irp来读最后一个位置，此时返回长度为0，返回状态STATUS\_FILE\_END即可。  
  
10 自己发送Irp完成读请求

关于这个有一篇文档解释得很详细，不过我认为示例的代码有点太简略了，这篇文档在IFS所附带的OSR文档中，请自己寻找。

为何要自己发送Irp?在一个文件过滤驱动中，如果你打算读写文件，可以试用ZwReadFile.但是这有一些问题。Zw系列的Native API使用句柄。而句柄是有线程环境限制的。此外也有中断级别的限制。再说，Zw系列函数来读写文件，最终还是要发出Irp,又会被自己的过滤驱动捕获到。结果带来判断上的困难。对资源也是浪费。那么最应该的办法是什么呢？当然是直接对卷设备发Irp了。

但是Irp是非常复杂的数据结构，而且又被微软所构造的很多未空开的部件所处理。所以自己发irp并不是一件简单的事情。

比较万能的方法是IoAllocateIrp,分配后自己逐个填写。问题是细节实在太多，很多无文档可寻。有兴趣的应该看看我上边所提及的那篇文章“Rolling Your Own”。

有意思的是这篇文章后来提到了捷径，就是利用三个函数：

IoBuildAsynchronousFsdRequest(...)  
IoBuildSynchronousFsdRequest(...)  
IoBuildDeviceIoControlRequest(...)

于是我参考了他这方面的示例代码，发现运行良好，程序也很简单。建议怕深入研究的选手就可以使用我下边提供的方法了。

首先的建议是使用IoBuildAsynchronousFsdRequest(),而不要使用同步的那个。使用异步的Irp使irp和线程无关。而你的过滤驱动一般很难把握当前线程（如果你开一个系统线程来专门读取文件那例外）。此时，你可以轻松的在Irp的完成函数中删除你分配过的Irp,避免去追究和线程相关的事情。

但是这个方法有局限性。文档指出，这个方法仅仅能用于IRP\_MJ\_READ,IRP\_MJ\_WRITE,IRP\_MJ\_FLUSH\_BUFFERS,和IRP\_MJ\_SHUTDOWN.刚好我这里仅仅要求完成文件读。

用Irp完成文件读需要一个FILE\_OBJECT.FileObject是比Zw系列所用的句柄更好的东西。因为这个FileObject是和线程无关的。你可以放心的在未知的线程中使用他。

自己要获得一个FILE\_OBJECT必须自己发送IRP\_MJ\_CREATE的IRP.这又不是一件轻松的事情。不过我跳过了这个问题。因为我是文件系统过滤驱动，所以我从上面发来的IRP中得到FILE\_OBJECT,然后再构造自己的IRP使用这个FILE\_OBJECT,我发现运行很好。

但是又出现一个问题，如果IRP的irp->Flags中有IRP\_PAGING（或者说是Cache管理器所发来的IRP）标记，则其FileObject我获得并使用后，老是返回错误。阅读网上的经验表明，带有IRP\_PAGINGE的FileObject不可以使用.于是我避免使用这时的FileObject.我总是使用不带IRP\_PAGING的Irp（认为是用户程序发来的读请求）的FileObject。

好，现在废话很多了，现在来看看构造irp的代码：

\_inline wd\_irp \*wd\_irp\_fsd\_read\_alloc(wd\_dev \*dev,  
wd\_void \*buf,  
wd\_ulong length,  
wd\_lgint \*offset,  
wd\_io\_stat\_block \*io\_stat)  
\{  
return IoBuildAsynchronousFsdRequest(IRP\_MJ\_READ,dev,  
buf,length,  
offset,  
io\_stat);  
\}

io\_stat我不知道是做何用，我一般填写NULL.类型是PIO\_STATUS\_BLOCK.buf则是缓冲。在Irp中被用做UserBuffer接收数据。offset是这次读的偏移量。

以上函数构造一个读irp.请注意，此时您还没有设置FileObject.实际上我是这样发出请求的：

irp = wd\_irp\_fsd\_read\_alloc(dev,buf,len,&start,NULL);  
if(irp == NULL)  
return;  
irpsp = wd\_irp\_next\_sp(irp);  
wd\_irpsp\_file\_set(irpsp,file);  
wd\_irp\_comp(irp,my\_req\_comp,context);

请注意wd\_irp\_next\_sp，我是得到了这个irp的下一个IO\_STACK\_LOCATION，然后我设置了FileObject.接下来应该设置了完成后，我就可以发送请求了！请求发送完毕后，一旦系统完成请求就会调用你的my\_req\_comp.

再看看my\_req\_comp如何收场：

wd\_stat my\_req\_comp(in wd\_dev \*dev,  
in wd\_irp \*irp,  
in wd\_void \*context)  
\{

// 请注意，无论成功还是失败，我都得在这里彻底销毁irp  
wd\_irp\_send\_by\_myself\_free(irp);

// 返回这个，仅仅是因为irp我已经销毁，不想让系统再次销毁它而已。  
return wd\_stat\_more\_processing;  
\}

wd\_stat\_more\_prcessing就是STATUS\_MORE\_PROCESSING\_REQUIRED。之所以返回这个，是因为我已经把irp给删除了。我不想windows系统再对这个irp做什么。所以干脆说我还要继续处理，这样避免了io管理器再去动用这个irp的可能。

最后是那个irp删除函数的代码：

\_inline wd\_void wd\_irp\_send\_by\_myself\_free(wd\_irp \*irp)  
\{  
if (irp->MdlAddress)  
\{  
MmUnmapLockedPages(MmGetSystemAddressForMdl(irp->MdlAddress),  
irp->MdlAddress);  
MmUnlockPages(irp->MdlAddress);  
IoFreeMdl(irp->MdlAddress);  
\}  
IoFreeIrp(irp);  
\};

因为我自己没有分配过MdlAddress下去过。所以如果下边返回了MDL,我得附带清理它。

好了，祝愿你心情愉快。如果你何我一样懒惰的话，不妨就用上边的简单方法自己发irp来读文件了。  
  
11.文件和目录的生成打开，关闭与删除

我们已经分析了读，写与读类似。文件系统还有其他的操作。比如文件或目录的打开（打开已经存在的或者创建新的）,关闭。文件或目录的移动，删除。

实际上FILE\_OBJECT并不仅仅指文件对象。在windows文件系统中，目录和文件都是用FileObject来抽象的。这里产生一个问题，对于一个已经有的FileObject,我如何判断这是一个目录还是一个文件呢?

对于一个已经存在的FileObject,我没有找到除了发送IRP来向卷设备询问这个FileObject的信息之外更好的办法。自己发送IRP很麻烦。不是我很乐意做的那种事情。但是FileObject都是在CreateFile的时候诞生的。在诞生的过程中，确实有机会得到这个即将诞生的FileObject,是一个文件还是一个目录。

Create的时候，获得当前IO\_STACK\_LOCATION,假设为irpsp,那么irpsp->Parameters.Create的结构为：

struct \{  
PIO\_SECURITY\_CONTEXT SecurityContext;  
ULONG Options;  
USHORT FileAttributes;  
USHORT ShareAccess;  
ULONG EaLength;  
\};

这个结构中的参数是与CreateFile这个api中的参数对应的，请自己研究。我先写一些函数包装来方便读取irpsp.

\_inline wd\_ulong wd\_irpsp\_file\_opts(wd\_irpsp \*irpsp)  
\{  
return irpsp->Parameters.Create.Options;  
\}

\_inline wd\_ushort wd\_irpsp\_file\_attrs(wd\_irpsp \*irpsp)  
\{  
return irpsp->Parameters.Create.FileAttributes;  
\}

enum \{wd\_file\_opt\_dir = FILE\_DIRECTORY\_FILE\};  
enum \{wd\_file\_attr\_dir = FILE\_ATTRIBUTE\_DIRECTORY\};

然后我们搞清上边Options和FileAttributes的意思。是不是Options里边有FILE\_DIRECTORY\_FILE标记就表示这是一个目录?实际上，CreateOpen是一种尝试性的动作。无论如何，我们只有当CreateOpen成功的时候，判断FileObject才有意义。否则是空谈。

成功有两种可能，一是已经打开了原有的文件或者目录，另一种是新建立了文件或者目录。Options里边带有FILE\_DIRECTORY\_FILE表示打开或者生成的对象是一个目录。那么，如果在Create的完成函数中，证实生成或者打开是成功的，那么返回得到的FILE\_OBJECT,确实应该是一个目录。

当我经常要使用我过滤时得到的文件或者目录对象的时候，我一般在Create成功的的时候捕获他们，并把他们记录在一个“集合”中。这时你得写一个用来表示“集合”的数据结构。你可以用链表或者数组，只是注意保证多线程安全性。因为Create的时候已经得到了属性表示FileObject是否是目录，你就没有必要再发送IRP来询问FileObject的Attribute了。

对了上边有FileAttributes。但是这个东西并不可靠。因为在生成或者打开的时候，你只需要设置Options。我认为这个字段并无法说明你打开的文件对象是目录。

这你需要设置一下Create的完成函数。如果设置这里不再重复，请参考上边对文件读操作。

wd\_stat my\_create\_comp(in wd\_dev \*dev,  
in wd\_irp \*irp,  
in wd\_void \*context)  
\{  
wd\_irpsp \*irpsp = wd\_irp\_cur\_sp(irp);  
wd\_file \*file = wd\_irpsp\_file(irpsp);

UNREFERENCED\_PARAMETER(dev);

if(wd\_suc(wd\_irp\_status(irp))  
\{  
// 如果成功了,把这个FileObject记录到集合里,这是一个  
// 刚刚打开或者生成的目录  
if(file &&  
(wd\_irpsp\_file\_opts(irpsp) & wd\_file\_opt\_dir))  
add\_obj\_to\_set(file);  
\}  
return wd\_irp\_status(irp);  
\}

这里顺便解释一下UNREFERENCED\_PARAMETER宏。我曾经不理解这个宏的意思。其实就是因为本函数传入了三个参数，这些参数你未必会用到。如果你不用的话，大家知道c编译器会发出一条警告。一般认为驱动应该去掉所有的警告，所以用了这个宏来“使用”一下没有用到过的参数。你完全可以不用他们。

现在所有的目录都被你记录。那么得到一个FileObject的时候，判断一下这个FileObject在不在你的集合里，如果在，就说明是目录，反之是文件。

当这个FileObject被关闭的时候你应该把它从你的集合中删除。你可以捕获Close的IRP来做这个。记得本教程很早以前，我们已经安装过my\_close函数的来处理IRP（请回忆或者翻阅第3节的内容），那么很简单了，在该函数中从你的集合中删除该FileObject即可。作为保险的做法，应该观察一下关闭是否成功。如果成功的话，再进行你的从集合中删除元素工作。

因为判断FileObject是文件还是目录的问题，我们已经见识了文件的打开和关闭工作。现在看一下文件是如何被删除的。

删除的操作，第一步是打开文件，打开文件的时候必须设置为可以删除。如果打开失败，则直接导致无法删除文件。第二步设置文件属性为用于删除，第三步关闭文件即可。关闭的时候，文件被系统删除。

不过请注意这里的“删除”并非把文件删除到回收站。如果要测试，你必须按住shift彻底删除文件。文件删除到回收站只是一种改名操作。改名操作我们留到以后再讨论。

第一步是打开文件，我应该可以在文件被打开的时候，捕获到的irpsp的参数，记得前边的参数结构，中间有：

PIO\_SECURITY\_CONTEXT SecurityContext;