程序人生HIT计算机系统大作业——Hello的自白

Posted 2023-04-06 是咸咸咸鱼

摘  要

本论文通过简单的hello.c程序为例，围绕一个程序从编写到运行的生命过程进行展开讲解。从C语言文件到可执行文件，论文详细介绍了预处理、编译、汇编、链接的过程，在Shell中创建进程并加载hello可执行程序，并对执行过程中的存储管理以及I/O管理进行了探究。以《深入理解计算机系统》的授课内容为主线，进行了知识的回顾与应用。

关键词：深入理解计算机系统；编译；汇编；链接；存储；进程；I/O      

第1章 概述

1.1 Hello简介

1.2 环境与工具

1.3 中间结果

1.4 本章小结

第2章 预处理

2.1 预处理的概念与作用

2.2在Ubuntu下预处理的命令

2.3 Hello的预处理结果解析

2.4 本章小结

第3章 编译

3.1 编译的概念与作用

3.2 在Ubuntu下编译的命令

3.3 Hello的编译结果解析

3.4 本章小结

第4章 汇编

4.1 汇编的概念与作用

4.2 在Ubuntu下汇编的命令

4.3 可重定位目标elf格式

4.4 Hello.o的结果解析

4.5 本章小结

第5章 链接

5.1 链接的概念与作用

5.2 在Ubuntu下链接的命令

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

5.4 hello的虚拟地址空间

5.5 链接的重定位过程分析

5.6 hello的执行流程

5.7 Hello的动态链接分析

5.8 本章小结

6.1 进程的概念与作用

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

6.3 Hello的fork进程创建过程

6.4 Hello的execve过程

6.5 Hello的进程执行

6.6 hello的异常与信号处理

6.7本章小结

第7章 hello的存储管理

7.1 hello的存储器地址空间

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

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

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

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

7.6 hello进程fork时的内存映射

7.7 hello进程execve时的内存映射

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

7.9动态存储分配管理

7.10本章小结

第8章 hello的IO管理

8.1 Linux的IO设备管理方法

8.2 简述Unix IO接口及其函数

8.3 printf的实现分析

8.4 getchar的实现分析

8.5本章小结

结论

附件

参考文献

第1章 概述

1.1 Hello简介

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

Program to progress：首先将写好的C语言源程序保存为hello.c文件（program)，通过预处理器cpp处理生成hello.i文件，此时仍为文本文件，通常为ASCII码表示的文本文件，然后通过编译器ccl生成汇编文件hello.s此时文件变成了机器级语言程序，经过编译器处理后生成了可重定位目标程序hello.o此时变为了二进制文件，最后hello.o以及静态库中的printf.o在链接器ld作用下生成可执行目标程序hello，接下来在bash中运行该程序，bash将为其创建一个进程，成为了progress.

0 to 0: 在bash中输入./hello运行hello程序，bash通过调用fork()创建子进程，同时在子进程中调用execve()函数，加载hello程序，CPU为运行的hello程序分配时间片并执行逻辑控制流。当程序执行结束后bash回收进程，释放内存，并删除与运行hello程序有关的数据结构，一切重新变为0，即为0 to 0.

1.2 环境与工具

列出你为编写本论文，折腾Hello的整个过程中，使用的软硬件环境，以及开发与调试工具。

硬件：基于 X64 的处理器，64 位操作系统，2.9GHZ，16GRAM，512GDisk；

软件：Windows10 64 位，VMWare 16，Ubuntu 16.04;

工具：gcc, vim/vi, edb;

1.3 中间结果

列出你为编写本论文，生成的中间结果文件的名字，文件的作用等。

文件名	功能
hello.i	预处理后得到的文本文件
hello.s	编译后得到的汇编语言文件
hello.o	汇编后得到的可重定位目标文件
hello.elf	用readelf读取hello.o得到的ELF格式信息
helloasm.txt	反汇编hello.o得到的反汇编文件
helloout.txt	由hello可执行文件生成的.elf文件
helloasm2.txt	反汇编hello可执行文件得到的反汇编文件

