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

CUI Jiaqi

已于 2022-11-14 12:39:04 修改

阅读量1.5k

点赞数 2

文章标签：程序人生

于 2022-11-14 09:23:54 首次发布

本文链接：https://blog.csdn.net/DearBCUI/article/details/127841424

版权

计算机系统

大作业

题目程序人生-Hello’s P2P

专业计算机科学与技术

学　　号 2021110509

班级 2103101

学生崔佳奇

指导教师刘宏伟

计算机科学与技术学院

2022年5月

摘要

本文介绍了一个C程序Hello是如何在Linux系统下完成它一生的使命的。

Hello程序源于简简单单的Hello.c，在经过GCC下预处理、编译、汇编、链接这一串多重考验，最终成为了伟大的Hello可执行目标文件。在命令行输入./Hello按下回车那一刻，Hello便开始了在计算机系统的历程，计算机系统对其进行进程管理、信号处理、存储管理等一系列操作，最终Hello在系统进程中消失殆尽。这篇文章我会结合我所学的知识对Hello的一生进行深入探索。

关键词： 预处理；汇编；编译；链接；信号；进程

目录

2.2在Ubuntu下预处理的命令 - 6 -

2.3 Hello的预处理结果解析 - 6 -

2.4 本章小结 - 7 -

第3章编译 - 8 -

3.1 编译的概念与作用 - 8 -

3.2 在Ubuntu下编译的命令 - 8 -

3.3 Hello的编译结果解析 - 8 -

3.4 本章小结 - 13 -

第4章汇编 - 14 -

4.1 汇编的概念与作用 - 14 -

4.2 在Ubuntu下汇编的命令 - 14 -

4.3 可重定位目标elf格式 - 14 -

4.4 Hello.o的结果解析 - 17 -

4.5 本章小结 - 20 -

第5章链接 - 21 -

5.1 链接的概念与作用 - 21 -

5.2 在Ubuntu下链接的命令 - 21 -

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

5.4 hello的虚拟地址空间 - 26 -

5.5 链接的重定位过程分析 - 26 -

5.6 hello的执行流程 - 27 -

5.7 Hello的动态链接分析 - 28 -

5.8 本章小结 - 28 -

第6章 hello进程管理 - 29 -

6.1 进程的概念与作用 - 29 -

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

6.3 Hello的fork进程创建过程 - 29 -

6.4 Hello的execve过程 - 29 -

6.5 Hello的进程执行 - 30 -

6.6 hello的异常与信号处理 - 31 -

6.7本章小结 - 34 -

第7章 hello的存储管理 - 35 -

7.1 hello的存储器地址空间 - 35 -

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

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

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

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

7.6 hello进程fork时的内存映射 - 39 -

7.7 hello进程execve时的内存映射 - 39 -

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

7.9动态存储分配管理 - 40 -

7.10本章小结 - 41 -

第8章 hello的IO管理 - 43 -

8.1 Linux的IO设备管理方法 - 43 -

8.2 简述Unix IO接口及其函数 - 43 -

8.3 printf的实现分析 - 43 -

8.4 getchar的实现分析 - 44 -

第1章概述

1.1 Hello简介

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

Hello的P2P(From Program to Process)

Hello的源程序是hello.c，hello.c在经过预处理器cpp后，得到了修改后的源程序hello.i，经过编译器cc1后得到了汇编文件hello.s，经过汇编器as后得到了可重定位目标文件hello.o，最后，经过链接器ld得到了可执行目标文件hello。执行程序 “hello”，shell就会通过fork()创建一个子进程，子进程执行execve()在子进程的上下文中加载并执行hello。到这里P2P告一段落。

Hello的O2O(From Zero-0 to Zero-0)

shell在调用完execve()执行hello程序之后，系统内核就会为hello进程映射一份虚拟内存。在hello进入程序入口之后，hello的相关数据就会被系统内核加载到物理内存中，至此hello便开始了他的时间——hello正式被系统开始运行。为了保证正常执行，系统内核还要为hello做一系列工作，比如分配时间片、分配逻辑控制流等。hello运行结束后，它便成为了zombie进程，之后shell会负责回收它，最后，shell删除了一切和hello相关的内容。

1.2 环境与工具

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

使用的软件环境：VMware16虚拟机 Ubuntu22.04.01 LTS

硬件环境：AMD Ryzen7 5800H处理器 16 G RAM 512 G HD Disk

开发工具：gcc，edb，gdb

1.3 中间结果

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

文件名	作用
hello.c	Hello的源文件
hello.i	Hello的修改了的源程序
hello.s	Hello的汇编文件
hello.o	Hello的可重定位目标文件
hello	Hello的可执行目标文件
elfheader.txt	hello.o的ELF头
secheader.txt	hello.o的节头部表
relahello.txt	hello.o的重定位节
hellosymbol.txt	hello.o的符号表
disassembly.txt	hello.o的反汇编
helloelfhead.txt	hello的ELF 头
hellosection.txt	hello的节头部表
hellodiss.txt	hello的反汇编
hellorela.txt	hello的重定位节
hellosym.txt	hello的符号表
tree.txt	进程树

表1 文件的中间结果

1.4 本章小结

这一章主要介绍了一下shell执行hello的全过程，简单说明了hello从hello.c变成hello的全过程，说明了进行实验的软硬件环境和测试工具。

第2章预处理

2.1 预处理的概念与作用

预处理的概念：

预处理就是通过预处理器cpp操作hello.c，根据hello.c中所有以 “#”开头的命令，比如一些宏定义、条件编译、include<.h>等，修改原始的C程序，并将引用的所有库展开合并成为一个完整的文本文件。

预处理的作用：

预处理可以是编写的程序更便于阅读、修改、移植和调回，同时还有利于模块化程序设计。

比如hello.c变成hello.i的过程，cpp把#include <unistd.h> 、#include <stdlib.h>、#include<stdio.h>这三个头文件插入到了程序的文本文件之中，方便编译器cc1进行下一步的操作，结果就是得到了hello.i。hello.i本质上也是一个C程序，只不过经过预处理后后缀通常为.i。

2.2在Ubuntu下预处理的命令

gcc预处理的命令 Linux>gcc hello.c -E -o hello.i

图2.1 利用gcc对hello.c进行预处理

2.3 Hello的预处理结果解析

hello.i的图标

图2.2 产生的hello.i

hello.i的内容

图2.3 hello.i中的代码部分

预处理过后生成的hello.i文件内的内容相比于hello.c多了不少，但是其中的代码内容被完整的保留了下来。hello.i中包含了很多宏展开，头文件中的内容。

2.4 本章小结

这一章介绍了C程序预处理的相关概念和作用，展现了Ubuntu下利用gcc预处理C文件的过程，并分析了.c和.i文件内容上的异同。

第3章编译

3.1 编译的概念与作用

编译的概念：

简单的来说，编译就是将预处理文件（hello.i）生成汇编文件（hello.s）的过程。编译器cc1对hello.i经过一系列的语法分析、语义分析，并根据优化等级（-O）进行优化之后生成了相应的汇编代码文件，汇编代码文件是一个文本文件。

编译的作用：

编译可以将源程序（高级语言C语言）翻译成为优化后的汇编代码（低级语言），在这个阶段还可以对源程序进行语法检查、调试、修改、覆盖、优化等操作，以及一些嵌入式汇编的处理。

