X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fuserprog%2Fpagedir.c;h=4604ca2ddf94b24e97f31fbd5d553b06ab3ff7c1;hb=615bf3b3d2a8573ed6fb9ddc0055745e163ac999;hp=7d1018eadde49f68711ccfbd69e6060553804352;hpb=ffea652d0433aa0818046011ae337b55f8dc3582;p=pintos-anon diff --git a/src/userprog/pagedir.c b/src/userprog/pagedir.c index 7d1018e..4604ca2 100644 --- a/src/userprog/pagedir.c +++ b/src/userprog/pagedir.c @@ -6,6 +6,9 @@ #include "threads/mmu.h" #include "threads/palloc.h" +static uint32_t *active_pd (void); +static void invalidate_pagedir (uint32_t *); + /* Creates a new page directory that has mappings for kernel virtual addresses, but none for user virtual addresses. Returns the new page directory, or a null pointer if memory @@ -13,8 +16,9 @@ uint32_t * pagedir_create (void) { - uint32_t *pd = palloc_get (0); - memcpy (pd, base_page_dir, PGSIZE); + uint32_t *pd = palloc_get_page (0); + if (pd != NULL) + memcpy (pd, base_page_dir, PGSIZE); return pd; } @@ -37,38 +41,36 @@ pagedir_destroy (uint32_t *pd) for (pte = pt; pte < pt + PGSIZE / sizeof *pte; pte++) if (*pte & PG_P) - palloc_free (pte_get_page (*pte)); - palloc_free (pt); + palloc_free_page (pte_get_page (*pte)); + palloc_free_page (pt); } - palloc_free (pd); + palloc_free_page (pd); } -/* Returns the mapping of user virtual address UADDR in page - directory PD into a kernel virtual address. - If UADDR is unmapped, behavior varies based on CREATE: - if CREATE is true, then a new, zeroed page is created and a - pointer into it is returned, - otherwise a null pointer is returned. - Also returns a null pointer if UADDR is a kernel address. */ +/* Returns the address of the page table entry for virtual + address VADDR in page directory PD. + If PD does not have a page table for VADDR, behavior depends + on CREATE. If CREATE is true, then a new page table is + created and a pointer into it is returned. Otherwise, a null + pointer is returned. */ static uint32_t * -lookup_page (uint32_t *pd, void *uaddr, bool create) +lookup_page (uint32_t *pd, const void *vaddr, bool create) { uint32_t *pt, *pde; ASSERT (pd != NULL); - /* Make sure it's a user address. */ - if (uaddr >= PHYS_BASE) - return NULL; + /* Shouldn't create new kernel virtual mappings. */ + ASSERT (!create || is_user_vaddr (vaddr)); - /* Check for a page table for UADDR. + /* Check for a page table for VADDR. If one is missing, create one if requested. */ - pde = pd + pd_no (uaddr); + pde = pd + pd_no (vaddr); if (*pde == 0) { if (create) { - pt = palloc_get (PAL_ZERO); + pt = palloc_get_page (PAL_ZERO); if (pt == NULL) return NULL; @@ -80,11 +82,11 @@ lookup_page (uint32_t *pd, void *uaddr, bool create) /* Return the page table entry. */ pt = pde_get_pt (*pde); - return &pt[pt_no (uaddr)]; + return &pt[pt_no (vaddr)]; } -/* Adds a mapping from user virtual address UPAGE to kernel - virtual address KPAGE in page directory PD. +/* Adds a mapping from user virtual page UPAGE to kernel virtual + address KPAGE in page directory PD. UPAGE must not already be mapped. If WRITABLE is true, the new page is read/write; otherwise it is read-only. @@ -98,12 +100,15 @@ pagedir_set_page (uint32_t *pd, void *upage, void *kpage, ASSERT (pg_ofs (upage) == 0); ASSERT (pg_ofs (kpage) == 0); - ASSERT (upage < PHYS_BASE); - ASSERT (pagedir_get_page (pd, upage) == NULL); + ASSERT (is_user_vaddr (upage)); + ASSERT (vtop (kpage) >> PTSHIFT < ram_pages); + ASSERT (pd != base_page_dir); pte = lookup_page (pd, upage, true); + if (pte != NULL) { + ASSERT ((*pte & PG_P) == 0); *pte = pte_create_user (kpage, writable); return true; } @@ -112,13 +117,98 @@ pagedir_set_page (uint32_t *pd, void *upage, void *kpage, } /* Returns the kernel virtual address that user virtual address - UADDR is mapped to in PD, or a null pointer if there is no - mapping. */ + UADDR is mapped to in PD, or a null pointer if UADDR is not + present. */ void * pagedir_get_page (uint32_t *pd, const void *uaddr) { - uint32_t *pte = lookup_page (pd, (void *) uaddr, false); - return pte != NULL && *pte != 0 ? pte_get_page (*pte) : NULL; + uint32_t *pte; + + ASSERT (is_user_vaddr (uaddr)); + + pte = lookup_page (pd, uaddr, false); + if (pte != NULL && (*pte & PG_P) != 0) + return pte_get_page (*pte) + pg_ofs (uaddr); + else + return NULL; +} + +/* Marks user virtual page UPAGE "not present" in page + directory PD. Later accesses to the page will fault. Other + bits in the page table entry are preserved. + UPAGE need not be mapped. */ +void +pagedir_clear_page (uint32_t *pd, void *upage) +{ + uint32_t *pte; + + ASSERT (pg_ofs (upage) == 0); + ASSERT (is_user_vaddr (upage)); + + pte = lookup_page (pd, upage, false); + if (pte != NULL && (*pte & PG_P) != 0) + { + *pte &= ~PG_P; + invalidate_pagedir (pd); + } +} + +/* Returns true if the PTE for virtual page VPAGE in PD is dirty, + that is, if the page has been modified since the PTE was + installed. + Returns false if PD contains no PTE for VPAGE. */ +bool +pagedir_is_dirty (uint32_t *pd, const void *vpage) +{ + uint32_t *pte = lookup_page (pd, vpage, false); + return pte != NULL && (*pte & PG_D) != 0; +} + +/* Set the dirty bit to DIRTY in the PTE for virtual page VPAGE + in PD. */ +void +pagedir_set_dirty (uint32_t *pd, const void *vpage, bool dirty) +{ + uint32_t *pte = lookup_page (pd, vpage, false); + if (pte != NULL) + { + if (dirty) + *pte |= PG_D; + else + { + *pte &= ~(uint32_t) PG_D; + invalidate_pagedir (pd); + } + } +} + +/* Returns true if the PTE for virtual page VPAGE in PD has been + accessed recently, that is, between the time the PTE was + installed and the last time it was cleared. Returns false if + PD contains no PTE for VPAGE. */ +bool +pagedir_is_accessed (uint32_t *pd, const void *vpage) +{ + uint32_t *pte = lookup_page (pd, vpage, false); + return pte != NULL && (*pte & PG_A) != 0; +} + +/* Sets the accessed bit to ACCESSED in the PTE for virtual page + VPAGE in PD. */ +void +pagedir_set_accessed (uint32_t *pd, const void *vpage, bool accessed) +{ + uint32_t *pte = lookup_page (pd, vpage, false); + if (pte != NULL) + { + if (accessed) + *pte |= PG_A; + else + { + *pte &= ~(uint32_t) PG_A; + invalidate_pagedir (pd); + } + } } /* Loads page directory PD into the CPU's page directory base @@ -128,5 +218,43 @@ pagedir_activate (uint32_t *pd) { if (pd == NULL) pd = base_page_dir; - asm volatile ("movl %0,%%cr3" :: "r" (vtop (pd))); + + /* Store the physical address of the page directory into CR3 + aka PDBR (page directory base register). This activates our + new page tables immediately. See [IA32-v2a] "MOV--Move + to/from Control Registers" and [IA32-v3] 3.7.5. */ + asm volatile ("mov %%cr3, %0" :: "r" (vtop (pd))); +} + +/* Returns the currently active page directory. */ +static uint32_t * +active_pd (void) +{ + /* Copy CR3, the page directory base register (PDBR), into + `pd'. + See [IA32-v2a] "MOV--Move to/from Control Registers" and + [IA32-v3] 3.7.5. */ + uintptr_t pd; + asm volatile ("mov %0, %%cr3" : "=r" (pd)); + return ptov (pd); +} + +/* Seom page table changes can cause the CPU's translation + lookaside buffer (TLB) to become out-of-sync with the page + table. When this happens, we have to "invalidate" the TLB by + re-activating it. + + This function invalidates the TLB if PD is the active page + directory. (If PD is not active then its entries are not in + the TLB, so there is no need to invalidate anything.) */ +static void +invalidate_pagedir (uint32_t *pd) +{ + if (active_pd () == pd) + { + /* We cleared a page-table entry in the active page + table, so we have to invalidate the TLB. See + [IA32-v3], section 3.11. */ + pagedir_activate (pd); + } }