哈工大-CS-计算机系统-大作业: hello的一生

计算机系统

大作业

题     目  程序人生-Hello’s P2P  

专       业                       

学　　   号                  

班   级                      

学       生                

指 导 教 师                     

计算机科学与技术学院

2022年5月

摘  要

在编译源文件的过程中，gcc通过调用cpp/cc1/as/ld，将C语言源文件进行预处理、编译、汇编、链接，最终形成可执行目标文件hello，由存储器保存在磁盘中。运行进程时，操作系统为其分配虚拟地址空间，提供异常控制流等强大的工具，Unix I/O为其提供与程序员和系统文件交互的方式。本文通过分析Hello程序从代码编辑器到运行进程的过程，对计算机系统编译源文件、运行进程等机制进行较深入的分析和介绍。

关键词：计算机系统；操作系统；进程加载； C语言底层实现；CSAPP;                           

（摘要0分，缺失-1分，根据内容精彩称都酌情加分0-1分）

目  录

第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章 hello进程管理

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简介

在编译源文件的过程中，gcc通过调用cpp/cc1/as/ld，将C语言源文件进行预处理、编译、汇编、链接，最终形成可执行目标文件hello，由存储器保存在磁盘中。运行进程时，操作系统为其分配虚拟地址空间，随着一连串的缺页故障，hello被逐渐地载入物理内存。操作系统提供异常控制流等强大的工具，不断对系统中运行着的进程进行调度。Unix I/O为其提供与程序员和系统文件交互的方式，让它不再孤单。当程序从main中返回，意味着程序的终止。之后，shell作为其父进程会负责将其回收，操作系统内核删除相关数据结构，释放其占据的资源，hello的一生就此结束。

1.2 环境与工具

1.2.1 硬件环境

处理器：Intel(R) Core(TM) i7-10750H CPU @ 2.60GHz   2.59 GHz

RAM：16.0 GB

1.2.2 系统类型

64位操作系统，基于x64的处理器

1.2.3 软件环境

Windows10 64位；Ubuntu 20.04

1.2.4 开发与调试工具：

gcc/as/ld/vim/edb/readelf/gedit

1.3 中间结果

文件的作用	文件名
预处理后的文件	hello.i
编译之后的汇编文件	hello.s
汇编之后的可重定位目标文件	hello.o
链接之后的可执行目标文件	hello
hello.o 的 ELF 格式	elf.hello.o.txt
hello.o 的反汇编代码	dump_hello_o.txt
hello的ELF 格式	elf.hello.txt
hello 的反汇编代码	dump_hello.txt

1.4 本章小结

本章对hello的一生进行了简要的介绍和描述，介绍了P2P的整个过程，介绍了本计算机的硬件环境、软件环境、开发工具，介绍了为编写本论文的中间文件的名称和其作用。

（第1章0.5分）

第2章 预处理

2.1 预处理的概念与作用

什么是预处理？

程序设计领域中，预处理一般是指在程序源代码被翻译为目标代码的过程中，生成二进制代码之前的过程。

典型地，由预处理器(preprocessor) 对程序源代码文本进行处理，得到的结果再由编译器核心进一步编译。这个过程并不对程序的源代码进行解析，但它把源代码分割或处理成为特定的单位——预处理记号(preprocessing token)用来支持语言特性（如宏调用）。

最常见的预处理是C语言和C++语言。预处理器在UNIX传统中通常缩写为PP，在自动构建脚本中C预处理器被缩写为CPP的宏指代。为了不造成歧义，C++(cee-plus-plus) 经常并不是缩写为CPP，而改成CXX。

为什么预处理？

ISO C和ISO C++都规定程序由源代码被翻译分为若干有序的阶段(phase)，通常前几个阶段由预处理器实现。预处理中会展开以#起始的行，试图解释为预处理指令(preprocessing directive) ，其中ISO C/C++要求支持的包括#if / #ifdef / #ifndef / #else / #elif / #endif（条件编译）、#define（宏定义）、#include（源文件包含）、#line（行控制）、#error（错误指令）、#pragma（和实现相关的杂注）以及单独的#（空指令）。预处理指令一般被用来使源代码在不同的执行环境中被方便的修改或者编译。