3.2 在Ubuntu下编译的命令

gcc编译的命令 Linux>gcc -S hello.i -o hello.s

图3.1 利用gcc对hello.i进行编译

3.3 Hello的编译结果解析

3.3.1 数据

1. 字符串常量

在汇编文件标注.rodata这个位置上写着printf()中的字符串常量以及格式串

图3.2 .rodata节的字符串

主函数参数int argc和char **argv

查看main函数的汇编代码，按照x86-64的参数传递规则，argc应该存放在寄存器%edi中，argv应该存放在寄存器%rsi中。

程序的最开始就是把%rbp压入栈中，为main函数创建栈帧。

图3.3 main()函数的汇编代码

printf的参数

在调用printf之前寄存器%rdi和%rsi有所更新

图3.4 参数传递的汇编代码

从汇编代码来看恰好是argv中的元素传入了printf

3.3.2 全局函数

图3.5 全局函数的在汇编代码中的标志

从汇编代码的声明中可以看出 int main(int argc, char **argv)是被定义成为了全局函数，main中的字符串常量被存在.rodata节

3.3.3 赋值操作

在hello.c程序中，主要的赋值操作就是在for循环之前的i = 0，这一条指令，是利用mov指令来实现的

图3.6 赋值操作的汇编代码

此外程序中还有通过lea指令来实现赋值操作，lea指令是用来进行地址传送的，它只计算地址的值

图3.7 赋值操作的汇编代码

3.3.4 关系操作

(1)hello程序中，有一处条件判断指令：argc != 4，这个条件分支用于判断程序是否需要分区，对应的汇编代码是这个

图3.8 分支跳转比较的汇编代码

在程序的for循环之中，还有一处循环条件判断指令i < 9，对应的汇编代码是

图3.9 分支跳转比较的汇编代码

这条代码的意思就是去比较8和-4（%rbp）中的值，设置对应的条件码，jle来根据条件码确定是否需要进行循环跳转，jle的条件码判断是(ZF ^ OF) | ZF，就是如果满足小于或等于就进行跳转

3.3.5 算数操作

（1）在有关栈的操作的时候，通常都会利用sub指令来对%rsp中的栈指针进行加减8（或者是8的整数倍）操作，对应的汇编代码有

图3.10 栈指针的减法操作

在for循环之中，会有i ++这一操作，会使用到add指令给i的值加一，对应的汇编代码为

图3.11 参数的加一操作

3.3.6 控制转移指令

在汇编代码中，分支语句if - else以及各种循环都是通过条件跳转来实现的，对应的汇编代码有

图3.12 条件分支跳转的操作

3.3.7 类型转换

argv存放着参数字符串，但是sleep函数的参数类型是int型的，直接把参数传入是不可以的，所以程序调用了标准库中的函数atoi()，把字符串数字转换成int型的变量再传递给sleep使用，在汇编代码中就是call调用了atoi()函数进行类型转换的操作

图3.13 利用call调用atoi进行类型转换

3.3.8 函数操作

汇编代码中的函数调用通常都是使用call指令 + 函数名，在调用函数之前，汇编代码都会更新程序计数器%rip的值，确定函数调用结束后应该执行的指令。

在x86-64架构下，函数调用的时候前6个参数依次存放在%rdi，%rsi，%rdx，%rcx，%r8，%r9这6个通用寄存器中，其余的参数存放在栈。

函数的局部变量存放在栈中或者寄存器中。

函数的返回值存放在寄存器%rax中。

图3.14 利用call进行函数调用

函数调用结束后，会使用ret指令来结束调用

3.4 本章小结

本章介绍了在编译过程中C语言转换成汇编代码的过程，同时练习了阅读汇编代码，明白了C语言和汇编代码之间指令的相关联系，知道了一些汇编指令的微操作。

第4章汇编

4.1 汇编的概念与作用

汇编的概念：

汇编就是指汇编器as将汇编文件.s翻译成为机器语言，生成可重定位目标文件.o的过程，可重定位目标文件是二进制文件

汇编的作用：

汇编阶段可以生成可重定位目标文件，为下一步与其他程序相链接，和动态库，静态库相链接做好准备。

4.2 在Ubuntu下汇编的命令

gcc汇编的命令 Linux>gcc hello.s -c -o hello.o

图4.1 利用gcc汇编生成hello.o

生成的hello.o文件

图4.2 生成的hello.o文件

4.3 可重定位目标elf格式

ELF header（ELF头）的相关信息

查看指令 Linux> readelf -h hello.o > elfheader.txt

图4.3 hello.o文件的ELF头

ELF Header 文件包含了文件类别，数据类型，系统信息，链接器语法分析，程序入口地址等内容。

此外在文件靠前位置的Magic段主要是程序用来确认读入的是否是elf文件头，每次程序在读取elf头文件的时候，都会确认Magic是否正确，以防读入的不是elf文件。

Section Header（节头部表）的相关信息

查看指令 Linux> readelf -S hello.o > secheader.txt

节头部表包含了hello.o文件中各个节的类型、地址、大小、偏移量等信息

4.4 Hello.o的结果解析

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

说明机器语言的构成，与汇编语言的映射关系。特别是机器语言中的操作数与汇编语言不一致，特别是分支转移函数调用等。

查看指令 Linux> objdump -d -r hello.o > disassembly.txt

hello.o的反汇编

hello.c的汇编

hello.o：文件格式 elf64-x86-64

Disassembly of section .text:

0000000000000000 <main>:

0: f3 0f 1e fa endbr64

4: 55 push %rbp

5: 48 89 e5 mov %rsp,%rbp

8: 48 83 ec 20 sub $0x20,%rsp

c: 89 7d ec mov %edi,-0x14(%rbp)

f: 48 89 75 e0 mov %rsi,-0x20(%rbp)

13: 83 7d ec 04 cmpl $0x4,-0x14(%rbp)

17: 74 19 je 32 <main+0x32>

19: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 20 <main+0x20>

1c: R_X86_64_PC32 .rodata-0x4

20: 48 89 c7 mov %rax,%rdi

23: e8 00 00 00 00 call 28 <main+0x28>

24: R_X86_64_PLT32 puts-0x4

28: bf 01 00 00 00 mov $0x1,%edi

2d: e8 00 00 00 00 call 32 <main+0x32>

2e: R_X86_64_PLT32 exit-0x4

32: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)

39: eb 4b jmp 86 <main+0x86>

3b: 48 8b 45 e0 mov -0x20(%rbp),%rax

3f: 48 83 c0 10 add $0x10,%rax

43: 48 8b 10 mov (%rax),%rdx

46: 48 8b 45 e0 mov -0x20(%rbp),%rax

4a: 48 83 c0 08 add $0x8,%rax

4e: 48 8b 00 mov (%rax),%rax

51: 48 89 c6 mov %rax,%rsi

54: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 5b <main+0x5b>

57: R_X86_64_PC32 .rodata+0x29

5b: 48 89 c7 mov %rax,%rdi

5e: b8 00 00 00 00 mov $0x0,%eax

63: e8 00 00 00 00 call 68 <main+0x68>

64: R_X86_64_PLT32 printf-0x4

