您的位置:首页 > 运维架构 > Shell

CSAPP 之 ShellLab 详解

2022-05-22 14:20 2931 查看

前言

本篇博客将会详细介绍 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:

    总结

    通过这次实验,可以加深对进程控制和信号处理的理解,同时对于并发现象有了更直观的认识,以上~~

    内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
    标签: