自学教程：C++ sys_env_set_pgfault_upcall函数代码示例

//// 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 uvpd, uvpt, and duppage.//   Remember to fix "thisenv" 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_tfork(void){	// LAB 4: Your code here.	set_pgfault_handler(pgfault);	envid_t childid = sys_exofork();	if(childid < 0)		panic("Fork Failed/n");	if(childid == 0) {		thisenv = &envs[ENVX(sys_getenvid())];		return 0;	}	int i, j;	for(i = 0; i < PDX(UTOP); i++) {		if (!(uvpd[i] & PTE_P)) continue;		for(j = 0; (j < 1024) && (i*NPDENTRIES + j < PGNUM(UXSTACKTOP - PGSIZE)); j++ ) {			if(!uvpt[i*NPDENTRIES + j] & PTE_P) continue;			if(duppage(childid, i*NPDENTRIES + j) < 0)				panic("dup page failed");		}	}	if ((sys_page_alloc(childid, (void *)(UXSTACKTOP - PGSIZE), PTE_U | PTE_P | PTE_W)) < 0) {          panic("Allocation of page for Exception stack cups!/n");        }        if ((sys_env_set_pgfault_upcall(childid, thisenv->env_pgfault_upcall)) < 0) {          panic("Unable to set child process' upcall");        }	 // Copy own uxstack to temp page        memmove((void *)(UXSTACKTOP - PGSIZE), PFTEMP, PGSIZE);	int r;        // Unmap temp page        if (sys_page_unmap(sys_getenvid(), PFTEMP) < 0) {                return -1;        }                if ((r = sys_env_set_pgfault_upcall(childid, thisenv->env_pgfault_upcall)) < 0)                panic("sys_env_set_pgfault_upcall: error %e/n", r);        if ((r = sys_env_set_status(childid, ENV_RUNNABLE)) < 0) {                cprintf("sys_env_set_status: error %e/n", r);                return -1;        }	return childid;	panic("fork not implemented");}

//// 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 uvpd, uvpt, and duppage.//   Remember to fix "thisenv" 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_tfork(void){	// LAB 4: Your code here.	set_pgfault_handler (pgfault);	envid_t envid;	uint32_t addr;	int r;	envid = sys_exofork();	if (envid < 0)		panic("sys_exofork: %e", envid);	// We’re the child	if (envid == 0) {		env = &envs[ENVX(sys_getenvid())];		return 0;	}	// We’re the parent.	for (addr = UTEXT; addr < UXSTACKTOP - PGSIZE; addr += PGSIZE) {	if ((vpd[VPD(addr)] & PTE_P) > 0 && (vpt[VPN(addr)] & PTE_P) > 0 && (vpt[		VPN(addr)] & PTE_U) > 0)		duppage (envid, VPN(addr));	}	if ((r = sys_page_alloc (envid, (void *)(UXSTACKTOP - PGSIZE), PTE_U|PTE_W|PTE_P)) < 0)		panic ("fork: page allocation failed : %e", r);	extern void _pgfault_upcall (void);	sys_env_set_pgfault_upcall (envid, _pgfault_upcall);	// Start the child environment running	if ((r = sys_env_set_status(envid, ENV_RUNNABLE)) < 0)		panic("fork: set child env status failed : %e", r);	return envid;	//panic("fork not implemented");}

//// 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 uvpd, uvpt, and duppage.//   Remember to fix "thisenv" 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_tfork(void){  extern void _pgfault_upcall();  // LAB 4: Your code here.  set_pgfault_handler(pgfault);  envid_t envid = sys_exofork();  if (envid == 0) {    thisenv = &envs[ENVX(sys_getenvid())];    return 0;  }  if (envid < 0) {    panic("sys_exofork failed: %e", envid);  }  uint32_t addr;  for (addr = 0; addr < USTACKTOP; addr += PGSIZE) {    if ((uvpd[PDX(addr)] & PTE_P) && (uvpt[PGNUM(addr)] & PTE_P) && (uvpt[PGNUM(addr)] & PTE_U)) {      duppage(envid, PGNUM(addr));    }  }  int alloc_err = sys_page_alloc(envid, (void *)(UXSTACKTOP-PGSIZE), PTE_U|PTE_W|PTE_P);  if (alloc_err) {    panic("sys_page_alloc failed with error: %e", alloc_err);  }  sys_env_set_pgfault_upcall(envid, _pgfault_upcall);  int set_status_err = sys_env_set_status(envid, ENV_RUNNABLE);  if (set_status_err) {    panic("sys_env_set_status");  }  return envid;}

//// Set the page fault handler function.// If there isn't one yet, _pgfault_handler will be 0.// The first time we register a handler, we need to// allocate an exception stack (one page of memory with its top// at UXSTACKTOP), and tell the kernel to call the assembly-language// _pgfault_upcall routine when a page fault occurs.//voidset_pgfault_handler(void (*handler)(struct UTrapframe *utf)){	int r;    int re;    envid_t envid = sys_getenvid();	if (_pgfault_handler == 0) {		// First time through!		// LAB 4: Your code here.		sys_env_set_pgfault_upcall(envid, _pgfault_upcall);		re = sys_page_alloc(envid, (void *)(UXSTACKTOP - PGSIZE),PTE_U | PTE_P |PTE_W);        if( re < 0){            cprintf("process %x,sys_page_alloc fail/n",envid);            sys_env_destroy(envid);        }		//panic("set_pgfault_handler not implemented");	}	// Save handler pointer for assembly to call.	_pgfault_handler = handler;	//cprintf("_pgfault_handler = %x/n",(uint32_t)_pgfault_handler);}

