[操作系统实验lab3]实验报告

[感受]

这次操作系统实验感觉还是比较难的，除了因为助教老师笔误引发的2个错误外，还有一些关键性的理解的地方感觉还没有很到位，这些天一直在不断地消化、理解Lab3里的内容，到现在感觉比Lab2里面所蕴含的内容丰富很多，也算是有所收获，和大家分享一下我个人的一些看法与思路，如果有错误的话请指正。

---

[关键函数理解]

首先第一部分我觉得比较关键的是对于一些非常关键的函数的理解与把握，这些函数是我们本次实验的精华所在，虽然好几个实验都不需要我们自己实现，但是这些函数真的是非常厉害！有多厉害，呆会就知道了。

首先是从第一个我们要填的函数说起吧：

• env_init

void
env_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_vm

static int
env_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

 int env_alloc(struct Env **new, u_int parent_id)
 {
         int r;
         /*precondtion: env_init has been called before this function*/
         /*1. get a new Env from env_free_list*/
         struct Env *currentE;
         currentE = LIST_FIRST(&env_free_list);
         /*2. call some function(has been implemented) to intial kernel memory layout for this new Env.
          *hint:please read this c file carefully, this function mainly map the kernel address to this new Env address*/
         if((r=env_setup_vm(currentE))<)
                 return r;
         /*3. initial every field of new Env to appropriate value*/
         currentE->env_id = mkenvid(currentE);
         currentE->env_parent_id = parent_id;
         currentE->env_status = ENV_NOT_RUNNABLE;
         /*4. focus on initializing env_tf structure, located at this new Env. especially the sp register,
          * CPU status and PC register(the value of PC can refer the comment of load_icode function)*/
         //currentE->env_tf.pc = 0x20+UTEXT;
         currentE->env_tf.regs[] = USTACKTOP;
         currentE->env_tf.pc = UTEXT + 0xb0;
         currentE->env_tf.cp0_status = 0x10001004;
         /*5. remove the new Env from Env free list*/
         LIST_REMOVE(currentE,env_link);
         *new = currentE;
         return ;
 }

　　

　　这一部分呢，是单个进程控制块要被分配资源的时候做的一些初始化的工作，其中有几个比较有意思的点很值得深究：

　　  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

 static void
 load_icode(struct Env *e, u_char *binary, u_int size)
 {
         int r;
         u_long currentpg,endpg;

         currentpg = UTEXT;
 //      printf("\ncurrentpg:%x\n",currentpg);
         endpg = currentpg + ROUND(size,BY2PG);
         //currentpg is since 0x0040 0000;so it is already rounded;
         /*precondition: we have a valid Env object pointer e, a valid binary pointer pointing to some valid
         machine code(you can find them at $WORKSPACE/init/ directory, such as code_a_c, code_b_c,etc), which can
          *be executed at MIPS, and its valid size */
         while(currentpg < endpg){
              struct Page *page;
              if((r= page_alloc(&page))<)
                 return;
              if((r= page_insert(e->env_pgdir,page,currentpg,PTE_V|PTE_R))<)
                 return;
              //printf("*binary:%8x\n",binary);
              //printf("*page2kva:%8x\n",page2kva(page));
              //bcopy((void *)binary,page2kva(page),BY2PG);
              //bcopy((void *)binary,page2pa(page),BY2PG);
              bzero(page2kva(page),BY2PG);
              bcopy((void *)binary,page2kva(page),BY2PG);
              //printf("copy succeed!\n");
              binary += BY2PG;
              currentpg +=BY2PG;
         }
             //currentpg = UTEXT;
         //bzero(currentpg,ROUND(size,BY2PG));
         //bcopy((void *)binary,(void *)currentpg,size);
         /*1. copy the binary code(machine code) to Env address space(start from UTEXT to high address), it may call some auxiliare function
         (eg,page_insert or bcopy.etc)*/
         struct Page *stack;
         page_alloc(&stack);
         page_insert(e->env_pgdir,stack,(USTACKTOP-BY2PG),PTE_V|PTE_R);
         //printf("Stack Set success\n");
         /*2. make sure PC(env_tf.pc) point to UTEXT + 0x20, this is very import, or your code is not executed correctly when your
          * process(namely Env) is dispatched by CPU*/
         assert(e->env_tf.pc == UTEXT+0xb0);
         e->env_status = ENV_RUNNABLE;
         //printf("env_tf.pc:%x\n",e->env_tf.pc);
 }

load_icode

　　这个堪称是本次实验中为数不多的坑函数之一，无数仁人志士在bcopy这里落马，所以我也就重点讲一下几个要点好了。

　　首先要解释的就是这个page_insert函数，这个函数看起来平淡无奇，但是如果层层深入，就能发现里面的一些奥妙之处。

