手写简易操作系统(二十八)--实现简单shell

前情提要

Shell是计算机操作系统中的一个重要概念，它是用户与操作系统内核之间的接口。Shell接受用户的命令，并将其转换为操作系统能够理解的指令，然后执行这些指令，并将执行结果返回给用户。

Shell可以理解为一个命令解释器，它负责解释和执行用户输入的命令。它不仅仅是一个命令解释器，还提供了一些功能，如命令历史记录、自动补全、脚本编程等，以方便用户进行操作。

一、实现清屏

global cls_screen
cls_screen:
    pushad
    ;;;;;;;;;;;;;;;
        ; 由于用户程序的cpl为3,显存段的dpl为0,故用于显存段的选择子gs在低于自己特权的环境中为0,
        ; 导致用户程序再次进入中断后,gs为0,故直接在put_str中每次都为gs赋值. 
    mov ax, SELECTOR_VIDEO	   ; 不能直接把立即数送入gs,须由ax中转
    mov gs, ax

    mov ebx, 0
    mov ecx, 80*25
.cls:
    mov word [gs:ebx], 0x0720 ;0x0720是黑底白字的空格键
    add ebx, 2
    loop .cls 
    mov ebx, 0

.set_cursor:			      ;直接把set_cursor搬过来用,省事
    ;;;;;;; 1 先设置高8位 ;;;;;;;;
    mov dx, 0x03d4			  ;索引寄存器
    mov al, 0x0e			  ;用于提供光标位置的高8位
    out dx, al
    mov dx, 0x03d5			  ;通过读写数据端口0x3d5来获得或设置光标位置 
    mov al, bh
    out dx, al

    ;;;;;;; 2 再设置低8位 ;;;;;;;;;
    mov dx, 0x03d4
    mov al, 0x0f
    out dx, al
    mov dx, 0x03d5 
    mov al, bl
    out dx, al
    popad
    ret

这是一段汇编代码，实际上用C实现也可以，只是效率低了那么一点。这个就很简单了，把显存段覆盖，然后设置光标即可，这两个函数实际上之前就实现了。

二、简单的shell

现在这个简单的shell只是简单打印一下字符

2.1、代码

#define cmd_len 128	       // 最大支持键入128个字符的命令行输入
#define MAX_ARG_NR 16	   // 加上命令名外,最多支持15个参数

// 存储输入的命令
static char cmd_line[cmd_len] = { 0 };

// 用来记录当前目录,是当前目录的缓存,每次执行cd命令时会更新此内容
char cwd_cache[64] = { 0 };

// 输出提示符
void print_prompt(void) {
    printf("[lyj@%s]$ ", cwd_cache);
}

/**
 * @description: 从键盘缓冲区中最多读入count个字节到buf。
 * @param {char*} buf
 * @param {int32_t} count
 * @return {*}
 */
static void readline(char* buf, int32_t count) {
    char* pos = buf;
    while (read(stdin_no, pos, 1) != -1 && (pos - buf) < count) {
        // 在不出错情况下,直到找到回车符才返回
        switch (*pos) {

        // 找到回车或换行符后认为键入的命令结束,直接返回
        case '\n':
        case '\r':
            // 添加cmd_line的终止字符0
            *pos = 0;
            putchar('\n');
            return;

        // 退格键
        case '\b':
            if (buf[0] != '\b') {
                // 退回到缓冲区cmd_line中上一个字符
                --pos;
                putchar('\b');
            }
            break;

        // 非控制键则输出字符
        default:
            putchar(*pos);
            pos++;
        }
    }
    printf("readline: can`t find enter_key in the cmd_line, max num of char is 128\n");
}

/**
 * @description: 简单的shell
 * @return {*}
 */
void my_shell(void) {
    cwd_cache[0] = '/';
    while (1) {
        print_prompt();
        memset(cmd_line, 0, cmd_len);
        readline(cmd_line, cmd_len);
        // 若只键入了一个回车
        if (cmd_line[0] == 0) {
            continue;
        }
    }
}

