CS:APP3e 深入理解计算机系统_3e ShellLab(tsh)实验


详细的题目要求和资源可以到 http://csapp.cs.cmu.edu/3e/labs.html 或者 http://www.cs.cmu.edu/~./213/schedule.html 获取。


前期准备

  • Signal (IPC)
  • signal(2) - Linux manual page - man7.org
  • fork(2) - Linux manual page - man7.org
  • wait(2) - Linux manual page - man7.org
  • sigprocmask(2) - Linux manual page - man7.org
  • access(2) - Linux manual page - man7.org
  • sigemptyset(3): POSIX signal set operations
  • How to Use C's Volatile Keyword - Barr Group
  • Atomic Types


注意事项

  • tsh的提示符为“tsh> ”
  • 用户的输入分为第一个的name和后面的参数,之间以一个或多个空格隔开。如果name是一个tsh内置的命令,那么tsh应该马上处理这个命令然后等待下一个输入。否则,tsh应该假设name是一个路径上的可执行文件,并在一个子进程中运行这个文件(这也称为一个工作、job)
  • tsh不需要支持管道和重定向
  • 如果用户输入ctrl-c (ctrl-z),那么SIGINT (SIGTSTP)信号应该被送给每一个在前台进程组中的进程,如果没有进程,那么这两个信号应该不起作用。
  • 如果一个命令以“&”结尾,那么tsh应该将它们放在后台运行,否则就放在前台运行(并等待它的结束)
  • 每一个工作(job)都有一个正整数PID或者job ID(JID)。JID通过"%"前缀标识符表示,例如,“%5”表示JID为5的工作,而“5”代笔PID为5的进程。
  • tsh应该有如下内置命令:
quit: 退出当前shell

jobs: 列出所有后台运行的工作

bg : 这个命令将会向代表的工作发送SIGCONT信号并放在后台运行,可以是一个PID也可以是一个JID。

fg : 这个命令会向代表的工作发送SIGCONT信号并放在前台运行,可以是一个PID也可以是一个JID。
  • tsh应该回收(reap)所有僵尸孩子,如果一个工作是因为收到了一个它没有捕获的(没有按照信号处理函数)而终止的,那么tsh应该输出这个工作的PID和这个信号的相关描述。


提示

  • 利用测试文件逐步构建tsh,例如先从trace01.txt开始。
  • setpgid中的WUNTRACED and WNOHANG选项有用(参看前期准备)
  • 当解析命令并产生子进程的时候(fork )的时候,必须先调用sigprocmask block SIGCHLD信号,调用addjob将刚刚创建的工作加入到工作列表里,然后unblock该信号(课件里有讲这个竞争产生的问题)。另外,由于子进程会继承block的特性,所以子进程要记得unblock。
  • 一些具有终端环境的进程会尝试从父进程读写数据,例如/bin/sh,还有一些程序例如more less vi emacs 会对终端做一些“奇怪的设置”。本次实验用/bin/ls /bin/echo这样的文字模式的程序测试即可。
  • 当我们在真正的shell(例如bash)中执行tsh时,tsh本身也是被放在前台进程组中的,它的子进程也会在前台进程组中,例如下图所示:
               +----------+
               |   Bash   |
               +----+-----+
                    |
+-----------------------------------------+
|                   v                     |
|              +----+-----+   foreground  |
|              |   tsh    |   group       |
|              +----+-----+               |
|                   |                     |
|         +--------------------+          |
|         |         |          |          |
|         v         v          v          |
|       /bin/ls    /bin/sleep  xxxxx      |
|                                         |
|                                         |
+-----------------------------------------+

所以当我们在终端输入ctrl-c (ctrl-z)的时候,SIGINT (SIGTSTP)信号应该被送给每一个在前台进程组中的所有进程,包括我们在tsh中认为是后台进程的程序。一个决绝的方法就是在fork之后execve之前,子进程应该调用setpgid(0, 0)使得它进入一个新的进程组(其pgid等于该进程的pid)。tsh接收到SIGINT SIGTSTP信号后应该将它们发送给tsh眼中正确的“前台进程组”(包括其中的所有进程)。


