计算机系统大作业：Hello的一生

摘  要

HelloWorld是几乎全世界程序员编写的第一个程序，我们缓慢地输入HelloWorld 的几行代码，点击运行，惊喜地看到输出栏中的“Hello，World!”。但是很快我们就不再理会这个程序，去学习其他的语法。然而，在这个简单的hello中，囊括一个程序运行的所有过程，蕴含着无数计算机科学家的思想精华。

本文通过跟踪hello的一生，介绍了hello从代码编辑器到运行最后结束的过程，对计算机底层进行了较深的分析。

关键词：计算机系统；Linux；C语言；                            

第1章 概述

1.1 Hello简介

根据Hello的自白，利用计算机系统的术语，简述Hello的P2P，020的整个过程。

P2P：在文本编辑器中将hello的代码输入，并保存为.c格式的文件，形成hello.c文件。这就是程序（Program），这是hello程序的生命周期的开始。在OS（例如Linux）中，通过交互式应用程序Shell，输入命令实现对hello.c从源文件到目标文件的转化。源程序通过cpp（预处理器）预处理，ccl（编译器）编译，as（汇编器）汇编，最后通过ld（链接器）链接生成hello可执行目标程序并将其保存到磁盘中。

020：在Shell运行该hello程序时，Shell调用fork函数创建子进程，并通过execve函数将hello程序载入并创建运行环境，比如分配虚拟内存，运行完成后，Shell回收该进程，释放内存空间。

1.2 环境与工具

硬件环境：X86-64 Intel i7 10th   16 GB RAM   512 GHD Disk

软件环境：Windows 10    VMware 16  Ubuntu 20.04 LTS

开发调试工具：GDB，EDB，Visual Studio Code，Vim，gcc

1.3 中间结果

1. hello.c：源代码文件。
2. hello.i：预处理后的文本文件。
3. hello.s：编译后的汇编文件。
4. hello.o：汇编后的可重定位文件。
5. hello：链接后的可执行文件。
6. disa_hello.s：反汇编hello.o的汇编代码。
7. disa_hello_2.s：反汇编hello的汇编代码。

1.4 本章小结

本章对hello程序运行的P2P和020过程进行了简单的介绍，列出了此次大作业所使用的相关工具和软硬件环境，最后介绍了文中所用到的文件和作用。

第2章 预处理

2.1 预处理的概念与作用

预处理概念：预处理器cpp根据以字符#开头的命令（宏定义、条件编译），修改原始的C程序，将引用的所有库展开合并成为一个完整的文本文件。

预处理阶段作用：

1.处理宏定义指令预处理器根据#if和#ifdef等编译命令及其后的条件，将源程序中的某部分包含进来或排除在外，通常把排除在外的语句转换成空行。

2. 处理条件编译指令

条件编译指令如#ifdef，#ifndef，#else，#elif，#endif等。 这些伪指令的引入使得程序员可以通过定义不同的宏来决定编译程序对哪些代码进行处理。预编译程序将根据有关的文件，将那些不必要的代码过滤掉。

3.处理头文件包含指令头文件包含指令如#include "FileName"或者#include 等。 该指令将头文件中的定义统统都加入到它所产生的输出文件中，以供编译程序对之进行处理。

4.处理特殊符号

预编译程序可以识别一些特殊的符号。 例如在源程序中出现的LINE标识将被解释为当前行号（十进制数），FILE则被解释为当前被编译的C源程序的名称。预编译程序对于在源程序中出现的这些串将用合适的值进行替换。

2.2在Ubuntu下预处理的命令

预处理命令：gcc -E hello.c -o hello.i

图1 预处理命令

图2 文件列表

2.3 Hello的预处理结果解析

打开hello.i查看文件。

开头时引入外部库.h文件。

图3 hello.i文本文件 1

接下来是typedef进行数据类型名称替换。

图4 hello.i文本文件 2

引入外部函数：

图5 hello.i文本文件 3

最后，是我们编写的main函数代码：

图6 hello.i文本文件 4

经过预处理之后，hello.c转化为hello.i文件，打开该文件可以发现，文件的内容增加，且仍为可以阅读的C语言程序文本文件。对原文件中的宏进行了宏展开，头文件中的内容被包含进该文件中。例如声明函数、定义结构体、定义变量、定义宏等内容。另外，如果代码中有#define命令还会对相应的符号进行替换。

2.4 本章小结

本章介绍了hello.c的预处理过程，大致分析了预处理后形成的hello.i文件。可以知道，仅23行的.c文件预处理后的文件竟有3000行。如果编写一个hello程序需要3000行，这样的效率是极其低下的。这也就是预处理的意义：能让我们轻松写出可读性高，方便修改，利于调试的代码。

第3章 编译

3.1 编译的概念与作用

概念：编译是将预处理后的文本文件.i翻译为汇编语言的文本文件.s。

编译程序把一个源程序翻译成目标程序的工作过程分为五个阶段：词法分析，语法分析，语义检查和中间代码生成，代码优化，目标代码生成。主要是进行词法分析和语法分析，又称为源程序分析，分析过程中发现有语法错误，给出提示信息。

作用：将高级程序语言翻译为统一的，接近机器语言，对机器友好的汇编语言。

3.2 在Ubuntu下编译的命令

编译命令：gcc -S hello.i -o hello.s

图7 编译命令

图8 文件列表

3.3 Hello的编译结果解析

3.3.0汇编指令的介绍

.file:声明源文件

.text：代码节

.section:

.rodata:只读代码段

.align：数据或者指令的地址对其方式

.string：声明一个字符串（.LC0,.LC1）

.global：声明全局变量(main)

.type:声明一个符号是数据类型还是函数类型

编译生成了hello.s文件，为汇编代码，该小节将针对hello程序具体介绍编译器怎么处理C语言中各个数据类型以及各类操作的。

3.3.1常量

