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