操作系统实验报告 lab4

练习0 填写已有实验

本实验依赖实验1～实验3。请把已做的实验1～实验3的代码填入本实验中代码中有lab1，lab2，lab3的注释部分。

运用meld软件进行比较，截图如下：

可以看到，需要补全的文件是

default_pmm.c
pmm.c
swap_fifo.c
vmm.c
trap.c

---

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

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

关键数据结构 struct proc_struct

    struct proc_struct {  
        enum proc_state state; // Process state  
        int pid; // Process ID  
        int runs; // the running times of Proces  
        uintptr_t kstack; // Process kernel stack  
        volatile bool need_resched; // need to be rescheduled to release CPU?  
        struct proc_struct *parent; // the parent process  
        struct mm_struct *mm; // Process's memory management field  
        struct context context; // Switch here to run process  
        struct trapframe *tf; // Trap frame for current interrupt  
        uintptr_t cr3; // the base addr of Page Directroy Table(PDT)  
        uint32_t flags; // Process flag  
        char name[PROC_NAME_LEN + 1]; // Process name  
        list_entry_t list_link; // Process link list  
        list_entry_t hash_link; // Process hash list  
    };  

下面对参数进行简单的讲解

mm：内存管理的信息，包括内存映射列表、页表指针等。
state：进程所处的状态。
parent：用户进程的父进程（创建它的进程）。
kstack：记录了分配给该进程/线程的内核桟的位置。
need_resched：是否需要调度
context：进程的上下文，用于进程切换
tf：中断帧的指针
cr3: cr3 保存页表的物理地址

代码填写

根据题目中的提示填写代码

    static struct proc_struct *  
    alloc_proc(void) {  
        struct proc_struct *proc = kmalloc(sizeof(struct proc_struct));  
        if (proc != NULL) {  
        //LAB4:EXERCISE1 YOUR CODE  
        /* 
         * below fields in proc_struct need to be initialized 
         *       enum proc_state state;                      // Process state 
         *       int pid;                                    // Process ID 
         *       int runs;                                   // the running times of Proces 
         *       uintptr_t kstack;                           // Process kernel stack 
         *       volatile bool need_resched; // bool value: need to be rescheduled to release CPU? 
         *       struct proc_struct *parent;                 // the parent process 
         *       struct mm_struct *mm;               // Process's memory management field 
         *       struct context context;                     // Switch here to run process 
         *       struct trapframe *tf;                       // Trap frame for current interrupt 
         *       uintptr_t cr3;      // CR3 register: the base addr of Page Directroy Table(PDT) 
         *       uint32_t flags;                             // Process flag 
         *       char name[PROC_NAME_LEN + 1];               // Process name 
         */  
            proc->state = PROC_UNINIT;  //设置进程为“初始”态  
            proc->pid = -1; //设置进程pid的未初始化值  
            proc->runs = 0;//初始化时间片  
            proc->kstack = 0;//内核栈的地址  
            proc->need_resched = 0;//是否需要调度  
            proc->parent = NULL;//父节点为空  
            proc->mm = NULL; //内存管理初始化  
            memset(&(proc->context), 0, sizeof(struct context));//进程上下文初始化  
            proc->tf = NULL; //中断帧指针置为空，总是能够指向中断前的trapframe  
            proc->cr3 = boot_cr3;//设置内核页目录表的基址  
            proc->flags = 0; //标志位初始化  
            memset(proc->name, 0, PROC_NAME_LEN); //进程名初始化  
        }  
        return proc;  
    }  

context和*tf的作用分析

①context：进程的上下文，用于进程切换。起到的作用就是保存了现场。在 ucore中，所有的进程在内核中也是相对独立的，因此context 保存寄存器的目的就在于在内核态中能够进行上下文之间的切换。实际利用context进行上下文切换的函数是在kern/process/switch.S中定义switch_to。

② tf：中断帧的指针，总是指向内核栈的某个位置：当进程从用户空间跳到内核空间时，中断帧记录了进程在被中断前的状态。当内核需要跳回用户空间时，需要调整中断帧以恢复让进程继续执行的各寄存器值。除此之外，ucore内核允许嵌套中断。因此为了保证嵌套中断发生时tf 总是能够指向当前的tf，ucore 在内核栈上维护了 tf 的链。

---

练习2 为新创建的内核线程分配资源

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

扫描二维码关注公众号，回复： 10940559 查看本文章

执行步骤

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

代码填写

