【Linux取经路】初探进程地址空间

  
一、历史问题回顾

之前在先容 fork 函数的时候说过该函数返回了两次，至于为什么会返回两次，以及 fork 函数是如何做到返回两次的，在【Linux取经路】揭秘进程的父与子一文中已经做了具体的解释，忘了小伙伴可以点回去看看。在解释一个变量怎么会有两个不同值的时候，其时的说法是由于进程具有独立性，所以子进程把把父进程的数据拷贝了一份（写时拷贝），本质上是因为有两块空间，但是为什么同一个变量名可以让父子进程看到不同的内容其时并没有过多解释，因为这涉及到本日要讲解的步伐地址空间问题，接下来就让我们来一探究竟吧。
二、语言层面的地址空间

信托大家在学习 C/C++ 语言的时候，一定都见过下面这张图：

小Tips：上图是以32位机为底子的，32位地址线最多可以表现                                             2                            32                                       2^{32}                  232个地址，因为每个地址线上只有0和1两种可能，终极也就是有4G个地址，一个地址对应一个字节，所以就是                                             2                            32                                       2^{32}                  232个字节，所以总的地址空间大小就是4G。内核空间是给利用体系使用的，一个进程对应的所有的数据结构对象都存储在内核空间。
2.1 验证

1. #include <stdio.h>   
2. #include <stdlib.h>   
3.    
4. int g_val_1; // 定义一个未初始化全局变量   
5. int g_val_2 = 100; // 定义一个已初始化全局变量   
6. int main(int argc, char* argv[], char* env[])   
7. {   
8.     printf("code addr：%p\n", main);// 函数名代表的就是地址，通过打印 main 函数的地址来查看代码区的地址   
9.     const char *str = "Hello word";// 定义一个字符串常量   
10.     printf("read only string addr：%p\n", str);// 字符常量区的地址   
11.     printf("init global value addr：%p\n", &g_val_2);// 已初始化全局变量的地址   
12.     printf("uninit global value addr：%p\n", &g_val_1); // 未初始化全局变量的地址   
13.     char* men1 = (char*)malloc(100);   
14.     printf("heap addr-men1：%p\n", men1);// 堆区的地址   
15.     printf("stack addr-str：%p\n", &str); // 栈区的地址   
16.     static int a = 10;// 定义一个静态局部变量   
17.     printf("static a add：%p\n", &a); // 静态局部变量的地址   
18.     int i = 0;   
19.     for(; argv[i]; i++)   
20.         printf("argv[%d],addr：%p\n", i, argv[i]);// 打印命令行参数的地址   
21.     for(i = 0; env[i]; i++)   
22.         printf("env[%d],addr：%p\n", i, env[i]);// 打印环境变量的地址                                                                                                                                          
23.     return 0;   
24. }

复制代码

小Tips：堆栈空间是相对“生长”的。即堆区是先使用低地址再使用高地址，而栈区是先使用高地址再使用低地址。

1. // 栈区地址由高向低增长
2. int main()   
3. {   
4.     int a;   
5.     int b;   
6.     int c;   
7.     int d;   
8.     printf("stack addr：%p\n", &a);   
9.     printf("stack addr：%p\n", &b);   
10.     printf("stack addr：%p\n", &c);   
11.     printf("stack addr：%p\n", &d);                                                                                                                                                                              
12. }   

复制代码

1. // 堆区地址由低向高增长
2. int main()   
3. {   
4.     char* mem1 = (char*)malloc(100);   
5.     char* mem2 = (char*)malloc(100);   
6.     char* mem3 = (char*)malloc(100);   
7.     char* mem4 = (char*)malloc(100);   
8.     printf("Heap addr：%p\n", mem1);   
9.     printf("Heap addr：%p\n", mem2);   
10.     printf("Heap addr：%p\n", mem3);   
11.     printf("Heap addr：%p\n", mem4);                                                                                                                                                                              
12.     return 0;   
13. }

复制代码

小Tips：这里另有一个小细节，堆栈地址其实相聚很远，原因是堆栈之间另有一块区域，这块区域在讲解动静态库的时候为大家讲解。

