6.828 Lab4（上）

	// First, round up the size
	size = ROUNDUP(size, PGSIZE);
	// watch out for overflow
	if((base + size > MMIOLIM) || (base + size < base))
		panic("Overflow in mmio region");
	boot_map_region(kern_pgdir, base, size, pa, PTE_PCD | PTE_PWT | PTE_W);
	base += size;
	return (void*)(base - size);

	struct PageInfo* mp_entry_page = pa2page(MPENTRY_PADDR);
	size_t i;
	for (i = 1; i < npages_basemem; i++) {
		if(pages + i == mp_entry_page)
			continue;
		pages[i].pp_ref = 0;
		pages[i].pp_link = page_free_list;
		page_free_list = &pages[i];
	}
	i = PADDR(boot_alloc(0)) / PGSIZE;
	for(; i < npages; i++)
	{
		pages[i].pp_ref = 0;
		pages[i].pp_link = page_free_list;
		page_free_list = &pages[i];
	}

	// LAB 4: Your code here:
	uintptr_t kstacktop_i;
	for(int i = 0; i < NCPU; i++)
	{
		kstacktop_i = KSTACKTOP - i * (KSTKSIZE + KSTKGAP);
		boot_map_region(kern_pgdir, kstacktop_i - KSTKSIZE, KSTKSIZE, 
		PADDR(percpu_kstacks[i]), PTE_W);
	}

	// LAB 4: Your code here:

	// Setup a TSS so that we get the right stack
	// when we trap to the kernel.
	thiscpu->cpu_ts.ts_esp0 = (uintptr_t)(percpu_kstacks[cpunum()] + KSTKSIZE);
	thiscpu->cpu_ts.ts_ss0 = GD_KD;
	thiscpu->cpu_ts.ts_iomb = sizeof(struct Taskstate);

	// Initialize the TSS slot of the gdt.
	gdt[(GD_TSS0 >> 3) + cpunum()] = SEG16(STS_T32A, (uint32_t)(&(thiscpu->cpu_ts)),
					sizeof(struct Taskstate) - 1, 0);
	gdt[(GD_TSS0 >> 3) + cpunum()].sd_s = 0;

	// Load the TSS selector (like other segment selectors, the
	// bottom three bits are special; we leave them 0)
	ltr(GD_TSS0 + (cpunum() << 3));

	// Load the IDT
	lidt(&idt_pd);
}

	// Acquire the big kernel lock before waking up APs
	// Your code here:
	lock_kernel();



	// Now that we have finished some basic setup, call sched_yield()
	// to start running processes on this CPU.  But make sure that
	// only one CPU can enter the scheduler at a time!
	//
	// Your code here:
	lock_kernel();
	sched_yield();


	if ((tf->tf_cs & 3) == 3) {
		// Trapped from user mode.
		// Acquire the big kernel lock before doing any
		// serious kernel work.
		// LAB 4: Your code here.
		lock_kernel();
		assert(curenv);


	lcr3(PADDR(curenv->env_pgdir));
	unlock_kernel();
	env_pop_tf(&curenv->env_tf);

	// LAB 4: Your code here.
	// idle is where we start searching
	idle = (curenv == NULL) ? envs : (curenv + 1);
	// A flag, indicating whether find an runnable env
	bool flag = false;
	for(struct Env* e = idle; e != envs + NENV; e++)
	{
		if(e->env_status == ENV_RUNNABLE)
		{
			flag = true;
			env_run(e);
			break;
		}
	}
	// do the circular searching
	if(!flag)
		for(struct Env* e = envs; e != idle; e++)
		{
			if(e->env_status == ENV_RUNNABLE)
			{
				flag = true;
				env_run(e);
				break;
			}		
		}
	// check idle for the last time, for the time it is running
	if(!flag && curenv != NULL && curenv->env_status == ENV_RUNNING)
		env_run(curenv);
	// sched_halt never returns
	if(!flag)
		sched_halt();
}

