[Windows驱动开发]之内存概念及内存操作示例代码

最新推荐文章于 2024-09-25 22:11:28 发布
最新推荐文章于 2024-09-25 22:11:28 发布
阅读量600 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： 驱动编程
原文链接：https://www.cnblogs.com/kuangke/p/5606867.html
本文深入解析内存管理核心概念，涵盖物理内存与虚拟内存的区别，用户态与内核态地址空间，以及分页与非分页内存的应用。同时，介绍了Windows驱动程序如何高效使用内存资源，探讨了链表和Lookaside结构在驱动中的运用，以及关键内存操作函数。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、内存管理概念

1. 物理内存概念（Physical Memory Address）

PC上有三条总线，分别是数据总线、地址总线和控制总线。32位CPU的寻址能力为4GB（2的32次方）个字节。用户最多可以使用4GB的真实物理内存。PC中很多设备都提供了自己的设备内存。这部分内存会映射到PC的物理内存上，也就是读写这段物理地址，其实读写的是设备内存地址，而不是物理内存地址。

2. 虚拟内存概念

虽然可以寻址4GB的内存，但是PC中往往没有如此多的真实物理内存。操作系统和硬件（主要是CPU中的内存管理单元MMU）为使用者提供了虚拟内存的概念。Windows的所有程序可以操作的都是虚拟内存。对虚拟内存的所有操作最终都会被转换成对真实物理内存的操作。
CPU中有一个重要的寄存器CR0，它是一个32位寄存器，其中的PG位负责标记是否分页。Windows在启动前会将它设置为1，即允许分页。WDK中有一个宏PAGE_SIZE记录分页大小，一般为4KB。4GB的虚拟内存会被分割成1M个分页单元。
其中，有一部分单元会和物理内存对应起来，即虚拟内存中第N个分页单元对应着物理内存的第M个分页单元。这种对应不是一一对应，而是多对一的映射，多个虚拟内存页可以映射同一个物理内存页。还有一部分单元会被映射成磁盘上的一个文件，并被标记为“脏的（Dirty）”。读取这段虚拟内存的时候，系统会发出一个异常，此时会触发异常处理函数，异常处理函数会将这个页的磁盘文件读入内存，并将其标记设置为“不脏”。让经常不读写的内存页交换（Swap）成文件，并将此页设置为“脏”。还有一部分单元什么也没有对应，为空。
Windows如此设计是因为以下两种原因：
a. 虚拟的增加了内存的大小。
b. 使不同进程的虚拟内存互不干扰。

3. 用户态地址和内核态地址

虚拟地址在00x7fffffff范围内的虚拟内存，即低2GB的虚拟地址，被称为用户态地址。而0x800000000xffffffff范围内的虚拟内存，即高2GB的虚拟内存，被称为内核态地址。Windows规定运行在用户态（Ring3层）的程序只能访问用户态地址，而运行在内核态（Ring0层）的程序可以访问整个4GB的虚拟内存。
Windows的核心代码和Windows的驱动程序加载的位置都是在高2GB的内核地址中。Windows操作系统在进程切换时，保持内核态地址是完全相同的，即所有进程的内核地址映射完全一致，进程切换时只改变用户模式地址的映射。

4. Windows驱动程序和进程的关系

驱动程序类似于一个DLL，被应用程序加载到虚拟内存中，只不过加载地址是内核地址。它能访问的只是这个进程的虚拟内存，不能访问其他进程的虚拟地址。Windows驱动程序里的不同例程运行在不同的进程中。DriverEntry例程和AddDevice例程是运行在系统（System）进程中的。这个进程是Windows第一个运行的进程。当需要加载的时候，这个进程中会有一个线程将驱动程序加载到内核模式地址空间内，并调用DriverEntry例程。
其他的例程，如IRP的派遣函数会运行于应用程序的“上下文”中。“上下文”是指运行于某个进程的环境中，所能访问的虚拟地址是这个进程的虚拟地址。
在内核态通过调用PsGetCurrentProcess()函数得到当前IO活动的进程，它是EPROCESS的结构体，其中包含了进程的相关信息。由于微软没有公开EPROCESS结构体，所以不同的系统需要使用Windbg查看其具体的值。在Win XP SP2中这个结构的0x174偏移处记录了一个字符串指针，表示的是进程的映像名称。

5. 分页与非分页内存

