【Linux】进程7——进程地址空间

1.再谈fork

之前提到了fork之后对父子进程返回不同的id值，给父进程返回子进程的pid，给子进程返回0，所以对于一个id如何存储两个值的说法，在我们之前已经提到过了一个概念叫做写时拷贝，就是在子进程要想修改父进程的id变量是，操作系统就会给子进程重新划分一块空间，将父进程的空间中的内容拷贝给子进程，再让子进程去修改id值，今天我们就从内存角度深度理解这个过程！

2、程序地址空间

在我们之前学习C语言的时候大家应该都见过这张地址表。

在我们32位机器下，这张地址表一共有4GB的大小，因为我们的CPU有32根总线的话，它的寻址范围就是 $2^{32}$ ,所以能接受内存的最大大小就是4GB。

我们通过代码来验证一下

#include <iostream>
#include <cstdio>

using namespace std;
int g_val_1;
int g_val_2 = 100;

int main(int argc,char *argv[],char *env[])
{
    printf("正文代码区:%p\n",main);
    const char *str = "hello world";
    printf("字符常量区:%p\n",str);
    printf("已初始化数据区:%p\n",&g_val_2);
    printf("未初始化数据区:%p\n",&g_val_1);
    char *mem = (char*)malloc(10);
    printf("堆区:%p\n",mem);
    printf("栈区:%p\n",&str);

    static int a = 0;
    printf("静态局部变量地址:%p\n",&a);
    
    printf("命令行参数argv[0]:%p\n",argv[0]);
    printf("环境变量env[0]:%p\n",env[0]);

    return 0;
}

从上面打印信息可以看到我们内存中各个区域的分配确实是按照那张程序地址空间表进行分配的，而且我们在函数中定义的静态局部变量其实是属于全局数据区的。

我们再来单独打印一些栈区地址：

#include<stdio.h>
int main()
{
    int a = 0;
    int b = 0;
    int c = 0;
    int d = 0;
    printf("栈区:%p\n",&a);
    printf("栈区:%p\n",&b);
    printf("栈区:%p\n",&c);
    printf("栈区:%p\n",&d);

    return 0;
}

我们可以看到栈区的地址是由高向低增长的，这说明栈区是先使用高地址在使用低地址。这正是因为我们栈这个数据结构是需要压栈的，所以先进去的往往是在高地址处。

我们再来打印一波堆区地址：

#include<stdio.h>
int main()
{
    char *mem = (char*)malloc(10);
    char *mem1 = (char*)malloc(10);
    char *mem2 = (char*)malloc(10);
    char *mem3 = (char*)malloc(10);
    printf("堆区:%p\n",mem);
    printf("堆区:%p\n",mem1);
    printf("堆区:%p\n",mem2);
    printf("堆区:%p\n",mem3);


    return 0;
}

可以看到堆区的地址是由低向高增长，此时我们可以得到一个结论就是：堆栈之间是相对增长的。

对于中间这块共享区，我们在以后讲解动静态库的时候再来聊。

3、虚拟地址&&线性地址

为了更深入地理解，我们用做了这样一个测试：

#include <iostream>
#include <cstdio>
#include <unistd.h>
using namespace std;
int g_val = 100;
int main()
{
    pid_t id = fork();
    if (id == 0) // 子进程
    {
        int cnt = 3;
        while (true)
        {
            printf("i am child, pid:%d,ppid:%d,g_val:%d,&g_val:%p\n", getpid(), getppid(), g_val, &g_val);
            sleep(1);
            if (cnt--);
            else g_val = 200;
        }
    }
    else
    {
        while (true)
        {
            printf("i am parent, pid:%d,ppid:%d,g_val:%d,&g_val:%p\n", getpid(), getppid(), g_val, &g_val);
            sleep(1);
        }
    }
    return 0;

}

可以看出的是，父子进程中对于同一个变量打印的地址是一样的，这是因为子进程以父进程为模板，因为都没有对数据进行修改，所以这里变量地址也是一样的。

我们再看一段代码，对上面的代码进行一些修改：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int g_val = 10;

