MSH：一個簡單SH工具實現

時間 2019-11-11

標籤 msh 一個簡單工具實現简体版

原文原文鏈接

本文將分爲不一樣的Part，分別實現Shell的一部分功能。
msh從CSAPP的SHLAB出發，逐漸完善SHELL功能，並移植到本身的OS上。
Github: https://github.com/He11oLiu/msh ios

Part1

Part1 目標git

首先，tsh須要支持內嵌指令功能，使用int builtin_cmd(char **argv)實現。
再，tsh須要支持先後臺執行程序的功能，shell須要接收SIGCHLD進程，回收僵死進程或處理暫停進程。github

在給出的handout中已經把語義分析寫好了，直接用便可。shell

命令求值函數

/* * 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;
    pid_t pid;
    sigset_t mask;


    bg = parseline(cmdline,argv);
    if(argv[0] == NULL)
        return ;
    if(!builtin_cmd(argv)){
        sigemptyset(&mask);
        sigaddset(&mask,SIGCHLD);
        sigaddset(&mask,SIGINT);
        sigaddset(&mask,SIGTSTP);
        sigprocmask(SIG_BLOCK,&mask,NULL);
        /* child proc */
        if((pid = Fork()) == 0){
            setpgid(0, 0);
            if(verbose){
                pid = getpid();
                printf("Child proc started with pid %d\n",(int)pid);
            }
            sigprocmask(SIG_UNBLOCK,&mask,NULL);
            if(execve(argv[0],argv,environ)<0){
                printf("%s: Command not found.\n",argv[0]);
                exit(0);
            }
        }
        /* parent proc */
        else{
            addjob(jobs,pid,bg?BG:FG,cmdline);
            sigprocmask(SIG_UNBLOCK,&mask,NULL);
            if(!bg){
                /* Use waitfg to wait until proc(pid) is no longer a frontgroud proc. */
                waitfg(pid);
            }
            else{
                printf("[%d] (%d) %s",pid2jid(pid),pid,cmdline);
            }
        }
    }
    return ;
}

在第一階段的目標下，不須要在課本的基礎上改多少內容，一個是對於前臺的子進程再也不使用waitpid來阻塞，而是使用更加優雅的waitfg來阻塞。再一個是添加了SIGCHLD的處理函數，用於處理回收僵死或暫停進程。markdown

前臺阻塞處理

對於前臺，最初實現是直接waitpid。可是一旦使用SIGCHLD的處理函數來回收，兩個waitpid會致使結構很差，全局FLAG之類也不夠優雅。框架

發現其提供了waitfg的接口，思路一用如下方法實現。ide

void waitfg(pid_t pid){
    struct job_t *cur = getjobpid(jobs,pid);
    while(cur != NULL && cur->state == FG){
        cur = getjobpid(jobs,pid);
    }
    /* 2 cases: BG : switch to BG from FG NULL : delete from jobs */
    return;
}

性能不佳，且不夠優雅。每次都觀察前臺的proc是否是pid便可，再利用pause暫停，直到有下一個信號來臨。函數

void waitfg(pid_t pid){
    while(pid == fgpid(jobs))
        pause();
    return;
}

這樣就優雅多了。性能

回收僵死進程

須要使用sigchld_handler來接收SIGCHLD信號對僵死進程進行回收或者處理被暫停的進程。測試

/* * 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) {
    pid_t pid;
    int status;
    struct job_t *job;
    while((pid = waitpid(-1,&status,WNOHANG | WUNTRACED))>0){
        if(WIFEXITED(status)){  /*process is exited in normal way*/
            if(verbose)
                printf("Job [%d] (%d) terminated normally with exit status %d\n",pid2jid(pid),pid,WEXITSTATUS(status));
            deletejob(jobs,pid);
        }
        else if(WIFSTOPPED(status)){/*process is stop because of a signal*/
            printf("Job [%d] (%d) stopped by signal %d\n",pid2jid(pid),pid,WSTOPSIG(status));
            job = getjobpid(jobs,pid);
            if(job !=NULL) job->state = ST;
        }
        else if(WIFSIGNALED(status)){/*process is terminated by a signal*/
            printf("Job [%d] (%d) terminated by signal %d\n",pid2jid(pid),pid,WTERMSIG(status));
            deletejob(jobs,pid);
        }

    }
    return;
}

其中要注意的是，若是使用了while輪巡檢查回收全部的僵死進程，須要在options參數中加入WNOHANG來確保其當即返回。爲了將來可以處理暫停的應用程序，這裏options的參數選擇爲WNOHANG|WUNTRACED，其表達爲若是沒有等待集合中的任何子進程中止或終止，則當即返回，且返回值爲0.

利用status來接收返回的狀態，在用宏定義打包的位操做來判斷狀態。

正常退出的進入WIFEXITED(status)的分支，在有-v選項時，利用WEXITSTATUS(status)來獲取其返回值。
由信號形成的進程終止，進入WIFSIGNALED(status)分支。利用WTERMSIG(status)來獲取引發進程終止的信號數量。
由信號形成的進程暫停，進入WIFSTOPPED(status)分支。利用WSTOPSIG(status)來獲取引發進程終止的信號數量。

