《操作系统真象还原》从零开始自制操作系统自写源码实现（userprog相关文件）

我会带着你远行 2022-09-04 15:55 94阅读 0赞

### 文章目录 ###

*   *  专栏博客链接
     *  userprog相关文件
     *   *  编写完的exec.c
         *  编写完的exec.h
         *  编写完的fork.c
         *  编写完的fork.h
         *  编写完的process.c
         *  编写完的process.h
         *  编写完的syscall-init.c
         *  编写完的syscall-init.h
         *  编写完的tss.c
         *  编写完的tss.h

--------------------

## 专栏博客链接 ##

--------------------

**[《操作系统真象还原》从零开始自制操作系统 全章节博客链接][Link 1]**

--------------------

## userprog相关文件 ##

--------------------

### 编写完的exec.c ###

--------------------

#include "exec.h"
    #include "global.h"
    #include "memory.h"
    #include "string.h"
    #include "../fs/fs.h"
    #include "../fs/file.h"
    #include "stdio-kernel.h"
    #include "interrupt.h"
    #include "syscall.h"
    
    
    extern void intr_exit(void);
    
    
    /***************** //半完成品 //值到最后的读取出现了错误 找了一天的原因 也对比了一天的代码了 //值能够读取 但是发生了缺页 遗憾告终 ****************/
    //将偏移为offset 大小为filesz的段移动到虚拟地址为 vaddr 的内存上
    bool segment_load(int32_t fd,uint32_t offset,uint32_t filesz,uint32_t vaddr)
    { 
        //得到页框起始位置
        uint32_t vaddr_first_page = vaddr & 0xfffff000;
        //得到第一个页面的剩余空间
        uint32_t size_in_first_page = PG_SIZE - (vaddr & 0x00000fff);
        
        //占用页面数
        uint32_t occupy_pages = 0; 
        //大于第一个页面的剩余空间
        if(filesz > size_in_first_page)
        { 
            uint32_t left_size = filesz - size_in_first_page;
            occupy_pages = DIV_ROUND_UP(left_size,PG_SIZE) + 1;
        }
        else    occupy_pages = 1;
        
        //开始分配内存咯 如果那个位置的内存没有 我们即分配 有的话直接覆盖即可
        uint32_t page_idx= 0;
        uint32_t vaddr_page = vaddr_first_page;
        
        while(page_idx < occupy_pages)
        { 
            uint32_t* pde = pde_ptr(vaddr_page);
            uint32_t* pte = pte_ptr(vaddr_page);
            //先看页目录在不在 在的话再判断页表上面有没有 都没有的话 就直接分配内存即可 毕竟用的是老进程的页表
            if(!(*pde & 0x00000001) || !(*pte & 0x00000001))
            { 
                if(get_a_page(PF_USER,vaddr_page) == NULL)
                    return false;
            }
            printk("ok!\n");
            //如果原进程页表就分配了 之间覆盖于其上即可
            //不需要客气 哈哈
            vaddr_page += PG_SIZE;
            ++page_idx;
        }
        sys_lseek(fd,offset,SEEK_SET);    //文件指针指向我们的offset
        sys_read(fd,vaddr,filesz); //fd指向的文件
        while(1);
        printk("very ok!\n");
        return true;
    }
    
    //在文件系统中 加载用户程序 并返回起始地址
    int32_t load(const char* pathname)
    { 
        int32_t ret = -1;
        struct Elf32_Ehdr elf_header;  //elf头
        struct Elf32_Phdr prog_header; //程序头表
        memset(&elf_header,0,sizeof(struct Elf32_Ehdr));
        
        int32_t fd = open(pathname,O_RDONLY);
        if(fd == -1)
        	return -1;
        
        if(read(fd,&elf_header,sizeof(struct Elf32_Ehdr)) != sizeof(struct Elf32_Ehdr))
            goto done;
        sys_lseek(fd,0,SEEK_SET);
        //开头7字节是固定的魔数 0X7F 0X45 0X4C 0X46 0X1 0X1 0X1 我博客里面readelf那张图里面也有
        if(memcmp(elf_header.e_ident,"\177ELF\1\1\1",7) || elf_header.e_machine != 3 || elf_header.e_type != 2 || \
           elf_header.e_version != 1 || elf_header.e_phnum > 1024 || \
           elf_header.e_phentsize != sizeof(struct Elf32_Phdr))
        { 
            printk("load: memcmp fail\n");
            goto done;
        }
        //程序头表在文件中的偏移地址
        Elf32_Off  prog_header_offset = elf_header.e_phoff;
        Elf32_Half prog_header_size   = elf_header.e_phentsize;
        
        //遍历程序头 根据e_phnum来遍历 具体偏移位置由程序头表里面的offset决定 offset是给出下个程序头距离当前的头的巨鹿
        uint32_t prog_idx = 0;
        while(prog_idx < elf_header.e_phnum)
        { 
            memset(&prog_header,0,sizeof(struct Elf32_Phdr));
            sys_lseek(fd,prog_header_offset,SEEK_SET);
            if(sys_read(fd,&prog_header,prog_header_size) != prog_header_size)
                goto done;
            //可用于加载的有效段
            if(PT_LOAD == prog_header.p_type && prog_header.p_vaddr >= elf_header.e_entry)
            { 
                //载入到内存中
                if(!segment_load(fd,prog_header.p_offset,prog_header.p_filesz,prog_header.p_vaddr))
                    goto done;
            }
            
            prog_header_offset += elf_header.e_phentsize;
            ++prog_idx;
        }
        
        ret = elf_header.e_entry;  //入口点地址
        done:
        sys_close(fd);
        return ret;
    }
    
    //用path指向的程序替换进程
    int32_t sys_execv(const char* path,const char* argv[])
    { 
        uint32_t argc = 0;
        while(argv[argc])
        	++argc;
        	
        int32_t entry_point = load(path);
        if(entry_point == -1)
            return -1;
            
        //得到pcb
        struct task_struct* cur = running_thread();
        int32_t TASK_NAME_LEN = strlen(path);
        memset(cur->name,0,strlen(cur->name));
        memcpy(cur->name,path,TASK_NAME_LEN);
        cur->name[TASK_NAME_LEN-1] = 0;
        
        //这里我们在fork那里 已经在熟悉不过了
        struct intr_stack* intr_0_stack = (struct intr_stack*)\
        ((uint32_t)cur + PG_SIZE - sizeof(struct intr_stack));
        intr_0_stack->ebx = (uint32_t)argv;      // 参数地址 第一个参数位置
        intr_0_stack->ecx = argc;               // 参数个数 第二个参数位置
        intr_0_stack->eip = (void*)entry_point; // 入口地址处 ok了家人
        intr_0_stack->esp = (void*)0xc0000000; //用户栈最顶点 当然我们用户栈也一直设置在那里的 哈哈
        
        //好凶 直接开跳了
        while(1);
        asm volatile("movl %0,%%esp ; jmp intr_exit" : : "g" (intr_0_stack) : "memory");
        return 0;// 哈哈 跳都跳转了 无法执行了
    }

