环境

ubuntu 20.04 64位系统
之前有些实验是在xv6的源码上操作的，发现20.04无法运行。后来发现lab还是可以在20.04正常做的，就把环境切换到本机上了。

lab地址:mit 6.828 lab3

废话

这次实验感觉难做了不少，参考了别人不少的代码。毕竟代码是别人写的，要花心思去理解别人的思路。注释里面的提示我也觉得有点模棱两可。做起来比较困难，还存在一些问题都没有很好理解。完成本lab最好阅读一下xv6 book的trap和page table这两节。

正文

先说在前面，本次lab里面提到的environment就是进程(process)，不知道为什么要起这样奇奇怪怪的名字。
新引入的文件inc/env.h包括了JOS中envrionment的基本定义(当成进程来就完事儿了)。kernel使用Env这个struct来操作每一个用户进程。在本次lab当中你只需要创建一个进程，但是你需要让JOS能够支持多进程;lab4将会是用这个特性通过使用fork来创建一个新的用户进程。
几个关键的变量(kern/env.c):

struct Env *envs = NULL;        // All environments
struct Env *curenv = NULL;      // The current env
static struct Env *env_free_list;   // Free environment list

注释里面写的很明白了，envs指向所有的进程，curenv指向当前正在运行的进程，env_free_list是一个空闲进程的链表。当JOS启动的时候，envs指向了系统所有的进程。在JOS中，所有的同时可运行的进程数量为NENV个（(NENV在inc/env.h当中)）,1<<LOG2NENV=1024，这也就是说JOS最多可以同时运行1024个进程。

当我们需要创建一个新的进程的时候，只需要从env_free_list中拿一个出来，然后放到envs当中就行。都知道链表对于添加和删除是非常方便的。
下面是进程的定义:

struct Env {
    struct Trapframe env_tf;    // Saved registers
    struct Env *env_link;       // Next free Env
    envid_t env_id;         // Unique environment identifier
    envid_t env_parent_id;      // env_id of this env's parent
    enum EnvType env_type;      // Indicates special system environments
    unsigned env_status;        // Status of the environment
    uint32_t env_runs;      // Number of times environment has run

    // Address space
    pde_t *env_pgdir;       // Kernel virtual address of page dir
};

• env_tf: 这个进程所属的寄存器的值，当发生进程切换到时候，我们需要保存当前正在运行的进程的寄存器的值。
• env_link:这个就是相当于链表中的next，指向下一个节点，这样才能够把所有env串起来
• env_id:进程的ID
• env_parent_id:附进程的ID
• env_type: 进程的类型，虽然大部分都进程都是ENV_TYPE_USER.（）用户进程
• env_status: ENV_FREE表示这个Env结构是空闲的，也就说它还在env_free_list当中，可以被分配使用。ENV_RUNNABLE表示这个进程可运行。比如说我们从硬盘中加载这个进程的代码到内存当中，初始化它的寄存器后，那么此时这个进程就是runnable了。ENV_RUNNING表示这个进程正在占用CPU。ENV_NOT_RUNNABLE这个就是进程被挂起了，这个进程此时激活的(inactive)的，但是还没准备好运行，比如说等待硬盘或者网络的IO结束。ENV_DYINGzombie进程，它此时还在内存中没有被释放，当下一次时钟中断发生的时候且轮到它执行，kernel发现他是zombie就会将他释放了(本次lab没有涉及到这个)
• env_pgdir：这个进程的page directory的虚拟地址,注意看是虚拟地址。
  JOS中的environment和xv6中的process是差不多一个东西，就是JOS中的environemnt没有进程自己的栈，所以JOS使用的栈是内核栈

Allocating the Environments Array
在lab2当中，我们为pages[]这个数组分配了内存。现在我们需要为envs这个数组分配内存。envs应该放在UENVS开始的地方并且要让用户程序也可以访问。
这个和lab2当中对pages的操作差不多，在 kern/pmap.c 中加入下面的代码:

 //为envs分配内存
envs = (struct Env*) boot_alloc(NENV * sizeof(struct Env));
memset(envs,0, NENV* sizeof (struct Env));
//将envs映射到UENVS开始的地方,注意PTE_U,因为用户程序也要访问

boot_map_region(kern_pgdir,UENVS,PTSIZE,PADDR(envs),PTE_U | PTE_P);

Creating and Running Environments
接下来我们要写一些代码来运行进程，因为我们此时还没有文件系统，所以我们在内核当中嵌入了一些进程镜像，这些镜像也是ELF格式的。
Exercise 2

