计算机系统大作业——程序人生

计算机系统

大作业

题 目 程序人生-Hello’s P2P
专 业 未来技术（人工智能）
学　　 号 7203610402
班　　 级 2036017
学 生 陈鹏宇 　　　
指 导 教 师 史先俊

计算机科学与技术学院
2022年5月
摘 要
hello基本上是每一个学习编程的人第一个接触的程序。本文以hello程序从一个文本文件经过预处理、编译、汇编、链接的一系列步骤变成可执行文件的过程为主要内容，同时分析了hello运行过程中涉及到的进程管理、内存管理、io管理、回收等问题。整个过程是在ubuntu的环境下运行的，并且使用了gcc、edb等工具协助。
关键词：预处理、编译、汇编、链接、进程管理、内存管理、io管理
查看图片请访问
https://www.cnblogs.com/ddm252/p/16292156.html

目 录

第1章 概述 – 4 –
1.1 Hello简介 – 4 –
1.2 环境与工具 – 4 –
1.3 中间结果 – 4 –
1.4 本章小结 – 4 –
第2章 预处理 – 5 –
2.1 预处理的概念与作用 – 5 –
2.2在Ubuntu下预处理的命令 – 5 –
2.3 Hello的预处理结果解析 – 5 –
2.4 本章小结 – 5 –
第3章 编译 – 6 –
3.1 编译的概念与作用 – 6 –
3.2 在Ubuntu下编译的命令 – 6 –
3.3 Hello的编译结果解析 – 6 –
3.4 本章小结 – 6 –
第4章 汇编 – 7 –
4.1 汇编的概念与作用 – 7 –
4.2 在Ubuntu下汇编的命令 – 7 –
4.3 可重定位目标elf格式 – 7 –
4.4 Hello.o的结果解析 – 7 –
4.5 本章小结 – 7 –
第5章 链接 – 8 –
5.1 链接的概念与作用 – 8 –
5.2 在Ubuntu下链接的命令 – 8 –
5.3 可执行目标文件hello的格式 – 8 –
5.4 hello的虚拟地址空间 – 8 –
5.5 链接的重定位过程分析 – 8 –
5.6 hello的执行流程 – 8 –
5.7 Hello的动态链接分析 – 8 –
5.8 本章小结 – 9 –
第6章 hello进程管理 – 10 –
6.1 进程的概念与作用 – 10 –
6.2 简述壳Shell-bash的作用与处理流程 – 10 –
6.3 Hello的fork进程创建过程 – 10 –
6.4 Hello的execve过程 – 10 –
6.5 Hello的进程执行 – 10 –
6.6 hello的异常与信号处理 – 10 –
6.7本章小结 – 10 –
第7章 hello的存储管理 – 11 –
7.1 hello的存储器地址空间 – 11 –
7.2 Intel逻辑地址到线性地址的变换-段式管理 – 11 –
7.3 Hello的线性地址到物理地址的变换-页式管理 – 11 –
7.4 TLB与四级页表支持下的VA到PA的变换 – 11 –
7.5 三级Cache支持下的物理内存访问 – 11 –
7.6 hello进程fork时的内存映射 – 11 –
7.7 hello进程execve时的内存映射 – 11 –
7.8 缺页故障与缺页中断处理 – 11 –
7.9动态存储分配管理 – 11 –
7.10本章小结 – 12 –
第8章 hello的IO管理 – 13 –
8.1 Linux的IO设备管理方法 – 13 –
8.2 简述Unix IO接口及其函数 – 13 –
8.3 printf的实现分析 – 13 –
8.4 getchar的实现分析 – 13 –
8.5本章小结 – 13 –
结论 – 14 –
附件 – 15 –
参考文献 – 16 –

第1章 概述
1.1 Hello简介
Hello基本上是大部分人学习编程的时候所接触到的第一个程序。
对于hello的P2P过程，即将程序文件翻译成一个可执行文件hello。这个过程可以分成四个阶段完成：
预处理：根据以字符#开头的命令，修改原始的C程序。
编译阶段：翻译成汇编语言。
汇编阶段：翻译成机器语言指令，并打包保存在hello.o中。
链接阶段：合并库文件。
图1 P2P示例
对于020过程：shell调用fork函数为程序创建新的进程，之后操作系统调用exceve在上下文中加载并运行hello，映射虚拟内存，并加载对应的物理内存。随后在时间片到达时开始执行主函数。主函数执行结束后，父进程将回收这一进程，进程终止，回收资源，恢复shell上下文，将控制权交给shell。
1.2 环境与工具
列出你为编写本论文，折腾Hello的整个过程中，使用的软硬件环境，以及开发与调试工具。
1.2.1 硬件环境
CPU； AMD Ryzen 4800H
RAM；16GB
1.2.2 软件环境
Windows 10 ；Vmware 15；Ubuntu 16.04 。
1.2.3 开发工具
Visual Studio 2022；CodeBlocks 64位；vi/vim/gedit+gcc。

