linux内核链表宏 container_of的详细推导

linux-2.6.29/include/linux/kernel.h
493 #define container_of(ptr, type, member) ({                      /
494         const typeof( ((type *)0)->member ) *__mptr = (ptr);    /
495         (type *)( (char *)__mptr - offsetof(type,member) );})


内核中常常要使用这个container_of宏，刚开始接触的朋友可能会对这个感到很费解，不知道这个宏是怎么来的，下面我们详细推导一下：

1. 我们先写一个小程序：

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <unistd.h>
  4
  5 typedef struct {
  6     int a;
  7     int b;
  8     int c;
  9 }hehe;
 10
 11 int main(int argc, char *argv[])
 12 {
 13     hehe hoho;
 14     hehe *haha;
 15     hehe *hihi;
 16     int *ptr;
 17
 18     hoho.a = 1;
 19     hoho.b = 2;
 20     hoho.c = 3;
 21     
 22     hihi = &hoho;
 23
 24     ptr = &hoho.b;
 25
 26     printf("ptr = %d, hihi = 0x%08x/n", *ptr, hihi);
 27
 28     haha = ptr - (&hihi->b - (int *) hihi);
 29     printf("a = %d, b = %d, c = %d /n", haha->a, haha->b, haha->c);
 30 }  


程序中定义了一个结构体hehe,它有3个成员a,b,c；用hehe定义hoho，并定义2个hehe类型的指针haha,hihi;初始化hoho的成员a,b,c分别为1,2,3；hihi指向hoho,ptr指向hoho.b;

这样我们要做的就是通过hoho的成员b获得hoho的首地址，也就是28行：

 28     haha = (char *)ptr - (char *)(&hihi->b - (int *) hihi);

要想使haha最终的值为hoho的首地址，那么haha = &hoho = &hoho.b - (&hoho.b - &hoho)
                                     = ptr - hoho.b到hoho的偏移
                                     = ptr - (&hihi->b - (int *) hihi)
因此上述程序编译后执行正确的打印出hoho的a,b,c的值：
$ ./2
ptr = 2, hihi = 0xbfb838dc
a = 1, b = 2, c = 3

2. 接下来我们对这个程序进行修改，从上面的打印结果看到hihi的值为0xbfb838dc，也就是hoho的首地址为0xbfb838dc，而指针其实就是一个保存一个地址的内存区域，而指针的类型就决定了解析这个地址的方法，因此我们就可以用进行了强制类型转化的地址来代替指针，我想对c语言有所了解的都能明白这种替换的，ok，那么这里我们作出下面的修改：

 28     haha = ptr - (&((hehe *)(0xbfb838dc))->b - (int *)0xbfb838dc);

因为hihi为指向一个hehe结构体的指针，因此这里进行替换的时候需要将hihi->b改为((hehe *)(0xbfb838dc))->b，而hihi就直接0xbfb838dc就可以了，不过这里需要加上(int *)，因为b的类型是 int型的，直接进行这种地址的加减的时候一定要保证两个地址对应的类型一致，不然程序会出错。

这样编译后运行：
$ ./2
ptr = 2, hihi = 0xbfea6bfc
a = 1, b = 2, c = 3

恩，打印出来的a,b,c的值还是正确的。

3. 你可能会注意到上面的hihi的值已经发生了变化，这是自然的，每次运行的程序分配的内存地址都不一定相同，这样就会发现一个问题，其实这个结构体在内存的什么位置都不会有影响，而且这里我们计算的是hoho.b到hoho的偏移，因此hoho的首地址的位置不会对结果有影响，那么就可以有一个结论&((hehe *)(0xbfb838dc))->b - (int *)0xbfb838dc = &((hehe *)(0x0))->b - (int *)0x0,因此我们对程序作下面的修改：

 28     haha = ptr - (&((hehe *)(0))->b - (int *) 0);

编译后运行：
$ ./2
ptr = 2, hihi = 0xbf9d071c
a = 1, b = 2, c = 3

结果仍然没有问题。

4. 我们再研究一下程序的28行：

 28     haha = ptr - (&((hehe *)(0))->b - (int *) 0);

可以看到&((hehe *)(0))->b - (int *)0，很明显我们可以将程序改为：

haha = ptr - &((hehe *)(0))->b

不过，这里程序必须要加上加上强制类型转换，不然会计算错误，因此程序：

 28     haha = (char *)ptr - (char *)&((hehe *)0)->b;

编译运行之后：
$ ./2
ptr = 2, hihi = 0xbff5fcac
a = 1, b = 2, c = 3

结果仍然正确。

5. 将这个代码写成宏的形式，就可以写成

#define container_of(ptr, type, member) (type *)((char *)ptr - (char *)&((type *)0)->member)

最后将程序改为

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <unistd.h>
  4
  5 #define container_of(ptr, type, member) (type *)((char *)ptr - (char *)&((type *)0)->member)
  6
  7 typedef struct {
  8     int a;
  9     int b;
 10     int c;
 11 }hehe;
 12
 13 int main(int argc, char *argv[])
 14 {
 15     hehe hoho;
 16     hehe *haha;
 17     hehe *hihi;
 18     int *ptr;
 19
 20     hoho.a = 1;
 21     hoho.b = 2;
 22     hoho.c = 3;
 23
 24     hihi = &hoho;
 25
 26     ptr = &hoho.b;
 27
 28     printf("ptr = %d, hihi = 0x%08x/n", *ptr, hihi);
 29
 30     haha = container_of(ptr, hehe, b);
 31     printf("a = %d, b = %d, c = %d /n", haha->a, haha->b, haha->c);
 32 }
 33

编译后运行：
$ ./2
ptr = 2, hihi = 0xbfe14b5c
a = 1, b = 2, c = 3

结果正确。

最后你只需要对这跟宏稍作一些修改就可以写成文章最开始的那种形式了。

恩，以上就是对container_of宏的推导过程，希望会对大家有所帮助。