68: 48 8b 45 e0 mov -0x20(%rbp),%rax

6c: 48 83 c0 18 add $0x18,%rax

70: 48 8b 00 mov (%rax),%rax

73: 48 89 c7 mov %rax,%rdi

76: e8 00 00 00 00 call 7b <main+0x7b>

77: R_X86_64_PLT32 atoi-0x4

7b: 89 c7 mov %eax,%edi

7d: e8 00 00 00 00 call 82 <main+0x82>

7e: R_X86_64_PLT32 sleep-0x4

82: 83 45 fc 01 addl $0x1,-0x4(%rbp)

86: 83 7d fc 08 cmpl $0x8,-0x4(%rbp)

8a: 7e af jle 3b <main+0x3b>

8c: e8 00 00 00 00 call 91 <main+0x91>

8d: R_X86_64_PLT32 getchar-0x4

91: b8 00 00 00 00 mov $0x0,%eax

96: c9 leave

97: c3 ret

.file "hello.c"

.text

.section .rodata

.align 8

.LC0:

.string "\347\224\250\346\263\225: Hello 2021110509 \345\264\224\344\275\263\345\245\207 \347\247\222\346\225\260\357\274\201"

.LC1:

.string "Hello %s %s\n"

.text

.globl main

.type main, @function

main:

.LFB6:

.cfi_startproc

endbr64

pushq %rbp

.cfi_def_cfa_offset 16

.cfi_offset 6, -16

movq %rsp, %rbp

.cfi_def_cfa_register 6

subq $32, %rsp

movl %edi, -20(%rbp)

movq %rsi, -32(%rbp)

cmpl $4, -20(%rbp)

je .L2

leaq .LC0(%rip), %rax

movq %rax, %rdi

call puts@PLT

movl $1, %edi

call exit@PLT

.L2:

movl $0, -4(%rbp)

jmp .L3

.L4:

movq -32(%rbp), %rax

addq $16, %rax

movq (%rax), %rdx

movq -32(%rbp), %rax

addq $8, %rax

movq (%rax), %rax

movq %rax, %rsi

leaq .LC1(%rip), %rax

movq %rax, %rdi

movl $0, %eax

call printf@PLT

movq -32(%rbp), %rax

addq $24, %rax

movq (%rax), %rax

movq %rax, %rdi

call atoi@PLT

movl %eax, %edi

call sleep@PLT

addl $1, -4(%rbp)

.L3:

cmpl $8, -4(%rbp)

jle .L4

call getchar@PLT

movl $0, %eax

leave

.cfi_def_cfa 7, 8

ret

.cfi_endproc

.LFE6:

.size main, .-main

.ident "GCC: (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0"

.section .note.GNU-stack,"",@progbits

.section .note.gnu.property,"a"

.align 8

.long 1f - 0f

.long 4f - 1f

.long 5

.string "GNU"

.align 8

.long 0xc0000002

.long 3f - 2f

.long 0x3

.align 8

表3 两种汇编的比较

机器语言的构成

在计算机中，机器语言是由一系列的0、1代码构成的，在反汇编文件中可以看到机器代码由16进制数来描述

与汇编语言的映射关系

每一个机器指令序列都包含的操作码、操作数等信息，以此一一对应着每一种汇编指令，把汇编转换成为机器语言

机器语言中的操作数与汇编语言不一致分析

首先，机器语言中使用的操作数均为16进制表示，原始的汇编语言中的操作数都是10进制表示的。此外，编译阶段没有保留符号的名字，所以函数调用均写成主函数 + 偏移量的形式。

汇编代码hello.s中函数调用的call指令使用的是函数名称，反汇编代码中的call指令使用的是main函数相对偏移地址。由于函数只有在链接后才能确定所运行执行的地址（可以看到call指令对应机器代码的后四个字节均为0），所以为其添加重定位条目。

对机器语言而言，给定文件开始位置就能够将合法字节序列唯一地翻译解释成有效指令；但是机器反汇编代码的操作数却会被映射为特定字节或“小/大端序”来表示的十六进制立即数。

4.5 本章小结

在这一章中我完成了汇编操作，将hello.s，转换成为了hello.o，并仔细的分析并阅读了可重定位目标文件的ELF内的相关内容，如ELF头、节头部表、符号表以及课程定位节。同时完成了对hello.o的反汇编操作，明白了汇编操作的原理和作用，分析比较了hello.s和反汇编文件之间的异同，明白了机器指令和汇编代码之间的一一对应关系，同时了解了之后链接对于一个C程序的作用。
第5章链接

5.1 链接的概念与作用

链接的概念：

链接就是指把各种代码和数据片段收集并组合成为一个文件的过程，这个文件就叫做可执行目标文件，它可以直接被加载到内存中执行。链接分为三种：

编译时链接（链接静态库，也称静态链接），加载时链接和运行时链接（动态链接，用于链接动态库）。

链接的作用：

可以使分块编程成为可能，有了链接，程序员不用去编写巨大的程序，同时也方便了程序的维护，更新和优化。

5.2 在Ubuntu下链接的命令

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

链接的指令 Linux> 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 利用gcc链接

生成的可执行目标文件的图标

图5.2 生成的可执行目标文件

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

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

5.3.1 可执行目标文件的ELF Header

查看指令 Linux> readelf -a hello > helloelfhead.txt

图5.3 生成ELF头

具体内容如下

ELF 头：

Magic： 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00

类别: ELF64

数据: 2 补码，小端序 (little endian)

Version: 1 (current)

OS/ABI: UNIX - System V

ABI 版本: 0

类型: EXEC (可执行文件)

系统架构: Advanced Micro Devices X86-64

版本: 0x1

入口点地址： 0x4010f0

程序头起点： 64 (bytes into file)

Start of section headers: 13560 (bytes into file)

标志： 0x0

Size of this header: 64 (bytes)

Size of program headers: 56 (bytes)

Number of program headers: 12

Size of section headers: 64 (bytes)

Number of section headers: 27

Section header string table index: 26

表4 节头部表的内容

可以看到，相比于hello.o的ELF头，文件类型改变了，从REL变成了EXEC，入口点地址从0x0变成了0x4010f0（从不确定值变成了确定值），节头数量从14变成了27

5.3.2 可执行目标文件的Section Headers

利用指令 Linux> readelf -S hello > hellosection.txt

具体内容

There are 27 section headers, starting at offset 0x34f8:

节头：

[号] 名称类型地址偏移量

大小全体大小旗标链接信息对齐

[ 0] NULL 0000000000000000 00000000

0000000000000000 0000000000000000 0 0 0

[ 1] .interp PROGBITS 00000000004002e0 000002e0

000000000000001c 0000000000000000 A 0 0 1

[ 2] .note.gnu.pr[...] NOTE 0000000000400300 00000300

0000000000000030 0000000000000000 A 0 0 8

[ 3] .note.ABI-tag NOTE 0000000000400330 00000330

0000000000000020 0000000000000000 A 0 0 4

[ 4] .hash HASH 0000000000400350 00000350

0000000000000038 0000000000000004 A 6 0 8

[ 5] .gnu.hash GNU_HASH 0000000000400388 00000388

000000000000001c 0000000000000000 A 6 0 8

[ 6] .dynsym DYNSYM 00000000004003a8 000003a8

