《操作系统-真象还原》15. 系统交互

文章目录

- fork 的原理与实现
- - 简介
  - 什么是 fork
  - fork 的实现
  - - 思路
    - 代码
    - - get_a_page_without_opvaddrbitmap
      - copy_pcb_vaddrbitmap_stack0
      - copy_body_stack3
      - build_child_stack
      - update_inode_open_cnts
      - copy_process
      - sys_fork
  - 添加 fork 系统调用与实现 init 进程
  - - 添加 fork 系统调用
    - 实现 init 进程
- shell 的前置准备工作
- 实现一个简单的 shell
- - readline / print_prompt 函数
  - 添加 Ctrl+u 和 Ctrl+l 快捷键
  - cmd_str 分割输入的指令，相对于高级语言中字符串的 split 函数。
  - 解析路径
  - 实现 ls、c、mkdir、ps、rm 等指令
  - shell 主程序
- 现在 Shell 的问题

fork 的原理与实现

简介

pid_t fork( void);

pid_t 是一个宏定义，其实质是int 被定义在 #includesys/types.h> 中。

返回值：若成功调用一次则返回两个值，其返回值的意义如下

0：子进程
子进程ID，即 >0：父进程
-1：错误

fork 的另一个特性是所有由父进程打开的描述符都被复制到子进程中。父、子进程中相同编号的文件描述符在内核中指向同一个file结构体，也就是说，file结构体的引用计数要增加。（相关函数请看 fork 的实现 -> 思路）

什么是 fork

#include <unistd.h>
#include <stdio.h>

int main() {
    printf("I will fork in 5 seconds.\n");
    sleep(5);
    int pid = fork();
    if(pid == -1) {
        printf("fork error!\n");
        return 1;
    }
    if(pid) {
        printf("[fork->pid=%d] I am father, my pid is %d\n.", pid, getpid());
        sleep(5);
        return 0;
    } else {
        printf("[fork->pid=%d] I am child, my pid is %d\n.", pid, getpid());
        sleep(5);
        return 0;
    }
}

需要打开两个终端，一个用于运行程序，一个用于查看进程信息。
终端一：运行测试程序

终端二：查看进程信息

一开始并无相关进程信息，接下来执行测试程序，首先执行父进程，得到 pid=8917，休眠 5s 后执行 fork() 函数，之后会发现输出了两条语句，也就是说 fork 返回一次返回了两个不同的返回值，为什么呢？

看进程信息，fork 后多了一个“子进程”，其 pid=8932，也就是说 fork 其实是将父进程克隆了一份，而进程拥有独立的地址空间，因此两个进程执行的是独立且相同的代码，所以它们并不共享同一内存空间，也就是执行的是两套代码（代码是相同的，只是有两套而已）。

看输出的结果，是先执行的父进程，其 fork 返回父进程的 pid，其次执行的才是子进程，其子进程 fork 返回的是 0。

注意，这里并不是父子进程各调用一次，父子进程合计才调用了一次 fork，也就是说执行一次 fork 会返回两个值，只是返回的地方不一样，一次是在父进程，一次是在父进程。

fork 的实现

思路

前面说明了 fork 本质是将父进程克隆了一份，称为子进程。首先我们需要明确要复制的资源，复制完成后让处理器的 cs:eip 指向新进程的指令部分。
实现 fork 分两步：

先复制进程资源。
让处理器的 cs:eip 指向子进程的指令部分（也就是程序代码部分）。

明确要复制的资源有：

进程的 PCB，即 task_struct。相关函数：copy_pcb_vaddrbitmap_stack0
程序体，即代码段、数据段等，这是进程的实体。相关函数：copy_body_stack3
用户栈，编译器会把局部变量存入栈，而调用函数也需要压栈执行。相关函数：copy_body_stack3
内核栈，进入内核态时，一方面要用它来保护上下文环境，而另一方面和用户栈一样。相关函数：copy_pcb_vaddrbitmap_stack0
虚拟地址池，每个进程都拥有独立的内存空间，其虚拟地址是虚拟地址池来管理的。相关函数：copy_pcb_vaddrbitmap_stack0
页表，让进程拥有独立的内存空间。相关函数：create_page_dir

克隆后的进程要如何执行：将新进程加入到就绪队列就可以了，当然要提前把相关的栈准备好。相关函数：build_child_stack

注意：复制完 PCB 后，要记得文件描述符所对应打开的文件的次数要增加。相关函数：update_inode_open_cnts

