MDL数据结构

最新推荐文章于 2016-05-03 21:14:11 发布
最新推荐文章于 2016-05-03 21:14:11 发布
阅读量245 收藏 1
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/sideny/p/3295831.html
版权

微软的文档里对MDL的描述感觉语焉不详，这两天在找工作的间隙逆向+黑盒测试了一下MmBuildMdlForNonPagedPool，把得到的一些理解描述下来。

一.MDL数据结构

    MDL是用来建立一块虚拟地址空间与物理页面之间的映射，结构定义如下：

   

  1. typedef struct _MDL {  
  2.   struct _MDL *Next;  
  3.   CSHORT Size;  
  4.   CSHORT MdlFlags;  
  5.   struct _EPROCESS *Process;  
  6.   PVOID MappedSystemVa;  
  7.   PVOID StartVa;  
  8.   ULONG ByteCount;  
  9.   ULONG ByteOffset;  
  10.  } MDL, *PMDL;  

 

    各field的解释：

    Next：MDL可以连接成一个单链表，这在IRP的结构里能找到。具体是做什么用的参考对IRP的描述

    Size：一个MDL并不单单包含结构里这些东西，在内存中紧接着一个MDL结构，存着这个MDL对应的各个物理页面编号，由于一个物理页面一定是4KB 对齐的，所以这个编号相当于一个物理页面起始地址的高20位。Size的值减去sizeof（MDL），等于存放编号的区域的大小。比如该MDL需要三个 物理页面来映射虚拟地址空间，则Size-sizeof（MDL）==4*3==12；

    MdlFlags：与这个MDL相关的一些标记

    Process：如果虚拟地址是某一进程的用户地址空间，那么MDL代表的这块虚拟地址必须是从属于某一个进程，这个成员指向从属进程的结构

    MappedSystemVa：该MDL结构对应的物理页面可能被映射到内核地址空间，这个成员代表这个内核地址空间下的虚拟地址。对 MmBuildMdlForNonPagedPool的逆向表明，MappedSystemVa=StartVa+ByteOffset。这是因为这个函 数的输入MDL，其StartVa是由ExAllocatePoolWithTag决定的，所以已经从内核空间到物理页面建立了映 射，MappedSystemVa自然就可以这样算。 可以猜测，如果是调用MmProbeAndLockPages返回，则MappedSystemVa不会与StartVa有这样的对应关系，因为此时对应的物理页面还没有被映射到内核空间。（此处未定，MmProbeAndLockPages是否会到PDE与PTE中建立映射，未知。）

    StartVa：虚拟地址空间的首地址，当这块虚拟地址描述的是一个用户进程地址空间的一块时，这个地址从属于某一个进程。

    ByteCount：虚拟地址块的大小，字节数

    ByteOffset：StartVa+ByteCount等于缓冲区的开始地址

 