1.4 本章小结

本章是大作业的简介性质的章节，主要介绍了此次大作业大致的流程以及所需要的硬件，软件环境以及所需要的工具，并列出了最终大作业所得到的文件。

第2章 预处理

2.1 预处理的概念与作用

概念：预处理器根据以字符#开头的命令，修改原始的C程序。比如hello.c中第一行的#include<stdio.h>命令告诉预处理器读取系统头文件stdio.h的内容，并把它直接插入程序文本中。结果就得到了另一个C程序，通常是以.i作为文件扩展名。

作用：通过预处理命令，可以通过添加头文件和宏定义等方法，调用包含在头文件中已经编写好的函数，大大提高了编写程序的效率，增大了代码的简洁程度。通常使用预处理器实现的功能有：

1. 文件包含：#include把指令所指的文件内容包含到当前文件中；
2. 条件编译：#if, #endif等为进行编译时有选择的挑选，注释掉一些指定代码；
3. 布局控制：#pragma设定编译器的状态或指示编译器完成一些特定的动作；
4. 宏替换：#define, 可以实现定义符号常量、重新命名等功能。

2.2在Ubuntu下预处理的命令

应截图，展示预处理过程！cpp hello.c >hello.i

2.3 Hello的预处理结果解析

经过预处理后，与源程序进行对比，可以发现原本的头文件全都被替换为了其原本的文件内容，hello.c中的main函数出现在hello.i的3047行的位置。同时源文件中所有的注释都被删除了，查看添加进hello.i的代码中不再出现#include #if等预处理指令，均已通过预处理去掉。

2.4 本章小结

本章进行的是hello.c文件的预处理过程，是hello.c的一生的第一步，预处理工作虽然看起来有些繁杂，但是可以说正是艰难的第一步才保证了平稳的第二步，第三步......同时也正是预处理，解放了编程的效率，让程序员们不再需要每一次编程都要手动编写复杂的代码。

第3章 编译

3.1 编译的概念与作用

注意：这儿的编译是指从 .i 到 .s 即预处理后的文件到生成汇编语言程序

概念：编译将用某种编程语言写成的源代码，转换成另一种编程语言。通常会将便于人编写、阅读、维护的高级程序语言编写的源程序翻译为计算机能够解读并运行的低阶机器语言的程序，也是将代码所构成的文本文件重新编译为计算机可执行的二进制文件的程序。

作用：将高级程序语言翻译为低级机器语言，使计算机可以理解和执行。

3.2 在Ubuntu下编译的命令

应截图，展示编译过程！

3.3 Hello的编译结果解析

此部分是重点，说明编译器是怎么处理C语言的各个数据类型以及各类操作的。应分3.3.1~ 3.3.x等按照类型和操作进行分析，只要hello.s中出现的属于大作业PPT中P4给出的参考C数据与操作，都应解析。

经分析源文件可知，hello.c中包含的操作有：数据，赋值，算术操作，关系操作，数组/指针/结构操作，控制转移以及函数操作。

3.3.1 汇编指示

 

.file 源文件

.text 代码段

.align 对齐格式

.section .rodata 只读代码段

.String 字符串类型数据

.global 全局变量

.type 符号类型

3.3.2 数据

对于数据操作，hello.c中包含了常量，局部变量，全局变量三种。

        1. 常量：hello.s中所有的常量均以立即数表示，记录为$x(x为数字).

下图中0和4均为常量

        2. 局部变量：hello.s中的局部变量一般与赋值操作一同出现

下图中将立即数0存至%rbp-4对应的栈地址中，联系hello.c中的代码可知，此处的操作应为赋值0给局部变量i.

下图中两个赋值操作将参数保存为函数内的局部变量，并存在栈中。

 

        3. 全局变量：本程序中全局变量只有一个，即main函数，由.global可知

3.3.3赋值

在本程序中只有=赋值过程

(1) 下图中为将传入的参数存入栈中，其中rdi保存的是源程序中的argc变量，rsi保存的是argv的地址，由cmpl一行可以印证。

 ​​​​​​​

