Changes in / [f126c87:2a2fbc8] in mainline

Location:

kernel

Files:

• arch/abs32le/include/arch/mm/page.h (modified) (1 diff)
• arch/amd64/include/arch/mm/page.h (modified) (1 diff)
• arch/arm32/include/arch/mm/page_armv4.h (modified) (1 diff)
• arch/arm32/include/arch/mm/page_armv6.h (modified) (1 diff)
• arch/ia32/include/arch/mm/page.h (modified) (1 diff)
• arch/ia64/src/mm/tlb.c (modified) (13 diffs)
• arch/mips32/include/arch/mm/page.h (modified) (1 diff)
• arch/mips32/src/mm/tlb.c (modified) (7 diffs)
• arch/ppc32/include/arch/mm/page.h (modified) (1 diff)
• arch/ppc32/src/mm/pht.c (modified) (3 diffs)
• arch/sparc32/include/arch/mm/page.h (modified) (1 diff)
• arch/sparc64/src/mm/sun4u/tlb.c (modified) (6 diffs)
• arch/sparc64/src/mm/sun4v/tlb.c (modified) (6 diffs)
• genarch/include/genarch/mm/page_ht.h (modified) (3 diffs)
• genarch/src/mm/as_ht.c (modified) (5 diffs)
• genarch/src/mm/page_ht.c (modified) (9 diffs)
• genarch/src/mm/page_pt.c (modified) (4 diffs)
• generic/include/mm/page.h (modified) (2 diffs)
• generic/src/ipc/ops/pagein.c (modified) (1 diff)
• generic/src/mm/as.c (modified) (6 diffs)
• generic/src/mm/backend_anon.c (modified) (1 diff)
• generic/src/mm/backend_elf.c (modified) (3 diffs)
• generic/src/mm/page.c (modified) (3 diffs)
• generic/src/synch/futex.c (modified) (2 diffs)

kernel/arch/abs32le/include/arch/mm/page.h

@@ -115 +115 @@
 /* Macros for querying the last level entries. */
 #define PTE_VALID_ARCH(p) \
-        (*((uint32_t *) (p)) != 0)
+        ((p)->soft_valid != 0)
 #define PTE_PRESENT_ARCH(p) \
         ((p)->present != 0)

kernel/arch/amd64/include/arch/mm/page.h

@@ -131 +131 @@
 /* Macros for querying the last-level PTE entries. */
 #define PTE_VALID_ARCH(p) \
-        (*((uint64_t *) (p)) != 0)
+        ((p)->soft_valid != 0)
 #define PTE_PRESENT_ARCH(p) \
         ((p)->present != 0)

kernel/arch/arm32/include/arch/mm/page_armv4.h

@@ -44 +44 @@
 /* Macros for querying the last-level PTE entries. */
 #define PTE_VALID_ARCH(pte) \
-        (*((uint32_t *) (pte)) != 0)
+        (((pte_t *) (pte))->l0.should_be_zero != 0 || PTE_PRESENT_ARCH(pte))
 #define PTE_PRESENT_ARCH(pte) \
         (((pte_t *) (pte))->l0.descriptor_type != 0)

kernel/arch/arm32/include/arch/mm/page_armv6.h

@@ -44 +44 @@
 /* Macros for querying the last-level PTE entries. */
 #define PTE_VALID_ARCH(pte) \
-        (*((uint32_t *) (pte)) != 0)
+        (((pte_t *) (pte))->l0.should_be_zero_0 != 0 || PTE_PRESENT_ARCH(pte))
 #define PTE_PRESENT_ARCH(pte) \
         (((pte_t *) (pte))->l0.descriptor_type != 0)

kernel/arch/ia32/include/arch/mm/page.h

@@ -132 +132 @@
 /* Macros for querying the last level entries. */
 #define PTE_VALID_ARCH(p) \
-        (*((uint32_t *) (p)) != 0)
+        ((p)->soft_valid != 0)
 #define PTE_PRESENT_ARCH(p) \
         ((p)->present != 0)

kernel/arch/ia64/src/mm/tlb.c

