《操作系统真象还原》第十五章系统交互

kanshanxd

已于 2023-09-17 08:22:39 修改

阅读量697

点赞数

分类专栏：操作系统真象还原笔记文章标签： linux

于 2023-09-13 09:07:53 首次发布

本文链接：https://blog.csdn.net/kanshanxd/article/details/132844915

版权

操作系统真象还原笔记专栏收录该内容

16 篇文章 128 订阅

订阅专栏

配合视频学习体验更佳！
a小节：https://www.bilibili.com/video/BV1gk4y1w7u1/?vd_source=701807c4f8684b13e922d0a8b116af31
b小节：https://www.bilibili.com/video/BV1Mm4y1N7fS/?vd_source=701807c4f8684b13e922d0a8b116af31
c小节：https://www.bilibili.com/video/BV1Th4y1A7xw/?vd_source=701807c4f8684b13e922d0a8b116af31
d小节：https://www.bilibili.com/video/BV1cm4y1N7XG/?vd_source=701807c4f8684b13e922d0a8b116af31
e小节：https://www.bilibili.com/video/BV1qh4y1Y7gE/?vd_source=701807c4f8684b13e922d0a8b116af31
f小节：https://www.bilibili.com/video/BV1Su4y1675s/?vd_source=701807c4f8684b13e922d0a8b116af31
g小节：https://www.bilibili.com/video/BV1RP41187cD/?vd_source=701807c4f8684b13e922d0a8b116af31
h小节：https://www.bilibili.com/video/BV1mH4y1D7Ze/?vd_source=701807c4f8684b13e922d0a8b116af31
i小节：https://www.bilibili.com/video/BV1rP411t7bd/?vd_source=701807c4f8684b13e922d0a8b116af31
j小节：https://www.bilibili.com/video/BV1Jk4y1F7ob/?vd_source=701807c4f8684b13e922d0a8b116af31
k小节：https://www.bilibili.com/video/BV1pm4y1N7CH/?vd_source=701807c4f8684b13e922d0a8b116af31

代码仓库：https://github.com/xukanshan/the_truth_of_operationg_system

小节a：
fork

这一小节，我们要实现fork

fork是用于复制进程的，也就是根据父进程复制出一个子进程。但是由于他们本质是两个进程，所以还是有很多不相同的地方，比如独立的资源，单独的pid之类的。

有这样一段代码

#include <unistd.h>
#include <stdio.h>
int main() {
	int pid = fork();
	if (pid == -1)
		return 1;
	printf("who am I ? my pid is %d\n", getpid());
	sleep (5) ;
	return 0;
}

当执行完fork()后，fork之后的代码会由于属于两个进程（调用fork的主进程与被复制出来的子进程）而被执行两次（自然是主进程与子进程各执行一次）。

由于fork复制进程，而且复制步骤是在fork自己的代码结束前就完成（假设fork代码1000行，第800行就完成了复制），所以fork代码最后一行的return 就会被执行两次。对于父进程来说，fork会返回子进程pid。对于子进程来说，fork会返回0。我们就可以根据fork返回的不同值来区别父子进程，以让父子进程执行不同的代码。比如：

if (pid) {
	printf("I am father, my pid is d\n",getpid());
	sleep(5);
	return 0;
} 
else {
	printf("I am child, my pid is d\n",getpid());
	sleep(5);
	return 0;
}

现在开始实现fork，先实现一些基础设施函数

fork_pid就是封装了allocate_pid，因为allocate_pid之前实现的时候有关键字static，所以作者为了不去修改这个，就采取了进一步封装

修改（myos/thread/thread.c）

/* fork进程时为其分配pid,因为allocate_pid已经是静态的,别的文件无法调用.
不想改变函数定义了,故定义fork_pid函数来封装一下。*/
pid_t fork_pid(void)
{
    return allocate_pid();
}

函数声明，修改（myos/thread/thread.h）

pid_t fork_pid(void);

get_a_page_without_opvaddrbitmap用于为指定的虚拟地址创建物理页映射，与get_a_page相比，少了操作进程pcb中的虚拟内存池位图