voidumain(int, char **){	sys_page_alloc(0, (void*) (UXSTACKTOP - PGSIZE), PTE_P|PTE_U|PTE_W);	sys_env_set_pgfault_upcall(0, (void*) 0xDeadBeef);	*(int*)0 = 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 "thisenv" 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_tfork(void){	// LAB 4: Your code here.	//panic("fork not implemented");	extern void _pgfault_upcall(void);	set_pgfault_handler(pgfault);	envid_t id = sys_exofork();	int r;	if (id < 0)		panic("exofork: child");	if (id == 0)	{		thisenv = envs + ENVX(sys_getenvid());		return 0;	}//	cprintf("fork id: %x",id);	if ((r=sys_page_alloc(id, (void*)(UXSTACKTOP-PGSIZE), PTE_U | PTE_W | PTE_P))<0)		return r;	int i;	for (i=0;i<UTOP-PGSIZE;i+=PGSIZE)		if ((vpd[PDX(i)] & PTE_P) && (vpt[PGNUM(i)] & PTE_P))		{//			cprintf("i:%x ",i);			if ((r=duppage(id,PGNUM(i)))<0)				return r;		}	if ((r=sys_env_set_pgfault_upcall(id,(void*)_pgfault_upcall))<0)		return r;	if ((r=sys_env_set_status(id, ENV_RUNNABLE))<0)		return r;	return id;}

//// 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 "thisenv" 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_tfork(void){    // LAB 4: Your code here.    envid_t envid;        uint64_t addr;        uint32_t err;        extern unsigned char end[];        int r;        set_pgfault_handler(pgfault);        envid = sys_exofork();        if (envid < 0)                panic("sys_exofork: %e", envid);        if (envid == 0) {                // We're the child.                // The copied value of the global variable 'thisenv'                // is no longer valid (it refers to the parent!).                // Fix it and return 0.                thisenv = &envs[ENVX(sys_getenvid())];                return 0;        }        //Allocate exception stack for the child        if ((err = sys_page_alloc(envid, (void *) (UXSTACKTOP - PGSIZE), PTE_P|PTE_U|PTE_W)) < 0)                panic("Error in sys_page_alloc: %e", err);        // We're the parent.        // Map our entire address space into the child.        for (addr = UTEXT; addr < USTACKTOP-PGSIZE; addr += PGSIZE) {               if((vpml4e[VPML4E(addr)] & PTE_P) && (vpde[VPDPE(addr)] & PTE_P)                        && (vpd[VPD(addr)] & PTE_P) && (vpt[VPN(addr)] & PTE_P)) {                       duppage(envid, VPN(addr));                }        }        //Allocate a new stack for the child and copy the contents of parent on to it.        addr = USTACKTOP-PGSIZE;	if ((r = sys_page_alloc(0, (void *)PFTEMP, PTE_P|PTE_U|PTE_W)) < 0)                panic("sys_page_alloc failed: %e/n", r);        memcpy(PFTEMP, (void *) ROUNDDOWN(addr, PGSIZE), PGSIZE);        void *vaTemp = (void *) ROUNDDOWN(addr, PGSIZE);        if ((r = sys_page_map(0, (void *)PFTEMP, envid, vaTemp, PTE_P|PTE_U|PTE_W)) < 0)                panic("sys_page_map failed: %e/n", r);        if ((r = sys_page_unmap(0, (void *)PFTEMP)) < 0)                panic("sys_page_unmap failed: %e/n", r);        //Set child's page fault handler        if ((err = sys_env_set_pgfault_upcall(envid, _pgfault_upcall) < 0))                panic("Error in sys_env_set_pgfault_upcall: %e",err);        //Set the child ready to run        if ((err = sys_env_set_status(envid, ENV_RUNNABLE)) < 0)                panic("sys_env_set_status: %e", err);        return envid;    panic("fork not implemented");}

//// Set the page fault handler function.// If there isn't one yet, _pgfault_handler will be 0.// The first time we register a handler, we need to// allocate an exception stack (one page of memory with its top// at UXSTACKTOP), and tell the kernel to call the assembly-language// _pgfault_upcall routine when a page fault occurs.//voidset_pgfault_handler(void (*handler)(struct UTrapframe *utf)){	int r;	if (_pgfault_handler == 0) {		// First time through!		// code for lab 4 -M.G        //	panic("set_pgfault_handler not implemented");        envid_t cur_envid = sys_getenvid();        uintptr_t ux_stack_top = UXSTACKTOP - PGSIZE;                if (sys_page_alloc(cur_envid, (void *)ux_stack_top, PTE_P | PTE_U | PTE_W) < 0)        {                    panic("ERROR: Cannot allocate memory for exception stack!!");        }                if (sys_env_set_pgfault_upcall(cur_envid, _pgfault_upcall) < 0)        {            panic("ERROR: Cannot set pagefault handler!!");        }	}	// Save handler pointer for assembly to call.	_pgfault_handler = handler;}

//// Set the page fault handler function.// If there isn't one yet, _pgfault_handler will be 0.// The first time we register a handler, we need to// allocate an exception stack (one page of memory with its top// at UXSTACKTOP), and tell the kernel to call the assembly-language// _pgfault_upcall routine when a page fault occurs.//voidset_pgfault_handler(void (*handler)(struct UTrapframe *utf)){	int r;	if (_pgfault_handler == 0) {		// First time through!		// LAB 4: Your code here.		void *offset=(void *)(UXSTACKTOP-PGSIZE);//		envid_t envid=sys_getenvid();//		cprintf("set_pgfault_handler/n");		r=sys_page_alloc(0,(void *)(UXSTACKTOP-PGSIZE),PTE_P|PTE_U|PTE_W);//		cprintf("page alloc successfull/n");		if(r<0)		{			panic("not enough memory to allocate page");		}//		cprintf("setting page upcall/n");		sys_env_set_pgfault_upcall(0,_pgfault_upcall);		//panic("set_pgfault_handler not implemented");	}	// Save handler pointer for assembly to call.	_pgfault_handler = handler;}

//// 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 uvpd, uvpt, and duppage.//   Remember to fix "thisenv" 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_tfork(void){	// LAB 4: Your code here.    set_pgfault_handler(pgfault);    int r, childid;    childid = sys_exofork();    if (childid <0)            panic("exofork error in fork()!/n");    else if (childid ==0)    {            thisenv = &envs[ENVX(sys_getenvid())];            return 0;    } else    {        int addr;        for (addr = UTEXT; addr<UXSTACKTOP-PGSIZE; addr+=PGSIZE)        {                int pn = PGNUM(addr);                if (((uvpd[PDX(addr)] & PTE_P) >0) &&                    ((uvpt[pn] & PTE_P) >0) &&                    ((uvpt[pn] & PTE_U) > 0))                        duppage(childid, pn);        }        extern void _pgfault_upcall();        sys_page_alloc(childid, (void*) (UXSTACKTOP - PGSIZE),  PTE_U|PTE_W|PTE_P);        sys_env_set_pgfault_upcall(childid, _pgfault_upcall);        sys_env_set_status(childid, ENV_RUNNABLE);        return childid;    }}

//// Set the page fault handler function.// If there isn't one yet, _pgfault_handler will be 0.// The first time we register a handler, we need to// allocate an exception stack (one page of memory with its top// at UXSTACKTOP), and tell the kernel to call the assembly-language// _pgfault_upcall routine when a page fault occurs.//voidset_pgfault_handler(void (*handler)(struct UTrapframe *utf)){	int r;	if (_pgfault_handler == 0) {		// First time through!			// LAB 4: Your code here.		//int sys_page_alloc(envid_t envid, void *va, int perm)		r = sys_page_alloc(0, (void*)(UXSTACKTOP - PGSIZE), PTE_U | PTE_W | PTE_P);		if (r < 0) {			panic("sys_page_alloc error : %e/n", r);		}		// how to know envid, put 0, envid2env will help us to get curenv in syscall		r = sys_env_set_pgfault_upcall(0, _pgfault_upcall);				if (r < 0) {			panic("sys_env_set_pgfault_upcall error : %e/n", r);		}	}	// Save handler pointer for assembly to call.	_pgfault_handler = handler;}

//// Set the page fault handler function.// If there isn't one yet, _pgfault_handler will be 0.// The first time we register a handler, we need to // allocate an exception stack (one page of memory with its top// at UXSTACKTOP), and tell the kernel to call the assembly-language// _pgfault_upcall routine when a page fault occurs.//voidset_pgfault_handler(void (*handler)(struct UTrapframe *utf)){	int r;     //cprintf("Env %x called setpgflt handler cur value of pgflt handler %x/n",sys_getenvid(),_pgfault_handler);    if (_pgfault_handler == 0)     {         // First time through!         // LAB 4: Your code here.         //First allocate a page to map to UXSTACKTOP        if ((r = sys_page_alloc(0, (void*)(UXSTACKTOP - PGSIZE), PTE_P|PTE_U|PTE_W)) < 0)            panic("sys_page_alloc: %e", r);         //cprintf("Registering the handler %x/n",handler);        //Register the handler with kernel        sys_env_set_pgfault_upcall(0,_pgfault_upcall);    }   // Save handler pointer for assembly to call.    _pgfault_handler = handler;}

//// Set the page fault handler function.// If there isn't one yet, _pgfault_handler will be 0.// The first time we register a handler, we need to// allocate an exception stack (one page of memory with its top// at UXSTACKTOP), and tell the kernel to call the assembly-language// _pgfault_upcall routine when a page fault occurs.//voidset_pgfault_handler(void (*handler)(struct UTrapframe *utf)){	int r;	if (_pgfault_handler == 0) {		r = sys_page_alloc(sys_getenvid(), (void*)(UXSTACKTOP - PGSIZE), PTE_W | PTE_U | PTE_P);		if(r)		{			panic("pgfault.c:40: Error %e when allocating User Exception Stack/n", r);		} 		}	// Save handler pointer for assembly to call.	_pgfault_handler = handler;	/*	* We register with the kernel the assembly routine to return to execution.	*/	r = sys_env_set_pgfault_upcall(sys_getenvid(), _pgfault_upcall);		if(r)	{		panic("pgfault.c:55: Error %e when setting the pgfault upcall/n", r);	} 	}

//// 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 uvpd, uvpt, and duppage.//   Remember to fix "thisenv" 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_tfork(void){    // LAB 4: Your code here.    //panic("fork not implemented");    void *addr;    set_pgfault_handler(pgfault);    envid_t forkid = sys_exofork();    if (forkid < 0)        panic("sys_exofork: %e", forkid);    if(forkid == 0) {        thisenv = &envs[ENVX(sys_getenvid())];        return 0;    }    for (addr = (uint8_t*) UTEXT; addr < (void *) USTACKTOP; addr += PGSIZE)        if( (uvpd[PDX(addr)] & PTE_P) && (uvpt[PGNUM(addr)] & PTE_P) )            duppage(forkid, PGNUM(addr));    if (sys_page_alloc(forkid, (void *)(UXSTACKTOP-PGSIZE), PTE_U|PTE_W|PTE_P) < 0)        panic("user stack alloc failure/n");    extern void _pgfault_upcall();    if(sys_env_set_pgfault_upcall(forkid, _pgfault_upcall) < 0)        panic("set pgfault upcall fails %d/n", forkid);    if(sys_env_set_status(forkid, ENV_RUNNABLE) < 0)        panic("set %d runnable fails/n", forkid);    return forkid;}

//// Set the page fault handler function.// If there isn't one yet, _pgfault_handler will be 0.// The first time we register a handler, we need to// allocate an exception stack (one page of memory with its top// at UXSTACKTOP), and tell the kernel to call the assembly-language// _pgfault_upcall routine when a page fault occurs.//voidset_pgfault_handler(void (*handler)(struct UTrapframe *utf)){	int r;	//cprintf("inside page fault handler, _pgfault_handler = %0x/n", _pgfault_handler);	if (_pgfault_handler == 0) {		// First time through!		// LAB 4: Your code here.		envid_t envid = sys_getenvid();		r = sys_page_alloc(envid, (void*) (UXSTACKTOP - PGSIZE), PTE_P|PTE_U|PTE_W);		r = sys_page_alloc(envid, (void*) (UXSTACKTOP - 2*PGSIZE), PTE_P|PTE_U|PTE_W);		if(r < 0)			panic("page_alloc: %e", r);		//cprintf("setting the upcall/n");		r = sys_env_set_pgfault_upcall(envid, _pgfault_upcall);		//cprintf("set the upcall with result = %d/n", r);		if(r < 0)			panic("pgfault_upcall: %e", r);		//panic("set_pgfault_handler not implemented");	}	// Save handler pointer for assembly to call.	_pgfault_handler = handler;}

// Dispatches to the correct kernel function, passing the arguments.int64_tsyscall(uint64_t syscallno, uint64_t a1, uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5){	// Call the function corresponding to the 'syscallno' parameter.	// Return any appropriate return value.	// LAB 3: Your code here.//	panic("syscall not implemented");	switch (syscallno) {	case SYS_cputs:			sys_cputs((const 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(a1);	case SYS_yield:			sys_yield();			return 0;				case SYS_page_alloc:        		return sys_page_alloc((envid_t)a1, (void *)a2,(int)a3);	case SYS_page_map:			return sys_page_map((envid_t)a1, (void *)a2, (envid_t)a3, (void *)a4, (int)a5);        	case SYS_page_unmap:			return sys_page_unmap((envid_t)a1, (void *)a2);        	case SYS_exofork:			return sys_exofork();        	case SYS_env_set_status:			return sys_env_set_status((envid_t)a1, a2);		case SYS_env_set_pgfault_upcall:			return sys_env_set_pgfault_upcall((envid_t)a1,(void *)a2);			case SYS_ipc_try_send:			return sys_ipc_try_send((envid_t)a1, (uint32_t)a2, (void *)a3, a4);	case SYS_ipc_recv:			return sys_ipc_recv((void *)a1);		case SYS_env_set_trapframe:			return sys_env_set_trapframe((envid_t)a1, (struct Trapframe *)a2);	case SYS_time_msec:			return sys_time_msec();	case SYS_packet_transmit:			return sys_packet_transmit((char*)a1,(size_t)a2);	case SYS_packet_receive:                        return sys_packet_receive((char *)a1);	//lab 7 code from here	case SYS_insmod:			return sys_insmod((char *)a1, (char *)a2,(char *)a3);	case SYS_rmmod:			return sys_rmmod((char *)a1);	case SYS_lsmod:			return sys_lsmod();	case SYS_depmod:			return sys_depmod((char *)a1);	//lab7 code ends here	default:		return -E_NO_SYS;	}}

// Dispatches to the correct kernel function, passing the arguments.int32_tsyscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5){	// Call the function corresponding to the 'syscallno' parameter.	// Return any appropriate return value.	// LAB 3: Your code here.        curenv->env_syscalls++;        switch(syscallno){        case SYS_cputs:                sys_cputs((char *)a1, (size_t)a2);break;        case SYS_cgetc:                sys_cgetc();break;        case SYS_getenvid:                return sys_getenvid();        case SYS_env_destroy:                return sys_env_destroy((envid_t)a1);        case SYS_dump_env:                sys_dump_env();break;        case SYS_page_alloc:                return sys_page_alloc((envid_t)a1, (void *)a2, (int)a3);        case SYS_page_map: {                return sys_page_map((envid_t)a1, (void *)a2,                                    (envid_t)a3, (void *)a4, (int)a5);        }        case SYS_page_unmap:                return sys_page_unmap((envid_t)a1, (void *)a2);        case SYS_exofork:                return sys_exofork();        case SYS_env_set_status:                return sys_env_set_status((envid_t)a1,(int)a2);        case SYS_env_set_trapframe:                return sys_env_set_trapframe((envid_t)a1,                                             (struct Trapframe *)a2);        case SYS_env_set_pgfault_upcall:                return sys_env_set_pgfault_upcall((envid_t)a1, (void *)a2);        case SYS_yield:                sys_yield();break;//new add syscall for lab4;        case SYS_ipc_try_send:                return sys_ipc_try_send((envid_t)a1, (uint32_t)a2,                                        (void *)a3, (unsigned)a4);        case SYS_ipc_recv:                return sys_ipc_recv((void *)a1);        case SYS_ide_read:                sys_ide_read((uint32_t)a1, (void *)a2, (size_t)a3);                break;        case SYS_ide_write:                sys_ide_write((uint32_t)a1, (void *)a2, (size_t)a3);                break;        case SYS_time_msec:                return sys_time_msec();        case NSYSCALLS:                break;        default:                return -E_INVAL;        }        return 0;	//panic("syscall not implemented");}

// Dispatches to the correct kernel function, passing the arguments.int32_tsyscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5){	// Call the function corresponding to the 'syscallno' parameter.	// Return any appropriate return value.	// LAB 3: Your code here.	int32_t ret = -E_INVAL;	switch(syscallno) {		case SYS_cputs:			sys_cputs((char *)a1, a2);			break;		case SYS_cgetc:			ret = sys_cgetc();			break;		case SYS_getenvid:			ret = sys_getenvid();			break;		case SYS_env_destroy:			ret = sys_env_destroy(a1);			break;		case SYS_yield:			sys_yield();			ret = 0;			break;		case SYS_map_kernel_page:			ret = sys_map_kernel_page((void *)a1, (void *)a2);			break;		case SYS_sbrk:			ret = sys_sbrk(a1);			break;		case SYS_exofork:			ret = sys_exofork();			break;		case SYS_env_set_status:			ret = sys_env_set_status(a1,a2);			break;		case SYS_page_alloc:			ret = sys_page_alloc(a1,(void*)a2,a3);			break;		case SYS_page_map:			ret = sys_page_map(a1,(void*)a2,a3,(void*)a4,a5);			break;		case SYS_page_unmap:			ret = sys_page_unmap(a1,(void*)a2);			break;		case SYS_env_set_pgfault_upcall:			ret = sys_env_set_pgfault_upcall(a1,(void*)a2);			break;		case SYS_ipc_try_send:			ret = sys_ipc_try_send(a1,a2,(void*)a3,a4);			break;		case SYS_ipc_recv:			ret = sys_ipc_recv((void*)a1);	}	return ret;//	panic("syscall not implemented");}

// Dispatches to the correct kernel function, passing the arguments.int32_tsyscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5){	// Call the function corresponding to the 'syscallno' parameter.	// Return any appropriate return value.	// LAB 3: Your code here.    /* lj */    int ret = 0;    switch(syscallno) {        case SYS_cputs:            sys_cputs((const char *)a1, a2);        break;        case SYS_cgetc:            ret = sys_cgetc();        break;        case SYS_getenvid:            ret = sys_getenvid();        break;        case SYS_env_destroy:            ret = sys_env_destroy(a1);        break;        case SYS_yield:            sys_yield();        break;        case SYS_exofork:            ret = sys_exofork();        break;        case SYS_env_set_status:            ret = sys_env_set_status((envid_t)a1, a2);        break;        case SYS_page_alloc:            ret = sys_page_alloc((envid_t)a1, (void *)a2, a3);        break;        case SYS_page_map:            ret = sys_page_map((envid_t)a1, (void *)a2, (envid_t)a3, (void *)a4, a5);        break;        case SYS_page_unmap:            ret = sys_page_unmap((envid_t)a1, (void *)a2);        break;        case SYS_env_set_pgfault_upcall:            ret = sys_env_set_pgfault_upcall((envid_t)a1, (void *)a2);        break;        case SYS_ipc_try_send:            ret = sys_ipc_try_send((envid_t)a1, a2, (void *)a3, a4);        break;        case SYS_ipc_recv:            ret = sys_ipc_recv((void *)a1);        break;        default:            ret = -E_INVAL;        break;    }    //panic("syscall not implemented");    //cprintf("%d return to user %d/n", syscallno, ret);    return ret;}

//// 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" 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_tfork(void){	// LAB 4: Your code here.	//cprintf("In environment %04x/n", sys_getenvid());	set_pgfault_handler(pgfault);	envid_t envid;	int r;	envid = sys_exofork();	if(envid < 0)		panic("sys_exofork: %e", envid);		else if(envid == 0)	{		env = &envs[ENVX(sys_getenvid())];		//cprintf("I am the child %04x %04x/n", sys_getenvid(), env->env_id);		return 0;	}		//cprintf("In the parent process %04x/n", sys_getenvid());	if((r = sys_page_alloc(envid, (void *)(UXSTACKTOP - PGSIZE), PTE_W | PTE_U | PTE_P))<0)		panic("sys_page_alloc: %e", r);	if((r = sys_env_set_pgfault_upcall(envid, env->env_pgfault_upcall))<0)		panic("sys_env_set_pgfault_upcall: %e", r);		uint32_t va;	for(va = UTEXT; va < UTOP; va += PGSIZE)		if(va == UXSTACKTOP - PGSIZE) 		{			if((r = sys_page_alloc(envid, (void *)(UXSTACKTOP - PGSIZE), PTE_P | PTE_W | PTE_U))<0)				panic("sys_page_alloc: %e", r);		}		else if((vpd[VPN(va)/NPTENTRIES] & PTE_P) && (vpt[VPN(va)] & PTE_P))			duppage(envid, va>>PGSHIFT);	//cprintf("Done with the copying in environment %04x/n", env->env_id);	if((r = sys_env_set_pgfault_upcall(envid, env->env_pgfault_upcall))<0)		panic("sys_env_set_pgfault_upcall: %e", r);	if((r = sys_env_set_status(envid, ENV_RUNNABLE))<0)		panic("sys_env_status: %e", r);	// Returning the child's envid to the parent	return envid;}

//// 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 uvpd, uvpt, and duppage.//   Remember to fix "thisenv" 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_tfork(void){	// LAB 4: Your code here.	//panic("fork not implemented");	envid_t envid=-1;	pte_t ptentry=0, ptable=0, page_num=0;	pde_t pdentry=0;	uintptr_t addr=0;	int pdindex = 0, pte_perm=0, pte_loop=0;	int r=-1;	//cprintf("/nin fork envid:%x/n", thisenv->env_id);	set_pgfault_handler(pgfault);	if((envid=sys_exofork())<0)		panic("/nCannot create a child process:%e/n",envid);	//cprintf("/nenvid of newly created child:%x/n",envid);	if (envid == 0) {		// We're the child.		// The copied value of the global variable 'thisenv'		// is no longer valid (it refers to the parent!).		// Fix it and return 0.		thisenv = &envs[ENVX(sys_getenvid())];		//set_pgfault_handler(pgfault);		return 0;	}	//Incrementing by PGSIZE in loop because 1 page of pgsize corresponds to 1 page taable entry	//Incrementing the address by 4MB because uvpd has no entry means 1 uvpd->4 MB region so need to skip it.	while(addr<(UXSTACKTOP-PGSIZE))	{		//cprintf("parent address:%x",addr);		if(uvpd[PDX(addr)] & PTE_P)		{			if(uvpt[PGNUM(addr)] & PTE_P)			{				//cprintf("/ncalling duppgae for address %x/n",addr);				duppage(envid, PGNUM(addr));			}			addr += PGSIZE;		}		else		{			addr = addr + PTSIZE;		}	}	if ((r = sys_page_alloc(envid,(void *)UXSTACKTOP-PGSIZE, PTE_P|PTE_U|PTE_W)) < 0)		panic("sys_page_alloc: %e", r);	if ((r = sys_env_set_pgfault_upcall(envid, _pgfault_upcall)) < 0)		panic("pagefault upcall setup error: %e", r);	sys_env_set_status(envid, ENV_RUNNABLE);	//cprintf("/n fork exiting - envid:%x/n",thisenv->env_id);	return envid;}

//// 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_tfork(void){	// LAB 4: Your code here.		// Assembly language pgfault entrypoint defined in lib/pgfaultentry.S.	extern void _pgfault_upcall(void);		envid_t chenvid;		void *addr;	void *addr2;	unsigned pn;		pte_t pte, pde;	int count, r, entries;	set_pgfault_handler(pgfault);	if ( (chenvid = sys_exofork()) < 0)		panic("fork() - no free env!");	else if (chenvid == 0){					//we are in child - ren		env = &envs[ENVX(sys_getenvid())];			return 0;	     }		//we are in parent - ren	//copy mappings - ren	entries = NPDENTRIES;	for(addr = 0; entries--; addr+=NPTENTRIES*PGSIZE){	//walk through page directory - ren		pde = vpd[PDX(addr)];		if (pde & PTE_P) {												//walk through page table - ren			for(addr2 = addr, count = NPTENTRIES; ((uintptr_t)addr2 < (uintptr_t)UTOP - PGSIZE) && (count);							       addr2+=PGSIZE, count--){					pte = vpt[VPN(addr2)];				if (pte & PTE_P){					duppage(chenvid, (uintptr_t)addr2/PGSIZE);								}			}			if (count)							break;				//reached exception stack - ren						}		}		if( (r = sys_page_alloc(chenvid, (void *) UXSTACKTOP-PGSIZE, PTE_U | PTE_P | PTE_W)) < 0)			panic("fork() - could not allocate exception stack for the child!");		if( (r = sys_env_set_pgfault_upcall(chenvid, (void *) _pgfault_upcall)) < 0)			panic("fork() - could not set page fault entrypoint for the child!");	if( (r = sys_env_set_status(chenvid, ENV_RUNNABLE)) < 0)			panic("fork() - could not set child ENV_RUNNABLE!");	return chenvid;}		

envid_tfork(void){    // LAB 4: Your code here.    // seanyliu    int r;    int pdidx = 0;    int peidx = 0;    envid_t childid;    set_pgfault_handler(pgfault);    // create child environment    childid = sys_exofork();    if (childid < 0) {        panic("fork: failed to create child %d", childid);    }    if (childid == 0) {        env = &envs[ENVX(sys_getenvid())];        return 0;    }    // loop through pg dir, avoid user exception stack (which is immediately below UTOP    for (pdidx = 0; pdidx < PDX(UTOP); pdidx++) {        // check if the pg is present        if (!(vpd[pdidx] & PTE_P)) continue;        // loop through pg table entries        for (peidx = 0; (peidx < NPTENTRIES) && (pdidx*NPDENTRIES+peidx < (UXSTACKTOP - PGSIZE)/PGSIZE); peidx++) {            if (vpt[pdidx * NPTENTRIES + peidx] & PTE_P) {                if ((r = duppage(childid, pdidx * NPTENTRIES + peidx)) < 0) {                    panic("fork: duppage failed: %d", r);                }            }        }    }    // allocate fresh page in the child for exception stack.    if ((r = sys_page_alloc(childid, (void *)(UXSTACKTOP - PGSIZE), PTE_U | PTE_P | PTE_W)) < 0) {        panic("fork: %d", r);    }    // parent sets the user page fault entrypoint for the child to look like its own.    if ((r = sys_env_set_pgfault_upcall(childid, env->env_pgfault_upcall)) < 0) {        panic("fork: %d", r);    }    // parent marks child runnable    if ((r = sys_env_set_status(childid, ENV_RUNNABLE)) < 0) {        panic("fork: %d", r);    }    return childid;    //panic("fork not implemented");}

// Dispatches to the correct kernel function, passing the arguments.int32_tsyscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5){	// Call the function corresponding to the 'syscallno' parameter.	// Return any appropriate return value.	// LAB 3: Your code here.	int32_t r =0;	switch(syscallno){		case SYS_cputs:			sys_cputs((const char*)a1,(size_t)a2);			break;		case SYS_cgetc:			r = sys_cgetc();			break;		case SYS_getenvid:			r = sys_getenvid();			break;		case SYS_env_destroy:			r = sys_env_destroy((envid_t)a1);			break;		case SYS_yield:			sys_yield();			r =0;			break;		case SYS_exofork:			r = sys_exofork();			break;		case SYS_env_set_status:			r = sys_env_set_status((envid_t)a1,(int)a2);			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_pgfault_upcall:			r = sys_env_set_pgfault_upcall((envid_t)a1, (void *)a2);			break;		case SYS_ipc_try_send:			r = sys_ipc_try_send((envid_t)a1, (uint32_t)a2, (void *)a3, (unsigned int)a4);			break;		case SYS_ipc_recv:			r = sys_ipc_recv((void *)a1);			break;		default:			r = -E_INVAL;	}	return r;	panic("syscall not implemented");}

// Dispatches to the correct kernel function, passing the arguments.int32_tsyscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5){	// Call the function corresponding to the 'syscallno' parameter.	// Return any appropriate return value.	// LAB 3: Your code here.	switch (syscallno){		case SYS_getenvid:			return sys_getenvid();		case SYS_cputs:			sys_cputs((const char*)a1, a2);			return 0;		case SYS_cgetc:			return sys_cgetc();		case SYS_env_destroy:			return sys_env_destroy(a1);		case SYS_map_kernel_page:			return sys_map_kernel_page((void*)a1, (void*)a2);		case SYS_sbrk:			return sys_sbrk(a1);		case SYS_yield:			sys_yield();			return 0;		case SYS_exofork:			return sys_exofork();		case SYS_env_set_status:			return sys_env_set_status((envid_t)a1, (int)a2);		case SYS_page_alloc:			return sys_page_alloc((envid_t)a1, (void *)a2, 						(int)a3);		case SYS_page_map:			return sys_page_map((envid_t)*((uint32_t*)a1),					(void*)*((uint32_t*)a1+1), 					(envid_t)*((uint32_t*)a1+2), 					(void*)*((uint32_t*)a1+3), 					(int)*((uint32_t*)a1+4));		case SYS_page_unmap:			return sys_page_unmap((envid_t)a1, (void*)a2);		case SYS_env_set_priority:			return sys_env_set_priority((envid_t)a1, (int) a2);		case SYS_env_set_pgfault_upcall:			return sys_env_set_pgfault_upcall((envid_t)a1,						 (void*)a2);		case SYS_ipc_recv:			return sys_ipc_recv((void*)a1);		case SYS_ipc_try_send:			return sys_ipc_try_send((envid_t)a1, a2, 						(void*)a3, (int)a4);		default:			return -E_INVAL;	}}

// Dispatches to the correct kernel function, passing the arguments.int32_tsyscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5){	// Call the function corresponding to the 'syscallno' parameter.	// Return any appropriate return value.	// LAB 3: Your code here.//	panic("syscall not implemented");	switch (syscallno) {	case SYS_cputs:		sys_cputs((char *)a1, a2);		break;	case SYS_cgetc:		return sys_cgetc();	case SYS_env_destroy:		return sys_env_destroy(a1);	case SYS_getenvid:		return sys_getenvid();	case SYS_yield:		sys_yield();		break;	case SYS_page_alloc:		return sys_page_alloc(a1, (void *)a2, a3);	case SYS_page_map:		return sys_page_map(a1, (void *)a2, a3, (void *)a4, a5);	case SYS_page_unmap:		return sys_page_unmap(a1, (void *)a2);	case SYS_env_set_status:		return sys_env_set_status(a1, a2);	case SYS_exofork:		return sys_exofork();	case SYS_env_set_pgfault_upcall:		return sys_env_set_pgfault_upcall(a1, (void *)a2);	case SYS_ipc_try_send:		return sys_ipc_try_send(a1, a2, (void*)a3, a4);	case SYS_ipc_recv:		return sys_ipc_recv((void*)a1);	case SYS_env_set_trapframe:		return sys_env_set_trapframe(a1, (struct Trapframe *)a2);	case SYS_time_msec:		return sys_time_msec();	case SYS_trans_pkt:		return sys_trans_pkt((void*)a1, a2);	case SYS_recv_pkt:		return sys_recv_pkt((void *)a1, (size_t *)a2);	default:		return -E_INVAL;	}	return 0;}

// Challenge!intsfork(void){	int r;	pde_t *pde;	pte_t *pte;	unsigned i;	uint32_t addr;	envid_t envid;	envid = sys_exofork();//创建子环境	if(envid < 0)		panic("sys_exofork: %e", envid);	if(envid==0)//子环境中	{		env = &envs[ENVX(sys_getenvid())];		return 0;	}	else{//父环境中,注意：这里需要设置父环境的缺页异常栈，还需要设置子环境的缺页异常栈，	//父子环境的页异常栈不共享？具体原因还得思考		env = &envs[ENVX(sys_getenvid())];		set_pgfault_handler(pgfault);//设置缺页异常处理函数，这里设置了父环境的缺页异常栈		for(i=0;i<(unsigned)VPN(UTOP);i++)//重映射writable or copy-to-write的页面		{			addr=i*PGSIZE;			pde =(pde_t*) &vpd[VPD(addr)];			if(*pde&PTE_P)//这里只处理有物理页面映射的页表项			{				pte=(pte_t*)&vpt[VPN(addr)];			}			else    continue;			if((i==(unsigned)VPN(USTACKTOP-PGSIZE))||(i==(unsigned)VPN(PFTEMP)))								//特殊处理，用户层普通栈			{					if((r=duppage(envid,i))<0)					return r;				continue;			}			if((r=sduppage(envid,i))<0)				return r;		}		if((r=sys_page_alloc(envid,(void*)(UXSTACKTOP-PGSIZE),PTE_W|PTE_U|PTE_P))<0)                        return r;//设置子环境的缺页异常栈		if((r=sys_env_set_pgfault_upcall(envid,(void*)_pgfault_upcall))<0)			return r;//设置子环境的缺页异常处理入口点		if((r=sys_env_set_status(envid,ENV_RUNNABLE))<0)			return r;//设置子环境的状态为可运行		return envid;	}	//panic("sfork not implemented");	//return -E_INVAL;}

// Dispatches to the correct kernel function, passing the arguments.	int64_tsyscall(uint64_t syscallno, uint64_t a1, uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5){	// Call the function corresponding to the 'syscallno' parameter.	// Return any appropriate return value.	// LAB 3: Your code here.	uint64_t retval = 0;	switch (syscallno) {		case SYS_cputs:			sys_cputs((char *) a1, (size_t) a2);			return retval;		case SYS_cgetc:			return (int64_t) sys_cgetc();		case SYS_getenvid:			return (int64_t) sys_getenvid();		case SYS_env_destroy:			return (int64_t) sys_env_destroy((envid_t) a1);		case SYS_yield:			sys_yield();			return retval;		case SYS_exofork:			return (int64_t)sys_exofork();		case SYS_page_alloc:			return (int64_t)sys_page_alloc((envid_t)a1, (void *)a2, (int)a3);		case SYS_page_map:			return (int64_t)sys_page_map((envid_t)a1, (void *)a2, (envid_t)a3, (void *)a4, (int)a5);		case SYS_page_unmap:			return (int64_t)sys_page_unmap((envid_t)a1, (void *)a2);		case SYS_env_set_status:			return (int64_t)sys_env_set_status((envid_t)a1, (int)a2);		case SYS_env_set_pgfault_upcall:			return (int64_t)sys_env_set_pgfault_upcall((envid_t)a1, (void *)a2);		case SYS_ipc_try_send:			return (int64_t) sys_ipc_try_send((envid_t) a1, (uint32_t) a2, (void *) a3, (unsigned) a4);		case SYS_ipc_recv:			return (int64_t)sys_ipc_recv((void*)a1);		case SYS_env_set_trapframe:			return sys_env_set_trapframe((envid_t)a1, (struct Trapframe*)a2);		case SYS_time_msec:			return sys_time_msec();		case SYS_net_try_send:			return sys_net_try_send((char *) a1, (int) a2);		case SYS_net_try_receive:			return sys_net_try_receive((char *) a1, (int *) a2);		default:			return -E_INVAL;	}	panic("syscall not implemented");}