lab4

这一个lab主要学习进程管理和进程通讯，come on,好好学习

PART A: 多处理器支持

Exercise 1:

void *
mmio_map_region(physaddr_t pa, size_t size)
{
	// Where to start the next region.  Initially, this is the
	// beginning of the MMIO region.  Because this is static, its
	// value will be preserved between calls to mmio_map_region
	// (just like nextfree in boot_alloc).
	static uintptr_t base = MMIOBASE;

	// Reserve size bytes of virtual memory starting at base and
	// map physical pages [pa,pa+size) to virtual addresses
	// [base,base+size).  Since this is device memory and not
	// regular DRAM, you'll have to tell the CPU that it isn't
	// safe to cache access to this memory.  Luckily, the page
	// tables provide bits for this purpose; simply create the
	// mapping with PTE_PCD|PTE_PWT (cache-disable and
	// write-through) in addition to PTE_W.  (If you're interested
	// in more details on this, see section 10.5 of IA32 volume
	// 3A.)
	//
	// Be sure to round size up to a multiple of PGSIZE and to
	// handle if this reservation would overflow MMIOLIM (it's
	// okay to simply panic if this happens).
	//
	// Hint: The staff solution uses boot_map_region.
	//
	// Your code here:
	uintptr_t nextBase=base+ROUNDUP(size,PGSIZE);
	uintptr_t i;
	if(nextBase>=MMIOLIM) panic(" mmio_map_region: mmio is out of limit\n");
	boot_map_region(kern_pgdir,base,ROUNDUP(size,PGSIZE),pa,PTE_PCD|PTE_PWT|PTE_W);
	i=base;
	base=nextBase;
	return (void *)i;
	//panic("mmio_map_region not implemented");
}

Exercise 2:

void
page_init(void)
{
	
	size_t i;
	uint32_t j=((uint32_t)boot_alloc(0)-KERNBASE)/PGSIZE;
	uint32_t j2=IOPHYSMEM/PGSIZE;
	uint32_t j3=MPENTRY_PADDR/PGSIZE;
	for (i = npages-1; i>=1; i--) {
		//the physical memory pages that has been used by pages and kernel 
		
		//cprintf("rrrrrrrrrrrrrrrrr");
		if(!((i>=j2&&i<j)||i==0||i==j3)){
			pages[i].pp_ref = 0;
			pages[i].pp_link = page_free_list;
			page_free_list = &pages[i];
		}
	}
}