// Allocate a new environment.
// Returns envid of new environment, or < 0 on error.  Errors are:
//	-E_NO_FREE_ENV if no free environment is available.
//	-E_NO_MEM on memory exhaustion.
static envid_t
sys_exofork(void)
{
	// Create the new environment with env_alloc(), from kern/env.c.
	// It should be left as env_alloc created it, except that
	// status is set to ENV_NOT_RUNNABLE, and the register set is copied
	// from the current environment -- but tweaked so sys_exofork
	// will appear to return 0.

	// LAB 4: Your code here.
	struct Env* store = NULL;
	// val used to store the return value
	// Two kinds of error return value is passed directly from env_alloc
	int val;
	if((val = env_alloc(&store, curenv->env_id)) < 0)
		return val;
	store->env_status = ENV_NOT_RUNNABLE;
	store->env_tf = curenv->env_tf;
	// Child environment will return zero instead; change the eax register
	store->env_tf.tf_regs.reg_eax = 0;
	// curenv will return the envid of child environment
	return store->env_id;
}

// Set envid's env_status to status, which must be ENV_RUNNABLE
// or ENV_NOT_RUNNABLE.
//
// Returns 0 on success, < 0 on error.  Errors are:
//	-E_BAD_ENV if environment envid doesn't currently exist,
//		or the caller doesn't have permission to change envid.
//	-E_INVAL if status is not a valid status for an environment.
static int
sys_env_set_status(envid_t envid, int status)
{
	// Hint: Use the 'envid2env' function from kern/env.c to translate an
	// envid to a struct Env.
	// You should set envid2env's third argument to 1, which will
	// check whether the current environment has permission to set
	// envid's status.

	// LAB 4: Your code here.
	// First, check whether status argument is valid
	if(status != ENV_RUNNABLE && status != ENV_NOT_RUNNABLE)
		return -E_INVAL;
	struct Env* store = NULL;
	if(envid2env(envid, &store, 1) < 0)
		return -E_BAD_ENV;
	// All Preconditions met, now do the assignment part
	store->env_status = status;
	return 0;
}

// Allocate a page of memory and map it at 'va' with permission
// 'perm' in the address space of 'envid'.
// The page's contents are set to 0.
// If a page is already mapped at 'va', that page is unmapped as a
// side effect.
//
// perm -- PTE_U | PTE_P must be set, PTE_AVAIL | PTE_W may or may not be set,
//         but no other bits may be set.  See PTE_SYSCALL in inc/mmu.h.
//
// Return 0 on success, < 0 on error.  Errors are:
//	-E_BAD_ENV if environment envid doesn't currently exist,
//		or the caller doesn't have permission to change envid.
//	-E_INVAL if va >= UTOP, or va is not page-aligned.
//	-E_INVAL if perm is inappropriate (see above).
//	-E_NO_MEM if there's no memory to allocate the new page,
//		or to allocate any necessary page tables.
static int
sys_page_alloc(envid_t envid, void *va, int perm)
{
	// Hint: This function is a wrapper around page_alloc() and
	//   page_insert() from kern/pmap.c.
	//   Most of the new code you write should be to check the
	//   parameters for correctness.
	//   If page_insert() fails, remember to free the page you
	//   allocated!

	// LAB 4: Your code here.
	struct Env* store = NULL;
	struct PageInfo* page = NULL;
	// First, do the parameter check
	// check envid
	if(envid2env(envid, &store, 1) < 0)
		return -E_BAD_ENV;
	// check va
	if(((uintptr_t)va >= (uintptr_t)UTOP) || (ROUNDDOWN((uintptr_t)va, PGSIZE) != (uintptr_t)va))
		return -E_INVAL;
	// check perm, is PTE_U and PTE_P already set?
	if(((perm & PTE_U) == 0) || ((perm & PTE_P) == 0) )
		return -E_INVAL;
	// is perm set with other perms that should never be set?
	// bit-and ~PTE_SYSCALL clear the four bits
	if((perm & ~PTE_SYSCALL) != 0)
		return -E_INVAL;
	// Now start to do the real things, first alloc a physical page
	if((page = page_alloc(ALLOC_ZERO)) == NULL)
		return -E_NO_MEM;
	// map it at given va, with given perm
	page_insert(store->env_pgdir, page, va, perm);
	// If the control flow executes through here, then we are done
	return 0;
}