修改（myos/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;
}

函数声明，修改（myos/kernel/memory.h）

void *get_a_page_without_opvaddrbitmap(enum pool_flags pf, uint32_t vaddr);

copy_pcb_vaddrbitmap_stack0用于根据传入的父子进程pcb指针，先复制整个父进程pcb内容到子进程pcb中，然后再针对设置子进程pcb内容，包含：pid, elapsed_ticks, status, ticks, parent_pid, general_tag, all_list_tag, u_block_desc, userprog_vaddr（让子进程拥有自己的用户虚拟地址空间内存池，但是其位图是拷贝父进程的）。这个过程中，内核栈中的内容被完全拷贝了。

（myos/userprog/fork.c）

#include "fork.h"
#include "stdint.h"
#include "global.h"
#include "thread.h"
#include "string.h"
#include "debug.h"
#include "process.h"

/* 将父进程的pcb、虚拟地址位图拷贝给子进程 */
static int32_t copy_pcb_vaddrbitmap_stack0(struct task_struct *child_thread, struct task_struct *parent_thread)
{
    /* a 复制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);
    /* b 复制父进程的虚拟地址池的位图 */
    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->userprog_vaddr.vaddr_bitmap.bits还是指向父进程虚拟地址的位图地址
     * 下面将child_thread->userprog_vaddr.vaddr_bitmap.bits指向自己的位图vaddr_btmp */
    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用于根据传入的父子进程pcb指针，复制进程的用户空间堆与栈中的数据。核心原理：遍历父进程的userprog_vaddr当中的虚拟地址空间位图，来判断父进程的用户虚拟地址空间中是否有数据。如果有，就拷贝到内核空间的中转区中，然后调用page_dir_activate，切换到子进程页表，调用get_a_page_without_opvaddrbitmap为子进程特定虚拟地址申请一个物理页（其中并不涉及子进程userprog_vaddr中的位图修改），然后从内核中转区中把数据拷贝到子进程相同的虚拟地址内。

修改（myos/userprog/fork.c）

extern void intr_exit(void);

/* 复制子进程的进程体(代码和数据)及用户栈 */
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_bytes_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_bytes_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;
                    /* 下面的操作是将父进程用户空间中的数据通过内核空间做中转,最终复制到子进程的用户空间 */

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

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

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

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

build_child_stack用于修改子进程的返回值和设定其内核栈。子进程返回0原理：我们之前构建系统调用机制时，系统调用的返回值会放入内核栈中的中断栈（intr_stack）eax的位置，这样中断退出（intr_exit）就会push eax时将返回值放入eax中。所以我们将子进程的内核栈中断栈eax的值改成0。

我们的子进程上机运行是通过让自己就绪之后，等待某个时钟中断调用switch_to函数上机

   mov eax, [esp + 24]		 
   mov esp, [eax]		 
   pop ebp
   pop ebx
   pop edi
   pop esi	
   ret

switch_to会从子进程的pcb中找到内核栈的栈顶放入esp中，然后执行switch_to的那4条pop和ret指令，我们现在经过拷贝后的子进程内核栈布局如图：

在这里插入图片描述
所以，我们直接去用子进程这样的内核栈布局肯定不行，要人为去修改成

也就是在intr_stack前面增加switch_to栈（也就是书p694提到的thread_stack），让pcb最顶端的esp指向switch_to栈栈顶，并且switch_to栈中返回地址要填上intr_exit函数地址。这样执行ret之后，就能去执行intr_exit，并利用intr_stack执行中断返回，由于intr_stack中拷贝了父进程进入中断时的用户栈信息，cs: ip 信息，所以中断退出后，子进程将会继续执行父进程之后的代码。

修改（myos/userprog/fork.c）

/* 为子进程构建thread_stack和修改返回值 */
static int32_t build_child_stack(struct task_struct *child_thread)
{
    /* a 使子进程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;

    /* b 为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由于fork出来的子进程几乎和父进程一样，所以父进程打开的文件，子进程也要打开。所以，父进程的全局打开文件结构中记录文件打开的次数都需要 + 1。原理：遍历进程pcb（父，子均可）中的文件描述符，找到对应的全局打开文件结构索引就行了

修改（myos/user/fork.c）

#include <file.h>

/* 更新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_cnts++;
        }
        local_fd++;
    }
}

copy_process就是fork时用于复制父进程资源的函数，就是前面函数的封装。原理：调用copy_pcb_vaddrbitmap_stack0复制父进程的pcb、虚拟地址位图、内核栈到子进程；然后调用create_page_dir为子进程创建页表，这个页表已经包含了内核地址空间的映射；然后调用copy_body_stack3复制进程的用户空间堆与栈中的数据；然后调用build_child_stack用于修改子进程的返回值和设定其内核栈；最后调用update_inode_open_cnts更新inode的打开数。

修改（myos/user/fork.c）

/* 拷贝父进程本身所占资源给子进程 */
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;
    }

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

    /* b 为子进程创建页表,此页表仅包括内核空间 */
    child_thread->pgdir = create_page_dir();
    if (child_thread->pgdir == NULL)
    {
        return -1;
    }

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

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

    /* e 更新文件inode的打开数 */
    update_inode_open_cnts(child_thread);

    mfree_page(PF_KERNEL, buf_page, 1);
    return 0;
}

