ucore Lab4 操作系统实验

LAB4内核进程实验报告

知识准备

（主要依据理论课知识以及学堂在线上清华大学教学视频)

1.进程与线程定义与区别

进程是指一个具有一定独立功能的程序在一个数据集合上的一次动态执行过程，通常我们可以将其视为资源的拥有者。线程是进程的一部分，描述指令流的执行状态，是进程中指令执行流的最小单元，CPU调度的基本单位。一个程序至少一个进程，一个进程至少一个线程。进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位。 可以这样认为： 线程=进程-共享资源

个人的通俗理解：如果说程序是一个小品剧表演，则进程就是指包括舞台等各种资源的表演集合，线程就是演员。

内核线程与用户进程的区别：

• 内核线程只运行在内核态，用户进程会在在用户态和内核态交替运行
• 所有内核线程共用ucore内核内存空间，不需为每个内核线程维护单独的内存空间；用户进程需要维护各自的用户内存空间

2.进程的一些相关知识

进程包括了正在运行的一个程序的所有状态信息，包括代码、数据、寄存器等。

进程的一些特点：

• 动态性：可以动态地创建、结束进程
• 并发行：进程可以被独立调用并占用处理机运行
• 独立性：不同进程间工作不受影响
• 制约性：多个进程因访问共享数据、资源或进程间同步而产生制约

进程控制块(PCB)是管理控制进程运行所用信息的集合。PCB是进程存在的唯一标志，每个进程在操作系统中都有一个对应的PCB，操作系统用PCB来描述进程的基本信息以及运行变化情况。PCB通常包含进程标识符、处理机的信息、进程调度信息、进程控制信息。

进程切换(上下文切换)：暂停当前的进程，从运行状态变为其他状态，调用另一个进程从就绪状态改为运行状态。在这一过程中，切换前需要保存进程上下文，以便于之后恢复该进程，且尽可能地快速切换(因此通常用汇编写进程切换过程的代码)。CPU给每个任务一定的服务时间，当时间片轮转的时候，需要把当前状态保存下来，同时加载下一个任务，这时候就进行上下文切换。

经典的进程五状态模型(new,ready,waitting,running,terminated)：
进程挂起：处于挂起状态的进程映像在磁盘上，目的是减少进程占用内存。与之相对的成为进程激活，将处于挂起状态的进程激活，将进程从外存转到内存

3.线程的一些相关知识

线程的优点：一个进程可以执行多个线程，各线程可以并发执行，各线程可以共享地址空间与文件等资源。

单线程进程与多线程进程：(强调：寄存器不共享)

进程与线程之间的对应关系(一对一、多对一、一对多、多对多)：

进程线程一对一：

• 缺点：每创建一个用户线程都需要创建一个相应的内核线程，创建内核线程的开销会影响应用程序的性能
• 优点：一个线程执行阻塞系统调用时，能允许另一个线程继续执行

进程线程一对多：

• 缺点：一个用户线程导致waiting将导致其他用户线程不能用
• 优点：控制用户线程由用户线程库，修改用户线程库比较简单，线程切换在用户空间不会有模式切换

进程线程多对多：

• 开发人员可以创建任意多的用户线程并且相应内核线程能在多处理器系统上并发执行，并且当一个线程阻塞系统调用时内核能调度另一个线程执行
• Kernel thread数量最多等于user thread，因为最多一对一。执行时一个内核线程对应一个用户线程

线程分为用户线程和内核线程：

• 用户线程：由一组用户级的线程库函数来完成线程的管理，包括线程的创建、终止、同步、调度等。不依赖于操作系统内核，用户态的线程切换较快，在用户空间实现线程。但是当线程发起系统调用而阻塞时，整个进程进入等待状态，不支持基于线程的处理机抢占。只能以进程为单位分配CPU时间。
• 内核线程：由内核通过系统调用实现的线程机制，由内核完成线程的创建、终止和管理。内核线程由内核维护PCB和TCB，线程执行系统调用阻塞时不影响其他线程。但线程创建、终止、切换的开销较大。可以以线程为单位进行分配CPU时间。

