19、Windows内存管理

1、虚拟地址

Windows的所有程序（ring0,ring3），可以操作的都是虚拟内存。CPU中寄存器CR0一个位PG位来告诉系统是否分页的。1为允许分页。DDK中宏PAGE_SIZE记录着分页大小，一般为4K，4GB的虚拟内存会被分割成1M个单元。

图 物理内存的映射 P120

2、两种模式

4G虚拟地址中，低2G为用户模式，高2G为内核模式。Windows规定用户态程序只能访问用户模式地址，而内核态程序可以访问整个4G虚拟地址。[1]

进程切换时，所有进程的内核地址映射完全一致，进程切换时改变,只是改变用户模式地址的映射。

图 两种模式 P121

Windwos驱动程序里的不同例程运行在不同的进程中。

打印当前进程的进程名：

void DisplayItsProcessName()

{

PEPROCESS pEProcess = PsGetCurrentProcess();

PTSTR = ProcessName = (PTSTR)((ULONG)pEProcess + 0x174);

KdPrint(("%s\n", ProcessName));

}

3、分页与非分页内存

可以交换到文件中的虚拟内存页面称为分页内存，否则称为非分页内存。当程序的中断请求级大于等于DISPATCH_LEVEL时，程序只能使用非分页内存。

#define PAGEDCODE code_seg("PAGE")

#define LOCKEDCODE code_seg()

#define INITCODE code_seg("INIT")

#define PAGEDDATA data_seg("PAGE")

#define LOCKEDDATA data_seg()

#define INITDATA data_seg("INIT")

将PAGEDCODE 等放在函数前来表现是可否可以分页等情况。PAGED_CODE()是DDK提供的宏，它只在check版本中生效，来检查运行是否低于DISPATCH_LEVEL的中断请求级，如果不低于则产生断言。

4、驱动程序不适合递归调用或者局部变量是大型结构体。如果需要大型结构体，请使用堆。

ExAllocatePool

ExAllocatePoolWithTag

ExAllocatePoolWithQuotaTag

ExAllocatePoolWithQuota

5、链表

双向链表有两个指针，BLINK指向前一个元素，FLINK指向下一个元素。

IsListEmpty

InitializeListHead

typedef struct _LIST_ENTRY {

struct _LIST_ENTRY *Flink;

struct _LIST_ENTRY *Blink;

} LIST_ENTRY, *PLIST_ENTRY;程序员需要自己定义链表中每个元素的数据类型，并将LIST_ENTRY结构作为自定义结构的一个子域。LIST_ENTRY的作用是将自定义的数据结构串与一个链表。

InsertHeadList

图 插入前链表状态

图 插入后

InsertTailList

RemoveHeadList

RemoveTailList

和插入链表有两种方法一样，删除链表也有两种方法，一种是从头部删除，另外一种是尾部删除。

不过有一个问题如下：

PLIST_ENTRY RemoveHeadList(

__inout PLIST_ENTRY ListHead

);

RemoveHeadList returns a pointer to the entry removed from the list. If the list is empty, RemoveHeadList returns ListHead.

也就是说这个函数返回的是一个指针，指向从链表中删除下来的元素中的LIST_ENTRY，那么如何得到用户自定义的数据结构的指针呢？；如果 LIST_ENTRY放在一个结构体的首部，那么返回的这个地址就等于用户自定义的数据结构的指针；而如果LIST_ENTRY不放在结构体的首部呢？这时，我们用地址偏移来实现。一个宏如下定义：

PCHAR CONTAINING_RECORD(

[in] PCHAR Address,

[in] TYPE Type,

[in] PCHAR Field

);

如下实现：

#define CONTAINING_RECORD(address, type, field) ((type *)( \

(PCHAR)(address) - \

(ULONG_PTR)(&((type *)0)->field)))

VOID LinkListTest()
{
LIST_ENTRY linkListHead;
 //初始化链表
 InitializeListHead(&linkListHead);
PMYDATASTRUCT pData;
ULONG i = 0;
 //在链表中插入10个元素
 KdPrint(("Begin insert to link list"));
 for (i=0 ; i<10 ; i++)
{
pData = (PMYDATASTRUCT)
ExAllocatePool(PagedPool,sizeof(MYDATASTRUCT));
pData->number = i;
InsertHeadList(&linkListHead,&pData->ListEntry);
}

 //从链表中取出，并显示
 KdPrint(("Begin remove from link list\n"));
 while(!IsListEmpty(&linkListHead))
{
PLIST_ENTRY pEntry = RemoveTailList(&linkListHead);
pData = CONTAINING_RECORD(pEntry,
MYDATASTRUCT,
ListEntry);
KdPrint(("%d\n",pData->number));
ExFreePool(pData);
}
}

4、Lookaside结构

如果驱动程序频繁地从内存中申请回收固定大小的内存，可以使用Lookaside对象。可以将Lookaside对象想象成一个自动的内存分配容器。避免产生内存空洞。

1）初始化：

ExInitializeNPagedLookasideList

ExInitializePagedLookasideList

2）初始完内存后，可以申请内存了：

ExAllocateFromNPagedLookasideList

ExAllocateFromPagedLookasideList

3）回收内存