思路及其实现

我首先将书上(8.5.5节)说的6个关于信号处理函数安全性的要求列出(详细的解释请参考书),在编程的时候要注意:

  1. 尽量保持信号处理函数的简单性,例如只改变一个flag
  2. 在信号处理函数内部只调用async-signal-safe的函数(man 7 signal里面有完全的列出)
  3. 在进入和退出信号处理函数的时候保存和还原errno变量(参考:Thread-local storage )
  4. 当试图访问全局结构变量的时候暂时block所有的信号,然后还原
  5. 全局变量的声明为volatile
  6. 将flag(标志)声明为sig_atomic_t


下面我就实验要求完成的7个函数说几个注意的地方,代码中的注释也解释了一些:

/* Here are the functions that you will implement */
void eval(char *cmdline);
int builtin_cmd(char **argv, char *cmdline);
void do_bgfg(char **argv, char *cmdline);
void waitfg(pid_t pid);

void sigchld_handler(int sig);
void sigtstp_handler(int sig);
void sigint_handler(int sig);


1.void eval(char *cmdline)

在调用parseline解析输出后,我们首先判断这是一个内置命令(shell实现)还是一个程序(本地文件)。如果是内置命令,进入builtin_cmd(argv, cmdline) ,否则创建子进程并在job列表里完成添加。这里要注意在fork前用access判断是否存在这个文件,不然fork以后无法回收,另外要注意一个线程并行竞争(race)的问题:fork以后会在job列表里添加job,信号处理函数sigchld_handler回收进程后会在job列表中删除,如果信号来的比较早,那么就可能会发生先删除后添加的情况。这样这个job永远不会在列表中消失了(内存泄露),所以我们要先blockSIGCHLD ,添加以后再还原。

更新:fork子进程后发生错误退出子进程应该使用_exit而非exitunix_error里面也是用的exit ) 参考:What is the difference between using _exit() & exit() in a conventional Linux fork-exec?

/*
 * eval - Evaluate the command line that the user has just typed in
 *
 * If the user has requested a built-in command (quit, jobs, bg or fg)
 * then execute it immediately. Otherwise, fork a child process and
 * run the job in the context of the child. If the job is running in
 * the foreground, wait for it to terminate and then return.  Note:
 * each child process must have a unique process group ID so that our
 * background children don't receive SIGINT (SIGTSTP) from the kernel
 * when we type ctrl-c (ctrl-z) at the keyboard.
 */
void eval(char *cmdline)
{
    char *argv[MAXARGS];
    int bg_flag;

    bg_flag = parseline(cmdline, argv); /* true if the user has requested a BG job, false if the user has requested a FG job. */

    if (builtin_cmd(argv, cmdline)) /* built-in command */
    {
        return;
    }
    else /* program (file) */
    {
        if (access(argv[0], F_OK)) /* do not fork and addset! */
        {
            fprintf(stderr, "%s: Command not found\n", argv[0]);
            return;
        }

        pid_t pid;
        sigset_t mask, prev;
        sigemptyset(&mask);
        sigaddset(&mask, SIGCHLD);
        sigprocmask(SIG_BLOCK, &mask, &prev); /* block SIG_CHLD */

        if ((pid=fork()) == 0) /* child */
        {
            sigprocmask(SIG_SETMASK, &prev, NULL); /* unblock SIG_CHLD */

            if (!setpgid(0, 0))
            {
                if (execve(argv[0], argv, environ))
                {
                    fprintf(stderr, "%s: Failed to execve\n", argv[0]);
                    _exit(1);
                }
                /* context changed */
            }
            else
            {
                fprintf(stderr, "Failed to invoke setpgid(0, 0)\n");
                _exit(1);
            }
        }
        else if (pid > 0)/* tsh */
        {
            if (!bg_flag) /* exec foreground */
            {
                fg_pid = pid;
                fg_pid_reap = 0;
                addjob(jobs, pid, FG, cmdline);
                sigprocmask(SIG_SETMASK, &prev, NULL); /* unblock SIG_CHLD */
                waitfg(pid);
            }
            else /* exec background */
            {
                addjob(jobs, pid, BG, cmdline);
                sigprocmask(SIG_SETMASK, &prev, NULL); /* unblock SIG_CHLD */
                printf("[%d] (%d) %s", maxjid(jobs), pid, cmdline);
            }
            return;
        }
        else
        {
            unix_error("Failed to fork child");
        }
    }
    return;
}