1. 1. 字符串常量：

"用法: Hello 学号 姓名 秒数！\n"

"Hello %s %s\n"。

汇编文件在开头为.LC0和.LC1中存放这两个字符串，其中一个汉字对应一个\xxx。这些常量存放在.rodata节，意为只读数据。

图9 hello.s文件 1

1. 1. 立即数常量

如for循环中9这个常量：

图10 hello.s文件 2

3.3.2变量

1. 1. 局部变量

“int i”

局部变量存放在寄存器或栈中。

查看汇编代码：

图11 hello.s文件 3

可以知道，i存放在栈中。

3.3.3算术操作

“i++”：

如上图，addl指令对i进行+1。

1. 赋值:

“i = 0”:

图12 hello.s文件 4

通过movl指令赋初值。

程序中的赋值操作主要有：i=0这条赋值操作在汇编代码主要使用mov指令来实现，而根据数据的类型又有好几种不一样的后缀

movb:一个字节

movw：两个字节

movl：四个字节

movq：八个字节

3.3.4比较语句：

比较通过cmp等指令来实现，根据两个操作数的差来设置条件码。

3.3.5数组/指针操作

“sleep(atoi(argv[3]))”：

图13 hello.s文件 5

可以知道%rax先保存了argv[3]的地址。

3.3.6函数调用及返回：

如上图中调用的atoi函数，%rdi为参数，存放着字符串的首地址，%eax为返回值，为一个整数。调用函数时有以下操作：（假设函数P调用函数Q）

（1）传递控制：进行过程 Q 的时候，程序计数器必须设置为 Q 的代码的起始 地址，然后在返回时，要把程序计数器设置为 P 中调用 Q 后面那条指令的 地址。

（2）传递数据：P 必须能够向 Q 提供一个或多个参数，Q 必须能够向 P 中返回 一个值。

（3） 分配和释放内存：在开始时，Q 可能需要为局部变量分配空间，而在返回 前，又必须释放这些空间。

hello.C涉及的函数操作有：

main函数，printf，exit，sleep ，getchar函数

main函数的参数是argc和argv；两次printf函数的参数恰好是那两个字符串

exit参数是1，sleep函数参数是atoi（argv[3]）

函数的返回值存储在%eax寄存器中。

3.4 本章小结

本节主要介绍编译器通过编译由.i文件生成汇编语言的.s文件的过程，并分析了变量，赋值，循环等各类C语言的基本语句的汇编表示。汇编语言和高级语言很不同，即使是高级语言中一个简单的条件语句或者循环语句在汇编语言中都需要涉及到更多步骤来实现。学习汇编语言与编译，使我们能够真正的理解计算机底层的一些执行方法，有利于我们以后对程序的优化或调试。

第4章 汇编

4.1 汇编的概念与作用

概念：把汇编语言翻译成机器语言的过程称为汇编，汇编器同时将汇编程序（.s文件）打包成可重定位目标程序（.o文件）。这里的.o是二进制文件，而.s仍然是文本文件。

作用：通过汇编，汇编代码转化为了计算机能够完全理解的机器代码。

4.2 在Ubuntu下汇编的命令

汇编命令：gcc -c -m64 -no-pie -fno-PIC hello.s -o hello.o

图14 汇编命令

图15 文件列表

4.3 可重定位目标elf格式

分析hello.o的ELF格式，用readelf等列出其各节的基本信息，特别是重定位项目分析。

分析：

1. ELF头

命令：readelf -h -hello.o

ELF头首先以一个16字节的序列开始，这个序列描述了生成该文件的系统的 字的大小和字节顺序。剩下部分就如下图所示，列出了包含帮助链接器语法分析和解释目标文件的信息。其中包括ELF头的大小（64字节），目标文件的类型（REL可重定位文件），机器类型（AMD X86-64），节头部表的文件偏移，以及节头部表中条目的大小和数量。

图16 ELF头

1. 节头部表

命令：readelf -S hello.o

图17 节头部表

Section Headers:节头部表，包含了文件中出现的各个节的语义，包括节 的类型、位置和大小等信息。 由于是可重定位目标文件，所以每个节都从0开始，用于重定位。在文件头中得到节头表的信息，然后再使用节头表中的字节偏移信息得到各节在文件中的起始位置，以及各节所占空间的大小，同时可以观察到，代码是可执行的，但是不能写；数据段和只读数据段都不可执行，而且只读数据段也不可写。符号表（.symtab）

命令：readelf -s hello.o

图18 符号表

可以看到.c文件中用到的main，atoi，exit，sleep函数。

.symtab： 存放程序中定义和引用的函数和全局变量的信息。name是符号名称，对于可冲定位目标模块，value是符号相对于目标节的起始位置偏移，对于可执行目标文件，该值是一个绝对运行的地址。size是目标的大小，type要么是数据要么是函数。Bind字段表明符号是本地的还是全局的。

1. 重定位条目

命令：readelf -r hello.o

图19 重定位条目

重定位节：一个.text 节中位置的列表，包含.text 节中需要进行重定位的信息，当链接器把这个目标文件和其他文件组合时，需要修改这些位置。

重定位节.rela.text中各项符号的信息：

Offset:需要被修改的引用节的偏移Info：包括symbol和type两个部分，symbol在前面四个字节，type在后面四个字节,

symbol：标识被修改引用应该指向的符号,

type:重定位的类型

Type：告知链接器应该如何修改新的应用

Attend：一个有符号常数，一些重定位要使用它对被修改引用的值做偏移调整Name:重定向到的目标的名称。