实验内容

实验2/3完成了物理和虚拟内存管理，这给创建内核线程（内核线程是一种特殊的进程）打下了提供内存管理的基础。当一个程序加载到内存中运行时，首先通过ucore OS的内存管理子系统分配合适的空间，然后就需要考虑如何分时使用CPU来“并发”执行多个程序，让每个运行的程序（这里用线程或进程表示）“感到”它们各自拥有“自己”的CPU。本次实验将首先接触的是内核线程的管理。

在实验前，非常有必要看一下此次实验增添的内容以及相关数据结构和函数，这将对之后完成实验有着很大帮助。

0.一些新增的非常重要的数据结构与函数：

此次实验主要增加了proc.h，proc.c，entry.S，switch.S四个文件

在proc.h中，我们可以看到新增了一些数据结构：

• 表示进程状态的 enum 常量 proc_state:

  //存取进程的状态
  enum proc_state {
      PROC_UNINIT = 0,  //未初始状态
      PROC_SLEEPING,    // 分配了物理页，此时处于睡眠状态或等待状态
      PROC_RUNNABLE,    // 运行与就绪状态
      PROC_ZOMBIE,      // 死亡状态
  };
  

  需要强调的是进程创建后进入为初始状态，分配物理页后进程进入睡眠状态。进程处于PROC_RUNNABLE状态不一定在运行。当程序指令执行完毕，由操作系统回收进程所占用的资源时，进程进入了“死亡”状态。

• 进程管理信息proc_struct结构体:

//进程管理信息proc_struct
struct proc_struct {
    enum proc_state state;                      // 进程状态
    int pid;                                    // 进程 ID
    int runs;                                   // 运行时间
    uintptr_t kstack;                           // 内核栈位置
    volatile bool need_resched;                 // 是否需要重新调度释放CPU　
    struct proc_struct *parent;                 // 父进程控制块
    struct mm_struct *mm;                       // 进程内存描述符
    struct context context;                     // 进程上下文
    struct trapframe *tf;                       // 当前中断帧的指针
    uintptr_t cr3;                              // 页表地址
    uint32_t flags;                             // 反应进程状态的信息，但不是运行状态，
                                                // 用于内核识别进程当前的状态，以备下一步操作
    char name[PROC_NAME_LEN + 1];               //进程名字
    list_entry_t list_link;                     // 进程的链表
    list_entry_t hash_link;                     // Process hash list
};

结合gitbook以及自己的理解对部分成员变量做详解：

• mm：内存管理的信息，包括内存映射列表、页表指针等。内核线程常驻内存，不需要考虑swap page问题，因此在lab4中mm对于内核线程就没有用了，这样内核线程的proc_struct的成员变量mm=0是合理的，mm里有个很重要的项pgdir，记录的是该进程使用的一级页表的物理地址。
• state：表示进程所处的状态
• parent：用户进程的父进程（创建它的进程）。内核根据这个父子关系建立一个树形结构，用于维护一些特殊的操作，例如确定某个进程是否可以对另外一个进程进行某种操作等等。
• context：进程的上下文，用于进程切换。在 uCore中，所有的进程在内核中也是相对独立的（例如独立的内核堆栈以及上下文等）。使用 context 保存寄存器的目的就在于在内核态中能够进行上下文之间的切换。
• tf：当前中断帧的指针。当进程从用户空间跳到内核空间时，中断帧记录了进程在被中断前的状态。当内核需要跳回用户空间时，需要调整中断帧以恢复让进程继续执行的各寄存器值。
• cr3：cr3 保存页表的物理地址，目的就是进程切换的时候方便直接使用 lcr3实现页表切换，避免每次都根据 mm 来计算 cr3。**当某个进程是一个普通用户态进程的时候，PCB 中的 cr3 就是 mm 中页表（pgdir）的物理地址；而当它是内核线程的时候，cr3 等于boot_cr3。**而boot_cr3指向了uCore启动时建立好的内核虚拟空间的页目录表首地址
• kstack: kstack记录分配给该进程/线程的内核栈的位置。每个线程都有一个内核栈，并且位于内核地址空间的不同位置。对于内核线程，该栈就是运行时的程序使用的栈；而对于普通进程，该栈是发生特权级改变的时候使保存被打断的硬件信息用的栈。