// Map the page of memory at 'srcva' in srcenvid's address space
// at 'dstva' in dstenvid's address space with permission 'perm'.
// Perm has the same restrictions as in sys_page_alloc, except
// that it also must not grant write access to a read-only
// page.
//
// Return 0 on success, < 0 on error.  Errors are:
//	-E_BAD_ENV if srcenvid and/or dstenvid doesn't currently exist,
//		or the caller doesn't have permission to change one of them.
//	-E_INVAL if srcva >= UTOP or srcva is not page-aligned,
//		or dstva >= UTOP or dstva is not page-aligned.
//	-E_INVAL is srcva is not mapped in srcenvid's address space.
//	-E_INVAL if perm is inappropriate (see sys_page_alloc).
//	-E_INVAL if (perm & PTE_W), but srcva is read-only in srcenvid's
//		address space.
//	-E_NO_MEM if there's no memory to allocate any necessary page tables.
static int
sys_page_map(envid_t srcenvid, void *srcva,
	     envid_t dstenvid, void *dstva, int perm)
{
	// Hint: This function is a wrapper around page_lookup() and
	//   page_insert() from kern/pmap.c.
	//   Again, most of the new code you write should be to check the
	//   parameters for correctness.
	//   Use the third argument to page_lookup() to
	//   check the current permissions on the page.

	// LAB 4: Your code here.
	struct Env* src = NULL;
	struct Env* dst = NULL;
	// First do the parameter check
	// check two envids
	if(envid2env(srcenvid, &src, 1) < 0 || envid2env(dstenvid, &dst, 1) < 0)
		return -E_BAD_ENV;
	// check two vas
	if((uintptr_t)srcva >= UTOP || ROUNDDOWN((uintptr_t)srcva, PGSIZE) != (uintptr_t)srcva)
		return -E_INVAL;
	if((uintptr_t)dstva >= UTOP || ROUNDDOWN((uintptr_t)dstva, PGSIZE) != (uintptr_t)dstva)
		return -E_INVAL;
	// check whether srcva is mapped in src
	pte_t* pte_addr = NULL;
	struct PageInfo* page = NULL;
	if((page = page_lookup(src->env_pgdir, srcva, &pte_addr)) == NULL)
		return -E_INVAL;
	// check whether perm is inappropriate
	if(((perm & PTE_U) == 0) || ((perm & PTE_P) == 0) || ((perm & ~PTE_SYSCALL) != 0))
		return -E_INVAL;
	// check whether srcva is read-only but perm cotains PTE_W
	if(!(*pte_addr & PTE_W) && (perm & PTE_W))
		return -E_INVAL;
	// Now, do the real things, since we have got the physical page
	// just use page_insert() to map it at given addr
	if(page_insert(dst->env_pgdir, page, dstva, perm) < 0)
		return -E_NO_MEM;
	// If we could execute through here, then we are done
	return 0;
}

// Unmap the page of memory at 'va' in the address space of 'envid'.
// If no page is mapped, the function silently succeeds.
//
// Return 0 on success, < 0 on error.  Errors are:
//	-E_BAD_ENV if environment envid doesn't currently exist,
//		or the caller doesn't have permission to change envid.
//	-E_INVAL if va >= UTOP, or va is not page-aligned.
static int
sys_page_unmap(envid_t envid, void *va)
{
	// Hint: This function is a wrapper around page_remove().

	// LAB 4: Your code here.
	// First check envid
	struct Env* store = NULL;
	if(envid2env(envid, &store, 1) < 0)
		return -E_BAD_ENV;
	// Then check va
	if((uintptr_t)va >= UTOP || ROUNDDOWN((uintptr_t)va, PGSIZE) != (uintptr_t)va)
		return -E_INVAL;
	// Then do the real stuff
	page_remove(store->env_pgdir, va);
	// If we could execute through here, then everything is done
	return 0;
}

static int
sys_env_set_pgfault_upcall(envid_t envid, void *func)
{
	// LAB 4: Your code here.
	struct Env* store = NULL;
	if(envid2env(envid, &store, 1) < 0)
		return -E_BAD_ENV;
	store->env_pgfault_upcall = func;
	return 0;
}

