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

//// 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 do we need to mark ours// copy-on-write again if it was already copy-on-write at the beginning of// this function?)//// Returns: 0 on success, < 0 on error.// It is also OK to panic on error.//static intduppage(envid_t envid, unsigned pn){	int r;	// LAB 4: Your code here.//------------  Lab4  ----------------------------------------------------------------------------------------			if (pn * PGSIZE == UXSTACKTOP - PGSIZE) return 0;	uintptr_t addr = (uintptr_t)(pn * PGSIZE);	if ( (uvpt[pn] & PTE_W) || (uvpt[pn] & PTE_COW) ) {		r = sys_page_map(0, (void *)addr, envid, (void *)addr, PTE_P | PTE_U | PTE_COW);		if (r < 0)			panic("sys_page_map failed in duppage %e/n", r);		r = sys_page_map(0, (void *)addr, 0, (void *)addr, PTE_P | PTE_U | PTE_COW);		if (r < 0)			panic("sys_page_map failed in duppage %e/n", r);	}	else {		r = sys_page_map(0, (void *)addr, envid, (void *)addr, PTE_P | PTE_U);		if (r < 0)			panic("sys_page_map failed in duppage %e/n", r);	}	return 0;//------------  Lab4  ----------------------------------------------------------------------------------------				//panic("duppage not implemented");	return 0;}

//// 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 do we need to mark ours// copy-on-write again if it was already copy-on-write at the beginning of// this function?)//// Returns: 0 on success, < 0 on error.// It is also OK to panic on error.//static intduppage(envid_t envid, unsigned pn){	int r;	uint32_t perm = PTE_P | PTE_COW;	envid_t this_envid = thisenv->env_id;	// LAB 4: Your code here.	if (uvpt[pn] & PTE_SHARE) {		if ((r = sys_page_map(this_envid, (void *) (pn*PGSIZE), envid, (void *) (pn*PGSIZE), uvpt[pn] & PTE_SYSCALL)) < 0)			panic("sys_page_map: %e/n", r);	} else if (uvpt[pn] & PTE_COW || uvpt[pn] & PTE_W) {		if (uvpt[pn] & PTE_U)			perm |= PTE_U;		// Map page COW, U and P in child		if ((r = sys_page_map(this_envid, (void *) (pn*PGSIZE), envid, (void *) (pn*PGSIZE), perm)) < 0)			panic("sys_page_map: %e/n", r);		// Map page COW, U and P in parent		if ((r = sys_page_map(this_envid, (void *) (pn*PGSIZE), this_envid, (void *) (pn*PGSIZE), perm)) < 0)			panic("sys_page_map: %e/n", r);	} else { // map pages that are present but not writable or COW with their original permissions		if ((r = sys_page_map(this_envid, (void *) (pn*PGSIZE), envid, (void *) (pn*PGSIZE), uvpt[pn] & PTE_SYSCALL)) < 0)			panic("sys_page_map: %e/n", r);	}	return 0;}

// Make file descriptor 'newfdnum' a duplicate of file descriptor 'oldfdnum'.// For instance, writing onto either file descriptor will affect the// file and the file offset of the other.// Closes any previously open file descriptor at 'newfdnum'.// This is implemented using virtual memory tricks (of course!).intdup(int oldfdnum, int newfdnum){	int r;	char *ova, *nva;	pte_t pte;	struct Fd *oldfd, *newfd;	if ((r = fd_lookup(oldfdnum, &oldfd)) < 0)		return r;	close(newfdnum);	newfd = INDEX2FD(newfdnum);	ova = fd2data(oldfd);	nva = fd2data(newfd);	if ((vpd[VPD(ova)] & PTE_P) && (vpt[VPN(ova)] & PTE_P))		if ((r = sys_page_map(0, ova, 0, nva, vpt[VPN(ova)] & PTE_SYSCALL)) < 0)			goto err;	if ((r = sys_page_map(0, oldfd, 0, newfd, vpt[VPN(oldfd)] & PTE_SYSCALL)) < 0)		goto err;	return newfdnum;err:	sys_page_unmap(0, newfd);	sys_page_unmap(0, nva);	return r;}