2.2在Ubuntu下预处理的命令

预处理需要调用cpp，我们将其重定向到hello.i中。

【命令】cpp hello.c > hello.i

2.3 Hello的预处理结果解析

文件增大

可以发现，整个.i文件相比于.c文件，扩展到了三千多行。

源代码保留

hello.c程序本来的内容出现在最后。在此之前，则是stdio.h unistd.h stdlib.h的源代码的依次展开。

模块化拼接

最开始的一段代码，是hello.c拼接的各种库文件。

中间的某段代码，对很多内部的函数进行声明。

程序的源代码在文件的末尾。

2.4 本章小结

本章介绍了预处理的概念和作用，学习了在ubuntu中用cpp指令对hello.c文件进行预处理，将其重定向到hello.i中。我们浏览了hello.i的代码，对hello.i的内容有了感性认识。

（第2章0.5分）

第3章 编译

3.1 编译的概念与作用

什么是编译？

编译程序所要作得工作就是通过词法分析和语法分析，在确认所有的指令都符合语法规则之后，将其翻译成等价的中间代码表示或汇编代码。

在hello的一生中，编译器将文本文件 hello.i 翻译成文本文件 hello.s。

为什么要编译？

编译的过程可以达成以下效果：

1.语法分析：编译程序的语法分析器以单词符号作为输入，分析单词符号串是否形成符合语法规则的语法单位，方法分为两种：自上而下分析法和自下而上分析法。

2.中间代码：源程序的一种内部表示，或称中间语言。中间代码的作用是可使编译程序的结构在逻辑上更为简单明确，特别是可使目标代码的优化比较容易实现中间代码。

3.代码优化：指对程序进行多种等价变换，使得从变换后的程序出发，能生成更有效的目标代码。

4.目标代码：生成是编译的最后一个阶段。目标代码生成器把语法分析后或优化后的中间代码变换成目标代码。此处指汇编语言代码，须经过汇编程序汇编后，成为可执行的机器语言代码。

3.2 在Ubuntu下编译的命令

【命令】gcc -S hello.i -o hello.s

3.3 Hello的编译结果解析

数据和赋值

1.整数和字符串常量

在语句

中，常量4的值保存的位置在.text中，作为指令的一部分

同理，

中的数字0、8也被存储在.text节中；

在下述函数中：

printf()、scanf()中的字符串则被存储在.rodata节中

2.变量

全局变量：

已经初始化并且初始值非零的全局变量储存在.data节，它的初始化不需要汇编语句，而是通过虚拟内存请求二进制零的页直接完成的。

局部变量：

局部变量存储在寄存器或栈中。程序中的局部变量i定义

在汇编代码中

表示i被保存在栈中%rbp-4的位置上。

算术操作

在循环操作中，使用了++操作符：

对应的汇编代码为，对i自加，栈上存储变量i的值加1

关系操作和控制转移

程序判断传入参数argc是否等于4，

汇编代码为

je用于判断cmpl产生的条件码，若两个操作数的值不相等则调过“本该”执行的语句；

for循环中的循环执行条件

汇编代码为

这里采取了init – 跳转到中间 – 循环判断的模式。jle用于判断cmpl产生的条件码，若后一个操作数的值小于等于前一个，则跳转到.L4——重新执行循环；

数组/指针/结构操作

主函数main的参数中有指针数组char *argv[]

在argv数组中，argv[0]指向输入程序的路径和名称，argv[1]和argv[2]分别表示两个字符串。

因为char* 数据类型占8个字节，根据

对比原函数可知通过M[%rbp-32+16]和M[%rbp-32+8]，分别得到argv[1]和argv[2]两个字符串的首地址。

函数操作

