my solution to lab3

Author: anexpn

answer-lab3.txt

@@ -0,0 +1,7 @@
+1. 目的是为了将用户有权限触发的系统调用和其他用户不可交互的异常处理函数区分开来，
+如果处理函数都指向同一个函数就不能提供保护的同时实现系统调用。
+2. page fault handler的DPL是0，用户模式执行int $14会因为权限不够而触发general protection fault，即trap 13，
+在trap_init()里把page fault的idt项的DPL设为3，那么用户就可以执行int $14，不过这样会让用户可以越权执行内存管理。
+3. int3是在用户模式调用的，如果T_BRKPT的idt项的DPL为3那么就可以正常触发break point exception，如果DPL为0就会触发
+general protection fault。应把DPL设为3。
+4. 关键在于是否进行保护，int3的语义就是不进行保护的，所以可以把DPL设为3，而page fault不是。

inc/env.h

@@ -54,6 +54,7 @@ struct Env {
 
 	// Address space
 	pde_t *env_pgdir;		// Kernel virtual address of page dir
+	uint32_t env_break;
 };
 
 #endif // !JOS_INC_ENV_H

inc/x86.h

@@ -3,6 +3,11 @@
 
 #include <inc/types.h>
 
+#define wrmsr(msr,val1,val2) \
+	__asm__ __volatile__("wrmsr" \
+	: /* no outputs */ \
+	: "c" (msr), "a" (val1), "d" (val2))
+
 static inline void
 breakpoint(void)
 {

kern/env.c

@@ -116,6 +116,21 @@ env_init(void)
 {
 	// Set up envs array
 	// LAB 3: Your code here.
+	struct Env *p, *tail;
+	
+	tail = env_free_list;
+
+	for (size_t i = 0; i < NENV; i++) {
+		p = envs + i;
+		p->env_id = 0;
+		p->env_status = ENV_FREE;
+		if (tail == NULL) {
+			tail = env_free_list = p;
+		} else {
+			tail->env_link = p;
+			tail = tail->env_link;
+		}
+	}
 
 	// Per-CPU part of the initialization
 	env_init_percpu();
@@ -179,7 +194,11 @@ env_setup_vm(struct Env *e)
 	//    - The functions in kern/pmap.h are handy.
 
 	// LAB 3: Your code here.
-
+	p->pp_ref++;
+	e->env_pgdir = page2kva(p);
+	for (i = PDX(UTOP); i < NPDENTRIES; i++) {
+		e->env_pgdir[i] = kern_pgdir[i];
+	}
 	// UVPT maps the env's own page table read-only.
 	// Permissions: kernel R, user R
 	e->env_pgdir[PDX(UVPT)] = PADDR(e->env_pgdir) | PTE_P | PTE_U;
@@ -257,7 +276,7 @@ env_alloc(struct Env **newenv_store, envid_t parent_id)
 // Pages should be writable by user and kernel.
 // Panic if any allocation attempt fails.
 //
-static void
+void
 region_alloc(struct Env *e, void *va, size_t len)
 {
 	// LAB 3: Your code here.
@@ -267,6 +286,24 @@ region_alloc(struct Env *e, void *va, size_t len)
 	//   'va' and 'len' values that are not page-aligned.
 	//   You should round va down, and round (va + len) up.
 	//   (Watch out for corner-cases!)
+	struct PageInfo *p;
+	char *eva, *sva;
+
+	if (len <= 0) {
+		return;
+	}
+	//TODO: check later
+	eva = ROUNDUP(va + len, PGSIZE);
+	sva = ROUNDDOWN(va, PGSIZE);
+	for (; sva < eva; sva += PGSIZE) {
+		if (!(p = page_alloc(0))) {
+			panic("region_alloc: %e\n", -E_NO_MEM);
+		}
+		p->pp_ref++;
+		if (page_insert(e->env_pgdir, p, sva, PTE_W | PTE_U) < 0) {
+			panic("region_alloc: %e\n", -E_NO_MEM);
+		}
+	}
 }
 
 //
@@ -323,11 +360,39 @@ load_icode(struct Env *e, uint8_t *binary)
 	//  What?  (See env_run() and env_pop_tf() below.)
 
 	// LAB 3: Your code here.
+	struct Proghdr *ph, *eph;
+	struct Elf *elf;
+
+	elf = (struct Elf *)binary;
+
+	if (elf->e_magic != ELF_MAGIC)
+		panic("load_icode: bad\n");
+	
+	lcr3(PADDR(e->env_pgdir));
+
+	e->env_break = 0;
+	ph = (struct Proghdr *) ((uint8_t *) elf + elf->e_phoff);
+	eph = ph + elf->e_phnum;
+	for (; ph < eph; ph++) {
+		if (ph->p_type != ELF_PROG_LOAD)
+			continue;
+		if (ph->p_flags == (ELF_PROG_FLAG_READ | ELF_PROG_FLAG_WRITE)) {
+			e->env_break = MAX((ph->p_va + ph->p_memsz), e->env_break);
+		}
+		region_alloc(e, (void *)ph->p_va, ph->p_memsz);
+		for (size_t i = 0; i < ph->p_filesz; i++) {
+			*(((uint8_t *)ph->p_va) + i) = *(binary + ph->p_offset + i);
+		}
+		memset((void *)(ph->p_va + ph->p_filesz), 0, ph->p_memsz - ph->p_filesz);
+	}
 
 	// Now map one page for the program's initial stack
 	// at virtual address USTACKTOP - PGSIZE.
 
 	// LAB 3: Your code here.
+	region_alloc(e, (void *)(USTACKTOP - PGSIZE), PGSIZE);
+	e->env_tf.tf_eip = elf->e_entry;
+	lcr3(PADDR(kern_pgdir));
 }
 
 //
@@ -341,6 +406,14 @@ void
 env_create(uint8_t *binary, enum EnvType type)
 {
 	// LAB 3: Your code here.
+	struct Env *e;
+	int r;
+
+	if ((r = env_alloc(&e, 0)) < 0) {
+		panic("env_create: %e\n", r);
+	}
+	load_icode(e, binary);
+	e->env_type = type;
 }
 
 //
@@ -457,7 +530,16 @@ env_run(struct Env *e)
 	//	e->env_tf to sensible values.
 
 	// LAB 3: Your code here.
+	//panic("env_run not yet implemented");
+	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);
 