1.3 中间结果
hello.c 源程序
hello.i 预处理后文本文件
hello.s 汇编程序
hello.o 可重定位目标程序
hello 可执行目标程序（二进制）
hello1.txt hello.o的反汇编文件
hello2.txt hello的反汇编文件
elf.txt hello.o的ELF
elf2.txt hello的ELF
1.4本章小结
本章介绍了hello程序的P2P过程（From Program to Process）和020过程（From Zero-0 to Zero-0），对实验所涉及的文件做了基本介绍。

（第1章0.5分）

第2章 预处理
2.1 预处理的概念与作用
2.1.1预处理的概念
预处理是C语言的一个重要的功能，它由预处理程序负责完成。当对一个源文件进行编译时，系统将自动引用预处理程序对源程序中的预处理命令部分做处理，处理完毕自动进入对源程序的编译。任何C语言程序都有一个预处理程序。预处理器根据以字符#开始的预编译指令，修改原始的C语言程序。主要包括1. 宏定义；2. 文件包含；3. 条件编译
2.1.2 预处理的作用
得到另一个C程序，通常以.i作文件扩展名。根据预处理指令分别处理：将源文件中以“include”格式包含的文件复制到编译的源文件中；用实际值替换“#define”定义的字符串；3.根据“#if”后面的条件决定需要编译的代码。为下一步编译提供文本文件。
2.2在Ubuntu下预处理的命令
预处理命令为gcc -E hello.c -o hello.i
图2 预处理示例

2.3 Hello的预处理结果解析
打开预处理得到的文本程序，可以发现hello.i仍未高级语言程序，实际上这就是插入头文件所得到的高级语言程序源码。

图3 hello.i
2.4 本章小结
本章介绍了预处理的概念及作用。并且以hello.c为例，在ubuntu下利用gcc对hello.c进行了预处理，并且分析了预处理所得到的hello.i文件。

（第2章0.5分）

第3章 编译
3.1 编译的概念与作用
3.1.1编译的概念
编译器(ccl)将文本文件.i翻译成文本文件.s，它包含一个汇编语言程序。
3.1.2编译的作用
编译将预处理之后得到的高级语言程序.i翻译成汇编语言程序.s同时进行词法分析和语法分析，若发现错误，可以给出提示。
3.2 在Ubuntu下编译的命令
编译的命令：gcc -S hello.i -o hello.s
图4 在ubuntu
3.3 Hello的编译结果解析
3.3.1汇编指令

图5 汇编指令
.file：声明源文件
.text： 声明代码节
.section： 指示把代码划分成若干个段（Section）
.rodata： 只读代码
.align： 声明对指令或数据的存放地址对齐方式
.string： 声明一个字符串（.LC0,.LC1）
.global： 声明全局变量(main)
.type： 指定类型
3.1.2数据
在hello.c程序中使用到的数据结构有整数和字符串。
3.1.2.1整数
图6 i的定义
i为程序开始就声明的局部变量，被保存在栈%rbx中。i为int类型共占四个字节。
图7 变量argc
argc为形参，保存在寄存器%edb中。
图8 立即数举例
除了上述的两个int型整型参数，程序中还有立即数表示为$形式。
3.1.2.2字符串
在hello.c的只读数据段
图9 字符串

3.1.2.3数组
图10 数组
指针数组char argv[]是main函数的形参，argv[0]指向输入程序的路径和名称，argv[1]和argv[2]分别指向两个字符串数组的首地址。char占8个字节，所以argv[1]和argv[2]两个字符串的首地址分别为-16（%rbp）和-24（%rbp）。
3.2赋值操作

