内存与链表

2.1内存的分配与释放

    内存泄漏是C语言中一个臭名昭著的问题。但是作为内核开发者，读者将有必要自己来面对它。在传统的C语言中，分配内存常常使用的函数是malloc。这个函数的使用非常简单，传入长度参数就得到内存空间。在驱动中使用内存分配，这个函数不再有效。驱动中分配内存，最常用的是调用ExAllocatePoolWithTag。其他的方法在本章范围内全部忽略。回忆前一小节关于字符串的处理的情况。一个字符串被复制到另一个字符串的时候，最好根据源字符串的空间长度来分配目标字符串的长度。下面的举例，是把一个字符串src拷贝到字符串dst。

   

    // 定义一个内存分配标记

    #define MEM_TAG ‘MyTt’

    // 目标字符串，接下来它需要分配空间。

    UNICODE_STRING dst = { 0 };

    // 分配空间给目标字符串。根据源字符串的长度。

    dst.Buffer =

        (PWCHAR)ExAllocatePoolWithTag(NonpagedPool,src->Length,MEM_TAG);

    if(dst.Buffer == NULL)

    {

        // 错误处理

        status = STATUS_INSUFFICIENT_RESOUCRES;

        ……

    }

    dst.Length = dst.MaximumLength = src->Length;

    status = RtlCopyUnicodeString(&dst,&src);

    ASSERT(status == STATUS_SUCCESS);

 

    ExAllocatePoolWithTag的第一个参数NonpagedPool表明分配的内存是锁定内存。这些内存永远真实存在于物理内存上。不会被分页交换到硬盘上去。第二个参数是长度。第三个参数是一个所谓的“内存分配标记”。

    内存分配标记用于检测内存泄漏。想象一下，我们根据占用越来越多的内存的分配标记，就能大概知道泄漏的来源。一般每个驱动程序定义一个自己的内存标记。也可以在每个模块中定义单独的内存标记。内存标记是随意的32位数字。即使冲突也不会有什么问题。

    此外也可以分配可分页内存，使用PagedPool即可。

    ExAllocatePoolWithTag分配的内存可以使用ExFreePool来释放。如果不释放，则永远泄漏。并不像用户进程关闭后自动释放所有分配的空间。即使驱动程序动态卸载，也不能释放空间。唯一的办法是重启计算机。

    ExFreePool只需要提供需要释放的指针即可。举例如下：

 

    ExFreePool(dst.Buffer);

    dst.Buffer = NULL;

    dst.Length = dst.MaximumLength = 0;

   

    ExFreePool不能用来释放一个栈空间的指针。否则系统立刻崩溃。像以下的代码：

 

    UNICODE_STRING src = RTL_CONST_STRING(L”My source string!”);

    ExFreePool(src.Buffer);

 

    会招来立刻蓝屏。所以请务必保持ExAllocatePoolWithTag和ExFreePool的成对关系。

 

