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：

總結

通過這次實驗，可以加深對程式控制和訊號處理的理解，同時對於並發現象有了更直觀的認識，以上~~