(2) 下图为for()循环中，为i赋初值0的代码，其中栈地址rbp-4处保存迭代变量i.

3.3.4 算数操作

下图为for()循环中每次循环i+1的加法计算

 

3.3.5 关系操作

        1. !=

在hello.s中，不等关系被相等关系所表达，源程序中如果参数argc参数不为4则执行操作的代码在汇编语言中变为：如果argc参数为4则跳转到循环操作，不再执行括号内的操作，与原本的语义等价。

 

•         2. <  

在hello.s中，存在判断小于关系的操作，在源程序中表示为for()循环中的边界条件判断。在汇编语言中表示为i与立即数7的比较，如果i小于等于7则返回循环，否则进行下一步。

 

3.3.5 数组/指针/结构操作

源程序中并没有进行结构操作，但是参数传递过传递了指针数组，并且字符串的保存也使用了数组操作。将rsi中保存的64位指针数组的首地址存入栈中。

加载字符串指针数组首地址至寄存器rax, 并将寄存器进行+8操作--栈地址指向指针数组中的第二个指针元素，并将该指针的值放入寄存器rsi, 准备在printf函数中进行调用，对应打印局部变量argv[1]，argv[2]. 同理可以得到argv[3]的访问过程。

 

3.3.6 控制转移

        1.if判断

对于argc!=4的判断，使用cmpl语句进行判断，等于4直接进行跳转，不等于4是才进行括号内语句的运行。

        2. for循环

在hello.s文件中，对于for语句的翻译，采用jmp等跳转语句来实现，当为满足i>7的跳出循环的条件时，使用jle语句，跳转到循环的开始进行新一轮的迭代。

 

3.3.7 函数操作

• 参数传递
• hello.c中main函数传递了int argc, 以及字符串指针数组char* argv[]，在汇编代码中就是两个寄存器的值存入栈中，即前面所提到的寄存器edi和rsi, rsi保存的是字符串指针数组的首地址。
• 函数调用
• hello.c程序中使用了很多的函数，包括sleep, printf, atoi等，这些函数的调用都是通过call指令来实现的。

• 3.4 本章小结

  通过对hello.c进行编译可以得到汇编语言文件hello.s，通过查看汇编指令并查阅源程序中的代码，可以了解到编译器是如何理解一个程序，并把诸多比较复杂的数据结构表达成更为低级的汇编语言。

• 第4章 汇编

  4.1 汇编的概念与作用

  注意：这儿的汇编是指从 .s 到 .o 即编译后的文件到生成机器语言二进制程序的过程。

  概念：使用汇编器（as）把生成的汇编指令逐条翻译成机器可以识别的形式，即机器码。

  作用：将文本文件hello.s翻译成机器码，并将指令打包成可重定位目标程序的二进制文件，生成hello.o

  4.2 在Ubuntu下汇编的命令

  gcc -m64 -no-pie -fno-PIC -o hello.o hello.s

• 

  • 4.3 可重定位目标elf格式

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

    ​​​​​​​​​​​​​​        1. ELF头

• 以16字节序列魔数开始，描述了生成该文件的系统的字的大小和字节顺序，ELF头剩下的部分包含帮助链接器进行符号解析以及解释可重定位目标程序的相关信息，其中包含了ELF头大小，目标文件类型，OS类型，节头表的偏移以及节头表中条目的大小和数量等相关信息。

  • ​​​​​​​

    

            2. 节头

• 包含了文件中出现的各个节的意义，包括节的类型、位置和大小等信息。

  •         3. 重定位节 .rela .text

    • 偏移量：表示需要进行重定向的代码在.text或.data节中的偏移位置
    • 信息：包括symbol和type两部分，其中symbol占前半部分，tyoe占后半部分，symbol代表重定位到的目标在.symtab中的偏移量，type代表重定位的类型
    • 类型：表示重定位的入口的类型
    • 加数：计算重定位位置的辅助信息