//// 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 do we need to mark ours// copy-on-write again if it was already copy-on-write at the beginning of// this function?)//// Returns: 0 on success, < 0 on error.// It is also OK to panic on error.//static intduppage(envid_t envid, unsigned pn){	if (pn * PGSIZE == UXSTACKTOP - PGSIZE) return 0;	int r;	// LAB 4: Your code here.	if (uvpt[pn] & PTE_SHARE) {		r = sys_page_map (0, (void*) (pn * PGSIZE), envid, (void*) (pn * PGSIZE), uvpt[pn] & PTE_SYSCALL);		if (r < 0) panic("duppage sys_page_map error : %e/n", r);	} 	else if ((uvpt[pn] & PTE_W) || (uvpt[pn] & PTE_COW)) {		r = sys_page_map(0, (void*) (pn * PGSIZE), envid, (void*) (pn * PGSIZE), PTE_U | PTE_P | PTE_COW);		if (r < 0) panic("map failed");		r = sys_page_map(0, (void*) (pn * PGSIZE), 0, (void*) (pn * PGSIZE), PTE_U | PTE_P | PTE_COW);		if (r < 0) panic("map failed");	}	else {		r = sys_page_map(0, (void*) (pn * PGSIZE), envid, (void*) (pn * PGSIZE), PTE_U | PTE_P);		if (r < 0) panic("map failed");	}//	panic("duppage not implemented");	return 0;}

//// 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 might we need to mark ours// copy-on-write again if it was already copy-on-write at the beginning of// this function?)//// Returns: 0 on success, < 0 on error.// It is also OK to panic on error.//static intduppage(envid_t envid, unsigned pn){    int r;    // LAB 4: Your code here.    // seanyliu    // LAB 7: add in a new if check    if (vpt[pn] & PTE_SHARE) {        if ((r = sys_page_map(sys_getenvid(), (void *)(pn * PGSIZE), envid, (void *)(pn * PGSIZE), vpt[pn] & PTE_USER)) < 0) {            return r;        }    } else if (vpt[pn] & (PTE_W | PTE_COW)) {        // If the page is writable or copy-on-write, the new mapping must be created copy-on-write        if ((r = sys_page_map(sys_getenvid(), (void *)(pn*PGSIZE), envid, (void *)(pn*PGSIZE), PTE_U | PTE_COW | PTE_P)) < 0) {            panic("duppage: sys_page_map %d", r);        }        // and then our mapping must be marked copy-on-write as well        //vpt[pn] = vpt[pn] | PTE_COW;        if ((r = sys_page_map(sys_getenvid(), (void *)(pn*PGSIZE), sys_getenvid(), (void *)(pn*PGSIZE), PTE_U | PTE_COW | PTE_P)) < 0) {            panic("duppage: sys_page_map %d", r);        }    } else {        if ((r = sys_page_map(sys_getenvid(), (void *)(pn*PGSIZE), envid, (void *)(pn*PGSIZE), PTE_U | PTE_P)) < 0) {            panic("duppage: sys_page_map %d", r);        }    }    //panic("duppage not implemented");    return 0;}

//// 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 do we need to mark ours// copy-on-write again if it was already copy-on-write at the beginning of// this function?)//// Returns: 0 on success, < 0 on error.// It is also OK to panic on error.//    static intduppage(envid_t envid, unsigned pn){    int r;    unsigned va;    // LAB 4: Your code here.	pte_t pte = vpt[pn];        int perm = pte & 0xfff;        int perm_share = pte & PTE_USER;        va = pn * PGSIZE;        if (perm_share & PTE_SHARE)                return sys_page_map(0, (void *)(uint64_t)va, envid, (void *)(uint64_t)va, perm_share);        if (pte & (PTE_W|PTE_COW)) {                //child                if ((r = sys_page_map(0, (void *)(uint64_t)va, envid, (void *)(uint64_t)va, PTE_P|PTE_U|PTE_COW)) < 0)                        panic("sys_page_map failed: %e/n", r);                // parent                return sys_page_map(0, (void *)(uint64_t)va, 0, (void *)(uint64_t)va, PTE_P|PTE_U|PTE_COW);        }        return sys_page_map(0, (void *)(uint64_t)va, envid, (void *)(uint64_t)va, PTE_P|PTE_U|perm);    //panic("duppage not implemented");    //return 0;}

//// 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 do we need to mark ours// copy-on-write again if it was already copy-on-write at the beginning of// this function?)//// Returns: 0 on success, < 0 on error.// It is also OK to panic on error.//    static intduppage(envid_t envid, unsigned pn){	// LAB 4: Your code here.	int r;	pte_t pte = vpt[pn];	void * addr = (void *)((uint64_t)pn * PGSIZE);		int perm = pte & PTE_USER;		if(perm&PTE_SHARE) {		if((r = sys_page_map(0, addr, envid, addr, perm)) < 0)	//map shared pages			panic("Couldn't map shared page %e",r);		return 0;	}	else if((perm&PTE_W) || (perm&PTE_COW)) {	//if write or COW pages		 perm &= ~PTE_W;   		 perm |= PTE_COW;		if((r = sys_page_map(0, addr, envid, addr, perm)) < 0)	// map once in child			panic("Couldn't map page COW child %e",r);				if((r = sys_page_map(0, addr, 0, addr, perm)) < 0) //map once in yourself			panic("Couldn't map page COW parent %e",r);			return 0;	}	else {		//cprintf("perm: %x/n",perm);		if((r = sys_page_map(0, addr, envid, addr, PTE_P|PTE_U)) < 0)	//map readonly pages			panic("Couldn't map readonly page %e",r);		return 0;	}}

