OSDev.org

Code: Select all

// implement fork from user space

#include <inc/string.h>
#include <inc/lib.h>

// PTE_COW marks copy-on-write page table entries.
// It is one of the bits explicitly allocated to user processes (PTE_AVAIL).
#define PTE_COW		0x800
extern void _pgfault_upcall(void);

//
// Custom page fault handler - if faulting page is copy-on-write,
// map in our own private writable copy.
//
static void
pgfault(struct UTrapframe *utf)
{
	cprintf("pgfault\n");
	void *addr = (void *) utf->utf_fault_va;
	uint32_t err = utf->utf_err;
	int r;
	uint32_t pn;
	envid_t envid = sys_getenvid();

	// Check that the faulting access was (1) a write, and (2) to a
	// copy-on-write page.  If not, panic.
	// Hint:
	//   Use the read-only page table mappings at vpt
	//   (see <inc/memlayout.h>).

	// LAB 4: Your code here.
	if(!(err & FEC_WR))
		panic("not a write operation");
	pn = VPN(addr);
	if(!(vpt[pn] & PTE_COW))
		panic("not copy-on-write page");

	// Allocate a new page, map it at a temporary location (PFTEMP),
	// copy the data from the old page to the new page, then move the new
	// page to the old page's address.
	// Hint:
	//   You should make three system calls.
	//   No need to explicitly delete the old page's mapping.
	
	// LAB 4: Your code here.
	if((r = sys_page_alloc(envid,PFTEMP,PTE_W|PTE_U|PTE_P)) < 0)
		panic("pgfault page alloc%e",r);
	memmove((void*)PFTEMP, (void*)ROUNDDOWN(addr,PGSIZE),PGSIZE);
	if((r = sys_page_map(envid,(void*)PFTEMP,envid,(void*)ROUNDDOWN(addr,PGSIZE),PTE_P|PTE_U|PTE_W)) < 0)
		panic("map failed:%e",r);
	if((r = sys_page_unmap(envid,(void*)PFTEMP)) < 0)
		panic("unmap failed:%e",r);	
	
	//panic("pgfault not implemented");
}

//
// Map our virtual page pn (address pn*PGSIZE) into the target envid
// at the same virtual address.  If the page is writable or copy-on-write,
// the new mapping must be created copy-on-write, and then our mapping must be
// marked copy-on-write as well.  (Exercise: Why mark ours copy-on-write again
// if it was already copy-on-write?)
//
// Returns: 0 on success, < 0 on error.
// It is also OK to panic on error.
// 
static int
duppage(envid_t envid, unsigned pn)
{
	int r;
	void *addr;
	pte_t pte;
	uint32_t perm = 0;
	addr = (void*)(pn*PGSIZE);
	struct Env *env;
	//envid2env(sys_getenvid(),&env,1);
	// LAB 4: Your code here.
	if((vpt[pn] & PTE_W) || (vpt[pn] & PTE_COW))
	{
		perm = PTE_U|PTE_P|PTE_COW;
		if((r = sys_page_map(0,addr,envid,addr,perm)) < 0)
			return r;
		if((r = sys_page_map(0,addr,0,addr,perm)) < 0)
			return r;
		//tlb_invalidate(env->env_pgdir,addr);
	}
	else
	{
		if((r = sys_page_map(sys_getenvid(),addr,envid,addr,PGOFF(vpt[pn]))) < 0)
			return r;
	}	
	//panic("duppage not implemented");
	return 0;
}

