GeekOS课程设计-Project 2

﹏ヽ暗。殇╰゛Y 2022-10-13 12:43 351阅读 0赞

### Project 2 ###

*   *  1、实验任务
     *  2、实验原理
     *   *  2.1 系统用户态进程创建：
         *   *  2.1.1 用户态进程创建流程：
             *  2.1.2 系统用户态进程初始化
     *  3、具体实现
     *   *  3.1 编辑源代码文件
         *   *  user.c
             *  elf.c
             *  userseg.c
             *  kthread.c
             *  syscall.c
             *  main.c
         *  3.2 编辑.bochsrc文件
         *  3.3 编辑Makefile文件
     *  4、运行结果
     *  5、课后作业
     *  感谢阅读

[源代码链接][Link 1]

## 1、实验任务 ##

扩充 GeekOS 操作系统内核，使得系统能够支持用户级进程的动态创建和执行。

## 2、实验原理 ##

1.  “src/GeekOS/user.c”文件中的函数 Spawn()，其功能是生成一个新的用户级进程；
2.  “src/GeekOS/user.c”文件中的函数 Switch\_To\_User\_Context()，调度程序在执行  
    一个新的进程前调用该函数以切换用户地址空间；
3.  “src/GeekOS/elf.c”文件中的函数 Parse\_ELF\_Executable()。该函数的实现要求和项目1相同；
4.  “src/GeekOS/userseg.c”文件中主要是实现一些为实现对“src/GeekOS/user.c”中高层操作支持的函数。Destroy\_User\_Context()函数的功能是释放用户态进程占用的内存资源。Load\_User\_Program()函数的功能通过加载可执行文件镜像创建新进程的 User\_Context结构。Copy\_From\_User()和Copy\_To\_User()函数的功能是在用户地址空间和内核地址空间之间复制数据，在分段存储器管理模式下，只要段有效，调用memcpy函数就可以实现这两个函数的功能。Switch\_To\_Address\_Space()函数的功能是通过将进程的LDT装入到LDT寄存器来激活用户的地址空间。
5.  “src/GeekOS/kthread.c”文件中的 Start\_User\_Thread 函数和 Setup\_User\_Thread 函数。Setup\_User\_Thread()函数的功能是为进程初始化内核栈，栈中是为进程首次进入用户态运行时设置处理器状态要使用的数据。Start\_User\_Thread()是一个高层操作，该函数使用User\_Context对象开始一个新进程。
6.  “src/GeekOS/kthread.c”文件中主要是实现用户程序要求内核进行服务的一些系统调用函数定义。要求用户实现的有Sys\_Exit()函数、Sys\_PrintString()函数、 Sys\_GetKey()、Sys\_SetAttr()、Sys\_GetCursor()、Sys\_PutCursor()、Sys\_Spawn()函数、Sys\_Wait()函数和Sys\_GetPID()函数。
7.  在main.c文件中改写生成第一个用户态进程的函数调用：Spawn\_Init\_Process()

GeekOS进程状态及转换：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDEzNDk4_size_16_color_FFFFFF_t_70]  
  在GeekOS中为了区分用户态进程和内核进程，在Kernel\_Thread结构体中设置了一个字段 userContext，指向用户态进程上下文。对于内核进程来说，这个指针为空，而用户态进程都拥有自己的用户上下文（User\_Context）。因此，在GeekOS中要判断一个进程是内核进程还是用户态进程，只要通过userContext字段是否为空来判断就可以了。GeekOS用户态进程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDEzNDk4_size_16_color_FFFFFF_t_70 1]  
  项目2需要实现用户进程，其实用户进程就是基于内核进程的一个改进。内核进程控制块结构Kernel\_Thread中有一个字段User\_Context，而在初始化内核进程的函数时系统将其初始化为零；User\_Context字段其实就是上下文数据结构，定义如下：

StructUser_Context { 
    	#define NUM_USER_LDT_ENTRIES 3
    	StructSegment_Descriptor ldt[NUM_USRE_LDT_ENTRIES];
    	Structsegment_Descriptor* ldtDsecriptor;
    	Char* memory;
    	Ulong_t size;
    	Ushort_tldtSelector;
    	Ushort_t csSelector;
    	Ushort_tdsSelector;
    	Pde_t*pageDir;
    	Ulong_tentryAddr;
    	Ulong_targBlockAddr;
    	Ulong_tstackPointerAddr;
    	Int refCount;
    	#if 0
    	Int *semaphores
    	#endif
    };

Struct Segment Descriptor ldt\[NUM\_USER\_LDT\_ENTRIES\]: 是Segment Descriptor数组，这里只有两个元素，一个Segment用于用户进程的数据，一个Segment用于用户进程的代码。ldtDescriptor 是LDT的描述Segment Descriptor，memory是用户内存空间的其实地址。Size是用户空间的大小。entryAddr是用户代码的其实地址，进程就是从这个地址开始运行的。  
  用户态进程空间。每个用户态进程都拥有属于自己的内存段空间，如：代码段、数据段、栈段等，每个段有一个段描述符（segment descriptor），并且每个进程有一个段描述符表（Local Descriptor Table），用于保存该进程的所有段描述符。操作系统中还设置一个全局描述符表（GDT，Global Descriptor Table），用于记录了系统中所有进程的ldt描述符。用户态进程空间:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDEzNDk4_size_16_color_FFFFFF_t_70 2]

### 2.1 系统用户态进程创建： ###

#### 2.1.1 用户态进程创建流程： ####

![在这里插入图片描述][20210707011748949.png]  
首先使用Read\_Fully()函数将ELF文件读取到缓冲区，使用Parse\_ELF\_Excutable()函数把缓冲区中ELF文件所包含的程序格式读取出来（包括可执行文件的段偏移量、执行文件段数据的长度、用户内存空间的开始地址、内存空间的大小等等），并将其保存在exeFormat结构体中。使用Load\_User\_Program()按照exeFormat的格式创建一个用户上下文。最后Start\_User\_Thread()函数会调用Create\_Thread()函数创建一个用户态线程。再调用Setup\_User\_Thread()函数（该函数会调用Attach\_User\_Context()函数）把创建的线程和用户上下文连接起来。这样一个用户级线程就创建成功了。

*  Spawn函数的功能  
    int Spawn(const char \*program, const char \*command, struct Kernel\_Thread \*\*pThread)  
    参数说明：Program对应的是要读入内存缓冲区的可执行文件，Command是用户执行程序执行时的命令行字符串，pThread是存放指向刚创建进程的指针。  
    Spawn函数主要完成的主要功能是：  
    ① 调用Read\_Fully函数将名为program的可执行文件全部读入内存缓冲区。  
    ② 调用Parse\_ELF\_Executable函数，分析ELF格式文件。Parse\_ELF\_Executable函数功能在项目1中已经实现。  
    ③ 调用Load\_User\_Program将可执行程序的程序段和数据段等装入内存，初始化User\_context数据结构。  
    ④ 调用Start\_User\_Thread函数创建一个进程并使该进程进入准备运行队列。
 *  Load\_User\_Program主要实现功能如下：
    
        int Load_User_Program(
        	char *exeFileData, //保存在内存缓冲中的用户程序可执行文件
        	ulong_t exeFileLength,// 可执行文件的长度
        	struct Exe_Format *exeFormat, //调用Parse_ELF_Executable函数得到的可执行文件格式信息
        	const char *command,// 用户输入的命令行，包括可执行文件的名称及其他参数
        	struct User_Context **pUserContext //指向User_Conetxt的指针，是本函数完成用户上下文初始化的对象
        )
 *  Load\_User\_Program：  
    ① 根据Parse\_ELF\_Executable函数的执行结果Exe\_Format中的Exe\_Segment结构提供的用户程序段信息，用户命令参数及用户态进程栈大小计算用户态进程所需的最大内存空间，即要分配给用户态进程的内存空间。  
    ②为用户程序分配内存空间，并初始化。  
    ③ 根据Exe\_Segment提供的用户段信息初始化代码段、数据段以及栈段的段描述符和段选择子。  
    ④ 根据段信息将用户程序中的各段内容复制到分配的用户内存空间。  
    ⑤ 根据Exe\_Format结构初始化User\_Context结构中的用户态进程代码段入口entry字段，并根据command参数初始化用户内存空间中的参数块。  
    ⑥ 初始化User\_Context结构的用户打开文件列表，并添加标准输入输出文件。  
    ⑦ 将初始化完毕的User\_Context指针赋予\*pUserContext，返回0表示成功。
 *  Load\_User\_Program()实现流程  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDEzNDk4_size_16_color_FFFFFF_t_70 3]

#### 2.1.2 系统用户态进程初始化 ####

user\_context之后的是调用Start\_User\_Thread()函数开始队进程的创建。通过调用Create\_Thread()函数申请对应的空间以及将线程加入到进程队列中，最后Setup\_User\_Thread()函数将user\_context中代码段内容初始化到所有的线程中。得到user\_context之后创建用户态进程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDEzNDk4_size_16_color_FFFFFF_t_70 4]

