Linux核心原始碼中的連結串列是一個雙向迴圈連結串列，該連結串列的設計具有優秀的封裝性和可擴充套件性。本文將從2.6.39版本核心的核心連結串列移植到Windows平臺的visual studio2010環境中。連結串列的原始碼位於核心原始碼的include/linux/list.h中。移植的步驟如下：
  （1）去除依賴的標頭檔案
  list.h依賴的標頭檔案如下：

#include <linux/types.h>
#include <linux/stddef.h>
#include <linux/poison.h>
#include <linux/prefetch.h>
 

  依次進入這4個頭檔案，提取檔案內的有被list使用到的程式碼：

//types.h：
struct list_head {
    struct list_head *next, *prev;
};

struct hlist_head {
    struct hlist_node *first;
};

struct hlist_node {
    struct hlist_node *next, **pprev;
};

//stddef.h：
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
 

  offsetof巨集可參考offsetof和container_of一般它和container_of巨集配合使用。核心的container_of原型如下：

#define container_of(ptr, type, member) ({                  \
        const typeof(((type*)0)->member)* __mptr = (ptr);   \
        (type*)((char*)__mptr - offsetof(type, member)); })

  因為typeof是GNU C編譯器的關鍵字，微軟編譯器並不支援，所以不能使用該關鍵字，即沒有型別檢查的功能：

#define m_container(ptr, type, member) ((type *)( (char *)ptr - offsetof(type,member)))

//poison.h：
#define LIST_POISON1  ((void *) 0x00100100 + POISON_POINTER_DELTA)
#define LIST_POISON2  ((void *) 0x00200200 + POISON_POINTER_DELTA)

  list的刪除節點函式list_del()的實現中最後將被刪除的節點的next和pre指標分別為LIST_POISON1和LIST_POISON2，所以可以將這兩個巨集修改為：

#define LIST_POISON1  ((void *) 0x00)
#define LIST_POISON2  ((void *) 0x00)

//prefetch.h：
#define prefetch(x) __builtin_prefetch(x)

  __builtin_prefetch()是GNU C編譯器特有的內建函式，意義在於程式碼優化。因為我們要將list.h移植到使用微軟編譯器的平臺，所以不可使用__builtin_prefetch()函式，可修改為：

#define prefetch(x) ((void*)(x))

  （2）將list.h中的所有函式的宣告屬性“static inline”修改為“static”，因為“static inline”同時修飾一個函式只在GNU C編譯器宣告。
連結串列的一般設計是：

  從圖可見，節點的指標域指向的是下一個節點(或上一個節點)變數開始的地址，指標的型別為Node_t*。顯然隨著節點型別的不同，指標域的指標型別也要隨之改變。Linux核心為了設計成具有封裝性和擴充套件性的連結串列，將節點指標域中的指標的指向做了改變：

  作為雙向迴圈連結串列的節點，每一個型別節點的指標域都具有兩個指標，這是不變的，核心將指標的指向改為下一個節點(或上一個節點)變數的指標域開始地方，這樣每一個節點的定義只需要包含核心定義的指標域型別即可使用核心連結串列。連結串列的操作（如增加/刪除）是針對指標域型別的，所以這些函式能適用於任何使用核心連結串列組織的資料。
  注意，這樣一來，我們要訪問使用核心連結串列的節點的資料域時，不可以直接通過指標域的的指向的地址來訪問，中間需要一個轉換過程，即使用核心的container_of巨集，container_of可以實現通過結構體的某個成員變數的地址獲取結構體變數的起始地址，我們通過該地址就可以獲取給結構體的任意成員了，這正是Linux核心設計的巧妙之處。
  核心連結串列的常用函式/巨集有：

1.INIT_LIST_HEAD()：初始化連結串列(頭)
2.list_add()：在；連結串列頭插入節點
3.list_add_tail()：在連結串列尾部插入節點
4.list_del()：刪除節點
5.list_entry()：通過節點的指標域獲取資料節點的起始地址
6.list_for_each()：遍歷連結串列(不可和list_del()配合使用)
7.list_for_each_safe()：安全的遍歷連結串列(可和list_del()配合使用))

  編寫測試函式(1)：

