嵌入式C语言自我修养 04:Linux 内核第一宏:container_of

4.1 typeof 关键字

ANSI C 定义了 sizeof 关键字,用来获取一个变量或数据类型在内存中所占的存储字节数。GNU C 扩展了一个关键字 typeof,用来获取一个变量或表达式的类型。这里使用关键字可能不太合适,因为毕竟 typeof 还没有被写入 C 标准,是 GCC 扩展的一个关键字。为了方便,我们就姑且称之为关键字吧。

通过使用 typeof,我们可以获取一个变量或表达式的类型。所以 typeof 的参数有两种形式:表达式或类型。

int i ;
typeof(i) j = 20;

typeof(int *) a;

int f();
typeof(f()) k;

在上面的代码中,因为变量 i 的类型为 int,所以 typeof(i) 就等于 int,typeof(i) j =20 就相当于 int j = 20,typeof(int ) a; 相当于 int a;,函数也是有类型的,函数的类型即其返回值类型,所以 typeof(f()) k; 就相当于 int k;。

4.2 typeof 使用示例

根据上面 typeof 的用法,我们编写一个程序,来学习一下 typeof 的使用。

int main(void)
{
    int i = 2;
    typeof(i) k = 6;

    int *p = &k;
    typeof(p) q = &i;

    printf("k = %d\n",k);
    printf("*p= %d\n",*p);
    printf("i = %d\n",i);
    printf("*q= %d\n",*q);
    return 0;
}

运行结果为:

k  = 6
*p = 6
i  = 2
*q = 2

通过运行结果可知,通过 typeof 获取一个变量的类型 int 后,可以使用该类型再定义一个变量。这跟我们直接使用 int 定义一个变量,效果是一样的。

4.3 typeof 的其它使用方法

除了使用 typeof 获取基本数据类型,还有其它一些高级的用法:

typeof (int *) y;   // 把 y 定义为指向 int 类型的指针,相当于int *y;
typeof (int)  *y;   //定义一个执行 int 类型的指针变量 y
typeof (*x) y;      //定义一个指针 x 所指向类型 的指针变量y
typeof (int) y[4];  //相当于定义一个:int y[4]
typeof (*x) y[4];   //把 y 定义为指针 x 指向的数据类型的数组
typeof (typeof (char *)[4]) y;//相当于定义字符指针数组:char *y[4];
typeof(int x[4]) y;  //相当于定义:int y[4]

4.4 继续完善 MAX(a,b) 宏

在上一节中,我们定义了一个宏 MAX(x,y),用来求出两个数中较大的那个,而且可以支持不同类型数据:

#define MAX(type,x,y)({         type _x = x;            type _y = y;            _x > _y ? _x : _y; })

这个宏虽然可以支持任意数据类型,但是仍有瑕疵:我们必须把数据的类型作为一个单独的参数传递给宏。接下来,我们继续优化这个宏:不需要再单独传递这个参数,而是使用 typeof 关键字来直接获取参数的数据类型。

#define MAX(x,y)({         typeof(x) _x = x;            typeof(x) _y = y;            _x > _y ? _x : _y; })

int main(void)
{
    int i = 2;
    int j = 6;
    printf("max: %d\n", MAX(i, j));
    printf("max: %f\n", MAX(3.14, 3.15));
    return 0;
}

通过 typeof 直接获取宏的参数类型,这样我们就不必再单独将参数的类型传给宏了。改进后的宏同样也支持任意类型的数据比较大小。在 main 函数中,我们分别使用这个宏去比较 int 型数据和 float 型数据,发现都可以正常工作!是不是很酷?等你面试时把这个宏写给面试官看,你觉得面试官还会舍得让你回去等消息么?

有了这个思路,我们同样也可以将以前定义的一些宏通过这种方式改写,这样 SWAP 宏也可以支持多种类型的数据了。

#define swap(a, b) do {                   typeof(a) __tmp = (a);  \
    (a) = (b);             (b) = __tmp; } while (0)

4.5 typeof 在内核中的应用

关键字 typeof 在 Linux 内核中被广泛使用,主要用在宏定义中,用来获取宏参数类型。比如内核中,min/max 宏的定义:

#define min(x, y) ({                    typeof(x) _min1 = (x);              typeof(y) _min2 = (y);              (void) (&_min1 == &_min2);          _min1 < _min2 ? _min1 : _min2; })

#define max(x, y) ({                    typeof(x) _max1 = (x);              typeof(y) _max2 = (y);              (void) (&_max1 == &_max2);          _max1 > _max2 ? _max1 : _max2; })

在 min\max 宏定义中,使用 typeof 直接获取参数类型,就不必再给宏单独传递参数 type 了。内核中定义的宏跟我们上面举的例子有点不一样,多了一行代码:

(void) (&_max1 == &_max2);

这一句很有意思:看起来是一句废话,其实用得很巧妙!它主要是用来检测宏的两个参数 x 和 y 的数据类型是否相同。如果不相同,编译器会给一个警告信息,提醒程序开发人员。

warning:comparison of distinct pointer types lacks a cast

让我们分析一下,它是怎么实现的:语句 &_max1 == &_max2 用来判断两个变量 _max1 和 _max2的地址是否相等,即比较两个指针是否相等。&_max1 和 &_max2分别表示两个不同变量的地址,怎么可能相等呢!既然大家都知道,内存中两个不同的变量地址肯定不相等,那为什么还要在此多此一举呢?妙就妙在,当两个变量类型不相同时,对应的地址,即指针类型也不相同。比如一个 int 型变量,一个 char 变量,对应的指针类型,分别为 char 和 int ,而两个指针比较,它们必须是同种类型的指针,否则编译器会有警告信息。所以,通过这种“曲线救国”的方式,这行程序语句就实现了这样一个功能:当宏的两个参数类型不相同时,编译器会及时给我们一个警告信息,提醒开发者。

看完这个宏的实现,不得不感叹内核的博大精深!每一个细节,每一个不经意的语句,细细品来,都能学到很多知识,让你的 C 语言功底更加深厚。不要走,我们接着分析 Linux 内核中另一个更有意思的宏。

4.6 Linux 内核中的 container_of 宏

container_of 宏介绍

有了上面语句表达式和 typeof 的基础知识,接下来我们就可以分析 Linux 内核第一宏:container_of。这个宏在 Linux 内核中应用甚广。会不会用这个宏,看不看得懂这个宏,也逐渐成为考察一个内核驱动开发者 C 语言功底的不成文标准。废话少说,我们还是先一睹芳容吧。

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

作为内核第一宏,绝对不是盖的:看看这身段,这曲线,高端大气上档次,低调奢华有内涵,不出去再做个头发,简直就是暴殄天物。GNU C 高端扩展特性的综合运用,宏中有宏,不得不佩服内核开发者这天才般地设计。那这个宏到底是干什么的呢?它的主要作用就是:根据结构体某一成员的地址,获取这个结构体的首地址。根据宏定义,我们可以看到,这个宏有三个参数,它们分别是:

  • type:结构体类型
  • member:结构体内的成员
  • ptr:结构体内成员member的地址

也就是说,我们知道了一个结构体的类型,结构体内某一成员的地址,就可以直接获得到这个结构体的首地址。container_of 宏返回的就是这个结构体的首地址。

container_of 宏使用示例

比如现在,我们定义一个结构体类型 student:

struct student
{
    int age;
    int num;
    int math;
};
int main(void)
{
    struct student stu;
    struct student *p;
    p = container_of( &stu.num, struct student, num);
    return 0;
}

在这个程序中,我们定义一个结构体类型 student,然后定义一个结构体变量 stu,我们现在已经知道了结构体成员变量 stu.num 的地址,那我们就可以通过 container_of 宏来获取结构体变量 stu 的首地址。

这个宏在内核中非常重要。我们知道,Linux 内核驱动中,为了抽象,对数据结构体进行了多次封装,往往一个结构体里面嵌套多层结构体。也就是说,内核驱动中不同层次的子系统或模块,使用的是不同封装程度的结构体,这也是 C 语言的面向对象思想。分层、抽象、封装,可以让我们的程序兼容性更好,适配更多的设备,但同时也增加了代码的复杂度。

我们在内核中,经常会遇到这种情况:我们传给某个函数的参数是某个结构体的成员变量,然后在这个函数中,可能还会用到此结构体的其它成员变量,那这个时候怎么办呢?container_of 就是干这个的,通过它,我们可以首先找到结构体的首地址,然后再通过结构体的成员访问就可以访问其它成员变量了。