## 3、具体实现 ##

### 3.1 编辑源代码文件 ###

#### user.c ####

/*
     * Common user mode functions
     * Copyright (c) 2001,2003,2004 David H. Hovemeyer <daveho@cs.umd.edu>
     * $Revision: 1.50 $
     * 
     * This is free software.  You are permitted to use,
     * redistribute, and modify it as specified in the file "COPYING".
     */
    
    #include <geekos/errno.h>
    #include <geekos/ktypes.h>
    #include <geekos/kassert.h>
    #include <geekos/int.h>
    #include <geekos/mem.h>
    #include <geekos/malloc.h>
    #include <geekos/kthread.h>
    #include <geekos/vfs.h>
    #include <geekos/tss.h>
    #include <geekos/user.h>
    
    /*
     * This module contains common functions for implementation of user
     * mode processes.
     */
    
    /*
     * Associate the given user context with a kernel thread.
     * This makes the thread a user process.
     */
    void Attach_User_Context(struct Kernel_Thread* kthread, struct User_Context* context)
    {
        KASSERT(context != 0);
        kthread->userContext = context;
    
        Disable_Interrupts();
    
        /*
         * We don't actually allow multiple threads
         * to share a user context (yet)
         */
        KASSERT(context->refCount == 0);
    
        ++context->refCount;
        Enable_Interrupts();
    }
    
    /*
     * If the given thread has a user context, detach it
     * and destroy it.  This is called when a thread is
     * being destroyed.
     */
    void Detach_User_Context(struct Kernel_Thread* kthread)
    {
        struct User_Context* old = kthread->userContext;
    
        kthread->userContext = 0;
    
        if (old != 0) {
    	int refCount;
    
    	Disable_Interrupts();
            --old->refCount;
    	refCount = old->refCount;
    	Enable_Interrupts();
    
    	/*Print("User context refcount == %d\n", refCount);*/
            if (refCount == 0)
                Destroy_User_Context(old);
        }
    }
    
    /*
     * Spawn a user process.
     * Params:
     *   program - the full path of the program executable file
     *   command - the command, including name of program and arguments
     *   pThread - reference to Kernel_Thread pointer where a pointer to
     *     the newly created user mode thread (process) should be
     *     stored
     * Returns:
     *   The process id (pid) of the new process, or an error code
     *   if the process couldn't be created.  Note that this function
     *   should return ENOTFOUND if the reason for failure is that
     *   the executable file doesn't exist.
     */
    int Spawn(const char *program, const char *command, struct Kernel_Thread **pThread)
    {
        /*
         * Hints:
         * - Call Read_Fully() to load the entire executable into a memory buffer
         * - Call Parse_ELF_Executable() to verify that the executable is
         *   valid, and to populate an Exe_Format data structure describing
         *   how the executable should be loaded
         * - Call Load_User_Program() to create a User_Context with the loaded
         *   program
         * - Call Start_User_Thread() with the new User_Context
         *
         * If all goes well, store the pointer to the new thread in
         * pThread and return 0.  Otherwise, return an error code.
         */
        //TODO("Spawn a process by reading an executable from a filesystem");
        int res;
    	/* 读取 ELF 文件 */     
        char *exeFileData = NULL; 
        ulong_t exeFileLength = 0;     
        res = Read_Fully(program, (void**)&exeFileData, &exeFileLength);     
        if (res != 0)     
        {                
            if (exeFileData != NULL) Free(exeFileData);         
            return ENOTFOUND;     
        } 
    
        /* 分析 ELF 文件 */     
        struct Exe_Format exeFormat;     
        res = Parse_ELF_Executable(exeFileData, exeFileLength, &exeFormat);     
        if (res != 0)     
        {                 
            if (exeFileData != NULL) Free(exeFileData);         
            return res;     
        }
    
        /* 加载用户程序 */     
        struct User_Context *userContext = NULL;     
        res = Load_User_Program(exeFileData, exeFileLength, &exeFormat, command, &userContext);     
        if (res != 0)     
        {                
            if (exeFileData != NULL) Free(exeFileData);         
            if (userContext != NULL) Destroy_User_Context(userContext);         
            return res;     
        }     
        if (exeFileData != NULL) Free(exeFileData);     
        exeFileData = NULL;     
    
        /* 开始用户进程 */     
        struct Kernel_Thread *thread = NULL;     
        thread = Start_User_Thread(userContext, false);     
        /* 超出内存 创建新进程失败 */     
        if (thread == NULL) 
        {         
            if (userContext != NULL) Destroy_User_Context(userContext);
                 return ENOMEM;     
        }
    
        KASSERT(thread->refCount == 2);
        /* 返回核心进程的指针 */ 
        *pThread = thread; 
        return 0; 
    }
    
    /*
     * If the given thread has a User_Context,
     * switch to its memory space.
     *
     * Params:
     *   kthread - the thread that is about to execute
     *   state - saved processor registers describing the state when
     *      the thread was interrupted
     */
    void Switch_To_User_Context(struct Kernel_Thread* kthread, struct Interrupt_State* state)
    {
        /*
         * Hint: Before executing in user mode, you will need to call
         * the Set_Kernel_Stack_Pointer() and Switch_To_Address_Space()
         * functions.
         */
        //TODO("Switch to a new user address space, if necessary");
    	//之前最近使用过的 userContxt
        static struct User_Context* s_currentUserContext;
    
        //指向User_Conetxt的指针，并初始化为准备切换的进程
        struct User_Context* userContext = kthread->userContext;
    
        KASSERT(!Interrupts_Enabled());
    
        //userContext为0表示此进程为核心态进程就不用切换地址空间
        if (userContext == 0) return;
    
        if (userContext != s_currentUserContext)
        {
            //为用户态进程时则切换地址空间
            Switch_To_Address_Space(userContext);
            //新进程的核心栈指针 
            ulong_t esp0 = ((ulong_t)kthread->stackPage) + PAGE_SIZE;
            //设置内核堆栈指针
            Set_Kernel_Stack_Pointer(esp0);
            //保存新的 userContxt
            s_currentUserContext = userContext;
        }
    }

#### elf.c ####

/*
     * ELF executable loading
     * Copyright (c) 2003, Jeffrey K. Hollingsworth <hollings@cs.umd.edu>
     * Copyright (c) 2003, David H. Hovemeyer <daveho@cs.umd.edu>
     * $Revision: 1.29 $
     * 
     * This is free software.  You are permitted to use,
     * redistribute, and modify it as specified in the file "COPYING".
     */
    
    #include <geekos/errno.h>
    #include <geekos/kassert.h>
    #include <geekos/ktypes.h>
    #include <geekos/screen.h>  /* for debug Print() statements */
    #include <geekos/pfat.h>
    #include <geekos/malloc.h>
    #include <geekos/string.h>
    #include <geekos/user.h>
    #include <geekos/elf.h>
    
    
    /**
     * From the data of an ELF executable, determine how its segments
     * need to be loaded into memory.
     * @param exeFileData buffer containing the executable file
     * @param exeFileLength length of the executable file in bytes
     * @param exeFormat structure describing the executable's segments
     *   and entry address; to be filled in
     * @return 0 if successful, < 0 on error
     */
    int Parse_ELF_Executable(char *exeFileData, ulong_t exeFileLength,struct Exe_Format *exeFormat)
    {
        //TODO("Parse an ELF executable image");
    	//利用ELF头部结构体指向可执行文件头部，便于获取相关信息
        elfHeader *ehdr = (elfHeader*)exeFileData;
        //段的个数
        exeFormat->numSegments = ehdr->phnum;
        //代码入口地址
        exeFormat->entryAddr = ehdr->entry;
        //获取头部表在文件中的位置，便于读取信息
        programHeader *phdr = (programHeader*)(exeFileData + ehdr->phoff);
        //填充Exe_Segment
        unsigned int i;
        for(i = 0; i < exeFormat->numSegments; i++, phdr++)
        {
            struct Exe_Segment *segment = &exeFormat->segmentList[i];
            //获取该段在文件中的偏移量*
            segment->offsetInFile = phdr->offset;
            //获取该段的数据在文件中的长度
            segment->lengthInFile = phdr->fileSize;
            //获取该段在用户内存中的起始地址
            segment->startAddress = phdr->vaddr;
            //获取该段在内存中的大小
            segment->sizeInMemory = phdr->memSize;
            //获取该段的保护标志位
            segment->protFlags = phdr->flags;
        }
        return 0;
    }

#### userseg.c ####