int main()
{
	int ret = fork();
	if (ret < 0){
		// error
		perror("fork error");
		return 0;
	}
	else if (ret == 0){
		// child
		int count = 0;
	    while (1){
	      printf("修改数据前：\n");
	      printf("I am child,pid:%d %d:%p\n", getpid(), g_val, &g_val);
	      sleep(1);
	      count++;
	      if (count == 3){
	        g_val = 20;// 子进程对数据进行修改
	        printf("修改数据后：\n");
	    }
	}
	else{
		// parent
		while (1){
			printf("I am parent:pid:%d %d:%p\n", getpid(), g_val, &g_val);
			sleep(1);
		}
	}
	return 0;
}

代码运行结果如下：

可以发现，子进程对数据进行修改后，父子进程打印g_val的值是不一样的，但是地址却是一样的。
分析结果得出的原因:

        在fork创建子进程那一篇博客中，我们说过，父子进程共享代码和数据，但是如果有一方对数据做出了修改，那么修改方将堆被修改的这一份数据写实拷贝，这一份数据各自私有，所以根据我们现有的知识可以推断出变量g_val在父子进程中的地址应该是不一样的，但是测试发现他们的这个变量地址是一样的，但是内容却不一样。
        难道对于同一块空间可以有两份不同的数据吗？
答案是否定的。
        所以我们可以得出结论，我们上面看到的地址绝对不是物理地址。

事实上，在Linux地址下，这种地址叫做虚拟地址（下面讨论）。且平时我们在C/C++语言打印所看到的地址都是虚拟地址，物理地址对于我们用户是看不到的，由OS管理。

【注意】：以上代码都是在Linux下的结果，Windows下的vs中可能会有所不同。

3.1.初步理解这种现象–引入地址空间概念

在我们创建进程时，一旦进程的PCB（进程控制块）被创建出来，操作系统会为该进程创建一个叫做地址空间的东西，以使该进程能够更好地运行。

除了内核创建PCB这样的内核结构之外，地址空间是操作系统为每个进程提供的独立空间，用于存储进程的代码、数据和各种系统资源。

线性或虚拟地址，这是我们在编程中经常使用的东西。为了使这些地址能被正确地使用，系统需要为每个进程构建一个名为页表的结构。页表的作用是将虚拟地址映射到物理地址，这是一种键值对（kv）的映射关系。左侧是虚拟地址，右侧是物理地址。

假设我们定义了一个全局变量，并给它分配了一个地址，比如0x40405c。这个地址其实是我们上层代码使用的虚拟地址。当这个虚拟地址被填入页表的左侧时，系统就会为这个变量在内存中分配一段空间。这段空间在物理内存中也有自己的物理地址，比如0x11223344。

当我们尝试访问这个虚拟地址时，操作系统会自动根据页表将虚拟地址转换为物理地址。这样，我们就可以直接访问物理地址中的内容了。简而言之，页表的作用就是将我们使用的虚拟地址转换成真正的物理地址，使我们能够正确地访问内存中的内容。

3.2再次理解这种现象

在父进程创建子进程时，操作系统会为新创建的子进程创建一个内核的PCB结构。子进程会以父进程为模板初始化其内部的结构体对象。每个进程都需要一个地址空间，所以子进程也会复制父进程的地址空间。为了保持独立性，子进程具有独立的PCB和地址空间，虽然其中一些字段是从父进程继承下来的。

子进程在初始化数据区也有一个虚拟地址，比如0x40405c。子进程同样需要一个独立的页表结构。开始时，父子进程的大部分资源共享，它们的页表指向相同的物理地址。但当子进程尝试修改某个地址时，比如将g_val从100改为200，操作系统会识别到这个修改操作。

操作系统会在内存中为父子进程共享的数据重新划分空间，在物理内存中为这个变量开辟新的空间。这个新空间的物理地址会发生变化，比如变成0x00112233。然后，操作系统会将页表中的旧物理地址（比如0x11223344）改为新地址（比如0x00112233）。

这样，父子进程在物理内存上的值就被分开了。通过这种方式，子进程能够独立地运行，而不会受到父进程的影响。

所以子进程在打印时，显示的地址与父进程相同，这是因为子进程继承了父进程的地址空间，包括这个地址。

但在实际访问时，读取到的内容是不同的。

这是因为父进程通过页表找到的是物理内存中的某个地址，值为100，而子进程通过自己的页表找到的是物理内存中的另一个地址，值为200。

因此，虽然应用层面上看到的虚拟地址相同，但实际的值却是不一样的。

【注意】

写时拷贝 --是由操作系统自己完成的。
重新开辟空间这个过程中，页表左侧的虚拟地址是0感知的，不关心，不会影响到它

4、地址空间究竟是什么？

4.1什么叫做地址空间?

地址空间本质上是进程对内存进行宏观划分的一个视角。当进程需要读取代码或数据时，它必须正在运行，因为只有当前正在运行的进程才会有访问内存的需求。如果一个进程没有被调度或者被挂起阻塞，它就不会有访问内存的需求。

在32位计算机中，我们有32位的地址总线，这些地址总线可以被用来在内存中选取特定的位置。由于每一根地址总线上只有0和1两种状态，也就是强弱电平的概念，所以从CPU到内存的01组合一共有 $2^{32}$ 种。因为内存选址的最基本单位是字节，所以我们的内存大小一定是 $2^{32}$ 字节，即4GB。这就是一个32位计算机最多能够装载的内存空间。

那么，什么是地址空间呢？地址空间就是由这些地址的排列组合形成的范围。在32位计算机中，地址空间就是从0到 $2^{32}$ −1的范围。每个进程都有自己的地址空间，它是进程对内存进行管理和访问的基础。

总的来说，所谓的进程地址空间，本质是一个描述进程可视范围的大小。地址空间内一定要存在各种区域划分，对线性地址进行start，和end即可。

地址空间本质是内核的一个数据结构对象，类似PCB一样，地址空间也是要被操作系统管理的:先描述，在组织

struct mm_struct //默认划分的区域是4GB.
{
	/* ... 其他字段 ... */
    unsigned long start_code, end_code; /* 代码段的开始和结束地址 */
    unsigned long start_data, end_data; /* 数据段的开始和结束地址 */
    unsigned long start_brk, brk;       /* 堆的当前和最大结束地址 */
    unsigned long start_stack;/* 栈的开始地址*/
    unsigned long arg_start, arg_end;   /* 命令行参数的开始和结束地址 */  
    unsigned long env_start, env_end;   /* 环境变量的开始和结束地址 */ 
     /* ... 其他字段 ... */
};

在可视范围内，连续的空间中，每一个最小单位都可以有地址，这个地址可以被进程直接使用!!!

所谓的地址空间其实就是操作系统给进程画的一个大饼，虽然说给你们每个进程都分配了4GB大小，但是，每个进程都不知道其他进程的存在，都以为会自己独享4GB，实际上操作系统并不会直接把4GB直接给进程，而是进程需要多少空间的时候向操作系统申请多少空间。

4.2为什么要有进程地址空间？

所谓的进程=内核数据结构(task_struct && mm_struct &&页表)+程序的代码和数据。

原因一：让进程以统一的视角看待内存。
原因二：增加进程虚拟地址空间可以让我们访问内存的时候，增加一个转换的过程，在这个转化的过程中，可以对我们的寻址请求进行审查，所以一旦异常访问，直接拦截，该请求不会到达物理内存，起到保护物理内存的作用
原因三：因为有地址空间和页表的存在，将进程管理模块，和内存管理模块进行解耦合!

5、页表

5.1基本概念：

        页表是一种特殊的数据结构，被放在系统空间的页表区，用于存放逻辑页与物理页帧的对应关系。每一个进程都拥有一个自己的页表，进程控制块（PCB）中有指向页表的指针。页表的作用是记录虚拟内存地址到物理内存地址的映射关系，以实现内存管理。当程序访问一个虚拟内存地址时，操作系统会根据页表将该地址映射到相应的物理内存地址上。

        在采用页式内存管理的系统中，虚拟内存空间和物理内存空间都被划分成相同大小的页（或称为页面）和页框。页表记录了每个虚拟页对应的物理页框的地址。此外，页表的每一个表项通常还包含一些标志位，用于描述该页的访问权限、是否在内存中、是否被修改过等信息。

       当进程访问某个虚拟地址时，如果对应的页不在物理内存中（即发生缺页中断），则会引发一个缺页异常，此时操作系统会根据页表中的信息从外存中加载该页到内存中，以排除故障。因此，页表是实现虚拟存储系统的重要机制之一。

在操作系统中，为了实现线性地址到物理地址或虚拟地址到物理地址的转换，系统会为每个进程维护一个对应的页表结构。这个页表结构可以简化为包含三个字段（尽管实际上页表具有更多属性）。为了方便理解，我们可以将页表想象成一种类似于unordered_map或map的数据结构，它在内存中为进程构建了一张映射表。这张映射表的内容用于保存对应的物理地址。

需要注意的是，这种简化理解并不完全准确，但它有助于我们初步掌握页表的基本概念。后续我们会提供更详细和准确的信息来校正这一理解。目前，为了简化讨论，我们暂时采用这种简化的视角。

5.2 CR3寄存器

每个正在执行的进程在CPU内部都有一个特定的寄存器，即Cr3寄存器（在x86体系结构中），用于存储其页表的起始地址。这个寄存器是管理性的，它确保了当前运行进程的页表地址始终可得。因此，无论进程何时被切换走，我们都不必担心其页表地址的丢失。这是因为，在进程运行期间，Cr3寄存器中保存的页表地址本质上是该进程硬件上下文的一部分。

当进程不再运行，即被切换走时，它会带走其寄存器中的内容。当进程再次获得执行权时，它会恢复其原先保存在地址空间中的页表地址，从而能够重新访问自己的页表。这样，每个进程都能始终找到其对应的页表，确保地址转换的正确进行。

需要明确的是，Cr3寄存器中保存的页表起始地址是物理地址。在CPU需要访问进程的地址空间时，它会直接读取Cr3寄存器中的物理地址，并据此查找页表，实现地址的正确转换。这种机制确保了操作系统在硬件层面上能够高效地访问和管理进程的页表结构。

5.3 理解代码段和字符常量段是只读的

先看现象：

int main()
{
    char *str = "hello world";
    *str = 's';

    printf("%s",str);

    return 0;
}

这里可以看到程序直接挂掉了。
那么操作系统怎么知道我们要修改了只读常量区的数据呢？

        当程序从磁盘加载到内存时，操作系统会负责将代码区和字符常量区等只读部分加载到相应的只读内存区域。虽然物理内存本身没有直接的只读或只写属性，但操作系统通过虚拟内存管理提供了这样的抽象。
        CPU在访问内存时，实际上是通过访问页表来实现的。页表将虚拟地址映射到物理地址，同时页表中还包含了关于该内存页的访问权限等信息。对于只读的内存区域，页表中相应的条目会被标记为只读。
        因此，当CPU试图修改只读内存区域时，操作系统会拦截这个操作，并直接杀掉这个进程。

5.4 缺页中断

        基本概念： 缺页中断，也被称为页缺失或Page fault，是计算机科学中的一个概念。当软件试图访问已映射在虚拟地址空间中，但是并未被加载在物理内存中的一个分页时，由中央处理器的内存管理单元所发出的中断。
        具体来说，进程线性地址空间里的页面不必常驻内存。在执行一条指令时，如果发现要访问的页没有在内存中（即存在位为0），那么会停止该指令的执行，并产生一个页不存在的异常，即缺页中断。此时，对应的故障处理程序会试图从外存加载该页到内存，以排除故障。如果加载成功，那么原先引起异常的指令就可以继续执行，而不再产生异常。
        在虚拟存储系统中，缺页中断是实现内存管理、内存保护和内存扩充的重要手段。通过缺页中断，操作系统可以将不常用的页面换出到外存，从而为即将被访问的页面腾出空间。同时，缺页中断还可以用来实现内存保护，防止进程访问不属于它的内存空间。
        虽然名为“中断”，但缺页中断并不总是意味着错误。在许多情况下，它是操作系统正常管理内存的一部分。然而，如果缺页中断频繁发生，可能会导致系统性能下降，因为每次中断都需要消耗一定的时间来处理。因此，在设计程序和系统时，需要尽量减少不必要的缺页中断。

我们现代操作系统，几乎不做任何浪费时间和浪费空间的事！

        当我们玩一些特别大的游戏时，尽管游戏的体积可能达到几十个G，而我们计算机的物理内存可能只有4G或8G，但游戏仍然能够正常运行。这是因为操作系统采用了分批加载的策略来处理大文件。
        操作系统不会一次性将整个游戏加载到内存中，因为这可能超出了内存的容量。相反，它会先将游戏的一部分数据，比如前1G或500M，加载到内存中供程序运行。当这部分内存被使用完毕后，操作系统会释放它，然后再加载下一批数据。
        这种加载策略被称为惰性加载。对于可执行程序，操作系统在创建进程时，会先创建内核数据结构，包括为该进程维护的PCB（进程控制块）和地址空间页表等对应关系。然后，它才会开始逐步加载可执行程序。
        在页表中，虚拟地址和物理地址的对应关系不是一开始就全部建立的。对于还未加载到内存中的部分，页表中的对应项会留空，并标记为指向磁盘中的特定地址。当程序试图访问这些地址时，会引发缺页中断。
        在缺页中断发生时，操作系统会识别出所需的内存页或数据尚未加载到内存中。然后，它会在物理内存中为这部分数据申请空间，并将它从磁盘加载到内存中。加载完成后，操作系统会更新页表，将新加载的数据的地址填入对应的项中。
        这个过程是自动完成的，对于用户来说是无感知的。因此，即使你的程序很快就启动了，但可执行程序可能并没有被完全加载到内存中。只有当程序实际需要使用某部分数据时，那部分数据才会被加载到内存中。这种按需加载的方式有效地利用了有限的内存资源，使得大程序也能在有限的内存空间中运行。

【总结】：

         当我们通过虚拟地址转化尝试访问物理内存时，如果发现所需的物理内存并未在系统中（即内存尚未申请），这时就会触发一个缺页中断。随后，操作系统会负责重新申请内存、加载数据，并更新页表。这一系列的操作，包括内存的申请、数据的加载以及页表的更新，都是由操作系统的内存管理模块来完成的。
        在页表的结构中，左侧部分我们通常称之为进程管理相关的部分，而右侧则与内存管理紧密相关。由于有了页表和地址空间的存在，进程管理部分无需直接关心内存管理的细节。进程只需使用虚拟地址，若虚拟地址不足或不存在，操作系统会自动触发缺页中断，并调用内存管理功能进行处理。
        因此，虚拟地址空间的存在在软件层面上实现了内存管理和进程管理的解耦，使得两者可以相对独立地工作，提高了系统的灵活性和可维护性。