[操作系统实验lab3]实验报告[感受]这次操作系统实验感觉还是比较难的，除了因为助教老师笔误引发的2个错误外，还有一些关键性的理解的地方感觉还没有很到位，这些天一直在不断地消化、理解Lab3里的内容，到现在感觉比Lab2里面所蕴含的内容丰富很多，也算是有所收获，和大家分享一下我个人的一些看法与思路，如果有错误的话请指正。
[关键函数理解]首先第一部分我觉得比较关键的是对于一些非常关键的函数的理解与把握，这些函数是我们本次实验的精华所在，虽然好几个实验都不需要我们自己实现，但是这些函数真的是非常厉害！有多厉害，呆会就知道了。
首先是从第一个我们要填的函数说起吧：
env_initvoidenv_init(void){ int i;/*PRecondition: envs pointer has been initialized at mips_vm_init, called by mips_init*/ /*1. initial env_free_list*/ LIST_INIT(&env_free_list); //step 1; /*2. travel the elements in 'envs', initial every element(mainly initial its status, mark it as free) and inserts them into the env_free_list. attention :Insert in reverse order */ for(i=NENV-1;i>=0;i--){ envs[i].env_status = ENV_FREE; LIST_INSERT_HEAD(&env_free_list,envs+i,env_link); }}以上是env_init的实现。其实这个函数没什么太多好说的，就是初始化env_free_list，然后按逆序插入envs[i]。
这里唯一值得并需要引起警惕的是逆序，因为我们使用的是LIST_INSERT_HEAD这个宏，任何一个对齐有所了解的人应该都知道，这个宏每次都会将一个结点插入，变成链表的第一个可用结点，而我们在取用的时候是使用LIST_FIRST宏来取的，所以如果这里写错了的话，可能在调度算法里就要有所更改。
可能会有同学问为什么NENV是envs的长度，这个实际上在pmap.c里面的mips_vm_init里可以找到我们的证据，证明envs数组确实给它分配了NENV个结构体的空间，所以它也就有NENV个元素了。
env_steup_vmstatic intenv_setup_vm(struct Env *e){ // Hint: int i, r; struct Page *p = NULL; Pde *pgdir; if ((r = page_alloc(&p)) < 0) { panic("env_setup_vm - page_alloc error\n"); return r; } p->pp_ref++; e->env_pgdir = (void *)page2kva(p); e->env_cr3 = page2pa(p); static_assert(UTOP % PDMAP == 0); for (i = PDX(UTOP); i <= PDX(~0); i++) e->env_pgdir[i] = boot_pgdir[i]; e->env_pgdir[PDX(VPT)] = e->env_cr3 ; e->env_pgdir[PDX(UVPT)] = e->env_cr3 ; return 0;}其实这个函数并不需要我们实现，但是我还是想讲一讲这个函数的一些有意思的地方。
我们知道，每一个进程都有4G的逻辑地址可以访问，我们所熟知的系统不管是linux还是Windows系统，都可以支持3G/1G模式或者2G/2G模式。3G/1G模式即满32位的进程地址空间中，用户态占3G，内核态占1G。这些情况在进入内核态的时候叫做陷入内核，因为即使进入了内核态，还处在同一个地址空间中，并不切换CR3寄存器。但是！还有一种模式是4G/4G模式，内核单独占有一个4G的地址空间，所有的用户进程独享自己的4G地址空间，这种模式下，在进入内核态的时候，叫做切换到内核，因为需要切换CR3寄存器，所以进入了不同的地址空间！
而我们这次实验，根据./include/mmu.h里面的布局来说，我们其实就是2G/2G模式，用户态占用2G，内核态占用2G。所以记住，我们在用户进程开启后，访问内核地址不需要切换CR3寄存器！其实这个布局模式也很好地解释了为什么我们需要把boot_pgdir里的内容拷到我们的e->env_pgdir中，在我们的实验中，对于不同的进程而言，其虚拟地址ULIM以上的地方，映射关系都是一样的！这是因为这2G虚拟地址与物理地址的对应，不是由进程管理的，是由内核管理的。
另外一点有意思的地方不知大家注意到没有，UTOP~ULIM明明是属于User的区域，却还是把内核这部分映射到了User区，而且我们看mmu.h的布局，觉得会非常有意思！ 盗用mmu.h里面这张图，我们仔细地来分析一下：
o ULIM -----> +----------------------------+-----------0x80000000 o | User VPT | PDMAP o UVPT -----> +----------------------------+-----------0x7fc00000 o | PAGES | PDMAP o UPAGES -----> +----------------------------+-----------0x7f800000 o | ENVS | PDMAP o UTOP,UENVS -----> +----------------------------+-----------0x7f400000 o UXSTACKTOP -/ | user exception stack | BY2PG o +----------------------------+------------0x7f3ff000 o | Invalid memory | BY2PG o USTACKTOP ----> +----------------------------+------------0x7f3fe000 o | normal user stack | BY2PG o +----------------------------+------------0x7f3fd000 a | | 可以看到UTOP是0x7f40 0000，既然有映射，一定就有分配映射的过程，我们使用grep指令搜索一下 UENVS，发现它在这里有pmap.c里的mips_vm_init有所迹象：
envs = (struct Env*)alloc(NENV*sizeof(struct Env),BY2PG,1); boot_map_segment(pgdir,UENVS,NENV*sizeof(struct Env),PADDR(envs),PTE_R);
可以发现什么呢？其实我们发现，UENVS和envs实际上都映射到了envs对应的物理地址！
其实足以看出来，内核在映射的时候已经为用户留下了一条路径！一条获取其他进程信息的路途！而且我们其实可以知道，这一部分对于进程而言应当是只能读不可以写的。开启中断后我们在进程中再访问内核就会产生异常来陷入内核了，所以应该是为了方便读一些进程信息，内核专门开辟了这4M的用户进程虚拟区。用户读这4M空间的内容是不需要产生异常的。
e->env_pgdir[PDX(VPT)] = e->env_cr3 ; e->env_pgdir[PDX(UVPT)] = e->env_cr3 ;
这一部分是设置UVPT和VPT映射到4M的页表的起始地址，不过这里还没想太清楚。这里设置UVPT充其量只是能读到e->env_pgdir的那些东西，只有4K的页目录而已，那为什么要用4M的虚拟地址来映射呢？奇怪。。。
env_alloc 1 int env_alloc(struct Env **new, u_int parent_id) 2 { 3 int r; 4 /*precondtion: env_init has been called before this function*/ 5 /*1. get a new Env from env_free_list*/ 6 struct Env *currentE; 7 currentE = LIST_FIRST(&env_free_list); 8 /*2. call some function(has been implemented) to intial kernel memory layout for this new Env. 9 *hint:please read this c file carefully, this function mainly map the kernel address to this new Env address*/10 if((r=env_setup_vm(currentE))<0)11 return r;12 /*3. initial every field of new Env to appropriate value*/13 currentE->env_id = mkenvid(currentE);14 currentE->env_parent_id = parent_id;15 currentE->env_status = ENV_NOT_RUNNABLE;16 /*4. focus on initializing env_tf structure, located at this new Env. especially the sp register,17 * CPU status and PC register(the value of PC can refer the comment of load_icode function)*/18 //currentE->env_tf.pc = 0x20+UTEXT;19 currentE->env_tf.regs[29] = USTACKTOP;20 currentE->env_tf.pc = UTEXT + 0xb0;21 currentE->env_tf.cp0_status = 0x10001004;22 /*5. remove the new Env from Env free list*/23 LIST_REMOVE(currentE,env_link);24 *new = currentE;25 return 0;26 }
View Code
这一部分呢，是单个进程控制块要被分配资源的时候做的一些初始化的工作，其中有几个比较有意思的点很值得深究： currentE->env_tf.pc = UTEXT + 0xb0; currentE->env_tf.cp0_status = 0x10001004;第一条可能会有比较大的疑问，为什么进程的二进制码分配到UTEXT对应的地址那里去了，而且也建立好映射关系了，怎么还要加个偏移量作为pc初始值呢？我们知道pc初始值实际上是进程开始运行的地方，而这里为什么是UTEXT+0xb0，这0xb0是什么东西？我们需要去探究一下code_a.c或者code_b.c文件了，实际上经过一定的了解，这个文件应当是一个elf文件。看其前四个字节就能看出：0x7f 0x46 0x4c 0x46这是elf的标准头，而实际上像这样的标准头的长度是有0xb0的长度，这个实际上我们可以把code_a.c里的数组搞出来，然后变成一个elf文件，最后使用readelf来读取出地址，这样就能明白原理了。所以UTEXT+0xb0这个虚拟地址对应物理地址里面放着的，才是真正可执行代码的第一条。再来就是这个0x10001004这个问题，这个问题很好玩。因为R3000自身的SR寄存器与mips其他版本的SR寄存器略有不同，它的最后六位记载了是一组深度为二的二重栈，不过笔者在这里还残留着一些不大不小的问题。《see mips run》中只是提到了关于这些寄存器的作用，而没有提到中断的时候这些寄存器应当是什么状态。如果有兴趣的同学可以grep一下 "CP0_STATUS" 和"cp0_status" 说不定能发现个中玄机。 load_icode 1 static void 2 load_icode(struct Env *e, u_char *binary, u_int size) 3 { 4 int r; 5 u_long currentpg,endpg; 6 7 currentpg = UTEXT; 8 // printf("\ncurrentpg:%x\n",currentpg); 9 endpg = currentpg + ROUND(size,BY2PG);10 //currentpg is since 0x0040 0000;so it is already rounded;11 /*precondition: we have a valid Env object pointer e, a valid binary pointer pointing to some valid12 machine code(you can find them at $WORKSPACE/init/ directory, such as code_a_c, code_b_c,etc), which can13 *be executed at MIPS, and its valid size */14 while(currentpg < endpg){15 struct Page *page;16 if((r= page_alloc(&page))<0)17 return;18 if((r= page_insert(e->env_pgdir,page,currentpg,PTE_V|PTE_R))<0)19 return;20 //printf("*binary:%8x\n",binary);21 //printf("*page2kva:%8x\n",page2kva(page));22 //bcopy((void *)binary,page2kva(page),BY2PG);23 //bcopy((void *)binary,page2pa(page),BY2PG);24 bzero(page2kva(page),BY2PG);25 bcopy((void *)binary,page2kva(page),BY2PG);26 //printf("copy succeed!\n");27 binary += BY2PG;28 currentpg +=BY2PG;29 }30 //currentpg = UTEXT;31 //bzero(currentpg,ROUND(size,BY2PG));32 //bcopy((void *)binary,(void *)currentpg,size);33 /*1. copy the binary code(machine code) to Env address space(start from UTEXT to high address), it may call some auxiliare function34 (eg,page_insert or bcopy.etc)*/35 struct Page *stack;36 page_alloc(&stack);37 page_insert(e->env_pgdir,stack,(USTACKTOP-BY2PG),PTE_V|PTE_R);38 //printf("Stack Set success\n");39 /*2. make sure PC(env_tf.pc) point to UTEXT + 0x20, this is very import, or your code is not executed correctly when your40 * process(namely Env) is dispatched by CPU*/41 assert(e->env_tf.pc == UTEXT+0xb0);42 e->env_status = ENV_RUNNABLE;43 //printf("env_tf.pc:%x\n",e->env_tf.pc);44 }
load_icode这个堪称是本次实验中为数不多的坑函数之一，无数仁人志士在bcopy这里落马，所以我也就重点讲一下几个要点好了。
首先要解释的就是这个page_insert函数，这个函数看起来平淡无奇，但是如果层层深入，就能发现里面的一些奥妙之处。
我们首先来看page_insert：
1 int 2 page_insert(Pde *pgdir, struct Page *pp, u_long va, u_int perm) 3 { // Fill this function in 4 u_int PERM; 5 Pte *pgtable_entry; 6 PERM = perm | PTE_V; 7 8 pgdir_walk(pgdir, va, 0, &pgtable_entry); 9 10 if(pgtable_entry!=0 &&(*pgtable_entry & PTE_V)!=0)11 if(pa2page(*pgtable_entry)!=pp) page_remove(pgdir,va);12 else13 {14 tlb_invalidate(pgdir, va);15 *pgtable_entry = (page2pa(pp)|PERM);16 return 0;17 }18 tlb_invalidate(pgdir, va);19 if(pgdir_walk(pgdir, va, 1, &pgtable_entry)!=0){20 return -E_NO_MEM;21 }22 *pgtable_entry = (page2pa(pp)|PERM);23 // printf("page_insert get the pa:*pgtable_entry %x\n",*pgtable_entry);24 pp->pp_ref++;25 return 0;26 }
View Code实际上这个函数是这样一个流程：
先判断va是否有对应的页表项，如果页表项有效。或者叫va是否已经有了映射的物理地址。如果有的话，则去判断这个物理地址是不是我们要插入的那个物理地址，如果不是，那么就把该物理地址移除掉；如果是的话，则修改权限，放到tlb里去！
关于page_inert以下两点一定要注意：
page_insert处理将同一虚拟地址映射到同一个物理页面上不会将当前已有的物理页面移除掉，但是需要修改掉permission；只要对页表有修改，都必须tlb_invalidate一下，否则后面紧接着对内存的访问很有可能出错。这就是为什么有一些同学直接使用了pgdir_walk而没有page_insert产生错误的原因。既然提到了tlb_invalidate函数，那么我们来仔细分析一下这个函数，这个函数代码如下：
1 void2 tlb_invalidate(Pde *pgdir, u_long va)3 {4 if (curenv)5 tlb_out(PTE_ADDR(va)|GET_ENV_ASID(curenv->env_id));6 else7 tlb_out(PTE_ADDR(va));8 9 }
tlb_invalidate关于为什么要使用GET_ENV_ASID宏，助教老师给的指导书里其实没有讲太清楚，tlb的ASID区域只有20位，而我们mkenvid函数调用后得到的id值是可以超出20位的，大家可以在env_init初始化的时候打印env_id的值，然后在init.c里面create 1024个进程即可看到实际上envid最大可达1ffbfe，而使用GET宏之后最大可达ffc0，而且都可以为tlb用于区分进程，所以肯定是位数越少越好啦。而且还有一个比较有意思的地方，GET宏里实际上是让env_id先 >>11 然后 <<6 达到最后效果的，这样和>>5有什么区别呢？区别就在于 如果先>>11再 <<6，后6位一定是0！（2进制位），所以我猜后六位一定是有其独特用处的，否则在这里也不会强调清零，不过我们这次实验里还没有看到特殊用处。
1 LEAF(tlb_out) 2 //1: j 1b 3 nop 4 mfc0 k1,CP0_ENTRYHI 5 mtc0 a0,CP0_ENTRYHI 6 nop 7 tlbp 8 nop 9 nop10 nop11 nop12 mfc0 k0,CP0_INDEX13 bltz k0,NOFOUND14 nop15 mtc0 zero,CP0_ENTRYHI16 mtc0 zero,CP0_ENTRYLO017 nop18 tlbwi19 //add k0, 4020 //sb k0, 0x9000000021 //li k0, '>'22 //sb k0, 0x9000000023 NOFOUND:24 25 mtc0 k1,CP0_ENTRYHI26 27 j ra28 nop29 END(tlb_out)
tlb_out这段汇编是tlb_invalidate函数的精华所在，CP0_ENTRYHI实际上就是用来给tlb倒腾数据的，不用太在意其本身的作用。
前两句是指把之前的CP0_ENTRYHI存在k1里面暂存一下。然后我们就有一条很关键的汇编指令 tlbp ，很关键！
通过查mips手册可以知道tlbp的功能如下：
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