-	panic("env_run not yet implemented");
 }
 

kern/env.h

@@ -16,6 +16,8 @@ void	env_free(struct Env *e);
 void	env_create(uint8_t *binary, enum EnvType type);
 void	env_destroy(struct Env *e);	// Does not return if e == curenv
 
+void region_alloc(struct Env *e, void *va, size_t len);
+
 int	envid2env(envid_t envid, struct Env **env_store, bool checkperm);
 // The following two functions do not return
 void	env_run(struct Env *e) __attribute__((noreturn));

kern/kdebug.c

@@ -142,6 +142,8 @@ debuginfo_eip(uintptr_t addr, struct Eipdebuginfo *info)
 		// Make sure this memory is valid.
 		// Return -1 if it is not.  Hint: Call user_mem_check.
 		// LAB 3: Your code here.
+		if (user_mem_check(curenv, usd, sizeof(*usd), 0) < 0)
+			return -1;
 
 		stabs = usd->stabs;
 		stab_end = usd->stab_end;
@@ -150,6 +152,10 @@ debuginfo_eip(uintptr_t addr, struct Eipdebuginfo *info)
 
 		// Make sure the STABS and string table memory is valid.
 		// LAB 3: Your code here.
+		if (user_mem_check(curenv, stabs, sizeof(*stabs), 0) < 0)
+			return -1;
+		if (user_mem_check(curenv, stabstr, sizeof(*stabstr), 0) < 0)
+			return -1;
 	}
 
 	// String table validity checks