图11 赋值
Hello.c程序中的赋值只有在for循环中的一条，即为将i的初始值赋值为0，在汇编中使用mov直接利用立即数赋值。
3.3类型转换
hello.c中的类型转换是使用atoi函数进行的，程序利用函数将字符串转换成了数字。
图12 类型转换
3.4算数操作
在循环中的i++为算数操作，直接使用立即数$1来操作。同时移栈操作也是使用算数操作进行的例如在为数组argv开辟空间时使用到了subq $32, %rsp，取出argv数组中的对应内容时的addq $24, %rax等。
图13 i++算数运算
3.5关系操作
在程序中一共使用了两个关系判断，分别为if和for的判断语句。即
if(argc!=4)，for(i=0;i<8;i++)。
3.5.1 if的关系操作

图14 if的关系操作语句
使用cmpl将argc直接与立即数$4进行比较，如果相等跳转到L2，如果不相等继续按照顺序运行。
3.5.2 for的关系操作
图15 for的关系操作
使用cmpl将i直接与立即数$7进行比较，如果小于或等于7，跳转到L4，如果不相等继续按照顺序运行。
3.6数组/指针/结构操作
本程序中只有argc字符指针数组涉及到了数组/指针/结构操作，主要是利用栈操作实现的命令。
图16 指针操作
3.7控制转移
控制转移操作与3.5中所介绍的关系操作基本一致。
在if的控制转移中，使用cmpl将argc直接与立即数$4进行比较，如果相等跳转到L2，如果不相等继续按照顺序运行。（图14）
在for的控制转移中使用cmpl将i直接与立即数$7进行比较，如果小于或等于7，跳转到L4，如果不相等继续按照顺序运行。（图15）
3.8函数操作
hello.c程序一共使用了五次函数调用，在汇编程序中使用call表示函数调用。
3.8.1exit()
exit函数的作用是直接退出程序运行，%edi寄存器中的值为1，将1传递进去之后直接退出程序执行。
图17 exit函数的调用
3.8.2atoi()
atoi函数作用是将字符串转化为整型。在hello.c中，将参数存储在%rdi中，然后调用atoi函数。
图18 atoi函数调用
3.8.3printf()
printf函数作用是打印。在hello.c中，使用两次printf，但是在汇编程序中只有一次printf函数的调用。原因是第一次的printf被优化成为了puts（可能是因为没有参数输入）
图19 printf被优化成了puts
图20 printf函数调用
3.8.4sleep()
sleep函数在atoi函数调用完后紧接着调用。atoi函数的返回值即为sleep函数的参数。
图21 sleep函数调用
3.8.5getchar()
getchar()函数直接调用。
图22 getchar函数调用
3.4 本章小结
本章介绍了编译的概念和作用。并且在ubuntu下，以hello程序为例对编译所得到的汇编程序进行了初步分析。详细介绍了编译的数据、赋值、类型转换、算术操作、关系操作、数组指针结构操作、函数调用、控制转移等方面的处理方法。

（第3章2分）

第4章 汇编
4.1 汇编的概念与作用
4.1.1汇编的概念
汇编器（as）将汇编程序翻译成机器语言指令，把这些指令打包成可重定位目标程序（relocatable object program）的格式，并将结果保存在.o 目标文件中，.o 文件是一个二进制文件，它包含程序的指令编码。
4.1.2 汇编的作用
将汇编语言翻译成机器语言。
4.2 在Ubuntu下汇编的命令
Ubuntu下汇编的命令为：gcc -c -o hello.o hello.s
图23 Ubuntu下的汇编指令
4.3 可重定位目标elf格式
使用readelf -a hello.o > ./elf.txt，可以提取hello.o文件的ELF。
图24 生成elf.txt
Elf可以分为四个部分，ELF头、节头部表、符号表、重定位节。
4.3.1 ELF头
打开elf.txt，寻找到ELF头。ELF头以16进制的Magic开始，Magic描述了生成该文件的系统的字的大小和字节顺序。ELF头剩下的部分包含了帮助链接器语法分析和解释目标文件的信息，ELF头其余部分包含了帮助链接器语法分析和解释目标文件的信息，包括ELF头的大小、目标文件的类型（如可重定位、可执行、共享的）、机器类型（如x86-64）、节头部表（section header table）的文件偏移，以及节头部表中条目的大小和数量。
图25 ELF头
4.3.2节头部表
打开ELF.txt，找到节头部表。记录这里各节的名称、类型、地址、偏移量、大小、全体大小、旗标、链接、信息、对齐等。
图26 节头部表
4.3.3 符号表
打开ELF.txt，找到符号表。符号表存放程序中定义和引用的函数和全局变量的信息。其中name是符号名称， value是符号相对于目标节的起始位置偏移，size是目标的大小，type数据或者函数。Bind字段表明符号是本地的还是全局的。
图27 符号表
4.3.4 重定位节
重定位节保存的是.text节中需要被修正的信息，任何调用外部函数或者引用全局变量的指令都需要被修正，调用外部函数的指令和引用全局变量的指令需要重定位，调而用局部函数的指令不需要重定位。链接器会通过重定位节的重定位条目计算出正确的地址。
在hello程序中，puts，exit，printf，atoi，sleep，getchar都需要进行重定位。
图28 重定位节
4.4 Hello.o的结果解析
使用objdump -d -r hello.o > hello1.s得到hello.o的反汇编，保存在hello1.s中。与hello.s做对比。
图29 hello1.s
机器语言的构成：机器语言是二进制（十六进制表示）序列，机器直接根据这个序列进行工作。是最低级的语言，也是执行效率最高的语言。
机器语言与汇编语言的映射关系：汇编语言程序可以由汇编程序转为机器语言，接着机器读取机器语言运行程序，同时机器语言可以通过反汇编生成汇编语言文件。
hello.s和hello1.s的区别：
1）分支转移：在汇编语言中使用.Lx等助记符表示；在反汇编代码中，分支转移通过主函数+偏移量来表示。
2）函数调用：在汇编语言中直接使用函数名称来表示函数调用；在反汇编代码中，直接用地址跳转来表达函数调用。
3）立即数表示：在汇编语言中使用十进制数；在反汇编语言中使用16进制数。
4.5 本章小结
本章介绍了汇编的概念和作用，并以hello程序为例进行了汇编的演示。利用readelf对文件做了分析。最后进行了反汇编，比较了汇编语言和反汇编语言的区别。
（第4章1分）