　　我们首先来看page_insert：

 int
 page_insert(Pde *pgdir, struct Page *pp, u_long va, u_int perm)
 {       // Fill this function in
         u_int PERM;
         Pte *pgtable_entry;
         PERM = perm | PTE_V;

         pgdir_walk(pgdir, va, , &pgtable_entry);

         if(pgtable_entry!= &&(*pgtable_entry & PTE_V)!=)
                 if(pa2page(*pgtable_entry)!=pp) page_remove(pgdir,va);
                 else
                 {
                         tlb_invalidate(pgdir, va);
                         *pgtable_entry = (page2pa(pp)|PERM);
                         return ;
                 }
         tlb_invalidate(pgdir, va);
         if(pgdir_walk(pgdir, va, , &pgtable_entry)!=){
                 return -E_NO_MEM;
         }
         *pgtable_entry = (page2pa(pp)|PERM);
 //      printf("page_insert get the pa:*pgtable_entry %x\n",*pgtable_entry);
         pp->pp_ref++;
         return ;
 }

　　实际上这个函数是这样一个流程：

　　先判断va是否有对应的页表项，如果页表项有效。或者叫va是否已经有了映射的物理地址。如果有的话，则去判断这个物理地址是不是我们要插入的那个物理地址，如果不是，那么就把该物理地址移除掉；如果是的话，则修改权限，放到tlb里去！

　　关于page_inert以下两点一定要注意：

• page_insert处理将同一虚拟地址映射到同一个物理页面上不会将当前已有的物理页面移除掉，但是需要修改掉permission；
• 只要对页表有修改，都必须tlb_invalidate一下，否则后面紧接着对内存的访问很有可能出错。这就是为什么有一些同学直接使用了pgdir_walk而没有page_insert产生错误的原因。

　　既然提到了tlb_invalidate函数，那么我们来仔细分析一下这个函数，这个函数代码如下：

 void
 tlb_invalidate(Pde *pgdir, u_long va)
 {
         if (curenv)
                 tlb_out(PTE_ADDR(va)|GET_ENV_ASID(curenv->env_id));
         else
                 tlb_out(PTE_ADDR(va));

 }

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进制位），所以我猜后六位一定是有其独特用处的，否则在这里也不会强调清零，不过我们这次实验里还没有看到特殊用处。

　　

 LEAF(tlb_out)
 //1: j 1b
 nop
         mfc0    k1,CP0_ENTRYHI
         mtc0    a0,CP0_ENTRYHI
         nop
         tlbp
         nop
         nop
         nop
         nop
         mfc0    k0,CP0_INDEX
         bltz    k0,NOFOUND
         nop
                 mtc0    zero,CP0_ENTRYHI
                 mtc0    zero,CP0_ENTRYLO0
                 nop
                 tlbwi
         //add   k0, 40
         //sb    k0, 0x90000000
         //li    k0, '>'
         //sb    k0, 0x90000000
 NOFOUND:

         mtc0    k1,CP0_ENTRYHI

         j       ra
         nop
 END(tlb_out)

tlb_out

　　这段汇编是tlb_invalidate函数的精华所在，CP0_ENTRYHI实际上就是用来给tlb倒腾数据的，不用太在意其本身的作用。

　　前两句是指把之前的CP0_ENTRYHI存在k1里面暂存一下。然后我们就有一条很关键的汇编指令 tlbp ，很关键！

　　通过查mips手册可以知道tlbp的功能如下：

aaarticlea/png;base64,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" alt="" width="643" height="394" />

　　之后的几个nop应该是为tlb指令设置的流水缓冲，因为tlbp执行的周期要比一般指令长。其实这条汇编的目的就是：

　　To find a matching entry in the TLB.所以说实际上是把va及其对应的物理地址存在tlb里了，而且tlbp应该是依托于CP0_INDEX和CP0_EnrtyHI寄存器的。那么后面的那些读CP0_INDEX实际上是对tlbp执行是否成功的一个判断而已。注意，这里的tlbp就是在内核态下进行的，所以不会产生异常！如果在用户态下修改CP0的寄存器，或者使用tlbp汇编等，那就说明是tlb缺失或page_fault了！

　　那么再返回我们的page_insert来看看下一句，下一句是建立一个va与pa之间的桥梁，一个页表的建立，pgdir_walk(pgdir, va, 1, &pgtable_entry)，所以说我们其实在最开始load_icode的时候，实际上是建立了不止size大小的页，还需要建立一个能够映射到该页的页表！那么在最后，为页表项的内容设置权限位PTE_R。恩，那么page_insert函数就此结束了。

　　page_insert函数结束了，不代表我们这个load_icode结束。下一步则是bcopy。

