/* * lpage_fault - handle a fault on a specific lpage. If the page is * not resident, get a physical page from coremap and swap it in. * * You do not yet need to distinguish a readonly fault from a write * fault. When we implement sharing, there will be a difference. * * Synchronization: Lock the lpage while checking if it's in memory. * If it's not, unlock the page while allocting space and loading the * page in. This only works because lpages are not currently sharable. * The page should be locked again as soon as it is loaded, but be * careful of interactions with other locks while modifying the coremap. * * After it has been loaded, the page must be pinned so that it is not * evicted while changes are made to the TLB. It can be unpinned as soon * as the TLB is updated. */ int lpage_fault(struct lpage *lp, struct addrspace *as, int faulttype, vaddr_t va) { paddr_t pa = lp->lp_paddr & PAGE_FRAME; off_t swap = lp->lp_swapaddr; int writable = 0; //lock the page lpage_lock_and_pin(lp); //If the page is not in RAM, load into RAM if(pa == INVALID_PADDR) { //unlock the page if its not lpage_unlock(lp); //allocate a page and pin it pa = coremap_allocuser(lp); if(pa == INVALID_PADDR) { coremap_unpin(lp->lp_paddr & PAGE_FRAME); return ENOMEM; } //assert the page is pinned and lock KASSERT(coremap_pageispinned(pa)); lock_acquire(global_paging_lock); //fetch from disk and put in RAM swap_pagein(pa, swap); //release locks lpage_lock(lp); lock_release(global_paging_lock); //make sure nobody else paged in the page KASSERT((lp->lp_paddr & PAGE_FRAME) == INVALID_PADDR); //set the pages new phyiscal address lp->lp_paddr = pa; } if(faulttype == VM_FAULT_WRITE || faulttype == VM_FAULT_READONLY) { LP_SET(lp, LPF_DIRTY); writable = 1; } //put a mapping into the TLB /*if(coremap_pageispinned(lp->lp_paddr) == 0) { DEBUG(DB_VM, "Page is unpinned!"); }*/ mmu_map(as, va, pa, writable); lpage_unlock(lp); return 0; }
/* * lpage_fault - handle a fault on a specific lpage. If the page is * not resident, get a physical page from coremap and swap it in. * * You do not yet need to distinguish a readonly fault from a write * fault. When we implement sharing, there will be a difference. * * Synchronization: Lock the lpage while checking if it's in memory. * If it's not, unlock the page while allocting space and loading the * page in. This only works because lpages are not currently sharable. * The page should be locked again as soon as it is loaded, but be * careful of interactions with other locks while modifying the coremap. * * After it has been loaded, the page must be pinned so that it is not * evicted while changes are made to the TLB. It can be unpinned as soon * as the TLB is updated. */ int lpage_fault(struct lpage *lp, struct addrspace *as, int faulttype, vaddr_t va) { paddr_t pa, swa; /* Pin the physical page and lock the lpage. */ lpage_lock_and_pin(lp); // Get the physical address pa = lp->lp_paddr & PAGE_FRAME; // If the page is not in memeory, get it from swap if (pa == INVALID_PADDR) { swa = lp->lp_swapaddr; lpage_unlock(lp); // Have a page frame allocated pa = coremap_allocuser(lp); if (pa == INVALID_PADDR) { coremap_unpin(lp->lp_paddr & PAGE_FRAME); lpage_destroy(lp); return ENOMEM; } KASSERT(coremap_pageispinned(pa)); lock_acquire(global_paging_lock); // Add page contents from swap to physical memory swap_pagein(pa, swa); lpage_lock(lp); lock_release(global_paging_lock); /* Assert nobody else did the pagein. */ KASSERT((lp->lp_paddr & PAGE_FRAME) == INVALID_PADDR); lp->lp_paddr = pa; } //Update TLB switch (faulttype){ case VM_FAULT_READONLY: mmu_map(as, va, pa, 0); break; case VM_FAULT_READ: case VM_FAULT_WRITE: // Set it to dirty LP_SET(lp, LPF_DIRTY); mmu_map(as, va, pa, 1); } // Already unpinned in mmu_map lpage_unlock(lp); return 0; }
/* * lpage_fault - handle a fault on a specific lpage. If the page is * not resident, get a physical page from coremap and swap it in. * * You do not yet need to distinguish a readonly fault from a write * fault. When we implement sharing, there will be a difference. * * Synchronization: Lock the lpage while checking if it's in memory. * If it's not, unlock the page while allocating space and loading the * page in. This only works because lpages are not currently sharable. * The page should be locked again as soon as it is loaded, but be * careful of interactions with other locks while modifying the coremap. * * After it has been loaded, the page must be pinned so that it is not * evicted while changes are made to the TLB. It can be unpinned as soon * as the TLB is updated. */ int lpage_fault(struct lpage *lp, struct addrspace *as, int faulttype, vaddr_t va) { KASSERT(lp != NULL); // kernel pages never get paged out, thus never fault lock_acquire(global_paging_lock); if ((lp->lp_paddr & PAGE_FRAME) != INVALID_PADDR) { lpage_lock_and_pin(lp); } else { lpage_lock(lp); } lock_release(global_paging_lock); KASSERT(lp->lp_swapaddr != INVALID_SWAPADDR); paddr_t pa = lp->lp_paddr; int writable; // 0 if page is read-only, 1 if page is writable /* case 1 - minor fault: the frame is still in memory */ if ((pa & PAGE_FRAME) != INVALID_PADDR) { /* make sure it's a minor fault */ KASSERT(pa != INVALID_PADDR); /* Setting the TLB entry's dirty bit */ writable = (faulttype != VM_FAULT_READ); /* update stats */ spinlock_acquire(&stats_spinlock); ct_minfaults++; DEBUG(DB_VM, "\nlpage_fault: minor faults = %d.", ct_minfaults); spinlock_release(&stats_spinlock); } else { /* case 2 - major fault: the frame was swapped out to disk */ /* make sure it is a major fault */ KASSERT(pa == INVALID_PADDR); /* allocate a new frame */ lpage_unlock(lp); // must not hold lpage locks before entering coremap pa = coremap_allocuser(lp); // do evict if needed, also pin coremap if ((pa & PAGE_FRAME)== INVALID_PADDR) { DEBUG(DB_VM, "lpage_fault: ENOMEM: va=0x%x\n", va); return ENOMEM; } KASSERT(coremap_pageispinned(pa)); /* retrieving the content from disk */ lock_acquire(global_paging_lock); // because swap_pagein needs it swap_pagein((pa & PAGE_FRAME), lp->lp_swapaddr); // coremap is already pinned above lpage_lock(lp); lock_release(global_paging_lock); /* assert that nobody else did the pagein */ KASSERT((lp->lp_paddr & PAGE_FRAME) == INVALID_PADDR); /* now update PTE with new PFN */ lp->lp_paddr = pa ; // page is clean /* Setting the TLB entry's dirty bit */ writable = 0; // this way we can detect the first write to a page /* update stats */ spinlock_acquire(&stats_spinlock); ct_majfaults++; DEBUG(DB_VM, "\nlpage_fault: MAJOR faults = %d", ct_majfaults); spinlock_release(&stats_spinlock); } /* check preconditions before update TLB/PTE */ KASSERT(coremap_pageispinned(lp->lp_paddr)); KASSERT(spinlock_do_i_hold(&lp->lp_spinlock)); /* PTE entry is dirty if the instruction is a write */ if (writable) { LP_SET(lp, LPF_DIRTY); } /* Put the new TLB entry into the TLB */ KASSERT(coremap_pageispinned(lp->lp_paddr)); // done in both cases of above IF clause mmu_map(as, va, lp->lp_paddr, writable); // update TLB and unpin coremap lpage_unlock(lp); return 0; }