实验四-Shelllab实验（csapp、计算机系统外壳实验）

  一、准备工作

1、首先明确实验目的：

·总的来说就是让我们补充位于tsh.c中的七个函数，从而实现一个支持任务功能的shell。

因此在这儿将这七个函数分为两部分：

（1）实现完成内建命令（jobs、fg、bg、kill）的四个函数：

接着再来了解一下tsh支持的四个内置命令：

·Quit：命令终止tsh进程

·jobs：命令列出所有后台进程

·bg：命令会向作业发送SIGCNOT信号来重启job，并作为后台作业运行，参数可以是PID或JID

·fg：同上，唯一区别是job以前台作业运行

（2）实现三个信号（SIGCHLD、SIGINT、SIGTSTP）的处理函数：

· 因此我们再来具体了解一下这三个信号：

· 再来了解一下需要用到的辅助函数：

2、了解实验资源：

以上文件中，我们要实现的七个函数均在tsh.c中，tshref是参考文件。图中的txt文件均是测试文件。

3、如何比对我们实现的同时是否正确：

（1）首先执行make指令编译tsh.c得到可执行文件tsh：

 （2）然后就执行make rtest01 ；make test01进行比对，如果我们的执行结果与参考结果一致，则实现正确，如下：

否则不正确，如下：

（输出不一致，说明功能未成功实现）

二、具体实现

1. trace01 ->  正确终止EOF：

    可成功运行。

     2.trace 02 ->实现内置的quit

1. 分析 ：

 trace02.txt文件中只有quit，WAIT两条命令。

先执行看看：

可以看到无法正常终止，因为tsh的quit内置命令还未编写，所以不能正常退出。

因此需要我们实现终止命令（quit。 

（2）实现之前我们来了解eval()与execve()执行流程和fork()多进程运行方式：

  程序会首先执行 eval()，在 eval中进行判断（使用buildin_cmp()函数），如果发现命令不是内置命令，则会调用 fork()函数来新建一个子进程，在子进程中调用 execve()函数通过 argv[0]来寻找路径，并在子进程中运行路径中的可执行文件，如果找不到可执行文件，则说明命令为无效命令，输出命令无效，并用 exit(0)结束该子进程即可。

（3）实现quit：

 ·补齐文件tsh.c中的函数eval()函数和函数builtin_cmd()与quit相关的部分。

 · 实现思路：首先从命令中提取参数，然后判断是否为内置命令，如果为内置命令，则直接在当前进程执行即可；如果不是内置命令，则需要新建一个子进程，并利用 execve 来通过参数给出的路径寻找出可执行文件并在子进程中执行，如果找不到该可执行文件，则输出命令未找到，并结束子进程。

· 代码：

1. 首先是eval函数：

  2.然后是判断是否为内置命令的函数builtin_cmd()：

 （4）验证：因为tset03功能是运行一个前台job，并且也是以quit终止，因此一起验证：

可以看出，成功！

3 . trace04 -->实现eval()的后台作业（BK job）管理功能

（1）思路：

·在原有的eval函数基础之上添加将作业添加至后台作业管理的函数使用（addjobs（））。

·加以信号的阻塞和取消阻塞。

***（注意）

那为什么在这里要控制信号的阻塞呢？

答：总的来说，为了保证处理程序回收终止的子进程（delete job）在父进程（addjob）之后进行，否则父子进程之间会出现经典的同步错误---竞争。

详细理解：因为当父进程创建一个子进程时，它就会将这个子进程添加到作业列表（addjobs）。当父进程在SIGCHLD处理程序中回收一个僵尸子进程时，就要从作业列表中删除子进程。理想状态下，这个过程很正确，但是往往真实的运行情况下，会出现问题，如下图：

 总结来说，就是会出现在addjob之前调用deletejob，导致出错。

***

（2）具体实现：

 1.首先使用一个标记符号（bg）：

 2.因为要分析传入指令是否要在后台执行进程，因此要补充分析命令的函数builtin_cmd()：

 3.接着在eval中进行判断是否为后台进程：

 4.再将waitfg（）函数补充完整：