@@ -484 +484 @@
 {
         uintptr_t va;
-        pte_t *t;
+        pte_t t;
         
         va = istate->cr_ifa; /* faulting address */
@@ -490 +490 @@
         ASSERT(!is_kernel_fault(va));
 
-        t = page_mapping_find(AS, va, true);
-        if (t) {
+        bool found = page_mapping_find(AS, va, true, &t);
+        if (found) {
                 /*
                  * The mapping was found in software page hash table.
                  * Insert it into data translation cache.
                  */
-                itc_pte_copy(t);
+                itc_pte_copy(&t);
         } else {
                 /*
@@ -600 +600 @@
         
         
-        pte_t *entry = page_mapping_find(as, va, true);
-        if (entry) {
+        pte_t t;
+        bool found = page_mapping_find(as, va, true, &t);
+        if (found) {
                 /*
                  * The mapping was found in the software page hash table.
                  * Insert it into data translation cache.
                  */
-                dtc_pte_copy(entry);
+                dtc_pte_copy(&t);
         } else {
                 if (try_memmap_io_insertion(va, istate))
@@ -641 +642 @@
 {
         uintptr_t va;
-        pte_t *t;
+        pte_t t;
         as_t *as = AS;
         
@@ -649 +650 @@
                 as = AS_KERNEL;
 
-        t = page_mapping_find(as, va, true);
-        ASSERT((t) && (t->p));
-        if ((t) && (t->p) && (t->w)) {
+        bool found = page_mapping_find(as, va, true, &t);
+
+        ASSERT(found);
+        ASSERT(t.p);
+
+        if (found && t.p && t.w) {
                 /*
                  * Update the Dirty bit in page tables and reinsert
                  * the mapping into DTC.
                  */
-                t->d = true;
-                dtc_pte_copy(t);
+                t.d = true;
+                dtc_pte_copy(&t);
+                page_mapping_update(as, va, true, &t);
         } else {
                 as_page_fault(va, PF_ACCESS_WRITE, istate);
@@ -672 +677 @@
 {
         uintptr_t va;
-        pte_t *t;
+        pte_t t;
         
         va = istate->cr_ifa;  /* faulting address */
@@ -678 +683 @@
         ASSERT(!is_kernel_fault(va));
         
-        t = page_mapping_find(AS, va, true);
-        ASSERT((t) && (t->p));
-        if ((t) && (t->p) && (t->x)) {
+        bool found = page_mapping_find(AS, va, true, &t);
+
+        ASSERT(found);
+        ASSERT(t.p);
+
+        if (found && t.p && t.x) {
                 /*
                  * Update the Accessed bit in page tables and reinsert
                  * the mapping into ITC.
                  */
-                t->a = true;
-                itc_pte_copy(t);
+                t.a = true;
+                itc_pte_copy(&t);
+                page_mapping_update(AS, va, true, &t);
         } else {
                 as_page_fault(va, PF_ACCESS_EXEC, istate);
@@ -701 +710 @@
 {
         uintptr_t va;
-        pte_t *t;
+        pte_t t;
         as_t *as = AS;
         
@@ -709 +718 @@
                 as = AS_KERNEL;
 
-        t = page_mapping_find(as, va, true);
-        ASSERT((t) && (t->p));
-        if ((t) && (t->p)) {
+        bool found = page_mapping_find(as, va, true, &t);
+
+        ASSERT(found);
+        ASSERT(t.p);
+
+        if (found && t.p) {
                 /*
                  * Update the Accessed bit in page tables and reinsert
                  * the mapping into DTC.
                  */
-                t->a = true;
-                dtc_pte_copy(t);
+                t.a = true;
+                dtc_pte_copy(&t);
+                page_mapping_update(as, va, true, &t);
         } else {
                 if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
@@ -736 +749 @@
 {
         uintptr_t va;
-        pte_t *t;
+        pte_t t;
         
         va = istate->cr_ifa;  /* faulting address */
@@ -745 +758 @@
          * Assume a write to a read-only page.
          */
-        t = page_mapping_find(AS, va, true);
-        ASSERT((t) && (t->p));
-        ASSERT(!t->w);
+        bool found = page_mapping_find(AS, va, true, &t);
+
+        ASSERT(found);
+        ASSERT(t.p);
+        ASSERT(!t.w);
+
         as_page_fault(va, PF_ACCESS_WRITE, istate);
 }
@@ -760 +776 @@
 {
         uintptr_t va;
-        pte_t *t;
+        pte_t t;
         
         va = istate->cr_ifa;  /* faulting address */
@@ -766 +782 @@
         ASSERT(!is_kernel_fault(va));
 
-        t = page_mapping_find(AS, va, true);
-        ASSERT(t);
-        
-        if (t->p) {
+        bool found = page_mapping_find(AS, va, true, &t);
+
+        ASSERT(found);
+        
+        if (t.p) {
                 /*
                  * If the Present bit is set in page hash table, just copy it
                  * and update ITC/DTC.
                  */
-                if (t->x)
-                        itc_pte_copy(t);
+                if (t.x)
+                        itc_pte_copy(&t);
                 else
-                        dtc_pte_copy(t);
+                        dtc_pte_copy(&t);
         } else {
                 as_page_fault(va, PF_ACCESS_READ, istate);

kernel/arch/mips32/include/arch/mm/page.h

@@ -137 +137 @@
 
 /* Last-level info macros. */
-#define PTE_VALID_ARCH(pte)                     (*((uint32_t *) (pte)) != 0)
-#define PTE_PRESENT_ARCH(pte)                   ((pte)->p != 0)
-#define PTE_GET_FRAME_ARCH(pte)                 ((pte)->pfn << 12)
-#define PTE_WRITABLE_ARCH(pte)                  ((pte)->w != 0)
-#define PTE_EXECUTABLE_ARCH(pte)                1
+#define PTE_VALID_ARCH(pte)             ((pte)->soft_valid != 0)
+#define PTE_PRESENT_ARCH(pte)           ((pte)->p != 0)
+#define PTE_GET_FRAME_ARCH(pte)         ((pte)->pfn << 12)
+#define PTE_WRITABLE_ARCH(pte)          ((pte)->w != 0)
+#define PTE_EXECUTABLE_ARCH(pte)        1
 
 #ifndef __ASM__

kernel/arch/mips32/src/mm/tlb.c

@@ -97 +97 @@
         entry_lo_t lo;
         uintptr_t badvaddr;
-        pte_t *pte;
+        pte_t pte;
         
         badvaddr = cp0_badvaddr_read();
 
-        pte = page_mapping_find(AS, badvaddr, true);
-        if (pte && pte->p) {
+        bool found = page_mapping_find(AS, badvaddr, true, &pte);
+        if (found && pte.p) {
                 /*
                  * Record access to PTE.
                  */
-                pte->a = 1;
-
-                tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->d,
-                    pte->cacheable, pte->pfn);
+                pte.a = 1;
+
+                tlb_prepare_entry_lo(&lo, pte.g, pte.p, pte.d,
+                    pte.cacheable, pte.pfn);
+
+                page_mapping_update(AS, badvaddr, true, &pte);
 
                 /*
@@ -138 +140 @@
         tlb_index_t index;
         uintptr_t badvaddr;
-        pte_t *pte;
+        pte_t pte;
 
         /*
@@ -162 +164 @@
         badvaddr = cp0_badvaddr_read();
 
-        pte = page_mapping_find(AS, badvaddr, true);
-        if (pte && pte->p) {
+        bool found = page_mapping_find(AS, badvaddr, true, &pte);
+        if (found && pte.p) {
                 /*
                  * Read the faulting TLB entry.
@@ -172 +174 @@
                  * Record access to PTE.
                  */
-                pte->a = 1;
-
-                tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->d,
-                    pte->cacheable, pte->pfn);
+                pte.a = 1;
+
+                tlb_prepare_entry_lo(&lo, pte.g, pte.p, pte.d,
+                    pte.cacheable, pte.pfn);
+
+                page_mapping_update(AS, badvaddr, true, &pte);
 
                 /*
@@ -200 +204 @@
         tlb_index_t index;
         uintptr_t badvaddr;
-        pte_t *pte;
+        pte_t pte;
 
         badvaddr = cp0_badvaddr_read();
@@ -224 +228 @@
         }
 
-        pte = page_mapping_find(AS, badvaddr, true);
-        if (pte && pte->p && pte->w) {
+        bool found = page_mapping_find(AS, badvaddr, true, &pte);
+        if (found && pte.p && pte.w) {
                 /*
                  * Read the faulting TLB entry.
@@ -234 +238 @@
                  * Record access and write to PTE.
                  */
-                pte->a = 1;
-                pte->d = 1;
-
-                tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->w,
-                    pte->cacheable, pte->pfn);
+                pte.a = 1;
+                pte.d = 1;
+
+                tlb_prepare_entry_lo(&lo, pte.g, pte.p, pte.w,
+                    pte.cacheable, pte.pfn);
+
+                page_mapping_update(AS, badvaddr, true, &pte);
 
                 /*

kernel/arch/ppc32/include/arch/mm/page.h

@@ -140 +140 @@
 
 /* Macros for querying the last-level PTEs. */
-#define PTE_VALID_ARCH(pte)       (*((uint32_t *) (pte)) != 0)
+#define PTE_VALID_ARCH(pte)       ((pte)->valid != 0)
 #define PTE_PRESENT_ARCH(pte)     ((pte)->present != 0)
 #define PTE_GET_FRAME_ARCH(pte)   ((pte)->pfn << 12)

kernel/arch/ppc32/src/mm/pht.c

@@ -49 +49 @@
  * @param access   Access mode that caused the fault.
  * @param istate   Pointer to interrupted state.
- *
- * @return PTE on success, NULL otherwise.
- *
- */
-static pte_t *find_mapping_and_check(as_t *as, uintptr_t badvaddr, int access,
-    istate_t *istate)
+ * @param[out] pte Structure that will receive a copy of the found PTE.
+ *
+ * @return True if the mapping was found, false otherwise.
+ *
+ */
+static bool find_mapping_and_check(as_t *as, uintptr_t badvaddr, int access,
+    istate_t *istate, pte_t *pte)
 {
         /*
          * Check if the mapping exists in page tables.
          */
-        pte_t *pte = page_mapping_find(as, badvaddr, true);
-        if ((pte) && (pte->present)) {
+        bool found = page_mapping_find(as, badvaddr, true, pte);
+        if (found && pte->present) {
                 /*
                  * Mapping found in page tables.
                  * Immediately succeed.
                  */
-                return pte;
+                return true;
         }
         /*
@@ -76 +77 @@
                  * The mapping ought to be in place.
                  */
-                pte = page_mapping_find(as, badvaddr, true);
-                ASSERT((pte) && (pte->present));
-                return pte;
-        }
-
-        return NULL;
+                found = page_mapping_find(as, badvaddr, true, pte);
+
+                ASSERT(found);
+                ASSERT(pte->present);
+
+                return found;
+        }
+
+        return false;
 }
 
@@ -182 +186 @@
                 badvaddr = istate->pc;
         
-        pte_t *pte = find_mapping_and_check(AS, badvaddr,
-            PF_ACCESS_READ /* FIXME */, istate);
-        
-        if (pte) {
+        pte_t pte;
+        bool found = find_mapping_and_check(AS, badvaddr,
+            PF_ACCESS_READ /* FIXME */, istate, &pte);
+        
+        if (found) {
                 /* Record access to PTE */
-                pte->accessed = 1;
-                pht_insert(badvaddr, pte);
+                pte.accessed = 1;
+                pht_insert(badvaddr, &pte);
         }
 }

kernel/arch/sparc32/include/arch/mm/page.h

@@ -129 +129 @@
 /* Macros for querying the last level entries. */
 #define PTE_VALID_ARCH(p) \
-        (*((uint32_t *) (p)) != 0)
+        ((p)->et != PTE_ET_INVALID)
 #define PTE_PRESENT_ARCH(p) \
         ((p)->et != 0)

kernel/arch/sparc64/src/mm/sun4u/tlb.c

@@ -197 +197 @@
 {
         size_t index = (istate->tpc >> MMU_PAGE_WIDTH) % MMU_PAGES_PER_PAGE;
-        pte_t *t;
-
-        t = page_mapping_find(AS, istate->tpc, true);
-        if (t && PTE_EXECUTABLE(t)) {
+        pte_t t;
+
+        bool found = page_mapping_find(AS, istate->tpc, true, &t);
+        if (found && PTE_EXECUTABLE(&t)) {
                 /*
                  * The mapping was found in the software page hash table.
                  * Insert it into ITLB.
                  */
-                t->a = true;
-                itlb_pte_copy(t, index);
+                t.a = true;
+                itlb_pte_copy(&t, index);
 #ifdef CONFIG_TSB
-                itsb_pte_copy(t, index);
-#endif
+                itsb_pte_copy(&t, index);
+#endif
+                page_mapping_update(AS, istate->tpc, true, &t);
         } else {
                 /*
@@ -233 +234 @@
         uintptr_t page_16k;
         size_t index;
-        pte_t *t;
+        pte_t t;
         as_t *as = AS;
 
@@ -253 +254 @@
         }
 
-        t = page_mapping_find(as, page_16k, true);
-        if (t) {
+        bool found = page_mapping_find(as, page_16k, true, &t);
+        if (found) {
                 /*
                  * The mapping was found in the software page hash table.
                  * Insert it into DTLB.
                  */
-                t->a = true;
-                dtlb_pte_copy(t, index, true);
+                t.a = true;
+                dtlb_pte_copy(&t, index, true);
 #ifdef CONFIG_TSB
-                dtsb_pte_copy(t, index, true);
-#endif
+                dtsb_pte_copy(&t, index, true);
+#endif
+                page_mapping_update(as, page_16k, true, &t);
         } else {
                 /*
@@ -283 +285 @@
         uintptr_t page_16k;
         size_t index;
-        pte_t *t;
+        pte_t t;
         as_t *as = AS;
 
@@ -293 +295 @@
                 as = AS_KERNEL;
 
-        t = page_mapping_find(as, page_16k, true);
-        if (t && PTE_WRITABLE(t)) {
+        bool found = page_mapping_find(as, page_16k, true, &t);
+        if (found && PTE_WRITABLE(&t)) {
                 /*
                  * The mapping was found in the software page hash table and is
@@ -300 +302 @@
                  * into DTLB.
                  */
-                t->a = true;
-                t->d = true;
+                t.a = true;
+                t.d = true;
                 dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_SECONDARY,
                     page_16k + index * MMU_PAGE_SIZE);
-                dtlb_pte_copy(t, index, false);
+                dtlb_pte_copy(&t, index, false);
 #ifdef CONFIG_TSB
-                dtsb_pte_copy(t, index, false);
-#endif
+                dtsb_pte_copy(&t, index, false);
+#endif
+                page_mapping_update(as, page_16k, true, &t);
         } else {
                 /*

kernel/arch/sparc64/src/mm/sun4v/tlb.c

@@ -211 +211 @@
 {
         uintptr_t va = ALIGN_DOWN(istate->tpc, PAGE_SIZE);
-        pte_t *t;
-
-        t = page_mapping_find(AS, va, true);
-
-        if (t && PTE_EXECUTABLE(t)) {
+        pte_t t;
+
+        bool found = page_mapping_find(AS, va, true, &t);
+        if (found && PTE_EXECUTABLE(&t)) {
                 /*
                  * The mapping was found in the software page hash table.
                  * Insert it into ITLB.
                  */
-                t->a = true;
-                itlb_pte_copy(t);
+                t.a = true;
+                itlb_pte_copy(&t);
 #ifdef CONFIG_TSB
-                itsb_pte_copy(t);
-#endif
+                itsb_pte_copy(&t);
+#endif
+                page_mapping_update(AS, va, true, &t);
         } else {
                 /*
@@ -244 +244 @@
 void fast_data_access_mmu_miss(unsigned int tt, istate_t *istate)
 {
-        pte_t *t;
+        pte_t t;
         uintptr_t va = DMISS_ADDRESS(istate->tlb_tag_access);
         uint16_t ctx = DMISS_CONTEXT(istate->tlb_tag_access);
@@ -261 +261 @@
         }
 
-        t = page_mapping_find(as, va, true);
-        if (t) {
+        bool found = page_mapping_find(as, va, true, &t);
+        if (found) {
                 /*
                  * The mapping was found in the software page hash table.
                  * Insert it into DTLB.
                  */
-                t->a = true;
-                dtlb_pte_copy(t, true);
+                t.a = true;
+                dtlb_pte_copy(&t, true);
 #ifdef CONFIG_TSB
-                dtsb_pte_copy(t, true);
-#endif
+                dtsb_pte_copy(&t, true);
+#endif
+                page_mapping_update(as, va, true, &t);
         } else {
                 /*
@@ -288 +289 @@
 void fast_data_access_protection(unsigned int tt, istate_t *istate)
 {
-        pte_t *t;
+        pte_t t;
         uintptr_t va = DMISS_ADDRESS(istate->tlb_tag_access);
         uint16_t ctx = DMISS_CONTEXT(istate->tlb_tag_access);
@@ -296 +297 @@
                 as = AS_KERNEL;
 
-        t = page_mapping_find(as, va, true);
-        if (t && PTE_WRITABLE(t)) {
+        bool found = page_mapping_find(as, va, true, &t);
+        if (found && PTE_WRITABLE(&t)) {
                 /*
                  * The mapping was found in the software page hash table and is
@@ -303 +304 @@
                  * into DTLB.
                  */
-                t->a = true;
-                t->d = true;
+                t.a = true;
+                t.d = true;
                 mmu_demap_page(va, ctx, MMU_FLAG_DTLB);
-                dtlb_pte_copy(t, false);
+                dtlb_pte_copy(&t, false);
 #ifdef CONFIG_TSB
-                dtsb_pte_copy(t, false);
-#endif
+                dtsb_pte_copy(&t, false);
+#endif
+                page_mapping_update(as, va, true, &t);
         } else {
                 /*

kernel/genarch/include/genarch/mm/page_ht.h

@@ -44 +44 @@
 #include <mm/page.h>
 #include <mm/slab.h>
-#include <synch/mutex.h>
 #include <adt/hash_table.h>
 
@@ -55 +54 @@
 
 /* Macros for querying page hash table PTEs. */
-#define PTE_VALID(pte)       ((pte) != NULL)
+#define PTE_VALID(pte)       ((void *) (pte) != NULL)
 #define PTE_PRESENT(pte)     ((pte)->p != 0)
 #define PTE_GET_FRAME(pte)   ((pte)->frame)
@@ -66 +65 @@
 
 extern slab_cache_t *pte_cache;
-extern mutex_t page_ht_lock;
 extern hash_table_t page_ht;
 extern hash_table_operations_t ht_operations;

kernel/genarch/src/mm/as_ht.c

@@ -77 +77 @@
         if (flags & FLAG_AS_KERNEL) {
                 hash_table_create(&page_ht, PAGE_HT_ENTRIES, 2, &ht_operations);
-                mutex_initialize(&page_ht_lock, MUTEX_PASSIVE);
                 pte_cache = slab_cache_create("pte_t", sizeof(pte_t), 0,
                     NULL, NULL, SLAB_CACHE_MAGDEFERRED);
@@ -99 +98 @@
 /** Lock page table.
  *
- * Lock address space and page hash table.
+ * Lock address space.
  * Interrupts must be disabled.
  *
@@ -110 +109 @@
         if (lock)
                 mutex_lock(&as->lock);
-        
-        mutex_lock(&page_ht_lock);
 }
 
 /** Unlock page table.
  *
- * Unlock address space and page hash table.
+ * Unlock address space.
  * Interrupts must be disabled.
  *
@@ -125 +122 @@
 void ht_unlock(as_t *as, bool unlock)
 {
-        mutex_unlock(&page_ht_lock);
-        
         if (unlock)
                 mutex_unlock(&as->lock);
@@ -140 +135 @@
 bool ht_locked(as_t *as)
 {
-        return (mutex_locked(&page_ht_lock) && mutex_locked(&as->lock));
+        return mutex_locked(&as->lock);
 }
 

kernel/genarch/src/mm/page_ht.c

@@ -59 +59 @@
 static void ht_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
 static void ht_mapping_remove(as_t *, uintptr_t);
-static pte_t *ht_mapping_find(as_t *, uintptr_t, bool);
+static bool ht_mapping_find(as_t *, uintptr_t, bool, pte_t *);
+static void ht_mapping_update(as_t *, uintptr_t, bool, pte_t *);
 static void ht_mapping_make_global(uintptr_t, size_t);
 
@@ -70 +71 @@
  *
  */
-mutex_t page_ht_lock;
+IRQ_SPINLOCK_STATIC_INITIALIZE(page_ht_lock);
 
 /** Page hash table.
@@ -91 +92 @@
         .mapping_remove = ht_mapping_remove,
         .mapping_find = ht_mapping_find,
+        .mapping_update = ht_mapping_update,
         .mapping_make_global = ht_mapping_make_global
 };
@@ -191 +193 @@
 
         ASSERT(page_table_locked(as));
+
+        irq_spinlock_lock(&page_ht_lock, true);
         
         if (!hash_table_find(&page_ht, key)) {
@@ -217 +221 @@
                 hash_table_insert(&page_ht, key, &pte->link);
         }
+
+        irq_spinlock_unlock(&page_ht_lock, true);
 }
 
@@ -238 +244 @@
         ASSERT(page_table_locked(as));
         
+        irq_spinlock_lock(&page_ht_lock, true);
+
         /*
          * Note that removed PTE's will be freed
@@ -243 +251 @@
          */
         hash_table_remove(&page_ht, key, 2);
-}
-
-
-/** Find mapping for virtual page in page hash table.
- *
- * @param as     Address space to which page belongs.
- * @param page   Virtual page.
- * @param nolock True if the page tables need not be locked.
- *
- * @return NULL if there is no such mapping; requested mapping otherwise.
- *
- */
-pte_t *ht_mapping_find(as_t *as, uintptr_t page, bool nolock)
+
+        irq_spinlock_unlock(&page_ht_lock, true);
+}
+
+static pte_t *ht_mapping_find_internal(as_t *as, uintptr_t page, bool nolock)
 {
         sysarg_t key[2] = {
@@ -263 +263 @@
 
         ASSERT(nolock || page_table_locked(as));
-        
+
         link_t *cur = hash_table_find(&page_ht, key);
         if (cur)
@@ -271 +271 @@
 }
 
+/** Find mapping for virtual page in page hash table.
+ *
+ * @param as       Address space to which page belongs.
+ * @param page     Virtual page.
+ * @param nolock   True if the page tables need not be locked.
+ * @param[out] pte Structure that will receive a copy of the found PTE.
+ *
+ * @return True if the mapping was found, false otherwise.
+ */
+bool ht_mapping_find(as_t *as, uintptr_t page, bool nolock, pte_t *pte)
+{
+        irq_spinlock_lock(&page_ht_lock, true);
+
+        pte_t *t = ht_mapping_find_internal(as, page, nolock);
+        if (t)
+                *pte = *t;
+
+        irq_spinlock_unlock(&page_ht_lock, true);
+        
+        return t != NULL;
+}
+
+/** Update mapping for virtual page in page hash table.
+ *
+ * @param as       Address space to which page belongs.
+ * @param page     Virtual page.
+ * @param nolock   True if the page tables need not be locked.
+ * @param pte      New PTE.
+ */
+void ht_mapping_update(as_t *as, uintptr_t page, bool nolock, pte_t *pte)
+{
+        irq_spinlock_lock(&page_ht_lock, true);
+
+        pte_t *t = ht_mapping_find_internal(as, page, nolock);
+        if (!t)
+                panic("Updating non-existent PTE");
+        
+        ASSERT(pte->as == t->as);
+        ASSERT(pte->page == t->page);
+        ASSERT(pte->frame == t->frame);
+        ASSERT(pte->g == t->g);
+        ASSERT(pte->x == t->x);
+        ASSERT(pte->w == t->w);
+        ASSERT(pte->k == t->k);
+        ASSERT(pte->c == t->c);
+        ASSERT(pte->p == t->p);
+
+        t->a = pte->a;
+        t->d = pte->d;
+
+        irq_spinlock_unlock(&page_ht_lock, true);
+}
+
 void ht_mapping_make_global(uintptr_t base, size_t size)
 {

kernel/genarch/src/mm/page_pt.c

@@ -53 +53 @@
 static void pt_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
 static void pt_mapping_remove(as_t *, uintptr_t);
-static pte_t *pt_mapping_find(as_t *, uintptr_t, bool);
+static bool pt_mapping_find(as_t *, uintptr_t, bool, pte_t *pte);
+static void pt_mapping_update(as_t *, uintptr_t, bool, pte_t *pte);
 static void pt_mapping_make_global(uintptr_t, size_t);
 
@@ -60 +61 @@
         .mapping_remove = pt_mapping_remove,
         .mapping_find = pt_mapping_find,
+        .mapping_update = pt_mapping_update,
         .mapping_make_global = pt_mapping_make_global
 };
@@ -289 +291 @@
 }
 
-/** Find mapping for virtual page in hierarchical page tables.
- *
- * @param as     Address space to which page belongs.
- * @param page   Virtual page.
- * @param nolock True if the page tables need not be locked.
- *
- * @return NULL if there is no such mapping; entry from PTL3 describing
- *         the mapping otherwise.
- *
- */
-pte_t *pt_mapping_find(as_t *as, uintptr_t page, bool nolock)
+static pte_t *pt_mapping_find_internal(as_t *as, uintptr_t page, bool nolock)
 {
         ASSERT(nolock || page_table_locked(as));
@@ -334 +326 @@
         
         return &ptl3[PTL3_INDEX(page)];
+}
+
+/** Find mapping for virtual page in hierarchical page tables.
+ *
+ * @param as       Address space to which page belongs.
+ * @param page     Virtual page.
+ * @param nolock   True if the page tables need not be locked.
+ * @param[out] pte Structure that will receive a copy of the found PTE.
+ *
+ * @return True if the mapping was found, false otherwise.
+ */
+bool pt_mapping_find(as_t *as, uintptr_t page, bool nolock, pte_t *pte)
+{
+        pte_t *t = pt_mapping_find_internal(as, page, nolock);
+        if (t)
+                *pte = *t;
+        return t != NULL;
+}
+
+/** Update mapping for virtual page in hierarchical page tables.
+ *
+ * @param as       Address space to which page belongs.
+ * @param page     Virtual page.
+ * @param nolock   True if the page tables need not be locked.
+ * @param[in] pte  New PTE.
+ */
+void pt_mapping_update(as_t *as, uintptr_t page, bool nolock, pte_t *pte)
+{
+        pte_t *t = pt_mapping_find_internal(as, page, nolock);
+        if (!t)
+                panic("Updating non-existent PTE");     
+
+        ASSERT(PTE_VALID(t) == PTE_VALID(pte));
+        ASSERT(PTE_PRESENT(t) == PTE_PRESENT(pte));
+        ASSERT(PTE_GET_FRAME(t) == PTE_GET_FRAME(pte));
+        ASSERT(PTE_WRITABLE(t) == PTE_WRITABLE(pte));
+        ASSERT(PTE_EXECUTABLE(t) == PTE_EXECUTABLE(pte));
+
+        *t = *pte;
 }
 

kernel/generic/include/mm/page.h

@@ -48 +48 @@
         void (* mapping_insert)(as_t *, uintptr_t, uintptr_t, unsigned int);
         void (* mapping_remove)(as_t *, uintptr_t);
-        pte_t *(* mapping_find)(as_t *, uintptr_t, bool);
+        bool (* mapping_find)(as_t *, uintptr_t, bool, pte_t *);
+        void (* mapping_update)(as_t *, uintptr_t, bool, pte_t *);
         void (* mapping_make_global)(uintptr_t, size_t);
 } page_mapping_operations_t;
@@ -60 +61 @@
 extern void page_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
 extern void page_mapping_remove(as_t *, uintptr_t);
-extern pte_t *page_mapping_find(as_t *, uintptr_t, bool);
+extern bool page_mapping_find(as_t *, uintptr_t, bool, pte_t *);
+extern void page_mapping_update(as_t *, uintptr_t, bool, pte_t *);
 extern void page_mapping_make_global(uintptr_t, size_t);
 extern pte_t *page_table_create(unsigned int);

kernel/generic/src/ipc/ops/pagein.c

@@ -47 +47 @@
 {
         if (!IPC_GET_RETVAL(answer->data)) {
-                pte_t *pte;
+                pte_t pte;
                 uintptr_t frame;
 
                 page_table_lock(AS, true);
-                pte = page_mapping_find(AS, IPC_GET_ARG1(answer->data), false);
-                if (pte) {
-                        frame = PTE_GET_FRAME(pte);
+                bool found = page_mapping_find(AS, IPC_GET_ARG1(answer->data),
+                    false, &pte);
+                if (found) {
+                        frame = PTE_GET_FRAME(&pte);
                         pfn_t pfn = ADDR2PFN(frame);
                         if (find_zone(pfn, 1, 0) != (size_t) -1) {

kernel/generic/src/mm/as.c

@@ -889 +889 @@
                 
                                 for (; i < node_size; i++) {
-                                        pte_t *pte = page_mapping_find(as,
-                                            ptr + P2SZ(i), false);
+                                        pte_t pte;
+                                        bool found = page_mapping_find(as,
+                                            ptr + P2SZ(i), false, &pte);
                                         
-                                        ASSERT(pte);
-                                        ASSERT(PTE_VALID(pte));
-                                        ASSERT(PTE_PRESENT(pte));
+                                        ASSERT(found);
+                                        ASSERT(PTE_VALID(&pte));
+                                        ASSERT(PTE_PRESENT(&pte));
                                         
                                         if ((area->backend) &&
@@ -900 +901 @@
                                                 area->backend->frame_free(area,
                                                     ptr + P2SZ(i),
-                                                    PTE_GET_FRAME(pte));
+                                                    PTE_GET_FRAME(&pte));
                                         }
                                         
@@ -1003 +1004 @@
                         
                         for (size = 0; size < (size_t) node->value[i]; size++) {
-                                pte_t *pte = page_mapping_find(as,
-                                     ptr + P2SZ(size), false);
+                                pte_t pte;
+                                bool found = page_mapping_find(as,
+                                     ptr + P2SZ(size), false, &pte);
                                 
-                                ASSERT(pte);
-                                ASSERT(PTE_VALID(pte));
-                                ASSERT(PTE_PRESENT(pte));
+                                ASSERT(found);
+                                ASSERT(PTE_VALID(&pte));
+                                ASSERT(PTE_PRESENT(&pte));
                                 
                                 if ((area->backend) &&
@@ -1014 +1016 @@
                                         area->backend->frame_free(area,
                                             ptr + P2SZ(size),
-                                            PTE_GET_FRAME(pte));
+                                            PTE_GET_FRAME(&pte));
                                 }
                                 
@@ -1315 +1317 @@
                         
                         for (size = 0; size < (size_t) node->value[i]; size++) {
-                                pte_t *pte = page_mapping_find(as,
-                                    ptr + P2SZ(size), false);
+                                pte_t pte;
+                                bool found = page_mapping_find(as,
+                                    ptr + P2SZ(size), false, &pte);
                                 
-                                ASSERT(pte);
-                                ASSERT(PTE_VALID(pte));
-                                ASSERT(PTE_PRESENT(pte));
+                                ASSERT(found);
+                                ASSERT(PTE_VALID(&pte));
+                                ASSERT(PTE_PRESENT(&pte));
                                 
-                                old_frame[frame_idx++] = PTE_GET_FRAME(pte);
+                                old_frame[frame_idx++] = PTE_GET_FRAME(&pte);
                                 
                                 /* Remove old mapping */
@@ -1452 +1455 @@
          * we need to make sure the mapping has not been already inserted.
          */
-        pte_t *pte;
-        if ((pte = page_mapping_find(AS, page, false))) {
-                if (PTE_PRESENT(pte)) {
-                        if (((access == PF_ACCESS_READ) && PTE_READABLE(pte)) ||
-                            (access == PF_ACCESS_WRITE && PTE_WRITABLE(pte)) ||
-                            (access == PF_ACCESS_EXEC && PTE_EXECUTABLE(pte))) {
+        pte_t pte;
+        bool found = page_mapping_find(AS, page, false, &pte);
+        if (found) {
+                if (PTE_PRESENT(&pte)) {
+                        if (((access == PF_ACCESS_READ) && PTE_READABLE(&pte)) ||
+                            (access == PF_ACCESS_WRITE && PTE_WRITABLE(&pte)) ||
+                            (access == PF_ACCESS_EXEC && PTE_EXECUTABLE(&pte))) {
                                 page_table_unlock(AS, false);
                                 mutex_unlock(&area->lock);

kernel/generic/src/mm/backend_anon.c

@@ -131 +131 @@
                         
                         for (j = 0; j < count; j++) {
-                                pte_t *pte;
+                                pte_t pte;
+                                bool found;
                         
                                 page_table_lock(area->as, false);
-                                pte = page_mapping_find(area->as,
-                                    base + P2SZ(j), false);
-                                ASSERT(pte && PTE_VALID(pte) &&
-                                    PTE_PRESENT(pte));
+                                found = page_mapping_find(area->as,
+                                    base + P2SZ(j), false, &pte);
+
+                                ASSERT(found);
+                                ASSERT(PTE_VALID(&pte));
+                                ASSERT(PTE_PRESENT(&pte));
+
                                 btree_insert(&area->sh_info->pagemap,
                                     (base + P2SZ(j)) - area->base,
-                                    (void *) PTE_GET_FRAME(pte), NULL);
+                                    (void *) PTE_GET_FRAME(&pte), NULL);
                                 page_table_unlock(area->as, false);
 
-                                pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(pte));
+                                pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(&pte));
                                 frame_reference_add(pfn);
                         }

kernel/generic/src/mm/backend_elf.c

@@ -184 +184 @@
                         
                         for (j = 0; j < count; j++) {
-                                pte_t *pte;
+                                pte_t pte;
+                                bool found;
                         
                                 /*
@@ -196 +197 @@
                                 
                                 page_table_lock(area->as, false);
-                                pte = page_mapping_find(area->as,
-                                    base + P2SZ(j), false);
-                                ASSERT(pte && PTE_VALID(pte) &&
-                                    PTE_PRESENT(pte));
+                                found = page_mapping_find(area->as,
+                                    base + P2SZ(j), false, &pte);
+
+                                ASSERT(found);
+                                ASSERT(PTE_VALID(&pte));
+                                ASSERT(PTE_PRESENT(&pte));
+
                                 btree_insert(&area->sh_info->pagemap,
                                     (base + P2SZ(j)) - area->base,
-                                    (void *) PTE_GET_FRAME(pte), NULL);
+                                    (void *) PTE_GET_FRAME(&pte), NULL);
                                 page_table_unlock(area->as, false);
 
-                                pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(pte));
+                                pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(&pte));
                                 frame_reference_add(pfn);
                         }
@@ -335 +339 @@
                         dirty = true;
                 } else {
-                        pte_t *pte = page_mapping_find(AS_KERNEL,
-                            base + i * FRAME_SIZE, true);
-
-                        ASSERT(pte);
-                        ASSERT(PTE_PRESENT(pte));
-
-                        frame = PTE_GET_FRAME(pte);
+                        pte_t pte;
+                        bool found;
+
+                        found = page_mapping_find(AS_KERNEL,
+                            base + i * FRAME_SIZE, true, &pte);
+
+                        ASSERT(found);
+                        ASSERT(PTE_PRESENT(&pte));
+
+                        frame = PTE_GET_FRAME(&pte);
                 }       
         } else if (upage >= start_anon) {

kernel/generic/src/mm/page.c

@@ -137 +137 @@
 /** Find mapping for virtual page.
  *
- * @param as     Address space to which page belongs.
- * @param page   Virtual page.
- * @param nolock True if the page tables need not be locked.
- *
- * @return NULL if there is no such mapping; requested mapping
- *         otherwise.
- *
- */
-NO_TRACE pte_t *page_mapping_find(as_t *as, uintptr_t page, bool nolock)
+ * @param as       Address space to which page belongs.
+ * @param page     Virtual page.
+ * @param nolock   True if the page tables need not be locked.
+ * @param[out] pte Structure that will receive a copy of the found PTE.
+ *
+ * @return True if the mapping was found, false otherwise.
+ */
+NO_TRACE bool page_mapping_find(as_t *as, uintptr_t page, bool nolock,
+    pte_t *pte)
 {
         ASSERT(nolock || page_table_locked(as));
@@ -153 +153 @@
         
         return page_mapping_operations->mapping_find(as,
-            ALIGN_DOWN(page, PAGE_SIZE), nolock);
+            ALIGN_DOWN(page, PAGE_SIZE), nolock, pte);
+}
+
+/** Update mapping for virtual page.
+ *
+ * Use only to update accessed and modified/dirty bits.
+ *
+ * @param as       Address space to which page belongs.
+ * @param page     Virtual page.
+ * @param nolock   True if the page tables need not be locked.
+ * @param pte      New PTE.
+ */
+NO_TRACE void page_mapping_update(as_t *as, uintptr_t page, bool nolock,
+    pte_t *pte)
+{
+        ASSERT(nolock || page_table_locked(as));
+        
+        ASSERT(page_mapping_operations);
+        ASSERT(page_mapping_operations->mapping_find);
+        
+        page_mapping_operations->mapping_update(as,
+            ALIGN_DOWN(page, PAGE_SIZE), nolock, pte);
 }
 
@@ -173 +194 @@
         page_table_lock(AS, true);
         
-        pte_t *pte = page_mapping_find(AS, virt, false);
-        if ((!PTE_VALID(pte)) || (!PTE_PRESENT(pte))) {
+        pte_t pte;
+        bool found = page_mapping_find(AS, virt, false, &pte);
+        if (!found || !PTE_VALID(&pte) || !PTE_PRESENT(&pte)) {
                 page_table_unlock(AS, true);
                 return ENOENT;
         }
         
-        *phys = PTE_GET_FRAME(pte) +
+        *phys = PTE_GET_FRAME(&pte) +
             (virt - ALIGN_DOWN(virt, PAGE_SIZE));
         

kernel/generic/src/synch/futex.c

@@ -291 +291 @@
         spinlock_lock(&futex_ht_lock);
 
-        bool found = false;
-        pte_t *t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), true);
-        
-        if (t && PTE_VALID(t) && PTE_PRESENT(t)) {
-                found = true;
-                *paddr = PTE_GET_FRAME(t) + (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
+        bool success = false;
+
+        pte_t t;
+        bool found;
+
+        found = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), true, &t);
+        if (found && PTE_VALID(&t) && PTE_PRESENT(&t)) {
+                success = true;
+                *paddr = PTE_GET_FRAME(&t) +
+                    (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
         }
         
@@ -302 +306 @@
         page_table_unlock(AS, false);
         
-        return found;
+        return success;
 }