我们具体查看一下context变量：

//主要用于上下文切换保存寄存器状态
struct context {
    uint32_t eip;   //存储CPU要读取指令的地址
    uint32_t esp;   //栈指针寄存器，指向栈顶
    uint32_t ebp;   //基址指针寄存器，指向栈底
    uint32_t ebx;   //数据寄存器
    uint32_t ecx;    //计数寄存器
    uint32_t edx;    //数据寄存器
    uint32_t esi;   //变址寄存器，主要用于存放存储单元在段内的偏移量
    uint32_t edi;   //变址寄存器，主要用于存放存储单元在段内的偏移量
 
};
//需要强调的是不需要保存所有的段寄存器，因为这些都是跨内核上下文的常量
//保存的是上下文切换时前一个进程的状态现场。
//保存上下文的函数在switch.S中

查看switch.S文件，查看操作系统是如何进行上下文切换的：
容易看出**switch_to函数主要完成的是进程的上下文切换，先保存当前寄存器的值，然后再将下一进程的上下文信息保存到对于寄存器中**。

最后再强调一下几个全局变量(操作系统用来管理系统中所有的进程控制块设置的全局变量)

//所有进程控制块的双向线性列表，proc_struct中的成员变量list_link将链接入这个链表中。
extern list_entry_t proc_list;
//current：当前占用CPU且处于“运行”状态进程控制块指针
//initproc：本实验指向一个内核线程，本实验以后，此指针将指向第一个用户态进程。
extern struct proc_struct *idleproc, *initproc, *current;
//所有进程控制块的哈希表，proc_struct中的成员变量hash_link将基于pid链接入这个哈希表中。
static list_entry_t hash_list[HASH_LIST_SIZE];

实际上，通过这些数据结构信息我们基本了解了操作系统管理线程时需要处理的相关信息以及维护的数据情况，之后，便可以开始练习题的解答

练习1：分配并初始化一个进程控制块（需要编码）

alloc_proc函数（位于kern/process/proc.c中）负责分配并返回一个新的struct proc_struct结构，用于存储新建立的内核线程的管理信息。ucore需要对这个结构进行最基本的初始化，你需要完成这个初始化过程。

【提示】在alloc_proc函数的实现中，需要初始化的proc_struct结构中的成员变量至少包括：state/pid/runs/kstack/need_resched/parent/mm/context/tf/cr3/flags/name。

请在实验报告中简要说明你的设计实现过程。

答：查看alloc_proc函数，可知该函数负责创建并初始化一个新的proc_struct结构存储内核线程信息，通过kmalloc函数便可以为相关的数据信息申请获得内存空间，之后进行初始化即可。初始过程中有一个小技巧，对于包含较多变量的成员变量或占据空间较大的变量，可以使用memset进行初始化。注意思考每种变量较为合理的初始化(初始化为0或是一些特殊值之类的)。根据代码注释的提示将变量一个个初始化即可，总的来说较为容易。

代码如下:

// alloc_proc -负责创建并初始化一个新的proc_struct结构存储内核线程信息
static struct proc_struct *
alloc_proc(void) 
{
    //为创建的线程申请空间
    struct proc_struct *proc = kmalloc(sizeof(struct proc_struct));
    if (proc != NULL) 
    {
    //LAB4:EXERCISE1 YOUR CODE
    //因为没有分配物理页，故将线程状态初始为初始状态
     proc->state=PROC_UNINIT;
     proc->pid=-1; //id初始化为-1
     proc->runs=0; //运行时间为0
     proc->kstack=0; 
     proc->need_resched=0; //不需要释放CPU，因为还没有分配
     proc->parent=NULL;  //当前没有父进程，初始为null
     proc->mm=NULL;     //当前未分配内存，初始为null
     //用memset非常方便将context变量中的所有成员变量置为0
     //避免了一一赋值的麻烦。。
     memset(&(proc -> context), 0, sizeof(struct context)); 
     proc->tf=NULL;   		//当前没有中断帧,初始为null
     proc->cr3=boot_cr3;    //内核线程，cr3 等于boot_cr3
     proc->flags=0;
     memset(proc -> name, 0, PROC_NAME_LEN);
    }
    return proc;
}

