程序人生-Hello’s P2P

首先将源程序hello.c经过预处理生成hello.i，再经过编译器编译生成汇编程序hello.s,然后通过汇编器翻译成机器语言指令，即可重定位目标程序hello.o，再通过链接将目标文件关联到一起，最终生成可执行目标文件hello.out，该文件可以被加载到内存中运行。生成可执行文件后，OS将可执行文件通过ececve和fork产生进程。

020阶段：From Zero-0 to Zero-0，通过OS + CPU/RAM/IO等，通过mmap分配时间片，进行进程调度，取值译码执行、流水线并行，通过虚拟内存映射、缓存访问数据，最后通过shell回收终止进程，使内存恢复到运行前状态。

1.2 环境与工具

1.2.1 硬件环境

X64 CPU；2.38GHz；16G RAM；476GHD Disk

1.2.2 软件环境

Windows10 64位；Vmware 15；Ubuntu 20.04 LTS 64位

1.2.3 开发工具

Visual Studio 2022 64位；CodeBlocks 64位；vi/vim/gedit+gcc

1.3 中间结果

hello.c:编写的源代码

hello.i:预处理后的文件

hello.s:编译后的汇编代码

hello.o:汇编后的二进制文件

hello.elf:hello.o的elf文件

hello:链接后的可执行文件

hello1.elf:hello的elf文件

1.4 本章小结

本章通过简要介绍hello的From Program to Process和From Zero-0 to Zero-0阶段，概述程序到进程执行再回收的过程，并列出环境与工具、中间结果文件。

第2章预处理

2.1 预处理的概念与作用

预处理概念：预处理主要进行代码文本的替换工作，用于处理#开头的指令，根据#后的具体内容进行不同的处理，转换为实际代码中的内容。

预处理作用:

1.宏替换，宏定义在预处理的过程中会进行宏替换。在不带参数的宏定义中，要用实际值替换用# define定义的字符或字符串；而在带参数的宏定义中，不仅仅要进行实际值的替换，还要将参数进行代换。

2.加载头文件，将源文件中以#include格式包含的文件复制到编译的源文件中。

是包含头文件的操作，将所包含头文件的指令替代。如果头文件中包含了其他头文件，也需要将头文件展开包含

3.条件编译：根据“#if”后面的条件决定需要编译的代码。条件编译能够根据不同条件决定需要进行编译的代码，使用条件编译可以使目标程序变小，在满足条件之后才会进行编译。

2.3 Hello的预处理结果解析

hello.i预处理相较于hello.c文件，多了很多行代码，通过对比发现，在开头添加了很多行代码，源代码在文件的最后，且不包含源代码中#开头的代码。

2-2 hello.i内容

预处理处理#后的指令，读取#后的stdio.h、unistd.h、stdlib.h中的内容并依次进行展开，这些都属于#include中的内容，那么就将头文件中的内容被包含到该文件中，而源程序中这些都由<>括起，则编译程序将到C语言开发环境中设置好的 include文件中去找指定的文件。 #include命令的作用是把指定的文件模块内容插入到#include所在的位置，当程序编译链接时，系统会把所有#include指定的文件链接生成可执行代码。可知开头代码应为对头文件的解析。

2.4 本章小结

介绍预处理的概念、作用，给出hello.c经过预处理转化为hello.i的指令，并分析hello预处理的结果。

第3章编译

3.1 编译的概念与作用

编译概念：指将经过预处理文件（.i）之后的程序转换成特定汇编代码(.s)的过程。

编译作用：通过语法检验、代码优化等过程，将程序员识别的编程语言转化为汇编语言输出。

3.2 在Ubuntu下编译的命令

gcc -S hello.i -o hello.s

3-1编译命令

3.3 Hello的编译结果解析

3.3.1数据

（1）int i;

为局部变量，被存储在栈中，定义时被压栈

（2）int argv

作为参数使用寄存器edi传递到main中，并压栈

3.3.2赋值

i=0;

使用movl向栈中存储的i传递立即数0

3.3.2算数操作

i++;

使用add和立即数1完成存储在栈中的i的++的每次加一的操作

3.3.2关系操作

（1）argc!=4

通过cmp与立即数4比较并设置标志位以便后续进行控制转移

（2）i<8

通过cmp与立即数7比较并设置标志位以便后续进行控制转移

3.3.5指针、数组操作

（1）char *argv[]

