CSAPP Shell Lab

Posted 2023-02-02 joker D888

CSAPP Shell Lab

本实验的目的是更加熟悉过程控制和信号的概念。 您将通过编写一个支持作业控制的简单 Unix shell 程序来完成此操作。

我们要做的是填写tsh.c文件的空函数，完善其内容，使其达到我们预期的目的。详细的需要实现的功能请查看实验文档。根据文档的提示，我们可以根据测试文件tracei.txt来从易到难一步一步实现相应功能，通过make testi和make rtesti对比输出内容判断相应功能是否正确实现。做之前先看一遍已经给实现好的辅助函数一遍后续解题正确使用，并且要仔细看实验文档，里面有很多重要提示，最好仔细阅读过第八章内容。

关键点

以下是程序中的一些要点，一些甚至关乎着程序的正确性：

• 实现信号处理程序时，务必将信号发送至整个进程组，即在kill函数中使用-pid而不是pid。
• 使用sigprocmask来避免deletejob和addjob出现竞争情况。做法是父进程必须在派生子进程之前使用 sigprocmask 来阻塞SIGCHLD信号，在将子进程通过addjob添加到作业列表后再次使用 sigprocmask以取消阻塞这些信号。 由于子进程继承了父进程的阻塞向量，因此子进程必须在执行新程序之前取消阻塞 SIGCHLD 信号。
• 使用setpgid(0,0)将fork的子进程创建新的进程组。确保在前台进程中只有一个进程，即我们的shell即tsh进程。这样做是为避免我们所执行的作业影响我们的shell，如果我们的shell创建了一个子进程，默认情况该子进程也是前台进程组，若此时键入ctrl-c将会向前台的进程组发送SIGINT，将导致shell退出，显然不对。
• waitpid的WUNTRACED和WNOHANG选项，可避免等待任何运行中的子进程，同时可以获知子进程的终止和停止状态。
• 在waitfg中使用一个围绕睡眠函数的繁忙循环。
• 只要子进程的状态发生改变就会向父进程发送SIGCHLD信号。
• 在使用printf等有输出缓冲区的函数往标准输出上输出后，及时使用fflush刷新缓冲区，避免出现令人意想不到的结果。
• 阻塞所有的信号，保护对共享全局数据结构的访问。
• 保护和恢复errno。

准备工作

我是预先添加了错误处理函数，简化程序结构，如下。参考csapp官网。

// 额外增加错误处理包装函数--begin
pid_t Fork(void) 
    pid_t pid;

    if ((pid = fork()) < 0) unix_error("Fork error");
    return pid;


pid_t Waitpid(pid_t pid, int *iptr, int options) 
    pid_t retpid;

    if ((retpid = waitpid(pid, iptr, options)) < 0) unix_error("Waitpid error");
    return (retpid);

void Kill(pid_t pid, int signum) 
    int rc;

    if ((rc = kill(pid, signum)) < 0) unix_error("Kill error");


void Sigprocmask(int how, const sigset_t *set, sigset_t *oldset) 
    if (sigprocmask(how, set, oldset) < 0) unix_error("Sigprocmask error");
    return;


void Sigemptyset(sigset_t *set) 
    if (sigemptyset(set) < 0) unix_error("Sigemptyset error");
    return;


void Sigfillset(sigset_t *set) 
    if (sigfillset(set) < 0) unix_error("Sigfillset error");
    return;


void Sigaddset(sigset_t *set, int signum) 
    if (sigaddset(set, signum) < 0) unix_error("Sigaddset error");
    return;


int Sigsuspend(const sigset_t *set) 
    int rc = sigsuspend(set); /* always returns -1 */
    if (errno != EINTR) unix_error("Sigsuspend error");
    return rc;

void Setpgid(pid_t pid, pid_t pgid) 
    int rc;

    if ((rc = setpgid(pid, pgid)) < 0) unix_error("Setpgid error");
    return;

// 额外增加错误处理包装函数--end

builtin_cmd

最简单是先完成builtin_cmd,判断是否是内置命令，若是执行。

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

eval

再仿照书上完成eval的内容，需要额外注意的是，如果是运行在前台的，要调用waitfg函数等待其不再执行。