env_init():初始化所有的Env结构，并且放到env_free_list当中
env_setup_vm():为进程分配page directory,并且在页表中分配kernel所属的内存。
region_alloc():为进程分配物理内存
load_icode():将ELF文件加载为进程（毕竟ELF文件是无法直接运行的）
env_create():调用env_alloc()，env_alloc()初始化好进程所需要的东西，然后还需要使用load_icode()为这个进程加载ELF镜像
env_run():运行用户进程

一上来就直接实现这几个函数可能十分的难，所以首先先来整理下这些函数的调用关系，如下图所示:

函数关系

env_init():
在前面我们已经位envs分配好了内存空间。env_init()的目的就是可用的进程串到env_free_list当中。根据注释中的提示信息，它要求我们数组中进程的顺序和链表中的顺序要相同。所以for从数组的后面开始，然后使用头插法插入到链表当中，从而使得链表中的第一个元素就是数组的envs[0]。知道了链表的头插法插入数据后，代码应该很好理解

void env_init(void)
{
    // Set up envs array
    // LAB 3: Your code here.
    for(int i = NENV-1; i >= 0; i--) {
        //头插法
        envs[i].env_id = 0;
        envs[i].env_status = ENV_FREE;
        envs[i].env_link = env_free_list;
        env_free_list = &envs[i];
    }
    // Per-CPU part of the initialization
    env_init_percpu();
}

env_setup_vm():
新的进程要有自己的page directory。阅读下xv6 book page table这一节(有点忘了，应该是在这节)，我们知道每一个进程的地址空间都分为kernel portion和user space portion。这样一来就理解了注释中说的初始化kernel portion。page_alloc()用于分配一个物理页，返回可用的物理页对应的PageInfo结构。前面说了env_pgdir是虚拟地址，所以我们使用page2kva()将PageInfo结构转为虚拟地址。然后根据注释，我们不需要初始化地址空间中属于用户程序的那部分，所以e->env_pgdir[i] = 0;。但是需要初始化地址空间中属于内核的那部分，所以这一部分只需要将内核的page directory中page directory复制过来就行，e->env_pgdir[i] = kern_pgdir[i];最后在进程自己的page directory将page directory对应的page entry写入就行。

    int i = 0;
    struct PageInfo *p = NULL;

    // Allocate a page for the page directory
    if (!(p = page_alloc(ALLOC_ZERO)))
        return -E_NO_MEM;
    e->env_pgdir = (pde_t *)page2kva(p);
    p->pp_ref++;
    for(; i<PDX(UTOP); i++){
        e->env_pgdir[i] = 0;
    }

    for(; i<NPDENTRIES; i++){
        e->env_pgdir[i] = kern_pgdir[i];
    }
        //进程的页目录表
    e->env_pgdir[PDX(UVPT)] = PADDR(e->env_pgdir) | PTE_P | PTE_U;

region_alloc():
这个函数主要完成的是:将进程的虚拟地址va和物理地址映射起来，长度是len。在前面的函数中，我们可以使用env_setup_vm()来获得page directory。想象一下，建立新的映射关系，相当于往page table(页表)中加入page table(当然有时候page table可能在page directory中还不存在，所以需要现在page directory存放page table的地址，这个工作室pgdir_walk()完成的，忘了的老铁可以看一下pgdir_walk()的实现)。另外注释也说了，注意起始地址和结束地址的对齐，所以我们还需要调用一下ROUNDUP和ROUNDDOWN。

    uintptr_t va_start =(uintptr_t) ROUNDDOWN(va,PGSIZE);
    uintptr_t va_end = (uintptr_t)ROUNDUP(va+len,PGSIZE);
    struct PageInfo *p;
    int result;
    for(uintptr_t i = va_start; i < va_end; i += PGSIZE) {
        p = page_alloc(ALLOC_ZERO);  //申请一个页
        result = page_insert(e->env_pgdir,p,(void *)i,PTE_W | PTE_U); //插入新申请的页到page table 当中
        if( p == NULL || result != 0) {
            cprintf("region_alloc:allocate memory failed");
        }
    }