将数组首地址作为参数通过寄存器rsi传递给main，然后压栈

（2）argv[]

根据数组元素与数组首地址的偏移量从栈中取值，每个数据偏移量为8，由于在栈中存放的是指针数组，所以在取值时先取得数据地址，再从对应地址取数

3.3.3控制转移

（1）if(argc!=4)

与关系操作结合，判断标志位是否满足je条件，如果相等则跳转至相应操作

（2）for(i=0;i<8;i++)

与关系操作、赋值操作、算数操作结合，判断标志位是否满足jle条件，如果符合循环条件进入循环体

3-2-11 hello.s内容

3.3.4函数操作

（1）printf("用法: Hello 学号姓名秒数！\n")：将字符串LC0传递给寄存器rdi作为参数，调用函数

3-2-12 hello.s内容

printf("Hello %s %s\n",argv[1],argv[2])：先根据地址偏移得到地址位置，在取值传递给参数寄存器rdx、rax，将字符串LC1传递给rdi，调用函数

3-2-13 hello.s内容

（2）exit(1):通过edi传参立即数1

3-2-14 hello.s内容

（2）sleep(atoi(argv[3]))：由于参数是atoi返回值，先调用atoi，将返回值从寄存器eax中向edi传参

3-2-15 hello.s内容

（3）atoi(argv[3])先根据地址偏移得到地址位置，在取值传递给参数寄存器rdi

3-2-16 hello.s内容

（4）getchar()：直接调用

3-2-17 hello.s内容

3.4 本章小结

通过对比.s与.c文件中对于同样的语言的实现，区别汇编语言与编程的表示方式，体现编译器处理C语言的各个数据类型以及各类操作的方式。

第4章汇编

4.1 汇编的概念与作用

概念：将上一步的汇编代码转换成机器码，产生二进制格式的目标文件。

作用：汇编语言中助记符代替操作码，不能直接被机器识别，将汇编语言书写的程序翻译成与之等价的机器语言程序的翻译程序，使其链接后可被机器识别。

4.2 在Ubuntu下汇编的命令

gcc -c hello.s -o hello.o

4-1 汇编命令

4.3 可重定位目标elf格式

生成elf：readelf -a hello.o>hello.elf

4-2 elf生成命令

ELF头：以一个四字节的魔数开始，描述生成该文件是64位、小端存储，剩下的部分包含帮助链接器语法分析和解释目标文件的信息。其中包括ELF头的大小、目标文件的类型、机器类型为x86-64、节头部表的文件偏移，以及节头部表中条目的大小和数量。

4-3 ELF头

节头：存有节的基本信息，包括序号，名称，大小，类型，偏移量等信息。

4-4 节头

重定位节：给出了偏移量、信息、类型、符号值、符号名称，加数信息。当链接器把这个目标文件和其他文件组合时，需要修改这些位置。

. rela.text：给出L0（rodata只读数据）、puts、exit、L1（rodata只读数据）、printf、atoi、sleep、getchar的重定位信息，可以看出，这些是程序中的函数和字符串

.rela.eh_frame：重定位.text(已编译的机器代码)

4-5 重定位节

符号表：存放程序中定义的全局变量和函数的信息(不包括局部变量)。name记录目标名称，value记录符号地址，size记录目标大小，type记录是函数还是数据，bind记录全局还是本地。

4-6 符号表

4.4 Hello.o的结果解析

4-7 hello.o反汇编

构成：由操作码和操作数两部分组成，操作码指出该指令所要完成的操作，即指令的功能，操作数指出参与运算的对象，以及运算结果所存放的位置等。

映射关系：一条二进制机器语言都有相应的操作码和操作数，这与汇编代码中可以直接读出的操作码和操作数一一对应。

不一致：

（1）分支转移：hello.s中分支转移通过L1、L2等助记符进行跳转，但这些并不能被机器识别，而hello.o的反汇编中直接使用main+地址偏移量进行跳转，

（2）函数调用：.s中函数调用直接在call后使用函数名称，而.o中使用的是main+地址偏移量，标记了相对偏移地址。

（3）进制表示：由十进制改为了方便机器识别的十六进制。

（4）左侧多出一列相对于main的偏移量，方便寻找偏移地址。

4.5 本章小结

通过生成.o问价和可重定位目标文件elf，同时通过比较.s和.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-1 链接命令

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

生成readref:

5-2 生成elf及elf文件

