【Linux】——初识程序地址空间_程序进程的地址空间代码起始为什么不从0开始-CSDN博客

本文链接：https://blog.csdn.net/m0_62179366/article/details/126796462

一、fork()问题

我们还是接着上一篇文章，前面说fork()的返回值有两个值，同一个变量竟然有两个不同的值同时存在，这一点是十分反直觉的，难道我们前面所学的地址指针是错误的吗？

我们先对这个问题按下不表，我们看这样一段代码

 #include<stdio.h>
 #include<unistd.h> 
 int g_value = 100;
  
  int main()
  {
      pid_t id = fork();
  
      if(id < 0)
      {
          perror("fork");
          return 1;
      }
      else if(id == 0)
      {
          //child
          int cnt = 0;
          while(1)
          {
              printf("I am child  pid: %d  ppid: %d  g_value: %d  &g_value: %p\n",     
                      getpid(), getppid(), g_value, &g_value);
              cnt++;
              if(cnt == 5)
              {
                  printf("child modify g_value g_value: %d -> ", g_value);
                  g_value = 200;
                  printf("%d\n", g_value);
              }
              sleep(1);
          }
      }
      else 
      {                                                                                                                                                                                  
          //father
          while(1)
          {
              printf("I am father  pid: %d  ppid: %d  g_value: %d  &g_value: %p\n", 
                      getpid(), getppid(), g_value, &g_value);
              sleep(1);
          }
      }

    return 0;
}

我们定义了一个全局变量，然后创建了一个子进程，然后让子进程修改全局变量的值，观察出现的现象

在没有修改全局变量时一切都正常，修改之后，父进程的g_value没有修改，子进程的g_value修改了，这也符合我们的预期，然后我们看g_value的地址，也没有毛病，地址没有修改，证明还是原来的那个变量，但是我们将这两种现象合到一起再看，就会发现这种现象十分的奇怪。

同一个变量，相同的地址，但是内容却不一样。这个现象基本上是颠覆了我们前面的关于地址的认知。

其实，这里面所说的地址绝对不是物理内存地址，而是虚拟内存地址(线性地址)

所有的语言如果有地址的概念，那么所谓的地址一定不是物理地址，而是虚拟地址。

C/C++ 是一种编译型语言，编译之后就已经是二进制可执行程序了。

二、详解程序地址空间

1、基本概念

我们在学习编程语言时一定见过类似的图片

但是，这张图片说的就是对的吗？

下面我们来验证一下

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 
  4 int g_value = 100;
  5 int g_unvalue;
  6 
  7 int main(int argc, char* argv[], char* env[])
  8 {
  9     printf("code_adder: %p\n", main);//正文代码
 10 
 11     printf("init_adder: %p\n", &g_value);//已初始化全局数据区
 12 
 13     printf("uninit_adder: %p\n", &g_unvalue);//未初始化全局数据区
 14 
 15     char* heap_mem1 = (char*)malloc(10);
 16     char* heap_mem2 = (char*)malloc(10);
 17     char* heap_mem3 = (char*)malloc(10);
 18     char* heap_mem4 = (char*)malloc(10);
 19 
 20     printf("heap_adder: %p\n", heap_mem1);//堆区
 21     printf("heap_adder: %p\n", heap_mem2);
 22     printf("heap_adder: %p\n", heap_mem3);
 23     printf("heap_adder: %p\n", heap_mem4);
 24 
 25     printf("stack_adder: %p\n", &heap_mem1);//栈区
 26     printf("stack_adder: %p\n", &heap_mem2);
 27     printf("stack_adder: %p\n", &heap_mem3);
 28     printf("stack_adder: %p\n", &heap_mem4);
 29 
 30     for(int i = 0; i < argc; i++)
 31     {
 32         printf("argv[%d]: %p\n", i, argv[i]);//命令行参数
 33     }
 34                                                                                                                                                                                        
 35     for(int i = 0; env[i]; i++)
 36     {
 37         printf("env[%d]: %p\n", i, env[i]);//环境变量
 38     }
 39     return 0;
 40 }

我们发现打印出来的结果刚好符合上面的图，我们要是能够仔细的观察也会发现堆和栈有两个箭头，这个箭头代表着堆栈增长方向，堆栈相对而生，堆向高地址方向增长，栈向低地址方向增长，在上面的实验中我们在每个区域定义了多个变量，就是为了验证这个结论

