数据类型 LIST_ENTRY

另一个常见的 Windows 2000 数据类型是 LIST_ENTRY 结构。内核使用该结构将所有对象维护在一个双向链表中。一个对象分属多个链表是很常见的， Flink 成员是一个向前链接，指向下一个 LIST_ENTRY 结构， Blink 成员则是一个向后链接，指向前一个 LIST_ENTRY 结构。通常情况下，这些链表都成环形，也就是说，最后一个 Flink 指向链表中的第一个 LIST_ENTRY 结构，而第一个 Blink 指向最后一个。这样就很容易双向遍历该链表。如果一个程序要遍历整个链表，它需要保存第一个 LIST_ENTRY 结构的地址，以判断是否已遍历了整个链表。如果链表仅包含一个 LIST_ENTRY 结构，那么该 LIST_ENTRY 结构必须引用其自身，也就是说， Flink 和 Blink 都指向其自己。

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

--------------------------------------------------------------------------------
LIST_ENTRY使用：
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);
       }
}

遍历：
PLIST_ENTRY pLink=NULL;
for(pLink = glinkListRule.Flink; pLink !=(PLIST_ENTRY) &glinkListRule.Flink; pLink = pLink->Flink)
{
  pRegPrtRule pData= CONTAINING_RECORD(pLink,RegPrtRule,ListEntry);
  
}

--------------------------------------------------------------------------------

在驱动中使用链表：
在驱动程序的开发中经常需要用到链表，常见的链表有单向链表和双向链表，我们只介绍双向链表的使用方法，DDK为我们提供了标准的双向链表LIST_ENTRY，但这个链表里面没有数据，不能直接使用，我们需要自己定义一个结构体类型，然后将LIST_ENTRY作为结构体的一个子域，如下所示：
typedef struct _MYDATASTRUCT{
    ULONG number;
    LIST_ENTRY ListEntry;
} MYDATASTRUCT, *PMYDATASTRUCT;
    实际上把LIST_ENTRY放在结构体的第一个子域才是较好的做法，此处我们不过多地关心，反正用法都是大同小异。下面我们就在驱动程序中创建一个链表，使用刚刚定义的结构体作为节点类型。代码如下所示：

  1.  
  2. VOID  LinkListTest()
     
  3. {
     
  4.     LIST_ENTRY linkListHead;  // 链表
     
  5.     PMYDATASTRUCT pData;  // 节点数据
     
  6.     ULONG i = 0;     // 计数
     
  7.     //初始化
     
  8.     InitializeListHead(&linkListHead);
     
  9.     //向链表中插入10个元素
     
  10.     KdPrint(("[ProcessList] Begin insert to link list"));
     
  11.     for (i=0 ; i<10 ; i++)
     
  12.     {     // pData是我们定义的指针，必须被初始化后才能使用
     
  13.           pData = (PMYDATASTRUCT)ExAllocatePool(PagedPool,sizeof(MYDATASTRUCT));
     
  14.           pData->number = i;
     
  15.           // 将其作为一个节点插入链表
     
  16.           InsertHeadList(&linkListHead,&pData->ListEntry);
     
  17.     }
     

  18.  
  19.      // 从链表中取出所有数据并显示
     
  20.      KdPrint(("[ProcessList] Begin remove from link list\n"));
     
  21.      while(!IsListEmpty(&linkListHead))
     
  22.      {
     
  23.            // 取出一个节点
     
  24.            PLIST_ENTRY pEntry = RemoveTailList(&linkListHead);
     
  25.            // 获取节点内容
     
  26.            pData = CONTAINING_RECORD(pEntry, MYDATASTRUCT, ListEntry);
     
  27.            KdPrint(("%d\n",pData->number));
     
  28.            // 释放节点，ExAllocatePool必须与ExFreePool成对使用
     
  29.            ExFreePool(pData);
     
  30.       }
     
  31. }
复制代码

    上述代码可以正常地通过编译并运行，但其中存在着一个很大的隐患：它不是多线程安全的。如果有多个线程同时操作同一个链表的话，可能会引发不可预料的后果，我们可以通过使用自旋锁来避免，修改后的代码如下所示：

  1.  
  2. VOID  LinkListTest()
     
  3. {
     
  4.     LIST_ENTRY linkListHead;  // 链表
     
  5.     PMYDATASTRUCT pData;  // 节点数据
     
  6.     ULONG i = 0;     // 计数
     
  7.     KSPIN_LOCK spin_lock; // 自旋锁
     
  8.     KIRQL  irql;    // 中断级别
     
  9.     // 初始化
     
  10.     InitializeListHead(&linkListHead);
     
  11.     KeInitializeSpinLock(&spin_lock);
     

  12.  
  13.     //向链表中插入10个元素
     
  14.     KdPrint(("[ProcessList] Begin insert to link list"));
     
  15.     // 锁定，注意这里的irql是个指针
     
  16.     KeAcquireSpinLock(&spin_lock, &irql);
     
  17.     for (i=0 ; i<10 ; i++)
     
  18.     {
     
  19.          pData = (PMYDATASTRUCT)ExAllocatePool(PagedPool,sizeof(MYDATASTRUCT));
     
  20.          pData->number = i;
     
  21.          InsertHeadList(&linkListHead,&pData->ListEntry);
     
  22.     }
     
  23.     // 解锁，注意这里的irql不是指针
     
  24.     KeReleaseSpinLock(&spin_lock, irql);
     

  25.  
  26.     //从链表中取出所有数据并显示
     
  27.     KdPrint(("[ProcessList] Begin remove from link list\n"));
     
  28.     // 锁定
     
  29.     KeAcquireSpinLock(&spin_lock, &irql);
     
  30.     while(!IsListEmpty(&linkListHead))
     
  31.     {
     
  32.          PLIST_ENTRY pEntry = RemoveTailList(&linkListHead);
     
  33.          pData = CONTAINING_RECORD(pEntry, MYDATASTRUCT, ListEntry);
     
  34.          KdPrint(("%d\n",pData->number));
     
  35.          ExFreePool(pData);
     
  36.     }
     
  37.     // 解锁
     
  38.     KeReleaseSpinLock(&spin_lock, irql);
     
  39. }
复制代码

    上述代码介绍了自旋锁的使用方法，但需要注意的是：上面这段代码在实际应用中是没有任何价值的。因为在上述代码我们定义的锁是一个局部变量，被分配在栈中，这样每个线程在调用该函数的时候，都会重新初始化一个锁，因此这个锁就失去了本来的作用。在实际的编程中，我们应该把锁定义成一个全局变量，或者静态（static）变量，或者将其创建在堆空间中。
    另外，我们还可以为每个链表都定义并初始化一个锁，在需要向该链表插入或移除节点时不使用前面介绍的普通函数，而是使用如下方法：
ExInterlockedInsertHeadList(&linkListHead, &pData->ListEntry, &spin_lock);
pData = (PMYDATASTRUCT)ExInterlockedRemoveHeadList(&linkListHead, &spin_lock);
    此时在向链表中插入或移除节点时会自动调用关联的锁进行加锁操作，有效地保证了多线程安全性。