ELF头：类型变更为可执行文件，有27个节

5-3 ELF头

节头：对所有的节信息进行了声明，包括大小和偏移量，因此根据节头中的信息我们就可以定位各个节所在区间。其中地址是程序被载入到虚拟地址的起始地址。

5-4 节头

程序头：

5-5 程序头

段节：

5-6 段节

重定位节：

5-7 重定位节

符号表：

5-8 符号表

5.4 hello的虚拟地址空间

虚拟地址空间：通过Data Dump看到虚拟地址内容

5-9 虚拟地址内容

edb中可查看各节的起始位置：与5.3中对比，可以发现从虚拟地址0x401000开始，程序的各部分按顺序载入，各个节载入的顺序与5.3中节头出现的顺序相同。

5-10 edb中各节起始位置 5-11 hello节头表

5.5 链接的重定位过程分析

5-12 hello反汇编

hello与hello.o的不同：

hello.o中最左边一列是相对偏移地址，在hello中是虚拟内存地址
函数调用时，hello.o中call后面接的是关于main的偏移量，不是函数的所在位置地址，而hello中完成了重定位，call直接指向函数所在的虚拟地址。
增加了函数和节的汇编代码。
在向printf传递参数的地址从0，变为关于rip中寄存地址的偏移量

链接的过程：在使用 ld 命令链接的时候，主要定义了初始化函数_init，_start 程序调用 hello.c 中的 main 函数，链接时加载.so后缀的共享库，进行动态链接。定义了 hello.c 中用到的 printf、sleep、getchar、exit 函数。链接器将上述函数加入。.text 与.plt 的相对距离已经确定，链接器计算相对距离，将对动态链接库中函数的调用值改为 PLT 中函数与下条指令的相对地址，指向对应函数。

重定位：在hello.o的反汇编中可以看见有两个R_X86_64_PC32类型数据（即两个字符串）的重定位。因为两个节之间的相对距离确定，所以在hello的反汇编中，传入printf的参数地址为rip中寄存地址的偏移量而非hello中的0。

5.6 hello的执行流程

单步执行时可看到的调用顺序如下：

ld-2.23.so!_dl_start

ld-2.23.so!_dl_setup_hash

ld-2.23.so!_dl_sysdep_start

hello!__libc_start_main@plt

ld-2.23.so!_dl_fixup

ld-2.23.so!_dl_lookup_symbol_x

libc-2.23.so!__cxa_atexit

libc-2.23.so!__new_exitfn

hello!_init

libc-2.23.so!__sigjmp_save

hello!puts@plt

hello!exit@plt

5.7 Hello的动态链接分析

动态链接项目：链接器采用延迟绑定的策略,通过PLT和GOT实现。

PLT是一个数组，每个条目是16字节代码，PLT[0]是一个特殊条目，它跳转到动态链接器中。PLT[1]调用系统启动函数，初始化执行环境， PLT[2]开始的条目是调用用户代码调用的函数。

GOT是一个数组，每个条目是8字节地址。和PLT联合使用。GOT[0]与 GOT[1]包含动态链接器在解析函数地址时的会使用的信息。GOT[2]是动态链接器在 ld-linux.so 模块的入口点，其余条目对应一个函数，在第一次调用时进行解析，结束后将其指向正确的函数运行时地址。

在dl_init前后变化：查表知GOT起始位置403ff0

5-13 节头中GOT位置

调用前：

5-14 调用前GOT内容

调用后：

5-15 调用后GOT内容

5.8 本章小结

本章介绍链接的概念和作用，通过分析hello.o和hello的不同，展示链接和重定位的过程和原理。

第6章 hello进程管理

6.1 进程的概念与作用

概念：进程是一个执行中的程序的实例。系统的每一个程序都运行在某个进程的上下文中，上下文由程序正确运行的状态组成，包括代码、数据、栈、寄存器、程序计数器、环境变量、打开文件描述符的集合。

作用：给在运行一个程序时，得到一个假象，好像程序独占地使用处理器和内存系统。

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

作用：Shell是一个交互型应用级程序，代表用户运行其他程序，bash是linux下的一种Shell

处理流程：

（1）Shell打印一个命令行提示符，等待用户在标准输入上输入命令行，然后读入命令行，切分命令行字符串获得参数

（2）检查第一个命令行参数是否内置，是则直接执行

（3）不是则用fork创建子程序，调用execve

