Changeset 2c2d54a in mainline for kernel

Timestamp:

2016-09-02T17:58:05Z (9 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

4c3602c4

Parents:

4bf0926e (diff), 3233adb (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge from lp:~jakub/helenos/pager

Location:

kernel

Files:

• Makefile (modified) (2 diffs)
• 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/ipc/ipc.h (modified) (2 diffs)
• generic/include/ipc/sysipc.h (modified) (1 diff)
• generic/include/mm/as.h (modified) (3 diffs)
• generic/include/mm/page.h (modified) (2 diffs)
• generic/src/ipc/ipc.c (modified) (4 diffs)
• generic/src/ipc/ops/pagein.c (added)
• generic/src/ipc/sysipc.c (modified) (3 diffs)
• generic/src/ipc/sysipc_ops.c (modified) (2 diffs)
• generic/src/mm/as.c (modified) (10 diffs)
• generic/src/mm/backend_anon.c (modified) (1 diff)
• generic/src/mm/backend_elf.c (modified) (3 diffs)
• generic/src/mm/backend_user.c (added)
• generic/src/mm/page.c (modified) (3 diffs)
• generic/src/synch/futex.c (modified) (2 diffs)

kernel/Makefile

@@ -237 +237 @@
         generic/src/mm/backend_elf.c \
         generic/src/mm/backend_phys.c \
+        generic/src/mm/backend_user.c \
         generic/src/mm/slab.c \
         generic/src/lib/func.c \
@@ -278 +279 @@
         generic/src/ipc/ops/datawrite.c \
         generic/src/ipc/ops/debug.c \
+        generic/src/ipc/ops/pagein.c \
         generic/src/ipc/ops/sharein.c \
         generic/src/ipc/ops/shareout.c \

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

@@ -151 +151 @@
 /* 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/ipc/ipc.h

@@ -147 +147 @@
         struct task *sender;
         
+        /*
+         * Answerbox that will receive the answer.
+         * This will most of the times be the sender's answerbox,
+         * but we allow for useful exceptions.
+         */
+        answerbox_t *callerbox;
+
         /** Phone which was used to send the call. */
         phone_t *caller_phone;
@@ -172 +179 @@
 extern void ipc_call_release(call_t *);
 
+extern int ipc_call_sync(phone_t *, call_t *);
 extern int ipc_call(phone_t *, call_t *);
 extern call_t *ipc_wait_for_call(answerbox_t *, uint32_t, unsigned int);

kernel/generic/include/ipc/sysipc.h

@@ -40 +40 @@
 #include <typedefs.h>
 
+extern int ipc_req_internal(int, ipc_data_t *);
+
 extern sysarg_t sys_ipc_call_async_fast(sysarg_t, sysarg_t, sysarg_t,
     sysarg_t, sysarg_t, sysarg_t);

kernel/generic/include/mm/as.h

@@ -169 +169 @@
 /** Backend data stored in address space area. */
 typedef union mem_backend_data {
+        /* anon_backend members */
+        struct {
+        };
+
         /** elf_backend members */
         struct {
@@ -181 +185 @@
                 bool anonymous;
         };
+
+        /** user_backend members */
+        struct {
+                as_area_pager_info_t pager_info;
+        };
+
 } mem_backend_data_t;
 
@@ -296 +306 @@
 extern mem_backend_t elf_backend;
 extern mem_backend_t phys_backend;
+extern mem_backend_t user_backend;
 
 /* Address space area related syscalls. */
-extern sysarg_t sys_as_area_create(uintptr_t, size_t, unsigned int, uintptr_t);
+extern sysarg_t sys_as_area_create(uintptr_t, size_t, unsigned int, uintptr_t,
+    as_area_pager_info_t *);
 extern sysarg_t sys_as_area_resize(uintptr_t, size_t, unsigned int);
 extern sysarg_t sys_as_area_change_flags(uintptr_t, unsigned int);

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/ipc.c

@@ -77 +77 @@
         call->forget = false;
         call->sender = NULL;
+        call->callerbox = &TASK->answerbox;
         call->buffer = NULL;
 }
@@ -185 +186 @@
         phone->state = IPC_PHONE_FREE;
         atomic_set(&phone->active_calls, 0);
+}
+
+/** Helper function to facilitate synchronous calls.
+ *
+ * @param phone   Destination kernel phone structure.
+ * @param request Call structure with request.
+ *
+ * @return EOK on success or a negative error code.
+ *
+ */
+int ipc_call_sync(phone_t *phone, call_t *request)
+{
+        answerbox_t *mybox = slab_alloc(ipc_answerbox_slab, 0);
+        ipc_answerbox_init(mybox, TASK);
+        
+        /* We will receive data in a special box. */
+        request->callerbox = mybox;
+        
+        int rc = ipc_call(phone, request);
+        if (rc != EOK) {
+                slab_free(ipc_answerbox_slab, mybox);
+                return rc;
+        }
+        // TODO: forget the call if interrupted
+        (void) ipc_wait_for_call(mybox, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
+        
+        slab_free(ipc_answerbox_slab, mybox);
+        return EOK;
 }
 
@@ -220 +249 @@
         spinlock_unlock(&call->forget_lock);
 
-        answerbox_t *callerbox = &call->sender->answerbox;
+        answerbox_t *callerbox = call->callerbox;
         bool do_lock = ((!selflocked) || (callerbox != &TASK->answerbox));
         
@@ -755 +784 @@
         ipc_cleanup_call_list(&TASK->answerbox,
             &TASK->answerbox.dispatched_calls);
-
+        
         ipc_forget_all_active_calls();
         ipc_wait_for_all_answered_calls();

kernel/generic/src/ipc/sysipc.c

@@ -106 +106 @@
 {
         switch (imethod) {
+        case IPC_M_PAGE_IN:
         case IPC_M_SHARE_OUT:
         case IPC_M_SHARE_IN:
@@ -137 +138 @@
         case IPC_M_CONNECT_TO_ME:
         case IPC_M_CONNECT_ME_TO:
+        case IPC_M_PAGE_IN:
         case IPC_M_SHARE_OUT:
         case IPC_M_SHARE_IN:
@@ -257 +259 @@
 {
         return SYSIPC_OP(request_process, call, box);
+}
+
+/** Make a call over IPC and wait for reply.
+ *
+ * @param phoneid     Phone handle for the call.
+ * @param data[inout] Structure with request/reply data.
+ *
+ * @return EOK on success.
+ * @return ENOENT if there is no such phone handle.
+ *
+ */
+int ipc_req_internal(int phoneid, ipc_data_t *data)
+{
+        phone_t *phone;
+        if (phone_get(phoneid, &phone) != EOK)
+                return ENOENT;
+        
+        call_t *call = ipc_call_alloc(0);
+        memcpy(call->data.args, data->args, sizeof(data->args));
+        
+        int rc = request_preprocess(call, phone);
+        if (!rc) {
+#ifdef CONFIG_UDEBUG
+                udebug_stoppable_begin();
+#endif
+
+                rc = ipc_call_sync(phone, call); 
+
+#ifdef CONFIG_UDEBUG
+                udebug_stoppable_end();
+#endif
+
+                if (rc != EOK)
+                        return EINTR;
+
+                process_answer(call);
+        } else
+                IPC_SET_RETVAL(call->data, rc);
+        
+        memcpy(data->args, call->data.args, sizeof(data->args));
+        ipc_call_free(call);
+        
+        return EOK;
 }
 

kernel/generic/src/ipc/sysipc_ops.c

@@ -42 +42 @@
 sysipc_ops_t ipc_m_connect_to_me_ops;
 sysipc_ops_t ipc_m_connect_me_to_ops;
+sysipc_ops_t ipc_m_page_in_ops;
 sysipc_ops_t ipc_m_share_out_ops;
 sysipc_ops_t ipc_m_share_in_ops;
@@ -54 +55 @@
         [IPC_M_CONNECT_TO_ME] = &ipc_m_connect_to_me_ops,
         [IPC_M_CONNECT_ME_TO] = &ipc_m_connect_me_to_ops,
+        [IPC_M_PAGE_IN] = &ipc_m_page_in_ops,
         [IPC_M_SHARE_OUT] = &ipc_m_share_out_ops,
         [IPC_M_SHARE_IN] = &ipc_m_share_in_ops,

kernel/generic/src/mm/as.c

@@ -574 +574 @@
  * @param backend_data NULL or a pointer to custom backend data.
  * @param base         Starting virtual address of the area.
- *                     If set to -1, a suitable mappable area is found.
- * @param bound        Lowest address bound if base is set to -1.
+ *                     If set to AS_AREA_ANY, a suitable mappable area is
+ *                     found.
+ * @param bound        Lowest address bound if base is set to AS_AREA_ANY.
  *                     Otherwise ignored.
  *
@@ -585 +586 @@
     mem_backend_data_t *backend_data, uintptr_t *base, uintptr_t bound)
 {
-        if ((*base != (uintptr_t) -1) && !IS_ALIGNED(*base, PAGE_SIZE))
+        if ((*base != (uintptr_t) AS_AREA_ANY) && !IS_ALIGNED(*base, PAGE_SIZE))
                 return NULL;
         
@@ -601 +602 @@
         mutex_lock(&as->lock);
         
-        if (*base == (uintptr_t) -1) {
+        if (*base == (uintptr_t) AS_AREA_ANY) {
                 *base = as_get_unmapped_area(as, bound, size, guarded);
                 if (*base == (uintptr_t) -1) {
@@ -888 +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) &&
@@ -899 +901 @@
                                                 area->backend->frame_free(area,
                                                     ptr + P2SZ(i),
-                                                    PTE_GET_FRAME(pte));
+                                                    PTE_GET_FRAME(&pte));
                                         }
                                         
@@ -1002 +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) &&
@@ -1013 +1016 @@
                                         area->backend->frame_free(area,
                                             ptr + P2SZ(size),
-                                            PTE_GET_FRAME(pte));
+                                            PTE_GET_FRAME(&pte));
                                 }
                                 
@@ -1314 +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 */
@@ -1451 +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);
@@ -2182 +2187 @@
 
 sysarg_t sys_as_area_create(uintptr_t base, size_t size, unsigned int flags,
-    uintptr_t bound)
+    uintptr_t bound, as_area_pager_info_t *pager_info)
 {
         uintptr_t virt = base;
+        mem_backend_t *backend;
+        mem_backend_data_t backend_data;
+
+        if (pager_info == AS_AREA_UNPAGED)
+                backend = &anon_backend;
+        else {
+                backend = &user_backend;
+                if (copy_from_uspace(&backend_data.pager_info, pager_info,
+                        sizeof(as_area_pager_info_t)) != EOK) {
+                        return (sysarg_t) AS_MAP_FAILED;
+                }
+        }
         as_area_t *area = as_area_create(AS, flags, size,
-            AS_AREA_ATTR_NONE, &anon_backend, NULL, &virt, bound);
+            AS_AREA_ATTR_NONE, backend, &backend_data, &virt, bound);
         if (area == NULL)
-                return (sysarg_t) -1;
+                return (sysarg_t) AS_MAP_FAILED;
         
         return (sysarg_t) virt;

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