Changeset c520034 in mainline for kernel/genarch/src/mm/page_pt.c

Timestamp:

2011-12-31T18:19:35Z (13 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

295f658, 77c2b02, 96cd5b4

Parents:

852052d (diff), 22f0561 (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:

Support for kernel non-identity mappings, phase I.

• identity/non-identity kernel memory split on all architectures
• low/high physical memory split on all architectures
• frame allocator understands low/high memory
• high physical memory currently unused (Phase II)
• more compact frame_t
• zone conf frames, pte_t, kernel stacks allocated from low memory
• lockless TLB-miss handlers everywhere (newly sparc64, ia64)
• preallocate PTL1 page tables for non-identity and prevent their deallocation
• hw_map() unification
• new resource allocator used for allocating kernel virtual addresses

Breakage:

• sparc64/sun4v creates too large kernel identity; not fixed because of lack of testing hw
• ppc32's tlb_refill() seems wrong as it creates too large kernel identity, but appears unused and the architecture works normally

Not implemented yet (phase II):

• allow high memory to be used for common kernel allocations

File:

• kernel/genarch/src/mm/page_pt.c (modified) (12 diffs)

kernel/genarch/src/mm/page_pt.c

@@ -39 +39 @@
 #include <mm/page.h>
 #include <mm/frame.h>
+#include <mm/km.h>
 #include <mm/as.h>
 #include <arch/mm/page.h>
@@ -45 +46 @@
 #include <arch/asm.h>
 #include <memstr.h>
+#include <align.h>
+#include <macros.h>
 
 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 void pt_mapping_make_global(uintptr_t, size_t);
 
 page_mapping_operations_t pt_mapping_operations = {
         .mapping_insert = pt_mapping_insert,
         .mapping_remove = pt_mapping_remove,
-        .mapping_find = pt_mapping_find
+        .mapping_find = pt_mapping_find,
+        .mapping_make_global = pt_mapping_make_global
 };
 
@@ -75 +80 @@
         
         if (GET_PTL1_FLAGS(ptl0, PTL0_INDEX(page)) & PAGE_NOT_PRESENT) {
-                pte_t *newpt = (pte_t *) frame_alloc(PTL1_SIZE, FRAME_KA);
+                pte_t *newpt = (pte_t *) frame_alloc(PTL1_SIZE,
+                    FRAME_LOWMEM | FRAME_KA);
                 memsetb(newpt, FRAME_SIZE << PTL1_SIZE, 0);
                 SET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page), KA2PA(newpt));
-                SET_PTL1_FLAGS(ptl0, PTL0_INDEX(page), PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE | PAGE_WRITE);
+                SET_PTL1_FLAGS(ptl0, PTL0_INDEX(page),
+                    PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE |
+                    PAGE_WRITE);
         }
         
@@ -84 +92 @@
         
         if (GET_PTL2_FLAGS(ptl1, PTL1_INDEX(page)) & PAGE_NOT_PRESENT) {
-                pte_t *newpt = (pte_t *) frame_alloc(PTL2_SIZE, FRAME_KA);
+                pte_t *newpt = (pte_t *) frame_alloc(PTL2_SIZE,
+                    FRAME_LOWMEM | FRAME_KA);
                 memsetb(newpt, FRAME_SIZE << PTL2_SIZE, 0);
                 SET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page), KA2PA(newpt));
-                SET_PTL2_FLAGS(ptl1, PTL1_INDEX(page), PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE | PAGE_WRITE);
+                SET_PTL2_FLAGS(ptl1, PTL1_INDEX(page),
+                    PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE |
+                    PAGE_WRITE);
         }
         
@@ -93 +104 @@
         
         if (GET_PTL3_FLAGS(ptl2, PTL2_INDEX(page)) & PAGE_NOT_PRESENT) {
-                pte_t *newpt = (pte_t *) frame_alloc(PTL3_SIZE, FRAME_KA);
+                pte_t *newpt = (pte_t *) frame_alloc(PTL3_SIZE,
+                    FRAME_LOWMEM | FRAME_KA);
                 memsetb(newpt, FRAME_SIZE << PTL3_SIZE, 0);
                 SET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page), KA2PA(newpt));
-                SET_PTL3_FLAGS(ptl2, PTL2_INDEX(page), PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE | PAGE_WRITE);
+                SET_PTL3_FLAGS(ptl2, PTL2_INDEX(page),
+                    PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE |
+                    PAGE_WRITE);
         }
         
@@ -123 +137 @@
         /*
          * First, remove the mapping, if it exists.
-         *
          */
         
