现在的位置: 首页 > 综合 > 正文

自制操作系统–（8）内核

2019年05月21日 ⁄ 综合 ⁄ 共 6197字 ⁄ 字号 小 中 大 ⁄ 评论关闭

神说、内核要有自己的数据、使用户不可访问．事就这样成了。 
神称高地址为内核空间、称低地址为用户空间．　神看着是好的。 
神说、用户要有自己的进程、和自己的页表、并可以进行系统调用．事就这样成了。  
有晚上、有早晨、是第三日。 

1、lab3概述
lab3大体分为两部分，第一部分包括执行环境（可以简单的理解为进程，下文也用进程代替执行环境）的建立和运行第一个进程，第二个部分初始化并完成中断和异常以及系统调用相关机制，本文只描述第一部分的做法。

2、原理
在建立进程之前首先要建立进程的管理机制，包括分配进程描述符的空间、建立空闲进程列表、把进程描述符数组相应内存进行映射等。这是进程描述符管理的一些工作。
其次初始化进程的虚拟地址空间，也就是给其页目录赋值过程，主要是将内核空间映射到虚拟地址的高位上。
然后加载进程的代码，代码以二进制形式和内核编译到一起了，所谓“加载”就是将这段代码从内存（内核区往上一点的位置）复制到某个物理位置，接着将这个位置和相应虚拟地址进行映射。
最后将进程的页目录加载进cr3，然后将各寄存器压栈，通过iret跳到用户态执行。
大体上讲就是这样。

3、具体实现与代码
（1）Env数据结构
Env数据结构代表一个进程描述符，定义在env.h中，包括进程的id，父进程的id，执行状态，该进程的寄存器状态，执行的次数等，并使用env_link指向下一个空闲的Env。
所有Env对象存储在envs数组中，该数组定义在env.c的开头。
除此之外curenv代表当前正在执行的进程，env_free_list指向空闲的进程描述符，组成链表，链表的添加与删除均在表头执行。
（2）进程描述符空间的分配
首先在pmap.c里给数组envs分配空间，然后将分配的页面从free_page_list里剔除掉，最后将UENVS映射到envs，整个过程跟Page数组的处理完全一样，不再赘述。通过检查函数即代表完成。
（3）进程描述符数组初始化
完成env_init函数，将数组中所有的进程id置0，同时将各元素串起来，并把数组地址赋给env_free_list，代码如下：

  1. void  
  2. env_init(void)  
  3. {  
  4.     // Set up envs array  
  5.     // LAB 3: Your code here.  
  6.     int i=0;  
  7.     for(i=0;i<=NENV-1;i++)  
  8.     {  
  9.         envs[i].env_id=0;  
  10.         if(i!=NENV-1)  
  11.         {  
  12.         envs[i].env_link=&envs[i+1];  
  13.         }  
  14.     }  
  15.     env_free_list=envs;  
  16.     // Per-CPU part of the initialization  
  17.     env_init_percpu();  
  18. }  

（4）初始化进程虚拟地址空间
完成env_setup_vm函数。不同的进程有不同的虚拟地址空间，进而就必须有自己的页目录和页表，该函数的任务就是初始化页目录。
首先分配一个空闲页当做页目录，然后将这个页目录映射内核地址空间（UTOP之上的部分），不需要映射页表因为可以和内核共用页表。
接着增加分配的物理页的引用（JOS设计的一个很不美的地方），将此页的虚拟地址赋值给进程的pgdir，然后使进程有权限操作自己的pgdir。

  1. static int  
  2. env_setup_vm(struct Env *e)  
  3. {  
  4.     int i;  
  5.     struct Page *p = NULL;  
  6.     cprintf("env_setup_vm\r\n");  
  7.     // Allocate a page for the page directory  
  8.     if (!(p = page_alloc(ALLOC_ZERO)))  
  9.         return -E_NO_MEM;
     
  10.     // LAB 3: Your code here.  
  11.     e->env_pgdir=page2kva(p);  
  12.     for(i=PDX(UTOP);i<1024;i++)  
  13.     {  
  14.         e->env_pgdir[i]=kern_pgdir[i];  
  15.     }  
  16.     p->pp_ref++;  
  17.     // UVPT maps the env's own page table read-only.  
  18.     // Permissions: kernel R, user R  
  19.     e->env_pgdir[PDX(UVPT)] = PADDR(e->env_pgdir) | PTE_P | PTE_U;  
  20.   
  21.     return 0;  
  22. }