sys_fork用于复制出一个进程，并将其加入就绪队列

（myos/userprog/fork.c）

#include "interrupt.h"

/* fork子进程,内核线程不可直接调用 */
pid_t sys_fork(void)
{
    struct task_struct *parent_thread = running_thread();
    struct task_struct *child_thread = get_kernel_pages(1); // 为子进程创建pcb(task_struct结构)
    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
}

函数声明（myos/userprog/fork.h）

#ifndef __USERPROG_FORK_H
#define __USERPROG_FORK_H

#include "stdint.h"

pid_t sys_fork(void);

#endif

然后我们添加fork系统调用

添加系统调用号，修改（myos/lib/user/syscall.h）

#include "thread.h"

enum SYSCALL_NR {
   SYS_GETPID,
   SYS_WRITE,
   SYS_MALLOC,
   SYS_FREE,
   SYS_FORK
};

用户态系统调用入口，修改（myos/lib/user/syscall.c）

#include "thread.h"

/* 派生子进程,返回子进程pid */
pid_t fork(void)
{
    return _syscall0(SYS_FORK);
}

函数声明，修改（myos/lib/user/syscall.h）

pid_t fork(void);

系统调用表中添加实际系统调用函数，修改（myos/userprog/syscall-init.c）

#include "fork.h"

/* 初始化系统调用 */
void syscall_init(void) {
	put_str("syscall_init start\n");
	syscall_table[SYS_GETPID] = sys_getpid;
	syscall_table[SYS_WRITE] = sys_write;
	syscall_table[SYS_MALLOC] = sys_malloc;
   	syscall_table[SYS_FREE] = sys_free;
    syscall_table[SYS_FORK] = sys_fork;
	put_str("syscall_init done\n");
}

init进程：我们学习Linux做法，让init作为pid为1的用户进程，所以必须要放在主线程创建之创建。后续所有的进程都是它的孩子，它还负责所有子进程的资源回收

修改（myos/thread/thread.c/thread_init），让init的pid为1

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");         // 放在第一个初始化,这是第一个进程,init进程的pid为1
    /* 将当前main函数创建为线程 */
    make_main_thread();
    /* 创建idle线程 */
    idle_thread = thread_start("idle", 10, idle, NULL);
    put_str("thread_init done\n");
}

测试代码与init进程实现

（myos/kernel/main.c）

#include "print.h"
#include "init.h"
#include "fork.h"
#include "stdio.h"
#include "syscall.h"

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)
        ;
}

