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

 #ifdef CONFIG_VIRT_IDX_DCACHE
 #include <arch/mm/cache.h>
 #endif /* CONFIG_VIRT_IDX_DCACHE */
-#ifndef __OBJC__
 /**
  * Each architecture decides what functions will be used to carry out
  * address space operations such as creating or locking page tables.
  */
 as_operations_t *as_operations = NULL;
 /**
  * Slab for as_t objects.
  */
 static slab_cache_t *as_slab;
-#endif
 /**
  * This lock serializes access to the ASID subsystem.
  * It protects:
  * - inactive_as_with_asid_head list
 LIST_INITIALIZE(inactive_as_with_asid_head);
 /** Kernel address space. */
 as_t *AS_KERNEL = NULL;
-static int area_flags_to_page_flags(int aflags);
+static int area_flags_to_page_flags(int);
-static as_area_t *find_area_and_lock(as_t *as, uintptr_t va);
+static as_area_t *find_area_and_lock(as_t *, uintptr_t);
-static bool check_area_conflicts(as_t *as, uintptr_t va, size_t size,
+static bool check_area_conflicts(as_t *, uintptr_t, size_t, as_area_t *);
-    as_area_t *avoid_area);
-static void sh_info_remove_reference(share_info_t *sh_info);
+static void sh_info_remove_reference(share_info_t *);
-#ifndef __OBJC__
 static int as_constructor(void *obj, int flags)
+{
     as_t *as = (as_t *) obj;
     int rc;
     link_initialize(&as->inactive_as_with_asid_link);
-    mutex_initialize(&as->lock);
+    mutex_initialize(&as->lock, MUTEX_PASSIVE);
     rc = as_constructor_arch(as, flags);
     return rc;
+}
+{
     as_t *as = (as_t *) obj;
     return as_destructor_arch(as);
+}
-#endif
 /** Initialize address space subsystem. */
 void as_init(void)
+{
     as_arch_init();
-#ifndef __OBJC__
     as_slab = slab_cache_create("as_slab", sizeof(as_t), 0,
         as_constructor, as_destructor, SLAB_CACHE_MAGDEFERRED);
-#endif
     AS_KERNEL = as_create(FLAG_AS_KERNEL);
     if (!AS_KERNEL)
         panic("can't create kernel address space\n");
+}
 /** Create address space.
+ *
- * @param flags Flags that influence way in wich the address space is created.
+ * @param flags     Flags that influence the way in wich the address space
+ *          is created.
  */
 as_t *as_create(int flags)
+{
     as_t *as;
-#ifdef __OBJC__
-    as = [as_t new];
-    link_initialize(&as->inactive_as_with_asid_link);
-    mutex_initialize(&as->lock);
-    (void) as_constructor_arch(as, flags);
-#else
     as = (as_t *) slab_alloc(as_slab, 0);
-#endif
     (void) as_create_arch(as, 0);
     btree_create(&as->as_area_btree);
     if (flags & FLAG_AS_KERNEL)
+ *
  * When there are no tasks referencing this address space (i.e. its refcount is
  * zero), the address space can be destroyed.
+ *
  * We know that we don't hold any spinlock.
+ *
+ * @param as        Address space to be destroyed.
  */
 void as_destroy(as_t *as)
+{
     ipl_t ipl;
     bool cond;
     page_table_destroy(NULL);
 #endif
     interrupts_restore(ipl);
-#ifdef __OBJC__
-    [as free];
-#else
     slab_free(as_slab, as);
-#endif
+}
 /** Create address space area of common attributes.
+ *
  * The created address space area is added to the target address space.
+ *
- * @param as Target address space.
+ * @param as        Target address space.
- * @param flags Flags of the area memory.
+ * @param flags     Flags of the area memory.
- * @param size Size of area.
+ * @param size      Size of area.
- * @param base Base address of area.
+ * @param base      Base address of area.
- * @param attrs Attributes of the area.
+ * @param attrs     Attributes of the area.
- * @param backend Address space area backend. NULL if no backend is used.
+ * @param backend   Address space area backend. NULL if no backend is used.
- * @param backend_data NULL or a pointer to an array holding two void *.
+ * @param backend_data  NULL or a pointer to an array holding two void *.
+ *
- * @return Address space area on success or NULL on failure.
+ * @return      Address space area on success or NULL on failure.
  */
 as_area_t *
 as_area_create(as_t *as, int flags, size_t size, uintptr_t base, int attrs,
-           mem_backend_t *backend, mem_backend_data_t *backend_data)
+    mem_backend_t *backend, mem_backend_data_t *backend_data)
+{
     ipl_t ipl;
     as_area_t *a;
     if (base % PAGE_SIZE)
         return NULL;
+    }
     a = (as_area_t *) malloc(sizeof(as_area_t), 0);
