进程程序替换

最新推荐文章于 2024-07-17 20:41:49 发布
最新推荐文章于 2024-07-17 20:41:49 发布
阅读量615 收藏 1
点赞数
分类专栏： Linux 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57723028/article/details/128372546
版权

文章目录

进程程序替换是什么

概念

通过之前的学习，我们知道子进程执行的是父进程的代码片段。
如果我们想让创建出来的子进程，执行的是全新的程序呢？
这里我们就需要用到进程程序替换。

原理

1.将磁盘中的程序，加载入内存结构
2.重新建立页表映射，谁执行程序替换，就重新建立谁的映射(子进程)
效果:让我们的父进程和子进程彻底分离，并让子进程执行一个新的程序。

在这里插入图片描述

那么问题来了!!!

这个过程有没有创建新的进程呢？

答:我们肯定没有创建新的进程，只不过让子进程执行了新的程序

为什么要进行程序替换

我们一般在服务器设计(linux编程)的时候，往往需要子进程干两件种类的事情

  • 1.让子进程执行父进程的代码片段(服务器代码)
  • 2.让子进程执行磁盘中的一个全新的程序(shell,想让客户端执行对应的程序，通过我们的进程，执行其他人写的进程的代码等等)
    例如我们用C语言的进程去掉java/python/C++等等的程序。

如何进行程序替换

由OS完成，所以我们要调用系统接口。

首先带大家来看看系统接口有什么！

在这里插入图片描述
我们如果要执行一个全新的程序，我们需要做几件事情呢？

  • 程序本质就是一个磁盘上的文件，所以我们需要先找到这个程序在哪里
  • 程序可能携带选项进行执行(也可以不携带)，然后告诉OS，我要怎么执行这个程序？(要不要带选项)

使用接口

execl

在这里插入图片描述

其中参数列表中：“…” 叫做可变参数，说白了就是可以按照用户的意愿传入参数的大小个数，如果还不理解，大家肯定都用过C语言中的printf函数吧，printf有没有规定你只能打印几个参数呢？没有的，这是根据用户自己来定义的！这就是可变参数

在这里插入图片描述

执行完以上的代码，我们发现一个问题！！！

最后一句代码为什么没有被打印出来呢？？？
因为进程一旦替换成功，是将当前进程的代码和数据全部替换了！！！

后面的printf是代码吗？？有没有被替换呢？？当然，已经早就被替换了！！该代码不存在了！！

所以这个程序替换函数，用不用判断返回值？为什么？
答:不用判断返回值，因为只要成功了，就不会有返回值。而失败的时候，必然会继续向后执行！！最多通过返回值得到什么原因导致的替换失败！

引入进程创建

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<sys/types.h>

int main()
{
    printf("我是一个进程: %d\n",getpid());
    pid_t id=fork();
    if(id==0)
    {
        printf("我是子进程，我的pid是：%d\n",getpid());
        execl("/usr/bin/ls","ls","-l","-a",NULL);
        exit(1);
    }

    int status=0;
    pid_t ret=waitpid(id,&status,0);
    if(ret==id)
    {
        sleep(2);                 
        printf("父进程等待成功！\n");
    }
    
    return 0;
}

在这里插入图片描述

子进程进行程序替换的时候会不会影响父进程呢？
答:不会，因为进程具有独立性。

为什么？如何做到的？
因为数据层面发生了写时拷贝！当程序替换的时候，我们可以理解成为，代码和数据都发生了写时拷贝，完成了父子的分离。

execv

他的第二个参数是一个指针数组，他和execl的区别就是把选项作为参数放入指针数组，然后进行传参！

int main()
  7 {
  8     printf("我是一个进程，我的pid是：%d\n",getpid());
  9     pid_t id=fork(); 
 10     if(id==0)
 11     {
 12         //child
 13         //我们想让子进程执行新的程序，以前是执行父进程的代码片段
 14         printf("我是子进程，我的pid是：%d\n",getpid());
 15       char *const argv_[]={
 16         (char*)"ls",
 17         (char*)"-a",
 18         (char*)"-l",
 19          NULL
 20          };
 21       execv("/usr/bin/ls",argv_);                                                                                                            
 22         exit(1);
 23     }
 24     //一定是父进程
 25     int status=0;
 26     int ret=waitpid(id,&status,0);
 27     if(ret==id)
 28     {
 29         sleep(2);
 30         printf("父进程等待成功！\n");
 31     }
 32 
 33     return 0;
 34 }

