Changeset b7068da in mainline for kernel/generic/src/mm

Timestamp:

2012-02-09T20:35:12Z (14 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

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

Children:

591762c6

Parents:

7cede12c (diff), 3d4750f (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 mainline changes

Location:

kernel/generic/src/mm

Files:

• as.c (modified) (12 diffs)
• backend_anon.c (modified) (7 diffs)
• backend_elf.c (modified) (12 diffs)
• frame.c (modified) (22 diffs)
• km.c (added)
• page.c (modified) (4 diffs)
• reserve.c (modified) (5 diffs)

kernel/generic/src/mm/as.c

@@ -387 +387 @@
 }
 
+/** Return pointer to unmapped address space area
+ *
+ * The address space must be already locked when calling
+ * this function.
+ *
+ * @param as    Address space.
+ * @param bound Lowest address bound.
+ * @param size  Requested size of the allocation.
+ *
+ * @return Address of the beginning of unmapped address space area.
+ * @return -1 if no suitable address space area was found.
+ *
+ */
+NO_TRACE static uintptr_t as_get_unmapped_area(as_t *as, uintptr_t bound,
+    size_t size)
+{
+        ASSERT(mutex_locked(&as->lock));
+        
+        if (size == 0)
+                return (uintptr_t) -1;
+        
+        /*
+         * Make sure we allocate from page-aligned
+         * address. Check for possible overflow in
+         * each step.
+         */
+        
+        size_t pages = SIZE2FRAMES(size);
+        
+        /*
+         * Find the lowest unmapped address aligned on the size
+         * boundary, not smaller than bound and of the required size.
+         */
+        
+        /* First check the bound address itself */
+        uintptr_t addr = ALIGN_UP(bound, PAGE_SIZE);
+        if ((addr >= bound) &&
+            (check_area_conflicts(as, addr, pages, NULL)))
+                return addr;
+        
+        /* Eventually check the addresses behind each area */
+        list_foreach(as->as_area_btree.leaf_list, cur) {
+                btree_node_t *node =
+                    list_get_instance(cur, btree_node_t, leaf_link);
+                
+                for (btree_key_t i = 0; i < node->keys; i++) {
+                        as_area_t *area = (as_area_t *) node->value[i];
+                        
+                        mutex_lock(&area->lock);
+                        
+                        addr =
+                            ALIGN_UP(area->base + P2SZ(area->pages), PAGE_SIZE);
+                        bool avail =
+                            ((addr >= bound) && (addr >= area->base) &&
+                            (check_area_conflicts(as, addr, pages, area)));
+                        
+                        mutex_unlock(&area->lock);
+                        
+                        if (avail)
+                                return addr;
+                }
+        }
+        
+        /* No suitable address space area found */
+        return (uintptr_t) -1;
+}
+
 /** Create address space area of common attributes.
  *
@@ -394 +461 @@
  * @param flags        Flags of the area memory.
  * @param size         Size of area.
- * @param base         Base address of area.
  * @param attrs        Attributes of the area.
  * @param backend      Address space area backend. NULL if no backend is used.
  * @param backend_data NULL or a pointer to an array holding two void *.
+ * @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.
+ *                     Otherwise ignored.
  *
  * @return Address space area on success or NULL on failure.
@@ -403 +473 @@
  */
 as_area_t *as_area_create(as_t *as, unsigned int flags, size_t size,
-    uintptr_t base, unsigned int attrs, mem_backend_t *backend,
-    mem_backend_data_t *backend_data)
-{
-        if ((base % PAGE_SIZE) != 0)
+    unsigned int attrs, mem_backend_t *backend,
+    mem_backend_data_t *backend_data, uintptr_t *base, uintptr_t bound)
+{
+        if ((*base != (uintptr_t) -1) && ((*base % PAGE_SIZE) != 0))
                 return NULL;
         
@@ -420 +490 @@
         mutex_lock(&as->lock);
         
-        if (!check_area_conflicts(as, base, pages, NULL)) {
+        if (*base == (uintptr_t) -1) {
+                *base = as_get_unmapped_area(as, bound, size);
+                if (*base == (uintptr_t) -1) {
+                        mutex_unlock(&as->lock);
+                        return NULL;
+                }
+        }
+        
+        if (!check_area_conflicts(as, *base, pages, NULL)) {
                 mutex_unlock(&as->lock);
                 return NULL;
@@ -434 +512 @@
         area->pages = pages;
         area->resident = 0;
-        area->base = base;
+        area->base = *base;
         area->sh_info = NULL;
         area->backend = backend;
@@ -452 +530 @@
         
         btree_create(&area->used_space);
-        btree_insert(&as->as_area_btree, base, (void *) area, NULL);
+        btree_insert(&as->as_area_btree, *base, (void *) area,
+            NULL);
         
         mutex_unlock(&as->lock);
@@ -860 +939 @@
  * @param acc_size       Expected size of the source area.
  * @param dst_as         Pointer to destination address space.
- * @param dst_base       Target base address.
  * @param dst_flags_mask Destination address space area flags mask.
+ * @param dst_base       Target base address. If set to -1,
+ *                       a suitable mappable area is found.
+ * @param bound          Lowest address bound if dst_base is set to -1.
+ *                       Otherwise ignored.
  *
  * @return Zero on success.
@@ -873 +955 @@
  */
 int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size,
-    as_t *dst_as, uintptr_t dst_base, unsigned int dst_flags_mask)
+    as_t *dst_as, unsigned int dst_flags_mask, uintptr_t *dst_base,
+    uintptr_t bound)
 {
         mutex_lock(&src_as->lock);
@@ -945 +1028 @@
          * to support sharing in less privileged mode.
          */
-        as_area_t *dst_area = as_area_create(dst_as, dst_flags_mask, src_size,
-            dst_base, AS_AREA_ATTR_PARTIAL, src_backend, &src_backend_data);
+        as_area_t *dst_area = as_area_create(dst_as, dst_flags_mask,
+            src_size, AS_AREA_ATTR_PARTIAL, src_backend,
+            &src_backend_data, dst_base, bound);
         if (!dst_area) {
                 /*
@@ -1955 +2039 @@
  */
 
-/** Wrapper for as_area_create(). */
-sysarg_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)
-{
-        if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address,
-            AS_AREA_ATTR_NONE, &anon_backend, NULL))
-                return (sysarg_t) address;
-        else
+sysarg_t sys_as_area_create(uintptr_t base, size_t size, unsigned int flags,
+    uintptr_t bound)
+{
+        uintptr_t virt = base;
+        as_area_t *area = as_area_create(AS, flags | AS_AREA_CACHEABLE, size,
+            AS_AREA_ATTR_NONE, &anon_backend, NULL, &virt, bound);
+        if (area == NULL)
                 return (sysarg_t) -1;
-}
-
-/** Wrapper for as_area_resize(). */
+        
+        return (sysarg_t) virt;
+}
+
 sysarg_t sys_as_area_resize(uintptr_t address, size_t size, unsigned int flags)
 {
@@ -1971 +2056 @@
 }
 
-/** Wrapper for as_area_change_flags(). */
 sysarg_t sys_as_area_change_flags(uintptr_t address, unsigned int flags)
 {
@@ -1977 +2061 @@
 }
 
-/** Wrapper for as_area_destroy(). */
 sysarg_t sys_as_area_destroy(uintptr_t address)
 {
         return (sysarg_t) as_area_destroy(AS, address);
-}
-
-/** Return pointer to unmapped address space area
- *
- * @param base Lowest address bound.
- * @param size Requested size of the allocation.
- *
- * @return Pointer to the beginning of unmapped address space area.
- *
- */
-sysarg_t sys_as_get_unmapped_area(uintptr_t base, size_t size)
-{
-        if (size == 0)
-                return 0;
-        
-        /*
-         * Make sure we allocate from page-aligned
-         * address. Check for possible overflow in
-         * each step.
-         */
-        
-        size_t pages = SIZE2FRAMES(size);
-        uintptr_t ret = 0;
-        
-        /*
-         * Find the lowest unmapped address aligned on the sz
-         * boundary, not smaller than base and of the required size.
-         */
-        
-        mutex_lock(&AS->lock);
-        
-        /* First check the base address itself */
-        uintptr_t addr = ALIGN_UP(base, PAGE_SIZE);
-        if ((addr >= base) &&
-            (check_area_conflicts(AS, addr, pages, NULL)))
-                ret = addr;
-        
-        /* Eventually check the addresses behind each area */
-        list_foreach(AS->as_area_btree.leaf_list, cur) {
-                if (ret != 0)
-                        break;
-
-                btree_node_t *node =
-                    list_get_instance(cur, btree_node_t, leaf_link);
-                
-                btree_key_t i;
-                for (i = 0; (ret == 0) && (i < node->keys); i++) {
-                        uintptr_t addr;
-
-                        as_area_t *area = (as_area_t *) node->value[i];
-                        
-                        mutex_lock(&area->lock);
-                        
-                        addr = ALIGN_UP(area->base + P2SZ(area->pages),
-                            PAGE_SIZE);
-                        
-                        if ((addr >= base) && (addr >= area->base) &&
-                            (check_area_conflicts(AS, addr, pages, area)))
-                                ret = addr;
-                        
-                        mutex_unlock(&area->lock);
-                }
-        }
-        
-        mutex_unlock(&AS->lock);
-        
-        return (sysarg_t) ret;
 }
 

kernel/generic/src/mm/backend_anon.c

@@ -44 +44 @@
 #include <mm/frame.h>
 #include <mm/slab.h>
+#include <mm/km.h>
 #include <synch/mutex.h>
 #include <adt/list.h>
@@ -155 +156 @@
 int anon_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
 {
+        uintptr_t upage = ALIGN_DOWN(addr, PAGE_SIZE);
+        uintptr_t kpage;
         uintptr_t frame;
 
@@ -175 +178 @@
                 mutex_lock(&area->sh_info->lock);
                 frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
-                    ALIGN_DOWN(addr, PAGE_SIZE) - area->base, &leaf);
+                    upage - area->base, &leaf);
                 if (!frame) {
                         bool allocate = true;
@@ -185 +188 @@
                          */
                         for (i = 0; i < leaf->keys; i++) {
-                                if (leaf->key[i] ==
-                                    ALIGN_DOWN(addr, PAGE_SIZE) - area->base) {
+                                if (leaf->key[i] == upage - area->base) {
                                         allocate = false;
                                         break;
@@ -192 +194 @@
                         }
                         if (allocate) {
-                                frame = (uintptr_t) frame_alloc_noreserve(
-                                    ONE_FRAME, 0);
-                                memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
+                                kpage = km_temporary_page_get(&frame,
+                                    FRAME_NO_RESERVE);
+                                memsetb((void *) kpage, PAGE_SIZE, 0);
+                                km_temporary_page_put(kpage);
                                 
                                 /*
@@ -201 +204 @@
                                  */
                                 btree_insert(&area->sh_info->pagemap,
-                                    ALIGN_DOWN(addr, PAGE_SIZE) - area->base,
-                                    (void *) frame, leaf);
+                                    upage - area->base, (void *) frame, leaf);
                         }
                 }
@@ -223 +225 @@
                  *   the different causes
                  */
-                frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME, 0);
-                memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
+                kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
+                memsetb((void *) kpage, PAGE_SIZE, 0);
+                km_temporary_page_put(kpage);
         }
         
         /*
-         * Map 'page' to 'frame'.
+         * Map 'upage' to 'frame'.
          * Note that TLB shootdown is not attempted as only new information is
          * being inserted into page tables.
          */