Windows规定有些虚拟内存页面是可以交换到文件中的，这类内存被称为分页内存。而有些虚拟内存页永远也不会交换到文件中，这些内存被称为非分页内存。
当程序的中断请求级在DISPATCH_LEVEL之上时（包括DISPATCH_LEVEL层），程序只能使用非分页内存，否则将导致系统蓝屏死机。
在编译WDK提供的例程时，可以指定某个例程和某个全局变量是载入分页内存还是非分页内存，需要做如下定义：



    //  
      
    #define PAGEDCODE code_seg("PAGE")  
    #define LOCKEDCODE code_seg()  
    #define INITCODE code_seg("INIT")  
      
    #define PAGEDDATA code_seg("PAGE")  
    #define LOCKEDDATA code_seg()  
    #define INITDATA code_seg("INIT")  
      
    //   

//

#define PAGEDCODE code_seg("PAGE")
#define LOCKEDCODE code_seg()
#define INITCODE code_seg("INIT")

#define PAGEDDATA code_seg("PAGE")
#define LOCKEDDATA code_seg()
#define INITDATA code_seg("INIT")

//

如果将某个函数载入到分页内存中，我们需要在函数的实现中加入如下代码：



  //  
      
    #pragma PAGEDCODE  
    VOID SomeFunction()  
    {  
        PAGED_CODE();  
        // Do any other things ....  
    }  
      
    //  

//

#pragma PAGEDCODE
VOID SomeFunction()
{
    PAGED_CODE();
    // Do any other things ....
}

//

其中，PAGED_CODE()是WDK提供的宏，只在check版本中生效。他会检测这个函数是否运行低于DISPATCH_LEVEL的中断请求级，如果等于或高于这个中断请求级，将产生一个断言。
如果让函数加载到非分页内存中，需要在函数的实现中加入如下代码：



    //  
      
    #pragma LOCKEDCODE  
    VOID SomeFunction()  
    {  
        // Do any other things ....  
    }  
      
    //  

//

#pragma LOCKEDCODE
VOID SomeFunction()
{
    // Do any other things ....
}

//

还有一些特殊的情况，当某个例程在初始化的时候载入内存，然后就可以从内存中卸载掉。这种情况特指在调用DriverEntry的时候。尤其是NT式驱动，它会很长，占用很大的空间，为了节省内存，需要及时的从内存中卸载掉。代码如下：



  //  
      
    #pragma INITCODE  
    extern "C" NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING pRegistryPath)  
    {  
        // Do any other things ....  
    }  
      
    //  

//

#pragma INITCODE
extern "C" NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING pRegistryPath)
{
    // Do any other things ....
}

//

6. 分配内核内存

Windows驱动程序使用的内存资源非常珍贵，分配内存时要尽量节约。和应用程序一样，局部变量是存放在栈（Stack）空间中的。但是栈空间不会像应用程序那么大，所以驱动程序不适合递归调用或者局部变量是大型结构体。如果需要大型结构体，需要在堆（Heap）中申请。
堆中申请内存的函数有以下几个：





    //  
      
    NTKERNELAPI  
    PVOID  
    ExAllocatePool(  
        __drv_strictTypeMatch(__drv_typeExpr) __in POOL_TYPE PoolType,  
        __in SIZE_T NumberOfBytes  
        );  
      
    NTKERNELAPI  
    PVOID  
    NTAPI  
    ExAllocatePoolWithTag(  
        __in __drv_strictTypeMatch(__drv_typeExpr) POOL_TYPE PoolType,  
        __in SIZE_T NumberOfBytes,  
        __in ULONG Tag  
        );  
      
    NTKERNELAPI  
    PVOID  
    ExAllocatePoolWithQuota(  
        __drv_strictTypeMatch(__drv_typeExpr) __in POOL_TYPE PoolType,  
        __in SIZE_T NumberOfBytes  
        );  
      
    NTKERNELAPI  
    PVOID  
    ExAllocatePoolWithQuotaTag(  
        __in __drv_strictTypeMatch(__drv_typeExpr) POOL_TYPE PoolType,  
        __in SIZE_T NumberOfBytes,  
        __in ULONG Tag  
        );  
      
    //  

//

NTKERNELAPI
PVOID
ExAllocatePool(
    __drv_strictTypeMatch(__drv_typeExpr) __in POOL_TYPE PoolType,
    __in SIZE_T NumberOfBytes
    );