2.int builtin_cmd(char **argv, char *cmdline)

这个函数分情况判断是哪一个内置命令,要注意如果用户仅仅按下回车键,那么在解析后argv的第一个变量将是一个空指针。如果用这个空指针去调用strcmp函数会引发segment fault。

/*
 * builtin_cmd - If the user has typed a built-in command then execute
 *    it immediately.
 */
int builtin_cmd(char **argv, char *cmdline)
{
    char *first_arg = argv[0];

    if (first_arg == NULL) /* if input nothing('\n') in function main, then the
                              first_arg here will be NULL, which will cause SEG fault when invoke strcmp(read) */
    {
        return 1;
    }

    if (!strcmp(first_arg, "quit"))
    {
        exit(0);
    }
    else if (!strcmp(first_arg, "jobs"))
    {
        listjobs(jobs);
        return 1;
    }
    else if (!strcmp(first_arg, "bg") || !strcmp(first_arg, "fg"))
    {
        do_bgfg(argv, cmdline);
        return 1;
    }

    return 0;
}


3.void do_bgfg(char **argv, char *cmdline)

这个函数单独处理了bgfg这两个内置命令。要注意fg有两个对应的情况:1.后台程序是stopped的状态,这时我们需要设置相关变量,然后发送继续的信号。2.如果这个进程本身就在运行,我们就只需要改变job的状态,设置相关变量,然后进入waitfg等待这个新的前台进程执行完毕。

写这个也出现了一个让我debug 几个小时的兼容性问题:

man 7 signal中,SIGCHLD描述如下:

SIGCHLD   20,17,18    Ign     Child stopped or terminated

也就是说,子进程终止或者停止的时候会向父进程发送这个信号,然后父进程进入sigchld_handler信号处理函数进行回收或者提示。但是在我的机器上却发现在子进程从stopped变到running(收到SIGCONT )的时候也会向父进程发送这个信号。这样就会出现一个问题:我们要使后台一个stopped的进程重新运行,但是它会向父进程(shell)发送一个SIGCHLD ,这样父进程就会进入信号处理函数sigchld_handler试图回收它(不是stop),而它有没有结束,所以信号处理函数会一直等待它执行完毕,在shell中显示的情况就是卡住了。

经过长时间调试确认后发现在POSIX某个标准中SIGCHLD信号的定义如下:

SIGCHLD

The SIGCHLD signal is sent to a process when a child process terminates, is interrupted, or resumes after being interrupted. One common usage of the signal is to instruct the operating system to clean up the resources used by a child process after its termination without an explicit call to the wait system call.

or resumes after being interrupted. ,看到这句的时候我就要吐血了。。。

为了进一步证实我的想法,我在FreeBSD11.1上面查了一下手册:

CS:APP3e 深入理解计算机系统_3e ShellLab(tsh)实验_第1张图片

他说的是“changed”,看来我的机器是按照POSIX的某个标准实现的。

我的解决方案是设置一个pid_t的全局变量stopped_resume_child记录我们要fg的stopped进程,在进入信号处理函数后首先检查这个变量是否大于零,如果是就直接退出不做处理。(这里其实有一个和其他进程竞争的问题,时间有限就不去做更改了)

/*
 * do_bgfg - Execute the builtin bg and fg commands
 */