-        page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
-        if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
+        page_mapping_insert(AS, upage, frame, as_area_get_flags(area));
+        if (!used_space_insert(area, upage, 1))
                 panic("Cannot insert used space.");
                 

kernel/generic/src/mm/backend_elf.c

@@ -44 +44 @@
 #include <mm/page.h>
 #include <mm/reserve.h>
+#include <mm/km.h>
 #include <genarch/mm/page_pt.h>
 #include <genarch/mm/page_ht.h>
@@ -229 +230 @@
         elf_segment_header_t *entry = area->backend_data.segment;
         btree_node_t *leaf;
-        uintptr_t base, frame, page, start_anon;
+        uintptr_t base;
+        uintptr_t frame;
+        uintptr_t kpage;
+        uintptr_t upage;
+        uintptr_t start_anon;
         size_t i;
         bool dirty = false;
@@ -249 +254 @@
             (((void *) elf) + ALIGN_DOWN(entry->p_offset, PAGE_SIZE));
 
-        /* Virtual address of faulting page*/
-        page = ALIGN_DOWN(addr, PAGE_SIZE);
+        /* Virtual address of faulting page */
+        upage = ALIGN_DOWN(addr, PAGE_SIZE);
 
         /* Virtual address of the end of initialized part of segment */
@@ -264 +269 @@
                 mutex_lock(&area->sh_info->lock);
                 frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