struct student
{
    int age;
    int num;
    int math;
};
int main(void)
{
    struct student stu = { 20, 1001, 99};

    int *p = &stu.math;
    struct student *stup = NULL;
    stup = container_of( p, struct student, math);
    printf("%p\n",stup);
    printf("age: %d\n",stup->age);
    printf("num: %d\n",stup->num);

    return 0;
}

在这个程序中,我们定义一个结构体变量 stu,知道了它的成员变量 math 的地址 &stu.math,我们就可以通过 container_of 宏直接获得 stu 结构体变量的首地址,然后就可以直接访问 stu 结构体的其它成员 stup->age 和 stup->num。

4.7 container_of 宏实现分析

知道了 container_of 宏的用法之后,我们接着去分析这个宏的实现。作为一名 Linux 内核驱动开发者,除了要面对各种手册、底层寄存器,有时候还要应付底层造轮子的事情,为了系统的稳定和性能,有时候我们不得不深入底层,死磕某个模块,进行分析和优化。底层的工作虽然很有挑战性,但有时候也是很枯燥的,不像应用开发那样有意思。所以,为了提高对工作的兴趣,大家表面上虽然不说自己牛 X,但内心深处,一定要建立起自己的职位优越感。人不可有傲气,但一定要有傲骨:我们可不像应用开发,知道 API 接口、读读文档、完成功能就 OK 了。作为一名底层开发者,要时刻记住,要和寄存器、内存、硬件电路等各族底层群众打成一片。从群众中来,到群众中去,急群众所急,想群众所想,这样才能构建一个稳定和谐的嵌入式系统:稳定高效、上下通畅、运行365个日出也不崩溃。

container_of 宏的实现主要用到了我们上两节所学的知识:语句表达式和 typeof,再加上结构体存储的基础知识。为了帮助大家更好地理解这个宏,我们先复习下结构体存储的基础知识。

结构体在内存中的存储

我们知道,结构体作为一个复合类型数据,它里面可以有多个成员。当我们定义一个结构体变量时,编译器要给这个变量在内存中分配存储空间。除了考虑数据类型、字节对齐因素之外,编译器会按照结构体中各个成员的顺序,在内存中分配一片连续的空间来存储它们。

struct student{
    int age;
    int num;
    int math;
};
int main(void)
{
    struct student stu = { 20, 1001, 99};
    printf("&stu = %p\n", &stu);
    printf("&stu.age =%p\n", &stu.age);
    printf("&stu.num =%p\n", &stu.num);
    printf("&stu.math =%p\n", &stu.math);

    return 0;
}

在这个程序中,我们定义一个结构体,里面有三个 int 型数据成员,我们定义一个变量,然后分别打印结构体的地址、各个成员变量的地址,运行结果如下:

&stu      = 0028FF30
&stu.age  = 0028FF30
&stu.num  = 0028FF34
&stu.math = 0028FF38

从运行结果我们可以看到,结构体中的每个成员变量,从结构体首地址开始,依次存放。每个成员变量相对于结构体首地址,都有一个固定偏移。比如 num 相对于结构体首地址偏移了4个字节。math 的存储地址,相对于结构体首地址偏移了8个字节。

计算成员变量在结构体内的偏移

一个结构体数据类型,在同一个编译环境下,各个成员相对于结构体首地址的偏移是固定的。我们可以修改一下上面的程序,当结构体的首地址为0时,结构体中的各成员地址在数值上等于结构体各成员相对于结构体首地址的偏移。

struct student{
    int age;
    int num;
    int math;
};
int main(void)
{
    printf("&age = %p\n",&((struct student*)0)->age);
    printf("&num = %p\n",&((struct student*)0)->num);
    printf("&math= %p\n",&((struct student*)0)->math);
    return 0;
}

在上面的程序中,我们没有直接定义结构体变量,而是将数字0,通过强制类型转换,转换为一个指向结构体类型为 student 的常量指针,然后分别打印这个常量指针指向的结构体的各成员地址。运行结果如下:

&age = 00000000
&num = 00000004
&math= 00000008

因为常量指针为0,即可以看做结构体首地址为0,所以结构体中每个成员变量的地址即为该成员相对于结构体首地址的偏移。container_of 宏的实现就是使用这个技巧来实现的。

container_of 宏的实现

有了上面的基础,我们再去分析 container_of 宏的实现就比较简单了。知道了结构体成员的地址,如何去获取结构体的首地址?很简单,直接拿结构体成员的地址,减去该成员在结构体内的偏移,就可以得到该结构体的首地址了。

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