二.对MmBuildMdlForNonPagedPool的黑盒测试

   测试的程序主要执行如下步骤：

   1.用ExAllocatePoolWithTag在内核地址空间的NonpagedPool分配一块10000自己的区域

    2.用上述得到的地址和大小调用IoAllocateMdl，返回一个MDL

    3.打印该MDL个成员的值

    4.调用MmBuildMdlForNonPagedPool

    5.打印MDL各成员的值，比较与步骤3中的不同

    代码如下：

  1. #include "ntddk.h"  
  2. #include "wdm.h"  
  3. #include "ntdef.h"  
  4. #define BUF_LENGTH 10000  
  5. static void OutputMDL(PMDL pMDL);  
  6. static void Unload( IN PDRIVER_OBJECT pDriverObject);  
  7. NTSTATUS DriverEntry( IN PDRIVER_OBJECT  pDriverObject, IN PUNICODE_STRING RegistryPath )  
  8. {  
  9.     PVOID pBuf = NULL;  
  10.     PMDL pMDL;  
  11. //set up unload routing  
  12.     pDriverObject->DriverUnload = Unload;  
  13. //allocate memory from non-paged pool  
  14.     pBuf = ExAllocatePoolWithTag(NonPagedPool,BUF_LENGTH,(ULONG)DriverEntry);  
  15.     if(!pBuf) {  
  16.         DbgPrint("ExAllocatePoolWithTag failed./n");  
  17.         return STATUS_SUCCESS;  
  18.     }  
  19.     DbgPrint("MDL_TEST: pBuf=0x%08x/n",(ULONG)pBuf);  
  20. //allocate a MDL      
  21.     pMDL = IoAllocateMdl(pBuf,BUF_LENGTH,FALSE,FALSE,NULL);  
  22.     if(!pMDL) {  
  23.         DbgPrint("IoAllocateMdl failed./n");  
  24.         ExFreePoolWithTag(pBuf,(ULONG)DriverEntry);  
  25.         return STATUS_SUCCESS;  
  26.     }  
  27. //print MDL right after IoAllocateMdl  
  28.     OutputMDL(pMDL);  
  29. //  
  30.     DbgPrint("****************************************/n");  
  31. //call MmBuildMdlForNonPagedPool  
  32.     MmBuildMdlForNonPagedPool(pMDL);  
  33. //print MDL after MmBuildMdlForNonPagedPool is called  
  34.     OutputMDL(pMDL);  
  35. //return  
  36.     IoFreeMdl(pMDL);  
  37.     ExFreePoolWithTag(pBuf,(ULONG)DriverEntry);  
  38.     return STATUS_SUCCESS;  
  39. }  
  40. void Unload( IN PDRIVER_OBJECT pDriverObject)  
  41. {  
  42.     DbgPrint("MDL_TEST: Unloading. 88/n");  
  43. }  
  44. void OutputMDL(PMDL pMDL)  
  45. {  
  46.     int i;  
  47.     ULONG * p = (ULONG*)(pMDL+1);  
  48.       
  49.     DbgPrint("MDL_TEST: Size=%d/n",pMDL->Size);  
  50.     DbgPrint("MDL_TEST: MdlFlags=0x%04x/n",pMDL->MdlFlags);  
  51.     DbgPrint("MDL_TEST: Process=0x%08x/n",(ULONG)pMDL->Process);  
  52.     DbgPrint("MDL_TEST: MappedSystemVa=0x%08x/n",(ULONG)pMDL->MappedSystemVa);  
  53.     DbgPrint("MDL_TEST: StartVa=0x%08x/n",(ULONG)pMDL->StartVa);  
  54.     DbgPrint("MDL_TEST: ByteCount=%u/n",pMDL->ByteCount);  
  55.     DbgPrint("MDL_TEST: ByteOffset=%u/n",pMDL->ByteOffset);  
  56. //print a few 4-bytes after the MDL structure  
  57.     for(i=0;i<5;i++)  
  58.         DbgPrint("MDL_TEST: p[%d]=0x%08x/n",i,p[i]);  
  59.       
  60. }  

 

执行的结果如下：

  1. MDL_TEST: pBuf=0xadc92000  
  2. MDL_TEST: Size=40  
  3. MDL_TEST: MdlFlags=0x0008  
  4. MDL_TEST: Process=0x87e85c88  
  5. MDL_TEST: MappedSystemVa=0x95fb1cc4  
  6. MDL_TEST: StartVa=0xadc92000  
  7. MDL_TEST: ByteCount=10000  
  8. MDL_TEST: ByteOffset=0  
  9. MDL_TEST: p[0]=0x0002d72f  
  10. MDL_TEST: p[1]=0x0002e2b0  
  11. MDL_TEST: p[2]=0x0007e15a  
  12. MDL_TEST: p[3]=0x0007e15b  
  13. MDL_TEST: p[4]=0x0007e15c  
  14. ****************************************  
  15. MDL_TEST: Size=40  
  16. MDL_TEST: MdlFlags=0x000c  
  17. MDL_TEST: Process=0x00000000  
  18. MDL_TEST: MappedSystemVa=0xadc92000  
  19. MDL_TEST: StartVa=0xadc92000  
  20. MDL_TEST: ByteCount=10000  
  21. MDL_TEST: ByteOffset=0  
  22. MDL_TEST: p[0]=0x0005bd23  
  23. MDL_TEST: p[1]=0x0005bea2  
  24. MDL_TEST: p[2]=0x0005bb21  
  25. MDL_TEST: p[3]=0x0007e15b  
  26. MDL_TEST: p[4]=0x0007e15c 

对驱动程序采用Direct I/O方式进行数据读的测试

 

采用这种方式进行读数据时，I/O Manager调用MmProbeAndLockPages将ReadFile参数提供的用户空间缓冲区对应的物理页面锁定为不可换出，然后将得到的 MDL放在Irp->MdlAddress里，将IRP传递给相应驱动程序的DispatchRead。根据Walter Oney在书中的描述，此时I/O Manager的行为可以用下面的代码来描述：

[c-sharp] view plain copy
  1. KPROCESSOR_MODE mode;   // <== either KernelMode or UserMode  
  2. PMDL mdl = IoAllocateMdl(uva, length, FALSE, TRUE, Irp);  
  3. MmProbeAndLockPages(mdl, mode,  
  4.   reading ? IoWriteAccess : IoReadAccess);  
  5. <code to send and await IRP>  
  6. MmUnlockPages(mdl);  
  7. IoFreeMdl(mdl);  

