进程控制（下）

🕗 发布于 2024-12-09 11:41 git github c++ c语言

进程控制（下）

在这里插入图片描述

进程程序替换

在这里插入图片描述

fork() 之后,⽗⼦各⾃执⾏⽗进程代码的⼀部分如果⼦进程就想执⾏⼀个全新的程序呢？进程的程序替换来完成这个功能！

程序替换是通过特定的接⼝，加载磁盘上的⼀个全新的程序(代码和数据)，加载到调⽤进程的地址空间中！

替换原理

⽤fork创建⼦进程后执⾏的是和⽗进程相同的程序(但有可能执⾏不同的代码分⽀),⼦进程往往要调⽤⼀种exec函数以执⾏另⼀个程序。当进程调⽤⼀种exec函数时,该进程的⽤⼾空间代码和数据完全被新程序替换,从新程序的启动例程开始执⾏。调⽤exec并不创建新进程,所以调⽤exec前后该进程的id并未改变。

替换函数

其实有六种以exec开头的函数,统称exec函数:

#include <unistd.h>
 int execl(const char *path, const char *arg, ...);
 int execlp(const char *file, const char *arg, ...);
 int execle(const char *path, const char *arg, ...,char *const envp[]);
 int execv(const char *path, char *const argv[]);
 int execvp(const char *file, char *const argv[]);
 int execve(const char *path, char *const argv[], char *const envp[]);

函数解释

这些函数如果调⽤成功则加载新的程序从启动代码开始执⾏,不再返回
如果调⽤出错则返回-1
所以exec函数只有出错的返回值⽽没有成功的返回值。

命名理解

这些函数原型看起来很容易混,但只要掌握了规律就很好记。

l(list) : 表⽰参数采⽤列表
v(vector) : 参数⽤数组
p(path):有p⾃动搜索环境变量PATH
e(env):表⽰⾃⼰维护环境变量

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

exec调⽤举例如下:

#include <unistd.h>
 int main()
 {
 char *const argv[] = {"ps", "-ef", NULL};
 char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};
 execl("/bin/ps", "ps", "-ef", NULL);
 // 带p的，可以使⽤环境变量PATH，⽆需写全路径
 
execlp("ps", "ps", "-ef", NULL);
 // 带e的，需要⾃⼰组装环境变量
 
execle("ps", "ps", "-ef", NULL, envp);
 execv("/bin/ps", argv);
 execvp("ps", argv);
 // 带p的，可以使⽤环境变量PATH，⽆需写全路径
 
// 带e的，需要⾃⼰组装环境变量
 
execve("/bin/ps", argv, envp);
 exit(0);
 }

事实上,只有execve是真正的系统调⽤,其它五个函数最终都调⽤execve,所以execve在man⼿册第2节, 其它函数在man⼿册第3节。这些函数之间的关系如下图所⽰。

下图exec函数簇⼀个完整的例⼦:

在这里插入图片描述

⾃主Shell命令⾏解释器

⽬标

要能处理普通命令
要能处理内建命令
要能帮助我们理解内建命令/本地变量/环境变量这些概念
要能帮助我们理解shell的允许原理

实现原理

考虑下⾯这个与shell典型的互动：

 [root@localhost epoll]# ls
 client.cpp  readme.md  server.cpp  utility.h
 [root@localhost epoll]# ps
 PID TTY          TIME CMD
 3451 pts/0    3514 pts/0    
00:00:00 bash 00:00:00 ps

⽤下图的时间轴来表⽰事件的发⽣次序。其中时间从左向右。shell由标识为sh的⽅块代表，它随着时间的流逝从左向右移动。shell从⽤⼾读⼊字符串"ls"。shell建⽴⼀个新的进程，然后在那个进程中运⾏ls程序并等待那个进程结束。

在这里插入图片描述

然后shell读取新的⼀⾏输⼊，建⽴⼀个新的进程，在这个进程中运⾏程序并等待这个进程结束。

所以要写⼀个shell，需要循环以下过程:

获取命令⾏
解析命令⾏
建⽴⼀个⼦进程（fork）
替换⼦进程（execvp）
⽗进程等待⼦进程退出（wait）

根据这些思路，和我们前⾯的学的技术，就可以⾃⼰来实现⼀个shell了。

源码

实现代码:

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <string>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <ctype.h>
 using namespace std;
 const int basesize = 1024;
 const int argvnum = 64;
 const int envnum = 64;
 // 全局的命令⾏参数表
 
char *gargv[argvnum];
 int gargc = 0;
 // 全局的变量
 
int lastcode = 0;
 // 我的系统的环境变量
 
char *genv[envnum];
 // 全局的当前shell⼯作路径
  