代码

get_a_page_without_opvaddrbitmap

kernel/memory.c

// 安装 1页 大小的 vaddr，专门针对 fork 时虚拟地址位图无需操作的情况
void* get_a_page_without_opvaddrbitmap(enum pool_flags pf, uint32_t vaddr) {
    struct pool* mem_pool = pf & PF_KERNEL ? &kernel_pool : &user_pool;
    lock_acquire(&mem_pool -> lock);
    void* page_phyaddr = palloc(mem_pool);
    if(page_phyaddr == NULL) {
        lock_release(&mem_pool -> lock);
        return NULL;
    }
    page_table_add((void*) vaddr, page_phyaddr);
    lock_release(&mem_pool -> lock);
    return (void*) vaddr;
}

copy_pcb_vaddrbitmap_stack0

userprog/fork.c

// 将父进程的 PCB、虚拟地址位图拷贝给子进程
static int32_t copy_pcb_vaddrbitmap_stack0(struct task_struct* child_thread, struct task_struct* parent_thread) {
    // 复制 PCB 所在的整个页，里面包含了进程 PCB 信息以及特权级0的栈
    memcpy(child_thread, parent_thread, PG_SIZE);
    child_thread -> pid = fork_pid();
    child_thread -> elapsed_ticks = 0;
    child_thread -> status = TASK_READY;
    child_thread -> ticks = child_thread -> priority; // 重置时间片，将其填满
    child_thread -> parent_pid = parent_thread -> pid;
    child_thread -> general_tag.prev = child_thread -> general_tag.next = NULL;
    child_thread -> all_list_tag.prev = child_thread -> all_list_tag.next = NULL;
    block_desc_init(child_thread -> u_block_desc);
    // 复制父进程的虚拟内存池位图
    uint32_t bitmap_pg_cnt = DIV_ROUND_UP((0xc0000000 - USER_VADDR_START) / PG_SIZE / 8, PG_SIZE);
    void* vaddr_btmp = get_kernel_pages(bitmap_pg_cnt);
    if(vaddr_btmp == NULL) return -1;
    // 将父进程的虚拟内存池位图复制一份给子进程, child_thread 其实也可以换成 parent_thread
    memcpy(vaddr_btmp, child_thread -> userprog_vaddr.vaddr_bitmap.bits, bitmap_pg_cnt * PG_SIZE);
    child_thread -> userprog_vaddr.vaddr_bitmap.bits = vaddr_btmp;
    ASSERT(strlen(child_thread -> name) < 11); // pcb.name 长度为 16，为避免下面 strcat 越界
    strcat(child_thread -> name, "_fork");
    return 0;
}

copy_body_stack3

// 复制子进程的进程体（代码和数据）以及用户栈
static void copy_body_stack3(struct task_struct* child_thread, struct task_struct* parent_thread, void* buf_page) {
    uint8_t* vaddr_btmp = parent_thread -> userprog_vaddr.vaddr_bitmap.bits;
    uint32_t btmp_byte_len = parent_thread -> userprog_vaddr.vaddr_bitmap.btmp_bytes_len;
    uint32_t vaddr_start = parent_thread -> userprog_vaddr.vaddr_start;
    uint32_t idx_byte = 0;
    uint32_t idx_bit = 0;
    uint32_t prog_vaddr = 0;

    // 在父进程的用户空间中查找已有数据的页
    while(idx_byte < btmp_byte_len) {
        if(vaddr_btmp[idx_byte]) { // 逐个字节判断
            idx_bit = 0;
            while(idx_bit < 8) { // 逐个位判断
                if((BITMAP_MASK << idx_bit) & vaddr_btmp[idx_byte]) {
                    // 计算虚拟地址
                    prog_vaddr = (idx_byte * 8 + idx_bit) * PG_SIZE + vaddr_start;

                    // 将父进程所在用户空间中的数据复制到内核缓冲区 buf_page
                    // 目的是下面切换到子进程的页表后，还能访问到父进程的数据
                    memcpy(buf_page, (void*) prog_vaddr, PG_SIZE);

                    // 将页表切换到子进程，目的是避免下面申请内存的函数将 pte 及 pde 安装到父进程的页表中
                    page_dir_activate(child_thread);
                    // 申请虚拟地址 prog_vaddr
                    get_a_page_without_opvaddrbitmap(PF_USER, prog_vaddr);

                    // 从内核缓冲区中将父进程数据复制到子进程的用户空间中
                    memcpy((void*) prog_vaddr, buf_page, PG_SIZE);

                    // 恢复父进程页表
                    page_dir_activate(parent_thread);
                }
                idx_bit++;
            }
        }
        idx_byte++;
    }
}

