Linux进程控制【进程程序替换】

简介: Linux进程程序替换,程序替换原理、七大替换函数以及简易版shell模拟实现详细讲解,干货满满!

Linux进程控制【进程程序替换】

子进程在被创建后,会共享父进程的代码,如果想让子进程执行其他任务,就需要把当前子进程的程序替换为目标程序,这就是进程程序替换

1. 程序替换原理

我们使用一个替换函数execl,来看看现象

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

int main()
{
   
  printf("begin......\n");
  printf("begin......\n");
  printf("begin......\n");

  execl("/bin/ls", "ls", "-a", "-l", NULL);

  printf("end.....\n");
  printf("end.....\n");
  printf("end.....\n");
  return 0;
}

我们发现在myfile程序执行的过程中,调用execl来执行另一个程序,新的代码和数据加载了,但执行完新程序后并没有回来继续执行原程序,原程序中后续的代码直接被替换了,没机会执行了,这就是程序替换

进程程序替换原理

  • fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支)
  • 进程有对应的PCB,数据和代码会被加载到内存中,子进程调用一种exec函数(替换函数)时,该进程的代码和数据完全被新程序替换,执行新程序
  • 进程的程序替换并没有创建新的进程,而是对原有程序中的数据和代码进行修改,调用exec函数前后该进程的PID并没有变化
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/wait.h>

int main()
{
   
  pid_t id = fork();
  if(id == 0)
  {
   
    printf("我是子进程, 我的PID:%d, PPID:%d\n", getpid(), getppid());
    execl("/bin/ls","ls", "-a", "-l");
  }
  sleep(3);

  printf("我是父进程,我的PID:%d\n", getpid());
  waitpid(id, NULL, 0);

  return 0;
}

进程程序替换图解

进程程序替换的目的就是是让子进程帮我们执行特定的任务

  • shell外壳中的bash就是一个任务处理平台,当我们发出指令后,bash会创建子进程,将其替换为对应的指令程序并执行任务,就能实现各种指令
  • bash运行后,使用指令本质上就是在进行程序替换

2. 替换函数

进程程序替换函数一共有七个,其中六个都是对系统级接口execve的封装

各替换函数关系图示

2.1 execl函数

#include <unistd.h>

int execl(const char* path, const char* arg, ...);

execl函数

  • 返回值:替换失败返回-1,成功后不返回
  • path参数:代替换程序的路径
  • arg参数:代替换程序名
  • . . .:可变参数列表,可以传递多个参数(这里是链式传递),表示待替换的程序选项,最后一个必须以NULL结尾,表示选项传递结束

七个替换函数都是失败返回-1,成功不返回,成功后代码都被替换了,返回就没有意义了

使用实例

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

int main()
{
   
    printf("Can you see me?\n");

  int ret = execl("/bin/pwd", "pwd", NULL);

  if(ret == -1)
    printf("程序替换失败");

  printf("Can you see me?\n");
  return 0;
}

2.2 execv函数

#include <unistd.h>

int execv(const char* path, char* const argv[]);

execv函数

  • path参数:待替换程序的路径
  • argv[]参数:代替换程序名及其选项,是一个指针数组,相当于用一张表传递参数

使用实例

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

int main()
{
   
  char* const argv[] = {
   "ls", "-a", "-l", NULL}; //最后一个参数也要设为NULL

  execv("/bin/ls", argv);
  return 0;
}

2.3 execlp函数

#include <unistd.h>

int execlp(const char* file, const char* arg, ...);

execlp函数

  • file参数:执行文件名
  • arg参数:代替换程序名
  • . . .:可变参数列表,待替换的程序选项

使用实例

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

int main()
{
   
  execlp("ls", "ls", "-a", "-l", NULL);  

  return 0;
}
//第一个ls是执行文件名,第二个ls及以后是怎样执行的参数

execlp函数不用填写文件路径,可以自动到PATH变量中去查找程序,如果程序路径不在PATH变量中,则无法进行替换

2.4 execvp函数

#include <unistd.h>