在这里插入图片描述
区分execl和execv
在这里插入图片描述

execlp

在这里插入图片描述

相比于execl这个接口的第一个参数变化。
我们执行指令的时候，默认的搜索路径，在哪里搜索呢？
环境变量PATH！

p代表PATH

所以命名中带p的，可以不带路径，只要说出你要执行哪一个程序即可！

#include<stdio.h>
#include<unistd.h>
#include<sys/wait.h>
#include<stdlib.h>

int main()
{
    printf("我是一个进程，我的pid是：%d\n",getpid());
    pid_t id=fork(); 
    if(id==0)
    {
        //child
        //我们想让子进程执行新的程序，以前是执行父进程的代码片段
        printf("我是子进程，我的pid是：%d\n",getpid());
      char *const argv_[]={
        (char*)"ls",
        (char*)"-a",
        (char*)"-l",
         NULL
         };
      	execlp("ls","ls","-a","-l",NULL);//这里出现了两个ls，含义一样吗？不一样！
        exit(1);
    }
    //一定是父进程
    int status=0;
    int ret=waitpid(id,&status,0);
    if(ret==id)
    {
        sleep(2);
        printf("父进程等待成功！\n");
    }

    return 0;
}

在这里插入图片描述

execvp

在这里插入图片描述

#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
    printf("我是一个进程，我的pid是：%d\n", getpid());
    pid_t id = fork();
    if (id == 0)
    {
        // child
        // 我们想让子进程执行新的程序，以前是执行父进程的代码片段
        printf("execvp 我是子进程，我的pid是：%d\n", getpid());
       char *const argv_[] = {
            (char *)"ls",
            (char *)"-a",
            (char *)"-l",
            NULL};
        execvp("ls", argv_);
        exit(1);
    }
    // 一定是父进程
    int status = 0;
    int ret = waitpid(id, &status, 0);
    if (ret == id)
    {
        sleep(2);
        printf("父进程等待成功！\n");
    }

    return 0;
}

在这里插入图片描述

execle

在这里插入图片描述
这里的前两个接口都非常熟悉了，这里最后一个接口叫做环境变量。那么为什么要有这个接口呢？

说到环境变量之前我们先来看一下这个问题，我们刚刚提到过，进程替换可以让我们执行其他语言写的程序，那么我们怎么来执行呢？（我们使用execl 函数来调用）

我们现在的目标是想用我们写的myexec.c把mycmd.cpp调用起来，那么怎么来用呢？
myexec.c

#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
    printf("我是一个进程，我的pid是：%d\n", getpid());
    pid_t id = fork();
    if (id == 0)
    {
        // child
        // 我们想让子进程执行新的程序，以前是执行父进程的代码片段
        printf("execl 运行mycmd 我是子进程，我的pid是：%d\n", getpid());
      /*char *const argv_[] = {
            (char *)"ls",
            (char *)"-a",
            (char *)"-l",
            NULL};*/
        execl("/home/jys/code.c/mycmd", "mycmd",NULL);
        exit(1);
    }
    // 一定是父进程
    int status = 0;
    int ret = waitpid(id, &status, 0);
    if (ret == id)
    {
        sleep(2);
        printf("父进程等待成功！\n");
    }

    return 0;
}

mycmd.cc

#include <iostream>
using namespace std;
int main()
{
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;

    return 0;
}

在这里插入图片描述
我们当前使用的是绝对路径来吊用我的mycmd程序！
当然我们也可以使用相对路径来调用。

所以我们使用ece系列的系统级函数可以把任何语言耦合在一起！

谈完这个话题我们再来谈谈环境变量，execle这个函数多了一个e，这个e就是环境变量，如果你想给这个函数传入环境变量，我们就可以传入环境变量。
在这里插入图片描述
myexec.c

#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
    extern char** __environ;
    printf("我是一个进程，我的pid是：%d\n", getpid());
    pid_t id = fork();
    if (id == 0)
    {

        // child
        // 我们想让子进程执行新的程序，以前是执行父进程的代码片段
        printf("execle 运行mycmd 我是子进程，我的pid是：%d\n", getpid());
        execle("/home/jys/code.c/mycmd", "mycmd",NULL,__environ);
        exit(1);
    }
    // 一定是父进程
    int status = 0;
    int ret = waitpid(id, &status, 0);
    if (ret == id)
    {
        sleep(2);
        printf("父进程等待成功！\n");
    }

    return 0;
}

mycmd.cc