00000000000000d8 0000000000000018 A 7 1 8

[ 7] .dynstr STRTAB 0000000000400480 00000480

0000000000000067 0000000000000000 A 0 0 1

[ 8] .gnu.version VERSYM 00000000004004e8 000004e8

0000000000000012 0000000000000002 A 6 0 2

[ 9] .gnu.version_r VERNEED 0000000000400500 00000500

0000000000000030 0000000000000000 A 7 1 8

[10] .rela.dyn RELA 0000000000400530 00000530

0000000000000030 0000000000000018 A 6 0 8

[11] .rela.plt RELA 0000000000400560 00000560

0000000000000090 0000000000000018 AI 6 21 8

[12] .init PROGBITS 0000000000401000 00001000

000000000000001b 0000000000000000 AX 0 0 4

[13] .plt PROGBITS 0000000000401020 00001020

0000000000000070 0000000000000010 AX 0 0 16

[14] .plt.sec PROGBITS 0000000000401090 00001090

0000000000000060 0000000000000010 AX 0 0 16

[15] .text PROGBITS 00000000004010f0 000010f0

00000000000000cd 0000000000000000 AX 0 0 16

[16] .fini PROGBITS 00000000004011c0 000011c0

000000000000000d 0000000000000000 AX 0 0 4

[17] .rodata PROGBITS 0000000000402000 00002000

0000000000000042 0000000000000000 A 0 0 8

[18] .eh_frame PROGBITS 0000000000402048 00002048

00000000000000a0 0000000000000000 A 0 0 8

[19] .dynamic DYNAMIC 0000000000403e50 00002e50

00000000000001a0 0000000000000010 WA 7 0 8

[20] .got PROGBITS 0000000000403ff0 00002ff0

0000000000000010 0000000000000008 WA 0 0 8

[21] .got.plt PROGBITS 0000000000404000 00003000

0000000000000048 0000000000000008 WA 0 0 8

[22] .data PROGBITS 0000000000404048 00003048

0000000000000004 0000000000000000 WA 0 0 1

[23] .comment PROGBITS 0000000000000000 0000304c

000000000000002b 0000000000000001 MS 0 0 1

[24] .symtab SYMTAB 0000000000000000 00003078

0000000000000270 0000000000000018 25 7 8

[25] .strtab STRTAB 0000000000000000 000032e8

000000000000012e 0000000000000000 0 0 1

[26] .shstrtab STRTAB 0000000000000000 00003416

00000000000000e1 0000000000000000 0 0 1

Key to Flags:

W (write), A (alloc), X (execute), M (merge), S (strings), I (info),

L (link order), O (extra OS processing required), G (group), T (TLS),

C (compressed), x (unknown), o (OS specific), E (exclude),

D (mbind), l (large), p (processor specific)

表5 节头部表的内容

这里和hello.o不同的地方是，在可执行目标文件中，每个节的地址不是0x0，而是变成了根据节自身的大小和对齐规则计算得出的偏移量。

5.3.3 可执行目标文件的重定位节.rela.txt

利用指令 Linux> readelf -r hello > hellorela.txt

具体内容

重定位节 '.rela.dyn' at offset 0x530 contains 2 entries:

偏移量信息类型符号值符号名称 + 加数

000000403ff0 000100000006 R_X86_64_GLOB_DAT 0000000000000000 __libc_start_main@GLIBC_2.34 + 0

000000403ff8 000500000006 R_X86_64_GLOB_DAT 0000000000000000 __gmon_start__ + 0

重定位节 '.rela.plt' at offset 0x560 contains 6 entries:

偏移量信息类型符号值符号名称 + 加数

000000404018 000200000007 R_X86_64_JUMP_SLO 0000000000000000 puts@GLIBC_2.2.5 + 0

000000404020 000300000007 R_X86_64_JUMP_SLO 0000000000000000 printf@GLIBC_2.2.5 + 0

000000404028 000400000007 R_X86_64_JUMP_SLO 0000000000000000 getchar@GLIBC_2.2.5 + 0

000000404030 000600000007 R_X86_64_JUMP_SLO 0000000000000000 atoi@GLIBC_2.2.5 + 0

000000404038 000700000007 R_X86_64_JUMP_SLO 0000000000000000 exit@GLIBC_2.2.5 + 0

000000404040 000800000007 R_X86_64_JUMP_SLO 0000000000000000 sleep@GLIBC_2.2.5 + 0

表6 重定位节的内容

可以看到，相比于hello.o的重定位节，hello的重定位节被分成了两部分，包含动态链接的重定位内容，同时每一个部分都有了准确的偏移量，因而所有的加数都变成了0。

5.3.4 可执行目标文件的符号表

利用指令 Linux> readelf -s hello > hellosym.txt

具体内容如下

Symbol table '.dynsym' contains 9 entries:

Num: Value Size Type Bind Vis Ndx Name

0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND

1: 0000000000000000 0 FUNC GLOBAL DEFAULT UND _[...]@GLIBC_2.34 (2)

2: 0000000000000000 0 FUNC GLOBAL DEFAULT UND puts@GLIBC_2.2.5 (3)

3: 0000000000000000 0 FUNC GLOBAL DEFAULT UND [...]@GLIBC_2.2.5 (3)

4: 0000000000000000 0 FUNC GLOBAL DEFAULT UND [...]@GLIBC_2.2.5 (3)

5: 0000000000000000 0 NOTYPE WEAK DEFAULT UND __gmon_start__

6: 0000000000000000 0 FUNC GLOBAL DEFAULT UND atoi@GLIBC_2.2.5 (3)

7: 0000000000000000 0 FUNC GLOBAL DEFAULT UND exit@GLIBC_2.2.5 (3)

8: 0000000000000000 0 FUNC GLOBAL DEFAULT UND sleep@GLIBC_2.2.5 (3)

Symbol table '.symtab' contains 26 entries:

Num: Value Size Type Bind Vis Ndx Name

0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND

1: 0000000000000000 0 FILE LOCAL DEFAULT ABS crt1.o

2: 0000000000400330 32 OBJECT LOCAL DEFAULT 3 __abi_tag

3: 0000000000000000 0 FILE LOCAL DEFAULT ABS hello.c

4: 0000000000000000 0 FILE LOCAL DEFAULT ABS

5: 0000000000403e50 0 OBJECT LOCAL DEFAULT 19 _DYNAMIC

6: 0000000000404000 0 OBJECT LOCAL DEFAULT 21 _GLOBAL_OFFSET_TABLE_

7: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __libc_start_mai[...]

8: 0000000000404048 0 NOTYPE WEAK DEFAULT 22 data_start

9: 0000000000000000 0 FUNC GLOBAL DEFAULT UND puts@GLIBC_2.2.5

10: 000000000040404c 0 NOTYPE GLOBAL DEFAULT 22 _edata

11: 00000000004011c0 0 FUNC GLOBAL HIDDEN 16 _fini

12: 0000000000000000 0 FUNC GLOBAL DEFAULT UND printf@GLIBC_2.2.5

13: 0000000000404048 0 NOTYPE GLOBAL DEFAULT 22 __data_start

14: 0000000000000000 0 FUNC GLOBAL DEFAULT UND getchar@GLIBC_2.2.5