2.2 使用LIST_ENTRY

    Windows的内核开发者们自己开发了部分数据结构，比如说LIST_ENTRY。

    LIST_ENTRY是一个双向链表结构。它总是在使用的时候，被插入到已有的数据结构中。下面举一个例子。我构筑一个链表，这个链表的每个节点，是一个文件名和一个文件大小两个数据成员组成的结构。此外有一个FILE_OBJECT的指针对象。在驱动中，这代表一个文件对象。本书后面的章节会详细解释。这个链表的作用是：保存了文件的文件名和长度。只要传入FILE_OBJECT的指针，使用者就可以遍历链表找到文件名和文件长度。

 

    typedef struct {

        PFILE_OBJECT file_object;

        UNICODE_STRING file_name;

        LARGE_INTEGER file_length;

    } MY_FILE_INFOR, *PMY_FILE_INFOR;

 

    一些读者会马上注意到文件的长度用LARGE_INTEGER表示。这是一个代表长长整型的数据结构。这个结构我们在下一小小节“使用长长整型数据”中介绍。

    为了让上面的结构成为链表节点，我必须在里面插入一个LIST_ENTRY结构。至于插入的位置并无所谓。可以放在最前，也可以放中间，或者最后面。但是实际上读者很快会发现把LIST_ENTRY放在开头是最简单的做法：

 

    typedef struct {

        LIST_ENTRY list_entry;

        PFILE_OBJECT file_object;

        UNICODE_STRING file_name;

        LARGE_INTEGER file_length;

    } MY_FILE_INFOR, *PMY_FILE_INFOR;  

 

    list_entry如果是作为链表的头，在使用之前，必须调用InitializeListHead来初始化。下面是示例的代码：

 

    // 我们的链表头

    LIST_ENTRY      my_list_head;

 

    // 链表头初始化。一般的说在应该在程序入口处调用一下

    void MyFileInforInilt()

    {

        InitializeListHead(&my_list_head);

    }

 

    // 我们的链表节点。里面保存一个文件名和一个文件长度信息。

    typedef struct {

        LIST_ENTRY list_entry;

        PFILE_OBJECT file_object;

        PUNICODE_STRING file_name;

        LARGE_INTEGER file_length;

    } MY_FILE_INFOR, *PMY_FILE_INFOR;

 

    // 追加一条信息。也就是增加一个链表节点。请注意file_name是外面分配的。

    // 内存由使用者管理。本链表并不管理它。

    NTSTATUS MyFileInforAppendNode(

        PFILE_OBJECT file_object,

        PUNICODE_STRING file_name,

        PLARGE_INTEGER file_length)

    {

        PMY_FILE_INFOR my_file_infor =

            (PMY_FILE_INFOR)ExAllocatePoolWithTag(

                PagedPool,sizeof(MY_FILE_INFOR),MEM_TAG);

        if(my_file_infor == NULL)

            return STATUS_INSUFFICIENT_RESOURES;

 

        // 填写数据成员。

        my_file_infor->file_object = file_object;

        my_file_infor->file_name = file_name;

        my_file_infor->file_length = file_length;

 

        // 插入到链表末尾。请注意这里没有使用任何锁。所以，这个函数不是多

        // 多线程安全的。在下面自旋锁的使用中讲解如何保证多线程安全性。

        InsertHeadList(&my_list_head, (PLIST_ENTRY)& my_file_infor);

        return STATUS_SUCCESS; 

    }

 

    以上的代码实现了插入。可以看到LIST_ENTRY插入到MY_FILE_INFOR结构的头部的好处。这样一来一个MY_FILE_INFOR看起来就像一个LIST_ENTRY。不过糟糕的是并非所有的情况都可以这样。比如MS的许多结构喜欢一开头是结构的长度。因此在通过LIST_ENTRY结构的地址获取所在的节点的地址的时候，有个地址偏移计算的过程。可以通过下面的一个典型的遍历链表的示例中看到：

 

    for(p = my_list_head.Flink; p != &my_list_head.Flink; p = p->Flink)

{

        PMY_FILE_INFOR elem =

            CONTAINING_RECORD(p,MY_FILE_INFOR, list_entry);

        // 在这里做需要做的事…

        }

    }

 

    其中的CONTAINING_RECORD是一个WDK中已经定义的宏，作用是通过一个LIST_ENTRY结构的指针，找到这个结构所在的节点的指针。定义如下：

 

   

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

        (PCHAR)(address) - \

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

 

从上面的代码中可以总结如下的信息：

    LIST_ENTRY中的数据成员Flink指向下一个LIST_ENTRY。

    整个链表中的最后一个LIST_ENTRY的Flink不是空。而是指向头节点。

    得到LIST_ENTRY之后，要用CONTAINING_RECORD来得到链表节点中的数据。

2.3 使用长长整型数据

    这里解释前面碰到的LARGE_INTEGER结构。与可能的误解不同，64位数据并非要在64位操作系统下才能使用。在VC中，64位数据的类型为__int64。定义写法如下：

 

    __int64 file_offset;

 

    上面之所以定义的变量名为file_offset，是因为文件中的偏移量是一种常见的要使用64位数据的情况。同时，文件的大小也是如此（回忆上一小节中定义的文件大小）。32位数据无符号整型只能表示到4GB。而众所周知，现在超过4GB的文件绝对不罕见了。但是实际上__int64这个类型在驱动开发中很少被使用。基本上被使用到的是一个共用体：LARGE_INTEGER。这个共用体定义如下：

 

    typedef __int64 LONGLONG;  

    typedef union _LARGE_INTEGER {

        struct {

            ULONG LowPart;

            LONG HighPart;

        };

        struct {

            ULONG LowPart;

            LONG HighPart;

        } u;

        LONGLONG QuadPart;

    } LARGE_INTEGER;

 

    这个共用体的方便之处在于，既可以很方便的得到高32位，低32位，也可以方便的得到整个64位。进行运算和比较的时候，使用QuadPart即可。

 

    LARGE_INTEGER a,b;

    a.QuadPart = 100;

    a.QuadPart *= 100;

    b.QuadPart = a.QuadPart;

    if(b.QuadPart > 1000)

    {

        KdPrint(“b.QuadPart < 1000, LowPart = %x HighPart = %x”, b.LowPart,b.HighPart);

    }

   

    上面这段代码演示了这种结构的一般用法。在实际编程中，会碰到大量的参数是LARGE_INTEGER类型的。