（4）判断命令为前台作业等待作业终止后返回

（5）若为后台作业直接shell返回

（6）随时接受收到异常和信号并进行处理

6.3 Hello的fork进程创建过程

向bash中输入./hello 120L021214 liu 1时，hello为可执行程序不是内置命令，此时就会调用fork创建一个新的运行的子进程，子进程得到与父进程虚拟地址空间相同的(但独立)一份副本（代码、数据段、堆、共享库以及用户栈），子进程获得与父进程任何打开文件描述符相同的副本，有不同于父进程的PID，然后将可执行程序hello加载到内存中开始执行。

6.4 Hello的execve过程

由于hello是可执行程序而非内置命令，则会创建子进程然后调用execve,在当前进程中载入并运行程序hello，并传入可执行文件filename、参数列表argv、环境变量列表envp，

删除子进程现有的虚拟内存段，创建一组新的段（栈与堆初始化为0),并将虚拟地址空间中的页映射到可执行文件的页大小的片chunk，新的代码与数据段被初始化为可执行文件的内容，然后跳到_start，除了一些头部信息实际没读文件，直到缺页中断

覆盖当前进程的代码、数据、栈，保留有相同的PID，继承已打开的文件描述符和信号上下文。

6.5 Hello的进程执行

调度过程：在进程执行的某些时刻，内核可以决定抢占当前进程，并重新开始一个先前被抢占了的进程，这种决策是调度。内核调度了一个新的进程运行后，它抢占当前进程，并使用上下文切换机制。

用户态和核心态转换：运行hello最开始在用户态中，从用户态到核心态的方式是通过中断、故障或陷入系统调用的异常。如hello调用的sleep陷入中断异常，控制传递到异常处理程序，处理器从用户态到核心态，此时内核代表用户执行系统调用，发生上下文切换，请求让调用进程休眠，处理程序运行在内核模式，时间片结束后，从核心态转为用户态，控制返回给hello紧随在调用sleep后的那条指令。

6.6 hello的异常与信号处理

异常：

（1）中断：外部I/O设备引起的异常，回到下一条指令。

（2）陷阱：陷阱是有意的异常，是执行一条指令的结果，如sleep。陷阱处理程序控制返回下一条指令。

（3）故障：在执行hello程序的时候，可能会发生缺页故障，重新执行被修复的指令或终止。

（4）终止：在hello执行过程可能会出现DRAM或者SRAM位损坏的奇偶错误，终止。

信号：

（1）SIGINT：crtl c键盘中断，终止

（2）SIGTSTP：crtl z键盘停止，停止直到下一个SIGCONT

（3）SIGCHLD：子进程停止或终止

（4）SIGKILL：kill命令，终止

（5）SIGCONT：继续停止的进程

各命令运行结果：正常状态下：

6-1 正常执行

不停乱按(非Ctrl-C、Ctrl-Z)：包括回车在内，在getchar（）执行之前未对进程执行产生影响，执行之后输入内容作为下一条命令内容

6-2 乱按

Ctrl-C：收到键盘发出SIGINT信号，进程终止不可恢复，且被回收

6-3 Ctrl C

Ctrl-Z：收到键盘发出SIGTSTP信号，进程停止等待继续的信号SIGCONT才能继续执行，并输出相应信息

6-4 Ctrl Z

ps：打印当前系统进程信息，Ctrl z后显示该进程未被回收，仍有继续运行的可能

6-5 Ctrl Z+ps

jobs：打印当前shell执行的进程的pid，状态，和名称

6-6 Ctrl Z+jobs

pstree: 查看进程树，以树形结构显示程序和进程之间的关系

6-7 Ctrl Z+pstrer

fg:将后台停止的进程提到前台执行，并等待直到这个进程结束

6-8 Ctrl Z+fg

kill:杀死对应pid的进程并回收

6-9 Ctrl Z+kill

6.7本章小结

介绍进程的概念与作用，并简要叙述shell处理流程、调度方法、fork、execve过程，通过结合hello的实例进行异常和信号处理。

第7章 hello的存储管理

7.1 hello的存储器地址空间

逻辑地址：在汇编代码hello.o中出现的地址，由段标识符加指定段内相对地址偏移量组成，对应的是硬件平台段式管理转换前的地址。