15: 0000000000000000 0 NOTYPE WEAK DEFAULT UND __gmon_start__

16: 0000000000402000 4 OBJECT GLOBAL DEFAULT 17 _IO_stdin_used

17: 0000000000404050 0 NOTYPE GLOBAL DEFAULT 22 _end

18: 0000000000401120 5 FUNC GLOBAL HIDDEN 15 _dl_relocate_sta[...]

19: 00000000004010f0 38 FUNC GLOBAL DEFAULT 15 _start

20: 000000000040404c 0 NOTYPE GLOBAL DEFAULT 22 __bss_start

21: 0000000000401125 152 FUNC GLOBAL DEFAULT 15 main

22: 0000000000000000 0 FUNC GLOBAL DEFAULT UND atoi@GLIBC_2.2.5

23: 0000000000000000 0 FUNC GLOBAL DEFAULT UND exit@GLIBC_2.2.5

24: 0000000000000000 0 FUNC GLOBAL DEFAULT UND sleep@GLIBC_2.2.5

25: 0000000000401000 0 FUNC GLOBAL HIDDEN 12 _init

表7 符号表的内容

这部分相比于hello.o多出了动态链接解析出来的符号。同时其他的符号也多了不少。

5.4 hello的虚拟地址空间

使用edb来分析一下hello，查看一下虚拟空间的位置在哪里

图5.4 虚拟地址空间开头

可以看到，hello的虚拟是从0x400000开始的，根据hello的节头部表，我们得知.interp的偏移量是0x0002e0，所以它的位置应该就在0x4002e0，查看一下

图5.5 .interp节的内容

确实是这样

同样的，还可以找到.rodata节的位置在0x402000

[17] .rodata PROGBITS 0000000000402000 00002000

0000000000000042 0000000000000000 A 0 0 8

图5.6 .rodata节的内容

看到了固定的字符串！

5.5 链接的重定位过程分析

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

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

首先对hello进行反汇编

指令 Linux> objdump -d -r hello > hellodiss.txt

hello：文件格式 elf64-x86-64

Disassembly of section .init:

0000000000401000 <_init>:

401000: f3 0f 1e fa endbr64

401004: 48 83 ec 08 sub $0x8,%rsp

401008: 48 8b 05 e9 2f 00 00 mov 0x2fe9(%rip),%rax # 403ff8 <__gmon_start__@Base>

40100f: 48 85 c0 test %rax,%rax

401012: 74 02 je 401016 <_init+0x16>

401014: ff d0 call *%rax

401016: 48 83 c4 08 add $0x8,%rsp

40101a: c3 ret

Disassembly of section .plt:

0000000000401020 <.plt>:

401020: ff 35 e2 2f 00 00 push 0x2fe2(%rip) # 404008 <_GLOBAL_OFFSET_TABLE_+0x8>

401026: f2 ff 25 e3 2f 00 00 bnd jmp *0x2fe3(%rip) # 404010 <_GLOBAL_OFFSET_TABLE_+0x10>

40102d: 0f 1f 00 nopl (%rax)

401030: f3 0f 1e fa endbr64

401034: 68 00 00 00 00 push $0x0

401039: f2 e9 e1 ff ff ff bnd jmp 401020 <_init+0x20>

40103f: 90 nop

401040: f3 0f 1e fa endbr64

401044: 68 01 00 00 00 push $0x1

401049: f2 e9 d1 ff ff ff bnd jmp 401020 <_init+0x20>

40104f: 90 nop

401050: f3 0f 1e fa endbr64

401054: 68 02 00 00 00 push $0x2

401059: f2 e9 c1 ff ff ff bnd jmp 401020 <_init+0x20>

40105f: 90 nop

401060: f3 0f 1e fa endbr64

401064: 68 03 00 00 00 push $0x3

401069: f2 e9 b1 ff ff ff bnd jmp 401020 <_init+0x20>

40106f: 90 nop

401070: f3 0f 1e fa endbr64

401074: 68 04 00 00 00 push $0x4

401079: f2 e9 a1 ff ff ff bnd jmp 401020 <_init+0x20>

40107f: 90 nop

401080: f3 0f 1e fa endbr64

401084: 68 05 00 00 00 push $0x5

401089: f2 e9 91 ff ff ff bnd jmp 401020 <_init+0x20>

40108f: 90 nop

Disassembly of section .plt.sec:

0000000000401090 <puts@plt>:

401090: f3 0f 1e fa endbr64

401094: f2 ff 25 7d 2f 00 00 bnd jmp *0x2f7d(%rip) # 404018 <puts@GLIBC_2.2.5>

40109b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)

00000000004010a0 <printf@plt>:

4010a0: f3 0f 1e fa endbr64

4010a4: f2 ff 25 75 2f 00 00 bnd jmp *0x2f75(%rip) # 404020 <printf@GLIBC_2.2.5>

4010ab: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)

00000000004010b0 <getchar@plt>:

4010b0: f3 0f 1e fa endbr64

4010b4: f2 ff 25 6d 2f 00 00 bnd jmp *0x2f6d(%rip) # 404028 <getchar@GLIBC_2.2.5>

4010bb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)

00000000004010c0 <atoi@plt>:

4010c0: f3 0f 1e fa endbr64

4010c4: f2 ff 25 65 2f 00 00 bnd jmp *0x2f65(%rip) # 404030 <atoi@GLIBC_2.2.5>

4010cb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)

00000000004010d0 <exit@plt>:

4010d0: f3 0f 1e fa endbr64

4010d4: f2 ff 25 5d 2f 00 00 bnd jmp *0x2f5d(%rip) # 404038 <exit@GLIBC_2.2.5>

4010db: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)

00000000004010e0 <sleep@plt>:

4010e0: f3 0f 1e fa endbr64

4010e4: f2 ff 25 55 2f 00 00 bnd jmp *0x2f55(%rip) # 404040 <sleep@GLIBC_2.2.5>

4010eb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)

Disassembly of section .text:

00000000004010f0 <_start>:

4010f0: f3 0f 1e fa endbr64

4010f4: 31 ed xor %ebp,%ebp

4010f6: 49 89 d1 mov %rdx,%r9

4010f9: 5e pop %rsi

4010fa: 48 89 e2 mov %rsp,%rdx

4010fd: 48 83 e4 f0 and $0xfffffffffffffff0,%rsp

401101: 50 push %rax

401102: 54 push %rsp

401103: 45 31 c0 xor %r8d,%r8d

401106: 31 c9 xor %ecx,%ecx

401108: 48 c7 c7 25 11 40 00 mov $0x401125,%rdi

40110f: ff 15 db 2e 00 00 call *0x2edb(%rip) # 403ff0 <__libc_start_main@GLIBC_2.34>

401115: f4 hlt

401116: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1)

40111d: 00 00 00

0000000000401120 <_dl_relocate_static_pie>:

401120: f3 0f 1e fa endbr64

401124: c3 ret

0000000000401125 <main>:

401125: f3 0f 1e fa endbr64

401129: 55 push %rbp

40112a: 48 89 e5 mov %rsp,%rbp

40112d: 48 83 ec 20 sub $0x20,%rsp

401131: 89 7d ec mov %edi,-0x14(%rbp)

401134: 48 89 75 e0 mov %rsi,-0x20(%rbp)