X86-64中,过程调用传递参数规则：第1~6个参数一次储存在%rdi、%rsi、%rdx、%rcx、%r8、%r9这六个寄存器中，剩下的参数保存在栈当中。

main函数：

参数传递：传入参数argc和argv[]，分别用寄存器%rdi和%rsi存储。

函数调用：被系统启动函数调用。

函数返回：设置%eax为0并且返回，对应return 0 。

源代码

汇编代码

printf函数：

1. call puts

参数传递：

传入了字符串参数首地址；

函数调用：

if判断满足条件后调用，

源代码：

汇编代码：

2.call in for loop

参数传递：

传入了格式字符串的地址、 argv[1]、argc[2]的地址。

函数调用：

在for循环的过程中调用。

源代码：

汇编代码：

exit函数：

参数传递：

传入参数1

函数调用：

if判断条件满足后被调用.

源代码：

汇编代码：

atoi函数：

参数传递：

传入参数argv[3]

函数调用：

随着for循环被调用

源代码：

汇编代码：

sleep函数：

参数传递：

传入参数atoi(argv[3])

函数调用：

随着for循环被调用

源代码：

汇编代码：

getchar函数：

函数调用：

在main中被调用

源代码：

汇编代码：

3.4 本章小结

本章介绍了编译的概念以及过程。通过hello函数分析了c语言如何转换成为汇编代码。介绍了汇编代码如何实现变量、常量、传递参数以及分支和循环。

（第3章2分）

第4章 汇编

4.1 汇编的概念与作用

什么是汇编

驱动程序运行汇编器as，将汇编语言的ascii码文件（这里是hello.s）翻译成机器语言的可重定位目标文件（hello.o）的过程称为汇编。

为什么要汇编

.o文件是一个二进制文件，它包含程序的指令编码。

汇编就是将高级语言转化为机器可直接识别执行的代码文件的过程，汇编器将.s 汇编程序翻译成机器语言指令，把这些指令打包成可重定位目标程序的格式，并将结果保存在.o目标文件中。

4.2 在Ubuntu下汇编的命令

【命令】as hello.s -o hello.o

4.3 可重定位目标elf格式

4.3.1 readelf命令：

【命令】readelf -a hello.o > ./elf.txt

4.3.2 ELF头

包含了系统信息，编码方式，ELF头大小，节的大小和数量等等一系列信息。Elf头内容如下：

4.3.3 节头

描述了.o文件中出现的各个节的类型、位置、所占空间大小等信息。

4.3.4 重定位节：

各个段引用的外部符号等在链接时需要通过重定位对这些位置的地址进行修改。链接器会通过重定位节的重定位条目计算出正确的地址。

hello.o需重定位：.rodata中的模式串，puts，exit，printf，atoi，sleep，getchar等符号。

4.3.5符号表：

.symtab存放在程序中定义和引用的函数和全局变量的信息。

4.4 Hello.o的结果解析

【命令】objdump -d -r hello.o > dump_hello.txt

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

在数的表示上，hello.s中的操作数表现为十进制，而hello.o反汇编代码中的操作数为十六进制。说明机器语言的构成，与汇编语言的映射关系。特别是机器语言中的操作数与汇编语言不一致，特别是分支转移函数调用等。

在控制转移上，hello.s使用.L2和.LC1等段名称进行跳转，而反汇编代码使用目标代码的虚拟地址跳转。不过目前留下了重定位条目，跳转地址为零。它们将在链接之后被填写正确的位置。

在函数调用上，hello.s直接call函数名称，而反汇编代码中call的是目标的虚拟地址。但和上一条的情况类似，只有在链接之后才能确定运行执行的地址，目前目的地址是全0，并留下了重定位条目。

4.5 本章小结

本章介绍了汇编。经过汇编器，汇编语言转化为机器语言，hello.s文件转化为hello.o可重定位目标文件。我们研究了可重定位目标文件elf格式，接触了了readelf命令、elf头、节头部表、重定位节、符号表。我们对比hello.s和hello.o，分析了汇编语言到机器语言的变化。