//// 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 do we need to mark ours// copy-on-write again if it was already copy-on-write at the beginning of// this function?)//// Returns: 0 on success, < 0 on error.// It is also OK to panic on error.// static intduppage(envid_t envid, unsigned pn){	int r;	// LAB 4: Your code here.	pde_t *pde;	pte_t *pte;	void *addr=(void*)(pn*PGSIZE);	pde =(pde_t*) &vpd[VPD(addr)];	if(*pde&PTE_P)	{		pte=(pte_t*)&vpt[VPN(addr)];	}	else    panic("page table for pn page is not exist");	if((*pte&PTE_W)||(*pte&PTE_COW))	{		if((r=sys_page_map(0,addr,envid,addr,PTE_COW|PTE_U))<0)			return r;		if((r=sys_page_map(0,addr,0,addr,PTE_COW|PTE_U))<0)//映射的时候注意env的id                        return r;	}	else{			if((r=sys_page_map(0,addr,envid,addr,PTE_U|PTE_P))<0)			return r;	}	//panic("duppage not implemented");	return 0;}

//// 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 do we need to mark ours// copy-on-write again if it was already copy-on-write at the beginning of// this function?)//// Returns: 0 on success, < 0 on error.// It is also OK to panic on error.//static intduppage(envid_t envid, unsigned pn){	int perm = uvpt[pn]&PTE_SYSCALL;	// If the old permissions were write and the page isn't being shared,	//  the new permissions should include COW and not include PTE_W.	if((uvpt[pn]&(PTE_W|PTE_COW)) != 0 && (uvpt[pn]&PTE_SHARE) == 0) {		perm |= PTE_COW;		perm &= ~PTE_W;	}	// Now map the page to the new environment	if(sys_page_map(0, (void *)(pn*PGSIZE), envid, (void *)(pn*PGSIZE), perm) != 0)		panic("duppage: unable to map page 0x%x to child", pn*PGSIZE);	// The old mapping must be converted to COW as well. This must be done	//  after the child mapping because of mapping the user stack.  A fault	//  happens immediately, switching that mapping to a writable page.  That	//  mapping is then copied over to the child incorrectly.	if(perm&PTE_COW) {		if(sys_page_map(0, (void *)(pn*PGSIZE), 0, (void *)(pn*PGSIZE), perm) != 0)			panic("duppage: unable to set permissions for own page");	}	return 0;}

//// 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 intduppage(envid_t envid, unsigned pn){	int r;	void *addr;	pte_t pte;	envid_t our_envid;	// LAB 4: Your code here.	our_envid = sys_getenvid();	addr = (void *) (pn*PGSIZE);	pte = (pte_t)vpt[VPN(addr)];	        // + LAB 6:        if ( pte & PTE_SHARE ){            if ( (r = sys_page_map(our_envid, addr, envid, addr, pte & PTE_USER)) < 0)			panic("duppage() - failed to map shared page!");            return 0;        }        // - LAB 6        	if ( (pte & PTE_W) || (pte & PTE_COW) ){		if ( (r = sys_page_map(our_envid, addr, envid, addr, PTE_COW | PTE_U | PTE_P)) < 0)			panic("duppage() - failed to map writable or COW page!");		if ( (r = sys_page_map(our_envid, addr, our_envid, addr, PTE_COW | PTE_U | PTE_P)) < 0)			panic("duppage() - failed to remap!");	}else{		if ( (r = sys_page_map(our_envid, addr, envid, addr, PTE_U | PTE_P)) < 0)			panic("duppage() - failed to map read-only page!");	}		return 0;}

