• 实验四-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其实还有点不太清楚。

    最后贴上所有代码：

    1. void eval(char *cmdline) //加载且执行命令
    2. {
    3.     char *argv[MAXARGS];        /* 参数列表execve() */
    4.     char buf[MAXLINE];          /* 保存修改的命令行 */
    5.     int bg;                     /* 这个作业应该在后台进行？ */
    6.     pid_t pid;                  /* 进程id*/
    7.     strcpy(buf,cmdline);
    8.     bg = parseline(buf,argv);
    9.     if(argv[0] == NULL)
    10.         return;                 /* 忽略空命令 */
    11.  
    12.     sigset_t mask_all,mask_one,prev_one;
    13.     if(!builtin_cmd(argv)){
    14.         sigfillset(&mask_all);  /* 保存当前的阻塞信号集合(blocked位向量) */
    15.         sigemptyset(&mask_one); //初始化mask_one为空集
    16.         sigaddset(&mask_one,SIGCHLD);//添加SIGCHLD到mask_one中
    17.         //以上三句保存了当前的已阻塞信号集合
    18.  
    19.         sigprocmask(SIG_BLOCK,&mask_one,&prev_one);         /* 添加mask_one中的信号到信号集合（blocked位向量），从而父进程保持SIGCHLD的阻塞*/
    20.         if((pid = fork()) == 0){    /* 子程序运行用户作业 */
    21.  
    22.             sigprocmask(SIG_SETMASK,&prev_one,NULL); /* 因为子进程继承了它们父进程的被阻塞集合，所以在调用execve之前，必须
    23.                                                          解除子进程对SIGCHLD的阻塞，避免子进程fork出来的进程无法被回收*/
    24.  
    25.  
    26.        if(setpgid(0,0) < 0){               /* 把子进程放到一个新进程组中，该进程组ID与子进程的PID相同。这将确保前台进程组中只有一个进程，即shell进程。*/
    27.         printf("setpgid error");
    28.         exit(0);
    29.     }
    30.             if(execve(argv[0],argv,environ) < 0){
    31.                 printf("%s: Command not found.\n",argv[0]);
    32.        //第一个错误处理，直接在这里进行提示信息输出
    33.                 exit(0);
    34.             }
    35.         }
    36.         
    37.         sigprocmask(SIG_BLOCK,&mask_all,NULL);   /* 恢复信号集合(blocked位向量) */
    38.         addjob(jobs,pid,bg==1 ? BG : FG,cmdline); /* 将子任务添加到任务列表中 */
    39.         sigprocmask(SIG_SETMASK,&prev_one,NULL);  /* 解除子进程对SIGCHLD的阻塞 */
    40.         /* 这样子sigchld_handler处理程序在我们将其添加到工作队列
    41.             中之前是不会运行的。因为直到addjob()之后，我们才解除对SIGCHLD的阻塞
    42.          */
    43.  
    44.  
    45.         /* 父任务等待前台任务结束 */
    46.         if (!bg){ //如果不是后台进程，就等待当前的前台进程
    47.             waitfg(pid);
    48.         }else{  /* 否则就是后台进程，开始在后台工作 */
    49.             printf("[%d] (%d) %s",pid2jid(pid),pid,cmdline);
    50.         }
    51.     }
    52.  
    53.     return;
    54.  
    55. }
    1. /* 
    2.  * builtin_cmd - If the user has typed a built-in command then execute
    3.  *    it immediately.  
    4.  */
    5. int builtin_cmd(char **argv) //判断当前命令是否为内置命令
    6. {
    7.    if(!strcmp(argv[0],"quit")) //如果是内置命令quit
    8.         exit(0);               //就结束当前进程
    9.    if(!strcmp(argv[0],"jobs")){    /* jobs内置指令 */
    10.         listjobs(jobs);
    11.         return 1;
    12.     }
    13.    if(!strcmp(argv[0],"&")) /* 忽略单& */
    14.         return 1;  //然后返回1，因为如果一个命令以&结尾，shell应该在后台运行它，否则在前台运行；
    15.  
    16.   if(!strcmp(argv[0],"bg")){      /* bg内置指令 */
    17.     do_bgfg(argv);
    18.     return 1;
    19. }
    20.    if(!strcmp(argv[0],"fg")){      /* fg内置指令 */
    21.     do_bgfg(argv);
    22.     return 1;
    23.   }
    24.  
    25.     return 0;     /* 不是一个内置命令 */
    26. }
    1. void do_bgfg(char **argv) 
    2. {
    3.  
    4.     pid_t pid;                      /* 进程id */
    5.     int jid;                        /* job的id */
    6.     struct job_t * job;
    7.     if (argv[1] == NULL){
    8.         printf("%s command requires PID or %%jobid argument\n",argv[0]);
    9.         return;
    10.     }
    11.     //第二个错误是没有传入pid或者jid（为空），就报错并返回
    12.  
    13.     if (argv[1][0] == '%'){   /* 如果输入的是jid（作业） */
    14.         if(argv[1][1] < '0' || argv[1][1] >'9'){
    15.             printf("fg: argument must be a PID or %%jobid\n");
    16.             return;
    17.         }
    18.    //第三个错误命令是传入了，但是传入的数据不是不符合pid或jid的规范（输入必须为数字）
    19.    //在这里判断并输出错误信息：fg: argument must be a PID or %%jobid\n
    20.         jid = atoi(argv[1]+1);
    21.         job = getjobjid(jobs,jid);//通过jid找到需要执行的job
    22.         if(job == NULL){
    23.             printf("%%%d: No such job\n",jid);
    24.             return;
    25.         }
    26.    //第四个错误就是通过jid找到的job==null，因此“NO such job”
    27.         pid = job->pid;
    28.     }else{                              /* 给的是pid */
    29.         if(argv[1][0] < '0' || argv[1][0] >'9'){
    30.             printf("bg: argument must be a PID or %%jobid\n");
    31.             return;
    32.         }
    33.         pid = atoi(argv[1]);
    34.         job = getjobpid(jobs,pid);
    35.         if(job == NULL){
    36.             printf("(%d): No such process\n",pid);
    37.             return;
    38.         }
    39. //第五个错误就是通过jid找到的job==null，因此“NO such job”
    40.         jid = job->jid;
    41.     }
    42.     if(pid > 0){
    43.         if(!strcmp(argv[0],"bg")){          /* bg内置指令 */
    44.             printf("[%d] (%d) %s",jid,pid,job->cmdline);
    45.             job->state = BG;                /* 更改状态 */
    46.             kill(-pid,SIGCONT);              /* 传递SIGCONT信号给进程组中的所有进程 */
    47.             
    48.         }else
    49.         if(!strcmp(argv[0],"fg")){          /* fg内置指令 */
    50.             job->state = FG;                /* 更改状态 */
    51.             kill(-pid,SIGCONT);             /* 传递SIGCONT信号给进程组中的所有进程 */
    52.             waitfg(pid);                    /* 等待前台job完成 */
    53.         }
    54.     }
    55.  
    56.     return;
    57. }
    1. /* 
    2.  * waitfg - 阻塞，直到进程的pid不再是前台进程
    3.  */
    4. void waitfg(pid_t pid)
    5. {
    6.      /* 唯一的前台作业结束后，被sigchld_handler回收，deletejob()后，jobs列表中就没有前台作业了，
    7.         循环fpgid(..)
    8.     */
    9.     while(pid==fgpid(jobs)){
    10.         sleep(0);
    11.     }
    12.     return;
    13. }
    1. /* 
    2.  * sigchld_handler - 每当子作业终止(变成僵尸)，或者因为收到SIGSTOP或SIGTSTP信号而停止时，
    3.  * 内核就向shell发送SIGCHLD。该处理程序获取所有可用的僵尸子进程，
    4.  * 但不等待任何其他当前运行的子进程终止。
    5.  */
    6. void sigchld_handler(int sig) 
    7. {
    8.     int olderrno = errno;
    9.     sigset_t mask_all,prev_all;
    10.     pid_t pid;
    11.     int status;
    12.  
    13.     sigfillset(&mask_all);                          /* 保存当前的信号集合(blocked位向量) */
    14.     while((pid = waitpid(-1,&status,WNOHANG | WUNTRACED)) > 0){    /* WNOHANG:非阻塞的 */
    15.         /* 通过调用exit或者一个返回(return)正常终止 */
    16.         if(WIFEXITED(status)){
    17.             sigprocmask(SIG_BLOCK,&mask_all,&prev_all); /* 恢复信号集合(blocked位向量) */
    18.             deletejob(jobs,pid);     
    19.             sigprocmask(SIG_SETMASK,&prev_all,NULL);                   
    20.         }
    21.         /* 子进程是因为一个未被捕获的信号终止的(SIGINT) */
    22.         if(WIFSIGNALED(status)){
    23.             int jid = pid2jid(pid);
    24.             printf("Job [%d] (%d) terminated by signal %d\n",jid,pid,WTERMSIG(status));
    25.             deletejob(jobs,pid);/* 终止就删除pid的job */
    26.         }
    27.         /* 引起返回的子进程当前是停止的(SIGTSTP) */
    28.         if(WIFSTOPPED(status)){
    29.             struct job_t * job = getjobpid(jobs,pid);
    30.             int jid = pid2jid(pid);
    31.             printf("Job [%d] (%d) stopped by signal %d\n",jid,pid,WSTOPSIG(status));
    32.             job->state = ST;			/* 状态设为停止(ST) */
    33.         }
    34.         
    35.     }
    36.     errno = olderrno;
    37.  
    38.     return;
    39. }
    1. /* 
    2.  * sigint_handler - 当用户在键盘上键入ctrl-c时，内核向shell发送一个SIGINT。抓住它并把它发送到前台工作。
    3.  */
    4. void sigint_handler(int sig) 
    5. {
    6.     pid_t pid = fgpid(jobs);	/* 获取前台进程id */
    7.     if(pid > 0){
    8.         kill(-pid,sig);     	/* 转发信号sig给进程组|pid|中的每个进程 */
    9.     }
    10.     return;
    11. }
    1. /*
    2.  * sigtstp_handler - 每当用户在键盘上键入ctrl-z时，内核就向shell发送一个SIGTSTP。捕获它并通过向它发送SIGTSTP来挂起前台作业。
    3.  */
    4. void sigtstp_handler(int sig) 
    5. {
    6.     pid_t pid = fgpid(jobs);    /* 获取前台进程id */
    7.  
    8.     if(pid > 0){
    9.         kill(-pid,sig);         /* 转发信号sig给进程组|pid|中的每个进程 */
    10.     }
    11.     return;
    12. }

  • 相关阅读:
    巧用数组——一维数组
    Idea项目爆红
    中国互联网众筹行业
    算法设计与分析 SCAU10346 带价值的作业安排问题
    Day27.组合总和II、分割回文串
    正则表达式规则及在JavaScript中使用的详细介绍
    kali /mac 成功的反弹shell语句
    Redis01——Redis简介
    【ONE·C++ || 智能指针 & 特殊类的设计】
    极智嘉(Geek+)官宣重磅合作伙伴，再度赋能仓储自动化解决方案落地
  • 原文地址：https://blog.csdn.net/longzaizai_/article/details/124972640