Question 1:
MPBOOTPHYS(start32)是取得start32的物理地址
为什么ljmpl $(PROT_MODE_CSEG),$(MPBOOTPHYS(start32),中需要取得start32的物理地址？
在boot/boot.s中，0-4M线性地址空间被映射到0-4M物理内存，start的线性地址与实际的物理地址一样，使用相对地址跳转后，还是跳转到protcseg, 所以不需要求物理地址；
而在这里，mpentry.s从别的地方拷贝过来的，其中start32是相对于mpentry_start的地址，这个地址与启用用保护模式后start32所在的物理地址不同，所以跳转不到start32指令处。
记住ljmpl后，就是跳转到cs+EIP的地址去，这里的内容就是cs+EIP转化为物理地址后，这个物理内存的内容。
深入理解跳转的含义！！！
Exercise 3:

static void
mem_init_mp(void)
{

	// LAB 4: Your code here:
	uint32_t i,stacki_beginV,stacki_beginPh;
	for(i=0;i<NCPU;i++){
	 stacki_beginV=(uint32_t)(KSTACKTOP-i*(KSTKSIZE + KSTKGAP)-KSTKSIZE);
	 //stacki_beginPh=(uint32_t)(bootstacktop-i*(KSTKSIZE + KSTKGAP)-KSTKSIZE);
	 boot_map_region(kern_pgdir,stacki_beginV,KSTKSIZE,PADDR(percpu_kstacks[i]),PTE_W|PTE_P);
	}

}

Exercise 4:

void
trap_init_percpu(void)
{
// LAB 4: Your code here:

	// Setup a TSS so that we get the right stack
	// when we trap to the kernel.
	//ts.ts_esp0 = KSTACKTOP;
	//ts.ts_ss0 = GD_KD;
	uint8_t i=thiscpu->cpu_id;
	thiscpu->cpu_ts.ts_esp0=KSTACKTOP-i*(KSTKSIZE+KSTKGAP);
	thiscpu->cpu_ts.ts_ss0=GD_KD;
	// Initialize the TSS slot of the gdt.
	//gdt[GD_TSS0 >> 3] = SEG16(STS_T32A, (uint32_t) (&ts),
	//				sizeof(struct Taskstate), 0);
	//gdt[GD_TSS0 >> 3].sd_s = 0;
	gdt[(GD_TSS0>>3)+i]=SEG16(STS_T32A,(uint32_t)(&thiscpu->cpu_ts),sizeof(struct Taskstate),0);
	gdt[(GD_TSS0>>3)+i].sd_s = 0;
	

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

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

Exercise 5: 很简单
Question 2: 为什么呢？user->kernel,使用kernel栈？ 使用完后，下一次再进入kernel,栈中数据清空了!
                   考虑极端情况，如果某个cpu A在使用kernel, cpu B用户程序运行时产生中断，这时cpu B直接将数据保存到内核堆栈，而这时还没有申请big kernel lock呢！！！

Challenge 1:这个很难呀，很难! 

Exercise 6:这个花了我好长的时间，kernel总是崩掉，后来经过仔细调试，发现有两点影响这个问题：1. 以前lab所编写的函数env_setup_vm没有将这次试验中用到的MMIOBASE-MMIOLIM之间的内用拷贝到enviroment的页目录中去。2.就是trap_init_percpu中thiscpu->cpu_ts.ts_esp0的赋值，我一开始给出的是percpu_kstacks[i],不知为什么使用这个总是出现问题，必须使用KSTACKTOP-i*(KSTKSIZE+KSTKGAP), 可能有别的地方用到了这个地址了

static int
env_setup_vm(struct Env *e)
{
	int i;
	struct PageInfo *p = NULL;

	// Allocate a page for the page directory
	if (!(p = page_alloc(ALLOC_ZERO)))
		return -E_NO_MEM;

	// Now, set e->env_pgdir and initialize the page directory.
	//
	// Hint:
	//    - The VA space of all envs is identical above UTOP
	//	(except at UVPT, which we've set below).
	//	See inc/memlayout.h for permissions and layout.
	//	Can you use kern_pgdir as a template?  Hint: Yes.
	//	(Make sure you got the permissions right in Lab 2.)
	//    - The initial VA below UTOP is empty.
	//    - You do not need to make any more calls to page_alloc.
	//    - Note: In general, pp_ref is not maintained for
	//	physical pages mapped only above UTOP, but env_pgdir
	//	is an exception -- you need to increment env_pgdir's
	//	pp_ref for env_free to work correctly.
	//    - The functions in kern/pmap.h are handy.

	// LAB 3: Your code here.
	e->env_pgdir = (pde_t *)page2kva(p);
    memmove(e->env_pgdir, kern_pgdir, PGSIZE);
    memset(e->env_pgdir, 0, PDX(UTOP)*sizeof(pde_t));
    p->pp_ref ++;
	
	// 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;

	return 0;
}

void
sched_yield(void)
{
	struct Env *idle;

	// Implement simple round-robin scheduling.
	//
	// Search through 'envs' for an ENV_RUNNABLE environment in
	// circular fashion starting just after the env this CPU was
	// last running.  Switch to the first such environment found.
	//
	// If no envs are runnable, but the environment previously
	// running on this CPU is still ENV_RUNNING, it's okay to
	// choose that environment.
	//
	// Never choose an environment that's currently running on
	// another CPU (env_status == ENV_RUNNING). If there are
	// no runnable environments, simply drop through to the code
	// below to halt the cpu.

	// LAB 4: Your code here.
	
    int i;
	if(thiscpu->cpu_env != NULL) {
		int cur_env_id = thiscpu->cpu_env->env_id;
		cur_env_id = ENVX(cur_env_id);
		for(i = (cur_env_id+1)%NENV; i != cur_env_id; i = (i+1)%NENV) {
			if(envs[i].env_status == ENV_RUNNABLE)
				break;
		}
		if(i != cur_env_id)
		env_run(&envs[i]);
		if(thiscpu->cpu_env->env_status == ENV_RUNNING)
		env_run(thiscpu->cpu_env);
     }else{
        for(i = 0; i<NENV; i++){
			if(envs[i].env_status == ENV_RUNNABLE)
				break;
		}
		if(i!=NENV) env_run(&envs[i]);
     }
	// sched_halt never returns
	sched_halt();
}

Question 3: 所有envrioment中的kernel线性地址部分都一样，和没有进入environment前的kernel一样. 所以按理说exericse6中使用percpu_kstacks[i]也正确，但是不知为什么总是报中断问题!!
Question 4: 使用sys_yield()，从用户模式进入kernel模式，trap.c中就保存在envs中了
Challenge 2: 添加一个系统调用，设置priority, 这样可以设置每个env的优先级
Challenge 3: env添加一些保存的项目
Exercise 7:

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 *newenv_store=NULL;
	int r=env_alloc(&newenv_store,curenv->env_id);
	if(r<0) {cprintf("env_alloc error: %e", r);return r;}
	newenv_store->env_tf=curenv->env_tf;
	//memmove((void *)&(newenv_store->env_tf),(const void *)&(curenv->env_tf), sizeof(struct Trapframe));
	newenv_store->env_status=ENV_NOT_RUNNABLE;
	newenv_store->env_tf.tf_regs.reg_eax=0;
	return newenv_store->env_id;
	//panic("sys_exofork not implemented");
}

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.
	struct Env *newenv_store=NULL;
	int i=envid2env(envid,&newenv_store,1);
	if(i<0) return -E_BAD_ENV;
	if((status==ENV_RUNNABLE)||(status==ENV_NOT_RUNNABLE)){
		newenv_store->env_status=status;
		return 0;
	}else{
	     cprintf("xxxxxxxxxxx   status %d\n",status);
	     return -E_INVAL;
	}

	
	//panic("sys_env_set_status not implemented");
}

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.
	if(((uint32_t)va>=UTOP)||((uint32_t)va%PGSIZE!=0))return -E_INVAL;
	if(!((perm&PTE_U)&&(perm&PTE_P)))return -E_INVAL;
	if(perm&(~PTE_SYSCALL))return -E_INVAL;
	struct Env *newenv_store=NULL;
	int i=envid2env(envid,&newenv_store,1);
	if(i<0) return -E_BAD_ENV;
	struct PageInfo *pageinfo=page_alloc(ALLOC_ZERO);
	if(pageinfo==NULL) return -E_NO_MEM;
	
	i=page_insert(newenv_store->env_pgdir,pageinfo,va,perm);
	if(i<0) {
		page_free(pageinfo);
		return -E_NO_MEM;
	}
	return 0;
	//panic("sys_page_alloc not implemented");
}

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.
	if(((uint32_t)srcva>=UTOP)||((uint32_t)srcva%PGSIZE!=0))return -E_INVAL;
	if(((uint32_t)dstva>=UTOP)||((uint32_t)dstva%PGSIZE!=0))return -E_INVAL;
	if(!((perm&PTE_U)&&(perm&PTE_P)))return -E_INVAL;
	if(perm&(~PTE_SYSCALL))return -E_INVAL;
	struct Env *newenv_store=NULL;
	int i=envid2env(srcenvid,&newenv_store,1);
	if(i<0) return -E_BAD_ENV;
	pte_t *ptet=NULL;
	struct PageInfo *pageinfo=page_lookup(newenv_store->env_pgdir,srcva,&ptet);
	if(pageinfo==NULL)return -E_INVAL;
	if(perm&PTE_W){
		if(!(*ptet&PTE_W))return -E_INVAL;
	}
	i=envid2env(dstenvid,&newenv_store,1);
	if(i<0) return -E_BAD_ENV;
	i=page_insert(newenv_store->env_pgdir,pageinfo,dstva,perm);
	if(i<0)return -E_NO_MEM;
	return 0;
	//panic("sys_page_map not implemented");
}