（第4章1分）

第5章 链接

5.1 链接的概念与作用

什么是链接

链接是将各种不同文件（主要是可重定位目标文件）的代码和数据综合在一起，通过符号解析和重定位等过程，最终组合成一个可以在程序中加载和运行的单一的可执行目标文件的过程。

为什么链接

链接令分离编译成为可能，方便了程序的修改和编译：无需重新编译整个工程，而是仅编译修改的文件。

链接还有利于构建共享库。源程序节省空间而未编入的常用函数文件（如printf.o）进行合并，生成可以正常工作的可执行文件。

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的格式

5.3.1 ELF文件头：

5.3.2 节头

描述了各个节的大小、偏移量和其他属性。链接器链接时，会将各个文件的相同段合并成一个大段，并且根据这个大段的大小以及偏移量重新设置各个符号的地址。

5.4 hello的虚拟地址空间

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

使用edb加载hello， data dump窗口可以查看加载到虚拟地址中的hello程序。program headers告诉链接器运行时加载的内容并提供动态链接需要的信息。

   

程序包含PHDR，INTERP，LOAD，DYNAMIC，NOTE，GNU_STACK，GNU_RELRO几个部分，其中PHDR 保存程序头表。INTERP 指定在程序已经从可执行文件映射到内存之后，必须调用的解释器。LOAD 表示一个需要从二进制文件映射到虚拟地址空间的段。其中保存了常量数据、程序的目标代码等。DYNAMIC 保存了由动态链接器使用的信息。NOTE 保存辅助信息。GNU_STACK：权限标志，用于标志栈是否是可执行。GNU_RELRO：指定在重定位结束之后哪些内存区域是需要设置只读。

5.5 链接的重定位过程分析

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

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

【命令】objdump -d -r hello > hello_objdump.s

5.5.1 新增函数：

链接加入了在hello.c中用到的库函数，如exit、printf、sleep、getchar、atoi等函数。

5.5.2 新增节：

hello中增加了.init和.plt节，和一些节中定义的函数。

5.5.3 函数调用地址：

Hello实现了调用函数时的重定位，因此在调用函数时调用的地址已经是函数确切的虚拟地址。

5.5.4控制流跳转地址：

Hello实现了调用函数时的重定位，因此在跳转时调用的地址已经是函数确切的虚拟地址。

5.5.5 链接的过程：

链接器首先组织所有模块的节，将所有类型相同的节合并在一起，然后把运行时的内存地址赋给新的合并得到的聚合节，以及输入模块定义的每个节和符号。

在重定位过程中，链接器进行符号解析，关联每个符号引用和符号定义，进行重定位时，使用汇编器产生的重定位条目，把符号定义和一个内存位置关联起来，使每条指令和全局变量拥有唯一的运行时地址。最终，就得到了一个可执行目标文件。

5.6 hello的执行流程

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

5.7 Hello的动态链接分析

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

5.8 本章小结

本章研究了链接的过程。通过edb查看hello的虚拟地址空间，对比hello与hello.o的反汇编代码，深入研究了链接的过程中重定位的过程。

（第5章1分）

第6章 hello进程管理

6.1 进程的概念与作用

什么是进程

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

为什么使用进程

进程提供给应用程序的关键抽象：一个独立的逻辑控制流，如同程序独占处理器；一个私有的地址空间，如同程序独占内存系统。可以说，如果没有进程，体系如此庞大的计算机不可能设计出来。

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

Shell是用户级的应用程序，代表用户控制操作系统中的任务。处理流程如下：

① 在shell命令行中输入命令：$./hello

② shell命令行解释器构造argv和envp；

③ 调用fork()函数创建子进程，其地址空间与shell父进程完全相同，包括只读代码段、读写数据段、堆及用户栈等

④ 调用execve()函数在当前进程（新创建的子进程）的上下文中加载并运行hello程序。将hello中的.text节、.data节、.bss节等内容加载到当前进程的虚拟地址空间