--------------------

### 编写完的exec.h ###

--------------------

#ifndef __USERPROG_EXEC_H
    #define __USERPROG_EXEC_H
    
    #include "stdint.h"
    
    typedef uint32_t Elf32_Word,Elf32_Addr,Elf32_Off;
    typedef uint16_t Elf32_Half;
    
    //Elf32位的头
    struct Elf32_Ehdr
    { 
        unsigned char e_ident[16];
        Elf32_Half    e_type;   	//目标文件类型
        Elf32_Half    e_machine;	//体系结构 EM_386 3
        Elf32_Word    e_version;   //版本 1
        Elf32_Addr    e_entry;     //入口地址
        Elf32_Off     e_phoff;     //Programme Header Off
        Elf32_Off     e_shoff;     //Segment Header Off
        Elf32_Word    e_flags;     //0x0
        Elf32_Half    e_ehsize;    //Elfsize
        Elf32_Half    e_phentsize; //Programme Header Size
        Elf32_Half    e_phnum;     //num of Programme Header
        Elf32_Half    e_shentsize; //Segment Header Size
        Elf32_Half    e_shnum;     //Segment Header Number
        Elf32_Half    e_shstmdx;
    };
    
    //程序头表
    struct Elf32_Phdr
    { 
        Elf32_Word    p_type;
        Elf32_Off     p_offset;
        Elf32_Addr    p_vaddr;
        Elf32_Addr    p_paddr;
        Elf32_Word    p_filesz;
        Elf32_Word    p_memsz;
        Elf32_Word    p_flags;
        Elf32_Word    p_align;
    };
    
    //段类型
    enum segment_type
    { 
        PT_NULL,
        PT_LOAD,    //可加载程序段
        PT_DYNAMIC, //动态加载信息
        PT_INTERP,  //动态加载器名称
        PT_NOTE,    //辅助信息
        PT_SHLIB,   //保留
        PT_PHDR     //程序头表
    };
    
    bool segment_load(int32_t fd,uint32_t offset,uint32_t filesz,uint32_t vaddr);
    int32_t load(const char* pathname);
    int32_t sys_execv(const char* path,const char* argv[]);
    
    #endif