@@ -204,6 +210,11 @@ debuginfo_eip(uintptr_t addr, struct Eipdebuginfo *info)
 	//	Look at the STABS documentation and <inc/stab.h> to find
 	//	which one.
 	// Your code here.
+	stab_binsearch(stabs, &lline, &rline, N_SLINE, addr);
+	if (lline <= rline)
+		info->eip_line = lline;
+	else
+		return -1;
 
 
 	// Search backwards from the line number for the relevant filename

kern/pmap.c

@@ -167,6 +167,12 @@ mem_init(void)
 	}
 	page_free_list = NULL;
 
+	envs = (struct Env *)boot_alloc(NENV * sizeof(struct Env));
+	for (size_t i = 0; i < NENV; i++) {
+		memset(envs + i, 0, sizeof(struct Env));
+	}
+	curenv = NULL;
+
 
 	//////////////////////////////////////////////////////////////////////
 	// Now that we've allocated the initial kernel data structures, we set
@@ -192,6 +198,8 @@ mem_init(void)
 	// Your code goes here:
 	boot_map_region(kern_pgdir, UPAGES, PTSIZE, PADDR(pages), PTE_U);
 
+	boot_map_region(kern_pgdir, UENVS, PTSIZE, PADDR(envs), PTE_U);
+
 	//////////////////////////////////////////////////////////////////////
 	// Use the physical memory that 'bootstack' refers to as the kernel
 	// stack.  The kernel stack grows down from virtual address KSTACKTOP.
@@ -563,6 +571,26 @@ int
 user_mem_check(struct Env *env, const void *va, size_t len, int perm)
 {
 	// LAB 3: Your code here.
+	char *sva, *eva;
+	uintptr_t uva;
+	pte_t *p;
+
+	uva = (uintptr_t)va;
+	if (uva >= ULIM) {
+		user_mem_check_addr = uva;
+		return -E_FAULT;
+	}
+
+	sva = (char *)ROUNDDOWN(uva, PGSIZE);
+	eva = (char *)ROUNDUP(uva + len, PGSIZE);
+	for (; sva < eva; sva += PGSIZE) {
+		p = pgdir_walk(env->env_pgdir, sva, 0);
+		if (!p || ((*p & (perm | PTE_P)) != (perm | PTE_P))) {
+			user_mem_check_addr = MAX(uva, (uintptr_t)sva);
+			return -E_FAULT;
+		}
+	}
+	
 
 	return 0;
 }

kern/syscall.c

@@ -21,6 +21,7 @@ sys_cputs(const char *s, size_t len)
 	// Destroy the environment if not.
 
 	// LAB 3: Your code here.
+	user_mem_assert(curenv, s, len, 0);
 
 	// Print the string supplied by the user.
 	cprintf("%.*s", len, s);
@@ -77,7 +78,9 @@ static int
 sys_sbrk(uint32_t inc)
 {
     // LAB3: your code here.
-    return 0;
+	region_alloc(curenv, (void *)curenv->env_break, inc);
+	curenv->env_break += inc;
+    return curenv->env_break;
 }
 
 // Dispatches to the correct kernel function, passing the arguments.
@@ -88,11 +91,24 @@ syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4,
 	// Return any appropriate return value.
 	// LAB 3: Your code here.
 
-	panic("syscall not implemented");
+	//panic("syscall not implemented");
 
 	switch (syscallno) {
-	default:
-		return -E_INVAL;
+		case SYS_cputs:
+			sys_cputs((char *)a1, (size_t)a2);
+			return 0;
+		case SYS_cgetc: 
+			return sys_cgetc();
+		case SYS_getenvid: 
+			return sys_getenvid();
+		case SYS_env_destroy: 
+			return sys_env_destroy((envid_t)a1);
+		case SYS_map_kernel_page: 
+			return sys_map_kernel_page((void *)a1, (void *)a2);
+		case SYS_sbrk: 
+			return sys_sbrk(a1);
+		default:
+			return -E_INVAL;
 	}
 }