将父进程用户空间中的数据复制到子进程的用户空间。但各用户进程的低3G空间是独立的，因此用户进程不能互相访问彼此的空间，但高1G是内核空间，内核空间是所有用户共享的，因此要把数据从一个进程拷贝到另一个进程，必须要借助内核空间作为数据中转，即先父进程用户空间的数据先复制到位于内核空间的 buf_page 中，最后再将 buf_page 复制到子进程的用户空间中。

这里采用一页一页对拷的形式，即父进程找到一页，子进程就申请一页空间，然后对拷。但不同进程之所以有单独的虚拟地址空间，是因为它们各自有单独的页目录，我们分配内存时，会在页表中产生新的 PTE，若申请的内存跨越 4MB 的页表大小，则还需要在页目录表中创建 PDE，既然是为子进程分配内存，那么就要保证这些 PTE 和 PDE 是创建在子进程的页目录表中的。所以在将 buf_page 的数据拷贝到子进程之前，一定要将页表替换为子进程的页表。

build_child_stack

// 为子进程构建 thread_stack 和修改返回值
static int32_t build_child_stack(struct task_struct* child_thread) {
    // -----------------------
    // 使子进程 pid 返回 0
    // -----------------------
    // 获取子进程0级栈栈顶
    struct intr_stack* intr_0_stack = (struct intr_stack*)((uint32_t) child_thread + PG_SIZE - sizeof(struct intr_stack));
    // 修改子进程的返回值为 0
    intr_0_stack -> eax = 0;

    // 为 switch_to 构建 struct thread_stack，构建在 intr_stack 之下的空间
    uint32_t* ret_addr_in_thread_stack  = (uint32_t*)intr_0_stack - 1;

    /***   这三行不是必要的,只是为了梳理thread_stack中的关系 ***/
    uint32_t* esi_ptr_in_thread_stack = (uint32_t*)intr_0_stack - 2; 
    uint32_t* edi_ptr_in_thread_stack = (uint32_t*)intr_0_stack - 3; 
    uint32_t* ebx_ptr_in_thread_stack = (uint32_t*)intr_0_stack - 4; 
    /**********************************************************/

    /* ebp在thread_stack中的地址便是当时的esp(0级栈的栈顶),
    即esp为"(uint32_t*)intr_0_stack - 5" */
    uint32_t* ebp_ptr_in_thread_stack = (uint32_t*)intr_0_stack - 5; 

    // 更新内存中的数据
    // switch_to 的返回地址更新为 intr_exit，直接从中断返回
    *ret_addr_in_thread_stack = (uint32_t) intr_exit;

    /* 下面这两行赋值只是为了使构建的thread_stack更加清晰,其实也不需要,
     * 因为在进入intr_exit后一系列的pop会把寄存器中的数据覆盖 */
    *ebp_ptr_in_thread_stack = *ebx_ptr_in_thread_stack =\
    *edi_ptr_in_thread_stack = *esi_ptr_in_thread_stack = 0;
   /*********************************************************/

    // 把构建的 thread_stack 的栈顶作为 switch_to 恢复数据时的栈顶
    child_thread -> self_kstack = ebp_ptr_in_thread_stack;
    return 0;
}

update_inode_open_cnts

// 更新 inode 打开数，其实就是更新文件被打开的次数
static void update_inode_open_cnts(struct task_struct* thread) {
    int32_t local_fd = 3, global_fd = 0;
    while(local_fd < MAX_FILES_OPEN_PER_PROC) {
        global_fd = thread -> fd_table[local_fd];
        ASSERT(global_fd < MAX_FILE_OPEN);
        if(global_fd != -1)
            file_table[global_fd].fd_inode->i_open_cnt++;
        local_fd++;
    }
}

copy_process