编译运行会报页错误，经过排查，修改（myos/thread/thread.c/thread_create）

    /* 先预留中断使用栈的空间,可见thread.h中定义的结构 */
    // pthread->self_kstack -= sizeof(struct intr_stack);  //-=结果是sizeof(struct intr_stack)的4倍
    // self_kstack类型为uint32_t*，也就是一个明确指向uint32_t类型值的地址，那么加减操作，都是会是sizeof(uint32_t) = 4 的倍数
    pthread->self_kstack = (uint32_t *)((int)(pthread->self_kstack) - sizeof(struct intr_stack));

    /* 再留出线程栈空间,可见thread.h中定义 */
    // pthread->self_kstack -= sizeof(struct thread_stack);
    pthread->self_kstack = (uint32_t *)((int)(pthread->self_kstack) - sizeof(struct thread_stack));

为

    /* 先预留中断使用栈的空间,可见thread.h中定义的结构 */
    pthread->self_kstack -= sizeof(struct intr_stack);  //-=结果是sizeof(struct intr_stack)的4倍
    // self_kstack类型为uint32_t*，也就是一个明确指向uint32_t类型值的地址，那么加减操作，都是会是sizeof(uint32_t) = 4 的倍数
    // pthread->self_kstack = (uint32_t *)((int)(pthread->self_kstack) - sizeof(struct intr_stack));

    /* 再留出线程栈空间,可见thread.h中定义 */
    pthread->self_kstack -= sizeof(struct thread_stack);
    // pthread->self_kstack = (uint32_t *)((int)(pthread->self_kstack) - sizeof(struct thread_stack));

典型的程序依靠错误运行，暂不知道为何错误

小节b：

获取键盘输入

sys_read用于从指定文件描述符中获取conunt字节数据，如果文件描述符是stdin_no，那么直接循环调用ioq_getchar从键盘获取内容，否则调用file_read从文件中读取内容

sys_put_char用于向屏幕输出一个字符

修改（myos/fs/fs.c/sys_read）

#include "keyboard.h"
#include "ioqueue.h"

/* 从文件描述符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(&kbd_buf);
            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;
}

/* 向屏幕输出一个字符 */
void sys_putchar(char char_asci)
{
    console_put_char(char_asci);
}

函数声明，修改（myos/fs/fs.h）

void sys_putchar(char char_asci);

cls_screen用于清空屏幕，核心原理：向代表80列×25行，共2000个字符位置的内存写入空格符，然后设定光标位置为左上角（即位置0）

修改（myos/lib/kernel/print.S）

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

函数声明，修改（myos/lib/kernel/print.h）

void cls_screen(void);

将sys_read、sys_putchar、cls_screen做成系统调用

添加系统调用号，修改（myos/lib/user/syscall.h）

enum SYSCALL_NR
{
    SYS_GETPID,
    SYS_WRITE,
    SYS_MALLOC,
    SYS_FREE,
    SYS_FORK,
    SYS_READ,
    SYS_PUTCHAR,
    SYS_CLEAR
};

准备好read、put_char与clear的用户态入口，修改（myos/lib/user/syscall.c）

/* 从文件描述符fd中读取count个字节到buf */
int32_t read(int32_t fd, void *buf, uint32_t count)
{
    return _syscall3(SYS_READ, fd, buf, count);
}

/* 输出一个字符 */
void putchar(char char_asci)
{
    _syscall1(SYS_PUTCHAR, char_asci);
}

/* 清空屏幕 */
void clear(void)
{
    _syscall0(SYS_CLEAR);
}

然后声明函数，修改（myos/lib/user/syscall.h）

int32_t read(int32_t fd, void* buf, uint32_t count);
void putchar(char char_asci);
void clear(void);

将系统调用实际执行程序，添加至系统调用表中，修改（myos/lib/user/syscall.c）

/* 初始化系统调用 */
void syscall_init(void)
{
    put_str("syscall_init start\n");
    syscall_table[SYS_GETPID] = sys_getpid;
    syscall_table[SYS_WRITE] = sys_write;
    syscall_table[SYS_MALLOC] = sys_malloc;
    syscall_table[SYS_FREE] = sys_free;
    syscall_table[SYS_FORK] = sys_fork;
    syscall_table[SYS_READ] = sys_read;
    syscall_table[SYS_PUTCHAR] = sys_putchar;
    syscall_table[SYS_CLEAR] = cls_screen;
    put_str("syscall_init done\n");
}