load_icode():
这个代码有一个点比较有意思。这个函数要实现的就是将elf文件加载到它指定的内存地址当中去。这一过程和之前在boot阶段加载内核比较相似。为了将进程放到用户程序所属的地址空间去，肯定需要切换cr3寄存器，然后加载完了之后在切换到内核的page directory。因此这里引出一个问题，变换了cr3寄存器的内容，为什么代码还可以执行？ 因为，我们在之前在用户进程中的page directory中把属于内核的那部分从内核的page directory中复制过来了，所以可以继续执行。 接下来要做的就是，加载用户程序。根据注释，我们只加载ph->p_type == ELF_PROG_LOAD的program header。每一个program header要被加载到的虚拟地址是ph->p_va。进程所需要的空间为ph->p_filesz 字节，这些字节是从binary + ph->p_offset开始的，应该复制到ph->p_va去。它还提到，通常来说ph->p_filesz <= ph->p_memsz,这里关于为什么直接去google搜下就行。还有一点,e->env_pgdir是虚拟地址在，所以我们在放入cr3寄存器的时候，需要用PADDR()将他转为物理地址。

    struct Elf *ELF_Header = (struct Elf*)binary; 
    if (ELF_Header->e_magic != ELF_MAGIC)
        panic("The binary is not a ELF magic!\n");
    e->env_tf.tf_eip = ELF_Header->e_entry;
    lcr3(PADDR(e->env_pgdir)); //切换cr3寄存器，这样才能操作用户程序的地址空间
    struct Proghdr *ph, *eph;    
    ph = (struct Proghdr *) ((uint8_t *) ELF_Header + ELF_Header->e_phoff); // 获得program header的地址
    eph = ph + ELF_Header->e_phnum;
    for (; ph < eph; ph++)
        if(ph->p_type == ELF_PROG_LOAD){
            if(ph->p_memsz < ph->p_filesz)
                panic("segment out of memory!\n");
            region_alloc(e, (void *)ph->p_va, ph->p_memsz);    //为进程申请内存
            memset((void *)ph->p_va, 0, ph->p_memsz);//这里注释解释了，先初始化进程空间的内容
            memcpy((void *)ph->p_va, binary+ph->p_offset, ph->p_filesz);//复制进程的内容
        }
    
    region_alloc(e, (void *)(USTACKTOP-PGSIZE), PGSIZE); //申请栈空间
    lcr3(PADDR(kern_pgdir));  //切换到内核的cr3

env_create():
创建一个新的进程，这个没啥好说的，比较简单，直接贴代码吧

void
env_create(uint8_t *binary, enum EnvType type)
{
    // LAB 3: Your code here.
    struct Env *e;
    if(env_alloc(&e, 0)<0)
        panic("fail to create a env!\n");
    load_icode(e, binary);
    e->env_type = type;
}

env_run():
这个也不怎么难，根据注释应该可以完成，直接贴代码吧,注意要把panic给注释了

void
env_run(struct Env *e)
{
    if (curenv && curenv->env_status == ENV_RUNNING) {
        curenv->env_status = ENV_RUNNABLE;
    }
    curenv = e;
    curenv->env_status = ENV_RUNNING;
    curenv->env_runs++;
    lcr3(PADDR(curenv->env_pgdir));
    
    env_pop_tf(&(curenv->env_tf));
}

当我们完成这些函数时候，如果此时我们直接运行make qemu,会发现qemu会一直重复输出一些内容,如下图

make qemu

iret语句

cmp

对照下entry的源代码，我们成功了。

Handling Interrupts and Exceptions

官网中关于中断和异常的文字比较多，翻译比较花时间，就不翻译了，应该也不是特别难懂（如果你已经知道一些关于x86的异常和中断处理的过程）。简单的来说,x86处理器有一个IDT用于存放所有的中断或者异常的处理函数。比如说int 1就是调用1号中断，CPU会从IDT中拿出这个中断处理函数的CS和EIP。然后跳转到中断处理函数去执行。当内核处理完中断后，还需要返回到用户程序，所以内核需要将用户程序的所属的各个寄存器的值保存起来。在JOS中，inc/trap.h定义了Trapframe这个结构，用于保存用户程序的各个寄存器。另外，当用户程序发生异常的时候(比如说除0)，往往需要发生特权级的转移(由CPL=3转移到CPL=0)。内核是最重要的，所以不能枉然的使用用户程序的栈，也因此我们需要由内核栈切换到用户栈。为了获得内核栈的地址，有一个结构叫做TSS(task state segment),我们事先在里面写入了内核栈的地址。当发生了特权级转换的时候，处理器会从TSS中取得内核的栈地址，并且将用户程序的ss,esp,eflags,cs,eip压入到内核栈当中，这些是处理去做的。所以我们还需要手动的压入那些通用寄存器（待会要做的_alltraps要做的事情）。当然有时候内核也会发生异常，当在内核的中断处理函数中发生异常的时候，此时的就不需要压入栈了。只需要压入cs,eip,eflags就行。这种在中断中发生中断的情况叫做nested exceptions and interrupts(嵌套的中断和异常).
Setting Up the IDT
阅读完官网的那些文字，接下来要做的就是设置好IDT(interrupt descriptor table)和以及对应的中断处理函数。到现在为止，我们只需要设置0-31这些中断。下面这幅图描述了基本的流程:

idt

修改 trapentry.S和trap.c文件并且实现上面说的功能。两个宏函数TRAPHANDLER和TRAPHANDER_NOEC还有定义在inc/trap.h中的T_*(一开始没看懂，原来就是说一些宏定义)对你很有帮助。你需要在trapentry.S中为每一个中断实现他们的entry point。还要实现一个_alltraps。你还需要修改trap_init()函数来初始化idt。
_alltraps:

1. 往栈里面压入值，使得栈看起来像一个trapframe
2. 加载GD_KD到ds和es寄存器
3. 压入esp作为参数传给trap()
4. 调用 trap

实现代码的前戏:
这道题的代码一开始我是做不来的，参考了别人的代码做完的。首先我们要做的是实现中断的entry point，题目要求说了在trapentry.S中写好entry point，注意这里要使用那两个宏函数来完成。首先先来讲解一下这两个宏函数,简书的markdown太垃圾了，竟然把宏函数给注释掉了，认真观察。
TRAPHANDLER:

#define TRAPHANDLER(name, num)                      \
    .globl name;        /* define global symbol for 'name' */   \
    .type name, @function;  /* symbol type is function */       \
    .align 2;       /* align function definition */     \
    name:           /* function starts here */      \
    pushl $(num);                           \
    jmp _alltraps

TRAPHANDLER_NOEC:

#define TRAPHANDLER_NOEC(name, num)                 \
    .globl name;                            \
    .type name, @function;                      \
    .align 2;                           \
    name:                               \
    pushl $0;                           \
    pushl $(num);                           \
    jmp _alltraps

如果你仔细阅读了上面的文字，知道在中断中有一些中断会使得处理器压入error code,有些不会压入error code。看一下这两个宏定义的代码以及注释，可以看到这俩的区别就是：有些中断不会压入error code,所以TRAPHANDLER_NOEC有一条语句push 0用来替代没有error code的情况。通过这两个宏定义，我们把中断处理函数的entry point变得更加通用了。
此时我们大概了解了要借助于这两个宏函数来完成entry point的过程，另外一个关键点就是在idt中初始化一下。了解过C语言编译的过程，我们知道宏函数在编译的时候是被直接替换的，所以上面提到的TRAPHEANDLER和TRAPHANDLER_NOEC会被直接替换为对应的标号。我们只要把这些标号放入到每一个IDT成员中就行了，IDT就初始化完成了。
还有一个问题就是完成_alltraps。前面提到过，由用户程序切换到内核，我们需要保存用户程序的各个寄存器信息，这些信息都被保存到用户程序的Trapframe里面。_alltraps要做的事情就是构建一个trapframe接着代码跳转到trap()当中去执行。帮助理解，下面是trapframe的图示:

_alltraps

trap_init():
首先先做的就是初始化IDT，我们要填充kern/trap.c的trap_init()的代码。我们需要初始化的中断定义在inc/trap.h当中。与之对应我们声明一些中断处理函数,比如说除0，就叫divide_handler()下面是所有的中断处理函数。注意，只需要声明，具体的函数是在trapentry.S当中的。

void divide_handler();
void debug_handler();
void nmi_handler();
void brkpt_handler();
void oflow_handler();
void bound_handler();
void device_handler();
void illop_handler();
void tss_handler();
void segnp_handler();
void stack_handler();
void gpflt_handler();
void pgflt_handler();
void fperr_handler();
void align_handler();
void mchk_handler();
void simderr_handler();
void syscall_handler();
void dblflt_handler();