/*
     * Segmentation-based user mode implementation
     * Copyright (c) 2001,2003 David H. Hovemeyer <daveho@cs.umd.edu>
     * $Revision: 1.23 $
     * 
     * This is free software.  You are permitted to use,
     * redistribute, and modify it as specified in the file "COPYING".
     */
    
    #include <geekos/ktypes.h>
    #include <geekos/kassert.h>
    #include <geekos/defs.h>
    #include <geekos/mem.h>
    #include <geekos/string.h>
    #include <geekos/malloc.h>
    #include <geekos/int.h>
    #include <geekos/gdt.h>
    #include <geekos/segment.h>
    #include <geekos/tss.h>
    #include <geekos/kthread.h>
    #include <geekos/argblock.h>
    #include <geekos/user.h>
    
    /* ----------------------------------------------------------------------
     * Variables
     * ---------------------------------------------------------------------- */
    
    #define DEFAULT_USER_STACK_SIZE 8192
    
    
    /* ----------------------------------------------------------------------
     * Private functions
     * ---------------------------------------------------------------------- */
    
    
    /*
     * Create a new user context of given size
     */
    
    static struct User_Context* Create_User_Context(ulong_t size)
    {
    	struct User_Context *userContext;
        size = Round_Up_To_Page(size);     
        userContext = (struct User_Context *)Malloc(sizeof(struct User_Context));
        /* 内存分配成功则继续为 userContext 下的 memory 分配内存空间 */
        if (userContext == NULL)     
        {
             return NULL;
        }     
        userContext->memory = (char *)Malloc(size);     
        if (userContext->memory == NULL)
        {         
             Free(userContext);         
             return NULL;
        }     
        memset(userContext->memory, '\0', size);
        userContext->size = size; 
    
        /* 新建一个 LDT 描述符 */     
        userContext->ldtDescriptor = Allocate_Segment_Descriptor();     
        if (userContext->ldtDescriptor == NULL)
        {                
             Free(userContext->memory);         
             return NULL;     
        }     
        /* 初始化段描述符 */
        Init_LDT_Descriptor(userContext->ldtDescriptor, userContext->ldt, NUM_USER_LDT_ENTRIES);     
        /* 新建一个 LDT 选择子 */
        userContext->ldtSelector = Selector(KERNEL_PRIVILEGE, true, Get_Descriptor_Index(userContext->ldtDescriptor));     
        /* 新建一个代码段描述符 */     
        Init_Code_Segment_Descriptor(&userContext->ldt[0], (ulong_t)userContext->memory, size / PAGE_SIZE, USER_PRIVILEGE);
        /* 新建一个数据段描述符 */     
        Init_Data_Segment_Descriptor(&userContext->ldt[1], (ulong_t)userContext->memory, size / PAGE_SIZE, USER_PRIVILEGE);     
        /* 新建数据段和代码段选择子 */
        userContext->csSelector = Selector(USER_PRIVILEGE, false, 0); 
        userContext->dsSelector = Selector(USER_PRIVILEGE, false, 1);
        /* 将引用数清零 */     
        userContext->refCount = 0; 
    
        return userContext; 
    }
    
    
    static bool Validate_User_Memory(struct User_Context* userContext,
        ulong_t userAddr, ulong_t bufSize)
    {
        ulong_t avail;
    
        if (userAddr >= userContext->size)
            return false;
    
        avail = userContext->size - userAddr;
        if (bufSize > avail)
            return false;
    
        return true;
    }
    
    /* ----------------------------------------------------------------------
     * Public functions
     * ---------------------------------------------------------------------- */
    
    /*
     * Destroy a User_Context object, including all memory
     * and other resources allocated within it.
     */
    void Destroy_User_Context(struct User_Context* userContext)
    {
        /*
         * Hints:
         * - you need to free the memory allocated for the user process
         * - don't forget to free the segment descriptor allocated
         *   for the process's LDT
         */
        //TODO("Destroy a User_Context");
    	KASSERT(userContext->refCount == 0);     
        /* 释放 LDT descriptor */     
        Free_Segment_Descriptor(userContext->ldtDescriptor);     
        /* 释放内存空间 */     
        Disable_Interrupts();     
        Free(userContext->memory);     
        Free(userContext);     
        Enable_Interrupts();
    }
    
    /*
     * Load a user executable into memory by creating a User_Context
     * data structure.
     * Params:
     * exeFileData - a buffer containing the executable to load
     * exeFileLength - number of bytes in exeFileData
     * exeFormat - parsed ELF segment information describing how to
     *   load the executable's text and data segments, and the
     *   code entry point address
     * command - string containing the complete command to be executed:
     *   this should be used to create the argument block for the
     *   process
     * pUserContext - reference to the pointer where the User_Context
     *   should be stored
     *
     * Returns:
     *   0 if successful, or an error code (< 0) if unsuccessful
     */
    int Load_User_Program(char *exeFileData, ulong_t exeFileLength,
        struct Exe_Format *exeFormat, const char *command,
        struct User_Context **pUserContext)
    {
        /*
         * Hints:
         * - Determine where in memory each executable segment will be placed
         * - Determine size of argument block and where it memory it will
         *   be placed
         * - Copy each executable segment into memory
         * - Format argument block in memory
         * - In the created User_Context object, set code entry point
         *   address, argument block address, and initial kernel stack pointer
         *   address
         */
        //TODO("Load a user executable into a user memory space using segmentation");
        unsigned int i;     
        struct User_Context *userContext = NULL; 
    
        /* 要分配的最大内存空间 */     
        ulong_t maxva = 0;     
        /* 计算用户态进程所需的最大内存空间 */     
        for (i = 0; i < exeFormat->numSegments; i++)     
        {         
            struct Exe_Segment *segment = &exeFormat->segmentList[i];        
            ulong_t topva = segment->startAddress + segment->sizeInMemory;        
            if (topva > maxva) maxva = topva; 
        } 
        /* 程序参数数目 */     
        unsigned int numArgs;     
        /* 获取参数块的大小 */     
        ulong_t argBlockSize;     
        Get_Argument_Block_Size(command, &numArgs, &argBlockSize);     
        /* 用户进程大小 = 参数块总大小 + 进程堆栈大小(8192) */     
        ulong_t size = Round_Up_To_Page(maxva) + DEFAULT_USER_STACK_SIZE;     
        /* 参数块地址 */     
        ulong_t argBlockAddr = size;     
        size += argBlockSize;     
        /* 按相应大小创建一个进程 */     
        userContext = Create_User_Context(size);     
        /* 如果进程创建失败则返回错误信息 */     
        if (userContext == NULL)     
        {                  
            return -1;     
        } 
    
        /* 将用户程序中的各段内容复制到分配的用户内存空间 */     
        for (i = 0; i < exeFormat->numSegments; i++)     
        {        
            struct Exe_Segment *segment = &exeFormat->segmentList[i];        
            memcpy(userContext->memory + segment->startAddress,                
                    exeFileData + segment->offsetInFile,                
                    segment->lengthInFile);    
        } 
    
        /* 格式化参数块 */     
        Format_Argument_Block(userContext->memory + argBlockAddr, numArgs, argBlockAddr, command);     
        /* 初始化数据段、堆栈段及代码段信息 */     
        userContext->entryAddr = exeFormat->entryAddr;     
        userContext->argBlockAddr = argBlockAddr;     
        userContext->stackPointerAddr = argBlockAddr; 
    
        /* 将初始化完毕的 User_Context 赋给*pUserContext */     
        *pUserContext = userContext; 
    
        return 0; 
    }
    
    /*
     * Copy data from user memory into a kernel buffer.
     * Params:
     * destInKernel - address of kernel buffer
     * srcInUser - address of user buffer
     * bufSize - number of bytes to copy
     *
     * Returns:
     *   true if successful, false if user buffer is invalid (i.e.,
     *   doesn't correspond to memory the process has a right to
     *   access)
     */
    bool Copy_From_User(void* destInKernel, ulong_t srcInUser, ulong_t bufSize)
    {
        /*
         * Hints:
         * - the User_Context of the current process can be found
         *   from g_currentThread->userContext
         * - the user address is an index relative to the chunk
         *   of memory you allocated for it
         * - make sure the user buffer lies entirely in memory belonging
         *   to the process
         */
        //TODO("Copy memory from user buffer to kernel buffer");
        //Validate_User_Memory(NULL,0,0); /* delete this; keeps gcc happy */
        struct User_Context* userContext = g_currentThread->userContext;     
        /* 如果访问的用户内存空间非法(越界访问)，则直接返回失败 */     
        if (!Validate_User_Memory(userContext, srcInUser, bufSize))         
            return false;     
        /* 拷贝当前用户内存空间数据到系统内核空间 */     
        memcpy(destInKernel, userContext->memory + srcInUser, bufSize);     
        /* 拷贝成功则返回 1 */     
        return true; 
    }
    
    /*
     * Copy data from kernel memory into a user buffer.
     * Params:
     * destInUser - address of user buffer
     * srcInKernel - address of kernel buffer
     * bufSize - number of bytes to copy
     *
     * Returns:
     *   true if successful, false if user buffer is invalid (i.e.,
     *   doesn't correspond to memory the process has a right to
     *   access)
     */
    bool Copy_To_User(ulong_t destInUser, void* srcInKernel, ulong_t bufSize)
    {
        /*
         * Hints: same as for Copy_From_User()
         */
        //TODO("Copy memory from kernel buffer to user buffer");
        struct User_Context* userContext = g_currentThread->userContext;     
        /* 如果需要拷贝的内容超出用户内存空间(越界)，则直接返回失败 */     
        if (!Validate_User_Memory(userContext, destInUser, bufSize))         
            return false;     
        /* 拷贝当前系统内核空间数据到用户内存空间 */     
        memcpy(userContext->memory + destInUser, srcInKernel, bufSize);     
        /* 拷贝成功则返回 1 */     
        return true;
    }
    
    /*
     * Switch to user address space belonging to given
     * User_Context object.
     * Params:
     * userContext - the User_Context
     */
    void Switch_To_Address_Space(struct User_Context *userContext)
    {
        /*
         * Hint: you will need to use the lldt assembly language instruction
         * to load the process's LDT by specifying its LDT selector.
         */
        //TODO("Switch to user address space using segmentation/LDT");
        ushort_t ldtSelector = userContext->ldtSelector;     
        __asm__ __volatile__ (     
        "lldt %0"     
        :     
        : "a" (ldtSelector)     
        );
    }