// 拷贝父进程本身所占资源给子进程（对前面函数的封装罢了）
static int32_t copy_process(struct task_struct* child_thread, struct task_struct* parent_thread) {
    // 内核缓冲区，作为父进程用户空间的数据复制到子进程用户空间的中转
    void* buf_page = get_kernel_pages(1);
    if(buf_page == NULL) return -1;

    // 复制父进程的 PCB、虚拟地址位图、内核栈到子进程
    if(copy_pcb_vaddrbitmap_stack0(child_thread, parent_thread) == -1) return -1;

    // 为子进程创建页表，此页表仅包含内核空间
    child_thread -> pgdir = create_page_dir();
    if(child_thread -> pgdir == NULL) return -1;

    // 复制父进程的进程体及用户栈给子进程
    copy_body_stack3(child_thread, parent_thread, buf_page);

    // 构建子进程的 thread_stack 和修改返回值 pid
    build_child_stack(child_thread);

    // 更新文件(inode)被打开的次数
    update_inode_open_cnts(child_thread);

    mfree_page(PF_KERNEL, buf_page, 1);

    return 0;
}

sys_fork

// fork 子进程，内核线程不可直接调用
pid_t sys_fork(void) {
    struct task_struct* parent_thread = running_thread();
    struct task_struct* child_thread = get_kernel_pages(1);
    if(child_thread == NULL) return -1;

    ASSERT(INTR_OFF == intr_get_status() && parent_thread -> pgdir != NULL);

    if(copy_process(child_thread, parent_thread) == -1) return -1;

    // 添加到就绪队列和所有线程队列，子进程由调度器安排运行
    ASSERT(!elem_find(&thread_ready_list, &child_thread->general_tag));
    list_append(&thread_ready_list, &child_thread -> general_tag);
    ASSERT(!elem_find(&thread_all_list, &child_thread->all_list_tag));
    list_append(&thread_all_list, &child_thread -> all_list_tag);

    return child_thread -> pid; // 父进程返回子进程的 pid
}

添加 fork 系统调用与实现 init 进程

添加 fork 系统调用

这个没啥好说，老套路走一遍就行。

实现 init 进程

在 Linux 中，init 是用户级进程，它是第一个启动的程序，因此它的 pid=1，后续的所有进程都是它的孩子，故 init 是所有进程父进程，所以它还负责所有子进程的资源回收。

既然 init 是父进程，也就是说它要主动调用 fork 才能派生出子子孙孙，所以在实现它之前要先实现 fork 系统调用。

kernel/main.c

void init(void);

int main(void) {
   put_str("I am kernel.\n");
   init_all();

   while(1);
   return 0;
}

// init 进程
void init(void) {
   uint32_t ret_pid = fork();
   if(ret_pid)
      printf("i am father, my pid is %d, child pid is %d\n", getpid(), ret_pid);
   else
      printf("i am child, my pid is %d, ret pid is %d\n", getpid(), ret_pid);
   while(1);
}

thread/thread.c

extern void init(void);
...
// 初始化线程环境
void thread_init(void) {
    put_str("thread_init start\n");
    list_init(&thread_ready_list);
    list_init(&thread_all_list);
    lock_init(&pid_lock);

    // 线创建第一个用户进程 init
    process_execute(init, "init"); // 由于是第一个创建的进程，因此该进程 pid = 1

    // 将当前 main 函数创建为线程
    make_main_thread();

    // 创建 idle 线程
    idle_thread = thread_start("idle", 10, idle, NULL);
    put_str("thead_init done\n");
}

shell 的前置准备工作

三个新的j基础系统调用：

read 系统调用，获取键盘输入。
putchar 系统调用，输出字符。
clear 系统调用，清空屏幕。

其中 clear 的内核实现是 cls_screen，采用纯汇编实现，代码位于：kernel/print.S

这里就贴出 read 的内核实现函数：

fs/fs.c

// 从文件描述符 fd 指向的文件中读取 count 个字节到 buf，成功返回读取的字节数，到文末返回-1
int32_t sys_read(int32_t fd, void* buf, uint32_t count) {
    ASSERT(buf != NULL);
    int32_t ret = -1;
    if(fd < 0 || fd == stdout_no || fd == stderr_no) { // 标准输出流
        printk("sys_read: fd error.\n");
    } else if(fd == stdin_no) { // 标准输入流
        char* buffer = buf;
        uint32_t bytes_read = 0;
        while(bytes_read < count) { // 不断的从输入缓冲区中读取数据
            *buffer = ioq_getchar(&kdb_buf); // 从键盘缓冲区 kdb_buf 中读取1个字节
            bytes_read++;
            buffer++;
        }
        ret = (bytes_read == 0 ? -1 : (int32_t) bytes_read);
    } else { // 文件读取
        uint32_t _fd = fd_local2global(fd);
        ret = file_read(&file_table[_fd], buf, count);
    }
    return ret;
}