NTKERNELAPI
PVOID
NTAPI
ExAllocatePoolWithTag(
    __in __drv_strictTypeMatch(__drv_typeExpr) POOL_TYPE PoolType,
    __in SIZE_T NumberOfBytes,
    __in ULONG Tag
    );

NTKERNELAPI
PVOID
ExAllocatePoolWithQuota(
    __drv_strictTypeMatch(__drv_typeExpr) __in POOL_TYPE PoolType,
    __in SIZE_T NumberOfBytes
    );

NTKERNELAPI
PVOID
ExAllocatePoolWithQuotaTag(
    __in __drv_strictTypeMatch(__drv_typeExpr) POOL_TYPE PoolType,
    __in SIZE_T NumberOfBytes,
    __in ULONG Tag
    );

//

● PoolType：枚举变量。如果为NonPagedPool，则分配非分页内存。如果为PagedPool，则分配分页内存。
● NumberOfBytes：分配内存的大小。注：最好是4的倍数。
● 返回值：分配内存的地址，一定是内核模式地址。如果返回0则代表分配失败。

以上四个函数功能类似。以WithQuota结尾的函数代表分配的时候按配额分配。以WithTag结尾的函数和ExAllocatePool功能类似，唯一不同的是多了一个tag参数，系统在要求的内存外额外地多分配了4字节的标签。在调试的时候，可以找到是否有标有这个标签的内存没有被释放。
以上4个函数都需要指定PoolType，分别可以指定如下几种：
● NonPagedPool：指定要求分配非分页内存。
● PagedPool：指定要求分配分页内存。
● NonPagedPoolMustSucceed：指定分配非分页内存，必须成功。
● DontUseThisType：未指定。
● NonPagedPoolCacheAligned：指定要求分配非分页内存，而且必须内存对齐。
● PagedPoolCacheAligned：指定分配分页内存，而且必须内存对齐。
● NonPagedPoolCacheAlignedMustS：指定分配非分页内存，而且必须对齐，且必须成功。

将分配的内存进行回收的函数是ExFreePool和ExFreePoolWithTag，他们的原型是：




    //  
      
    NTKERNELAPI  
    VOID  
    ExFreePoolWithTag(  
        __in __drv_freesMem(Mem) PVOID P,   // 要释放的地址  
        __in ULONG Tag  
        );  
      
    #define ExFreePool(a) ExFreePoolWithTag(a,0)  
      
    //  

//

NTKERNELAPI
VOID
ExFreePoolWithTag(
    __in __drv_freesMem(Mem) PVOID P,   // 要释放的地址
    __in ULONG Tag
    );

#define ExFreePool(a) ExFreePoolWithTag(a,0)

//


# 二、在驱动中使用链表

WDK提供了两种链表：单向链表、双向链表。
单项链表每个元素有一个Next指针指向下一个元素。双向链表每隔元素有两个指：：BLINK指向前一个元素，FLINK指向下一个元素。

1. 链表结构




    // WDK中定义的双向链表数据结构  
      
    //  
    //  Doubly linked list structure.  Can be used as either a list head, or  
    //  as link words.  
    //  
      
    typedef struct _LIST_ENTRY {  
       struct _LIST_ENTRY *Flink;  
       struct _LIST_ENTRY *Blink;  
    } LIST_ENTRY, *PLIST_ENTRY, *RESTRICTED_POINTER PRLIST_ENTRY;  
      
    //  
    //  Singly linked list structure. Can be used as either a list head, or  
    //  as link words.  
    //  
      
    typedef struct _SINGLE_LIST_ENTRY {  
        struct _SINGLE_LIST_ENTRY *Next;  
    } SINGLE_LIST_ENTRY, *PSINGLE_LIST_ENTRY;  
      
    //   

// WDK中定义的双向链表数据结构

//
//  Doubly linked list structure.  Can be used as either a list head, or
//  as link words.
//

typedef struct _LIST_ENTRY {
   struct _LIST_ENTRY *Flink;
   struct _LIST_ENTRY *Blink;
} LIST_ENTRY, *PLIST_ENTRY, *RESTRICTED_POINTER PRLIST_ENTRY;

//
//  Singly linked list structure. Can be used as either a list head, or
//  as link words.
//

typedef struct _SINGLE_LIST_ENTRY {
    struct _SINGLE_LIST_ENTRY *Next;
} SINGLE_LIST_ENTRY, *PSINGLE_LIST_ENTRY;