2.2、仿真

三、添加 Ctrl+u 和 Ctrl+l 快捷键

在Linux中，“Ctrl+u”的作用是清除输入，也就是在回车前，按下“Ctrl+u”可以清掉本次的输入，相当于连续按下退格键的效果。“Ctrl+l”的作用是清屏，效果等同于Clear命令，但是有一点要注意，“Ctrl+l”并不会清掉本次的输入。

        /* ctrl+l 清屏 */
        case 'l' - 'a':
            // 1 先将当前的字符'l'-'a'置为0
            *pos = 0;
            // 2 再将屏幕清空
            clear();
            // 3 打印提示符
            print_prompt();
            // 4 将之前键入的内容再次打印
            printf("%s", buf);
            break;

        /* ctrl+u 清掉输入 */
        case 'u' - 'a':
            while (buf != pos) {
                putchar('\b');
                *(pos--) = 0;
            }
            break;

四、解析键入字符

这里解析输入的字符，怎么解析呢，就是将输入的一个字符串按照空格键分隔为多个字符串

/**
 * @description: 分析字符串cmd_str中以token为分隔符的单词,将各单词的指针存入argv数组
 * @param {char*} cmd_str
 * @param {char**} argv
 * @param {char} token
 * @return {*}
 */
static int32_t cmd_parse(char* cmd_str, char** argv, char token) {
    int32_t arg_idx = 0;
    while (arg_idx < MAX_ARG_NR) {
        argv[arg_idx] = NULL;
        arg_idx++;
    }
    char* next = cmd_str;
    int32_t argc = 0;
    /* 外层循环处理整个命令行 */
    while (*next) {
        /* 去除命令字或参数之间的空格 */
        while (*next == token) {
            next++;
        }
        /* 处理最后一个参数后接空格的情况,如"ls dir2 " */
        if (*next == 0) {
            break;
        }
        argv[argc] = next;

        /* 内层循环处理命令行中的每个命令字及参数 */
        while (*next && *next != token) {	  // 在字符串结束前找单词分隔符
            next++;
        }

        /* 如果未结束(是token字符),使tocken变成0 */
        if (*next) {
            // 将token字符替换为字符串结束符0,做为一个单词的结束,并将字符指针next指向下一个字符
            *next++ = 0;
        }

        /* 避免argv数组访问越界,参数过多则返回0 */
        if (argc > MAX_ARG_NR) {
            return -1;
        }
        argc++;
    }
    return argc;
}


int32_t argc = -1;
/**
 * @description: 简单的shell
 * @return {*}
 */
void my_shell(void) {
    cwd_cache[0] = '/';
    while (1) {
        print_prompt();
        memset(final_path, 0, MAX_PATH_LEN);
        memset(cmd_line, 0, MAX_PATH_LEN);
        readline(cmd_line, MAX_PATH_LEN);
        // 若只键入了一个回车
        if (cmd_line[0] == 0) {
            continue;
        }
        argc = -1;
        argc = cmd_parse(cmd_line, argv, ' ');
        if (argc == -1) {
            printf("num of arguments exceed %d\n", MAX_ARG_NR);
            continue;
        }

        int32_t arg_idx = 0;
        while (arg_idx < argc) {
            printf("%s ", argv[arg_idx]);
            arg_idx++;
        }
        printf("\n");
    }
}

五、添加ps调用

5.1、代码

/**
 * @description: 以填充空格的方式输出buf
 * @param {char*} buf 
 * @param {int32_t} buf_len
 * @param {void*} ptr
 * @param {char} format
 * @return {*}
 */
static void pad_print(char* buf, int32_t buf_len, void* ptr, char format) {
    memset(buf, 0, buf_len);
    uint8_t out_pad_0idx = 0;
    switch (format) {
    case 's':
        out_pad_0idx = sprintf(buf, "%s", ptr);
        break;
    case 'd':
        out_pad_0idx = sprintf(buf, "%d", *((int32_t*)ptr));
        break;
    case 'x':
        out_pad_0idx = sprintf(buf, "%x", *((uint32_t*)ptr));
        break;
    }
    while (out_pad_0idx < buf_len) {
        // 以空格填充
        buf[out_pad_0idx] = ' ';
        out_pad_0idx++;
    }
    sys_write(stdout_no, buf, buf_len - 1);
}