#### kthread.c ####

/*
     * Kernel threads
     * Copyright (c) 2001,2003 David H. Hovemeyer <daveho@cs.umd.edu>
     * $Revision: 1.49 $
     * 
     * This is free software.  You are permitted to use,
     * redistribute, and modify it as specified in the file "COPYING".
     */
    
    #include <geekos/kassert.h>
    #include <geekos/defs.h>
    #include <geekos/screen.h>
    #include <geekos/int.h>
    #include <geekos/mem.h>
    #include <geekos/symbol.h>
    #include <geekos/string.h>
    #include <geekos/kthread.h>
    #include <geekos/malloc.h>
    #include <geekos/user.h>
    
    
    /* ----------------------------------------------------------------------
     * Private data
     * ---------------------------------------------------------------------- */
    
    /*
     * List of all threads in the system.
     */
    static struct All_Thread_List s_allThreadList;
    
    /*
     * Queue of runnable threads.
     */
    static struct Thread_Queue s_runQueue;
    
    /*
     * Current thread.
     */
    struct Kernel_Thread* g_currentThread;
    
    /*
     * Boolean flag indicating that we need to choose a new runnable thread.
     * It is checked by the interrupt return code (Handle_Interrupt,
     * in lowlevel.asm) before returning from an interrupt.
     */
    int g_needReschedule;
    
    /*
     * Boolean flag indicating that preemption is disabled.
     * When set, external interrupts (such as the timer tick)
     * will not cause a new thread to be selected.
     */
    volatile int g_preemptionDisabled;
    
    /*
     * Queue of finished threads needing disposal,
     * and a wait queue used for communication between exited threads
     * and the reaper thread.
     */
    static struct Thread_Queue s_graveyardQueue;
    static struct Thread_Queue s_reaperWaitQueue;
    
    /*
     * Counter for keys that access thread-local data, and an array
     * of destructors for freeing that data when the thread dies.  This is
     * based on POSIX threads' thread-specific data functionality.
     */
    static unsigned int s_tlocalKeyCounter = 0;
    static tlocal_destructor_t s_tlocalDestructors[MAX_TLOCAL_KEYS];
    
    /* ----------------------------------------------------------------------
     * Private functions
     * ---------------------------------------------------------------------- */
    
    /*
     * Initialize a new Kernel_Thread.
     */
    static void Init_Thread(struct Kernel_Thread* kthread, void* stackPage,
    	int priority, bool detached)
    {
        static int nextFreePid = 1;
    
        struct Kernel_Thread* owner = detached ? (struct Kernel_Thread*)0 : g_currentThread;
    
        memset(kthread, '\0', sizeof(*kthread));
        kthread->stackPage = stackPage;
        kthread->esp = ((ulong_t) kthread->stackPage) + PAGE_SIZE;
        kthread->numTicks = 0;
        kthread->priority = priority;
        kthread->userContext = 0;
        kthread->owner = owner;
    
        /*
         * The thread has an implicit self-reference.
         * If the thread is not detached, then its owner
         * also has a reference to it.
         */
        kthread->refCount = detached ? 1 : 2;
    
        kthread->alive = true;
        Clear_Thread_Queue(&kthread->joinQueue);
        kthread->pid = nextFreePid++;
    
    }
    
    /*
     * Create a new raw thread object.
     * Returns a null pointer if there isn't enough memory.
     */
    static struct Kernel_Thread* Create_Thread(int priority, bool detached)
    {
        struct Kernel_Thread* kthread;
        void* stackPage = 0;
    
        /*
         * For now, just allocate one page each for the thread context
         * object and the thread's stack.
         */
        kthread = Alloc_Page();
        if (kthread != 0)
            stackPage = Alloc_Page();    
    
        /* Make sure that the memory allocations succeeded. */
        if (kthread == 0)
    	return 0;
        if (stackPage == 0) {
    	Free_Page(kthread);
    	return 0;
        }
    
        /*Print("New thread @ %x, stack @ %x\n", kthread, stackPage); */
    
        /*
         * Initialize the stack pointer of the new thread
         * and accounting info
         */
        Init_Thread(kthread, stackPage, priority, detached);
    
        /* Add to the list of all threads in the system. */
        Add_To_Back_Of_All_Thread_List(&s_allThreadList, kthread);
    
        return kthread;
    }
    
    /*
     * Push a dword value on the stack of given thread.
     * We use this to set up some context for the thread before
     * we make it runnable.
     */
    static __inline__ void Push(struct Kernel_Thread* kthread, ulong_t value)
    {
        kthread->esp -= 4;
        *((ulong_t *) kthread->esp) = value;
    }
    
    /*
     * Destroy given thread.
     * This function should perform all cleanup needed to
     * reclaim the resources used by a thread.
     * Called with interrupts enabled.
     */
    static void Destroy_Thread(struct Kernel_Thread* kthread)
    {
    
        /* Dispose of the thread's memory. */
        Disable_Interrupts();
        Free_Page(kthread->stackPage);
        Free_Page(kthread);
    
        /* Remove from list of all threads */
        Remove_From_All_Thread_List(&s_allThreadList, kthread);
    
        Enable_Interrupts();
    
    }
    
    /*
     * Hand given thread to the reaper for destruction.
     * Must be called with interrupts disabled!
     */
    static void Reap_Thread(struct Kernel_Thread* kthread)
    {
        KASSERT(!Interrupts_Enabled());
        Enqueue_Thread(&s_graveyardQueue, kthread);
        Wake_Up(&s_reaperWaitQueue);
    }
    
    /*
     * Called when a reference to the thread is broken.
     */
    static void Detach_Thread(struct Kernel_Thread* kthread)
    {
        KASSERT(!Interrupts_Enabled());
        KASSERT(kthread->refCount > 0);
    
        --kthread->refCount;
        if (kthread->refCount == 0) {
    	Reap_Thread(kthread);
        }
    }
    
    /*
     * This function performs any needed initialization before
     * a thread start function is executed.  Currently we just use
     * it to enable interrupts (since Schedule() always activates
     * a thread with interrupts disabled).
     */
    static void Launch_Thread(void)
    {
        Enable_Interrupts();
    }
    
    /*
     * Push initial values for general purpose registers.
     */
    static void Push_General_Registers(struct Kernel_Thread* kthread)
    {
        /*
         * Push initial values for saved general-purpose registers.
         * (The actual values are not important.)
         */
        Push(kthread, 0);  /* eax */
        Push(kthread, 0);  /* ebx */
        Push(kthread, 0);  /* edx */
        Push(kthread, 0);  /* edx */
        Push(kthread, 0);  /* esi */
        Push(kthread, 0);  /* edi */
        Push(kthread, 0);  /* ebp */
    }
    
    /*
     * Shutdown a kernel thread.
     * This is called if a kernel thread exits by falling off
     * the end of its start function.
     */
    static void Shutdown_Thread(void)
    {
        Exit(0);
    }
    
    /*
     * Set up the initial context for a kernel-mode-only thread.
     */
    static void Setup_Kernel_Thread(
        struct Kernel_Thread* kthread,
        Thread_Start_Func startFunc,
        ulong_t arg)
    {
        /*
         * Push the argument to the thread start function, and the
         * return address (the Shutdown_Thread function, so the thread will
         * go away cleanly when the start function returns).
         */
        Push(kthread, arg);
        Push(kthread, (ulong_t) &Shutdown_Thread);
    
        /* Push the address of the start function. */
        Push(kthread, (ulong_t) startFunc);
    
        /*
         * To make the thread schedulable, we need to make it look
         * like it was suspended by an interrupt.  This means pushing
         * an "eflags, cs, eip" sequence onto the stack,
         * as well as int num, error code, saved registers, etc.
         */
    
        /*
         * The EFLAGS register will have all bits clear.
         * The important constraint is that we want to have the IF
         * bit clear, so that interrupts are disabled when the
         * thread starts.
         */
        Push(kthread, 0UL);  /* EFLAGS */
    
        /*
         * As the "return address" specifying where the new thread will
         * start executing, use the Launch_Thread() function.
         */
        Push(kthread, KERNEL_CS);
        Push(kthread, (ulong_t) &Launch_Thread);
    
        /* Push fake error code and interrupt number. */
        Push(kthread, 0);
        Push(kthread, 0);
    
        /* Push initial values for general-purpose registers. */
        Push_General_Registers(kthread);
    
        /*
         * Push values for saved segment registers.
         * Only the ds and es registers will contain valid selectors.
         * The fs and gs registers are not used by any instruction
         * generated by gcc.
         */
        Push(kthread, KERNEL_DS);  /* ds */
        Push(kthread, KERNEL_DS);  /* es */
        Push(kthread, 0);  /* fs */
        Push(kthread, 0);  /* gs */
    }
    
    /*
     * Set up the a user mode thread.
     */
    /*static*/ void Setup_User_Thread(
        struct Kernel_Thread* kthread, struct User_Context* userContext)
    {
        /*
         * Hints:
         * - Call Attach_User_Context() to attach the user context
         *   to the Kernel_Thread
         * - Set up initial thread stack to make it appear that
         *   the thread was interrupted while in user mode
         *   just before the entry point instruction was executed
         * - The esi register should contain the address of
         *   the argument block
         */
        //TODO("Create a new thread to execute in user mode");
        ulong_t eflags = EFLAGS_IF;     
        unsigned int csSelector = userContext->csSelector;  /* CS 选择子 */     
        unsigned int dsSelector = userContext->dsSelector;  /* DS 选择子 */ 
    
        /* 调用 Attach_User_Context 加载用户上下文 */  
        Attach_User_Context(kthread, userContext); 
    
        /* 初始化用户态进程堆栈，使之看上去像刚被中断运行一样 */     
        /* 分别调用 Push 函数将以下数据压入堆栈 */     
        Push(kthread, dsSelector);  /* DS 选择子 */     
        Push(kthread, userContext->stackPointerAddr);  /* 堆栈指针 */     
        Push(kthread, eflags);  /* Eflags */     
        Push(kthread, csSelector);  /* CS 选择子 */     
        Push(kthread, userContext->entryAddr);  /* 程序计数器 */     
        Push(kthread, 0);  /* 错误代码(0) */     
        Push(kthread, 0);  /* 中断号(0) */ 
    
    //    if (uthreadDebug)         
    //      Print("Entry addr=%lx\n", userContext->entryAddr); 
    
        /* 初始化通用寄存单元，向 esi 传递参数块地址 */     
        Push(kthread, 0);  /* eax */     
        Push(kthread, 0);  /* ebx */     
        Push(kthread, 0);  /* ecx */     
        Push(kthread, 0);  /* edx */     
        Push(kthread, userContext->argBlockAddr);  /* esi */     
        Push(kthread, 0);  /* edi */     
        Push(kthread, 0);  /* ebp */ 
    
        /* 初始化数据段寄存单元 */     
        Push(kthread, dsSelector);  /* ds */     
        Push(kthread, dsSelector);  /* es */     
        Push(kthread, dsSelector);  /* fs */     
        Push(kthread, dsSelector);  /* gs */ 
    }
    
    
    /*
     * This is the body of the idle thread.  Its job is to preserve
     * the invariant that a runnable thread always exists,
     * i.e., the run queue is never empty.
     */
    static void Idle(ulong_t arg)
    {
        while (true)
    	Yield();
    }
    
    /*
     * The reaper thread.  Its job is to de-allocate memory
     * used by threads which have finished.
     */
    static void Reaper(ulong_t arg)
    {
        struct Kernel_Thread *kthread;
    
        Disable_Interrupts();
    
        while (true) {
    	/* See if there are any threads needing disposal. */
    	if ((kthread = s_graveyardQueue.head) == 0) {
    	    /* Graveyard is empty, so wait for a thread to die. */
    	    Wait(&s_reaperWaitQueue);
    	}
    	else {
    	    /* Make the graveyard queue empty. */
    	    Clear_Thread_Queue(&s_graveyardQueue);
    
    	    /*
    	     * Now we can re-enable interrupts, since we
    	     * have removed all the threads needing disposal.
    	     */
    	    Enable_Interrupts();
    	    Yield();   /* allow other threads to run? */
    
    	    /* Dispose of the dead threads. */
    	    while (kthread != 0) {
    		struct Kernel_Thread* next = Get_Next_In_Thread_Queue(kthread);
    #if 0
    		Print("Reaper: disposing of thread @ %x, stack @ %x\n",
    		    kthread, kthread->stackPage);
    #endif
    		Destroy_Thread(kthread);
    		kthread = next;
    	    }
    
    	    /*
    	     * Disable interrupts again, since we're going to
    	     * do another iteration.
    	     */
    	    Disable_Interrupts();
    	}
        }
    }
    
    /*
     * Find the best (highest priority) thread in given
     * thread queue.  Returns null if queue is empty.
     */
    static __inline__ struct Kernel_Thread* Find_Best(struct Thread_Queue* queue)
    {
        /* Pick the highest priority thread */
        struct Kernel_Thread *kthread = queue->head, *best = 0;
        while (kthread != 0) {
    	if (best == 0 || kthread->priority > best->priority)
    	    best = kthread;
    	kthread = Get_Next_In_Thread_Queue(kthread);
        }
        return best;
    }
    
    /*
     * Acquires pointer to thread-local data from the current thread
     * indexed by the given key.  Assumes interrupts are off.
     */
    static __inline__ const void** Get_Tlocal_Pointer(tlocal_key_t k) 
    {
        struct Kernel_Thread* current = g_currentThread;
    
        KASSERT(k < MAX_TLOCAL_KEYS);
    
        return &current->tlocalData[k];
    }
    
    /*
     * Clean up any thread-local data upon thread exit.  Assumes
     * this is called with interrupts disabled.  We follow the POSIX style
     * of possibly invoking a destructor more than once, because a
     * destructor to some thread-local data might cause other thread-local
     * data to become alive once again.  If everything is NULL by the end
     * of an iteration, we are done.
     */
    static void Tlocal_Exit(struct Kernel_Thread* curr) {
        int i, j, called = 0;
    
        KASSERT(!Interrupts_Enabled());
    
        for (j = 0; j<MIN_DESTRUCTOR_ITERATIONS; j++) {
    
            for (i = 0; i<MAX_TLOCAL_KEYS; i++) {
    
    	    void *x = (void *)curr->tlocalData[i];
    	    if (x != NULL && s_tlocalDestructors[i] != NULL) {
    
    	        curr->tlocalData[i] = NULL;
    		called = 1;
    
    		Enable_Interrupts();
    		s_tlocalDestructors[i](x);
    		Disable_Interrupts();
    	    }
    	}
    	if (!called) break;
        }
    }
    
    
    /* ----------------------------------------------------------------------
     * Public functions
     * ---------------------------------------------------------------------- */
    
    void Init_Scheduler(void)
    {
        struct Kernel_Thread* mainThread = (struct Kernel_Thread *) KERN_THREAD_OBJ;
    
        /*
         * Create initial kernel thread context object and stack,
         * and make them current.
         */
        Init_Thread(mainThread, (void *) KERN_STACK, PRIORITY_NORMAL, true);
        g_currentThread = mainThread;
        Add_To_Back_Of_All_Thread_List(&s_allThreadList, mainThread);
    
        /*
         * Create the idle thread.
         */
        /*Print("starting idle thread\n");*/
        Start_Kernel_Thread(Idle, 0, PRIORITY_IDLE, true);
    
        /*
         * Create the reaper thread.
         */
        /*Print("starting reaper thread\n");*/
        Start_Kernel_Thread(Reaper, 0, PRIORITY_NORMAL, true);
    }
    
    /*
     * Start a kernel-mode-only thread, using given function as its body
     * and passing given argument as its parameter.  Returns pointer
     * to the new thread if successful, null otherwise.
     *
     * startFunc - is the function to be called by the new thread
     * arg - is a paramter to pass to the new function
     * priority - the priority of this thread (use PRIORITY_NORMAL) for
     *    most things
     * detached - use false for kernel threads
     */
    struct Kernel_Thread* Start_Kernel_Thread(
        Thread_Start_Func startFunc,
        ulong_t arg,
        int priority,
        bool detached
    )
    {
        struct Kernel_Thread* kthread = Create_Thread(priority, detached);
        if (kthread != 0) {
    	/*
    	 * Create the initial context for the thread to make
    	 * it schedulable.
    	 */
    	Setup_Kernel_Thread(kthread, startFunc, arg);
    
    
    	/* Atomically put the thread on the run queue. */
    	Make_Runnable_Atomic(kthread);
        }
    
        return kthread;
    }
    
    /*
     * Start a user-mode thread (i.e., a process), using given user context.
     * Returns pointer to the new thread if successful, null otherwise.
     */
    struct Kernel_Thread*
    Start_User_Thread(struct User_Context* userContext, bool detached)
    {
        /*
         * Hints:
         * - Use Create_Thread() to create a new "raw" thread object
         * - Call Setup_User_Thread() to get the thread ready to
         *   execute in user mode
         * - Call Make_Runnable_Atomic() to schedule the process
         *   for execution
         */
        //TODO("Start user thread");
        /* 如果传入的用户上下文字段为空(非用户态进程)则返回错误 */     
        if (userContext == NULL)     
        {                
            return NULL;    
        } 
    
        /* 建立用户态进程 */     
        struct Kernel_Thread *kthread = Create_Thread(PRIORITY_USER, detached);     
        if (kthread == NULL) 
        {                  
            return NULL;     
        }     
        Setup_User_Thread(kthread, userContext);     
    
        /* 将新创建的进程加入就绪进程队列 */     
        Make_Runnable_Atomic(kthread); 
    
        /* 新用户态进程创建成功，返回指向该进程的指针 */    
        return kthread; 
    }
    
    /*
     * Add given thread to the run queue, so that it
     * may be scheduled.  Must be called with interrupts disabled!
     */
    void Make_Runnable(struct Kernel_Thread* kthread)
    {
        KASSERT(!Interrupts_Enabled());
    
        Enqueue_Thread(&s_runQueue, kthread);
    }
    
    /*
     * Atomically make a thread runnable.
     * Assumes interrupts are currently enabled.
     */
    void Make_Runnable_Atomic(struct Kernel_Thread* kthread)
    {
        Disable_Interrupts();
        Make_Runnable(kthread);
        Enable_Interrupts();
    }
    
    /*
     * Get the thread that currently has the CPU.
     */
    struct Kernel_Thread* Get_Current(void)
    {
        return g_currentThread;
    }
    
    /*
     * Get the next runnable thread from the run queue.
     * This is the scheduler.
     */
    struct Kernel_Thread* Get_Next_Runnable(void)
    {
        struct Kernel_Thread* best = 0;
    
        best = Find_Best(&s_runQueue);
        KASSERT(best != 0);
        Remove_Thread(&s_runQueue, best);
    
    /*
     *    Print("Scheduling %x\n", best);
     */
        return best;
    }
    
    /*
     * Schedule a thread that is waiting to run.
     * Must be called with interrupts off!
     * The current thread should already have been placed
     * on whatever queue is appropriate (i.e., either the
     * run queue if it is still runnable, or a wait queue
     * if it is waiting for an event to occur).
     */
    void Schedule(void)
    {
        struct Kernel_Thread* runnable;
    
        /* Make sure interrupts really are disabled */
        KASSERT(!Interrupts_Enabled());
    
        /* Preemption should not be disabled. */
        KASSERT(!g_preemptionDisabled);
    
        /* Get next thread to run from the run queue */
        runnable = Get_Next_Runnable();
    
        /*
         * Activate the new thread, saving the context of the current thread.
         * Eventually, this thread will get re-activated and Switch_To_Thread()
         * will "return", and then Schedule() will return to wherever
         * it was called from.
         */
        Switch_To_Thread(runnable);
    }
    
    /*
     * Voluntarily give up the CPU to another thread.
     * Does nothing if no other threads are ready to run.
     */
    void Yield(void)
    {
        Disable_Interrupts();
        Make_Runnable(g_currentThread);
        Schedule();
        Enable_Interrupts();
    }
    
    /*
     * Exit the current thread.
     * Calling this function initiates a context switch.
     */
    void Exit(int exitCode)
    {
        struct Kernel_Thread* current = g_currentThread;
    
        if (Interrupts_Enabled())
    	Disable_Interrupts();
    
        /* Thread is dead */
        current->exitCode = exitCode;
        current->alive = false;
    
        /* Clean up any thread-local memory */
        Tlocal_Exit(g_currentThread);
    
        /* Notify the thread's owner, if any */
        Wake_Up(&current->joinQueue);
    
        /* Remove the thread's implicit reference to itself. */
        Detach_Thread(g_currentThread);
    
        /*
         * Schedule a new thread.
         * Since the old thread wasn't placed on any
         * thread queue, it won't get scheduled again.
         */
        Schedule();
    
        /* Shouldn't get here */
        KASSERT(false);
    }
    
    /*
     * Wait for given thread to die.
     * Interrupts must be enabled.
     * Returns the thread exit code.
     */
    int Join(struct Kernel_Thread* kthread)
    {
        int exitCode;
    
        KASSERT(Interrupts_Enabled());
    
        /* It is only legal for the owner to join */
        KASSERT(kthread->owner == g_currentThread);
    
        Disable_Interrupts();
    
        /* Wait for it to die */
        while (kthread->alive) {
    	Wait(&kthread->joinQueue);
        }
    
        /* Get thread exit code. */
        exitCode = kthread->exitCode;
    
        /* Release our reference to the thread */
        Detach_Thread(kthread);
    
        Enable_Interrupts();
    
        return exitCode;
    }
    
    /*
     * Look up a thread by its process id.
     * The caller must be the thread's owner.
     */
    struct Kernel_Thread* Lookup_Thread(int pid)
    {
        struct Kernel_Thread *result = 0;
    
        bool iflag = Begin_Int_Atomic();
    
        /*
         * TODO: we could remove the requirement that the caller
         * needs to be the thread's owner by specifying that another
         * reference is added to the thread before it is returned.
         */
    
        result = Get_Front_Of_All_Thread_List(&s_allThreadList);
        while (result != 0) {
    	if (result->pid == pid) {
    	    if (g_currentThread != result->owner)
    		result = 0;
    	    break;
    	}
    	result = Get_Next_In_All_Thread_List(result);
        }
    
        End_Int_Atomic(iflag);
    
        return result;
    }
    
    
    /*
     * Wait on given wait queue.
     * Must be called with interrupts disabled!
     * Note that the function will return with interrupts
     * disabled.  This is desirable, because it allows us to
     * atomically test a condition that can be affected by an interrupt
     * and wait for it to be satisfied (if necessary).
     * See the Wait_For_Key() function in keyboard.c
     * for an example.
     */
    void Wait(struct Thread_Queue* waitQueue)
    {
        struct Kernel_Thread* current = g_currentThread;
    
        KASSERT(!Interrupts_Enabled());
    
        /* Add the thread to the wait queue. */
        Enqueue_Thread(waitQueue, current);
    
        /* Find another thread to run. */
        Schedule();
    }
    
    /*
     * Wake up all threads waiting on given wait queue.
     * Must be called with interrupts disabled!
     * See Keyboard_Interrupt_Handler() function in keyboard.c
     * for an example.
     */
    void Wake_Up(struct Thread_Queue* waitQueue)
    {
        struct Kernel_Thread *kthread = waitQueue->head, *next;
    
        KASSERT(!Interrupts_Enabled());
    
        /*
         * Walk throught the list of threads in the wait queue,
         * transferring each one to the run queue.
         */
        while (kthread != 0) {
    	next = Get_Next_In_Thread_Queue(kthread);
    	Make_Runnable(kthread);
    	kthread = next;
        }
    
        /* The wait queue is now empty. */
        Clear_Thread_Queue(waitQueue);
    }
    
    /*
     * Wake up a single thread waiting on given wait queue
     * (if there are any threads waiting).  Chooses the highest priority thread.
     * Interrupts must be disabled!
     */
    void Wake_Up_One(struct Thread_Queue* waitQueue)
    {
        struct Kernel_Thread* best;
    
        KASSERT(!Interrupts_Enabled());
    
        best = Find_Best(waitQueue);
    
        if (best != 0) {
    	Remove_Thread(waitQueue, best);
    	Make_Runnable(best);
    	/*Print("Wake_Up_One: waking up %x from %x\n", best, g_currentThread); */
        }
    }
    
    /*
     * Allocate a key for accessing thread-local data.
     */
    int Tlocal_Create(tlocal_key_t *key, tlocal_destructor_t destructor) 
    {
        KASSERT(key);
    
        bool iflag = Begin_Int_Atomic();
    
        if (s_tlocalKeyCounter == MAX_TLOCAL_KEYS) return -1;
        s_tlocalDestructors[s_tlocalKeyCounter] = destructor;
        *key = s_tlocalKeyCounter++;
    
        End_Int_Atomic(iflag);
      
        return 0;
    }
    
    /*
     * Store a value for a thread-local item
     */
    void Tlocal_Put(tlocal_key_t k, const void *v) 
    {
        const void **pv;
    
        KASSERT(k < s_tlocalKeyCounter);
    
        pv = Get_Tlocal_Pointer(k);
        *pv = v;
    }
    
    /*
     * Acquire a thread-local value
     */
    void *Tlocal_Get(tlocal_key_t k) 
    {
        const void **pv;
    
        KASSERT(k < s_tlocalKeyCounter);
    
        pv = Get_Tlocal_Pointer(k);
        return (void *)*pv;
    }
    
    /*
     * Print list of all threads in system.
     * For debugging.
     */
    void Dump_All_Thread_List(void)
    {
        struct Kernel_Thread *kthread;
        int count = 0;
        bool iflag = Begin_Int_Atomic();
    
        kthread = Get_Front_Of_All_Thread_List(&s_allThreadList);
    
        Print("[");
        while (kthread != 0) {
    	++count;
    	Print("<%lx,%lx,%lx>",
    	    (ulong_t) Get_Prev_In_All_Thread_List(kthread),
    	    (ulong_t) kthread,
    	    (ulong_t) Get_Next_In_All_Thread_List(kthread));
    	KASSERT(kthread != Get_Next_In_All_Thread_List(kthread));
    	kthread = Get_Next_In_All_Thread_List(kthread);
        }
        Print("]\n");
        Print("%d threads are running\n", count);
    
        End_Int_Atomic(iflag);
    }

