linux 进程补充

环境变量

 基本概念
环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数
如：我们在编写C/C++代码的时候，在链接的时候，从来不知道我们的所链接的动态静态库在哪
里，但是照样可以链接成功，生成可执行程序，原因就是有相关环境变量帮助编译器进行查找。
环境变量通常具有某些特殊用途，还有在系统当中通常具有全局特性

常见环境变量

• PATH : 指定命令的搜索路径
• HOME : 指定用户的主工作目录(即用户登陆到Linux系统中时,默认的目录)
• SHELL : 当前Shell,它的值通常是/bin/bash。 

查看环境变量方法
echo $NAME //NAME:你的环境变量名称

命令行传参数

#include <stdio.h>
int main(int argc, char *argv[], char *env[])
{
int i = 0;
for(; env[i]; i++){
printf("%s\n", env[i]);
}
return 0;
}

命令行参数可以通过选项来执行不同的子功能 

 #include<stdio.h>2 #include<string.h>
W>  3 int main(int argc,char *argv[])4 {5 if(argc!=2)6 {7   printf("usage:%s [-a|-b|-c]\n",argv[0]);8 9 }10 const char *arg=argv[1];11 if(strcmp(arg,"-a")==0) printf("这是-a选项 功能1\n");12 else if(strcmp(arg,"-b")==0)printf("这是-b选项 功能2\n");13 else if(strcmp(arg,"-c")==0)printf("这是-c选项 功能3\n");14 else printf("usage:%s [-a|-b|-c]\n",argv[0]);                                                                                                                                          15   return 0;                                                                                                                                         16 }

 所以类比一下：main函数也是一个进程，所带的命令行参数由bash切分，main函数的命令行参数int main(int argc, char *argv[], char *env[])所带的选项是实现程序不同子功能的方法

进程拥有一张表，argv表，用来支持选项功能！

测试HOME

 其实Linux里面的指令都是二进制文件，然后再链接我们总结写的文件，最后汇到一块一起运行，要运行一个二进制文件，必须先找到它 ./是在文件树下找，但是我把二进制拷贝到home下，系统默认的路径下我们不带./也能跑，这也是其他指令的由来

系统中存在环境变量，来帮助找到二进制文件 就是PATH 系统默认的搜索路径！

测试PATH 

• 直接覆盖路径

 将二进制文件code的路径覆盖原先的path路径，code可以跑，但是原先的指令跑不了了，因为原先的路径找不到了

• 添加路径

 这种是在原先路径下加一条路径，自带命令和code都能跑，但是这种不易加太多，自己写的二进制没有经过时间及用户的沉淀一般bug较多，写进去也没关系，以上两种重启xshell就自动复原了

理解argv表 

在bath进程启动的时候，在它自己内部构建出一张表，在用户输入指令时首先被bath拿到，被拆分成若干个字符串放在argv[0],argv[1],argv[3]...指针数组argv指向他们，bath通过argv【0】下的程序名字找到path下的二进制来运行

所以，在bath内部下，有两张表，一个是环境变量表(path)，一个是命令行参数表(argv) 

 环境变量的组织方式

 每个程序都会收到一张环境表，环境表是一个字符指针数组，每个指针指向一个以’\0’结尾的环境
字符串

和环境变量相关的命令

• echo: 显示某个环境变量值
• export: 设置一个新的环境变量
• env: 显示所有环境变量
• unset: 清除环境变量
• set: 显示本地定义的shell变量和环境变量 

通过代码如何获取环境变量

• 命令行第三个参数

 #include<stdio.h>2 #include<string.h>3 int main(int argc,char *argv[],char * env[])4 {5 (void)argc;6 (void)argv;7 8 for(int i=0;env[i];i++)9 {10   printf("env[%d]->%s\n",i,env[i]);                                                                                                                                                      11 12 }13   return 0;14 }

•  通过第三方变量environ获取

#include <stdio.h>
int main(int argc, char *argv[])
{
extern char **environ;
int i = 0;
for(; environ[i]; i++){
printf("%s\n", environ[i]);
}
return 0;
}

libc中定义的全局变量environ指向环境变量表,environ没有包含在任何头文件中,所以在使用时 要用
extern声明。

通过系统调用获取或设置环境变量

• export

获取的是父进程的环境变量,可通过export来新添加环境变量，环境变量可以通过子进程来继承

 

•  getenv 

通过名字获取环境变量，获取成功返回起始变量地址，否则就是NULL

#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("%s\n", getenv("PATH"));
return 0;
}

 环境变量通常是具有全局属性的
环境变量通常具有全局属性，可以被子进程继承下去

bath有两套变量

• 本地变量

只在bash内被使用，不会被子进程继承

• 环境变量 

环境变量在谁里面？bash！

#include <stdio.h>
#include <stdlib.h>
int main()
{
char *env = getenv("MYENV");
if(env){
printf("%s\n", env);
}
return 0;
}

运行结果啥也没有 ,说明该环境变量根本不存在

 导出环境变量 export MYENV="hello world"

注意：环境变量是可以被子进程继承下去的 ，内建命令有bash自己去执行，其他的都是调用子进程

程序地址空间

我们在讲C语⾔的时候，老师给大家画过这样的空间布局图

可是我们对他并不理解！可以先对其进行各区域分布验证 

 #include <stdio.h>2 #include <unistd.h>3 #include <stdlib.h>4 
E>  5 int g_unval;//未初始化全局变量6 int g_val = 100;//已初始化全局变量7 int main(int argc, char *argv[], char *env[])//命令行参数环境变量8 {9 const char *str = "helloworld";//临时变量10                                                                                                                                                                         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                                                                                                               16 static int test = 10;//静态常量                                                                                       17 char *heap_mem = (char*)malloc(10);                                                                                   18 char *heap_mem1 = (char*)malloc(10);                                                                                  19 char *heap_mem2 = (char*)malloc(10);                                                                                  20 char *heap_mem3 = (char*)malloc(10);                                                                                  21 printf("heap addr: %p\n", heap_mem); //heap_mem(0), &heap_mem(1)                                                      22 printf("heap addr: %p\n", heap_mem1); //heap_mem(0), &heap_mem(1)                                                     23 printf("heap addr: %p\n", heap_mem2); //heap_mem(0), &heap_mem(1)                                                     24 printf("heap addr: %p\n", heap_mem3); //heap_mem(0), &heap_mem(1)                                                     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 printf("read only string addr: %p\n", str);                                                                          31 for(int i = 0 ;i < argc; i++)                                                                                        32 {                                                                                                                    33 printf("argv[%d]: %p\n", i, argv[i]);                                                                                34 }                                                                                                                    35 for(int i = 0; env[i]; i++)                                                                                          36 {                                                                                                                    37 printf("env[%d]: %p\n", i, env[i]);                                                                                  38 }                                                                                                                    39 return 0;                                                                                                            40 }                                                                                                                    ~     

虚拟地址

 #include <stdio.h>2 #include <unistd.h>3 #include <stdlib.h>4 int gval =100;5 int main()6 {7 8 pid_t id =fork();9 if(id==0)10 {11 while(1)12 {13 printf("子 gval:%d,&gval:%p,pid:%d ppid:%d\n",gval,&gval,getpid(),getppid());14 sleep(1);15 gval++;16 }17 }18 else19 {20   while(1)21   {22  printf("父 gval:%d,&gval:%p,pid:%d ppid:%d\n",gval,&gval,getpid(),getppid());                                                                                                           23 sleep(1);24 25   }26 }27 return 0;28 }

 父进程2847，子进程2848，父进程gval一直是100，而子进程gval不断叠加，但是地址却一样这是为什么呢？

变量内容不一样,所以父子进程输出的变量绝对不是同一个变量，如果打印的地址是内存地址，就出bug了，说明这个地址不是内存地址，而是虚拟地址！C/C++用到的地址全部是虚拟地址，只是为了映射关系OS搞出的一套逻辑而已！

OS必须负责将 虚拟地址 转化成 物理地址 。

 进程地址空间

所以之前说‘程序的地址空间’是不准确的，准确的应该说成 进程地址空间 ，那该如何理解呢？看
图：

分页&虚拟地址空间

每个进程都有页表这个东西，里面存着数据的映射关系，打印的虚拟地址起始是页表中的地址，采用红黑树，类比哈希表的映射方式

子进程发生写实拷贝，将父亲的页表也拷贝过来，页表是存着映射关系，子进程继承了父进程的映射关系，拷贝了一份页表，从此，父子毫不相干，各自操作各自的页表，从此独立，可以完全被子进程继承！

虚拟内存管理

描述linux下进程的地址空间的所有的信息的结构体是 mm_struct （内存描述符）。每个进程只有一个mm_struct结构，在每个进程的task_struct结构中，有一个指向该进程的结构。

struct task_struct
{
/*...*/
struct mm_struct
*mm; //对于普通的⽤⼾进程来说该字段指向他的
虚拟地址空间的⽤⼾空间部分，对于内核线程来说这部分为NULL。
struct mm_struct
*active_mm; // 该字段是内核线程使⽤的。当该
进程是内核线程时，它的mm字段为NULL，表⽰没有内存地址空间，可也并不是真正的没有，这是因为所
有进程关于内核的映射都是⼀样的，内核线程可以使⽤任意进程的地址空间。
/*...*/
}

 可以说，mm_struct结构是对整个用户空间的描述。每一个进程都会有自己独立的mm_struct，这样每一个进程都会有自己独里的地址空间才能互不干扰。先来看看由task_struct到mm_struct，进程的地址空间的分布情况：

 定位mm_struct文件所在位置和task_struct所在路径是⼀样的，不过他们所在文件是不一样的，