內嵌功能實現

默認handout中已經實現了與job有關的操做函數，提供了基本操做接口，在不一樣的位置加入或刪除或修改jobs列表便可。這裏要注意阻塞對應的信號量避免陷入錯誤狀態，書上給了詳細的示例。

/* * 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") || !strcmp( argv[0],"exit"))
        exit(0);
    if(!strcmp(argv[0],"jobs")){
        listjobs(jobs);
        return 1;
    }
    return 0;     /* not a builtin command */
}

至此，能夠經過test05以及以前的需求。

Part2

Part2 目標

接收從鍵盤傳來的信號，處理SIGINT與SIGTSTP的信號
BG與FG內嵌功能實現
簡單錯誤處理

支持對前臺的終止與暫停操做

對SIGINT與SIGTSTP的處理函數稍加修改，便可實現該功能。須要找出前臺進程，並向該進程組發送信號便可。(以前將進程加到了與pid相同的組內)

/* * 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){
    pid_t pid = fgpid(jobs);
    if(pid) kill(-pid,SIGINT);
    return;
}

/* * 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){
    pid_t pid = fgpid(jobs);
    if(pid) kill(-pid,SIGTSTP);
    return;
}

添加這兩個處理函數後，test08及以前的測試可過。

BG與FG功能實現

從JID轉換到PID，異常處理。

/* jid2pid - Map job ID to process ID */
pid_t jid2pid(int jid){
    if(jid>=MAXJID || jid <= 0) return 0;
    return jobs[jid-1].pid;
}

由於bg與fg支持PID與JID兩種輸入方式，故利用parse arg塊來實現。對於atoi的異常狀況，在jid2pid中對0進行了處理。而對於不屬於該shell的pid，會沒法找到其JID，而不發消息。

/* * do_bgfg - Execute the builtin bg and fg commands */
void do_bgfg(char **argv){
    pid_t pid;
    int jid;
    struct job_t *job;
    if(argv[1]== NULL){
        printf("fg command requires PID or %%jobid argument\n");
        return;
    }
    /* parse arg */
    if(argv[1][0] == '%'){
        /* JID */
        jid = atoi(argv[1]+1);
        if(jid == 0 && argv[1][1] != '0'){
            /* Not number */
            printf("fg command requires PID or %%jobid argument\n");
            return;
        }
        if(!(pid=jid2pid(jid))){
            /* JID not exits */
            printf("%%%d: No such job\n",jid);
            return;
        }
    }
    else{
        /* PID */
        pid = atoi(argv[1]);
        if(pid == 0 && argv[1][0] != '0'){
            /* Not number */
            printf("fg command requires PID or %%jobid argument\n");
            return;
        }
        if(!(jid = pid2jid(pid))) {
            printf("(%d): No such process\n",pid);
            return;
        }
    }
    job = getjobjid(jobs,jid);

    if(!strcmp(argv[0],"bg")){
        /* bg function * The bg <job> command restarts <job> by sending it a SIGCONT signal, * and then runs it in the background. * The <job> argument can be either a PID or a JID. */
        job->state = BG;
        kill(-pid,SIGCONT);
        printf("[%d] (%d) %s",jid,pid,job->cmdline);
    }
    else{
        /* fg function * The fg <job> command restarts <job> by sending it a SIGCONT signal, * and then runs it in the foreground. * The <job> argument can be either a PID or a JID. */
        job->state = FG;
        kill(-pid,SIGCONT);
        waitfg(pid);
    }
    return;
}

添加這兩個處理函數後，全部的test測試可過。

Part3

Part3目標

實現cd功能
更改shell promp
增長默認PATH目錄

`cd`功能實現

獲取當前的工做路徑，拼接工做路徑，並改變工做路徑，便可完成cd。

char *getcwd( char *buffer, int maxlen );
int  chdir(const char *);

完成上述邏輯：

int do_cd(char **argv){
    char buf[MAXLINE];
    buf[0] = '\0';
    if(argv[1][0] != '/' && argv[1][0] != '.'){ 
        if(getcwd(buf, MAXLINE) == NULL){  
            fprintf(stderr, "Getcwd failed: %s\n", strerror(errno));  
            return -1;  
        }
        strncat(buf, "/", MAXLINE - strlen(buf));  
    }  
    strncat(buf, argv[1], MAXLINE - strlen(buf));
    printf("cd path : %s\n",buf);
    if(chdir(buf) == -1){  
        fprintf(stderr, "cd error : %s %s\n",strerror(errno),argv[1]);  
    }  
    return 0;  
}

修改`prompt`

因爲增長了cd功能，prompt改成更有意義的工做路徑時間