void trap_init(void)
{
    extern struct Segdesc gdt[];

    // LAB 3: Your code here.
    //#define SETGATE(gate, istrap, sel, off, dpl) 
    // 把SETGATE这个宏放在这里，帮助理解
    SETGATE(idt[T_DIVIDE], 0, GD_KT, divide_handler, 0);
    SETGATE(idt[T_DEBUG], 0, GD_KT, debug_handler, 0);
    SETGATE(idt[T_NMI], 0, GD_KT, nmi_handler, 0);
    SETGATE(idt[T_BRKPT], 0, GD_KT, brkpt_handler, 3);
    SETGATE(idt[T_OFLOW], 0, GD_KT, oflow_handler, 0);
    SETGATE(idt[T_BOUND], 0, GD_KT, bound_handler, 0);
    SETGATE(idt[T_DEVICE], 0, GD_KT, device_handler, 0);
    SETGATE(idt[T_ILLOP], 0, GD_KT, illop_handler, 0);
    SETGATE(idt[T_DBLFLT], 0, GD_KT, dblflt_handler, 0);
    SETGATE(idt[T_TSS], 0, GD_KT, tss_handler, 0);
    SETGATE(idt[T_SEGNP], 0, GD_KT, segnp_handler, 0);
    SETGATE(idt[T_STACK], 0, GD_KT, stack_handler, 0);
    SETGATE(idt[T_GPFLT], 0, GD_KT, gpflt_handler, 0);
    SETGATE(idt[T_PGFLT], 0, GD_KT, pgflt_handler, 0);
    SETGATE(idt[T_FPERR], 0, GD_KT, fperr_handler, 0);
    SETGATE(idt[T_ALIGN], 0, GD_KT, align_handler, 0);
    SETGATE(idt[T_MCHK], 0, GD_KT, mchk_handler, 0);
    SETGATE(idt[T_SIMDERR], 0, GD_KT, simderr_handler, 0);
    SETGATE(idt[T_SYSCALL], 0, GD_KT, syscall_handler, 3);
    // Per-CPU setup 
    trap_init_percpu();
}

trapentry.S
如果了解过C语言的编译过程，我们知道宏函数在编译的时候会被直接替换掉。如果我们调用TRAPHANDER_NOEC(divide_handler,T_DIVIDE)就相当于下面的代码:

divide_handler:
  push $0
  push T_DIVIDE

这样一来就和我们在trap_init()中的代码对应起来了，正式开始实现代码之前，先看一下x86中哪些中断有error code，osDev这里总结的比mit那个好，Error Code 。接下来只要调用两个宏函数就行了:

/*
 * Lab 3: Your code here for generating handler points for the different traps.
 */
TRAPHANDLER_NOEC(divide_handler, T_DIVIDE);
TRAPHANDLER_NOEC(debug_handler, T_DEBUG);
TRAPHANDLER_NOEC(nmi_handler, T_NMI);
TRAPHANDLER_NOEC(brkpt_handler, T_BRKPT);
TRAPHANDLER_NOEC(oflow_handler, T_OFLOW);
TRAPHANDLER_NOEC(bound_handler, T_BOUND);
TRAPHANDLER_NOEC(illop_handler, T_ILLOP);
TRAPHANDLER_NOEC(device_handler, T_DEVICE);
TRAPHANDLER(dblflt_handler, T_DBLFLT);
TRAPHANDLER(tss_handler, T_TSS);
TRAPHANDLER(segnp_handler, T_SEGNP);
TRAPHANDLER(stack_handler, T_STACK);
TRAPHANDLER(gpflt_handler, T_GPFLT);
TRAPHANDLER(pgflt_handler, T_PGFLT);
TRAPHANDLER_NOEC(fperr_handler, T_FPERR);
TRAPHANDLER(align_handler, T_ALIGN);
TRAPHANDLER_NOEC(mchk_handler, T_MCHK);
TRAPHANDLER_NOEC(simderr_handler, T_SIMDERR);
TRAPHANDLER_NOEC(syscall_handler, T_SYSCALL);

_alltraps:
代码如下，要记得一点就是_alltraps是要构建一个trapframe的。不过有一点我没有明白，为什么要push esp，这个是参考别人代码的，我觉得和x86 c calling convention可能有关。另外再说一下，当处理器在执行下面的代码的时候，已经是在CPL=0的内核中执行了。虽然已经发生了特权级的转换，但是中断发生的时候处理器只是替换了CS和EIP寄存器。所以此时的ds，es，eax，ebx寄存去都还是用户程序的寄存器。所以构建一个trapframe是可行的。

_alltraps:
    pushl %ds
    pushl %es
    pushal

    movl $GD_KD, %eax
    movl %eax, %ds
    movl %eax, %es

    push %esp  //我没有理解
    call trap

实验结果:
通过运行make grade,如果divezero，softint,badsegment都正确了的话说明你成功了。下面是我的实验结果；

实验结果

question

1. 为什么每一个中断或者异常都有自己的处理函数（也就是说如果所有的中断和异常都使用相同的处理函数会怎么样）

答：这个题目感觉有点无厘头，有点废话，不同的中断当然需要不同的处理函数，难道除0和page fault做相同的事情吗？。。 不知道是不是我对题目理解有问题

2. 怎么样才能使softint正常运行？评分脚本希望他产生13号中断，但是softint的代码是调用了14号中断，怎么做？
   答: 只要让14号中断的DPL=0就行了,softint是用户程序，它运行在DPL=3。当14号中断的DPL=0的时候，用户程序因为他的DPL比较低(DPL=0)所以没有权限去调用这个中断，因此会触发general protection fault。