#### syscall.c ####

/*
     * System call handlers
     * Copyright (c) 2003, Jeffrey K. Hollingsworth <hollings@cs.umd.edu>
     * Copyright (c) 2003,2004 David Hovemeyer <daveho@cs.umd.edu>
     * $Revision: 1.59 $
     * 
     * This is free software.  You are permitted to use,
     * redistribute, and modify it as specified in the file "COPYING".
     */
    
    #include <geekos/syscall.h>
    #include <geekos/errno.h>
    #include <geekos/kthread.h>
    #include <geekos/int.h>
    #include <geekos/elf.h>
    #include <geekos/malloc.h>
    #include <geekos/screen.h>
    #include <geekos/keyboard.h>
    #include <geekos/string.h>
    #include <geekos/user.h>
    #include <geekos/timer.h>
    #include <geekos/vfs.h>
    
    /* 添加函数 Copy_User_String 以便在函数 Sys_PrintString 中使用 */
    static int Copy_User_String(ulong_t uaddr, ulong_t len,
     ulong_t maxLen, char **pStr)
    {
        int result = 0;
        char *str;
        /* 字符串超过最大长度 */
        if (len > maxLen) return EINVALID;
        /* 为字符串分配内存空间 */
        str = (char*)Malloc(len + 1);
        if (str == 0){
            return ENOMEM;
            goto fail;
        }
        /* 从用户内存空间中复制字符串到系统内核空间 */
        if (!Copy_From_User(str, uaddr, len))
        {
            result = EINVALID;
            Free(str);
            goto fail;
        }
        str[len] = '\0';
        /* 拷贝成功 */
        *pStr = str;
    fail:
        return result;
    }
    
    /*
     * Null system call.
     * Does nothing except immediately return control back
     * to the interrupted user program.
     * Params:
     *  state - processor registers from user mode
     *
     * Returns:
     *   always returns the value 0 (zero)
     */
    static int Sys_Null(struct Interrupt_State* state)
    {
        return 0;
    }
    
    /*
     * Exit system call.
     * The interrupted user process is terminated.
     * Params:
     *   state->ebx - process exit code
     * Returns:
     *   Never returns to user mode!
     */
    static int Sys_Exit(struct Interrupt_State* state)
    {
        //TODO("Exit system call");
        Exit(state->ebx);
    }
    
    /*
     * Print a string to the console.
     * Params:
     *   state->ebx - user pointer of string to be printed
     *   state->ecx - number of characters to print
     * Returns: 0 if successful, -1 if not
     */
    static int Sys_PrintString(struct Interrupt_State* state)
    {
        //TODO("PrintString system call");
    	int result = 0;//返回值    
        uint_t length = state->ecx;//字符串长度
        uchar_t* buf = 0;
        if (length > 0){
            /* 将字符串复制到系统内核空间 */
            if (Copy_User_String(state->ebx, length, 1023, (char**)&buf) != 0)
                goto done;
            /* 输出字符串到控制台 */
            Put_Buf(buf, length);
        }
    done:
        if (buf != NULL) Free(buf);
        return result;
    }
    
    /*
     * Get a single key press from the console.
     * Suspends the user process until a key press is available.
     * Params:
     *   state - processor registers from user mode
     * Returns: the key code
     */
    static int Sys_GetKey(struct Interrupt_State* state)
    {
        //TODO("GetKey system call");
    	return Wait_For_Key();
    }
    
    /*
     * Set the current text attributes.
     * Params:
     *   state->ebx - character attributes to use
     * Returns: always returns 0
     */
    static int Sys_SetAttr(struct Interrupt_State* state)
    {
        //TODO("SetAttr system call");
    	Set_Current_Attr((uchar_t)state->ebx);
        return 0;
    }
    
    /*
     * Get the current cursor position.
     * Params:
     *   state->ebx - pointer to user int where row value should be stored
     *   state->ecx - pointer to user int where column value should be stored
     * Returns: 0 if successful, -1 otherwise
     */
    static int Sys_GetCursor(struct Interrupt_State* state)
    {
        //TODO("GetCursor system call");
    	/* 获取当前光标所在屏幕位置(行和列) */
        int row, col;
        Get_Cursor(&row, &col);
         if (!Copy_To_User(state->ebx, &row, sizeof(int)) ||
     !Copy_To_User(state->ecx, &col, sizeof(int)))
            return -1;
        return 0;
    }
    
    /*
     * Set the current cursor position.
     * Params:
     *   state->ebx - new row value
     *   state->ecx - new column value
     * Returns: 0 if successful, -1 otherwise
     */
    static int Sys_PutCursor(struct Interrupt_State* state)
    {
        //TODO("PutCursor system call");
    	/* 设置光标的位置(行和列) */
        return Put_Cursor(state->ebx, state->ecx) ? 0 : -1;
    }
    
    /*
     * Create a new user process.
     * Params:
     *   state->ebx - user address of name of executable
     *   state->ecx - length of executable name
     *   state->edx - user address of command string
     *   state->esi - length of command string
     * Returns: pid of process if successful, error code (< 0) otherwise
     */
    static int Sys_Spawn(struct Interrupt_State* state)
    {
        //TODO("Spawn system call");
    	int res;//程序返回值
        char *program = 0;//进程名称
        char *command = 0;//用户命令
        struct Kernel_Thread *process;
        /* 复制程序名和命令字符串到用户内存空间 */
        res = Copy_User_String(state->ebx, state->ecx, VFS_MAX_PATH_LEN, &program);
        if (res != 0)
        {//从用户空间复制进程名称
            goto fail;
        }
        res = Copy_User_String(state->edx, state->esi, 1023, &command);
        if (res != 0)
        {//从用户空间复制用户命令   
            goto fail;
        }
        /* 生成用户进程 */
        Enable_Interrupts();//开中断
        res = Spawn(program, command, &process);//得到进程名称和用户命令后便可生成一个新进程
        if (res == 0) {//若成功则返回新进程ID号   
            KASSERT(process != 0);   
            res = process->pid;  
        }  
        Disable_Interrupts();//关中断
     fail:
        if (program != 0) 
            Free(program);
        if (command != 0) 
            Free(command);
        return res;
    }
    
    /*
     * Wait for a process to exit.
     * Params:
     *   state->ebx - pid of process to wait for
     * Returns: the exit code of the process,
     *   or error code (< 0) on error
     */
    static int Sys_Wait(struct Interrupt_State* state)
    {
        //TODO("Wait system call");
    	int exitCode;
        /* 查找需要等待的进程 */
        struct Kernel_Thread *kthread = Lookup_Thread(state->ebx);
        /* 如果没有找到需要等待的进程，则返回错误代码 */
        if (kthread == 0) return -1;
        /* 等待指定进程结束 */
        Enable_Interrupts();
        exitCode = Join(kthread);
        Disable_Interrupts();
        return exitCode;
    }
    
    /*
     * Get pid (process id) of current thread.
     * Params:
     *   state - processor registers from user mode
     * Returns: the pid of the current thread
     */
    static int Sys_GetPID(struct Interrupt_State* state)
    {
        //TODO("GetPID system call");
    	/* 返回当前进程的 ID(PID) */
        return g_currentThread->pid;
    }
    
    
    /*
     * Global table of system call handler functions.
     */
    const Syscall g_syscallTable[] = {
        Sys_Null,
        Sys_Exit,
        Sys_PrintString,
        Sys_GetKey,
        Sys_SetAttr,
        Sys_GetCursor,
        Sys_PutCursor,
        Sys_Spawn,
        Sys_Wait,
        Sys_GetPID,
    };
    
    /*
     * Number of system calls implemented.
     */
    const int g_numSyscalls = sizeof(g_syscallTable) / sizeof(Syscall);