/**
 * @description: 用于在list_traversal函数中的回调函数,用于针对线程队列的处理
 * @param {list_elem*} pelem
 * @param {int arg} UNUSED
 * @return {*}
 */
static bool elem2thread_info(struct list_elem* pelem, int arg UNUSED) {
    struct task_struct* pthread = elem2entry(struct task_struct, all_tag, pelem);
    char out_pad[16] = { 0 };

    pad_print(out_pad, 16, &pthread->pid, 'd');

    if (pthread->parent_pid == -1) {
        pad_print(out_pad, 16, "NULL", 's');
    }
    else {
        pad_print(out_pad, 16, &pthread->parent_pid, 'd');
    }

    switch (pthread->status) {
    case 0:
        pad_print(out_pad, 16, "RUNNING", 's');
        break;
    case 1:
        pad_print(out_pad, 16, "READY", 's');
        break;
    case 2:
        pad_print(out_pad, 16, "BLOCKED", 's');
        break;
    case 3:
        pad_print(out_pad, 16, "WAITING", 's');
        break;
    case 4:
        pad_print(out_pad, 16, "HANGING", 's');
        break;
    case 5:
        pad_print(out_pad, 16, "DIED", 's');
    }
    pad_print(out_pad, 16, &pthread->elapsed_ticks, 'x');

    memset(out_pad, 0, 16);
    memcpy(out_pad, pthread->name, strlen(pthread->name));
    strcat(out_pad, "\n");
    sys_write(stdout_no, out_pad, strlen(out_pad));
    // 此处返回false是为了迎合主调函数list_traversal,只有回调函数返回false时才会继续调用此函数
    return false;
}

/**
 * @description: 打印任务列表
 * @return {*}
 */
void sys_ps(void) {
    char* ps_title = "PID            PPID           STAT           TICKS          COMMAND\n";
    sys_write(stdout_no, ps_title, strlen(ps_title));
    list_traversal(&thread_all_list, elem2thread_info, 0);
}

5.2、仿真

六、路径解析

6.1、代码

这里的路径解析指的是将当前的路径，包含 . 和 .. 的路径，解析成绝对路径

/**
 * @description: 将路径old_abs_path中的..和.转换为实际路径后存入new_abs_path
 * @param {char*} old_abs_path 旧的绝对路径
 * @param {char*} new_abs_path 新的绝对路径
 * @return {*}
 */
static void wash_path(char* old_abs_path, char* new_abs_path) {
    char name[MAX_FILE_NAME_LEN] = { 0 };
    char* sub_path = old_abs_path;
    sub_path = path_parse(sub_path, name);
    // 若只键入了"/",直接将"/"存入new_abs_path后返回 
    if (name[0] == 0) {
        new_abs_path[0] = '/';
        new_abs_path[1] = 0;
        return;
    }
    // 避免传给new_abs_path的缓冲区不干净
    new_abs_path[0] = 0;
    strcat(new_abs_path, "/");
    while (name[0]) {
        // 如果是上一级目录“..”
        if (!strcmp("..", name)) {
            char* slash_ptr = strrchr(new_abs_path, '/');
            // 如果未到new_abs_path中的顶层目录,就将最右边的'/'替换为0,这样便去除了new_abs_path中最后一层路径,相当于到了上一级目录
            if (slash_ptr != new_abs_path) {
                // 如new_abs_path为“/a/b”,".."之后则变为“/a”
                *slash_ptr = 0;
            }
            else {
                // 如new_abs_path为"/a",".."之后则变为"/"
                *(slash_ptr + 1) = 0;
            }
        }
        // 如果路径不是‘.’,就将name拼接到new_abs_path
        else if (strcmp(".", name)) {
            // 如果new_abs_path不是"/",就拼接一个"/",此处的判断是为了避免路径开头变成这样"//"
            if (strcmp(new_abs_path, "/")) {
                strcat(new_abs_path, "/");
            }
            strcat(new_abs_path, name);
        }
        // 若name为当前目录".",无须处理new_abs_path

        // 继续遍历下一层路径
        memset(name, 0, MAX_FILE_NAME_LEN);
        if (sub_path) {
            sub_path = path_parse(sub_path, name);
        }
    }
}