从语法角度,我们可以看到,container_of 宏的实现由一个语句表达式构成。语句表达式的值即为最后一个表达式的值:

(type *)( (char *)__mptr - offsetof(type,member) );

最后一句的意义就是,拿结构体某个成员 member 的地址,减去这个成员在结构体 type 中的偏移,结果就是结构体 type 的首地址。因为语句表达式的值等于最后一个表达式的值,所以这个结果也是整个语句表达式的值,container_of 最后就会返回这个地址值给宏的调用者。

那如何计算结构体某个成员在结构体内的偏移呢?内核中定义了 offset 宏来实现这个功能,我们且看它的定义:

#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)

这个宏有两个参数,一个是结构体类型 TYPE,一个是结构体的成员 MEMBER,它使用的技巧跟我们上面计算0地址常量指针的偏移是一样的:将0强制转换为一个指向 TYPE 的结构体常量指针,然后通过这个常量指针访问成员,获取成员 MEMBER 的地址,其大小在数值上就等于 MEMBER 在结构体 TYPE 中的偏移。

因为结构体的成员数据类型可以是任意数据类型,所以为了让这个宏兼容各种数据类型。我们定义了一个临时指针变量 __mptr,该变量用来存储结构体成员 MEMBER 的地址,即存储 ptr 的值。那如何获取 ptr 指针类型呢,通过下面的方式:

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

我们知道,宏的参数 ptr 代表的是一个结构体成员变量 MEMBER 的地址,所以 ptr 的类型是一个指向 MEMBER 数据类型的指针,当我们使用临时指针变量 mptr 来存储 ptr 的值时,必须确保 mptr 的指针类型是一个指向 MEMBER 类型的指针变量。typeof( ((type )0)->member )表达式使用 typeof 关键字,用来获取结构体成员 member 的数据类型,然后使用该类型,使用 typeof( ((type )0)->member ) *__mptr 这行程序语句,就可以定义一个指向该类型的指针变量了。

还有一个需要注意的细节就是:在语句表达式的最后,因为返回的是结构体的首地址,所以数据类型还必须强制转换一下,转换为 TYPE ,即返回一个指向 TYPE 结构体类型的指针,所以你会在最后一个表达之中看到一个强制类型转换(TYPE )。

小结

好了,到这里,我们对 container_of 宏的分析也就接近尾声了。任何一个复杂的东西,我们都可以把它分解,运用所学的基础知识一点一点剖析:先去降维分析,然后再进行综合。比如 container_of 宏的定义,就运用了结构体的存储、语句表达式、typeof 等知识点。掌握了这些基础知识,有了分析方法,以后在内核中再遇到这样类似的宏,就不用再百度、Google了,万一搜不到怎么办?在这样一个考察工程师技术能力的关键时刻,我们可以自信从容地去自己分析了。这就是你的核心竞争力,也是你超越其他工程师、脱颖而出的机会。

本教程根据 C语言嵌入式Linux高级编程视频教程 第05期 改编,电子版书籍可加入QQ群:475504428 下载,更多嵌入式视频教程,可关注:
微信公众号:宅学部落(armlinuxfun)
51CTO学院-王利涛老师:http://edu.51cto.com/sd/d344f

原文地址:http://blog.51cto.com/zhaixue/2348613

时间: 2024-10-13 12:01:46

嵌入式C语言自我修养 04:Linux 内核第一宏:container_of的相关文章

嵌入式C语言自我修养 03:宏构造利器 - 语句表达式

3.1 基础复习:表达式.语句和代码块 表达式 表达式和语句是 C 语言中的基础概念.什么是表达式呢?表达式就是由一系列操作符和操作数构成的式子.操作符可以是 C 语言标准规定的各种算术运算符.逻辑运算符.赋值运算符.比较运算符等.操作数可以是一个常量,也可以是一个变量.表达式也可以没有操作符,单独的一个常量甚至是一个字符串,也是一个表达式.下面的字符序列都是表达式: 2 + 3 2 i = 2 + 3 i = i++ + 3 "wit" 表达式一般用来数据计算或实现某种功能的算法.表

嵌入式C语言自我修养 09:链接过程中的强符号和弱符号