//
  1. 链表初始化
    初始化链表头用InitializeListHead宏实现。让双向链表的两个指针都指向自己。
    判断链表是否为空，只用判断链表指针是否指向自己即可。WDK提供了一个IsListEmpty。
    程序员需要自己定义链表每个元素的数据类型，并将LIST_ENTRY结构作为自动以结构的一个子域。LIST_ENTRY的作用是将自定义的数据结构串成一个链表。


    //  
      
    typedef struct _MYDATASTRUCT{  
        // List Entry要作为_MYDATASTRUCT结构体的一部分  
        LIST_ENTRY ListEntry;  
      
        // 自己定义的数据  
        ULONG x;  
        ULONG y;  
    };  
      
    //  

//

typedef struct _MYDATASTRUCT{
    // List Entry要作为_MYDATASTRUCT结构体的一部分
    LIST_ENTRY ListEntry;

    // 自己定义的数据
    ULONG x;
    ULONG y;
};

//


3. 从首部插入链表
    在头部插入链表使用语句InsertHeadList。

[cpp] view plain copy
print?

    //  
      
    InsertHeadList(&head, &mydata->ListEntry);  
      
    //  

//

InsertHeadList(&head, &mydata->ListEntry);

//





head是LIST_ENTRY结构的链表头，mydata是用户定义的数据结构，它的子域ListEntry是包含其中的LIST_ENTRY数据结构。
  1. 从尾部插入链表
    在尾部插入链表使用语句InsertTailList。
  //  
      
    InsertTailList(&head, &mydata->ListEntry);  
      
    //  

//

InsertTailList(&head, &mydata->ListEntry);

//

head是LIST_ENTRY结构的链表头，mydata是用户定义的数据结构，它的子域ListEntry是包含其中的LIST_ENTRY数据结构。
  1. 从链表删除
    从链表删除元素也是分两种。一种是从链表头部删除，一种是从链表尾部删除。分别队形RemoveHeadList和RemoveTailList函数。

//

PLIST_ENTRY pEntry = RemoveHeadList(&head);  
PLIST_ENTRY pEntry = RemoveTailList(&tail);  
  
//

//


PLIST_ENTRY pEntry = RemoveHeadList(&head);
PLIST_ENTRY pEntry = RemoveTailList(&tail);

//



head是链表头，pEntry是从链表删除下来的元素中的ListEntry。
如果用户自定义的数据结构第一个字段是LIST_ENTRY时，返回的指针可以强制转换为用户的数据结构指针。
如果第一个字段不是LIST_ENTRY时，需要减去偏移量。为了简化操作WDK提供了宏CONTAINING_RECORD，其用法如下：

   //  
      
    PLIST_ENTRY pEntry = RemoveHeadList(&head);  
    PIRP pIrp = CONTAINING_RECORD(pEntry, MYDATASTRUCT, ListEntry);  
      
    //  

//

PLIST_ENTRY pEntry = RemoveHeadList(&head);
PIRP pIrp = CONTAINING_RECORD(pEntry, MYDATASTRUCT, ListEntry);

//

ListEntry为自定义的数据结构指针。

三、 Lookaside结构

频繁申请和回收内存，会导致在内存上产生大量内存“空洞”，导致无法申请新的内存。WDK为程序员提供了Lookaside结构来解决此问题。

  1. 频繁申请内存的弊端
    频繁的申请与释放内存，会导致内存产生大量碎片。即使内存中有大量的可用内存，也会导致没有足够的连续内存空间而导致申请内存失败。在操作系统空闲的时候，系统会整理内存中的碎片，将碎片合并。

  2. 使用Lookaside
    Lookaside对象可以理解成一个内存容器。在初始的时候，它先向Windows申请量一块比较大的内存。以后程序员每次申请的时候就不直接向Windows申请内存了，而是直接向Lookaside对象申请呢村。Lookaside对象智能的避免产生内存碎片。
    如果Lookaside内部内存不够用时它会向操作系统申请更多的内存。当Lookaside有大量内存未被使用时，它会让Windows回收部分内存。使用Lookaside申请内存效率要高于直接向Windows申请内存。
    Lookaside一般在以下情况使用：
    a. 程序员每次申请固定大小的内存；
    b. 申请和回收操作非常频繁。

    使用Lookaside对象，首先要进行初始化：

    // WDK提供的Lookaside初始化函数  
      
    VOID ExInitializeNPagedLookasideList(  
        IN PNPAGED_LOOKASIDE_LIST  Lookaside,  
        IN PALLOCATE_FUNCTION  Allocate  OPTIONAL,  
        IN PFREE_FUNCTION  Free  OPTIONAL,  
        IN ULONG  Flags,  
        IN SIZE_T  Size,  
        IN ULONG  Tag,  
        IN USHORT  Depth);  
      
    VOID ExInitializePagedLookasideList(  
        IN PPAGED_LOOKASIDE_LIST  Lookaside,  
        IN PALLOCATE_FUNCTION  Allocate  OPTIONAL,  
        IN PFREE_FUNCTION  Free  OPTIONAL,  
        IN ULONG  Flags,  
        IN SIZE_T  Size,  
        IN ULONG  Tag,  
        IN USHORT  Depth);  
      
    //   