线性地址：非负整数地址的有序集合，如果地址空间中的整数是连续的，那么我们说它是一个线性地址空间。在分段部件中逻辑地址是段中的偏移地址，然后加上基地址就是线性地址。对应了硬件页式内存的转换前的地址。

虚拟地址：N = 2n 个虚拟地址的集合。在一个带虚拟内存的系统中，CPU从一个有N=2^n个地址的地址空间中生成虚拟地址，这个地址空间称为虚拟地址空间。

物理地址：M = 2m 个物理地址的集合，计算机系统的主存被组织成一个由M个连续的字节大小的单元组成的数组，每个字节都对应具体的物理地址。用于内存芯片级的单元寻址，与地址总线相对应。hello在运行时执行指令和访问数据最后都要通过物理地址来存取主存。

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

被选中的段描述符先被送至描述符cache，每次从描述符cache中取32位段基址，与32位段内偏移量（有效地址）相加得到线性地址。段标识符是由一个16位长的字段组成，其中前13位是段描述符索引号。多个段描述符组成段描述符表，可以通过段标识符的前13位，直接在段描述符表中找到一个具体的段描述符，这个描述符就描述了一个段。通过段选择符中的T1=0选择用GDT，T1=1用LDT。再根据相应寄存器，得到其地址和大小。拿出段选择符中前13位，可以在这个数组中，查找到对应的段描述符，基地址就知道了。基地址加偏移量，就是要转换的线性地址。

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

虚拟地址由TLB索引TLBI、TLB标记TLBT、虚拟页面偏移量VPO、虚拟页号VPN组成，物理地址由物理页面偏移量PPO、物理页号PPN组成。n位的虚拟地址包含两个部分：一个p位的虚拟页面偏移(VPO),一个n-p位的虚拟页号(VPN)，MMU利用VPN选择适当的PTE，例如VPN 0选择PTE 0。将PPN与VPO串联起来，得到相应的物理地址。

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

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

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

（4） MMU 构造物理地址，传送给高速缓存/主存

（5）高速缓存/主存返回所请求的数据字给处理器

7-1 线性地址到物理地址

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

开始时，MMU从虚拟地址中抽取VPN，到TLB中取出相应地PTE，如果TLB不命中，那么MMU必须从页表中地PTE取出PPN。对于四级页表层次结构，虚拟地址被划分为4个VPN和1个VPO，每个VPN i都是到第i级页表的索引（1≤i≤4）。CR3指向第一级页表的基址，第j级页表的每个PTE指向第j+1级的某个页表的基址。第4级页表的PTE包含某个物理页面的PPN或一个磁盘块地址。在确定PPN前，MMU必须访问4个PTE。得到PPN后与VPO组合得到最后的PA。

7-2 四级页表

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

MMU得到物理地址后，分为CT（缓存标记），CI（组索引），CO（块偏移）三部分，根据CI找到对应的组后，用CT进行标志位匹配，匹配成功后，且valid标志位为1，则缓存命中，根据CO得到对应数据块。否则缓存不命中，向下一级Cache寻找，若三级Cache都不命中，再到主存中寻找。

7.6 hello进程fork时的内存映射

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

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

7.7 hello进程execve时的内存映射

execve函数在当前程序中加载并运行包含在可执行文件hello中的程序，用hello代替了当前程序。加载并运行hello主要分为一下几个步骤：

（1）删除已存在的用户区域，删除当前进程虚拟地址的用户部分中的已存在的区域结构；

（2）映射私有区域，为新程序的代码、数据、bss和栈区域创建新的区域结构，所有这些新的区域都是私有的、写时复制的。代码和数据区域被映射为hello文件中的.text和.data区，bss区域是请求二进制零的，映射到匿名文件，其大小包含在hello中，栈和堆地址也是请求二进制零的，初始长度为零；

（3）映射共享区域， hello程序与共享对象libc.so链接，libc.so是动态链接到这个程序中的，然后再映射到用户虚拟地址空间中的共享区域内；

（4）设置程序计数器，设置当前进程上下文的程序计数器，使之指向代码区域的入口点。

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

缺页故障：虚拟内存中的字不在物理内存中 (DRAM 缓存不命中)。

缺页中断处理：调用内核里的缺页异常处理程序，该程序会选择一个牺牲页，若牺牲页已经被修改，就把它交换出去换入新的页面并更新页表，更新内存中的PTE，缺页处理程序返回到原来的进程，再次执行导致缺页的指令。CPU将引起缺页的虚拟地址重新发送给MMU。因为虚拟页面现在缓存在物理内存中，所以就会命中。