void eval(char *cmdline) 
    char *agrv[MAXARGS];
    char buf[MAXLINE];
    int bg;
    pid_t pid;

    strcpy(buf, cmdline);
    bg = parseline(buf, agrv);
    if (agrv[0] == NULL) return;  // Ignore empty lines

    if (!builtin_cmd(agrv)) 
        sigset_t mask_all, mask_one, prev_one;
        Sigfillset(&mask_all);
        Sigemptyset(&mask_one);
        Sigaddset(&mask_one, SIGCHLD);

        // 阻塞SIGCHLD信号，消除竞争，避免父进程运行到addjob之前子进程就退出
        // 在调用fork之前，阻塞SIGCHLD信号，然后再调用addjob之后取消阻塞这些信号，保证了在子进程被添加到作业列表之后回收该子进程
        Sigprocmask(SIG_BLOCK, &mask_one, &prev_one);  // 阻塞SIGCHLD
        if ((pid = Fork()) == 0)                      // Child runs user job
            // 创建一个新的进程组,和tsh进程组分离，避免后续操作影响到tsh进程
            Setpgid(0, 0);
            Sigprocmask(SIG_SETMASK, &prev_one, NULL);  // 子进程继承父进程状态，需要恢复上面阻塞SIGCHLD信号之前的状态
            if (execve(agrv[0], agrv, environ) < 0) 
                printf("%s: Command not found\\n", agrv[0]);
                exit(EXIT_SUCCESS);
            
        
        int status = bg ? BG : FG;
        Sigprocmask(SIG_BLOCK, &mask_all, NULL);  // 阻塞全部信号
        addjob(jobs, pid, status, cmdline);
        // bg需要打印信息，也会使用全局数据，为保证安全，也需要在Sigprocmask之间，屏蔽所有信号
        if (bg) printf("[%d] (%d) %s", getjobpid(jobs, pid)->jid, pid, cmdline);
        Sigprocmask(SIG_SETMASK, &prev_one, NULL);  // 恢复阻塞SIGCHLD信号之前的状态

        if (!bg)   // No background, waiting for child process to end
            waitfg(pid);
        
    

waitfg

阻塞直到pid不再是前台进程。这里使用sigsuspend作为睡眠函数，得益于其本身的原子性，避免潜在的竞争，详细原因见8.5.7节。

void waitfg(pid_t pid) 
    sigset_t mask;
    Sigemptyset(&mask);
    while (pid == fgpid(jobs)) Sigsuspend(&mask);

sigtstp_handler

SIGTSTP信号的处理程序，捕获它并通过发送SIGTSTP挂起前台作业。

void sigtstp_handler(int sig) 
    int olderrno = errno;
    pid_t pid = fgpid(jobs);
    if (pid) Kill(-pid, sig);
    errno = olderrno;

sigint_handler

SIGINT信号的处理程序，捕获它并将其发送到前台作业。

void sigint_handler(int sig) 
    int olderrno = errno;
    pid_t pid = fgpid(jobs);
    if (pid) Kill(-pid, sig);
    errno = olderrno;

sigchld_handler

只要子进程的状态发生改变就会向父进程发送SIGCHLD信号。如终止，停止，继续，只要导致这三种状态的出现，都会触发SIGCHLD信号。下面的处理程序，只处理终止和停止的状态，继续执行的这种状态专由do_bgfg处理。检查子进程的状态由waitpid函数的statusp记录，详见8.4.3节。