　　bcopy这个函数本身不坑，坑的是用法。首先对比原文中的这句我们来粗浅地看一下bcopy：

         bzero(page2kva(page),BY2PG);
         bcopy((void *)binary,page2kva(page),BY2PG);

　　我个人以为这里bzero清零比较好，因为不能保证lab2哪里有问题还会影响到这里来。我倾向于一页一页地清除目标页，分配原始页，当然实验证明这样写也是没有任何问题的。那么下面来解释一下为什么这里用的是page2kva(page)，而不是用与UTEXT有关的数值？

　　首先我们解释过了，UTEXT+0xb0是程序的入口，何谓入口？比如我们现在启动了一个进程，我们如何能从哪里开始，该怎样跑呢？这取决于我们run一个进程前的准备工作，当然这个工作在进程切换时也需要做，其中很重要的一点就是保存pc。这一点很重要，极其重要。如果是第一次run一个进程的时候，我们的pc是务必要被设置为UTEXT+0xb0的，这也是在env_alloc里面所做的工作。之后有一些我们没有关注过的汇编程序就会默默地根据我们设置的pc去找我们的程序入口，默默地执行，遇到中断默默地保存，切换。于是就这样完成了进程的运行与切换大计。

　　那么我们这里bcopy不能用UTEXT来copy是因为，我们这里还没开始一个进程，没有其页目录来作为基址，所以你现在copy到的地方也只是内核的UTEXT处。我们都知道在env_run时要切换页目录，切换为进程的页目录后，我们就再也找不到这部分copy的东西了（因为env_setup_vm只复制内核页目录ULIM以上的部分）。所以我们要copy到的地方一定是要内核和每个进程均可以访问的，显而易见要copy到ULIM以上的部分。即page2kva(page)这个地方。当然，你可以选择先切换到进程的页目录，然后copy，然后在结束的时候切换回内核的页目录，

　　再次强调一点，bcopy也好，bzero也好，在我们编写的程序中，只要是作为访问地址来使用的（什么叫作为地址来使用，就是可以取其内容的 *address)，全部都使用的是虚拟地址！　　

　　如果你还有更多的探索之心的话，我们可以这么来玩一下load_icode，你看我们之前bcopy不能copy到UTEXT的理由也知道了，那何不先切换到进程的页目录，复制完了以后再切换回来呢？事实上这种做法理论上是完全正确的，但是我在我们的实验里试验过发现不对！后来发现即使切换了页目录，也可以照常访问内核区的地址，完全没有问题！为什么？后来我才猛然想到，我们这次实验的lcontext切换页目录，完全是为tlb中断和page_fault服务的，所以指望lcontext来自动帮我们找到物理地址并且往里添加内容的话，是不可以的。

　　最后呢，实际上就是建个进程里的用户栈而已，这里区别开用户栈 和内存栈的区别。

　　多个进程运行时，实际上在内存中有一个栈型结构来存放进程的代码，数据，常量等，而在用户栈里放的则是运行过程中所定义的变量等，这点需要正确把握。当然最后要设置权限，PTE_R，这是写的权限，要设置给用户栈，否则后面进程没有办法写自己的栈了 Orz。　　

• env_create

　　终于把load_icode这玩意弄完了，那么实际上这里env_create就很简单了，就是alloc一个进程控制块，然后加载其代码，just so。下面是代码

 void
 env_create(u_char *binary, int size)
 {
         struct Env *e=NULL;
         /*precondition: env_init has been called before, binary and size is valid, which can refer load_icode function*/
         /*Hint: this function wrap the env_alloc and load_icode function*/
         env_alloc(&e,);
         //printf("alloc succeed!");
         /*1. allocate a new Env*/
         load_icode(e,binary,size);

         /*2. load binary code to this new Env address space*/

 }

env_create

• env_run

 void
 env_run(struct Env *e)
 {
         /*precondition: you have create at least one process(Env) in system.
         */
         struct Trapframe *tf = NULL;
         if(curenv){
               tf = TIMESTACK - sizeof(struct Trapframe);
               bcopy(tf,&curenv->env_tf,sizeof(struct Trapframe));
               curenv->env_tf.pc = tf->cp0_epc;
         }
         /*1. keep the kernel path(namely trap frame) of the process which will be swapped out by CPU at TIMESTACK*/

         curenv = e;
         /*2. set e to the current env*/

         lcontext(curenv->env_pgdir);
         /*3. keep current env's pgdir address in mCONTEXT, which will be used by tlb refill
          * hint: please read the env_asm.S, you can find how to write it*/
         env_pop_tf(&(curenv->env_tf),curenv->env_id);
         /*4. process switch, swap out old process, and run the new current env hint: please read the env_asm.S, you can find how to write it*/
 }
                      