//
// User-level fork with copy-on-write.
// Set up our page fault handler appropriately.
// Create a child.
// Copy our address space and page fault handler setup to the child.
// Then mark the child as runnable and return.
//
// Returns: child's envid to the parent, 0 to the child, < 0 on error.
// It is also OK to panic on error.
//
// Hint:
//   Use vpd, vpt, and duppage.
//   Remember to fix "env" and the user exception stack in the child process.
//   Neither user exception stack should ever be marked copy-on-write,
//   so you must allocate a new page for the child's user exception stack.
//
envid_t
fork(void)
{
	// LAB 4: Your code here.
	envid_t envid,curenvid;
	uint8_t * addr;
	uint32_t pdeno,pteno;
	int r;
	uint32_t pn = 0;
	extern unsigned char end[];	
	set_pgfault_handler(pgfault);
	envid = sys_exofork();
	//cprintf("envid:%08x,end:%08x,UTOP:%08x\n",envid,end,UTOP);
	if (envid < 0)
		panic("sys_exofork: %e", envid);
	if (envid == 0) {
		// We're the child.
		// The copied value of the global variable 'env'
		// is no longer valid (it refers to the parent!).
		// Fix it and return 0.
		cprintf("child\n");		
		env = &envs[ENVX(sys_getenvid())];
		return 0;
	}
	//cprintf("max pdeno:%08x,end :%08x\n",PDX(UTOP));
	for(pdeno = PDX(UTEXT);pdeno < PDX(UTOP);pdeno++)
	{
		if(!(vpd[pdeno] & (PTE_P)))
			continue;
		else
		{
			for(pteno = 0;pteno < NPTENTRIES;pteno++)
			{
				pn = (pdeno<<10) + pteno;
				//cprintf("pn:%08x\n",pn);				
				if(pn <= VPN(UXSTACKTOP - PGSIZE))
				{
					if(vpt[pn] & (PTE_P))
					{
						//cprintf("duppage,envid:%08x\n",envid);
						duppage(envid,pn);
					}
				}
				else
					break;
			}
		}
	}
    
	cprintf("map the page finished\n");
	
	if((r = sys_page_alloc(envid, (void*)(UXSTACKTOP - PGSIZE), PTE_U|PTE_P|PTE_W)) < 0)
			return r;
	cprintf("alloc the page for %08x uxstack finished\n",envid);

	
	//sys_env_set_pgfault_upcall(envid,_pgfault_upcall);
	//cprintf("set page fault upcall finished\n");
	if ((r = sys_env_set_status(envid, ENV_RUNNABLE)) < 0)
		panic("sys_env_set_status: %e", r);
	cprintf("%08x set status runnable finished\n",envid);
	return envid;

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

Code: Select all

Alloc page directory
Alloc pages array
Alloc envs array
trap_syscall: 306a006a
&trap_syscall: f0102c00
enabled interrupts: 1 2 4
             Setup timer interrupts via 8259A
enabled interrupts: 0 1 2 4
             unmasked timer interrupt
generate env_id:00001000
[00000000] new env 00001000
env create 00001000
generate env_id:00001001
[00000000] new env 00001001
env create 00001001
00000000 is runnable
00000001 is runnable
1001: I am ''
set page fault handler:00001001
page insert,env_id:00001001,env_pgdir:f1fb2000,page:f01cebbc,va:eebff000
generate env_id:00001002
[00001001] new env 00001002
map the page finished
00001002 set status runnable finished
generate env_id:00001003
[00001001] new env 00001003
pgfault
page insert,env_id:00001001,env_pgdir:f1fb2000,page:f01ceb80,va:007ff000
map the page finished
00001003 set status runnable finished
[00001001] exiting gracefully
[00001001] free env 00001001
00000000 is runnable
00000002 is runnable
00000003 is runnable
kernel panic at kern/trap.c:276: kernel page fault:eebffffc

Code: Select all

envid_t
fork(void)
{
	// LAB 4: Your code here.
	envid_t envid;
	uint8_t *addr;
	int r;
	extern unsigned char end[];

	// Allocate a new child environment.
	// The kernel will initialize it with a copy of our register state,
	// so that the child will appear to have called sys_exofork() too -
	// except that in the child, this "fake" call to sys_exofork()
	// will return 0 instead of the envid of the child.
	envid = sys_exofork();
	cprintf("fork envid:%08x\n",envid);
	if (envid < 0)
		panic("sys_exofork: %e", envid);
	if (envid == 0) {
		// We're the child.
		// The copied value of the global variable 'env'
		// is no longer valid (it refers to the parent!).
		// Fix it and return 0.
		//cprintf("I am the child\n");
		env = &envs[ENVX(sys_getenvid())];
		return 0;
	}

	// We're the parent.
	// Eagerly copy our entire address space into the child.
	// This is NOT what you should do in your fork implementation.
	cprintf("end:%08x,UTEXT:%08x,UTOP:%08x\n",end,UTEXT,UTOP);
	for (addr = (uint8_t*) UTEXT; addr < end; addr += PGSIZE)
		duppage(envid, addr);

	// Also copy the stack we are currently running on.
	duppage(envid, ROUNDDOWN(&addr, PGSIZE));

	// Start the child environment running
	cprintf("set %08x runnable\n",envid);
	if ((r = sys_env_set_status(envid, ENV_RUNNABLE)) < 0)
		panic("sys_env_set_status: %e", r);

	return envid;

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