2.4使用自旋锁

    链表之类的结构总是涉及到恼人的多线程同步问题，这时候就必须使用锁。这里只介绍最简单的自选锁。

    有些读者可能疑惑锁存在的意义。这和多线程操作有关。在驱动开发的代码中，大多是存在于多线程执行环境的。就是说可能有几个线程在同时调用当前函数。

    这样一来，前文1.2.2中提及的追加链表节点函数就根本无法使用了。因为MyFileInforAppendNode这个函数只是简单的操作链表。如果两个线程同时调用这个函数来操作链表的话：注意这个函数操作的是一个全局变量链表。换句话说，无论有多少个线程同时执行，他们操作的都是同一个链表。这就可能发生，一个线程插入一个节点的同时，另一个线程也同时插入。他们都插入同一个链表节点的后边。这时链表就会发生问题。到底最后插入的是哪一个呢？要么一个丢失了。要么链表被损坏了。

    如下的代码初始化获取一个自选锁：

 

    KSPIN_LOCK my_spin_lock;

    KeInitializeSpinLock(&my_spin_lock);

 

    KeInitializeSpinLock这个函数没有返回值。下面的代码展示了如何使用这个SpinLock。在KeAcquireSpinLock和KeReleaseSpinLock之间的代码是只有单线程执行的。其他的线程会停留在KeAcquireSpinLock等候。直到KeReleaseSpinLock被调用。KIRQL是一个中断级。KeAcquireSpinLock会提高当前的中断级。但是目前忽略这个问题。中断级在后面讲述。

   

    KIRQL irql;

    KeAcquireSpinLock(&my_spin_lock,&irql);

    // To do something …

    KeReleaseSpinLock(&my_spin_lock,irql);

   

    初学者要注意的是，像下面写的这样的“加锁”代码是没有意义的，等于没加锁：

   

    void MySafeFunction()

    {

        KSPIN_LOCK my_spin_lock;

        KIRQL irql;

        KeInitializeSpinLock(&my_spin_lock);

        KeAcquireSpinLock(&my_spin_lock,&irql);

        // 在这里做要做的事情…

        KeReleaseSpinLock(&my_spin_lock,irql);

    }

 

    原因是my_spin_lock在堆栈中。每个线程来执行的时候都会重新初始化一个锁。只有所有的线程共用一个锁，锁才有意义。所以，锁一般不会定义成局部变量。可以使用静态变量、全局变量，或者分配在堆中（见前面的1.2.1内存的分配与释放一节）。请读者自己写出正确的方法。

    LIST_ENTRY有一系列的操作。这些操作并不需要使用者自己调用获取与释放锁。只需要为每个链表定义并初始化一个锁即可：

 

   

    LIST_ENTRY      my_list_head;       // 链表头

    KSPIN_LOCK  my_list_lock;       // 链表的锁

   

    // 链表初始化函数

    void MyFileInforInilt()

    {

        InitializeListHead(&my_list_head);

        KeInitializeSpinLock(&my_list_lock);

    }

 

    链表一旦完成了初始化，之后的可以采用一系列加锁的操作来代替普通的操作。比如插入一个节点，普通的操作代码如下：

 

    InsertHeadList(&my_list_head, (PLIST_ENTRY)& my_file_infor);

 

    换成加锁的操作方式如下：

 

    ExInterlockedInsertHeadList(

        &my_list_head,

        (PLIST_ENTRY)& my_file_infor,

        &my_list_lock);

 

    注意不同之处在于，增加了一个KSPIN_LOCK的指针作为参数。在ExInterlockedInsertHeadList中，会自动的使用这个KSPIN_LOCK进行加锁。类似的还有一个加锁的Remove函数，用来移除一个节点，调用如下：

 

    my_file_infor = ExInterlockedRemoveHeadList (

        &my_list_head,

        &my_list_lock);

 

    这个函数从链表中移除第一个节点。并返回到my_file_infor中。

http://www.codesky.net/article/200812/88625.html