//// 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 do we need to mark ours// copy-on-write again if it was already copy-on-write at the beginning of// this function?)//// Returns: 0 on success, < 0 on error.// It is also OK to panic on error.// static intduppage(envid_t envid, unsigned pn){	int r;		// LAB 4: Your code here.	if (debug)		cprintf("/n duppage: 1/n");		pte_t pte = vpt[pn];	int perm = pte & PTE_USER;	void *va = (void*) (pn*PGSIZE);		if (debug)		cprintf("/n duppage: 2/n");			if ((perm & PTE_P) != PTE_P)		panic ("user panic: lib/fork.c: duppage(): page to be duplicated is not PTE_P/n");	if ((perm & PTE_U) != PTE_U)		panic ("user panic: lib/fork.c: duppage(): page to be duplicated is not PTE_U/n");	if (debug)		cprintf("/n duppage: 3/n");		// LAB 7: Include PTE_SHARE convention	if ( !(perm & PTE_SHARE) && (((perm & PTE_W) == PTE_W) || ((perm & PTE_COW) == PTE_COW)))	{		if (debug)			cprintf("/n duppage: 4/n");			// perm = PTE_P | PTE_U | PTE_COW;	// buggy permissions, removed in LAB 7		perm &= ~PTE_W;				// remove write from perm		perm |= PTE_COW;			// add copy-on-write		if (debug)			cprintf("/n duppage: 10/n");			if ((r = sys_page_map(0, va, envid, va, perm)) < 0)			return r;		if (debug)			cprintf("/n duppage: 11/n");			if ((r = sys_page_map(0, va, 0, va, perm)) < 0)			return r;					if (debug)			cprintf("/n duppage: 5/n");		}	// LAB 7: Include PTE_SHARE convention	else	{		if (debug)			cprintf("/n duppage: 6/n");			if ((r = sys_page_map(0, va, envid, va, perm)) < 0)			return r;		if (debug)			cprintf("/n duppage: 7/n");		}	//	cprintf("duppage() tried to copy a page which is neither PTE_W nor PTE_COW/n");	// panic("duppage not implemented");	return 0;}