401138: 83 7d ec 04 cmpl $0x4,-0x14(%rbp)

40113c: 74 19 je 401157 <main+0x32>

40113e: 48 8d 05 c3 0e 00 00 lea 0xec3(%rip),%rax # 402008 <_IO_stdin_used+0x8>

401145: 48 89 c7 mov %rax,%rdi

401148: e8 43 ff ff ff call 401090 <puts@plt>

40114d: bf 01 00 00 00 mov $0x1,%edi

401152: e8 79 ff ff ff call 4010d0 <exit@plt>

401157: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)

40115e: eb 4b jmp 4011ab <main+0x86>

401160: 48 8b 45 e0 mov -0x20(%rbp),%rax

401164: 48 83 c0 10 add $0x10,%rax

401168: 48 8b 10 mov (%rax),%rdx

40116b: 48 8b 45 e0 mov -0x20(%rbp),%rax

40116f: 48 83 c0 08 add $0x8,%rax

401173: 48 8b 00 mov (%rax),%rax

401176: 48 89 c6 mov %rax,%rsi

401179: 48 8d 05 b5 0e 00 00 lea 0xeb5(%rip),%rax # 402035 <_IO_stdin_used+0x35>

401180: 48 89 c7 mov %rax,%rdi

401183: b8 00 00 00 00 mov $0x0,%eax

401188: e8 13 ff ff ff call 4010a0 <printf@plt>

40118d: 48 8b 45 e0 mov -0x20(%rbp),%rax

401191: 48 83 c0 18 add $0x18,%rax

401195: 48 8b 00 mov (%rax),%rax

401198: 48 89 c7 mov %rax,%rdi

40119b: e8 20 ff ff ff call 4010c0 <atoi@plt>

4011a0: 89 c7 mov %eax,%edi

4011a2: e8 39 ff ff ff call 4010e0 <sleep@plt>

4011a7: 83 45 fc 01 addl $0x1,-0x4(%rbp)

4011ab: 83 7d fc 08 cmpl $0x8,-0x4(%rbp)

4011af: 7e af jle 401160 <main+0x3b>

4011b1: e8 fa fe ff ff call 4010b0 <getchar@plt>

4011b6: b8 00 00 00 00 mov $0x0,%eax

4011bb: c9 leave

4011bc: c3 ret

Disassembly of section .fini:

00000000004011c0 <_fini>:

4011c0: f3 0f 1e fa endbr64

4011c4: 48 83 ec 08 sub $0x8,%rsp

4011c8: 48 83 c4 08 add $0x8,%rsp

4011cc: c3 ret

表8 反汇编的内容

分析：

hello的反汇编文件中可以看出，相比于hello.o，里面所有的不确定的地址值都变得确定了，这说明链接器完成了对于hello的重定位工作。
hello中增加了很多hello.o中没有，但是定义在了动态库并被hello直接使用的函数。在链接过程中，链接器ld完成了对它们的符号解析和重定位。
相比于hello.o程序中大量使用了间接跳转。

5.6 hello的执行流程

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

利用edb执行hello

图5.7 利用edb执行hello

调用的子程序名和程序地址

子程序名	程序地址
_start	0x4010f0
_init	0x401000
main	0x40112d
puts@plt	0x401090
exit@plt	0x4010d0
_fini	0x4011c0
sleep@plt	0x4010e0
atoi@plt	0x4010c0
printf@plt	0x4010a0
getchar@plt	0x4010b0

表9 子程序地址

5.7 Hello的动态链接分析

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

动态链接采用了延迟加载的策略，只有在调用函数的时候才会进行符号的映射。动态链接通过使用偏移量表GOT和过程链表PLT的协同工作来实现。

GOT表中存放着函数的目标地址，PLT表则使用GOT中的地址来跳转到目标函数，在程序执行的过程中，dl_init负责修改PLT和GOT。

首先先找到GOT的地址

.got PROGBITS 0000000000403ff0 00002ff0 0000000000000010 0000000000000008 WA 0 0 8 ->起始地址为403ff8

调用edb查看调用dl_init前后的变化

调用前

调用后

图5.8 调用前后地址的变化

5.8 本章小结

这一章我介绍了hello.o的链接过程，分析比较了hello和hello.o的ELF文件的异同，仔细分析了动态链接过程中的各种变化，理解了链接的原理过程。

第6章 hello进程管理

6.1 进程的概念与作用

进程的概念：

经典的定义就是一个执行中程序的实例，每一个进程都有它自己的地址空间，一般情况下，包括文本区域、数据区域、和堆栈。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储区着活动过程调用的指令和本地变量。

进程的作用：

进程为用户提供了以下假象：

(1) 我们的程序好像是系统中当前运行的唯一程序一样，我们的程序好像是独占的使用处理器和内存。

(2) 处理器好像是无间断的执行我们程序中的指令，我们程序中的代码和数据好像是系统内存中唯一的对象。

图6.1 进程的逻辑控制流

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

Shell-bash的作用：

shell是一个交互型的应用程序，代表用户运行其他程序，执行一系列的读、求值步骤，然后终止。

Shell-bash的处理流程：

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_t fork()；创建的子进程得到与父进程用户级虚拟地址空间相同的（但是物理空间是独立的，所以两个进程中的变量值是不相关联的）一份副本，包括代码和数据段、堆、共享库以及用户栈。

子进程还获得与父进程任何打开文件描述符相同的副本，这就意味着当父进程调用fork()函数时，子进程可以读取父进程中打开的任何文件。

父进程与创建的子进程之间最大的区别在于它们有不同的PID。子进程中，fork()返回0。父进程中fork()会返回子进程的PID，因为子进程的PID总是为非零，返回值就提供一个明确的方法分辨程序是在父进程还是在子进程中。还可以进行多进程处理任务。

利用进程图就可以很形象的描述fork()的作用

图6.2 进程图示意

6.4 Hello的execve过程

execve()函数在当前进程的上下文中加载并运行一个新程序。execve()函数加载并运行可执行目标文件hello，且带参数列表argv和环境变量envp。只有当出现错误时，例如：找不到文件名，调用发生错误，execve()才会返回到调用程序，调用成功不会返回。

与fork()不同，fork()一次调用两次返回，execve()一次调用从不返回（必须是成功调用）。

图6.3 用户栈的结构

6.5 Hello的进程执行

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

上下文信息

上下文就是内核重新启动一个被抢占的进程所需要的状态，它由通用寄存器、浮点寄存器、程序计数器、用户栈、状态寄存器、内核栈和各种内核数据结构等对象的值构成（不包含代码段和数据段）。

进程的时间片

一个进程执行它的控制流的一部分的每一时间段叫做时间片。

用户模式和内核模式

处理器通常使用一个寄存器提供两种模式的区分，该寄存器描述了进程当前享有的特权，当没有设置模式位时，进程就处于用户模式中，用户模式的进程不允许执行特权指令，也不允许直接引用地址空间中内核区内的代码和数据；设置模式位时，进程处于内核模式，该进程可以执行指令集中的任何命令，并且可以访问系统中的任何内存位置。上下文切换的时候，进程就处于内核模式。

图6.3 上下文切换