当汇编器生成 hello.o 后，它并不知道数据和代码最终将放在内存中的什么位置。它也不知道这个模块引用的任何外部定义的函数或者全局变量的位置。所以，无论何时汇编器遇到对最终位置未知的目标引用，它就会生成一个重定位条目。重定位条目在链接时告诉链接器目标文件合并时如何修改应用。  

 重定位条目的类型这里有两种，R_X86_64_32意思是重定位时使用一个32位的绝对地址的引用，通过绝对寻址，CPU直接使用在指令中编码的32位值作为有效地址，不需要进一步修改。R_X86_64_PC32意思是重定位时使用一个32位PC相对地址的引用。一个PC相对地址就是据程序计数器的当前运行值的偏移量。

4.4 Hello.o的结果解析

命令：objdump -d -r hello.o > disa_hello.s

生成hello.o的反汇编文件。

分析hello.o的反汇编，并与第3章的 hello.s进行对照分析。

通过反汇编的代码和hello.s进行比较，发现汇编语言的指令并没有什么不同的地方，只是反汇编代码所显示的不仅仅是汇编代码，还有机器代码，机器语言程序的是二进制机器指令的集合，是纯粹的二进制数据表示的语言，是电脑可以真正识别的语言。机器指令由操作码和操作数构成，汇编语言是人们比较熟悉的词句直接表述CPU动作形成的语言，是最接近CPU运行原理的语言。每一条汇编语言操作码都可以用机器二进制数据来表示，进而可以将所有的汇编语言(操作码和操作数）和二进制机器语言建立一一映射的关系，因此可以将汇编语言转化为机器语言，通过对机器代码的分析可以看出一下不同的地方。

图20 disa_hello.s文件内容

不同点：

1. 跳转命令：hello.s的跳转目的是.L1，.L2这样的符号来实现的，而disa_hello.s中，是直接跳转到指令的地址。而这个地址在<>中注明了关于整个函数首地址的偏移量，这个偏移量是根据PC值和距跳转目的的偏移量算出来的。
2. 函数调用：hello.s函数调用后是函数名，而disa_hello.s中call后有函数名，也有关于这个函数地址的信息，如重定位条目的类型。

4.5 本章小结

从汇编代码变为机器代码后，这个程序就可以真正被计算机理解。我们也可以利用反汇编工具查看一些二进制机器程序的汇编代码从而去破解或翻译，虽然反汇编后的代码与原本的汇编代码有所不同。

第5章 链接

5.1 链接的概念与作用

概念：链接是将各种代码和数据片段收集并组合成为了一个单一文件的过程，这个文件可被加载（复制）到内存并执行。链接可以执行于编译时，也可以执行于加载时，分别对应静态链接和动态链接。

作用：链接在软件开发中扮演着重要角色，因为它使得分离编译成为可能。我们可以将软件进行模块化设计，然后模块化编程，这样分组工作高效。而且，需要修改或者调试时，只需要修改某个模块，然后简单地重新编译它，并重新链接，而不是全部重新编译链接。

5.2 在Ubuntu下链接的命令

链接命令：

ld -o hello -dynamic-linker

/lib64/ld-linux-x86-64.so.2  /usr/lib/x86_64-linux-gnu/crt1.o

/usr/lib/x86_64-linux-gnu/crti.o  hello.o

/usr/lib/x86_64-linux-gnu/libc.so  /usr/lib/x86_64-linux-gnu/crtn.o

图21 链接指令

5.3 可执行目标文件hello的格式

1. ELF头

命令：readelf -h hello

1. ELF Header:hello的文件头和hello.o文件头的不同之处如下图标记所示，Type类型为EXEC表明hello是一个可执行目标文件.
2. 节头部表Section Headers：Section Headers 对 hello中所有的节信息进行了声明，其 中包括大小 Size 以及在程序中的偏移量 Offset，因此根据 Section Headers 中的信息我们就可以用 HexEdit 定位各个节所占的区间（起始位置，大小）。其中 Address 是程序被载入到虚拟地址的起始地址。

图22 ELF头

节头数量由14变为27。

1. 节头部表：

命令：readelf -S hello

图23 节头部表-1

图24 节头部表-2

发现了一些动态链接所增加的段。

5.4 hello的虚拟地址空间

hello的虚拟地址从0x401000开始。

图25 EDB查看虚拟地址空间

比较readelf的段信息和edb的虚拟内存空间：

查看偏移0x3048的.data段

图26 EDB查看.data

5.5 链接的重定位过程分析

objdump -d -r hello > disa_hello_2.s分析与disa_hello.s的不同

通过分析hello与hello.o的不同，说明链接的过程。可以发现以下不同的地方：

hello反汇编的代码有确定的虚拟地址，也就是说已经完成了重定位,而hello.o反汇编代码中代码的虚拟地址均为0，未完成可重定位的过程，

图27 查看disa_hello_2.s文件内容

1. hello重定位的过程：

(1)重定位节和符号定义链接器将所有类型相同的节合并在一起后，这个节就作为可执行目标文件的节。然后链接器把运行时的内存地址赋给新的聚合节，赋给输入模块定义的每个节，以及赋给输入模块定义的每个符号，当这一步完成时，程序中每条指令和全局变量都有唯一运行时的地址。

(2)重定位节中的符号引用这一步中，连接器修改代码节和数据节中对每个符号的引用，使他们指向正确的运行时地址。执行这一步，链接器依赖于可重定位目标模块中称为的重定位条目的数据结构。

(3)重定位条目当编译器遇到对最终位置未知的目标引用时，它就会生成一个重定位条目。代码的重定位条目放在.rel.txt

1. 新增加的函数：

新增加了很多函数和它的实现汇编代码，如我们源代码中使用的printf，atoi，exit等。还有_init初始化函数。

1. 新增加的节（Section）：

新增加了.init节，.plt节，.plt.sec。

1. 调用函数：

调用函数不再有重定位类型和偏移量，而是直接为函数的绝对地址和它的函数名。

链接：链接器（ld）将各个目标文件（各种.o文件）组装在一起，文件中的各个函数段按照一定规则累积在一起。从.o提供的重定位条目将函数调用和控制流跳转的地址填写为最终的地址。

5.6 hello的执行流程

图28 hello的执行流程

5.7 Hello的动态链接分析

动态链接的基本思想是把程序按照模块拆分成各个相对独立部分，在程序运行时才将它们链接在一起形成一个完整的程序，而不是像静态链接一样把所有程序模块都链接成一个单独的可执行文件。虽然动态链接把链接过程推迟到了程序运行时，但是在形成可执行文件时（注意形成可执行文件和执行程序是两个概念），还是需要用到动态链接库。比如我们在形成可执行程序时，发现引用了一个外部的函数，此时会检查动态链接库，发现这个函数名是一个动态链接符号，此时可执行程序就不对这个符号进行重定位，而把这个过程留到装载时再进行。

在调用共享库函数时，编译器没有办法预测这个函数的运行时地址，因为定义它的共享模块在运行时可以加载到任意位置。正常的方法是为该引用生成一条重定位记录，然后动态链接器在程序加载的时候再解析它。GNU编译系统使用延迟绑定(lazybinding),将过程地址的绑定推迟到第一次调用该过程时。延迟绑定是通过GOT和PLT实现的。GOT是数据段的一部分，而PLT是代码段的一部分。两表内容分别为：

PLT：PLT是一个数组，其中每个条目是16字节代码。PLT[0]是一个特殊条目，它跳转到动态链接器中。每个被可执行程序调用的库函数都有它自己的PLT条目。每个条目都负责调用一个具体的函数。

GOT：GOT是一个数组，其中每个条目是8字节地址。和PLT联合使用时，GOT[O]和GOT[1]包含动态链接器在解析函数地址时会使用的信息。GOT[2]是动态链接器在1d-linux.so模块中的入口点。其余的每个条目对应于一个被调用的函数，其地址需要在运行时被解析。每个条目都有一个相匹配的PLT条目。

   在进行动态链接前，首先进行静态链接，生成部分链接的可执行目标文件 hello。此时共享库中的代码和数据没有被合并到 hello 中。只有在加载 hello 时，动态链接器才对共享目标文件中的相应模块内的代码和数据进行重定位，加载共享库，生成完全链接的可执行目标文件。

例如：查看.plt段

图29 EDB查看.plt段-1

运行后：

图30 EDB查看.plt段-2

5.8 本章小结

本章主要介绍了链接器如何将hello.o可重定向文件与动态库函数链接起来，分析了可重定位文件与可执行文件ELF的差异，并分析了重定位的过程。 

第6章 hello进程管理

6.1 进程的概念与作用

概念：进程的经典定义是一个执行中程序的实例，系统的每个程序都运行在某个进程的上下文。上下文是由程序正确运行所需的状态组成的，这个状态包括存放在内存里的程序的代码和数据，它的栈，通用目的寄存器的内容，程序计数器，环境变量以及打开文件描述符的集合。进程是计算机科学中最深刻，最成功的概念。

作用：通过进程，我们会得到一种假象，好像我们的程序是当前唯一运行的程序，我们的程序独占处理器和内存，我们程序的代码和数据好像是系统内存中唯一的对象。而这些假象就是通过进程来实现的。

6.2 简述壳Shell-bash的作用与处理流程

Shell 是一种交互型的应用级程序，用户能够通过 Shell 与操作系统内核进行交互。

bash，全称为Bourne-Again Shell。它是一个为GNU项目编写的Unix shell。bash脚本功能非常强大，尤其是在处理自动循环或大的任务方面可节省大量的时间。bash是许多Linux平台的内定Shell。

处理流程：

1. Shell读取用户输入的命令。
2. Shell判断是否为shell内置命令，如果不是则认为是一个可执行文件。、
3. Shell构建参数和环境变量。
4. Shell通过fork创建子进程，再通过execve函数加载可执行文件。
5. Shell回收创建的子进程，循环。

6.3 Hello的fork进程创建过程

我们在Shell上输入./hello,这个不是一个内置的Shell命令，所以Shell会认为hello是一个可执行目标文件，通过条用某个驻留在存储器中被称为加载器的操作系统代码来运行它。当Shell运行一个程序时，父进程通过fork函数生成这个程序的进程。这个子进程几乎与父进程相同，子进程得到与父进程相同的虚拟地址空间（独立）的一个副本，包括代码，数据段，堆，共享库以及用户栈，并且和父进程共享文件。它们之间最大的不同是PID不同。

1. 1. Hello的execve过程

当创建了一个子进程之后，子进程调用exceve函数在当前子进程的上下文加载并运行一个新的程序即hello程序，加载并运行需要以下几个步骤：

(1)删除已存在的用户区域。删除当前进程虚拟地址的用户部分中已存在的区域结构。

(2)映射私有区域。为新程序的代码、数据、bss和栈区域创建新的区域结构。所有这些区域结构都是私有的，写时复制的。虚拟地址空间的代码和数据区域被映射为hello文件的.txt和.data区。bss区域是请求二进制零的，映射匿名文件，其大小包含在hello文件中。栈和堆区域也是请求二进制零的，初始长度为零。如图6.4

(3)映射共享区域。如果hello程序与共享对象链接，比如标准C库libc.so，那么这些对象都是动态链接到这个程序的，然后再映射到用户虚拟地址空间中的共享区域。

(4)设置程序计数器（PC）。exceve做的最后一件事就是设置当前进程的上下文中的程序计数器，使之指向代码区域的入口点。下一次调用这个进程时，它将从这个入口点开始执行。Linux将根据需要换入代码和数据页面。

除了一些头部信息，在加载过程中没有任何从磁盘到内存的数据 复制。直到 CPU 引用一个被映射的虚拟页时才会进行复制，这时，操作系统利用 它的页面调度机制自动将页面从磁盘传送到内存。

6.5 Hello的进程执行

逻辑控制流：一系列程序计数器PC的值的序列叫做逻辑控制流，进程是轮流使用处理器的，在同一个处理器核心中，每个进程执行它的流的一部分后被抢占（暂时挂起），然后轮到其他进程。

时间片：一个进程执行它的控制流的一部分的每一时间段叫做时间片。

用户模式和内核模式：处理器通常使用一个寄存器提供两种模式的区分，该寄存器描述了进程当前享有的特权，当没有设置模式位时，进程就处于用户模式中，用户模式的进程不允许执行特权指令，也不允许直接引用地址空间中内核区内的代码和数据；设置模式位时，进程处于内核模式，该进程可以执行指令集中的任何命令，并且可以访问系统中的任何内存位置。

上下文信息：上下文就是内核重新启动一个被抢占的进程所需要的状态，它由通用寄存器、浮点寄存器、程序计数器、用户栈、状态寄存器、内核栈和各种内核数据结构等对象的值构成。

上下文切换：上下切换是由内核中调度器完成的，当内核调度新的进程运行后，它就会抢占当前进程，并进行1）保存以前进程的上下文2）恢复新恢复进程被保存的上下文，3）将控制传递给这个新恢复的进程 ，来完成上下文切换。

Hello：当hello运行到sleep函数时，是在用户模式，然后调用sleep函数，进入内核模式，内核处理休眠请求，并开始计时。当时间到了后，内核接受到恢复hello运行的信号，再进行调度，切换上下文，返回用户模式。

当hello调用getchar的时候，实际落脚到执行输入流是stdin的系统调用read，hello之前运行在用户模式，在进行read调用之后陷入内核，内核中的陷阱处理程序请求来自键盘缓冲区的DMA传输，并且安排在完成从键盘缓冲区到内存的数据传输后，中断处理器。此时进入内核模式，内核执行上下文切换，切换到其他进程。当完成键盘缓冲区到内存的数据传输时，引发一个中断信号，此时内核从其他进程进行上下文切换回hello进程。

1. 1. hello的异常与信号处理

异常和信号异常可以分为四类：中断、陷阱、故障、终止，各自的属性如图信号处理。

hello程序出现的异常可能有：

中断：在hello程序执行的过程中可能会出现外部I/O设备引起的异常。

陷阱：陷阱是有意的异常，是执行一条指令的结果，hello执行sleep函数的时候会出现这个异常。

故障：在执行hello程序的时候，可能会发生缺页故障。

终止：终止时不可恢复的错误，在hello执行过程可能会出现DRAM或者SRAM位损坏的奇偶错误。

在发生异常时会发出信号，比如缺页故障会导致OS发生SIGSEGV信号给用户进程，而用户进程以段错误退出。常见信号种类如下表所示。

1. 不停乱按，包括回车：

图31 乱按的现象

Shell会将回车前输出的字符串当作命令。

1. Ctrl + C

图32 Ctrl + C的现象

会立即终止进程，通过ps命令发现hello进程被回收。

1. Ctrl + Z

图33 Ctrl + Z的现象

会在后台停止，fg放到前台运行时，会输出剩下的7个字符串。

6.7本章小结

本章了解了hello进程的执行过程。在hello运行过程中，内核对其调度，异常处理程序为其将处理各种异常。每种信号都有不同的处理机制，对不同的shell命令，hello也有不同的响应结果。

第七章 hello的存储管理

7.1hello的存储器地址空间

逻辑地址：程序经过编译后出现在汇编代码中的地址。逻辑地址用来指定一个操作数或者是一条指令的地址。是由一个段标识符加上一个指定段内相对地址的偏移量，表示为 [段标识符：段内偏移量]。

线性地址：也叫虚拟地址，和逻辑地址类似，也是一个不真实的地址，如果逻辑地址是对应的硬件平台段式管理转换前地址的话，那么线性地址则对应了硬件也是内存的转换前地址。

虚拟地址：也就是线性地址。

物理地址：用于内存芯片级的单元寻址，与处理器和CPU链接的地址总线相对应。可以直接把物理地址理解成插在机器上那根内存本身，把内存看成一个从0字节一直到最大空量逐字节的编号的大数组，然后把这个数组叫做物理地址，但是事实上，这只是一个硬件提供给软件的抽像，内存的寻址方式并不是这样。所以，说它是“与地址总线相对应”，是更贴切一些，不过抛开对物理内存寻址方式的考虑，直接把物理地址与物理的内存一一对应，也是可以接受的。也许错误的理解更利于形而上的抽像。

7.2 Intel逻辑地址到线性地址的变换-段式管理

一个逻辑地址由两部份组成，段标识符: 段内偏移量。段标识符是由一个16位长的字段组成，称为段选择符。其中前13位是一个索引号。后面3位包含一些硬件细节，表示具体的是代码段寄存器还是栈段寄存器抑或是数据段寄存器，如图所示。

索引号就是“段描述符(segment descriptor)”的索引，段描述符具体地址描述了一个段。很多个段描述符，就组了一个数组，叫“段描述符表”，这样，可以通过段标识符的前13位，直接在段描述符表中找到一个具体的段描述符，这句话很关键，说明段标识符的具体作用，每一个段描述符由8个字节组成，如图所示

Base字段，表示的是包含段的首字节的线性地址，也就是一个段的开始位置的线性地址。一些全局的段描述符，就放在“全局段描述符表(GDT)”中，一些局部的，例如每个进程自己的，就放在所谓的“局部段描述符表(LDT)”中。那究竟什么时候该用GDT，什么时候该用LDT呢？这是由段选择符中的T1字段表示的，=0，表示用GDT，=1表示用LDT，GDT在内存中的地址和大小存放在CPU的gdtr控制寄存器中，而LDT则在ldtr寄存器中。

图详细显示了一个逻辑地址是怎样转换成相应线性地址的，逻辑地址转换为线性地址的一般步骤：

首先，给定一个完整的逻辑地址[段选择符：段内偏移地址]，

1、看段选择符的T1=0还是1，知道当前要转换是GDT中的段，还是LDT中的段，再根据相应寄存器，得到其地址和大小。我们就有了一个数组了。

2、拿出段选择符中前13位，可以在这个数组中，查找到对应的段描述符，这样，它了Base，即基地址就知道了。

3、把Base + offset，就是要转换的线性地址了。

7.3 Hello的线性地址到物理地址的变换-页式管理

由课本知识点可知，线性地址（也就是虚拟地址 VA）到物理地址（PA）之间的转换通过分页机制完成。而分页机制是对虚拟地址内存空间进行分页。

这里我们不考虑TLB和多级页表，这将在下面探讨。

使用虚拟寻址，CPU通过生成一个虚拟地址来访问主存，这个虚拟地址被送到内存之前首先转换为适当的物理地址。将一个虚拟地址转换为物理地址叫做地址翻译，需要CPU硬件和操作系统之间的紧密合作。CPU芯片上叫做内存管理单元(MMU)的住哪用硬件，利用主存中的查询表来动态翻译虚拟地址。

虚拟地址作为到磁盘上存放字节的数组的索引，磁盘上的数组内容被缓存在主存中。同时，磁盘上的数据被分割成块，这些块作为磁盘和主存之间的传送单元。虚拟内存分割被成为虚拟页。物理内存被分割为物理页，物理页和虚拟页的大小时相同的。

任意时刻虚拟页都被分为三个不相交的子集：

未分配的：VM系统还未分配的页

缓存的：当前已经缓存在物理内存的已分配页

未缓存的：当前未缓存在物理内存的已分配页

每次将虚拟地址转换为物理地址，都会查询页表来判断一个虚拟页是否缓存在DRAM的某个地方，如果不在DRAM的某个地方，通过查询页表条目可以知道虚拟页在磁盘的位置。页表将虚拟页映射到物理页。如图7.3.1所示，页表就是一个页表条目的数组，每一个页表条目是由一个有效位和一个n为地址字段组成。有效位表明虚拟页是否缓存在DRAM中，n位地址字段是物理页的起始地址或者虚拟页在次胖的起始地址。通过了解了上述虚拟地址转换为物理地址操作系统所提供的机制，现在我们来看一下到底是如何实现虚拟地址到物理地址的转换。如图所示。

通过了解了上述虚拟地址转换为物理地址操作系统所提供的机制，现在我们来看一下到底是如何实现虚拟地址到物理地址的转换。

n位的虚拟地址包含两个部分：一个p位的虚拟页面偏移(VPO),一个n-p位的虚拟页号(VPN)，MMU利用VPN选择适当的PTE，例如VPN 0选择PTE 0。根据PTE，我们知道虚拟页的信息，如果虚拟页是已缓存的，那直接将页表条目的物理页号和虚拟地址的VPO串联起来就得到一个相应的物理地址。这里的VPO和PPO是相同的。如果虚拟页是未缓存的，会触发一个缺页故障。调用一个缺页处理子程序将磁盘的虚拟页重新加载到内存中，然后再执行这个导致缺页的指令。

7.4 TLB与四级页表支持下的VA到PA的变换

 TLB与四级页表支持下的VA到PA的变换在 Intel Core i7 环境下研究 VA 到 PA 的地址翻译问题。前提如下： 虚拟地址空间 48 位，物理地址空间 52 位，页表大小 4KB，4 级页表。TLB 4 路 16 组相联。CR3 指向第一级页表的起始位置（上下文一部分）。 解析前提条件：由一个页表大小 4KB，一个 PTE 条目8B，共 512 个条目，使 用 9 位二进制索引，一共 4 个页表共使用 36 位二进制索引，所以 VPN 共 36 位， 因为 VA 48 位，所以 VPO 12 位；因为 TLB 共 16 组，所以 TLBI 需 4 位，因为 VPN 36 位，所以 TLBT 32 位。

如图，CPU 产生虚拟地址 VA，VA 传送给 MMU，MMU 使用前 36 位 VPN 作为 TLBT（前 32 位）+TLBI（后 4 位）向 TLB 中匹配，如果命中，则得到 PPN （40bit）与 VPO（12bit）组合成 PA（52bit）。 如果 TLB 中没有命中，MMU 向页表中查询，CR3 确定第一级页表的起始地 址，VPN1（9bit）确定在第一级页表中的偏移量，查询出 PTE，如果在物理内存 中且权限符合，确定第二级页表的起始地址，以此类推，最终在第四级页表中查 询到 PPN，与 VPO 组合成 PA，并且向 TLB 中添加条目。如果查询 PTE 的时候发现不在物理内存中，则引发缺页故障。如果发现权限不够，则引发段错误。

7.5 三级Cache支持下的物理内存访问

我们只讨论Cashe1的物理内存访问，Cashe2，Cashe3原理相同。

由于L1Cashe有64组，所以组索引位s为6，每组有8个高速缓存行，由于每个块的大小为64B，所以块偏移为为6，因此标记位为52-6-6=40位。

因此L1Cashe的物理访存大致过程如下：

(1) 组选择取出虚拟地址的组索引位，将二进制组索引转化为一个无符号整数，找到相应组

(2) 行匹配把虚拟地址的标记为拿去和相应的组中所有行的标记位进行比较，当虚拟地址的标记位和高速缓存行的标记位匹配时，而且高速缓存行的有效位是1，则高速缓存命中。

(3) 字选择一旦高速缓存命中，我们就知道我们要找的字节在这个块的某个地方。因此块偏移位提供了第一个字节的偏移。把这个字节的内容取出返回给CPU即可

（4）不命中如果高速缓存不命中，那么需要从存储层次结构中的下一层取出被请求的块，然后将新的块存储在组索引位所指示的组中的一个高速缓存行中。一种简单的 放置策略如下：如果映射到的组内有空闲块，则直接放置，否则组内都是有效块， 产生冲突（evict），则采用最近最少使用策略 LFU 进行替换。如图所示 。

7.6 hello进程fork时的内存映射

当 fork 函数被 shell 进程调用时，内核为新进程创建各种数据结构，并分配给 它一个唯一的 PID，为了给这个新进程创建虚拟内存，它创建了当前进程的 mm_struct、区域结构和页表的原样副本。它将这两个进程的每个页面都标记为只 读，并将两个进程中的每个区域结构都标记为私有的写时复制。

7.7 hello进程execve时的内存映射

execve 函数调用驻留在内核区域的启动加载器代码，在当前进程中加载并运 行包含在可执行目标文件 hello 中的程序，用 hello 程序有效地替代了当前程序。 加载并运行 hello 需要以下几个步骤：

1)删除已存在的用户区域，删除当前进程虚拟地址的用户部分中的已存 在的区域结构。