void do_bgfg(char **argv, char *cmdline)
{
    char *first_arg = argv[0];
    if (!strcmp(first_arg, "bg"))
    {
        if (argv[1] == NULL)
        {
            fprintf(stderr, "bg command requires PID or %%jobid argument\n");
            return;
        }

        if (argv[1][0] == '%') /* JID */
        {
            int jid = atoi(argv[1] + 1);
            if (jid)
            {
                struct job_t *job_tmp = getjobjid(jobs, jid);
                if (job_tmp != NULL)
                {
                    job_tmp->state = BG;
                    printf("[%d] (%d) %s", jid, job_tmp->pid, job_tmp->cmdline);
                    stopped_resume_child = job_tmp->pid;
                    killpg(job_tmp->pid, SIGCONT);
                   
                    return;
                }
                else
                {
                    fprintf(stderr, "%%%s: No such job\n", argv[1] + 1);
                }
            }
            else
            {
                fprintf(stderr, "%%%s: No such job\n", argv[1] + 1);
            }
        }
        else /* PID */
        {
            pid_t pid = atoi(argv[1]);
            if(pid)
            {
                struct job_t *job_tmp = getjobpid(jobs, pid);
                if (job_tmp != NULL)
                {
                    job_tmp->state = BG;
                    printf("[%d] (%d) %s", job_tmp->jid, pid, job_tmp->cmdline);
                    stopped_resume_child = job_tmp->pid;
                    killpg(pid, SIGCONT);
                   
                    return;
                }
                else
                {
                    fprintf(stderr, "(%s): No such process\n", argv[1]);
                }
            }
            else
            {
                fprintf(stderr, "bg: argument must be a PID or %%jobid\n");
            }
        }
    }
    else
    {
        /* there are two case when using fg:
        1. the job stopped 
        2. the job is running
        */

        if (argv[1] == NULL)
        {
            fprintf(stderr, "fg command requires PID or %%jobid argument\n");
            return;
        }
        if (argv[1][0] == '%') /* JID */
        {
            int jid = atoi(argv[1] + 1);
            if (jid)
            {
                struct job_t *job_tmp = getjobjid(jobs, jid);
                if (job_tmp != NULL)
                {
                    int state = job_tmp->state;
                    fg_pid = job_tmp->pid; /* this is the new foreground process */
                    fg_pid_reap = 0;

                    job_tmp->state = FG;

                    if (state == ST)
                    {
                        stopped_resume_child = job_tmp->pid; /* set the global var in case of wait in SIGCHLD handler */
                        killpg(job_tmp->pid, SIGCONT);
                    }
                    
                    waitfg(job_tmp->pid); /* wait until the foreground terminate/stop */
                    return;
                }
                else
                {
                    fprintf(stderr, "%%%s: No such job\n", argv[1] + 1);
                }
            }
            else
            {
                fprintf(stderr, "%%%s: No such job\n", argv[1] + 1);
            }
        }
        else /* PID */
        {
            pid_t pid = atoi(argv[1]);
            if(pid)
            {
                struct job_t *job_tmp = getjobpid(jobs, pid);
                if (job_tmp != NULL)
                {
                    int state = job_tmp->state;
                    fg_pid = job_tmp->pid; /* this is the new foreground process */
                    fg_pid_reap = 0;

                    job_tmp->state = FG;

                    if (state == ST)
                    {
                        stopped_resume_child = job_tmp->pid; /* set the global var in case of wait in SIGCHLD handler */
                        killpg(pid, SIGCONT);
                    }
                    
                    waitfg(job_tmp->pid); /* wait until the foreground terminate/stop */
                    return;
                }
                else
                {
                    fprintf(stderr, "(%s): No such process\n", argv[1]);
                }
            }
            else
            {
                fprintf(stderr, "fg: argument must be a PID or %%jobid\n");
            }
        }
    }
    return;
}


4.void waitfg(pid_t pid)

我之前声明了一个volatile sig_atomic_t的全局变量fg_pid_reap ,只要信号处理函数回收了前台进程,它就会将fg_pid_reap 置1,这样我们的waitfg函数就会退出,接着读取用户的下一个输入。使用busysleep会有一些延迟,实验报告上要求这么实现我也没办法; )

/*
 * waitfg - Block until process pid is no longer the foreground process
 */
void waitfg(pid_t pid)
{
    while (!fg_pid_reap)
    {
        sleep(1);
    }
    fg_pid_reap = 0;
    return;
}