static intduppage(envid_t envid, unsigned pn){	int r;        int i=0;        int dir_index = 0 ;        uint32_t perm = 0 ;        //check if vpt[i] is marked as Write or cow, if so         //mark it as COW  for child and parent            //cprintf("i %d vpt[i] %x /n",i,&vpt[i]);         //Make sure that this page is not the exception stack       if ( pn * PGSIZE >= ( UXSTACKTOP - PGSIZE ) &&            pn * PGSIZE <= ( UXSTACKTOP )          )          {             //cprintf("Found a Exception stack at %d/n",pn);              return 0;          }          if( ( vpt[pn] & PTE_P ) == PTE_P )         {             perm = vpt[pn] & 0xFFF; //Get last 12 bits            if(( vpt[pn] & PTE_SHARED) == PTE_SHARED)            {                perm |= PTE_SHARED;              //cprintf("Mapping the page for child %d/n",pn);              //insert this page in child's PG DIR               r = sys_page_map(0,(void*)( pn * PGSIZE), envid,(void*)(pn*PGSIZE),perm | PTE_P);              if( r < 0 )               {                   panic("Unable to map a page %d/n",pn);              }              //cprintf("Mapping the page for parent %d/n",pn);              //update the Parent PGDIR to reflect new permission             r = sys_page_map(0,(void*)( pn * PGSIZE), 0,(void*)(pn*PGSIZE),perm | PTE_P);              if( r < 0 )               {                   panic("Unable to map a page %d/n",pn);              }          }        } 	// LAB 4: Your code here.	//panic("duppage not implemented");	return 0;}

static intmap_segment(envid_t child, uintptr_t va, size_t memsz,	int fd, size_t filesz, off_t fileoffset, int perm){	int i, r;	void *blk;	//cprintf("map_segment %x+%x/n", va, memsz);	if ((i = PGOFF(va))) {		va -= i;		memsz += i;		filesz += i;		fileoffset -= i;	}	for (i = 0; i < memsz; i += PGSIZE) {		if (i >= filesz) {			// allocate a blank page			if ((r = sys_page_alloc(0, UTEMP, perm)) < 0) {				return r;			}                        memset(UTEMP, 0, PGSIZE);			sys_page_map(0, UTEMP, child, (void *)(va+i), perm);			return r;		} else {			// from file			if (perm & PTE_W) {				// must make a copy so it can be writable				if ((r = sys_page_alloc(0, UTEMP, PTE_P|PTE_U|PTE_W)) < 0)					return r;				if ((r = seek(fd, fileoffset + i)) < 0)					return r;				if ((r = read(fd, UTEMP, MIN(PGSIZE, filesz-i))) < 0)					return r;                                memset(UTEMP+MIN(PGSIZE, filesz-i), 0, PGSIZE-MIN(PGSIZE, filesz-i));				if ((r = sys_page_map(0, UTEMP, child, (void*) (va + i), perm)) < 0)					panic("spawn: sys_page_map data: %e", r);				sys_page_unmap(0, UTEMP);			} else {				// can map buffer cache read only				if ((r = read_map(fd, fileoffset + i, &blk)) < 0)					return r;				if ((r = sys_page_map(0, blk, child, (void*) (va + i), perm)) < 0)					panic("spawn: sys_page_map text: %e", r);			}		}	}	return 0;}

//// Custom page fault handler - if faulting page is copy-on-write,// map in our own private writable copy.//static voidpgfault(struct UTrapframe *utf){	void *addr = (void *) utf->utf_fault_va;	uint32_t err = utf->utf_err;	int r;	// 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 uvpt	//   (see <inc/memlayout.h>).	// LAB 4: Your code here.	if ((err & FEC_WR) == 0 || (vpd[VPD(addr)] & PTE_P) == 0 || (vpt[VPN(addr)] & PTE_COW) == 0)		panic ("pgfault: not a write or attempting to access a non-COW 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 (0, (void *)PFTEMP, PTE_U|PTE_P|PTE_W)) < 0)		panic ("pgfault: page allocation failed : %e", r);	addr = ROUNDDOWN (addr, PGSIZE);	memmove (PFTEMP, addr, PGSIZE);	if ((r = sys_page_map (0, PFTEMP, 0, addr, PTE_U|PTE_P|PTE_W)) < 0)		panic ("pgfault: page mapping failed : %e", r);	//panic("pgfault not implemented");}

// Copy the mappings for shared pages into the child address space.static intcopy_shared_pages(envid_t child){	// LAB 7: Your code here.	int r;	int pdeno, pteno;	uint32_t pn = 0;		for (pdeno = 0; pdeno < VPD(UTOP); pdeno++) 	{		if (vpd[pdeno] == 0) 		{			// skip empty PDEs			pn += NPTENTRIES;			continue;		}						for (pteno = 0; pteno < NPTENTRIES; pteno++,pn++) 		{			if (vpt[pn] == 0)				// skip empty PTEs				continue;								int perm = vpt[pn] & PTE_USER;			if (perm & PTE_SHARE) 			{				void *addr = (void *)(pn << PGSHIFT);				r = sys_page_map(0, addr, child, addr, perm);				if (r)					return r;			}		}	}	return 0;}

// Make sure a particular disk block is loaded into memory.// Returns 0 on success, or a negative error code on error.// // If blk != 0, set *blk to the address of the block in memory.//// Hint: Use diskaddr, map_block, and ide_read.static intread_block(uint32_t blockno, char **blk){	int r;	char *addr;	if (super && blockno >= super->s_nblocks)		panic("reading non-existent block %08x/n", blockno);	if (bitmap && block_is_free(blockno))		panic("reading free block %08x/n", blockno);	// LAB 5: Your code here.	r = map_block(blockno);	if (r)		return r;	addr = diskaddr(blockno);	r = ide_read(blockno * BLKSECTS, addr, BLKSECTS);	if (r)		return r;	if (blk)		*blk = addr;	return sys_page_map(0, addr, 0, addr, vpt[VPN(addr)] & PTE_USER);}

// Flush the contents of the block containing VA out to disk if// necessary, then clear the PTE_D bit using sys_page_map.// If the block is not in the block cache or is not dirty, does// nothing.// Hint: Use va_is_mapped, va_is_dirty, and ide_write.// Hint: Use the PTE_USER constant when calling sys_page_map.// Hint: Don't forget to round addr down.voidflush_block(void *addr){	uint32_t blockno = ((uint32_t)addr - DISKMAP) / BLKSIZE; 	uint32_t secno, r;	if (addr < (void*)DISKMAP || addr >= (void*)(DISKMAP + DISKSIZE))		panic("flush_block of bad va %08x", addr);	// LAB 5: Your code here.        addr = ROUNDDOWN(addr,PGSIZE);        secno = blockno*BLKSECTS;		if(va_is_mapped(addr) && va_is_dirty(addr))	{			r = ide_write(secno, addr, BLKSECTS);		if(r)			panic("IDE write failed: %e", r);		//cprintf("/nClearing PTE_D : 0x%08x/n", vpt[VPN(addr)] & (~PTE_D));		r = sys_page_map(0,addr,0,addr, ((vpt[VPN(addr)] | PTE_USER) & (~PTE_D)));		// & PTE_USER  		if(r)			cprintf("/nPage Mapping failed %e/n", r);	}	//panic("flush_block not implemented");}

// Copy the mappings for shared pages into the child address space.    static intcopy_shared_pages(envid_t child){    // LAB 7: Your code here.    uint64_t vaddr;    int r;    for(vaddr=0; vaddr<UTOP; vaddr += PGSIZE) {                // Copying from lib/fork.c bruh.        if( // Gotta use the virtual types apparently.            (vpml4e[VPML4E(vaddr)] & PTE_P) // Mota mota level is present.            && ((vpde[VPDPE(vaddr)] & PTE_U) && (vpde[VPDPE(vaddr)] & PTE_P)) // Slighlt less mota level is also present.            && ((vpd[VPD(vaddr)] & PTE_U) && (vpd[VPD(vaddr)] & PTE_P))            &&  ((vpt[VPN(vaddr)] & PTE_U) && (vpt[VPN(vaddr)] & PTE_P))            )            if(vpt[VPN(vaddr)]&PTE_SHARE) {                r = sys_page_map(0, (void*)vaddr, child, (void*)vaddr, vpt[VPN(vaddr)] & PTE_SYSCALL);                if(r<0) {                    cprintf("WARN: Your environments are now throughly done for man./n");                    return -1;                }            }    }    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 "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");}

// Copy the mappings for shared pages into the child address space.static intcopy_shared_pages(envid_t child){	int pn, perm;	int retval = 0;	// Step through each page below UTOP. If the page is PTE_SHARE,	//  then copy the mapping of that page to the child environment.	for(pn = 0; pn < PGNUM(UTOP); pn++) {		// Check to see if the page directory entry and page table		//  entry for this page exist, and if the page is marked		//  PTE_SHARE.		if((uvpd[PDX(pn*PGSIZE)]&PTE_P) == 0 ||		   (uvpt[pn]&PTE_P) == 0 ||		   (uvpt[pn]&PTE_SHARE) == 0)			continue;		// Grab the permissions for the page		perm = uvpt[pn]&PTE_SYSCALL;		// Copy the current page number over		if((retval = sys_page_map(0, (void *)(pn*PGSIZE), child, (void *)(pn*PGSIZE), perm)) != 0)			break;	}	return 0;}

// Flush the contents of the block containing VA out to disk if// necessary, then clear the PTE_D bit using sys_page_map.// If the block is not in the block cache or is not dirty, does// nothing.// Hint: Use va_is_mapped, va_is_dirty, and ide_write.// Hint: Use the PTE_SYSCALL constant when calling sys_page_map.// Hint: Don't forget to round addr down.voidflush_block(void *addr){    uint32_t blockno = ((uint32_t)addr - DISKMAP) / BLKSIZE;    int r;    if (addr < (void*)DISKMAP || addr >= (void*)(DISKMAP + DISKSIZE))        panic("flush_block of bad va %08x", addr);    // LAB 5: Your code here.    addr = (void *)ROUNDDOWN(addr, PGSIZE);    if (!va_is_mapped(addr) || !va_is_dirty(addr))        return;    if ((r = ide_write(BLKSECTS * blockno, addr, BLKSECTS)) < 0) {        panic("flush_block: ide_write error %e/n", r);    }    if ((r = sys_page_map(0, addr, 0, addr, uvpt[PGNUM(addr)] & PTE_SYSCALL & ~PTE_D))) {        panic("flush_block: sys_page_map error %e/n", r);    }    return;}

// Copy the current contents of the block out to disk.// Then clear the PTE_D bit using sys_page_map.// Hint: Use ide_write.// Hint: Use the PTE_USER constant when calling sys_page_map.voidwrite_block(uint32_t blockno){	char *addr;	if (!block_is_mapped(blockno))		panic("write unmapped block %08x", blockno);		// Write the disk block and clear PTE_D.	// LAB 5: Your code here.	// We will use the VM hardware to keep track of whether a 	// disk block has been modified since it was last read from 	// or written to disk. To see whether a block needs writing, 	// we can just look to see if the PTE_D "dirty" bit is set 	// in the vpt entry.	addr = diskaddr(blockno);	if(!va_is_dirty(addr)) return;		int error;	int secno = blockno*BLKSECTS;	error = ide_write(secno, addr, BLKSECTS);	if(error<0) panic("write block error on writing");	int env_id = sys_getenvid();	error = sys_page_map(env_id, addr, 		env_id, addr, ((PTE_U|PTE_P|PTE_W) & ~PTE_D));	if(error<0) panic("write block error on clearing PTE_D");	// panic("write_block not implemented");}

// 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;	}}

// Try to send 'value' to the target env 'envid'.// If srcva < UTOP, then also send page currently mapped at 'srcva',// so that receiver gets a duplicate mapping of the same page.//// The send fails with a return value of -E_IPC_NOT_RECV if the// target is not blocked, waiting for an IPC.//// The send also can fail for the other reasons listed below.//// Otherwise, the send succeeds, and the target's ipc fields are// updated as follows://    env_ipc_recving is set to 0 to block future sends;//    env_ipc_from is set to the sending envid;//    env_ipc_value is set to the 'value' parameter;//    env_ipc_perm is set to 'perm' if a page was transferred, 0 otherwise.// The target environment is marked runnable again, returning 0// from the paused sys_ipc_recv system call.  (Hint: does the// sys_ipc_recv function ever actually return?)//// If the sender wants to send a page but the receiver isn't asking for one,// then no page mapping is transferred, but no error occurs.// The ipc only happens when no errors occur.//// Returns 0 on success, < 0 on error.// Errors are://	-E_BAD_ENV if environment envid doesn't currently exist.//		(No need to check permissions.)//	-E_IPC_NOT_RECV if envid is not currently blocked in sys_ipc_recv,//		or another environment managed to send first.//	-E_INVAL if srcva < UTOP but srcva is not page-aligned.//	-E_INVAL if srcva < UTOP and perm is inappropriate//		(see sys_page_alloc).//	-E_INVAL if srcva < UTOP but srcva is not mapped in the caller's//		address space.//	-E_INVAL if (perm & PTE_W), but srcva is read-only in the//		current environment's address space.//	-E_NO_MEM if there's not enough memory to map srcva in envid's//		address space.static intsys_ipc_try_send(envid_t envid, uint32_t value, void *srcva, unsigned perm){	// LAB 4: Your code here.	// My code : alaud	//cprintf("Trying to send to %x, for %x, nice %x/n", envid,curenv->env_id, curenv->env_nice);	int status = 0;	struct Env *target_env;	if((status = envid2env(envid, &target_env, 0)) < 0)	{		return status;	}	if(!target_env -> env_ipc_recving)	{		return -E_IPC_NOT_RECV;	}	//cprintf("Still Trying to send to %x, for %x, nice %x/n", envid,curenv->env_id, curenv->env_nice);	target_env -> env_ipc_perm = 0;	if((uint32_t)srcva < UTOP && (uint32_t)target_env -> env_ipc_dstva < UTOP)	{		if((status = sys_page_map(curenv -> env_id, srcva, envid, target_env -> env_ipc_dstva, perm)) < 0)		{			return status;		}		target_env -> env_ipc_perm = perm;	}	//cprintf("Still Still Trying to send to %x, for %x, nice %x/n", envid,curenv->env_id, curenv->env_nice);	target_env -> env_ipc_value = value;	target_env -> env_ipc_recving = 0;	target_env -> env_ipc_from = curenv -> env_id;	target_env -> env_status = ENV_RUNNABLE;	return 0;	//panic("sys_ipc_try_send not implemented");}

// Try to send 'value' to the target env 'envid'.// If va != 0, then also send page currently mapped at 'va',// so that receiver gets a duplicate mapping of the same page.//// The send fails with a return value of -E_IPC_NOT_RECV if the// target has not requested IPC with sys_ipc_recv.//// Otherwise, the send succeeds, and the target's ipc fields are// updated as follows://    env_ipc_recving is set to 0 to block future sends;//    env_ipc_from is set to the sending envid;//    env_ipc_value is set to the 'value' parameter;//    env_ipc_perm is set to 'perm' if a page was transferred, 0 otherwise.// The target environment is marked runnable again, returning 0// from the paused ipc_recv system call.//// If the sender sends a page but the receiver isn't asking for one,// then no page mapping is transferred, but no error occurs.// The ipc doesn't happen unless no errors occur.//// Returns 0 on success where no page mapping occurs,// 1 on success where a page mapping occurs, and < 0 on error.// Errors are://	-E_BAD_ENV if environment envid doesn't currently exist.//		(No need to check permissions.)//	-E_IPC_NOT_RECV if envid is not currently blocked in sys_ipc_recv,//		or another environment managed to send first.//	-E_INVAL if srcva < UTOP but srcva is not page-aligned.//	-E_INVAL if srcva < UTOP and perm is inappropriate//		(see sys_page_alloc).//	-E_INVAL if srcva < UTOP but srcva is not mapped in the caller's//		address space.//	-E_NO_MEM if there's not enough memory to map srcva in envid's//		address space.static intsys_ipc_try_send(envid_t envid, uint32_t value, void *srcva, unsigned perm){	// LAB 4: Your code here.        int r = 0;        struct Env *dstEnv = NULL;        if ((r=envid2env(envid, &dstEnv, 0)) < 0) {                return r;        }        if (!dstEnv->env_ipc_recving) {                return -E_IPC_NOT_RECV;        }        dstEnv->env_ipc_recving = 0;        dstEnv->env_ipc_from = curenv->env_id;        dstEnv->env_ipc_value = value;        dstEnv->env_status = ENV_RUNNABLE;        if ((uint32_t)srcva < UTOP && (uint32_t)(dstEnv->env_ipc_dstva) < UTOP) {                if ((r = sys_page_map(0, srcva, envid, dstEnv->env_ipc_dstva, perm)) < 0) {                        return r;                }                dstEnv->env_ipc_perm = perm;        } else {                dstEnv->env_ipc_perm = 0;        }        return 0;	//panic("sys_ipc_try_send not implemented");}

// Copy the mappings for shared pages into the child address space.static intcopy_shared_pages(envid_t child){	// LAB 7: Your code here.	int r;	uint32_t i, j, pn;	// Copy shared address space to child	for (i = PDX(UTEXT); i < PDX(UXSTACKTOP); i++) {		if (vpd[i] & PTE_P) { // If page table present			for (j = 0; j < NPTENTRIES; j++) {					pn = PGNUM(PGADDR(i, j, 0));				if (pn == PGNUM(UXSTACKTOP - PGSIZE)) {					break; // Don't map when reach uxstack				}				if ((vpt[pn] & PTE_P) && 				    (vpt[pn] & PTE_SHARE)) {					if ((r = sys_page_map(0, 							      (void *) (pn * PGSIZE), 							      child, 							      (void *) (pn * PGSIZE), 							      vpt[pn] & PTE_SYSCALL)) < 0) {			return r;		}				}						}		}	}	return 0;}

//// Custom page fault handler - if faulting page is copy-on-write,// map in our own private writable copy.//static voidpgfault(struct UTrapframe *utf){	void *addr = (void *) utf->utf_fault_va;	uint32_t err = utf->utf_err;	int r;	// 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 uvpt	//   (see <inc/memlayout.h>).    if (((err & FEC_WR) == 0) || ((uvpd[PDX(addr)] & PTE_P)==0) ||                     ((uvpt[PGNUM(addr)] & PTE_COW)==0) )            panic("Page fault in lib/fork.c!/n");	// LAB 4: Your code here.	// 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.    if ((r = sys_page_alloc(0, (void*)PFTEMP, PTE_U|PTE_P|PTE_W))  <0)                panic("alloc page error in lib/fork.c/n");    addr = ROUNDDOWN(addr, PGSIZE);    memcpy(PFTEMP, addr, PGSIZE);    if ((r = sys_page_map(0, PFTEMP, 0, addr, PTE_U|PTE_P|PTE_W)) <0)                panic("page map error in lib/fork.c/n");    if ((r = sys_page_unmap(0, PFTEMP)) <0)                panic("page unmap error in lib/fork.c/n");// LAB 4: Your code here.}

// Flush the contents of the block containing VA out to disk if// necessary, then clear the PTE_D bit using sys_page_map.// If the block is not in the block cache or is not dirty, does// nothing.// Hint: Use va_is_mapped, va_is_dirty, and ide_write.// Hint: Use the PTE_SYSCALL constant when calling sys_page_map.// Hint: Don't forget to round addr down.voidflush_block(void *addr)	{		uint64_t blockno = ((uint64_t)addr - DISKMAP) / BLKSIZE;		int r;				if (addr < (void*)DISKMAP || addr >= (void*)(DISKMAP + DISKSIZE))			panic("flush_block of bad va %08x", addr);			// LAB 5: Your code here.		//panic("flush_block not implemented");		if(va_is_mapped(addr) == false || va_is_dirty(addr) == false)		{			return;		}		addr = ROUNDDOWN(addr, PGSIZE);#ifdef VMM_GUEST		if(0 != host_write((uint32_t) (blockno * BLKSECTS), (void*)addr, BLKSECTS))		{			panic("ide read failed in Page Fault Handling");				}#else		if(0 != ide_write((uint32_t) (blockno * BLKSECTS), (void*)addr, BLKSECTS))		{			panic("ide write failed in Flush Block");			}#endif			if ((r = sys_page_map(0, addr, 0, addr, PTE_SYSCALL)) < 0)		{			panic("in flush_block, sys_page_map: %e", r);		}	}

// Copy the mappings for shared pages into the child address space.static intcopy_shared_pages(envid_t child){	// LAB 5: Your code here.	int i,j,ret;	uintptr_t addr;	envid_t curr_envid = sys_getenvid();		for(i=0;i<PDX(UTOP);i++)	{		if(uvpd[i] & PTE_P && i != PDX(UVPT))		{			addr = i << PDXSHIFT;			for(j=0;j<NPTENTRIES;j++)			{				addr = (i<<PDXSHIFT)+(j<<PGSHIFT);								if((uvpt[addr>>PGSHIFT] & PTE_P) && (uvpt[addr>>PGSHIFT] & PTE_SHARE))				{					ret = sys_page_map(curr_envid, (void *)addr, child,(void *)addr,PTE_AVAIL|PTE_P|PTE_U|PTE_W);					if(ret) panic("sys_page_map: %e", ret);					//cprintf("addr %x is shared/n",addr);				}							}		}	}