WebSVN – HelenOS – Path Comparison – / – /branches/dynload/kernel/ Rev 3403 and /branches/dynload/kernel/ Rev 3402

Ignore whitespace Rev 3403 → Rev 3402

 /branches/dynload/kernel/generic/src/mm/as.c
 ,6 → 82,7
 #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.
 ,6 → 93,7
  * Slab for as_t objects.
  */
 static slab_cache_t *as_slab;
+#endif
 /**
  * This lock serializes access to the ASID subsystem.
 ,11 → 113,13
 /** Kernel address space. */
 as_t *AS_KERNEL = NULL;
-static int area_flags_to_page_flags(int);
-static as_area_t *find_area_and_lock(as_t *, uintptr_t);
-static bool check_area_conflicts(as_t *, uintptr_t, size_t, as_area_t *);
-static void sh_info_remove_reference(share_info_t *);
+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 void sh_info_remove_reference(share_info_t *sh_info);
+#ifndef __OBJC__
 static int as_constructor(void *obj, int flags)
 {
     as_t *as = (as_t *) obj;
 ,6 → 139,7
     return as_destructor_arch(as);
 }
+#endif
 /** Initialize address space subsystem. */
 void as_init(void)
 ,8 → 146,10
 {
     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)
 ,14 → 159,20
 /** Create address space.
  *
- * @param flags     Flags that influence the way in wich the address space
- *          is created.
+ * @param flags Flags that influence 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);
 ,8 → 199,6
  * 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)
 {
 ,7 → 263,11
     interrupts_restore(ipl);
+#ifdef __OBJC__
+    [as free];
+#else
     slab_free(as_slab, as);
+#endif
 }
 /** Create address space area of common attributes.
 ,19 → 274,19
  *
  * The created address space area is added to the target address space.
  *
- * @param as        Target address space.
- * @param flags     Flags of the area memory.
- * @param size      Size of area.
- * @param base      Base address of area.
- * @param attrs     Attributes of the area.
- * @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 as Target address space.
+ * @param flags Flags of the area memory.
+ * @param size Size of area.
+ * @param base Base address of area.
+ * @param attrs Attributes of the area.
+ * @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 *.
  *
- * @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;
 ,14 → 338,13
 /** 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 size      New size of the virtual memory block starting at
- *          address.
- * @param flags     Flags influencing the remap operation. Currently unused.
+ * @param as Address space.
+ * @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.
+ * @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)
 {
 ,10 → 452,8
                     cond = false;   /* we are almost done */
                     i = (start_free - b) >> PAGE_WIDTH;
-                    if (!used_space_remove(area, start_free,
-                        c - i))
-                        panic("Could not remove used "
-                            "space.\n");
+                    if (!used_space_remove(area, start_free, c - i))
+                        panic("Could not remove used space.\n");
                 } else {
                     /*
                      * The interval of used space can be
 ,8 → 460,7
                      * 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++) {
 ,10 → 522,10
 /** Destroy address space area.
  *
- * @param as        Address space.
- * @param address   Address within the area to be deleted.
+ * @param as Address space.
+ * @param address Address withing 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)
 {
 ,19 → 622,18
  * 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_base  Base address of the source address space area.
- * @param acc_size  Expected size of the source area.
- * @param dst_as    Pointer to destination address space.
- * @param dst_base  Target base address.
+ * @param src_as Pointer to source address space.
+ * @param src_base Base address of the source address space area.
+ * @param acc_size Expected size of the source area.
+ * @param dst_as Pointer to destination address space.
+ * @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 such address space area, EPERM if there was
- *          a problem in accepting the area or ENOMEM if there was a
- *          problem in allocating destination address space area.
- *          ENOTSUP is returned if the address space area backend
- *          does not support sharing.
+ * @return Zero on success or ENOENT if there is no such task or if there is no
+ * such address space area, EPERM if there was a problem in accepting the area
+ * or ENOMEM if there was a problem in allocating destination address space
+ * area. ENOTSUP is returned if the address space area backend 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)
 ,11 → 752,10
  *
  * The address space area must be locked prior to this call.
  *
- * @param area      Address space area.
- * @param access    Access mode.
+ * @param area Address space area.
+ * @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)
 {
 ,7 → 771,7
     return true;
 }
-/** Change adress space area flags.
+/** Change adress 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.
 ,11 → 778,11
  * 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.
+ * @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.
+ * @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)
 {
 ,14 → 887,9
     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.
+     * so that there's no instant when the memory area could be
+     * accesed with both the old and the new flags at once.
      */
     frame_idx = 0;
 ,20 → 927,19
 /** Handle page fault within the current address space.
  *
- * This is the high-level page fault handler. It decides whether the page fault
- * can be resolved by any backend and if so, it invokes the backend to resolve
- * the page fault.
+ * This is the high-level page fault handler. It decides
+ * whether the page fault can be resolved by any backend
+ * and if so, it invokes the backend to resolve the page
+ * fault.
  *
  * Interrupts are assumed disabled.
  *
- * @param page      Faulting page.
- * @param access    Access mode that caused the page fault (i.e.
- *          read/write/exec).
- * @param istate    Pointer to the interrupted state.
+ * @param page Faulting page.
+ * @param access Access mode that caused the fault (i.e. read/write/exec).
+ * @param istate Pointer to interrupted state.
  *
- * @return      AS_PF_FAULT on page fault, AS_PF_OK on success or
- *          AS_PF_DEFER if the fault was caused by copy_to_uspace()
- *          or copy_from_uspace().
+ * @return AS_PF_FAULT on page fault, AS_PF_OK on success or 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)
 {
 ,8 → 985,9
     page_table_lock(AS, false);
     /*
-     * To avoid race condition between two page faults on the same address,
-     * we need to make sure the mapping has not been already inserted.
+     * To avoid race condition between two page faults
+     * on the same address, we need to make sure
+     * the mapping has not been already inserted.
      */
     if ((pte = page_mapping_find(AS, page))) {
         if (PTE_PRESENT(pte)) {
 ,8 → 1041,8
  *
  * When this function is enetered, no spinlocks may be held.
  *
- * @param old       Old address space or NULL.
- * @param new       New address space.
+ * @param old Old address space or NULL.
+ * @param new New address space.
  */
 void as_switch(as_t *old_as, as_t *new_as)
 {
 ,9 → 1113,9
 /** 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)
 {
 ,9 → 1143,9
  * 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)
 {
 ,20 → 1154,23
 /** Create page table.
  *
- * Depending on architecture, create either address space private or global page
- * table.
+ * Depending on architecture, create either address space
+ * private or global page table.
  *
- * @param flags     Flags saying whether the page table is for the kernel
- *          address space.
+ * @param flags Flags saying whether the page table is for 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.
 ,14 → 1177,18
  *
  * 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.
 ,28 → 1200,36
  * 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 lock      If false, do not attempt to lock as->lock.
+ * @param as Address space.
+ * @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 unlock    If false, do not attempt to unlock as->lock.
+ * @param as Address space.
+ * @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
 }
 ,11 → 1237,11
  *
  * The address space must be locked and interrupts must be disabled.
  *
- * @param as        Address space.
- * @param va        Virtual address.
+ * @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)
 {
 ,15 → 1293,15
  *
  * The address space must be locked and interrupts must be disabled.
  *
- * @param as        Address space.
- * @param va        Starting virtual address of the area being tested.
- * @param size      Size of the area being tested.
- * @param avoid_area    Do not touch this area.
+ * @param as Address space.
+ * @param va Starting virtual address of the area being tested.
+ * @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.
+ * @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;
 ,7 → 1390,7
     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 {
 ,11 → 1404,11
  *
  * The address space area must be already locked.
  *
- * @param a     Address space area.
- * @param page      First page to be marked.
- * @param count     Number of page to be marked.
+ * @param a Address space area.
+ * @param page First page to be marked.
+ * @param count Number of page to be marked.
  *
- * @return      Zero on failure and non-zero on success.
+ * @return 0 on failure and 1 on success.
  */
 int used_space_insert(as_area_t *a, uintptr_t page, count_t count)
 {
 ,8 → 1678,8
         }
     }
-    panic("Inconsistency detected while adding %" PRIc " pages of used "
-        "space at %p.\n", count, page);
+    panic("Inconsistency detected while adding %" PRIc " pages of used space at "
+        "%p.\n", count, page);
 }
 /** Mark portion of address space area as unused.
 ,11 → 1686,11
  *
  * The address space area must be already locked.
  *
- * @param a     Address space area.
- * @param page      First page to be marked.
- * @param count     Number of page to be marked.
+ * @param a Address space area.
+ * @param page First page to be marked.
+ * @param count Number of page to be marked.
  *
- * @return      Zero on failure and non-zero on success.
+ * @return 0 on failure and 1 on success.
  */
 int used_space_remove(as_area_t *a, uintptr_t page, count_t count)
 {
 ,8 → 1857,8
     }
 error:
-    panic("Inconsistency detected while removing %" PRIc " pages of used "
-        "space from %p.\n", count, page);
+    panic("Inconsistency detected while removing %" PRIc " pages of used space "
+        "from %p.\n", count, page);
 }
 /** Remove reference to address space area share info.
 ,7 → 1865,7
  *
  * 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)
 {
 ,7 → 1934,7
 /** Print out information about address space.
  *
- * @param as        Address space.
+ * @param as Address space.
  */
 void as_print(as_t *as)
 {
 ,9 → 1956,9
             as_area_t *area = node->value[i];
             mutex_lock(&area->lock);
-            printf("as_area: %p, base=%p, pages=%" PRIc
-                " (%p - %p)\n", area, area->base, area->pages,
-                area->base, area->base + FRAMES2SIZE(area->pages));
+            printf("as_area: %p, base=%p, pages=%" PRIc " (%p - %p)\n",
+                area, area->base, area->pages, area->base,
+                area->base + FRAMES2SIZE(area->pages));
             mutex_unlock(&area->lock);
         }
     }