--------------------

### 编写完的fork.c ###

--------------------

#include "fork.h"
    #include "global.h"
    #include "stdint.h"
    #include "string.h"
    #include "memory.h"
    #include "interrupt.h"
    #include "../thread/sync.h"
    #include "../thread/thread.h"
    #include "debug.h"
    #include "process.h"
    #include "stdio-kernel.h"
    #include "../fs/file.h"
    #include "list.h"
    
    extern void intr_exit(void);
    
    //复制父进程的pcb
    int32_t copy_pcb_vaddrbitmap_stack0(struct task_struct* child_thread,struct task_struct* parent_thread)
    { 
        //直接先把pcb所在页 包括内核栈 中断栈全部一起复制过来 其他的需要修改的再一项项改
        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; //默认是-1 对于子进程的parent_pid 父进程的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);	//malloc 内存块分配符初始化
        //虚拟位图需要分配页 的页数 毕竟两个进程不能共享虚拟内存位图嘛 但是我们是需要把父进程的给复制了 
        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);
        //复制父进程的虚拟内存位图 并把自己刚分配好的独立位图给我们的子进程赋值
        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); //进程后面加个名字
        strcat(child_thread->name,"_fork");
        return 0;
    }
    
    //设置子进程的进程体 用户栈
    //把父进程的内存区全部复制下来 buf_page是因为用户进程间无法共享内存 看不见彼此 只能通过buf_page来作为过渡
    void copy_body_stack3(struct task_struct* parent_thread,struct task_struct* child_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) //一字节8位
                { 
                    if((BITMAP_MASK << idx_bit) & vaddr_btmp[idx_byte])
                    { 
                        prog_vaddr = (idx_byte * 8 + idx_bit) * PG_SIZE + vaddr_start;
                        memcpy(buf_page,(void*)prog_vaddr,PG_SIZE);
                        page_dir_activate(child_thread); //切换到用户页表 防止安装到父进程里面去了
                        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;
        }    
    }
    
    //给子进程构建内核栈 且设置0 返回值
    int32_t build_child_stack(struct task_struct* child_thread)
    { 
        //内核栈的最高地址处 intr中断栈最低地址处
        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;
        //这里我把其结构体搬过来了
        /*struct thread_stack { uint32_t ebp; uint32_t ebx; uint32_t edi; uint32_t esi; void (*eip) (thread_func* func,void* func_arg); //和下面的相互照应 以ret 汇编代码进入kernel_thread函数调用 void (*unused_retaddr); //占位数 在栈顶站住了返回地址的位置 因为是汇编ret thread_func* function; //进入kernel_thread要调用的函数地址 void* func_arg; //参数指针 };*/
        //返回地址毕竟是高地址
        uint32_t* ret_addr_in_thread_stack = (uint32_t*)intr_0_stack - 1;
        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;
        uint32_t* ebp_ptr_in_thread_stack =  (uint32_t*)intr_0_stack - 5;
        
        *ret_addr_in_thread_stack = (uint32_t)intr_exit;
        //反正之后的pop都会覆盖
        *esi_ptr_in_thread_stack = *edi_ptr_in_thread_stack = *ebx_ptr_in_thread_stack = \
        *ebp_ptr_in_thread_stack = 0;
        //内核栈栈顶
        child_thread->self_kstack = ebp_ptr_in_thread_stack;
        return 0;
    }
    
    //更新inode打开数
    void updata_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;
        }
    }
    
    //汇总函数 包装 把父进程资源给子进程
    int32_t copy_process(struct task_struct* child_thread,struct task_struct* parent_thread)
    { 
        //用于给memcpy 过渡的页面
        void* buf_page = get_kernel_pages(1);
        if(buf_page == NULL)
        { 
            printk("copy_process: buf_page alloc fail\n");
            return -1;
        }
        if(copy_pcb_vaddrbitmap_stack0(child_thread,parent_thread) == -1)
        { 
            printk("copy_process: copy_pcb_vaddrbitmap_stack0 fail\n");
            return -1;
        }
        
        child_thread->pgdir = create_page_dir();
        if(child_thread->pgdir == NULL)
        { 
            printk("copy_process: child_thread->pgdir create fail\n");
        	return -1;
        }
        
        copy_body_stack3(parent_thread,child_thread,buf_page);
        build_child_stack(child_thread);
        updata_inode_open_cnts(child_thread);
        mfree_page(PF_KERNEL,buf_page,1);
        return 0;
    }
    
    //禁止从内核调用 只能从用户进程调用
    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;
    }