#### main.c ####

/*
     * GeekOS C code entry point
     * Copyright (c) 2001,2003,2004 David H. Hovemeyer <daveho@cs.umd.edu>
     * Copyright (c) 2003, Jeffrey K. Hollingsworth <hollings@cs.umd.edu>
     * Copyright (c) 2004, Iulian Neamtiu <neamtiu@cs.umd.edu>
     * $Revision: 1.51 $
     * 
     * This is free software.  You are permitted to use,
     * redistribute, and modify it as specified in the file "COPYING".
     */
    
    #include <geekos/bootinfo.h>
    #include <geekos/string.h>
    #include <geekos/screen.h>
    #include <geekos/mem.h>
    #include <geekos/crc32.h>
    #include <geekos/tss.h>
    #include <geekos/int.h>
    #include <geekos/kthread.h>
    #include <geekos/trap.h>
    #include <geekos/timer.h>
    #include <geekos/keyboard.h>
    #include <geekos/dma.h>
    #include <geekos/ide.h>
    #include <geekos/floppy.h>
    #include <geekos/pfat.h>
    #include <geekos/vfs.h>
    #include <geekos/user.h>
    
    
    /*
     * Define this for a self-contained boot floppy
     * with a PFAT filesystem.  (Target "fd_aug.img" in
     * the makefile.)
     */
    /*#define FD_BOOT*/
    
    #ifdef FD_BOOT
    #  define ROOT_DEVICE "fd0"
    #  define ROOT_PREFIX "a"
    #else
    #  define ROOT_DEVICE "ide0"
    #  define ROOT_PREFIX "c"
    #endif
    
    #define INIT_PROGRAM "/" ROOT_PREFIX "/shell.exe"
    
    
    
    static void Mount_Root_Filesystem(void);
    static void Spawn_Init_Process(void);
    
    /*
     * Kernel C code entry point.
     * Initializes kernel subsystems, mounts filesystems,
     * and spawns init process.
     */
    void Main(struct Boot_Info* bootInfo)
    {
        Init_BSS();
        Init_Screen();
        Init_Mem(bootInfo);
        Init_CRC32();
        Init_TSS();
        Init_Interrupts();
        Init_Scheduler();
        Init_Traps();
        Init_Timer();
        Init_Keyboard();
        Init_DMA();
        Init_Floppy();
        Init_IDE();
        Init_PFAT();
    
        Mount_Root_Filesystem();
    
        Set_Current_Attr(ATTRIB(BLACK, GREEN|BRIGHT));
        Print("Welcome to GeekOS!\n");
        Set_Current_Attr(ATTRIB(BLACK, GRAY));
    
    
    
    
        Spawn_Init_Process();
    
        /* Now this thread is done. */
        Exit(0);
    }
    
    
    
    static void Mount_Root_Filesystem(void)
    {
        if (Mount(ROOT_DEVICE, ROOT_PREFIX, "pfat") != 0)
    	Print("Failed to mount /" ROOT_PREFIX " filesystem\n");
        else
    	Print("Mounted /" ROOT_PREFIX " filesystem!\n");
    
    }
    
    
    static void Spawn_Init_Process(void)
    {
        //TODO("Spawn the init process");
        struct Kernel_Thread *pThread;
        Spawn("/c/shell.exe","/c/shell.exe",&pThread);
    }