void list_test1()
{
    struct Node_t
    {
        struct list_head head;
        char value;
    };

    int i;
    struct Node_t l = {0};      //定義頭節點
    struct list_head* p = NULL;
    struct list_head* n;

    //初始化連結串列(頭節點)
    INIT_LIST_HEAD(&l.head);
    for (i = 0; i < 6; ++i)
    {
        struct Node_t* n = (struct Node_t* )malloc(sizeof(struct Node_t));
        n->value = i;
        //將新節點尾插到連結串列中
        list_add_tail(&n->head, &l.head);
    }

    //遍歷連結串列
    list_for_each(p, &l.head)
    {
        //因為Node_t的第一個成員的型別就是struct list_head型別，所以可以強制型別轉換
        printf("%-2d", ((struct Node_t*)p)->value);
    }
    printf("\n");

    list_for_each(p, &l.head)
    {
        //刪除第一個value為2的節點
        if (((struct Node_t*)p)->value == 2)
        {
            list_del(p);    //執行list_del()後p的指標域都指向NULL
            free((struct Node_t*)p);
            break;
        }
    }

    list_for_each(p, &l.head)
    {
        printf("%-2d", list_entry(p, struct Node_t, head)->value);
    }
    printf("\n");

    //不可以通過list_for_each遍歷來逐一銷燬動態分配的節點，因為銷燬完第一個節點後p的指標域都置為0
    //而list_for_each巨集是通過p來遍歷下一個節點的
    //list_for_each(p, &l.head)
    //{
    //  list_del(p);
    //}

    //可以使用list_for_each_safe遍歷來逐一銷燬動態分配的節點，因為該巨集使用了n來備份p指標
    list_for_each_safe(p, n, &l.head)
    {
        list_del(p);
        free((struct Node_t*)p);  //銷燬節點
        //或者free(list_entry(p, struct Node_t, head));   //銷燬節點
    }
}

  測試函式(2)：

void list_test2()
{
    struct Node_t
    {
        char value;
        struct list_head head;
    };

    struct Node_t l = {0};
    struct list_head* p;
    struct list_head* n;
    int i;

    //初始化連結串列(頭節點)
    INIT_LIST_HEAD(&l.head);

    for (i = 0; i < 6; ++i)
    {
        struct Node_t* n = (struct Node_t* )malloc(sizeof(struct Node_t));
        n->value = i;

        //將新節點以頭插的方式插入連結串列中
        list_add(&n->head, &l.head);
    }

    //遍歷列印
    list_for_each(p, &l.head)
    {
        printf("%-2d", list_entry(p, struct Node_t, head)->value);
    }
    printf("\n");

    //遍歷連結串列
    list_for_each(p, &l.head)
    {
        //因為Node_t的第一個成員不是list_head型別成員，所以需要list_entry巨集獲取Node_t型別物件的
        //起始地址，進而訪問其value成員
        struct Node_t *n = list_entry(p, struct Node_t, head);      
        if (n->value == 2)
        {
            list_del(p);
            free(n);
            break;
        }

    }

    list_for_each(p, &l.head)
    {
        printf("%-2d", list_entry(p, struct Node_t, head)->value);
    }
    printf("\n");

    list_for_each_safe(p, n, &l.head)
    {
        list_del(p);
        free(list_entry(p, struct Node_t, head));   //銷燬節點
    }
}

使用核心連結串列需要注意：
a. 不可以使用list_for_each遍歷連結串列節點並銷燬節點，原因見程式碼註釋；
b. 訪問節點的資料域時，如果節點型別的第一個成員不是list_head型別的變數時需要使用list_entry()獲取節點型別變數的起始地址，進而訪問節點的資料域，否則可以通過強制型別轉換(考慮兩個結構體變數的記憶體佈局)。