int execvp(const char* file, char* const argv[]);

execvp函数

  • file参数:待替换程序名,需要位于PATH
  • argv[]参数:代替换程序名及其选项,是一个指针数组,相当于用一张表传递参数
#include <stdio.h>
#include <unistd.h>

int main()
{
    
  char* const argv[] = {
   "ls", "-a", "-l", NULL};

  execvp("ls", argv);
  return 0;
}

如果file的路径不在 PATH中,程序会替换错误,想替换自己写的程序,需要将路径添加至 PATH

2.5 execle函数

execle最后的一个e,就表示环境变量表,可以将自定义的或者当前程序中的环境变量表传给待替换程序,其他没有带 e 的替换函数,默认传递当前程序中的环境变量表

#include <unistd.h>

int execl(const char* path, const char* arg, ..., char* const envp[]);

execle函数

  • path参数:代替换程序的路径
  • arg参数:代替换程序名
  • . . .:可变参数列表,待替换的程序选项

  • envp[]:可自定义待替换程序的环境变量表

使用实例

//myfile.c
#include <stdio.h>
#include <unistd.h>

int main()
{
   
  char* const myenv[] = {
   "MYENV=study9/test.c", NULL};

  execle("./exec/otherTest", "otherTest", NULL, myenv);
  return 0;
}
//Test.c
#include <iostream>
#include <unistd.h>
#include <stdlib.h>
using namespace std;

int main()
{
   
  for(int i = 0; i < 3; ++i)
  {
   
    cout << "我是exec路径下的程序,我的PID是: " << getpid() << " " << "MYENV:"<< (getenv("MYENV") == NULL ? "NULL" : getenv("MYENV")) << endl;
    sleep(1);
  }
  return 0;
}

我们改写一下Test.cc中的代码,来观察一个现象

//Test.c
#include <iostream>
#include <unistd.h>
#include <stdlib.h>
using namespace std;

int main()
{
   
    cout << "------------------------------------------------------" << endl;
    cout << "我是exec路径下的程序,我的PID是: " << getpid() << endl;
    cout << "MYENV:"<< (getenv("MYENV") == NULL ? "NULL" : getenv("MYENV")) << endl;
    cout << "PATH:"<< (getenv("PATH") == NULL ? "NULL" : getenv("PATH")) << endl;
    cout << "------------------------------------------------------" << endl;  
  return 0;
}

再来运行myfile

我们观察到当本程序中设定自定义环境变量,待替换的程序中有系统环境变量,此时运行本程序时,待替换程序中的系统环境变量为NULL

  • 如果主动传入环境变量后,待替换程序中的原环境变量表会被覆盖

这里可以使用putenv函数来解决这个现象

int putenv(char* string);  //改变或者添加一个环境变量

myfile.c中的代码进行改造

//myfile.c
#include <stdio.h>
#include <unistd.h>

extern char** environ; //声明环境变量表

int main()
{
  char* const myenv[] = {"MYENV=Test/myfile.c", NULL};
  putenv("MYENV=Test/myfile.c");
  execle("./exec/MyTest", "MyTest", NULL, environ);

  return 0;
}

环境变量表具有全局属性,可以被继承下去,原理就体现出来了

  • 所有的指令都是bash的子进程,在bash下执行程序,就是在bash下将子进程替换为指定程序,并将bash中的环境变量表environ传递给指定程序使用
  • bash执行指令都可以使用execl来执行,我们要把bash的环境变量交给子进程,子进程只需要调用execle,再把对应的bash的环境变量作为参数即可被子进程继承下去

2.6 execve函数

execve是系统级的程序替换函数,其他替换函数都是对execve的封装调用

#include <unistd.h>

int execve(const char* filename, char* const argv[], char* const envp[]);

execve函数

  • filename参数:待替换程序的路径
  • argv[]参数:代替换程序名及其选项,是一个指针数组,相当于用一张表传递参数
  • envp[]参数:可自定义待替换程序的环境变量表

