Linux内核笔记003 - Linux内核代码里面的C语言和汇编语言

淡淡的烟草味﹌ 2022-12-02 13:44 158阅读 0赞

> 本文转自网络文章，内容均为非盈利，版权归原作者所有。  
> 转载此文章仅为个人收藏，分享知识，如有侵权，马上删除。  
> 原文作者：jmpcall  
> 专栏地址：[https://zhuanlan.kanxue.com/user-815036.htm][https_zhuanlan.kanxue.com_user-815036.htm]

## [ ][https_zhuanlan.kanxue.com_user-815036.htm]1. Linux内核中的C语言 ##

Linux内核是用GNU C编写，从而必须用gcc编译，另外gcc编译器在发展过程中，在不断的扩展和舍弃一些东西，所以就会出现一种情况：高版本gcc编译不了低版本内核、低版本gcc也编译不了高版本内核。所以在编译内核时，一定要使用跟内核版本差不多时期的gcc版本。

*  带返回值的宏函数

#include <stdio.h>
    #define FUN() ({ \
        int ret = 100; \
        printf("do something ..\n"); \
        ret; \
    })
     
    int main()
    {
        int m = FUN();
     
        printf("%d\n", m);
        return 0;
    }

执行结果：

do something ..
    100

*  do \{\} while (0)

宏函数DUMP\_WRITE()，在如下情况被调用时：

if (addr)
        DUMP_WRITE(addr,nr);
    else
        do_something_else();

按照如下两种方式定义，在被调用处展开后，都有问题：

#define DUMP_WRITE(addr,nr) memcpy(bufp,addr,nr); bufp += nr;
    #define DUMP_WRITE(addr,nr) { memcpy(bufp,addr,nr); bufp += nr; }

而利用"do \{\} while (0)"将多条语句包在一起，无论怎么调用，都不会有问题：

#define DUMP_WRITE(addr, nr) do { \
        memcpy(bufp, addr, nr); \
        bufp += nr; \
    } while (0)

*  \[first ... last\] = value

这是GUN C相对于ANSI C的一个扩展，用于将数组某个区间，初始化为非0值，比如：

int array[100] = { [0 ... 9] = 1, [10 ... 98] = 2, 3 };

*  include/linux/list.h

GUN C相对于ANSI C的扩展还有很多，书上已经列举了一小部分，更具体的，可以到后期学习代码时遇到了，再逐个了解。相对的，我认为include/linux/list.h这个头文件里面的代码，必须要在一开始就看懂，因为这里面的接口，大量用于内核的代码中，同时我觉得这种设计的思维也很精妙。

它用于构造双向循环链表， 从如下两份代码的对比中，应该就可以感受到它的好处：

代码1：

#include <stdio.h>
     
    struct data_node {
        int               n;
        char              c;
        struct data_node *prev;
        struct data_node *next;
    };
     
    int main()
    {
        struct data_node datas[4] = {
            { 1, 'a', NULL, NULL },
            { 2, 'b', NULL, NULL },
            { 3, 'c', NULL, NULL }
        };
        struct data_node *head = &datas[0];
     
        // 添加节点、遍历链表，需要业务层本身实现
        datas[0].prev = &datas[2];
        datas[0].next = &datas[1];
     
        datas[1].prev = &datas[0];
        datas[1].next = &datas[2];
     
        datas[2].prev = &datas[1];
        datas[2].next = &datas[0];
     
        while (1) {
            printf("datas[%d]: n=%d, c=%c, prev=%p, next=%p\n",
                head->n - 1, head->n, head->c, head->prev, head->next);
            if (head->n == 3)
                break;
            head = head->next;
        };
     
        return 0;
    }

运行结果：

datas[0]: n=1, c=a, prev=0xbfc5c84c, next=0xbfc5c83c
    datas[1]: n=2, c=b, prev=0xbfc5c82c, next=0xbfc5c84c
    datas[2]: n=3, c=c, prev=0xbfc5c83c, next=0xbfc5c82c

代码2：

#include <stdio.h>
    #include "list.h"
     
    struct data_node {
        int              n;
        char             c;
        struct list_head list;
    };
     
    int main()
    {
        struct data_node datas[4] = {
            { 1, 'a', { NULL, NULL } },
            { 2, 'b', { NULL, NULL } },
            { 3, 'c', { NULL, NULL } }
        };
        struct list_head head = LIST_HEAD_INIT(head);
        struct list_head *pos;
     
        // 添加节点、遍历链表，业务层直接调用接口
        list_add_tail(&datas[0].list, &head);
        list_add_tail(&datas[1].list, &head);
        list_add_tail(&datas[2].list, &head);
     
        printf("head: %p, prev=%p, next=%p\n", &head, head.prev, head.next);
     
        list_for_each(pos, &head) {
            struct data_node *data = list_entry(pos, struct data_node, list);
            printf("datas[%d]: n=%d, c=%c, prev=%p, next=%p\n",
                data->n - 1, data->n, data->c, data->list.prev, data->list.next);
        }
     
        return 0;
    }

运行结果：

head: 0xbf9ad48c, prev=0xbf9ad474, next=0xbf9ad454
    datas[0]: n=1, c=a, prev=0xbf9ad48c, next=0xbf9ad464
    datas[1]: n=2, c=b, prev=0xbf9ad454, next=0xbf9ad474
    datas[2]: n=3, c=c, prev=0xbf9ad464, next=0xbf9ad48c

*  list\_entry()