⑤ 调用hello程序的main()函数，hello程序开始在一个进程的上下文中运行。

6.3 Hello的fork进程创建过程

6.4 Hello的execve过程

Execve的参数包括需要执行的程序(通常是argv[0])、参数argv、环境变量envp。 1. 删除已存在的用户区域（自父进程独立）。

2. 映射私有区：为Hello的代码、数据、.bss和栈区域创建新的区域结构，所有这些区域都是私有的、写时才复制的。

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

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

5. execve在调用成功的情况下不会返回，只有当出现错误时，例如找不到需要执行的程序时，execve才会返回到调用程序。

6.5 Hello的进程执行

6.5.1 逻辑控制流和时间片：

进程的运行本质上是CPU不断从程序计数器 PC 指示的地址处取出指令并执行，值的序列叫做逻辑控制流。操作系统会对进程的运行进行调度，执行进程A->上下文切换->执行进程B->上下文切换->执行进程A->… 如此循环往复。 在进程执行的某些时刻，内核可以决定抢占当前进程，并重新开始一个先前被抢占了的进程，这种决策就叫做调度，是由内核中称为调度器的代码处理的。当内核选择一个新的进程运行，我们说内核调度了这个进程。在内核调度了一个新的进程运行了之后，它就抢占了当前进程，并使用上下文切换机制来将控制转移到新的进程。在一个程序被调运行开始到被另一个进程打断，中间的时间就是运行的时间片。

6.5.2 用户模式和内核模式：

用户模式的进程不允许执行特殊指令，不允许直接引用地址空间中内核区的代码和数据。

内核模式进程可以执行指令集中的任何命令，并且可以访问系统中的任何内存位置。

6.5.3 上下文：

上下文就是内核重新启动一个被抢占的进程所需要恢复的原来的状态，由寄存器、程序计数器、用户栈、内核栈和内核数据结构等对象的值构成。

6.5.4 调度的过程：

在对进程进行调度的过程，操作系统主要做了两件事：加载保存的寄存器，切换虚拟地址空间。

6.5.5 用户态与核心态转换：

为了能让处理器安全运行，需要限制应用程序可执行指令所能访问的地址范围。因此划分了用户态与核心态。

核心态可以说是拥有最高的访问权限，处理器以一个寄存器当做模式位来描述当前进程的特权。进程只有故障、中断或陷入系统调用时才会得到内核访问权限，其他情况下始终处于用户权限之中，保证了系统的安全性。

6.6 hello的异常与信号处理

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

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

按下Ctrl+Z：进程收到 SIGSTP 信号， hello 进程挂起。用ps查看其进程PID，可以发现hello的PID是8022；再用jobs查看此时hello的后台 job号是1，用 fg 将其调回前台。

Ctrl+C：进程收到 SIGINT 信号，结束 hello。在job中没有显示，可以看出hello已经被彻底结束。

中途乱按：只是将屏幕的输入缓存到缓冲区。乱码被认为是命令。

6.7本章小结

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

（第6章1分）

第7章 hello的存储管理

7.1 hello的存储器地址空间

7.1.1 逻辑地址

逻辑地址（Logical Address）是指由程序产生的与段相关的偏移地址部分。在这里指的是hello.o中的内容。

7.1.2 线性地址

线性地址（Linear Address）是逻辑地址到物理地址变换之间的中间层。程序hello的代码会产生段中的偏移地址，加上相应段的基地址就生成了一个线性地址。

7.1.3 虚拟地址

CPU启动保护模式后，程序hello运行在虚拟地址空间中。注意，并不是所有的“程序”都是运行在虚拟地址中。CPU在启动的时候是运行在实模式的，Bootloader以及内核在初始化页表之前并不使用虚拟地址，而是直接使用物理地址的。

7.1.4 物理地址