• 包含信息如下：

  • 

  • 4.4 Hello.o的结果解析

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

  • 对比生成的hello.s中的汇编代码，可以看出其中跳转语句原本的label在反汇编后变为了相对偏移地址，即目标指令地址与即将执行的下一条指令之间的差值。
  • 在函数调用过程中，hello.s文件表示为直接call对应的函数名，而在反汇编的到的机器码文件中可以看到call的目标地址是当前指令的下一条指令。这是由于可重定位目标程序尚未经过链接器的处理，调用的函数并不实际存在于实际程序中，需要进一步调用共享库利用连接器才可以具体实现。对于不确定地址的函数调用，在编译过程中计算机会将地址全部设置为0，即指向当前指令的下一条指令，并将该函数名加入符号表中，并在.rela.text中添加重定位条目，等待进一步的静态链接。
  • 对于变量的访问，在hello.s文件中使用rip+段名称的方式访问了printf中的字符串，而对反汇编文件中此处的调用则是使用了rip+0x0的方式，原理同函数调用一样，机器尚未对程序进行符号解析，需要先放入重定位条目中，等待之后对变量进行重新定位并写入。
  • 
  • 
  • ​​​​​​​

4.5 本章小结

本章主要对由hello.s编译的hello.o--可重定位目标程序及其反汇编文件进行了分析，查阅了ELF头和各节头表信息，并查看了反汇编后的机器码，于hello.s的汇编代码进行了比较，发现了二者的差异，了解了编译过程的主要作用。

第5章 链接

5.1 链接的概念与作用

注意：这儿的链接是指从 hello.o 到hello生成过程。

概念：链接时奖各种代码和数据片段手机并组合成一个单一文件的过程，这个文件可被加载(复制)到内存并执行。链接可以执行于编译时，也就是在源代码被编译成机器代码时；也可以执行于加载时，也就是在程序被加载器加载到内存并执行时；甚至执行于运行时，也就是由应用程序来执行。在现代系统中，链接由链接器来自动执行。连接完成后将生成一个完全链接的可执行的目标文件（windows下文件扩展名.exe,linux下一般省略后缀名）

作用：提供了一种模块化的方式，可以将程序编写为一个较小的源文件的集合，且实现了分开编译更改源文件，从而减少整体文件的复杂度与大小，增加容错性，也方便对某一模块进行针对性修改。链接器（ld)将hello.o文件于C标准库函数的可重定位文件进行合并，生成一个可执行的.out文件。

5.2 在Ubuntu下链接的命令

使用ld的链接命令，应截图，展示汇编过程！ 注意不只连接hello.o文件

ld  -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 /usr/lib/gcc/x86_64-linux-gnu/9/crtbegin.o hello.o -lc /usr/lib/gcc/x86_64-linux-gnu/9/crtend.o /usr/lib/x86_64-linux-gnu/crtn.o -z relro -o hello.out

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

分析hello的ELF格式，用readelf等列出其各段的基本信息，包括各段的起始地址，大小等信息。

1.ELF头

2. 节头表

3. 程序头 

 程序头部分是一个结构体数组，描述了系统准备程序执行所需要的信息，如加载类型，偏移量，虚拟地址以及物理地址等。

• 

• 4. 动态段

  

• 5. 符号表

   符号表中给保存着定位以及重定位程序时符号的定义和引用信息，所有在重定位中需要使用的symbol都需要在其中进行声明。