1. // 静态变量地址的验证
2. int g_val_1; // 定义一个未初始化全局变量   
3. int g_val_2 = 100; // 定义一个已初始化全局变量   
4. int main()   
5. {   
6.     printf("code addr：%p\n", main);// 函数名代表的就是地址，通过打印 main 函数的地址来查看代码区的地址   
7.     const char *str = "Hello word";// 定义一个字符串常量   
8.     printf("read only string addr：%p\n", str);// 字符常量区的地址   
9.     printf("init global value addr：%p\n", &g_val_2);// 已初始化全局变量的地址   
10.     printf("uninit global value addr：%p\n", &g_val_1); // 未初始化全局变量的地址   
11.     char* men1 = (char*)malloc(100);   
12.     printf("heap addr-men1：%p\n", men1);   
13.     printf("stack addr-str：%p\n", &str);   
14.     static int a = 10;// 定义一个静态局部变量                                                                                                                                                                     
15.     printf("static a add：%p\n", &a);   
16.     return 0;   
17. }

复制代码

小Tips：从打印结果中可以看出，静态变量的地址和全局变量的地址非常靠近。这是因为 static 修饰的局部变量，编译的时候已经被编译到全局数据区了。注意静态局部变量被编译到全局数据区仅仅是延长了该变量的生命周期，作用域并没有改变，照旧只能在 main 函数的作用域中使用该变量。
注意：本末节的所有代码验证都是基于 Linux 利用体系的，雷同的代码放在 Windows 利用体系中的 VS 下跑出来的结果可能会有所不同。
三、虚拟地址的引入

下面通过一个例子来引入虚拟地址的概念。

1. int g_val = 100;                                                                                                                                                                                                  
2. int main()
3. {
4.     pid_t pid = fork();
6.     if(pid == 0)
7.     {
8.         int cnt = 5;
9.         // 子进程
10.         while(1)
11.         {
12.             printf("I am child, pid：%d, ppid：%d, g_val：%d, &g_val：%p\n", getpid(), getppid(), g_val, &g_val);
13.             sleep(1);
14.             if(cnt)
15.             {
16.                 cnt--;
17.             }   
18.             else   
19.             {   
20.                 g_val = 200;   
21.             }   
22.         }   
23.     }   
24.     else   
25.     {   
26.         // 父进程   
27.         while(1)   
28.         {   
29.             printf("I am parent, pid：%d, ppid：%d, g_val：%d, &g_val：%p\n", getpid(), getppid(), g_val, &g_val);   
30.             sleep(1);   
31.         }   
32.     }   
33.     return 0;   
34. }

复制代码

代码解释：上面这段代码中创建了一个子进程，并且界说了一个全局的变量 g_val，初始化为100。让父子进程同时去访问变量 g_val。在子进程要执行的代码片段中还界说了一个局部变量 cnt，初始化为5，每执行一次循环就让 cnt--，当 cnt 减到0的时候把 g_val 的值修改为200。

结果分析：从打印结果中可以看出，在子进程对 g_val 进行修改后，父子进程获取到的 g_val 的值并不一样，这符合我们的预期。因为父子进程相互独立，他们拥有各自的代码和数据，子进程在对 g_val 进行修改的时候会发生写时拷贝，这一点在前面的文章中已经讲过。但奇怪的是，为什么同一个地址，从该地址获取到的数据却不雷同。那么真想就只有一个，这个打印出来的地址一定不是真实存在的物理地址，因为真实存在的物理地址中只能存放一个数据，不可能同时存储两个不同的数据。因此我们可以得出一个结论：我们代码中打印出来的地址不是物理地址，一样平常把这个地址叫做线性地址大概虚拟地址。
3.1 初步解释这种现象——引入地址空间的概念

之前在先容进程的时候说过，一个进程就即是 task_struct + 代码和数据。但现实上事情并没有这么简单。一个进程一旦被创建出来，利用体系为了让该进程可以或许更好的运行，除了会为该进程创建对应的 PCB 对象之外，还会为这个进程创建一个地址空间（准确的叫法是进程地址空间）。我们平常在编码过程中使用的地址就是这个地址空间中的地址。进程地址空间本质上是内核为该进程创建的一个结构体对象。进程的 PCB 中是有对应的指针，指向该地址空间。进程地址空间中的虚拟地址和真是的物理地址是通过页表创建联系的，因此每个进程也会有一张页表。

小Tips：进程 PCB、进程地址空间、页表、物理地址四者之间的关系如上图所示。进程相干的代码和数据一定是存储在物理内存上的。
3.2 再来粗粒度明白上面的现象