放在寻址总线上的地址。放在寻址总线上，如果是读，电路根据这个地址每位的值就将相应地址的物理内存中的数据放到数据总线中传输。如果是写，电路根据这个地址每位的值就在相应地址的物理内存中放入数据总线上的内容。物理内存是以字节(8位)为单位编址的。

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

在 Intel 平台下，逻辑地址(logical address)是 selector:offset 这种形式，selector 是 CS 寄存器的值，offset 是 EIP 寄存器的值。如果用 selector 去 GDT( 全局描述符表 ) 里拿到 segment base address(段基址) 然后加上 offset(段内偏移)，这就得到了 linear address。我们把这个过程称作段式内存管理。

一个逻辑地址由段标识符和段内偏移量组成。段标识符是一个16位长的字段（段选择符）。可以通过段标识符的前13位，直接在段描述符表中找到一个具体的段描述符，这个描述符就描述了一个段。
全局的段描述符，放在“全局段描述符表(GDT)”中，一些局部的段描述符，放在“局部段描述符表(LDT)”中。
给定一个完整的逻辑地址段选择符+段内偏移地址，看段选择符的T1=0还是1，知道当前要转换是GDT中的段，还是LDT中的段，再根据相应寄存器，得到其地址和大小。拿出段选择符中前13位，可以在这个数组中，查找到对应的段描述符，就得到了其基地址。Base + offset = 线性地址。

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

页式管理是一种内存空间存储管理的技术，页式管理分为静态页式管理和动态页式管理。将各进程的虚拟空间划分成若干个长度相等的页(page)，页式管理把内存空间按页的大小划分成片或者页面（page frame），然后把页式虚拟地址与内存地址建立一一对应页表，并用相应的硬件地址变换机构，来解决离散地址变换问题。页式管理采用请求调页或预调页技术实现了内外存存储器的统一管理。

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

7.4.1 翻译后备缓冲器

每次CPU产生一个虚拟地址，MMU（内存管理单元）就必须查阅一个PTE（页表条目），以便将虚拟地址翻译为物理地址。在最糟糕的情况下，这会从内存多取一次数据，代价是几十到几百个周期。如果PTE碰巧缓存在L1中，那么开销就会下降1或2个周期。然而，许多系统都试图消除即使是这样的开销，它们在MMU中包括了一个关于PTE的小的缓存，称为翻译后备缓存器（TLB）。

7.4.2 多级页表：

将虚拟地址的VPN划分为相等大小的不同的部分，每个部分用于寻找由上一级确定的页表基址对应的页表条目。

7.4.3 VA到PA的变换

处理器生成一个虚拟地址，并将其传送给MMU。MMU用VPN向TLB请求对应的PTE，如果命中，则跳过之后的几步。MMU生成PTE地址(PTEA).，并从高速缓存/主存请求得到PTE。如果请求不成功，MMU向主存请求PTE，高速缓存/主存向MMU返回PTE。PTE的有效位为零, 因此 MMU触发缺页异常，缺页处理程序确定物理内存中的牺牲页 (若页面被修改，则换出到磁盘——写回策略)。缺页处理程序调入新的页面，并更新内存中的PTE。缺页处理程序返回到原来进程，再次执行导致缺页的指令。

在多级页表的情况下，无非就是不断通过索引 – 地址 – 索引 - 地址重复四次进行寻找。

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

CPU发送一条虚拟地址，随后MMU按照7.4所述的操作获得了物理地址PA。根据cache大小组数的要求，将PA分为CT（标记位）CI(组索引)，CO（块偏移）。根据CI寻找到正确的组，依次与每一行的数据比较，有效位有效且标记位一致则命中。如果命中，直接返回想要的数据。如果不命中，就依次去L2,L3,主存判断是否命中，命中时将数据传给CPU同时更新各级cache的储存。

7.6 hello进程fork时的内存映射

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

当fork在新进程中返回时，新进程现在的虚拟内存刚好和调用fork时存在的虚拟内存相同。当这两个进程中的任一个后来进行写操作时，写时复制机制就会创建新页面。