（5）辅助映射函数
当进行加载二进制代码的时候，需要一个辅助函数region_alloc，其作用是映射虚拟地址va及之后的len字节到进程e的虚拟地址空间里。
实现比较简单，首先将va向下4K对齐，va+len向上4k对齐，以保证分配的是整数页面。之后一个页面一个页面分配即可。
为了使页面用户态可写，需要权限PTE_W|PTE_U。

  1. static void  
  2. region_alloc(struct Env *e, void *va, size_t len)  
  3. {  
  4.     // LAB 3: Your code here.  
  5.     void* i;  
  6.     cprintf("region_alloc %x,%d\r\n",e->env_pgdir,len);  
  7.     for(i=ROUNDDOWN(va,PGSIZE);i<ROUNDUP(va+len,PGSIZE);i+=PGSIZE)  
  8.     {  
  9.         struct Page* p=(struct Page*)page_alloc(1);  
  10.         if(p==NULL)  
  11.             panic("Memory out!");  
  12.         page_insert(e->env_pgdir,p,i,PTE_W|PTE_U);  
  13.     }  
  14.   
  15. }  

（6）进程代码加载
通过load_icode给相应的进程加载可执行代码。可执行代码的格式是elf格式，因此使用类似加载kernel的方式将代码加载到相应内存中。
因为当前JOS没有文件系统，所以用户态的程序是编译在kernel里面的，通过编译器的导出符号来进行访问，通过追踪init.c里的相关代码也可以说明这一点。当然在这里我们无需更多的关注这个可执行代码目前在哪里，只需要完成其加载机制即可。
为了往进程对应的虚拟空间映射到的物理内存中写数据，首先必须要加载进程相应的页目录，当然必须使用此函数外的逻辑来保证在调用此函数之前页目录是已经初始化过的。接着仿照kernel的方式去分析elf文件，加载类型为ELF_PROG_LOAD的段到其要求的虚拟地址中，使用之前完成的辅助函数来方便的进行地址的映射。最后将程序入口放入进程的eip中（后面会有解释），并映射进程堆栈（个人认为堆栈映射应该放在env_setup_vm会更合乎逻辑一些），然后重新加载kern_pgdir，函数返回。

  1. static void  
  2. load_icode(struct Env *e, uint8_t *binary, size_t size)  
  3. {  
  4.     // LAB 3: Your code here.  
  5.     lcr3(PADDR(e->env_pgdir));  
  6.     cprintf("load_icode\r\n");  
  7.     struct Elf * ELFHDR=(struct Elf *)binary;  
  8.     struct Proghdr *ph, *eph;  
  9.     int i;  
  10.     if (ELFHDR->e_magic != ELF_MAGIC)  
  11.             panic("Not a elf binary");  
  12.   
  13.   
  14.         ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->e_phoff);  
  15.         eph = ph + ELFHDR->e_phnum;  
  16.         for (; ph < eph; ph++)  
  17.         {  
  18.             // p_pa is the load address of this segment (as well  
  19.             // as the physical address)  
  20.             if(ph->p_type==ELF_PROG_LOAD)  
  21.             {  
  22.             cprintf("load_prog %d\r\n",ph->p_filesz);  
  23.             region_alloc(e,(void*)ph->p_va,ph->p_filesz);  
  24.             char* va=(char*)ph->p_va;  
  25.             for(i=0;i<ph->p_filesz;i++)  
  26.             {  
  27.   
  28.                 va[i]=binary[ph->p_offset+i];  
  29.             }  
  30.   
  31.             }  
  32.         }  
  33.         e->env_tf.tf_eip=ELFHDR->e_entry;  
  34.   
  35.     // Now map one page for the program's initial stack  
  36.     // at virtual address USTACKTOP - PGSIZE.  
  37.   
  38.     // LAB 3: Your code here.  
  39.         struct Page* p=(struct Page*)page_alloc(1);  
  40.      if(p==NULL)  
  41.          panic("Not enough mem for user stack!");  
  42.      page_insert(e->env_pgdir,p,(void*)(USTACKTOP-PGSIZE),PTE_W|PTE_U);  
  43.      cprintf("load_icode finish!\r\n");  
  44.      lcr3(PADDR(kern_pgdir));  
  45. } 