include/linux/list.h这份代码整体不难，但是如果是刚开始学习，可能会对宏函数list\_entry()有些疑惑：

#define list_entry(ptr, type, member) \
        ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))

① 首先要明白的是：为什么需要这个宏函数？

代码1中，datas\[1\].prev，直接就是&datas\[0\]，而代码2中，datas\[1\].list->prev，只是&datas\[0\].list而已，想知道&datas\[0\]的话，还需要减去list成员相对于结构体开始的偏移，知道目的后，再去理解这个宏函数就不难了。

![format_png][]

但是，还有值得注意的地方："&((type \*)0)->member"，按照平时开发程序的经验，可能觉得这里会coredump！

直接举例：

#include <stdio.h>
     
    struct test {
        int  n;
        char c;
    };
     
    int main()
    {
        struct test *p = NULL;
     
        //printf("%d, %c\n", p->n, p->c);    // coredump
        printf("%p, %p\n", &p->n, &p->c);    // 不coredump
        printf("%p, %p\n", &((struct test*)0)->n, &((struct test*)0)->c);    // 不coredump
     
        return 0;
    }

这样，就可以推测出来一个过程，我们平常在C程序中写的"p->n"，其实等价于"\*(&p->n)"，"&p->n"前面有个显式的&，则只是根据p的地址，计算成员n的地址，哪怕"p=NULL"也没关系，coredump只是发生在访问这个错误地址的时候而已。

## 2. Linux内核中的汇编代码 ##

*  Linux内核使用汇编的场合

① 有些操作硬件的专用指令，在C语言没有对应的语言成分，比如给GDTR/LDTR寄存器赋值的特权指令：LGDT/LLDT

② 某些场合，对效率要求极高，或者对执行时间有精准的要求

③ 某些场合，对程序的体积也有极端的要求，如引导程序

*  Linux内核使用汇编的形式

① 纯汇编代码。比如学习到第10章"系统的引导和初始化"时，就会遇到纯汇编文件bootsect.S、sctup.S，另外，后缀如果是大S，里面可能会包含一些C语言中的预处理语句，后缀为小s，就没有任何其它语言的影子；

② 嵌入式汇编。在C函数中，可以按照\_\_asm\_\_ \_\_volatile\_\_ (“指令部：输出部：输入部：损坏部”)格式，嵌入一块汇编语言（稍后举例）。

*  AT&T格式与intel格式比较

从网上可以查到很详细的资料，我觉得刚开始学，只需要对一些符号（比如：$、%）有印象即可，在看代码时遇到了，再去确认具体的含义。

*  嵌入式汇编/内联汇编

书1.5.2节，最后举了内核中2个使用了内联汇编的函数：\_\_memcpy()、strncmp()。

![format_png 1][]

(这个图我在[chinaunix][]发过，所以不是抄袭)

汇编代码块前后，是可以有C语句的。

① 所有用双引号包围的内容，为"指令部"，从紧接着指令部的冒号开始，依次标记为0、1、2、..

指令部后面第一个冒号开始，为“输出部”，用于指定C的各个变量，由哪些寄存代替。例子中，用ecx作d0，用edi作d1，用esi作d2；  
指令部后面第二个冒号开始，为“输入部”，用于初始化变量。例子中，"0"标号对应的"ecx/d0"=n/4，"q"让编译器从eax/ebx/ecx/edx选择一个进行使用，并且初始化为n，"1"标号对应的"edi/d1"=to，"2"标号对应的"esi/d2"=from；  
指令部后面第三个冒号开始，为“损坏部”，指令部和输出部中的寄存器，在执行过程中，都有可能被修改掉，如果希望某些寄存器的值保持不变，就可以在损坏部指定，编译器就会在入口添加压栈保存、在出口添加出栈恢复的指令。

② "指令部"分析：  
"输入部"已经完成了初始化：ecx = n/4，eax = n，eid = to，esi = from；  
第一条指令"rep; movsl\\n\\t"：重复执行movsl n/4（ecx）次，每次从from（esi）拷由4byte到to（edi），执行完可能还剩1~3字节没有拷贝；  
第二条指令"testb $2,%b4\\n\\t"：AT&T格式中，"$数字"表示立即数，"%数字"表示输入/输出部相应标号处的内容，所以这条指令就是判断%4（拷贝长度n）的低第二位是否为1（代码中为"%b4"，不确实是不是告诉编译器尽量用ebx的意思），如果为1，则至少还剩2字节，所以执行第四条指令"movsw"，再拷贝2字节，否则执行第三条指令"je 1f\\n\\t"（"f"表示forward，往前方最近的1标号处跳转），直接跳转到"1:\\ttestb $1,%b4\\n\\t"；

第五条指令，同样的道理，判断是否还剩1字节没的拷贝，如果是，则会执行"movsb"指令，再拷贝1字节。

③ 执行效率

由于这个函数的使用频率极高，所以内核直接使用汇编实现，让函数简洁到了极限，没有任何一条多余的指令。感兴趣的话，可以用C语言写一个\_\_memcpy()，用不同的优化级别编译，然后反编译和内核中的这个函数对比，感受一下。

[https_zhuanlan.kanxue.com_user-815036.htm]: https://zhuanlan.kanxue.com/user-815036.htm
[format_png]: /images/20221123/22c56b5b003e431a8988fcd1cf5a7228.png
[format_png 1]: /images/20221123/b52fefdbffa04e129fa487d3128968b2.png
[chinaunix]: http://bbs.chinaunix.net/