// WDK提供的Lookaside初始化函数

VOID ExInitializeNPagedLookasideList(
    IN PNPAGED_LOOKASIDE_LIST  Lookaside,
    IN PALLOCATE_FUNCTION  Allocate  OPTIONAL,
    IN PFREE_FUNCTION  Free  OPTIONAL,
    IN ULONG  Flags,
    IN SIZE_T  Size,
    IN ULONG  Tag,
    IN USHORT  Depth);

VOID ExInitializePagedLookasideList(
    IN PPAGED_LOOKASIDE_LIST  Lookaside,
    IN PALLOCATE_FUNCTION  Allocate  OPTIONAL,
    IN PFREE_FUNCTION  Free  OPTIONAL,
    IN ULONG  Flags,
    IN SIZE_T  Size,
    IN ULONG  Tag,
    IN USHORT  Depth);

// 

这两个函数分别是对非分页内存和分页内存的申请。内存回收可用以下函数

    //   
      
    VOID   
      ExFreeToNPagedLookasideList(  
        IN PNPAGED_LOOKASIDE_LIST  Lookaside,  
        IN PVOID  Entry);  
      
    VOID   
      ExFreeToPagedLookasideList(  
        IN PPAGED_LOOKASIDE_LIST  Lookaside,  
        IN PVOID  Entry);  
      
    //   

// 

VOID 
  ExFreeToNPagedLookasideList(
    IN PNPAGED_LOOKASIDE_LIST  Lookaside,
    IN PVOID  Entry);

VOID 
  ExFreeToPagedLookasideList(
    IN PPAGED_LOOKASIDE_LIST  Lookaside,
    IN PVOID  Entry);

// 

它们是用于回收非分页内存与分页内存。
在使用完Lookaside对象后，需要删除Lookaside对象，有以下两个函数：

   //   
      
    VOID ExDeleteNPagedLookasideList(IN PNPAGED_LOOKASIDE_LIST  Lookaside);  
      
    VOID ExDeletePagedLookasideList(IN PPAGED_LOOKASIDE_LIST  Lookaside);  
      
    //   

// 

VOID ExDeleteNPagedLookasideList(IN PNPAGED_LOOKASIDE_LIST  Lookaside);

VOID ExDeletePagedLookasideList(IN PPAGED_LOOKASIDE_LIST  Lookaside);

// 

这两个函数分别删除非分页与分页的Lookaside对象。

Lookaside结构

频繁的申请和回收内存，会导致在内存上产生大量的内存“空洞”，从而导致最终无法申请内存。DDK为程序员提供了Lookaside结构来解决这个问题。

我们可以将Lookaside对象看成是一个内存容器。在初始化的时候，它先向Windows申请了一块比较大的内存。以后程序员每次申请内存的时候，不是直接向Windows申请内存，而是想Lookaside对象申请内存。Looaside会智能的避免产生内存“空洞”。如果Lookaside对象内部内存不够用时，它会向操作系统申请更多的内存。

Lookaside一般会在以下情况下使用：

  1.   程序员每次申请固定大小的内存。

  2.   申请和回收的操作十分频繁。

要使用Looaside对象，首先要初始化Lookaside对象，有以下两个函数可以使用：

（1）VOID    ExInitializeNPagedLookasideList(     IN PNPAGED_LOOKASIDE_LIST  Lookaside,     IN PALLOCATE_FUNCTION  Allocate  OPTIONAL,     IN PFREE_FUNCTION  Free  OPTIONAL,     IN ULONG  Flags,     IN SIZE_T  Size,     IN ULONG  Tag,     IN USHORT  Depth     );

