Changes in kernel/generic/src/mm/as.c [e394b736:7250d2c] in mainline

File:

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

kernel/generic/src/mm/as.c

@@ -94 +94 @@
  *
  * This lock protects:
- * - inactive_as_with_asid_head list
+ * - inactive_as_with_asid_list
  * - as->asid for each as of the as_t type
  * - asids_allocated counter
@@ -105 +105 @@
  * that have valid ASID.
  */
-LIST_INITIALIZE(inactive_as_with_asid_head);
+LIST_INITIALIZE(inactive_as_with_asid_list);
 
 /** Kernel address space. */
@@ -235 +235 @@
         bool cond = true;
         while (cond) {
-                ASSERT(!list_empty(&as->as_area_btree.leaf_head));
+                ASSERT(!list_empty(&as->as_area_btree.leaf_list));
                 
                 btree_node_t *node =
-                    list_get_instance(as->as_area_btree.leaf_head.next,
+                    list_get_instance(list_first(&as->as_area_btree.leaf_list),
                     btree_node_t, leaf_link);
                 
@@ -302 +302 @@
          * We don't want any area to have conflicts with NULL page.
          */
-        if (overlaps(addr, count << PAGE_WIDTH, (uintptr_t) NULL, PAGE_SIZE))
+        if (overlaps(addr, P2SZ(count), (uintptr_t) NULL, PAGE_SIZE))
                 return false;
         
@@ -329 +329 @@
                         mutex_lock(&area->lock);
                         
-                        if (overlaps(addr, count << PAGE_WIDTH,
-                            area->base, area->pages << PAGE_WIDTH)) {
+                        if (overlaps(addr, P2SZ(count), area->base,
+                            P2SZ(area->pages))) {
                                 mutex_unlock(&area->lock);
                                 return false;
@@ -346 +346 @@
                         mutex_lock(&area->lock);
                         
-                        if (overlaps(addr, count << PAGE_WIDTH,
-                            area->base, area->pages << PAGE_WIDTH)) {
+                        if (overlaps(addr, P2SZ(count), area->base,
+                            P2SZ(area->pages))) {
                                 mutex_unlock(&area->lock);
                                 return false;
@@ -366 +366 @@
                 mutex_lock(&area->lock);
                 
-                if (overlaps(addr, count << PAGE_WIDTH,
-                    area->base, area->pages << PAGE_WIDTH)) {
+                if (overlaps(addr, P2SZ(count), area->base,
+                    P2SZ(area->pages))) {
                         mutex_unlock(&area->lock);
                         return false;
@@ -380 +380 @@
          */
         if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
-                return !overlaps(addr, count << PAGE_WIDTH,
-                    KERNEL_ADDRESS_SPACE_START,
+                return !overlaps(addr, P2SZ(count), KERNEL_ADDRESS_SPACE_START,
                     KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
         }
@@ -474 +473 @@
         
         btree_node_t *leaf;
-        as_area_t *area = (as_area_t *) btree_search(&as->as_area_btree, va, &leaf);
+        as_area_t *area = (as_area_t *) btree_search(&as->as_area_btree, va,
+            &leaf);
         if (area) {
                 /* va is the base address of an address space area */
@@ -482 +482 @@
         
         /*
-         * Search the leaf node and the righmost record of its left neighbour
+         * Search the leaf node and the rightmost record of its left neighbour
          * to find out whether this is a miss or va belongs to an address
          * space area found there.
@@ -494 +494 @@
                 
                 mutex_lock(&area->lock);
-                
+
                 if ((area->base <= va) &&
-                    (va < area->base + (area->pages << PAGE_WIDTH)))
+                    (va <= area->base + (P2SZ(area->pages) - 1)))
                         return area;
                 
@@ -506 +506 @@
          * Because of its position in the B+tree, it must have base < va.
          */
-        btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf);
+        btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree,
+            leaf);
         if (lnode) {
                 area = (as_area_t *) lnode->value[lnode->keys - 1];
@@ -512 +513 @@
                 mutex_lock(&area->lock);
                 
-                if (va < area->base + (area->pages << PAGE_WIDTH))
+                if (va <= area->base + (P2SZ(area->pages) - 1))
                         return area;
                 
@@ -577 +578 @@
         
         if (pages < area->pages) {
-                uintptr_t start_free = area->base + (pages << PAGE_WIDTH);
+                uintptr_t start_free = area->base + P2SZ(pages);
                 
                 /*
@@ -590 +591 @@
                  */
                 ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid,
-                    area->base + (pages << PAGE_WIDTH), area->pages - pages);
+                    area->base + P2SZ(pages), area->pages - pages);
                 
                 /*
@@ -601 +602 @@
                 bool cond = true;
                 while (cond) {
-                        ASSERT(!list_empty(&area->used_space.leaf_head));
+                        ASSERT(!list_empty(&area->used_space.leaf_list));
                         
                         btree_node_t *node =
-                            list_get_instance(area->used_space.leaf_head.prev,
+                            list_get_instance(list_last(&area->used_space.leaf_list),
                             btree_node_t, leaf_link);
                         
@@ -613 +614 @@
                                 size_t i = 0;
                                 
-                                if (overlaps(ptr, size << PAGE_WIDTH, area->base,
-                                    pages << PAGE_WIDTH)) {
+                                if (overlaps(ptr, P2SZ(size), area->base,
+                                    P2SZ(pages))) {
                                         
-                                        if (ptr + (size << PAGE_WIDTH) <= start_free) {
+                                        if (ptr + P2SZ(size) <= start_free) {
                                                 /*
                                                  * The whole interval fits
@@ -647 +648 @@
                                 
                                 for (; i < size; i++) {
-                                        pte_t *pte = page_mapping_find(as, ptr +
-                                            (i << PAGE_WIDTH));
+                                        pte_t *pte = page_mapping_find(as,
+                                            ptr + P2SZ(i), false);
                                         
                                         ASSERT(pte);
@@ -657 +658 @@
                                             (area->backend->frame_free)) {
                                                 area->backend->frame_free(area,
-                                                    ptr + (i << PAGE_WIDTH),
+                                                    ptr + P2SZ(i),
                                                     PTE_GET_FRAME(pte));
                                         }
                                         
-                                        page_mapping_remove(as, ptr +
-                                            (i << PAGE_WIDTH));
+                                        page_mapping_remove(as, ptr + P2SZ(i));
                                 }
                         }
@@ -671 +671 @@
                  */
                 
-                tlb_invalidate_pages(as->asid, area->base + (pages << PAGE_WIDTH),
+                tlb_invalidate_pages(as->asid, area->base + P2SZ(pages),
                     area->pages - pages);
                 
                 /*
-                 * Invalidate software translation caches (e.g. TSB on sparc64).
-                 */
-                as_invalidate_translation_cache(as, area->base +
-                    (pages << PAGE_WIDTH), 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);
                 
@@ -726 +727 @@
         if (--sh_info->refcount == 0) {
                 dealloc = true;
-                link_t *cur;
                 
                 /*
@@ -732 +732 @@
                  * reference from all frames found there.
                  */
-                for (cur = sh_info->pagemap.leaf_head.next;
-                    cur != &sh_info->pagemap.leaf_head; cur = cur->next) {
+                list_foreach(sh_info->pagemap.leaf_list, cur) {
                         btree_node_t *node
                             = list_get_instance(cur, btree_node_t, leaf_link);
@@ -785 +784 @@
          * Visit only the pages mapped by used_space B+tree.
          */
-        link_t *cur;
-        for (cur = area->used_space.leaf_head.next;
-            cur != &area->used_space.leaf_head; cur = cur->next) {
+        list_foreach(area->used_space.leaf_list, cur) {
                 btree_node_t *node;
                 btree_key_t i;
@@ -797 +794 @@
                         
                         for (size = 0; size < (size_t) node->value[i]; size++) {
-                                pte_t *pte =
-                                    page_mapping_find(as, ptr + (size << PAGE_WIDTH));
+                                pte_t *pte = page_mapping_find(as,
+                                     ptr + P2SZ(size), false);
                                 
                                 ASSERT(pte);
@@ -807 +804 @@
                                     (area->backend->frame_free)) {
                                         area->backend->frame_free(area,
-                                            ptr + (size << PAGE_WIDTH), PTE_GET_FRAME(pte));
+                                            ptr + P2SZ(size),
+                                            PTE_GET_FRAME(pte));
                                 }
                                 
-                                page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
+                                page_mapping_remove(as, ptr + P2SZ(size));
                         }
                 }
@@ -822 +820 @@
         
         /*
-         * Invalidate potential software translation caches (e.g. TSB on
-         * sparc64).
+         * Invalidate potential software translation caches
+         * (e.g. TSB on sparc64, PHT on ppc32).
          */
         as_invalidate_translation_cache(as, area->base, area->pages);
@@ -897 +895 @@
         }
         
-        size_t src_size = src_area->pages << PAGE_WIDTH;
+        size_t src_size = P2SZ(src_area->pages);
         unsigned int src_flags = src_area->flags;
         mem_backend_t *src_backend = src_area->backend;
@@ -1063 +1061 @@
          */
         size_t used_pages = 0;
-        link_t *cur;
-        
-        for (cur = area->used_space.leaf_head.next;
-            cur != &area->used_space.leaf_head; cur = cur->next) {
+        
+        list_foreach(area->used_space.leaf_list, cur) {
                 btree_node_t *node
                     = list_get_instance(cur, btree_node_t, leaf_link);
@@ -1092 +1088 @@
         size_t frame_idx = 0;
         
-        for (cur = area->used_space.leaf_head.next;
-            cur != &area->used_space.leaf_head; cur = cur->next) {
-                btree_node_t *node
-                    = list_get_instance(cur, btree_node_t, leaf_link);
+        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;
                 
@@ -1103 +1098 @@
                         
                         for (size = 0; size < (size_t) node->value[i]; size++) {
-                                pte_t *pte =
-                                    page_mapping_find(as, ptr + (size << PAGE_WIDTH));
+                                pte_t *pte = page_mapping_find(as,
+                                    ptr + P2SZ(size), false);
                                 
                                 ASSERT(pte);
@@ -1113 +1108 @@
                                 
                                 /* Remove old mapping */
-                                page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
+                                page_mapping_remove(as, ptr + P2SZ(size));
                         }
                 }
@@ -1125 +1120 @@
         
         /*
-         * Invalidate potential software translation caches (e.g. TSB on
-         * sparc64).
+         * Invalidate potential software translation caches
+         * (e.g. TSB on sparc64, PHT on ppc32).
          */
         as_invalidate_translation_cache(as, area->base, area->pages);
@@ -1145 +1140 @@
         frame_idx = 0;
         
-        for (cur = area->used_space.leaf_head.next;
-            cur != &area->used_space.leaf_head; cur = cur->next) {
+        list_foreach(area->used_space.leaf_list, cur) {
                 btree_node_t *node
                     = list_get_instance(cur, btree_node_t, leaf_link);
@@ -1159 +1153 @@
                                 
                                 /* Insert the new mapping */
-                                page_mapping_insert(as, ptr + (size << PAGE_WIDTH),
+                                page_mapping_insert(as, ptr + P2SZ(size),
                                     old_frame[frame_idx++], page_flags);
                                 
@@ -1240 +1234 @@
          */
         pte_t *pte;
-        if ((pte = page_mapping_find(AS, page))) {
+        if ((pte = page_mapping_find(AS, page, false))) {
                 if (PTE_PRESENT(pte)) {
                         if (((access == PF_ACCESS_READ) && PTE_READABLE(pte)) ||
@@ -1290 +1284 @@
  * thing which is forbidden in this context is locking the address space.
  *
- * When this function is enetered, no spinlocks may be held.
+ * When this function is entered, no spinlocks may be held.
  *
  * @param old Old address space or NULL.
@@ -1332 +1326 @@
                         
                         list_append(&old_as->inactive_as_with_asid_link,
-                            &inactive_as_with_asid_head);
+                            &inactive_as_with_asid_list);
                 }
                 
@@ -1481 +1475 @@
         
         if (src_area) {
-                size = src_area->pages << PAGE_WIDTH;
+                size = P2SZ(src_area->pages);
                 mutex_unlock(&src_area->lock);
         } else
@@ -1536 +1530 @@
                 if (page >= right_pg) {
                         /* Do nothing. */
-                } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
-                    left_cnt << PAGE_WIDTH)) {
+                } else if (overlaps(page, P2SZ(count), left_pg,
+                    P2SZ(left_cnt))) {
                         /* The interval intersects with the left interval. */
                         return false;
-                } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
-                    right_cnt << PAGE_WIDTH)) {
+                } else if (overlaps(page, P2SZ(count), right_pg,
+                    P2SZ(right_cnt))) {
                         /* The interval intersects with the right interval. */
                         return false;
-                } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
-                    (page + (count << PAGE_WIDTH) == right_pg)) {
+                } else if ((page == left_pg + P2SZ(left_cnt)) &&
+                    (page + P2SZ(count) == right_pg)) {
                         /*
                          * The interval can be added by merging the two already
@@ -1553 +1547 @@
                         btree_remove(&area->used_space, right_pg, leaf);
                         goto success;
-                } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
+                } else if (page == left_pg + P2SZ(left_cnt)) {
                         /*
                          * The interval can be added by simply growing the left
@@ -1560 +1554 @@
                         node->value[node->keys - 1] += count;
                         goto success;
-                } else if (page + (count << PAGE_WIDTH) == right_pg) {
+                } else if (page + P2SZ(count) == right_pg) {
                         /*
                          * The interval can be addded by simply moving base of
@@ -1587 +1581 @@
                  */
                 
-                if (overlaps(page, count << PAGE_WIDTH, right_pg,
-                    right_cnt << PAGE_WIDTH)) {
+                if (overlaps(page, P2SZ(count), right_pg, P2SZ(right_cnt))) {
                         /* The interval intersects with the right interval. */
                         return false;
-                } else if (page + (count << PAGE_WIDTH) == right_pg) {
+                } else if (page + P2SZ(count) == right_pg) {
                         /*
                          * The interval can be added by moving the base of the
@@ -1626 +1619 @@
                 if (page < left_pg) {
                         /* Do nothing. */
-                } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
-                    left_cnt << PAGE_WIDTH)) {
+                } else if (overlaps(page, P2SZ(count), left_pg,
+                    P2SZ(left_cnt))) {
                         /* The interval intersects with the left interval. */
                         return false;
-                } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
-                    right_cnt << PAGE_WIDTH)) {
+                } else if (overlaps(page, P2SZ(count), right_pg,
+                    P2SZ(right_cnt))) {
                         /* The interval intersects with the right interval. */
                         return false;
-                } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
-                    (page + (count << PAGE_WIDTH) == right_pg)) {
+                } else if ((page == left_pg + P2SZ(left_cnt)) &&
+                    (page + P2SZ(count) == right_pg)) {
                         /*
                          * The interval can be added by merging the two already
@@ -1643 +1636 @@
                         btree_remove(&area->used_space, right_pg, node);
                         goto success;
-                } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
+                } else if (page == left_pg + P2SZ(left_cnt)) {
                         /*
                          * The interval can be added by simply growing the left
@@ -1650 +1643 @@
                         leaf->value[leaf->keys - 1] += count;
                         goto success;
-                } else if (page + (count << PAGE_WIDTH) == right_pg) {
+                } else if (page + P2SZ(count) == right_pg) {
                         /*
                          * The interval can be addded by simply moving base of
@@ -1677 +1670 @@
                  */
                 
-                if (overlaps(page, count << PAGE_WIDTH, left_pg,
-                    left_cnt << PAGE_WIDTH)) {
+                if (overlaps(page, P2SZ(count), left_pg, P2SZ(left_cnt))) {
                         /* The interval intersects with the left interval. */
                         return false;
-                } else if (left_pg + (left_cnt << PAGE_WIDTH) == page) {
+                } else if (left_pg + P2SZ(left_cnt) == page) {
                         /*
                          * The interval can be added by growing the left
@@ -1716 +1708 @@
                          */
                         
-                        if (overlaps(page, count << PAGE_WIDTH, left_pg,
-                            left_cnt << PAGE_WIDTH)) {
+                        if (overlaps(page, P2SZ(count), left_pg,
+                            P2SZ(left_cnt))) {
                                 /*
                                  * The interval intersects with the left
@@ -1723 +1715 @@
                                  */
                                 return false;
-                        } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
-                            right_cnt << PAGE_WIDTH)) {
+                        } else if (overlaps(page, P2SZ(count), right_pg,
+                            P2SZ(right_cnt))) {
                                 /*
                                  * The interval intersects with the right
@@ -1730 +1722 @@
                                  */
                                 return false;
-                        } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
-                            (page + (count << PAGE_WIDTH) == right_pg)) {
+                        } else if ((page == left_pg + P2SZ(left_cnt)) &&
+                            (page + P2SZ(count) == right_pg)) {
                                 /*
                                  * The interval can be added by merging the two
@@ -1739 +1731 @@
                                 btree_remove(&area->used_space, right_pg, leaf);
                                 goto success;
-                        } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
+                        } else if (page == left_pg + P2SZ(left_cnt)) {
                                 /*
                                  * The interval can be added by simply growing
@@ -1746 +1738 @@
                                 leaf->value[i - 1] += count;
                                 goto success;
-                        } else if (page + (count << PAGE_WIDTH) == right_pg) {
+                        } else if (page + P2SZ(count) == right_pg) {
                                 /*
                                  * The interval can be addded by simply moving
@@ -1812 +1804 @@
                         for (i = 0; i < leaf->keys; i++) {
                                 if (leaf->key[i] == page) {
-                                        leaf->key[i] += count << PAGE_WIDTH;
+                                        leaf->key[i] += P2SZ(count);
                                         leaf->value[i] -= count;
                                         goto success;
@@ -1822 +1814 @@
         }
         
-        btree_node_t *node = btree_leaf_node_left_neighbour(&area->used_space, leaf);
+        btree_node_t *node = btree_leaf_node_left_neighbour(&area->used_space,
+            leaf);
         if ((node) && (page < leaf->key[0])) {
                 uintptr_t left_pg = node->key[node->keys - 1];
                 size_t left_cnt = (size_t) node->value[node->keys - 1];
                 
-                if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
-                    count << PAGE_WIDTH)) {
-                        if (page + (count << PAGE_WIDTH) ==
-                            left_pg + (left_cnt << PAGE_WIDTH)) {
+                if (overlaps(left_pg, P2SZ(left_cnt), page, P2SZ(count))) {
+                        if (page + P2SZ(count) == left_pg + P2SZ(left_cnt)) {
                                 /*
                                  * The interval is contained in the rightmost
@@ -1839 +1830 @@
                                 node->value[node->keys - 1] -= count;
                                 goto success;
-                        } else if (page + (count << PAGE_WIDTH) <
-                            left_pg + (left_cnt << PAGE_WIDTH)) {
+                        } else if (page + P2SZ(count) <
+                            left_pg + P2SZ(left_cnt)) {
+                                size_t new_cnt;
+
                                 /*
                                  * The interval is contained in the rightmost
@@ -1848 +1841 @@
                                  * new interval.
                                  */
-                                size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
-                                    (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
+                                new_cnt = ((left_pg + P2SZ(left_cnt)) -
+                                    (page + P2SZ(count))) >> PAGE_WIDTH;
                                 node->value[node->keys - 1] -= count + new_cnt;
                                 btree_insert(&area->used_space, page +
-                                    (count << PAGE_WIDTH), (void *) new_cnt, leaf);
+                                    P2SZ(count), (void *) new_cnt, leaf);
                                 goto success;
                         }
@@ -1865 +1858 @@
                 size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
                 
-                if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
-                    count << PAGE_WIDTH)) {
-                        if (page + (count << PAGE_WIDTH) ==
-                            left_pg + (left_cnt << PAGE_WIDTH)) {
+                if (overlaps(left_pg, P2SZ(left_cnt), page, P2SZ(count))) {
+                        if (page + P2SZ(count) == left_pg + P2SZ(left_cnt)) {
                                 /*
                                  * The interval is contained in the rightmost
@@ -1876 +1867 @@
                                 leaf->value[leaf->keys - 1] -= count;
                                 goto success;
-                        } else if (page + (count << PAGE_WIDTH) < left_pg +
-                            (left_cnt << PAGE_WIDTH)) {
+                        } else if (page + P2SZ(count) < left_pg +
+                            P2SZ(left_cnt)) {
+                                size_t new_cnt;
+
                                 /*
                                  * The interval is contained in the rightmost
@@ -1885 +1878 @@
                                  * interval.
                                  */
-                                size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
-                                    (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
+                                new_cnt = ((left_pg + P2SZ(left_cnt)) -
+                                    (page + P2SZ(count))) >> PAGE_WIDTH;
                                 leaf->value[leaf->keys - 1] -= count + new_cnt;
                                 btree_insert(&area->used_space, page +
-                                    (count << PAGE_WIDTH), (void *) new_cnt, leaf);
+                                    P2SZ(count), (void *) new_cnt, leaf);
                                 goto success;
                         }
@@ -1911 +1904 @@
                          * to (i - 1) and i.
                          */
-                        if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
-                            count << PAGE_WIDTH)) {
-                                if (page + (count << PAGE_WIDTH) ==
-                                    left_pg + (left_cnt << PAGE_WIDTH)) {
+                        if (overlaps(left_pg, P2SZ(left_cnt), page,
+                            P2SZ(count))) {
+                                if (page + P2SZ(count) ==
+                                    left_pg + P2SZ(left_cnt)) {
                                         /*
                                          * The interval is contained in the
@@ -1923 +1916 @@
                                         leaf->value[i - 1] -= count;
                                         goto success;
-                                } else if (page + (count << PAGE_WIDTH) <
-                                    left_pg + (left_cnt << PAGE_WIDTH)) {
+                                } else if (page + P2SZ(count) <
+                                    left_pg + P2SZ(left_cnt)) {
+                                        size_t new_cnt;
+
                                         /*
                                          * The interval is contained in the
@@ -1932 +1927 @@
                                          * also inserting a new interval.
                                          */
-                                        size_t new_cnt = ((left_pg +
-                                            (left_cnt << PAGE_WIDTH)) -
-                                            (page + (count << PAGE_WIDTH))) >>
+                                        new_cnt = ((left_pg + P2SZ(left_cnt)) -
+                                            (page + P2SZ(count))) >>
                                             PAGE_WIDTH;
                                         leaf->value[i - 1] -= count + new_cnt;
                                         btree_insert(&area->used_space, page +
-                                            (count << PAGE_WIDTH), (void *) new_cnt,
+                                            P2SZ(count), (void *) new_cnt,
                                             leaf);
                                         goto success;
@@ -2025 +2019 @@
         
         /* Eventually check the addresses behind each area */
-        link_t *cur;
-        for (cur = AS->as_area_btree.leaf_head.next;
-            (ret == 0) && (cur != &AS->as_area_btree.leaf_head);
-            cur = cur->next) {
+        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);
@@ -2034 +2028 @@
                 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);
                         
-                        uintptr_t addr =
-                            ALIGN_UP(area->base + (area->pages << PAGE_WIDTH),
+                        addr = ALIGN_UP(area->base + P2SZ(area->pages),
                             PAGE_SIZE);
                         
@@ -2069 +2064 @@
         
         size_t area_cnt = 0;
-        link_t *cur;
-        
-        for (cur = as->as_area_btree.leaf_head.next;
-            cur != &as->as_area_btree.leaf_head; cur = cur->next) {
+        
+        list_foreach(as->as_area_btree.leaf_list, cur) {
                 btree_node_t *node =
                     list_get_instance(cur, btree_node_t, leaf_link);
@@ -2085 +2078 @@
         size_t area_idx = 0;
         
-        for (cur = as->as_area_btree.leaf_head.next;
-            cur != &as->as_area_btree.leaf_head; cur = cur->next) {
+        list_foreach(as->as_area_btree.leaf_list, cur) {
                 btree_node_t *node =
                     list_get_instance(cur, btree_node_t, leaf_link);
@@ -2098 +2090 @@
                         
                         info[area_idx].start_addr = area->base;
-                        info[area_idx].size = FRAMES2SIZE(area->pages);
+                        info[area_idx].size = P2SZ(area->pages);
                         info[area_idx].flags = area->flags;
                         ++area_idx;
@@ -2122 +2114 @@
         
         /* Print out info about address space areas */
-        link_t *cur;
-        for (cur = as->as_area_btree.leaf_head.next;
-            cur != &as->as_area_btree.leaf_head; cur = cur->next) {
+        list_foreach(as->as_area_btree.leaf_list, cur) {
                 btree_node_t *node
                     = list_get_instance(cur, btree_node_t, leaf_link);
@@ -2136 +2126 @@
                             " (%p - %p)\n", area, (void *) area->base,
                             area->pages, (void *) area->base,
-                            (void *) (area->base + FRAMES2SIZE(area->pages)));
+                            (void *) (area->base + P2SZ(area->pages)));
                         mutex_unlock(&area->lock);
                 }