Linux进程——进程地址空间

简介: Linux进程——进程地址空间

前言:在讲完环境变量后,相信大家对Linux有更进一步的认识,而Linux进程概念到这也快接近尾声了,现在我们了解Linux进程中的地址空间!


本篇主要内容:

了解程序地址空间

理解进程地址空间

探究页表和虚拟地址空间


1. 程序地址空间

我们在学习C语言的时候,大家都了解过这样的空间布局图

那么到底是不是这样排布的呢,我们来验证一下

    1 #include<stdio.h>
    2 #include<stdlib.h>
    3 
    4 int un_gval;
    5 int init_gval = 100;                         
    6                                      
    7 int main(int argc, char *argv[], char *env[])
    8  {                                            
    9      printf("code addr: %p\n", main);                   
   10      const char *str = "Hello, Linux!";                 
   11      printf("read only char addr: %p\n", str);          
   12      printf("init global value addr: %p\n", &init_gval);
   13      printf("uninit global value addr: %p\n", &un_gval);
   14                                     
   15      char *heap1=(char*)malloc(100);
   16      char *heap2=(char*)malloc(100);
   17      char *heap3=(char*)malloc(100);
   18      char *heap4=(char*)malloc(100);
   19                                        
   20      int a = 100;                      
   21                                        
   22      printf("heap1 addr: %p\n", heap1);
   23      printf("heap2 addr: %p\n", heap2);
   24      printf("heap3 addr: %p\n", heap3);
   25      printf("heap4 addr: %p\n", heap4); 
   26                                         
   27      printf("stack addr: %p\n", &str);  
   28      printf("stack addr: %p\n", &heap1);                                                                                                                                                       29       printf("stack addr: %p\n", &heap2);                                                                                                                                                30       printf("stack addr: %p\n", &heap3);
   31      printf("stack addr: %p\n", &heap4);                                                                                                                                                                  
   32      printf("a addr: %p\n",&a);  
   33      return 0;
   34  }


栈区中的数组和结构体

int num[10] ......&a[0]  &a[9]

struct s
{
  int a; ......&s.a
  int b; ......&s.b
  int c; ......&s.c
}

注意:栈区是整体向下增长,局部想上使用的,就是地址最低处,依次往上放后面的元素


但是如果我们将代码更改还能运行过去嘛?

char *str = "Hello, Linux!"; 
*str = 'S';

显然我们是不能更改的,一更改就就运行不了了

注意:其实是因为字符常量区与代码区很接近,而编译器在编译时,字符常量区就是被编译到代码区的,代码又不可被写入,所以字符常量区也不可被修改

综上:
  • 栈区是整体向下增长,局部想上使用的,就是地址最低处,依次往上放后面的元素
  • 常量区的字符串不允许修改

但是这都是我们之前了解的知识,现在我们来重新了解地址,我们先来看这段代码

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<sys/types.h>
  4 #include<unistd.h>
  5 
  6 int g_val = 200;
  7 
  8 int main()
  9 {
 10     pid_t id = fork();
 11     if(id == 0)
 12     {
 13         // 子进程
 14         int cnt = 5;
 15         while(1)
 16         {
 17             printf("child, pid: %d, ppid: %d, g_val: %d, &g_val: %p\n", getpid(), getppid(), g_val, &g_val);
 18             sleep(1);
 19             if(cnt == 0)
 20             {
 21                 g_val = 100;
 22                 printf("child change g_val: 200 -> 100\n");
 23             }
 24             cnt--;
 25         }
 26         
 27     }
 28     else{
 29         // 父进程
 30         while(1)
 31         {
 32             printf("father, pid: %d, ppid: %d, g_val: %d, &g_val: %p\n", getpid(), getppid(), g_val, &g_val);
 33             sleep(1);                                                                                                                                                                  
 34         }
 35     }
 36     return 0;
 37 }

我们发现在开始时,输出出来的变量值和地址是一模一样的!
因为我们之前讲过子进程按照父进程为模版,父子并没有对变量进行进行任何修改

但是在达到一定条件之后,父子进程,输出地址是一致的,但是变量内容不一样!

但是相同的地址为什么会有不同的值?

  • 所以我们能得出结论,我们之前看到的地址,绝对不是物理地址,我们平时用到的地址,其实都是虚拟地址/线性地址!
  • 而虚拟地址就是进程地址空间的内容

2. 进程地址空间

我们现在来深入的了解一下为什么相同的的地址为什么会有不同的值?