shell是用户与操作系统之间交互的接口，我们天天使用的Linux终端就是一个shell。它的功能就是获取用户的键盘输入，然后从中解析命令，然后根据命令去执行对应的动作。

print_prompt用于输出命令提示符，也就是我们在终端输入命令时，前面那串字符

（myos/shell/shell.c）

#include "shell.h"
#include "stdio.h"


char cwd_cache[64] = {0};

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

readline循环调用read从键盘输入缓冲读取字符，每次读取一个，最多读入count个字节到buf。根据每次读入的值不同，处理方式也不同：/n，/r表示按下enter键，用户输入命令结束，缓冲区输入个0表示命令字符串结尾。/b表示按下退格键，就删除一个字符。普通字符就直接读入buf。每种字符都调用了putchar进行打印，是因为我们的键盘中断处理函数已经删除打印功能。

修改（myos/shell/shell.c）

#include "file.h"
#include "debug.h"
#include "syscall.h"

/* 从键盘缓冲区中最多读入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 '\n':
        case '\r':
            *pos = 0; // 添加cmd_line的终止字符0
            putchar('\n');
            return;

        case '\b':
            if (buf[0] != '\b')
            {          // 阻止删除非本次输入的信息
                --pos; // 退回到缓冲区cmd_line中上一个字符
                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");
}

my_shell就是shell进程，不断循环：调用print_prompt输出命令提示符，然后调用readline获取用户输入

修改（myos/shell/shell.c）

#include "string.h"

#define cmd_len 128 // 最大支持键入128个字符的命令行输入
static char cmd_line[cmd_len] = {0};

/* 简单的shell */
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;
        }
    }
    PANIC("my_shell: should not be here");
}

函数声明，（myos/shell/shell.h）

#ifndef __KERNEL_SHELL_H
#define __KERNEL_SHELL_H

void print_prompt(void);
void my_shell(void);

#endif

我们让init来开启shell，修改（myos/kernel/main.c）

#include "print.h"
#include "init.h"
#include "fork.h"
#include "stdio.h"
#include "syscall.h"
#include "debug.h"
#include "shell.h"
#include "console.h"

void init(void);

int main(void) {
   put_str("I am kernel\n");
   init_all();
   cls_screen();
   console_put_str("[rabbit@localhost /]$ ");
   while(1);
   return 0;
}
/* init进程 */
void init(void)
{
    uint32_t ret_pid = fork();
    if (ret_pid)
    { // 父进程
        while (1)
            ;
    }
    else
    { // 子进程
        my_shell();
    }
    PANIC("init: should not be here");
}

删除（myos/device/keyboard.c/intr_keyboard_handler）中的打印语句

put_char(cur_char);	    // 临时的

makefile记得新增包含静态库

LIB= -I lib/ -I lib/kernel/ -I lib/user/ -I kernel/ -I device/ -I thread/ -I userprog/	-I fs/ -I shell/

这里的问题：

1、main函数中有打印命令提示符的语句，而init_all中调用thread_init调用process_execute创建了init进程，init运行时会fork出只调用shell的进程，这个进程会调用print_prompt打印命令提示符，这就和main当中打印是冲突了的。要想实现书上的效果，那么fork出运行shell的进程调用print_prompt必须在main调用cls_screen之前。这依赖于特定的任务执行顺序，不过一般不会出错。

小节c：

添加快捷键

readline中新增加对于组合键的处理，ctrl + l 清除除了当前行外的其他行。ctrl + u清除本行的输入，效果类似于连续按下多个退格。我们在键盘中断处理程序中已经预先写好了按下ctrl + l 与 ctrl + u 的处理

	        if ((ctrl_status && cur_char == 'l') || (ctrl_status && cur_char == 'u')) {
	            cur_char -= 'a';
	        }
            if (!ioq_full(&kbd_buf)) {
                ioq_putchar(&kbd_buf, cur_char);
            }