第5章 链接
5.1 链接的概念与作用
5.1.1链接的概念
链接（linking）是将各种代码和数据片段收集并合成为一个单一文件的过程，这个文件可被加载（复制）到内存并执行。链接可以执行于编译时（compile time），也就是在源代码被翻译成机器代码时；也可以执行于加载时（load time），也就是在程序被加载器（loader）加载到内存并执行时；甚至执行于运行时（run time），也就是在由应用程序来执行。
5.1.2链接的作用
链接器在软件开发过程中扮演着一个关键的角色，因为它们使得分离编译（separate compilation）成为可能。

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
图30 链接命令
5.3 可执行目标文件hello的格式
使用得到readelf -a hello > elf2.txt

图 31 生成elf2.txt
分析hello的ELF格式，用readelf等列出其各段的基本信息，包括各段的起始地址，大小等信息。这里的ELF格式同上文所提到的类似，都分为ELF头、节头部表、程序头、重定位节和字符表。
图32 ELF头
ELF头主要存储程序信息，与hello.o的ELF相比可以发现记录的类型发生了变化，变成了exec（可执行文件）。
节头部表记录各节的名称、类型、地址、偏移量、大小、全体大小、旗标、链接、信息、对齐等。链接时会把节头部表进行合成和更改。（图33）
程序头记录了页面大小、虚拟内存、段大小等信息。
符号表多出了一些符号，来源应为链接时产生的库或者启动函数。
重定位节失去了.rela.text，并且多一些新的重定位，应该与链接的库中的函数有关
图33 节头部表 图34 程序头
5.4 hello的虚拟地址空间
图35 虚拟地址空间范围
在edb中打开可执行程序hello，可以看到进程的虚拟地址信息。段的虚拟空间从0x400000开始到0x401000结束。
以5.3中以节头部表为例，.interp的偏移量为2e0，查找0x4002e0，证明成立。
图36 .interp的虚拟空间
其他部分同理。

5.5 链接的重定位过程分析
使用objdump -d -r hello对hello进行反汇编，比较其与hello.o的反汇编的差异。
图37 对hello反汇编
在链接之后，hello中增加了使用到的库函数，即puts、exit、printf、sleep、atoi、getchar等。
图38 增加的库函数
在连接之后，所有地址使用虚拟地址来表示。实现了调用函数和控制转移的重定位。（图39）
最后hello中还增加了.init和.plt。（图40）
5.6 hello的执行流程

图39虚拟地址 图40.init和.plt

使用edb执行hello，说明从加载hello到_start，到call main,以及程序终止的所有过程如下。执行流程和地址为
_libc_start_main 401008
_main 401125
_printf 4010a0
_exit 4010d0
_sleep 4010e0
_getchar 4010b0
Exit 4010d0
5.7 Hello的动态链接分析
查看.elf文件，寻找got位置，在edb中寻找该位置。
图41 寻找got
如图got的位置为403ff0。使用edb查找该位置内存如下图所示（图42）。在调用dl__init之后改变为（图43）。