9.1 属性声明:weak GNU C 通过 attribute 声明weak属性,可以将一个强符号转换为弱符号. 使用方法如下. void __attribute__((weak)) func(void); int num __attribte__((weak); 编译器在编译源程序时,无论你是变量名.函数名,在它眼里,都是一个符号而已,用来表征一个地址.编译器会将这些符号集中,存放到一个叫符号表的 section 中. 在一个软件工程项目中,可能有多个源文件,由不同工程师开发.有时候可能会遇

嵌入式C语言自我修养 10:内联函数探究

10.1 属性声明:noinline & always_inline 这一节,接着讲 attribute 属性声明,attribute可以说是 GNU C 最大的特色.我们接下来继续讲一下跟内联函数相关的两个属性:noinline 和 always_inline.这两个属性的用途是告诉编译器:编译时,对我们指定的函数内联展开或不展开.它们的使用方法如下. static inline __attribute__((noinline)) int func(); static inline __att

嵌入式C语言自我修养 13:总结

13.1 总结 前面12节的课程,主要针对 Linux 内核中 GNU C 扩展的一些常用 C 语言语法进行了分析.GNU C 的这些扩展语法,主要用来完善 C 语言标准和编译优化.而通过 C 标准的发展过程我们又发现,对于一些编译器扩展的一些特性,或者其它编程语言(如:C++)中的好的特性和语法,C 标准也会适时地吸收进来,作为新的 C 语言标准. 在 GNU C 的这些扩展语法中,attribute 和宏定义是两大特色.在嵌入式底层系统中,尤其是 Linux 内核和 U-boot 中,大量使

嵌入式C语言自我修养 05:零长度数组

5.1 什么是零长度数组 顾名思义,零长度数组就是长度为0的数组. ANSI C 标准规定:定义一个数组时,数组的长度必须是一个常数,即数组的长度在编译的时候是确定的.在ANSI C 中定义一个数组的方法如下: int a[10]; C99 新标准规定:可以定义一个变长数组. int len; int a[len]; 也就是说,数组的长度在编译时是未确定的,在程序运行的时候才确定,甚至可以由用户指定大小.比如,我们可以定义一个数组,然后在程序运行时才指定这个数组的大小,还可以通过输入数据来初始化

嵌入式C语言自我修养 06:U-boot镜像自拷贝分析:section属性

6.1 GNU C 的扩展关键字:attribute GNU C 增加一个 atttribute 关键字用来声明一个函数.变量或类型的特殊属性.声明这个特殊属性有什么用呢?主要用途就是指导编译器在编译程序时进行特定方面的优化或代码检查.比如,我们可以通过使用属性声明指定某个变量的数据边界对齐方式. attribute 的使用非常简单,当我们定义一个函数.变量或类型时,直接在它们名字旁边添加下面的属性声明即可: __atttribute__((ATTRIBUTE)) 这里需要注意的是:attrib

嵌入式C语言自我修养 07:地址对齐那些事儿

7.1 属性声明:aligned GNU C 通过 attribute 来声明 aligned 和 packed 属性,指定一个变量或类型的对齐方式.这两个属性用来告诉编译器:在给变量分配存储空间时,要按指定的地址对齐方式给变量分配地址.如果你想定义一个变量,在内存中以8字节地址对齐,就可以这样定义. int a __attribute__((aligned(8)); 通过 aligned 属性,我们可以直接显式指定变量 a 在内存中的地址对齐方式.aligned 有一个参数,表示要按几字节对齐

嵌入式C语言自我修养 11:有一种函数,叫内建函数

11.1 什么是内建函数 内建函数,顾名思义,就是编译器内部实现的函数.这些函数跟关键字一样,可以直接使用,无须像标准库函数那样,要 #include 对应的头文件才能使用. 内建函数的函数命名,通常以 __builtin 开头.这些函数主要在编译器内部使用,主要是为编译器服务的.内建函数的主要用途如下. 用来处理变长参数列表: 用来处理程序运行异常: 程序的编译优化.性能优化: 查看函数运行中的底层信息.堆栈信息等: C 标准库函数的内建版本. 因为内建函数是编译器内部定义,主要由编译器相关的

嵌入式C语言自我修养 08:变参函数的格式检查

8.1 属性声明:format GNU 通过 attribute 扩展的 format 属性,用来指定变参函数的参数格式检查. 它的使用方法如下: __attribute__(( format (archetype, string-index, first-to-check))) void LOG(const char *fmt, ...) __attribute__((format(printf,1,2))); 我们经常实现一些自己的打印调试函数.这些打印函数往往是变参函数,那编译器编译程序时