mm_struct所在的文件是mm_types.h。

struct mm_struct
{
/*...*/
struct vm_area_struct *mmap;
/* 指向虚拟区间(VMA)链表 */
struct rb_root mm_rb;
/* red_black树 */
unsigned long task_size;
/*具有该结构体的进程的虚拟地址空间的⼤⼩*/
/*...*/
// 代码段、数据段、堆栈段、参数段及环境段的起始和结束地址。
unsigned long start_code, end_code, start_data, end_data;
unsigned long start_brk, brk, start_stack;
unsigned long arg_start, arg_end, env_start, env_end;
/*...*/}

那既然每⼀个进程都会有自己独立的mm_struct，操作系统肯定是要将这么多进程的mm_struct组织起来的！虚拟空间的组织方式有两种：
1. 当虚拟区较少时采取单链表，由mmap指针指向这个链表；
2. 当虚拟区间多时采取红黑树进行管理，由mm_rb指向这棵树。
linux内核使用 vm_area_struct 结构来表示一个独立的虚拟内存区域(VMA)，由于每个不同质的虚
拟内存区域功能和内部机制都不同，因此一个进程使用多个vm_area_struct结构来分别表示不同类型的虚拟内存区域。上面提到的两种组织方式使用的就是vm_area_struct结构来连接各个VMA，⽅便进程快速访问。

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;

所以我们可以对上图在进行更细致的描述，如下图所示：

 

为什么要有虚拟地址空间 

这个问题其实可以转化为：如果程序直接可以操作物理内存会造成什么问题？

在早期的计算机中，要运行一个程序，会把这些程序全都装入内存，程序都是直接运行在内存上的，也就是说程序中访问的内存地址都是实际的物理内存地址。当计算机同时运行多个程序时，必须保证这些程序用到的内存总量要小于计算机实际物理内存的大小。
那当程序同时运行多个程序时，操作系统是如何为这些程序分配内存的呢？例如某台计算机总的内存大小是128M，现在同时运行两个程序A和B，A需占用内存10M，B需占用内存110。计算机在给程序分配内存时会采取这样的方法：先将内存中的前10M分配给程序A，接着再从内存中剩余的118M中划分出110M分配给程序B。

 这种分配方法可以保证程序A和程序B都能运行，但是这种简单的内存分配策略问题很多。

安全风险

• 每个进程都可以访问任意的内存空间，这也就意味着任意⼀个进程都能够去读写系统相关内存区域，如果是⼀个木马病毒，那么他就能随意的修改内存空间，让设备直接瘫痪。

地址不确定

• 众所周知，编译完成后的程序是存放在硬盘上的，当运行的时候，需要将程序搬到内存当中去运行，如果直接使用物理地址的话，我们无法确定内存现在使用到哪里了，也就是说拷贝的实际内存地址每一次运行都是不确定的，比如：第一次执行a.out时候，内存当中一个进程都没有运行，所以搬移到内存地址是0x00000000，但是第二次的时候，内存已经有10个进程在运行了，那执行a.out的时候，内存地址就不⼀定了

效率低下

• 如果直接使用物理内存的话，一个进程就是作为一个整体（内存块）操作的，如果出现物理内存不够用的时候，我们一般的办法是将不常用的进程拷贝到磁盘的交换分区中，好腾出内存，但是如果是物理地址的话，就需要将整个进程⼀起拷走，这样，在内存和磁盘之间拷贝时间太长，效率较低。

存在这么多问题，有了虚拟地址空间和分页机制就能解决了吗？当然！

• 地址空间和页表是OS创建并维护的！是不是也就意味着，凡是想使用地址空间和页表进行映射，也⼀定要在OS的监管之下来进行访问！！也顺便保护了物理内存中的所有的合法数据包括各个进程以及内核的相关有效数据!
• 因为有地址空间的存在和页表的映射的存在，我们的物理内存中可以对未来的数据进行任意位置的加载！物理内存的分配和进程的管理就可以做到没有关系，进程管理模块和内存管理模块就完成了解耦合。（因为有地址空间的存在，所以我们在C、C++语言上new, malloc空间的时候，其实是在地址空间上申请的，物理内存可以甚至一个字节都不给你。而当你真正进行对物理地址空间访问的时候，才执行内存的相关管理算法，帮你申请内存，构建页表映射关系（延迟分配），这是由操作系统自动完成，用户包括进程完全0感知！！）
• 因为页表的映射的存在，程序在物理内存中理论上就可以任意位置加载。它可以将地址空间上的虚拟地址和物理地址进行映射，在进程视角所有的内存分布都可以是有序的