目录
- [1. 冯诺依曼体系结构](#1. 冯诺依曼体系结构)
- [2. 操作系统(Operator System)](#2. 操作系统(Operator System))
-
- [2.1 概念](#2.1 概念)
- [2.2 设计OS的目的](#2.2 设计OS的目的)
- [2.3 核心功能](#2.3 核心功能)
- [2.4 如何理解管理](#2.4 如何理解管理)
- 3.进程
-
- 3.1基本概念与基本操作
-
- [3.1.1 描述进程-PCB](#3.1.1 描述进程-PCB)
- [3.1.2 task_struct](#3.1.2 task_struct)
- 3.1.3查看进程
- [3.1.4 通过系统调用获取进程标示符](#3.1.4 通过系统调用获取进程标示符)
- [3.1.5 通过系统调用创建进程-fork初始](#3.1.5 通过系统调用创建进程-fork初始)
- [3.2 进程状态](#3.2 进程状态)
-
- [3.2.1 Linux内核源代码怎么说](#3.2.1 Linux内核源代码怎么说)
- [3.2.2 进程状态查看](#3.2.2 进程状态查看)
- [3.2.3 Z(zombie)- 僵尸进程](#3.2.3 Z(zombie)- 僵尸进程)
- [3.4.2 僵尸进程危害](#3.4.2 僵尸进程危害)
- 3.2.5孤儿进程
- [3.3 进程优先级](#3.3 进程优先级)
-
- [3.3.1 基本概念](#3.3.1 基本概念)
- [3.3.2 查看系统进程](#3.3.2 查看系统进程)
- [3.3.3 PRI and NI](#3.3.3 PRI and NI)
- [3.3.4 PRI vs NI](#3.3.4 PRI vs NI)
- [3.3.5 查看进程优先级的命令](#3.3.5 查看进程优先级的命令)
- [3.3.6 补充概念-竞争、独立、并行、并发](#3.3.6 补充概念-竞争、独立、并行、并发)
- [3.4 进程切换](#3.4 进程切换)
- [3.4 Linux2.6 内核进程O(1)调度队列](#3.4 Linux2.6 内核进程O(1)调度队列)
-
- [3.4.1 一个CPU拥有一个runqueue](#3.4.1 一个CPU拥有一个runqueue)
- [3.4.2 优先级](#3.4.2 优先级)
- [3.4.3 活动队列](#3.4.3 活动队列)
- [3.4.4 过期队列](#3.4.4 过期队列)
- [3.4.5 active指针和expired指针](#3.4.5 active指针和expired指针)
- [3.4.6 总结](#3.4.6 总结)
- [4. 命令行参数和环境变量](#4. 命令行参数和环境变量)
-
- [4.1 基本概念](#4.1 基本概念)
- [4.2 常见的环境变量](#4.2 常见的环境变量)
- [4.3 查看环境变量方法](#4.3 查看环境变量方法)
- [4.4 环境变量相关的命令](#4.4 环境变量相关的命令)
- [4.5 环境变量的组织方式](#4.5 环境变量的组织方式)
- [4.6 通过代码如何获取环境变量](#4.6 通过代码如何获取环境变量)
- [4.7 通过系统调用获取或设置环境变量](#4.7 通过系统调用获取或设置环境变量)
- [4.8 环境变量通过是具有全局属性的](#4.8 环境变量通过是具有全局属性的)
- 5程序地址空间
-
- [5.1 研究平台](#5.1 研究平台)
- [5.2 程序地址空间回顾](#5.2 程序地址空间回顾)
- [5.3 虚拟地址](#5.3 虚拟地址)
- [5.4 进程地址空间](#5.4 进程地址空间)
- [5.5 虚拟内存管理](#5.5 虚拟内存管理)
1. 冯诺依曼体系结构
我们常见的计算机，如笔记本。我们不常见的计算机，如服务器，大部分都遵守冯诺依曼体系。
截至目前，我们所认识的计算机，都是由一个个的硬件组件组成
- 输入单元：包括键盘,鼠标，扫描仪,写字板等
- 中央处理器(CPU)：含有运算器和控制器等
- 输出单元：显示器，打印机等
关于冯诺依曼，必须强调⼏点：
- 这⾥的存储器指的是内存
- 不考虑缓存情况，这⾥的CPU能且只能对内存进⾏读写，不能访问外设(输⼊或输出设备)(数据层⾯)
- 外设(输⼊或输出设备)要输⼊或者输出数据，也只能写⼊内存或者从内存中读取。
- ⼀句话，所有设备都只能直接和内存打交道。
注意：
对冯诺依曼的理解，不能停留在概念上，要深入到对软件数据流理解上，请解释，从你登录上qq开始和某位朋友聊天开始，数据的流动过程。从你打开窗口，开始给他发消息，到他的到消息之后的数据流动过程。如果是在qq上发送文件呢？
2. 操作系统(Operator System)
2.1 概念
任何计算机系统都包含一个基本的程序集合，称为操作系统(OS)。笼统的理解，操作系统包括：
- 内核（进程管理，内存管理，文件管理，驱动管理）
- 其他程序（例如函数库，shell程序等等）
2.2 设计OS的目的
- 对下，与硬件交互，管理所有的软硬件资源
- 对上，为⽤⼾程序（应⽤程序）提供⼀个良好的执⾏环境
2.3 核心功能
- 在整个计算机软硬件架构中，操作系统的定位是：⼀款纯正的"搞管理"的软件
2.4 如何理解管理
- 管理的例⼦ - 学⽣，辅导员，校⻓
- 描述被管理对象
- 组织被管理对象
例子: 比如，校长要求明天早上7点某某学院的学生参加升旗仪式，然后有辅导员来通知学校，这里的校长是在描述，而辅导员就是组织的一方
总结
计算机管理硬件
- 描述起来，用struct结构体
- 组织起来，用链表或其他高效的数据结构
3.进程
3.1基本概念与基本操作
- 课本概念: 程序的一个执行实例，正在执行的程序等
- 内核观点：担当分配系统资源（CPU时间，内存）的实体
- 当前：进程=内核数据结构(task_struct)+自己的程序代码和数据
3.1.1 描述进程-PCB
基本概念
- 进程信息被放在一个叫做进程控制块的数据结构中，可以理解为进程属性的集合。
- 书上称之为PCB（process control block），Linux 操作系统下的PCB 是:task_struct
task_struct-PCB的一种 - 在Linux 中描述进程的结构体叫做task_struct。
- task_struct 是Linux 内核的一种数据结构类型，它会被装载到RAM(内存)里并且包含着进程的信息。
3.1.2 task_struct
内容分类
- 标识符:描述本进程的唯一标识符，用来区别其他进程。
- 状态:任务状态，退出代码，退出信号等。
- 优先级:相对于其他进程的优先级。
- 程序计数器:程序中即将被执行的下一条指令的地址。
- 内存指针:包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针
- 上下文数据:进程执行时处理器的寄存器中的数据休学例子，要加图CPU，寄存器。
- I／O状态信息:包括显示的I/O请求,分配给进程的I／O设备和被进程使用的文件列表。
- 记账信息:可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等。
组织进程
可以在内核源代码里找到它。所有运行在系统里的进程都以task_struct 双链表的形式存在内核里。
3.1.3查看进程
- 进程的信息可以通过系统文件夹查看
- 大多数进程信息同样可以使用top和ps这些用户级工具来获取
powershell
#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
int main()
{
while(1)
{
sleep(1);
}
return 0;
}
3.1.4 通过系统调用获取进程标示符
- 进程id(PID)
- 父进程id(PPID)
powershell
#include<stdio.h>
#include<sys/type.h>
#include<unistd.h>
int main()
{
printf("pid: %d\n", getpid());
printf("ppid: %d\n",getppid());
return 0;
}3.1.5 通过系统调用创建进程-fork初始
- 运行man fork 认识fork
- fork 有两个返回值
- 父子进程代码共享，数据各自开辟空间，私有一份(采用写时拷贝)
powershell
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
int ret=fork();
printf("hello proc : %d!, ret: %d\n", getpid(), ret);
sleep(1);
return 0;
}
fork有两个返回值，一个给父进程，一个给子进程，子进程如果创建成功会将子进程返回给父进程，0返回给子进程， 子进程如果创建不成功，会返回-1给父进程
- fork之后通常要用if进行分流
powershell
#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
int main()
{
int ret=fork();
if(ret<0){
perror("fork");
return 1;
}
else if(ret==0){
printf("i am child: %d!, ret: %d\n",getpid(),ret);
}else
printf("i am father: %d!, ret: %d\n",getppid(),ret);
sleep(1);
return 0;
}
3.2 进程状态
3.2.1 Linux内核源代码怎么说
- 为了弄明白正在运行的进程是什么意思，我们需要知道进程的不同状态。一个进程可以有几个状态（在Linux内核里，进程有时候也叫做任务）。
下面的状态在kernel源代码里定义：
powershell
static const char *const task_state_array[] = {
"R (running)", /*0 */
"S (sleeping)", /*1 */
"D (disk sleep)", /*2 */
"T (stopped)", /*4 */
"t(tracing stop)", /*8 */
"X(dead)", /*16 */
"Z(zombie)", /*32 */
};- R运行状态（running）:并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列里。
- S睡眠状态（sleeping):意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠（interruptible sleep））。
- D磁盘休眠状态（Disk sleep）有时候也叫不可中断睡眠状态（uninterruptible sleep），在这个状态的进程通常会等待IO的结束。
- T停止状态（stopped）：可以通过发送SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可以通过发送SIGCONT 信号让进程继续运行。
- X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态。
3.2.2 进程状态查看
ps aux /ps ajx 命令
- a：显示一个终端所有的进程，包括其他用户的进程。
- x：显示没有控制终端的进程，例如后台运行的守护进程。
- j：显示进程归属的进程组ID、会话ID、父进程ID，以及与作业控制相关的信息
- u：以用户为中心的格式显示进程信息，提供进程的详细信息，如用户、CPU和内存使用情况等
3.2.3 Z(zombie)- 僵尸进程
- 僵死状态（Zombies）是一个比较特殊的状态。当进程退出并且父进程（使用wait()系统调用）没有读取到子进程退出的返回代码时就会产生僵死(尸)进程
- 僵死进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码。
- 所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态
一个创建维持30秒的僵死进程例子
powershell
1 #include <stdio.h>
2 #include<sys/types.h>
3 #include<unistd.h>
4 #include<stdlib.h>
5 int main()
6 {
7 pid_t id=fork();
8 if(id<0){
9 perror("fork");
10 return 1;
11 }
12 else if(id>0){
13 printf("parent[%d] is sleeping...\n", getpid());
14 sleep(30);
15 }else{
16 printf("child[%d] is begin Z...\n",getpid());
17 sleep(5);
18 exit(EXIT_SUCCESS );
19 }
20 return 0;
21 }编译并在另一个终端下启动监控
开始测试
第一个终端
测试终端
看到结果
可以看到进程状态变成僵尸进程了
3.4.2 僵尸进程危害
- 进程的退出状态必须被维持下去，因为他要告诉关心它的进程（父进程），你交给我的任务，我办的怎么样了。可父进程如果一直不读取，那子进程就一直处于Z状态？是的！
- 维护退出状态本身就是要用数据维护，也属于进程基本信息，所以保存在task_struct (PCB)中，换句话说，Z状态一直不退出，PCB一直都要维护？是的！
- 那一个父进程创建了很多子进程，就是不回收，是不是就会造成内存资源的浪费？是的！因为数据结构对象本身就要占用内存，想想C中定义一个结构体变量（对象），是要在内存的某个位置进行开辟空间！
- 内存泄漏?是的！
3.2.5孤儿进程
- 父进程如果提前退出，那么子进程后退出，进入Z之后，那该如何处理呢？
- 父进程先退出，子进程就称之为"孤儿进程"
- 孤儿进程被1号in it/systemd进程领养，当然要有in it/systemd进程回收喽。
powershell
#include<stdio.h>
2 #include<unistd.h>
3 #include<stdlib.h>
4
5 int main(){
6 pid_t id=fork();
7 if(id<0){
8 perror("fork");
9 return 1;
10 }
11 else if(id==0){
12 printf("我是子进程 pid: %d\n",getpid());
13 sleep(10);
14 }else{
15 printf("我是父进程 ppid: %d\n",getppid());
16 sleep(3);
17 exit(0);
18 }
19
20 return 0;
21 }
3.3 进程优先级
3.3.1 基本概念
- cpu资源分配的先后顺序，就是指进程的优先权（priority）。
- 优先权高的进程有优先执行权利。配置进程优先权对多任务环境的linux很有用，可以改善系统性能。
- 还可以把进程运行到指定的CPU上，这样一来，把不重要的进程安排到某个CPU，可以大大改善系统整体性能。
3.3.2 查看系统进程
在linux或者unix 系统中，用ps --l命令则会类似输出以下几个内容：
我们很容易注意到其中的几个重要信息，有下：
- UID :代表执行者的身份
- PID :代表这个进程的代号
- PPID：代表这个进程是由哪个进程发展衍生而来的，亦即父进程的代号
- PRI：代表这个进程可被执行的优先级，其值越小越早被执行
- NI：代表这个进程的nice值
3.3.3 PRI and NI
- PRI也还是比较好理解的，即进程的优先级，或者通俗点说就是程序被CPU执行的先后顺序，此值越小进程的优先级别越高
- 那NI呢?就是我们所要说的nice值了，其表示进程可被执行的优先级的修正数值
- PRI值越小越快被执行，那么加入nice值后，将会使得PRI变为：PRI(new)=PRI(old)+nice,PRI(old)是80
- 这样，当nice值为负值的时候，那么该程序将会优先级值将变小，即其优先级会变高，则其越快被执行
- 所以，调整进程优先级，在Linux下，就是调整进程nice值
- nice其取值范围是-20至19，一共40个级别。
3.3.4 PRI vs NI
- 需要强调一点的是，进程的nice值不是进程的优先级，他们不是一个概念，但是进程nice值会影响到进程的优先级变化。
- 可以理解nice值是进程优先级的修正数据
3.3.5 查看进程优先级的命令
用top命令更改已存在进程的nice：
- top
- 进入top后按"r"-->输入进程PID-->输入nice值
3.3.6 补充概念-竞争、独立、并行、并发
- 竞争性:系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高效完成任务，更合理竞争相关资源，便具有了优先级
- 独立性:多进程运行，需要独享各种资源，多进程运行期间互不干扰
- 并行:多个进程在多个CPU下分别，同时进行运行，这称之为并行
- 并发:多个进程在一个CPU下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发
3.4 进程切换
CPU上下文切换：其实际含义是任务切换,或者CPU寄存器切换。当多任务内核决定运行另外的任务时,它保存正在运行任务的当前状态,也就是CPU寄存器中的全部内容。这些内容被保存在任务自己的堆栈中, ⼊栈⼯作完成后就把下⼀个将要运⾏的任务的当前状况从该任务的栈中重新装⼊CPU寄存器,并开始下⼀个任务的运⾏, 这⼀过程就是context switch。
注意:
时间⽚：当代计算机都是分时操作系统，没有进程都有它合适的时间⽚(其实就是⼀个计数器)。时间⽚到达，进程就被操作系统从CPU中剥离下来。
3.4 Linux2.6 内核进程O(1)调度队列
上图是Linux2.6内核中进程队列的数据结构
3.4.1 一个CPU拥有一个runqueue
- 如果有多个CPU就要考虑进程个数的负载均衡问题
3.4.2 优先级
- 普通优先级：100～139（我们都是普通的优先级，想想nice值的取值范围，可与之对应！）
- 实时优先级：0～99（不关心）
3.4.3 活动队列
- 时间片还没有结束的所有进程都按照优先级放在该队列
- nr_active:总共有多少个运行状态的进程
- queue140:一个元素就是一个进程队列，相同优先级的进程按照FIFO规则进行排队调度,所以，数组下标就是优先级！
- 从该结构中，选择一个最合适的进程，过程是怎么的呢？
- 从0下表开始遍历queue140
- 找到第一个非空队列，该队列必定为优先级最高的队列
- 拿到选中队列的第一个进程，开始运行，调度完成！
- 遍历queue140时间复杂度是常数！但还是太低效了！
- bitmap5:一共140个优先级，一共140个进程队列，为了提高查找非空队列的效率，就可以用5 *32个比特位表示队列是否为空，这样，便可以大大提高查找效率！
3.4.4 过期队列
- 过期队列和活动队列结构一模一样
- 过期队列上放置的进程，都是时间片耗尽的进程
- 当活动队列上的进程都被处理完毕之后，对过期队列的进程进行时间片重新计算
3.4.5 active指针和expired指针
- active指针永远指向活动队列
- expired指针永远指向过期队列
- 可是活动队列上的进程会越来越少，过期队列上的进程会越来越多，因为进程时间片到期时一直都存在的。
- 没关系，在合适的时候，只要能够交换active指针和expired指针的内容，就相当于有具有了一批新的活动进程！
3.4.6 总结
- 在系统当中查找一个最合适调度的进程的时间复杂度是一个常数，不随着进程增多而导致时间成本增加，我们称之为进程调度O(1)算法！
c
1 struct rq {
2 spinlock_t lock;
3
4 /*
5 * nr_running and cpu_load should be in the same cacheline because
6 * remote CPUs use both these fields when doing load calculation .
7 */
8 unsigned long nr_running;
9 unsigned long raw_weighted_load;
10 #ifdef CONFIG_SMP
11 unsigned long cpu_load[3];
12 #endif
13 unsigned long long nr_switches;
14
15 /*
16 *This is part of a global counter where only the total sum
17 *over all CPUs matters . A task can increase this counter on
18 *one CPU and if it got migrated afterwards it may decrease
19 * it on another CPU. Always updated under the runqueue lock:
20 */
21 unsigned long nr_uninterruptible;
22
23 unsigned long expired_timestamp;
24 unsigned long long timestamp_last_tick;
25 struct task_struct *curr , *idle;
26 struct mm_struct *prev_mm;
27 struct prio_array *active , *expired , arrays[2];
28 int best_expired_prio;
29 atomic_t nr_iowait;
30
31 #ifdef CONFIG_SMP
32 struct sched_domain *sd;
33
34 /* For active balancing */
35 int active_balance;
36 int push_cpu;
37
38 struct task_struct *migration_thread;
39 struct list_head migration_queue;
40 #endif
41
42 #ifdef CONFIG_SCHEDSTATS
43 /* latency stats */
44 struct sched_info rq_sched_info;
45
46 /* sys_sched_yield() stats */
47 unsigned long yld_exp_empty;
48 unsigned long yld_act_empty;
49 unsigned long yld_both_empty;
50 unsigned long yld_cnt;
51
52 /* schedule() stats */
53 unsigned long sched_switch;
54 unsigned long sched_cnt;
55 unsigned long sched_goidle;
56
57 /* try_to_wake_up () stats */
58 unsigned long ttwu_cnt;
59 unsigned long ttwu_local;
60 #endif
61 struct lock_class_key rq_lock_key;
62 };
63
64 /*
65 *These are the runqueue data structures :
66 */
67
68 struct prio_array {
69 unsigned int nr_active;
70 DECLARE_BITMAP(bitmap , MAX_PRIO+1); /* include 1 bit for delimiter */
71 struct list_head queue[MAX_PRIO];
72 };4. 命令行参数和环境变量
4.1 基本概念
- 环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数
- 如：我们在编写C/C++代码的时候，在链接的时候，从来不知道我们的所链接的动态静态库在哪里，但是照样可以链接成功，生成可执行程序，原因就是有相关环境变量帮助编译器进行查找。
- 环境变量通常具有某些特殊用途，还有在系统当中通常具有全局特性
4.2 常见的环境变量
- PATH :指定命令的搜索路径
- HOME :指定用户的主工作目录(即用户登陆到Linux系统中时,默认的目录)
- SHELL :当前Shell,它的值通常是/bin/bash。
4.3 查看环境变量方法
echo $NAME //NAME: 你的环境变量名称
测试PATH:
- 创建hello.c 文件
c
1 #include <stdio.h>
2
3
4 int main()
5 {
6 printf("hello linux!\n");
7 return 0;
8 }
~- 对比./hello执行和hello之间的执行区别
powershell
[zhangsan@VM-0-17-centos lesson]$ ll
total 20
-rwxrwxr-x 1 zhangsan zhangsan 8360 Oct 19 15:44 hello
-rw-rw-r-- 1 zhangsan zhangsan 76 Oct 19 15:43 hello.c
-rw-rw-r-- 1 zhangsan zhangsan 61 Oct 19 15:44 Makefile
# 可以看到执行hello系统是找不到的
[zhangsan@VM-0-17-centos lesson]$ hello
bash: hello: command not found
# 而./hello可是执行
[zhangsan@VM-0-17-centos lesson]$ ./hello
hello linux!- 为什么有些指令可以直接执行，不需要带路径，而我们的二进制程序需要带路径才能执行？
- 将我们的程序所在路径加入环境变量PATH当中,export PATH =$PATH:hello程序所在路径
powershell
[zhangsan@VM-0-17-centos lesson]$ PATH=$PATH:/home/zhangsan/lesson
# 可以发现PATH之后hello也可以执行了，这是因为我们不自己写打开路径，直接写指定，系统会自动从配置的环境变量去找
[zhangsan@VM-0-17-centos lesson]$ hello
hello linux!测试:HOME
- 用root和普通用户，分别执行echo $HOME ,对比差异
powershell
# 可以看到其他成员的都是在home目录下面，而root是在自己的根目录下面
[zhangsan@VM-0-17-centos lesson]$ echo $HOME
/home/zhangsan
[root@VM-0-17-centos home]# su lisi
[lisi@VM-0-17-centos home]$ echo $HOME
/home/lisi
[root@VM-0-17-centos lesson]# echo $HOME
/root- 执行cd ~; pwd, 对应 ~ 和HOME的关系
powershell
# 可以看到其他成员cd ~返回都是在home目录下, 只有root是返回在自己的根目录下面，这再次证明了其他成员是在一个家目录下
[zhangsan@VM-0-17-centos home]$ cd ~
[zhangsan@VM-0-17-centos ~]$ pwd
/home/zhangsan
[lisi@VM-0-17-centos zhangsan]$ cd ~
[lisi@VM-0-17-centos ~]$ pwd
/home/lisi
[root@VM-0-17-centos lisi]# cd ~
[root@VM-0-17-centos ~]# pwd
/root4.4 环境变量相关的命令
- echo:显示某个环境变量值
- export:设置一个新的环境变量
- env:显示所有环境变量
- unset:清除环境变量
- set:显示本地定义的shell变量和环境变量
4.5 环境变量的组织方式
每个程序都会收到一张环境表，环境表是一个字符指针数组，每个指针指向一个以'\0'结尾的环境字符串
4.6 通过代码如何获取环境变量
- 命令行第三个参数
powershell
# argc 是argv字符指针数组的大小，argv是字符指针数组，env是字符指针数组存储的是环境变量
1 #include <stdio.h>
2
3 int main(int argc,char* argv[],char* env[])
4 {
5 int i=0;
6 for(;env[i];i++)
7 {
8 printf("%s\n",env[i]);
9 }
10 return 0;
11 }- 通过第三方变量environ获取
powershell
1 #include <stdio.h>
2
3 int main(int argc,char* argv[])
4 {
5 extern char** environ;
6 int i=0;
7 for(;environ[i];i++)
8 {
9 printf("%s\n",environ[i]);
10 }
11 return 0;
12 }libc 中定义的全局变量environ指向环境变量表,environ没有包含在任何头文件中,所以在使用时要用extern声明。
4.7 通过系统调用获取或设置环境变量
- getenv,本次讲解
- putenv,后面讲解
powershell
1 #include <stdio.h>
2 #include <stdlib.h>
3 int main(int argc,char* argv[])
4 {
5 printf("%s\n",getenv("PATH"));
6 return 0;
7 }常用getenv和putenv函数来访问特定的环境变量。
4.8 环境变量通过是具有全局属性的
- 环境变量通常具有全局属性，可以被子进程继承下去
c
// test.c 代码
1 #include <stdio.h>
2 #include <stdlib.h>
3 int main()
4 {
5 char *env=getenv("MYENV");
6 if(env){
7 printf("%s\n",env);
8 }
9 return 0;
10 }
powershell
# 直接查看，发现没有结果，说明该环境变量根本不存在
[zhangsan@VM-0-17-centos lesson]$ MYENV="hello world"
[zhangsan@VM-0-17-centos lesson]$ ll
total 8
-rw-rw-r-- 1 zhangsan zhangsan 58 Oct 19 19:27 Makefile
-rw-rw-r-- 1 zhangsan zhangsan 134 Oct 19 19:38 test.c
[zhangsan@VM-0-17-centos lesson]$ make
gcc -o test test.c
[zhangsan@VM-0-17-centos lesson]$ ./test
[zhangsan@VM-0-17-centos lesson]$ - 导出环境变量
export MYENV="hello world" - 再次运行程序，发现结果有了！说明：环境变量是可以被子进程继承下去的！
powershell
[zhangsan@VM-0-17-centos lesson]$ ll
total 20
-rw-rw-r-- 1 zhangsan zhangsan 58 Oct 19 19:27 Makefile
-rwxrwxr-x 1 zhangsan zhangsan 8408 Oct 19 19:46 test
-rw-rw-r-- 1 zhangsan zhangsan 134 Oct 19 19:45 test.c
[zhangsan@VM-0-17-centos lesson]$ export MYENV="hello world"
[zhangsan@VM-0-17-centos lesson]$ ./test
hello world5程序地址空间
5.1 研究平台
- kernel 2.6.32
- 32位平台
5.2 程序地址空间回顾
我们在学习c语言的时候，都见过这样的空间布局图
可是我们对他并不理解！可以先对其进行各区域分布验证：
c
1 #include <stdio .h>
2 #include <unistd .h>
3 #include <stdlib .h>
4
5 int g_unval;
6 int g_val = 100;
7
8 int main(int argc , char *argv[], char *env [])
9 {
10 const char *str = "helloworld";
11 printf("code addr :%p\n", main);
12 printf("init global addr :%p\n",&g_val);
13 printf("uninit global addr :%p\n",&g_unval);
14
15 static int test = 10;
16 char *heap_mem = (char*)malloc(10);
17 char *heap_mem1 = (char*)malloc(10);
18 char *heap_mem2 = (char*)malloc(10);
19 char *heap_mem3 = (char*)malloc(10);
20 printf("heap addr :%p\n", heap_mem); //heap_mem (0), &heap_mem (1)
21 printf("heap addr :%p\n", heap_mem1); //heap_mem (0), &heap_mem (1)
22 printf("heap addr :%p\n", heap_mem2); //heap_mem (0), &heap_mem (1)
23 printf("heap addr :%p\n", heap_mem3); //heap_mem (0), &heap_mem (1)
24
25 printf("test static addr :%p\n",&test); //heap_mem (0), &heap_mem (1)
26 printf("stack addr :%p\n",&heap_mem); //heap_mem (0), &heap_mem (1)
27 printf("stack addr :%p\n",&heap_mem1); //heap_mem (0), &heap_mem (1)
28 printf("stack addr :%p\n",&heap_mem2); //heap_mem (0), &heap_mem (1)
29 printf("stack addr :%p\n",&heap_mem3); //heap_mem (0), &heap_mem (1)
30
31 printf("read only string addr :%p\n", str);
32 for(int i = 0 ;i < argc; i++)
33 {
34 printf("argv [%d]:%p\n", i , argv [i]);
35 }
36 for(int i = 0; env [i]; i++)
37 {
38 printf("env [%d]:%p\n", i , env [i]);
39 }
40
41 return 0;
42 }
powershell
可以看到堆区的地址是递增的，而栈区的地址是递减的
$ ./a .out
2 code addr : 0x40055d
3 init global addr : 0x601034
4 uninit global addr : 0x601040
5 heap addr : 0x1791010
6 heap addr : 0x1791030
7 heap addr : 0x1791050
8 heap addr : 0x1791070
9 test static addr : 0x601038
10 stack addr : 0x7ffd0f9a4368
11 stack addr : 0x7ffd0f9a4360
12 stack addr : 0x7ffd0f9a4358
13 stack addr : 0x7ffd0f9a4350
14 read only string addr : 0x400800
15 argv[0]: 0x7ffd0f9a4811
16 env [0]: 0x7ffd0f9a4819
17 env [1]: 0x7ffd0f9a482e
18 env [2]: 0x7ffd0f9a4845
19 env [3]: 0x7ffd0f9a4850
20 env [4]: 0x7ffd0f9a4860
21 env [5]: 0x7ffd0f9a486e
22 env [6]: 0x7ffd0f9a4892
23 env [7]: 0x7ffd0f9a48a5
24 env [8]: 0x7ffd0f9a48ae
25 env [9]: 0x7ffd0f9a48f1
26 env [10]: 0x7ffd0f9a4e8d
27 env [11]: 0x7ffd0f9a4ea6
28 env [12]: 0x7ffd0f9a4f00
29 env [13]: 0x7ffd0f9a4f13
30 env [14]: 0x7ffd0f9a4f24
31 env [15]: 0x7ffd0f9a4f3b
32 env [16]: 0x7ffd0f9a4f43
33 env [17]: 0x7ffd0f9a4f52
34 env [18]: 0x7ffd0f9a4f5e
35 env [19]: 0x7ffd0f9a4f93
36 env [20]: 0x7ffd0f9a4fb6
37 env [21]: 0x7ffd0f9a4fd5
38 env [22]: 0x7ffd0f9a4fdf5.3 虚拟地址
来段代码感受一下
c
1 #include <stdio .h>
2 #include <unistd .h>
3 #include <stdlib .h>
4
5 int g_val = 0;
6
7 int main()
8 {
9 pid_t id = fork();
10 if(id < 0){
11 perror("fork");
12 return 0;
13 }
14 else if(id == 0){ //child
15 printf("child[%d]:%d :%p\n", getpid(), g_val ,&g_val);
16 }else{ //parent
17 printf("parent[%d]:%d :%p\n", getpid(), g_val ,&g_val);
18 }
19 sleep(1);
20 return 0;
21 }输出
//与环境相关，观察现象即可
parent2995: 0 : 0x80497d8
child2996: 0 : 0x80497d8
我们发现，输出出来的变量值和地址是一模一样的，很好理解呀，因为子进程按照父进程为模版，父子并没有对变量进行进行任何修改。可是将代码稍加改动:
c
1 #include <stdio .h>
2 #include <unistd .h>
3 #include <stdlib .h>
4
5 int g_val = 0;
6
7 int main()
8 {
9 pid_t id = fork();
10 if(id < 0){
11 perror("fork");
12 return 0;
13 }
14 else if(id == 0){ //child,子进程肯定先跑完，也就是子进程先修改，完成之后，父进程再读取
15 g_val=100;
16 printf("child[%d]:%d :%p\n", getpid(), g_val ,&g_val);
17 }else{ //parent
18 sleep(3);
19 printf("parent[%d]:%d :%p\n", getpid(), g_val ,&g_val);
20 }
21 sleep(1);
22 return 0;
23 }输出结果
//与环境相关，观察现象即可
child3046: 100 : 0x80497e8
parent3045: 0 : 0x80497e8
我们发现，父子进程，输出地址是一致的，但是变量内容不一样！能得出如下结论:
- 变量内容不一样,所以父子进程输出的变量绝对不是同一个变量
- 但地址值是一样的，说明，该地址绝对不是物理地址！
- 在Linux地址下，这种地址叫做虚拟地址
- 我们在用C/C++语言所看到的地址，全部都是虚拟地址！物理地址，用户一概看不到，由OS统一管理
OS必须负责将虚拟地址转化成物理地址。
5.4 进程地址空间
所以之前说'程序的地址空间'是不准确的，准确的应该说成进程地址空间，那该如何理解呢？看图：
说明
- 上面的图就足矣说明问题，同一个变量，地址相同，其实是虚拟地址相同，内容不同其实是被映射到了不同的物理地址！
5.5 虚拟内存管理
描述linux下进程的地址空间的所有的信息的结构体是（内存描述符）。每个进程只有一个mm_struct结构，在每个进程的task_struct 结构中，有一个指向该进程的mm_struct结构体指针。
powershell
1 struct task_struct
2 {
3 /*...*/
4 struct mm_struct *mm; //对于普通的用户进程来说该字段指向他的虚拟地址空间的用户空间部分，对于内核线程来说这部分为NULL。
5 struct mm_struct *active_mm; // 该字段是内核线程使用的。当该进程是内核线程时，它的mm字段为NULL，表示没有内存地址空间，可也并不是真正的没有，这是因为所有进程关于内核的映射都是一样的，内核线程可以使用任意进程的地址空间。
6
7 /*...*/
8 }可以说，mm_struct 结构是对整个用户空间的描述。每一个进程都会有自己独立的mm_struct ，这样每一个进程都会有自己独立的地址空间才能互不干扰。先来看看由task_struct 到mm_struct，进程的地址空间的分布情况：
定位mm_struct 文件所在位置和task_struct 所在路径是一样的，不过他们所在文件是不一样的，mm_struct 所在的文件是mm_types .h
c
1 struct mm struct
2 {
3 /*...*/
4 struct vm_area_struct *mmap; /* 指向虚拟区间(VMA)链表*/
5 struct rb_root mm_rb; /* red_black树*/
6 unsigned long task_size; /*具有该结构体的进程的虚拟地址空间的大小*/
7 /*...*/
8 //代码段、数据段、堆栈段、参数段及环境段的起始和结束地址。
9 unsigned long start_code , end_code , start_data , end_data;
10 unsigned long start_brk , brk , start_stack;
11 unsigned long arg_start , arg_end , env_start , env_end;
12 /*...*/
13 }那既然每一个进程都会有自己独立的mm_struct ，操作系统肯定是要将这么多进程的mm_struct组织起来的！虚拟空间的组织方式有两种：
- 当虚拟区较少时采取单链表，由mmap指针指向这个链表；
- 当虚拟区间多时采取红黑树进行管理，由mm_rb指向这棵树。
linux内核使用结构来表示一个独立的虚拟内存区域(VMA)，由于每个不同质的虚拟内存区域功能和内部机制都不同，因此一个进程使用多个vm_area_struct结构来分别表示不同类型的虚拟内存区域。上面提到的两种组织方式使用的就是vm_area_struct结构来连接各个VMA，方便进程快速访问。
c
struct vm_area_struct {
unsigned long vm_start; //虚存区起始
unsigned long vm_end; //虚存区结束
struct vm_area_struct *vm_next , *vm_prev; //前后指针
struct rb_node vm_rb; //红黑树中的位置
unsigned long rb_subtree_gap;
struct mm_struct *vm_mm; //所属的mm_struct
pgprot_t vm_page_prot;
unsigned long vm_flags; //标志位
struct {
struct rb_node rb;
unsigned long rb_subtree_last;
} shared;
struct list_head anon_vma_chain;
struct anon_vma *anon_vma;
const struct vm_operations_struct *vm_ops; //vma对应的实际操作
unsigned long vm_pgoff; //文件映射偏移量
struct file *vm_file; //映射的文件
void *vm_private_data; //私有数据
atomic_long_t swap_readahead_info;
#ifndef CONFIG_MMU
struct vm_region *vm_region; /* NOMMU mapping region */
#endif
#ifdef CONFIG_NUMA
struct mempolicy *vm_policy; /* NUMA policy for the VMA */
#endif
struct vm_userfaultfd_ctx vm_userfaultfd_ctx;
} __randomize_layout;所以我们可以对上图在进行更细致的描述，如下图所示：