• • 5.4 hello的虚拟地址空间

    使用edb加载hello，查看本进程的虚拟地址空间各段信息，并与5.3对照分析说明。

    由于操作系统特性，0x000000~0x400000为逻辑地址，虚拟地址空间从0x400000开始，包括ELF头，程序头部表等载入在0x400000~0x401000中。可以观察到魔数即为第一行的数据。

  • 5.5 链接的重定位过程分析

    objdump -d -r hello 分析hello与hello.o的不同，说明链接的过程。

    结合hello.o的重定位项目，分析hello中对其怎么重定位的。

  • hello反汇编后，最直观的变化即每一行代码的序号不再是从0开始，而是有了具体的地址，这是由于重定位后链接器为程序指定了虚拟内存地址，而不再是原本的相对偏移量。
  • 函数调用指令call的参数发生变化。在链接过程中，链接器解析了重定位条目，call之后的字节代码被链接器直接修改为目标地址与下一条指令的地址之差，指向相应的代码段，从而得到完整的反汇编代码。重定位的简单规则如下：

  • 

  •  以调用函数puts为例，上图为可重定位目标程序中的反汇编代码，下图是可执行文件的反汇编代码。可以看出在可执行文件反汇编代码中，puts@plt函数名地址为0x401090, 由小端法可知fffffe95即-16b, 由此计算可得下一条指令0x4011fb减去相对偏移量即可得到实际函数的虚拟地址。

     

     

  • 增加了.plt节和.init节。相比较原本的汇编代码，增加了puts@plt, sleep@plt等函数，这是因为动态链接器讲共享库中的hello.c用到的函数加入进了可执行文件中。
  • 

• 5.6 hello的执行流程

  使用edb执行hello，说明从加载hello到_start，到call main,以及程序终止的所有过程。请列出其调用与跳转的各个子程序名或程序地址。

  使用edb单步调试运行程序，观察其调用的函数,这里可以发现在调用main之前主要进行了初始化的工作调用了_init，在这个函数之后动态链接的重定位工作已经完成，我们可以看到在这个函数的调用之后是一系列在这个程序中所用到的库函数（printf，exit，atoi等等）这些函数实际上在代码段并不占用实际的空间只是一个占位的符号，实际上他们的内容在共享区（高地址）处。之后调用了_start这个就是起始的地址，准备开始执行main的内容。

  下面列出了各个函数的名称与地址（部分函数）

• 
• 

• 5.7 Hello的动态链接分析

  分析hello程序的动态链接项目，通过edb调试，分析在dl_init前后，这些项目的内容变化。要截图标识说明。

  编译器没有办法预测函数的运行时地址，所以需要添加重定位记录，等待动态链接器处理，为避免运行时修改调用模块的代码段，链接器采用延迟绑定的策略。动态链接器使用过程链接表PLT+全局偏移量表GOT实现函数的动态链接，在GOT中存放函数目标地址，PLT使用GOT中地址跳转到目标函数，在加载时，动态链接器会重定位GOT中的每个条目，使得它包含目标的正确的绝对地址。

• 

• 根据节头表中给出的偏移地址可以看到.got和.got.plt段位置在0x403ff0和0x404000处, 即可在data dump中观察数据的变化。

• 

  观察可得：

  调用dl_init前后：

  下图依次为.got和.got.plt

• 

  
  

   

• 

   对比调用前后，可以说明hello程序已经动态链接了共享库。

5.8 本章小结

本章介绍了链接的概念和作用，并且读取了可执行文件hello的ELF格式文本，与可重定位目标程序的ELF头等信息进行了比较，探究了链接的过程以及重定位的原理。之后又比较了可重定位目标程序以及可执行文件的反汇编代码，分析了二者的区别，进一步加深了对于重定位以及动态链接的理解。

第6章 hello进程管理

6.1 进程的概念与作用

概念：指程序的依次运行过程。更确切说，进程是具有独立功能的一个程序关于某个数据集合的依次运行活动，进而进程具有动态含义。同一个程序处理不同的数据就是不同的进程。

作用：给应用程序提供两个关键抽象——

1. 一个独立的逻辑控制流，提供一个假象，好像程序独占地使用处理器
2. 一个私有地址空间，提供一个假象，好像程序独占地使用内存系统

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

shell 是一个用 C 语言编写的程序，它是用户使用 Linux 的桥梁。

1. Shell 既是一种命令语言，又是一种程序设计语言。Shell 是指一种应用程序，这个应用程序提供了一个界面，用户通过这个界面访问 Linux 内核的服务。