/* Get prompt */
if(getcwd(workpath, MAXLINE) == NULL){ 
    fprintf(stderr, "Getcwd failed: %s\n", strerror(errno));
    return -1;  
}
time (&t);
lt = localtime (&t);
sprintf (prompt, "\n%s#%s %s%s%s %s[%d:%d:%d]%s\n%sμ%s ",B_BLUE,FINISH,B_YELLOW,workpath,FINISH,BOLD,lt->tm_hour, lt->tm_min, lt->tm_sec,FINISH,B_RED,FINISH);

增長默認`PATH`目錄

獲取PATH變量，並切分放入pathargv中，數量放入pathargc

/* Get $PATH */
pathvar = getenv("PATH");
if(verbose)
printf("Loaded with PATH = %s\n",pathvar);
/* For macOS PATH devided by ':' */
pathargv[pathargc] = strtok( pathvar, ":" );
while( pathargv[pathargc] != NULL ) {
    pathargv[++pathargc] = strtok( NULL, ":" );
}

在執行命令以前，該用access檢測文件是否可執行

/* check execuable & check if needed add path */
if(!access(argv[0],1)){
    execfile = argv[0];
}
else if(argv[0][0]!='/' && argv[0][0]!='.'){
    for(i = 0; i< pathargc;i++){
        sprintf(buf,"%s/%s",pathargv[i],argv[0]);
        if(!access(buf,1)){ execfile = buf;break;}
    }
}

若是可執行，則execfile指針指向文件名，不然不可執行

if(execfile!=NULL){
    if(execve(execfile,argv,environ)<0){
        printf("%s: Execve error.\n",execfile);
        exit(0);
    }
}
else{
    printf("%s: Command not found.\n",argv[0]);
    exit(0);
}

出現問題

運行前臺程序，輸入沒有轉換過去？

前臺的程序沒法讀取輸入，並被中斷。

tcsetpgrp is to specify what is the foreground job. When your shell spawns a job in foreground (without &), it should create a new process group and make that the foreground job (of the controlling terminal, not whatever’s on STDIN).

stackoverflow

對於子程序，在執行前，須要將STDIN STDOUT的前臺程序設爲本身。

if(!bg){
    tcsetpgrp(STDIN_FILENO, getpid());
    tcsetpgrp(STDOUT_FILENO,pid);
}

對於父程序，在等待結束後須要從新將STDIN STDOUT的前臺程序設爲本身。

if(!bg){
    tcsetpgrp(STDIN_FILENO, pid);
    //tcsetpgrp(STDOUT_FILENO,pid);
    /* Use waitfg to wait until proc(pid) is no longer a foreground proc. */
    waitfg(pid);
    tcsetpgrp(STDIN_FILENO, getpid());
    //tcsetpgrp(STDOUT_FILENO,getpid());
}

注意do_bgfg一樣也要作相同操做。

利用scanf.c程序能夠測試是否正確。

Part 4

支持pipe
支持文件i/o redirection

Part Extra

嘗試獲取功能按鍵

因爲unix下沒有win的getch，便利用cfmakeraw實現了相似功能

char unix_getch(void){
    struct termios tm, tm_old;
    char ch;
    Tcgetattr(STDIN_FILENO,&tm);
    Tcgetattr(STDIN_FILENO,&tm_old);
    cfmakeraw(&tm);
    Tcsetattr(STDIN_FILENO, TCSANOW, &tm);
    ch = getchar();
    Tcsetattr(STDIN_FILENO, TCSANOW, &tm_old);
    return ch;
}

void Tcgetattr(int fd,struct termios *termios_p){
    if (tcgetattr(STDIN_FILENO,termios_p) < 0){
        fprintf(stderr,"tcgetattr error");
        exit(0);
    }
}

void Tcsetattr(int fd, int optional_actions, const struct termios *termios_p){
    if (tcsetattr(fd, optional_actions, termios_p) < 0){
        fprintf(stderr,"tcsetattr error");
        exit(0);
    }
}

而輸入計劃利用handler函數來處理，handler的框架以下。

void input_handler(char *cmdline){
    char ch;
    int index = 0;
    int cursorloc = 0;
    ch = unix_getch();
    memset(cmdline,'\0',sizeof(char)*MAXLINE);
    while(ch!= '\r'){
        /* key handler (unix type) */
        if(ch == 0x1b){
            ch = unix_getch();
            if(ch == 0x5b){
                ch = unix_getch();
                switch(ch){
                    case KEY_UP:
                        printf("KEY UP");
                    break;
                    case KEY_DOWN:
                        printf("KEY DOWN");
                    break;
                    case KEY_LEFT:
                        printf("KEY LEFT");
                    break;
                    case KEY_RIGHT:
                        printf("KEY RIGHT");
                        index ++;
                    break;
                }
                ch = unix_getch();
            }
            else{
                cmdline[index++] = 0x1b;
                cmdline[index++] = 0x5b;
            }
        }
        else{
            cursorloc ++;
            cmdline[index++] = ch;
            printf("%s",cmdline+index-1);
            ch = unix_getch();
        }
    }
    printf("\n");
    cmdline[index] = '\0';
}