系统及接口是不分语言的,无论什么语言最终都要调用系统接口,所以这里的替换函数还可以替换其他语言写的程序

2.7 execvpe函数

使用方法和execvp 一样,多了一个参数可以传递环境变量表

#include <unistd.h>

int execvpe(const char* file, char* const argv[], char* const envp[]);

execvpe函数

  • file参数:待替换程序名,需要位于PATH
  • argv[]参数:代替换程序名及其选项,是一个指针数组,相当于用一张表传递参数
  • envp[]参数:传递给待替换程序的环境变量表

2.8 函数记忆

函数名 参数格式 是否带路径 是否使用当前环境变量
execl 列表 不是
execlp 列表
execle 列表 不是 不是,必须自己组装环境变量
execv 数组 不是
execvp 数组
execve 数组 不是 不是,必须自己组装环境变量
execvpe 数组 不是,必须自己组装环境变量

exec系列替换函数的命名是有意义的

  • l就是list,表示链式传递
  • v就是vector,表示顺序表式传递
  • p就是PATH,表示能根据程序名自动在PATH变量中查找,无需写全路径
  • e就是environ,表示需要自己组装环境变量,可以传递自定义环境变量表

3. 模拟实现简易版shell

有了前面讲到的进程创建、进程退出、进程程序替换等知识的铺垫,我们可以自己写一个简易版的shell

shell 的循环过程

  • 获取命令行
  • 解析命令行
  • 建立一个子进程(fork)
  • 替换子进程(execvp)
  • 父进程等待子进程退出(wait)

编写有些粗糙,仅供理解框架思路

//模拟实现简易版bash命令行
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <sys/wait.h>
#include <sys/types.h>

#define COMMANDMAXSIZE 1024
#define ARGVMAXSIZE 64

int split(char* command_string, char* argv[])
{
   
  assert(command_string != NULL && argv != NULL);
  argv[0] = strtok(command_string, " ");
  if(argv[0] == NULL) 
  {
   
    return -1;
  }
  int i = 1;
  while((argv[i++] = strtok(NULL, " ")));
  return 0;
}

void debugOut(char* argv[])
{
   
  int i = 0;
  while(argv[i] != NULL)
  {
   
    printf("%d->%s\n", i, argv[i]);
    ++i;
  }
}

int main()
{
   
  while(1)
  {
   
    char command_string[COMMANDMAXSIZE] = {
   0};
    printf("[name@my_root currpath]# ");
    fflush(stdout);
    char* s = fgets(command_string, sizeof(command_string), stdin);
    assert(s != NULL);
    (void)s; //保证release版本时,因为去掉assert()导致ret未被使用,而带来的编译告警
    command_string[strlen(command_string) - 1] = '\0'; //去掉回车导致的换行
    char* argv[ARGVMAXSIZE] = {
   NULL};
    int ret = split(command_string, argv); //命令字符串切割
    if(ret != 0)
    {
   
      continue;
    }
    //debugOut(argv);

    pid_t id = fork();
    assert(id >= 0);
    if(id == 0) //子进程
    {
   
      execvp(argv[0], argv);
      exit(0); 
    }

    //父进程
    int status = 0;
    waitpid(id, &status, 0);

    //子进程去执行对应的命令,父进程等待子进程
  }
  return 0;
}

Linux进程控制—进程程序替换,到这里就介绍结束了,本篇文章对你由帮助的话,期待大佬们的三连,你们的支持是我最大的动力!

文章有写的不足或是错误的地方,欢迎评论或私信指出,我会在第一时间改正

