Linux内核中Container_Of宏的详细解释

我们在分析Linux内核链表的时候注意到内核在求解结构体偏移的时候巧妙的使用了container_of宏定义，今天我们来详细剖析下内核到底是如何求解结构体成员变量的地址的。

• 1. 结构体在内存中是如何存储的
• 2. container_of宏
• 3. typeof
• 4. (((type *)0)->member)
• 5. const typeof(((type * )0) ->member)*__mptr = (ptr);
• 6. offsetof(type, member))
• 7. (type * )((char * )__mptr - offsetof(type, member))
• 8. 举例

1. 结构体在内存中是如何存储的

1. int main() 
2. { 
3.  
4.  Student stu; 
5.  stu.id = 123456; 
6.  strcpy(stu.name,"feizhufeifei"); 
7.  stu.math = 90; 
8.  stu.PE = 80; 
9.  printf("Student:%p\r\n",&stu); 
10.  printf("stu.ID:%p\r\n",&stu.ID); 
11.  printf("stu.name:%p\r\n",&stu.name); 
12.  printf("stu.math:%p\r\n",&stu.math); 
13.  return 0; 
14. } 

打印结果如下：

1. //结构体的地址 
2. Student:0xffffcbb0 
3. //结构体第一个成员的地址 
4. stu.ID:0xffffcbb0  //偏移地址 +0 
5. stu.name:0xffffcbb4//偏移地址 +4 
6. stu.math:0xffffcbd4//偏移地址 +24 

??我们可以看到，结构体的地址和结构体第一个成员的地址是相同的。这也就是我们之前在拒绝造轮子!如何移植并使用Linux内核的通用链表(附完整代码实现)中提到的为什么在结构体中要把 struct list_head放在首位。

不太理解的再看下这两个例子：

struct A { int a; char b; int c; char d; };a 偏移为 0 ， b 偏移为 4 ， c 偏移为 8 (大于 4 + 1 的 4 的最小整数倍)， d 偏移为 12 。A 对齐为 4 ，大小为 16 。

struct B { int a; char b; char c; long d; };a 偏移为 0 ， b 偏移为 4 ， c 偏移为 5 ， d 偏移为 8 。B 对齐为 8 ， 大小为 16 。

我们可以看到，结构体中成员变量在内存中存储的其实是偏移地址。也就是说结构体A的地址+成员变量的偏移地址 = 结构体成员变量的起始地址。

因此，我们也可以根据结构体变量的起始地址和成员变量的偏移地址来反推出结构体A的地址。

2. container_of宏

1. #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE*)0)->MEMBER) 
2. #define container_of(ptr, type, member) ({          \ 
3.         const typeof(((type *)0)->member)*__mptr = (ptr);    \ 
4.     (type *)((char *)__mptr - offsetof(type, member)); }) 

??首先看下三个参数， ptr是成员变量的指针， type是指结构体的类型， member是成员变量的名字。

??container_of宏的作用是通过结构体内某个成员变量的地址和该变量名，以及结构体类型，找到该结构体变量的地址。这里使用的是一个利用编译器技术的小技巧，即先求得结构成员在结构中的偏移量，然后根据成员变量的地址反过来得出主结构变量的地址。下面具体分析下各个部分。

3. typeof

首先看下typeof，是用于返回一个变量的类型，这是GCC编译器的一个扩展功能，也就是说typeof是编译器相关的。既不是C语言规范的所要求，也不是某个标准的一部分。

typeof

1. int main() 
2. { 
3.  int a = 5; 
4.  //这里定义一个和a类型相同的变量b 
5.  typeof(a) b  = 6; 
6.  printf("%d,%d\r\n",a,b);//5 6 
7.  return 0; 
8. } 

4. (((type *)0)->member)

((TYPE *)0) 将0转换为type类型的结构体指针，换句话说就是让编译器认为这个结构体是开始于程序段起始位置0，开始于0地址的话，我们得到的成员变量的地址就直接等于成员变量的偏移地址了。