让父进程正确地等待。

   5.接下来实现信号的控制，这里使用sigprocmask()函数显式地阻塞和取消阻塞：

（1）初了解：

（2）在eval（）中的使用：

 上述图片的操作中，我们就保证了父进程先addjob（），然后子进程再deletejob（）；

6.接下来实现对应的sigcld_handler()以释放僵尸的子进程:

详情看红框操作。

综上，我们的addjobs就成功实现了！

7.验证：

通过！

4. trace05 -->处理jobs内置命令：

（1）思路：直接调用自带的listjobs()方法，就是在原有builtin_cmd函数中添加一个判断函数，如果参数是jobs，则执行listjobs函数的功能（即将所有的作业打印出来）。

（2）实现：

（3）测试：

成功！

5.trace06、trace07 ->处理SIGINT信号

（1）目的：

要实现的功能是：trace06->将SIGINT信号转发到前台作业；

                             trace07->仅仅将SIGINT信号转发到前台作业；

因此这里放在一起实现。

SIGINT：来自键盘的中断（ctrl+c）。

（2）文档提示：

 综上，就是说要保证ctrl+c只会终止你当前的shell进程，而不会影响其他进程。

（3）实现：

   根据文档中的解决方法，我们来一步步实现。

1.首先更改一下eval函数，在其中调用setpgid（0,0）：

添加了红框中的代码，解释也在注释中。

2.更改信号处理函数sigint_handler(),实现转发到前台作业的操作（包含前台作业的进程组）

3.还要修改sigchld_handler()函数：

****

为什么呢？

   答：是为了区分进程终止的原因（符合测试文件）（后边也会用到）

    1.是正常终止（exit或return）

     2.还是因为收到其他信号如：SIGINT而终止。（这里我们是收到SIGINT信号终止的）

****

修改如下：

综上，就成功实现！

（4）测试：

成功！

6、Trace08 -> 仅仅将SIGSTP（ctrl+z）转发到前台作业（与上一题实现大同小异）

（1）因此我们就直接实现其信号处理函数sigtstp_handler()：

（2）依旧来修改一下sigchld_handler()函数。区分终止/停止。

思路：因此在上一题的基础上加上对于SIGTSTP（ctrl+z）的判断和信息显示。

如下：

 ·加了红框框的内容，实现。

·还要加多一个WUNTRACED（见绿框），变成WNOHANG | WUNTRACED。

***

为什么呢？

WNOHANG：挂起调用进程，直到有子进程终止。

WUNTRACED：挂起调用进程，直到等待集合中的一个进程变成已终止或者被停止。

WNOHANG | WUNTRACED：等待集合中的子进程都没有被停止或终止，则返回值为0；如果有一个停止或终止，则返回值为该子进程的PID。

可以理解为WNOHANG接收终止，WUNTRACED接收停止。

两个合在一起就是接收终止和停止(ctrl+z和ctrl+c)。

***

（3）测试：

成功！

7.trace 09 ---> 实现进程内置命令bg

     bg <job>:命令会向一个已经停止的job发送SIGCNOT信号来重启这个job，并作为后台作业运行，参数可以是PID或JID。

（1）首先是完成识别命令：

要将bg命令添加到识别命令的函数builtin_cmd()中：

（2）接下来实现其处理函数：

·修改do_bgfg()方法：

（3）测试：

成功！

8 .trace 10 ---> 实现进程内置命令fg（与上一题差不多）

       fg <job>:将一个已停止或正在运行的后台作业更改为正在前台运行的作业。

（1）老方法，先往builtin_cmd()方法添加内容:

（2）然后往do_bgfg()函数中加入相关处理：

需要注意的一点就是红框所圈的内容，也是与BG实现区别的地方。

（3）测试：

成功！

9 .trace 11 ---> 将SIGINT转发给前台进程组中的每个进程

     trace 12 ----> 将SIGSTP转发给前台进程组中的每个进程

   这两个实验在之前的trace06-trace07的分析中已经实现了，因此我们直接执行即可：

（1）sigint_handler（）函数：

（2）sigtstp_handler（）函数：

（3）测试：

成功！

10.trace13 -->重新启动进程组中每个已经停止的进程

1. 首先回顾一下我们之前有关唤醒进程的操作：