根据进程独立性可知，每个进程都要有自己独立的 PCB、进程地址空间、页表。子进程的这些东西，大部分都是以父进程为模板创建出来的。对于全局变量 g_val，在物理内存上它始终只有一份，在父进程中 g_val 有自己的虚拟地址0X601054，创建子进程的时候，子进程根据父进程的地址空间创建出自己的地址空间，此时 g_val 对应的虚拟地址仍旧是0X601054。子进程的页表最初也是根据父进程的页表去创建的，因此子进程中 g_val 变量的虚拟地址和父进程中的一样，照旧0X601054，并且子进程页表中的虚拟地址和物理地址的映射关系照旧继续自父进程。因此，在子进程和父进程中都可以或许访问到 g_val 这个变量，并且在子进程和父进程中打印出来的 g_val 的地址都是一样的。父子进程共享同一份代码也是根据这个原理来实现的。当子进程要修改 g_val 变量的时候，由于父子进程的数据是相互独立的，该独立性表现在，在子进程去修改 g_val 的值不能影响到父进程，即，在父进程中 g_val 本身的值是100，在子进程将 g_val 的值修改成200的时候，父进程中 g_val 的值仍旧得保持100。所以子进程在修改的时候会发生写时拷贝，其本质就是利用体系发现子进程要去修改父子进程所共享的数据，利用体系会说：“子进程你等会儿，先别改”。然后利用体系会为子进程在物理内存中开辟一块空间来存储 g_val 的值，末了修改页表中的虚拟地址0X601054所对应的物理地址。这就是为什么打印出来的是通过一个地址，但是却有两个不同的值。

小Tips：写时拷贝是利用体系自动完成的，子进程并不知情。这就相称于你有一个朋友要到家里来玩，但是家里有点乱，你让他等会再来，期间你收拾房子的这个过程你朋友并不知情。利用体系就相称于是你，子进程就相称于是你的朋友。重新开辟空间，但是在这个过程中，左侧的虚拟地址是0感知的，它不关心也不会影响它。
四、细节解释

4.1 地址空间究竟是什么？

所谓的进程地址空间，本质是一个形貌进程可视范围的大小。并且地址空间内一定存在各种区域划分。因为每个进程未来都会有一个地址空间，所以利用体系一定会想办法把这些地址空间管理起来。管理的本质就是先形貌再组织。在语言层面要形貌一个事物只能通过结构体，因此地址空间本质是内核的一个数据结构对象，雷同 PCB 一样。Linux 中形貌地址空间的结构体是 struct mm_struct，该结构体中通过界说 start 和 end 字段来确定地址空间的范围，以及进行区域划分。

1. struct mm_struct
2. {
3.         unsigned long start_code; // 代码段的开始地址
4.         unsigned long end_code; // 代码段的结束地址
5.         unsigned long start_data; // 数据的首地址
6.         unsigned long end_data; // 数据的尾地址
7.         unsigned long start_brk; // 堆的首地址
8.         unsigned long brk; // 堆的尾地址
9.         unsigned long start_stack; // 进程栈的首地址
10.         //...
11. };

复制代码

小Tips：除了这些 start 和 end 对应的地址外，我们更应该注意在 start 和 end 范围内，连续的空间中，每一个最小单位都可以有地址，这个地址可以被直接使用。
4.2为什么要有地址空间

• 原因一：此中一个重要的原因是让进程以统一的视角看待内存。假如没有地址空间和页表，进程直接访问存储在内存上的数据和代码是非常麻烦的，起首进程需要将对应数据和代码的物理地址生存在进程 PCB 中，其次当一个进程从挂起状态大概壅闭状态被酿成运行状态的时候，其数据和代码会被重新加载到内存中，此时物理地址大概率是会发生变化的，如果没有地址空间，就需要去修改进程 PCB 中的内容，这个过程是非常复杂的，并且我们的可执行步伐加载到内存中并不一定是连续的，这一点会在背面进行讲解，因为可执行步伐并不是一次性全部加载到内存中，这就导致我们的代码在物理内存中是东一块西一块，很乱。而地址空间的存在会帮我们办理这些问题，我们可以对可执行步伐的虚拟地址进行连续的编址，如许就可以可以根据虚拟地址的先后序次去“重新”去执行可执行步伐，我们的进程不再需要担心可执行步伐现实存储在内存的什么位置。这一点也可以总结成，地址空间的存在将物理内存中的代码和数据从无序酿成了有序。
  
• 原因二：地址空间存在的第二个重要原因是，进程在访问内存的时候，增加一个转换的过程，在这个转换的过程中，可以对我们的寻址请求进行查察，一旦发生非常访问，比如越界访问，去修改只读数据等，会直接拦截，该请求不会到达物理内存，起到保护物理内存的作用。
  
• 原因三：因为有地址空间和页表的存在，将进程管理模块和内存管理模块进行解耦合。
  