根据代码提示填写代码如下，同时标注了对于代码的认识理解

    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;  
        //LAB4:EXERCISE2 YOUR CODE  
        /* 
         * Some Useful MACROs, Functions and DEFINEs, you can use them in below implementation. 
         * MACROs or Functions: 
         *   alloc_proc:   create a proc struct and init fields (lab4:exercise1) 
         *   setup_kstack: alloc pages with size KSTACKPAGE as process kernel stack 
         *   copy_mm:      process "proc" duplicate OR share process "current"'s mm according clone_flags 
         *                 if clone_flags & CLONE_VM, then "share" ; else "duplicate" 
         *   copy_thread:  setup the trapframe on the  process's kernel stack top and 
         *                 setup the kernel entry point and stack of process 
         *   hash_proc:    add proc into proc hash_list 
         *   get_pid:      alloc a unique pid for process 
         *   wakup_proc:   set proc->state = PROC_RUNNABLE 
         * VARIABLES: 
         *   proc_list:    the process set's list 
         *   nr_process:   the number of process set 
         */  

        //    1. call alloc_proc to allocate a proc_struct  
        //    2. call setup_kstack to allocate a kernel stack for child process  
        //    3. call copy_mm to dup OR share mm according clone_flag  
        //    4. call copy_thread to setup tf & context in proc_struct  
        //    5. insert proc_struct into hash_list && proc_list  
        //    6. call wakup_proc to make the new child process RUNNABLE  
    //    7. set ret vaule using child proc's pid  
    //第一步：申请内存块，如果失败，直接返回处理  
        if ((proc = alloc_proc()) == NULL) {  
            goto fork_out;  
        }  
    //将子进程的父节点设置为当前进程  
        proc->parent = current;  
    //第二步：为进程分配一个内核栈  
        if (setup_kstack(proc) != 0) {  
            goto bad_fork_cleanup_proc;  
    }  
    //第三步：复制父进程的内存信息到子进程  
        if (copy_mm(clone_flags, proc) != 0) {  
            goto bad_fork_cleanup_kstack;  
        }  
        //第四步：复制父进程相关寄存器信息（上下文）  
    copy_thread(proc, stack, tf);  
    //第五步：将新进程添加到进程列表（此过程需要加保护锁）  
        bool intr_flag;  
        local_intr_save(intr_flag);  
        {  
            proc->pid = get_pid();  
    //建立散列映射方便查找  
            hash_proc(proc);  
    //将进程链节点加入进程列表  
            list_add(&proc_list, &(proc->list_link));  
    //进程数+1  
            nr_process ++;  
        }  
        local_intr_restore(intr_flag);  
    //第六步：一切准备就绪，唤醒子进程  
        wakeup_proc(proc);  
    //第七步：别忘了设置返回的子进程号  
        ret = proc->pid;  
    fork_out:  
        return ret;  

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

在使用 fork 或 clone 系统调用时产生的进程均会由内核分配一个新的唯一的PID值。
具体来说，就是在分配PID时，设置一个保护锁，暂时不允许中断，保证了ID的唯一性。上述操作真正完成了资源分配的工作，与第一步中的工作有着明显的区别。do_fork只是创建当前进程的副本，他们执行的上下文，寄存器，代码都是一样的。

---

练习3 理解proc_run和它调用的函数如何完成进程切换的

schedule代码分析

在分析 proc_run 函数之前，我们先分析调度函数 schedule() 。
schedule()代码如下：

void
schedule(void) {
    bool intr_flag;
    list_entry_t *le, *last;
    struct proc_struct *next = NULL;
    local_intr_save(intr_flag);
    {
        current->need_resched = 0;
        last = (current == idleproc) ? &proc_list : &(current->list_link);
        le = last;
        do {
            if ((le = list_next(le)) != &proc_list) {
                next = le2proc(le, list_link);
                if (next->state == PROC_RUNNABLE) {
                    break;
                }
            }
        } while (le != last);
        if (next == NULL || next->state != PROC_RUNNABLE) {
            next = idleproc;
        }
        next->runs ++;
        if (next != current) {
            proc_run(next);
        }
    }
    local_intr_restore(intr_flag);
}

简单介绍一下schedule的执行过程：
①设置当前内核线程current->need_resched为0；
②proc_list队列存储着所有状态的进程/线程，在其中查找下一个处于“就绪”态的线程或进程next；
③找到这样的进程后，就调用proc_run函数，保存当前进程current的执行现场（进程上下文），恢复新进程的执行现场，完成进程切换。
至此，新的进程next就开始执行了。由于在proc10中只有两个内核线程，且idleproc要让出CPU给initproc执行，我们可以看到schedule函数通过查找proc_list进程队列，只能找到一个处于“就绪”态的initproc内核线程。

proc_run代码分析

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);
            lcr3(next->cr3);
            switch_to(&(prev->context), &(next->context));
        }
        local_intr_restore(intr_flag);
    }
}

通过proc_run和进一步的switch_to函数完成两个执行现场的切换，具体流程如下：
①让current指向next内核线程initproc；
②设置任务状态段ts中特权态0下的栈顶指针esp0为next内核线程initproc的内核栈的栈顶，即next->kstack + KSTACKSIZE ；
③设置CR3寄存器的值为next内核线程initproc的页目录表起始地址next->cr3，这实际上是完成进程间的页表切换；
由switch_to函数完成具体的两个线程的执行现场切换，即切换各个寄存器，当switch_to函数执行完“ret”指令后，就切换到initproc执行了。

switch_to函数分析

switch_to函数的执行流程：

.globl switch_to  
switch_to: # switch_to(from, to)  
# 保存前一个进程的执行现场，前两条汇编指令（如下所示）保存了进程在返回switch_to函数后的指令地址到context.eip中  
movl 4(%esp), %eax # eax points to from  
popl 0(%eax) # esp--> return address, so save return addr in FROM’s 
# 保存前一个进程的其他7个寄存器到context中的相应成员变量中。 
movl %esp, 4(%eax)
movl %ebx, 8(%eax)
movl %ecx, 12(%eax)
movl %edx, 16(%eax)
movl %esi, 20(%eax)
movl %edi, 24(%eax)
movl %ebp, 28(%eax) 
#再往后是恢复向一个进程的执行现场，这其实就是上述保存过程的逆执行过程，即从 context 的高地址的域 ebp 开始，逐一把相关域的值赋值给对应的寄存器。

设置了initproc->context.eip = (uintptr_t)forkret，这样，当执行switch_to函数并返回后，initproc将执行其实际上的执行入口地址forkret。

运行截图

---

实验总结

本次实验主要针对内核线程的管理，所有内核线程直接使用共同的ucore内核内存空间，而用户进程需要维护各自的用户内存空间。以及了解到了进程切换的相关细节操作，更加深一步的了解了操作系统。