（2）VOID    ExInitializePagedLookasideList(     IN PPAGED_LOOKASIDE_LIST  Lookaside,     IN PALLOCATE_FUNCTION  Allocate  OPTIONAL,     IN PFREE_FUNCTION  Free  OPTIONAL,     IN ULONG  Flags,     IN SIZE_T  Size,     IN ULONG  Tag,     IN USHORT  Depth     );

初始化玩Lookaside对象后，可以进行申请内存的操作了：



（1）PVOID      ExAllocateFromNPagedLookasideList(     IN PNPAGED_LOOKASIDE_LIST  Lookaside     );
（2）PVOID    ExAllocateFromPagedLookasideList(     IN PPAGED_LOOKASIDE_LIST  Lookaside     );

对Lookaside对象回收内存：

（1）VOID ExFreeToNPagedLookasideList( IN PNPAGED_LOOKASIDE_LIST Lookaside, IN PVOID Entry )；

（2）VOID ExFreeToPagedLookasideList( IN PPAGED_LOOKASIDE_LIST Lookaside, IN PVOID Entry );

在使用完Lookaside对象后，要删除Lookaside对象：

（1）VOID ExDeleteNPagedLookasideList( IN PNPAGED_LOOKASIDE_LIST Lookaside );

(2) VOID ExDeletePagedLookasideList( IN PPAGED_LOOKASIDE_LIST Lookaside );

测试代码：

#pragma INITCODE

VOID LookasideTets()

{

     KdPrint(("进入LookasideTest函数！\n"));

     PAGED_LOOKASIDE_LIST  Lookaside;

     ExInitializePagedLookasideList(&Lookaside,NULL, NULL, 0, sizeof(MYDATASTRUCT), 'abcd', 0);

     PMYDATASTRUCT pMyData[50];

     for (inti=0; i<50; i++)

     {

         pMyData[i] = (PMYDATASTRUCT)ExAllocateFromPagedLookasideList(&Lookaside);

         if ((i+1)%10 == 0)

         {

 

              KdPrint(("申请了 %d 个数据了!\n", ++i));

         }

     }

     for (inti=0; i<50; i++)

     {

         ExFreeToPagedLookasideList(&Lookaside,pMyData[i]);

         pMyData[i] =NULL;

         if ((i+1)%10 == 0)

         {

              KdPrint(("释放了 %d 个数据的内存了!\n", ++i));

         }

     }

     ExDeletePagedLookasideList(&Lookaside);

}

2.运行时函数

（1）内存间复制（非重叠）

VOID RtlCopyMemory( IN VOID UNALIGNED *Destination, IN CONST VOID UNALIGNED *Source, IN SIZE_T Length );

（2）内存间复制（可重叠）

VOID RtlMoveMemory( IN VOID UNALIGNED *Destination, IN CONST VOID UNALIGNED *Source, IN SIZE_T Length );

（3）填充内存

VOID RtlFillMemory( IN VOID UNALIGNED *Destination, IN SIZE_T Length, IN UCHAR Fill );

VOID RtlZeroMemory( IN VOID UNALIGNED *Destination, IN SIZE_T Length );

（4）内存比较

SIZE_T RtlCompareMemory( IN CONST VOID *Source1, IN CONST VOID *Source2, IN SIZE_T Length );

ULONG RtlEqualMemory( CONST VOID *Source1, CONST VOID *Source2, SIZE_T Length );

测试代码：

#define BUFFER_SIZE 1024

#pragma INITCODE

VOID RtlTest()

