1.list_for_each原型
#define list_for_each(pos, head) \
    for (pos = (head)->next, prefetch(pos->next); pos != (head); \
    pos = pos->next, prefetch(pos->next))
它实际上是一个 for 循环，利用传入的pos 作为循环变量，从表头 head开始，逐项向后（next方向）移动 pos ，直至又回到 head （prefetch() 可以不考虑，用于预取以提高遍历速度）。
注意：此宏必要把list_head放在数据结构第一项成员，至此，它的地址也就是结构变量的地址。

2.使用方法（以访问当前进程的子进程为例）：

struct list_head {
 struct list_head *next, *prev;
};

在struct task_struct 中有如下定义：
struct list_head children;

所以

struct task_struct *task;

struct list_head *list;

list_for_each(list,&current->chilidren) {

              task = list_entry(list, struct task_struct, sibling);/*task指向当前的某个子进程*/

}

其中用到了函数list_entry():
这个函数的作用在图1中表示就是可以通过已知的指向member子项的指针，获得整个结构体的指针（地址）
#define list_entry(ptr, type, member) \
        container_of(ptr, type, member)

二、list_for_each_entry：
在Linux内核源码中，经常要对链表进行操作，其中一个很重要的宏是list_for_each_entry：
意思大体如下：
假设只有两个结点，则第一个member代表head，
list_for_each_entry的作用就是循环遍历每一个pos中的member子项。
图1：
pos:                                                           pos:
___________                                        ____________
|                       |                                     |                          |
|                       |                                     |                          |
|    ...........        |                                     |   ................      |
|                       |                                     |                           |
|                       |                                     |                           |
|     member:    |                  _________|__> member    |
|   {                  |                |                    |  {                       |
|         *prev;    |                |                    |       *prev;        |
|         *next;        --|----------                    |        *next;-------------
|    }                |                                      |  }                      |             |
|—^———— |                                      |____________|             |
       |                                                                                                      |
       |                                                                                                     |
       |_____________________________________________|
宏list_for_each_entry: 
   
#define list_for_each_entry(pos, head, member)                          \
        for (pos = list_entry((head)->next, typeof(*pos), member);      \
             prefetch(pos->member.next), &pos->member != (head);        \
             pos = list_entry(pos->member.next, typeof(*pos), member))

       container_of(ptr, type, member)
和函数prefetch：
#define prefetch(x) __builtin_prefetch(x)

其中用到了builtin_prefetch:
prefetch的含义是告诉cpu那些元素有可能马上就要用到，告诉cpu预取一下，这样可以提高速度
其中用到了函数container_of():
493#define container_of(ptr, type, member) ({                      \
494        const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
495        (type *)( (char *)__mptr - offsetof(type,member) );})
其中又用到了offsetof（）函数：
lxr上找到的源码：
#define offset_of(type, memb) \
  47        ((unsigned long)(&((type *)0)->memb))
offsetof(TYPE, MEMBER)
该宏在Linux内核代码(版本2.6.22)中定义如下：
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER); 
分析：
(TYPE *)0,将 0 强制转换为 TYPE 型指针，记 p = (TYPE *)0，p是指向TYPE的指针，它的值是0。那么 p->MEMBER 就是 MEMBER 这个元素了，而&(p->MEMBER)就是MENBER的地址，而基地址为0，这样就巧妙的转化为了TYPE中的偏移量。再把结果强制转换为size_t型的就OK了，size_t其实也就是int。
typedef __kernel_size_t  size_t;
typedef unsigned int __kernel_size_t; 
可见，该宏的作用就是求出MEMBER在TYPE中的偏移量。