char pwd[basesize];
 char pwdenv[basesize];
 // "    "file.txt
 #define TrimSpace(pos) do{\
 while(isspace(*pos)){\
 pos++;\
 }\
 }while(0)
 string GetUserName()
 {
 string name = getenv("USER");
 return name.empty() ? "None" : name;
 }
 string GetHostName()
 {
 string hostname = getenv("HOSTNAME");
 return hostname.empty() ? "None" : hostname;
 }
 string GetPwd()
 {
 if(nullptr == getcwd(pwd, sizeof(pwd))) return "None";
 snprintf(pwdenv, sizeof(pwdenv),"PWD=%s", pwd);
putenv(pwdenv); // PWD=XXX
 return pwd;
 //string pwd = getenv("PWD");
 //return pwd.empty() ? "None" : pwd;
 }
 string LastDir()
 {
 string curr = GetPwd();
 if(curr == "/" || curr == "None") return curr;
 // /home/whb/XXX
 size_t pos = curr.rfind("/");
 if(pos == std::string::npos) return curr;
 return curr.substr(pos+1);
 }
 string MakeCommandLine()
 {
 // [whb@bite-alicloud myshell]$ 
char command_line[basesize];
 snprintf(command_line, basesize, "[%s@%s %s]# ",\
 GetUserName().c_str(), GetHostName().c_str(), LastDir().c_str());
 return command_line;
 }
 void PrintCommandLine() // 1. 命令⾏提⽰符 
{
 }
 printf("%s", MakeCommandLine().c_str());
 fflush(stdout);
 bool GetCommandLine(char command_buffer[], int size)   // 2. 获取⽤⼾命令
 
{
 }
 // 我们认为：我们要将⽤⼾输⼊的命令⾏，当做⼀个完整的字符串
 
// "ls -a -l -n"
 char *result = fgets(command_buffer, size, stdin);
 if(!result)
 {
 return false;
 }
 command_buffer[strlen(command_buffer)-1] = 0;
 if(strlen(command_buffer) == 0) return false;
 return true;
 void ParseCommandLine(char command_buffer[], int len) // 3. 分析命令
{
    (void)len;
    memset(gargv, 0, sizeof(gargv));
    gargc = 0;
    // "ls -a -l -n"
    const char *sep = " ";
    gargv[gargc++] = strtok(command_buffer, sep);
    // =是刻意写的
 
    while((bool)(gargv[gargc++] = strtok(nullptr, sep)));
    gargc--;
 }
 void debug()
 {
    printf("argc: %d\n", gargc);
    for(int i = 0; gargv[i]; i++)
    {
        printf("argv[%d]: %s\n", i, gargv[i]);
    }
 }
 // 在shell中
 
// 有些命令，必须由⼦进程来执⾏
 
// 有些命令，不能由⼦进程执⾏，要由shell⾃⼰执⾏ --- 内建命令 built command 
bool ExecuteCommand()   // 4. 执⾏命令
 {
    // 让⼦进程进⾏执⾏
 
    pid_t id = fork();
    if(id < 0) return false;
    if(id == 0)
    {
        //⼦进程
 
        // 1. 执⾏命令
 
        execvpe(gargv[0], gargv, genv);
        // 2. 退出
 
        exit(1);
    }
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if(rid > 0)
    {
        if(WIFEXITED(status))
        {
            lastcode = WEXITSTATUS(status);
        }
        else
        {
 lastcode = 100;
        }
        return true;
    }
    return false;
 }
 void AddEnv(const char *item)
 {
    int index = 0;
    while(genv[index])
    {
        index++;
    }
    genv[index] = (char*)malloc(strlen(item)+1);
    strncpy(genv[index], item, strlen(item)+1);
    genv[++index] = nullptr;
 }
 // shell⾃⼰执⾏命令，本质是shell调⽤⾃⼰的函数
 
bool CheckAndExecBuiltCommand()
 {
    if(strcmp(gargv[0], "cd") == 0)
    {
        // 内建命令
 
        if(gargc == 2)
        {
            chdir(gargv[1]);
            lastcode = 0;
        }
        else
        {
            lastcode = 1;
        }
        return true;
    }
    else if(strcmp(gargv[0], "export") == 0)
    {
        // export也是内建命令
 
        if(gargc == 2)
        {
            AddEnv(gargv[1]);
            lastcode = 0;
        }
        else
        {
            lastcode = 2;
 }
        return true;
    }
    else if(strcmp(gargv[0], "env") == 0)
    {
        for(int i = 0; genv[i]; i++)
        {
            printf("%s\n", genv[i]);
        }
        lastcode = 0;
        return true;
    }
    else if(strcmp(gargv[0], "echo") == 0)
    {
        if(gargc == 2)
        {
            // echo $?
            // echo $PATH
            // echo hello
            if(gargv[1][0] == '$')
            {
                if(gargv[1][1] == '?')
                {
                    printf("%d\n", lastcode);
                    lastcode = 0;
                }
            }
            else
            {
                printf("%s\n", gargv[1]);
                lastcode = 0;
            }
        }
        else
        {
            lastcode = 3;
        }
        return true;
    }
    return false;
 }
 // 作为⼀个shell，获取环境变量应该从系统的配置来
 