/**
 * @description: 将path处理成不含..和.的绝对路径,存储在final_path
 * @param {char*} path
 * @param {char*} final_path
 * @return {*}
 */
void make_clear_abs_path(char* path, char* final_path) {
    char abs_path[MAX_PATH_LEN] = { 0 };
    // 先判断是否输入的是绝对路径
    if (path[0] != '/') {
        // 若输入的不是绝对路径,就拼接成绝对路径
        memset(abs_path, 0, MAX_PATH_LEN);
        if (getcwd(abs_path, MAX_PATH_LEN) != NULL) {
            // 若abs_path表示的当前目录不是根目录/
            if (!((abs_path[0] == '/') && (abs_path[1] == 0))) {
                strcat(abs_path, "/");
            }
        }
    }
    strcat(abs_path, path);
    wash_path(abs_path, final_path);
}

6.2、仿真

七、实现基础命令

命令分为两大类，一种是外部命令，另一种是内部命令。

外部命令是指该命令是个存储在文件系统上的外部程序，执行该命令实际上是从文件系统上加载该程序到内存后运行的过程，也就是说外部命令会以进程的方式执行。大伙儿应该最为熟悉ls命令，它就是典型的外部命令，它通常的存储路径是/bin/ls。

内部命令也称为内建命令，是系统本身提供的功能，它们并不以单独的程序文件存在，只是一些单独的功能函数，系统执行这些命令实际上是在调用这些函数。比如cd、fg、jobs等命令是由bash提供的，因此它们称为BASH_BUILTINS。

我们的内部命令保存在 shell/buildin_cmd.c 路径下

7.1、pwd命令

将当前工作的绝对路径返回到 final_path 中并打印

/**
 * @description: pwd命令的内建函数
 * @param {uint32_t} argc
 * @param {char** argv} UNUSED
 * @return {*}
 */
void buildin_pwd(uint32_t argc, char** argv UNUSED) {
    if (argc != 1) {
        printf("pwd: no argument support!\n");
        return;
    }
    else {
        if (NULL != getcwd(final_path, MAX_PATH_LEN)) {
            printf("%s\n", final_path);
        }
        else {
            printf("pwd: get current work directory failed.\n");
        }
    }
}

7.2、cd命令

/**
 * @description: cd命令的内建函数
 * @param {uint32_t} argc
 * @param {char**} argv
 * @return {*}
 */
char* buildin_cd(uint32_t argc, char** argv) {
    if (argc > 2) {
        printf("cd: only support 1 argument!\n");
        return NULL;
    }

    // 若是只键入cd而无参数,直接返回到根目录.
    if (argc == 1) {
        final_path[0] = '/';
        final_path[1] = 0;
    }
    // 否则清洗成绝对路径
    else {
        make_clear_abs_path(argv[1], final_path);
    }
    // 将当前目录修改
    if (chdir(final_path) == -1) {
        printf("cd: no such directory %s\n", final_path);
        return NULL;
    }
    return final_path;
}

7.3、ls命令

/**
 * @description: ls命令的内建函数
 * @param {uint32_t} argc
 * @param {char**} argv
 * @return {*}
 */