7.7 hello进程execve时的内存映射

1）在bash中的进程中执行了如下的execve调用：execve("hello",NULL,NULL)；

2）execve函数在当前进程中加载并运行包含在可执行文件hello中的程序，用hello替代了当前bash中的程序。

3）删除已存在的用户区域。

4）映射私有区域

5）映射共享区域

6）设置程序计数器（PC）

最后，exceve设置当前进程的上下文中的程序计数器到代码区域的入口点。

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

页面命中完全是由硬件完成的，而处理缺页是由硬件和操作系统内核协作完成的：

（1）处理器生成一个虚拟地址，并将它传送给MMU

（2）MMU生成PTE地址，并从高速缓存/主存请求得到它

（3）高速缓存/主存向MMU返回PTE

（4）PTE中的有效位是0，所以MMU出发了一次异常，传递CPU中的控制到操作系统内核中的缺页异常处理程序。

（5）缺页处理程序确认出物理内存中的牺牲页，如果这个页已经被修改了，则把它换到磁盘。

（6）缺页处理程序页面调入新的页面，并更新内存中的PTE

（7）缺页处理程序返回到原来的进程，再次执行导致缺页的命令。CPU将引起缺页的虚拟地址重新发送给MMU。因为虚拟页面已经换存在物理内存中，所以就会命中。

7.9动态存储分配管理

动态储存分配管理使用动态内存分配器(如malloc)来进行。动态内存分配器维护着一个进程的虚拟内存区域，称为堆。分配器将堆视为一组不同大小的块的集合。每个块就是一个连续的虚拟内存页，要么是已分配的，要么是空闲的。

已分配的块显式地保留为供应用程序使用。

空闲块保持空闲，直到它显式地被应用所分配。

一个已分配的块保持已分配的状态，直到它被释放，这种释放要么是应用程序显式执行的，要么是内存分配器自身隐式执行的。动态内存分配主要有两种基本方法与策略：

7.9.1 带边界标签的隐式空闲链表分配器管理

带边界标记的隐式空闲链表的每个块是由一个字的头部、有效载荷、（可能的）额外填充以及一个字的尾部组成。

隐式空闲链表：空闲块通过头部的大小字段隐含地连接着。分配器遍历堆中所有的块，间接地遍历整个空闲块的集合。

当一个应用请求一个k字节的块时，分配器搜索空闲链表，查找一个足够大的可以放置所请求块的空闲块。分配器有三种放置策略：首次适配、下一次适配和最佳适配。分配器在面对释放一个已分配块时，可以合并相邻的空闲块，其中一种简单的方式，是利用隐式空闲链表的边界标记来进行合并。

7.9.2 显式空间链表管理

显式空闲链表是将堆的空闲块组织成一个双向链表，在每个空闲块中，都包含一个前驱与一个后继指针。进行内存管理。在显式空闲链表中。可以采用后进先出的顺序维护链表，将最新释放的块放置在链表的开始处，也可以采用按照地址顺序来维护链表，其中链表中每个块的地址都小于它的后继地址，在这种情况下，释放一个块需要线性时间的搜索来定位合适的前驱。

7.10本章小结

本章介绍了存储器地址空间、段式管理、页式管理，VA 到 PA 的变换、物理内存访问， hello 进程fork时和execve 时的内存映射、缺页故障与缺页中断处理、包括隐式空闲链表和显式空闲链表的动态存储分配管理。

（第7章 2分）

第8章 hello的IO管理

8.1 Linux的IO设备管理方法

Linux将文件所有的I/O设备都模型化为文件，甚至内核也被映射为文件。这种将设备优雅地映射为文件的方式，允许Linux内核引出一个简单、低级的应用接口，称为Unix I/O。Linux就是基于Unix I/O实现对设备的管理。

8.2 简述Unix IO接口及其函数

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;
    }
       
   