### 3.2 编辑.bochsrc文件 ###

megs: 8
    boot: a
    floppya: 1_44=fd.img, status=inserted
    log: ./bochs.out
    ata0-master: type=disk, path=diskc.img, mode=flat, cylinders=40, heads=8, spt=63

### 3.3 编辑Makefile文件 ###

TARGET_CC := $(TARGET_CC_PREFIX)gcc -m32
    HOST_CC := gcc -m32
    TARGET_LD := $(TARGET_CC_PREFIX)ld -m elf_i386
    GENERAL_OPTS := -O -Wall -fno-stack-protector $(EXTRA_C_OPTS)
    CC_GENERAL_OPTS := $(GENERAL_OPTS) #-Werror

## 4、运行结果 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDEzNDk4_size_16_color_FFFFFF_t_70 5]  
进程一开始PID为6，是因为在系统初始化之初已经运行了 5 个进程，因此我们的第一个用户程序的进程 ID 是从 6 开始的。这五个进程分别为： Idle、Reaper、Init\_Floppy()、 Init\_IDE()。Main。Idle、Reaper和Main三个进程，它们由Init\_Scheduler函数创建，是执行进程，空闲进程，进程死掉时回收；Init\_Floppy()初始化软盘， Init\_IDE()初始化硬盘。创建用户态进程时，除了分配用户态内存堆栈，还给参数专门分配了空间。B程序运行后会输出接收到的参数，上图可看出程序正确运行。