首先引入一个概念:每一个进程运行之后,都会有一个进程地址空间的存在,在系统层面都要有自己的页表映射结构!

因此:当一个进程先修改后,它就不再指向原来那块物理空间,而是拥有一个新的物理空间!而页表左边的虚拟空间没有发生改变,所以相同的的地址为什么会有不同的值,是因为映射的物理空间不同!


3. 什么是地址空间

在讲什么是地址空间之前,我们先来讲一个故事,来方便理解!

一个拥有10亿美元身家的富豪,他有4个私生子,每个人都不知道彼此的存在,但是富豪对每个孩子都说,认真做好现在的事,在未来可以继承自己的10个亿家产。

但是在得到10个亿之前,他的几个孩子,在经济上遇到了问题,前三个都要找富豪要10w美金来解决麻烦,富豪觉得合情合理也就给了,但是它的第四个孩子直接找他要10个亿,富豪当然不能给他,然后讲明原因后给了他20w美金。因此他的所有孩子都可以得到10亿之内的经济资助,但是绝对拿不到10个亿。

在这个故事中:

  • 操作系统:富豪
  • 内存:10亿美金
  • 进程:私生子
  • 虚拟地址空间:继承10亿的大饼

虚拟地址空间并不是真实的地址


3. 地址空间的管理

富豪给每一个私生子都画了饼,他要把每个私生子都管理起来,也就是要把所有大饼管理起来。

因此:地址空间也要被OS管理起来!!每一个进程都要有地址空间,系统中,一定要对地址空间做管理!!

而操作系统管理地址空间,一定是“先描述,在组织”!地址空间最终一定是一个内核的数据结构对象,
就是一个内核结构体!

而我们观察进程地址空间,发现里面是一堆的地址划分。

在Linux中,这个描述虚拟地址空间的东西叫做:

struct mm _struct
{
  long code_start;
  long code_end;
  long data_start;
  long data_end;
  long heap_start;
  long heap end; //brk
  long stack _start;
  long stack _end;
  ......
}

而该结构体的大小会被初始化成4gb,线性编程范围从全0到全F,然后把线性范围拆分成细小的范围,这就是地址空间


4. 页表

在上面我们了解到了页表,页表的映射关系中左侧表示虚拟地址,右侧表示物理地址,但是除了这两个其实在页表的映射关系中还存在一个标记字段——访问权限字段

讲到这里我们再回到字符常量区那里。

char *str = "Hello, Linux!"; 
*str = 'S';


此时我们就可以解释通字符常量区为什么不能修改:

  • 字符常量区在经过页表映射时,访问权限字段只设置成只读的,所以在写入时,页表直接将我们拦住,不让我们访问,所以字符常量区不能修改,代码区也是如此!

所以页表可以进行安全评估,有效的进行进程访问内存的安全检查


在除去上面提到的东西以外,页表还可以通过二进制衡量能存中有没有内容,是否分配地址

当我们有个虚拟地址要被访问了,但是它并没有被分配空间,更不会有内容,那该则么办呢?

其实在这个时候操作系统会将你的这个访问暂停,然后进行一下操作:

  • 操作系统会将你的可执行程序重新开辟空间
  • 把对应可执行程序需要执行的这个虚拟地址对应的代码加载到内存里
  • 把对应的虚拟地址填充到页表
  • 把标志位改为1,代表已经分配地址,且内容已经填充
  • 将暂停的代码继续访问

操作过程也称为缺页中断

而我们操作系统在进行这些工作时,是在进行内存管理, 而进程管理和内存管理因为有了地址空间的存在 ,实现了在操作系统层面上的模块的解耦!


5. 为什么要存在地址空间

到了这里我想大家也都了解得差不多了,为什么要存在地址空间,原因有很多

一、 让无序便有序

  • 让进程以统一的视角看待内存
  • 在页表层映射时会将不同的数据类型进行划分使得映射到物理内存后是比较有序的一种状态!
  • 所以任意一个进程,可以通过地址空间+页表可以将乱序的内存数据,变成有序,分门别类的规划好!

二、存在虚拟地址空间,可以有效的进行进程访问内存的安全检查

三、将进程管理和内存管理进行解耦

四、保证进程的独立性

通过页表让进程虽然虚拟地址一样但是映射到不同的物理内存处,从而实现进程的独立性

6. 总结拓展

拓展:

在mm_struct中还会存在一个struct vm_area_struct的结构 ,它能划分出一个start,一个end。如果我们还想继续划分就会有多个struct vm_area_struct的结构,然后他们会构成一个线性划分的链表结构。

struct vm_area_struct
{
  struct mm_struct * vm_mm;
  unsigned long vm_start;
  unsigned long vm_end;
  ......
}

到这里我们的进程地址空间也接近尾声了,地址空间让进程管理和内存管理互不干涉,起到了很大作用。结束进程地址空间,我们的Linux进程概念到这里也结束了,后面我将带大家走进进程控制。

谢谢大家支持本篇到这里就结束了


目录
相关文章
|
16天前
|
算法 Linux 调度
深入理解Linux操作系统的进程管理
本文旨在探讨Linux操作系统中的进程管理机制,包括进程的创建、执行、调度和终止等环节。通过对Linux内核中相关模块的分析,揭示其高效的进程管理策略,为开发者提供优化程序性能和资源利用率的参考。
43 1
|
5天前
|
存储 监控 Linux
嵌入式Linux系统编程 — 5.3 times、clock函数获取进程时间
在嵌入式Linux系统编程中,`times`和 `clock`函数是获取进程时间的两个重要工具。`times`函数提供了更详细的进程和子进程时间信息,而 `clock`函数则提供了更简单的处理器时间获取方法。根据具体需求选择合适的函数,可以更有效地进行性能分析和资源管理。通过本文的介绍,希望能帮助您更好地理解和使用这两个函数,提高嵌入式系统编程的效率和效果。
45 13
|
12天前
|
SQL 运维 监控
南大通用GBase 8a MPP Cluster Linux端SQL进程监控工具
南大通用GBase 8a MPP Cluster Linux端SQL进程监控工具
|
19天前
|
运维 监控 Linux
Linux操作系统的守护进程与服务管理深度剖析####
本文作为一篇技术性文章,旨在深入探讨Linux操作系统中守护进程与服务管理的机制、工具及实践策略。不同于传统的摘要概述,本文将以“守护进程的生命周期”为核心线索,串联起Linux服务管理的各个方面,从守护进程的定义与特性出发,逐步深入到Systemd的工作原理、服务单元文件编写、服务状态管理以及故障排查技巧,为读者呈现一幅Linux服务管理的全景图。 ####
|
1月前
|
缓存 监控 Linux
linux进程管理万字详解!!!
本文档介绍了Linux系统中进程管理、系统负载监控、内存监控和磁盘监控的基本概念和常用命令。主要内容包括: 1. **进程管理**: - **进程介绍**:程序与进程的关系、进程的生命周期、查看进程号和父进程号的方法。 - **进程监控命令**:`ps`、`pstree`、`pidof`、`top`、`htop`、`lsof`等命令的使用方法和案例。 - **进程管理命令**:控制信号、`kill`、`pkill`、`killall`、前台和后台运行、`screen`、`nohup`等命令的使用方法和案例。
137 4
linux进程管理万字详解!!!
|
25天前
|
缓存 算法 Linux
Linux内核的心脏:深入理解进程调度器
本文探讨了Linux操作系统中至关重要的组成部分——进程调度器。通过分析其工作原理、调度算法以及在不同场景下的表现,揭示它是如何高效管理CPU资源,确保系统响应性和公平性的。本文旨在为读者提供一个清晰的视图,了解在多任务环境下,Linux是如何智能地分配处理器时间给各个进程的。
|
1月前
|
存储 运维 监控
深入Linux基础:文件系统与进程管理详解
深入Linux基础:文件系统与进程管理详解
77 8
|
1月前
|
网络协议 Linux 虚拟化
如何在 Linux 系统中查看进程的详细信息?
如何在 Linux 系统中查看进程的详细信息?
68 1
|
1月前
|
Linux
如何在 Linux 系统中查看进程占用的内存?
如何在 Linux 系统中查看进程占用的内存?
|
1月前
|
算法 Linux 定位技术
Linux内核中的进程调度算法解析####
【10月更文挑战第29天】 本文深入剖析了Linux操作系统的心脏——内核中至关重要的组成部分之一,即进程调度机制。不同于传统的摘要概述,我们将通过一段引人入胜的故事线来揭开进程调度算法的神秘面纱,展现其背后的精妙设计与复杂逻辑,让读者仿佛跟随一位虚拟的“进程侦探”,一步步探索Linux如何高效、公平地管理众多进程,确保系统资源的最优分配与利用。 ####
71 4