问题1.1：请说明proc_struct中struct context context和struct trapframe *tf成员变量含义和在本实验中的作用是啥？（提示通过看代码和编程调试可以判断出来）**

根据提示我们查看相关的代码(通过查找定义tf以及context的函数)：

首先我们找到了kernel_thread函数和copy_thread函数，可知该函数对tf进行了设置，并对context的esp和eip进行了设置(具体设置过程在代码注释中给出)：

(这个过程代码很短，但是内容非常复杂，需要结合清华大学教学视频掌握)

/*
kernel_thread函数采用了局部变量tf来放置保存内核线程的临时中断帧，并把中断帧的指针传递给do_fork函数，而do_fork函数会调用copy_thread函数来在新创建的进程内核栈上专门给进程的中断帧分配一块空间
*/
int kernel_thread(int (*fn)(void *), void *arg, uint32_t clone_flags) {
    struct trapframe tf;
    memset(&tf, 0, sizeof(struct trapframe));
    //kernel_cs和kernel_ds表示内核线程的代码段和数据段在内核中
    tf.tf_cs = KERNEL_CS;
    tf.tf_ds = tf.tf_es = tf.tf_ss = KERNEL_DS;
    //fn指实际的线程入口地址
    tf.tf_regs.reg_ebx = (uint32_t)fn;
    tf.tf_regs.reg_edx = (uint32_t)arg;
    //kernel_thread_entry用于完成一些初始化工作
    tf.tf_eip = (uint32_t)kernel_thread_entry;
    return do_fork(clone_flags | CLONE_VM, 0, &tf);
}
static void
copy_thread(struct proc_struct *proc, uintptr_t esp, struct trapframe *tf) 
{
    //将tf进行初始化
    proc->tf = (struct trapframe *)(proc->kstack + KSTACKSIZE) - 1;
    *(proc->tf) = *tf;
    proc->tf->tf_regs.reg_eax = 0;
    //设置tf的esp，表示中断栈的信息
    proc->tf->tf_esp = esp;
    proc->tf->tf_eflags |= FL_IF;
    //对context进行设置
    //forkret主要对返回的中断处理，基本可以认为是一个中断处理并恢复
    proc->context.eip = (uintptr_t)forkret;
    proc->context.esp = (uintptr_t)(proc->tf);
}

通过上述函数并结合switch.S中对context的操作，将各种寄存器的值保存到context中。我们可以知道context是与上下文切换相关的，而tf则与中断的处理相关。具体结合gitbook上的介绍，具体回答：

proc_struct中的context：进程的上下文，用于进程切换。在 uCore中，所有的进程在内核中也是相对独立的（例如独立的内核堆栈以及上下文等）。使用 context 保存寄存器的目的就在于在内核态中能够进行上下文之间的切换。具体切换过程定义在switch.S中。

proc_struct中的tf：当前中断帧的指针。当进程从用户空间跳到内核空间时，中断帧记录了进程在被中断前的状态。当内核需要跳回用户空间时，需要调整中断帧以恢复让进程继续执行的各寄存器值。tf变量的作用在于在构造出了新的线程的时候，如果要将控制权交给这个线程，是使用中断返回的方式进行的，因此需要构造出一个伪造的中断返回现场，使得可以正确地将控制权转交给新的线程。

练习2：为新创建的内核线程分配资源（需要编码）