## 5、课后作业 ##

**1.GeekOS 系统启动后运行的第一个用户级线程是什么？**

答：shell

**2.GeekOS 系统中，内核级线程和用户级线程有什么区别？**

答：

*  进程结构不同。内核进程没有User\_Context 结构体，只有Kernel\_Thread结构体。而用户进程既拥有Kernel\_Thread结构体，也拥有User\_Context 结构体。User\_Context 结构体保存了用户栈地址、段描述符、段选择子、用户程序入口地址等内容。
 *  栈空间不同。每个进程都有自己的栈，内核进程有1个栈，内核栈；用户有两个栈空间，内核栈和用户栈空间。用户栈的空间指向用户地址空间，内核栈的空间指向内核地址空间。当进程在用户态运行（Ring3）时，CPU栈指针寄存器指向的 用户栈地址，使用用户栈。当进程运行在内核态时（Ring0），CPU栈指针寄存器指向的是内核栈空间地址，使用的是内核栈。其中用户栈地址保存在User\_Context结构体中，内核栈地址保存在Kernel\_Thread结构体中。

**3.什么是全局描述表？什么是局部描述表？**

答：

*  全局描述表GDT。在整个系统中，全局描述符表GDT只有一张(一个处理器对应一个GDT)，GDT可以被放在内存的任何位置，但CPU必须知道GDT的入口，也就是基地址放在哪里，Intel的设计者门提供了一个寄存器GDTR用来存放GDT的入口地址，程序员将GDT设定在内存中某个位置之后，可以通过LGDT指令将GDT的入口地址装入此积存器，从此以后，CPU就根据此寄存器中的内容作为GDT的入口来访问GDT了。GDTR中存放的是GDT在内存中的基地址和其表长界限。
 *  局部描述表LDT。局部描述符表是保护模式下存储器寻址的一种数据表，它包含了与某个任务相关联的段描述符，在设计操作系统时，通常每个任务有一个独立的LDT。LDT提供了将一任务的代码段、数据段与操作系统的其余部分相隔离的机制。

**4.在GeekOS系统内核中，如何由ELF文件创建一个用户级线程？**

答：用户级线程和内核级线程可以通过Kernel\_Thread对象的userContext指针是否为空判断。与内核级线程相比创建用户级进程需要有User\_Context对象、用户栈空间和用户地址空间。通过读取解析ELF文件得到可执行文件数据段、代码段等信息存入用户地址空间，之后完成User\_Context对象和用户栈空间相关属性的初始化，得到的User\_Context对象由Kernel\_Thread对象的userContext指针指向。从而创建了用户级线程。

**5.在GeekOS系统内核中，如何选择一个建立好的用户级线程来运行？**

答：加入准备运行队列，等待系统调度运行。

## 感谢阅读 ##

如果对你有帮助，点赞收藏再走呗。

[Link 1]: https://download.csdn.net/download/qq_38413498/20051683?spm=1001.2014.3001.5501
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDEzNDk4_size_16_color_FFFFFF_t_70]: /images/20221005/0f0ddc6f4cd64d97aa18d5bdfefe5a8f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDEzNDk4_size_16_color_FFFFFF_t_70 1]: /images/20221005/c949f0303a55448abc7757042de822ba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDEzNDk4_size_16_color_FFFFFF_t_70 2]: /images/20221005/096dedb6af10456fbcc2dd9938653e07.png
[20210707011748949.png]: /images/20221005/d56bded625e4470ba12af030780ae700.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDEzNDk4_size_16_color_FFFFFF_t_70 3]: /images/20221005/6ba19921d6ce406f84dfdcedde7371b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDEzNDk4_size_16_color_FFFFFF_t_70 4]: /images/20221005/207e2933911249b0b1873653f55035f4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDEzNDk4_size_16_color_FFFFFF_t_70 5]: /images/20221005/0c0eb1d451b44b74b0e572e566ca9f58.png