1. 作用：shell是一个命令解释器，它解释由用户输入的命令并且把它们送到内核。不仅如此，shell有自己的编程语言用于对命令的编辑，它允许用户编写由shell命令组成的程序。shell编程语言具有普通编程语言的很多特点，比如它也有循环结构和分支控制结构等，用这种编程语言编写的shell程序与其他应用程序具有同样的效果.
2. 处理流程：shell首先检查命令是否是内部命令，若不是则再检查是否是一个应用程序（这里的应用程序可以是Linux本身的实用程序，如ls和rm，也可以是购买的商业程序，如xv，或者是自由软件，如emacs）。然后shell在搜索路径里寻找这些应用程序（搜索路径就是一个能找到可执行程序的目录列表）。如果键入的命令不是一个内部命令并且在路径里没有找到这个可执行文件，将会显示一条错误信息。如果能够成功找到命令，该内部命令或应用程序将被分解为系统调用并传给Linux内核

6.3 Hello的fork进程创建过程

打开Shell, 输入参数./hello 刘雨尘 120L021809，带参数执行hello程序。

fork进程创建过程：首先，带参执行当前目录下的可执行文件hello，父进程会通过fork函数创建一个新的运行的子进程hello。子进程获取了与父进程的上下文，包括栈、通用寄存器、程序计数器，环境变量和打开的文件相同的一份副本。子进程与父进程的最大区别是有着跟父进程不一样的PID，子进程可以读取父进程打开的任何文件。当子进程运行结束时，父进程如果仍然存在，则执行对子进程的回收，否则就由init进程回收子进程。

6.4 Hello的execve过程

execve函数加载并运行一个可执行目标文件，这里是hello，而且带参数列表argv[]和环境变量列表envp[]，只有当找不到可执行目标文件时才会但回到调用程序，否则execve函数会将控制转移到新的可执行文件去执行，与fork函数调用一次返回两次不同，execve函数调用一次从不返回。

调用函数fork创建新的子进程之后，子进程会调用execve函数，在当前进程的上下文中加载并运行一个新程序hello。它将删除该进程的代码和地址空间内的内容并将其初始化，然后通过跳转到程序的第一条指令或入口点来运行该程序。将私有的区域映射进来，例如打开的文件，代码、数据段，然后将公共的区域映射进来。后面加载器跳转到程序的入口点，即设置PC指向_start 地址。_start函数最终调用hello中的 main 函数，这样，便完成了在子进程中的加载。

下图概括了私有区域的不同映射：

 

6.5 Hello的进程执行

用户向Shell输入可执行目标文件hello及其参数，运行程序时，Shell首先会调用fork函数创建一个新的子进程，然后在这个新进程的上下文中调用execve函数加载可执行目标文件hello。

hello进程将提供两个关键的抽象——

1. 一个独立的逻辑控制流，好像我们的程序独占地使用处理器。
2. 一个私有的地址空间，好像我们的程序独占地使用内存系统。

而时间片，则被表述为多个逻辑控制流重叠时又称并发运行时，由于多个进程之间轮流运行导致产生的逻辑流分段，也即多任务或时间分片。

对于用户模式和内核模式，设置模式位时，进程运行在内核模式，内核模式下的进程能够执行指令集中的任何指令，并且可以访问系统中任何内存位置。没有设置模式位时，进程就运行在用户模式中，用户模式下的进程不允许执行特权指令，也不允许用户模式中的进程直接引用地址空间中内核区内的代码和数据。

对于上下文切换，操作系统内核使用上下文切换来实现多任务。内核为每个进程维持一个上下文。上下文就是内核重新启动先前一个被强占的进程所需要的状态。在进程执行的某些时刻，内核可以决定抢占当前进程，并重新开始一个先前被抢占了的进程。这种决策就叫做调度,是由内核中称为调度器的代码处理的。

进程执行过程：