也就是说，我们按下ctrl + l 与 ctrl + u时，放入键盘输入缓冲区的字符是ascii 码为 ‘l’ - ‘a’ 与 ‘u’ - ‘a’，这两个ascii码都属于不可见的控制字符。所以我们只需要增加readline读出这两种情况的处理逻辑即可

修改（myos/shell/shell.c）

/* 从键盘缓冲区中最多读入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 '\n':
        case '\r':
            *pos = 0; // 添加cmd_line的终止字符0
            putchar('\n');
            return;

        case '\b':
            if (cmd_line[0] != '\b')
            {          // 阻止删除非本次输入的信息
                --pos; // 退回到缓冲区cmd_line中上一个字符
                putchar('\b');
            }
            break;

        /* 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;

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

小节d：

解析键入的字符

cmd_parse分析字符串cmd_str中以token为分隔符的单词，将各单词的指针存入argv数组。这个函数就是个字符串处理函数，从诸如 'ls dir ’ 这样的命令中拆单词，拆成 ‘ls’ 与 ‘dir’

修改（myos/shell/shell.c）

#define MAX_ARG_NR 16	   // 加上命令名外,最多支持15个参数

/* 分析字符串cmd_str中以token为分隔符的单词,将各单词的指针存入argv数组 */
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 dir2 " */
        if (*next == 0)
        {
            break;
        }
        argv[argc] = next;

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

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

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

my_shell增加测试代码，输出每个分离出来的单词

修改（myos/shell/shell.c）

char *argv[MAX_ARG_NR];              // argv必须为全局变量，为了以后exec的程序可访问参数
char final_path[MAX_PATH_LEN] = {0}; // 用于洗路径时的缓冲
int32_t argc = -1;

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");
    }
    PANIC("my_shell: should not be here");
}

小节e：

实现输入命令，然后调用对应的函数

先实现一个ps系统调用

pad_print用于对齐输出，也就是有一个buf区长度10字节，然后我们无论要输出什么，都向这个buf中写入，然后空余部分全部填充空格，最后将整个buf输出。比如输出“hello”，经过处理就变成了"hello "

elem2thread_info调用pad_print来对齐输出每个pcb的pid, ppid, status, elapsed_ticks, name

sys_ps调用list_traversal遍历所有任务队列，在其中回调elem2thread_info来输出进程或线程pcb中的信息

修改（myos/thread/thread.c）

#include "stdio.h"
#include "fs.h"
#include "file.h"

/* 以填充空格的方式输出buf */
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", *((int16_t *)ptr));
    case 'x':
        out_pad_0idx = sprintf(buf, "%x", *((uint32_t *)ptr));
    }
    while (out_pad_0idx < buf_len)
    { // 以空格填充
        buf[out_pad_0idx] = ' ';
        out_pad_0idx++;
    }
    sys_write(stdout_no, buf, buf_len - 1);
}

/* 用于在list_traversal函数中的回调函数,用于针对线程队列的处理 */
static bool elem2thread_info(struct list_elem *pelem, int arg UNUSED)
{
    struct task_struct *pthread = elem2entry(struct task_struct, all_list_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);
    ASSERT(strlen(pthread->name) < 17);
    memcpy(out_pad, pthread->name, strlen(pthread->name));
    strcat(out_pad, "\n");
    sys_write(stdout_no, out_pad, strlen(out_pad));
    return false; // 此处返回false是为了迎合主调函数list_traversal,只有回调函数返回false时才会继续调用此函数
}

/* 打印任务列表 */
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);
}

添加函数声明，修改（myos/thread/thread.h）

void sys_ps(void);

然后将上一章和本章实现的sys开头的函数，全部封装成系统调用

首先添加系统调用号，修改（myos/lib/user/syscall.h）

#include "fs.h"

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
};

然后实现它们的用户态入口，修改（myos/lib/user/syscall.c）


/* 获取当前工作目录 */
char *getcwd(char *buf, uint32_t size)
{
    return (char *)_syscall2(SYS_GETCWD, buf, size);
}

