进程控制（下）

进程控制（下）

进程程序替换

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，需要循环以下过程:

1. 获取命令⾏
2. 解析命令⾏
3. 建⽴⼀个⼦进程（fork）
4. 替换⼦进程（execvp）
5. ⽗进程等待⼦进程退出（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的返回值。