在程序运行时，Shell为hello fork了一个子进程，这个子进程与Shell有独立的逻辑控制流。在hello的运行过程中，若hello进程不被抢占，则正常执行；若被抢占，则进入内核模式，进行上下文切换，转入用户模式，调度其他进程。直到当hello调用sleep函数时，为了最大化利用处理器资源，sleep函数会向内核发送请求将hello挂起，并进行上下文切换，进入内核模式切换到其他进程，切换回用户模式运行抢占的进程。与此同时，将 hello 进程从运行队列加入等待队列，由用户模式变成内核模式，并开始计时。当计时结束时，sleep函数返回，触发一个中断，使得hello进程重新被调度，将其从等待队列中移出，并内核模式转为用户模式。此时 hello 进程就可以继续执行其逻辑控制流。

结合进程上下文信息、进程时间片，阐述进程调度的过程，用户态与核心态转换等等。

6.6 hello的异常与信号处理

 hello执行过程中会出现哪几类异常，会产生哪些信号，又怎么处理的。

 程序运行过程中可以按键盘，如不停乱按，包括回车，Ctrl-Z，Ctrl-C等，Ctrl-z后可以运行ps  jobs  pstree  fg  kill 等命令，请分别给出各命令及运行结截屏，说明异常与信号的处理。

• 正常运行：将打印8次信息输入回车结束程序。
• 乱按及回车时不影响程序运行，程序运行结束后除去一个回车会被作为结束标志，其余输入均将被作为Shell的指令输入至命令行中。
• 中途按下ctrl-Z，Shell进程中收到了SIGSTP信号，Shell提示停止信息并挂起hello进程，使用ps和jobs查看hello进程，可以验证hello确实被挂起而并没有被回收，并且作业编号为1.查看进程树，输入pstree，输入fg 1,则将hello程序恢复执行，执行尚未执行完的语句，并完成进程回收。输入kill杀死进程后再调用jobs查看，发现确实进程被杀死
• 输入ctrl+c，Shell将受到SIGINT信号，并终止进程

6.7本章小结

本章从进程的角度介绍了hello的执行过程，了解了Shell的功能和使用方法，明白了Shell是如何使用fork函数创建子进程并且调用execve函数加载可执行程序的，同时实操了使用Shell命令行管理hello进程，对进程的知识有了更深的了解。

第7章 hello的存储管理

7.1 hello的存储器地址空间

结合hello说明逻辑地址、线性地址、虚拟地址、物理地址的概念。

逻辑地址：在计算机体系结构中是指应用程序角度看到的内存单元、存储单元、网络主机的地址。由程序产生的与段相关的偏移地址部分，hello中要经过寻址方式的计算或变换才得到内存储器中的实际有效地址（物理地址）。

线性地址：是逻辑地址到物理地址变换之间的中间层。程式代码会产生逻辑地址，或说是段中的偏移地址，加上相应段的基地址就生成了一个线性地址。如果启用了分页机制，那么线性地址能再经变换以产生一个物理地址。若没有启用分页机制，那么线性地址直接就是物理地址。

虚拟地址：虚拟内存是硬件异常，硬件地址翻译，主存，磁盘文件和内核软件的完美结合，他为每个程序提供了一个大的、一致的和私有的地址空间。通过一个很清楚的机制提供了三个重要的能力：1）他将主存看成是一个存储在存盘上的地址空间的高速缓存。2）他为每个进程提供了一致的地址空间，从而简化了内存的管理。3）它保护了每个进程的地址空间不被其他进程破坏。而虚拟地址就是建立在虚拟内存之上的，在linux下进程加载到内存中时虚拟地址从0x400000开始，计算机通过MMU（地址翻译）完成对物理地址的映射。

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

Intel处理器从逻辑地址到线性地址的变换通过段式管理的方式实现。每个程序在系统中都保存着一个段表，段表保存着该程序各段装入主存的状况信息，包括段号或段名、段起点、装入位、段的长度、主存占用区域表、主存可用区域表等，从而方便进行段式管理。

 

如图所示即为段选择符的结构，其中包含三个部分分别为：索引，TI以及RPL.

索引：用来确定当前使用的段描述符在描述符表中的位置

TI：根据TI的值判断选择全局描述符表或选择局部描述符表

