WebSVN – HelenOS – Diff – /branches/dynload/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;
+{
     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, MUTEX_PASSIVE);
-    (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.
+}
 /** 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)
                      * 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;
+}
 /** 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)
+{
- * @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;
  * 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 area flags.
+/** 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).
      */
     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 there's no instant when the memory area could be
+     * so that the memory area could not be accesed with both the old and
-     * accesed with both the old and the new flags at once.
+     * 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) {
+}
 /** 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)) ||
     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(),
- * @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;
- * @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;
+ *
- * @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.
         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/dynload/kernel/generic/src/mm/as.c – Rev 3191 → 3403