计算机系统
大作业
题 目 程序人生-Hello’s P2P
专 业 航天学院 人工智能（未来技术）
学 号 7203610101
班 级 2036015
学 生 周子康
指 导 教 师 史先俊
计算机科学与技术学院
2022年5月
本论文将CSAPP课程所学内容结合hello小程序的一生，研究了hello.c这一简单c语言文件在Linux系统下的整个生命周期，对我们所学进行全面的梳理与回顾。以其原始程序开始，依次深入研究了编译、链接、加载、运行、终止、回收的过程，从而了解hello.c文件的“一生”。该论文以hello.c文件为研究对象，结合《深入理解计算机系统》书中的内容与课上老师的讲授，在Ubuntu下对hello程序的整个生命周期进行了研究，通过对hello.c程序的深入研究，得以把计算机系统整个的体系串联在一起，真正做到了学以致用，融会贯通。
关键词：hello；程序的一生；程序生命周期；计算机系统；计算机体系结构；
（摘要0分，缺失-1分，根据内容精彩称都酌情加分0-1分）
目 录
2.2在Ubuntu下预处理的命令.......................................................................... - 6 -
3.2 在Ubuntu下编译的命令............................................................................. - 9 -
4.2 在Ubuntu下汇编的命令........................................................................... - 22 -
5.2 在Ubuntu下链接的命令........................................................................... - 30 -
5.3 可执行目标文件hello的格式.................................................................. - 30 -
5.5 链接的重定位过程分析............................................................................... - 38 -
6.2 简述壳Shell-bash的作用与处理流程..................................................... - 43 -
6.3 Hello的fork进程创建过程..................................................................... - 43 -
6.6 hello的异常与信号处理............................................................................ - 44 -
第7章 hello的存储管理............................................................................... - 50 -
7.1 hello的存储器地址空间............................................................................ - 50 -
7.2 Intel逻辑地址到线性地址的变换-段式管理............................................ - 50 -
7.3 Hello的线性地址到物理地址的变换-页式管理...................................... - 50 -
7.4 TLB与四级页表支持下的VA到PA的变换............................................. - 51 -
7.5 三级Cache支持下的物理内存访问.......................................................... - 52 -
7.6 hello进程fork时的内存映射.................................................................. - 53 -
7.7 hello进程execve时的内存映射.............................................................. - 54 -
7.8 缺页故障与缺页中断处理........................................................................... - 54 -
8.1 Linux的IO设备管理方法.......................................................................... - 57 -
8.2 简述Unix IO接口及其函数....................................................................... - 57 -
第1章 概述
1.1 Hello简介
Hello的P2P是指hello.c文件从可执行程序（Program）变为运行时进程（Process）的过程。在Linux系统下，hello.c 文件依次经过cpp（C Pre-Processor，C预处理器）预处理、ccl（C Compiler，C编译器） 编译、as （Assembler，汇编器）汇编、ld （Linker，链接器）链接最终成为可执行目标程序hello（在Linux下该文件无固定后缀）。打开shell，输入命令./hello后，shell 通过fork产生子进程，hello 便从可执行程序（Program）变成为进程（Process）。
Hello的020是指hello.c文件“From 0 to 0”，初始时内存中并无hello文件的相关内容，这便是“From 0”。通过在Shell下调用execve函数，系统会将hello文件载入内存，执行相关代码，当程序运行结束后， hello进程被回收，并由内核删除hello相关数据，这即为“to 0”。
1.2 环境与工具
硬件环境：处理器：Intel(R) Core(TM) i7-10750H CPU @ 2.60GHz 2.59 GHz
RAM：16.0 GB (15.8 GB 可用)
系统类型：64位操作系统，基于x64的处理器
软件环境：Windows10 64位；Ubuntu 20.04.1
开发与调试工具：Visual Studio 2019，gedit，gcc，notepad++，readelf, objdump，hexedit，edb
1.3 中间结果
列出你为编写本论文，生成的中间结果文件的名字，文件的作用等。
表格 1 中间结果
| 文件名 | 功能 |
| hello.i | 预处理后得到的文本文件 |
| hello.s | 编译后得到的汇编语言文件 |
| hello.o | 汇编后得到的可重定位目标文件 |
| hello.elf | 用readelf读取hello.o得到的ELF格式信息 |
| hello.asm | 反汇编hello.o得到的反汇编文件 |
| hello1.elf | 由hello可执行文件生成的.elf文件 |
| hello1.asm | 反汇编hello可执行文件得到的反汇编文件 |
1.4 本章小结
本章对hello进行了一个总体的概括，简要介绍了hello 的P2P，020的具体含义，同时列出了研究时采用的具体软硬件环境和中间结果。
（第1章0.5分）
第2章 预处理
2.1 预处理的概念与作用
预处理中会展开以#起始的行，试图解释为预处理指令(preprocessing directive) ，其中 ISO C/C++要求支持的包括#if、 #ifdef、 #ifndef、 #else、 #elif、 #endif（条件编译）、 #define（宏定义）、 #include（源文件包含）、 #line（行控制）、 #error（错误指令）、 #pragma（和实现相关的杂注）以及单独的#（空指令）。预处理指令一般被用来使源代码在不同的执行环境中被方便的修改或者编译。
预处理的作用：
- 将源文件中用#include 形式声明的文件复制到新的程序中。比如 hello.c中的#include<stdio.h> 等命令告诉预处理器读取系统头文件 stdio.h unistd.h stdlib.h 的内容，并把它直接插入到程序文本中。
- 用实际值替换用#define 定义的字符串
- 根据#if 后面的条件决定需要编译的代码
- 特殊符号，预编译程序可以识别一些特殊的符号， 预编译程序对于在源程序中出现的这些串将用合适的值进行替换。
注：预处理过程中并未直接解析程序源代码的内容，而是对源代码进行相应的分割、处理和替换。简单来说，预处理是一个文本插入与替换的过程，生成的hello.i文件仍然是文本文件。
2.2在Ubuntu下预处理的命令
在Ubuntu下，进行预处理的命令为：
cpp hello.c > hello.i
运行截图如下：
正在上传…重新上传取消
图 1 预处理过程
2.3 Hello的预处理结果解析
在Linux下打开hello.i文件，可以发现hello.i程序已经拓展为3060行，行数比起hello.c文件大幅增加。其中， hello.c中的main函数相关代码在hello.i程序中对应着3047行到3060行。
正在上传…重新上传取消
图 2 预处理结果部分展示
在main函数内代码出现之前是大段的头文件 stdio.h unistd.h stdlib.h 的依次展开。展开的具体流程概述如下（以stdio.h为例）：CPP先删除指令#include <stdio.h>，并到Ubuntu系统的默认的环境变量中寻找 stdio.h，最终打开路径/usr/include/stdio.h下的stdio.h文件。若stdio.h文件中使用了#define语句，则按照上述流程继续递归地展开，直到所有#define语句都被解释替换掉为止。除此之外，CPP还会进行删除程序中的注释和多余的空白字符等操作，并对一些值进行替换。
2.4 本章小结
本章主要介绍了预处理的概念及作用、并结合Ubuntu系统下hello.c文件实际预处理之后得到的hello.i程序对预处理结果进行了解析，详细了解了预处理的内涵。
（第2章0.5分）
第3章 编译
3.1 编译的概念与作用
编译的概念：
编译程序所要做的工作就是通过词法分析和语法分析，在确认所有的指令都符合语法规则之后，将其翻译成等价的中间代码表示或汇编代码。编译器将文本文件 hello.i 翻译成文本文件 hello.s。
编译的作用：
编译包括以下基本流程：
- 语法分析：编译程序的语法分析器以单词符号作为输入，分析单词符号串是否形成符合语法规则的语法单位，方法分为两种：自上而下分析法和自下而上分析法。
- 中间代码：源程序的一种内部表示，或称中间语言。中间代码的作用是可使编译程序的结构在逻辑上更为简单明确，特别是可使目标代码的优化比较容易实现中间代码。
- 代码优化：指对程序进行多种等价变换，使得从变换后的程序出发，能生成更有效的目标代码。
- 目标代码：生成是编译的最后一个阶段。目标代码生成器把语法分析后或优化后的中间代码变换成目标代码。此处指汇编语言代码，须经过汇编程序汇编后，成为可执行的机器语言代码。
3.2 在Ubuntu下编译的命令
在Ubuntu系统下，进行预处理的命令为：
gcc -S hello.i -o hello.s
运行截图如下：
正在上传…重新上传取消
图 3 编译过程
3.3 Hello的编译结果解析
-
-
- 文件结构分析
-
对hello.s文件整体结构分析如下：
表格 2 hello.s文件结构
| 内容 | 含义 |
| .file | 源文件 |
| .text | 代码段 |
| .global | 全局变量 |
| .data | 存放已经初始化的全局和静态C 变量 |
| .section .rodata | 存放只读变量 |
| .align | 对齐方式 |
| .type | 表示是函数类型/对象类型 |
| .size | 表示大小 |
| .long .string | 表示是long类型/string类型 |
在if语句
正在上传…重新上传取消
中，常量4的值保存的位置在.text中，作为指令的一部分
正在上传…重新上传取消
同理可得
正在上传…重新上传取消
中的数字0、8、1、2、3也被存储在.text节中；
-
-
-
- 字符串
-
-
在下述函数中：
正在上传…重新上传取消
printf()、scanf()中的字符串则被存储在.rodata节中
正在上传…重新上传取消
字符串常量，储存在.text数据段中。\XXX为UTF-8编码，一个汉字对应三个字节。
-
-
-
- 变量
-
-
全局变量：
初始化的全局变量储存在.data节，在.type段声明其为object类型，在.size段声明其长度，它的初始化不需要汇编语句，而是直接完成的。
局部变量：
编译器将局部变量存储在寄存器或者栈空间中。i作为函数内部的局部变量，并不占用文件实际节的空间，只存在于运行时栈中。对于i的操作就是直接对寄存器或栈进行操作。
在hello.s中我们可以看出，i占据了4字节的地址空间：
正在上传…重新上传取消
在汇编代码中
正在上传…重新上传取消
此处是循环前i=0的操作，i被保存在栈当中。
-
-
-
- 数组
-
-
程序中涉及的数组为char *argv[]，即函数的第二个参数。在hello.s中，其首地址保存在栈中。访问时，通过寄存器寻址的方式访问。
正在上传…重新上传取消
表格 3 mov指令的后缀
| 后缀 | b | w | l | q |
| 大小（字节） | 1 | 2 | 3 | 4 |
2. 初始化的全局变量储存在.data节，在.type段声明其为object类型，在.size段声明其长度，它的初始化不需要汇编语句，而是直接完成的。
-
-
- 算术操作
-
汇编语言中，算数操作的指令包括：
表格 4 算数操作指令
| 指令 | 效果 |
| leaq s,d | d=&s |
| inc d | d+=1 |
| dec d | d-=1 |
| neg d | d=-d |
| add s,d | d=d+s |
| sub s,d | d=d-s |
| imulq s | r[%rdx]:r[%rax]=s*r[%rax]（有符号） |
| mulq s | r[%rdx]:r[%rax]=s*r[%rax]（无符号） |
| idivq s | r[%rdx]=r[%rdx]:r[%rax] mod s（有符号） r[%rax]=r[%rdx]:r[%rax] div s |
| divq s | r[%rdx]=r[%rdx]:r[%rax] mod s（无符号） r[%rax]=r[%rdx]:r[%rax] div s |
在hello.s中，具体涉及的算数操作包括：
- subq $32, %rsp：开辟栈帧
- addq $16, %rax：修改地址偏移量
- addl $1, -4(%rbp)：实现i++的操作
在hello.s中，具体涉及的关系操作包括：
- argc!=4：
检查argc是否不等于4。在hello.s中，使用cmpl $4,-20(%rbp)，比较 argc与4的大小并设置条件码，为下一步je利用条件码进行跳转作准备。
正在上传…重新上传取消
图 4检查argc!=4
- i<8：
检查i是否小于8。在hello.s中，使用cmpl $7, -4(%rbp)比较i与7的大小，然后设置条件码，为下一步jle利用条件码进行跳转做准备。
正在上传…重新上传取消
图 5 检查i<8
-
-
- 数组/指针/结构操作
-
主函数main的参数中有指针数组char *argv[]
正在上传…重新上传取消
在argv数组中，argv[0]指向输入程序的路径和名称，argv[1]和argv[2]分别表示两个字符串。
因为char* 数据类型占8个字节，根据
正在上传…重新上传取消
正在上传…重新上传取消
正在上传…重新上传取消
正在上传…重新上传取消对比原函数可知通过%rsi-8和%rax-16，分别得到argv[1]和argv[2]两个字符串。
-
-
- 控制转移
-
程序中控制转移的具体表现有两处：
- if(argc!=4)：
当argc不等于4时，执行函数体内部的代码。在hello.s中，使用cmpl $4,-20(%rbp)，比较 argc与4是否相等，若相等，则跳转至.L2，不执行后续部分内容；若不等则继续执行函数体内部对应的汇编代码。
正在上传…重新上传取消
图 6 控制转移
- for(i=0;i<8;i++)：
当i < 8时进行循环，每次循环i++。在hello.s中，使用cmpl $7,-4 (%rbp)，比较 i与7是否相等，在i<=7时继续循环，进入.L4，i>7时跳出循环。
正在上传…重新上传取消
图 7 循环的情况
C语言中，调用函数时进行的操作如下：
- 传递控制：
进行过程 Q 的时候，程序计数器必须设置为 Q 的代码的起始地址，然后在返回时，要把程序计数器设置为 P 中调用 Q 后面那条指令的地址。
- 传递数据：
P 必须能够向 Q 提供一个或多个参数，Q 必须能够向 P 中返回一个值。
- 分配和释放内存：
在开始时，Q 可能需要为局部变量分配空间，而在返回前，又必须释放这些空间。
另附64位系统下的参数传递顺序：
表格 5 64位系统的传参顺序
| 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| %rdi | %rsi | %rdx | %rcx | %r8 | %r9 | 栈空间 |
具体到hello.s中，程序入口处，调用了main 函数，其在hello.s中标注为@function函数类型。之后又调用 puts，printf，sleep，exit，getchar 函数，对函数的调用都通过call指令进行。
main函数：
参数传递：传入参数argc和argv[]，分别用寄存器%rdi和%rsi存储。
函数调用：被系统启动函数调用。
函数返回：设置%eax为0并且返回，对应return 0 。
源代码：
正在上传…重新上传取消
汇编代码：
正在上传…重新上传取消
可见argc存储在%edi中，argv存储在%rsi中；
printf函数：
参数传递：call puts时只传入了字符串参数首地址；for循环中call printf时传入了 argv[1]和argc[2]的地址。
函数调用：if判断满足条件后调用，与for循环中被调用。
源代码1：
正在上传…重新上传取消正在上传…重新上传取消
汇编代码1：
正在上传…重新上传取消正在上传…重新上传取消
正在上传…重新上传取消正在上传…重新上传取消
源代码2：
正在上传…重新上传取消正在上传…重新上传取消
汇编代码2：
正在上传…重新上传取消
exit函数：
参数传递：传入的参数为1，再执行退出命令
函数调用：if判断条件满足后被调用.
源代码：
正在上传…重新上传取消
汇编代码：
正在上传…重新上传取消正在上传…重新上传取消
sleep函数：
参数传递：传入参数atoi(argv[3])，
函数调用：for循环下被调用，call sleep
源代码：
正在上传…重新上传取消正在上传…重新上传取消
汇编代码：
正在上传…重新上传取消正在上传…重新上传取消
getchar函数：
函数调用：在main中被调用，call getchar
源代码：
正在上传…重新上传取消正在上传…重新上传取消
汇编代码：
正在上传…重新上传取消
3.4 本章小结
本章介绍了编译的概念与作用，编译是将文本文件翻译成汇编语言程序，为后续将其转化为二进制机器码做准备的过程。同时，本章以hello.s文件为例，介绍了编译器如何处理各个数据类型以及各类操作，验证了大部分数据、操作在汇编代码中的实现。
（第3章2分）
第4章 汇编
4.1 汇编的概念与作用
概念
汇编是指汇编器（assembler）将以.s结尾的汇编程序翻译成机器语言指令，并把这些指令打包成可重定位目标程序格式，最终结果保存在.o 目标文件中的过程
作用
汇编器将.s 汇编程序翻译成机器语言指令，把这些指令打包成可重定位目标程序的格式，并将结果保存在.o 目标文件中，.o文件是一个二进制文件，它包含程序的指令编码。
注意：这儿的汇编是指从 .s 到 .o 即编译后的文件到生成机器语言二进制程序的过程。
4.2 在Ubuntu下汇编的命令
在Ubuntu下汇编的命令为：
as hello.s -o hello.o
汇编过程如下：
正在上传…重新上传取消正在上传…重新上传取消
图 8 汇编的命令
4.3 可重定位目标elf格式
分析hello.o的ELF格式，用readelf等列出其各节的基本信息，特别是重定位项目分析。
首先，在shell中输入readelf -a hello.o > hello.elf 指令获得 hello.o 文件的 ELF 格式：
正在上传…重新上传取消正在上传…重新上传取消
图 9 生成ELF文件
其结构分析如下：
- ELF 头（ELF Header）：
以 16字节序列 Magic 开始，其描述了生成该文件的系统的字的大小和字节顺序，ELF 头剩下的部分包含帮助链接器语法分析和解释目标文件的信息，其中包括 ELF 头大小、目标文件类型、机器类型、节头部表的文件偏移，以及节头部表中条目的大小和数量等相关信息。
正在上传…重新上传取消正在上传…重新上传取消
图 10 ELF头的情况
- 节头：
包含了文件中出现的各个节的意义，包括节的类型、位置和大小等信息。
正在上传…重新上传取消正在上传…重新上传取消
图 11 节头的情况
- 重定位节.rela.text
一个.text 节中位置的列表，包含.text 节中需要进行重定位的信息，当链接器把这个目标文件和其他文件组合时，需要修改这些位置。
在这里，8 条重定位信息分别是对.L0（第一个 printf 中的字符串）、puts 函数、exit 函数、.L1（第二个 printf 中的字符串）、printf 函数、atoi、sleep 函数、getchar 函数进行重定位声明。
.rela.text节包含如下信息：
表格 6 .rela.text节包含的信息
| 偏移量 | 代表需要进行重定向的代码在.text或.data节中的偏移位置 |
| 信息 | 包括symbol和type两部分，其中symbol占前半部分，type占后半部分，symbol代表重定位到的目标在.symtab中的偏移量，type代表重定位的类型 |
| 类型 | 重定位到的目标的类型 |
| 加数 | 计算重定位位置的辅助信息 |
正在上传…重新上传取消正在上传…重新上传取消
图 12 .rela.text节
- 重定位节.rela.eh_frame
正在上传…重新上传取消正在上传…重新上传取消
图 13 .rela.eh_frame节
- 符号表Symbol table
符号表中保存着定位、重定位程序中符号定义和引用的信息，所有重定位需要引用的符号都在其中声明。
图 14 符号表的情况
4.4 Hello.o的结果解析
使用objdump -d -r hello.o > hello.asm 分析hello.o的反汇编，并与第3章的 hello.s文件进行对照分析。
正在上传…重新上传取消正在上传…重新上传取消
图 15 生成hello.asm文件
通过对比hello.asm与hello.s可知，两者在如下地方存在差异：
- 分支转移：
在hello.s中，跳转指令的目标地址直接记为段名称，如.L2，.L3等。而在反汇编得到的hello.asm中，跳转的目标为具体的地址，在机器代码中体现为目标指令地址与当前指令下一条指令的地址之差。
正在上传…重新上传取消正在上传…重新上传取消
图 16 分支转移
- 函数调用：
在hello.s文件中，call之后直接跟着函数名称，而在反汇编得到的hello.asm中，call 的目标地址是当前指令的下一条指令。这是因为 hello.c 中调用的函数都是共享库中的函数，最终需要通过动态链接器作用才能确定函数的运行时执行地址，在汇编成为机器语言的时候，对于这些不确定地址的函数调用，将其 call 指令后的相对地址设置为全0（此时，目标地址正是下一条指令），然后在.rela.text 节中为其添加重定位条目，等待静态链接进一步确定。
正在上传…重新上传取消正在上传…重新上传取消
图 17 函数调用
- 全局变量访问：
在hello.s 文件中，使用段名称+%rip访问 rodata（printf 中的字符串），而在反汇编得到的hello.asm中，使用 0+%rip进行访问。其原因与函数调用类似，rodata 中数据地址在运行时才能确定，故访问时也需要重定位。在汇编成为机器语言时，将操作数设置为全 0 并添加相应的重定位条目。
正在上传…重新上传取消正在上传…重新上传取消
图 18 全局变量访问
说明机器语言的构成，与汇编语言的映射关系。特别是机器语言中的操作数与汇编语言不一致，特别是分支转移函数调用等。
4.5 本章小结
本章介绍了汇编的概念与作用，在Ubuntu下通过实际操作将hello.s文件翻译为hello.o文件，并生成hello.o的ELF格式文件hello.elf，研究了ELF格式文件的具体结构。通过比较hello.o的反汇编代码（保存在hello.asm中）与hello.s中代码，
了解了汇编语言与机器语言的异同之处。
（第4章1分）
第5章 链接
5.1 链接的概念与作用
链接是指通过链接器（Linker），将程序编码与数据块收集并整理成为一个单一文件，生成完全链接的可执行的目标文件(windows系统下为.exe文件，Linux系统下一般省略后缀名)的过程。
- 链接的作用
提供了一种模块化的方式，可以将程序编写为一个较小的源文件的集合，且实现了分开编译更改源文件，从而减少整体文件的复杂度与大小，增加容错性，也方便对某一模块进行针对性修改。
注意：这儿的链接是指从 hello.o 到hello生成过程。
5.2 在Ubuntu下链接的命令
在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
链接过程如下：
正在上传…重新上传取消正在上传…重新上传取消
图 19 链接的命令
5.3 可执行目标文件hello的格式
在Shell中输入命令 readelf -a hello > hello1.elf 生成 hello 程序的 ELF 格式文件，保存为hello1.elf（与第四章中的elf文件作区分）：
正在上传…重新上传取消正在上传…重新上传取消
图 20 生成ELF文件
打开hello1.elf，分析hello的ELF格式如下：
- ELF 头（ELF Header）
hello1.elf中的ELF头与hello.elf中的ELF头包含的信息种类基本相同，以 描述了生成该文件的系统的字的大小和字节顺序的16字节序列 Magic 开始，剩下的部分包含帮助链接器语法分析和解释目标文件的信息。与hello.elf相比较，hello1.elf中的基本信息未发生改变（如Magic，类别等），而类型发生改变，程序头大小和节头数量增加，并且获得了入口地址。
正在上传…重新上传取消正在上传…重新上传取消
图 21 ELF头的情况
- 节头
hello1.elf中的节头包含了文件中出现的各个节的语义，包括节的类型、位置、偏移量和大小等信息。与hello.elf相比，其在链接之后的内容更加丰富详细（此处仅截取部分展示）。
正在上传…重新上传取消正在上传…重新上传取消
图 22 节头的情况
- 程序头
程序头部分是一个结构数组，描述了系统准备程序执行所需的段或其他信息。
正在上传…重新上传取消
图 23 程序头的部分
- Dynamic section
正在上传…重新上传取消正在上传…重新上传取消
正在上传…重新上传取消正在上传…重新上传取消
图 25 重定位节
- Symbol table
符号表中保存着定位、重定位程序中符号定义和引用的信息，所有重定位需要引用的符号都在其中声明（此处仅截取部分展示）。
正在上传…重新上传取消正在上传…重新上传取消
图 26 Symbol table
5.4 hello的虚拟地址空间
使用edb加载hello，查看本进程的虚拟地址空间各段信息，并与5.3对照分析说明。
正在上传…重新上传取消正在上传…重新上传取消
根据计算机系统的特性，程序被载入至地址0x400000~0x401000中。在该地址范围内，每个节的地址都与前一节中节对应的 Address 相同。根据edb查看的结果，在地址空间0x400000~0x400fff中存放着与地址空间0x400000~0x401000相同的程序，在0x400fff之后存放的是.dynamic到.shstrtab节的内容。
查看 ELF 格式文件中的程序头，它告诉链接器运行时加载的内容，并提供动态链接的信息。每一个表项提供了各段在虚拟地址空间和物理地址空间的各方面的信息。在下面可以看出，程序包含PHDR，INTERP，LOAD ，DYNAMIC，NOTE ，GNU_STACK，GNU_RELRO几个部分，如下图所示。
正在上传…重新上传取消正在上传…重新上传取消
其中PHDR 保存程序头表。INTERP 指定在程序已经从可执行文件映射到内存之后，必须调用的解释器。LOAD 表示一个需要从二进制文件映射到虚拟地址空间的段。其中保存了常量数据、程序的目标代码等。DYNAMIC 保存了由动态链接器使用的信息。NOTE 保存辅助信息。GNU_STACK：权限标志，用于标志栈是否是可执行。GNU_RELRO：指定在重定位结束之后哪些内存区域是需要设置只读。
正在上传…重新上传取消正在上传…重新上传取消
图 28 Linux 进程的虚拟地址空间
5.5 链接的重定位过程分析
在Shell中使用命令objdump -d -r hello > hello1.asm生成反汇编文件hello1.asm,与第四章中生成的hello.asm文件进行比较，其不同之处如下：
正在上传…重新上传取消正在上传…重新上传取消
图 29 生成.asm文件
- 链接后函数数量增加。链接后的反汇编文件helloasm中，多出了.plt，puts@plt，printf@plt，getchar@plt，atoi@plt，exit@plt，sleep@plt等函数的代码。这是因为动态链接器将共享库中hello.c用到的函数加入可执行文件中。
正在上传…重新上传取消正在上传…重新上传取消
图 30 链接后的函数
- 函数调用指令call的参数发生变化。在链接过程中，链接器解析了重定位条目，call之后的字节代码被链接器直接修改为目标地址与下一条指令的地址之差，指向相应的代码段，从而得到完整的反汇编代码。
正在上传…重新上传取消正在上传…重新上传取消
图 31 call指令的参数
- 跳转指令参数发生变化。在链接过程中，链接器解析了重定位条目，并计算相对距离，修改了对应位置的字节代码为PLT 中相应函数与下条指令的相对地址，从而得到完整的反汇编代码。
正在上传…重新上传取消正在上传…重新上传取消
图 32 跳转指令的参数
5.6 hello的执行流程
使用edb执行hello，说明从加载hello到_start，到call main,以及程序终止的所有过程。请列出其调用与跳转的各个子程序名或程序地址。
表格 7 程序名称与程序地址
| 程序名称 | 程序地址 |
| ld-2.27.so!_dl_start | 0x7fce8cc38ea0 |
| ld-2.27.so!_dl_init | 0x7fce8cc47630 |
| hello!_start | 0x400500 |
| libc-2.27.so!__libc_start_main | 0x7fce8c867ab0 |
| -libc-2.27.so!__cxa_atexit | 0x7fce8c889430 |
| -libc-2.27.so!__libc_csu_init | 0x4005c0 |
| hello!_init | 0x400488 |
| libc-2.27.so!_setjmp | 0x7fce8c884c10 |
| -libc-2.27.so!_sigsetjmp | 0x7fce8c884b70 |
| --libc-2.27.so!__sigjmp_save | 0x7fce8c884bd0 |
| hello!main | 0x400532 |
| hello!puts@plt | 0x4004b0 |
| hello!exit@plt | 0x4004e0 |
| *hello!printf@plt | -- |
| *hello!sleep@plt | -- |
| *hello!getchar@plt | -- |
| ld-2.27.so!_dl_runtime_resolve_xsave | 0x7fce8cc4e680 |
| -ld-2.27.so!_dl_fixup | 0x7fce8cc46df0 |
| --ld-2.27.so!_dl_lookup_symbol_x | 0x7fce8cc420b0 |
| libc-2.27.so!exit | 0x7fce8c889128 |
5.7 Hello的动态链接分析
编译器没有办法预测函数的运行时地址，所以需要添加重定位记录，等待动态链接器处理，为避免运行时修改调用模块的代码段，链接器采用延迟绑定的策略。动态链接器使用过程链接表PLT+全局偏移量表GOT实现函数的动态链接，在GOT中存放函数目标地址，PLT使用GOT中地址跳转到目标函数，在加载时，动态链接器会重定位GOT中的每个条目，使得它包含目标的正确的绝对地址。
.got与.plt节保存着全局偏移量表GOT，其内容从地址0x404000开始。通过edb查看，在dl_init调用前，其内容如下：
正在上传…重新上传取消正在上传…重新上传取消
图 33 调用前的情况
在调用后，其内容变为：
正在上传…重新上传取消正在上传…重新上传取消
图 34 调用后的情况
比较可以得知，0x404008~0x404017之间的内容，对应着全局偏移量表GOT[1]和GOT[2]的内容发生了变化。GOT[1]保存的是指向已经加载的共享库的链表地址。GOT[2]是动态链接器在ld-linux.so模块中的入口。这样，接下来执行程序的过程中，就可以使用过程链接表PLT和全局偏移量表GOT进行动态链接。
5.8 本章小结
本章中介绍了链接的概念与作用、并得到了链接后的hello可执行文件的ELF格式文本hello1.elf，据此分析了hello1.elf与hello.elf的异同；之后，根据反汇编文件hello1.asm与hello.asm的比较，加深了对重定位与动态链接的理解。
（第5章1分）
第6章 hello进程管理
6.1 进程的概念与作用
进程是一个正在运行的程序的实例，系统中的每一个程序都运行在某个进程的上下文中。
- 进程的作用
给应用程序提供两个关键抽象：
- 一个独立的逻辑控制流，提供一个假象，好像程序独占地使用处理器
- 一个私有地址空间，提供一个假象，好像程序独占地使用内存系统
6.2 简述壳Shell-bash的作用与处理流程
Shell 的作用：
Shell 是一个用C语言编写的交互型应用程序，代表用户运行其他程序。Shell 应用程序提供了一个界面，用户可以通过这个界面进行系统的基本操作，访问操作系统内核的服务。
Shell的处理流程大致如下：
- 从Shell终端读入输入的命令。
- 切分输入字符串，获得并识别所有的参数
- 若输入参数为内置命令，则立即执行
- 若输入参数并非内置命令，则调用相应的程序为其分配子进程并运行
- 若输入参数非法，则返回错误信息
- 处理完当前参数后继续处理下一参数，直到处理完毕
6.3 Hello的fork进程创建过程
打开Shell，输入命令./hello 1190200208 周子康 1s，带参数执行生成的可执行文件。
fork进程的创建过程如下：首先，带参执行当前目录下的可执行文件hello，父进程会通过fork函数创建一个新的运行的子进程hello。子进程获取了与父进程的上下文，包括栈、通用寄存器、程序计数器，环境变量和打开的文件相同的一份副本。子进程与父进程的最大区别是有着跟父进程不一样的PID，子进程可以读取父进程打开的任何文件。当子进程运行结束时，父进程如果仍然存在，则执行对子进程的回收，否则就由init进程回收子进程。
正在上传…重新上传取消正在上传…重新上传取消
图 35 程序执行的情况
6.4 Hello的execve过程
调用函数fork创建新的子进程之后，子进程会调用execve函数，在当前进程的上下文中加载并运行一个新程序hello。execve 函数从不返回，它将删除该进程的代码和地址空间内的内容并将其初始化，然后通过跳转到程序的第一条指令或入口点来运行该程序。将私有的区域映射进来，例如打开的文件，代码、数据段，然后将公共的区域映射进来。后面加载器跳转到程序的入口点，即设置PC指向_start 地址。_start函数最终调用hello中的 main 函数，这样，便完成了在子进程中的加载。
6.5 Hello的进程执行
在程序运行时，Shell为hello fork了一个子进程，这个子进程与Shell有独立的逻辑控制流。在hello的运行过程中，若hello进程不被抢占，则正常执行；若被抢占，则进入内核模式，进行上下文切换，转入用户模式，调度其他进程。直到当hello调用sleep函数时，为了最大化利用处理器资源，sleep函数会向内核发送请求将hello挂起，并进行上下文切换，进入内核模式切换到其他进程，切换回用户模式运行抢占的进程。与此同时，将 hello 进程从运行队列加入等待队列，由用户模式变成内核模式，并开始计时。当计时结束时，sleep函数返回，触发一个中断，使得hello进程重新被调度，将其从等待队列中移出，并内核模式转为用户模式。此时 hello 进程就可以继续执行其逻辑控制流。
6.6 hello的异常与信号处理
正在上传…重新上传取消正在上传…重新上传取消
图 36 程序正常执行
- 在程序运行时按回车，会多打印几处空行，程序可以正常结束。
正在上传…重新上传取消正在上传…重新上传取消
图 37 程序运行时按下回车
- 按下Ctrl + C，Shell进程收到SIGINT信号，Shell结束并回收hello进程。
正在上传…重新上传取消正在上传…重新上传取消
图 38 程序运行时按Ctrl + C
- 按下Ctrl + Z，Shell进程收到SIGSTP信号，Shell显示屏幕提示信息并挂起hello进程。
正在上传…重新上传取消正在上传…重新上传取消
图 39 程序运行时按Ctrl + Z
对hello进程的挂起可由ps和jobs命令查看，可以发现hello进程确实被挂起而非被回收，且其job代号为1。
正在上传…重新上传取消正在上传…重新上传取消
图 40 用ps命令查看挂起进程
在Shell中输入pstree命令，可以将所有进程以树状图显示（此处仅展示部分）：
正在上传…重新上传取消正在上传…重新上传取消
图 41 用pstree命令查看所有进程
输入kill命令，则可以杀死指定（进程组的）进程：
正在上传…重新上传取消正在上传…重新上传取消
图 42 kill命令杀死指定进程
输入fg 1则命令将hello进程再次调到前台执行，可以发现Shell首先打印hello的命令行命令，hello再从挂起处继续运行，打印剩下的语句。程序仍然可以正常结束，并完成进程回收。
正在上传…重新上传取消正在上传…重新上传取消
图 43 用fg命令将进程调回前台
- 不停乱按
在程序执行过程中乱按所造成的输入均缓存到stdin，当getchar的时候读出一个’\n’结尾的字串（作为一次输入），hello结束后，stdin中的其他字串会当做Shell的命令行输入。
正在上传…重新上传取消正在上传…重新上传取消
图 44 不停乱按的情况
6.7本章小结
本章介绍了进程的概念与作用，以及Shell-bash的基本概念。针对进程，在这一章中根据hello可执行文件的具体示例研究了fork,execve函数的原理与执行过程，并给出了hello带参执行情况下各种异常与信号处理的结果。
（第6章1分）
第7章 hello的存储管理
7.1 hello的存储器地址空间
逻辑地址是指由程序产生的与段相关的偏移地址部分，逻辑地址由选择符和偏移量两部分组成。具体而言，其为hello.asm中的相对偏移地址。
- 线性地址
逻辑地址经过段机制转化后为线性地址，其为处理器可寻址空间的地址，用于描述程序分页信息的地址。具体以hello而言，线性地址标志着 hello 应在内存上哪些具体数据块上运行。
- 虚拟地址
根据CSAPP教材，虚拟地址即为上述线性地址。
- 物理地址
CPU通过地址总线的寻址，找到真实的物理内存对应地址。
7.2 Intel逻辑地址到线性地址的变换-段式管理
Intel处理器从逻辑地址到线性地址的变换通过段式管理的方式实现。每个程序在系统中都保存着一个段表，段表保存着该程序各段装入主存的状况信息，包括段号或段名、段起点、装入位、段的长度、主存占用区域表、主存可用区域表等，从而方便进行段式管理。
在段寄存器中，存放着段选择符，可以通过段选择符来得到对应段首地址。段选择符的结构如下：
正在上传…重新上传取消正在上传…重新上传取消
图 45 段选择符的情况
其包含三部分：索引，TI，RPL
索引：用来确定当前使用的段描述符在描述符表中的位置；
TI：根据TI的值判断选择全局描述符表(TI=0，GDT)或选择局部描述符表(TI=1，LDT)；
RPL：判断重要等级。RPL=00，为第0级，位于最高级的内核，RPL=11，为第3级，位于最低级的用户状态；
通过一个索引，可以定位到段描述符，进而通过段描述符得到段基址。段基址与偏移量结合就得到了线性地址，虚拟地址。
7.3 Hello的线性地址到物理地址的变换-页式管理
线性地址（VA）到物理地址（PA）之间的转换通过对虚拟地址内存空间进行分页的分页机制完成。
通过7.2节中的段式管理过程，可以得到了线性地址/虚拟地址，记为VA。虚拟地址可被分为两个部分：VPN（虚拟页号）和VPO（虚拟页偏移量），根据计算机系统的特性可以确定VPN与VPO的具体位数，由于虚拟内存与物理内存的页大小相同，因此VPO与PPO（物理页偏移量）一致。而PPN（物理页号）则需通过访问页表中的页表条目（PTE）获取，如下图所示。
正在上传…重新上传取消正在上传…重新上传取消
图 46 Hello的线性地址到物理地址的变换-页式管理
若PTE的有效位为1，则发生页命中，可以直接获取到物理页号PPN，PPN与PPO共同组成物理地址。
若PTE的有效位为0，说明对应虚拟页没有缓存到物理内存中，产生缺页故障，调用操作系统的内核的缺页处理程序，确定牺牲页，并调入新的页面。再返回到原来的进程，再次调用导致缺页的指令。此时发生页命中，获取到PPN，与PPO共同组成物理地址。
7.4 TLB与四级页表支持下的VA到PA的变换
针对Intel Core i7 CPU研究VA到PA的变换。
Intel Core i7 CPU的基本参数如下：
- 虚拟地址空间48位(n=48)
- 物理地址空间52位(m=52)
- TLB四路十六组相连
- L1，L2，L3块大小为64字节
- L1，L2八路组相连
- L3十六路组相连
- 页表大小4KB(P=4x1024=2^12)，四级页表，页表条目(PTE)大小8字节
由上述信息可以得知，VPO与PPO有p=12位，故VPN为36位，PPN为40位。单个页表大小4KB，PTE大小8字节，则单个页表有512个页表条目，需要9位二进制进行索引，而四级页表则需要36位二进制进行索引，对应着36位的VPN。TLB有16组，故TLBI有t=4位，TLBT有36-4=32位。
正在上传…重新上传取消正在上传…重新上传取消
图 47 TLB与四级页表支持下的VA到PA的变换
如图所示， CPU产生虚拟地址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中添加条目。多级页表的工作原理展示如下：
正在上传…重新上传取消正在上传…重新上传取消
s
若查询PTE的时候发现不在物理内存中，则引发缺页故障。如果发现权限不够，则引发段错误。
7.5 三级Cache支持下的物理内存访问
因为三级Cache的工作原理基本相同，所以在这里以L1 Cache为例，介绍三级Cache支持下的物理内存访问。
L1 Cache的基本参数如下：
- 8路64组相连
- 块大小64字节
由L1 Cache的基本参数，可以分析知：
块大小64字节→需要6位二进制索引→块偏移6位
共64组→需要6位二进制索引→组索引6位
余下标记位→需要PPN+PPO-6-6=40位
故L1 Cache可被划分如下（从左到右）：
CT（40bit）CI（6bit）CO（6bit）
在7.4中我们已经由虚拟地址VA转换得到了物理地址PA，首先使用CI进行组索引，每组8路，对8路的块分别匹配CT（前40位）如果匹配成功且块的valid标志位为1，则命中（hit），根据数据偏移量CO取出相应的数据后返回。
若没有匹配成功或者匹配成功但是标志位是1，则不命中（miss），向下一级缓存中请求数据（请求顺序为L2 Cache→L3 Cache→主存，若仍不命中才继续向下一级请求）。查询到数据之后，需要对数据进行读入，一种简单的放置策略如下：若映射到的组内有空闲块，则直接放置在空闲块中，若当前组内没有空闲块，则产生冲突（evict），采用LFU策略进行替换。
7.6 hello进程fork时的内存映射
当fork函数被当前进程hello调用时，内核为新进程hello创建各种数据结构，并分配给它一个唯一的PID。为了给这个新的hello创建虚拟内存，它创建了当前进程的mm_struct、区域结构和页表的原样副本。它将两个进程中的每个页面都标记为只读，并将两个进程中的每个区域结构都标记为私有的写时复制。
当fork在新进程中返回时，新进程现在的虚拟内存刚好和调用fork时存在的虚拟内存相同。当着两个进程中的任一个后来进行写操作时，写时复制机制就会创建新页面，因此，也就为每个进程保持了私有地址空间的抽象概念。
7.7 hello进程execve时的内存映射
execve函数加载并运行hello需要以下几个步骤：
- 删除已存在的用户区域
删除当前进程hello虚拟地址的用户部分中的已存在的区域结构。
- 映射私有区域
为新程序的代码、数据、bss和栈区域创建新的私有的、写时复制的区域结构。其中，代码和数据区域被映射为hello文件中的.text和.data区。bss区域是请求二进制零的，映射到匿名文件，其大小包含在hello中。栈和堆区域也是请求二进制零的，初始长度为零。
- 映射共享区域
若hello程序与共享对象或目标（如标准C库libc.so）链接，则将这些对象动态链接到hello程序，然后再映射到用户虚拟地址空间中的共享区域内。
- 设置程序计数器
最后，execve设置当前进程上下文中的程序计数器，使之指向代码区域的入口点。
7.8 缺页故障与缺页中断处理
发生一个缺页异常后，控制会转移到内核的缺页处理程序。判断虚拟地址是否合法，若不合法，则产生一个段错误，然后终止这个进程。
若操作合法，则缺页处理程序从物理内存中确定一个牺牲页，若该牺牲页被修改过，则将它换出到磁盘，换入新的页面并更新页表。当缺页处理程序返回时，CPU 再次执行引起缺页的指令，将引起缺页的虚拟地址重新发送给MMU。因为虚拟页面现在缓存在物理内存中，所以就会命中，主存将所请求字返回给处理器。
7.9动态存储分配管理
动态内存分配器维护着一个称为堆的进程的虚拟内存区域。分配器将堆视为一组不同大小的块的集合来维护。每个块就是一个连续的虚拟内存片，要么是已分配的，要么是空闲的。已分配的块显式地保留为供应用程序使用。空闲块可用来分配。空闲块保持空闲，直到它显式地被应用所分配。一个已分配的块保持已分配状态，直到它被释放，这种释放可以由应用程序显式执行或内存分配器自身隐式执行。
具体而言，分配器分为两种基本风格：显式分配器、隐式分配器。
显式分配器：要求应用显式地释放任何已分配的块。
隐式分配器：要求分配器检测一个已分配块何时不再使用，那么就释放这个块，自动释放未使用的已经分配的块的过程叫做垃圾收集。
下面介绍动态存储分配管理中较为重要的概念：
- 隐式链表
堆中的空闲块通过头部中的大小字段隐含地连接，分配器通过遍历堆中所有的块，从而间接遍历整个空闲块的集合。
对于隐式链表，其结构如下：
正在上传…重新上传取消正在上传…重新上传取消
图 48 隐式链表的结构
- 显式链表
在每个空闲块中，都包含一个前驱（pred）与后继（succ）指针，从而减少了搜索与适配的时间。
显式链表的结构如下：
正在上传…重新上传取消正在上传…重新上传取消
图 49 显式链表的结构
- 带边界标记的合并
采取使用边界标记的堆块的格式，在堆块的末尾为其添加一个脚部，其为头部的副本。添加脚部之后，分配器就可以通过检查前面一个块的脚部，判断前面一个块的起始位置和状态。从而实现快速合并，减小性能消耗。
- 分离存储
维护多个空闲链表，其中，每个链表的块具有相同的大小。将所有可能的块大小分成一些等价类，从而进行分离存储。
7.10本章小结
本章主要介绍了hello 的存储器地址空间、intel 的段式管理、hello 的页式管理， VA 到PA 的变换、物理内存访问，hello进程fork、execve 时的内存映射、缺页故障与缺页中断处理、动态存储分配管理。
（第7章 2分）
第8章 hello的IO管理
8.1 Linux的IO设备管理方法
设备的模型化：文件
设备管理：unix io接口
所有的IO设备都被模型化为文件，而所有的输入和输出都被当做对相应文件的读和写来执行。这种将设备映射为文件的方式，允许Linux内核引出一个简单、低级的应用接口，称为Unix I/O。这使得所有的输入和输出都能以一种统一且一致的方式来执行：打开文件、改变当前的文件位置、读写文件、关闭文件。
8.2 简述Unix IO接口及其函数
- Unix I/O接口：
- 打开文件
一个应用程序通过要求内核打开相应的文件，来宣告它想要访问一个I/O设备，内核返回一个小的非负整数，叫做描述符，它在后续对此文件的所有操作中标识这个文件，内核记录有关这个打开文件的所有信息。对于Shell创建的每个进程，其都有三个打开的文件：标准输入，标准输出，标准错误。
- 改变当前的文件位置
对于每个打开的文件，内核保持着一个文件位置k，初始为0，这个文件位置是从文件开头起始的字节偏移量，应用程序能够通过执行seek，显式地将改变当前文件位置k。
- 读写文件
一个读操作就是从文件复制n>0个字节到内存，从当前文件位置k开始，然后将k增加到k+n，给定一个大小为m字节的而文件，当k>=m时，触发EOF。类似一个写操作就是从内存中复制n>0个字节到一个文件，从当前文件位置k开始，然后更新k。
- 关闭文件
内核释放文件打开时创建的数据结构，并将这个描述符恢复到可用的描述符池中去。
- Unix I/O函数：
- int open(char* filename,int flags,mode_t mode)
进程通过调用open函数来打开一个存在的文件或是创建一个新文件的。open函数将filename转换为一个文件描述符，并且返回描述符数字，返回的描述符总是在进程中当前没有打开的最小描述符，flags参数指明了进程打算如何访问这个文件，mode参数指定了新文件的访问权限位。
- int close(fd)
fd是需要关闭的文件的描述符，close返回操作结果。
- ssize_t read(int fd,void *buf,size_t n)
read函数从描述符为fd的当前文件位置赋值最多n个字节到内存位置buf。返回值-1表示一个错误，0表示EOF，否则返回值表示的是实际传送的字节数量。
- ssize_t wirte(int fd,const void *buf,size_t n)
write函数从内存位置buf复制至多n个字节到描述符为fd的当前文件位置。
8.3 printf的实现分析
查看windows系统下的printf函数体：
正在上传…重新上传取消正在上传…重新上传取消
图 50 printf的函数体
形参列表中的…是可变形参的一种写法，当传递参数的个数不确定时，用这种方式来表示。
va_list的定义：typedef char *va_list，说明它是一个字符指针，其中 (char*)(&fmt) + 4) 即arg表示的是...中的第一个参数。
再进一步查看windows系统下的vsprintf函数体：
正在上传…重新上传取消正在上传…重新上传取消
图 51 vsprintf的函数体
则知道vsprintf程序按照格式fmt结合参数args生成格式化之后的字符串，并返回字串的长度。
在printf中调用系统函数write(buf,i)将长度为i的buf输出。write函数如下：
printf函数的功能为接受一个格式化命令，并按指定的匹配的参数格式化输出，故i = vsprintf(buf, fmt, arg)是得到打印出来的字符串长度，其后的write(buf, i)是将buf中的i个元素写到终端。
因此，vsprintf的作用为接受确定输出格式的格式字符串fmt。用格式字符串对个数变化的参数进行格式化，进而产生格式化输出。
再进一步对write进行追踪：
正在上传…重新上传取消正在上传…重新上传取消
图 52 write的情况
这里给几个寄存器传递了参数，然后以一个int INT_VECTOR_SYS_CALL结束。INT_VECTOR_SYS_CALL代表通过系统调用syscall，查看syscall的实现：
正在上传…重新上传取消正在上传…重新上传取消
图 53 syscall的情况
syscall将字符串中的字节从寄存器中通过总线复制到显卡的显存中，显存中存储的是字符的ASCII码，符显示驱动子程序：从ASCII到字模库到显示vram（存储每一个点的RGB颜色信息）。显示芯片按照刷新频率逐行读取vram，并通过信号线向液晶显示器传输每一个点（RGB分量）。
8.4 getchar的实现分析
异步异常-键盘中断的处理：键盘中断处理子程序。接受按键扫描码转成ascii码，保存到系统的键盘缓冲区。
getchar有一个int型的返回值。当程序调用getchar时，程序就等着用户按键，用户输入的字符被存放在键盘缓冲区中直到用户按回车为止(回车字符也放在缓冲区中)。
当用户键入回车之后，getchar才开始从stdio流中每次读入一个字符。getchar函数的返回值是用户输入的第一个字符的ascii码,如出错返回-1,且将用户输入的字符回显到屏幕。如用户在按回车之前输入了不止一个字符,其他字符会保留在键盘缓存区中,等待后续getchar调用读取。也就是说,后续的getchar调用不会等待用户按键,而直接读取缓冲区中的字符,直到缓冲区中的字符读完为后,才等待用户按键。
getchar等调用read系统函数，通过系统调用读取按键ascii码，直到接受到回车键才返回。
getchar调用系统函数read，发送一个中断信号，内核抢占这个进程，用户输入字符串，键入回车后（字符串和回车都保存在缓冲区内），再次发送信号，内核重新调度这个进程，getchar从缓冲区读入字符。
8.5本章小结
本章主要介绍了linux的IO设备管理方法和及其接口和函数，对printf函数和getchar函数的底层实现有了基本了解。
（第8章1分）
结论
hello程序的一生经历了如下过程：
- 预处理
将hello.c中include的所有外部的头文件头文件内容直接插入程序文本中，完成字符串的替换，方便后续处理；
- 编译
通过词法分析和语法分析，将合法指令翻译成等价汇编代码。通过编译过程，编译器将hello.i 翻译成汇编语言文件 hello.s；
- 汇编
将hello.s汇编程序翻译成机器语言指令，并把这些指令打包成可重定位目标程序格式，最终结果保存在hello.o 目标文件中；
- 链接
通过链接器，将hello的程序编码与动态链接库等收集整理成为一个单一文件，生成完全链接的可执行的目标文件hello；
- 加载运行
打开Shell，在其中键入 ./hello 1190200208 周子康 1s，终端为其fork新建进程，并通过execve把代码和数据加载入虚拟内存空间，程序开始执行；
- 执行指令
在该进程被调度时，CPU为hello其分配时间片，在一个时间片中，hello享有CPU全部资源，PC寄存器一步一步地更新，CPU不断地取指，顺序执行自己的控制逻辑流；
- 访存
内存管理单元MMU将逻辑地址，一步步映射成物理地址，进而通过三级高速缓存系统访问物理内存/磁盘中的数据;
- 动态申请内存
printf 会调用malloc 向动态内存分配器申请堆中的内存；
- 信号处理
进程时刻等待着信号，如果运行途中键入ctr-c ctr-z 则调用shell 的信号处理函数分别进行停止、挂起等操作，对于其他信号也有相应的操作；
- 终止并被回收
Shell父进程等待并回收hello子进程，内核删除为hello进程创建的所有数据结构。
（结论0分，缺失 -1分，根据内容酌情加分）
附件
| 文件名 | 功能 |
| hello.i | 预处理后得到的文本文件 |
| hello.s | 编译后得到的汇编语言文件 |
| hello.o | 汇编后得到的可重定位目标文件 |
| hello.elf | 用readelf读取hello.o得到的ELF格式信息 |
| hello.asm | 反汇编hello.o得到的反汇编文件 |
| hello1.elf | 由hello可执行文件生成的.elf文件 |
| hello1.asm | 反汇编hello可执行文件得到的反汇编文件 |
（附件0分，缺失 -1分）
参考文献
为完成本次大作业你翻阅的书籍与网站等
[1] 林来兴. 空间控制技术[M]. 北京：中国宇航出版社，1992：25-42.
[2] 辛希孟. 信息技术与信息服务国际研讨会论文集：A集[C]. 北京：中国科学出版社，1999.
[3] 赵耀东. 新时代的工业工程师[M/OL]. 台北：天下文化出版社，1998 [1998-09-26]. http://www.ie.nthu.edu.tw/info/ie.newie.htm（Big5）.
[4] 谌颖. 空间交会控制理论与方法研究[D]. 哈尔滨：哈尔滨工业大学，1992：8-13.
[5] KANAMORI H. Shaking Without Quaking[J]. Science，1998，279（5359）：2063-2064.
[6] CHRISTINE M. Plant Physiology: Plant Biology in the Genome Era[J/OL]. Science，1998，281：331-332[1998-09-23]. http://www.sciencemag.org/cgi/ collection/anatmorp.
（参考文献0分，缺失 -1分）
扫一扫
786
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