2）映射私有区域，为新程序的代码、数据、bss 和栈区域创建新的区域结 构，所有这些新的区域都是私有的、写时复制的。代码和数据区域被映射为 hello 文件中的.text 和.data 区，bss 区域是请求二进制零的，映射到匿名 文件，其大小包含在 hello 中，栈和堆地址也是请求二进制零的，初始长 度为零。

3)映射共享区域， hello 程序与共享对象 libc.so 链接，libc.so 是动态链 接到这个程序中的，然后再映射到用户虚拟地址空间中的共享区域内。

4）设置程序计数器（PC），execve 做的最后一件事情就是设置当前进程 上下文的程序计数器，使之指向代码区域的入口点。

7.8 缺页故障与缺页中断处理

缺页故障：当指令引用一个相应的虚拟地址，而与改地址相应的物理页面不再内存中，会触发缺页故障。通过查询页表PTE可以知道虚拟页在磁盘的位置。缺页处理程序从指定的位置加载页面 到物理内存中，并更新PTE。然后控制返回给引起缺页故障的指令。当指令再次执行时，相应的物理页面已经驻留在内存中，因此指令可以没有故障的运行完成。故障处理具体流程如图所示

最终，我们在所学习的范围内，回顾了这段hello的一生。

7.9动态存储分配管理