若干个系统操作，添加完后总共有：

enum SYSCALL_NR {
   SYS_GETPID,
   SYS_WRITE,
   SYS_MALLOC,
   SYS_FREE,
   SYS_FORK,
   SYS_READ,
   SYS_PUTCHAR,
   SYS_CLEAR,
   SYS_GETCWD,
   SYS_OPEN,
   SYS_CLOSE,
   SYS_LSEEK,
   SYS_UNLINK,
   SYS_MKDIR,
   SYS_OPENDIR,
   SYS_CLOSEDIR,
   SYS_CHDIR,
   SYS_RMDIR,
   SYS_READDIR,
   SYS_REWINDDIR,
   SYS_STAT,
   SYS_PS // ps 指令
};

ps 指令的实现：

思路：遍历所有进程队列 thread_all_list，输出 PCB，即 task_struct 中的相关信息。
代码位于：thread/thread.c
相关函数：pad_print 填充函数（控制输出的格式），elem2thread_info 核心函数，sys_ps 对 ele2thread_info 函数的封装。

实现一个简单的 shell

操作系统如果想和用户交互，那么就必须知道用户的输入，知道了输入那么就要做出相应的输出，此乃交互。各种操作系统的交互方式不过只是提供了一个“外壳”供用户操作，Window 下有 GUI 图形化界面和命令行窗口，而 Linux 则是通过命令行的形式和用户交互，只是 Linux 的叫法更加直接，就直接称为“Shell”（外壳的英文）。

readline / print_prompt 函数

shell/shell.c

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