void buildin_ls(uint32_t argc, char** argv) {
    char* pathname = NULL;
    struct stat file_stat;
    memset(&file_stat, 0, sizeof(struct stat));
    bool long_info = false;
    uint32_t arg_path_nr = 0;

    // 跨过argv[0],argv[0]是字符串“ls”
    for (uint32_t arg_idx = 1; arg_idx < argc; arg_idx++) {
        if (argv[arg_idx][0] == '-') {
            // 如果是参数-l
            if (!strcmp("-l", argv[arg_idx])) {         
                long_info = true;
            }
            // 如果是参数-h
            else if (!strcmp("-h", argv[arg_idx])) {
                printf(ls_help);
                return;
            }
            // 其他不支持的参数
            else {
                printf("ls: invalid option %s\nTry `ls -h' for more information.\n", argv[arg_idx]);
                return;
            }
        }
        // ls的路径参数
        else {
            if (arg_path_nr == 0) {
                pathname = argv[arg_idx];
                arg_path_nr = 1;
            }
            else {
                printf("ls: only support one path\n");
                return;
            }
        }
    }

    // 若只输入了ls 或 ls -l,没有输入操作路径,默认以当前路径的绝对路径为参数.
    if (pathname == NULL) {
        if (NULL != getcwd(final_path, MAX_PATH_LEN)) {
            pathname = final_path;
        }
        else {
            printf("ls: getcwd for default path failed\n");
            return;
        }
    }
    else {
        make_clear_abs_path(pathname, final_path);
        pathname = final_path;
    }

    // 遍历目录文件
    if (stat(pathname, &file_stat) == -1) {
        printf("ls: cannot access %s: No such file or directory\n", pathname);
        return;
    }
    if (file_stat.st_filetype == FT_DIRECTORY) {
        struct dir* dir = opendir(pathname);
        struct dir_entry* dir_e = NULL;
        char sub_pathname[MAX_PATH_LEN] = { 0 };
        uint32_t pathname_len = strlen(pathname);
        uint32_t last_char_idx = pathname_len - 1;
        memcpy(sub_pathname, pathname, pathname_len);
        if (sub_pathname[last_char_idx] != '/') {
            sub_pathname[pathname_len] = '/';
            pathname_len++;
        }
        rewinddir(dir);
        if (long_info) {
            char ftype;
            printf("total: %d\n", file_stat.st_size);
            while ((dir_e = readdir(dir))) {
                ftype = 'd';
                if (dir_e->f_type == FT_REGULAR) {
                    ftype = '-';
                }
                sub_pathname[pathname_len] = 0;
                strcat(sub_pathname, dir_e->filename);
                memset(&file_stat, 0, sizeof(struct stat));
                if (stat(sub_pathname, &file_stat) == -1) {
                    printf("ls: cannot access %s: No such file or directory\n", dir_e->filename);
                    return;
                }
                printf("%c  %d  %d  %s\n", ftype, dir_e->i_no, file_stat.st_size, dir_e->filename);
            }
        }
        else {
            while ((dir_e = readdir(dir))) {
                printf("%s ", dir_e->filename);
            }
            printf("\n");
        }
        closedir(dir);
    }
    else {
        if (long_info) {
            printf("-  %d  %d  %s\n", file_stat.st_ino, file_stat.st_size, pathname);
        }
        else {
            printf("%s\n", pathname);
        }
    }
}

7.4、ps命令

/**
 * @description: ps命令内建函数
 * @param {uint32_t} argc
 * @param {char** argv} UNUSED
 * @return {*}
 */
void buildin_ps(uint32_t argc, char** argv UNUSED) {
    if (argc != 1) {
        printf("ps: no argument support!\n");
        return;
    }
    ps();
}

7.5、clear命令

/**
 * @description: clear命令内建函数
 * @param {uint32_t} argc
 * @param {char** argv} UNUSED
 * @return {*}
 */
void buildin_clear(uint32_t argc, char** argv UNUSED) {
    if (argc != 1) {
        printf("clear: no argument support!\n");
        return;
    }
    clear();
}

7.6、mkdir命令

/**
 * @description: mkdir命令内建函数
 * @param {uint32_t} argc
 * @param {char**} argv
 * @return {*}
 */
