Changes in kernel/generic/src/mm/as.c [826599a2:f97f1e51] in mainline

File:

• kernel/generic/src/mm/as.c (modified) (46 diffs)

kernel/generic/src/mm/as.c

@@ -79 +79 @@
 #include <syscall/copy.h>
 #include <arch/interrupt.h>
-#include <interrupt.h>
 
 /**
@@ -286 +285 @@
 /** Check area conflicts with other areas.
  *
- * @param as      Address space.
- * @param addr    Starting virtual address of the area being tested.
- * @param count   Number of pages in the area being tested.
- * @param guarded True if the area being tested is protected by guard pages.
- * @param avoid   Do not touch this area.
+ * @param as    Address space.
+ * @param addr  Starting virtual address of the area being tested.
+ * @param count Number of pages in the area being tested.
+ * @param avoid Do not touch this area.
  *
  * @return True if there is no conflict, false otherwise.
@@ -296 +294 @@
  */
 NO_TRACE static bool check_area_conflicts(as_t *as, uintptr_t addr,
-    size_t count, bool guarded, as_area_t *avoid)
+    size_t count, as_area_t *avoid)
 {
         ASSERT((addr % PAGE_SIZE) == 0);
         ASSERT(mutex_locked(&as->lock));
-
-        /*
-         * If the addition of the supposed area address and size overflows,
-         * report conflict.
-         */
-        if (overflows_into_positive(addr, P2SZ(count)))
-                return false;
         
         /*
@@ -313 +304 @@
         if (overlaps(addr, P2SZ(count), (uintptr_t) NULL, PAGE_SIZE))
                 return false;
-
+        
         /*
          * The leaf node is found in O(log n), where n is proportional to
@@ -337 +328 @@
                 if (area != avoid) {
                         mutex_lock(&area->lock);
-
-                        /*
-                         * If at least one of the two areas are protected
-                         * by the AS_AREA_GUARD flag then we must be sure
-                         * that they are separated by at least one unmapped
-                         * page.
-                         */
-                        int const gp = (guarded || 
-                            (area->flags & AS_AREA_GUARD)) ? 1 : 0;
-                        
-                        /*
-                         * The area comes from the left neighbour node, which
-                         * means that there already are some areas in the leaf
-                         * node, which in turn means that adding gp is safe and
-                         * will not cause an integer overflow.
-                         */
+                        
                         if (overlaps(addr, P2SZ(count), area->base,
-                            P2SZ(area->pages + gp))) {
-                                mutex_unlock(&area->lock);
-                                return false;
-                        }
-                        
-                        mutex_unlock(&area->lock);
-                }
-        }
-        
-        node = btree_leaf_node_right_neighbour(&as->as_area_btree, leaf);
-        if (node) {
-                area = (as_area_t *) node->value[0];
-                
-                if (area != avoid) {
-                        int gp;
-
-                        mutex_lock(&area->lock);
-
-                        gp = (guarded || (area->flags & AS_AREA_GUARD)) ? 1 : 0;
-                        if (gp && overflows(addr, P2SZ(count))) {
-                                /*
-                                 * Guard page not needed if the supposed area
-                                 * is adjacent to the end of the address space.
-                                 * We already know that the following test is
-                                 * going to fail...
-                                 */
-                                gp--;
-                        }
-                        
-                        if (overlaps(addr, P2SZ(count + gp), area->base,
                             P2SZ(area->pages))) {
                                 mutex_unlock(&area->lock);
@@ -393 +339 @@
         }
         
+        node = btree_leaf_node_right_neighbour(&as->as_area_btree, leaf);
+        if (node) {
+                area = (as_area_t *) node->value[0];
+                
+                if (area != avoid) {
+                        mutex_lock(&area->lock);
+                        
+                        if (overlaps(addr, P2SZ(count), area->base,
+                            P2SZ(area->pages))) {
+                                mutex_unlock(&area->lock);
+                                return false;
+                        }
+                        
+                        mutex_unlock(&area->lock);
+                }
+        }
+        
         /* Second, check the leaf node. */
         btree_key_t i;
         for (i = 0; i < leaf->keys; i++) {
                 area = (as_area_t *) leaf->value[i];
-                int agp;
-                int gp;
                 
                 if (area == avoid)
@@ -404 +365 @@
                 
                 mutex_lock(&area->lock);
-
-                gp = (guarded || (area->flags & AS_AREA_GUARD)) ? 1 : 0;
-                agp = gp;
-
-                /*
-                 * Sanitize the two possible unsigned integer overflows.
-                 */
-                if (gp && overflows(addr, P2SZ(count)))
-                        gp--;
-                if (agp && overflows(area->base, P2SZ(area->pages)))
-                        agp--;
-
-                if (overlaps(addr, P2SZ(count + gp), area->base,
-                    P2SZ(area->pages + agp))) {
+                
+                if (overlaps(addr, P2SZ(count), area->base,
+                    P2SZ(area->pages))) {
                         mutex_unlock(&area->lock);
                         return false;
@@ -427 +377 @@
         /*
          * So far, the area does not conflict with other areas.
-         * Check if it is contained in the user address space.
+         * Check if it doesn't conflict with kernel address space.
          */
         if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
-                return iswithin(USER_ADDRESS_SPACE_START,
-                    (USER_ADDRESS_SPACE_END - USER_ADDRESS_SPACE_START) + 1,
-                    addr, P2SZ(count));
+                return !overlaps(addr, P2SZ(count), KERNEL_ADDRESS_SPACE_START,
+                    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
         }
         
@@ -443 +392 @@
  * this function.
  *
- * @param as      Address space.
- * @param bound   Lowest address bound.
- * @param size    Requested size of the allocation.
- * @param guarded True if the allocation must be protected by guard pages.
+ * @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.
@@ -453 +401 @@
  */
 NO_TRACE static uintptr_t as_get_unmapped_area(as_t *as, uintptr_t bound,
-    size_t size, bool guarded)
+    size_t size)
 {
         ASSERT(mutex_locked(&as->lock));
@@ -475 +423 @@
         /* First check the bound address itself */
         uintptr_t addr = ALIGN_UP(bound, PAGE_SIZE);
-        if (addr >= bound) {
-                if (guarded) {
-                        /* Leave an unmapped page between the lower
-                         * bound and the area's start address.
-                         */
-                        addr += P2SZ(1);
-                }
-
-                if (check_area_conflicts(as, addr, pages, guarded, NULL))
-                        return addr;
-        }
+        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, leaf_link, btree_node_t, node) {
+        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++) {
@@ -497 +439 @@
                         addr =
                             ALIGN_UP(area->base + P2SZ(area->pages), PAGE_SIZE);
-
-                        if (guarded || area->flags & AS_AREA_GUARD) {
-                                /* We must leave an unmapped page
-                                 * between the two areas.
-                                 */
-                                addr += P2SZ(1);
-                        }
-
                         bool avail =
                             ((addr >= bound) && (addr >= area->base) &&
-                            (check_area_conflicts(as, addr, pages, guarded, area)));
+                            (check_area_conflicts(as, addr, pages, area)));
                         
                         mutex_unlock(&area->lock);
@@ -519 +453 @@
         return (uintptr_t) -1;
 }
-
-/** Remove reference to address space area share info.
- *
- * If the reference count drops to 0, the sh_info is deallocated.
- *
- * @param sh_info Pointer to address space area share info.
- *
- */
-NO_TRACE static void sh_info_remove_reference(share_info_t *sh_info)
-{
-        bool dealloc = false;
-        
-        mutex_lock(&sh_info->lock);
-        ASSERT(sh_info->refcount);
-        
-        if (--sh_info->refcount == 0) {
-                dealloc = true;
-                
-                /*
-                 * Now walk carefully the pagemap B+tree and free/remove
-                 * reference from all frames found there.
-                 */
-                list_foreach(sh_info->pagemap.leaf_list, leaf_link,
-                    btree_node_t, node) {
-                        btree_key_t i;
-                        
-                        for (i = 0; i < node->keys; i++)
-                                frame_free((uintptr_t) node->value[i], 1);
-                }
-                
-        }
-        mutex_unlock(&sh_info->lock);
-        
-        if (dealloc) {
-                if (sh_info->backend && sh_info->backend->destroy_shared_data) {
-                        sh_info->backend->destroy_shared_data(
-                            sh_info->backend_shared_data);
-                }
-                btree_destroy(&sh_info->pagemap);
-                free(sh_info);
-        }
-}
-
 
 /** Create address space area of common attributes.
@@ -572 +463 @@
  * @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 custom backend data.
+ * @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.
@@ -585 +476 @@
     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) -1) && ((*base % PAGE_SIZE) != 0))
                 return NULL;
         
         if (size == 0)
                 return NULL;
-
+        
         size_t pages = SIZE2FRAMES(size);
         
@@ -596 +487 @@
         if ((flags & AS_AREA_EXEC) && (flags & AS_AREA_WRITE))
                 return NULL;
-
-        bool const guarded = flags & AS_AREA_GUARD;
         
         mutex_lock(&as->lock);
         
         if (*base == (uintptr_t) -1) {
-                *base = as_get_unmapped_area(as, bound, size, guarded);
+                *base = as_get_unmapped_area(as, bound, size);
                 if (*base == (uintptr_t) -1) {
                         mutex_unlock(&as->lock);
@@ -608 +497 @@
                 }
         }
-
-        if (overflows_into_positive(*base, size)) {
-                mutex_unlock(&as->lock);
-                return NULL;
-        }
-
-        if (!check_area_conflicts(as, *base, pages, guarded, NULL)) {
+        
+        if (!check_area_conflicts(as, *base, pages, NULL)) {
                 mutex_unlock(&as->lock);
                 return NULL;
@@ -629 +513 @@
         area->resident = 0;
         area->base = *base;
+        area->sh_info = NULL;
         area->backend = backend;
-        area->sh_info = NULL;
         
         if (backend_data)
@@ -636 +520 @@
         else
                 memsetb(&area->backend_data, sizeof(area->backend_data), 0);
-
-        share_info_t *si = NULL;
-
-        /*
-         * Create the sharing info structure.
-         * We do this in advance for every new area, even if it is not going
-         * to be shared.
-         */
-        if (!(attrs & AS_AREA_ATTR_PARTIAL)) {
-                si = (share_info_t *) malloc(sizeof(share_info_t), 0);
-                mutex_initialize(&si->lock, MUTEX_PASSIVE);
-                si->refcount = 1;
-                si->shared = false;
-                si->backend_shared_data = NULL;
-                si->backend = backend;
-                btree_create(&si->pagemap);
-
-                area->sh_info = si;
-        
-                if (area->backend && area->backend->create_shared_data) {
-                        if (!area->backend->create_shared_data(area)) {
-                                free(area);
-                                mutex_unlock(&as->lock);
-                                sh_info_remove_reference(si);
-                                return NULL;
-                        }
-                }
-        }
-
+        
         if (area->backend && area->backend->create) {
                 if (!area->backend->create(area)) {
                         free(area);
                         mutex_unlock(&as->lock);
-                        if (!(attrs & AS_AREA_ATTR_PARTIAL))
-                                sh_info_remove_reference(si);
                         return NULL;
                 }
         }
-
+        
         btree_create(&area->used_space);
         btree_insert(&as->as_area_btree, *base, (void *) area,
@@ -761 +615 @@
 int as_area_resize(as_t *as, uintptr_t address, size_t size, unsigned int flags)
 {
-        if (!IS_ALIGNED(address, PAGE_SIZE))
-                return EINVAL;
-
         mutex_lock(&as->lock);
         
@@ -774 +625 @@
                 return ENOENT;
         }
-
-        if (!area->backend->is_resizable(area)) {
-                /*
-                 * The backend does not support resizing for this area.
+        
+        if (area->backend == &phys_backend) {
+                /*
+                 * Remapping of address space areas associated
+                 * with memory mapped devices is not supported.
                  */
                 mutex_unlock(&area->lock);
@@ -784 +636 @@
         }
         
-        mutex_lock(&area->sh_info->lock);
-        if (area->sh_info->shared) {
+        if (area->sh_info) {
                 /*
                  * Remapping of shared address space areas
                  * is not supported.
                  */
-                mutex_unlock(&area->sh_info->lock);
                 mutex_unlock(&area->lock);
                 mutex_unlock(&as->lock);
                 return ENOTSUP;
         }
-        mutex_unlock(&area->sh_info->lock);
         
         size_t pages = SIZE2FRAMES((address - area->base) + size);
@@ -816 +665 @@
                 
                 page_table_lock(as, false);
+                
+                /*
+                 * Start TLB shootdown sequence.
+                 */
+                ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid,
+                    area->base + P2SZ(pages), area->pages - pages);
                 
                 /*
@@ -871 +726 @@
                                 }
                                 
-                                /*
-                                 * Start TLB shootdown sequence.
-                                 *
-                                 * The sequence is rather short and can be
-                                 * repeated multiple times. The reason is that
-                                 * we don't want to have used_space_remove()
-                                 * inside the sequence as it may use a blocking
-                                 * memory allocation for its B+tree. Blocking
-                                 * while holding the tlblock spinlock is
-                                 * forbidden and would hit a kernel assertion.
-                                 */
-
-                                ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES,
-                                    as->asid, area->base + P2SZ(pages),
-                                    area->pages - pages);
-                
                                 for (; i < size; i++) {
                                         pte_t *pte = page_mapping_find(as,
@@ -904 +743 @@
                                         page_mapping_remove(as, ptr + P2SZ(i));
                                 }
-                
-                                /*
-                                 * Finish TLB shootdown sequence.
-                                 */
-                
-                                tlb_invalidate_pages(as->asid,
-                                    area->base + P2SZ(pages),
-                                    area->pages - pages);
-                
-                                /*
-                                 * Invalidate software translation caches
-                                 * (e.g. TSB on sparc64, PHT on ppc32).
-                                 */
-                                as_invalidate_translation_cache(as,
-                                    area->base + P2SZ(pages),
-                                    area->pages - pages);
-                                tlb_shootdown_finalize(ipl);
                         }
                 }
+                
+                /*
+                 * Finish TLB shootdown sequence.
+                 */
+                
+                tlb_invalidate_pages(as->asid, area->base + P2SZ(pages),
+                    area->pages - pages);
+                
+                /*
+                 * Invalidate software translation caches
+                 * (e.g. TSB on sparc64, PHT on ppc32).
+                 */
+                as_invalidate_translation_cache(as, area->base + P2SZ(pages),
+                    area->pages - pages);
+                tlb_shootdown_finalize(ipl);
+                
                 page_table_unlock(as, false);
         } else {
                 /*
                  * Growing the area.
-                 */
-
-                if (overflows_into_positive(address, P2SZ(pages)))
-                        return EINVAL;
-
-                /*
                  * Check for overlaps with other address space areas.
                  */
-                bool const guarded = area->flags & AS_AREA_GUARD;
-                if (!check_area_conflicts(as, address, pages, guarded, area)) {
+                if (!check_area_conflicts(as, address, pages, area)) {
                         mutex_unlock(&area->lock);
                         mutex_unlock(&as->lock);
@@ -959 +790 @@
 }
 
+/** Remove reference to address space area share info.
+ *
+ * If the reference count drops to 0, the sh_info is deallocated.
+ *
+ * @param sh_info Pointer to address space area share info.
+ *
+ */
+NO_TRACE static void sh_info_remove_reference(share_info_t *sh_info)
+{
+        bool dealloc = false;
+        
+        mutex_lock(&sh_info->lock);
+        ASSERT(sh_info->refcount);
+        
+        if (--sh_info->refcount == 0) {
+                dealloc = true;
+                
+                /*
+                 * Now walk carefully the pagemap B+tree and free/remove
+                 * reference from all frames found there.
+                 */
+                list_foreach(sh_info->pagemap.leaf_list, cur) {
+                        btree_node_t *node
+                            = list_get_instance(cur, btree_node_t, leaf_link);
+                        btree_key_t i;
+                        
+                        for (i = 0; i < node->keys; i++)
+                                frame_free((uintptr_t) node->value[i]);
+                }
+                
+        }
+        mutex_unlock(&sh_info->lock);
+        
+        if (dealloc) {
+                btree_destroy(&sh_info->pagemap);
+                free(sh_info);
+        }
+}
+
 /** Destroy address space area.
  *
@@ -993 +863 @@
          * Visit only the pages mapped by used_space B+tree.
          */
-        list_foreach(area->used_space.leaf_list, leaf_link, btree_node_t,
-            node) {
+        list_foreach(area->used_space.leaf_list, cur) {
+                btree_node_t *node;
                 btree_key_t i;
                 
+                node = list_get_instance(cur, btree_node_t, leaf_link);
                 for (i = 0; i < node->keys; i++) {
                         uintptr_t ptr = node->key[i];
@@ -1040 +911 @@
         area->attributes |= AS_AREA_ATTR_PARTIAL;
         
-        sh_info_remove_reference(area->sh_info);
+        if (area->sh_info)
+                sh_info_remove_reference(area->sh_info);
         
         mutex_unlock(&area->lock);
@@ -1096 +968 @@
         }
         
-        if (!src_area->backend->is_shareable(src_area)) {
-                /*
-                 * The backend does not permit sharing of this area.
+        if ((!src_area->backend) || (!src_area->backend->share)) {
+                /*
+                 * There is no backend or the backend does not
+                 * know how to share the area.
                  */
                 mutex_unlock(&src_area->lock);
@@ -1127 +1000 @@
          */
         share_info_t *sh_info = src_area->sh_info;
-        
-        mutex_lock(&sh_info->lock);
-        sh_info->refcount++;
-        bool shared = sh_info->shared;
-        sh_info->shared = true;
-        mutex_unlock(&sh_info->lock);
-
-        if (!shared) {
+        if (!sh_info) {
+                sh_info = (share_info_t *) malloc(sizeof(share_info_t), 0);
+                mutex_initialize(&sh_info->lock, MUTEX_PASSIVE);
+                sh_info->refcount = 2;
+                btree_create(&sh_info->pagemap);
+                src_area->sh_info = sh_info;
+                
                 /*
                  * Call the backend to setup sharing.
-                 * This only happens once for each sh_info.
                  */
                 src_area->backend->share(src_area);
+        } else {
+                mutex_lock(&sh_info->lock);
+                sh_info->refcount++;
+                mutex_unlock(&sh_info->lock);
         }
         
@@ -1258 +1133 @@
         }
         
-        if (area->backend != &anon_backend) {
+        if ((area->sh_info) || (area->backend != &anon_backend)) {
+                /* Copying shared areas not supported yet */
                 /* Copying non-anonymous memory not supported yet */
                 mutex_unlock(&area->lock);
@@ -1264 +1140 @@
                 return ENOTSUP;
         }
-
-        mutex_lock(&area->sh_info->lock);
-        if (area->sh_info->shared) {
-                /* Copying shared areas not supported yet */
-                mutex_unlock(&area->sh_info->lock);
-                mutex_unlock(&area->lock);
-                mutex_unlock(&as->lock);
-                return ENOTSUP;
-        }
-        mutex_unlock(&area->sh_info->lock);
         
         /*
@@ -1280 +1146 @@
         size_t used_pages = 0;
         
-        list_foreach(area->used_space.leaf_list, leaf_link, btree_node_t,
-            node) {
+        list_foreach(area->used_space.leaf_list, cur) {
+                btree_node_t *node
+                    = list_get_instance(cur, btree_node_t, leaf_link);
                 btree_key_t i;
                 
@@ -1305 +1172 @@
         size_t frame_idx = 0;
         
-        list_foreach(area->used_space.leaf_list, leaf_link, btree_node_t,
-            node) {
+        list_foreach(area->used_space.leaf_list, cur) {
+                btree_node_t *node = list_get_instance(cur, btree_node_t,
+                    leaf_link);
                 btree_key_t i;
                 
@@ -1356 +1224 @@
         frame_idx = 0;
         
-        list_foreach(area->used_space.leaf_list, leaf_link, btree_node_t,
-            node) {
+        list_foreach(area->used_space.leaf_list, cur) {
+                btree_node_t *node
+                    = list_get_instance(cur, btree_node_t, leaf_link);
                 btree_key_t i;
                 
@@ -1392 +1261 @@
  * Interrupts are assumed disabled.
  *
- * @param address Faulting address.
- * @param access  Access mode that caused the page fault (i.e.
- *                read/write/exec).
- * @param istate  Pointer to the interrupted state.
+ * @param page   Faulting page.
+ * @param access Access mode that caused the page fault (i.e.
+ *               read/write/exec).
+ * @param istate Pointer to the interrupted state.
  *
  * @return AS_PF_FAULT on page fault.
@@ -1403 +1272 @@
  *
  */
-int as_page_fault(uintptr_t address, pf_access_t access, istate_t *istate)
-{
-        uintptr_t page = ALIGN_DOWN(address, PAGE_SIZE);
-        int rc = AS_PF_FAULT;
-
+int as_page_fault(uintptr_t page, pf_access_t access, istate_t *istate)
+{
         if (!THREAD)
-                goto page_fault;
+                return AS_PF_FAULT;
         
         if (!AS)
-                goto page_fault;
+                return AS_PF_FAULT;
         
         mutex_lock(&AS->lock);
@@ -1468 +1334 @@
          * Resort to the backend page fault handler.
          */
-        rc = area->backend->page_fault(area, page, access);
-        if (rc != AS_PF_OK) {
+        if (area->backend->page_fault(area, page, access) != AS_PF_OK) {
                 page_table_unlock(AS, false);
                 mutex_unlock(&area->lock);
@@ -1490 +1355 @@
                 istate_set_retaddr(istate,
                     (uintptr_t) &memcpy_to_uspace_failover_address);
-        } else if (rc == AS_PF_SILENT) {
-                printf("Killing task %" PRIu64 " due to a "
-                    "failed late reservation request.\n", TASK->taskid);
-                task_kill_self(true);
         } else {
-                fault_if_from_uspace(istate, "Page fault: %p.", (void *) address);
-                panic_memtrap(istate, access, address, NULL);
+                return AS_PF_FAULT;
         }
         
@@ -1722 +1582 @@
 {
         ASSERT(mutex_locked(&area->lock));
-        ASSERT(IS_ALIGNED(page, PAGE_SIZE));
+        ASSERT(page == ALIGN_DOWN(page, PAGE_SIZE));
         ASSERT(count);
         
-        btree_node_t *leaf = NULL;
+        btree_node_t *leaf;
         size_t pages = (size_t) btree_search(&area->used_space, page, &leaf);
         if (pages) {
@@ -1733 +1593 @@
                 return false;
         }
-
-        ASSERT(leaf != NULL);
         
         if (!leaf->keys) {
@@ -2008 +1866 @@
 {
         ASSERT(mutex_locked(&area->lock));
-        ASSERT(IS_ALIGNED(page, PAGE_SIZE));
+        ASSERT(page == ALIGN_DOWN(page, PAGE_SIZE));
         ASSERT(count);
         
@@ -2185 +2043 @@
 {
         uintptr_t virt = base;
-        as_area_t *area = as_area_create(AS, flags, size,
+        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)
@@ -2223 +2081 @@
         size_t area_cnt = 0;
         
-        list_foreach(as->as_area_btree.leaf_list, leaf_link, btree_node_t,
-            node) {
+        list_foreach(as->as_area_btree.leaf_list, cur) {
+                btree_node_t *node =
+                    list_get_instance(cur, btree_node_t, leaf_link);
                 area_cnt += node->keys;
         }
@@ -2235 +2094 @@
         size_t area_idx = 0;
         
-        list_foreach(as->as_area_btree.leaf_list, leaf_link, btree_node_t,
-            node) {
+        list_foreach(as->as_area_btree.leaf_list, cur) {
+                btree_node_t *node =
+                    list_get_instance(cur, btree_node_t, leaf_link);
                 btree_key_t i;
                 
@@ -2270 +2130 @@
         
         /* Print out info about address space areas */
-        list_foreach(as->as_area_btree.leaf_list, leaf_link, btree_node_t,
-            node) {
+        list_foreach(as->as_area_btree.leaf_list, cur) {
+                btree_node_t *node
+                    = list_get_instance(cur, btree_node_t, leaf_link);
                 btree_key_t i;