--------------------

### 编写完的fork.h ###

--------------------

#ifndef __USERPROG__FORK_H
    #define __USERPROG__FORK_H
    
    #include "stdint.h"
    #include "string.h"
    #include "../thread/thread.h"
    
    int32_t copy_pcb_vaddrbitmap_stack0(struct task_struct* child_thread,struct task_struct* parent_thread);
    void copy_body_stack3(struct task_struct* parent_thread,struct task_struct* child_thread,void* buf_page);
    int32_t build_child_stack(struct task_struct* child_thread);
    void updata_inode_open_cnts(struct task_struct* thread);
    int32_t copy_process(struct task_struct* child_thread,struct task_struct* parent_thread);
    pid_t sys_fork(void);
    
    #endif

--------------------

### 编写完的process.c ###

--------------------

#include "tss.h"
    #include "process.h"
    #include "string.h"
    #include "global.h"
    #include "memory.h"
    #include "print.h"
    #include "../thread/thread.h"
    #include "../kernel/interrupt.h"
    #include "debug.h"
    #include "../device/console.h"
    
    void start_process(void* filename_)
    { 
        //schedule线程调度后 来到这里
        //特权级0级 到 3级通过 iretd "欺骗" cpu 把用户进程的环境给准备好 iretd即进入
        void* function = filename_;
        struct task_struct* cur = running_thread();
        struct intr_stack* proc_stack = (struct intr_stack*)((uint32_t)cur->self_kstack + sizeof(struct thread_stack)); 
        												//环境全存放在intr_stack中了
        proc_stack->edi = proc_stack->esi = proc_stack->ebp = proc_stack->esp_dummy = 0;
        proc_stack->ebx = proc_stack->edx = proc_stack->ecx = proc_stack->eax = 0;
        proc_stack->gs = 0;
        proc_stack->ds = proc_stack->es = proc_stack->fs = SELECTOR_U_DATA;			//数据段选择子
        proc_stack->eip = function;								//函数地址 ip
        proc_stack->cs = SELECTOR_U_CODE;								//cs ip cs选择子
        proc_stack->eflags = (EFLAGS_IOPL_0 | EFLAGS_MBS | EFLAGS_IF_1);				//不能够关闭中断 ELFAG_IF_1 不然会导致无法调度
        proc_stack->esp = (void*)((uint32_t)get_a_page(PF_USER,USER_STACK3_VADDR) + PG_SIZE);	//栈空间在0xc0000000以下一页的地方 当然物理内存是操作系统来分配
        proc_stack->ss = SELECTOR_U_DATA;								//数据段选择子
        asm volatile ("movl %0,%%esp;jmp intr_exit": : "g"(proc_stack) : "memory");
    }
    
    void page_dir_activate(struct task_struct* p_thread)
    { 
        uint32_t pagedir_phy_addr = 0x100000; //之前设置的页目录表的物理地址
        if(p_thread->pgdir != NULL)
        { 
        	pagedir_phy_addr = addr_v2p((uint32_t)p_thread->pgdir); //得到实际页目录地址
        }
        asm volatile ("movl %0,%%cr3" : : "r"(pagedir_phy_addr) : "memory");
    }
    
    void process_activate(struct task_struct* p_thread)
    { 
        page_dir_activate(p_thread);
        
        //tss切换需要
        if(p_thread->pgdir)
        	updata_tss_esp(p_thread);
    }
    
    uint32_t* create_page_dir(void)
    { 
        uint32_t* page_dir_vaddr = get_kernel_pages(1);				//得到内存
        if(page_dir_vaddr == NULL)
        { 
        	console_put_str("create_page_dir: get_kernel_page failed!\n");
        	return NULL;
        }
        
        memcpy((uint32_t*)((uint32_t)page_dir_vaddr + 0x300*4),(uint32_t*)(0xfffff000+0x300*4),1024); // 256项
        
        uint32_t new_page_dir_phy_addr = addr_v2p((uint32_t)page_dir_vaddr);                    
        page_dir_vaddr[1023] = new_page_dir_phy_addr | PG_US_U | PG_RW_W | PG_P_1;                    //最后一项是页目录项自己的地址
        return page_dir_vaddr;									     
    }
    
    void create_user_vaddr_bitmap(struct task_struct* user_prog)
    { 
        user_prog->userprog_vaddr.vaddr_start = USER_VADDR_START;	 //位图开始管理的位置
        uint32_t bitmap_pg_cnt = DIV_ROUND_UP((0xc0000000 - USER_VADDR_START)/ PG_SIZE / 8,PG_SIZE); //向上取整取虚拟页数
        user_prog->userprog_vaddr.vaddr_bitmap.bits = get_kernel_pages(bitmap_pg_cnt);
        user_prog->userprog_vaddr.vaddr_bitmap.btmp_bytes_len = (0xc0000000 - USER_VADDR_START) / PG_SIZE / 8;
        bitmap_init(&user_prog->userprog_vaddr.vaddr_bitmap);
    }
    
    void process_execute(void* filename,char* name)
    { 
        struct task_struct* thread = get_kernel_pages(1);  //分配一页空间 得到pcb
        init_thread(thread,name,default_prio);		 //初始化pcb
        create_user_vaddr_bitmap(thread);			 //为虚拟地址位图初始化 分配空间
        thread_create(thread,start_process,filename);	 //创造线程 start_process 之后通过start_process intr_exit跳转到用户进程
        thread->pgdir = create_page_dir();		 //把页目录表的地址分配了 并且把内核的页目录都给复制过去 这样操作系统对每个进程都可见
        block_desc_init(thread->u_block_desc);
        
        enum intr_status old_status = intr_disable();     
        ASSERT(!elem_find(&thread_ready_list,&thread->general_tag));
        list_append(&thread_ready_list,&thread->general_tag);     //添加线程 start_process到就绪队列中
        
        ASSERT(!elem_find(&thread_all_list,&thread->all_list_tag));
        list_append(&thread_all_list,&thread->all_list_tag);
        intr_set_status(old_status);
    }

