WebSVN – HelenOS – Diff – /trunk/kernel/generic/src/mm/as.c

 /**
  * Slab for as_t objects.
  */
 static slab_cache_t *as_slab;
+/**
-/** This lock protects inactive_as_with_asid_head list. It must be acquired before as_t mutex. */
+ * This lock protects inactive_as_with_asid_head list. It must be acquired
+ * before as_t mutex.
+ */
 SPINLOCK_INITIALIZE(inactive_as_with_asid_lock);
 /**
  * This list contains address spaces that are not active on any
  * processor and that have valid ASID.
 /** Kernel address space. */
 as_t *AS_KERNEL = NULL;
 static int area_flags_to_page_flags(int aflags);
 static as_area_t *find_area_and_lock(as_t *as, uintptr_t va);
-static bool check_area_conflicts(as_t *as, uintptr_t va, size_t size, as_area_t *avoid_area);
+static bool check_area_conflicts(as_t *as, uintptr_t va, size_t size,
+    as_area_t *avoid_area);
 static void sh_info_remove_reference(share_info_t *sh_info);
 static int as_constructor(void *obj, int flags)
+{
     as_t *as = (as_t *) obj;
 void as_init(void)
+{
     as_arch_init();
     as_slab = slab_cache_create("as_slab", sizeof(as_t), 0,
         as_constructor, as_destructor, SLAB_CACHE_MAGDEFERRED);
     AS_KERNEL = as_create(FLAG_AS_KERNEL);
     if (!AS_KERNEL)
         panic("can't create kernel address space\n");
     return as;
+}
 /** Destroy adress space.
+ *
- * When there are no tasks referencing this address space (i.e. its refcount is zero),
+ * When there are no tasks referencing this address space (i.e. its refcount is
- * the address space can be destroyed.
+ * zero), the address space can be destroyed.
  */
 void as_destroy(as_t *as)
+{
     ipl_t ipl;
     bool cond;
      */
     for (cond = true; cond; ) {
         btree_node_t *node;
         ASSERT(!list_empty(&as->as_area_btree.leaf_head));
-        node = list_get_instance(as->as_area_btree.leaf_head.next, btree_node_t, leaf_link);
+        node = list_get_instance(as->as_area_btree.leaf_head.next,
+            btree_node_t, leaf_link);
         if ((cond = node->keys)) {
             as_area_destroy(as, node->key[0]);
+        }
+    }
     a->sh_info = NULL;
     a->backend = backend;
     if (backend_data)
         a->backend_data = *backend_data;
     else
-        memsetb((uintptr_t) &a->backend_data, sizeof(a->backend_data), 0);
+        memsetb((uintptr_t) &a->backend_data, sizeof(a->backend_data),
+);
     btree_create(&a->used_space);
     btree_insert(&as->as_area_btree, base, (void *) a, NULL);
+}
 /** Find address space area and change it.
+ *
  * @param as Address space.
- * @param address Virtual address belonging to the area to be changed. Must be page-aligned.
+ * @param address Virtual address belonging to the area to be changed. Must be
+ *     page-aligned.
  * @param size New size of the virtual memory block starting at address.
  * @param flags Flags influencing the remap operation. Currently unused.
+ *
  * @return Zero on success or a value from @ref errno.h otherwise.
  */
          */
         /*
          * Start TLB shootdown sequence.
          */
-        tlb_shootdown_start(TLB_INVL_PAGES, AS->asid, area->base + pages*PAGE_SIZE, area->pages - pages);
+        tlb_shootdown_start(TLB_INVL_PAGES, AS->asid, area->base +
+            pages * PAGE_SIZE, area->pages - pages);
         /*
          * Remove frames belonging to used space starting from
          * the highest addresses downwards until an overlap with
          * the resized address space area is found. Note that this
          */
         for (cond = true; cond;) {
             btree_node_t *node;
             ASSERT(!list_empty(&area->used_space.leaf_head));
+            node =
-            node = list_get_instance(area->used_space.leaf_head.prev, btree_node_t, leaf_link);
+                list_get_instance(area->used_space.leaf_head.prev,
+                btree_node_t, leaf_link);
             if ((cond = (bool) node->keys)) {
                 uintptr_t b = node->key[node->keys - 1];
+                count_t c =
-                count_t c = (count_t) node->value[node->keys - 1];
+                    (count_t) node->value[node->keys - 1];
                 int i = 0;
-                if (overlaps(b, c*PAGE_SIZE, area->base, pages*PAGE_SIZE)) {
+                if (overlaps(b, c * PAGE_SIZE, area->base,
+                    pages*PAGE_SIZE)) {
-                    if (b + c*PAGE_SIZE <= start_free) {
+                    if (b + c * PAGE_SIZE <= start_free) {
                         /*
-                         * The whole interval fits completely
+                         * The whole interval fits
+                         * completely in the resized
-                         * in the resized address space area.
+                         * address space area.
                          */
                         break;
+                    }
                     /*
-                     * Part of the interval corresponding to b and c
+                     * Part of the interval corresponding
-                     * overlaps with the resized address space area.
+                     * to b and c overlaps with the resized
+                     * address space area.
                      */
                     cond = false;   /* we are almost done */
                     i = (start_free - b) >> PAGE_WIDTH;
-                    if (!used_space_remove(area, start_free, c - i))
+                    if (!used_space_remove(area, start_free,
+                        c - i))
-                        panic("Could not remove used space.\n");
+                        panic("Could not remove used "
+                            "space.\n");
                 } else {
                     /*
-                     * The interval of used space can be completely removed.
+                     * The interval of used space can be
+                     * completely removed.
                      */
                     if (!used_space_remove(area, b, c))
-                        panic("Could not remove used space.\n");
+                        panic("Could not remove used "
+                            "space.\n");
+                }
                 for (; i < c; i++) {
                     pte_t *pte;
                     page_table_lock(as, false);
-                    pte = page_mapping_find(as, b + i*PAGE_SIZE);
+                    pte = page_mapping_find(as, b +
+                        i * PAGE_SIZE);
-                    ASSERT(pte && PTE_VALID(pte) && PTE_PRESENT(pte));
+                    ASSERT(pte && PTE_VALID(pte) &&
+                        PTE_PRESENT(pte));
+                    if (area->backend &&
-                    if (area->backend && area->backend->frame_free) {
+                        area->backend->frame_free) {
                         area->backend->frame_free(area,
+                            b + i * PAGE_SIZE,
-                            b + i*PAGE_SIZE, PTE_GET_FRAME(pte));
+                            PTE_GET_FRAME(pte));
+                    }
-                    page_mapping_remove(as, b + i*PAGE_SIZE);
+                    page_mapping_remove(as, b +
+                        i * PAGE_SIZE);
                     page_table_unlock(as, false);
+                }
+            }
+        }
         /*
          * Finish TLB shootdown sequence.
          */
-        tlb_invalidate_pages(as->asid, area->base + pages*PAGE_SIZE, area->pages - pages);
+        tlb_invalidate_pages(as->asid, area->base + pages * PAGE_SIZE,
+            area->pages - pages);
         tlb_shootdown_finalize();
         /*
          * Invalidate software translation caches (e.g. TSB on sparc64).
          */
-        as_invalidate_translation_cache(as, area->base + pages*PAGE_SIZE, area->pages - pages);
+        as_invalidate_translation_cache(as, area->base +
+            pages * PAGE_SIZE, area->pages - pages);
     } else {
         /*
          * Growing the area.
          * Check for overlaps with other address space areas.
          */
-        if (!check_area_conflicts(as, address, pages * PAGE_SIZE, area)) {
+        if (!check_area_conflicts(as, address, pages * PAGE_SIZE,
+            area)) {
             mutex_unlock(&area->lock);
             mutex_unlock(&as->lock);
             interrupts_restore(ipl);
             return EADDRNOTAVAIL;
+        }
     tlb_shootdown_start(TLB_INVL_PAGES, as->asid, area->base, area->pages);
     /*
      * Visit only the pages mapped by used_space B+tree.
      */
+    for (cur = area->used_space.leaf_head.next;
-    for (cur = area->used_space.leaf_head.next; cur != &area->used_space.leaf_head; cur = cur->next) {
+        cur != &area->used_space.leaf_head; cur = cur->next) {
         btree_node_t *node;
         int i;
         node = list_get_instance(cur, btree_node_t, leaf_link);
         for (i = 0; i < node->keys; i++) {
             count_t j;
             pte_t *pte;
             for (j = 0; j < (count_t) node->value[i]; j++) {
                 page_table_lock(as, false);
-                pte = page_mapping_find(as, b + j*PAGE_SIZE);
+                pte = page_mapping_find(as, b + j * PAGE_SIZE);
-                ASSERT(pte && PTE_VALID(pte) && PTE_PRESENT(pte));
+                ASSERT(pte && PTE_VALID(pte) &&
+                    PTE_PRESENT(pte));
+                if (area->backend &&
-                if (area->backend && area->backend->frame_free) {
+                    area->backend->frame_free) {
-                    area->backend->frame_free(area,
+                    area->backend->frame_free(area, b +
-                        b + j*PAGE_SIZE, PTE_GET_FRAME(pte));
+                    j * PAGE_SIZE, PTE_GET_FRAME(pte));
+                }
-                page_mapping_remove(as, b + j*PAGE_SIZE);
+                page_mapping_remove(as, b + j * PAGE_SIZE);
                 page_table_unlock(as, false);
+            }
+        }
+    }
      */
     tlb_invalidate_pages(as->asid, area->base, area->pages);
     tlb_shootdown_finalize();
     /*
-     * Invalidate potential software translation caches (e.g. TSB on sparc64).
+     * Invalidate potential software translation caches (e.g. TSB on
+     * sparc64).
      */
     as_invalidate_translation_cache(as, area->base, area->pages);
     btree_destroy(&area->used_space);
     /* Share the cacheable flag from the original mapping */
     if (src_flags & AS_AREA_CACHEABLE)
         dst_flags_mask |= AS_AREA_CACHEABLE;
+    if (src_size != acc_size ||
-    if (src_size != acc_size || (src_flags & dst_flags_mask) != dst_flags_mask) {
+        (src_flags & dst_flags_mask) != dst_flags_mask) {
         mutex_unlock(&src_area->lock);
         mutex_unlock(&src_as->lock);
         interrupts_restore(ipl);
         return EPERM;
+    }
      * preliminary as_page_fault() calls.
      * The flags of the source area are masked against dst_flags_mask
      * to support sharing in less privileged mode.
      */
     dst_area = as_area_create(dst_as, dst_flags_mask, src_size, dst_base,
-                  AS_AREA_ATTR_PARTIAL, src_backend, &src_backend_data);
+        AS_AREA_ATTR_PARTIAL, src_backend, &src_backend_data);
     if (!dst_area) {
         /*
          * Destination address space area could not be created.
          */
         sh_info_remove_reference(sh_info);
      * the mapping has not been already inserted.
      */
     if ((pte = page_mapping_find(AS, page))) {
         if (PTE_PRESENT(pte)) {
             if (((access == PF_ACCESS_READ) && PTE_READABLE(pte)) ||
                 (access == PF_ACCESS_WRITE && PTE_WRITABLE(pte)) ||
                 (access == PF_ACCESS_EXEC && PTE_EXECUTABLE(pte))) {
                 page_table_unlock(AS, false);
                 mutex_unlock(&area->lock);
                 mutex_unlock(&AS->lock);
                 return AS_PF_OK;
+            }
     return AS_PF_OK;
 page_fault:
     if (THREAD->in_copy_from_uspace) {
         THREAD->in_copy_from_uspace = false;
+        istate_set_retaddr(istate,
-        istate_set_retaddr(istate, (uintptr_t) &memcpy_from_uspace_failover_address);
+            (uintptr_t) &memcpy_from_uspace_failover_address);
     } else if (THREAD->in_copy_to_uspace) {
         THREAD->in_copy_to_uspace = false;
+        istate_set_retaddr(istate,
-        istate_set_retaddr(istate, (uintptr_t) &memcpy_to_uspace_failover_address);
+            (uintptr_t) &memcpy_to_uspace_failover_address);
     } else {
         return AS_PF_FAULT;
+    }
     return AS_PF_DEFER;
              * any processor. It can be appended to the
              * list of inactive address spaces with assigned
              * ASID.
              */
              ASSERT(old->asid != ASID_INVALID);
-             list_append(&old->inactive_as_with_asid_link, &inactive_as_with_asid_head);
+             list_append(&old->inactive_as_with_asid_link,
+                 &inactive_as_with_asid_head);
+        }
         mutex_unlock(&old->lock);
         /*
          * Perform architecture-specific tasks when the address space
     /*
      * Second, prepare the new address space.
      */
     mutex_lock_active(&new->lock);
     if ((new->cpu_refcount++ == 0) && (new != AS_KERNEL)) {
-        if (new->asid != ASID_INVALID)
+        if (new->asid != ASID_INVALID) {
             list_remove(&new->inactive_as_with_asid_link);
-        else
+        } else {
+            /*
-            needs_asid = true;  /* defer call to asid_get() until new->lock is released */
+             * Defer call to asid_get() until new->lock is released.
+             */
+            needs_asid = true;
+        }
+    }
     SET_PTL0_ADDRESS(new->page_table);
     mutex_unlock(&new->lock);
     if (needs_asid) {
  * The address space must be locked and interrupts must be disabled.
+ *
  * @param as Address space.
  * @param va Virtual address.
+ *
- * @return Locked address space area containing va on success or NULL on failure.
+ * @return Locked address space area containing va on success or NULL on
+ *     failure.
  */
 as_area_t *find_area_and_lock(as_t *as, uintptr_t va)
+{
     as_area_t *a;
     btree_node_t *leaf, *lnode;
     /*
      * Second, locate the left neighbour and test its last record.
      * Because of its position in the B+tree, it must have base < va.
      */
-    if ((lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf))) {
+    lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf);
+    if (lnode) {
         a = (as_area_t *) lnode->value[lnode->keys - 1];
         mutex_lock(&a->lock);
         if (va < a->base + a->pages * PAGE_SIZE) {
             return a;
+        }
  * @param size Size of the area being tested.
  * @param avoid_area Do not touch this area.
+ *
  * @return True if there is no conflict, false otherwise.
  */
-bool check_area_conflicts(as_t *as, uintptr_t va, size_t size, as_area_t *avoid_area)
+bool check_area_conflicts(as_t *as, uintptr_t va, size_t size,
+              as_area_t *avoid_area)
+{
     as_area_t *a;
     btree_node_t *leaf, *node;
     int i;
             mutex_unlock(&a->lock);
             return false;
+        }
         mutex_unlock(&a->lock);
+    }
-    if ((node = btree_leaf_node_right_neighbour(&as->as_area_btree, leaf))) {
+    node = btree_leaf_node_right_neighbour(&as->as_area_btree, leaf);
+    if (node) {
         a = (as_area_t *) node->value[0];
         mutex_lock(&a->lock);
         if (overlaps(va, size, a->base, a->pages * PAGE_SIZE)) {
             mutex_unlock(&a->lock);
             return false;
      * So far, the area does not conflict with other areas.
      * Check if it doesn't conflict with kernel address space.
      */
     if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
         return !overlaps(va, size,
+            KERNEL_ADDRESS_SPACE_START,
-            KERNEL_ADDRESS_SPACE_START, KERNEL_ADDRESS_SPACE_END-KERNEL_ADDRESS_SPACE_START);
+            KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
+    }
     return true;
+}
         return 1;
+    }
     node = btree_leaf_node_left_neighbour(&a->used_space, leaf);
     if (node) {
-        uintptr_t left_pg = node->key[node->keys - 1], right_pg = leaf->key[0];
+        uintptr_t left_pg = node->key[node->keys - 1];
+        uintptr_t right_pg = leaf->key[0];
-        count_t left_cnt = (count_t) node->value[node->keys - 1], right_cnt = (count_t) leaf->value[0];
+        count_t left_cnt = (count_t) node->value[node->keys - 1];
+        count_t right_cnt = (count_t) leaf->value[0];
         /*
          * Examine the possibility that the interval fits
          * somewhere between the rightmost interval of
          * the left neigbour and the first interval of the leaf.
          */
         if (page >= right_pg) {
             /* Do nothing. */
-        } else if (overlaps(page, count*PAGE_SIZE, left_pg, left_cnt*PAGE_SIZE)) {
+        } else if (overlaps(page, count * PAGE_SIZE, left_pg,
+            left_cnt * PAGE_SIZE)) {
             /* The interval intersects with the left interval. */
             return 0;
-        } else if (overlaps(page, count*PAGE_SIZE, right_pg, right_cnt*PAGE_SIZE)) {
+        } else if (overlaps(page, count * PAGE_SIZE, right_pg,
+            right_cnt * PAGE_SIZE)) {
             /* The interval intersects with the right interval. */
             return 0;
-        } else if ((page == left_pg + left_cnt*PAGE_SIZE) && (page + count*PAGE_SIZE == right_pg)) {
+        } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
+            (page + count * PAGE_SIZE == right_pg)) {
+            /*
-            /* The interval can be added by merging the two already present intervals. */
+             * The interval can be added by merging the two already
+             * present intervals.
+             */
             node->value[node->keys - 1] += count + right_cnt;
             btree_remove(&a->used_space, right_pg, leaf);
             return 1;
-        } else if (page == left_pg + left_cnt*PAGE_SIZE) {
+        } else if (page == left_pg + left_cnt * PAGE_SIZE) {
+            /*
-            /* The interval can be added by simply growing the left interval. */
+             * The interval can be added by simply growing the left
+             * interval.
+             */
             node->value[node->keys - 1] += count;
             return 1;
-        } else if (page + count*PAGE_SIZE == right_pg) {
+        } else if (page + count * PAGE_SIZE == right_pg) {
             /*
-             * The interval can be addded by simply moving base of the right
+             * The interval can be addded by simply moving base of
-             * interval down and increasing its size accordingly.
+             * the right interval down and increasing its size
+             * accordingly.
              */
             leaf->value[0] += count;
             leaf->key[0] = page;
             return 1;
         } else {
             /*
              * The interval is between both neigbouring intervals,
              * but cannot be merged with any of them.
              */
-            btree_insert(&a->used_space, page, (void *) count, leaf);
+            btree_insert(&a->used_space, page, (void *) count,
+                leaf);
             return 1;
+        }
     } else if (page < leaf->key[0]) {
         uintptr_t right_pg = leaf->key[0];
         count_t right_cnt = (count_t) leaf->value[0];
         /*
-         * Investigate the border case in which the left neighbour does not
+         * Investigate the border case in which the left neighbour does
-         * exist but the interval fits from the left.
+         * not exist but the interval fits from the left.
          */
-        if (overlaps(page, count*PAGE_SIZE, right_pg, right_cnt*PAGE_SIZE)) {
+        if (overlaps(page, count * PAGE_SIZE, right_pg,
+            right_cnt * PAGE_SIZE)) {
             /* The interval intersects with the right interval. */
             return 0;
-        } else if (page + count*PAGE_SIZE == right_pg) {
+        } else if (page + count * PAGE_SIZE == right_pg) {
             /*
-             * The interval can be added by moving the base of the right interval down
+             * The interval can be added by moving the base of the
-             * and increasing its size accordingly.
+             * right interval down and increasing its size
+             * accordingly.
              */
             leaf->key[0] = page;
             leaf->value[0] += count;
             return 1;
         } else {
             /*
              * The interval doesn't adjoin with the right interval.
              * It must be added individually.
              */
-            btree_insert(&a->used_space, page, (void *) count, leaf);
+            btree_insert(&a->used_space, page, (void *) count,
+                leaf);
             return 1;
+        }
+    }
     node = btree_leaf_node_right_neighbour(&a->used_space, leaf);
     if (node) {
-        uintptr_t left_pg = leaf->key[leaf->keys - 1], right_pg = node->key[0];
+        uintptr_t left_pg = leaf->key[leaf->keys - 1];
+        uintptr_t right_pg = node->key[0];
-        count_t left_cnt = (count_t) leaf->value[leaf->keys - 1], right_cnt = (count_t) node->value[0];
+        count_t left_cnt = (count_t) leaf->value[leaf->keys - 1];
+        count_t right_cnt = (count_t) node->value[0];
         /*
          * Examine the possibility that the interval fits
          * somewhere between the leftmost interval of
          * the right neigbour and the last interval of the leaf.
          */
         if (page < left_pg) {
             /* Do nothing. */
-        } else if (overlaps(page, count*PAGE_SIZE, left_pg, left_cnt*PAGE_SIZE)) {
+        } else if (overlaps(page, count * PAGE_SIZE, left_pg,
+            left_cnt * PAGE_SIZE)) {
             /* The interval intersects with the left interval. */
             return 0;
-        } else if (overlaps(page, count*PAGE_SIZE, right_pg, right_cnt*PAGE_SIZE)) {
+        } else if (overlaps(page, count * PAGE_SIZE, right_pg,
+            right_cnt * PAGE_SIZE)) {
             /* The interval intersects with the right interval. */
             return 0;
-        } else if ((page == left_pg + left_cnt*PAGE_SIZE) && (page + count*PAGE_SIZE == right_pg)) {
+        } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
+            (page + count * PAGE_SIZE == right_pg)) {
+            /*
-            /* The interval can be added by merging the two already present intervals. */
+             * The interval can be added by merging the two already
+             * present intervals.
+             * */
             leaf->value[leaf->keys - 1] += count + right_cnt;
             btree_remove(&a->used_space, right_pg, node);
             return 1;
-        } else if (page == left_pg + left_cnt*PAGE_SIZE) {
+        } else if (page == left_pg + left_cnt * PAGE_SIZE) {
+            /*
-            /* The interval can be added by simply growing the left interval. */
+             * The interval can be added by simply growing the left
+             * interval.
+             * */
             leaf->value[leaf->keys - 1] +=  count;
             return 1;
-        } else if (page + count*PAGE_SIZE == right_pg) {
+        } else if (page + count * PAGE_SIZE == right_pg) {
             /*
-             * The interval can be addded by simply moving base of the right
+             * The interval can be addded by simply moving base of
-             * interval down and increasing its size accordingly.
+             * the right interval down and increasing its size
+             * accordingly.
              */
             node->value[0] += count;
             node->key[0] = page;
             return 1;
         } else {
             /*
              * The interval is between both neigbouring intervals,
              * but cannot be merged with any of them.
              */
-            btree_insert(&a->used_space, page, (void *) count, leaf);
+            btree_insert(&a->used_space, page, (void *) count,
+                leaf);
             return 1;
+        }
     } else if (page >= leaf->key[leaf->keys - 1]) {
         uintptr_t left_pg = leaf->key[leaf->keys - 1];
         count_t left_cnt = (count_t) leaf->value[leaf->keys - 1];
         /*
-         * Investigate the border case in which the right neighbour does not
+         * Investigate the border case in which the right neighbour
-         * exist but the interval fits from the right.
+         * does not exist but the interval fits from the right.
          */
-        if (overlaps(page, count*PAGE_SIZE, left_pg, left_cnt*PAGE_SIZE)) {
+        if (overlaps(page, count * PAGE_SIZE, left_pg,
+            left_cnt * PAGE_SIZE)) {
             /* The interval intersects with the left interval. */
             return 0;
-        } else if (left_pg + left_cnt*PAGE_SIZE == page) {
+        } else if (left_pg + left_cnt * PAGE_SIZE == page) {
+            /*
-            /* The interval can be added by growing the left interval. */
+             * The interval can be added by growing the left
+             * interval.
+             */
             leaf->value[leaf->keys - 1] += count;
             return 1;
         } else {
             /*
              * The interval doesn't adjoin with the left interval.
              * It must be added individually.
              */
-            btree_insert(&a->used_space, page, (void *) count, leaf);
+            btree_insert(&a->used_space, page, (void *) count,
+                leaf);
             return 1;
+        }
+    }
     /*
-     * Note that if the algorithm made it thus far, the interval can fit only
+     * Note that if the algorithm made it thus far, the interval can fit
-     * between two other intervals of the leaf. The two border cases were already
+     * only between two other intervals of the leaf. The two border cases
-     * resolved.
+     * were already resolved.
      */
     for (i = 1; i < leaf->keys; i++) {
         if (page < leaf->key[i]) {
-            uintptr_t left_pg = leaf->key[i - 1], right_pg = leaf->key[i];
+            uintptr_t left_pg = leaf->key[i - 1];
+            uintptr_t right_pg = leaf->key[i];
-            count_t left_cnt = (count_t) leaf->value[i - 1], right_cnt = (count_t) leaf->value[i];
+            count_t left_cnt = (count_t) leaf->value[i - 1];
+            count_t right_cnt = (count_t) leaf->value[i];
             /*
              * The interval fits between left_pg and right_pg.
              */
-            if (overlaps(page, count*PAGE_SIZE, left_pg, left_cnt*PAGE_SIZE)) {
+            if (overlaps(page, count * PAGE_SIZE, left_pg,
+                left_cnt * PAGE_SIZE)) {
+                /*
-                /* The interval intersects with the left interval. */
+                 * The interval intersects with the left
+                 * interval.
+                 */
                 return 0;
-            } else if (overlaps(page, count*PAGE_SIZE, right_pg, right_cnt*PAGE_SIZE)) {
+            } else if (overlaps(page, count * PAGE_SIZE, right_pg,
+                right_cnt * PAGE_SIZE)) {
+                /*
-                /* The interval intersects with the right interval. */
+                 * The interval intersects with the right
+                 * interval.
+                 */
                 return 0;
-            } else if ((page == left_pg + left_cnt*PAGE_SIZE) && (page + count*PAGE_SIZE == right_pg)) {
+            } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
+                (page + count * PAGE_SIZE == right_pg)) {
+                /*
-                /* The interval can be added by merging the two already present intervals. */
+                 * The interval can be added by merging the two
+                 * already present intervals.
+                 */
                 leaf->value[i - 1] += count + right_cnt;
                 btree_remove(&a->used_space, right_pg, leaf);
                 return 1;
-            } else if (page == left_pg + left_cnt*PAGE_SIZE) {
+            } else if (page == left_pg + left_cnt * PAGE_SIZE) {
+                /*
-                /* The interval can be added by simply growing the left interval. */
+                 * The interval can be added by simply growing
+                 * the left interval.
+                 */
                 leaf->value[i - 1] += count;
                 return 1;
-            } else if (page + count*PAGE_SIZE == right_pg) {
+            } else if (page + count * PAGE_SIZE == right_pg) {
                 /*
-                     * The interval can be addded by simply moving base of the right
+                     * The interval can be addded by simply moving
+                 * base of the right interval down and
-                 * interval down and increasing its size accordingly.
+                 * increasing its size accordingly.
                  */
                 leaf->value[i] += count;
                 leaf->key[i] = page;
                 return 1;
             } else {
                 /*
-                 * The interval is between both neigbouring intervals,
+                 * The interval is between both neigbouring
-                 * but cannot be merged with any of them.
+                 * intervals, but cannot be merged with any of
+                 * them.
                  */
-                btree_insert(&a->used_space, page, (void *) count, leaf);
+                btree_insert(&a->used_space, page,
+                    (void *) count, leaf);
                 return 1;
+            }
+        }
+    }
-    panic("Inconsistency detected while adding %d pages of used space at %p.\n", count, page);
+    panic("Inconsistency detected while adding %d pages of used space at "
+        "%p.\n", count, page);
+}
 /** Mark portion of address space area as unused.
+ *
  * The address space area must be already locked.
              * Find the respective interval.
              * Decrease its size and relocate its start address.
              */
             for (i = 0; i < leaf->keys; i++) {
                 if (leaf->key[i] == page) {
-                    leaf->key[i] += count*PAGE_SIZE;
+                    leaf->key[i] += count * PAGE_SIZE;
                     leaf->value[i] -= count;
                     return 1;
+                }
+            }
             goto error;
     node = btree_leaf_node_left_neighbour(&a->used_space, leaf);
     if (node && page < leaf->key[0]) {
         uintptr_t left_pg = node->key[node->keys - 1];
         count_t left_cnt = (count_t) node->value[node->keys - 1];
-        if (overlaps(left_pg, left_cnt*PAGE_SIZE, page, count*PAGE_SIZE)) {
+        if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,
+            count * PAGE_SIZE)) {
+            if (page + count * PAGE_SIZE ==
-            if (page + count*PAGE_SIZE == left_pg + left_cnt*PAGE_SIZE) {
+                left_pg + left_cnt * PAGE_SIZE) {
                 /*
-                 * The interval is contained in the rightmost interval
+                 * The interval is contained in the rightmost
-                 * of the left neighbour and can be removed by
+                 * interval of the left neighbour and can be
-                 * updating the size of the bigger interval.
+                 * removed by updating the size of the bigger
+                 * interval.
                  */
                 node->value[node->keys - 1] -= count;
                 return 1;
-            } else if (page + count*PAGE_SIZE < left_pg + left_cnt*PAGE_SIZE) {
+            } else if (page + count * PAGE_SIZE <
+                left_pg + left_cnt*PAGE_SIZE) {
                 count_t new_cnt;
                 /*
-                 * The interval is contained in the rightmost interval
+                 * The interval is contained in the rightmost
-                 * of the left neighbour but its removal requires
+                 * interval of the left neighbour but its
+                 * removal requires both updating the size of
-                 * both updating the size of the original interval and
+                 * the original interval and also inserting a
-                 * also inserting a new interval.
+                 * new interval.
                  */
+                new_cnt = ((left_pg + left_cnt * PAGE_SIZE) -
-                new_cnt = ((left_pg + left_cnt*PAGE_SIZE) - (page + count*PAGE_SIZE)) >> PAGE_WIDTH;
+                    (page + count*PAGE_SIZE)) >> PAGE_WIDTH;
                 node->value[node->keys - 1] -= count + new_cnt;
+                btree_insert(&a->used_space, page +
-                btree_insert(&a->used_space, page + count*PAGE_SIZE, (void *) new_cnt, leaf);
+                    count * PAGE_SIZE, (void *) new_cnt, leaf);
                 return 1;
+            }
+        }
         return 0;
     } else if (page < leaf->key[0]) {
     if (page > leaf->key[leaf->keys - 1]) {
         uintptr_t left_pg = leaf->key[leaf->keys - 1];
         count_t left_cnt = (count_t) leaf->value[leaf->keys - 1];
-        if (overlaps(left_pg, left_cnt*PAGE_SIZE, page, count*PAGE_SIZE)) {
+        if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,
+            count * PAGE_SIZE)) {
+            if (page + count * PAGE_SIZE ==
-            if (page + count*PAGE_SIZE == left_pg + left_cnt*PAGE_SIZE) {
+                left_pg + left_cnt * PAGE_SIZE) {
                 /*
-                 * The interval is contained in the rightmost interval
+                 * The interval is contained in the rightmost
-                 * of the leaf and can be removed by updating the size
+                 * interval of the leaf and can be removed by
-                 * of the bigger interval.
+                 * updating the size of the bigger interval.
                  */
                 leaf->value[leaf->keys - 1] -= count;
                 return 1;
-            } else if (page + count*PAGE_SIZE < left_pg + left_cnt*PAGE_SIZE) {
+            } else if (page + count * PAGE_SIZE < left_pg +
+                left_cnt * PAGE_SIZE) {
                 count_t new_cnt;
                 /*
-                 * The interval is contained in the rightmost interval
+                 * The interval is contained in the rightmost
-                 * of the leaf but its removal requires both updating
+                 * interval of the leaf but its removal
-                 * the size of the original interval and
+                 * requires both updating the size of the
-                 * also inserting a new interval.
+                 * original interval and also inserting a new
+                 * interval.
                  */
-                new_cnt = ((left_pg + left_cnt*PAGE_SIZE) - (page + count*PAGE_SIZE)) >> PAGE_WIDTH;
+                new_cnt = ((left_pg + left_cnt * PAGE_SIZE) -
+                    (page + count * PAGE_SIZE)) >> PAGE_WIDTH;
                 leaf->value[leaf->keys - 1] -= count + new_cnt;
+                btree_insert(&a->used_space, page +
-                btree_insert(&a->used_space, page + count*PAGE_SIZE, (void *) new_cnt, leaf);
+                    count * PAGE_SIZE, (void *) new_cnt, leaf);
                 return 1;
+            }
+        }
         return 0;
+    }
         if (page < leaf->key[i]) {
             uintptr_t left_pg = leaf->key[i - 1];
             count_t left_cnt = (count_t) leaf->value[i - 1];
             /*
-             * Now the interval is between intervals corresponding to (i - 1) and i.
+             * Now the interval is between intervals corresponding
+             * to (i - 1) and i.
              */
-            if (overlaps(left_pg, left_cnt*PAGE_SIZE, page, count*PAGE_SIZE)) {
+            if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,
+                count * PAGE_SIZE)) {
+                if (page + count * PAGE_SIZE ==
-                if (page + count*PAGE_SIZE == left_pg + left_cnt*PAGE_SIZE) {
+                    left_pg + left_cnt*PAGE_SIZE) {
                     /*
-                    * The interval is contained in the interval (i - 1)
+                     * The interval is contained in the
+                     * interval (i - 1) of the leaf and can
-                     * of the leaf and can be removed by updating the size
+                     * be removed by updating the size of
-                     * of the bigger interval.
+                     * the bigger interval.
                      */
                     leaf->value[i - 1] -= count;
                     return 1;
-                } else if (page + count*PAGE_SIZE < left_pg + left_cnt*PAGE_SIZE) {
+                } else if (page + count * PAGE_SIZE <
+                    left_pg + left_cnt * PAGE_SIZE) {
                     count_t new_cnt;
                     /*
-                     * The interval is contained in the interval (i - 1)
+                     * The interval is contained in the
+                     * interval (i - 1) of the leaf but its
-                     * of the leaf but its removal requires both updating
+                     * removal requires both updating the
-                     * the size of the original interval and
+                     * size of the original interval and
                      * also inserting a new interval.
                      */
+                    new_cnt = ((left_pg +
+                        left_cnt * PAGE_SIZE) -
-                    new_cnt = ((left_pg + left_cnt*PAGE_SIZE) - (page + count*PAGE_SIZE)) >> PAGE_WIDTH;
+                        (page + count * PAGE_SIZE)) >>
+                        PAGE_WIDTH;
                     leaf->value[i - 1] -= count + new_cnt;
+                    btree_insert(&a->used_space, page +
-                    btree_insert(&a->used_space, page + count*PAGE_SIZE, (void *) new_cnt, leaf);
+                        count * PAGE_SIZE, (void *) new_cnt,
+                        leaf);
                     return 1;
+                }
+            }
             return 0;
+        }
+    }
 error:
-    panic("Inconsistency detected while removing %d pages of used space from %p.\n", count, page);
+    panic("Inconsistency detected while removing %d pages of used space "
+        "from %p.\n", count, page);
+}
 /** Remove reference to address space area share info.
+ *
  * If the reference count drops to 0, the sh_info is deallocated.
         /*
          * Now walk carefully the pagemap B+tree and free/remove
          * reference from all frames found there.
          */
+        for (cur = sh_info->pagemap.leaf_head.next;
-        for (cur = sh_info->pagemap.leaf_head.next; cur != &sh_info->pagemap.leaf_head; cur = cur->next) {
+            cur != &sh_info->pagemap.leaf_head; cur = cur->next) {
             btree_node_t *node;
             int i;
             node = list_get_instance(cur, btree_node_t, leaf_link);
             for (i = 0; i < node->keys; i++)
  */
 /** Wrapper for as_area_create(). */
 unative_t sys_as_area_create(uintptr_t address, size_t size, int flags)
+{
-    if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address, AS_AREA_ATTR_NONE, &anon_backend, NULL))
+    if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address,
+        AS_AREA_ATTR_NONE, &anon_backend, NULL))
         return (unative_t) address;
     else
         return (unative_t) -1;
+}
     ipl = interrupts_disable();
     mutex_lock(&as->lock);
     /* print out info about address space areas */
     link_t *cur;
+    for (cur = as->as_area_btree.leaf_head.next;
-    for (cur = as->as_area_btree.leaf_head.next; cur != &as->as_area_btree.leaf_head; cur = cur->next) {
+        cur != &as->as_area_btree.leaf_head; cur = cur->next) {
+        btree_node_t *node;
-        btree_node_t *node = list_get_instance(cur, btree_node_t, leaf_link);
+        node = list_get_instance(cur, btree_node_t, leaf_link);
         int i;
         for (i = 0; i < node->keys; i++) {
             as_area_t *area = node->value[i];
             mutex_lock(&area->lock);
             printf("as_area: %p, base=%p, pages=%d (%p - %p)\n",
-                area, area->base, area->pages, area->base, area->base + area->pages*PAGE_SIZE);
+                area, area->base, area->pages, area->base,
+                area->base + area->pages*PAGE_SIZE);
             mutex_unlock(&area->lock);
+        }
+    }
     mutex_unlock(&as->lock);

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/src/mm/as.c – Rev 2071 → 2087