/* 以flag方式打开文件pathname */
int32_t open(char *pathname, uint8_t flag)
{
    return _syscall2(SYS_OPEN, pathname, flag);
}

/* 关闭文件fd */
int32_t close(int32_t fd)
{
    return _syscall1(SYS_CLOSE, fd);
}

/* 设置文件偏移量 */
int32_t lseek(int32_t fd, int32_t offset, uint8_t whence)
{
    return _syscall3(SYS_LSEEK, fd, offset, whence);
}

/* 删除文件pathname */
int32_t unlink(const char *pathname)
{
    return _syscall1(SYS_UNLINK, pathname);
}

/* 创建目录pathname */
int32_t mkdir(const char *pathname)
{
    return _syscall1(SYS_MKDIR, pathname);
}

/* 打开目录name */
struct dir *opendir(const char *name)
{
    return (struct dir *)_syscall1(SYS_OPENDIR, name);
}

/* 关闭目录dir */
int32_t closedir(struct dir *dir)
{
    return _syscall1(SYS_CLOSEDIR, dir);
}

/* 删除目录pathname */
int32_t rmdir(const char *pathname)
{
    return _syscall1(SYS_RMDIR, pathname);
}

/* 读取目录dir */
struct dir_entry *readdir(struct dir *dir)
{
    return (struct dir_entry *)_syscall1(SYS_READDIR, dir);
}

/* 回归目录指针 */
void rewinddir(struct dir *dir)
{
    _syscall1(SYS_REWINDDIR, dir);
}

/* 获取path属性到buf中 */
int32_t stat(const char *path, struct stat *buf)
{
    return _syscall2(SYS_STAT, path, buf);
}

/* 改变工作目录为path */
int32_t chdir(const char *path)
{
    return _syscall1(SYS_CHDIR, path);
}

/* 显示任务列表 */
void ps(void)
{
    _syscall0(SYS_PS);
}

添加系统调用用户态入口函数声明，修改修改（myos/lib/user/syscall.h）

char *getcwd(char *buf, uint32_t size);
int32_t open(char *pathname, uint8_t flag);
int32_t close(int32_t fd);
int32_t lseek(int32_t fd, int32_t offset, uint8_t whence);
int32_t unlink(const char *pathname);
int32_t mkdir(const char *pathname);
struct dir *opendir(const char *name);
int32_t closedir(struct dir *dir);
int32_t rmdir(const char *pathname);
struct dir_entry *readdir(struct dir *dir);
void rewinddir(struct dir *dir);
int32_t stat(const char *path, struct stat *buf);
int32_t chdir(const char *path);
void ps(void);

最后在系统调用表中添加真正的系统调用执行函数，修改（myos/userprog/syscall-init.c）

/* 初始化系统调用 */
void syscall_init(void)
{
    put_str("syscall_init start\n");
    syscall_table[SYS_GETPID] = sys_getpid;
    syscall_table[SYS_WRITE] = sys_write;
    syscall_table[SYS_MALLOC] = sys_malloc;
    syscall_table[SYS_FREE] = sys_free;
    syscall_table[SYS_FORK] = sys_fork;
    syscall_table[SYS_READ] = sys_read;
    syscall_table[SYS_PUTCHAR] = sys_putchar;
    syscall_table[SYS_CLEAR] = cls_screen;
    syscall_table[SYS_GETCWD] = sys_getcwd;
    syscall_table[SYS_OPEN] = sys_open;
    syscall_table[SYS_CLOSE] = sys_close;
    syscall_table[SYS_LSEEK] = sys_lseek;
    syscall_table[SYS_UNLINK] = sys_unlink;
    syscall_table[SYS_MKDIR] = sys_mkdir;
    syscall_table[SYS_OPENDIR] = sys_opendir;
    syscall_table[SYS_CLOSEDIR] = sys_closedir;
    syscall_table[SYS_CHDIR] = sys_chdir;
    syscall_table[SYS_RMDIR] = sys_rmdir;
    syscall_table[SYS_READDIR] = sys_readdir;
    syscall_table[SYS_REWINDDIR] = sys_rewinddir;
    syscall_table[SYS_STAT] = sys_stat;
    syscall_table[SYS_PS] = sys_ps;
    put_str("syscall_init done\n");
}