小Tips：地址空间就相称于是利用体系给进程画的一个大饼。利用体系给每个进程划分的地空间范围都是0~4G（以32位利用体系为例）。每个进程都不知道对方的存在，都以为自己会独享这4G的空间。但现实并不是如许的，利用体系并不会一次性把这4G的空间给同一个进程，而是每个进程需要多少了就来申请多少。
4.3 页表

关于页表我们本日只做简单的先容，真正的页表并不是向上图中画的那样只有两个字段，而是有多个字段并且分为多级页表。本日关于页表只先容一下几点：
4.3.1 CR3寄存器

CPU 中有一个叫做 CR3 的寄存器（X86架构），该寄存器中生存的就是当前正在运行的进程的页表的地址，本质上属于当前进程的硬件上下文，当前进程被切换走了，是会把和该进程有关的所以硬件上下文数据带走的，固然就包括 CR3 寄存器中生存的该进程页表的首地址。该进程重新被 CPU 调理的时候，会把该这些硬件上下文数据重新加载到 CPU 里对应的寄存器中。CR3 寄存器中存的是物理地址。
4.3.2 页表是由页表项构成的

页表是有多个页表项构成的，一样平常的页表项有如下几个。Present（存在位）：表现该页是否存在于物理内存当中。如果存在数据才可以访问。如果不存在，可能会引发缺页非常。Read/Write（读/写位）：表现是否答应读取和写入。如果设置了“只读”，则只答应读取，写入会引发保护非常。代码段和字符常量区的数据所对应的页就是“只读”。User/Supervisor（用户/超等用户位）：用于指示是否答应用户态步伐访问该页。如果设置了“用户态可访问”，则用户步伐可以访问；否则，只有内核态可以访问。这些权限位通过硬件（如CPU）来执行，当步伐尝试访问内存时，硬件会查抄相应的页表项权限位，如果权限不符合要求，会触发相应的非常，比方页故障非常。如许可以确保对内存的合法访问，提高体系的安全性和稳定性。
小Tips：这里需要注意一下，单纯的物理内存是没有“只读”、“只写”等这些权限管理概念的，对于物理内存上的任何一块空间来说，都应该是可读可写的。所以我们在语言层面所说的代码区和字符常量区是只读的，本质上是因为存储代码和字符常量的物理内存所对应的页中设置了“只读”权限。

1. #include <stdio.h>   
2.       
3. int main()   
4. {   
5.     char* str = "Hello World";   
6.     *str = 'B';                                                                                                                                                                                                
7.     return 0;   
8. }

复制代码

小Tips：上面这段代码一看就是错误的写法。因为正常来说是需要在 char* str 的前面加上 const。但是加上后，这段代码会在编译时就报错（语法上说不外去，被 const 修饰后是不能再进行修改的）。而不加则是在运行时报错，这就是这段代码在运行时通过页表去 *str 中的内容，被硬件查抄出不符合要求，进而产生了非常。
4.3.3 缺页中断

当代利用体系几乎不做任何浪费空间和时间的事情，利用体系对大文件可以实现分批加载。这个其实很好明白，我们平常玩的大型电脑游戏动辄就几十个G，而我们的内存一样平常就只有8个G大概16个G，所以我们在玩这种大型游戏的时候，一定没有把和该游戏有关的所有文件一次性加载到内存中，而是接纳分批加载的计谋。利用体系对可执行步伐一样平常接纳的是惰性加载机制，即利用体系承诺给进程分配4G的空间（虚拟内存的大小），但现实在物理内存上是用多少加载多少。通过页表中的Present（存在位）页表项去判断，去标记该页是否存在于物理内存中，如果不存在就会发生缺页中断，将需要的代码和数据加载到物理内存中。可不要小瞧加载过程，这里会涉及到物理内存这么大，该申请那块儿内存，加载是加载可执行步伐的那一部分，加载完后物理地址如何填到页表里呢？这一系列和缺页中断相干的问题终极都是由利用体系中的内存管理模块来执行的。整个缺页中断的过程对进程是不可见的。正是因为地址空间和页表的存在，才实现了进程管理和内存管理在软件层面的解耦。进程要访问对应的代码和数据只需要知道虚拟地址即可，内存管理模块根据虚拟地址去判断是否要进行缺页中断。
小Tips：进程在被创建的时候，一定是先创建内核数据结构（进程 PCB、地址空间、页表…），然后再加载对应的可执行步伐。挂起状态就是将进程的代码和数据从内存中清出去，然后再将Present（存在位）标记位设置成不存在即可。
五、结语

本日的分享到这里就结束啦！如果觉得文章还不错的话，可以三连支持一下，春人的主页另有很多有趣的文章，欢迎小伙伴们前往点评，您的支持就是春人前进的动力！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。