动态内存分配器维护者一个进程的虚拟内存区域，成为堆。(如图7.9.1所示),分配器将堆视为一组不同的大小的块的集合来维护。每个块就是一个连续的虚拟内存片，要么是已分配的，要么是空闲的。分配器有两种基本风格。两种风格都是要求显示的释放分配块。

1. 显式分配器：要求应用显示的释放任何已分配的块。例如C标准库提供一个叫做malloc程序包的显示分配器。

2. 隐式分配器：要求分配器检测一个已分配块何时不再被程序使用，那么就释放这个块。隐式分配器也叫垃圾收集器。

3.显示分配器的约束条件

①处理任意的请求序列

②立即相应请求

③只使用堆

④对其块(对齐要求)

⑤不修改已分配的块

4.隐式空闲链表

隐式空闲链表区别块的边界、已分配块和空闲块的方法如图所示

这种情况下，一个块是由一个字的头部、有效载荷，以及可能的填充组成。头部编码了这个块的大小(包括头部和所有的填充),以及这个块是已分配的还是空闲的。块的头最后一位指明这个块是已分配的还是空闲的。

头部后面是应用malloc时请求的有效载荷。有效载荷后面是一片不使用的填充块，其大小可以是任意的。块的格式如图所示，空闲块通过头部块的大小字段隐含的连接着，所以我们称这种结构就隐式空闲链表。

