CSAPP之ShellLab详解

前言

本篇博客将会详细介绍 CSAPP 之 ShellLab 的完成过程，实现一个简易（lou）的 shell。tsh 拥有以下功能：

• 可以执行外部程序
• 支持四个内建命令，名称和功能为：
  • quit：退出终端
  • jobs：列出所有后台作业
  • bg <job>：继续在后台运行一个处于停止状态的后台作业，<job> 可以是 PID 或者 %JID 形式
  • fg <job>：将一个处于运行或者停止状态的后台作业转移到前台继续运行
• 按下 ctrl + c 终止前台作业
• 按下 ctrl + z 停止前台作业

实验材料中已经写好了一些函数，只要求我们实现下列核心函数：

• eval：解析并执行指令
• builtin_cmd：识别并执行内建指令
• do_bgfg：执行 fg 和 bg 指令
• waitfg：阻塞终端直至前台任务完成
• sigchld_handler：捕获 SIGCHLD 信号
• sigint_handler：捕获 SIGINT 信号
• sigtstp_handler：捕获 SIGTSTP 信号

下面是具体实现过程。

实现过程

首先实现 eval 函数，由于 builtin_cmd 函数实现了内建指令的执行，所以 eval 里面主要负责创建子进程来执行外部程序，并将子进程登记到 jobs 数组中。为了避免父子进程间的竞争引发的同步问题，需要在创建子进程前屏蔽掉 SIGCHLD 信号，由于子进程会复制父进程中的所有变量，所以子进程在执行外部程序之前应该解除屏蔽。同时 setpgid(0, 0) 使得子进程的进程组编号和不同于父进程 tsh，不然按下 ctrl + c 会直接退出终端。

void eval(char* cmdline) {    char* argv[MAXARGS];    pid_t pid;    sigset_t mask_all, mask_one, prev_mask;    sigfillset(&mask_all);    sigemptyset(&mask_one);    sigaddset(&mask_one, SIGCHLD);    int bg = parseline(cmdline, argv);    // 忽略空行    if (argv[0] == NULL)        return;    if (builtin_cmd(argv))        return;    sigprocmask(SIG_BLOCK, &mask_one, &prev_mask);    if ((pid = Fork()) == 0) {        sigprocmask(SIG_SETMASK, &prev_mask, NULL);        setpgid(0, 0);        Execve(argv[0], argv, environ);    }    sigprocmask(SIG_BLOCK, &mask_one, NULL);    addjob(jobs, pid, bg ? BG : FG, cmdline);    if (!bg) {        waitfg(pid);    } else {        printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);    }    sigprocmask(SIG_SETMASK, &prev_mask, NULL);}

上述程序对 folk 和 execve 做了封装，可以让 eval 看起来更加简洁，代码如下所示：

pid_t Fork() {    pid_t pid = fork();    if (pid < 0)        unix_error("Fork error");    return pid;}int Execve(const char* __path, char* const* __argv, char* const* __envp) {    int result = execve(__path, __argv, __envp);    if (result < 0) {        printf("%s: Command not found\n", __argv[0]);        exit(1);    }    return result;}

如果遇到前台作业，终端应该调用 waitfg 函数并处于阻塞状态，这里使用 sigsuspend 函数而不使用 sleep 函数的原因是不好确定要 sleep 多长时间，间隔太短浪费处理器资源，间隔太长速度就太慢了：

void waitfg(pid_t pid) {    sigset_t mask;    sigemptyset(&mask);    while (fgpid(jobs)) {        sigsuspend(&mask);    }}

builtin_cmd 的具体代码如下所示，只要使用 strcmp 函数来比对指令就行了：

int builtin_cmd(char** argv) {    int is_buildin = 1;    if (!strcmp(argv[0], "quit")) {        exit(0);    } else if (!strcmp(argv[0], "fg") || !strcmp(argv[0], "bg")) {        do_bgfg(argv);    } else if (!strcmp(argv[0], "jobs")) {        listjobs(jobs);    } else {        is_buildin = 0;    }    return is_buildin; /* not a builtin command */}

在 builtin_cmd 中最重要的就是 do_bgfg 函数，负责作业的状态转换，如下图所示：

代码如下所示，首先根据输入的 ID 获取作业，如果 ID 非法就提示错误信息，否则发送 SIGCONT 信号给进程组中的每一个进程，为了做到这一点，需要将 kill 函数的 pid 参数取负值，不然就只发给指定的进程了，显然这不是我们想要的结果：

void do_bgfg(char** argv) {    char* cmd = argv[0];    char* id = argv[1];    struct job_t* job;    if (id == NULL) {        printf("%s command requires PID or %%jobid argument\n", cmd);        return;    }    // 根据 jid/pid 获取作业    if (id[0] == '%') {        if ((job = getjobjid(jobs, atoi(id + 1))) == NULL) {            printf("%s: No such job\n", id);            return;        }    } else if (atoi(id) > 0) {        if ((job = getjobpid(jobs, atoi(id))) == NULL) {            printf("(%d): No such process\n", atoi(id));            return;        }    } else {        printf("%s: argument must be a PID or %%jobid\n", cmd);        return;    }    // 状态转移    if (!strcmp(cmd, "fg")) {        job->state = FG;        kill(-job->pid, SIGCONT);        waitfg(job->pid);    } else if (!strcmp(cmd, "bg")) {        job->state = BG;        kill(-job->pid, SIGCONT);        printf("[%d] (%d) %s", job->jid, job->pid, job->cmdline);    }}

最后就是进行信号的处理了，由于同一种信号无法排队，需要使用 while 来 waitpid，同时使用 WNOHANG | WUNTRACED 来处理终止和停止的情况。停止作业后需要修改 job 的状态为 ST，不然 waitfg 中的循环会一直进行下去：

void sigchld_handler(int sig) {    int old_errno = errno;    pid_t pid;    int status;    sigset_t mask_all, prev_mask;    sigfillset(&mask_all);    while ((pid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {        // 终止作业        if (WIFEXITED(status) || WIFSIGNALED(status)) {            sigprocmask(SIG_BLOCK, &mask_all, &prev_mask);            // ctrl-c 终止            if (WIFSIGNALED(status)) {                printf("Job [%d] (%d) terminated by signal 2\n", pid2jid(pid), pid);            }            deletejob(jobs, pid);            sigprocmask(SIG_SETMASK, &prev_mask, NULL);        }        // 停止作业        else if (WIFSTOPPED(status)) {            sigprocmask(SIG_BLOCK, &mask_all, &prev_mask);            struct job_t* job = getjobpid(jobs, pid);            job->state = ST;            printf("Job [%d] (%d) stopped by signal 20\n", job->jid, job->pid);            sigprocmask(SIG_SETMASK, &prev_mask, NULL);        }    }    errno = old_errno;}void sigint_handler(int sig) {    int old_errno = errno;    pid_t pid = fgpid(jobs);    if (pid > 0)        kill(-pid, SIGKILL);    errno = old_errno;}void sigtstp_handler(int sig) {    int old_errno = errno;    pid_t pid = fgpid(jobs);    if (pid > 0)        kill(-pid, SIGTSTP);    errno = old_errno;}

最后来测试一下 tsh 好不好使，这里使用看起来最复杂的 trace15.txt：

总结

通过这次实验，可以加深对进程控制和信号处理的理解，同时对于并发现象有了更直观的认识，以上~~