@@ -140 +153 @@
         pte_t *ptl3 = (pte_t *) PA2KA(GET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page)));
         
-        /* Destroy the mapping. Setting to PAGE_NOT_PRESENT is not sufficient. */
+        /*
+         * Destroy the mapping.
+         * Setting to PAGE_NOT_PRESENT is not sufficient.
+         */
         memsetb(&ptl3[PTL3_INDEX(page)], sizeof(pte_t), 0);
         
         /*
-         * Second, free all empty tables along the way from PTL3 down to PTL0.
-         *
+         * Second, free all empty tables along the way from PTL3 down to PTL0
+         * except those needed for sharing the kernel non-identity mappings.
          */
         
@@ -162 +178 @@
                 /*
                  * PTL3 is empty.
-                 * Release the frame and remove PTL3 pointer from preceding table.
-                 *
-                 */
-                frame_free(KA2PA((uintptr_t) ptl3));
+                 * Release the frame and remove PTL3 pointer from the parent
+                 * table.
+                 */
 #if (PTL2_ENTRIES != 0)
                 memsetb(&ptl2[PTL2_INDEX(page)], sizeof(pte_t), 0);
@@ -171 +186 @@
                 memsetb(&ptl1[PTL1_INDEX(page)], sizeof(pte_t), 0);
 #else
+                if (km_is_non_identity(page))
+                        return;
+
                 memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
 #endif
+                frame_free(KA2PA((uintptr_t) ptl3));
         } else {
                 /*
@@ -195 +214 @@
                 /*
                  * PTL2 is empty.
-                 * Release the frame and remove PTL2 pointer from preceding table.
-                 *
-                 */
-                frame_free(KA2PA((uintptr_t) ptl2));
+                 * Release the frame and remove PTL2 pointer from the parent
+                 * table.
+                 */
 #if (PTL1_ENTRIES != 0)
                 memsetb(&ptl1[PTL1_INDEX(page)], sizeof(pte_t), 0);
 #else
+                if (km_is_non_identity(page))
+                        return;
+
                 memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
 #endif
+                frame_free(KA2PA((uintptr_t) ptl2));
         } else {
                 /*
@@ -227 +249 @@
                 /*
                  * PTL1 is empty.
-                 * Release the frame and remove PTL1 pointer from preceding table.
-                 *
-                 */
+                 * Release the frame and remove PTL1 pointer from the parent
+                 * table.
+                 */
+                if (km_is_non_identity(page))
+                        return;
+
+                memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
                 frame_free(KA2PA((uintptr_t) ptl1));
-                memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
         }
 #endif /* PTL1_ENTRIES != 0 */
@@ -267 +292 @@
 }
 
+/** Make the mappings in the given range global accross all address spaces.
+ *
+ * All PTL0 entries in the given range will be mapped to a next level page
+ * table. The next level page table will be allocated and cleared.
+ *
+ * pt_mapping_remove() will never deallocate these page tables even when there
+ * are no PTEs in them.
+ *
+ * @param as   Address space.
+ * @param base Base address corresponding to the first PTL0 entry that will be
+ *             altered by this function.
+ * @param size Size in bytes defining the range of PTL0 entries that will be
+ *             altered by this function.
+ */
+void pt_mapping_make_global(uintptr_t base, size_t size)
+{
+        uintptr_t ptl0 = PA2KA((uintptr_t) AS_KERNEL->genarch.page_table);
+        uintptr_t ptl0step = (((uintptr_t) -1) / PTL0_ENTRIES) + 1;
+        size_t order;
+        uintptr_t addr;
+
+#if (PTL1_ENTRIES != 0)
+        order = PTL1_SIZE;
+#elif (PTL2_ENTRIES != 0)
+        order = PTL2_SIZE;
+#else
+        order = PTL3_SIZE;
+#endif
+
+        ASSERT(ispwr2(ptl0step));
+
+        for (addr = ALIGN_DOWN(base, ptl0step); addr < base + size;
+            addr += ptl0step) {
+                uintptr_t l1;
+
+                l1 = (uintptr_t) frame_alloc(order, FRAME_KA | FRAME_LOWMEM);
+                memsetb((void *) l1, FRAME_SIZE << order, 0);
+                SET_PTL1_ADDRESS(ptl0, PTL0_INDEX(addr), KA2PA(l1));
+                SET_PTL1_FLAGS(ptl0, PTL0_INDEX(addr),
+                    PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE |
+                    PAGE_WRITE);
+        }
+}
+
 /** @}
  */