--------------------

### 编写完的process.h ###

--------------------

#ifndef __USERPROG__PROCESS_H
    #define __USERPROG__PROCESS_H
    
    #define USER_VADDR_START 0x8048000
    
    extern void intr_exit(void);
    
    void start_process(void* filename_);
    void page_dir_activate(struct task_struct* p_thread);
    void process_activate(struct task_struct* p_thread);
    uint32_t* create_page_dir(void);
    void create_user_vaddr_bitmap(struct task_struct* user_prog);
    void process_execute(void* filename,char* name);
    
    #endif

--------------------

### 编写完的syscall-init.c ###

--------------------

#include "syscall-init.h"
    #include "../lib/user/syscall.h"
    #include "stdint.h"
    #include "print.h"
    #include "interrupt.h"
    #include "memory.h"
    #include "../thread/thread.h"
    #include "../fs/file.h"
    #include "fork.h"
    #include "../lib/kernel/stdio-kernel.h"
    #include "exec.h"
    
    #define syscall_nr 32
    typedef void* syscall;
    syscall syscall_table[syscall_nr];
    
    uint32_t sys_getpid(void)
    { 
        return running_thread()->pid;
    }
    
    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;
        syscall_table[SYS_EXECV]     = sys_execv;
        put_str("syscall_init done\n");
    }