（7）进程建立
使用上述完成的函数来建立进程。
完成env_create函数，首先分配一个进程描述符，然后加载可执行代码，逻辑很简单。

  1. void  
  2. env_create(uint8_t *binary, size_t size, enum EnvType type)  
  3. {  
  4.     // LAB 3: Your code here.  
  5.   
  6.     struct Env* env;  
  7.   
  8.     if(env_alloc(&env,0)==0)  
  9.     {  
  10.         env->env_type=type;  
  11.         load_icode(env, binary,size);  
  12.     }  
  13.   
  14. }  

（8）进程执行
完成env_run函数来运行进程。
首先设置当前进程的一些信息，然后更改当前进程指针指向要运行的进程，之后加载进程页目录跳转到使用env_pop_tf真正使进程执行。

  1. void  
  2. env_run(struct Env *e)  
  3. {  
  4.    
  5.     // LAB 3: Your code here.  
  6.     cprintf("Run env!\r\n");  
  7.     if(curenv!=NULL)  
  8.     {  
  9.         if(curenv->env_status==ENV_RUNNING)  
  10.         {  
  11.             curenv->env_status=ENV_RUNNABLE;  
  12.         }  
  13.     }  
  14.     curenv=e;  
  15.     e->env_status=ENV_RUNNING;  
  16.     e->env_runs++;  
  17.     lcr3(PADDR(e->env_pgdir));  
  18.     env_pop_tf(&e->env_tf);  
  19. }  

接着分析env_pop_tf。

env_pop_tf首先将传入的trapframe，包含所有的寄存器信息压栈，然后使用iret，即中断返回来执行。

  1. void  
  2. env_pop_tf(struct Trapframe *tf)  
  3. {  
  4.     __asm __volatile("movl %0,%%esp\n"  
  5.         "\tpopal\n"  
  6.         "\tpopl %%es\n"  
  7.         "\tpopl %%ds\n"  
  8.         "\taddl $0x8,%%esp\n" /* skip tf_trapno and tf_errcode */  
  9.         "\tiret"  
  10.         : : "g" (tf) : "memory");  
  11.     panic("iret failed");  /* mostly to placate the compiler */  
  12. }  

iret到底是什么，这里引用一段IA-32手册上的话：
the IRET instruction pops the return instruction pointer, return code segment selector, and EFLAGS image from the stack to the EIP,
CS, and EFLAGS registers, respectively, and then resumes execution of the interrupted program or procedure. If the return is to another privilege level, the IRET instruction also pops the stack pointer and SS from the stack, before resuming program execution。

为什么要使用这种方式来运行第一个进程，而不是直接根据该进程入口执行，主要是因为当前运行在内核态（CPL，也就是CS等寄存器的后两位，见图），要使进程运行在用户态必须改变各段寄存器的CPL，但又不能直接给诸如CS等寄存器赋值，所以必须使用iret从堆栈里弹出相应寄存器的值，这也是需要事先将tf的eip放入进程代码入口地址的原因。



做完这些之后，第一个进程就能运行起来了，但立刻又崩溃了，因为没有处理系统调用，而系统调用相关的实现就是下篇日志的内容了。
返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