图42 got初始
图43 got改变之后的状态
5.8 本章小结
本章介绍了链接的概念和作用。利用工具edb查看了虚拟地址，并且对重定位和动态链接进行了深入分析。
（第5章1分）

第6章 hello进程管理
6.1 进程的概念与作用
进程是一个执行中程序的实例。一个程序运行起来我们就称为一个进程，是系统资源和调度的独立单位,它会占用对应的内存区域，由CPU进行执行与计算。进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,程与程序的区别在于,程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合,多个进程可以在单个处理器CPU上并发执行,多个进程之间不会互相影响。

6.2 简述壳Shell-bash的作用与处理流程
Shell：Shell 是一个用 C 语言编写的程序，它是用户使用 Linux 的桥梁。Shell 既是一种命令语言，又是一种程序设计语言。Shell 是指一种应用程序，这个应用程序提供了一个界面，用户通过这个界面访问操作系统内核的服务。处理流程：
1）从终端读入输入的命令。
2）将输入字符串切分获得所有的参数
3）如果是内置命令则立即执行
4）否则调用相应的程序执行
5）shell 应该接受键盘输入信号，并对这些信号进行相应处理
6.3 Hello的fork进程创建过程
在终端输入命令，shell对命令进行判断，如果不是内置指令则调用一个fork函数创建新的子进程。例如输入./hello 7203610402 陈鹏宇时，shell分析不是内置命令，则调用fork创建一个子进程，子进程与父进程数据空间、栈、堆等资源完全相同。
6.4 Hello的execve过程
创建子进程之后，子进程调用exceve（）函数在当前子进程的上下文加载并运行一个新的程序。当调用exceve函数加载并运行可执行目标文件时，如果出错，exceve会返回到调用程序，如果顺利进行，exceve不返回。exceve调用加载器加载可执行目标文件时首先删除已存在的用户区域，随后创建新的代码、数据、堆和栈段并且映射共享区域；最后设置程序计数器（PC）。
6.5 Hello的进程执行
上下文：系统中的每个程序都运行在某个进程的上下文中。上下文是由程序正确运行所需的状态组成的。这个状态包括存放在内存中的程序的代码和数据，它的栈、通用目的寄存器的内容、程序计数器、环境变量立即打开文件描述符的集合。
进程时间片：一个进程执行它的控制流的一部分的每一时间段叫做时间片。多任务也叫做时间分片。
进程调度：在进程执行的某些时刻，内核可以决定抢占当前进程，并重新开始一个先前被抢占的进程，这种决策叫做调度。
用户态和内核态：运行应用程序代码的进程初始是在用户模式中的。进程从用户模式变为内核模式的唯一方法是通过诸如中断、故障或者陷入系统调用这样的异常。当异常发生时，控制传递函数到异常处理程序，处理器将模式从用户模式变为内核模式。处理程序运行在内核模式中，当它返回到应用程序代码时，处理器就把模式从内核模式改回到用户模式。
6.6 hello的异常与信号处理
hello执行时可能出现如下四种异常：

图44 四种异常

下面利用hello程序进行实践：
1）程序正常进行时为：
图45 正常运行
2）回车：（图46）
3）Ctrl+C：程序终止（图47）

图46 回车 图47Ctrl+C
4）Ctrl+Z
图48 Ctrl+Z
5）ps
图 49 ps
6）Jobs
图50 jobs
7）pstree
图51 pstree
8）fg

图52 fg

9）kill
图53 kill
10）乱按
图54 乱按
6.7本章小结
本章介绍了进程的概念和作用，以及shell的作用和处理流程。并且以hello程序为例，介绍了fork，execve函数，异常的种类。最后介绍了hello的异常与信号处理。

（第6章1分）