-    mutex_initialize(&a->lock);
+    mutex_initialize(&a->lock, MUTEX_PASSIVE);
     a->as = as;
     a->flags = flags;
     a->attributes = attrs;
     a->pages = SIZE2FRAMES(size);
     return a;
+}
 /** Find address space area and change it.
+ *
- * @param as Address space.
+ * @param as        Address space.
- * @param address Virtual address belonging to the area to be changed. Must be
+ * @param address   Virtual address belonging to the area to be changed.
- *     page-aligned.
+ *          Must be page-aligned.
- * @param size New size of the virtual memory block starting at address.
+ * @param size      New size of the virtual memory block starting at
+ *          address.
- * @param flags Flags influencing the remap operation. Currently unused.
+ * @param flags     Flags influencing the remap operation. Currently unused.
+ *
- * @return Zero on success or a value from @ref errno.h otherwise.
+ * @return      Zero on success or a value from @ref errno.h otherwise.
  */
 int as_area_resize(as_t *as, uintptr_t address, size_t size, int flags)
+{
     as_area_t *area;
     ipl_t ipl;
         return EPERM;
+    }
     if (pages < area->pages) {
         bool cond;
-        uintptr_t start_free = area->base + pages*PAGE_SIZE;
+        uintptr_t start_free = area->base + pages * PAGE_SIZE;
         /*
          * Shrinking the area.
          * No need to check for overlaps.
          */
         /*
          * Start TLB shootdown sequence.
          */
-        tlb_shootdown_start(TLB_INVL_PAGES, AS->asid, area->base +
+        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
                      * 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.
                      */
                     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;
     return 0;
+}
 /** Destroy address space area.
+ *
- * @param as Address space.
+ * @param as        Address space.
- * @param address Address withing the area to be deleted.
+ * @param address   Address within the area to be deleted.
+ *
- * @return Zero on success or a value from @ref errno.h on failure.
+ * @return      Zero on success or a value from @ref errno.h on failure.
  */
 int as_area_destroy(as_t *as, uintptr_t address)
+{
     as_area_t *area;
     uintptr_t base;
  * If the source address space area has not been shared so far,
  * a new sh_info is created. The new address space area simply gets the
  * sh_info of the source area. The process of duplicating the
  * mapping is done through the backend share function.
+ *
- * @param src_as Pointer to source address space.
+ * @param src_as    Pointer to source address space.
- * @param src_base Base address of the source address space area.
+ * @param src_base  Base address of the source address space area.
- * @param acc_size Expected size of the source area.
+ * @param acc_size  Expected size of the source area.
- * @param dst_as Pointer to destination address space.
+ * @param dst_as    Pointer to destination address space.
- * @param dst_base Target base address.
+ * @param dst_base  Target base address.
  * @param dst_flags_mask Destination address space area flags mask.
+ *
- * @return Zero on success or ENOENT if there is no such task or if there is no
+ * @return      Zero on success or ENOENT if there is no such task or if
- * such address space area, EPERM if there was a problem in accepting the area
+ *          there is no such address space area, EPERM if there was
+ *          a problem in accepting the area or ENOMEM if there was a
- * or ENOMEM if there was a problem in allocating destination address space
+ *          problem in allocating destination address space area.
- * area. ENOTSUP is returned if the address space area backend does not support
+ *          ENOTSUP is returned if the address space area backend
- * sharing.
+ *          does not support sharing.
  */
 int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size,
     as_t *dst_as, uintptr_t dst_base, int dst_flags_mask)
+{
     ipl_t ipl;
      * Then it will be safe to unlock it.
      */
     sh_info = src_area->sh_info;
     if (!sh_info) {
         sh_info = (share_info_t *) malloc(sizeof(share_info_t), 0);
-        mutex_initialize(&sh_info->lock);
+        mutex_initialize(&sh_info->lock, MUTEX_PASSIVE);
         sh_info->refcount = 2;
         btree_create(&sh_info->pagemap);
         src_area->sh_info = sh_info;
         /*
          * Call the backend to setup sharing.
 /** Check access mode for address space area.
+ *
  * The address space area must be locked prior to this call.
+ *
- * @param area Address space area.
+ * @param area      Address space area.
- * @param access Access mode.
+ * @param access    Access mode.
+ *
- * @return False if access violates area's permissions, true otherwise.
+ * @return      False if access violates area's permissions, true
+ *          otherwise.
  */
 bool as_area_check_access(as_area_t *area, pf_access_t access)
+{
     int flagmap[] = {
         [PF_ACCESS_READ] = AS_AREA_READ,
         return false;
     return true;
+}
+/** Change adress space area flags.
+ *
+ * The idea is to have the same data, but with a different access mode.
+ * This is needed e.g. for writing code into memory and then executing it.
+ * In order for this to work properly, this may copy the data
+ * into private anonymous memory (unless it's already there).
+ *
+ * @param as        Address space.
+ * @param flags     Flags of the area memory.
+ * @param address   Address withing the area to be changed.
+ *
+ * @return      Zero on success or a value from @ref errno.h on failure.
+ */
+int as_area_change_flags(as_t *as, int flags, uintptr_t address)
+{
+    as_area_t *area;
+    uintptr_t base;
+    link_t *cur;
+    ipl_t ipl;
+    int page_flags;
+    uintptr_t *old_frame;
+    index_t frame_idx;
+    count_t used_pages;
+    /* Flags for the new memory mapping */
+    page_flags = area_flags_to_page_flags(flags);
+    ipl = interrupts_disable();
+    mutex_lock(&as->lock);
+    area = find_area_and_lock(as, address);
+    if (!area) {
+        mutex_unlock(&as->lock);
+        interrupts_restore(ipl);
+        return ENOENT;
+    }
+    if (area->sh_info || area->backend != &anon_backend) {
+        /* Copying shared areas not supported yet */
+        /* Copying non-anonymous memory not supported yet */
+        mutex_unlock(&area->lock);
+        mutex_unlock(&as->lock);
+        interrupts_restore(ipl);
+        return ENOTSUP;
+    }
+    base = area->base;
+    /*
+     * Compute total number of used pages in the used_space B+tree
+     */
+    used_pages = 0;
+    for (cur = area->used_space.leaf_head.next;
+        cur != &area->used_space.leaf_head; cur = cur->next) {
+        btree_node_t *node;
+        unsigned int i;
+        node = list_get_instance(cur, btree_node_t, leaf_link);
+        for (i = 0; i < node->keys; i++) {
+            used_pages += (count_t) node->value[i];
+        }
+    }
+    /* An array for storing frame numbers */
+    old_frame = malloc(used_pages * sizeof(uintptr_t), 0);
+    /*
+     * Start TLB shootdown sequence.
+     */
+    tlb_shootdown_start(TLB_INVL_PAGES, as->asid, area->base, area->pages);
+    /*
+     * Remove used pages from page tables and remember their frame
+     * numbers.
+     */
+    frame_idx = 0;
+    for (cur = area->used_space.leaf_head.next;
+        cur != &area->used_space.leaf_head; cur = cur->next) {
+        btree_node_t *node;
+        unsigned int i;
+        node = list_get_instance(cur, btree_node_t, leaf_link);
+        for (i = 0; i < node->keys; i++) {
+            uintptr_t b = node->key[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);
+                ASSERT(pte && PTE_VALID(pte) &&
+                    PTE_PRESENT(pte));
+                old_frame[frame_idx++] = PTE_GET_FRAME(pte);
+                /* Remove old mapping */
+                page_mapping_remove(as, b + j * PAGE_SIZE);
+                page_table_unlock(as, false);
+            }
+        }
+    }
+    /*
+     * Finish TLB shootdown sequence.
+     */
+    tlb_invalidate_pages(as->asid, area->base, area->pages);
+    /*
+     * Invalidate potential software translation caches (e.g. TSB on
+     * sparc64).
+     */
+    as_invalidate_translation_cache(as, area->base, area->pages);
+    tlb_shootdown_finalize();
+    /*
+     * Set the new flags.
+     */
+    area->flags = flags;
+    /*
+     * Map pages back in with new flags. This step is kept separate
+     * so that the memory area could not be accesed with both the old and
+     * the new flags at once.
+     */
+    frame_idx = 0;
+    for (cur = area->used_space.leaf_head.next;
+        cur != &area->used_space.leaf_head; cur = cur->next) {
+        btree_node_t *node;
+        unsigned int i;
+        node = list_get_instance(cur, btree_node_t, leaf_link);
+        for (i = 0; i < node->keys; i++) {
+            uintptr_t b = node->key[i];
+            count_t j;
+            for (j = 0; j < (count_t) node->value[i]; j++) {
+                page_table_lock(as, false);
+                /* Insert the new mapping */
+                page_mapping_insert(as, b + j * PAGE_SIZE,
+                    old_frame[frame_idx++], page_flags);
+                page_table_unlock(as, false);
+            }
+        }
+    }
+    free(old_frame);
+    mutex_unlock(&area->lock);
+    mutex_unlock(&as->lock);
+    interrupts_restore(ipl);
+    return 0;
+}
 /** Handle page fault within the current address space.
+ *
- * This is the high-level page fault handler. It decides
+ * This is the high-level page fault handler. It decides whether the page fault
- * whether the page fault can be resolved by any backend
- * and if so, it invokes the backend to resolve the page
+ * can be resolved by any backend and if so, it invokes the backend to resolve
- * fault.
+ * the page fault.
+ *
  * Interrupts are assumed disabled.
+ *
- * @param page Faulting page.
+ * @param page      Faulting page.
- * @param access Access mode that caused the fault (i.e. read/write/exec).
+ * @param access    Access mode that caused the page fault (i.e.
+ *          read/write/exec).
- * @param istate Pointer to interrupted state.
+ * @param istate    Pointer to the interrupted state.
  *
- * @return AS_PF_FAULT on page fault, AS_PF_OK on success or AS_PF_DEFER if the
+ * @return      AS_PF_FAULT on page fault, AS_PF_OK on success or
- *     fault was caused by copy_to_uspace() or copy_from_uspace().
+ *          AS_PF_DEFER if the fault was caused by copy_to_uspace()
+ *          or copy_from_uspace().
  */
 int as_page_fault(uintptr_t page, pf_access_t access, istate_t *istate)
+{
     pte_t *pte;
     as_area_t *area;
+    }
     page_table_lock(AS, false);
     /*
-     * To avoid race condition between two page faults
+     * To avoid race condition between two page faults on the same address,
-     * on the same address, we need to make sure
-     * the mapping has not been already inserted.
+     * we need to make sure 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)) ||
  * scheduling. Sleeping here would lead to deadlock on wakeup. Another
  * thing which is forbidden in this context is locking the address space.
+ *
  * When this function is enetered, no spinlocks may be held.
+ *
- * @param old Old address space or NULL.
+ * @param old       Old address space or NULL.
- * @param new New address space.
+ * @param new       New address space.
  */
 void as_switch(as_t *old_as, as_t *new_as)
+{
     DEADLOCK_PROBE_INIT(p_asidlock);
     preemption_disable();
     return EOK;
+}
 /** Convert address space area flags to page flags.
+ *
- * @param aflags Flags of some address space area.
+ * @param aflags    Flags of some address space area.
+ *
- * @return Flags to be passed to page_mapping_insert().
+ * @return      Flags to be passed to page_mapping_insert().
  */
 int area_flags_to_page_flags(int aflags)
+{
     int flags;
 /** Compute flags for virtual address translation subsytem.
+ *
  * The address space area must be locked.
  * Interrupts must be disabled.
+ *
- * @param a Address space area.
+ * @param a     Address space area.
+ *
- * @return Flags to be used in page_mapping_insert().
+ * @return      Flags to be used in page_mapping_insert().
  */
 int as_area_get_flags(as_area_t *a)
+{
     return area_flags_to_page_flags(a->flags);
+}
 /** Create page table.
+ *
- * Depending on architecture, create either address space
+ * Depending on architecture, create either address space private or global page
- * private or global page table.
+ * table.
+ *
- * @param flags Flags saying whether the page table is for kernel address space.
+ * @param flags     Flags saying whether the page table is for the kernel
+ *          address space.
+ *
- * @return First entry of the page table.
+ * @return      First entry of the page table.
  */
 pte_t *page_table_create(int flags)
+{
-#ifdef __OBJC__
-    return [as_t page_table_create: flags];
-#else
     ASSERT(as_operations);
     ASSERT(as_operations->page_table_create);
     return as_operations->page_table_create(flags);
-#endif
+}
 /** Destroy page table.
+ *
  * Destroy page table in architecture specific way.
+ *
- * @param page_table Physical address of PTL0.
+ * @param page_table    Physical address of PTL0.
  */
 void page_table_destroy(pte_t *page_table)
+{
-#ifdef __OBJC__
-    return [as_t page_table_destroy: page_table];
-#else
     ASSERT(as_operations);
     ASSERT(as_operations->page_table_destroy);
     as_operations->page_table_destroy(page_table);
-#endif
+}
 /** Lock page table.
+ *
  * This function should be called before any page_mapping_insert(),
+ *
  * Locking order is such that address space areas must be locked
  * prior to this call. Address space can be locked prior to this
  * call in which case the lock argument is false.
+ *
- * @param as Address space.
+ * @param as        Address space.
- * @param lock If false, do not attempt to lock as->lock.
+ * @param lock      If false, do not attempt to lock as->lock.
  */
 void page_table_lock(as_t *as, bool lock)
+{
-#ifdef __OBJC__
-    [as page_table_lock: lock];
-#else
     ASSERT(as_operations);
     ASSERT(as_operations->page_table_lock);
     as_operations->page_table_lock(as, lock);
-#endif
+}
 /** Unlock page table.
+ *
- * @param as Address space.
+ * @param as        Address space.
- * @param unlock If false, do not attempt to unlock as->lock.
+ * @param unlock    If false, do not attempt to unlock as->lock.
  */
 void page_table_unlock(as_t *as, bool unlock)
+{
-#ifdef __OBJC__
-    [as page_table_unlock: unlock];
-#else
     ASSERT(as_operations);
     ASSERT(as_operations->page_table_unlock);
     as_operations->page_table_unlock(as, unlock);
-#endif
+}
 /** Find address space area and lock it.
+ *
  * The address space must be locked and interrupts must be disabled.
+ *
- * @param as Address space.
+ * @param as        Address space.
- * @param va Virtual address.
+ * @param va        Virtual address.
+ *
- * @return Locked address space area containing va on success or NULL on
+ * @return      Locked address space area containing va on success or
- *     failure.
+ *          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;
 /** Check area conflicts with other areas.
+ *
  * The address space must be locked and interrupts must be disabled.
+ *
- * @param as Address space.
+ * @param as        Address space.
- * @param va Starting virtual address of the area being tested.
+ * @param va        Starting virtual address of the area being tested.
- * @param size Size of the area being tested.
+ * @param size      Size of the area being tested.
- * @param avoid_area Do not touch this area.
+ * @param avoid_area    Do not touch this area.
+ *
- * @return True if there is no conflict, false otherwise.
+ * @return      True if there is no conflict, false otherwise.
  */
+bool
-bool check_area_conflicts(as_t *as, uintptr_t va, size_t size,
+check_area_conflicts(as_t *as, uintptr_t va, size_t size, as_area_t *avoid_area)
-              as_area_t *avoid_area)
+{
     as_area_t *a;
     btree_node_t *leaf, *node;
     unsigned int i;
     as_area_t *src_area;
     size_t size;
     ipl = interrupts_disable();
     src_area = find_area_and_lock(AS, base);
-    if (src_area){
+    if (src_area) {
         size = src_area->pages * PAGE_SIZE;
         mutex_unlock(&src_area->lock);
     } else {
         size = 0;
+    }
 /** Mark portion of address space area as used.
+ *
  * The address space area must be already locked.
+ *
- * @param a Address space area.
+ * @param a     Address space area.
- * @param page First page to be marked.
+ * @param page      First page to be marked.
- * @param count Number of page to be marked.
+ * @param count     Number of page to be marked.
+ *
- * @return 0 on failure and 1 on success.
+ * @return      Zero on failure and non-zero on success.
  */
 int used_space_insert(as_area_t *a, uintptr_t page, count_t count)
+{
     btree_node_t *leaf, *node;
     count_t pages;
                 return 1;
+            }
+        }
+    }
-    panic("Inconsistency detected while adding %" PRIc " pages of used space at "
+    panic("Inconsistency detected while adding %" PRIc " pages of used "
-        "%p.\n", count, page);
+        "space at %p.\n", count, page);
+}
 /** Mark portion of address space area as unused.
+ *
  * The address space area must be already locked.
+ *
- * @param a Address space area.
+ * @param a     Address space area.
- * @param page First page to be marked.
+ * @param page      First page to be marked.
- * @param count Number of page to be marked.
+ * @param count     Number of page to be marked.
+ *
- * @return 0 on failure and 1 on success.
+ * @return      Zero on failure and non-zero on success.
  */
 int used_space_remove(as_area_t *a, uintptr_t page, count_t count)
+{
     btree_node_t *leaf, *node;
     count_t pages;
             return 0;
+        }
+    }
 error:
-    panic("Inconsistency detected while removing %" PRIc " pages of used space "
+    panic("Inconsistency detected while removing %" PRIc " pages of used "
-        "from %p.\n", count, page);
+        "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.
+ *
- * @param sh_info Pointer to address space area share info.
+ * @param sh_info   Pointer to address space area share info.
  */
 void sh_info_remove_reference(share_info_t *sh_info)
+{
     bool dealloc = false;
 unative_t sys_as_area_resize(uintptr_t address, size_t size, int flags)
+{
     return (unative_t) as_area_resize(AS, address, size, 0);
+}
+/** Wrapper for as_area_change_flags(). */
+unative_t sys_as_area_change_flags(uintptr_t address, int flags)
+{
+    return (unative_t) as_area_change_flags(AS, flags, address);
+}
 /** Wrapper for as_area_destroy(). */
 unative_t sys_as_area_destroy(uintptr_t address)
+{
     return (unative_t) as_area_destroy(AS, address);
+}
 /** Print out information about address space.
+ *
- * @param as Address space.
+ * @param as        Address space.
  */
 void as_print(as_t *as)
+{
     ipl_t ipl;
         unsigned 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=%" PRIc " (%p - %p)\n",
+            printf("as_area: %p, base=%p, pages=%" PRIc
-                area, area->base, area->pages, area->base,
+                " (%p - %p)\n", area, area->base, area->pages,
-                area->base + FRAMES2SIZE(area->pages));
+                area->base, area->base + FRAMES2SIZE(area->pages));
             mutex_unlock(&area->lock);
+        }
+    }
     mutex_unlock(&as->lock);

Subversion Repositories HelenOS

(root)/branches/tracing/kernel/generic/src/mm/as.c – Rev 3424 → 3425