操作系统为了方便用户使用，一般都会提供相对路径功能。比如我们当前工作路径是/home/kanshan/Desktop，我们想要运行一个编译好的程序输入./test，实际上是被操作系统解析成了/home/kanshan/Desktop/test，也就是当前工作路径 + 相对路径 = 绝对路径。

wash_path将路径old_abs_path（这是调用者提供的绝对路径）中的…和.转换为实际路径后存入new_abs_path。例如，给定路径/a/b/..应被转换成/a。给定路径/a/b/.应被转换成/a/b。核心原理：调用path_parse解析路径，如果是..，则退回上一层路径。如果是.，则什么都不做。带入一个例子，比如/a/../home/.就可以明白次函数如何工作

make_clear_abs_path将路径（包含相对路径与绝对路径两种）处理成不含…和.的绝对路径,存储在final_path中。核心原理：判断输入路径是相对路径还是绝对路径，如果是相对路径，调用getcwd获得当前工作目录的绝对路径，将用户输入的路径追加到工作目录路径之后形成绝对目录路径，将其作为参数传给wash_path进行路径转换。

#include "buildin_cmd.h"
#include "debug.h"
#include "dir.h"
#include "string.h"
#include "fs.h"
#include "syscall.h"

/* 将路径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后返回
        new_abs_path[0] = '/';
        new_abs_path[1] = 0;
        return;
    }
    new_abs_path[0] = 0; // 避免传给new_abs_path的缓冲区不干净
    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",".."之后则变为"/"
                /* 若new_abs_path中只有1个'/',即表示已经到了顶层目录,
                就将下一个字符置为结束符0. */
                *(slash_ptr + 1) = 0;
            }
        }
        else if (strcmp(".", name))
        { // 如果路径不是‘.’,就将name拼接到new_abs_path
            if (strcmp(new_abs_path, "/"))
            { // 如果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);
        }
    }
}


/* 将path处理成不含..和.的绝对路径,存储在final_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)))
            { // 若abs_path表示的当前目录不是根目录/
                strcat(abs_path, "/");
            }
        }
    }
    strcat(abs_path, path);
    wash_path(abs_path, final_path);
}

问题1：代码中：new_abs_path[0] = 0;意义何在？

确保了后续在new_abs_path上的任何字符串连接（例如通过strcat函数）都会从头开始。

函数声明，（myos/shell/buildin_cmd.h）

#ifndef __SHELL_BUILDIN_CMD_H
#define __SHELL_BUILDIN_CMD_H

void make_clear_abs_path(char *path, char *final_path);

#endif

支持代码，修改（myos/fs/fs.c）

static char *path_parse(char *pathname, char *name_store)

为

char *path_parse(char *pathname, char *name_store)

my_shell增加测试代码，修改（myos/shell/shell.c）

#include "buildin_cmd.h"

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;
        }

        char buf[MAX_PATH_LEN] = {0};
        int32_t arg_idx = 0;
        while (arg_idx < argc)
        {
            make_clear_abs_path(argv[arg_idx], buf);
            printf("%s -> %s\n", argv[arg_idx], buf);
            arg_idx++;
        }
    }
    PANIC("my_shell: should not be here");
}

小节f：

实现一系列内建命令

shell命令分为外部命令与内部命令。执行外部命令，实际上就是执行了一个进程。而内部命令，就是执行操作系统自带的函数。我们现在来实现一系列内部命令所需要的内建函数。

每个内建函数都会传入两个参数：

uint32_t argc: 这个参数表示传入到该函数的参数个数。在命令 ls -l 中，ls 是命令，而 -l 是ls的参数。在这个例子中，argc 就是2，因为有两个参数：ls 和 -l。
char** argv: 这是一个指向字符串数组的指针，代表传入的参数值。argv 的每一个元素都是一个字符串，表示命令行上的一个参数。

buildin_pwd就是调用了getcwd