第7章 hello的存储管理
7.1 hello的存储器地址空间
逻辑地址：指在计算机体系结构中是指应用程序角度看到的内存单元（memory cell）、存储单元（storage element）、网络主机（network host）的地址。 逻辑地址往往不同于物理地址（physical address），通过地址翻译器（address translator）或映射函数可以把逻辑地址转化为物理地址。 在有地址变换功能的计算机中，访内指令给出的地址 (操作数) 叫逻辑地址，也叫相对地址。
线性地址：如果地址空间中的整数是连续的，那么我们说它是一个线性地址空间。实际上就是偏移量。
虚拟地址：与逻辑地址类似与物理内存无关。
物理地址：在存储器中，每一个字节都有唯一的物理地址来表示该位置。
7.2 Intel逻辑地址到线性地址的变换-段式管理
段选择符的格式如图55所示其中 当TI=0时，表示全局描述符表(GDT)，TI=1时，表示局部描述符表(LDT)若RPL=00，为第0级，位于最高级的内核态，RPL=11，为第3级，位于最低级的用户态，第0级高于第3级，最后高13位-8K个索引用来确定当前使用的段描述符在描述符表中的位置。
图55 段选择符
寻址时被选中的段描述符先被送至描述符cache，每次从描述符cache中取32位段基址，与32位段内偏移量（有效地址）相加得到线性地址。其中GDT首址或LDT首址都在用户不可见寄存器中。

图56 Intel处理器的存储器寻址
图57 逻辑地址向线性地址转换
7.3 Hello的线性地址到物理地址的变换-页式管理
图58 基于页表的地址翻译
虚拟页地址到物理页地址的映射通过页表进行， CPU中的一个控制寄存器，页表基址寄存器指向当前页表。n位虚拟地址包含两部分，一个p位的虚拟页面偏移(VPO)和一个（n-p）位的虚拟页号（VPN）,MMU利用VPN来选择适当的PTE，例如，VPN 0选择PTE 0，VPN 1选择PTE 1，以此类推。将页表中的物理页号PPN与虚拟地址中的VPO串联起来，就得到相应的物理地址，
7.4 TLB与四级页表支持下的VA到PA的变换
7.4.1利用TLB加速地址翻译
图59 TLB命中 图60 TLB不命中
TLB是一个小的、虚拟寻址的缓存，其中每一行都保存着一个由单个PTE组成的块，通常有高度的相联度。
当TLB命中时步骤为：
1）CPU产生一个虚拟地址；
2）MMU从TLB中取出相应的PTE。
3）MMU将这个虚拟地址翻译成一个物理地址，并将它发送到高速缓存/主存。
4）高速缓存/主存将所请求的数据字返回给CPU。
当TLB不命中时，MMU必须从L1缓存中取出相应的PTE，新取的PTE存放在TLB中，可能会覆盖一个已经存在的条目。
7.4.2 四级页表
虚拟地址被划分为4个VPN和1个VPO。每个VPNi都是一个到第i级页表的索引，其中1<=i<=4。第j级页表中的每个PTE，1<=j<=k-1，都指向第j+1级的某个页表的基址，第4级页表中的每个PTE包含某个物理页面的PPN，或者一个磁盘块的地址。为了构造物理地址，在能够确定PPN之前，MMU必须访问四个PTE。

图61 多级页表的地址翻译
7.5 三级Cache支持下的物理内存访问

图62 三级Cache支持下的物理内存访问
在获得PA之后，根据得到的PA进行索引。依次比较L1中的数据，如果命中直接返回，如果不命中依次上下一级（L2，L3）中需按照，若命中返回数据，更新cache。更新cache时，如果有空闲块优先将数据放到空闲块中，如果没有则将某个块驱逐，目标块放到驱逐块的位置。
7.6 hello进程fork时的内存映射
在fork函数被当前进程调用时，内核为新进程上下文，并分配一个唯一的PID。为了给这个新进程创建虚拟内存，它创建了当前进程的mm_struct、区域结构和页表的原样副本。它将两个进程中的每个页面都标记位只读，并将两个进程中的每个区域结构都标记为私有的写时复制。当fork在新进程中返回时，新进程现在的虚拟内存刚好和调用fork时存在的虚拟内存相同。当这两个进程中的任一个后来进行写操作时，写时复制机制就会创建新页面，因此也就为每个进程保持了私有地址空间的抽象概念。
7.7 hello进程execve时的内存映射
使用execve函数加载并运行hello.out，使用hello.out程序替代当前程序。该过程分为以下几个步骤：
1）删除当前进程虚拟地址中已存在的用户区域
2）映射私有区域，为新程序的代码、数据、bss和栈创建新的区域结构。
3）映射共享区域。
4）设置当前进程上下文程序计数器（PC）。
下一次调度这个进程时，它将从这个入口开始执行。
7.8 缺页故障与缺页中断处理