ExFreeToNPagedLookasideList

ExFreeToPagedLookasideList

4）删除Lookaside对象

ExDeleteNPagedLookasideList

ExDeletePagedLookasideList

一个例子如下：

VOID LookasideTest()
{
//初始化Lookaside对象
PAGED_LOOKASIDE_LIST pageList;
ExInitializePagedLookasideList(&pageList,NULL,NULL,0,sizeof(MYDATASTRUCT),'1234',0);
#define ARRAY_NUMBER 50
PMYDATASTRUCT MyObjectArray[ARRAY_NUMBER];
//模拟频繁申请内存
for (int i=0;i<ARRAY_NUMBER;i++)
{
MyObjectArray[i] = (PMYDATASTRUCT)ExAllocateFromPagedLookasideList(&pageList);
}
//模拟频繁回收内存
for (i=0;i<ARRAY_NUMBER;i++)
{
ExFreeToPagedLookasideList(&pageList,MyObjectArray[i]);
MyObjectArray[i] = NULL;
}
ExDeletePagedLookasideList(&pageList);
//删除Lookaside对象
}

5、运行时函数

由编译器提供，不同操作系统实现不同，但是接口一样，如malloc。

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

RtlCopyMemory

2）可重叠复制

RtlMoveMemory

3）填充内存

RtlFillMemory

RtlZeroMemory

3）内存比较

RtlCompareMemory

DDK提供的运行时函数都是RtlXX形式。

6、使用C++特性分配内存

不能直接使用new和delete。因为MS编译器没有提供内核模式下的new操作符，我们可以对其进行重载来使用。

重载有两种方法，一种是类中重载，一种全局重载。

//全局new操作符
void * __cdecl operator new(size_t size,POOL_TYPE PoolType=PagedPool)
{
    KdPrint(("global operator new\n"));
    KdPrint(("Allocate size :%d\n",size));
    return ExAllocatePool(PagedPool,size);
}
//全局delete操作符
void __cdecl operator delete(void* pointer)
{
    KdPrint(("Global delete operator\n"));
    ExFreePool(pointer);
}

class TestClass
{
public:
    //构造函数
    TestClass()
    {
        KdPrint(("TestClass::TestClass()\n"));
    }

    //析构函数
    ~TestClass()
    {
        KdPrint(("TestClass::~TestClass()\n"));
    }

    //类中的new操作符
    void* operator new(size_t size,POOL_TYPE PoolType=PagedPool)
    {
        KdPrint(("TestClass::new\n"));
        KdPrint(("Allocate size :%d\n",size));
        return ExAllocatePool(PoolType,size);
    }

    //类中的delete操作符
    void operator delete(void* pointer)
    {
        KdPrint(("TestClass::delete\n"));
        ExFreePool(pointer);
    }
private:
    char buffer[1024];
};


void TestNewOperator()
{
    TestClass* pTestClass = new TestClass;
    delete pTestClass;

    pTestClass = new(NonPagedPool) TestClass;
    delete pTestClass;

    char *pBuffer = new(PagedPool) char[100];
    delete []pBuffer;

    pBuffer = new(NonPagedPool) char[100];
    delete []pBuffer;
}

7、其它

1）NTSTATUS含义

图 NTSTATUS含义 P141

2）检查内存可用性

ProbeForRead

ProbeForWrite

如果不满足条件时将是引发异常。用异常处理机制进行捕获。

3）结构化异常处理

异常概念类似于中断

A）try-except块

try-except-statement :

__try

{

compound-statement

}

__except ( expression )

{

compound-statement

}

EXCEPTION_CONTINUE_EXECUTION

EXCEPTION_CONTINUE_SEARCH

EXCEPTION_EXECUTE_HANDLER

例子如下：

#pragma INITCODE
VOID ProbeTest()
{
PVOID badPointer = NULL;
KdPrint(("Enter ProbeTest\n"));
__try
{
KdPrint(("Enter __try block\n"));
//判断空指针是否可读，显然会导致异常
ProbeForWrite(badPointer,100,4);
//由于在上面引发异常，所以以后语句不会被执行!
KdPrint(("Leave __try block\n"));
}

__except(EXCEPTION_EXECUTE_HANDLER)
{
KdPrint(("Catch the exception\n"));
KdPrint(("The program will keep going\n"));
}
//该语句会被执行
KdPrint(("Leave ProbeTest\n"));
}

其它引发异常函数：

ExRaiseAccessViolation

ExRaiseDatatypeMisalignment

ExRaiseStatus

B）try-finally 块

try-finally-statement :

__try compound-statement

__finally compound-statement

强迫函数有退出前执行一段代码。常用来一些资源的回收工作。

#pragma INITCODE
NTSTATUS TryFinallyTest()
{
NTSTATUS status = STATUS_SUCCESS;
__try
{
//做一些事情
return STATUS_SUCCESS;
}
__finally
{
KdPrint(("Enter finallly block\n"));
return status;
}
}

4）防止“侧效”错误（也就是多行宏在if等语句中表达的意思出现了不同），在if,while,for等语句中，无论是否只有一句话，都不能省略{}。

ASSERT断言

参考：

【１】 windows驱动开发详解