vsprintf(buf, fmt, arg)函数 
    
   

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返回的是要打印出来的字符串的长度。
       
   
        write函数：
   
    write:
     mov eax, _NR_write
     mov ebx, [esp + 4]
     mov ecx, [esp + 8]
     int INT_VECTOR_SYS_CALL
   
    write：写操作，把buf中的i个元素的值写到终端。

        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
   
   
        
     ecx中是要打印出的元素个数
    ebx中的是要打印的buf字符数组中的第一个元素
    这个函数的功能就是不断的打印出字符，直到遇到：'\0'
     [gs:edi]对应的是0x80000h：0采用直接写显存的方法显示字符串
     xor si,si
     mov ah,0Fh
     mov al,[ebx+si]
     cmp al,'\0'
     je .end
     mov [gs:edi],ax
     inc si
    loop:
     sys_call
   
    .end:
     ret
    
   
    vsprintf函数将所有的参数内容格式化之后存入buf，返回格式化数组的长度。write函数将buf中的i个元素写到终端。从vsprintf生成显示信息，到write系统函数，到陷阱-系统调用 int 0x80或syscall.字符显示驱动子程序：从ASCII到字模库到显示vram（存储每一个点的RGB颜色信息）。显示芯片按照刷新频率逐行读取vram，并通过信号线向液晶显示器传输每一个点（RGB分量）。

8.4 getchar的实现分析

当程序调用getchar时，程序等待用户按键，用户输入的字符被存放在键盘缓冲区中直到用户按回车(回车也在缓冲区中)。

当用户键入回车之后，getchar才开始从stdio流中每次读入一个字符。getchar函数的返回值是用户输入的第一个字符的ascii码,如出错返回-1,且将用户输入的字符回显到屏幕。如用户在按回车之前输入了不止一个字符,其他字符会保留在键盘缓存区中,等待后续getchar调用读取。也就是说，后续的getchar调用不会等待用户按键,而直接读取缓冲区中的字符,直到缓冲区中的字符读完为后,才等待用户按键。

异步异常-键盘中断的处理：当用户按键时触发键盘终端，操作系统将控制转移到键盘中断处理子程序，中断处理程序执行，接受按键扫描码转成ascii码，保存到系统的键盘缓冲区，显示在用户输入的终端内。当中断处理程序执行完毕后，返回到下一条指令运行。

8.5本章小结

本章介绍了 Linux 的 I/O 设备的基本概念和管理方法，以及Unix I/O 接口及其函数。最后分析了printf 函数和 getchar 函数的工作过程。

（第8章1分）

结论

至此，我们结束了hello的一生，回顾这段旅程，可谓历经千难万险：

（1）hello.c预处理到hello.i文本文件

（2）hello.i编译到hello.s汇编文件

（3）hello.s汇编到二进制可重定位目标文件hello.o

（4）hello.o链接生成可执行文件hello

（5）bash进程调用fork函数，生成子进程；

（6）execve函数加载运行当前进程的上下文中加载并运行新程序hello

（7）hello的运行需要地址的概念，虚拟地址是计算机系统最伟大的抽象。

（8）hello的输入输出与外界交互，与linux I/O息息相关

（9）hello最终被shell父进程回收，内核会收回为其创建的所有信息

计算机系统设计师们真的是太伟大了，因为他们，我们的世界才会如此丰富多彩！

（结论0分，缺失 -1分，根据内容酌情加分）

附件

文件的作用	文件名
预处理后的文件	hello.i
编译之后的汇编文件	hello.s
汇编之后的可重定位目标文件	hello.o
链接之后的可执行目标文件	hello
hello.o 的 ELF 格式	elf.hello.o.txt
hello.o 的反汇编代码	dump_hello_o.txt
hello的ELF 格式	elf.hello.txt
hello 的反汇编代码	dump_hello.txt
C语言源文件	hello.c

参考文献

为完成本次大作业你翻阅的书籍与网站等

[1]  https://zhuanlan.zhihu.com/p/384701815

[2]  [转]printf 函数实现的深入剖析 - Pianistx - 博客园

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