// 从键盘缓冲区中最多读入 count 个字节到 buf
static void readline(char* buf, int32_t count) {
    assert(buf != NULL && count > 0);
    char* pos = buf;
    while(read(stdin_no, pos, 1) != -1 && (pos - buf) < count) {
        switch(*pos) {
            // 清空屏幕，保留当前输入
            case 'l' - 'a':
                *pos = 0; // 重置
                clear(); // 清空屏幕
                print_prompt(); // 重新打印提示符
                printf("%s", buf); // 重新将之前输入的命令再次打印
                break;
            // 清空当前输入
            case 'u' - 'a':
                while(buf != pos) {
                    putchar('\b');
                    *(pos--) = 0;
                }
                break;
            case '\n':
            case '\r':
                *pos = 0;
                putchar('\n');
                return;
            case '\b':
                if(buf[0] != '\b') {
                    --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");
}

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

Ctrl+u：清空屏幕，但保留正在输入的指令。

Ctrl+l：清空当前输入。

简单说一下，两者的实现都是 u-a 和 l-a 各自所得差形成的属于 ASC 码表中的不可见字符，因此不会产生可见字符，利用这个特点作为快捷键。

cmd_str 分割输入的指令，相对于高级语言中字符串的 split 函数。

例如：ls /opt -a 解析完后变成：[ls, /opt, -a]

shell/shell.c

// 将 cmd_str 字符串以 token 字符分割
static int32_t cmd_parse(char* cmd_str, char** argv, char token) {
    assert(cmd_str != NULL);
    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 dir  */
        if(*next == 0) break;
        argv[argc] = next;
        // 获取整个有效参数
        while(*next && *next != token) next++;
        // 若未结束
        if(*next) *next++ = 0; // 则以字符串结束符0来表示一个单词的结束
        // 避免越界
        if(argc > MAX_ARG_NR) return -1;
        argc++; // 下一个参数
    }
    return argc;
}

解析路径

我们经常在终端中使用相对路径 . 和 ..，我们需要将这些路径转换成绝对路径 /**/**，这样便于我们操作。

shell/buildin_cmd.c

// 将路径 old_abs_path 中的 .. 和 . 转换成实际路径存入 new_abs_path
static void wash_path(char* old_abs_path, char* new_abs_path) {
    assert(old_abs_path[0] == '/');
    char name[MAX_FILE_NAME_LEN] = {0};
    char* sub_path = old_abs_path;
    sub_path = path_parse(sub_path, name);

    if(name[0] == 0) { // 只键入了 /
        new_abs_path[0] = '/';
        new_abs_path[1] = 0;
        return;
    }

    new_abs_path[0] = 0;
    strcat(new_abs_path, "/");
    while(name[0]) {
        if(!strcmp("..", name)) { // 若解析出来的目录是 ..
            char* slash_ptr = strrchr(new_abs_path, '/');
            if(slash_ptr != new_abs_path) { // 若 .. 后还未到达顶层，例如 /a/b .. 后为 /a
                *slash_ptr = 0;
            } else { // 若 .. 后到达了顶层，例如 /a .. 后为 /
                *(slash_ptr + 1) = 0;
            }
        } else if(strcmp(".", name)) { // 若解析出来的目录不是 .
            if(strcmp(new_abs_path, "/")) { // 判断顶层是否为 /
                strcat(new_abs_path, "/"); // 不是，则追加，这个判断是为了避免开头变成 // 的情况
            }
            // 追加目录
            strcat(new_abs_path, name);
        } // 若解析出来的目录是 . 则无需任何操作

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

// 将 path 处理成不含 .. 和 . 的绝对路径，保存到 final_path 中，path 是用户键入的
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) {
            if(!((abs_path[0] == '/') && (abs_path[1] == 0))) {
                strcat(abs_path, "/");
            }
        }
    }
    // 将键入的路径 path 拼接到当前层的绝对路径后面
    strcat(abs_path, path);
    // 将 abs_path 中的 . or .. 转为不含 . or .. 的绝对路径 final_path
    wash_path(abs_path, final_path);
}

实现 ls、c、mkdir、ps、rm 等指令

命令分为两类：外部命令、内部命令。

外部命令：存储在文件系统上的外部程序，执行该命令实际上是从文件系统上加载该程序到内存中运行，也就是说外部命令会以进程的方式执行。例如：ls，存储路径为 /bin/ls。

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

**内部命令的编写规则： **

命名方式：前缀 buildin_ + 命令名
形参均是 argc 和 argv，argv 是数组，其 argc 是数组长度，即命令参数的个数。
函数实现是调用同功能的系统调用实现的，如 buildin_cd 是调用系统调用 chdir 完成的。
在进行系统调用前，调用函数 make_clear_abs_path 把相对路径转为绝对路径。

这里就只贴出 ls 和 ps 的构建函数 shell/buildin_cmd.c

// ls 命令的内建函数
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;
    uint32_t arg_idx = 1; // 跨过argv[0],因为argv[0]=ls

    while(arg_idx < argc) {
        if(argv[arg_idx][0] == '-') { // 若是参数，则前缀为 -
            if(!strcmp("-l", argv[arg_idx])) { // 参数 -l
                long_info = true;
            } else if(!strcmp("-h", argv[arg_idx])) { // 参数 -h
                printf("usage: -l list all infomation about the file.\n-h for help\nlist all files in the current dirctory if no option\n");
                return;
            } else { // 只支持 -h -l 两个参数
                printf("ls: invalid option %s\nTry `ls -h' for more information.\n", argv[arg_idx]);
                return;
            }
        } else { // 得到路径参数值
            if(arg_path_nr == 0) {
                pathname = argv[arg_idx];
                arg_path_nr = 1;
            } else {
                printf("ls: only support one path\n");
                return;
            }
        }
        arg_idx++;
    }

    if(pathname == NULL) { // 若没有给明确的路径，则默认当前路径为路径参数
        if(getcwd(final_path, MAX_PATH_LEN) != NULL) {
            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);

        // 保证路径为 /a/b/c/ 而不是 /a/b/c 这是为了便于后面 stat 读取
        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);
    }
}

// mkdir 命令内建函数
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)) return ret; // 不能创建根目录
        if(mkdir(final_path) == 0) 
            ret = 0;
        else
            printf("mkdir: create directory %s failed.\n", argv[1]);
    }
    return ret;
}

// ps 命令内建函数
void buildin_ps(uint32_t argc, char** argv UNUSED) {
    if(argc != 1) {
        printf("ps: no argument support!\n");
        return;
    }
    ps(); // 系统调用，内核实现是 sys_ps，位于 thread/thread.c
}

shell 主程序

// 存储输入的命令
static char cmd_line[MAX_PATH_LEN] = {0};
char final_path[MAX_PATH_LEN] = {0}; // 用于洗路径时的缓冲

// 记录当前操作的所在目录，每次 cd 都会更新这个路径
char cwd_cache[MAX_PATH_LEN] = {0};

char* argv[MAX_ARG_NR]; // argv 必须为全局变量，为了以后 exec 的程序可以访问到参数
int32_t argc = -1; // 参数个数

...

// 简单的 shell
void my_shell(void) {
    cwd_cache[0] = '/';
    cwd_cache[1] = 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;
        }
        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");
    }
    panic("my_shell: should not be here");
}