int32_t buildin_mkdir(uint32_t argc, char** argv) {
    int32_t ret = -1;
    if (argc != 2) {
        printf("mkdir: only support 1 argument!\n");
    }
    else {
        make_clear_abs_path(argv[1], final_path);
        // 若创建的不是根目录
        if (strcmp("/", final_path)) {
            if (mkdir(final_path) == 0) {
                ret = 0;
            }
            else {
                printf("mkdir: create directory %s failed.\n", argv[1]);
            }
        }
    }
    return ret;
}

7.7、rmdir命令

/**
 * @description: rmdir命令内建函数
 * @param {uint32_t} argc
 * @param {char**} argv
 * @return {*}
 */
int32_t buildin_rmdir(uint32_t argc, char** argv) {
    int32_t ret = -1;
    if (argc != 2) {
        printf("rmdir: only support 1 argument!\n");
    }
    else {
        make_clear_abs_path(argv[1], final_path);
        // 若删除的不是根目录
        if (strcmp("/", final_path)) {
            if (rmdir(final_path) == 0) {
                ret = 0;
            }
            else {
                printf("rmdir: remove %s failed.\n", argv[1]);
            }
        }
    }
    return ret;
}

7.8、rm命令

/**
 * @description: rm命令内建函数
 * @param {uint32_t} argc
 * @param {char**} argv
 * @return {*}
 */
int32_t buildin_rm(uint32_t argc, char** argv) {
    int32_t ret = -1;
    if (argc != 2) {
        printf("rm: only support 1 argument!\n");
    }
    else {
        make_clear_abs_path(argv[1], final_path);
        // 若删除的不是根目录
        if (strcmp("/", final_path)) {
            if (unlink(final_path) == 0) {
                ret = 0;
            }
            else {
                printf("rm: delete %s failed.\n", argv[1]);
            }

        }
    }
    return ret;
}

7.9、touch命令

void buildin_touch(uint32_t argc, char** argv) {
    if (argc != 2) {
        printf("rm: only support 1 argument!\n");
    }
    else {
        make_clear_abs_path(argv[1], final_path);
        int fd = open(final_path, O_CREAT);
        if (fd != -1) {
            close(fd);
        }
    }
}

7.10、写入shell

void my_shell(void) {
    cwd_cache[0] = '/';
    clear();
    while (1) {
        print_prompt();
        memset(final_path, 0, MAX_PATH_LEN);
        memset(cmd_line, 0, MAX_PATH_LEN);
        readline(cmd_line, MAX_PATH_LEN);
        if (cmd_line[0] == 0) {	 // 若只键入了一个回车
            continue;
        }
        argc = -1;
        argc = cmd_parse(cmd_line, argv, ' ');
        if (argc == -1) {
            printf("num of arguments exceed %d\n", MAX_ARG_NR);
            continue;
        }
        if (!strcmp("ls", argv[0])) {
            buildin_ls(argc, argv);
        }
        else if (!strcmp("cd", argv[0])) {
            if (buildin_cd(argc, argv) != NULL) {
                memset(cwd_cache, 0, MAX_PATH_LEN);
                strcpy(cwd_cache, final_path);
            }
        }
        else if (!strcmp("pwd", argv[0])) {
            buildin_pwd(argc, argv);
        }
        else if (!strcmp("ps", argv[0])) {
            buildin_ps(argc, argv);
        }
        else if (!strcmp("clear", argv[0])) {
            buildin_clear(argc, argv);
        }
        else if (!strcmp("mkdir", argv[0])) {
            buildin_mkdir(argc, argv);
        }
        else if (!strcmp("rmdir", argv[0])) {
            buildin_rmdir(argc, argv);
        }
        else if (!strcmp("rm", argv[0])) {
            buildin_rm(argc, argv);
        }
        else {
            printf("external command\n");
        }
    }
}

7.11、仿真

结束语

本节实现了一个简单的shell，其实不难发现，就是我们之前写的那些调用

老规矩，本节的代码地址：https://github.com/lyajpunov/os