// LAB 4: Your code here.
// First check preconditions, shall we pass the control to user-level page
// fault handler? flag means whether a user-level page fault handler is needed
bool flag = true;
// check whether there exists a page fault upcall
if(curenv->env_pgfault_upcall == NULL)
	flag = false;
// ckeck whether exception stack fails
if((USTACKTOP <= fault_va) && (fault_va < UXSTACKTOP - PGSIZE))
	flag = false;
// Now start to do the real stuff
if(flag)
{
	struct UTrapframe* trapframe = NULL;
	// where do we put the struct UTrapFrame? It depends on whether the page
	// fault happens on user exception stack
	if((curenv->env_tf.tf_esp < UXSTACKTOP) && (curenv->env_tf.tf_esp >= UXSTACKTOP - PGSIZE))
		trapframe = (struct UTrapframe*)(curenv->env_tf.tf_esp - sizeof(struct UTrapframe) - 4);
	else
		trapframe = (struct UTrapframe*)(UXSTACKTOP - sizeof(struct UTrapframe));
	// check whether the env has a page mapped at exception stack, and has write 
	// permission to it. user_mem_assert will automacally destory the env and will
	// not return if the check fails.
	user_mem_assert(curenv, trapframe, sizeof(struct UTrapframe), PTE_W);
	// construct the user trap frame for user-level page fault handler
	trapframe->utf_eflags = curenv->env_tf.tf_eflags;
	trapframe->utf_eip = curenv->env_tf.tf_eip;
	trapframe->utf_err = curenv->env_tf.tf_err;
	trapframe->utf_esp = curenv->env_tf.tf_esp;
	trapframe->utf_fault_va = fault_va;
	trapframe->utf_regs = curenv->env_tf.tf_regs;
	// modify the curenv->env_tf to make it return to user-level page fault 
	// handler, and set the new esp
	curenv->env_tf.tf_eip = (uintptr_t)curenv->env_pgfault_upcall;
	curenv->env_tf.tf_esp = (uintptr_t)trapframe;
	// Finally, return to user space, run the user-level page fault handler
	// This function will never return
	env_run(curenv);
}
// Destroy the environment that caused the fault.
cprintf("[%08x] user fault va %08x ip %08x\n",
	curenv->env_id, fault_va, tf->tf_eip);
print_trapframe(tf);
env_destroy(curenv);

	// LAB 4: Your code here.
	// fault_va and errno is useless now, since we will use popal to 
	// registers, move the esp to point to correct stuff

	addl $8, %esp

	// we need to put the "eip" to the right place
	// if we use push command after switching the stack, then we need a 
	// general-purpose register to save this value, which is unacceptable
	// so we use mov command to do this, and do this before "popal" command
	// %eax stores the eip value, %ebx stores where to put it
	// Important: We need to modify the %esp in UTrapframe here, because we need
	// to return to the (%esp - 4) place

	movl 0x20(%esp), %eax
	movl 0x28(%esp), %ebx
	subl $4, %ebx
	movl %ebx, 0x28(%esp)
	movl %eax, (%ebx)

	// Restore the trap-time registers.  After you do this, you
	// can no longer modify any general-purpose registers.
	// LAB 4: Your code here.

	popal

	// Restore eflags from the stack.  After you do this, you can
	// no longer use arithmetic operations or anything else that
	// modifies eflags.
	// LAB 4: Your code here.
	// eip on this stack is useless now, ignore it

	addl $4, %esp
	popf

	// Switch back to the adjusted trap-time stack.
	// LAB 4: Your code here.

	movl (%esp), %esp

	// Return to re-execute the instruction that faulted.
	// LAB 4: Your code here.

	ret

void
set_pgfault_handler(void (*handler)(struct UTrapframe *utf))
{
	int r;

	if (_pgfault_handler == 0) {
		// First time through!
		// LAB 4: Your code here.
		sys_page_alloc(0, (void*)(UXSTACKTOP - PGSIZE), PTE_W | PTE_U | PTE_P);
		sys_env_set_pgfault_upcall(0, _pgfault_upcall);
	}

	// Save handler pointer for assembly to call.
	_pgfault_handler = handler;
}