对于hello程序，程序在调用了sleep()后就会进入内核模式，并会进行上下文切换。程序运行到getchar()的时候，内核也会进行上下文切换，让其他进程运行。

除此之外，系统还会为hello程序分配时间片，只要hello时间片被用完，即使没有执行到getchar()或者sleep()函数，系统就会判断当前程序的运行时间已经足够久了，从而进行上下文切换，将处理器让给其他进程，这样可以提升程序运行的效率。

6.6 hello的异常与信号处理

Linux环境下异常的种类

类别	原因	异步/同步	返回行为
中断	来自I/O设备的信号	异步	总是返回到下一条指令
陷阱	有意的异常	同步	总是返回到下一条指令
故障	潜在可恢复的错误	同步	可能返回到当前指令
终止	不可恢复的错误	同步	不会返回

hello运行过程中会出现哪些异常

中断：在执行hello程序的时候，由处理器外部的I/O设备的信号引起的。I/O设备通过像处理器芯片上的一个引脚发信号，并将异常号放到系统总线上，来触发中断。这个异常号标识了引起中断的设备。在当前指令完成执行后，处理器注意到中断引脚的电压变高了，就从系统总线读取异常号，然后调用适当的中断处理程序。在处理程序返回前，将控制返回给下一条指令。
陷阱：hello在执行sleep()函数的时候就会发生陷阱异常。
故障：hello在执行的时候可能会出现缺页的情况，导致缺页故障。
终止：终止大多是由于不可恢复的致命错误而导致的，通常都是一些硬件上的错误。

故障处理的方式

图1 异常处理

图2 陷阱处理

图3 故障处理

图4 终止处理

运行时输入

1. 运行时键入ctrl + c，向hello发送SIGINT信号

图6.4 发送信号

运行时输入ctrl + z，向hello发送SIGTSTP信号

图6.5 发送信号

此时输入ps ，监视后台程序

图6.5 进程监视

可以看到hello在后台被挂起了

输入jobs来查看当前被暂停的进程

图6.6 进程状态查看

输入pstree，查看进程树

systemd-+-ModemManager---2*[{ModemManager}]

|-NetworkManager---2*[{NetworkManager}]

|-VGAuthService

|-accounts-daemon---2*[{accounts-daemon}]

|-acpid

|-avahi-daemon---avahi-daemon

|-bluetoothd

|-colord---2*[{colord}]

|-cron

|-cups-browsed---2*[{cups-browsed}]

|-cupsd

|-dbus-daemon

|-gdm3-+-gdm-session-wor-+-gdm-wayland-ses-+-gnome-session-b---2*[{gnome-session-b}]

| | | `-2*[{gdm-wayland-ses}]

| | `-2*[{gdm-session-wor}]

| `-2*[{gdm3}]

|-gnome-keyring-d---3*[{gnome-keyring-d}]

|-irqbalance---{irqbalance}

|-2*[kerneloops]

|-networkd-dispat

|-packagekitd---2*[{packagekitd}]

|-polkitd---2*[{polkitd}]

|-power-profiles----2*[{power-profiles-}]

|-rsyslogd---3*[{rsyslogd}]

|-rtkit-daemon---2*[{rtkit-daemon}]

|-snapd---13*[{snapd}]

|-switcheroo-cont---2*[{switcheroo-cont}]

|-systemd-+-(sd-pam)

| |-at-spi2-registr---2*[{at-spi2-registr}]

| |-2*[dbus-daemon]

| |-dconf-service---2*[{dconf-service}]

| |-evolution-addre---5*[{evolution-addre}]

| |-evolution-calen---8*[{evolution-calen}]

| |-evolution-sourc---3*[{evolution-sourc}]

| |-fcitx---2*[{fcitx}]

| |-fcitx-dbus-watc

| |-gedit---3*[{gedit}]

| |-2*[gjs---6*[{gjs}]]

| |-gnome-session-b-+-at-spi-bus-laun-+-dbus-daemon

| | | `-3*[{at-spi-bus-laun}]

| | |-evolution-alarm---5*[{evolution-alarm}]

| | |-gsd-disk-utilit---2*[{gsd-disk-utilit}]

| | |-update-notifier---3*[{update-notifier}]

| | `-3*[{gnome-session-b}]

| |-gnome-session-c---{gnome-session-c}

| |-gnome-shell-+-Xwayland

| | |-gjs---7*[{gjs}]

| | `-10*[{gnome-shell}]

| |-gnome-shell-cal---5*[{gnome-shell-cal}]

| |-gnome-terminal--+-3*[bash]

| | |-bash-+-hello

| | | `-pstree

| | `-3*[{gnome-terminal-}]

| |-goa-daemon---3*[{goa-daemon}]

| |-goa-identity-se---2*[{goa-identity-se}]

| |-gsd-a11y-settin---3*[{gsd-a11y-settin}]

| |-gsd-color---3*[{gsd-color}]

| |-gsd-datetime---3*[{gsd-datetime}]

| |-gsd-housekeepin---3*[{gsd-housekeepin}]

| |-gsd-keyboard---3*[{gsd-keyboard}]

| |-gsd-media-keys---3*[{gsd-media-keys}]

| |-gsd-power---3*[{gsd-power}]

| |-gsd-print-notif---2*[{gsd-print-notif}]

| |-gsd-printer---2*[{gsd-printer}]

| |-gsd-rfkill---2*[{gsd-rfkill}]

| |-gsd-screensaver---2*[{gsd-screensaver}]

| |-gsd-sharing---3*[{gsd-sharing}]

| |-gsd-smartcard---3*[{gsd-smartcard}]

| |-gsd-sound---3*[{gsd-sound}]

| |-gsd-wacom---3*[{gsd-wacom}]

| |-gsd-xsettings---3*[{gsd-xsettings}]

| |-gvfs-afc-volume---3*[{gvfs-afc-volume}]

| |-gvfs-goa-volume---2*[{gvfs-goa-volume}]

| |-gvfs-gphoto2-vo---2*[{gvfs-gphoto2-vo}]

| |-gvfs-mtp-volume---2*[{gvfs-mtp-volume}]

| |-gvfs-udisks2-vo---3*[{gvfs-udisks2-vo}]

| |-gvfsd-+-gvfsd-dnssd---2*[{gvfsd-dnssd}]

| | |-gvfsd-network---3*[{gvfsd-network}]

| | |-gvfsd-smb-brows---4*[{gvfsd-smb-brows}]

| | |-gvfsd-trash---2*[{gvfsd-trash}]

| | `-2*[{gvfsd}]

| |-gvfsd-fuse---5*[{gvfsd-fuse}]

| |-gvfsd-metadata---2*[{gvfsd-metadata}]

| |-nautilus---5*[{nautilus}]

| |-pipewire---{pipewire}

| |-pipewire-media----{pipewire-media-}

| |-pulseaudio---3*[{pulseaudio}]

| |-snap-store---4*[{snap-store}]

| |-snapd-desktop-i---3*[{snapd-desktop-i}]

| |-sogoupinyin-ser---9*[{sogoupinyin-ser}]

| |-sogoupinyin-wat---5*[{sogoupinyin-wat}]

| |-tracker-miner-f---5*[{tracker-miner-f}]

| |-vmtoolsd---3*[{vmtoolsd}]

|-systemd-journal

|-systemd-logind

|-systemd-oomd

|-systemd-resolve

|-systemd-timesyn---{systemd-timesyn}

|-systemd-udevd

|-udisksd---4*[{udisksd}]

|-unattended-upgr---{unattended-upgr}

|-upowerd---2*[{upowerd}]

|-vmtoolsd---3*[{vmtoolsd}]

|-vmware-vmblock----2*[{vmware-vmblock-}]

`-wpa_supplicant