-                    page - area->base, &leaf);
+                    upage - area->base, &leaf);
                 if (!frame) {
                         unsigned int i;
@@ -273 +278 @@
 
                         for (i = 0; i < leaf->keys; i++) {
-                                if (leaf->key[i] == page - area->base) {
+                                if (leaf->key[i] == upage - area->base) {
                                         found = true;
                                         break;
@@ -281 +286 @@
                 if (frame || found) {
                         frame_reference_add(ADDR2PFN(frame));
-                        page_mapping_insert(AS, addr, frame,
+                        page_mapping_insert(AS, upage, frame,
                             as_area_get_flags(area));
-                        if (!used_space_insert(area, page, 1))
+                        if (!used_space_insert(area, upage, 1))
                                 panic("Cannot insert used space.");
                         mutex_unlock(&area->sh_info->lock);
@@ -294 +299 @@
          * mapping.
          */
-        if (page >= entry->p_vaddr && page + PAGE_SIZE <= start_anon) {
+        if (upage >= entry->p_vaddr && upage + PAGE_SIZE <= start_anon) {
                 /*
                  * Initialized portion of the segment. The memory is backed
@@ -304 +309 @@
                  */
                 if (entry->p_flags & PF_W) {
-                        frame = (uintptr_t)frame_alloc_noreserve(ONE_FRAME, 0);
-                        memcpy((void *) PA2KA(frame),
-                            (void *) (base + i * FRAME_SIZE), FRAME_SIZE);
+                        kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
+                        memcpy((void *) kpage, (void *) (base + i * PAGE_SIZE),
+                            PAGE_SIZE);
                         if (entry->p_flags & PF_X) {
-                                smc_coherence_block((void *) PA2KA(frame),
-                                    FRAME_SIZE);
+                                smc_coherence_block((void *) kpage, PAGE_SIZE);
                         }
+                        km_temporary_page_put(kpage);
                         dirty = true;
                 } else {
-                        frame = KA2PA(base + i * FRAME_SIZE);
+                        pte_t *pte = page_mapping_find(AS_KERNEL,
+                            base + i * FRAME_SIZE, true);
+
+                        ASSERT(pte);
+                        ASSERT(PTE_PRESENT(pte));
+
+                        frame = PTE_GET_FRAME(pte);
                 }       
-        } else if (page >= start_anon) {
+        } else if (upage >= start_anon) {
                 /*
                  * This is the uninitialized portion of the segment.
@@ -322 +333 @@
                  * and cleared.
                  */
-                frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME, 0);
-                memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
+                kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
+                memsetb((void *) kpage, PAGE_SIZE, 0);
+                km_temporary_page_put(kpage);
                 dirty = true;
         } else {
@@ -334 +346 @@
                  * (The segment can be and often is shorter than 1 page).
                  */
-                if (page < entry->p_vaddr)
-                        pad_lo = entry->p_vaddr - page;
+                if (upage < entry->p_vaddr)
+                        pad_lo = entry->p_vaddr - upage;
                 else
                         pad_lo = 0;
 
-                if (start_anon < page + PAGE_SIZE)
-                        pad_hi = page + PAGE_SIZE - start_anon;
+                if (start_anon < upage + PAGE_SIZE)
+                        pad_hi = upage + PAGE_SIZE - start_anon;
                 else
                         pad_hi = 0;
 
-                frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME, 0);
-                memcpy((void *) (PA2KA(frame) + pad_lo),
-                    (void *) (base + i * FRAME_SIZE + pad_lo),
-                    FRAME_SIZE - pad_lo - pad_hi);
+                kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
+                memcpy((void *) (kpage + pad_lo),
+                    (void *) (base + i * PAGE_SIZE + pad_lo),
+                    PAGE_SIZE - pad_lo - pad_hi);
                 if (entry->p_flags & PF_X) {
-                        smc_coherence_block((void *) (PA2KA(frame) + pad_lo), 
-                            FRAME_SIZE - pad_lo - pad_hi);
+                        smc_coherence_block((void *) (kpage + pad_lo), 
+                            PAGE_SIZE - pad_lo - pad_hi);
                 }
-                memsetb((void *) PA2KA(frame), pad_lo, 0);
-                memsetb((void *) (PA2KA(frame) + FRAME_SIZE - pad_hi), pad_hi,
-                    0);
+                memsetb((void *) kpage, pad_lo, 0);
+                memsetb((void *) (kpage + PAGE_SIZE - pad_hi), pad_hi, 0);
+                km_temporary_page_put(kpage);
                 dirty = true;
         }
@@ -360 +372 @@
         if (dirty && area->sh_info) {
                 frame_reference_add(ADDR2PFN(frame));
-                btree_insert(&area->sh_info->pagemap, page - area->base,
+                btree_insert(&area->sh_info->pagemap, upage - area->base,
                     (void *) frame, leaf);
         }
@@ -367 +379 @@
                 mutex_unlock(&area->sh_info->lock);
 
-        page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
-        if (!used_space_insert(area, page, 1))
+        page_mapping_insert(AS, upage, frame, as_area_get_flags(area));
+        if (!used_space_insert(area, upage, 1))
                 panic("Cannot insert used space.");
 

kernel/generic/src/mm/frame.c

@@ -240 +240 @@
 NO_TRACE static bool zone_can_alloc(zone_t *zone, uint8_t order)
 {
-        return (zone_flags_available(zone->flags)
-            && buddy_system_can_alloc(zone->buddy_system, order));
+        return ((zone->flags & ZONE_AVAILABLE) &&
+            buddy_system_can_alloc(zone->buddy_system, order));
 }
 
@@ -265 +265 @@
                  * Check whether the zone meets the search criteria.
                  */
-                if ((zones.info[i].flags & flags) == flags) {
+                if (ZONE_FLAGS_MATCH(zones.info[i].flags, flags)) {
                         /*
                          * Check if the zone has 2^order frames area available.
@@ -460 +460 @@
 NO_TRACE static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order)
 {
-        ASSERT(zone_flags_available(zone->flags));
+        ASSERT(zone->flags & ZONE_AVAILABLE);
         
         /* Allocate frames from zone buddy system */
@@ -490 +490 @@
 NO_TRACE static size_t zone_frame_free(zone_t *zone, size_t frame_idx)
 {
-        ASSERT(zone_flags_available(zone->flags));
+        ASSERT(zone->flags & ZONE_AVAILABLE);
         
         frame_t *frame = &zone->frames[frame_idx];
@@ -518 +518 @@
 NO_TRACE static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)
 {
-        ASSERT(zone_flags_available(zone->flags));
+        ASSERT(zone->flags & ZONE_AVAILABLE);
         
         frame_t *frame = zone_get_frame(zone, frame_idx);
@@ -549 +549 @@
     buddy_system_t *buddy)
 {
-        ASSERT(zone_flags_available(zones.info[z1].flags));
-        ASSERT(zone_flags_available(zones.info[z2].flags));
+        ASSERT(zones.info[z1].flags & ZONE_AVAILABLE);
+        ASSERT(zones.info[z2].flags & ZONE_AVAILABLE);
         ASSERT(zones.info[z1].flags == zones.info[z2].flags);
         ASSERT(zones.info[z1].base < zones.info[z2].base);
@@ -645 +645 @@
 NO_TRACE static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
 {
-        ASSERT(zone_flags_available(zones.info[znum].flags));
+        ASSERT(zones.info[znum].flags & ZONE_AVAILABLE);
         
         size_t cframes = SIZE2FRAMES(zone_conf_size(count));
@@ -681 +681 @@
     size_t count)
 {
-        ASSERT(zone_flags_available(zones.info[znum].flags));
+        ASSERT(zones.info[znum].flags & ZONE_AVAILABLE);
         ASSERT(frame_idx + count < zones.info[znum].count);
         
@@ -723 +723 @@
          * set of flags
          */
-        if ((z1 >= zones.count) || (z2 >= zones.count)
-            || (z2 - z1 != 1)
-            || (!zone_flags_available(zones.info[z1].flags))
-            || (!zone_flags_available(zones.info[z2].flags))
-            || (zones.info[z1].flags != zones.info[z2].flags)) {
+        if ((z1 >= zones.count) || (z2 >= zones.count) || (z2 - z1 != 1) ||
+            (zones.info[z1].flags != zones.info[z2].flags)) {
                 ret = false;
                 goto errout;
@@ -828 +825 @@
         zone->buddy_system = buddy;
         
-        if (zone_flags_available(flags)) {
+        if (flags & ZONE_AVAILABLE) {
                 /*
                  * Compute order for buddy system and initialize
@@ -865 +862 @@
 {
         return (count * sizeof(frame_t) + buddy_conf_size(fnzb(count)));
+}
+
+/** Allocate external configuration frames from low memory. */
+pfn_t zone_external_conf_alloc(size_t count)
+{
+        size_t size = zone_conf_size(count);
+        size_t order = ispwr2(size) ? fnzb(size) : (fnzb(size) + 1);
+
+        return ADDR2PFN((uintptr_t) frame_alloc(order - FRAME_WIDTH,
+            FRAME_LOWMEM | FRAME_ATOMIC));
 }
 
@@ -888 +895 @@
         irq_spinlock_lock(&zones.lock, true);
         
-        if (zone_flags_available(flags)) {  /* Create available zone */
+        if (flags & ZONE_AVAILABLE) {  /* Create available zone */
                 /* Theoretically we could have NULL here, practically make sure
                  * nobody tries to do that. If some platform requires, remove
@@ -894 +901 @@
                  */
                 ASSERT(confframe != ADDR2PFN((uintptr_t ) NULL));
+
+                /* Update the known end of physical memory. */
+                config.physmem_end = max(config.physmem_end, PFN2ADDR(start + count));
                 
                 /* If confframe is supposed to be inside our zone, then make sure
@@ -914 +924 @@
                                 for (i = 0; i < init.cnt; i++)
                                         if (overlaps(addr, PFN2ADDR(confcount),
-                                            KA2PA(init.tasks[i].addr),
+                                            init.tasks[i].paddr,
                                             init.tasks[i].size)) {
                                                 overlap = true;
@@ -1232 +1242 @@
         
         /* Tell the architecture to create some memory */
-        frame_arch_init();
+        frame_low_arch_init();
         if (config.cpu_active == 1) {
                 frame_mark_unavailable(ADDR2PFN(KA2PA(config.base)),
@@ -1241 +1251 @@
                 size_t i;
                 for (i = 0; i < init.cnt; i++) {
-                        pfn_t pfn = ADDR2PFN(KA2PA(init.tasks[i].addr));
+                        pfn_t pfn = ADDR2PFN(init.tasks[i].paddr);
                         frame_mark_unavailable(pfn,
                             SIZE2FRAMES(init.tasks[i].size));
@@ -1255 +1265 @@
                 frame_mark_unavailable(0, 1);
         }
+        frame_high_arch_init();
+}
+
+/** Adjust bounds of physical memory region according to low/high memory split.
+ *
+ * @param low[in]       If true, the adujstment is performed to make the region
+ *                      fit in the low memory. Otherwise the adjustment is
+ *                      performed to make the region fit in the high memory.
+ * @param basep[inout]  Pointer to a variable which contains the region's base
+ *                      address and which may receive the adjusted base address.
+ * @param sizep[inout]  Pointer to a variable which contains the region's size
+ *                      and which may receive the adjusted size.
+ * @retun               True if the region still exists even after the
+ *                      adjustment, false otherwise.
+ */
+bool frame_adjust_zone_bounds(bool low, uintptr_t *basep, size_t *sizep)
+{
+        uintptr_t limit = config.identity_size;
+
+        if (low) {
+                if (*basep > limit)
+                        return false;
+                if (*basep + *sizep > limit)
+                        *sizep = limit - *basep;
+        } else {
+                if (*basep + *sizep <= limit)
+                        return false;
+                if (*basep <= limit) {
+                        *sizep -= limit - *basep;
+                        *basep = limit;
+                }
+        }
+        return true;
 }
 
@@ -1293 +1336 @@
                 *total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
                 
-                if (zone_flags_available(zones.info[i].flags)) {
+                if (zones.info[i].flags & ZONE_AVAILABLE) {
                         *busy += (uint64_t) FRAMES2SIZE(zones.info[i].busy_count);
                         *free += (uint64_t) FRAMES2SIZE(zones.info[i].free_count);
@@ -1344 +1387 @@
                 irq_spinlock_unlock(&zones.lock, true);
                 
-                bool available = zone_flags_available(flags);
+                bool available = ((flags & ZONE_AVAILABLE) != 0);
                 
                 printf("%-4zu", i);
@@ -1356 +1399 @@
 #endif
                 
-                printf(" %12zu %c%c%c      ", count,
-                    available ? 'A' : ' ',
-                    (flags & ZONE_RESERVED) ? 'R' : ' ',
-                    (flags & ZONE_FIRMWARE) ? 'F' : ' ');
+                printf(" %12zu %c%c%c%c%c    ", count,
+                    available ? 'A' : '-',
+                    (flags & ZONE_RESERVED) ? 'R' : '-',
+                    (flags & ZONE_FIRMWARE) ? 'F' : '-',
+                    (flags & ZONE_LOWMEM) ? 'L' : '-',
+                    (flags & ZONE_HIGHMEM) ? 'H' : '-');
                 
                 if (available)
@@ -1401 +1446 @@
         irq_spinlock_unlock(&zones.lock, true);
         
-        bool available = zone_flags_available(flags);
+        bool available = ((flags & ZONE_AVAILABLE) != 0);
         
         uint64_t size;
@@ -1411 +1456 @@
         printf("Zone size:         %zu frames (%" PRIu64 " %s)\n", count,
             size, size_suffix);
-        printf("Zone flags:        %c%c%c\n",
-            available ? 'A' : ' ',
-            (flags & ZONE_RESERVED) ? 'R' : ' ',
-            (flags & ZONE_FIRMWARE) ? 'F' : ' ');
+        printf("Zone flags:        %c%c%c%c%c\n",
+            available ? 'A' : '-',
+            (flags & ZONE_RESERVED) ? 'R' : '-',
+            (flags & ZONE_FIRMWARE) ? 'F' : '-',
+            (flags & ZONE_LOWMEM) ? 'L' : '-',
+            (flags & ZONE_HIGHMEM) ? 'H' : '-');
         
         if (available) {

kernel/generic/src/mm/page.c

@@ -53 +53 @@
  * We assume that the other processors are either not using the mapping yet
  * (i.e. during the bootstrap) or are executing the TLB shootdown code.  While
- * we don't care much about the former case, the processors in the latter case 
+ * we don't care much about the former case, the processors in the latter case
  * will do an implicit serialization by virtue of running the TLB shootdown
  * interrupt handler.
@@ -74 +74 @@
 #include <syscall/copy.h>
 #include <errno.h>
+#include <align.h>
 
 /** Virtual operations for page subsystem. */
@@ -81 +82 @@
 {
         page_arch_init();
-}
-
-/** Map memory structure
- *
- * Identity-map memory structure
- * considering possible crossings
- * of page boundaries.
- *
- * @param addr Address of the structure.
- * @param size Size of the structure.
- *
- */
-void map_structure(uintptr_t addr, size_t size)
-{
-        size_t length = size + (addr - (addr & ~(PAGE_SIZE - 1)));
-        size_t cnt = length / PAGE_SIZE + (length % PAGE_SIZE > 0);
-        
-        size_t i;
-        for (i = 0; i < cnt; i++)
-                page_mapping_insert(AS_KERNEL, addr + i * PAGE_SIZE,
-                    addr + i * PAGE_SIZE, PAGE_NOT_CACHEABLE | PAGE_WRITE);
-        
-        /* Repel prefetched accesses to the old mapping. */
-        memory_barrier();
 }
 
@@ -176 +153 @@
 }
 
+/** Make the mapping shared by all page tables (not address spaces).
+ * 
+ * @param base Starting virtual address of the range that is made global.
+ * @param size Size of the address range that is made global.
+ */
+void page_mapping_make_global(uintptr_t base, size_t size)
+{
+        ASSERT(page_mapping_operations);
+        ASSERT(page_mapping_operations->mapping_make_global);
+        
+        return page_mapping_operations->mapping_make_global(base, size);
+}
+
+int page_find_mapping(uintptr_t virt, void **phys)
+{
+        mutex_lock(&AS->lock);
+        
+        pte_t *pte = page_mapping_find(AS, virt, false);
+        if ((!PTE_VALID(pte)) || (!PTE_PRESENT(pte))) {
+                mutex_unlock(&AS->lock);
+                return ENOENT;
+        }
+        
+        *phys = (void *) PTE_GET_FRAME(pte) +
+            (virt - ALIGN_DOWN(virt, PAGE_SIZE));
+        
+        mutex_unlock(&AS->lock);
+        
+        return EOK;
+}
+
 /** Syscall wrapper for getting mapping of a virtual page.
- * 
- * @retval EOK Everything went find, @p uspace_frame and @p uspace_node
- *             contains correct values.
- * @retval ENOENT Virtual address has no mapping.
- */
-sysarg_t sys_page_find_mapping(uintptr_t virt_address,
-    uintptr_t *uspace_frame)
-{
-        mutex_lock(&AS->lock);
-        
-        pte_t *pte = page_mapping_find(AS, virt_address, false);
-        if (!PTE_VALID(pte) || !PTE_PRESENT(pte)) {
-                mutex_unlock(&AS->lock);
-                
-                return (sysarg_t) ENOENT;
-        }
-        
-        uintptr_t phys_address = PTE_GET_FRAME(pte);
-        
-        mutex_unlock(&AS->lock);
-        
-        int rc = copy_to_uspace(uspace_frame,
-            &phys_address, sizeof(phys_address));
-        if (rc != EOK) {
-                return (sysarg_t) rc;
-        }
-        
-        return EOK;
+ *
+ * @return EOK on success.
+ * @return ENOENT if no virtual address mapping found.
+ *
+ */
+sysarg_t sys_page_find_mapping(uintptr_t virt, void *phys_ptr)
+{
+        void *phys;
+        int rc = page_find_mapping(virt, &phys);
+        if (rc != EOK)
+                return rc;
+        
+        rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
+        return (sysarg_t) rc;
 }
 

kernel/generic/src/mm/reserve.c

@@ -42 +42 @@
 #include <typedefs.h>
 #include <arch/types.h>
+#include <debug.h>
+
+static bool reserve_initialized = false;
 
 IRQ_SPINLOCK_STATIC_INITIALIZE_NAME(reserve_lock, "reserve_lock");
@@ -54 +57 @@
 {
         reserve = frame_total_free_get();
+        reserve_initialized = true;
 }
 
@@ -67 +71 @@
 {
         bool reserved = false;
+
+        ASSERT(reserve_initialized);
 
         irq_spinlock_lock(&reserve_lock, true);
@@ -111 +117 @@
 void reserve_force_alloc(size_t size)
 {
+        if (!reserve_initialized)
+                return;
+
         irq_spinlock_lock(&reserve_lock, true);
         reserve -= size;
@@ -122 +131 @@
 void reserve_free(size_t size)
 {
+        if (!reserve_initialized)
+                return;
+
         irq_spinlock_lock(&reserve_lock, true);
         reserve += size;