/branches/dynload/kernel/generic/src/mm/backend_anon.c
78,6 → 78,7
int anon_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
{
uintptr_t frame;
bool dirty = false;

if (!as_area_check_access(area, access))
return AS_PF_FAULT;
105,7 → 106,7
*/
for (i = 0; i < leaf->keys; i++) {
if (leaf->key[i] ==
ALIGN_DOWN(addr, PAGE_SIZE) - area->base) {
ALIGN_DOWN(addr, PAGE_SIZE)) {
allocate = false;
break;
}
113,6 → 114,7
if (allocate) {
frame = (uintptr_t) frame_alloc(ONE_FRAME, 0);
memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
dirty = true;

/*
* Insert the address of the newly allocated
143,6 → 145,7
*/
frame = (uintptr_t) frame_alloc(ONE_FRAME, 0);
memsetb((void *) PA2KA(frame), FRAME_SIZE, 0);
dirty = true;
}

/*

 /branches/dynload/kernel/generic/src/mm/backend_elf.c
 ,7 → 118,7
              */
             for (i = 0; i < leaf->keys; i++) {
-                if (leaf->key[i] == page - area->base) {
+                if (leaf->key[i] == page) {
                     found = true;
                     break;
                 }

 /branches/dynload/kernel/generic/src/proc/task.c
 ,7 → 71,11
 static task_id_t task_counter = 0;
-/** Initialize kernel tasks support. */
+/** Initialize tasks
+ *
+ * Initialize kernel tasks support.
+ *
+ */
 void task_init(void)
 {
     TASK = NULL;
 ,8 → 83,7
 }
 /*
- * The idea behind this walker is to remember a single task different from
- * TASK.
+ * The idea behind this walker is to remember a single task different from TASK.
  */
 static bool task_done_walker(avltree_node_t *node, void *arg)
 {
 ,7 → 98,9
     return true;    /* continue the walk */
 }
-/** Kill all tasks except the current task. */
+/** Kill all tasks except the current task.
+ *
+ */
 void task_done(void)
 {
     task_t *t;
 ,13 → 132,15
     } while (t != NULL);
 }
-/** Create new task with no threads.
+/** Create new task
  *
- * @param as        Task's address space.
- * @param name      Symbolic name.
+ * Create new task with no threads.
  *
- * @return      New task's structure.
+ * @param as Task's address space.
+ * @param name Symbolic name.
  *
+ * @return New task's structure
+ *
  */
 task_t *task_create(as_t *as, char *name)
 {
 ,7 → 194,7
 /** Destroy task.
  *
- * @param t     Task to be destroyed.
+ * @param t Task to be destroyed.
  */
 void task_destroy(task_t *t)
 {
 ,16 → 227,16
 /** Syscall for reading task ID from userspace.
  *
- * @param       uspace_task_id userspace address of 8-byte buffer
- *          where to store current task ID.
+ * @param uspace_task_id Userspace address of 8-byte buffer where to store
+ * current task ID.
  *
- * @return      Zero on success or an error code from @ref errno.h.
+ * @return 0 on success or an error code from @ref errno.h.
  */
 unative_t sys_task_get_id(task_id_t *uspace_task_id)
 {
     /*
-     * No need to acquire lock on TASK because taskid remains constant for
-     * the lifespan of the task.
+     * No need to acquire lock on TASK because taskid
+     * remains constant for the lifespan of the task.
      */
     return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid,
         sizeof(TASK->taskid));
 ,15 → 244,16
 /** Find task structure corresponding to task ID.
  *
- * The tasks_lock must be already held by the caller of this function and
- * interrupts must be disabled.
+ * The tasks_lock must be already held by the caller of this function
+ * and interrupts must be disabled.
  *
- * @param id        Task ID.
+ * @param id Task ID.
  *
- * @return      Task structure address or NULL if there is no such task
- *          ID.
+ * @return Task structure address or NULL if there is no such task ID.
  */
-task_t *task_find_by_id(task_id_t id) { avltree_node_t *node;
+task_t *task_find_by_id(task_id_t id)
+{
+    avltree_node_t *node;
     node = avltree_search(&tasks_tree, (avltree_key_t) id);
 ,13 → 264,11
 /** Get accounting data of given task.
  *
- * Note that task lock of 't' must be already held and interrupts must be
- * already disabled.
+ * Note that task lock of 't' must be already held and
+ * interrupts must be already disabled.
  *
- * @param t     Pointer to thread.
+ * @param t Pointer to thread.
  *
- * @return      Number of cycles used by the task and all its threads
- *          so far.
  */
 uint64_t task_get_accounting(task_t *t)
 {
 ,9 → 300,9
  * This function is idempotent.
  * It signals all the task's threads to bail it out.
  *
- * @param id        ID of the task to be killed.
+ * @param id ID of the task to be killed.
  *
- * @return      Zero on success or an error code from errno.h.
+ * @return 0 on success or an error code from errno.h
  */
 int task_kill(task_id_t id)
 {
 ,7 → 323,7
     spinlock_unlock(&tasks_lock);
     /*
-     * Interrupt all threads.
+     * Interrupt all threads except ktaskclnp.
      */
     spinlock_lock(&ta->lock);
     for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {

/branches/dynload/kernel/generic/src/main/kinit.c
177,6 → 177,7
*/
cap_set(programs[i].task, CAP_CAP \| CAP_MEM_MANAGER \|
CAP_IO_MANAGER \| CAP_PREEMPT_CONTROL \| CAP_IRQ_REG);


if (!ipc_phone_0)
ipc_phone_0 = &programs[i].task->answerbox;

 /branches/dynload/kernel/generic/src/ipc/ipc.c
 ,10 → 171,8
  *
  * @param phone     Destination kernel phone structure.
  * @param request   Call structure with request.
- *
- * @return      EOK on success or EINTR if the sleep was interrupted.
  */
-int ipc_call_sync(phone_t *phone, call_t *request)
+void ipc_call_sync(phone_t *phone, call_t *request)
 {
     answerbox_t sync_box;
 ,10 → 182,7
     request->callerbox = &sync_box;
     ipc_call(phone, request);
-    if (!ipc_wait_for_call(&sync_box, SYNCH_NO_TIMEOUT,
-        SYNCH_FLAGS_INTERRUPTIBLE))
-        return EINTR;
-    return EOK;
+    ipc_wait_for_call(&sync_box, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
 }
 /** Answer a message which was not dispatched and is not listed in any queue.
 ,13 → 195,6
     call->flags |= IPC_CALL_ANSWERED;
-    if (call->flags & IPC_CALL_FORWARDED) {
-        if (call->caller_phone) {
-            /* Demasquerade the caller phone. */
-            call->data.phone = call->caller_phone;
-        }
-    }
     spinlock_lock(&callerbox->lock);
     list_append(&call->link, &callerbox->answers);
     spinlock_unlock(&callerbox->lock);
 ,11 → 347,8
     list_remove(&call->link);
     spinlock_unlock(&oldbox->lock);
-    if (mode & IPC_FF_ROUTE_FROM_ME) {
-        if (!call->caller_phone)
-            call->caller_phone = call->data.phone;
+    if (mode & IPC_FF_ROUTE_FROM_ME)
         call->data.phone = newphone;
-    }
     return ipc_call(newphone, call);
 }
 ,9 → 577,8
         tmp = tmp->next) {
         call = list_get_instance(tmp, call_t, link);
         printf("Callid: %p Srctask:%" PRIu64 " M:%" PRIun
-            " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
-            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call,
-            call->sender->taskid,
+            " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
+            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call, call->sender->taskid,
             IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
             IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
             IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
 ,9 → 591,8
         tmp = tmp->next) {
         call = list_get_instance(tmp, call_t, link);
         printf("Callid: %p Srctask:%" PRIu64 " M:%" PRIun
-            " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
-            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call,
-            call->sender->taskid,
+            " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
+            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call, call->sender->taskid,
             IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
             IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
             IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
 ,12 → 600,11
     }
     /* Print answerbox - calls */
     printf("ABOX - ANSWERS:\n");
-    for (tmp = task->answerbox.answers.next;
-        tmp != &task->answerbox.answers;
+    for (tmp = task->answerbox.answers.next; tmp != &task->answerbox.answers;
         tmp = tmp->next) {
         call = list_get_instance(tmp, call_t, link);
         printf("Callid:%p M:%" PRIun " A1:%" PRIun " A2:%" PRIun
-            " A3:%" PRIun " A4:%" PRIun " A5:%" PRIun " Flags:%x\n",
+            " A3:%" PRIun " A4:%" PRIun " A5:%" PRIun " Flags:%x\n",
             call, IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
             IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
             IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),

 /branches/dynload/kernel/generic/src/ipc/sysipc.c
 ,12 → 270,12
             /* The recipient agreed to receive data. */
             int rc;
             uintptr_t dst;
-            size_t size;
-            size_t max_size;
+            uintptr_t size;
+            uintptr_t max_size;
-            dst = (uintptr_t)IPC_GET_ARG1(answer->data);
-            size = (size_t)IPC_GET_ARG2(answer->data);
-            max_size = (size_t)IPC_GET_ARG2(*olddata);
+            dst = IPC_GET_ARG1(answer->data);
+            size = IPC_GET_ARG2(answer->data);
+            max_size = IPC_GET_ARG2(*olddata);
             if (size <= max_size) {
                 rc = copy_to_uspace((void *) dst,
 ,9 → 442,7
     IPC_SET_ARG5(call.data, 0);
     if (!(res = request_preprocess(&call))) {
-        rc = ipc_call_sync(phone, &call);
-        if (rc != EOK)
-            return rc;
+        ipc_call_sync(phone, &call);
         process_answer(&call);
     } else {
         IPC_SET_RETVAL(call.data, res);
 ,9 → 480,7
     GET_CHECK_PHONE(phone, phoneid, return ENOENT);
     if (!(res = request_preprocess(&call))) {
-        rc = ipc_call_sync(phone, &call);
-        if (rc != EOK)
-            return rc;
+        ipc_call_sync(phone, &call);
         process_answer(&call);
     } else
         IPC_SET_RETVAL(call.data, res);

 /branches/dynload/kernel/generic/src/ipc/ipcrsc.c
 ,6 → 170,7
     int i;
     spinlock_lock(&TASK->lock);
     for (i = 0; i < IPC_MAX_PHONES; i++) {
         if (TASK->phones[i].state == IPC_PHONE_HUNGUP &&
             atomic_get(&TASK->phones[i].active_calls) == 0)
 ,9 → 183,8
     }
     spinlock_unlock(&TASK->lock);
-    if (i == IPC_MAX_PHONES)
+    if (i >= IPC_MAX_PHONES)
         return -1;
     return i;
 }

 /branches/dynload/kernel/generic/src/lib/memstr.c
 ,7 → 74,7
             ((uint8_t *)(((unative_t *) dst) + i))[j] = ((uint8_t *)(((unative_t *) src) + i))[j];
     }
-    return (char *) dst;
+    return (char *) src;
 }
 /** Fill block of memory

 /branches/dynload/kernel/generic/src/lib/objc_ext.c
 ,0 → 1,174
+/*
+ * Copyright (c) 2007 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup generic
+ * @{
+ */
+/**
+ * @file
+ * @brief   Objective C bindings.
+ *
+ * This file provides architecture independent binding
+ * functions which are needed to link with libobjc run-time
+ * library. Many of the functions are just dummy.
+ */
+#include <lib/objc_ext.h>
+#include <panic.h>
+#include <arch/memstr.h>
+#include <mm/slab.h>
+void *stderr;
+static unsigned short __ctype_b[384] = {
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     2,     2,     2,     2,     2,     2,     2,
+,  8195,  8194,  8194,  8194,  8194,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,
+,     2,     2,     2,     2,     2,     2,     2,
+, 49156, 49156, 49156, 49156, 49156, 49156, 49156,
+, 49156, 49156, 49156, 49156, 49156, 49156, 49156,
+, 55304, 55304, 55304, 55304, 55304, 55304, 55304,
+, 55304, 49156, 49156, 49156, 49156, 49156, 49156,
+, 54536, 54536, 54536, 54536, 54536, 54536, 50440,
+, 50440, 50440, 50440, 50440, 50440, 50440, 50440,
+, 50440, 50440, 50440, 50440, 50440, 50440, 50440,
+, 50440, 50440, 49156, 49156, 49156, 49156, 49156,
+, 54792, 54792, 54792, 54792, 54792, 54792, 50696,
+, 50696, 50696, 50696, 50696, 50696, 50696, 50696,
+, 50696, 50696, 50696, 50696, 50696, 50696, 50696,
+, 50696, 50696, 49156, 49156, 49156, 49156,     2,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0,
+,     0,     0,     0,     0,     0,     0,     0
+};
+static const unsigned short *__ctype_b_ptr = __ctype_b + 128;
+void __assert_fail(const char *assertion, const char *file, unsigned int line, const char *function)
+{
+    panic("Run-time assertion (%s:%u:%s) failed (%s)", file, line, function ? function : "", assertion);
+}
+void abort(void)
+{
+    panic("Run-time scheduled abort");
+}
+void *fopen(const char *path, const char *mode)
+{
+    return NULL;
+}
+size_t fread(void *ptr, size_t size, size_t nmemb, void *stream)
+{
+    return 0;
+}
+size_t fwrite(const void *ptr, size_t size, size_t nmemb, void *stream)
+{
+    return 0;
+}
+int fflush(void *stream)
+{
+    return 0;
+}
+int feof(void *stream)
+{
+    return 1;
+}
+int fclose(void *stream)
+{
+    return 0;
+}
+int vfprintf(void *stream, const char *format, va_list ap)
+{
+    return 0;
+}
+int sscanf(const char *str, const char *format, ...)
+{
+    return 0;
+}
+const unsigned short **__ctype_b_loc(void)
+{
+    return &__ctype_b_ptr;
+}
+long int __strtol_internal(const char *__nptr, char **__endptr, int __base, int __group)
+{
+    return 0;
+}
+void *memset(void *s, int c, size_t n)
+{
+    memsetb(s, n, c);
+    return s;
+}
+void *calloc(size_t nmemb, size_t size)
+{
+    return malloc(nmemb * size, 0);
+}
+/** @}
+ */

 /branches/dynload/kernel/generic/src/lib/rd.c
 ,14 → 48,14
 /**
  * RAM disk initialization routine. At this point, the RAM disk memory is shared
- * and information about the share is provided as sysinfo values to the
- * userspace tasks.
+ * and information about the share is provided as sysinfo values to the userspace
+ * tasks.
  */
 int init_rd(rd_header_t *header, size_t size)
 {
     /* Identify RAM disk */
     if ((header->magic[0] != RD_MAG0) || (header->magic[1] != RD_MAG1) ||
-        (header->magic[2] != RD_MAG2) || (header->magic[3] != RD_MAG3))
+        (header->magic[2] != RD_MAG2) || (header->magic[3] != RD_MAG3))
         return RE_INVALID;
     /* Identify version */
 ,8 → 86,7
     if ((uint64_t) hsize + dsize > size)
         dsize = size - hsize;
-    rd_parea.pbase = ALIGN_DOWN((uintptr_t) KA2PA((void *) header + hsize),
-        FRAME_SIZE);
+    rd_parea.pbase = ALIGN_DOWN((uintptr_t) KA2PA((void *) header + hsize), FRAME_SIZE);
     rd_parea.vbase = (uintptr_t) ((void *) header + hsize);
     rd_parea.frames = SIZE2FRAMES(dsize);
     rd_parea.cacheable = true;
 ,8 → 95,8
     sysinfo_set_item_val("rd", NULL, true);
     sysinfo_set_item_val("rd.header_size", NULL, hsize);
     sysinfo_set_item_val("rd.size", NULL, dsize);
-    sysinfo_set_item_val("rd.address.physical", NULL,
-        (unative_t) KA2PA((void *) header + hsize));
+    sysinfo_set_item_val("rd.address.physical", NULL, (unative_t)
+        KA2PA((void *) header + hsize));
     return RE_OK;
 }

 /branches/dynload/kernel/generic/src/lib/objc.c
 ,0 → 1,60
+/*
+ * Copyright (c) 2007 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup generic
+ * @{
+ */
+/**
+ * @file
+ * @brief   Objective C run-time environment.
+ *
+ * This file containts the (growing subset of)
+ * Objective C run-time environment. The code currently
+ * relies on the external libobjc library, but this
+ * dependency will be removed eventually.
+ */
+#include <lib/objc.h>
+@implementation base_t
++ (id) new
+{
+    return class_create_instance(self);
+}
+- (id) dispose
+{
+    return object_dispose(self);
+}
+@end
+/** @}
+ */

 /branches/dynload/kernel/generic/src/sysinfo/sysinfo.c
 ,15 → 281,10
     return ret;
 }
-#define SYSINFO_MAX_LEN 1024
 unative_t sys_sysinfo_valid(unative_t ptr, unative_t len)
 {
     char *str;
     sysinfo_rettype_t ret = {0, 0};
-    if (len > SYSINFO_MAX_LEN)
-        return ret.valid;
     str = malloc(len + 1, 0);
     ASSERT(str);
 ,9 → 299,6
 {
     char *str;
     sysinfo_rettype_t ret = {0, 0};
-    if (len > SYSINFO_MAX_LEN)
-        return ret.val;
     str = malloc(len + 1, 0);
     ASSERT(str);

 /branches/dynload/kernel/generic/include/mm/as.h
 ,6 → 53,10
 #include <adt/btree.h>
 #include <lib/elf.h>
+#ifdef __OBJC__
+#include <lib/objc.h>
+#endif
 /**
  * Defined to be true if user address space and kernel address space shadow each
  * other.
 ,6 → 84,47
 /** The page fault was caused by memcpy_from_uspace() or memcpy_to_uspace(). */
 #define AS_PF_DEFER     2
+#ifdef __OBJC__
+@interface as_t : base_t {
+    @public
+        /** Protected by asidlock. */
+        link_t inactive_as_with_asid_link;
+        /**
+         * Number of processors on wich is this address space active.
+         * Protected by asidlock.
+         */
+        count_t cpu_refcount;
+        /**
+         * Address space identifier.
+         * Constant on architectures that do not support ASIDs.
+         * Protected by asidlock.
+         */
+        asid_t asid;
+        /** Number of references (i.e tasks that reference this as). */
+        atomic_t refcount;
+        mutex_t lock;
+        /** B+tree of address space areas. */
+        btree_t as_area_btree;
+        /** Non-generic content. */
+        as_genarch_t genarch;
+        /** Architecture specific content. */
+        as_arch_t arch;
+}
++ (pte_t *) page_table_create: (int) flags;
++ (void) page_table_destroy: (pte_t *) page_table;
+- (void) page_table_lock: (bool) _lock;
+- (void) page_table_unlock: (bool) unlock;
+@end
+#else
 /** Address space structure.
  *
  * as_t contains the list of as_areas of userspace accessible
 ,6 → 168,7
     void (* page_table_lock)(as_t *as, bool lock);
     void (* page_table_unlock)(as_t *as, bool unlock);
 } as_operations_t;
+#endif
 /**
  * This structure contains information associated with the shared address space
 ,7 → 249,10
 extern as_t *AS_KERNEL;
+#ifndef __OBJC__
 extern as_operations_t *as_operations;
+#endif
 extern link_t inactive_as_with_asid_head;
 extern void as_init(void);

 /branches/dynload/kernel/generic/include/mm/page.h
 ,6 → 39,11
 #include <mm/as.h>
 #include <memstr.h>
+/**
+ * Macro for computing page color.
+ */
+#define PAGE_COLOR(va)  (((va) >> PAGE_WIDTH) & ((1 << PAGE_COLOR_BITS) - 1))
 /** Operations to manipulate page mappings. */
 typedef struct {
     void (* mapping_insert)(as_t *as, uintptr_t page, uintptr_t frame,

 /branches/dynload/kernel/generic/include/config.h
 ,6 → 40,8
 #define STACK_SIZE      PAGE_SIZE
+#define CONFIG_MEMORY_SIZE  (16 * 1024 * 1024)
 #define CONFIG_INIT_TASKS   32
 typedef struct {

 /branches/dynload/kernel/generic/include/lib/objc.h
 ,0 → 1,50
+/*
+ * Copyright (c) 2007 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup generic
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_OBJC_H_
+#define KERN_OBJC_H_
+extern id class_create_instance(Class _class);
+extern id object_dispose(id object);
+@interface base_t {
+    Class isa;
+}
++ (id) new;
+- (id) free;
+@end
+#endif

 /branches/dynload/kernel/generic/include/lib/objc_ext.h
 ,0 → 1,64
+/*
+ * Copyright (c) 2007 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup generic
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_OBJC_EXT_H_
+#define KERN_OBJC_EXT_H_
+#include <arch/types.h>
+#include <arch/arg.h>
+extern void *stderr;
+extern void __assert_fail(const char *assertion, const char *file, unsigned int line, const char *function);
+extern void abort(void);
+extern void *fopen(const char *path, const char *mode);
+extern size_t fread(void *ptr, size_t size, size_t nmemb, void *stream);
+extern size_t fwrite(const void *ptr, size_t size, size_t nmemb, void *stream);
+extern int fflush(void *stream);
+extern int feof(void *stream);
+extern int fclose(void *stream);
+extern int vfprintf(void *stream, const char *format, va_list ap);
+extern int sscanf(const char *str, const char *format, ...);
+extern const unsigned short **__ctype_b_loc(void);
+extern long int __strtol_internal(const char *__nptr, char **__endptr, int __base, int __group);
+extern void *memset(void *s, int c, size_t n);
+extern void *calloc(size_t nmemb, size_t size);
+#endif
+/** @}
+ */

 /branches/dynload/kernel/generic/include/ipc/ipc.h
 ,13 → 281,6
     /** Buffer for IPC_M_DATA_WRITE and IPC_M_DATA_READ. */
     uint8_t *buffer;
-    /*
-     * The forward operation can masquerade the caller phone. For those
-     * cases, we must keep it aside so that the answer is processed
-     * correctly.
-     */
-    phone_t *caller_phone;
 } call_t;
 extern void ipc_init(void);
 ,7 → 287,7
 extern call_t * ipc_wait_for_call(answerbox_t *, uint32_t, int);
 extern void ipc_answer(answerbox_t *, call_t *);
 extern int ipc_call(phone_t *, call_t *);
-extern int ipc_call_sync(phone_t *, call_t *);
+extern void ipc_call_sync(phone_t *, call_t *);
 extern void ipc_phone_init(phone_t *);
 extern void ipc_phone_connect(phone_t *, answerbox_t *);
 extern void ipc_call_free(call_t *);

 /branches/dynload/kernel/generic/include/macros.h
 ,20 → 40,20
 #define isdigit(d)  (((d) >= '0') && ((d) <= '9'))
 #define islower(c)  (((c) >= 'a') && ((c) <= 'z'))
 #define isupper(c)  (((c) >= 'A') && ((c) <= 'Z'))
-#define isalpha(c)  (is_lower((c)) || is_upper((c)))
-#define isalphanum(c)   (is_alpha((c)) || is_digit((c)))
+#define isalpha(c)  (is_lower(c) || is_upper(c))
+#define isalphanum(c)   (is_alpha(c) || is_digit(c))
 #define isspace(c)  (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || \
-                ((c) == '\r'))
+                ((c) == '\r'))
 #define min(a,b)    ((a) < (b) ? (a) : (b))
 #define max(a,b)    ((a) > (b) ? (a) : (b))
-/** Return true if the intervals overlap.
+/** Return true if the interlvals overlap.
  *
- * @param s1        Start address of the first interval.
- * @param sz1       Size of the first interval.
- * @param s2        Start address of the second interval.
- * @param sz2       Size of the second interval.
+ * @param s1 Start address of the first interval.
+ * @param sz1 Size of the first interval.
+ * @param s2 Start address of the second interval.
+ * @param sz2 Size of the second interval.
  */
 static inline int overlaps(uintptr_t s1, size_t sz1, uintptr_t s2, size_t sz2)
 {
 ,15 → 64,11
 }
 /* Compute overlapping of physical addresses */
-#define PA_overlaps(x, szx, y, szy) \
-    overlaps(KA2PA((x)), (szx), KA2PA((y)), (szy))
+#define PA_overlaps(x, szx, y, szy) overlaps(KA2PA(x), szx, KA2PA(y), szy)
-#define SIZE2KB(size) ((size) >> 10)
-#define SIZE2MB(size) ((size) >> 20)
+#define SIZE2KB(size) (size >> 10)
+#define SIZE2MB(size) (size >> 20)
-#define KB2SIZE(kb) ((kb) << 10)
-#define MB2SIZE(mb) ((mb) << 20)
 #define STRING(arg) STRING_ARG(arg)
 #define STRING_ARG(arg) #arg

/branches/dynload/kernel/generic/include/errno.h
56,7 → 56,6
#define EINVAL -13 /* Invalid value */
#define EBUSY -14 /* Resource is busy */
#define EOVERFLOW -15 /* The result does not fit its size. */
#define EINTR -16 /* Operation was interrupted. */

#endif

 /branches/dynload/kernel/arch/ppc32/include/mm/page.h
 ,6 → 40,8
 #define PAGE_WIDTH  FRAME_WIDTH
 #define PAGE_SIZE   FRAME_SIZE
+#define PAGE_COLOR_BITS 0            /* dummy */
 #ifdef KERNEL
 #ifndef __ASM__

 /branches/dynload/kernel/arch/ppc32/Makefile.inc
 ,15 → 29,11
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 BFD_NAME = elf32-powerpc
 BFD_ARCH = powerpc:common
 BFD = binary
 TARGET = ppc-linux-gnu
-TOOLCHAIN_DIR = $(CROSS_PREFIX)/ppc
+TOOLCHAIN_DIR = /usr/local/ppc
 GCC_CFLAGS += -mcpu=powerpc -msoft-float -m32
 AFLAGS += -a32

 /branches/dynload/kernel/arch/ia32/src/drivers/ega.c
 ,6 → 93,12
     sysinfo_set_item_val("fb.width", NULL, ROW);
     sysinfo_set_item_val("fb.height", NULL, ROWS);
     sysinfo_set_item_val("fb.address.physical", NULL, VIDEORAM);
+    sysinfo_set_item_val("fb.address.color", NULL, PAGE_COLOR((uintptr_t)
+        videoram));
+#ifndef CONFIG_FB
+    putchar('\n');
+#endif
 }
 static void ega_display_char(char ch)

 /branches/dynload/kernel/arch/ia32/src/asm.S
 ,7 → 71,7
  * @param MEMCPY_SRC(%esp)  Source address.
  * @param MEMCPY_SIZE(%esp) Size.
  *
- * @return MEMCPY_DST(%esp) on success and 0 on failure.
+ * @return MEMCPY_SRC(%esp) on success and 0 on failure.
  */
 memcpy:
 memcpy_from_uspace:
 ,7 → 96,7
 :
     movl %edx, %edi
     movl %eax, %esi
-    movl MEMCPY_DST(%esp), %eax /* MEMCPY_DST(%esp), success */
+    movl MEMCPY_SRC(%esp), %eax /* MEMCPY_SRC(%esp), success */
     ret
 /*

 /branches/dynload/kernel/arch/ia32/src/mm/as.c
 ,7 → 39,9
 /** Architecture dependent address space init. */
 void as_arch_init(void)
 {
+#ifndef __OBJC__
     as_operations = &as_pt_operations;
+#endif
 }
 /** @}

 /branches/dynload/kernel/arch/ia32/include/atomic.h
 ,7 → 113,7
         "xchgl %0, %1\n"
         "testl %1, %1\n"
         "jnz 0b\n"
-                : "+m" (val->count), "=&r"(tmp)
+                : "+m" (val->count), "=r"(tmp)
     );
     /*
      * Prevent critical section code from bleeding out this way up.

 /branches/dynload/kernel/arch/ia32/include/mm/page.h
 ,6 → 40,8
 #define PAGE_WIDTH  FRAME_WIDTH
 #define PAGE_SIZE   FRAME_SIZE
+#define PAGE_COLOR_BITS 0            /* dummy */
 #ifdef KERNEL
 #ifndef __ASM__

 /branches/dynload/kernel/arch/ia32/Makefile.inc
 ,15 → 29,11
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 BFD_NAME = elf32-i386
 BFD_ARCH = i386
 BFD = binary
 TARGET = i686-pc-linux-gnu
-TOOLCHAIN_DIR = $(CROSS_PREFIX)/i686
+TOOLCHAIN_DIR = /usr/local/i686
 DEFS += -DMACHINE=$(MACHINE) -D__32_BITS__
 ,7 → 74,7
     CONFIG_HT = n
 endif
 ifeq ($(MACHINE),core)
-    FPU_NO_CFLAGS = -mno-mmx -mno-sse -mno-sse2 -mno-sse3
+    FPU_NO_CFLAGS = -mno-mmmx -mno-sse -mno-sse2 -mno-sse3
     CMN2 = -march=prescott
     GCC_CFLAGS += $(CMN2)
     ICC_CFLAGS += $(CMN2)

 /branches/dynload/kernel/arch/amd64/include/atomic.h
 ,13 → 108,13
 #endif
         "mov %0, %1\n"
         "testq %1, %1\n"
-        "jnz 0b\n"       /* lightweight looping on locked spinlock */
+        "jnz 0b\n"       /* Lightweight looping on locked spinlock */
         "incq %1\n"      /* now use the atomic operation */
         "xchgq %0, %1\n"
         "testq %1, %1\n"
         "jnz 0b\n"
-                : "+m" (val->count), "=&r" (tmp)
+                : "+m" (val->count), "=r"(tmp)
     );
     /*
      * Prevent critical section code from bleeding out this way up.

 /branches/dynload/kernel/arch/amd64/include/mm/page.h
 ,6 → 52,8
 #define PAGE_WIDTH  FRAME_WIDTH
 #define PAGE_SIZE   FRAME_SIZE
+#define PAGE_COLOR_BITS 0            /* dummy */
 #ifdef KERNEL
 #ifndef __ASM__

 /branches/dynload/kernel/arch/amd64/Makefile.inc
 ,15 → 29,11
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 BFD_NAME = elf64-x86-64
 BFD_ARCH = i386:x86-64
 BFD = binary
 TARGET = amd64-linux-gnu
-TOOLCHAIN_DIR = $(CROSS_PREFIX)/amd64
+TOOLCHAIN_DIR = /usr/local/amd64
 FPU_NO_CFLAGS = -mno-sse -mno-sse2
 CMN1 = -m64 -mcmodel=kernel -mno-red-zone -fno-unwind-tables

 /branches/dynload/kernel/arch/amd64/src/asm_utils.S
 ,12 → 98,12
  * @param MEMCPY_SRC    Source address.
  * @param MEMCPY_SIZE   Number of bytes to copy.
  *
- * @retrun MEMCPY_DST on success, 0 on failure.
+ * @retrun MEMCPY_SRC on success, 0 on failure.
  */
 memcpy:
 memcpy_from_uspace:
 memcpy_to_uspace:
-    movq MEMCPY_DST, %rax
+    movq MEMCPY_SRC, %rax
     movq MEMCPY_SIZE, %rcx
     shrq $3, %rcx           /* size / 8 */

 /branches/dynload/kernel/arch/mips32/include/mm/page.h
 ,6 → 40,8
 #define PAGE_WIDTH  FRAME_WIDTH
 #define PAGE_SIZE   FRAME_SIZE
+#define PAGE_COLOR_BITS 0            /* dummy */
 #ifndef __ASM__
 #   define KA2PA(x) (((uintptr_t) (x)) - 0x80000000)
 #   define PA2KA(x) (((uintptr_t) (x)) + 0x80000000)

 /branches/dynload/kernel/arch/mips32/include/mm/tlb.h
 ,9 → 35,6
 #ifndef KERN_mips32_TLB_H_
 #define KERN_mips32_TLB_H_
-#include <arch/types.h>
-#include <typedefs.h>
-#include <arch/mm/asid.h>
 #include <arch/exception.h>
 #ifdef TLBCNT
 ,13 → 46,7
 #define TLB_WIRED       1
 #define TLB_KSTACK_WIRED_INDEX  0
-#define TLB_PAGE_MASK_4K    (0x000 << 13)
-#define TLB_PAGE_MASK_16K   (0x003 << 13)
-#define TLB_PAGE_MASK_64K   (0x00f << 13)
-#define TLB_PAGE_MASK_256K  (0x03f << 13)
-#define TLB_PAGE_MASK_1M    (0x0ff << 13)
-#define TLB_PAGE_MASK_4M    (0x3ff << 13)
-#define TLB_PAGE_MASK_16M   (0xfff << 13)
+#define TLB_PAGE_MASK_16K   (0x3<<13)
 #define PAGE_UNCACHED           2
 #define PAGE_CACHEABLE_EXC_WRITE    5
 ,8 → 159,6
 extern void tlb_invalid(istate_t *istate);
 extern void tlb_refill(istate_t *istate);
 extern void tlb_modified(istate_t *istate);
-extern void tlb_prepare_entry_lo(entry_lo_t *lo, bool g, bool v, bool d, bool cacheable, uintptr_t pfn);
-extern void tlb_prepare_entry_hi(entry_hi_t *hi, asid_t asid, uintptr_t addr);
 #endif

 /branches/dynload/kernel/arch/mips32/include/mm/as.h
 ,7 → 38,7
 #define KERNEL_ADDRESS_SPACE_SHADOWED_ARCH  0
 #define KERNEL_ADDRESS_SPACE_START_ARCH     (unsigned long) 0x80000000
-#define KERNEL_ADDRESS_SPACE_END_ARCH       (unsigned long) 0x9fffffff
+#define KERNEL_ADDRESS_SPACE_END_ARCH       (unsigned long) 0xffffffff
 #define USER_ADDRESS_SPACE_START_ARCH       (unsigned long) 0x00000000
 #define USER_ADDRESS_SPACE_END_ARCH     (unsigned long) 0x7fffffff

 /branches/dynload/kernel/arch/mips32/include/drivers/arc.h
 ,0 → 1,267
+/*
+ * Copyright (c) 2005 Ondrej Palkovsky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup mips32
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_mips32_ARC_H_
+#define KERN_mips32_ARC_H_
+#include <arch/types.h>
+#include <console/chardev.h>
+#define ARC_BASE_ADDR 0x1000;
+#define ARC_MAGIC 0x53435241
+/* Frame size used by ARC */
+#define ARC_FRAME 4096
+typedef enum {
+    CmResourceTypeNull = 0,
+    CmResourceTypePort,
+    CmResourceTypeInterrupt,
+    CmResourceTypeMemory,
+    CmResourceTypeDma,
+    CmResourceTypeDeviceSpecific,
+    CmResourceTypeVendor,
+    CmResourceTypeProductName,
+    CmResourceTypeSerialNumber
+} cm_resource_type;
+typedef struct {
+    uint8_t type;
+    uint8_t sharedisposition;
+    uint16_t flags;
+    union {
+        struct {
+            long long start; /* 64-bit phys address */
+            unsigned long length;
+        }port;
+        struct {
+            unsigned long level;
+            unsigned long vector;
+            unsigned long reserved1;
+        }interrupt;
+        struct {
+            long long start; /* 64-bit phys address */
+            unsigned long length;
+        }memory;
+    }u;
+} __attribute__ ((packed)) cm_resource_descriptor;
+typedef struct {
+    uint16_t version;
+    uint16_t revision;
+    unsigned long count;
+    cm_resource_descriptor descr[1];
+} __attribute__ ((packed)) cm_resource_list;
+typedef enum {
+    SystemClass = 0,
+    ProcessorClass,
+    CacheClass,
+    AdapterClass,
+    ControllerClass,
+    PeripheralClass,
+    MemoryClass
+} arc_component_class;
+typedef enum {
+    ARC_type = 0,
+    CPU_type,
+    FPU_type,
+    PrimaryICache,
+    PrimaryDCache,
+    SecondaryICache,
+    SecondaryDCache,
+    SecondaryCache,
+    Memory, /* Not in NT PROM */
+    EISAAdapter,
+    TCAdapter,
+    SCSIAdapter,
+    DTIAdapter,
+    MultiFunctionAdapter,
+    DiskController,
+    TapeController,
+    CDROMController,
+    WORMController,
+    SerialController,
+    NetworkController,
+    DisplayController,
+    ParallelController,
+    PointerController,
+    KeyboardController,
+    AudioController,
+    OtherController,
+    DiskPeripheral,
+    FloppyDiskPeripheral,
+    TapePeripheral,
+    ModemPeripheral,
+    MonitorPeripheral,
+    PrinterPeripheral,
+    PointerPeripheral,
+    KeyboardPeripheral,
+    TerminalPeripheral,
+    LinePeripheral,
+    NetworkPeripheral,
+    OtherPeripheral,
+    XTalkAdapter,
+    PCIAdapter,
+    GIOAdapter,
+    TPUAdapter,
+    Anonymous
+} arc_component_type;
+typedef enum {
+    Failed = 1,
+    ReadOnly = 2,
+    Removable = 4,
+    ConsoleIn = 8,
+    ConsoleOut = 16,
+    Input = 32,
+    Output = 64
+} arc_component_flags;
+typedef struct  {
+    arc_component_class class;
+    arc_component_type type;
+    arc_component_flags flags;
+    uint16_t revision;
+    uint16_t version;
+    uint32_t key;
+    uint32_t affinitymask;
+    uint32_t configdatasize;
+    uint32_t identifier_len;
+    char *identifier;
+} __attribute__ ((packed)) arc_component;
+typedef struct {
+    uint16_t year;
+    uint16_t month;
+    uint16_t day;
+    uint16_t hour;
+    uint16_t minutes;
+    uint16_t seconds;
+    uint16_t mseconds;
+} __attribute__ ((packed)) arc_timeinfo;
+/* This is the SGI block structure, WinNT has it different */
+typedef enum {
+    ExceptionBlock,
+    SystemParameterBlock,
+    FreeContiguous,
+    FreeMemory,
+    BadMemory,
+    LoadedProgram,
+    FirmwareTemporary,
+    FirmwarePermanent
+} arc_memorytype_t;
+typedef struct  {
+    arc_memorytype_t type;
+    uint32_t basepage;  /* *4096 = baseaddr */
+    uint32_t basecount;
+} arc_memdescriptor_t;
+typedef struct {
+    char vendorid[8];
+    char prodid[8];
+} arc_sysid_t;
+typedef struct {
+    long (*load)(void); /* ... */
+    long (*invoke)(uint32_t eaddr,uint32_t saddr,uint32_t argc,char **argv,
+               char **envp);
+    long (*execute)(char *path,uint32_t argc,char **argv,char **envp);
+    void (*halt)(void);
+    void (*powerdown)(void);
+    void (*restart)(void);
+    void (*reboot)(void);
+    void (*enterinteractivemode)(void);
+    long (*reserved)(void);
+/* 10 */
+    arc_component * (*getpeer)(arc_component *c);
+    arc_component * (*getchild)(arc_component *c);
+    arc_component * (*getparent)(arc_component *c);
+    long (*getconfigurationdata)(void *configdata, arc_component *c);
+    long (*addchild)(arc_component *c, arc_component *template,
+             void *configdata);
+    long (*deletecomponet)(arc_component *current);
+    long (*getcomponent)(char *path);
+    long (*saveconfiguration)(void);
+    arc_sysid_t (*getsystemid)(void);
+    arc_memdescriptor_t * (*getmemorydescriptor)(arc_memdescriptor_t *cur);
+/* 20 */
+    long (*reserved2)(void);
+    arc_timeinfo * (*gettime)(void);
+    uint32_t (*getrelativetime)(void);
+    long (*getdirectoryentry)();
+    long (*open)(void); /* ... */
+    long (*close)(uint32_t fileid);
+    long (*read)(uint32_t fileid,void *buf,uint32_t n,uint32_t *cnt);
+    long (*getreadstatus)(uint32_t fileid);
+    long (*write)(uint32_t fileid, void *buf,uint32_t n,uint32_t *cnt);
+    long (*seek)(void); /* ... */
+/* 30 */
+    long (*mount)(void); /* ... */
+    char * (*getenvironmentvariable)(char *name);
+    char * (*setenvironmentvariable)(char *name, char *value);
+    long (*getfileinformation)(void); /* ... */
+    long (*setfileinformation)(uint32_t fileid,uint32_t attflags,uint32_t attmask);
+    void (*flushallcaches)(void);
+    long (*testunicodecharacter)(void); /* ... */
+    long (*getdisplaystatus)(void); /* ... */
+} arc_func_vector_t;
+typedef struct {
+    uint32_t signature;
+    uint32_t length;
+    uint16_t version;
+    uint16_t revision;
+    void *restartblock;
+    void *debugblock;
+    void *gevector;
+    void *utlbmissvector;
+    uint32_t firmwarevectorlen;
+    arc_func_vector_t *firmwarevector;
+    uint32_t privvectorlen;
+    void *privvector;
+    uint32_t adaptercount;
+} __attribute__ ((packed)) arc_sbp;
+extern int arc_init(void);
+extern int arc_reboot(void);
+extern int arc_frame_init(void);
+extern int arc_console(void);
+#endif
+ /** @}
+ */

 /branches/dynload/kernel/arch/mips32/include/drivers/serial.h
 ,8 → 37,6
 #include <console/chardev.h>
-#define SERIAL_ADDRESS    0x98000000
 #define SERIAL_MAX        4
 #define SERIAL_COM1       0x3f8
 #define SERIAL_COM1_IRQ   4
 ,19 → 43,16
 #define SERIAL_COM2       0x2f8
 #define SERIAL_COM2_IRQ   3
-#define P_WRITEB(where, what)     (*((volatile char *) (SERIAL_ADDRESS + where)) = what)
-#define P_READB(where)            (*((volatile char *) (SERIAL_ADDRESS + where)))
+#define P_WRITEB(where,what)     (*((volatile char *) (0xB8000000+where))=what)
+#define P_READB(where)           (*((volatile char *)(0xB8000000+where)))
-#define SERIAL_READ(x)            P_READB(x)
-#define SERIAL_WRITE(x, c)        P_WRITEB(x, c)
+#define SERIAL_READ(x)           P_READB(x)
+#define SERIAL_WRITE(x,c)        P_WRITEB(x,c)
 /* Interrupt enable register */
 #define SERIAL_READ_IER(x)              (P_READB((x) + 1))
-#define SERIAL_WRITE_IER(x,c)           (P_WRITEB((x) + 1, c))
+#define SERIAL_WRITE_IER(x,c)           (P_WRITEB((x)+1,c))
 /* Interrupt identification register */
 #define SERIAL_READ_IIR(x)             (P_READB((x) + 2))
 /* Line status register */
 #define SERIAL_READ_LSR(x)             (P_READB((x) + 5))
 #define TRANSMIT_EMPTY_BIT      5

 /branches/dynload/kernel/arch/mips32/include/drivers/msim.h
 ,11 → 35,6
 #ifndef KERN_mips32_MSIM_H_
 #define KERN_mips32_MSIM_H_
-/** Address of devices. */
-#define MSIM_VIDEORAM       0x90000000
-#define MSIM_KBD_ADDRESS    0x90000000
-#define MSIM_KBD_IRQ        2
 #include <console/chardev.h>
 void msim_console(devno_t devno);

 /branches/dynload/kernel/arch/mips32/src/mips32.c
 ,6 → 48,7
 #include <sysinfo/sysinfo.h>
 #include <arch/interrupt.h>
+#include <arch/drivers/arc.h>
 #include <console/chardev.h>
 #include <arch/barrier.h>
 #include <arch/debugger.h>
 ,6 → 97,7
     /* Initialize dispatch table */
     exception_init();
+    arc_init();
     /* Copy the exception vectors to the right places */
     memcpy(TLB_EXC, (char *) tlb_refill_entry, EXCEPTION_JUMP_SIZE);
 ,7 → 187,8
 void arch_reboot(void)
 {
-    ___halt();
+    if (!arc_reboot())
+        ___halt();
     while (1)
         ;

 /branches/dynload/kernel/arch/mips32/src/drivers/arc.c
 ,0 → 1,394
+/*
+ * Copyright (c) 2005 Ondrej Palkovsky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup mips32
+ * @{
+ */
+/** @file
+ */
+#include <arch/drivers/arc.h>
+#include <arch/mm/page.h>
+#include <print.h>
+#include <arch.h>
+#include <byteorder.h>
+#include <arch/mm/frame.h>
+#include <mm/frame.h>
+#include <interrupt.h>
+#include <align.h>
+#include <console/console.h>
+#include <console/kconsole.h>
+#include <console/cmd.h>
+#include <mm/slab.h>
+/* This is a good joke, SGI HAS different types than NT bioses... */
+/* Here is the SGI type */
+static char *basetypes[] = {
+    "ExceptionBlock",
+    "SystemParameterBlock",
+    "FreeContiguous",
+    "FreeMemory",
+    "BadMemory",
+    "LoadedProgram",
+    "FirmwareTemporary",
+    "FirmwarePermanent"
+};
+static char *ctypes[] = {
+    "ARC_type",
+    "CPU_type",
+    "FPU_type",
+    "PrimaryICache",
+    "PrimaryDCache",
+    "SecondaryICache",
+    "SecondaryDCache",
+    "SecondaryCache",
+    "Memory",
+    "EISAAdapter",
+    "TCAdapter",
+    "SCSIAdapter",
+    "DTIAdapter",
+    "MultiFunctionAdapter",
+    "DiskController",
+    "TapeController",
+    "CDROMController",
+    "WORMController",
+    "SerialController",
+    "NetworkController",
+    "DisplayController",
+    "ParallelController",
+    "PointerController",
+    "KeyboardController",
+    "AudioController",
+    "OtherController",
+    "DiskPeripheral",
+    "FloppyDiskPeripheral",
+    "TapePeripheral",
+    "ModemPeripheral",
+    "MonitorPeripheral",
+    "PrinterPeripheral",
+    "PointerPeripheral",
+    "KeyboardPeripheral",
+    "TerminalPeripheral",
+    "OtherPeripheral",
+    "LinePeripheral",
+    "NetworkPeripheral"
+    "OtherPeripheral",
+    "XTalkAdapter",
+    "PCIAdapter",
+    "GIOAdapter",
+    "TPUAdapter",
+    "Anonymous"
+};
+static arc_sbp *sbp = (arc_sbp *) PA2KA(0x1000);
+static arc_func_vector_t *arc_entry;
+/** Return true if ARC is available */
+#define arc_enabled() (sbp != NULL)
+/** Print configuration data that ARC reports about component */
+static void arc_print_confdata(arc_component *c)
+{
+    cm_resource_list *configdata;
+    unsigned int i;
+    if (!c->configdatasize)
+        return; /* No configuration data */
+    configdata = malloc(c->configdatasize, 0);
+    if (arc_entry->getconfigurationdata(configdata, c)) {
+        free(configdata);
+        return;
+    }
+    /* Does not seem to return meaningful data, don't use now */
+    free(configdata);
+    return;
+    for (i = 0; i < configdata->count; i++) {
+        switch (configdata->descr[i].type) {
+        case CmResourceTypePort:
+            printf("Port: %p-size:%d ",
+                   (uintptr_t) configdata->descr[i].u.port.start,
+                   configdata->descr[i].u.port.length);
+            break;
+        case CmResourceTypeInterrupt:
+            printf("Irq: level(%d) vector(%d) ",
+                   configdata->descr[i].u.interrupt.level,
+                   configdata->descr[i].u.interrupt.vector);
+            break;
+        case CmResourceTypeMemory:
+            printf("Memory: %p-size:%d ",
+                   (uintptr_t)configdata->descr[i].u.port.start,
+                   configdata->descr[i].u.port.length);
+            break;
+        default:
+            break;
+        }
+    }
+    free(configdata);
+}
+/** Print information about component */
+static void arc_print_component(arc_component *c)
+{
+    unsigned int i;
+    printf("%s: ",ctypes[c->type]);
+    for (i = 0; i < c->identifier_len; i++)
+        printf("%c", c->identifier[i]);
+    printf(" ");
+    arc_print_confdata(c);
+    printf("\n");
+}
+/**
+ * Read from ARC bios configuration data and print it
+ */
+static int cmd_arc_print_devices(cmd_arg_t *argv)
+{
+    arc_component *c, *next;
+    c = arc_entry->getchild(NULL);
+    while (c) {
+        arc_print_component(c);
+        next = arc_entry->getchild(c);
+        while (!next) {
+            next = arc_entry->getpeer(c);
+            if (!next)
+                c = arc_entry->getparent(c);
+            if (!c)
+                return 0;
+        }
+        c = next;
+    }
+    return 1;
+}
+static cmd_info_t devlist_info = {
+    .name = "arcdevlist",
+    .description = "Print arc device list",
+    .func = cmd_arc_print_devices,
+    .argc = 0
+};
+/** Read from arc bios memory map and print it
+ *
+ */
+void physmem_print(void)
+{
+    printf("Base       Size       Type\n");
+    printf("---------- ---------- ---------\n");
+    if (arc_enabled()) {
+        arc_memdescriptor_t *desc = arc_entry->getmemorydescriptor(NULL);
+        while (desc) {
+            printf("%#10x %#10x %s\n",
+                desc->basepage * ARC_FRAME, desc->basecount * ARC_FRAME,
+                basetypes[desc->type]);
+            desc = arc_entry->getmemorydescriptor(desc);
+        }
+    } else
+        printf("%#10x %#10x free\n", 0, CONFIG_MEMORY_SIZE);
+}
+/** Print charactor to console */
+static void arc_putchar(char ch)
+{
+    uint32_t cnt;
+    ipl_t ipl;
+    /* TODO: Should be spinlock? */
+    ipl = interrupts_disable();
+    arc_entry->write(1, &ch, 1, &cnt);
+    interrupts_restore(ipl);
+}
+/** Initialize ARC structure
+ *
+ * @return 0 - ARC OK, -1 - ARC does not exist
+ */
+int arc_init(void)
+{
+    if (sbp->signature != ARC_MAGIC) {
+        sbp = NULL;
+        return -1;
+    }
+    arc_entry = sbp->firmwarevector;
+    arc_putchar('A');
+    arc_putchar('R');
+    arc_putchar('C');
+    arc_putchar('\n');
+    /* Add command for resetting the computer */
+    cmd_initialize(&devlist_info);
+    cmd_register(&devlist_info);
+    return 0;
+}
+int arc_reboot(void)
+{
+    if (arc_enabled()) {
+        arc_entry->reboot();
+        return true;
+    }
+    return false;
+}
+static bool kbd_polling_enabled;
+static chardev_t console;
+/** Try to get character, return character or -1 if not available */
+static void arc_keyboard_poll(void)
+{
+    char ch;
+    uint32_t count;
+    long result;
+    if (!kbd_polling_enabled)
+        return;
+    if (arc_entry->getreadstatus(0))
+        return;
+    result = arc_entry->read(0, &ch, 1, &count);
+    if ((result) || (count != 1)) {
+        return;
+    }
+    if (ch == '\r')
+        ch = '\n';
+    if (ch == 0x7f)
+        ch = '\b';
+    chardev_push_character(&console, ch);
+}
+static char arc_read(chardev_t *dev)
+{
+    char ch;
+    uint32_t count;
+    long result;
+    result = arc_entry->read(0, &ch, 1, &count);
+    if ((result) || (count != 1)) {
+        printf("Error reading from ARC keyboard.\n");
+        cpu_halt();
+    }
+    if (ch == '\r')
+        return '\n';
+    if (ch == 0x7f)
+        return '\b';
+    return ch;
+}
+static void arc_write(chardev_t *dev, const char ch)
+{
+    arc_putchar(ch);
+}
+static void arc_enable(chardev_t *dev)
+{
+    kbd_polling_enabled = true;
+}
+static void arc_disable(chardev_t *dev)
+{
+    kbd_polling_enabled = false;
+}
+static chardev_operations_t arc_ops = {
+    .resume = arc_enable,
+    .suspend = arc_disable,
+    .write = arc_write,
+    .read = arc_read
+};
+int arc_console(void)
+{
+    if (arc_enabled()) {
+        kbd_polling_enabled = true;
+        chardev_initialize("arc_console", &console, &arc_ops);
+        virtual_timer_fnc = &arc_keyboard_poll;
+        stdin = &console;
+        stdout = &console;
+        return true;
+    }
+    return false;
+}
+/* Initialize frame zones from ARC firmware.
+ * In the future we may use even the FirmwareTemporary regions,
+ * currently we use the FreeMemory (what about the LoadedProgram?)
+ */
+int arc_frame_init(void)
+{
+    if (arc_enabled()) {
+        arc_memdescriptor_t *desc;
+        uintptr_t base;
+        size_t basesize;
+        desc = arc_entry->getmemorydescriptor(NULL);
+        while (desc) {
+            if ((desc->type == FreeMemory) ||
+                (desc->type == FreeContiguous)) {
+                base = desc->basepage*ARC_FRAME;
+                basesize = desc->basecount*ARC_FRAME;
+                if (base % FRAME_SIZE ) {
+                    basesize -= FRAME_SIZE - (base % FRAME_SIZE);
+                    base = ALIGN_UP(base, FRAME_SIZE);
+                }
+                basesize = ALIGN_DOWN(basesize, FRAME_SIZE);
+                zone_create(ADDR2PFN(base), SIZE2FRAMES(basesize),
+                        ADDR2PFN(base), 0);
+            }
+            desc = arc_entry->getmemorydescriptor(desc);
+        }
+        return true;
+    }
+    return false;
+}
+/** @}
+ */

 /branches/dynload/kernel/arch/mips32/src/drivers/msim.c
 ,9 → 39,12
 #include <arch/cp0.h>
 #include <console/console.h>
 #include <sysinfo/sysinfo.h>
-#include <ddi/ddi.h>
-static parea_t msim_parea;
+/** Address of devices. */
+#define MSIM_VIDEORAM       0xB0000000
+#define MSIM_KBD_ADDRESS    0xB0000000
+#define MSIM_KBD_IRQ        2
 static chardev_t console;
 static irq_t msim_irq;
 ,16 → 158,6
     sysinfo_set_item_val("kbd.devno", NULL, devno);
     sysinfo_set_item_val("kbd.inr", NULL, MSIM_KBD_IRQ);
     sysinfo_set_item_val("kbd.address.virtual", NULL, MSIM_KBD_ADDRESS);
-    msim_parea.pbase = KA2PA(MSIM_VIDEORAM);
-    msim_parea.vbase = MSIM_VIDEORAM;
-    msim_parea.frames = 1;
-    msim_parea.cacheable = false;
-    ddi_parea_register(&msim_parea);
-    sysinfo_set_item_val("fb", NULL, true);
-    sysinfo_set_item_val("fb.kind", NULL, 3);
-    sysinfo_set_item_val("fb.address.physical", NULL, KA2PA(MSIM_VIDEORAM));
 }
 /** @}

 /branches/dynload/kernel/arch/mips32/src/mm/tlb.c
 ,14 → 47,18
 #include <align.h>
 #include <interrupt.h>
-static void tlb_refill_fail(istate_t *);
-static void tlb_invalid_fail(istate_t *);
-static void tlb_modified_fail(istate_t *);
+static void tlb_refill_fail(istate_t *istate);
+static void tlb_invalid_fail(istate_t *istate);
+static void tlb_modified_fail(istate_t *istate);
-static pte_t *find_mapping_and_check(uintptr_t, int, istate_t *, int *);
+static pte_t *find_mapping_and_check(uintptr_t badvaddr, int access, istate_t *istate, int *pfrc);
-/** Initialize TLB.
+static void prepare_entry_lo(entry_lo_t *lo, bool g, bool v, bool d, bool cacheable, uintptr_t pfn);
+static void prepare_entry_hi(entry_hi_t *hi, asid_t asid, uintptr_t addr);
+/** Initialize TLB
  *
+ * Initialize TLB.
  * Invalidate all entries and mark wired entries.
  */
 void tlb_arch_init(void)
 ,6 → 76,7
         cp0_index_write(i);
         tlbwi();
     }
     /*
      * The kernel is going to make use of some wired
 ,9 → 85,11
     cp0_wired_write(TLB_WIRED);
 }
-/** Process TLB Refill Exception.
+/** Process TLB Refill Exception
  *
- * @param istate    Interrupted register context.
+ * Process TLB Refill Exception.
+ *
+ * @param istate Interrupted register context.
  */
 void tlb_refill(istate_t *istate)
 {
 ,15 → 131,14
      */
     pte->a = 1;
-    tlb_prepare_entry_hi(&hi, asid, badvaddr);
-    tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->d, pte->cacheable,
-        pte->pfn);
+    prepare_entry_hi(&hi, asid, badvaddr);
+    prepare_entry_lo(&lo, pte->g, pte->p, pte->d, pte->cacheable, pte->pfn);
     /*
      * New entry is to be inserted into TLB
      */
     cp0_entry_hi_write(hi.value);
-    if ((badvaddr / PAGE_SIZE) % 2 == 0) {
+    if ((badvaddr/PAGE_SIZE) % 2 == 0) {
         cp0_entry_lo0_write(lo.value);
         cp0_entry_lo1_write(0);
     }
 ,9 → 157,11
     tlb_refill_fail(istate);
 }
-/** Process TLB Invalid Exception.
+/** Process TLB Invalid Exception
  *
- * @param istate    Interrupted register context.
+ * Process TLB Invalid Exception.
+ *
+ * @param istate Interrupted register context.
  */
 void tlb_invalid(istate_t *istate)
 {
 ,7 → 178,7
      * Locate the faulting entry in TLB.
      */
     hi.value = cp0_entry_hi_read();
-    tlb_prepare_entry_hi(&hi, hi.asid, badvaddr);
+    prepare_entry_hi(&hi, hi.asid, badvaddr);
     cp0_entry_hi_write(hi.value);
     tlbp();
     index.value = cp0_index_read();
 ,13 → 221,12
      */
     pte->a = 1;
-    tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->d, pte->cacheable,
-        pte->pfn);
+    prepare_entry_lo(&lo, pte->g, pte->p, pte->d, pte->cacheable, pte->pfn);
     /*
      * The entry is to be updated in TLB.
      */
-    if ((badvaddr / PAGE_SIZE) % 2 == 0)
+    if ((badvaddr/PAGE_SIZE) % 2 == 0)
         cp0_entry_lo0_write(lo.value);
     else
         cp0_entry_lo1_write(lo.value);
 ,9 → 241,11
     tlb_invalid_fail(istate);
 }
-/** Process TLB Modified Exception.
+/** Process TLB Modified Exception
  *
- * @param istate    Interrupted register context.
+ * Process TLB Modified Exception.
+ *
+ * @param istate Interrupted register context.
  */
 void tlb_modified(istate_t *istate)
 {
 ,7 → 262,7
      * Locate the faulting entry in TLB.
      */
     hi.value = cp0_entry_hi_read();
-    tlb_prepare_entry_hi(&hi, hi.asid, badvaddr);
+    prepare_entry_hi(&hi, hi.asid, badvaddr);
     cp0_entry_hi_write(hi.value);
     tlbp();
     index.value = cp0_index_read();
 ,6 → 296,12
     }
     /*
+     * Fail if the page is not writable.
+     */
+    if (!pte->w)
+        goto fail;
+    /*
      * Read the faulting TLB entry.
      */
     tlbr();
 ,13 → 312,12
     pte->a = 1;
     pte->d = 1;
-    tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->w, pte->cacheable,
-        pte->pfn);
+    prepare_entry_lo(&lo, pte->g, pte->p, pte->w, pte->cacheable, pte->pfn);
     /*
      * The entry is to be updated in TLB.
      */
-    if ((badvaddr / PAGE_SIZE) % 2 == 0)
+    if ((badvaddr/PAGE_SIZE) % 2 == 0)
         cp0_entry_lo0_write(lo.value);
     else
         cp0_entry_lo1_write(lo.value);
 ,10 → 344,8
     if (s)
         sym2 = s;
-    fault_if_from_uspace(istate, "TLB Refill Exception on %p",
-        cp0_badvaddr_read());
-    panic("%x: TLB Refill Exception at %x(%s<-%s)\n", cp0_badvaddr_read(),
-        istate->epc, symbol, sym2);
+    fault_if_from_uspace(istate, "TLB Refill Exception on %p", cp0_badvaddr_read());
+    panic("%x: TLB Refill Exception at %x(%s<-%s)\n", cp0_badvaddr_read(), istate->epc, symbol, sym2);
 }
 ,10 → 356,8
     char *s = get_symtab_entry(istate->epc);
     if (s)
         symbol = s;
-    fault_if_from_uspace(istate, "TLB Invalid Exception on %p",
-        cp0_badvaddr_read());
-    panic("%x: TLB Invalid Exception at %x(%s)\n", cp0_badvaddr_read(),
-        istate->epc, symbol);
+    fault_if_from_uspace(istate, "TLB Invalid Exception on %p", cp0_badvaddr_read());
+    panic("%x: TLB Invalid Exception at %x(%s)\n", cp0_badvaddr_read(), istate->epc, symbol);
 }
 void tlb_modified_fail(istate_t *istate)
 ,27 → 367,23
     char *s = get_symtab_entry(istate->epc);
     if (s)
         symbol = s;
-    fault_if_from_uspace(istate, "TLB Modified Exception on %p",
-        cp0_badvaddr_read());
-    panic("%x: TLB Modified Exception at %x(%s)\n", cp0_badvaddr_read(),
-        istate->epc, symbol);
+    fault_if_from_uspace(istate, "TLB Modified Exception on %p", cp0_badvaddr_read());
+    panic("%x: TLB Modified Exception at %x(%s)\n", cp0_badvaddr_read(), istate->epc, symbol);
 }
-/** Try to find PTE for faulting address.
+/** Try to find PTE for faulting address
  *
+ * Try to find PTE for faulting address.
  * The AS->lock must be held on entry to this function.
  *
- * @param badvaddr  Faulting virtual address.
- * @param access    Access mode that caused the fault.
- * @param istate    Pointer to interrupted state.
- * @param pfrc      Pointer to variable where as_page_fault() return code
- *          will be stored.
+ * @param badvaddr Faulting virtual address.
+ * @param access Access mode that caused the fault.
+ * @param istate Pointer to interrupted state.
+ * @param pfrc Pointer to variable where as_page_fault() return code will be stored.
  *
- * @return      PTE on success, NULL otherwise.
+ * @return PTE on success, NULL otherwise.
  */
-pte_t *
-find_mapping_and_check(uintptr_t badvaddr, int access, istate_t *istate,
-    int *pfrc)
+pte_t *find_mapping_and_check(uintptr_t badvaddr, int access, istate_t *istate, int *pfrc)
 {
     entry_hi_t hi;
     pte_t *pte;
 ,7 → 402,7
      * Check if the mapping exists in page tables.
      */
     pte = page_mapping_find(AS, badvaddr);
-    if (pte && pte->p && (pte->w || access != PF_ACCESS_WRITE)) {
+    if (pte && pte->p) {
         /*
          * Mapping found in page tables.
          * Immediately succeed.
 ,7 → 425,6
             page_table_lock(AS, true);
             pte = page_mapping_find(AS, badvaddr);
             ASSERT(pte && pte->p);
-            ASSERT(pte->w || access != PF_ACCESS_WRITE);
             return pte;
             break;
         case AS_PF_DEFER:
 ,9 → 445,7
     }
 }
-void
-tlb_prepare_entry_lo(entry_lo_t *lo, bool g, bool v, bool d, bool cacheable,
-    uintptr_t pfn)
+void prepare_entry_lo(entry_lo_t *lo, bool g, bool v, bool d, bool cacheable, uintptr_t pfn)
 {
     lo->value = 0;
     lo->g = g;
 ,7 → 455,7
     lo->pfn = pfn;
 }
-void tlb_prepare_entry_hi(entry_hi_t *hi, asid_t asid, uintptr_t addr)
+void prepare_entry_hi(entry_hi_t *hi, asid_t asid, uintptr_t addr)
 {
     hi->value = ALIGN_DOWN(addr, PAGE_SIZE * 2);
     hi->asid = asid;
 ,10 → 484,10
         lo1.value = cp0_entry_lo1_read();
         printf("%-2u %-4u %#6x %#4x %1u %1u %1u %1u %#6x\n",
-            i, hi.asid, hi.vpn2, mask.mask,
-            lo0.g, lo0.v, lo0.d, lo0.c, lo0.pfn);
+            i, hi.asid, hi.vpn2, mask.mask,
+            lo0.g, lo0.v, lo0.d, lo0.c, lo0.pfn);
         printf("                    %1u %1u %1u %1u %#6x\n",
-            lo1.g, lo1.v, lo1.d, lo1.c, lo1.pfn);
+            lo1.g, lo1.v, lo1.d, lo1.c, lo1.pfn);
     }
     cp0_entry_hi_write(hi_save.value);
 ,12 → 564,11
     cp0_entry_hi_write(hi_save.value);
 }
-/** Invalidate TLB entries for specified page range belonging to specified
- * address space.
+/** Invalidate TLB entries for specified page range belonging to specified address space.
  *
- * @param asid      Address space identifier.
- * @param page      First page whose TLB entry is to be invalidated.
- * @param cnt       Number of entries to invalidate.
+ * @param asid Address space identifier.
+ * @param page First page whose TLB entry is to be invalidated.
+ * @param cnt Number of entries to invalidate.
  */
 void tlb_invalidate_pages(asid_t asid, uintptr_t page, count_t cnt)
 {
 ,7 → 585,7
     for (i = 0; i < cnt + 1; i += 2) {
         hi.value = 0;
-        tlb_prepare_entry_hi(&hi, asid, page + i * PAGE_SIZE);
+        prepare_entry_hi(&hi, asid, page + i * PAGE_SIZE);
         cp0_entry_hi_write(hi.value);
         tlbp();
 ,10 → 592,7
         index.value = cp0_index_read();
         if (!index.p) {
-            /*
-             * Entry was found, index register contains valid
-             * index.
-             */
+            /* Entry was found, index register contains valid index. */
             tlbr();
             lo0.value = cp0_entry_lo0_read();

 /branches/dynload/kernel/arch/mips32/src/mm/frame.c
 ,238 → 32,27
 /** @file
  */
-#include <macros.h>
 #include <arch/mm/frame.h>
-#include <arch/mm/tlb.h>
-#include <interrupt.h>
 #include <mm/frame.h>
-#include <mm/asid.h>
 #include <config.h>
-#include <arch/drivers/msim.h>
-#include <arch/drivers/serial.h>
-#include <print.h>
+#include <arch/drivers/arc.h>
-#define ZERO_PAGE_MASK      TLB_PAGE_MASK_256K
-#define ZERO_FRAMES         2048
-#define ZERO_PAGE_WIDTH     18  /* 256K */
-#define ZERO_PAGE_SIZE      (1 << ZERO_PAGE_WIDTH)
-#define ZERO_PAGE_ASID      ASID_INVALID
-#define ZERO_PAGE_TLBI      0
-#define ZERO_PAGE_ADDR      0
-#define ZERO_PAGE_OFFSET    (ZERO_PAGE_SIZE / sizeof(uint32_t) - 1)
-#define ZERO_PAGE_VALUE     (((volatile uint32_t *) ZERO_PAGE_ADDR)[ZERO_PAGE_OFFSET])
-#define ZERO_PAGE_VALUE_KSEG1(frame) (((volatile uint32_t *) (0xa0000000 + (frame << ZERO_PAGE_WIDTH)))[ZERO_PAGE_OFFSET])
-#define MAX_REGIONS         32
-typedef struct {
-    pfn_t start;
-    pfn_t count;
-} phys_region_t;
-static count_t phys_regions_count = 0;
-static phys_region_t phys_regions[MAX_REGIONS];
-/** Check whether frame is available
- *
- * Returns true if given frame is generally available for use.
- * Returns false if given frame is used for physical memory
- * mapped devices and cannot be used.
- *
- */
-static bool frame_available(pfn_t frame)
-{
-#if MACHINE == msim
-    /* MSIM device (dprinter) */
-    if (frame == (KA2PA(MSIM_VIDEORAM) >> ZERO_PAGE_WIDTH))
-        return false;
-    /* MSIM device (dkeyboard) */
-    if (frame == (KA2PA(MSIM_KBD_ADDRESS) >> ZERO_PAGE_WIDTH))
-        return false;
-#endif
-#if MACHINE == simics
-    /* Simics device (serial line) */
-    if (frame == (KA2PA(SERIAL_ADDRESS) >> ZERO_PAGE_WIDTH))
-        return false;
-#endif
-#if (MACHINE == lgxemul) || (MACHINE == bgxemul)
-    /* gxemul devices */
-    if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
-x10000000, MB2SIZE(256)))
-        return false;
-#endif
-    return true;
-}
-/** Check whether frame is safe to write
- *
- * Returns true if given frame is safe for read/write test.
- * Returns false if given frame should not be touched.
- *
- */
-static bool frame_safe(pfn_t frame)
-{
-    /* Kernel structures */
-    if ((frame << ZERO_PAGE_WIDTH) < KA2PA(config.base))
-        return false;
-    /* Kernel */
-    if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
-        KA2PA(config.base), config.kernel_size))
-        return false;
-    /* Kernel stack */
-    if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
-        KA2PA(config.stack_base), config.stack_size))
-        return false;
-    /* Init tasks */
-    bool safe = true;
-    count_t i;
-    for (i = 0; i < init.cnt; i++)
-        if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
-            KA2PA(init.tasks[i].addr), init.tasks[i].size)) {
-            safe = false;
-            break;
-        }
-    return safe;
-}
-static void frame_add_region(pfn_t start_frame, pfn_t end_frame)
-{
-    if (end_frame > start_frame) {
-        /* Convert 1M frames to 16K frames */
-        pfn_t first = ADDR2PFN(start_frame << ZERO_PAGE_WIDTH);
-        pfn_t count = ADDR2PFN((end_frame - start_frame) << ZERO_PAGE_WIDTH);
-        /* Interrupt vector frame is blacklisted */
-        pfn_t conf_frame;
-        if (first == 0)
-            conf_frame = 1;
-        else
-            conf_frame = first;
-        zone_create(first, count, conf_frame, 0);
-        if (phys_regions_count < MAX_REGIONS) {
-            phys_regions[phys_regions_count].start = first;
-            phys_regions[phys_regions_count].count = count;
-            phys_regions_count++;
-        }
-    }
-}
 /** Create memory zones
  *
- * Walk through available 256 KB chunks of physical
- * memory and create zones.
- *
- * Note: It is assumed that the TLB is not yet being
- * used in any way, thus there is no interference.
- *
+ * If ARC is known, read information from ARC, otherwise
+ * assume some defaults.
+ * - blacklist first FRAME because there is an exception vector
  */
 void frame_arch_init(void)
 {
-    ipl_t ipl = interrupts_disable();
-    /* Clear and initialize TLB */
-    cp0_pagemask_write(ZERO_PAGE_MASK);
-    cp0_entry_lo0_write(0);
-    cp0_entry_lo1_write(0);
-    cp0_entry_hi_write(0);
-    count_t i;
-    for (i = 0; i < TLB_ENTRY_COUNT; i++) {
-        cp0_index_write(i);
-        tlbwi();
+    if (!arc_frame_init()) {
+        zone_create(0, ADDR2PFN(CONFIG_MEMORY_SIZE), 1, 0);
+        /*
+         * Blacklist interrupt vector
+         */
+        frame_mark_unavailable(0, 1);
     }
-    pfn_t start_frame = 0;
-    pfn_t frame;
-    bool avail = true;
-    /* Walk through all 1 MB frames */
-    for (frame = 0; frame < ZERO_FRAMES; frame++) {
-        if (!frame_available(frame))
-            avail = false;
-        else {
-            if (frame_safe(frame)) {
-                entry_lo_t lo0;
-                entry_lo_t lo1;
-                entry_hi_t hi;
-                tlb_prepare_entry_lo(&lo0, false, true, true, false, frame << (ZERO_PAGE_WIDTH - 12));
-                tlb_prepare_entry_lo(&lo1, false, false, false, false, 0);
-                tlb_prepare_entry_hi(&hi, ZERO_PAGE_ASID, ZERO_PAGE_ADDR);
-                cp0_pagemask_write(ZERO_PAGE_MASK);
-                cp0_entry_lo0_write(lo0.value);
-                cp0_entry_lo1_write(lo1.value);
-                cp0_entry_hi_write(hi.value);
-                cp0_index_write(ZERO_PAGE_TLBI);
-                tlbwi();
-                ZERO_PAGE_VALUE = 0;
-                if (ZERO_PAGE_VALUE != 0)
-                    avail = false;
-                else {
-                    ZERO_PAGE_VALUE = 0xdeadbeef;
-                    if (ZERO_PAGE_VALUE != 0xdeadbeef)
-                        avail = false;
-#if (MACHINE == lgxemul) || (MACHINE == bgxemul)
-                    else {
-                        ZERO_PAGE_VALUE_KSEG1(frame) = 0xaabbccdd;
-                        if (ZERO_PAGE_VALUE_KSEG1(frame) != 0xaabbccdd)
-                            avail = false;
-                    }
-#endif
-                }
-            }
-        }
-        if (!avail) {
-            frame_add_region(start_frame, frame);
-            start_frame = frame + 1;
-            avail = true;
-        }
-    }
-    frame_add_region(start_frame, frame);
-    /* Blacklist interrupt vector frame */
-    frame_mark_unavailable(0, 1);
-    /* Cleanup */
-    cp0_pagemask_write(ZERO_PAGE_MASK);
-    cp0_entry_lo0_write(0);
-    cp0_entry_lo1_write(0);
-    cp0_entry_hi_write(0);
-    cp0_index_write(ZERO_PAGE_TLBI);
-    tlbwi();
-    interrupts_restore(ipl);
 }
-void physmem_print(void)
-{
-    printf("Base       Size\n");
-    printf("---------- ----------\n");
-    count_t i;
-    for (i = 0; i < phys_regions_count; i++) {
-        printf("%#010x %10u\n",
-            PFN2ADDR(phys_regions[i].start), PFN2ADDR(phys_regions[i].count));
-    }
-}
 /** @}
  */

 /branches/dynload/kernel/arch/mips32/src/mm/as.c
 ,7 → 44,7
 /** Architecture dependent address space init. */
 void as_arch_init(void)
 {
-    as_operations = &as_pt_operations;
+        as_operations = &as_pt_operations;
     asid_fifo_init();
 }

 /branches/dynload/kernel/arch/mips32/src/console.c
 ,15 → 34,18
 #include <console/console.h>
 #include <arch/console.h>
+#include <arch/drivers/arc.h>
 #include <arch/drivers/serial.h>
 #include <arch/drivers/msim.h>
 void console_init(devno_t devno)
 {
-    if (serial_init())
-        serial_console(devno);
-    else
-        msim_console(devno);
+    if (!arc_console()) {
+        if (serial_init())
+            serial_console(devno);
+        else
+            msim_console(devno);
+    }
 }
 /** Acquire console back for kernel

/branches/dynload/kernel/arch/mips32/src/interrupt.c
38,6 → 38,7
#include <arch.h>
#include <arch/cp0.h>
#include <time/clock.h>
#include <arch/drivers/arc.h>
#include <ipc/sysipc.h>
#include <ddi/device.h>

 /branches/dynload/kernel/arch/mips32/src/asm.S
 ,7 → 71,6
     and $v0,$v0,$v1
     beq $a1,$v0,3f
     move    $t0,$a0
-    move    $t2,$a0         # save dst
 :
     beq $a2,$zero,2f
 ,7 → 86,7
 :
     jr  $ra
-    move    $v0,$t2
+    move    $v0,$a1
 :
     addiu   $v0,$a0,3
 ,7 → 126,7
     sb  $a0,0($v1)
     jr  $ra
-    move    $v0,$t2
+    move    $v0,$a1
 memcpy_from_uspace_failover_address:
 memcpy_to_uspace_failover_address:

 /branches/dynload/kernel/arch/mips32/Makefile.inc
 ,19 → 29,17
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 BFD_ARCH = mips
 TARGET = mipsel-linux-gnu
-TOOLCHAIN_DIR = $(CROSS_PREFIX)/mipsel
+TOOLCHAIN_DIR = /usr/local/mipsel
 KERNEL_LOAD_ADDRESS = 0x80100000
+INIT_ADDRESS = 0x81000000
+INIT_SIZE = 262144
 GCC_CFLAGS += -mno-abicalls -G 0 -fno-zero-initialized-in-bss
-DEFS += -D__32_BITS__ -DMACHINE=$(MACHINE) -DKERNEL_LOAD_ADDRESS=${KERNEL_LOAD_ADDRESS}
+DEFS += -D__32_BITS__ -DMACHINE=$(MACHINE) -DKERNEL_LOAD_ADDRESS=${KERNEL_LOAD_ADDRESS} -DINIT_ADDRESS=${INIT_ADDRESS} -DINIT_SIZE=${INIT_SIZE}
 ## Compile with hierarchical page tables support.
 #
 ,6 → 56,20
 ## Accepted MACHINEs
 #
+ifeq ($(MACHINE),indy)
+    # GCC 4.0.1 compiled for mipsEL has problems compiling in
+    # BigEndian mode with the swl/swr/lwl/lwr instructions.
+    # We have to compile it with mips-sgi-irix5 to get it right.
+    BFD_NAME = elf32-bigmips
+    BFD = ecoff-bigmips --impure
+    TARGET = mips-sgi-irix5
+    TOOLCHAIN_DIR = /usr/local/mips/bin
+    KERNEL_LOAD_ADDRESS = 0x88002000
+    GCC_CFLAGS += -EB -DBIG_ENDIAN -DARCH_HAS_FPU -march=r4600
+    INIT_ADDRESS = 0
+    INIT_SIZE = 0
+endif
 ifeq ($(MACHINE),lgxemul)
     BFD_NAME = elf32-tradlittlemips
     BFD = binary
 ,8 → 79,9
     BFD_NAME = elf32-bigmips
     BFD = ecoff-bigmips
     TARGET = mips-sgi-irix5
-    TOOLCHAIN_DIR = $(CROSS_PREFIX)/mips/bin
+    TOOLCHAIN_DIR = /usr/local/mips/bin
     GCC_CFLAGS += -EB -DBIG_ENDIAN -DARCH_HAS_FPU -mips3
+    INIT_ADDRESS = 0x81800000
 endif
 ifeq ($(MACHINE),simics)
     # SIMICS 4kc emulation is broken, although for instructions
 ,6 → 123,7
     arch/$(ARCH)/src/mm/as.c \
     arch/$(ARCH)/src/fpu_context.c \
     arch/$(ARCH)/src/ddi/ddi.c \
+    arch/$(ARCH)/src/drivers/arc.c \
     arch/$(ARCH)/src/drivers/msim.c \
     arch/$(ARCH)/src/drivers/serial.c \
     arch/$(ARCH)/src/smp/order.c

 /branches/dynload/kernel/arch/sparc64/src/asm.S
 ,7 → 41,6
  */
 .global memcpy
 memcpy:
-    mov %o0, %o3        ! save dst
     add %o1, 7, %g1
     and %g1, -8, %g1
     cmp %o1, %g1
 ,7 → 59,7
     mov %g2, %g3
 :
     jmp %o7 + 8         ! exit point
-    mov %o3, %o0
+    mov %o1, %o0
 :
     and %g1, -8, %g1
     cmp %o0, %g1
 ,7 → 93,7
     mov %g2, %g3
     jmp %o7 + 8         ! exit point
-    mov %o3, %o0
+    mov %o1, %o0
 /*
  * Almost the same as memcpy() except the loads are from userspace.
 ,7 → 100,6
  */
 .global memcpy_from_uspace
 memcpy_from_uspace:
-    mov %o0, %o3        ! save dst
     add %o1, 7, %g1
     and %g1, -8, %g1
     cmp %o1, %g1
 ,7 → 118,7
     mov %g2, %g3
 :
     jmp %o7 + 8         ! exit point
-    mov %o3, %o0
+    mov %o1, %o0
 :
     and %g1, -8, %g1
     cmp %o0, %g1
 ,7 → 152,7
     mov %g2, %g3
     jmp %o7 + 8         ! exit point
-    mov %o3, %o0
+    mov %o1, %o0
 /*
  * Almost the same as memcpy() except the stores are to userspace.
 ,7 → 159,6
  */
 .global memcpy_to_uspace
 memcpy_to_uspace:
-    mov %o0, %o3        ! save dst
     add %o1, 7, %g1
     and %g1, -8, %g1
     cmp %o1, %g1
 ,7 → 177,7
     mov %g2, %g3
 :
     jmp %o7 + 8         ! exit point
-    mov %o3, %o0
+    mov %o1, %o0
 :
     and %g1, -8, %g1
     cmp %o0, %g1
 ,7 → 211,7
     mov %g2, %g3
     jmp %o7 + 8         ! exit point
-    mov %o3, %o0
+    mov %o1, %o0
 .global memcpy_from_uspace_failover_address
 .global memcpy_to_uspace_failover_address

 /branches/dynload/kernel/arch/sparc64/include/mm/page.h
 ,6 → 53,11
 #define MMU_PAGES_PER_PAGE  (1 << (PAGE_WIDTH - MMU_PAGE_WIDTH))
+/*
+ * With 16K pages, there is only one page color.
+ */
+#define PAGE_COLOR_BITS 0    /**< 14 - 14; 2^14 == 16K == alias boundary. */
 #ifdef KERNEL
 #ifndef __ASM__

 /branches/dynload/kernel/arch/sparc64/include/atomic.h
 ,7 → 37,6
 #include <arch/barrier.h>
 #include <arch/types.h>
-#include <preemption.h>
 /** Atomic add operation.
  *
 ,8 → 56,7
         a = *((uint64_t *) x);
         b = a + i;
-        asm volatile ("casx %0, %2, %1\n" : "+m" (*((uint64_t *)x)),
-            "+r" (b) : "r" (a));
+        asm volatile ("casx %0, %2, %1\n" : "+m" (*((uint64_t *)x)), "+r" (b) : "r" (a));
     } while (a != b);
     return a;
 ,8 → 97,7
     uint64_t v = 1;
     volatile uintptr_t x = (uint64_t) &val->count;
-    asm volatile ("casx %0, %2, %1\n" : "+m" (*((uint64_t *) x)),
-        "+r" (v) : "r" (0));
+    asm volatile ("casx %0, %2, %1\n" : "+m" (*((uint64_t *) x)), "+r" (v) : "r" (0));
     return v;
 }
 ,8 → 109,6
     volatile uintptr_t x = (uint64_t) &val->count;
-    preemption_disable();
     asm volatile (
     "0:\n"
         "casx %0, %3, %1\n"

 /branches/dynload/kernel/arch/sparc64/Makefile.inc
 ,15 → 29,11
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 BFD_NAME = elf64-sparc
 BFD_ARCH = sparc
 BFD = binary
 TARGET = sparc64-linux-gnu
-TOOLCHAIN_DIR = $(CROSS_PREFIX)/sparc64
+TOOLCHAIN_DIR = /usr/local/sparc64
 GCC_CFLAGS += -m64 -mcpu=ultrasparc
 SUNCC_CFLAGS += -m64 -xarch=sparc -xregs=appl,no%float

 /branches/dynload/kernel/arch/ia64/src/asm.S
 ,7 → 51,7
     adds r14 = 7, in1
     mov r2 = ar.lc
-    mov r8 = in0
+    mov r8 = in1 ;;
     and r14 = -8, r14 ;;
     cmp.ne p6, p7 = r14, in1
 (p7)    br.cond.dpnt 3f ;;
 ,7 → 63,7
 (p6)    mov r17 = r0 ;;
 (p6)    mov ar.lc = r14
 :
-    add r14 = r16, in1
+    add r14 = r16, r8
     add r15 = r16, in0
     adds r17 = 1, r17 ;;
     ld1 r14 = [r14]
 ,6 → 72,7
     br.cloop.sptk.few 1b ;;
 :
     mov ar.lc = r2
     mov ar.pfs = loc0
     br.ret.sptk.many rp
 :
 ,7 → 90,7
 :
     shladd r14 = r16, 3, r0
     adds r16 = 1, r17 ;;
-    add r15 = in1, r14
+    add r15 = r8, r14
     add r14 = in0, r14
     mov r17 = r16 ;;
     ld8 r15 = [r15] ;;
 ,7 → 104,7
     cmp.eq p6, p7 = 0, r15
     add in0 = r14, in0
     adds r15 = -1, r15
-    add r17 = r14, in1
+    add r17 = r14, r8
 (p6)    br.cond.dpnt 2b ;;
     mov ar.lc = r15
 :
 ,6 → 116,7
     st1 [r15] = r14
     br.cloop.sptk.few 6b ;;
     mov ar.lc = r2
     mov ar.pfs = loc0
     br.ret.sptk.many rp

 /branches/dynload/kernel/arch/ia64/include/mm/page.h
 ,6 → 41,8
 #define PAGE_SIZE   FRAME_SIZE
 #define PAGE_WIDTH  FRAME_WIDTH
+#define PAGE_COLOR_BITS 0            /* dummy */
 #ifdef KERNEL
 /** Bit width of the TLB-locked portion of kernel address space. */

 /branches/dynload/kernel/arch/ia64/Makefile.inc
 ,15 → 29,14
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 BFD_NAME = elf64-little
 BFD_ARCH = ia64-elf64
 TARGET = ia64-pc-linux-gnu
-TOOLCHAIN_DIR = $(CROSS_PREFIX)/ia64
+TOOLCHAIN_DIR = /usr/local/ia64
+INIT0_ADDRESS = 0xe000000004404000
+INIT0_SIZE = 0x100000
 CMN1 = -mconstant-gp -fno-unwind-tables -mfixed-range=f32-f127
 GCC_CFLAGS += $(CMN1)
 ICC_CFLAGS += $(CMN1)
 ,8 → 44,9
 LFLAGS += -EL
 AFLAGS += -mconstant-gp
-DEFS += -D__64_BITS__ -D$(MACHINE)
+DEFS += -D__64_BITS__ -DINIT0_ADDRESS=$(INIT0_ADDRESS) -DINIT0_SIZE=$(INIT0_SIZE) -D$(MACHINE)
 ## Compile with page hash table support.
 #
 ,5 → 96,6
     CONFIG_I8042 = y
     DEFS += -DI460GX -DCONFIG_I8042
     BFD = binary
 endif

 /branches/dynload/kernel/arch/arm32/src/asm.S
 ,8 → 45,7
     add     r3, r1, #3
     bic     r3, r3, #3
     cmp     r1, r3
-    stmdb   sp!, {r4, r5, lr}
-    mov r5, r0          /* save dst */
+    stmdb   sp!, {r4, lr}
     beq     4f
 :
     cmp     r2, #0
 ,8 → 58,8
     cmp     ip, r2
     bne     2b
 :
-    mov     r0, r5
-    ldmia   sp!, {r4, r5, pc}
+    mov     r0, r1
+    ldmia   sp!, {r4, pc}
 :
     add     r3, r0, #3
     bic     r3, r3, #3
 ,5 → 94,5
 memcpy_from_uspace_failover_address:
 memcpy_to_uspace_failover_address:
-    mov r0, #0
-    ldmia   sp!, {r4, r5, pc}
+    mov     r0, #0
+    ldmia   sp!, {r4, pc}

 /branches/dynload/kernel/arch/arm32/include/mm/page.h
 ,6 → 43,8
 #define PAGE_WIDTH  FRAME_WIDTH
 #define PAGE_SIZE   FRAME_SIZE
+#define PAGE_COLOR_BITS 0            /* dummy */
 #ifndef __ASM__
 #   define KA2PA(x) (((uintptr_t) (x)) - 0x80000000)
 #   define PA2KA(x) (((uintptr_t) (x)) + 0x80000000)

 /branches/dynload/kernel/arch/arm32/Makefile.inc
 ,15 → 29,11
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 BFD_NAME = elf32-littlearm
 BFD_ARCH = arm
 BFD = binary
 TARGET = arm-linux-gnu
-TOOLCHAIN_DIR = $(CROSS_PREFIX)/arm
+TOOLCHAIN_DIR = /usr/local/arm
 KERNEL_LOAD_ADDRESS = 0x80200000

 /branches/dynload/kernel/arch/ia32xen/src/asm.S
 ,7 → 67,7
  * @param MEMCPY_SRC(%esp)  Source address.
  * @param MEMCPY_SIZE(%esp) Size.
  *
- * @return MEMCPY_DST(%esp) on success and 0 on failure.
+ * @return MEMCPY_SRC(%esp) on success and 0 on failure.
  */
 memcpy:
 memcpy_from_uspace:
 ,7 → 92,7
 :
     movl %edx, %edi
     movl %eax, %esi
-    movl MEMCPY_DST(%esp), %eax     /* MEMCPY_DST(%esp), success */
+    movl MEMCPY_SRC(%esp), %eax     /* MEMCPY_SRC(%esp), success */
     ret
 /*

 /branches/dynload/kernel/arch/ia32xen/include/mm/page.h
 ,6 → 40,8
 #define PAGE_WIDTH  FRAME_WIDTH
 #define PAGE_SIZE   FRAME_SIZE
+#define PAGE_COLOR_BITS 0            /* dummy */
 #ifdef KERNEL
 #ifndef __ASM__

 /branches/dynload/kernel/arch/ia32xen/Makefile.inc
 ,15 → 29,11
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 BFD_NAME = elf32-i386
 BFD_ARCH = i386
 BFD = elf32-i386
 TARGET = i686-pc-linux-gnu
-TOOLCHAIN_DIR = $(CROSS_PREFIX)/i686
+TOOLCHAIN_DIR = /usr/local/i686
 DEFS += -DMACHINE=$(MACHINE) -D__32_BITS__

 /branches/dynload/kernel/arch/ppc64/include/mm/page.h
 ,6 → 40,8
 #define PAGE_WIDTH  FRAME_WIDTH
 #define PAGE_SIZE   FRAME_SIZE
+#define PAGE_COLOR_BITS 0            /* dummy */
 #ifdef KERNEL
 #ifndef __ASM__

 /branches/dynload/kernel/arch/ppc64/Makefile.inc
 ,15 → 29,11
 ## Toolchain configuration
 #
-ifndef CROSS_PREFIX
-    CROSS_PREFIX = /usr/local
-endif
 BFD_NAME = elf64-powerpc
 BFD_ARCH = powerpc:common64
 BFD = binary
 TARGET = ppc64-linux-gnu
-TOOLCHAIN_DIR = $(CROSS_PREFIX)/ppc64
+TOOLCHAIN_DIR = /usr/local/ppc64
 GCC_CFLAGS += -mcpu=powerpc64 -msoft-float -m64
 AFLAGS += -a64

 /branches/dynload/kernel/Makefile
 ,6 → 317,16
         test/sysinfo/sysinfo1.c
 endif
+## Experimental features
+#
+ifeq ($(CONFIG_EXPERIMENTAL),y)
+    GENERIC_SOURCES += generic/src/lib/objc_ext.c \
+        generic/src/lib/objc.c
+    EXTRA_OBJECTS = $(LIBDIR)/libobjc.a
+    EXTRA_FLAGS += -x objective-c
+endif
 GENERIC_OBJECTS := $(addsuffix .o,$(basename $(GENERIC_SOURCES)))
 ARCH_OBJECTS := $(addsuffix .o,$(basename $(ARCH_SOURCES)))
 GENARCH_OBJECTS := $(addsuffix .o,$(basename $(GENARCH_SOURCES)))

 /branches/dynload/kernel/genarch/src/mm/as_pt.c
 ,6 → 52,31
 static void pt_lock(as_t *as, bool lock);
 static void pt_unlock(as_t *as, bool unlock);
+#ifdef __OBJC__
+@implementation as_t
++ (pte_t *) page_table_create: (int) flags
+{
+    return ptl0_create(flags);
+}
++ (void) page_table_destroy: (pte_t *) page_table
+{
+    ptl0_destroy(page_table);
+}
+- (void) page_table_lock: (bool) _lock
+{
+    pt_lock(self, _lock);
+}
+- (void) page_table_unlock: (bool) unlock
+{
+    pt_unlock(self, unlock);
+}
+@end
+#else
 as_operations_t as_pt_operations = {
     .page_table_create = ptl0_create,
     .page_table_destroy = ptl0_destroy,
 ,6 → 83,7
     .page_table_lock = pt_lock,
     .page_table_unlock = pt_unlock
 };
+#endif
 /** Create PTL0.
  *

 /branches/dynload/kernel/genarch/include/mm/page_pt.h
 ,7 → 116,9
 #define PTE_WRITABLE(p)     PTE_WRITABLE_ARCH((p))
 #define PTE_EXECUTABLE(p)   PTE_EXECUTABLE_ARCH((p))
+#ifndef __OBJC__
 extern as_operations_t as_pt_operations;
+#endif
 extern page_mapping_operations_t pt_mapping_operations;
 extern void page_mapping_insert_pt(as_t *as, uintptr_t page, uintptr_t frame,

 /branches/dynload/kernel/kernel.config
 ,6 → 81,7
 @ "simics" Virtutech Simics simulator
 @ "lgxemul" GXEmul Little Endian
 @ "bgxemul" GXEmul Big Endian
+@ "indy" SGI Indy
 ! [ARCH=mips32] MACHINE (choice)
 # Framebuffer support
 ,3 → 168,9
 # Compile kernel tests
 ! CONFIG_TEST (y/n)
+## Experimental features
+# Enable experimental features
+! CONFIG_EXPERIMENTAL (n/y)

 /branches/dynload/kernel/doc/AUTHORS
 ,12 → 1,12
-Jakub Jermar
-Martin Decky
-Ondrej Palkovsky
-Jiri Svoboda
-Jakub Vana
-Josef Cejka
-Michal Kebrt
-Sergey Bondari
-Pavel Jancik
-Petr Stepan
-Michal Konopa
+Jakub Jermar <jermar@helenos.eu>
+Martin Decky <decky@helenos.eu>
+Ondrej Palkovsky <palkovsky@helenos.eu>
+Jakub Vana <vana@helenos.eu>
+Josef Cejka <cejka@helenos.eu>
+Michal Kebrt <michalek.k@seznam.cz>
+Sergey Bondari <bondari@helenos.eu>
+Pavel Jancik <alfik.009@seznam.cz>
+Petr Stepan <stepan.petr@volny.cz>
+Michal Konopa <mkonopa@seznam.cz>
 Vojtech Mencl

/branches/dynload/kernel/doc/arch/mips32
3,9 → 3,11

mips32 is the second port of SPARTAN kernel originally written by Jakub Jermar.
It was first developed to run on MIPS R4000 32-bit simulator.
Now it can run on real hardware as well.
It can be compiled and run either as little- or big-endian.

HARDWARE REQUIREMENTS
o SGI Indy R4600
o emulated MIPS 4K CPU

CPU

 /branches/dynload/kernel/doc/BUGS_FOUND
 ,0 → 1,23
+During development of this operating system, there were found bugs in:
+Simics
+======
+- ia32 BIOS rewrites memory during AP start in SMP environment (#3351)
+- ia32 Simics does not report #GP when EFER.NXE is 0 and finds NX page (#4214)
+- incorrect MIPS instructions MSUB, MSUBU
+Bochs
+=====
+- FXSAVE/FXRSTOR not working correctly with XMM registers (patch #1282033)
+Msim
+====
+- Incorrect interpretation of lwl/lwr/swl/swr instructions
+- Omitted excMod case in write_proc_mem()
+- Incorrect signed multiplication
+Gcc
+===
+- Incorrect generation of unaligned data access instructions
+  (lwl/lwr/swl/swr) when using mipsel- target and -EB(big endian)
+  compilation, -O2 (#23824)

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3403 → Rev 3402