表11 进程树

可以从进程树中看到hello这个进程被挂起了

输入fg，让hello重新到前台执行

图6.7 程序运行

运行kill指令，让hello终止运行

先查看一下hello的PID

图6.8 程序运行

输入 kill -9 3993就可以了

图6.9 杀死进程

再查看一下进程

图6.10 查看进程

hello已经被杀死了

运行时输入回车

图6.11 运行时按回车

并没有什么异常

在键盘上乱按

图6.12 运行时乱按

可以看到随便乱按并不会影响到当前进程的运行，不仅如此，shell会依次记录你的输入的命令，在当前进程运行结束之后去依次处理的输入的内容。

6.7本章小结

这一章我详细介绍了进程的概念和作用，并仔细分析了fork()和execve()的调用方法，过程和作用，上下文切换的原理和过程，还有对于hello的信号异常的处理与分析。

第7章 hello的存储管理

7.1 hello的存储器地址空间

各种地址空间的概念：

逻辑地址：逻辑地址指的是在汇编代码中通过偏移量+段基址得到的地址，所以汇编代码中所有显示的地址都是逻辑地址。

物理地址：计算机系统的主存被组织成一个由M个连续的字节大小的单元组成的数组。每个字节都有一个唯一的物理地址。第一个字节的地址为0，写下来的字节地址为1，再下一个为2，以此类推。所以物理地址就像是一个大的数组。

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

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

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

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

在Intel下，对于cache的访问时通过物理地址来实现的，一个物理地址可以被分成三个部分：标记位，组索引，块偏移

图7.1 物理地址的构成

Intel i7芯片中的cache都是以组相联的方式构成的，也就是说cache被分成了很多块，块分成了很多组，组内有分成了很多行。在访问cache的时候，首先通过组索引来找到我们的地址在Cache中所对应的组号，再通过标记和Cache的有效位来判断我们的内容是否在Cache中。若命中则通过块偏移读取我们要的数据，若不命中则从下一级Cache（准确的来说是下一层存储空间，因为L3 cache不命中会从主存DRAM中寻找）中寻找。

讨论一个例子，这个是我的电脑L1 D-cache 的信息

图7.2 L1D-cache的信息

可以知道每一个L1 D-cache的大小为32KB，每一组cache中有8行，查询我的CPU的配置，可以知道每一块是64B，物理地址位数是52位，经过公式

C=S *E*B，可以知道我的电脑中组索引为6位，块偏移为6位，标志位40位。

7.6 hello进程fork时的内存映射

7.7 hello进程execve时的内存映射

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

7.9动态存储分配管理

7.10本章小结

这一章我简单介绍了计算机系统中的逻辑地址和物理地址这两个地址空间的概念，并且详细分析了物理地址的构成，含义，寻址方式，结合自己电脑的配置完成了对于cache寻址方式的了解。

第8章 hello的IO管理

8.1 Linux的IO设备管理方法

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;

}

printf函数是一个变参数函数，也就是说它在使用的过程中参数的个数是不确定的。

函数中的va_list就是typedef后的char*字符串。va_list arg = (va_list)((char*)(&fmt) + 4);就是得到了后面所有参数（就是...）中的第一个量。

之后printf调用vsprintf函数。vsprintf函数将我们需要输出的字符串格式化并把内容存放在buf（缓冲区）中。并返回要输出的字符个数i。然后调用系统函数write来在屏幕上打印buf中的前i个字符，也就是我们要输出的格式串。

调用write系统函数后，程序进入到陷阱，系统调用 int 0x80或syscall指令等，通过字符驱动子程序打印printf中的内容。

最后程序返回我们实际输出的字符数量i，也就是说printf是由返回值的，只是我们很少去使用。

8.4 getchar的实现分析

查看一下getchar()函数的定义

int getchar (void)

{

static char buf [BUFSIZ];

static char *bb = buf;

static int n = 0;
if (n == 0)
n = read(0, buf, BUFSIZ);
bb = buf;

}

return(--n >= 0)? (unsigned char) *bb++ : EOF;

}

当用户按键时，键盘接口会得到一个代表该按键的键盘扫描码，同时产生一个中断请求，中断请求抢占当前进程运行键盘中断子程序，键盘中断子程序先从键盘接口取得该按键的扫描码，然后将该按键扫描码转换成ASCII 码，保存到系统的键盘buf缓冲区之中。

getchar() 函数落实到底层调用了系统函数 read()，通过系统调用 read() 读取存储在键盘缓冲区中的 ASCII 码直到读到回车符然后返回整个字串，getchar() 进行封装，大体逻辑是读取字符串的第一个字符然后返回。

8.5本章小结

根据我的所学知识，这一章我总结介绍了printf()和getchar()这两个I/O函数的具体实现过程，理解了计算机系统是如何实现内部和外部相互联系并且同时运作的。

结论

Hello最初只是一个简简单单的hello.c文件，只是一些简简单单的文本，它能够在屏幕上显示出 “Hello World!”，真的经历了许多考验。

一开始，hello.c只是默默的存在磁盘当中，终于有一刻，有一位程序员使用了gcc，让hello.c经过了预处理，其中的头文件被展开，宏常量被存入了hello.i中。接着，编译器cc1又对它进行了一番处理，hello.c变成了较为低级的存在——hello.s汇编代码，但是这远远不够，只有经历了编译器的考验，变成机器能够认识的语言——机器语言，才能够继续它的使命。俗话说，一木不成林，仅仅靠hello.o单个程序还是难以运行，只有经过了链接器的处理，有了动态库的合作，hello.c才最终成为了伟大的hello——可执行目标文件。

当在命令行中输入了./hello之后，“Hello World!”完美的出现在了屏幕上，这个过程还有这shell的功劳，shell解析了输入命令行的命令，调用fork()创建子进程，并用execve()在子进程的上下文中加载程序，经过一系列操作，hello终于进入了CPU的内部。

最后，hello运行完成，它完成了它伟大的使命，默默的消失在了茫茫的计算机系统中，被回收，再次回到了孤单的磁盘之中。

计算机系统，知识很多，难度很大，但是内容真的很有趣，我很喜欢，我一定会在未来继续深入探究。

附件

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

文件名	作用
hello.c	Hello的源文件
hello.i	Hello的修改了的源程序
hello.s	Hello的汇编文件
hello.o	Hello的可重定位目标文件
hello	Hello的可执行目标文件
elfheader.txt	hello.o的ELF头
secheader.txt	hello.o的节头部表
relahello.txt	hello.o的重定位节
hellosymbol.txt	hello.o的符号表
disassembly.txt	hello.o的反汇编
helloelfhead.txt	hello的ELF 头
hellosection.txt	hello的节头部表
hellodiss.txt	hello的反汇编
hellorela.txt	hello的重定位节
hellosym.txt	hello的符号表
tree.txt	进程树