#include <iostream>
#include<cstdlib>
using namespace std;
int main()
{
    cout<<getenv("USER")<<"\n";
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;

    return 0;
}

在这里插入图片描述
这个是父进程用extern继承了系统的环境变量，子进程继承了父进程的环境变量

#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
   // extern char** __environ;
    printf("我是一个进程，我的pid是：%d\n", getpid());
    pid_t id = fork();
    if (id == 0)
    {

        // child
        // 我们想让子进程执行新的程序，以前是执行父进程的代码片段
        printf("execle 运行mycmd 我是子进程，我的pid是：%d\n", getpid());
      /*char *const argv_[] = {
            (char *)"ls",
            (char *)"-a",
            (char *)"-l",
            NULL};*/
         char* const env_[]={(char*)"MYPATH=迪丽热巴我老婆\n",NULL};
        execle("./mycmd", "mycmd",NULL,env_);
        exit(1);
    }
    // 一定是父进程
    int status = 0;
    int ret = waitpid(id, &status, 0);
    if (ret == id)
    {
        sleep(2);
        printf("父进程等待成功！\n");
    }

    return 0;
}

在这里插入图片描述

#include <iostream>
#include<cstdlib>
using namespace std;
int main()
{
    cout<<getenv("MYPATH")<<"\n";
   // cout<<getenv("USER")<<"\n";
    
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;
    cout << "你调用了我，很好，你成功引起了我的注意" << endl;

    return 0;
}

在这里插入图片描述

这里我们发现我们导入的环境变量出现了！

我们很好奇为什么呢？依照上面两个实验我们可以得出什么结论呢？

我们可以得出execle添加环境变量给目标程序的时候是覆盖式传入的！！

我们自己传入系统的环境变量给我们程序替换的程序

#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
   extern char** __environ;
    printf("我是一个进程，我的pid是：%d\n", getpid());
    pid_t id = fork();
    if (id == 0)
    {

        // child
        // 我们想让子进程执行新的程序，以前是执行父进程的代码片段
        printf("execle 运行mycmd 我是子进程，我的pid是：%d\n", getpid());
      /*char *const argv_[] = {
            (char *)"ls",
            (char *)"-a",
            (char *)"-l",
            NULL};*/
         //char* const env_[]={(char*)"MYPATH=迪丽热巴我老婆\n",NULL};
        execle("./mycmd", "mycmd",NULL,__environ);
        exit(1);
    }
    // 一定是父进程
    int status = 0;
    int ret = waitpid(id, &status, 0);
    if (ret == id)
    {
        sleep(2);
        printf("父进程等待成功！\n");
    }

    return 0;
}

在这里插入图片描述

在这里插入图片描述