在trace09和trace10中对BG和FG的处理中（do_bgfg()函数），我们是有条件地唤醒进程，并将之修改为对应需要的状态（前台或后台），如下图：

继续分析：

· 因为此时需要唤醒所有停止的进程，因此要将唤醒函数kill(pid,SIGCONT)的第一个参数改为-pid，因为当其第一个参数<0时，kill就会将SIGCONT信号传递给整个进程组。

· 因为在FG中，有一步是需要等待当前的前台进程完成之后，才会唤醒进程组中的进程，所以为了保证唤醒所有进程，就要去掉FG中，job->state == ST才传递SIGCONT信号的判断，因为当前运行进程可能没有停止(ST)，但是进程组中是有停止的，进程组中停止的这些也需要被唤醒。

（2）综上，我们得到以下实现：

（3）测试：

成功！

11.trace14- 简单的错误处理（就是处理输入未实现的命令、fg、bg参数不正确等错误情况）

（1）先运行看看怎么处理：

从上图看出一共有五种处理方式，因此我们在do_bgfg()中进行对应的处理即可。

（2）处理：

·第一个错误：Command not found，未实现的命令。

我们再次回顾一下shell的执行流程：程序会首先执行 eval()，在 eval中进行判断（使用buildin_cmp()函数），如果发现命令不是内置命令，则会调用 fork()函数来新建一个子进程，在子进程中调用 execve()函数通过 argv[0]来寻找路径，并在子进程中运行路径中的可执行文件，如果找不到可执行文件，则说明命令为无效命令。因此我们在此处加入输出语句即可，如下图：

· 第二个错误是：fg command requires PID or %jobid argument，fg命令时没有传入pid或jid。

  因此在do_bgfg()中实现：

·第三个错误是：fg: argument must be a PID or %jobid，传入了pid或jid，但是不符合规范（pid或jid必须为数字）。

处理：

·第四个错误是：No such process，通过传入的pid找不到对应的作业（job=null）

处理：

·第五个错误：No such job，通过传入的jid找不到对应的job（job=null）

此外，我们发现还有一行（绿色框所圈），这里我们和trace15

一起解决。所以接下来看一下trace15.

12. trace15-->所有命令一起运行

（1）先make rtest一下，看看缺什么：

如上图，缺少这两条消息的处理，因此我们要加上处理：

那么首先查看一下文件trace15.txt，看看是因为什么信号出现这种情况：

可以看到，INT信号将job10终止。

 TSTP信号将job1中断。

因此我们就在终止信号处理函数sihchld_handler()中进行判断处理，并输出上述错误信息：

处理：

OK，完成！

（3）测试：

Trace14：

成功！

Trace15（测试所有命令）：

成功！

13. trace16 -->测试shell是否能够处理来自其他进程而不是终端的SIGTSTP和SIGINT信号。

（1）查看一下trace16.txt:

可以看到测试文件的操作是：

     测试shell能否处理来自mystop和myint的SICINT和SINTSTP信号。

（2）测试：

 分析：可以看到上图中小旗帜标识的位置，在jobs执行内置命令之后，对于SIGINT和SINTSTP信号均做出了处理。成功！

ps：trace16其实还有点不太清楚。文章来源地址https://www.toymoban.com/news/detail-454816.html

最后贴上所有代码：