7.9动态存储分配管理

动态内存分配器维护着一个进程的虚拟内存区域，称为堆。对于每个进程，内核维护着一个变量 brk，它指向堆的顶部。

分配器将堆视为一组不同大小的块的结合来维护。每个块就是一个连续的拟内存片，要么是已分配的，要么是空闲的。已分配的块显式地保留为供应用程序使用。空闲块可用来分配。一个已分配的块保持已分配状态，直到它被释放，这种释放要么是应用程序显式执行的，要么是内存分配器自身隐式执行的。

分配器有两种基本风格，两种风格都要求应用显式地分配块，不同在于由哪个实体来负责释放已分配的块。显式分配器要求应用显式地释放任何已分配的块（如malloc）。隐式分配器求分配器检测一个已分配块何时不再使用，那么就释放这个块，自动释放未使用的已经分配的块的过程叫做垃圾收集。

对于显式分配器必须在一些相当严格的约束条件下工作:

（1）处理任意请求序列。一个应用可以有任意的分配请求和释放请求序列，只要满足约束条件:每个释放请求必须对应于一个当前已分配块，这个块是由一个以前的分配请求获得的。因此，分配器不可以假设分配和释放请求的顺序。例如，分配器不能假设所有的分配请求都有相匹配的释放请求，或者有相匹配的分配和空闲请求是嵌套的。

（2）立即响应请求。分配器必须立即响应分配请求。因此，不允许分配器为了提高性能重新排列或者缓冲请求。

（3）只使用堆。为了使分配器是可扩展的，分配器使用的任何非标量数据结构都必须保存在堆里。

（4）对齐块(对齐要求)。分配器必须对齐块，使得它们可以保存任何类型的数据对象。

（5）不修改已分配的块。分配器只能操作或者改变空闲块。特别是，-旦块被分配了，就不允许修改或者移动它了。因此，诸如压缩已分配块这样的技术是不允许使用的。

7.10本章小结

本章从虚拟内存的角度，首先介绍了hello的逻辑地址、线性地址、虚拟地址、物理地址概念，再通过段页式管理进行转化，使用TLB和多级页表进行加速原理，同时阐述fork和evecve的内存映射，并对缺页故障和缺页中断处理、动态存储分配进行介绍。

第8章 hello的IO管理

8.1 Linux的IO设备管理方法

设备的模型化：文件

所有的I/O设备（例如网络、磁盘和终端）都被模型化为文件，而所有的输入和输出都被当做相应文件的读和写来执行。

设备管理：unix io接口

这种将设备映射为文件的方式，允许Linux内核引出一个简单、低级的应用接口，称为Unix I/O。这使得所有的输入和输出都能以一种统一且一致的方式来执行。

8.2 简述Unix IO接口及其函数

Unix IO接口：

(1)打开文件。一个应用程序通过要求内核打开相应的文件，来宣告它想要访问一个 I/O 设备，内核返回一个小的非负整数，叫做描述符，它在后续对此文件的所有操作中标识这个文件，内核记录有关这个打开文件的所有信息。