{

     KdPrint(("进入RtlTest函数！\n"));

     PUCHAR pBuffer1 = (PUCHAR)ExAllocatePool(PagedPool,BUFFER_SIZE);

     RtlZeroMemory(pBuffer1,BUFFER_SIZE);

     PUCHAR pBuffer2 = (PUCHAR)ExAllocatePool(PagedPool,BUFFER_SIZE);

     RtlFillMemory(pBuffer2,BUFFER_SIZE, 0xAA);

     RtlCopyMemory(pBuffer1,pBuffer2, BUFFER_SIZE);

    

     if (RtlEqualMemory(pBuffer1,pBuffer2, BUFFER_SIZE))

     {

         KdPrint(("两块内存块数据一样！\n"));

         for(inti=0; i<BUFFER_SIZE;i++)

         {

              KdPrint(("%02X", pBuffer1[i]));

         }

        

     }

     else

     {

         KdPrint(("两块内存块数据不一样！\n"));

     }

     KdPrint(("离开RtlTest函数！\n"));

}
驱动开发系列08 - 驱动程序如何分配内存
GPU全栈博主
07-22 2154
Linux 内核提供了丰富的内存分配函数、在本文中，我们将介绍在设备驱动程序中分配和使用内存的方法，以及如何优化系统的内存资源。由于内核为驱动程序提供了统一的内存管理接口。所以我们不会去讨论不同架构是如何管理内存的，文本不涉及分段、分页等问题，此外在本文中，我们也不会描述Linux内存管理的内部细节，这在驱动开发系列06 - 内存映射和DMA已经介绍过了，感兴趣的读者可以前往了解。kmalloc 是一个功能强大的内存分配函数，由于它与 malloc 相似，因此很容易学习。
Windows驱动开发(二)申请内存
qq_33789853的博客
03-10 1460
接前文Windows驱动开发(一) MDL驱动读写 下面是驱动申请内存 NTSTATUS AllocMemory(IN ULONG ProcessPid, IN SIZE_T Length, OUT PVOID Buffer) { NTSTATUS Status = STATUS_SUCCESS; PEPROCESS pEProcess = NULL; KAPC_STATE ApcState = { 0 }; PVOID BaseAddress = NULL; Status = PsLookup
Windows驱动内存操作
PwnGuo的博客
05-25 2793
内存复制 内存复制分两种情况，非重叠和可重叠 如图：当复制A~C到B~D段内存b-c段内存重叠 RtlCopyMemory为非重叠复制，即不能使用RtlCopyMemory操作上图中的内存段，RtlMoveMemory为可重叠复制，此函数对内存是否重叠进行判断。 void RtlCopyMemory( Destination, //表示要复制内存的目的地址 Sourc...
Windows内核编程基础之内存的分配与释放
知其所以然
08-26 3198
内存泄漏是C语言中一个臭名昭著的问题。但是作为内核开发者，读者将有必要自己来面对它。在传统的C语言中，分配内存常常使用的函数是：malloc，这个函数的使用非常简单，传入长度参数就得到内存空间。在驱动中使用内存分配，这个函数不再有效。驱动中分配内存，最常用的是调用ExAllocatePoolWithTag,其他的方法在本章范围内全部忽略。回忆前一节关于字符串处理的情况。一个字符串被复制到另一个字符
驱动开发 判断内存是否可读 可写
05-17 706
MmIsAddressValid 内存可读 返回真(使用这个家伙最好带上__try __exception) 写入内存直接开启cr0 写就OK了 转载于:https://www.cnblogs.com/kuangke/p/5501361.html
Windows驱动开发框架WDF源码，来自微软Github
12-18
Windows驱动开发框架（Windows Driver Framework，简称WDF）是微软推出的一种现代化的驱动程序开发模型，旨在简化驱动程序的编写，提高驱动程序的稳定性和安全性。这个框架建立在Windows Driver Model（WDM）的基础...
Windows内核安全与驱动开发 随书源码.rar
06-18
Windows驱动开发主要包括用户模式驱动和内核模式驱动。用户模式驱动运行在较低权限级别，安全性相对较高，但性能受限；而内核模式驱动则拥有更高的权限，可以更直接地访问硬件，但同时也增加了安全风险。 在Windows...
Windows内核安全与驱动开发 代码 谭文 陈铭霖
08-29
《Windows内核安全与驱动开发》是一本深入探讨Windows操作系统内核安全机制和驱动程序开发的专业书籍。由谭文和陈铭霖两位作者共同撰写，旨在帮助读者理解并掌握Windows系统内部的工作原理，以及如何安全地进行驱动...
34个windows vxd驱动开发示例源代码.zip
06-14
这些示例代码对于那些希望深入理解Windows 9x内核机制和驱动开发的人员来说，是非常宝贵的参考资料。不过需要注意的是，由于Windows 9x已经过时，这些技术主要适用于历史研究和教育目的，现代操作系统通常使用更高...
Windows驱动开发技术详解.( 张帆,史彩成)_添加目录完整版
09-05
Windows驱动开发技术详解是一本专注于Windows操作系统下的驱动程序开发的专业技术书籍。本书的作者张帆和史彩成，通过使用微软提供的驱动开发工具包（Driver Development Kit，简称DDK），向读者展示如何从零开始，...
Windows内核驱动API大全.pdf
04-10
Windows内核驱动API大约有两千多个，仅有函数名，没有函数原型
驱动开发：通过内存拷贝读写内存
优快云
09-25 1万+
内核中读写内存的方式有很多，典型的读写方式有CR3读写，MDL读写，以及今天要给大家分享的内存拷贝实现读写，拷贝读写的核心是使用`MmCopyVirtualMemory`这个内核API函数实现，通过调用该函数即可很容易的实现内存的拷贝读写。 MmCopyVirtualMemory是Windows内核中一个非常有用的函数，它可以在用户空间和内核空间之间实现内存数据的拷贝。这个函数通过复制内存页表并更新它们来实现拷贝，从而实现了高效的内存拷贝操作。使用MmCopyVirtualMemory可以省去手动复制内存
如何在WINDOWS内核中为结构体申请内存
weixin_35749796的博客
01-06 236
在 Windows 内核中为结构体申请内存，可以使用内存分配函数来实现。常用的内存分配函数有 ExAllocatePoolWithTag 和 ExAllocatePoolWithQuotaTag。 使用方法如下： #include <wdm.h> // 为结构体 MyStruct 申请内存 MyStruct *pStruct; pStruct = (MyStruct *)ExAl...
驱动的一点体会
不论你在什么时候开始，重要的是开始之后就不要停止。
10-20 3101
一.驱动程序介绍 Windows 环境下，应用程序访问硬件设备需要通过设备驱动程序。 在Windows 95/98下，驱动程序通常是一个Vxd文件；而在Windows NT下， 驱动程序则是一个Sys文件。虽然这两个操作系统都是出自微软门下， 但其使用的驱动程序结构是完全不同的，因此当一个硬件产品需要在以 上两种操作系统下都能运行时，就需要分别编写其特定环境下的驱驱 动程序。驱动程序的编写是一件相
Windows内核编程基础（3）
最新发布
zhaotianff的专栏
09-25 1151
类型的内存属性为“可执行”,意味着开发者可以将这块内存写入二进制指令然后执行，这个机制虽然很灵活，但存在一定的安全隐患︰对于一些存在漏洞的代码来说,攻击者可以使用“缓存区溢出攻击”技术，在目标内存（缓冲区）中写入可执行指令，由于这块内存具有“可执行“属性，所以攻击者可以成功实施攻击。上更小粒度的分割，这个分割由堆管理器管理，根据需求，堆管理器会申请 一页（或多页虚拟内存），然后对这块虚拟内存进行更小粒度的内存分割与管理，以满足开发者对内存的需求。标志对应的内存大小，找到最大的或者持续增长的内存块。
[Win驱动3] Windows内核态的堆管理, LookAside，链表以及运行时函数
輚至消亡
10-08 582
内存机制简述 现代操作系统一般都有分页机制，其控制方式是通过Cr0控制寄存器中的PG位，如果PG位置位则表示分页机制开启，这种机制在还未进入保护模式时就已经确定了。在32位的CPU下，假设是4KB为一页，则4GB内存可以被分成2^20个页，并且通过页表来映射到各个进程或者磁盘上去。同一页可以映射到多个进程的虚拟内存空间中。 内核态堆空间分配 内核态中可以分配分页内存以及非分页的内存, 分页内存是CPU开启分页机制时才存在，如果没有开启分页机制，所有内存都是非分页的。 分页机制作用主要是为了给进程一个
win10驱动开发7——分页快查表（LOOKASIDE）
qq_41610493的博客
11-30 497
非分页 分页 ExInitializeNPagedLookasideLIst ExInitializePagedLookasideLIst ExAllocateFromNPagedLookasideList ExAllocateFromPagedLookasideList ExFreeToNPagedLookasideList ExFreeToPagedLookasideList ExDeleteNPagedLookasideList ExDeletePagedLookaside...
windows驱动程序中的预处理含义
05-21 146
#pragma code_seg(“PAGE”) 作用是将此部分代码放入分页内存中运行。 #pragma code_seg() 将代码段设置为默认的代码段 #pragma code_seg("INIT") 加载到INIT内存区域中，成功加载后，可以退出内存 转自：http://blog.youkuaiyun.com/whatday/article/details/710...
Page Size
热门推荐
小GIS的成长日记
01-03 1万+
看好多论文和源码中都有Page Size的概念，我却一直比较模糊，今天特地仔细查了一下。基本概念 Traditionally, pages in a system had uniform size, for example 4096 bytes.一般来说，系统中页的大小是规定好的，比如说4096B，也即4KB页的内部分段When transferring from disk, much of the delay is caused by seek time, the time it takes to cor
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值