static int
sys_page_unmap(envid_t envid, void *va)
{
	// Hint: This function is a wrapper around page_remove().

	// LAB 4: Your code here.
	if(((uint32_t)va>=UTOP)||((uint32_t)va%PGSIZE!=0))return -E_INVAL;
	struct Env *newenv_store=NULL;
	int i=envid2env(envid,&newenv_store,1);
	if(i<0) return -E_BAD_ENV;
	pte_t *ptet=NULL;
	struct PageInfo *pageinfo=page_lookup(newenv_store->env_pgdir,va,&ptet);
	if(pageinfo==NULL)return 0;
	page_remove(newenv_store->env_pgdir,va);
	return 0;
	//panic("sys_page_unmap not implemented");
}

int32_t syscall中添加:
case SYS_exofork:
			r=sys_exofork();
			break;
		case SYS_page_alloc:
			r=sys_page_alloc((envid_t)a1,(void *) a2,(int)a3);
			break;
		case SYS_page_map:
			r=sys_page_map((envid_t)a1,(void*)a2,(envid_t)a3,(void*)a4,(int)a5);
			break;
		case SYS_page_unmap:
			r=sys_page_unmap((envid_t)a1,(void*)a2);
			break;
		case SYS_env_set_status:
			r=sys_env_set_status((envid_t)a1,(int)a2);
			break;

注意：sys_page_umap中我一开始未使用page_remove，而使用*ptet=0,哈哈，这样不行呀，导致系统崩溃!!!
Challenge 4: 这个和进程干冻差不多，哈哈，未做！

PART B: Copy-on-write fork

Exercise 9:
Exercise 10:
Exercise 11:
Challenge 4:怎么要处理user environment所有的异常呢？现代OS中都是这么搞的？为什么是用户程序来处理这些呢？？
Exercise 12: 这几个exercises没认真做，看明白了ruizhe huang的代码, pfentry.s的代码注意，如何实现user unexception-> user normal模式和user->unexception？ 将eip保存到空白中，esp指到这个空白处，然后pop %esp,然后ret(pop %eip),这样就跳转过去了,真的很tricky,很tricky
Challenge 5,6:未做 

PART C: Preemptive Multitasking and IPC

Exersice 13:很简单, 使用SEGGATE时，设置为中断门，而不是异常门。

Exersice 14:时钟中断为IRQ0，对应处理函数为routine_irq0

trap_dispatch中添加：

case (IRQ_OFFSET+IRQ_TIMER):
			lapic_eoi();
			sched_yield();
			return;

Exercise 15: 具体实现IPC,就是实现两个系统调用，send和recv,来实现进程通信。具体没做，看huangrui zhe的实验报告跑了跑
最后几个Challenge也未做
2013.7.29-2012.8.4