哈工大2022计算机系统大作业“程序人生”
Posted jy_Xiaodao
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了哈工大2022计算机系统大作业“程序人生”相关的知识，希望对你有一定的参考价值。
计算机系统
大作业
题 目 程序人生-Hello’s P2P
专 业 计算机
学 号 120L021504
班 级 2003012
学 生 乔江洋
指 导 教 师 郑贵滨
计算机科学与技术学院
2022年5月
摘 要
本文主要阐述了hello程序在Linux系统下的生命周期，hello程序在经过预处理、汇编、编译、链接生成可执行文件的全过程。并结合上课学习的知识详细阐述计算机系统对hello进行进程管理、储存管理以及I/O管理，探索hello生命周期的探索。
关键词：预处理；汇编；编译；链接；进程管理；储存管理；I/O管理
第1章 概述
1.1 Hello简介
P2P（from program to process）:
在Linux环境下，hello的源程序，即hello.c经过cpp的预处理得到hello.i文件、经过cc1编译生成hello.s的汇编文件、经过as的处理成为可重定位目标文件hello.o、最后由ld链接生成可执行文件hello。通过shell输入./shell，shell通过fork函数创建了一个子进程，子进程执行execve函数加载hello。至此，完成由源程序转换为被执行进程的过程。
O2O（from zero-0 to zero-0）:
在execve执行hello程序后，内核为hello进程映射虚拟内存。在hello进入程序入口后，hello相关的数据就被内核加载到物理内存中，hello程序开始正式被执行。为了让hello正常执行，内核还需要为hello分配时间片、逻辑控制流。最后，当hello运行结束，终止成为僵尸进程后，由shell负责回收hello进程，删除与hello有关的数据内容。
1.2 环境与工具
硬件环境：X64 CPU；2GHz；2G RAM；256GHD Disk 以上
软件环境：Windows7 64位以上；VirtualBox/Vmware 11以上；Ubuntu 16.04 LTS 64位/优麒麟 64位
开发与调试工具：gcc，vim，edb，readelf，HexEdit
1.3 中间结果
列出你为编写本论文，生成的中间结果文件的名字，文件的作用等。
hello.i 预处理之后的程序（文本）
hello.s 汇编语言程序（文本）
hello.o 可重定位目标程序（二进制）
hello 可执行目标程序（二进制）
1.4 本章小结
本章概述了hello从源程序到可执行程序的过程以及shell执行hello的过程，列出了环境以及中间结果信息。
第2章 预处理
2.1 预处理的概念与作用
预处理：
预处理器cpp根据以字符#开头的命令（宏定义、条件编译），修改原始的C程序，将引用的所有库展开合并成为一个完整的文本文件。
预处理作用：
合理使用预处理功能编写的程序便于阅读、修改、移植和调试，也有利于模块化程序设计。以#includ为例，预处理器（cpp）把程序中声明的文件复制到这个程序中，具体到hello.c的就是#include <unistd.h> 、#include <stdlib.h>、#include<stdio.h>。cpp把这些头文件的内容插入到程序文本中，方便编译器进行下一步的编译。结果就是得到了另一个c程序，通常得到的程序以.i作为文件扩展名。
2.2在Ubuntu下预处理的命令
Linux中hello.c文件进行预处理的命令是：gcc hello.c -E -o hello.i
应截图，展示预处理过程！
图 1 2.2
2.3 Hello的预处理结果解析
图 2 2.3-1，2
经过预处理后hello.c文件转化为hello.i文件，打开后发现内容增加到3000+行，且仍为可以阅读的C语言程序文本文件。对原文件中的宏进行了宏展开，头文件中的内容被包含进该文件中。例如声明函数、定义结构体、定义变量、定义宏等内容。另外，如果代码中有#define命令还会对相应的符号进行替换。
2.4 本章小结
本章介绍了预处理的相关概以及作用，并展示在ubuntu下用gcc对.c文件进行预处理，分析文本的前后变化。
第3章 编译
3.1 编译的概念与作用
编译：
编译是指利用编译程序从预处理文本文件（.i）产生汇编程序（.s）的过程。这个过程就是把完成预处理后的文件进行一系列词法分析、语法分析、语义分析以及优化后生成相应的汇编代码文件。
编译的作用：
编译程序的基本功能是把源程序(高级语言)翻译成目标程序。除了基本功能之外，编译程序还具备语法检查、调试措施、修改手段、覆盖处理、目标程序优化、不同语言合用以及人际联系等重要功能。
注意：这儿的编译是指从 .i 到 .s 即预处理后的文件到生成汇编语言程序
3.2 在Ubuntu下编译的命令
在ubuntu下对.i文件进行编译的指令是：gcc -S hello.i -o hello.s
应截图，展示编译过程！
图 3 3.2-1
3.3 Hello的编译结果解析
3.3.0 汇编代码
图 4 3.3.0-1，2，3
.file:声明源文件
.text：代码节
.section:
.rodata:只读代码段
.align：数据或者指令的地址对其方式
.string：声明一个字符串（.LC0,.LC1）
.global：声明全局变量(main)
.type:声明一个符号是数据类型还是函数类型
3.3.1 数据
1.字符串
程序中有两个字符串，由上图可知，这两个字符串都在只读数据段中，分别如图所示：
图 5 3.3.1-1
2.局部变量i
局部变量i被放在栈中，通过rbp的相对偏移来访问。
图 6 3.3.1-2
3. 主函数传递参数argc、argv
符号数argc和字符型数组指针argv，根据寄存器使用规则，这两个参数分别通过%edi和%esi传递。在程序最开始，为main函数建立栈帧，并完成参数传递。argc存放于%rsp-20；argv作为main函数的参数，数组的元素都是指向字符类型的指针，起始地址存放在栈中-32（%rbp）的位置，被两次调用找参数传给printf。
图 7 3.3.1-3，4
3.3.2全局函数
图 8 3.3.2-1
从 hello.c 可以看出 hello.c 描述并编译了全局函数 int main( intargc, char*argv[])后，将main函数中使用的字符串常量也保存到数据区域。
3.3.3赋值操作
程序中的赋值操作主要有：i=0这条赋值操作在汇编代码主要使用mov指令来实现，而根据数据的类型又有好几种不一样的后缀
movb:一个字节
movw：两个字节
movl：四个字节
movq：八个字节
图 9 3.3.3-1
处理c语言中翻译过来的赋值操作，在汇编代码中还有通过以lea（地址传递）来赋值的方式。
图 10 3.3.3-2
3.3.4算术操作
c代码中的算术操作有i++，在汇编代码中是通过add来实现的：
图 11 3.3.4-1
除了c代码中的算数操作，在汇编代码中还有通过sub（减操作）：
图 12 3.3.4-2
3.3.5关系操作
(1) argc! = 3; 判断条件句子的条件: 编译 argc! = 3时，本命令语如下: cmpl $3,-20 (% rbp ) ， 此命令包含代码设置， 并判断是否需要分区 。
图 13 3.3.5-1
2）i<8, hello.c以判断循环为条件，在汇编代码中编译如下: 计算cmpl $7,-4(% rbp), i-7后设置条件代码， 准备在下一个 jle 利用条件代码跳跃。
图 14 3.3.5-2
3.3.6控制转移指令
在c源程序中的控制转移有if语句和for循环，在汇编代码中这两者都是通过条件跳转指令来完成的。如图：
图 15 3.3.6-1，2
3.3.7函数操作
在64位系统中，参数的传递首先是通过寄存器，顺序是rdi、rsi、rdx、rcx、r8、r9，其余参数压栈。
函数的调用使用的是call语句，如果用立即数驱动call语句就必须要计算函数所在位置和rip的相对偏移量。
图 16 3.3.7-1，2，3，4
可以看到，我们汇编代码中的函数调用用的都是call加上函数名的方法。
函数一般都通过ret指令返回，返回去往往要通过leave函数等方式进行堆栈平衡，返回值一般都存放在rax中，如图：
图 17 3.3.7-5
3.3.8类型转换
Sleep函数的参数为int值，而argv为字符串数组，在hello.c中用atoi将字符串转化成int型，在hello.s中用call语句调用atoi函数强制处理该类型转换。
图 18 3.3.8-1
3.4 本章小结
本章主要讲述了在编译阶段，编译器如何处理各种操作与数据，以及c语言种各种操作和类型对应的汇编语言，帮助我们理解汇编语言与c语言之间的转化。
第4章 汇编
4.1 汇编的概念与作用
汇编指的是汇编器ad将.s文件翻译成机器语言，并将其生成后缀名为.o的可重定位目标文件的过程。
注意：这儿的汇编是指从 .s 到 .o 即编译后的文件到生成机器语言二进制程序的过程。
4.2 在Ubuntu下汇编的命令
gcc hello.s -c -o hello.o
应截图，展示汇编过程！
图 19 4.2-1
4.3 可重定位目标elf格式
(1) ELF Header : 用命令 : readelf -h hello.o
ELF Header: 以 16B 序列 Magic 启动， 说明 Magic 创建此文件的系统的字体大小和字节顺序 。 ELF 头条的剩余部分包括链接器语法分析和#标题显示对象文件的大小、目标文件的种类、机器类型、字节头桌的文件偏移、节点头桌的项目大小和个数等。
图 20 4.3-1
(2) Section Headers:用命令：readelf -S hello.o
Section Headers:节头部表，包含了文件中出现的各个节的语义，包括节 的类型、位置和大小等信息。 由于是可重定位目标文件，所以每个节都从0开始，用于重定位。在文件头中得到节头表的信息，然后再使用节头表中的字节偏移信息得到各节在文件中的起始位置，以及各节所占空间的大小，同时可以观察到，代码是可执行的，但是不能写；数据段和只读数据段都不可执行，而且只读数据段也不可写。
图 21 4.3-2
(3)查看符号表.symtab ：命令readelf -s hello.o
.symtab： 存放程序中定义和引用的函数和全局变量的信息。name是符号名称，对于可冲定位目标模块，value是符号相对于目标节的起始位置偏移，对于可执行目标文件，该值是一个绝对运行的地址。size是目标的大小，type要么是数据要么是函数。Bind字段表明符号是本地的还是全局的。
图 22 4.3-3
(4)重定位节.rela.text
重定位节 :. text 节点位置列表 。 当目标文件和链接将其它文件组合起来时， 您必须更改 。
重定位节. rela.text 的符号信息 :
Offset: 包含要更改的引用节的偏移Info: symbol 和 type 两个部分 。 symbol是前四节拍，type是后四节拍，
symbol: 更改了标志， 指向了它们的符号，
type: 初始化类型
Type: 链接提示您如何修改新程序 。
Attend: 有符号常数。部分重整行用于更改引用值Name: 重命名目标 。
4.4 Hello.o的结果解析
objdump -d -r hello.o 分析hello.o的反汇编，并请与第3章的 hello.s进行对照分析。
图 23 4.4-1，2，3
汇编的代码和hello.s比较的结果，汇编的命令语没有区别。 只是汇编代码不仅标注了汇编代码，还标注了机器代码。 机器语言软件是李镇洙机器的命令语集合，是纯粹的李镇洙数据所表现的语言，是计算机能够正确识别语言。机器指令由操作代码和操作数组成，汇编语言是直接表现CPU动作的形成，是最接近CPU运转原理的语言。每个汇编操作代码都可以用机器的二进制数据来表示，进而可以使所有的汇编（操作代码和操作数）和二进制语言建立一个个映射的关系，因此可以将汇编转换成机器语言。
(1)分支转移: 汇编的移动指令是。 L3, 不是短路，而是汇编时容易写出的帮助，因此汇编语言后就不存在了。
(2)函数调用: 如果函数在.s 文件中呼出， 函数名称将保持原样， 反向编程程序中的 call 目标地址是当前命令 。这是因为从 hello.c 呼出的函数是共享库中的函数， 因此只能通过动态链接来执行， 当汇编成为汇编语言时， 对于这个不确定的函数呼出， call 命令的相对地址设置为 0， 并在下一个命令中设置下列命令 。 在 rela.text 栏目中再次添加静态链接， 然后等待下一个链接 。
4.5 本章小结
本章对hello.s进行了汇编，生成了hello.o可重定位目标文件，并且分析了可重定位文件的ELF头、节头部表、符号表和可重定位节，比较了hello.s和hello.o反汇编代码的不同之处，分析了从汇编语言到机器语言的一一映射关系。
第5章 链接
5.1 链接的概念与作用
链接是将各种代码和数据片段收集并组合成一个单一文件的过程，这个文件可被加载(复制)到内存并执行。链接可以执行于编译时，也就是在源代码被编译成机器代 码时；也可以执行于加载时，也就是在程序被加载器加载到内存并执行时；甚至于运行时，也就是由应用程序来执行。
链接是由叫做链接器的程序执行的。链接器使得分离编译成为可能，极大地方便了模块化编程。
注意：这儿的链接是指从 hello.o 到hello生成过程。
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
使用ld的链接命令，应截图，展示汇编过程！ 注意不只连接hello.o文件
图 24 5.2-1
5.3 可执行目标文件hello的格式
分析hello的ELF格式，用readelf等列出其各段的基本信息，包括各段的起始地址，大小等信息。
5.3.1 ELF Header
图 25 5.3.1-1
可以看到，可执行文件的ELF头与可重定位目标文件的ELF头有以下几个不同：
1.可执行文件的类型不再是REL而是EXEC。
2.程序的入口点不一样，因为连接上了库文件，使得main函数不再是从0x0开始。同理节头的开始位置也发生了变化。
3.节头的数量产了变化。
5.3.2节头部表Section Headers
图 26 5.3.2-1
可以看到与hello.o不同，在可执行文件中经过重定位每个节的地址不再是0，而是根据自身大小加上对齐规则计算的偏移量。
比如.hash的地址，计算方式是.note.ABI-tag的地址0x40021c加上.note.ABI-tag的大小0x20，得到0x40023c，再对.hash要求的8字节对齐进行调整，得到最终地址0x40024。
5.3.3符号表.symtab
图 27 5.3.3-1
在可执行文件中多出了.dynym节。这里面存放的是通过动态链接解析出的符号，这里我们解析出的符号是程序引用的头文件中的函数。
5.3.4重定位节
图 28 5.3.4-1
重定位节的偏移量与hello.o已经完全不一样了。
5.4 hello的虚拟地址空间
使用edb加载hello，查看本进程的虚拟地址空间各段信息，并与5.3对照分析说明。
通过查看edb，看出hello的虚拟地址空间开始于0x400000,结束与0x400ff0：
图 29 5.4-1，2
通过5.3.2的节头部表可以找到各节信息，例如：
.text节是从0x4010f0开始的：
.rodate节是从0x402000开始的：
图 30 5.4-3，4
5.5 链接的重定位过程分析
objdump -d -r hello 分析hello与hello.o的不同，说明链接的过程。
结合hello.o的重定位项目，分析hello中对其怎么重定位的。
（1）在hello.o中call、jmp指令后紧跟着的是相对地址，而hello中紧跟的是虚拟内存的确定地址，原因在于链接器完成了重定位过程，可以确定运行时的地址
图 31 5.5-1
（2）在hello中增加了一些在hello.o中没有的函数，这些都是在hello.c中没有定义却直接使用的函数，这些函数定义在共享库中，在链接时完成了符号解析和重定位，如printf、sleep等。
图 32 5.5-2
综上所述，重定位的大体过程是链接器ld将所有链接文件中相同的节合并，并按照要求计算新的偏移地址赋值给新的节。同时链接器按链接指令的顺序搜索符号表，查找符号引用。
5.6 hello的执行流程
使用edb执行hello，说明从加载hello到_start，到call main,以及程序终止的所有过程。请列出其调用与跳转的各个子程序名或程序地址。
子程序名 地址
ld-2.31.so!_dl_start 0x7f8586bea770
ld-2.31.so!_dl_init 0x7f8586bea9a0
hello!_start 0x4010f0
libc-2.31.so!_libc_start_main 0x7f634a96ce60
hello!printf@plt 0x401040
hello!sleep@plt 0x401080
hello!getchar@plt 0x401050
libc-2.31.so!exit 0x7f634a7540d0
5.7 Hello的动态链接分析
分析hello程序的动态链接项目，通过edb调试，分析在dl_init前后，这些项目的内容变化。要截图标识说明。
动态链接采用了延迟加载的策略，即在调用函数时才进行符号的映射。使用偏移量表GOT和过程链接表PLT的协同工作实现函数的动态链接。GOT中存放函数目标地址，PLT使用GOT中的地址跳转到目标函数。
程序开始后，通过执行dl_init可以修改PLT和GOT，下面是执行dl_init之前的PLT内容：
图 33 5.7-1
执行dl_init之后的内容：
图 34 5.7-2
从图中第二行可以看到变化。
5.8 本章小结
本章介绍了链接的概念和作用，详细介绍了hello.o如何成为可执行的目标文件，详细介绍了hello.o的ELF形式和各节的意义，分析了hello的虚拟地址空间、重置进程、运行进程和动态链接过程。
第6章 hello进程管理
6.1 进程的概念与作用
进程是一个执行中的程序的实例，每一个进程都有它自己的地址空间，一般情 况下，包括文本区域、数据区域、和堆栈。文本区域存储处理器执行的代码；数 据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储区着活动 过程调用的指令和本地变量。
作用：进程为用户提供了以下假象：
(1) 我们的程序好像是系统中当前运行的唯一程序一样，我们的程序好像是独占的使用处理器和内存。
(2) 处理器好像是无间断的执行我们程序中的指令，我们程序中的代码和数据好像是系统内存中唯一的对象。
6.2 简述壳Shell-bash的作用与处理流程
Linux系统中，Shell是一个交互型应用级程序，代表用户运行其他程序(是命令行解释器，以用户态方式运行的终端进程)。
其基本功能是解释并运行用户的指令，重复如下处理过程：
(1)终端进程读取用户由键盘输入的命令行。
(2)分析命令行字符串，获取命令行参数，并构造传递给execve的argv向量
(3)检查第一个(首个、第0个）命令行参数是否是一个内置的shell命令
(4)如果不是内部命令，调用fork( )创建新进程/子进程
(5)在子进程中，用步骤2获取的参数，调用execve( )执行指定程序。
(6)如果用户没要求后台运行(命令末尾没有&号）否则shell使用waitpid（或wait…等待作业终止后返回。
7)如果用户要求后台运行(如果命令末尾有&号），则shell返回；
6.3 Hello的fork进程创建过程
终端程序通过调用fork()函数创建一个子进程，子进程得到与父进程完全相同但是独立的一个副本，包括代码段、段、数据段、共享库以及用户栈。子进程还获得与父进程任何打开文件描述符相同的副本，父进程和子进程最大的不同时他们的PID是不同的。父进程与子进程是并发运行的独立进程，内核能够以任意方式交替执行它们的 逻辑控制流的指令。在子进程执行期间，父进程默认选项是显示等待子进程的完成。
6.4 Hello的execve过程
当创建了一个子进程之后，子进程调用exceve函数在当前子进程的上下文加载并运行一个新的程序即hello程序，加载并运行需要以下几个步骤：
(1)删除已存在的用户区域。删除当前进程虚拟地址的用户部分中已存在的区域结构。
(2)映射私有区域。为新程序的代码、数据、bss和栈区域创建新的区域结构。所有这些区域结构都是私有的，写时复制的。虚拟地址空间的代码和数据区域被映射为hello文件的.txt和.data区。bss区域是请求二进制零的，映射匿名文件，其大小包含在hello文件中。栈和堆区域也是请求二进制零的，初始长度为零。
(3)映射共享区域。如果hello程序与共享对象链接，比如标准C库libc.so，那么这些对象都是动态链接到这个程序的，然后再映射到用户虚拟地址空间中的共享区域。
(4)设置程序计数器（PC）。exceve做的最后一件事就是设置当前进程的上下文中的程序计数器，使之指向代码区域的入口点。下一次调用这个进程时，它将从这个入口点开始执行。Linux将根据需要换入代码和数据页面。
6.5 Hello的进程执行
结合进程上下文信息、进程时间片，阐述进程调度的过程，用户态与核心态转换等等。
进程提供给应用程序的抽象：
(1) 一个独立的逻辑控制流，它提供一个假象，好像我们的进程独占的使用处理器
(2) 一个私有的地址空间，它提供一个假象，好像我们的程序独占的使用CPU内存。
hello进程的执行是依赖于进程所提供的抽象的基础上，下面阐述操作系统所提供的的进程抽象：
①逻辑控制流:：一系列程序计数器 PC 的值的序列叫做逻辑控制流，进程是轮流 使用处理器的，在同一个处理器核心中，每个进程执行它的流的一部分后被抢占 （暂时挂起），然后轮到其他进程。
②并发流：一个逻辑流的执行时间与另一个流重叠，成为并发流，这两个流成为并发的运行。多个流并发的执行的一般现象成为并发。
③时间片：一个进程执行它的控制流的一部分的每一时间段叫做时间片。
④私有地址空间：进程为每个流都提供一种假象，好像它是独占的使用系统地址空间。一般而言，和这个空间中某个地址相关联的那个内存字节是不能被其他进程读或者写的，在这个意义上，这个地址空间是私有的。
⑤用户模式和内核模式：：处理器通常使用一个寄存器提供两种模式的区分，该寄 存器描述了进程当前享有的特权，当没有设置模式位时，进程就处于用户模式中， 用户模式的进程不允许执行特权指令，也不允许直接引用地址空间中内核区内的 代码和数据；设置模式位时，进程处于内核模式，该进程可以执行指令集中的任 何命令，并且可以访问系统中的任何内存位置。
⑥上下文信息：上下文就是内核重新启动一个被抢占的进程所需要的状态，它由 通用寄存器、浮点寄存器、程序计数器、用户栈、状态寄存器、内核栈和各种内 核数据结构等对象的值构成。
⑦上下文切换：当内核选择一个新的进程运行时，则内核调度了这个进程。在内核调度了一个新的进程运行后，它就抢占当前进程，并使用一种称为上下文切换的机制来将控制转移到新的进程：
1） 保存以前进程的上下文
2）恢复新恢复进程被保存的上下文，
3）将控制传递给这 个新恢复的进程 ，来完成上下文切换。
以hello为例，hello程序在调用了sleep程序后会陷入内核状态，内核可能会进行上下文切换。程序运行到getchar的时候，内核也会进行上下文切换，让其他进程运行。除了这些，系统还会为hello程序分配时间片，即使没有执行到getchar或者sleep函数，只要hello时间片被用完，系统就会判断当前程序以及执行够久了，从而进行上下文切换，将处理器让给其他进程。
6.6 hello的异常与信号处理
hello执行过程中会出现哪几类异常，会产生哪些信号，又怎么处理的。
程序运行过程中可以按键盘，如不停乱按，包括回车，Ctrl-Z，Ctrl-C等，Ctrl-z后可以运行ps jobs pstree fg kill 等命令，请分别给出各命令及运行结截屏，说明异常与信号的处理。
（1）异常和信号异常可以分为四类：中断、陷阱、故障、终止。异常的同步异步指的是异常的发生和程序的关系。比如从键盘输入crtl+c作为异步异常与程序的执行没有关系。而缺页异常这样的同步异常是随着程序的执行产生的。
图 35 6.6-1
(2)键盘上各种操作导致的异常
1.正常运行结果：
图 36 6.6-2
2.按下ctrl+z结果：
图 37 6.6-3
Ctrl+z效果是挂起前台作业，hello进程运行在后台
图 38 6.6-4
输入ps命令可发现，hello进程并未被回收，且在后台工作号为1，输入fg 1命令将hello进程调至前台，此时 shell 程序首先打印 hello 的命令行命令， hello 继续运行打印剩下的“hello 120L021504 乔江洋”，程序结束，再次输入ps命令，发现进程被回收。
图 39 6.6-5
3.按下ctrl+c结果：
图 40 6.6-7
输入Ctrl+c会导致内核发送一个SIGINT信号到前台进程组的每个进程，默认情况是终止前台作业，用ps查看前台进程组发现没有hello进程。
图 41 6.6-8
4.胡乱输入结果：
图 42 6.6-9
不停乱按，可以发现，乱按只是将屏幕的输入缓存到 stdin，当 getchar 的时候读出一个“\\n”结尾的字串（作为一次输入），其他字串会当做 shell 命令行输入。
6.7本章小结
在本章中，阐述进程的定义与作用，同时介绍了 Shell 的一般处理流程和作用，并且着重分析了调用 fork 创建新进程，调用 execve函数 执行 hello，hello的进程执行，以及hello 的异常与信号处理。
第7章 hello的存储管理
7.1 hello的存储器地址空间
结合hello说明逻辑地址、线性地址、虚拟地址、物理地址的概念。
逻辑地址：逻辑地址指的是在汇编代码中通过偏移量+段基址得到的地址，与物理地址不同。在hello反汇编代码中我们能够看到的就是逻辑地址。
线性地址：线性地址就是虚拟地址，具体见下。
虚拟地址：虚拟地址是逻辑地址计算后的结果，同样不能直接用来访存，需要通过MMU翻译得到物理地址来访存。在hello反汇编代码计算后就能得到虚拟地址。
物理地址：计算机系统的主存被组织成一个由M个连续的字节大小的单元组成的数组。每个字节都有一个唯一的物理地址。第一个字节的地址为0，写下来的字节地址为1，再下一个为2，以此类推。虚拟地址通过MMU翻译后得到物理地址。在hello中通过翻译得到的物理地址来得到我们需要的数据。
7.2 Intel逻辑地址到线性地址的变换-段式管理
一个逻辑地址由两部份组成，段标识符: 段内偏移量。段标识符是由一个16位长的字段组成，称为段选择符。其中前13位是一个索引号。后面3位包含一些硬件细节，表示具体的是代码段寄存器还是栈段寄存器抑或是数据段寄存器。
图 43 7.2-1
索引号就是“段描述符(segment descriptor)”的索引，段描述符具体地址描述了一个段。很多个段描述符，就组了一个数组，叫“段描述符表”，这样，可以通过段标识符的前13位，直接在段描述符表中找到一个具体的段描述符，这句话很关键，说明段标识符的具体作用，每一个段描述符由8个字节组成。
Base字段，表示的是包含段的首字节的线性地址，也就是一个段的开始位置的线性地址。一些全局的段描述符，就放在“全局段描述符表(GDT)”中，一些局部的，例如每个进程自己的，就放在所谓的“局部段描述符表(LDT)”中。那究竟什么时候该用GDT，什么时候该用LDT呢？这是由段选择符中的T1字段表示的，=0，表示用GDT，=1表示用LDT，GDT在内存中的地址和大小存放在CPU的gdtr控制寄存器中，而LDT则在ldtr寄存器中。
7.3 Hello的线性地址到物理地址的变换-页式管理
线性地址也就是虚拟地址，我们一般通过页表来获得虚拟地址到物理地址的映射。
页表是一个关于页表条目PTE的数组。页表条目由有效位和物理页号组成。
一个虚拟页只有如下三个状态：
未分配的：VM系统还未分配（或者创建）的页。未分配的块没有任何数据和它们相关联，因此也就不占用任何内存。
缓存的：当前已缓存在物理内存中的已分配页。
未缓存在虚拟内存中的已分配页。
如图：
图 44 7.3-1
结合以上两点，我们就可以按下图的方法通过页表将虚拟页映射到物理页上。
图 45 7.3-2
接下来我们来讨论地址的翻译，由于接下来要分析多级页表，因此在这里我只论述一级页表的情况。
我们将n为的虚拟地址拆分成p为的虚拟页面偏移VPO和n-p位的VPN。我们通过VPN找到页表，并通过页表来获得虚拟页号，将m-p位的物理页号和p位的虚拟页面偏移组合在一起（虚拟页面偏移等价于物理页面偏移，因为物理内存映射的是虚拟内存的一整页。）就得到了m位的物理地址。如图：
图 46 7.3-3
7.4 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 的时候发现不在物理内存中，则引发缺页故障。如果发现权限不够，则引发段错误。
图 47 7.4-1
7.5 三级Cache支持下的物理内存访问
Cache的访问并不复杂，对Cache的访问需要把一个物理地址分为标记、组索引、块偏移三个部分。首先我们通过组索引来找到我们的地址在Cache中所对应的组号，再通过标记和Cache的有效位来判断我们的内容是否在Cache中。若命中则通过块偏移读取我们要的数据，若不命中则从下一级Cache中寻找（下一级Cache不一定真的是Cache，比如对L3来说，它的下一级Cache就是主存）。
先来讨论一级Cahce，Core i7CPU的L1 Cache大小为32kb，每组八路，每个块大小为64字节。通过计算可以得出这个Cahce一共有64组。而我们知道，i7CPU的物理地址是52位，因此我们可以分析出这个Cache对物理地址的划分如图：
图 48 7.5-1
通过MMU将虚拟地址转化成物理地址后，计算机就通过提取中的组索引在L1中搜索组，再通过标记位匹配。如果匹配成功且有效位是1，则将块偏移指向的块中的内容交还给CPU，否则未命中，需要从下一级Cache中在重复上述操作。当我们找到内容后需要将内容写回我们的L1中，如果L1中没有空闲块，即有效位为0的块则需要牺牲一块内容，我们通常采用LRU算法来进行这一过程。对L2、L3的访问也是这样，因此就不再赘述。
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。然后控制返回给引起缺页故障的指令。当指令再次执行时，相应的物理页面已经驻留在内存中，因此指令可以没有故障的运行完成。故障处理具体流程如图所示：
图 49 7.8-1
7.9动态存储分配管理
7.9.1 动态分配器介绍：
虽然可以使用低级的mmap和munmap函数来创建和删除虚拟内存区域，但是C程序员还是会觉得当运行时需要额外虚拟内存时，用动态内存分配器更方便，也有更好的可移植性。
动态内存分配器维护着一个进程的虚拟内存域，称为堆。堆每个进程，内核维护着一个变量brk，它指向堆的顶部。
分配器有两种基本风格。两种风格都要求应用显示地分配块。它们的不同之处在于由哪个实体负责释放已分配的块。
显式分配器：
要求应用显式地释放任何已分配的块。例如，c标准库提供一种叫做malloc程序包的显式分配器。c程序通过调用malloc函数来分配一个块，并通过调用free函数来释放一个块。c++中的new和delete操作符与c中的malloc和free相当。
隐式分配器：
另一方面，要求分配器检测一个已分配块何时不再被程序所使用，那么就释放这个块。隐式分配器也叫做垃圾收集器，而自动释放未使用的已分配的块的过程叫做垃圾收集，例如Lisp,ML以及Java之类的高级语言就依赖垃圾收集来释放已分配的块。
7.9.2 带边界标签的隐式空闲链表分配器
带边界标签的隐式空闲链表与普通的空闲链表不同，一个块除了是由一个字的头部、有效载荷、可能的一些额外的填充组成外，还有一个与头部相同的脚部组成。头部和脚部编码了这个块的大小（包括头部和所有的填充），以及这个块是已分配的还是空闲的。如果我们强加一个双字的对齐约束条件，那么块大小就总是8的倍数，且块大小的最低3位总是0。因此，我们只需要内存大小的29个高位，释放剩余的3位来编码其他信息。在这种情况中，我们用其中的最低位（已分配位）来指明这个块是已分配的还是空闲的。
头部后面就是应用调用malloc时请求的有效载荷。有效载荷后面是一片不使用的填充块，其大小可以是任意的。需要填充有很多原因。比如，填充可能是分配器策略的一部分，用来对付外部碎片。或者也需要用它来满足对齐要求。
我们称这种结构称为隐式空闲链表，是因为空闲块是通过头部中的大小字段隐含地连接着的。分配器可以通过遍历堆中所有的块，从而间接地遍历整个空闲块的集合。在带边界标签的隐式空闲链表中，我们的脚部就标记了一个块的结束。
合并的时候分配器就可以通过检查脚部来检查前一块的状态和大小了。
7.9.3 显式空间链表
将空闲块组织为某种形式的显示数据结构是一种更好的方法，因为根据定义，程序不需要一个空闲块的主体，所以实现空闲链表数据结构的指针可以存放在这些空闲块的主体里面。
显式空闲链表是将对组织成双向链表。在每个空闲块的主体中，都包含一个pred（前驱）和succ（后继）指针。
使用双向链表而不是隐式空闲链表，使首次适配的分配时间从块总数的线性时间减少到了空闲块数量的线性时间。不过，释放一个块的时间可以是线性的，也可能是个常数，这取决于空闲链表中块的排序策略。
一种方法是用后进先出（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接口及其函数
8.2.1 Unix I/O接口：
根据8.1中描述的Unix I/O接口的概念，我们可以确定I/O接口需要有如下结构功能：
打开文件：一个应用程序通过要求内核打开相应的文件，来宣告它想要访问一个 I/O 设备，Linux shell 创建的每个进程开始时都有三个打开的文件：标准输入（描述符为0）、标准输出（描述符为1）和标准错误（描述符为2）。
改变当前文件的位置。对于每个打开的文件，内核保持着一个文件位置k，初始为0。
读写文件：一个读操作就是从文件复制n > 0个字符到内存，从当前文件位置k开始，然后k += n。对给定一个大小为m字节的文件，当k>=m时执行读操作会出发一个称为EOF的条件。
关闭文件：当应用完成了对文件的访问之后，它就通知内核关闭这个文件。
8.2.2 Unix I/O函数：
1、打开文件函数：int open(char *filename, int flags, mode_t mode);flag参数为写提供一些额外的指示，mode指定了访问权限。
2、关闭文件函数：int close(int fd);fd是打开文件时的返回值。
3、读文件函数：ssize_t read(int fd, void *buf, size_t n);
4、写文件函数：ssize_t write(int fd, const void *buf, size_t n);
8.3 printf的实现分析
首先来看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;
其中传递参数中的…表示不确定个数。
函数中的va_list实际上就是typedef后的char*。而va_list arg = (va_list)((char*)(&fmt) + 4);这句操作实际上就是得到了…中的第一个量。
之后我们调用vsprintf函数。vsprintf函数将我们需要输出的字符串格式化并把内容存放在buf中。并返回要输出的字符个数i。然后调用系统函数write来在屏幕上打印buf中的前i个字符，也就是我们要输出的格式串。
调用write系统函数后，程序进入到陷阱，系统调用 int 0x80或syscall等，通过字符驱动子程序打印我们的线性。
字符显示驱动子程序：从ASCII到字模库到显示vram（存储每一个点的RGB颜色信息）。
显示芯片按照刷新频率逐行读取vram，并通过信号线向液晶显示器传输每一个点（RGB分量）。
最后程序返回我们实际输出的字符数量i。
8.4 getchar的实现分析
getchar 的源代码为：
图 50 8.4-1
异步异常-键盘中断的处理：当用户按键时，键盘接口会得到一个代表该按键 的键盘扫描码，同时产生一个中断请求，中断请求抢占当前进程运行键盘中断子 程序，键盘中断子程序先从键盘接口取得该按键的扫描码，然后将该按键扫描码 转换成 ASCII 码，保存到系统的键盘缓冲区之中。
getchar 函数落实到底层调用了系统函数 read，通过系统调用 read 读取存储在 键盘缓冲区中的 ASCII 码直到读到回车符然后返回整个字串，getchar 进行封装， 大体逻辑是读取字符串的第一个字符然后返回。
8.5本章小结
本章主要介绍了 Linux 的 IO 设备管理方法、Unix IO 接口及其函数，分析了 printf 函数和 getchar 函数的实现。
结论
用计算机系统的语言，逐条总结hello所经历的过程。
编写： 通过编辑器输入hello.c的C语言代码
预处理：预处理器对hello.c处理生成hello.i文件
编译： 编译器编译hello.i将其转化成汇编语言描述的hello.s文件
汇编： 汇编器将hello.s文件翻译成可重定位文件hello.o
链接： 链接器将hello.o和其他目标文件进行链接，生成可执行文件hello
运行： 在shell中输入./hello 1170301004 wanghang，开始运行hello程序
创建新进程：shell为hello程序fork一个新进程
加载： 在新进程中调用execve函数，将hello程序映射到虚拟内存中
执行： 内核调度该进程执行，进行虚拟地址的翻译，此时会发生缺页，开始加载hello代码和数据到对应的物理页中，然后开始执行。
信号处理：在hello进程运行中，按下ctrl+z、ctrl+c等将会发送信号给hello，
进而调用信号处理程序进行处理。
终止： 输出完10遍对应的字符串后，执行getchar，等待用户输入，输 入字符按下回车后，hello进程终止。
回收： hello进程终止后发送SIGCHLD信号给shell，shell将其退出状态 进行回收，最后内核从系统中删除hello所有的信息
你对计算机系统的设计与实现的深切感悟，你的创新理念，如新的设计与实现方法。
计算机系统的设计和实现是一门抽象的艺术，从底层的二进制到处理器、内存、I/O设备，一直在强调和运用抽象的概念，将抽象运用到了极致，接触了计算机系统才真正知道，一个简单的hello程序从代码到实现需要经历如此繁杂的步骤，这其中凝聚的是多少代计算机人的智慧和付出。
附件
列出所有的中间产物的文件名，并予以说明起作用。
hello.c 源程序（文本）
hello.i 预处理之后的程序（文本）
hello.s 汇编语言程序（文本）
hello.o 可重定位目标程序（二进制）
hello 可执行目标程序（二进制）
参考文献
为完成本次大作业你翻阅的书籍与网站等
[1] 深入理解计算机系统（原书第3版）/（美）兰德尔·E.布莱恩特等著；龚奕利，贺莲译.
[2] https://www.cnblogs.com/diaohaiwei/p/5094959.html
[3] https://www.cnblogs.com/pianist/p/3315801.html
[4] https://blog.csdn.net/weixin_44819348/article/details/103772429
哈工大计算机系统2022年秋程序人生大作业
哈尔滨工业大学计算机系统
大作业
题 目 程序人生-Hello’s P2P
专 业 计算机科学与技术
学 号 2021112558
班 级 2103101
学 生 陈思达
指 导 教 师 刘宏伟
计算机科学与技术学院
2022年5月
本论文主要介绍了从最开始编写的C语言源文件hello.c逐步生成hello可执行文件的过程，重点分析了计算机体系在生成hello可执行文件的预处理、编译、汇编、链接、进程管理几个阶段。通过理论与实际操作相结合的方式，生动形象的展示了上述的流程。
关键词：计算机科学技术，计算机操作系统，计算机底层原理
目 录
6.2 简述壳Shell-bash的作用与处理流程 - 10 -
第1章 概述
1.1 Hello简介
P2P过程：
P2P既是From Program to Process的简写，hello.c这个C语言源文件先经过预处理器处理生成hello.i，再经过编译器处理生成汇编程序hello.s，然后经过汇编器as处理生成可重定位目标程序hello.o，最后通过链接器ld链接生成可执行文件hello。
O2O过程：
O2O既是From Zero-0 to Zero-0的简写，输入执行hello的命令后，shell通过execve和fork创建子进程并将hello载入，映射虚拟内存，进入程序入口后将程序载入物理内存，开始执行hello的代码。程序运行完成后，shell回收子进程，内核清除数据痕迹。一切归零。
1.2 环境与工具
硬件环境：AMD Ryzen 7 5800H with Radeon Graphics 3.20 GH
16.0 GB RAM
软件环境：VMware Ubuntu
开发与调试工具：Vim objump gdb edb gcc readelf等工具
1.3 中间结果
hello.i 预处理文件,由预处理器预处理C语言源文件得到，是对C语言源文件的#include,#define等对编译器命令进行解释生成的。
hello.s 汇编语言文件，都编译器处理C语言源文件得到，是C语言代码对应的汇编语言形式。
hello.o 可重定位文件，都汇编器翻译汇编语言文件得到，是C语言代码对应的二进制机器语言形式。
hello 可执行文件,对hello.c源文件进行编译的最终结果。
1.4 本章小结
本章介绍了hello的P2P,O2O过程，介绍了本实验的硬件环境、软件环境、开发工具以及本实验中生成的中间结果文件的名字和作用。
第2章 预处理
2.1 预处理的概念与作用
基本概念：
预处理一般是指在程序源代码被翻译为目标代码的过程中，生成二进制代码之前。典型地，由预处理器对程序源代码文本进行处理，得到的结果再由编译器核心进一步编译。
作用：
预处理过程并不对程序的源代码进行解析，但它把源代码分割或处理成为特定的单位--预处理记号用来支持语言特性。预处理的功能可以分为宏定义，文件包含，条件编译三方面,由预处理器解析宏定义命令、文件包含命令、条件编译命令。为进一步编译提供准备文件。
2.2在Ubuntu下预处理的命令
预处理指令为：gcc -E hello.c -o hello.i
2.3 Hello的预处理结果解析
在对hello.c文件进行预处理之后，使用VIM预览预处理得到的hello.i文件，发现，代码行数惊人的多，从之前hello.c的几十行扩展到3000行
预处理器主要对源代码做了以下两个工作，代码的替换与增添，代码的删除。
代码的替换与增添：预处理器将源代码中的#include,#define等命令，解释替换成相应的代码。如上图中可以发现源代码中的#include已经被替换成1026 ”/usr/include/stdlib.h” 3 4等命令 。在对代码进行替换的同时，也增加了大量的函数声明，外部变量声明，typedef等定义,这都是为了之后进一步生成可执行程序做的准备工作。
代码的删除：主要是删除了注释等于生成程序无用的信息。
2.4 本章小结
本章主要介绍了预处理的概念，功能和机制。展示了对hello.c文件进行预处理的操作和预处理得到的结果。并对hello.c预处理的结果进行了分析。
第3章 编译
3.1 编译的概念与作用
概念：将编程语言翻译成汇编语言的过程。
作用：将预处理后的程序翻译成汇编语言程序，为不同高级语言的不同编译器提供了通用的输出语言。
3.2 在Ubuntu下编译的命令
编译指令为：gcc -Og -S hello.c
3.3 Hello的编译结果解析
在对hello.c文件进行编译之后，使用VIM预览预处理得到的hello.s文件。
数据：
hello.c中的数据只有字符串和局部变量
字符串：
在源代码文件中的字符串一共有两条：1."用法: Hello 学号 姓名 秒数！\\n"2."Hello %s %s\\n"
在.s文件中，中文字符被转换成了UTF-8码而英文字符保持不变
局部变量：
局部变量都被保存在寄存器或栈中。
赋值操作：
对变量的赋值使用MOV指令，如:
对hello.c中的i赋初值，次数i被保存在寄存器%rbx中
算数操作：
在hello.c中用到了一种算数操作：+操作
这里是对局部变量i进行加一操作。可以发现，在汇编语言中使用的是addl指令
关系操作：
hello.c中的两个逻辑操作：1.argc!=4 2.i<9
进行这两个逻辑操作时需要使用cmpl指令
- 判断argc是否等于4
此时argc变量被保存在寄存器%edi中
- 判断i是否小于9
此时i变量被保存在寄存器%ebx中
控制转移：
1.
如果argc不等于4就进入if语句块内部，如果等于就跳过if语句块
2.
这是循环的控制转移操作部分，如果i<=8就再一次跳转到循环开始位置
函数操作：
printf函数的调用：
第一个printf函数：
将该printf的字符串的其实位置作为参数传递给printf函数
第二个printf函数：
第一个参数：%rdi中存放的格式控制参数
第二个参数：%rsi中存放着这个printf函数的格式串的地址
第三个参数：因为%rbp中保存的是argv的地址，所以%rdx中存放着argv[1]
第四个参数：%rcx中存放着argv[2]
atoi函数的调用：
第一个参数被保存在%rdi中，是argv[3]
返回值保存在%rax中
sleep函数的调用：
第一个参数%rdi中保存的是 atoi函数的返回值
getchar函数的调用：
getchar函数从标注输入流得到参数
3.4 本章小结
介绍了编译的概念和作用，介绍了生成.s文件的操作，并结合hello.s文件，分析了C语言的各种数据与操作在汇编语言中的表现形式。
第4章 汇编
4.1 汇编的概念与作用
汇编的概念：汇编器将.s文件中的汇编语言翻译成二进制机器语言并生成可重定位文件。
汇编的作用：将汇编语言转换成二进制的机器语言。
4.2 在Ubuntu下汇编的命令
汇编指令为：gcc -Og -c hello.c
4.3 可重定位目标elf格式
ELF头
ELF头描述了文件的整体格式
节头部表
节头部表指示了各个节的大小和信息。
.rela.txt节
是一个.txt节中位置的列表，指示了当链接器要把这个目标文件和其他文件组合时，需要修改的位置。一般来说，任何调用外部函数或应用全局变量的指令都需要修改。可以发现在这节中的类型有两种R_X86_64_PC32和R_X86_64_PLT32，其中R_X86_64_PC32就是深入理解计算机系统书上的PC相对跳转，而R_X86_64_PLT32是一个新的函数入口表，书上并没有涉及。
.symtab节
符号表指示了符号的名字，地址，目标的大小，类型，对应的节。
在这个符号表中，我们可以发现，在hello.c中引用的函数，都被包含在了表中，它们分别对应这一个name，如printf()函数对应着__printf_chk，它们的类型都是全局符号。在这个符号表中，可以发现只有main这个符号的size是大于零的，这是因为，只有main是本地符号，是被声明并被定义在这个文件中的函数，而别的函数都只是仅仅被引用，实际的声明和定义并不咋这个文件中，所以并不占用大小。
4.4 Hello.o的结果解析
与hello.s文件与hello.o文件的差异：
- hello.o文件的反汇编明显多出了二进制的机器代码部分。汇编语言是面向机器的程序设计语言，它是为了解决机器语言难以理解和记忆的缺点，用易于理解和记忆的名称和符号表示机器指令中的操作码，这样用符号代替机器语言的二进制码，就把机器语言变成了汇编语言。而机器语言是一种指令集的体系，它是用二进制代码表示的语言，是计算机唯一可以直接识别和执行的语言，它具有计算机可以直接执行、简洁、运算速度快等优点，但它的直观性差，非常容易出错，程序的检查和调试都比较困难，此外对机器的依赖型也很强。
- hello.s文件中的call和jump分别对应着相对的函数名和标签名，而在hello.o文件的反汇编中call和jump都对应着一个相对位置，而在对应的二进制机器语言中则都是0x0这是因为hello.o文件还没有经过重定位,相对位置还不能确定,这些地址在经过链接器的处理后才能确定。
4.5 本章小结
在本章中介绍了汇编的概念和应用，介绍了生成.o文件的操作，使用readelf和objdump工具对生成的hello.o文件进行了分析，展示并分析了可重定位目标elf格式和hello.o的反汇编结果。
第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
5.3 可执行目标文件hello的格式
ELF头：
入口起始地址：0x400570 大小64字节
节头部表：
起始地址：0x19e8 一共有29节
符号表：
程序中的全局变量和引用的函数
5.4 链接的重定位过程分析
反汇编结果如下：
hello与hello.c对比：
1.发现hello代码的长度较hello.o大大增加了，这是因为在链接的过程中加入了printf等函数的代码。
2.在链接后hello的call，jmp等指令都拥有了一个确定的值，而hello.o中则全为0x0，这是因为链接器对hello.o进行了重定位。
重定位的原理：
objdump -d -r hello 分析hello与hello.o的不同，说明链接的过程。
结合hello.o的重定位项目，分析hello中对其怎么重定位的。
5.5 hello的执行流程
//call main
5.6 Hello的动态链接分析
在节头部表中找到该节，标注为DYNAMIC
5.7 本章小结
本章分析了链接的过程，通过edb查看hello程序的相关信息，对比hello与hello.o的反汇编代码，分析了链接的过程中重定位的过程和作用。
第6章 hello进程管理
6.1 进程的概念与作用
进程的概念：进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。是一个执行中程序的实例，是操作系统对一个正在运行的程序的抽象。
进程的作用：一个程序在系统上运行时，操作系统会提供一种程序在独占这个系统，包括处理器，主存，I/O设备的假象。处理器看上去在不间断地一条一条执行程序中的指令。
6.2 简述壳Shell-bash的作用与处理流程
Shell-bash的作用：
Linux系统中，Shell是一个交互型应用级程序，代表用户运行其他程序，是一个命令行解释器，以用户态方式运行的终端进程，其基本功能是解释并运行用户的指令。
处理流程：shell会重复如下处理过程
(1)终端进程读取用户由键盘输入的命令行。
(2)分析命令行字符串，获取命令行参数，并构造传递给execve的argv向量。
(3)检查第一个(首个、第0个）命令行参数是否是一个内置的shell命令。
(3)如果不是内部命令，调用fork( )创建新进程/子进程。
(4)在子进程中，用步骤2获取的参数，调用execve( )执行指定程序。
(5)如果用户没要求后台运行(命令末尾没有&号）否则shell使用waitpid（或wait...)等待作业终止后返回。
(6)如果用户要求后台运行(如果命令末尾有&号），则shell返回。
6.3 Hello的fork进程创建过程
用户在键盘上键入“./hello 学号 姓名 秒数”这一字符串,shall读取到从键盘输入的命令行，shell首先对这个命令行进行分割构造出argv向量，shall对argv[0]进行解释,发现这不是一个shell的内置命令,于是shell使用fork()函数创建一个子进程。
6.4 Hello的execve过程
在shell使用fork()函数创建出一个子进程之后，这个子进程使用execvc()函数将命令对应的可执行文件加载入这个进程，并同时将构造好的argv向量和envp向量传递给execve()函数来加载程序。在程序头部表的引导下，加载器将可执行文件的片复制到代码段和数据段，之后，加载器跳转到程序的入口：入口函数的地址。入口函数调用系统启动函数，之后初始化环境，调用用户层的main函数，处理main函数返回值，并且在需要的时候返回给内核。
6.5 Hello的进程执行
hello进程的上下文信息：
hello的进程上下文是hello进程正常运行所需要的信息，主要包含以下几种信息：hello进程存放在内存中的代码和数据，hello的栈,通用寄存器，程序计数器，环境变量和打开文件描述符的集合。
hello的进程时间片：
当hello进程在运行状态时，操作系统会为hello进程分配一个时间片，在这个时间片里,CPU执行hello进程的命令,当hello进程的时间片结束之后，操作系统会将控制从hello进程中收回,运行其他进程，然后再将控制交给hello进程，如此循环往复直到hello进程执行完毕。
hello的进程调度过程：
在执行过程中，内核可以决定抢占当前进程，并重新开始一个先前被抢占的进程，这个决策称为调度。调度的过程是由调度器完成的，当内核调度新的进程运行后，它就会抢占当前进程，并保存以前进程的上下文，然后恢复新进程被保存的上下文最后将控制传递给这个新恢复的进程，来完成上下文切换。
6.6 hello的异常与信号处理
hello执行过程中会出现的异常
1.中断：运行 hello 程序时，外部 I/O 设备可能出现异常,如键盘的输入等。
2.陷阱：运行hello程序时调用sleep()函数时会出现陷阱。
hello执行过程中会出现的信号：
- SIGCHILD信号
当hello进程结束时，会向父进程发送一个SIGCHILD信号
- SIGINT信号
当键盘输入CTRL+C时，操作系统会向hello发送SIGINT信号。
- SIGTSTP信号
当键盘输入CTRL+Z时，操作系统会向hello发送SIGTSTP信号。
4.其他等等类型的信号
在hello运行时按ctrl+c：
hello进程直接终止
在hello运行时按ctrl+z：
发现hello进程被挂起并被移入后台
在hello运行时乱按键盘：
乱按键盘不影响hello进程的运行
在hello进程被挂起后重新移入前台执行：
6.7本章小结
介绍了进程的概念与作用，简述了Shell的作用与处理流程，结合hello程序介绍了进程的异常与信号处理。
结论
在用hello.c源程序生成并运行hello可执行文件的过程中，主要有以下几个流程：
1.预处理器解释hello.c中的#include,#define等命令，并删除无关的信息，生成hello.i文件。
2.编译器将经过预处理的C语言文件翻译成汇编语言文件，生成hello.s文件。
3.汇编器将汇编语言文件翻译成二进制的可重定位文件，生成hello.o文件。
4.链接器将hello.o文件与其他必要的可重定位文件链接到一起，为每个需要进行重定位的符号分配地址，生成hello可执行文件。
5.bash创建新进程并将hello可执行文件加载入这个进程中，从而hello可执行程序开始运行。
计算机系统无比的复杂繁琐，若想对每个微操作都了如指掌真可谓是天方夜谭，但是如果我们使用抽象的方法来了解这个复杂的系统，难度就会大大的减少。我们可以发现，计算机系统在设计和运行时也大量的采用了抽象的方法，如指令集架构和进程的概念，都是对复杂流程的抽象化解释。若是在理解计算机系统时掌握了抽象的方法，那我们的学习就会事半功倍。
附件
hello.c C语言源文件
hello.i 预处理文件,由预处理器预处理C语言源文件得到，是对C语言源文件的#include,#define等对编译器命令进行解释生成的。
hello.s 汇编语言文件，都编译器处理C语言源文件得到，是C语言代码对应的汇编语言形式。
hello.o 可重定位文件，都汇编器翻译汇编语言文件得到，是C语言代码对应的二进制机器语言形式。
hello 可执行文件,对hello.c源文件进行编译的最终结果。
参考文献
- [S]ISO/IEC(E) 9899:2011
- C语言程序设计
- Computer Systems:A Programmer's Perspective Bryant,R.E..
- C语言编译全过程介绍 – 百度文库
以上是关于哈工大2022计算机系统大作业“程序人生”的主要内容，如果未能解决你的问题，请参考以下文章
2022春哈工大ICS大作业——程序人生-hello‘sP2P