RPL：判断重要等级。RPL=00，为第0级，位于最高级的内核，RPL=11，为第3级，位于最低级的用户状态

而段描述符则为8个字节组成：

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

Linux下，虚拟地址(VA)到物理地址(PA)的转化与翻译是依靠页式管理来实现的，虚拟内存作为内存管理的工具。概念上而言，虚拟内存被组织为一个由存放在磁盘上的N个连续的字节大小的单元组成的数组. 磁盘上数组的内容被缓存在物理内存中  (DRAM cache)这些内存块被称为页 (每个页面的大小为P = 2p字节)。

通过段式管理可以得到线性地址/虚拟地址，虚拟地址可被分为两个部分：VPN（虚拟页号）和VPO（虚拟页偏移量），根据计算机系统的特性可以确定VPN与VPO的具体位数，由于虚拟内存与物理内存的页大小相同，因此VPO与PPO（物理页偏移量）一致。而PPN（物理页号）则需通过访问页表中的页表条目（PTE）获取，如图所示。

​​​​​​​

若PTE的有效位为1，则发生页命中，可以直接获取到物理页号PPN，PPN与PPO共同组成物理地址。

若PTE的有效位为0，说明对应虚拟页没有缓存到物理内存中，产生缺页故障，调用操作系统的内核的缺页处理程序，确定牺牲页，并调入新的页面。再返回到原来的进程，再次调用导致缺页的指令。此时发生页命中，获取到PPN，与PPO共同组成物理地址。

处理过程如图所示：

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

多级页表的概念：如果在计算机内部页表是将所有的项都全部表示出来并且都存在主存中，那么会出现很多问题，假设:4KB (212) 页面, 48位地址空间, 8字节 PTE 那么将需要一个大小为 512 GB 的页表!这512GB的页表如果存放在主存中，这笔开销是十分巨大的。但是事实是由于程序良好的局部性和程序的每一个段并不是连续的，如下图所示，中间会有大量的页表的映射是用不上的，即每次我们访问的页面大概率只有几个为了解决这个问题，我们可以采用页表分级的策略减少常驻内存的页表的开销，依照多级cacahe的原理，将页表进行一级一级缓存。

 

针对Intel Core i7 CPU研究VA到PA的变换。

Intel Core i7 CPU的基本参数如下：

1. 虚拟地址空间48位(n=48)
2. 物理地址空间52位(m=52)
3. TLB四路十六组相连
4. L1，L2，L3块大小为64字节
5. L1，L2八路组相连
6. L3十六路组相连
7. 页表大小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位。

 

如图所示， 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中添加条目。多级页表的工作原理展示如下：

若查询PTE时发现不再物理内存中，则引发缺页故障。若发现权限不够则引发段错误。

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

在完成了7.4中的VA到PA的转换后，得到了一个52位的物理地址。首先图中的L1cache有64组，每组8行，每个块的大小为64B，所以块偏移为6，s=6，所以将这52位的地址分为3部分，分别是40位的CT高速缓存标记，6位的CI高速缓存索引，6位的CO缓冲块内的字节偏移量。

1. 先根据CI得到需要查找的组序号
2.  查找该组的8个行，根据CT与行中的标记位进行匹配，且行的有效为为1，则该高速缓存行命中。
3. 命中后，由CO得到我们需要的字节起始位置，取出返回CPU即可。
4. 若不命中，就需要到L2，L3，甚至于到主存中去寻找请求的块，然后将该请求的块放置或

   哈工大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

   以上是关于程序人生HIT计算机系统大作业——Hello的自白的主要内容，如果未能解决你的问题，请参考以下文章

   程序人生——Hello‘s P2P（HIT CSAPP大作业）

   hit csapp大作业 程序人生-Hello’s P2P

   HIT计统大作业——程序人生

   2022春哈工大ICS大作业——程序人生-hello‘sP2P

   2022计算机系统大作业——程序人生-Hello’s P2P

   计算机系统大作业：程序人生-Hello‘s P2P