　  刚刚说到的load_icode是为数不多的坑函数之一，env_run也是，而且其实按程度来讲可能更甚一筹。

　　那我们来一步一步分析一下这个函数的坑处。

　　首先是要理解进程切换，需要做些什么？百度告诉我们：alt+tab就可以。哈哈，开个小玩笑，实际上进程切换的时候，为了保证下一次进入这个进程的时候我们不会再“从头来过”，我们要保存一些信息，那么，需要保存什么信息呢？保存的应该是以下几方面：

　　[1]、进程本身的状态

　　[2]、进程周围的环境的状态，环境就是指此时的CPU的状态

　　那么我们可能会产生疑问，进程本身的状态怎么记录呢？

　　进程本身的状态无非就是进程块里面那几个东西，包括id,parent_id,pc,tf...

　　等等！你刚刚说什么，tf? Trapframe里面有什么？ cp0_badvaddr,cp0_cause,cp0_epc,regs[32]...

　　这些东西是进程自己的吗？是进程自己的吗？不！这些都是CPU的状态啊！所以说实际上一个进程控制块中的tf，就是来记录它的环境的状态的！进程本身的状态在进程切换的时候是不会变的。（我们没有去毁灭一个进程块，进程块跟我们又没仇。。。）会变的也是需要我们保存的实际上是进程的环境信息。

　　谨记这一点，或许你就能开始明白run代码中的第一句:(明明是一段好吗)

  if(curenv){
               tf = TIMESTACK - sizeof(struct Trapframe);
               bcopy(tf,&curenv->env_tf,sizeof(struct Trapframe));
               curenv->env_tf.pc = tf->cp0_epc;
         }

　　很多同学在这里可能遇到了他们在lab3中的最大困惑：

　　　　为什么这里不能从KERNEL_SP取东西，而是非要从TIMESTACK取。KERNEL_SP是用来干啥的？

　　为了搞清楚这一点，我们需要知道：什么时候我们把东西往TIMESTACK放，又是什么时候取出来的？

　　笔者在 ./include/stackframe.h 找到了一点端倪：

 .macro get_sp
         mfc0    k1, CP0_CAUSE
         andi    k1, 0x107C
         xori    k1, 0x1000
         bnez    k1, 1f
         nop
         li      sp, 0x82000000
         j       2f
         nop
 :
         bltz    sp, 2f
         nop
         lw      sp, KERNEL_SP
         nop

 :      nop

 .endm

　　发现什么了？实际上我们的TIMSTACK就是0x82000000，因为我们本次都是时钟中断，所以sp是TIMSTACK区！

　　而我们再仔细地观察这个头文件，发现其实里面的宏汇编  RESTORE_SOME 和env_pop_tf 几乎一模一样啊！那么经过和HT大神的讨论，我们认为应该是这样:TIMESTACK是时钟中断后的存储区，而KERNEL_SP应当是系统调用后的存储区。我们可以把run里面的TIMSTACK改成 KERNEL_SP试试，发现其实KERNEL_SP在第一个进程执行完之后就没更新过，这是显而易见的，因为我们第一个进程启动后，就再也没有给过内核进程控制权啊！不过我们的猜想估计要到后面的实验才能认证。

　   那么实际上我们在往某个寄存器比如$1里放东西的时候，应该是放到了sp为起始虚拟地址对应的物理地址处，那么就是

• 　　env_pop_tf 负责放东西到sp(这里是TIMESTACK)中去；
• 　　而这开头的一段负责从sp里取出东西来(这里是TIMSTACK)。

　　所以我们一开始没有正在运行的进程块的时候，是不需要取的，但是一旦一个进程块运行到末尾的话，就会向TIMSTACK中存入东西。

　　比如我们进程1开始运行，运行到env_run的末尾，我们把当时的环境保存了下来。运行一段时间后，时钟中断导致切换，发现要到进程2了，在切换之前，我们把进程1的离开时的状态保存在其tf内，离开的状态其实就在TIMESTACK中。因为我理解的这个TIMESTACK就是当前访问CPU的寄存器所用虚拟地址，所以其所对应的值就是CPU的各个寄存器的值，所以就会在进程运行时改变，所以要更新。

　　注意还有一个小坑的地方在于 如果要env_pop_tf的时候，千万记得要先lcontext切换了页目录，否则是会出错的。env_pop_tf 的字面意思估计大家也明白了，就是把env里的tf 压到 寄存器里去。

　　大概流程就是这样，明白了这点，我觉得就明白了整个实验的精髓。当然，笔者的理解可能是错的，正确与否，纠正什么的还需要以后的造化，哈哈。希望大家都能理解这些东西最好~

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　乾 　　 2015/5/17