创建一个内核线程需要分配和设置好很多资源。kernel_thread函数通过调用do_fork函数完成具体内核线程的创建工作。do_kernel函数会调用alloc_proc函数来分配并初始化一个进程控制块，但alloc_proc只是找到了一小块内存用以记录进程的必要信息，并没有实际分配这些资源。ucore一般通过do_fork实际创建新的内核线程。do_fork的作用是，创建当前内核线程的一个副本，它们的执行上下文、代码、数据都一样，但是存储位置不同。在这个过程中，需要给新内核线程分配资源，并且复制原进程的状态。你需要完成在kern/process/proc.c中的do_fork函数中的处理过程。它的大致执行步骤包括：

• 调用alloc_proc，首先获得一块用户信息块。
• 为进程分配一个内核栈。
• 复制原进程的内存管理信息到新进程（但内核线程不必做此事）
• 复制原进程上下文到新进程
• 将新进程添加到进程列表
• 唤醒新进程
• 返回新进程号

请在实验报告中简要说明你的设计实现过程。

答：该练习非常容易，因为注释已经将实现说得非常清楚，只需要按照提示的过程一步步进行即可。当然，要完成该过程最好仔细阅读一下代码注释中标注的要使用的函数，了解用途以及用法即可。

根据注释提示我们了解几个函数用途以及用法：

//创建一个proc并初始化所有成员变量
void alloc_proc(void) 
//为一个内核线程分配物理页
static int setup_kstack(struct proc_struct *proc)
//暂时未看出其用处，可能是之后的lab会用到
static int copy_mm(uint32_t clone_flags, struct proc_struct *proc)
//复制原进程上下文到新进程
static void copy_thread(struct proc_struct *proc, uintptr_t esp, struct trapframe *tf)
//返回一个pid
static int get_pid(void)
//将proc加入到hash_list
static void hash_proc(struct proc_struct *proc)
// 唤醒该线程，即将该线程的状态设置为可以运行
void wakeup_proc(struct proc_struct *proc);

了解以上函数后，根据提示，很容易完成do_fork函数：

int
do_fork(uint32_t clone_flags, uintptr_t stack, struct trapframe *tf) {
    int ret = -E_NO_FREE_PROC;
    struct proc_struct *proc;
    if (nr_process >= MAX_PROCESS) {
        goto fork_out;
    }
    ret = -E_NO_MEM;
    //1. call alloc_proc to allocate a proc_struct
    if((proc=alloc_proc())==NULL) 
        goto fork_out;
    proc->parent=current;
    // 2. call setup_kstack to allocate a kernel stack for child process
    if (setup_kstack(proc)!=0)
        goto bad_fork_cleanup_proc;
    // 3. call copy_mm to dup OR share mm according clone_flag
    if(copy_mm(clone_flags, proc)!=0)
        goto bad_fork_cleanup_proc;
    // 4. call copy_thread to setup tf & context in proc_struct
    copy_thread(proc,stack,tf);  
    // 5. insert proc_struct into hash_list && proc_list
    proc->pid = get_pid(); //创建一个id
    // 将线程放入使用hash组织的链表以及所有线程的链表中
    hash_proc(proc); 
    list_add(&proc_list, &proc->list_link); 
    nr_process ++;  // 将全局线程的数目加1
    // 6. call wakup_proc to make the new child process RUNNABLE
    wakeup_proc(proc);
    // 7. set ret vaule using child proc's pid
     ret = proc->pid; // 返回新线程的pid
fork_out:
    return ret;

bad_fork_cleanup_kstack:
    put_kstack(proc);
bad_fork_cleanup_proc:
    kfree(proc);
    goto fork_out;
}

完成后，运行make qemu，查看运行结果：

为了更加确定执行正确，执行make grade:
故可以确定练习1、2均成功完成。

问题2.1：请说明ucore是否做到给每个新fork的线程一个唯一的id？请说明你的分析和理由。

为了回答这个问题，必须从给fork id的函数入手，也就是get_pid()函数，查看get_pid()的代码：

（分配id的过程在代码注释中给出）