(2）Shell 创建的每个进程都有三个打开的文件：标准输入，标准输出，标准错误。

(3)改变当前的文件位置：对于每个打开的文件，内核保持着一个文件位置 k，初始为 0，这个文件位置是从文件开头起始的字节偏移量，应用程序能够通过执行 seek操作，显式地将改变当前文件位置 k。

(4)读写文件：一个读操作就是从文件复制 n>0 个字节到内存，从当前文件位置 k 开始，然后将 k 增加到 k+n，给定一个大小为 m 字节的而文件，当 k≥m 时，触发 EOF。类似一个写操作就是从内存中复制 n>0 个字节到一个文件，从当前文件位置 k 开始，然后更新 k。

(5)关闭文件：当应用完成了对文件的访问之后，它就通知内核关闭这个文件。内核释放文件打开时创建的数据结构，并将这个描述符恢复到可用的描述符池中。

函数：

打开文件：int open(char *filename, int flags, mode_t mode)

open函数将filename转换为一个文件描述符，成功返回描述符数字，失败-1。flags指明进程访问文件方式。mode指定新文件访问权限位。

关闭文件：int close(fd)

fd是需要关闭的文件的描述符，close返回操作结果，成功0，失败-1。

读文件：ssize_t read(int fd,void *buf,size_t n)

从描述符fd的当前文件复制n个字节到内存位置buf处。出错返回-1，EOF返回0，否则返回读的字节数。

写文件：ssize_t wirte(int fd,const void *buf,size_t n)

从内存位置buf处复制n个字节给描述符fd的当前文件。出错返回-1，否则返回写的字节数。

8.3 printf的实现分析

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

printf中调用了vsprintf，从vsprintf生成显示信息，vsprintf的作用是格接受确定输出格式的格式字符串fmt。用格式字符串对个数变化的参数进行格式化，产生格式化输出。

8-1 vsprintf内容

到write系统函数，将栈中参数放入寄存器，ecx存放字符个数，ebx存放第一个字符地址。

8-2 write内容

其中，int INT_VECTOR_SYS_CALLA代表通过系统调用syscall，将字符串中的字节从寄存器中通过总线复制到显卡的显存中，显存中存储的是字符的ASCII码。

8-3 INT_VECTOR_SYS_CALLA内容

字符显示驱动子程序：从ASCII到字模库到显示vram（存储每一个点的RGB颜色信息）。显示芯片按照刷新频率逐行读取vram，并通过信号线向液晶显示器传输每一个点（RGB分量）。

8.4 getchar的实现分析

异步异常-键盘中断的处理：键盘中断处理子程序。接受按键扫描码转成ascii码，保存到系统的键盘缓冲区。

getchar等调用read系统函数，通过系统调用读取按键ascii码，直到接受到回车键才返回。当程序调用getchar时，等待用户按键，输入的字符被存放在键盘缓冲区，直到用户输入回车，同时回车也放在缓冲区。这时getchar才开始从stdio流中每次读入一个字符。getchar函数的返回值是用户输入的字符的ASCII码，如出错返回-1，且将用户输入的字符回显到屏幕。如用户在按回车之前输入了不止一个字符，其他字符会保留在键盘缓存区中，等待后续getchar调用读取直到缓冲区字符读完后，才等待用户按键。

8.5本章小结

本章介绍linux的IO设备管理方法，并列出来Unix接口即函数，并通过分析hello中的printf和getchar实现来具体地体现这种IO函数。

结论

hello程序经历过程的整个流程如下：首先由程序员编写出hello.c，经过预处理生成hello.i,编译生成汇编代码hello.s,汇编产生二进制的hello.o，最终通过链接生成可执行程序hello， hello.c从编写出的代码变成了可执行文件，可以通过Shell进行进程调用执行hello,为hello调用fork创建子进程并调用evecve，载入并运行hello并进行段页式存储管理、内存映射、动态存储分配管理来实现相应的操作，同时一些涉及到IO的操作也调用了相应函数，在执行过程中对收到的信号和异常进行处理，在运行结束后通过指令对进程进行回收，内存恢复到运行前的状态。

从hello.c到变为可执行程序再到被回收，这个过程是依靠计算机系统来设计和实现的，这让我从以前没有关注过的角度重新认识了一个程序的一生。从代码到机器可识别的语言，再到shell调度分配进程执行和回收，背后是计算机系统精密严谨的执行步骤。哪怕只是一个基础的程序，背后也蕴含着计算机系统之间相互配合的深层逻辑。

附件

列出所有的中间产物的文件名，并予以说明起作用。

hello.c:编写的源代码

hello.i:预处理后的文件

hello.s:编译后的汇编代码

hello.o:汇编后的二进制文件

hello.elf:hello.o的elf文件

hello:链接后的可执行文件

hello1.elf:hello的elf文件

参考文献

[1] https://www.cnblogs.com/stevenchow/p/14930206.html

[2] C语言预处理作用与宏定义_孙浩的博客的博客-CSDN博客_预处理作用

[3] Linux内核分析（七）系统调用execve处理过程_|宇文拓>的博客-CSDN博客

[4] Linux kill命令 | 菜鸟教程

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

[6] 兰德尔E.布莱恩特，大卫R.奥哈拉伦.深入理解计算机系统

wdnn_wza

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
程序人生-Hello’s P2P

本文通过介绍hello程序在编写后形成可执行程序，在进程中调用最后被回收的过程，通过展示各中间文件，对从源文件到可执行文件变化过程进行分析，并运用计算机系统有关进程和虚拟内存等知识，结合hello程序的运行过程进行分析。
复制链接

扫一扫