同时，我们还会发现命令行参数和环境变量，在程序地址空间较高的地址处，而且环境变量的地址是高于命令行参数的。

在堆区的地址增长趋势来看，我们使用malloc申请空间只是申请了10个字节，可是它的每个变量的间隔是20个字节而不是10个字节这是为什么呢？

我们知道malloc函数它有一个参数是开辟空间的大小，并且会返回我们申请的空间的起始地址，可是free只有一个参数，是要释放的空间的起始地址，但是并没有显式的传入要释放空间的大小。

我们前面已经了解了malloc和free的基本信息，我们还是使用上面的例子。malloc申请空间时，假如我们要申请10字节的空间，C标准库实际上会多申请空间，多出来的空间用来记录堆的属性信息如：申请空间的时间，申请空间的大小，权限等等……

我们还是以这个图片讲解，说明每个区间的具体含义。

我们以前学过程序地址空间是从0x0000 0000 开始一直到0xFFFF FFFF

但是正文代码的起始位置并不是从全0开始的，他们中间是有间隔的。

接下来是正文代码：正文代码一定是二进制代码，因为这里说的并不是真实的内存，而是虚拟内存，它一定是已经编译之后的结果了。

在正文代码的end之前，它还有一小块区域是字符常量区，它是只读的。它内部存放的是什么？

它内部存储的是字面常量例如"Hello World" 1 2 'a'等等

所有的字面常量都是硬编码进代码的，所以它存在正文代码区

已初始化全局数据区：顾名思义它是用来存放初始化过的全局变量，但是它并不仅仅可以存储初始化的全局变量，它还可以存储static修饰的初始化的静态变量

未初始化全局数据区：与已初始化全局数据区具有相似的定义，只不过它存储的都是未初始化的。

堆：我们应该是相当的熟悉，平时动态开辟的空间都是从这里来的，这也是我们能够自主操纵的空间。

栈：也是我们常说的概念，栈的空间我们并不能操控，它只有在程序运行时才会开辟空间

在这幅图片中，我们发现它将程序地址空间简单分为两部分，【0~3GB】是用户空间

【3GB~4GB】是内核空间

回到我们打印出的例子。这里打印出的地址都不是物理地址，都是虚拟地址。

打印全部都是进程在打印地址，它们是程序运行之后打印的。

2、什么是地址空间？

所谓进程地址空间（process address space），就是从进程的视角看到的地址空间，是进程运行时所用到的虚拟地址的集合。

我们看这个定义有一些懵，也不知道具体的概念。

我们还是看一个例子：

有一个美国的富豪，他具有10亿美元的家产，同时他有三个私生子a,b,c三个私生子并不知道彼此的存在。富豪分别对三个私生子画大饼将来10亿家产全部给他，富豪给每个儿子都画了一张大饼但是他不能拿出30亿分别给每个儿子10亿，私生子向富豪要钱，富豪就给钱，但是私生子们想要10亿美元，但是富豪就是不给，同时富豪也要管理这些大饼，防止出现问题。

富豪就相当于——操作系统

私生子——进程

这里所谓的饼，在现实中是物理内存

这里画的饼就是虚拟内存。

既然这些饼要被管理起来，我们就会想到操作系统的管理理念：先描述，再组织

那么既然要描述虚拟内存也就要有相应的结构体和相应的数据结构将结构体与相应的进程关联起来。

在以前，进程是直接访问物理内存的，这种访问是相当的不安全。

我们假如有三个进程直接被加载到物理内存中，如果我们有一个进程出现野指针，将进程2的某些数据直接修改了，就有可能导致进程2挂掉。假如进程2是用来保存密码的，我们写一个程序，将指针指向进程2的密码，那么我们就会获取到密码，因此这种访问方式并不安全。

现代计算机提出了新的方式

我们知道每一个进程都会有一个PCB结构体task_struct，而task_struct中有一个指针指向该进程的进程地址空间，然后通过映射机制，将虚拟内存映射到物理内存。

虽然这样还是会访问物理地址，但是我们可以在映射那里加入合法性检验。

如果我的虚拟地址是非法的，就会禁止映射。