5.void sigchld_handler(int sig)

注意保存errno

注意到这里不能使用while来回收进程,因为我们的后台还可能有正在运行的进程,这样做的话会使得waitpid一直等待这个进程结束。当然使用if只回收一次也可能会导致信号累加的问题,例如多个后台程序同时结束,实验报告上要求这么实现我也没办法 ; )

注意如果程序是被stop的话SIGTSTP ctrl-z ,我们不用回收、删除job列表中的节点。

/*
 * sigchld_handler - The kernel sends a SIGCHLD to the shell whenever
 *     a child job terminates (becomes a zombie), or stops because it
 *     received a SIGSTOP or SIGTSTP signal. The handler reaps all
 *     available zombie children, but doesn't wait for any other
 *     currently running children to terminate.
 */
void sigchld_handler(int sig) /* When a child process stops or terminates, SIGCHLD is sent to the parent process. */
{
    int olderrno = errno;

    if (stopped_resume_child)
    {
        stopped_resume_child = 0;
        return;
    }
    int status;
    pid_t pid;

    if ((pid = waitpid(-1, &status, WUNTRACED)) > 0) /* don't use while! */
    {
        if (pid == fg_pid)
        {
            fg_pid_reap = 1;
        }

        if (WIFEXITED(status)) /* returns true if the child terminated normally */
        {
        
        
            deletejob(jobs, pid);
        }
        else if (WIFSIGNALED(status)) /* returns true if the child process was terminated by a signal. */
                                      /* since job start from zero, we add it one */
        {
        
        
            printf("Job [%d] (%d) terminated by signal %d\n", pid2jid(pid), pid, WTERMSIG(status));
            deletejob(jobs, pid);
        }
        else /* SIGTSTP */
        {
            /* don't delete job */
            struct job_t *p = getjobpid(jobs, pid);
            p->state = ST; /* Stopped */
            printf("Job [%d] (%d) stopped by signal 20\n", pid2jid(pid), pid);
        }
    }

    errno = olderrno;
    return;
}


6.void sigtstp_handler(int sig)

注意是群发,即killpg,不能只发一个。

/*
 * sigint_handler - The kernel sends a SIGINT to the shell whenver the
 *    user types ctrl-c at the keyboard.  Catch it and send it along
 *    to the foreground job.
 */
void sigint_handler(int sig)
{
    int olderrno = errno;

    pid_t pgid = fgpid(jobs);
    if (pgid)
    {
        killpg(pgid, SIGINT);
    }

    errno = olderrno;
    return;
}


7.void sigint_handler(int sig)

不解释。

/*
 * sigtstp_handler - The kernel sends a SIGTSTP to the shell whenever
 *     the user types ctrl-z at the keyboard. Catch it and suspend the
 *     foreground job by sending it a SIGTSTP.
 */
void sigtstp_handler(int sig)
{
    int olderrno = errno;

    pid_t pgid = fgpid(jobs);
    if (pgid)
    {
        killpg(pgid, SIGTSTP);
    }
    
    errno = olderrno;
    return;
}


运行结果

为了方便检查结果,我写了一个bash脚本,用来比较我的tsh和实验给的正确参考程序tshref的输出结果(测试用例为trace01.txt~trace16.txt):

frank@under:~/tmp/shlab-handout$ cat test.sh 
#! /bin/bash

for file in $(ls trace*)
do
    ./sdriver.pl -t $file -s ./tshref > tshref_$file
    ./sdriver.pl -t $file -s ./tsh > tsh_$file
done 

for file in $(ls trace*)
do
    diff tsh_$file tshref_$file > diff_$file
done

for file in $(ls diff_trace*)
do
    echo $file " :"
    cat $file
    echo -e "-------------------------------------\n"


全部打印出来太长,这里列出最后几个:

frank@under:~/tmp/shlab-handout$ ./test.sh 

#.............................
#.............................
#.............................