米兰的小铁匠2333
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Linux】进程控制 —— 进程替换
Hello_World_213的博客
09-25 1258
[Linux]进程替换原理, exec系列系统调用, 用C程序执行其他语言程序, 模拟实现简单的shell(命令行解释器)
详解：进程程序替换
胡坚涛的博客
12-01 1118
一般情况下，对应的语言写的程序只能调用对应的语言的接口，而不能调用其他语言的接口，如C++不能调用Java或者Python或者Shell等语言的接口，那么如果我们想要调用别人写的程序应该怎么办呢？那么进程程序替换就能够很好地帮助我们解决这个问题，这在很大程度上减少了我们编程的成本，学会进程程序替换，在很多时候，如果有现成的程序，那么我们不需要自己再去写一个，是不是方便很多了？
进程替换详解
m0_74626010的博客
04-08 232
e代表环境变量，程序替换不会替换环境变量，我们可以通过带e的接口设置新的环境变量。我们可以创建子进程，然后把子进程替换成我们需要的进程，执行其他程序的代码。并且我们代码中的 exec end 没有打出来，验证了进程替换后，后续代码不再执行。进程替换后：1、程序替换后，替换函数之后的代码不会被执行，因为进程已经被替换了。3、替换完成，不创建新的程序。我们可以观察得到，这些函数前面都有exec，后面跟着的。进程替换就是把当前进程替换成我们需要执行的进程，一般是通过系统调用实现。4、程序替换不会替换环境变量。
linux--进程程序替换
qzt__l0ve的博客
05-01 817
所谓进程程序替换，顾名思义，就是使用一个新的程序替换原有的程序，进程将执行新程序的代码，而不再执行原有程序的代码，前面我们已经学习了如何创建一个进程，一般情况下，进程程序替换都不会使用父进程直接进行进程程序替换，而是让父进程调用fork()函数创建一个子进程，让子进程去执行一个新的程序即可。
进程控制3——进程程序替换
weixin_74074953的博客
11-17 322
进程程序替换
win10可用x64进程替换代码
05-17
在IT安全领域，进程替换是一种常见的恶意软件技术，它允许恶意程序将自己的代码注入到系统中的一个合法进程中，以此来隐藏自身的行为，绕过安全防护措施，并获取更高的权限。标题提到的"win10可用x64进程替换代码"是...
我的进程创建程序.rar_进程创建
09-19
总的来说，学习进程创建不仅能够帮助你理解操作系统的底层工作原理，还能为编写高效、安全的多进程程序打下坚实的基础。通过实践和分析提供的"进程创建"程序，你将能够更深入地掌握这些概念，并能运用到自己的项目中...
Linux 进程替换(exec函数）实现代码
09-15
在上述示例中，如果`execve`成功，"child id done"不会被打印出来，因为进程已经被新程序替换。如果`exec`失败，它会返回一个错误值，使得程序能够捕获并处理错误。 总结来说，`exec`函数家族在Linux中用于进程替换...
防杀进程.zip易语言程序源码资源下载
02-25
5. **自我保护**：程序可能会创建守护进程，或者在内存中加载并执行自身，以防止被轻易删除或替换。 对于初学者，理解并学习这样的源码可以帮助你： - **理解系统底层**：通过研究进程管理和权限获取，可以深入...
windows守护进程小工具
08-27
用户需要将`ProgramPath`替换为实际的程序路径，`ProgramName`替换为程序的文件名。保存配置文件后，守护进程小工具即可根据这些设置开始工作。 总的来说，"Windows守护进程小工具"是一个简洁而实用的解决方案，...
进程替换
编程鸟
11-23 2413
1、替换原理： 用fork创建子进程后执行的是和父进程相同的程序，也有可能执行不同的代码分支，子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新进程替换，从新程序的启动例程（main函数）开始执行。记住：调用exec并不创建新进程，所以调用exec前后该进程的id并为改变。exec只是用磁盘上的一个新程序替换了当前进程的正文段、数据段
进程控制-进程的替换
fengjunziya的博客
05-22 324
虽然进程的替换有很多函数接口，但是，实际上他们的用法都是大同小异，理解它们的命名风格，就懂了。
Linux——详解进程替换
广西彭于晏的博客
07-06 311
转载自仅供学习使用 侵删！
[Linux]进程替换
qq_59456417的博客
02-11 1178
进程替换的原理及应实现方式。
【Linux】进程替换的简单实现
qq_43411563的博客
05-01 212
一、进程替换的定义 像我们一般写的进程都是，创建子进程后，子进程执行的还是父进程的指令。这样是很不方便的。所谓的进程替换就是一个进程能够去执行另一份程序。也就是fork之后，子进程进行进程的替换，父进程继续执行其指令，子进程就可以执行另一份指令。 二、进程替换的方法 1、int execl();属于库函数 int execl(char* pathname,char* argv0,char* ar...
进程替换(简单的函数使用)
Sock的博客
04-19 822
什么是进程替换 进程替换就是用新进程来替换当前进程. 在 bash 中, 进程替换其实就是命令替换和管道的组合. 替换原理: 我们知道子进程存在的意义不仅仅是它能帮助父进程进行压力分摊, 最主要的功能其实是让子进程去完成其他的工作, 也就是进程替换. 子进程通过调用 exec 系列函数时, 当前进程的虚拟地址空间上的各个数据段被磁盘上指定的新程序给替换掉, 本质上并没有创建新的进程, 进程的 ID...
Linux中的环境变量
最新发布
qhy850716的博客
07-17 537
我们思考这样一个问题：指令也是可执行程序，我们写好的编译好的c语言也是程序，为什么我们在执行c语言程序时要./a.out带上当前路径，而ls这种指令就不要带路径呢？这就是环境变量PATH的作用，Linux中存在一些全局设置，表明命令行解释器应该去哪个路径下寻找可执行程序。系统中的很多配置在我们登录Linux时就已经被加载到bash中了，也就是内存。
进程替换代码例子
05-31
以下是一个简单的进程替换的代码例子，它可以将当前进程替换为一个新的可执行文件： ```c #include #include #include int main() { char *args[]={"./new_program",NULL}; //新程序的路径和参数 execvp(args...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值