这里主要关注的地方是MmProbeAndLockPages有没有进行实际的虚拟地址的映射，即将物理页面映射到内核地址空间中。我们用下面的驱动代码来测试这一行为。

[c-sharp] view plain copy
  1. NTSTATUS DispatchRead(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp)  
  2. {  
  3.     PVOID pSysAddr;  
  4.     PMDL pMDL = pIrp->MdlAddress;  
  5.     DbgPrint("******************DispatchRead******************/n");  
  6.     DbgPrint("Before MmGetSystemAddressForMdlSafe/n");  
  7.     OutputMDL(pMDL);  
  8.     pSysAddr = MmGetSystemAddressForMdlSafe(pMDL,LowPagePriority);  
  9.     if(!pSysAddr) {  
  10.         DbgPrint("MmGetSystemAddressForMdlSafe failed./n");  
  11.         return STATUS_SUCCESS;  
  12.     }  
  13.       
  14.     DbgPrint("After MmGetSystemAddressForMdlSafe/n");  
  15.     OutputMDL(pMDL);  
  16.     pIrp->IoStatus.Status = STATUS_SUCCESS;  
  17.     pIrp->IoStatus.Information = MmGetMdlByteCount(pMDL);  
  18.     IoCompleteRequest(pIrp,IO_NO_INCREMENT);  
  19.       
  20.     return STATUS_SUCCESS;  
  21. }  

再写一个应用程序来发起一个读操作：

[c-sharp] view plain copy
  1. void TestMDLDriver()  
  2. {  
  3.     HANDLE hDevice;  
  4.     BOOL bRet;  
  5.     DWORD dwRead;  
  6.     BYTE buf[10000] = {'S','Q','U','I'};  
  7.     hDevice = CreateFile(_T(".//MDLTest"),GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);  
  8.     if(hDevice==INVALID_HANDLE_VALUE)   
  9.     {  
  10.         fprintf(stderr,"CreateFile error : %d/n",GetLastError());  
  11.         return;  
  12.     }  
  13. //issue a read request  
  14.     bRet = ReadFile(hDevice,buf,sizeof(buf),&dwRead,NULL);  
  15.     if(!bRet)  
  16.     {  
  17.         fprintf(stderr,"ReadFile error : %d/n",GetLastError());  
  18.         return;  
  19.     }  
  20.     printf("Read bytes:%d/n",dwRead);  
  21. //  
  22.     CloseHandle(hDevice);  
  23. }  

导致的内核输出如下：

  1. 00000009    4.27463436  ******************DispatchRead******************  
  2. 00000010    4.27464771  Before MmGetSystemAddressForMdlSafe  
  3. 00000011    4.27465439  MDL_TEST: Size=40  
  4. 00000012    4.27466011  MDL_TEST: MdlFlags=0x008a  
  5. 00000013    4.27466583  MDL_TEST: Process=0x86ca7b58  
  6. 00000014    4.27467155  MDL_TEST: MappedSystemVa=0x92b1f000  
  7. 00000015    4.27467775  MDL_TEST: StartVa=0x001ad000  
  8. 00000016    4.27468348  MDL_TEST: ByteCount=10000  
  9. 00000017    4.27468824  MDL_TEST: ByteOffset=1148  
  10. 00000018    4.27469397  MDL_TEST: p[0]=0x00064429  
  11. 00000019    4.27469969  MDL_TEST: p[1]=0x000619fc  
  12. 00000020    4.27470541  MDL_TEST: p[2]=0x000618ee  
  13. 00000021    4.27471066  MDL_TEST: p[3]=0x00060749  
  14. 00000022    4.27471685  MDL_TEST: p[4]=0x86abca24  
  15. 00000023    4.27472448  After MmGetSystemAddressForMdlSafe  
  16. 00000024    4.27472973  MDL_TEST: Size=40  
  17. 00000025    4.27473545  MDL_TEST: MdlFlags=0x008b  
  18. 00000026    4.27474070  MDL_TEST: Process=0x86ca7b58  
  19. 00000027    4.27474689  MDL_TEST: MappedSystemVa=0xb01e747c  
  20. 00000028    4.27475214  MDL_TEST: StartVa=0x001ad000  
  21. 00000029    4.27475786  MDL_TEST: ByteCount=10000  
  22. 00000030    4.27476311  MDL_TEST: ByteOffset=1148  
  23. 00000031    4.27476835  MDL_TEST: p[0]=0x00064429  
  24. 00000032    4.27477455  MDL_TEST: p[1]=0x000619fc  
  25. 00000033    4.27477980  MDL_TEST: p[2]=0x000618ee  
  26. 00000034    4.27478504  MDL_TEST: p[3]=0x00060749  
  27. 00000035    4.27479029  MDL_TEST: p[4]=0x86abca24  