(1)放置已分配的块当一个应用请求一个k字节的块时，分配器搜索空闲链表。查找一个足够大可以放置所请求的空闲块。分配器搜索方式的常见策略是首次适配、下一次适配和最佳适配。

1. 分割空闲块一旦分配器找到一个匹配的空闲块，就必须做一个另策决定，那就是分配这个块多少空间。分配器通常将空闲块分割为两部分。第一部分变为了已分配块，第二部分变为了空闲块。如图7.9.4所示。

(3)获取额外堆内存如果分配器不能为请求块找到空闲块，一个选择是合并那些在物理内存上相邻的空闲块，如果这样还不能生成一个足够大的块，分配器会调用sbrk函数，向内核请求额外的内存。

1. 合并空闲块合并的情况一共分为四种：前空后不空，前不空后空，前后都空，前后都不空。对于四种情况分别进行空闲块合并，我们只需要通过改变头部的信息就能完成合并空闲块。Knuth提出了一种采用边界标记的技术快速完成空闲块的合并。如图所示

5.显示空闲链表

显示空闲链表是将空闲块组织为某种形式的显示数据结构。如图所示。堆被组织为一个双向空闲链表，在每个空闲块中，都包含一个前驱和后继的指针。

使用双向链表而不是隐式空闲链表，使首次适配的分配时间从块总数的线 性时间减少到了空闲块数量的线性时间。