void eval(char *cmdline) //加载且执行命令
{
    char *argv[MAXARGS];        /* 参数列表execve() */
    char buf[MAXLINE];          /* 保存修改的命令行 */
    int bg;                     /* 这个作业应该在后台进行？ */
    pid_t pid;                  /* 进程id*/
    strcpy(buf,cmdline);
    bg = parseline(buf,argv);
    if(argv[0] == NULL)
        return;                 /* 忽略空命令 */

    sigset_t mask_all,mask_one,prev_one;
    if(!builtin_cmd(argv)){
        sigfillset(&mask_all);  /* 保存当前的阻塞信号集合(blocked位向量) */
        sigemptyset(&mask_one); //初始化mask_one为空集
        sigaddset(&mask_one,SIGCHLD);//添加SIGCHLD到mask_one中
        //以上三句保存了当前的已阻塞信号集合

        sigprocmask(SIG_BLOCK,&mask_one,&prev_one);         /* 添加mask_one中的信号到信号集合（blocked位向量），从而父进程保持SIGCHLD的阻塞*/
        if((pid = fork()) == 0){    /* 子程序运行用户作业 */

            sigprocmask(SIG_SETMASK,&prev_one,NULL); /* 因为子进程继承了它们父进程的被阻塞集合，所以在调用execve之前，必须
                                                         解除子进程对SIGCHLD的阻塞，避免子进程fork出来的进程无法被回收*/


       if(setpgid(0,0) < 0){               /* 把子进程放到一个新进程组中，该进程组ID与子进程的PID相同。这将确保前台进程组中只有一个进程，即shell进程。*/
        printf("setpgid error");
        exit(0);
    }
            if(execve(argv[0],argv,environ) < 0){
                printf("%s: Command not found.\n",argv[0]);
       //第一个错误处理，直接在这里进行提示信息输出
                exit(0);
            }
        }
        
        sigprocmask(SIG_BLOCK,&mask_all,NULL);   /* 恢复信号集合(blocked位向量) */
        addjob(jobs,pid,bg==1 ? BG : FG,cmdline); /* 将子任务添加到任务列表中 */
        sigprocmask(SIG_SETMASK,&prev_one,NULL);  /* 解除子进程对SIGCHLD的阻塞 */
        /* 这样子sigchld_handler处理程序在我们将其添加到工作队列
            中之前是不会运行的。因为直到addjob()之后，我们才解除对SIGCHLD的阻塞
         */


        /* 父任务等待前台任务结束 */
        if (!bg){ //如果不是后台进程，就等待当前的前台进程
            waitfg(pid);
        }else{  /* 否则就是后台进程，开始在后台工作 */
            printf("[%d] (%d) %s",pid2jid(pid),pid,cmdline);
        }
    }

    return;

}

/* 
 * builtin_cmd - If the user has typed a built-in command then execute
 *    it immediately.  
 */
int builtin_cmd(char **argv) //判断当前命令是否为内置命令
{
   if(!strcmp(argv[0],"quit")) //如果是内置命令quit
        exit(0);               //就结束当前进程
   if(!strcmp(argv[0],"jobs")){    /* jobs内置指令 */
        listjobs(jobs);
        return 1;
    }
   if(!strcmp(argv[0],"&")) /* 忽略单& */
        return 1;  //然后返回1，因为如果一个命令以&结尾，shell应该在后台运行它，否则在前台运行；

  if(!strcmp(argv[0],"bg")){      /* bg内置指令 */
    do_bgfg(argv);
    return 1;
}
   if(!strcmp(argv[0],"fg")){      /* fg内置指令 */
    do_bgfg(argv);
    return 1;
  }

    return 0;     /* 不是一个内置命令 */
}

void do_bgfg(char **argv) 
{

    pid_t pid;                      /* 进程id */
    int jid;                        /* job的id */
    struct job_t * job;
    if (argv[1] == NULL){
        printf("%s command requires PID or %%jobid argument\n",argv[0]);
        return;
    }
    //第二个错误是没有传入pid或者jid（为空），就报错并返回

    if (argv[1][0] == '%'){   /* 如果输入的是jid（作业） */
        if(argv[1][1] < '0' || argv[1][1] >'9'){
            printf("fg: argument must be a PID or %%jobid\n");
            return;
        }
   //第三个错误命令是传入了，但是传入的数据不是不符合pid或jid的规范（输入必须为数字）
   //在这里判断并输出错误信息：fg: argument must be a PID or %%jobid\n
        jid = atoi(argv[1]+1);
        job = getjobjid(jobs,jid);//通过jid找到需要执行的job
        if(job == NULL){
            printf("%%%d: No such job\n",jid);
            return;
        }
   //第四个错误就是通过jid找到的job==null，因此“NO such job”
        pid = job->pid;
    }else{                              /* 给的是pid */
        if(argv[1][0] < '0' || argv[1][0] >'9'){
            printf("bg: argument must be a PID or %%jobid\n");
            return;
        }
        pid = atoi(argv[1]);
        job = getjobpid(jobs,pid);
        if(job == NULL){
            printf("(%d): No such process\n",pid);
            return;
        }
//第五个错误就是通过jid找到的job==null，因此“NO such job”
        jid = job->jid;
    }
    if(pid > 0){
        if(!strcmp(argv[0],"bg")){          /* bg内置指令 */
            printf("[%d] (%d) %s",jid,pid,job->cmdline);
            job->state = BG;                /* 更改状态 */
            kill(-pid,SIGCONT);              /* 传递SIGCONT信号给进程组中的所有进程 */
            
        }else
        if(!strcmp(argv[0],"fg")){          /* fg内置指令 */
            job->state = FG;                /* 更改状态 */
            kill(-pid,SIGCONT);             /* 传递SIGCONT信号给进程组中的所有进程 */
            waitfg(pid);                    /* 等待前台job完成 */
        }
    }

    return;
}