此时从VS的调试器中看到，应用程序中buf[10000]的地址为0x001ad47c

从输出可以得到如下结论：

1.MmProbeAndLockPages并不将物理页面映射到内核地址空间，而仅锁定物理页面；MappedSystemVa的变化可以显示这一点

2.buf的地址=StartVa+ByteOffset；

3.MmGetSystemAddressForMdlSafe进行实际的映射操作，并设置MdlFlags的MDL_MAPPED_TO_SYSTEM_VA标志。

4.MmProbeAndLockPages将MdlFlags=MDL_WRITE_OPERATION | MDL_ALLOCATED_FIXED_SIZE | MDL_PAGES_LOCKED

转载于:https://www.cnblogs.com/sideny/p/3295831.html

weixin_30808693
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
对MDL(Memory Descriptor List)的初步学习
weixin_43742894的博客
03-14 2663
首先查阅CSDN，在其中有这样的定义： 内存描述符列表 (MDL) 是一个系统定义的结构，通过一系列物理地址描述缓冲区。执行直接 I/O 的驱动程序从 I/O 管理器接收一个 MDL 的指针，并通过 MDL 读写数据。一些驱动程序在执行直接 I/O 来满足设备 I/O 控制请求时也使用 MDL。 MDL分为两部分：固定长部分和变长部分，固定长部分结构如下： Next：MDL可以连接成...
MDL 数据结构
Ghjhfssfgk的博客
03-30 268
《Windows驱动开发技术详解》中说 在使用直接方式来读写设备的时候，操作系统会将用户模式下的缓冲区锁住，然后操作系统将这段缓冲区在内核模式地址再次映射一遍。这样，用户模式的缓冲区和内核模式的缓冲区都使用的是同一块物理内存，无论操作系统如果切换进程，内核模式的地址都保持不变。 操作系统先将用户模式的地址锁定后会使用MDL来记录这片内存。被记录的内存在物理内存上可能是离散的，但是在虚拟内存上一定是...
存储描述符表(MDL)剖析（一）
namelcx的专栏
09-29 5267
一 MDL是什么  在MSDN中有这样的定义 内存描述符列表 (MDL) 是一个系统定义的结构，通过一系列物理地址描述缓冲区。执行直接 I/O 的驱动程序从 I/O 管理器接收一个 MDL 的指针，并通过 MDL 读写数据。一些驱动程序在执行直接 I/O 来满足设备 I/O
Windows MDL原理总结
weixin_33850015的博客
12-25 390
1 先是mdl的数据结构。 2 下面根据用法逐步的讲解mdl数据结构的含义：一般用法，先是 IoAllocateMdl ：原型为： 最常用的是VirtualAddress和Length。把自己的NonPageable buffer的起始地址传给IoAllocateMdl ，长度也传给他。可是这个函数具体做了啥呢(下面只是些基本的影响理解的部分，具体更多的东西，更细节的东西，自己去看WRK的代码...
MDL结构
死胖子的博客
03-12 2292
// // I/O system definitions. // // 定义一个内存描述符列表(MDL) // // 一个MDL通过一系列物理页面描述在虚拟缓冲中的页面。 // 通过一个队列描述与缓冲区相关的页面，这个队列的内存位置紧跟着MDL头结构之后。 // // 一个简单的计算队列的地址的方法是在这个MDL的地址上加一： // // Pages = (PPFN_NUMBER) (
详细分析mysql MDL元数据锁
09-08
- 数据复制避免错误：在主从复制场景中，MDL锁防止了DDL操作和DML操作的交错，避免因表结构改变而产生的复制错误。 2. MDL锁的类型： - MDL读锁：DML操作（如INSERT, UPDATE, DELETE）需要的锁，允许多个读锁并存...
MDL.rar_.mdl_mdl
09-19
2. 数据结构设计：创建相应的数据结构来存储3D模型的各个组件，以便于处理和渲染。 3. GPU编程：使用Direct3D或OpenGL API创建顶点缓冲区和索引缓冲区，设置纹理和着色器，实现模型的渲染。 4. 动画系统：处理模型的...
MDL_Driver
08-16
MDL，全称为Memory Descriptor List（内存描述符列表），是Windows操作系统内核中用于管理I/O操作的一种数据结构。它在系统进行磁盘读写、网络传输等涉及内存与外设交互时起着关键作用。 MDL驱动程序主要是指那些...
MDL_Test.rar_mdl
最新发布
09-23
MDL是Windows内核模式驱动程序用来描述I/O缓冲区的一种数据结构。当驱动程序处理I/O请求时，它可能需要映射物理内存到虚拟内存，以便处理器能够访问这些数据。MDL提供了一种方式来跟踪这些映射，确保数据在DMA...
MDL.rar_mdl_microstation
09-21
1. **语法结构**：MDL语言的基础包括变量、数据类型、运算符、流程控制语句（如if-else、for、while循环）、函数和子程序等。它的语法类似于C语言，但具有自己的特性，比如使用`#define`进行宏定义，以及特有的事件...
关于MDL的一些事情
zacklin的专栏
04-16 5208
微软的文档里对MDL的描述感觉语焉不详，这两天在找工作的间隙逆向+黑盒测试了一下MmBuildMdlForNonPagedPool，把得到的一些理解描述下来。 一.MDL数据结构     MDL是用来建立一块虚拟地址空间与物理页面之间的映射，结构定义如下：     [cpp] view plaincopy typedef struct _MDL {    struc
初步认识MDL
热门推荐
chenyujing1234的专栏
12-17 1万+
一、 内存描述符列表 (MDL) 是一个系统定义的结构，通过一系列物理地址描述缓冲区。执行直接 I/O 的驱动程序从 I/O 管理器接收一个 MDL 的指针，并通过 MDL 读写数据。一些驱动程序在执行直接 I/O 来满足设备 I/O 控制请求时也使用 MDL。 驱动程序编写人员不应该假设 MDL 描述的内存页的顺序或内容。驱动程序不得依赖于 MDL 指向的任何位置的数据值，并且不应该直接取消
【个人理解】探究MDL
tbwork
03-20 3778
     以下的虚拟内存可以理解成逻辑内存，因为我觉得只有这样才能讲通下面所有的东西。以下的“未分页”指没有为页进行编码。以下为MDL结构体（我很郁闷，我在MSDN上没有找到这个结构体）typedef struct _MDL {   struct _MDL *Next;   //下一个MDL   CSHORT Size;       //大小   CSHORT MdlFlags;  //标志，
zz: 设备读写 之 直接方式（Direct I/O）MmGetMdlByteCount/MmGetMdlByteOffset/MmGetMdlVirtualAddress
jtujtujtu的专栏
12-31 2534
最近一直在看WDM的驱动，在memory方面有一些不是很清楚，譬如 MDL 的具体结构、使用方法等等。 在网络上搜刮一番，了解了MDL的具体使用，主要是MmGetMdlByteOffset这个宏的意义。之前一直认为这个值应该是0。事实并非如此，这个值是一个相对于page start addrss的offset，也就是说Va转为Pa时，并没有从page start address开始，而是从其中的
MDL的理解
qinli5的专栏
06-06 4588
最近在看《Windows NT File System Internals》，重新理解MDL。 什么是mdl：              Mdl的全称是内存描述符列表(Memory Descriptor list),主要用于关联虚拟地址和物理地址，有点像页表。但是，比页表简单，其实它对于虚拟地址的映射也是查看页表得到的。虚拟地址在mdl中可以通过一个宏获得，物理地址的页帧存放在紧接着md
【驱动笔记14】初步认识MDL
kingswb的博客
05-03 2140
前段时间在群里有人问起什么是MDL，当时三言两语也不知道解释清楚了没，今天闲着无事，索性记录下来吧，就当是做个笔记，以后忘了也好查阅。 我们知道，系统中一些重要的表项如SSDT是只读的，如果我们强行对其进行修改就会造成BSOD的严重后果。当然这种保护方式很容易被绕过，我们曾经介绍了通过修改cr0来禁用WP（WriteProtect，写保护）位的方法，现在再介绍一种不需要使用汇编的方法，就是M
MDL（memory descriptor list）
多媒体编程、网络编程、系统编程、网络安全编程、驱动编程
03-24 1203
typedef struct _MDL { struct _MDL *Next; CSHORT Size; CSHORT MdlFlags; struct _EPROCESS *Process; PVOID MappedSystemVa; PVOID StartVa; ULONG ByteCount; ULONG ByteOffset; } MDL, *PMDL; MDL只
MicroStation MDL程序设计详解
MDL中的结构和联合允许开发者组织数据，特别是处理元素的联合。指针的使用，包括通过引用和值传递，是MDL中实现高效代码的关键。此外，本章还讨论了MicroStation的状态机模型和资源管理，如命令表和状态控制函数。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值