--------------------

### 编写完的syscall-init.h ###

--------------------

#ifndef __USERPROG_SYSCALL_INIT_H
    #define __USERPROG_SYSCALL_INIT_H
    #include "stdint.h"
    
    uint32_t sys_getpid(void);
    void syscall_init(void);
    
    #endif

--------------------

### 编写完的tss.c ###

--------------------

#include "tss.h"
    #include "global.h"
    #include "../thread/thread.h"
    #include "print.h"
    #include "string.h"
    
    struct tss
    { 
        uint32_t backlink;
        uint32_t* esp0;
        uint32_t ss0;
        uint32_t* esp1;
        uint32_t ss1;
        uint32_t* esp2;
        uint32_t ss2;
        uint32_t cr3;
        uint32_t (*eip) (void);
        uint32_t eflags;
        uint32_t eax;
        uint32_t ecx;
        uint32_t edx;
        uint32_t ebx;
        uint32_t esp;
        uint32_t ebp;
        uint32_t esi;
        uint32_t edi;
        uint32_t es;
        uint32_t cs;
        uint32_t ss;
        uint32_t ds;
        uint32_t fs;
        uint32_t gs;
        uint32_t ldt;
        uint32_t trace;
        uint32_t io_base;
    };
    
    struct tss tss;
    
    //内核栈都是位于 pcb头顶一页的地方
    void updata_tss_esp(struct task_struct* pthread)
    { 
        tss.esp0 = (uint32_t*)((uint32_t)pthread + PG_SIZE);
    }
    
    struct gdt_desc make_gdt_desc(uint32_t* desc_addr,uint32_t limit,uint8_t attr_low,uint8_t attr_high)
    { 
        struct gdt_desc desc;
        uint32_t desc_base = (uint32_t) desc_addr;
        desc.limit_low_word =  limit & 0x0000ffff;
        desc.base_low_word = desc_base & 0x0000ffff;
        desc.base_mid_byte = ((desc_base & 0x00ff0000) >> 16);
        desc.attr_low_byte = (uint8_t)(attr_low);
        desc.limit_high_attr_high = (((limit & 0x000f0000) >> 16) + (uint8_t)(attr_high));
        desc.base_high_byte = desc_base >> 24;
        return desc;
    }
    
    void tss_init()
    { 
        put_str("tss_init start\n");
        uint32_t tss_size = sizeof(tss);
        memset(&tss,0,tss_size);
        tss.ss0 = SELECTOR_K_STACK;
        tss.io_base = tss_size;
        
        //之前的gdt 个性使然 放在了0xc0000603的位置
        *((struct gdt_desc*)0xc0000623) = make_gdt_desc((uint32_t*)&tss,tss_size-1,TSS_ATTR_LOW,TSS_ATTR_HIGH);
        *((struct gdt_desc*)0xc000062b) = make_gdt_desc((uint32_t*)0,0xfffff,GDT_CODE_ATTR_LOW_DPL3,\
        									       GDT_ATTR_HIGH);
        *((struct gdt_desc*)0xc0000633) = make_gdt_desc((uint32_t*)0,0xfffff,GDT_DATA_ATTR_LOW_DPL3,\
        									       GDT_ATTR_HIGH);
        
        uint64_t gdt_operand = \
        ((8*7 - 1) | ((uint64_t)(uint32_t)0xc0000603 << 16));
        
        asm volatile("lgdt %0" :: "m"(gdt_operand));
        asm volatile("ltr %w0" :: "r"(SELECTOR_TSS));
        put_str("tss_init and ltr done\n");
    }

--------------------

### 编写完的tss.h ###

--------------------

#ifndef __USERPROG_TSS_H
    #define __USERPROG_TSS_H
    #include "../thread/thread.h"
    
    //内核栈都是位于 pcb头顶一页的地方
    void updata_tss_esp(struct task_struct* pthread);
    struct gdt_desc make_gdt_desc(uint32_t* desc_addr,uint32_t limit,uint8_t attr_low,uint8_t attr_high);
    void tss_init(void);
    
    #endif

[Link 1]: https://love6.blog.csdn.net/article/details/119133589