// get_pid - alloc a unique pid for process
static int
get_pid(void) {
    //实际上，之前定义了MAX_PID=2*MAX_PROCESS，意味着ID的总数目是大于PROCESS的总数目的
    //因此不会出现部分PROCESS无ID可分的情况
    static_assert(MAX_PID > MAX_PROCESS);
    struct proc_struct *proc;
    list_entry_t *list = &proc_list, *le;
    //next_safe和last_pid两个变量，这里需要注意！ 它们是static全局变量！！！
    static int next_safe = MAX_PID, last_pid = MAX_PID;
    //++last_pid>-MAX_PID,说明pid以及分到尽头，需要从头再来
    if (++ last_pid >= MAX_PID) 
    {
        last_pid = 1;
        goto inside;
    }
    if (last_pid >= next_safe) 
    {
    inside:
        next_safe = MAX_PID;
    repeat:
        //le等于线程的链表头
        le = list;
        //遍历一遍链表
        //循环扫描每一个当前进程：当一个现有的进程号和last_pid相等时，则将last_pid+1；
            //当现有的进程号大于last_pid时，这意味着在已经扫描的进程中
          //[last_pid,min(next_safe, proc->pid)] 这段进程号尚未被占用，继续扫描。
        while ((le = list_next(le)) != list) 
        { 
            proc = le2proc(le, list_link);
            //如果proc的pid与last_pid相等，则将last_pid加1
            //当然，如果last_pid>=MAX_PID,then 将其变为1
            //确保了没有一个进程的pid与last_pid重合
            if (proc->pid == last_pid) 
            {
                if (++ last_pid >= next_safe) 
                {
                    if (last_pid >= MAX_PID) 
                    {
                        last_pid = 1;
                    }
                    next_safe = MAX_PID;
                    goto repeat;
                }
            }
            //last_pid
            else if (proc->pid > last_pid && next_safe > proc->pid) 
            {
                next_safe = proc->pid;
            }
        }
    }
    return last_pid;
}

说实话，这段代码很难看懂。看了很久才大致掌握思想。

必须注意的是 next_safe和last_pid两个变量，需要注意：它们是static全局变量！！！

通过代码的解释很直观知道get_id将为每个调用fock的线程返回不同的id。

之所以按照这样的过程来找寻id，因为暴力搜索复杂度较高，我认为操作系统内部的算法应强调小而快。其次，维护一个合法的pid的区间，不仅优化了时间效率，而且不同的调用get_pid函数的时候可以利用到先前调用这个函数的中间结果去求解；

练习3：阅读代码，理解 proc_run 函数和它调用的函数如何完成进程切换的。（无编码工作）

要理解proc_run函数，首先需要查看唯一一个调用它的函数：schedule函数，其实很容易schedule函数定义的是一个FIFO算法，找到第一个可调度的进程即调用

void
schedule(void) {
    bool intr_flag; //定义中断变量
    list_entry_t *le, *last; //当前list，下一list
    struct proc_struct *next = NULL; //下一进程
    //关闭中断
    local_intr_save(intr_flag); 
    {
        current->need_resched = 0; 
      //last是否是idle进程(第一个创建的进程),如果是，则从表头开始搜索  否则获取下一链表
        last = (current == idleproc) ? &proc_list : &(current->list_link);
        le = last; 
        //循环找到可调度的进程
        do 
        { 
            if ((le = list_next(le)) != &proc_list) 
            {
                //获取下一进程
                next = le2proc(le, list_link);
                //找到一个可以调度的进程，break
                if (next->state == PROC_RUNNABLE) 
					break;
            }
        } while (le != last);
        //如果没有找到可调度的进程
        if (next == NULL || next->state != PROC_RUNNABLE) 
        {
            next = idleproc; 
        }
        next->runs ++; //运行次数加一
        //运行新进程,调用proc_run函数
        if (next != current)
        {
            proc_run(next); 
        }
    }
    //恢复中断
    local_intr_restore(intr_flag); 
}

schedule函数的执行逻辑：1．设置当前内核线程current->need_resched为0； 2．在proc_list队列中查找下一个处于“就绪”态的线程或进程next； 3．找到这样的进程后，就调用proc_run函数，保存当前进程current的执行现场（进程上下文），恢复新进程的执行现场，完成进程切换