diff_trace13.txt  :
5c5
< tsh> Job [1] (6173) stopped by signal 20
---
> tsh> Job [1] (6162) stopped by signal 20
7c7
< tsh> [1] (6173) Stopped ./mysplit 4 
---
> tsh> [1] (6162) Stopped ./mysplit 4 
20,24c20,24
<  6170 pts/5    S+     0:00 /usr/bin/perl ./sdriver.pl -t trace13.txt -s ./tsh
<  6171 pts/5    S+     0:00 ./tsh
<  6173 pts/5    T      0:00 ./mysplit 4
<  6174 pts/5    T      0:00 ./mysplit 4
<  6177 pts/5    R      0:00 /bin/ps a
---
>  6159 pts/5    S+     0:00 /usr/bin/perl ./sdriver.pl -t trace13.txt -s ./tshref
>  6160 pts/5    S+     0:00 ./tshref
>  6162 pts/5    T      0:00 ./mysplit 4
>  6163 pts/5    T      0:00 ./mysplit 4
>  6166 pts/5    R      0:00 /bin/ps a
41c41
<  1303 tty7     Ssl+  21:49 /usr/lib/xorg/Xorg -core :0 -seat seat0 -auth /var/run/lightdm/root/:0 -nolisten tcp vt7 -novtswitch
---
>  1303 tty7     Ssl+  21:48 /usr/lib/xorg/Xorg -core :0 -seat seat0 -auth /var/run/lightdm/root/:0 -nolisten tcp vt7 -novtswitch
51,53c51,53
<  6170 pts/5    S+     0:00 /usr/bin/perl ./sdriver.pl -t trace13.txt -s ./tsh
<  6171 pts/5    S+     0:00 ./tsh
<  6182 pts/5    R      0:00 /bin/ps a
---
>  6159 pts/5    S+     0:00 /usr/bin/perl ./sdriver.pl -t trace13.txt -s ./tshref
>  6160 pts/5    S+     0:00 ./tshref
>  6169 pts/5    R      0:00 /bin/ps a
-------------------------------------

diff_trace14.txt  :
7c7
< tsh> [1] (6207) ./myspin 4 &
---
> tsh> [1] (6188) ./myspin 4 &
23c23
< tsh> Job [1] (6207) stopped by signal 20
---
> tsh> Job [1] (6188) stopped by signal 20
27c27
< tsh> [1] (6207) ./myspin 4 &
---
> tsh> [1] (6188) ./myspin 4 &
29c29
< tsh> [1] (6207) Running ./myspin 4 &
---
> tsh> [1] (6188) Running ./myspin 4 &
-------------------------------------

diff_trace15.txt  :
7c7
< tsh> Job [1] (6241) terminated by signal 2
---
> tsh> Job [1] (6224) terminated by signal 2
9c9
< tsh> [1] (6244) ./myspin 3 &
---
> tsh> [1] (6226) ./myspin 3 &

可以发现除了PID不同以外其余都相同,说明tsh实现正确。





完整项目代码




感悟

这次实验给我最大的教训就是不要完全相信文档,自己去实现和求证也很重要。另外,并行产生的竞争问题也有了一些了解。

另外,有意思的是,我在做实验之前看到实验指导里说:

– In waitfg, use a busy loop around the sleep function.
– In sigchld handler, use exactly one call to waitpid.

当时我还想说用sleep 和在waitpid里面只用一个回收是不是不安全或者太傻了,结果我上github一看不仅都是这样,而且他们的代码非常不安全(上面提到的六个安全注意点完全不遵守,各种调用也没有检查返回值和异常),于是觉得自己写的肯定比他们好多了

结果。。。如果注意这些安全问题会有很多麻烦,时间也有限,我就把几个容易实现的实现了,还有两个“访问全局结构变量前block”和“在信号处理函数中仅使用async-signal-safe没有实现。

最后,改编一下Mutt E-Mail Client作者的一句话总结一下这次实验:

All code about this ShellLab on github sucks. This one just sucks less ;)

转载于:https://www.cnblogs.com/liqiuhao/p/8120617.html

你可能感兴趣的:(CS:APP3e 深入理解计算机系统_3e ShellLab(tsh)实验)