// 我们今天就直接从⽗shell中获取环境变量
 
void InitEnv()
 {
    extern char **environ;
int index = 0;
 while(environ[index])
 {
 genv[index] = (char*)malloc(strlen(environ[index])+1);
 strncpy(genv[index], environ[index], strlen(environ[index])+1);
 index++;
 }
 genv[index] = nullptr;
 }
 int main()
 {
 InitEnv();
 char command_buffer[basesize];
 while(true)
 {
 PrintCommandLine(); // 1. 命令⾏提⽰符
 
// command_buffer -> output
 if( !GetCommandLine(command_buffer, basesize) )   // 2. 获取⽤⼾命令
 
{
 continue;
 }
 //printf("%s\n", command_buffer);
 ParseCommandLine(command_buffer, strlen(command_buffer)); // 3. 分析命令
 
if ( CheckAndExecBuiltCommand() )
 {
 continue;
 }
 ExecuteCommand();   // 4. 执⾏命令
 
}
 return 0;
 }

总结

函数和进程之间的相似性

exec/exit就像call/return

⼀个C程序有很多函数组成。⼀个函数可以调⽤另外⼀个函数，同时传递给它⼀些参数。被调⽤的函数执⾏⼀定的操作，然后返回⼀个值。每个函数都有他的局部变量，不同的函数通过call/return系统进⾏通信。

这种通过参数和返回值在拥有私有数据的函数间通信的模式是结构化程序设计的基础。Linux⿎励将这种应⽤于程序之内的模式扩展到程序之间。如下图

在这里插入图片描述

⼀个C程序可以fork/exec另⼀个程序，并传给它⼀些参数。这个被调⽤的程序执⾏⼀定的操作，然后通过exit(n)来返回值。调⽤它的进程可以通过wait（&ret）来获取exit的返回值。

原文地址：https://blog.csdn.net/Mr_Xuhhh/article/details/144269932

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：springSecurity权限控制
下一篇：GCC/G++ Centos离线安装

.NET(C#) 如何配置用户首选项及保存用户设置
.NET(C#) 如何配置用户首选项及保存用户设置
阅读更多2024-12-14
【最新】北大数字普惠金融指数数据集-省市县（2011-2023年）
郭峰,王靖一,王芳,孔涛,张勋,程志云.测度中国数字普惠金融发展:指数编制与空间特征[J].经济学(季刊),2020,19(04):1401-1418.时间跨度：省级和城市级指数时间跨度为2011-2
阅读更多2024-12-14
GESP202412 四级【Recamán】题解（AC）
a11ak−1−kkakak−1−kak−1k小杨想知道 Recamán 数列的前n项从小到大排序后的结果。手动计算非常困难，小杨希望你能帮他解决这个问题。
阅读更多2024-12-14
IDEA遇到EasyConnect中的网络资源无法访问的问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。原文链接：https://blog.csdn.net/wanshanyu_/article/de
阅读更多2024-12-14
双目摄像头标定方法
此时已经完成标定，左下角为反投影误差，右边为外参可视化。将双目左右目拍的图像上传（左右目最好不少于20张）此时回到主页面，即可看到成功导出。把这些误差大的删除即可。
阅读更多2024-12-14
Servlet、omcat服务器架构与工作原理
Servlet是运行在服务器端的Java程序，它的主要职责之一是接收并处理来自客户端（如浏览器）的HTTP请求。当客户端发送一个请求到服务器时，Servlet可以解析请求中的信息，例如请求的URL路径
阅读更多2024-12-14
Vue生命周期钩子函数：深入解析与实践
作为高级Vue前端开发人员，对Vue组件的生命周期钩子函数有着深刻的理解是至关重要的。生命周期钩子函数是指在Vue组件的创建、更新、销毁等过程中，Vue自动调用的一系列方法。通过这些钩子函数，我们可以
阅读更多2024-12-14
安卓开发--使用android studio发布APP
app发布
阅读更多2024-12-14
数据结构与算法学习笔记----拓扑排序
@ author: 明月清了个风。
阅读更多2024-12-14
python 将数据保存到现有的Excel文件的新工作表
out_file = ‘query.xlsx’df1 = pd.DataFrame(out_data)若直接写入：df1.to_excel(out_file, index=False, sheet_n
阅读更多2024-12-14

进程控制（下）