void sigchld_handler(int sig) 
    pid_t pid;
    int status;

    sigset_t mask_all, prev_all;
    Sigfillset(&mask_all);  // 设置全阻塞
    Sigprocmask(SIG_BLOCK, &mask_all, &prev_all);
    // 这里要判断>0,因为WNOHANG | WUNTRACED表示若等待集合中的子进程都没有停止或终止，则返回0，
    // 若有任一个终止或停止，返回该子进程的pid
    // 由于我们的SIGCONT信号的处理是放在do_bgfg()中的，所以有可能是SIGCONT信号导致的SIGCHLD信号而返回0
    while ((pid = Waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) 
        if (WIFEXITED(status))   // 正常终止
            deletejob(jobs, pid);
         else if (WIFSIGNALED(status))   // 信号导致终止
            printf("Job [%d] (%d) terminated by signal %d\\n", pid2jid(pid), pid, WTERMSIG(status));
            fflush(stdout);
            deletejob(jobs, pid);
         else if (WIFSTOPPED(status))   // 信号导致停止
            struct job_t *job = getjobpid(jobs, pid);
            job->state = ST;
            printf("Job [%d] (%d) stopped by signal %d\\n", job->jid, job->pid, WSTOPSIG(status));
            fflush(stdout);
        
    

    Sigprocmask(SIG_SETMASK, &prev_all, NULL);

do_bgfg

此函数则是用于处理内置命令bg fg的，程序相当一部分是关于参数判断和错误的处理。需要注意的是进程状态的改变也要相应的在jobs中改变，如果是调到前台运行的，要调用相应的waitfg函数。

void do_bgfg(char **argv) 
    // argv错误处理
    if (argv[1] == NULL) 
        printf("%s command requires PID or %%jobid argument\\n", argv[0]);
        fflush(stdout);
        return;
    

    sigset_t mask_all, prev_all;
    Sigfillset(&mask_all);

    struct job_t *job;

    if (argv[1][0] == '%')                                              // jid
        if (strspn(argv[1] + 1, "0123456789") != strlen(argv[1] + 1))   // 如果%后面的不全是数字，错误
            printf("%s: argument must be a PID or %%jobid\\n", argv[0]);
            fflush(stdout);
            return;
        
        int jid = atoi(argv[1] + 1);
        job = getjobjid(jobs, jid);
        if (job == NULL) 
            printf("%s: No such job\\n", argv[1]);
            fflush(stdout);
            return;
        
     else                                                      // pid
        if (strspn(argv[1], "0123456789") != strlen(argv[1]))   // 如果不全是数字，错误
            printf("%s: argument must be a PID or %%jobid\\n", argv[0]);
            fflush(stdout);
            return;
        
        pid_t pid = atoi(argv[1]);
        job = getjobpid(jobs, pid);
        if (job == NULL) 
            printf("(%s): No such process\\n", argv[1]);
            fflush(stdout);
            return;
        
    
    Sigprocmask(SIG_BLOCK, &mask_all, &prev_all);  // 需要访问jobs全局变量，先屏蔽全部信号
    if (!strcmp(argv[0], "fg"))                   // fg,将一个停止或运行的后台作业改变为在前台运行
        if (job->state == ST)                     // 如果是停止的，发送SIGCONT信号重新启动
            Kill(-(job->pid), SIGCONT);
        
        job->state = FG;
        Sigprocmask(SIG_SETMASK, &prev_all, NULL);
        waitfg(job->pid);  // 等待前台作业运行
     else                // bg,将一个后台停止作业改变为后台运行
        printf("[%d] (%d) %s", job->jid, job->pid, job->cmdline);
        Kill(-(job->pid), SIGCONT);
        job->state = BG;
        Sigprocmask(SIG_SETMASK, &prev_all, NULL);
    

总结

可以通过以下命令将测试的输出内容重定向到新建的文件tsh.out，随后通过文本比较和tshref.out进行比较，检查是否除了pid和ps a不同，其他都和tshref.out相同，经测试，以上所编写的代码和tshref.out比较无误：

./sdriver.pl -t trace01.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace02.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace03.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace04.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace05.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace06.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace07.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace08.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace09.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace10.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace11.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace12.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace13.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace14.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace15.txt -s ./tsh -a "-p" >> tsh.out 
./sdriver.pl -t trace16.txt -s ./tsh -a "-p" >> tsh.out 

本实验难度适中，代码量也不大，若是认真阅读过第八章内容以及实验文档，编写起来还是比较顺利的。通过此实验，较清晰的了解了shell的工作原理，以及信号的处理，如何避免出现竞争，并发的编程规范，但以上程序中，对于getjobpid此类从job获取信息但不对其进行修改我并没有使用sigprocmask屏蔽全部信号，因为我认为，及时指令序列被处理程序中断，也不会影响其后续的结果，关于这一问题，暂存疑，若有缺陷的地方，后续将会修改。