一种方法使用后进先出的顺序维护链表，将新释放的块在链表的开始处。使用LIFO的顺序和首次适配的放置策略，分配器会最先检查最近使用过 的块，在这种情况下，释放一个块可以在线性的时间内完成，如果使用了边界 标记，那么合并也可以在常数时间内完成。

按照地址顺序来维护链表，其中链 表中的每个块的地址都小于它的后继的地址，在这种情况下，释放一个块需要 线性时间的搜索来定位合适的前驱。平衡点在于，按照地址排序首次适配比 LIFO 排序的首次适配有着更高的内存利用率，接近最佳适配的利用率。

7.10本章小结

本章主要介绍了hello的存储器的地址空间，介绍了四种地址空间的差别和地址的相互转换。同时介绍了hello的四级页表的虚拟地址空间到物理地址的转换。阐述了三级cashe的物理内存访问、进程 fork 时的内存映射、execve 时的内存映射、缺页故障与缺页中断处理、动态存储分配管理。

第8章 hello的IO管理

8.1 Linux的IO设备管理方法

一个Linux文件就是一个m字节的序列：B0,B1,B2……Bm

所有的 IO 设备(如网路、磁盘、终端)都被模型化为文件，而所有的输入和输出都被 当做对相应文件的读和写来执行，这种将设备优雅地映射为文件的方式，允许 Linux 内核引出一个简单低级的应用接口，称为 Unix I/O,这使得所有的输入和输出都被当做相应文件的读和写来执行：