(((type *)0)->member) 引用结构体中MEMBER成员。

1. typedef struct student{ 
2.  int id; 
3.  char name[30]; 
4.  int math; 
5. }Student; 
6. int main() 
7. { 
8.  //这里时把结构体强制转换成0地址，然后打印name的地址。 
9.  printf("%d\r\n",&((Student *)0)->name);//4 
10.  return 0; 
11. } 

5. const typeof(((type * )0) ->member)*__mptr = (ptr);

这句代码意思是用typeof()获取结构体里member成员属性的类型，然后定义一个该类型的临时指针变量__mptr，并将ptr所指向的member的地址赋给__mptr;

为什么不直接使用 ptr 而要多此一举呢?我想可能是为了避免对 ptr 及prt 指向的内容造成破坏。

6. offsetof(type, member))

1. ((size_t) &((TYPE*)0)->MEMBER) 

size_t是标准C库中定义的，在32位架构中被普遍定义为：

1. typedef unsigned int size_t; 

而在64位架构中被定义为：

1. typedef unsigned long size_t; 

可以从定义中看到，size_t是一个非负数，所以size_t通常用来计数(因为计数不需要负数区)：

1. for(size_t i=0;i<300;i++) 

为了使程序有很好的移植性，因此内核使用size_t，而不是int，unsigned。((size_t) &((TYPE*)0)->MEMBER) 结合之前的解释，我们可以知道这句话的意思就是求出MEMBER相对于0地址的一个偏移值。

7. (type * )((char * )__mptr - offsetof(type, member))

这句话的意思就是，把 __mptr 转换成 char* 类型。因为 offsetof 得到的偏移量是以字节为单位。两者相减得到结构体的起始位置， 再强制转换成 type 类型。

8. 举例

1. #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) 
2. #define container_of(ptr, type, member) ({ \ 
3.         const typeof( ((type *)0)->member ) *__mptr = (ptr); \ 
4.         (type *)( (char *)__mptr - offsetof(type,member) );}) 
5.          
6. typedef struct student 
7. { 
8.  int id; 
9.  char name[30]; 
10.  int math; 
11. }Student; 
12.  
13. int main() 
14. { 
15.     Student stu; 
16.         Student *sptr = NULL; 
17.   stu.id = 123456; 
18.   strcpy(stu.name,"zhongyi"); 
19.   stu.math = 90; 
20.         sptr = container_of(&stu.id,Student,id); 
21.         printf("sptr=%p\n",sptr); 
22.         sptr = container_of(&stu.name,Student,name); 
23.         printf("sptr=%p\n",sptr); 
24.         sptr = container_of(&stu.math,Student,id); 
25.         printf("sptr=%p\n",sptr); 
26.         return 0;  
27. } 

运行结果如下：

1. sptr=0xffffcb90 
2. sptr=0xffffcb90 
3. sptr=0xffffcbb4 

宏展开可能会看的更清楚一些

1. int main() 
2. { 
3.     Student stu; 
4.         Student *sptr = NULL; 
5.   stu.id = 123456; 
6.   strcpy(stu.name,"zhongyi"); 
7.   stu.math = 90; 
8.   //展开替换 
9.         sptr = ({ const unsigned char  *__mptr = (&stu.id); (Student *)( (char *)__mptr - ((size_t) &((Student *)0)->id) );}); 
10.         printf("sptr=%p\n",sptr); 
11.         //展开替换 
12.         sptr = ({ const unsigned char  *__mptr = (&stu.name); (Student *)( (char *)__mptr - ((size_t) &((Student *)0)->name) );}); 
13.         printf("sptr=%p\n",sptr); 
14.         //展开替换 
15.         sptr = ({ const unsigned int *__mptr = (&stu.math); (Student *)( (char *)__mptr - ((size_t) &((Student *)0)->math) );}); 
16.         printf("sptr=%p\n",sptr); 
17.         return 0;  
18. } 

原文链接：https://mp.weixin.qq.com/s/hF7mP_J4BySYw0HCgk27IA