相关实践学习
CentOS 7迁移Anolis OS 7
龙蜥操作系统Anolis OS的体验。Anolis OS 7生态上和依赖管理上保持跟CentOS 7.x兼容,一键式迁移脚本centos2anolis.py。本文为您介绍如何通过AOMS迁移工具实现CentOS 7.x到Anolis OS 7的迁移。
目录
相关文章
|
9天前
|
运维 监控 Linux
Linux操作系统的守护进程与服务管理深度剖析####
本文作为一篇技术性文章,旨在深入探讨Linux操作系统中守护进程与服务管理的机制、工具及实践策略。不同于传统的摘要概述,本文将以“守护进程的生命周期”为核心线索,串联起Linux服务管理的各个方面,从守护进程的定义与特性出发,逐步深入到Systemd的工作原理、服务单元文件编写、服务状态管理以及故障排查技巧,为读者呈现一幅Linux服务管理的全景图。 ####
|
1月前
|
缓存 监控 Linux
linux进程管理万字详解!!!
本文档介绍了Linux系统中进程管理、系统负载监控、内存监控和磁盘监控的基本概念和常用命令。主要内容包括: 1. **进程管理**: - **进程介绍**:程序与进程的关系、进程的生命周期、查看进程号和父进程号的方法。 - **进程监控命令**:`ps`、`pstree`、`pidof`、`top`、`htop`、`lsof`等命令的使用方法和案例。 - **进程管理命令**:控制信号、`kill`、`pkill`、`killall`、前台和后台运行、`screen`、`nohup`等命令的使用方法和案例。
119 4
linux进程管理万字详解!!!
|
24天前
|
存储 运维 监控
深入Linux基础:文件系统与进程管理详解
深入Linux基础:文件系统与进程管理详解
63 8
|
21天前
|
Linux
如何在 Linux 系统中查看进程占用的内存?
如何在 Linux 系统中查看进程占用的内存?
|
1月前
|
算法 Linux 定位技术
Linux内核中的进程调度算法解析####
【10月更文挑战第29天】 本文深入剖析了Linux操作系统的心脏——内核中至关重要的组成部分之一,即进程调度机制。不同于传统的摘要概述,我们将通过一段引人入胜的故事线来揭开进程调度算法的神秘面纱,展现其背后的精妙设计与复杂逻辑,让读者仿佛跟随一位虚拟的“进程侦探”,一步步探索Linux如何高效、公平地管理众多进程,确保系统资源的最优分配与利用。 ####
69 4
|
1月前
|
缓存 负载均衡 算法
Linux内核中的进程调度算法解析####
本文深入探讨了Linux操作系统核心组件之一——进程调度器,着重分析了其采用的CFS(完全公平调度器)算法。不同于传统摘要对研究背景、方法、结果和结论的概述,本文摘要将直接揭示CFS算法的核心优势及其在现代多核处理器环境下如何实现高效、公平的资源分配,同时简要提及该算法如何优化系统响应时间和吞吐量,为读者快速构建对Linux进程调度机制的认知框架。 ####
|
1月前
|
消息中间件 存储 Linux
|
5月前
|
运维 关系型数据库 MySQL
掌握taskset:优化你的Linux进程,提升系统性能
在多核处理器成为现代计算标准的今天,运维人员和性能调优人员面临着如何有效利用这些处理能力的挑战。优化进程运行的位置不仅可以提高性能,还能更好地管理和分配系统资源。 其中,taskset命令是一个强大的工具,它允许管理员将进程绑定到特定的CPU核心,减少上下文切换的开销,从而提升整体效率。
掌握taskset:优化你的Linux进程,提升系统性能
|
5月前
|
弹性计算 Linux 区块链
Linux系统CPU异常占用(minerd 、tplink等挖矿进程)
Linux系统CPU异常占用(minerd 、tplink等挖矿进程)
184 4
Linux系统CPU异常占用(minerd 、tplink等挖矿进程)
|
4月前
|
算法 Linux 调度
探索进程调度:Linux内核中的完全公平调度器
【8月更文挑战第2天】在操作系统的心脏——内核中,进程调度算法扮演着至关重要的角色。本文将深入探讨Linux内核中的完全公平调度器(Completely Fair Scheduler, CFS),一个旨在提供公平时间分配给所有进程的调度器。我们将通过代码示例,理解CFS如何管理运行队列、选择下一个运行进程以及如何对实时负载进行响应。文章将揭示CFS的设计哲学,并展示其如何在现代多任务计算环境中实现高效的资源分配。

热门文章

最新文章