- A+
Lab3 Part A
内核维护了三个关于用户环境的全局量
struct Env *envs = NULL; // All environments struct Env *curenv = NULL; // The current env static struct Env *env_free_list; // Free environment list 分别对应所有的环境，当前运行的用户环境和空闲的环境链表。
Environment State
Env结构体的定义如下：
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:
这个指针指向env_free_list的后一个空闲的Env结构体。
env_id:
唯一地确定使用这个结构体的用户环境。用户环境终止后，内核也许会把这个结构体分给另外一个环境，新的环境会有新的env_id值。
env_parent_id:
创建这个用户环境的环境(parent)的env_id，构建一颗tree。
env_type:
用于区别特别的用户环境。大多数清空下值都是ENV_TYPE_USER.
env_status:
这个变量有以下可能的取值：
ENV_FREE: 代表这个Env结构体不活跃的，应该在链表env_free_list中。
ENV_RUNNABLE: 对应的用户环境已经就绪，等待被分配处理机。
ENV_RUNNING: 对应的用户环境正在运行。
ENV_NOT_RUNNABLE: Env结构体所代表的是一个当前状态下活跃的用户环境，但是并未就绪，在等待IPC(Interprocess communication)。
ENV_DYING: Env对应的是一个僵尸环境(Zombie environment)。一个僵尸环境在下一次陷入内核时会被释放回收(Lab4 会使用)。
env_pgdir:
存放着这个环境的页目录的虚拟地址。
Allocating the Environment Array
需要进一步地修改mem_init()函数，分配一个envs数组，这个数组保存所有的环境，并进行映射。需要新增的代码如下：
struct Env* envs = (struct Env*)boot_alloc(NENV * sizeof(struct Env)); memset(envs,0,NENV * sizeof(struct Env)); //... ... boot_map_region(kern_pgdir,UENVS,PTSIZE,PADDR(envs),PTE_U); Creating and Running Environments
现在需要完成如何让用户环境跑起来的代码了。因为还没有文件系统，因此只能加载嵌入内核自身的静态二进制映像。Lab3的makefile会生成几个二进制文件放在obj/user中，一些技巧将这些二进制文件link到了内核之中。二进制文件中会有一个特殊的符号，通过生成的这些符号可以来引用到这些代码。
-
第一个函数env_init()，需要初始化所有的Env结构，将其挂入链表，也调用env_init_percpu来配置底层的信息。
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(); }与lab2的pages数组处理类似。注意链表的顺序。
-
第二个函数env_setup_vm()，为新的环境分配页目录，并且初始化
static int env_setup_vm(struct Env *e) { //------------------------------------------ // 源代码中的注释此处为了篇幅，很多详细说明都略去了 // 详细的信息，请自行阅读源代码 //------------------------------------------ int i; struct PageInfo *p = NULL; // 给页目录的分配一个物理页来存储 if (!(p = page_alloc(ALLOC_ZERO))) return -E_NO_MEM; // 得到页目录的虚拟地址所在 e->env_pgdir = (pde_t*)page2kva(p); // 要求的自增引用计数 p->pp_ref++; // 这部分的页目录值，和kern_pgdir是一致的 // 因此 也可以使用 // memcpy(e->env_pgdir,kern_pgdir,PGSIZE); for(i=0;i<PDX(UTOP);i++){ e->env_pgdir[i]=0; } for(i=PDX(UTOP);i<NPDENTRIES;i++){ e->env_pgdir[i]=kern_pgdir[i]; } // 唯一和kern_pgdir不一样的是对于自身的映射 e->env_pgdir[PDX(UVPT)] = PADDR(e->env_pgdir) | PTE_P | PTE_U; return 0; }设置完页目录，用户环境继承了内核的地址映射，对于后续而言，每个用户进程都能有自己的虚拟地址空间，且共享内核。
-
第三个函数region_alloc()，作用是为环境分配物理空间。分配物理空间，就是之前说的分配物理页，使用的是page_alloc()。分配物理也，然后更改页表。
static void region_alloc(struct Env *e, void *va, size_t len) { void * beigin =ROUNDDOWN(va,PGSIZE); void * end = ROUNDUP(va+len,PGSIZE); for(;beigin<end;beigin+=PGSIZE){ // 申请物理页 struct PageInfo* apage=page_alloc(0); if(!apage){ panic("region_alloc fail ,out of memory!"); } // 安装到页表 page_insert(e->env_pgdir,apage,beigin,PTE_U|PTE_W); } } -
第四个函数 load_icode()，用来解析一个ELF映像，像Lab1中bootloader做的一样。并把映像加载到新环境的用户空间。在编写时，如下几点值得注意：
- 阅读boot/main.c 来得到灵感
- 只有p_type=ELF_PROG_LOAD的段才需要被被加载
- ph->p_va 是需要被加载到的虚地址
- ph->p_memsz 是整个在内存中占的大小，也是我们申请空间时的大小
- 从 binary + ph->p_offset 开始的ph->p_filesz字节需要被复制到ph->p_va处
- 需要考虑一些ELF头的入口点处理
- 这个过程在进行环境处理时，因为需要映射新的页，因此需要切换页目录
- 哪些地方会产生panic？
static void load_icode(struct Env *e, uint8_t *binary) { struct Proghdr *ph,*end_ph; struct Elf * elf_header = (struct Elf*)binary; if(elf_header->e_magic!=ELF_MAGIC){ panic("not a elf format file"); } ph=(struct Proghdr*)((uint8_t*)elf_header+elf_header->e_phoff); end_ph=ph+elf_header->e_phnum; lcr3(PADDR(e->env_pgdir)); for(;ph<end_ph;ph++){ if(ph->p_type==ELF_PROG_LOAD){ if(ph->p_memsz-ph->p_filesz<0){ panic("p_memsz < p_filesz"); } region_alloc(e,(void*)ph->p_va,ph->p_memsz); memcpy((void*)ph->p_va,(void*)binary+ph->p_offset,ph->p_filesz); memset((void*)(ph->p_va+ph->p_filesz),0,ph->p_memsz-ph->p_filesz); } } e->env_tf.tf_eip=elf_header->e_entry; region_alloc(e,(void*)(USTACKTOP-PGSIZE),PGSIZE); lcr3(PADDR(kern_pgdir)); } -
第五个函数env_create(),用来分配环境并加载ELF文件。实现很简单，使用env_alloc获得一个新的环境，然后用load_icode加载。
void env_create(uint8_t *binary, enum EnvType type) { struct Env* new_env; int r; if((r=env_alloc(&new_env,0))!=0){ panic("env alloc fail in env creat :%e",r); } new_env->env_type=type; load_icode(new_env,binary); } -
第六个函数env_run()，在用户态中开始运行一个环境。这部分函数只要按照注释完成即可。
void env_run(struct Env *e) { if((curenv!=NULL) && curenv->env_status==ENV_RUNNING){ curenv->env_type=ENV_RUNNABLE; } curenv=e; e->env_status=ENV_RUNNING; e->env_runs++; lcr3(PADDR(e->env_pgdir)); //保存环境 env_pop_tf(&e->env_tf); }
有一个函数也值得讨论，那就是env_pop_tf()，相关的结构和定义如下：
struct PushRegs { /* registers as pushed by pusha */ uint32_t reg_edi; uint32_t reg_esi; uint32_t reg_ebp; uint32_t reg_oesp; /* Useless */ uint32_t reg_ebx; uint32_t reg_edx; uint32_t reg_ecx; uint32_t reg_eax; } __attribute__((packed)); struct Trapframe { struct PushRegs tf_regs; uint16_t tf_es; uint16_t tf_padding1; uint16_t tf_ds; uint16_t tf_padding2; uint32_t tf_trapno; /* below here defined by x86 hardware */ uint32_t tf_err; uintptr_t tf_eip; uint16_t tf_cs; uint16_t tf_padding3; uint32_t tf_eflags; /* below here only when crossing rings, such as from user to kernel */ uintptr_t tf_esp; uint16_t tf_ss; uint16_t tf_padding4; } __attribute__((packed)); void env_pop_tf(struct Trapframe *tf) { asm volatile( "tmovl %0,%%espn" // esp指向tf结构，弹出时会弹到tf里 "tpopaln" // 弹出tf_regs中值到各通用寄存器 "tpopl %%esn" // 弹出tf_es 到 es寄存器 "tpopl %%dsn" // 弹出tf_ds 到 ds寄存器 "taddl $0x8,%%espn" // 跳过tf_trapno和tf_err "tiretn" // 中断返回 弹出tf_eip,tf_cs,tf_eflags,tf_esp,tf_ss到相应寄存器 : : "g" (tf) : "memory"); panic("iret failed"); /* mostly to placate the compiler */ } 运行make qemu-gdb和make gdb，然后断点打在env_pop_tf，执行到iret指令,在iret之前
eax 0x0 0 ecx 0x0 0 edx 0x0 0 ebx 0x0 0 esp 0xf01d1030 0xf01d1030 ebp 0x0 0x0 esi 0x0 0 edi 0x0 0 eip 0xf01038e2 0xf01038e2 <env_pop_tf+31> eflags 0x96 [ PF AF SF ] cs 0x8 8 ss 0x10 16 ds 0x23 35 es 0x23 35 fs 0x23 35 gs 0x23 35 可以看到此时的cs为00001 000，是我们GDT中的第一个段，内核段。在iret之后
eax 0x0 0 ecx 0x0 0 edx 0x0 0 ebx 0x0 0 esp 0xeebfe000 0xeebfe000 ebp 0x0 0x0 esi 0x0 0 edi 0x0 0 eip 0x800020 0x800020 eflags 0x2 [ ] cs 0x1b 27 ss 0x23 35 ds 0x23 35 es 0x23 35 fs 0x23 35 gs 0x23 35 cs=0X1b=0001 1011,所以是GDT中的第三个描述符（user code segment），权限为3（用户态）。
在obj/user/hello.asm找到
800b93: cd 30 int $0x30 syscall(SYS_cputs, 0, (uint32_t)s, len, 0, 0, 0); 断点设置在此处，由于系统调用还没有实现，这里往下执行就会触发triple fault。
可以有如下的函数调用图:
- start (kern/entry.S)
- i386_init (kern/init.c)
-
cons_init
-
mem_init
-
env_init
-
trap_init (still incomplete at this point)
-
env_create
-
env_alloc
- env_setup_vm
-
load_icode
- region_alloc
-
-
env_run
- env_pop_tf
-
User stack and Kernel stack
这里提前说明一下关于用户栈和内核栈，以及这俩的切换过程，在后续进程等地方，这一套机制都很受用。
这是涉及到特权级切换的情况，用户程序的栈和内核的栈，组合形成一套栈。这个过程ss，sp，eflags，cs，eip在中断发生时由处理器压入,通用寄存器部分需要自己实现，详情可以参考哈工大李治军老师关于操作系统的课程。
Handling Interrupts and Exceptions
Part of 80386 Programmer's Manual
这是这部分开头练习的要求，这里就来读一读8086程序员手册。
首先便是中断和溢出的分类：
一般地不刻意区分这些术语(在这套体系中)。
NMI和Exception都分配了唯一的中断号，系统保留0~31这32个中断号（因此，如果用户自定义中断，中断号应从32开始）。
如果一定要区分的话，exception被分为faults, traps和aborts, 区分的标准是这些exception如何被通知，何时重新执行造成溢出的指令。
下一个话题是中断描述符表IDT，每个中断或者溢出的服务程序都和IDT中的8B中断描述符相关联。和GDT，LDT不同，IDT的第一个描述符并不是空的。
IDT中的描述符有三种类别：任务们，中断门，陷阱门（由type字段标识）。
至于中断服务程序的定位，就是在查GDT或LDT之前，多查一次IDT
而中断服务程序如果和当前代码之间存在特权级的转移，那么栈的变化在上文已经说明了。
An Example
讲前文的诸多小知识拼凑起来，通过一个例子来过一遍整个过程。
处理器正在用户空间执行代码，遇到了一条除以零的指令，由此引发溢出：
- 处理器切换到内核栈(由SS0 ESP0进行内核栈的定位)，此时内核栈为空。
- 内核栈压入一系列溢出现场，进行现场保护
- 因为正在处理除以零溢出，因此中断向量0被索引到了，因此处理器读取IDT的第0项，将cs:eip指向中断处理程序。
- 处理程序获得控制权并处理该溢出，比如说该程序终止该用户环境的运行。
某些特定的x86溢出，除了会压入上面的经典5个字段，还会压入error code。在处理栈时，不要忘了跳过这个字段，如果需要的话。
Setting Up the IDT
经过了理论部分，现在到了该实现IDT的时候了。
首先是trapentry.S, 在这个文件中提供了如下两个宏：
作用是压入中断号，跳转到_alltraps；其中对于压入错误码的使用TRAPHANDLER，对于不压入错误码的使用TRAPHANDLER_NOEC。此处入口的name应该是一个函数的名字，正如内部声明：.type name, @function; /* symbol type is function */
#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 #define TRAPHANDLER_NOEC(name, num) .globl name; .type name, @function; .align 2; name: pushl $0; pushl $(num); jmp _alltraps 阅读注释，可以完善该文件：
_alltraps中的push %esp 相当于传递了一个Trapframe结构，因为经典的5个字段由处理器自动压入，而_alltraps中压入的顺序，正好可以与Trapframe结构对应起来，因此trap函数可以获得Trapframe信息。
/* * Lab 3: Your code here for generating entry points for the different traps. */ TRAPHANDLER_NOEC(int0,0); TRAPHANDLER_NOEC(int1,1); TRAPHANDLER_NOEC(int2,2); TRAPHANDLER_NOEC(int3,3); TRAPHANDLER_NOEC(int4,4); TRAPHANDLER_NOEC(int5,5); TRAPHANDLER_NOEC(int6,6); TRAPHANDLER_NOEC(int7,7); TRAPHANDLER(int8,8); TRAPHANDLER(int10,10); TRAPHANDLER(int11,11); TRAPHANDLER(int12,12); TRAPHANDLER(int13,13); TRAPHANDLER(int14,14); TRAPHANDLER_NOEC(int16,16); TRAPHANDLER_NOEC(__syscall,T_SYSCALL); /* * Lab 3: Your code here for _alltraps */ _alltraps: pushl %ds pushl %es pushal push $GD_KD popl %ds push $GD_KD popl %es pushl %esp call trap 下面要建立IDT，首先关于门描述符，在mmu.h中提供了相关的工具
// Gate descriptors for interrupts and traps struct Gatedesc { unsigned gd_off_15_0 : 16; // low 16 bits of offset in segment unsigned gd_sel : 16; // segment selector unsigned gd_args : 5; // # args, 0 for interrupt/trap gates unsigned gd_rsv1 : 3; // reserved(should be zero I guess) unsigned gd_type : 4; // type(STS_{TG,IG32,TG32}) unsigned gd_s : 1; // must be 0 (system) unsigned gd_dpl : 2; // descriptor(meaning new) privilege level unsigned gd_p : 1; // Present unsigned gd_off_31_16 : 16; // high bits of offset in segment }; // Set up a normal interrupt/trap gate descriptor. // - istrap: 1 for a trap (= exception) gate, 0 for an interrupt gate. // see section 9.6.1.3 of the i386 reference: "The difference between // an interrupt gate and a trap gate is in the effect on IF (the // interrupt-enable flag). An interrupt that vectors through an // interrupt gate resets IF, thereby preventing other interrupts from // interfering with the current interrupt handler. A subsequent IRET // instruction restores IF to the value in the EFLAGS image on the // stack. An interrupt through a trap gate does not change IF." // - sel: Code segment selector for interrupt/trap handler // - off: Offset in code segment for interrupt/trap handler // - dpl: Descriptor Privilege Level - // the privilege level required for software to invoke // this interrupt/trap gate explicitly using an int instruction. #define SETGATE(gate, istrap, sel, off, dpl) { (gate).gd_off_15_0 = (uint32_t) (off) & 0xffff; (gate).gd_sel = (sel); (gate).gd_args = 0; (gate).gd_rsv1 = 0; (gate).gd_type = (istrap) ? STS_TG32 : STS_IG32; (gate).gd_s = 0; (gate).gd_dpl = (dpl); (gate).gd_p = 1; (gate).gd_off_31_16 = (uint32_t) (off) >> 16; } 因此trap_init()函数如下
void trap_init(void) { extern struct Segdesc gdt[]; // LAB 3: Your code here. void int0(); void int1(); void int2(); void int3(); void int4(); void int5(); void int6(); void int7(); void int8(); void int10(); void int11(); void int12(); void int13(); void int14(); void int16(); void _syscall_(); SETGATE(idt[0],0,GD_KT,int0,0); SETGATE(idt[1],0,GD_KT,int1,0); SETGATE(idt[2],0,GD_KT,int2,0); SETGATE(idt[3],0,GD_KT,int3,0); SETGATE(idt[4],0,GD_KT,int4,0); SETGATE(idt[5],0,GD_KT,int5,0); SETGATE(idt[6],0,GD_KT,int6,0); SETGATE(idt[7],0,GD_KT,int7,0); SETGATE(idt[8],0,GD_KT,int8,0); SETGATE(idt[10],0,GD_KT,int10,0); SETGATE(idt[11],0,GD_KT,int11,0); SETGATE(idt[12],0,GD_KT,int12,0); SETGATE(idt[13],0,GD_KT,int13,0); SETGATE(idt[14],0,GD_KT,int14,0); SETGATE(idt[16],0,GD_KT,int16,0); SETGATE(idt[T_SYSCALL],0,GD_KT,_syscall_,0); // Per-CPU setup trap_init_percpu(); } 至此，函数的调用关系如图：
当遇到中断时，会调用trap：
trap会打印出相关的信息。
现在可以开始测试了：
实验三的A部分到此完结。下一篇文章，关于PartA 的一些问题和PartB