/* 
 * waitfg - 阻塞，直到进程的pid不再是前台进程
 */
void waitfg(pid_t pid)
{
     /* 唯一的前台作业结束后，被sigchld_handler回收，deletejob()后，jobs列表中就没有前台作业了，
        循环fpgid(..)
    */
    while(pid==fgpid(jobs)){
        sleep(0);
    }
    return;
}

/* 
 * sigchld_handler - 每当子作业终止(变成僵尸)，或者因为收到SIGSTOP或SIGTSTP信号而停止时，
 * 内核就向shell发送SIGCHLD。该处理程序获取所有可用的僵尸子进程，
 * 但不等待任何其他当前运行的子进程终止。
 */
void sigchld_handler(int sig) 
{
    int olderrno = errno;
    sigset_t mask_all,prev_all;
    pid_t pid;
    int status;

    sigfillset(&mask_all);                          /* 保存当前的信号集合(blocked位向量) */
    while((pid = waitpid(-1,&status,WNOHANG | WUNTRACED)) > 0){    /* WNOHANG:非阻塞的 */
        /* 通过调用exit或者一个返回(return)正常终止 */
        if(WIFEXITED(status)){
            sigprocmask(SIG_BLOCK,&mask_all,&prev_all); /* 恢复信号集合(blocked位向量) */
            deletejob(jobs,pid);     
            sigprocmask(SIG_SETMASK,&prev_all,NULL);                   
        }
        /* 子进程是因为一个未被捕获的信号终止的(SIGINT) */
        if(WIFSIGNALED(status)){
            int jid = pid2jid(pid);
            printf("Job [%d] (%d) terminated by signal %d\n",jid,pid,WTERMSIG(status));
            deletejob(jobs,pid);/* 终止就删除pid的job */
        }
        /* 引起返回的子进程当前是停止的(SIGTSTP) */
        if(WIFSTOPPED(status)){
            struct job_t * job = getjobpid(jobs,pid);
            int jid = pid2jid(pid);
            printf("Job [%d] (%d) stopped by signal %d\n",jid,pid,WSTOPSIG(status));
            job->state = ST;			/* 状态设为停止(ST) */
        }
        
    }
    errno = olderrno;

    return;
}

/* 
 * sigint_handler - 当用户在键盘上键入ctrl-c时，内核向shell发送一个SIGINT。抓住它并把它发送到前台工作。
 */
void sigint_handler(int sig) 
{
    pid_t pid = fgpid(jobs);	/* 获取前台进程id */
    if(pid > 0){
        kill(-pid,sig);     	/* 转发信号sig给进程组|pid|中的每个进程 */
    }
    return;
}

/*
 * sigtstp_handler - 每当用户在键盘上键入ctrl-z时，内核就向shell发送一个SIGTSTP。捕获它并通过向它发送SIGTSTP来挂起前台作业。
 */
void sigtstp_handler(int sig) 
{
    pid_t pid = fgpid(jobs);    /* 获取前台进程id */

    if(pid > 0){
        kill(-pid,sig);         /* 转发信号sig给进程组|pid|中的每个进程 */
    }
    return;
}

到了这里，关于实验四-Shelllab实验（csapp、计算机系统外壳实验）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！