再看proc_run函数:

// proc_run - make process "proc" running on cpu
// NOTE: before call switch_to, should load  base addr of "proc"'s new PDT
void proc_run(struct proc_struct *proc) 
{  //判断一下要调度的进程是不是当前进程
    if (proc != current) 
    {
        bool intr_flag;
        struct proc_struct *prev = current, *next = proc;
        // 关闭中断
        local_intr_save(intr_flag);
        {
            //当前进程设为待调度的进程
            current = proc;
            //加载待调度进程的内核栈基地址
            load_esp0(next->kstack + KSTACKSIZE);
            //将当前的cr3寄存器改为需要运行进程的页目录表
            lcr3(next->cr3);
            //进行上下文切换，保存原线程的寄存器并恢复待调度线程的寄存器
            switch_to(&(prev->context), &(next->context));
        }
        //恢复中断
        local_intr_restore(intr_flag);
    }
}

switch_to函数在上面已经详解过，主要就是保存之前进程的相关寄存器值，恢复现在进程的相关寄存器的值。

因此根据代码以及注释很容易理解proc_run函数的过程。

问题3.1：在本实验的执行过程中，创建且运行了几个内核线程？

通过kernel_thread函数、proc_init函数以及具体的实现结果可知，本次实验共建立了两个内核线程。首先是idleproc内核线程，该线程是最初的内核线程，完成内核中各个子线程的创建以及初始化。之后循环执行调度，执行其他进程。还有一个是initproc内核线程，该线程主要是为了显示实验的完成而打印出字符串"hello world"的内核线程。

问题3.2：语句local_intr_save(intr_flag);..local_intr_restore(intr_flag);在这里有何作用?请说明理由

该语句应该是关闭中断以及恢复中断。在操作系统理论课上"进程同步"中讲过类似的操作–原子操作。在此处应该是可以把这一过程视为原子操作的，主要目的是避免在运行过程中被其他中断打断，或是被其他线程修改了相关变量的值导致程序结果与预期不符。

实验具体实现时的一些感受：

在完成练习2的时候，我根据注释很容易完成了代码，并且通过了测试，但是当看到练习3中相关代码时我发现已给的代码中有些地方存在类似于“原子操作”的做法，我仔细思考了该做法的意义，觉得这是一个非常良好的编程习惯。我的代码虽然能够运行，但是如果出现多线程对统一数据调用时很可能导致数据不统一问题，因此在练习2中我进行了部分修改，在设置fork的线程的关键信息以及将其加入proc列表的时候关闭了中断，防止被中断打断操作，从而导致存储线程的信息的不一致。

具体修改如下：

 //原来的：
    proc->pid = get_pid(); 
    hash_proc(proc); 
    list_add(&proc_list, &proc->list_link); 
    nr_process ++; 
 // 改后的： 
  local_intr_save(intr_flag);
    {
        proc->pid = get_pid();
        hash_proc(proc);
        list_add(&proc_list, &proc->list_link); 
    	nr_process ++;
    }
    local_intr_restore(intr_flag);

参考资料

gitbook上相关内容，其中对很多知识点的解释非常详细，认真看收获非常大，对完成实验内容帮助很大

清华大学学堂在线操作系统教学视频，该视频对理论进行了很好、很详细的讲解，并对实验部分进行了大致介绍

CSDN上与进程和线程、上下文切换、进程状态转移、进程基本调度等相关的内容

操作系统理论课书籍

虚拟机遇到的一个小问题

这次虚拟机又遇到了之前遇到过的一个问题，但这次查找到了很好的解决方案，很快便完成解决。

非常感谢 https://www.jianshu.com/p/2e3429d45aea 提供的解决方案

遇到的问题：

解决办法：

首先关闭Hyper-V，查看是否可用，如果不行，继续下一步骤。

以管理员身份运行命令提示符 ，执行命令 bcdedit /set hypervisorlaunchtype off ，之后重启，运行vm即可

尝试后解决了问题。

如果给你带来了帮助，可点击关注，博主将继续努力推出好文。