图63 缺页故障与缺页中断处理
假设MMU在试图翻译某个虚拟地址A时，触发了一个缺页。这个异常导致控制转移到内核的缺页处理程序，处理程序随后就执行下面的步骤:
1）虚拟地址A是否合法？缺页处理程序搜索区域结构的链表，把A和每个区域结构中的vm_start和vm_end做比较。如果这个指令是不合法的，那么缺页处理程序就触发一个段错误，从而终止这个进程。在图63中标记为1
2）试图进行的内存访问是否合法?进程是否有读、写或者执行这个区域内页面的权限？如果试图进行的访问是不合法的，那么缺页处理程序会触发一个保护异常，从而终止这个进程。在图63中标记为2
3）内核知道了这个缺页是由于对合法的虚拟地址进行合法的操作造成的。接下来选择一个牺牲页面，如果这个牺牲页面被修改过，那么就将它交换出去，换入新的页面并更新页表。当缺页处理程序返回时，CPU重新启动引起缺页的指令，这条指令将再次发送A到MMU。
7.9动态存储分配管理
当运行时需要额外虚拟内存时，用动态内存分配器更方便，也有更好的可移植性。
动态内存分配器维护着一个进程的虚拟内存区域，称为堆。假设堆是一个请求二进制零的区域，它紧接在未初始化的数据区域后开始，并向上生长(向更高的地址)。对于每个进程，内核维护着一个变量brk，它指向堆的顶部。
分配器将堆视为一组不同大小的块( block)的集合来维护。每个块就是一个连续的虚拟内存片(chunk),要么是已分配的，要么是空闲的。已分配的块显式地保留为供应用程序使用。空闲块可用来分配。空闲块保持空闲，直到它显式地被应用所分配。一个已分配的块保持已分配状态，直到它被释放，这种释放要么是应用程序显式执行的，要么是内存分配器自身隐式执行的。
分配器有两种基本风格。两种风格都要求应用显式地分配块。它们的不同之处在于由哪个实体来负责释放已分配的块。
显式分配器(，要求应用显式地释放任何已分配的块。
隐式分配器(implicit allocator)，另一方面，要求分配器检测一个已分配块何时不再被程序所使用，那么就释放这个块。隐式分配器也叫做垃圾收集器，而自动释放未使用的已分配的块的过程叫做垃圾收集。
7.10本章小结
本章介绍了hello的地址存储空间、段式管理、页式管理，VA到PA的转换，内存映射、缺页故障与缺页中断处理、和动态存储分配管理。
（第7章 2分）

第8章 hello的IO管理
8.1 Linux的IO设备管理方法
在Linux系统中所有的I/O设备(例如网络、磁盘和终端)都被模型化为文件，而所有的输人和输出都被当作对相应文件的读和写来执行。这种方式，允许Linux内核引出一个简单、低级的应用接口，称为Unix I/O，这使得所有的输入和输出都能以一种统一且一致的方式来执行。
设备的模型化：文件
设备管理：unix io接口
8.2 简述Unix IO接口及其函数
打开文件。一个应用程序通过要求内核打开相应的文件，来宣告它想要访问一个I/O设备。内核返回一个小的非负整数，叫做描述符，它在后续对此文件的所有操作中标识这个文件。内核记录有关这个打开文件的所有信息。应用程序只需记住这个描述符。
函数为：int open(char* filename,int flags,mode_t mode)
Linux shell 创建的每个进程开始时都有三个打开的文件:标准输入(描述符为0)、标准输出(描述符为1)和标准错误(描述符为2)。头文件定义了常量STDIN_FILENO、STDOUT_FILENO和 STDERR_FILENO，它们可用来代替显式的描述符值。
改变当前的文件位置。对于每个打开的文件，内核保持着一个文件位置k，初始为0。这个文件位置是从文件开头起始的字节偏移量。应用程序能够通过执行seek 操作，显式地设置文件的当前位置为k。
读写文件。一个读操作就是从文件复制n>0个字节到内存，从当前文件位置k开始，然后将k增加到k+n。给定一个大小为m字节的文件，当k≥m时执行读操作会触发一个称为end-of-file(EOF)的条件，应用程序能检测到这个条件。在文件结尾处并没有明确的“EOF符号”。写操作就是从内存复制n>0个字节到一个文件，从当前文件位置k开始，然后更新k。
函数：ssize_t read(int fd,void *buf,size_t n)
ssize_t wirte(int fd,const void *buf,size_t n)
关闭文件。当应用完成了对文件的访问之后，它就通知内核关闭这个文件。作为响应，内核释放文件打开时创建的数据结构，并将这个描述符恢复到可用的描述符池中。无论一个进程因为何种原因终止时，内核都会关闭所有打开的文件并释放它们的内存资源。
函数：int close(int fd)

8.3 printf的实现分析
程序实例为
int printf(const char *fmt, …)
{
int i;
char buf[256];

 va_list arg = (va_list)((char*)(&fmt) + 4); i = vsprintf(buf, fmt, arg); write(buf, i); return i;

}
查看vsprintf函数
int vsprintf(char *buf, const char fmt, va_list args)
{
char p;
char tmp[256];
va_list p_next_arg = args;

for (p=buf;*fmt;fmt++) { if (*fmt != '%') { *p++ = *fmt; continue; } fmt++; switch (*fmt) { case 'x': itoa(tmp, *((int*)p_next_arg)); strcpy(p, tmp); p_next_arg += 4; p += strlen(tmp); break; case 's': break; default: break; } } return (p - buf); 

}
vsprintf的作用就是格式化。它接受确定输出格式的格式字符串fmt。用格式字符串对个数变化的参数进行格式化，产生格式化输出。代码中的vsprintf只实现了对16进制的格式化。随后时函数write和sys_call.
write:
mov eax, _NR_write
mov ebx, [esp + 4]
mov ecx, [esp + 8]
int INT_VECTOR_SYS_CALL
int INT_VECTOR_SYS_CALL表示要通过系统来调用sys_call这个函数。
sys_call:
call save

 push dword [p_proc_ready] sti push ecx push ebx call [sys_call_table + eax * 4] add esp, 4 * 3 mov [esi + EAXREG - P_STACKBASE], eax cli ret

sys_cal可以显示格式化了的字符串。
从vsprintf生成显示信息，到write系统函数，到陷阱-系统调用 int 0x80或syscall等.
字符显示驱动子程序：从ASCII到字模库到显示vram（存储每一个点的RGB颜色信息）。
显示芯片按照刷新频率逐行读取vram，并通过信号线向液晶显示器传输每一个点（RGB分量）。从而实现printf的功能。
8.4 getchar的实现分析
getchar()函数运行时，用户通过键盘输入控制权交给os，输入的内容便会显示在屏幕上。按下回车键表示输入完成，这时控制权将被交还给程序。
异步异常-键盘中断的处理：键盘中断处理子程序。接受按键扫描码转成ascii码，保存到系统的键盘缓冲区。
getchar等调用read系统函数，通过系统调用读取按键ascii码，直到接受到回车键才返回。
8.5本章小结
本章介绍了在Linux系统下的IO管理方法，IO的接口和函数，最后分析了printf和getchar函数。
结论
Hello的经历：
1）源文件：高级程序语言文本文件，hello.c
2）预处理：对源程序中的预处理命令部分做处理，主要包括1. 宏定义；2. 文件包含；3. 条件编译，得到hello.i。
3）编译：编译器(ccl)将文本文件.i翻译成文本文件.s，即翻译成汇编语言。
4）汇编：将汇编程序翻译成机器语言指令（.i）
5）链接：链接器进行符号解析、重定位、动态链接等创建一个可执行目标文件hello。可以执行。
6）fork创建进程：调用fork函数创建子进程，供hello程序的运行。
7）运行：在内核的调度下配合存储管理（MMU、TLB、多级页表、cache、DRAM内存、动态内存分配器）运行。
8）终止：结束进程，020。
学习这门课对计算机有了更深刻的认识，在简单的hello程序的运行背后是硬件、软件、操作系统配合协调工作的结果。在深刻了解了计算机系统之后，我对程序的认知更加深刻，帮助我写出面对机器更加友好的程序。我认识到了计算机是复杂而美丽的，它精巧的设计凝聚了人类的智慧的精华。
（结论0分，缺失 -1分，根据内容酌情加分）

附件
hello.c 源程序
hello.i 预处理后文本文件
hello.s 汇编程序
hello.o 可重定位目标程序
hello 可执行目标程序（二进制）
hello1.txt hello.o的反汇编文件
hello2.txt hello的反汇编文件
elf.txt hello.o的ELF
elf2.txt hello的ELF

参考文献
为完成本次大作业你翻阅的书籍与网站等
[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.
[7] [转]printf 函数实现的深入剖析 – Pianistx – 博客园 (cnblogs.com)
[8] randal E.Bryant 深入理解计算机系统[M]. 机械工业出版社， 2016

（参考文献0分，缺失 -1分）