设备的模型化：文件

设备管理：unix io接口

8.2 简述Unix IO接口及其函数

Unix I/O 接口：

(1)打开文件。一个应用程序通过要求内核打开相应的文件，来宣告它想 要访问一个 I/O 设备，内核返回一个小的非负整数，叫做描述符，它在 后续对此文件的所有操作中标识这个文件，内核记录有关这个打开文 件的所有信息。

(2）Shell 创建的每个进程都有三个打开的文件：标准输入，标准输出，标 准错误。 (3)改变当前的文件位置：对于每个打开的文件，内核保持着一个文件位 置 k，初始为 0，这个文件位置是从文件开头起始的字节偏移量，应用 程序能够通过执行 seek，显式地将改变当前文件位置 k。

(4)读写文件：一个读操作就是从文件复制 n>0 个字节到内存，从当前文 件位置 k 开始，然后将 k 增加到 k+n，给定一个大小为 m 字节的而文 件，当 k>=m 时，触发 EOF。类似一个写操作就是从内存中复制 n>0 个字节到一个文件，从当前文件位置 k 开始，然后更新 k。

(5)关闭文件，内核释放文件打开时创建的数据结构，并将这个描述符恢 复到可用的描述符池中去。

Unix I/O 函数:

（1）int open(char* filename,int flags,mode_t mode) ，进程通过调用 open 函 数来打开一个存在的文件或是创建一个新文件的。 open函数将filename 转换为一个文件描述符，并且返回描述符数字，返回的描述符总是在 进程中当前没有打开的最小描述符，flags 参数指明了进程打算如何访 问这个文件，mode 参数指定了新文件的访问权限位。

(2)int close(fd)，fd 是需要关闭的文件的描述符，close 返回操作结果。

(3) ssize_t read(int fd,void *buf,size_t n)，read 函数从描述符为 fd 的当前文 件位置赋值最多 n 个字节到内存位置 buf。返回值-1 表示一个错误，0 表示 EOF，否则返回值表示的是实际传送的字节数量。

4） ssize_t wirte(int fd,const void *buf,size_t n)，write 函数从内存位置 buf 复制至多 n 个字节到描述符为 fd 的当前文件位置。

8.3 printf的实现

分析首先查看printf函数的函数体：

printf程序按照格式fmt结合参数args生成格式化之后的字符串，并返回字串的长度。接下来是write函数：

在printf中调用系统函数write(buf,i)将长度为i的buf输出，在write函数中，将栈中参数放入寄存器，ecx是字符个数，ebx存放第一个字符地址，

int INT_VECTOR_SYS_CALLA代表通过系统调用syscall。

查看syscall函数体：

syscall将字符串中的字节从寄存器中通过总线复制到显卡的显存中，显存中存储的是字符的ASCII码。字符显示驱动子程序将通过ASCII码在字模库中找到点阵信息将点阵信息存储到vram中。

显示芯片会按照一定的刷新频率逐行读取vram，并通过信号线向液晶显示器传输每一个点（RGB分量）。

于是我们的打印字符串就显示在了屏幕上。

从vsprintf生成显示信息，到write系统函数，到陷阱-系统调用 int 0x80或syscall.

字符显示驱动子程序：从ASCII到字模库到显示vram（存储每一个点的RGB颜色信息）。

显示芯片按照刷新频率逐行读取vram，并通过信号线向液晶显示器传输每一个点（RGB分量）。

8.4 getchar的实现分析

getchar 的源代码为：

异步异常-键盘中断的处理：当用户按键时，键盘接口会得到一个代表该按键 的键盘扫描码，同时产生一个中断请求，中断请求抢占当前进程运行键盘中断子 程序，键盘中断子程序先从键盘接口取得该按键的扫描码，然后将该按键扫描码 转换成 ASCII 码，保存到系统的键盘缓冲区之中。

getchar 函数落实到底层调用了系统函数 read，通过系统调用 read 读取存储在 键盘缓冲区中的 ASCII 码直到读到回车符然后返回整个字串，getchar 进行封装， 大体逻辑是读取字符串的第一个字符然后返回。

8.5本章小结

本章主要介绍了 Linux 的 IO 设备管理方法、Unix IO 接口及其函数，分析了 printf 函数和 getchar 函数的实现。

结论

1. 编写hello.c源代码程序。
2. hello.c预处理为hello.i。
3. hello.i编译为汇编语言hello.s。
4. hello.s汇编翻译为机器语言生成可重定位文件hello.o。
5. hello.o文件与动态库链接，生成可执行文件hello。
6. 在Shell中，输出./hello，创建进程。
7. 在子进程中，加载hello的上下文，映射内存。
8. 在hello运行的过程中，接收信号，进行信号处理。
9. 程序运行完成后，回收进程，释放内存。

会想起一开始的C语言学习，有时候报一些不是语法的错很不理解，有时候数组越界了却提示超时错误也很不理解。我们只是把从源代码到结果作为一个黑盒，而现在对于一个程序如何执行有了一个大体的认识，明白了之前的错误，但是还是有不清楚的地方，只学习到了第八章，还需要在以后的学习中继续努力。