WebSVN – HelenOS – Path Comparison – / – /branches/rcu/ Rev 2307 and /branches/rcu/ Rev 2306

Ignore whitespace Rev 2307 → Rev 2306

 /branches/rcu/kernel/generic/src/proc/scheduler.c
 ,7 → 61,6
 #include <cpu.h>
 #include <print.h>
 #include <debug.h>
-#include <synch/rcu.h>
 static void before_task_runs(void);
 static void before_thread_runs(void);
 ,7 → 115,6
 void after_thread_ran(void)
 {
     after_thread_ran_arch();
-    rcu_run_callbacks();
 }
 #ifdef CONFIG_FPU_LAZY
 ,7 → 207,7
     interrupts_disable();
-    for (i = 0; i < RQ_COUNT; i++) {
+    for (i = 0; i<RQ_COUNT; i++) {
         r = &CPU->rq[i];
         spinlock_lock(&r->lock);
         if (r->n == 0) {
 ,8 → 377,7
 void scheduler_separated_stack(void)
 {
     int priority;
-    DEADLOCK_PROBE_INIT(p_joinwq);
     ASSERT(CPU != NULL);
     if (THREAD) {
 ,8 → 406,6
                     spinlock_unlock(&THREAD->lock);
                     delay(10);
                     spinlock_lock(&THREAD->lock);
-                    DEADLOCK_PROBE(p_joinwq,
-                        DEADLOCK_THRESHOLD);
                     goto repeat;
                 }
                 _waitq_wakeup_unsafe(&THREAD->join_wq, false);
 ,8 → 447,8
             /*
              * Entering state is unexpected.
              */
-            panic("tid%llu: unexpected state %s\n", THREAD->tid,
-                thread_states[THREAD->state]);
+            panic("tid%d: unexpected state %s\n", THREAD->tid,
+                thread_states[THREAD->state]);
             break;
         }
 ,7 → 500,7
     THREAD->state = Running;
 #ifdef SCHEDULER_VERBOSE
-    printf("cpu%d: tid %llu (priority=%d, ticks=%llu, nrdy=%ld)\n",
+    printf("cpu%d: tid %d (priority=%d, ticks=%lld, nrdy=%ld)\n",
         CPU->id, THREAD->tid, THREAD->priority, THREAD->ticks,
         atomic_get(&CPU->nrdy));
 #endif
 ,7 → 568,7
      * Searching least priority queues on all CPU's first and most priority
      * queues on all CPU's last.
      */
-    for (j = RQ_COUNT - 1; j >= 0; j--) {
+    for (j= RQ_COUNT - 1; j >= 0; j--) {
         for (i = 0; i < config.cpu_active; i++) {
             link_t *l;
             runq_t *r;
 ,8 → 609,8
                  */
                 spinlock_lock(&t->lock);
                 if ((!(t->flags & (THREAD_FLAG_WIRED |
-                    THREAD_FLAG_STOLEN))) &&
-                    (!(t->fpu_context_engaged))) {
+                    THREAD_FLAG_STOLEN))) &&
+                    (!(t->fpu_context_engaged)) ) {
                     /*
                      * Remove t from r.
                      */
 ,7 → 636,7
                  */
                 spinlock_lock(&t->lock);
 #ifdef KCPULB_VERBOSE
-                printf("kcpulb%d: TID %llu -> cpu%d, nrdy=%ld, "
+                printf("kcpulb%d: TID %d -> cpu%d, nrdy=%ld, "
                     "avg=%nd\n", CPU->id, t->tid, CPU->id,
                     atomic_get(&CPU->nrdy),
                     atomic_get(&nrdy) / config.cpu_active);
 ,7 → 719,7
             for (cur = r->rq_head.next; cur != &r->rq_head;
                 cur = cur->next) {
                 t = list_get_instance(cur, thread_t, rq_link);
-                printf("%llu(%s) ", t->tid,
+                printf("%d(%s) ", t->tid,
                     thread_states[t->state]);
             }
             printf("\n");

 /branches/rcu/kernel/generic/src/proc/thread.c
 ,7 → 94,7
 btree_t threads_btree;
 SPINLOCK_INITIALIZE(tidlock);
-thread_id_t last_tid = 0;
+uint32_t last_tid = 0;
 static slab_cache_t *thread_slab;
 #ifdef ARCH_HAS_FPU
 ,7 → 238,6
     cpu = CPU;
     if (t->flags & THREAD_FLAG_WIRED) {
-        ASSERT(t->cpu != NULL);
         cpu = t->cpu;
     }
     t->state = Ready;
 ,7 → 496,7
     ipl_t ipl;
     /*
-     * Since the thread is expected not to be already detached,
+     * Since the thread is expected to not be already detached,
      * pointer to it must be still valid.
      */
     ipl = interrupts_disable();
 ,7 → 580,7
             char suffix;
             order(t->cycles, &cycles, &suffix);
-            printf("%-6llu %-10s %#10zx %-8s %#10zx %-3ld %#10zx "
+            printf("%-6zd %-10s %#10zx %-8s %#10zx %-3ld %#10zx "
                 "%#10zx %9llu%c ", t->tid, t->name, t,
                 thread_states[t->state], t->task, t->task->context,
                 t->thread_code, t->kstack, cycles, suffix);
 ,11 → 636,12
 /** Process syscall to create new thread.
  *
  */
-unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name, thread_id_t *uspace_thread_id)
+unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name)
 {
     thread_t *t;
     char namebuf[THREAD_NAME_BUFLEN];
     uspace_arg_t *kernel_uarg;
+    uint32_t tid;
     int rc;
     rc = copy_from_uspace(namebuf, uspace_name, THREAD_NAME_BUFLEN);
 ,14 → 658,12
     t = thread_create(uinit, kernel_uarg, TASK, THREAD_FLAG_USPACE, namebuf,
         false);
     if (t) {
+        tid = t->tid;
         thread_ready(t);
-        if (uspace_thread_id != NULL)
-            return (unative_t) copy_to_uspace(uspace_thread_id, &t->tid,
-                sizeof(t->tid));
-        else
-            return 0;
-    } else
+        return (unative_t) tid;
+    } else {
         free(kernel_uarg);
+    }
     return (unative_t) ENOMEM;
 }
 ,22 → 678,6
     return 0;
 }
-/** Syscall for getting TID.
- *
- * @param uspace_thread_id Userspace address of 8-byte buffer where to store
- * current thread ID.
- *
- * @return 0 on success or an error code from @ref errno.h.
+/** @}
  */
-unative_t sys_thread_get_id(thread_id_t *uspace_thread_id)
-{
-    /*
-     * No need to acquire lock on THREAD because tid
-     * remains constant for the lifespan of the thread.
-     */
-    return (unative_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
-        sizeof(THREAD->tid));
-}
-/** @}
- */

 /branches/rcu/kernel/generic/src/proc/task.c
 ,7 → 41,6
 #include <proc/uarg.h>
 #include <mm/as.h>
 #include <mm/slab.h>
-#include <atomic.h>
 #include <synch/spinlock.h>
 #include <synch/waitq.h>
 #include <arch.h>
 ,49 → 92,6
     btree_create(&tasks_btree);
 }
-/** Kill all tasks except the current task.
- *
- */
-void task_done(void)
-{
-    task_t *t;
-    do { /* Repeat until there are any tasks except TASK */
-        /* Messing with task structures, avoid deadlock */
-        ipl_t ipl = interrupts_disable();
-        spinlock_lock(&tasks_lock);
-        t = NULL;
-        link_t *cur;
-        for (cur = tasks_btree.leaf_head.next; cur != &tasks_btree.leaf_head; cur = cur->next) {
-            btree_node_t *node = list_get_instance(cur, btree_node_t, leaf_link);
-            unsigned int i;
-            for (i = 0; i < node->keys; i++) {
-                if ((task_t *) node->value[i] != TASK) {
-                    t = (task_t *) node->value[i];
-                    break;
-                }
-            }
-        }
-        if (t != NULL) {
-            task_id_t id = t->taskid;
-            spinlock_unlock(&tasks_lock);
-            interrupts_restore(ipl);
-#ifdef CONFIG_DEBUG
-            printf("Killing task %llu\n", id);
-#endif
-            task_kill(id);
-        } else {
-            spinlock_unlock(&tasks_lock);
-            interrupts_restore(ipl);
-        }
-    } while (t != NULL);
-}
 /** Create new task
  *
 ,8 → 140,11
     /*
      * Increment address space reference count.
+     * TODO: Reconsider the locking scheme.
      */
-    atomic_inc(&as->refcount);
+    mutex_lock(&as->lock);
+    as->refcount++;
+    mutex_unlock(&as->lock);
     spinlock_lock(&tasks_lock);
 ,8 → 166,15
     task_destroy_arch(t);
     btree_destroy(&t->futexes);
-    if (atomic_predec(&t->as->refcount) == 0)
+    mutex_lock_active(&t->as->lock);
+    if (--t->as->refcount == 0) {
+        mutex_unlock(&t->as->lock);
         as_destroy(t->as);
+        /*
+         * t->as is destroyed.
+         */
+    } else
+        mutex_unlock(&t->as->lock);
     free(t);
     TASK = NULL;
 ,7 → 382,7
     link_t *cur;
     ipl_t ipl;
-    /* Messing with task structures, avoid deadlock */
+    /* Messing with thread structures, avoid deadlock */
     ipl = interrupts_disable();
     spinlock_lock(&tasks_lock);
 ,7 → 408,7
             char suffix;
             order(task_get_accounting(t), &cycles, &suffix);
-            printf("%-6llu %-10s %-3ld %#10zx %#10zx %9llu%c %7zd "
+            printf("%-6lld %-10s %-3ld %#10zx %#10zx %9llu%c %7zd "
                 "%6zd", t->taskid, t->name, t->context, t, t->as,
                 cycles, suffix, t->refcount,
                 atomic_get(&t->active_calls));
 ,7 → 495,7
     ipc_cleanup();
     futex_cleanup();
-    klog_printf("Cleanup of task %llu completed.", TASK->taskid);
+    klog_printf("Cleanup of task %lld completed.", TASK->taskid);
 }
 /** Kernel thread used to kill the userspace task when its main thread exits.

 /branches/rcu/kernel/generic/src/main/main.c
 ,7 → 82,6
 #include <smp/smp.h>
 #include <ddi/ddi.h>
 #include <proc/tasklet.h>
-#include <synch/rcu.h>
 /** Global configuration structure. */
 config_t config;
 ,8 → 275,6
     tasklet_run_tasklet_thread(k);
-    rcu_init();
     /*
      * This call to scheduler() will return to kinit,
      * starting the thread of kernel threads.

 /branches/rcu/kernel/generic/src/main/kinit.c
 ,7 → 118,7
 #ifdef CONFIG_SMP
     if (config.cpu_count > 1) {
-        count_t i;
+        unsigned int i;
         /*
          * For each CPU, create its load balancing thread.

 /branches/rcu/kernel/generic/src/time/clock.c
 ,6 → 41,7
 #include <time/clock.h>
 #include <time/timeout.h>
+#include <arch/types.h>
 #include <config.h>
 #include <synch/spinlock.h>
 #include <synch/waitq.h>
 ,12 → 57,16
 #include <mm/frame.h>
 #include <ddi/ddi.h>
-/* Pointer to variable with uptime */
-uptime_t *uptime;
-/** Physical memory area of the real time clock */
+/** Physical memory area of the real time clock. */
 static parea_t clock_parea;
+/* Pointers to public variables with time */
+struct ptime {
+    unative_t seconds1;
+    unative_t useconds;
+    unative_t seconds2;
+};
+struct ptime *public_time;
 /* Variable holding fragment of second, so that we would update
  * seconds correctly
  */
 ,14 → 86,15
     if (!faddr)
         panic("Cannot allocate page for clock");
-    uptime = (uptime_t *) PA2KA(faddr);
-    uptime->seconds1 = 0;
-    uptime->seconds2 = 0;
-    uptime->useconds = 0;
+    public_time = (struct ptime *) PA2KA(faddr);
+        /* TODO: We would need some arch dependent settings here */
+    public_time->seconds1 = 0;
+    public_time->seconds2 = 0;
+    public_time->useconds = 0;
     clock_parea.pbase = (uintptr_t) faddr;
-    clock_parea.vbase = (uintptr_t) uptime;
+    clock_parea.vbase = (uintptr_t) public_time;
     clock_parea.frames = 1;
     clock_parea.cacheable = true;
     ddi_parea_register(&clock_parea);
 ,16 → 116,16
 static void clock_update_counters(void)
 {
     if (CPU->id == 0) {
-        secfrag += 1000000 / HZ;
+        secfrag += 1000000/HZ;
         if (secfrag >= 1000000) {
             secfrag -= 1000000;
-            uptime->seconds1++;
+            public_time->seconds1++;
             write_barrier();
-            uptime->useconds = secfrag;
+            public_time->useconds = secfrag;
             write_barrier();
-            uptime->seconds2 = uptime->seconds1;
+            public_time->seconds2 = public_time->seconds1;
         } else
-            uptime->useconds += 1000000 / HZ;
+            public_time->useconds += 1000000/HZ;
     }
 }

 /branches/rcu/kernel/generic/src/time/timeout.c
 ,6 → 45,7
 #include <arch/asm.h>
 #include <arch.h>
 /** Initialize timeouts
  *
  * Initialize kernel timeouts.
 ,7 → 175,6
     timeout_t *hlp;
     link_t *l;
     ipl_t ipl;
-    DEADLOCK_PROBE_INIT(p_tolock);
 grab_locks:
     ipl = interrupts_disable();
 ,8 → 186,7
     }
     if (!spinlock_trylock(&t->cpu->timeoutlock)) {
         spinlock_unlock(&t->lock);
-        interrupts_restore(ipl);
-        DEADLOCK_PROBE(p_tolock, DEADLOCK_THRESHOLD);
+        interrupts_restore(ipl);
         goto grab_locks;
     }

/branches/rcu/kernel/generic/src/ddi/irq.c
138,7 → 138,6
{
link_initialize(&irq->link);
spinlock_initialize(&irq->lock, "irq.lock");
irq->preack = false;
irq->inr = -1;
irq->devno = -1;
irq->trigger = (irq_trigger_t) 0;

 /branches/rcu/kernel/generic/src/console/cmd.c
 ,7 → 48,6
 #include <arch/types.h>
 #include <adt/list.h>
 #include <arch.h>
-#include <config.h>
 #include <func.h>
 #include <macros.h>
 #include <debug.h>
 ,26 → 79,10
 static cmd_info_t exit_info = {
     .name = "exit",
-    .description = "Exit kconsole.",
+    .description = "Exit kconsole",
     .argc = 0
 };
-static int cmd_reboot(cmd_arg_t *argv);
-static cmd_info_t reboot_info = {
-    .name = "reboot",
-    .description = "Reboot.",
-    .func = cmd_reboot,
-    .argc = 0
-};
-static int cmd_uptime(cmd_arg_t *argv);
-static cmd_info_t uptime_info = {
-    .name = "uptime",
-    .description = "Print uptime information.",
-    .func = cmd_uptime,
-    .argc = 0
-};
 static int cmd_continue(cmd_arg_t *argv);
 static cmd_info_t continue_info = {
     .name = "continue",
 ,10 → 192,10
 };
 /* Data and methods for 'call0' command. */
-static char call0_buf[MAX_CMDLINE + 1];
-static char carg1_buf[MAX_CMDLINE + 1];
-static char carg2_buf[MAX_CMDLINE + 1];
-static char carg3_buf[MAX_CMDLINE + 1];
+static char call0_buf[MAX_CMDLINE+1];
+static char carg1_buf[MAX_CMDLINE+1];
+static char carg2_buf[MAX_CMDLINE+1];
+static char carg3_buf[MAX_CMDLINE+1];
 static int cmd_call0(cmd_arg_t *argv);
 static cmd_arg_t call0_argv = {
 ,21 → 211,6
     .argv = &call0_argv
 };
-/* Data and methods for 'mcall0' command. */
-static int cmd_mcall0(cmd_arg_t *argv);
-static cmd_arg_t mcall0_argv = {
-    .type = ARG_TYPE_STRING,
-    .buffer = call0_buf,
-    .len = sizeof(call0_buf)
-};
-static cmd_info_t mcall0_info = {
-    .name = "mcall0",
-    .description = "mcall0 <function> -> call function() on each CPU.",
-    .func = cmd_mcall0,
-    .argc = 1,
-    .argv = &mcall0_argv
-};
 /* Data and methods for 'call1' command. */
 static int cmd_call1(cmd_arg_t *argv);
 static cmd_arg_t call1_argv[] = {
 ,7 → 406,6
 static cmd_info_t *basic_commands[] = {
     &call0_info,
-    &mcall0_info,
     &call1_info,
     &call2_info,
     &call3_info,
 ,8 → 413,6
     &cpus_info,
     &desc_info,
     &exit_info,
-    &reboot_info,
-    &uptime_info,
     &halt_info,
     &help_info,
     &ipc_task_info,
 ,41 → 488,6
     return 1;
 }
-/** Reboot the system.
- *
- * @param argv Argument vector.
- *
- * @return 0 on failure, 1 on success.
- */
-int cmd_reboot(cmd_arg_t *argv)
-{
-    reboot();
-    /* Not reached */
-    return 1;
-}
-/** Print system uptime information.
- *
- * @param argv Argument vector.
- *
- * @return 0 on failure, 1 on success.
- */
-int cmd_uptime(cmd_arg_t *argv)
-{
-    ASSERT(uptime);
-    /* This doesn't have to be very accurate */
-    unative_t sec = uptime->seconds1;
-    printf("Up %u days, %u hours, %u minutes, %u seconds\n",
-        sec / 86400, (sec % 86400) / 3600, (sec % 3600) / 60, sec % 60);
-    return 1;
-}
 /** Describe specified command.
  *
  * @param argv Argument vector.
 ,7 → 540,7
     struct {
         unative_t f;
         unative_t gp;
-    } fptr;
+    }fptr;
 #endif
     symaddr = get_symbol_addr((char *) argv->buffer);
 ,7 → 551,7
         printf("Duplicate symbol, be more specific.\n");
     } else {
         symbol = get_symtab_entry(symaddr);
-        printf("Calling %s() (%.*p)\n", symbol, sizeof(uintptr_t) * 2, symaddr);
+        printf("Calling f(): %.*p: %s\n", sizeof(uintptr_t) * 2, symaddr, symbol);
 #ifdef ia64
         fptr.f = symaddr;
         fptr.gp = ((unative_t *)cmd_call2)[1];
 ,32 → 565,6
     return 1;
 }
-/** Call function with zero parameters on each CPU */
-int cmd_mcall0(cmd_arg_t *argv)
-{
-    /*
-     * For each CPU, create a thread which will
-     * call the function.
-     */
-    count_t i;
-    for (i = 0; i < config.cpu_count; i++) {
-        thread_t *t;
-        if ((t = thread_create((void (*)(void *)) cmd_call0, (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
-            spinlock_lock(&t->lock);
-            t->cpu = &cpus[i];
-            spinlock_unlock(&t->lock);
-            printf("cpu%u: ", i);
-            thread_ready(t);
-            thread_join(t);
-            thread_detach(t);
-        } else
-            printf("Unable to create thread for cpu%u\n", i);
-    }
-    return 1;
-}
 /** Call function with one parameter */
 int cmd_call1(cmd_arg_t *argv)
 {
 ,7 → 713,7
 /** Write 4 byte value to address */
 int cmd_set4(cmd_arg_t *argv)
 {
-    uint32_t *addr;
+    uint32_t *addr ;
     uint32_t arg1 = argv[1].intval;
     bool pointer = false;

 /branches/rcu/kernel/generic/src/lib/objc.c
 ,7 → 49,7
     return class_create_instance(self);
 }
-- (id) dispose
+- (id) free
 {
     return object_dispose(self);
 }

 /branches/rcu/kernel/generic/src/lib/memstr.c
 ,8 → 130,7
 {
     char *orig = dest;
-    while ((*(dest++) = *(src++)))
-        ;
+    while ((*(dest++) = *(src++)));
     return orig;
 }

 /branches/rcu/kernel/generic/src/lib/func.c
 ,23 → 223,20
 void order(const uint64_t val, uint64_t *rv, char *suffix)
 {
-    if (val > 10000000000000000000ULL) {
-        *rv = val / 1000000000000000000ULL;
-        *suffix = 'Z';
-    } else if (val > 1000000000000000000ULL) {
-        *rv = val / 1000000000000000ULL;
+    if (val > 1000000000000000000LL) {
+        *rv = val / 1000000000000000LL;
         *suffix = 'E';
-    } else if (val > 1000000000000000ULL) {
-        *rv = val / 1000000000000ULL;
+    } else if (val > 1000000000000000LL) {
+        *rv = val / 1000000000000LL;
         *suffix = 'T';
-    } else if (val > 1000000000000ULL) {
-        *rv = val / 1000000000ULL;
+    } else if (val > 1000000000000LL) {
+        *rv = val / 1000000000LL;
         *suffix = 'G';
-    } else if (val > 1000000000ULL) {
-        *rv = val / 1000000ULL;
+    } else if (val > 1000000000LL) {
+        *rv = val / 1000000LL;
         *suffix = 'M';
-    } else if (val > 1000000ULL) {
-        *rv = val / 1000ULL;
+    } else if (val > 1000000LL) {
+        *rv = val / 1000LL;
         *suffix = 'k';
     } else {
         *rv = val;

 /branches/rcu/kernel/generic/src/mm/as.c
 ,7 → 57,6
 #include <genarch/mm/page_ht.h>
 #include <mm/asid.h>
 #include <arch/mm/asid.h>
-#include <preemption.h>
 #include <synch/spinlock.h>
 #include <synch/mutex.h>
 #include <adt/list.h>
 ,7 → 181,7
     else
         as->asid = ASID_INVALID;
-    atomic_set(&as->refcount, 0);
+    as->refcount = 0;
     as->cpu_refcount = 0;
 #ifdef AS_PAGE_TABLE
     as->genarch.page_table = page_table_create(flags);
 ,16 → 196,13
  *
  * When there are no tasks referencing this address space (i.e. its refcount is
  * zero), the address space can be destroyed.
- *
- * We know that we don't hold any spinlock.
  */
 void as_destroy(as_t *as)
 {
     ipl_t ipl;
     bool cond;
-    DEADLOCK_PROBE_INIT(p_asidlock);
-    ASSERT(atomic_get(&as->refcount) == 0);
+    ASSERT(as->refcount == 0);
     /*
      * Since there is no reference to this area,
 ,23 → 209,8
      * it is safe not to lock its mutex.
      */
-    /*
-     * We need to avoid deadlock between TLB shootdown and asidlock.
-     * We therefore try to take asid conditionally and if we don't succeed,
-     * we enable interrupts and try again. This is done while preemption is
-     * disabled to prevent nested context switches. We also depend on the
-     * fact that so far no spinlocks are held.
-     */
-    preemption_disable();
-    ipl = interrupts_read();
-retry:
-    interrupts_disable();
-    if (!spinlock_trylock(&asidlock)) {
-        interrupts_enable();
-        DEADLOCK_PROBE(p_asidlock, DEADLOCK_THRESHOLD);
-        goto retry;
-    }
-    preemption_enable();    /* Interrupts disabled, enable preemption */
+    ipl = interrupts_disable();
+    spinlock_lock(&asidlock);
     if (as->asid != ASID_INVALID && as != AS_KERNEL) {
         if (as != AS && as->cpu_refcount == 0)
             list_remove(&as->inactive_as_with_asid_link);
 ,16 → 472,15
         /*
          * Finish TLB shootdown sequence.
          */
         tlb_invalidate_pages(as->asid, area->base + pages * PAGE_SIZE,
             area->pages - pages);
+        tlb_shootdown_finalize();
         /*
          * Invalidate software translation caches (e.g. TSB on sparc64).
          */
         as_invalidate_translation_cache(as, area->base +
             pages * PAGE_SIZE, area->pages - pages);
-        tlb_shootdown_finalize();
     } else {
         /*
          * Growing the area.
 ,14 → 568,14
     /*
      * Finish TLB shootdown sequence.
      */
     tlb_invalidate_pages(as->asid, area->base, area->pages);
+    tlb_shootdown_finalize();
     /*
      * Invalidate potential software translation caches (e.g. TSB on
      * sparc64).
      */
     as_invalidate_translation_cache(as, area->base, area->pages);
-    tlb_shootdown_finalize();
     btree_destroy(&area->used_space);
 ,29 → 867,12
  * scheduling. Sleeping here would lead to deadlock on wakeup. Another
  * thing which is forbidden in this context is locking the address space.
  *
- * When this function is enetered, no spinlocks may be held.
- *
  * @param old Old address space or NULL.
  * @param new New address space.
  */
 void as_switch(as_t *old_as, as_t *new_as)
 {
-    DEADLOCK_PROBE_INIT(p_asidlock);
-    preemption_disable();
-retry:
-    (void) interrupts_disable();
-    if (!spinlock_trylock(&asidlock)) {
-        /*
-         * Avoid deadlock with TLB shootdown.
-         * We can enable interrupts here because
-         * preemption is disabled. We should not be
-         * holding any other lock.
-         */
-        (void) interrupts_enable();
-        DEADLOCK_PROBE(p_asidlock, DEADLOCK_THRESHOLD);
-        goto retry;
-    }
-    preemption_enable();
+    spinlock_lock(&asidlock);
     /*
      * First, take care of the old address space.

 /branches/rcu/kernel/generic/src/mm/page.c
 ,7 → 76,7
     cnt = length / PAGE_SIZE + (length % PAGE_SIZE > 0);
     for (i = 0; i < cnt; i++)
-        page_mapping_insert(AS_KERNEL, s + i * PAGE_SIZE, s + i * PAGE_SIZE, PAGE_NOT_CACHEABLE | PAGE_WRITE);
+        page_mapping_insert(AS_KERNEL, s + i * PAGE_SIZE, s + i * PAGE_SIZE, PAGE_NOT_CACHEABLE);
 }

 /branches/rcu/kernel/generic/src/synch/spinlock.c
 ,6 → 73,7
  * @param sl Pointer to spinlock_t structure.
  */
 #ifdef CONFIG_DEBUG_SPINLOCK
+#define DEADLOCK_THRESHOLD  100000000
 void spinlock_lock_debug(spinlock_t *sl)
 {
     count_t i = 0;
 ,7 → 84,7
     while (test_and_set(&sl->val)) {
         /*
-         * We need to be careful about printf_lock and fb_lock.
+         * We need to be careful about printflock and fb_lock.
          * Both of them are used to report deadlocks via
          * printf() and fb_putchar().
          *
 ,13 → 94,13
          * However, we encountered false positives caused by very
          * slow VESA framebuffer interaction (especially when
          * run in a simulator) that caused problems with both
-         * printf_lock and fb_lock.
+         * printflock and fb_lock.
          *
-         * Possible deadlocks on both printf_lock and fb_lock
+         * Possible deadlocks on both printflock and fb_lock
          * are therefore not reported as they would cause an
          * infinite recursion.
          */
-        if (sl == &printf_lock)
+        if (sl == &printflock)
             continue;
 #ifdef CONFIG_FB
         if (sl == &fb_lock)

 /branches/rcu/kernel/generic/src/printf/vprintf.c
 ,11 → 35,7
 #include <print.h>
 #include <printf/printf_core.h>
 #include <putchar.h>
-#include <synch/spinlock.h>
-#include <arch/asm.h>
-SPINLOCK_INITIALIZE(printf_lock);           /**< vprintf spinlock */
 static int vprintf_write(const char *str, size_t count, void *unused)
 {
     size_t i;
 ,16 → 55,8
 int vprintf(const char *fmt, va_list ap)
 {
     struct printf_spec ps = {(int(*)(void *, size_t, void *)) vprintf_write, NULL};
-    int irqpri = interrupts_disable();
-    spinlock_lock(&printf_lock);
-    int ret = printf_core(fmt, &ps, ap);
-    spinlock_unlock(&printf_lock);
-    interrupts_restore(irqpri);
-    return ret;
+    return printf_core(fmt, &ps, ap);
 }
 /** @}

/branches/rcu/kernel/generic/src/printf/snprintf.c
50,3 → 50,4

/** @}
*/

 /branches/rcu/kernel/generic/src/printf/vsnprintf.c
 ,6 → 42,8
     char *string; /* destination string */
 };
+int vsnprintf_write(const char *str, size_t count, struct vsnprintf_data *data);
 /** Write string to given buffer.
  * Write at most data->size characters including trailing zero. According to C99, snprintf() has to return number
  * of characters that would have been written if enough space had been available. Hence the return value is not
 ,7 → 54,7
  * @param data structure with destination string, counter of used space and total string size.
  * @return number of characters to print (not characters really printed!)
  */
-static int vsnprintf_write(const char *str, size_t count, struct vsnprintf_data *data)
+int vsnprintf_write(const char *str, size_t count, struct vsnprintf_data *data)
 {
     size_t i;
     i = data->size - data->len;

 /branches/rcu/kernel/generic/src/printf/printf_core.c
 ,9 → 38,14
 #include <printf/printf_core.h>
 #include <putchar.h>
 #include <print.h>
+#include <synch/spinlock.h>
 #include <arch/arg.h>
+#include <arch/asm.h>
 #include <arch.h>
+SPINLOCK_INITIALIZE(printflock);            /**< printf spinlock */
 #define __PRINTF_FLAG_PREFIX        0x00000001  /**< show prefixes 0x or 0*/
 #define __PRINTF_FLAG_SIGNED        0x00000002  /**< signed / unsigned number */
 #define __PRINTF_FLAG_ZEROPADDED    0x00000004  /**< print leading zeroes */
 ,6 → 458,7
  */
 int printf_core(const char *fmt, struct printf_spec *ps, va_list ap)
 {
+    int irqpri;
     int i = 0, j = 0; /**< i is index of currently processed char from fmt, j is index to the first not printed nonformating character */
     int end;
     int counter; /**< counter of printed characters */
 ,7 → 472,10
     uint64_t flags;
     counter = 0;
+    irqpri = interrupts_disable();
+    spinlock_lock(&printflock);
     while ((c = fmt[i])) {
         /* control character */
         if (c == '%' ) {
 ,6 → 712,8
     }
 out:
+    spinlock_unlock(&printflock);
+    interrupts_restore(irqpri);
     return counter;
 }

 /branches/rcu/kernel/generic/src/printf/vsprintf.c
 ,7 → 36,7
 int vsprintf(char *str, const char *fmt, va_list ap)
 {
-    return vsnprintf(str, (size_t) - 1, fmt, ap);
+    return vsnprintf(str, (size_t)-1, fmt, ap);
 }
 /** @}

 /branches/rcu/kernel/generic/src/syscall/syscall.c
 ,7 → 100,7
     if (id < SYSCALL_END)
         rc = syscall_table[id](a1, a2, a3, a4);
     else {
-        klog_printf("TASK %llu: Unknown syscall id %d",TASK->taskid,id);
+        klog_printf("TASK %lld: Unknown syscall id %d",TASK->taskid,id);
         task_kill(TASK->taskid);
         thread_exit();
     }
 ,7 → 118,6
     /* Thread and task related syscalls. */
     (syshandler_t) sys_thread_create,
     (syshandler_t) sys_thread_exit,
-    (syshandler_t) sys_thread_get_id,
     (syshandler_t) sys_task_get_id,
     /* Synchronization related syscalls. */

 /branches/rcu/kernel/generic/src/adt/btree.c
 ,7 → 970,7
         printf("(");
         for (i = 0; i < node->keys; i++) {
-            printf("%llu%s", node->key[i], i < node->keys - 1 ? "," : "");
+            printf("%lld%s", node->key[i], i < node->keys - 1 ? "," : "");
             if (node->depth && node->subtree[i]) {
                 list_append(&node->subtree[i]->bfs_link, &head);
             }
 ,7 → 992,7
         printf("(");
         for (i = 0; i < node->keys; i++)
-            printf("%llu%s", node->key[i], i < node->keys - 1 ? "," : "");
+            printf("%lld%s", node->key[i], i < node->keys - 1 ? "," : "");
         printf(")");
     }
     printf("\n");

/branches/rcu/kernel/generic/src/ipc/irq.c
336,7 → 336,6
while (box->irq_head.next != &box->irq_head) {
link_t *cur = box->irq_head.next;
irq_t *irq;
DEADLOCK_PROBE_INIT(p_irqlock);

irq = list_get_instance(cur, irq_t, notif_cfg.link);
if (!spinlock_trylock(&irq->lock)) {
345,7 → 344,6
*/
spinlock_unlock(&box->irq_lock);
interrupts_restore(ipl);
DEADLOCK_PROBE(p_irqlock, DEADLOCK_THRESHOLD);
goto loop;
}

 /branches/rcu/kernel/generic/src/ipc/ipc.c
 ,7 → 374,6
     int i;
     call_t *call;
     phone_t *phone;
-    DEADLOCK_PROBE_INIT(p_phonelck);
     /* Disconnect all our phones ('ipc_phone_hangup') */
     for (i=0;i < IPC_MAX_PHONES; i++)
 ,10 → 387,9
     spinlock_lock(&TASK->answerbox.lock);
     while (!list_empty(&TASK->answerbox.connected_phones)) {
         phone = list_get_instance(TASK->answerbox.connected_phones.next,
-            phone_t, link);
+                      phone_t, link);
         if (! spinlock_trylock(&phone->lock)) {
             spinlock_unlock(&TASK->answerbox.lock);
-            DEADLOCK_PROBE(p_phonelck, DEADLOCK_THRESHOLD);
             goto restart_phones;
         }
 ,7 → 500,7
     printf("ABOX - CALLS:\n");
     for (tmp=task->answerbox.calls.next; tmp != &task->answerbox.calls;tmp = tmp->next) {
         call = list_get_instance(tmp, call_t, link);
-        printf("Callid: %p Srctask:%llu M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
+        printf("Callid: %p Srctask:%lld M:%d A1:%d A2:%d A3:%d 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), call->flags);
     }
 ,7 → 510,7
          tmp != &task->answerbox.dispatched_calls;
          tmp = tmp->next) {
         call = list_get_instance(tmp, call_t, link);
-        printf("Callid: %p Srctask:%llu M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
+        printf("Callid: %p Srctask:%lld M:%d A1:%d A2:%d A3:%d 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), call->flags);
     }

 /branches/rcu/kernel/generic/include/proc/thread.h
 ,11 → 53,7
 /* Thread flags */
-/** Thread cannot be migrated to another CPU.
- *
- * When using this flag, the caller must set cpu in the thread_t
- * structure manually before calling thread_ready (even on uniprocessor).
- */
+/** Thread cannot be migrated to another CPU. */
 #define THREAD_FLAG_WIRED   (1 << 0)
 /** Thread was migrated to another CPU and has not run yet. */
 #define THREAD_FLAG_STOLEN  (1 << 1)
 ,7 → 193,7
     /** Thread's priority. Implemented as index to CPU->rq */
     int priority;
     /** Thread ID. */
-    thread_id_t tid;
+    uint32_t tid;
     /** Architecture-specific data. */
     thread_arch_t arch;
 ,9 → 248,8
 extern slab_cache_t *fpu_context_slab;
 /* Thread syscall prototypes. */
-extern unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name, thread_id_t *uspace_thread_id);
-extern unative_t sys_thread_exit(int uspace_status);
-extern unative_t sys_thread_get_id(thread_id_t *uspace_thread_id);
+unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name);
+unative_t sys_thread_exit(int uspace_status);
 #endif

 /branches/rcu/kernel/generic/include/proc/task.h
 ,10 → 90,10
      * Active asynchronous messages. It is used for limiting uspace to
      * certain extent.
      */
-    atomic_t active_calls;
+    atomic_t active_calls;
     /** Architecture specific task data. */
-    task_arch_t arch;
+    task_arch_t arch;
     /**
      * Serializes access to the B+tree of task's futexes. This mutex is
 ,7 → 111,6
 extern btree_t tasks_btree;
 extern void task_init(void);
-extern void task_done(void);
 extern task_t *task_create(as_t *as, char *name);
 extern void task_destroy(task_t *t);
 extern task_t *task_run_program(void *program_addr, char *name);

 /branches/rcu/kernel/generic/include/ddi/irq.h
 ,14 → 121,6
      *  this lock must not be taken first.
      */
     SPINLOCK_DECLARE(lock);
-    /** Send EOI before processing the interrupt.
-     *  This is essential for timer interrupt which
-     *  has to be acknowledged before doing preemption
-     *  to make sure another timer interrupt will
-     *  be eventually generated.
-     */
-    bool preack;
     /** Unique device number. -1 if not yet assigned. */
     devno_t devno;
 ,7 → 127,7
     /** Actual IRQ number. -1 if not yet assigned. */
     inr_t inr;
-    /** Trigger level of the IRQ. */
+    /** Trigger level of the IRQ.*/
     irq_trigger_t trigger;
     /** Claim ownership of the IRQ. */
     irq_ownership_t (* claim)(void);

 /branches/rcu/kernel/generic/include/mm/as.h
 ,11 → 101,11
          */
         asid_t asid;
-        /** Number of references (i.e tasks that reference this as). */
-        atomic_t refcount;
         mutex_t lock;
+        /** Number of references (i.e tasks that reference this as). */
+        count_t refcount;
         /** B+tree of address space areas. */
         btree_t as_area_btree;
 ,11 → 147,11
      */
     asid_t asid;
+    mutex_t lock;
     /** Number of references (i.e tasks that reference this as). */
-    atomic_t refcount;
+    count_t refcount;
-    mutex_t lock;
     /** B+tree of address space areas. */
     btree_t as_area_btree;

 /branches/rcu/kernel/generic/include/synch/spinlock.h
 ,26 → 101,8
     preemption_enable();
 }
-#ifdef CONFIG_DEBUG_SPINLOCK
-extern int printf(const char *, ...);
-#define DEADLOCK_THRESHOLD      100000000
-#define DEADLOCK_PROBE_INIT(pname)  count_t pname = 0
-#define DEADLOCK_PROBE(pname, value)                    \
-    if ((pname)++ > (value)) {                  \
-        (pname) = 0;                        \
-        printf("Deadlock probe %s: exceeded threshold %d\n",    \
-            "cpu%d: function=%s, line=%d\n",            \
-            #pname, (value), CPU->id, __FUNCTION__, __LINE__);  \
-    }
 #else
-#define DEADLOCK_PROBE_INIT(pname)
-#define DEADLOCK_PROBE(pname, value)
-#endif
-#else
 /* On UP systems, spinlocks are effectively left out. */
 #define SPINLOCK_DECLARE(name)
 #define SPINLOCK_EXTERN(name)
 ,9 → 113,6
 #define spinlock_trylock(x)         (preemption_disable(), 1)
 #define spinlock_unlock(x)      preemption_enable()
-#define DEADLOCK_PROBE_INIT(pname)
-#define DEADLOCK_PROBE(pname, value)
 #endif
 #endif

 /branches/rcu/kernel/generic/include/synch/mutex.h
 ,11 → 44,13
 } mutex_t;
 #define mutex_lock(mtx) \
-    _mutex_lock_timeout((mtx), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)
+    _mutex_lock_timeout((mtx),SYNCH_NO_TIMEOUT,SYNCH_FLAGS_NONE)
 #define mutex_trylock(mtx) \
-    _mutex_lock_timeout((mtx), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING)
-#define mutex_lock_timeout(mtx, usec) \
-    _mutex_lock_timeout((mtx), (usec), SYNCH_FLAGS_NON_BLOCKING)
+    _mutex_lock_timeout((mtx),SYNCH_NO_TIMEOUT,SYNCH_FLAGS_NON_BLOCKING)
+#define mutex_lock_timeout(mtx,usec) \
+    _mutex_lock_timeout((mtx),(usec),SYNCH_FLAGS_NON_BLOCKING)
+#define mutex_lock_active(mtx) \
+    while (mutex_trylock((mtx)) != ESYNCH_OK_ATOMIC)
 extern void mutex_initialize(mutex_t *mtx);
 extern int _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, int flags);

 /branches/rcu/kernel/generic/include/print.h
 ,7 → 40,7
 #include <arch/arg.h>
 /* We need this address in spinlock to avoid deadlock in deadlock detection */
-SPINLOCK_EXTERN(printf_lock);
+SPINLOCK_EXTERN(printflock);
 #define EOF (-1)

/branches/rcu/kernel/generic/include/syscall/syscall.h
40,7 → 40,6
SYS_TLS_SET = 1, /* Hardcoded in AMD64, IA32 uspace - psthread.S */
SYS_THREAD_CREATE,
SYS_THREAD_EXIT,
SYS_THREAD_GET_ID,
SYS_TASK_GET_ID,
SYS_FUTEX_SLEEP,
SYS_FUTEX_WAKEUP,

 /branches/rcu/kernel/generic/include/time/clock.h
 ,19 → 35,8
 #ifndef KERN_CLOCK_H_
 #define KERN_CLOCK_H_
-#include <arch/types.h>
 #define HZ      100
-/** Uptime structure */
-typedef struct {
-    unative_t seconds1;
-    unative_t useconds;
-    unative_t seconds2;
-} uptime_t;
-extern uptime_t *uptime;
 extern void clock(void);
 extern void clock_counter_init(void);

 /branches/rcu/kernel/generic/include/arch.h
 ,12 → 74,8
 extern void arch_post_cpu_init(void);
 extern void arch_pre_smp_init(void);
 extern void arch_post_smp_init(void);
 extern void calibrate_delay_loop(void);
-extern void reboot(void);
-extern void arch_reboot(void);
 #endif
 /** @}

 /branches/rcu/kernel/generic/include/interrupt.h
 ,7 → 48,7
 #define fault_if_from_uspace(istate, cmd, ...) \
 { \
     if (istate_from_uspace(istate)) { \
-        klog_printf("Task %llu killed due to an exception at %p.", TASK->taskid, istate_get_pc(istate)); \
+        klog_printf("Task %lld killed due to an exception at %p.", TASK->taskid, istate_get_pc(istate)); \
         klog_printf("  " cmd, ##__VA_ARGS__); \
         task_kill(TASK->taskid); \
         thread_exit(); \

 /branches/rcu/kernel/generic/include/printf/printf_core.h
 ,7 → 47,7
 };
-int printf_core(const char *fmt, struct printf_spec *ps, va_list ap);
+int printf_core(const char *fmt, struct printf_spec *ps ,va_list ap);
 #endif

 /branches/rcu/kernel/arch/sparc64/src/mm/cache.S
 ,10 → 45,8
     subcc %g1, DCACHE_LINE_SIZE, %g1
     bnz,pt %xcc, 0b
     stxa %g0, [%g1] ASI_DCACHE_TAG
-    membar #Sync
     retl
-    ! beware SF Erratum #51, do not put the MEMBAR here
-    nop
+    membar #Sync
 /** Flush only D-cache lines of one virtual color.
  *

 /branches/rcu/kernel/arch/sparc64/src/mm/tlb.c
 ,7 → 198,7
 }
 /** ITLB miss handler. */
-void fast_instruction_access_mmu_miss(unative_t unused, istate_t *istate)
+void fast_instruction_access_mmu_miss(int n, istate_t *istate)
 {
     uintptr_t va = ALIGN_DOWN(istate->tpc, PAGE_SIZE);
     index_t index = (istate->tpc >> MMU_PAGE_WIDTH) % MMU_PAGES_PER_PAGE;
 ,18 → 234,15
  *
  * Note that some faults (e.g. kernel faults) were already resolved by the
  * low-level, assembly language part of the fast_data_access_mmu_miss handler.
- *
- * @param tag Content of the TLB Tag Access register as it existed when the
- *    trap happened. This is to prevent confusion created by clobbered
- *    Tag Access register during a nested DTLB miss.
- * @param istate Interrupted state saved on the stack.
  */
-void fast_data_access_mmu_miss(tlb_tag_access_reg_t tag, istate_t *istate)
+void fast_data_access_mmu_miss(int n, istate_t *istate)
 {
+    tlb_tag_access_reg_t tag;
     uintptr_t va;
     index_t index;
     pte_t *t;
+    tag.value = dtlb_tag_access_read();
     va = ALIGN_DOWN((uint64_t) tag.vpn << MMU_PAGE_WIDTH, PAGE_SIZE);
     index = tag.vpn % MMU_PAGES_PER_PAGE;
 ,19 → 282,15
     }
 }
-/** DTLB protection fault handler.
- *
- * @param tag Content of the TLB Tag Access register as it existed when the
- *    trap happened. This is to prevent confusion created by clobbered
- *    Tag Access register during a nested DTLB miss.
- * @param istate Interrupted state saved on the stack.
- */
-void fast_data_access_protection(tlb_tag_access_reg_t tag, istate_t *istate)
+/** DTLB protection fault handler. */
+void fast_data_access_protection(int n, istate_t *istate)
 {
+    tlb_tag_access_reg_t tag;
     uintptr_t va;
     index_t index;
     pte_t *t;
+    tag.value = dtlb_tag_access_read();
     va = ALIGN_DOWN((uint64_t) tag.vpn << MMU_PAGE_WIDTH, PAGE_SIZE);
     index = tag.vpn % MMU_PAGES_PER_PAGE;   /* 16K-page emulation */
 ,10 → 371,9
     uintptr_t va;
     va = tag.vpn << MMU_PAGE_WIDTH;
-    if (tag.context) {
-        fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d)\n", str, va,
-            tag.context);
-    }
+    fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d)\n", str, va,
+        tag.context);
     dump_istate(istate);
     printf("Faulting page: %p, ASID=%d\n", va, tag.context);
     panic("%s\n", str);
 ,10 → 386,8
     va = tag.vpn << MMU_PAGE_WIDTH;
-    if (tag.context) {
-        fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d)\n", str, va,
-            tag.context);
-    }
+    fault_if_from_uspace(istate, "%s, Page=%p (ASID=%d)\n", str, va,
+        tag.context);
     printf("Faulting page: %p, ASID=%d\n", va, tag.context);
     dump_istate(istate);
     panic("%s\n", str);

/branches/rcu/kernel/arch/sparc64/src/mm/as.c
66,7 → 66,6
*/
int order = fnzb32(((ITSB_ENTRY_COUNT + DTSB_ENTRY_COUNT) *
sizeof(tsb_entry_t)) >> FRAME_WIDTH);

uintptr_t tsb = (uintptr_t) frame_alloc(order, flags \| FRAME_KA);

if (!tsb)
75,7 → 74,6
as->arch.itsb = (tsb_entry_t *) tsb;
as->arch.dtsb = (tsb_entry_t ) (tsb + ITSB_ENTRY_COUNT
sizeof(tsb_entry_t));

memsetb((uintptr_t) as->arch.itsb,
(ITSB_ENTRY_COUNT + DTSB_ENTRY_COUNT) * sizeof(tsb_entry_t), 0);
#endif

 /branches/rcu/kernel/arch/sparc64/src/mm/tsb.c
 ,8 → 61,6
     ASSERT(as->arch.itsb && as->arch.dtsb);
     i0 = (page >> MMU_PAGE_WIDTH) & TSB_INDEX_MASK;
-    ASSERT(i0 < ITSB_ENTRY_COUNT && i0 < DTSB_ENTRY_COUNT);
     if (pages == (count_t) -1 || (pages * 2) > ITSB_ENTRY_COUNT)
         cnt = ITSB_ENTRY_COUNT;
     else
 ,12 → 84,9
     as_t *as;
     tsb_entry_t *tsb;
     index_t entry;
-    ASSERT(index <= 1);
     as = t->as;
     entry = ((t->page >> MMU_PAGE_WIDTH) + index) & TSB_INDEX_MASK;
-    ASSERT(entry < ITSB_ENTRY_COUNT);
     tsb = &as->arch.itsb[entry];
     /*
 ,8 → 102,8
     write_barrier();
     tsb->tag.context = as->asid;
-    /* the shift is bigger than PAGE_WIDTH, do not bother with index  */
-    tsb->tag.va_tag = t->page >> VA_TAG_PAGE_SHIFT;
+    tsb->tag.va_tag = (t->page + (index << MMU_PAGE_WIDTH)) >>
+        VA_TAG_PAGE_SHIFT;
     tsb->data.value = 0;
     tsb->data.size = PAGESIZE_8K;
     tsb->data.pfn = (t->frame >> MMU_FRAME_WIDTH) + index;
 ,11 → 128,8
     tsb_entry_t *tsb;
     index_t entry;
-    ASSERT(index <= 1);
     as = t->as;
     entry = ((t->page >> MMU_PAGE_WIDTH) + index) & TSB_INDEX_MASK;
-    ASSERT(entry < DTSB_ENTRY_COUNT);
     tsb = &as->arch.dtsb[entry];
     /*
 ,8 → 145,8
     write_barrier();
     tsb->tag.context = as->asid;
-    /* the shift is bigger than PAGE_WIDTH, do not bother with index */
-    tsb->tag.va_tag = t->page >> VA_TAG_PAGE_SHIFT;
+    tsb->tag.va_tag = (t->page + (index << MMU_PAGE_WIDTH)) >>
+        VA_TAG_PAGE_SHIFT;
     tsb->data.value = 0;
     tsb->data.size = PAGESIZE_8K;
     tsb->data.pfn = (t->frame >> MMU_FRAME_WIDTH) + index;

 /branches/rcu/kernel/arch/sparc64/src/mm/frame.c
 ,10 → 65,10
             if (confdata == ADDR2PFN(KA2PA(PFN2ADDR(0))))
                 confdata = ADDR2PFN(KA2PA(PFN2ADDR(2)));
             zone_create(ADDR2PFN(start),
-                SIZE2FRAMES(ALIGN_DOWN(size, FRAME_SIZE)),
-                confdata, 0);
+                SIZE2FRAMES(ALIGN_DOWN(size, FRAME_SIZE)),
+                confdata, 0);
             last_frame = max(last_frame, start + ALIGN_UP(size,
-                FRAME_SIZE));
+                FRAME_SIZE));
         }
         /*

 /branches/rcu/kernel/arch/sparc64/src/smp/ipi.c
 ,8 → 74,8
         panic("Interrupt Dispatch Status busy bit set\n");
     do {
-        asi_u64_write(ASI_UDB_INTR_W, ASI_UDB_INTR_W_DATA_0,
-            (uintptr_t) func);
+        asi_u64_write(ASI_UDB_INTR_W, ASI_UDB_INTR_W_DATA_0, (uintptr_t)
+            func);
         asi_u64_write(ASI_UDB_INTR_W, ASI_UDB_INTR_W_DATA_1, 0);
         asi_u64_write(ASI_UDB_INTR_W, ASI_UDB_INTR_W_DATA_2, 0);
         asi_u64_write(ASI_UDB_INTR_W,

 /branches/rcu/kernel/arch/sparc64/src/smp/smp.c
 ,7 → 100,7
         if (waitq_sleep_timeout(&ap_completion_wq, 1000000, SYNCH_FLAGS_NONE) == ESYNCH_TIMEOUT)
             printf("%s: waiting for processor (mid = %d) timed out\n",
-                __FUNCTION__, mid);
+                __FUNCTION__, mid);
     }
 }

 /branches/rcu/kernel/arch/sparc64/src/sparc64.c
 ,11 → 155,5
     /* not reached */
 }
-void arch_reboot(void)
-{
-    // TODO
-    while (1);
-}
 /** @}
  */

 /branches/rcu/kernel/arch/sparc64/src/cpu/cpu.c
 ,10 → 63,10
             mid = *((uint32_t *) prop->value);
             if (mid == CPU->arch.mid) {
                 prop = ofw_tree_getprop(node,
-                    "clock-frequency");
+                    "clock-frequency");
                 if (prop && prop->value)
                     clock_frequency = *((uint32_t *)
-                        prop->value);
+                        prop->value);
             }
         }
         node = ofw_tree_find_peer_by_device_type(node, "cpu");

 /branches/rcu/kernel/arch/sparc64/src/asm.S
 ,7 → 273,7
     flushw
     wrpr %g0, 0, %cleanwin      ! avoid information leak
-    mov %i2, %o0            ! uarg
+    mov %i3, %o0            ! uarg
     clr %i2
     clr %i3

 /branches/rcu/kernel/arch/sparc64/src/proc/scheduler.c
 ,8 → 62,9
          * - preemptible trap handler switches to alternate globals
          *   before it explicitly uses %g7.
          */
-        uint64_t sp = (uintptr_t) THREAD->kstack + STACK_SIZE -
-            (STACK_BIAS + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT));
+        uint64_t sp = (uintptr_t) THREAD->kstack + STACK_SIZE
+            - (STACK_BIAS + ALIGN_UP(STACK_ITEM_SIZE,
+            STACK_ALIGNMENT));
         write_to_ig_g6(sp);
         write_to_ag_g6(sp);
         write_to_ag_g7((uintptr_t) THREAD->arch.uspace_window_buffer);

 /branches/rcu/kernel/arch/sparc64/src/proc/thread.c
 ,7 → 55,7
          * belonging to a killed thread.
          */
         frame_free(KA2PA(ALIGN_DOWN((uintptr_t)
-            t->arch.uspace_window_buffer, PAGE_SIZE)));
+            t->arch.uspace_window_buffer, PAGE_SIZE)));
     }
 }
 ,8 → 75,8
          * Mind the possible alignment of the userspace window buffer
          * belonging to a killed thread.
          */
-        t->arch.uspace_window_buffer = (uint8_t *) ALIGN_DOWN(uw_buf,
-            PAGE_SIZE);
+         t->arch.uspace_window_buffer = (uint8_t *) ALIGN_DOWN(uw_buf,
+            PAGE_SIZE);
     }
 }

 /branches/rcu/kernel/arch/sparc64/include/mm/tlb.h
 ,9 → 428,9
     membar();
 }
-extern void fast_instruction_access_mmu_miss(unative_t unused, istate_t *istate);
-extern void fast_data_access_mmu_miss(tlb_tag_access_reg_t tag, istate_t *istate);
-extern void fast_data_access_protection(tlb_tag_access_reg_t tag , istate_t *istate);
+extern void fast_instruction_access_mmu_miss(int n, istate_t *istate);
+extern void fast_data_access_mmu_miss(int n, istate_t *istate);
+extern void fast_data_access_protection(int n, istate_t *istate);
 extern void dtlb_insert_mapping(uintptr_t page, uintptr_t frame, int pagesize, bool locked, bool cacheable);

/branches/rcu/kernel/arch/sparc64/include/types.h
62,7 → 62,6
typedef int64_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/sparc64/include/trap/mmu.h
 ,21 → 129,7
     wrpr %g0, 1, %tl
 .endif
-    /*
-     * Switch from the MM globals.
-     */
     wrpr %g0, PSTATE_PRIV_BIT | PSTATE_AG_BIT, %pstate
-    /*
-     * Read the Tag Access register for the higher-level handler.
-     * This is necessary to survive nested DTLB misses.
-     */
-    mov VA_DMMU_TAG_ACCESS, %g2
-    ldxa [%g2] ASI_DMMU, %g2
-    /*
-     * g2 will be passed as an argument to fast_data_access_mmu_miss().
-     */
     PREEMPTIBLE_HANDLER fast_data_access_mmu_miss
 .endm
 ,21 → 142,7
     wrpr %g0, 1, %tl
 .endif
-    /*
-     * Switch from the MM globals.
-     */
     wrpr %g0, PSTATE_PRIV_BIT | PSTATE_AG_BIT, %pstate
-    /*
-     * Read the Tag Access register for the higher-level handler.
-     * This is necessary to survive nested DTLB misses.
-     */
-    mov VA_DMMU_TAG_ACCESS, %g2
-    ldxa [%g2] ASI_DMMU, %g2
-    /*
-     * g2 will be passed as an argument to fast_data_access_mmu_miss().
-     */
     PREEMPTIBLE_HANDLER fast_data_access_protection
 .endm

 /branches/rcu/kernel/arch/sparc64/include/barrier.h
 ,12 → 39,12
  * Our critical section barriers are prepared for the weakest RMO memory model.
  */
 #define CS_ENTER_BARRIER()              \
-    asm volatile (                  \
+    asm volatile (              \
         "membar #LoadLoad | #LoadStore\n"   \
         ::: "memory"                \
     )
 #define CS_LEAVE_BARRIER()              \
-    asm volatile (                  \
+    asm volatile (              \
         "membar #StoreStore\n"          \
         "membar #LoadStore\n"           \
         ::: "memory"                \

 /branches/rcu/kernel/arch/ia64/src/ia64.c
 ,11 → 176,5
 #endif
 }
-void arch_reboot(void)
-{
-    // TODO
-    while (1);
-}
 /** @}
  */

/branches/rcu/kernel/arch/ia64/include/types.h
70,7 → 70,6
typedef int64_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/ppc32/src/mm/page.c
 ,7 → 53,7
     uintptr_t virtaddr = PA2KA(last_frame);
     pfn_t i;
     for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
-        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE | PAGE_WRITE);
+        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE);
     last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);

 /branches/rcu/kernel/arch/ppc32/src/interrupt.c
 ,19 → 60,11
     int inum;
     while ((inum = pic_get_pending()) != -1) {
-        bool ack = false;
         irq_t *irq = irq_dispatch_and_lock(inum);
         if (irq) {
             /*
              * The IRQ handler was found.
              */
-            if (irq->preack) {
-                /* Acknowledge the interrupt before processing */
-                pic_ack_interrupt(inum);
-                ack = true;
-            }
             irq->handler(irq, irq->arg);
             spinlock_unlock(&irq->lock);
         } else {
 ,9 → 75,7
             printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum);
 #endif
         }
-        if (!ack)
-            pic_ack_interrupt(inum);
+        pic_ack_interrupt(inum);
     }
 }

 /branches/rcu/kernel/arch/ppc32/src/drivers/cuda.c
 ,8 → 48,7
 #define PACKET_ADB  0x00
 #define PACKET_CUDA 0x01
-#define CUDA_POWERDOWN  0x0a
-#define CUDA_RESET      0x11
+#define CUDA_POWERDOWN 0x0a
 #define RS 0x200
 #define B (0 * RS)
 ,6 → 191,9
 };
+void send_packet(const uint8_t kind, index_t count, ...);
 static void receive_packet(uint8_t *kind, index_t count, uint8_t data[])
 {
     cuda[B] = cuda[B] & ~TIP;
 ,7 → 316,7
 }
-static void send_packet(const uint8_t kind, count_t count, ...)
+void send_packet(const uint8_t kind, index_t count, ...)
 {
     index_t i;
     va_list va;
 ,17 → 341,13
 void cpu_halt(void) {
+#ifdef CONFIG_POWEROFF
+    send_packet(PACKET_CUDA, 1, CUDA_POWERDOWN);
+#endif
     asm volatile (
         "b 0\n"
     );
 }
-void arch_reboot(void) {
-    send_packet(PACKET_CUDA, 1, CUDA_RESET);
-    asm volatile (
-        "b 0\n"
-    );
-}
 /** @}
  */

/branches/rcu/kernel/arch/ppc32/include/types.h
62,7 → 62,6
typedef int32_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/ia32xen/src/interrupt.c
 ,21 → 176,14
     ASSERT(n >= IVT_IRQBASE);
     int inum = n - IVT_IRQBASE;
-    bool ack = false;
     ASSERT(inum < IRQ_COUNT);
     ASSERT((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
     irq_t *irq = irq_dispatch_and_lock(inum);
     if (irq) {
         /*
          * The IRQ handler was found.
          */
-        if (irq->preack) {
-            /* Send EOI before processing the interrupt */
-            trap_virtual_eoi();
-            ack = true;
-        }
         irq->handler(irq, irq->arg);
         spinlock_unlock(&irq->lock);
     } else {
 ,9 → 194,7
         printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum);
 #endif
     }
-    if (!ack)
-        trap_virtual_eoi();
+    trap_virtual_eoi();
 }
 void interrupt_init(void)

 /branches/rcu/kernel/arch/ia32xen/src/ia32xen.c
 ,11 → 211,5
 {
 }
-void arch_reboot(void)
-{
-    // TODO
-    while (1);
-}
 /** @}
  */

 /branches/rcu/kernel/arch/ia32xen/src/smp/smp.c
 ,13 → 80,13
     if (config.cpu_count > 1) {
         page_mapping_insert(AS_KERNEL, l_apic_address, (uintptr_t) l_apic,
-                  PAGE_NOT_CACHEABLE | PAGE_WRITE);
+                  PAGE_NOT_CACHEABLE);
         page_mapping_insert(AS_KERNEL, io_apic_address, (uintptr_t) io_apic,
-                  PAGE_NOT_CACHEABLE | PAGE_WRITE);
+                  PAGE_NOT_CACHEABLE);
         l_apic = (uint32_t *) l_apic_address;
         io_apic = (uint32_t *) io_apic_address;
-    }
+        }
 }
 /*

/branches/rcu/kernel/arch/ia32xen/include/types.h
62,7 → 62,6
typedef int32_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/amd64/src/interrupt.c
 ,21 → 156,14
     ASSERT(n >= IVT_IRQBASE);
     int inum = n - IVT_IRQBASE;
-    bool ack = false;
     ASSERT(inum < IRQ_COUNT);
     ASSERT((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
     irq_t *irq = irq_dispatch_and_lock(inum);
     if (irq) {
         /*
          * The IRQ handler was found.
          */
-        if (irq->preack) {
-            /* Send EOI before processing the interrupt */
-            trap_virtual_eoi();
-            ack = true;
-        }
         irq->handler(irq, irq->arg);
         spinlock_unlock(&irq->lock);
     } else {
 ,9 → 174,7
         printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum);
 #endif
     }
-    if (!ack)
-        trap_virtual_eoi();
+    trap_virtual_eoi();
 }
 void interrupt_init(void)

 /branches/rcu/kernel/arch/amd64/src/pm.c
 ,7 → 33,6
 /** @file
  */
-#include <arch.h>
 #include <arch/pm.h>
 #include <arch/asm.h>
 #include <mm/as.h>
 ,24 → 227,5
     tr_load(gdtselector(TSS_DES));
 }
-/* Reboot the machine by initiating
- * a triple fault
- */
-void arch_reboot(void)
-{
-    preemption_disable();
-    ipl_t ipl = interrupts_disable();
-    memsetb((uintptr_t) idt, sizeof(idt), 0);
-    idtr_load(&idtr);
-    interrupts_restore(ipl);
-    asm volatile (
-        "int $0x03\n"
-        "cli\n"
-        "hlt\n"
-    );
-}
 /** @}
  */

 /branches/rcu/kernel/arch/amd64/src/mm/page.c
 ,7 → 83,7
 {
     uintptr_t cur;
     int i;
-    int identity_flags = PAGE_CACHEABLE | PAGE_EXEC | PAGE_GLOBAL | PAGE_WRITE;
+    int identity_flags = PAGE_CACHEABLE | PAGE_EXEC | PAGE_GLOBAL;
     if (config.cpu_active == 1) {
         page_mapping_operations = &pt_mapping_operations;
 ,8 → 112,10
         exc_register(14, "page_fault", (iroutine) page_fault);
         write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
-    } else
+    }
+    else {
         write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
+    }
 }
 ,7 → 208,7
     uintptr_t virtaddr = PA2KA(last_frame);
     pfn_t i;
     for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
-        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE | PAGE_WRITE);
+        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE);
     last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);

 /branches/rcu/kernel/arch/amd64/src/boot/boot.S
 ,26 → 72,8
     movl %eax, grub_eax                         # save parameters from GRUB
     movl %ebx, grub_ebx
-    # Protected 32-bit. We want to reuse the code-seg descriptor,
-    # the Default operand size must not be 1 when entering long mode
-    movl $0x80000000, %eax
-    cpuid
-    cmp $0x80000000, %eax                       # any function > 80000000h?
-    jbe long_mode_unsupported
-    movl $(AMD_CPUID_EXTENDED), %eax            # Extended function code 80000001
-    cpuid
-    bt $29, %edx                                # Test if long mode is supported.
-    jc long_mode_supported
-    long_mode_unsupported:
-        movl $long_mode_msg, %esi
-        jmp error_halt
-    long_mode_supported:
 #ifdef CONFIG_FB
-    mov $vesa_init, %esi
+    mov $vesa_init, %esi;
     mov $VESA_INIT_SEGMENT << 4, %edi
     mov $e_vesa_init - vesa_init, %ecx
     cld
 ,7 → 92,25
     shr $16, %ebx
     mov %bx, KA2PA(vesa_bpp)
 #endif
+    # Protected 32-bit. We want to reuse the code-seg descriptor,
+    # the Default operand size must not be 1 when entering long mode
+    movl $0x80000000, %eax
+    cpuid
+    cmp $0x80000000, %eax                       # any function > 80000000h?
+    jbe long_mode_unsupported
+    movl $(AMD_CPUID_EXTENDED), %eax            # Extended function code 80000001
+    cpuid
+    bt $29, %edx                                # Test if long mode is supported.
+    jc long_mode_supported
+    long_mode_unsupported:
+        cli
+        hlt
+    long_mode_supported:
     # Enable 64-bit page transaltion entries - CR4.PAE = 1.
     # Paging is not enabled until after long mode is enabled
 ,12 → 303,11
 #define VESA_INFO_SIZE 1024
-#define VESA_MODE_ATTRIBUTES_OFFSET 0
 #define VESA_MODE_LIST_PTR_OFFSET 14
-#define VESA_MODE_SCANLINE_OFFSET 16
 #define VESA_MODE_WIDTH_OFFSET 18
 #define VESA_MODE_HEIGHT_OFFSET 20
 #define VESA_MODE_BPP_OFFSET 25
+#define VESA_MODE_SCANLINE_OFFSET 16
 #define VESA_MODE_PHADDR_OFFSET 40
 #define VESA_END_OF_MODES 0xffff
 ,14 → 317,14
 #define VESA_GET_INFO 0x4f00
 #define VESA_GET_MODE_INFO 0x4f01
 #define VESA_SET_MODE 0x4f02
-#define VESA_SET_PALETTE 0x4f09
 #define CONFIG_VESA_BPP_a 255
 #if CONFIG_VESA_BPP == 24
-#define CONFIG_VESA_BPP_VARIANT 32
+#undef CONFIG_VESA_BPP_a
+#define CONFIG_VESA_BPP_a 32
 #endif
     mov $VESA_GET_INFO, %ax
     mov $e_vesa_init - vesa_init, %di
     push %di
 ,7 → 339,7
     mov VESA_MODE_LIST_PTR_OFFSET(%di), %si
     add $VESA_INFO_SIZE, %di
 :# Try next mode
     mov %gs:(%si), %cx
     cmp $VESA_END_OF_MODES, %cx
 ,13 → 369,10
     mov $CONFIG_VESA_BPP, %al
     cmp VESA_MODE_BPP_OFFSET(%di), %al
-#ifdef CONFIG_VESA_BPP_VARIANT
     jz 2f
-    mov $CONFIG_VESA_BPP_VARIANT, %al
+    mov $CONFIG_VESA_BPP_a, %al
     cmp VESA_MODE_BPP_OFFSET(%di), %al
-#endif
     jnz 1b
 :
 ,60 → 386,7
     pop %di
     cmp $VESA_OK, %al
     jnz 0f
-#if CONFIG_VESA_BPP == 8
-    # Set 3:2:3 VGA palette
-    mov VESA_MODE_ATTRIBUTES_OFFSET(%di), %ax
-    push %di
-    mov $vga323 - vesa_init, %di
-    mov $0x100, %ecx
-    bt $5, %ax                          # Test if VGA compatible registers are present
-    jnc vga_compat
-        # Try VESA routine to set palette
-        mov $VESA_SET_PALETTE, %ax
-        xor %bl, %bl
-        xor %dx, %dx
-        int $0x10
-        jmp vga_not_compat
-    vga_compat:
-        # Try VGA registers to set palette
-        movw $0x3c6, %dx                        # Set palette mask
-        movb $0xff, %al
-        outb %al, %dx
-        movw $0x3c8, %dx                        # First index to set
-        xor %al, %al
-        outb %al, %dx
-        movw $0x3c9, %dx                        # Data port
-        vga_loop:
-            movb %es:2(%di), %al
-            outb %al, %dx
-            movb %es:1(%di), %al
-            outb %al, %dx
-            movb %es:(%di), %al
-            outb %al, %dx
-            addw $4, %di
-            loop vga_loop
-    vga_not_compat:
-    pop %di
-#endif
     mov VESA_MODE_PHADDR_OFFSET(%di), %esi
     mov VESA_MODE_WIDTH_OFFSET(%di), %ax
     shl $16, %eax
 ,10 → 427,8
     mov $0xffffffff, %edi       # EGA text mode used, because of problems with VESA
     xor %ax, %ax
     jz 8b                       # Force relative jump
-vga323:
-#include "vga323.pal"
 .code32
 vesa_init_protect:
     movw $gdtselector(KDATA_DES), %cx
 ,73 → 441,11
     movw %cx, %fs
     movw %cx, %gs
-    movl $START_STACK, %esp         # initialize stack pointer
     jmpl $gdtselector(KTEXT32_DES), $vesa_meeting_point
 .align 4
 e_vesa_init:
-#endif
-# Print string from %esi to EGA display (in red) and halt
-error_halt:
-    movl $0xb8000, %edi                     # base of EGA text mode memory
-    xorl %eax, %eax
-    movw $0x3d4, %dx                        # read bits 8 - 15 of the cursor address
-    movb $0xe, %al
-    outb %al, %dx
-    movw $0x3d5, %dx
-    inb %dx, %al
-    shl $8, %ax
-    movw $0x3d4, %dx                        # read bits 0 - 7 of the cursor address
-    movb $0xf, %al
-    outb %al, %dx
-    movw $0x3d5, %dx
-    inb %dx, %al
-    cmp $1920, %ax
-    jbe cursor_ok
-        movw $1920, %ax                     # sanity check for the cursor on the last line
-    cursor_ok:
-    movw %ax, %bx
-    shl $1, %eax
-    addl %eax, %edi
-    movw $0x0c00, %ax                       # black background, light red foreground
-    cld
-    ploop:
-        lodsb
-        cmp $0, %al
-        je ploop_end
-        stosw
-        inc %bx
-        jmp ploop
-    ploop_end:
-    movw $0x3d4, %dx                        # write bits 8 - 15 of the cursor address
-    movb $0xe, %al
-    outb %al, %dx
-    movw $0x3d5, %dx
-    movb %bh, %al
-    outb %al, %dx
-    movw $0x3d4, %dx                        # write bits 0 - 7 of the cursor address
-    movb $0xf, %al
-    outb %al, %dx
-    movw $0x3d5, %dx
-    movb %bl, %al
-    outb %al, %dx
-    cli
-    hlt
+#endif
 .section K_DATA_START, "aw", @progbits
 .align 4096
 ,6 → 513,3
 grub_ebx:
     .long 0
-long_mode_msg:
-    .asciz "64 bit long mode not supported. System halted."

/branches/rcu/kernel/arch/amd64/include/types.h
62,7 → 62,6
typedef int64_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/amd64/include/asm.h
 ,17 → 55,10
     return v;
 }
-static inline void cpu_sleep(void)
-{
-    asm volatile ("hlt\n");
-};
+static inline void cpu_sleep(void) { __asm__ volatile ("hlt\n"); };
+static inline void cpu_halt(void) { __asm__ volatile ("hlt\n"); };
-static inline void cpu_halt(void)
-{
-    asm volatile ("hlt\n");
-};
 /** Byte from port
  *
  * Get byte from port

 /branches/rcu/kernel/arch/ppc64/src/mm/page.c
 ,8 → 264,10
         uintptr_t cur;
         int flags;
+        /* Frames below 128 MB are mapped using BAT,
+           map rest of the physical memory */
         for (cur = 128 << 20; cur < last_frame; cur += FRAME_SIZE) {
-            flags = PAGE_CACHEABLE | PAGE_WRITE;
+            flags = PAGE_CACHEABLE;
             if ((PA2KA(cur) >= config.base) && (PA2KA(cur) < config.base + config.kernel_size))
                 flags |= PAGE_GLOBAL;
             page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
 ,7 → 296,7
     uintptr_t virtaddr = PA2KA(last_frame);
     pfn_t i;
     for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
-        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE | PAGE_WRITE);
+        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE);
     last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);

 /branches/rcu/kernel/arch/ppc64/src/interrupt.c
 ,19 → 60,11
     int inum;
     while ((inum = pic_get_pending()) != -1) {
-        bool ack = false;
         irq_t *irq = irq_dispatch_and_lock(inum);
         if (irq) {
             /*
              * The IRQ handler was found.
              */
-            if (irq->preack) {
-                /* Acknowledge the interrupt before processing */
-                pic_ack_interrupt(inum);
-                ack = true;
-            }
             irq->handler(irq, irq->arg);
             spinlock_unlock(&irq->lock);
         } else {
 ,9 → 75,7
             printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum);
 #endif
         }
-        if (!ack)
-            pic_ack_interrupt(inum);
+        pic_ack_interrupt(inum);
     }
 }

 /branches/rcu/kernel/arch/ppc64/src/ppc64.c
 ,7 → 128,6
 void arch_grab_console(void)
 {
 }
 /** Return console to userspace
  *
  */
 ,11 → 135,5
 {
 }
-void arch_reboot(void)
-{
-    // TODO
-    while (1);
-}
 /** @}
  */

/branches/rcu/kernel/arch/ppc64/include/types.h
62,7 → 62,6
typedef int64_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/mips32/src/mips32.c
 ,11 → 178,5
     return 0;
 }
-void arch_reboot(void)
-{
-    ___halt();
-    while (1);
-}
 /** @}
  */

/branches/rcu/kernel/arch/mips32/include/types.h
62,7 → 62,6
typedef int32_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/mips32/_link.ld.in
 ,7 → 10,7
 OUTPUT_ARCH(mips)
-ENTRY(kernel_image_start)
+ENTRY(kernel_image_start)
 SECTIONS {
     . = KERNEL_LOAD_ADDRESS;
 ,10 → 31,9
         *(.rodata*);
         *(.sdata);
         *(.reginfo);
-        *(.sbss);
-        *(.scommon);
-        *(.bss);        /* uninitialized static variables */
-        *(COMMON);      /* global variables */
+        /* Unfortunately IRIX does not allow us
+             * to include this as a last section :-(
+         * BSS/SBSS addresses will be wrong */
         symbol_table = .;
         *(symtab.*);
     }
 ,6 → 40,14
     _gp = . + 0x8000;
     .lit8 : { *(.lit8) }
     .lit4 : { *(.lit4) }
+    .sbss : {
+        *(.sbss);
+        *(.scommon);
+    }
+    .bss : {
+        *(.bss);        /* uninitialized static variables */
+        *(COMMON);      /* global variables */
+    }
     kdata_end = .;

 /branches/rcu/kernel/arch/ia32/src/smp/apic.c
 ,14 → 139,7
 static void l_apic_timer_irq_handler(irq_t *irq, void *arg, ...)
 {
-    /*
-     * Holding a spinlock could prevent clock() from preempting
-     * the current thread. In this case, we don't need to hold the
-     * irq->lock so we just unlock it and then lock it again.
-     */
-    spinlock_unlock(&irq->lock);
     clock();
-    spinlock_lock(&irq->lock);
 }
 /** Initialize APIC on BSP. */
 ,7 → 162,6
     io_apic_disable_irqs(0xffff);
     irq_initialize(&l_apic_timer_irq);
-    l_apic_timer_irq.preack = true;
     l_apic_timer_irq.devno = device_assign_devno();
     l_apic_timer_irq.inr = IRQ_CLK;
     l_apic_timer_irq.claim = l_apic_timer_claim;

 /branches/rcu/kernel/arch/ia32/src/smp/smp.c
 ,13 → 82,13
     if (config.cpu_count > 1) {
         page_mapping_insert(AS_KERNEL, l_apic_address, (uintptr_t) l_apic,
-                  PAGE_NOT_CACHEABLE | PAGE_WRITE);
+                  PAGE_NOT_CACHEABLE);
         page_mapping_insert(AS_KERNEL, io_apic_address, (uintptr_t) io_apic,
-                  PAGE_NOT_CACHEABLE | PAGE_WRITE);
+                  PAGE_NOT_CACHEABLE);
         l_apic = (uint32_t *) l_apic_address;
         io_apic = (uint32_t *) io_apic_address;
-    }
+        }
 }
 /*

 /branches/rcu/kernel/arch/ia32/src/interrupt.c
 ,21 → 176,14
     ASSERT(n >= IVT_IRQBASE);
     int inum = n - IVT_IRQBASE;
-    bool ack = false;
     ASSERT(inum < IRQ_COUNT);
     ASSERT((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
     irq_t *irq = irq_dispatch_and_lock(inum);
     if (irq) {
         /*
          * The IRQ handler was found.
          */
-        if (irq->preack) {
-            /* Send EOI before processing the interrupt */
-            trap_virtual_eoi();
-            ack = true;
-        }
         irq->handler(irq, irq->arg);
         spinlock_unlock(&irq->lock);
     } else {
 ,9 → 194,7
         printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, inum);
 #endif
     }
-    if (!ack)
-        trap_virtual_eoi();
+    trap_virtual_eoi();
 }
 void interrupt_init(void)

/branches/rcu/kernel/arch/ia32/src/drivers/i8254.c
82,7 → 82,6
void i8254_init(void)
{
irq_initialize(&i8254_irq);
i8254_irq.preack = true;
i8254_irq.devno = device_assign_devno();
i8254_irq.inr = IRQ_CLK;
i8254_irq.claim = i8254_claim;

 /branches/rcu/kernel/arch/ia32/src/mm/page.c
 ,7 → 61,7
          * PA2KA(identity) mapping for all frames until last_frame.
          */
         for (cur = 0; cur < last_frame; cur += FRAME_SIZE) {
-            flags = PAGE_CACHEABLE | PAGE_WRITE;
+            flags = PAGE_CACHEABLE;
             if ((PA2KA(cur) >= config.base) && (PA2KA(cur) < config.base + config.kernel_size))
                 flags |= PAGE_GLOBAL;
             page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
 ,8 → 69,10
         exc_register(14, "page_fault", (iroutine) page_fault);
         write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
-    } else
+    }
+    else {
         write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
+    }
     paging_on();
 }
 ,7 → 86,7
     uintptr_t virtaddr = PA2KA(last_frame);
     pfn_t i;
     for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
-        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE | PAGE_WRITE);
+        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE);
     last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);
 ,12 → 95,12
 void page_fault(int n, istate_t *istate)
 {
-    uintptr_t page;
+        uintptr_t page;
     pf_access_t access;
-    page = read_cr2();
+        page = read_cr2();
-    if (istate->error_word & PFERR_CODE_RSVD)
+        if (istate->error_word & PFERR_CODE_RSVD)
         panic("Reserved bit set in page directory.\n");
     if (istate->error_word & PFERR_CODE_RW)
 ,14 → 107,14
         access = PF_ACCESS_WRITE;
     else
         access = PF_ACCESS_READ;
-    if (as_page_fault(page, access, istate) == AS_PF_FAULT) {
+        if (as_page_fault(page, access, istate) == AS_PF_FAULT) {
         fault_if_from_uspace(istate, "Page fault: %#x", page);
-        decode_istate(istate);
-        printf("page fault address: %#x\n", page);
-        panic("page fault\n");
-    }
+                decode_istate(istate);
+                printf("page fault address: %#x\n", page);
+                panic("page fault\n");
+        }
 }
 /** @}

 /branches/rcu/kernel/arch/ia32/src/pm.c
 ,7 → 121,7
 void idt_init(void)
 {
     idescriptor_t *d;
-    unsigned int i;
+    int i;
     for (i = 0; i < IDT_ITEMS; i++) {
         d = &idt[i];
 ,28 → 230,5
     gdtr_load(&cpugdtr);
 }
-/* Reboot the machine by initiating
- * a triple fault
- */
-void arch_reboot(void)
-{
-    preemption_disable();
-    ipl_t ipl = interrupts_disable();
-    memsetb((uintptr_t) idt, sizeof(idt), 0);
-    ptr_16_32_t idtr;
-    idtr.limit = sizeof(idt);
-    idtr.base = (uintptr_t) idt;
-    idtr_load(&idtr);
-    interrupts_restore(ipl);
-    asm volatile (
-        "int $0x03\n"
-        "cli\n"
-        "hlt\n"
-    );
-}
 /** @}
  */

 /branches/rcu/kernel/arch/ia32/src/boot/boot.S
 ,24 → 63,9
     jmpl $selector(KTEXT_DES), $multiboot_meeting_point
     multiboot_meeting_point:
-    movl %eax, grub_eax                 # save parameters from GRUB
-    movl %ebx, grub_ebx
+    pushl %ebx                          # save parameters from GRUB
+    pushl %eax
-    xorl %eax, %eax
-    cpuid
-    cmp $0x0, %eax                      # any function > 0?
-    jbe pse_unsupported
-    movl $0x1, %eax                     # Basic function code 1
-    cpuid
-    bt $3, %edx                         # Test if PSE is supported
-    jc pse_supported
-    pse_unsupported:
-        movl $pse_msg, %esi
-        jmp error_halt
-    pse_supported:
 #ifdef CONFIG_FB
     mov $vesa_init, %esi
     mov $VESA_INIT_SEGMENT << 4, %edi
 ,8 → 89,8
     call map_kernel                         # map kernel and turn paging on
-    movl grub_eax, %eax
-    movl grub_ebx, %ebx
+    popl %eax
+    popl %ebx
     cmpl $MULTIBOOT_LOADER_MAGIC, %eax              # compare GRUB signature
     je valid_boot
 ,7 → 209,7
     rep movsb
 #endif
     call main_bsp                               # never returns
     cli
 ,20 → 222,19
     # For simplicity, we map the entire 4G space.
     #
     movl %cr4, %ecx
-    orl $(1 << 4), %ecx                         # turn PSE on
-    andl $(~(1 << 5)), %ecx                     # turn PAE off
-    movl %ecx, %cr4
+    orl $(1<<4), %ecx
+    movl %ecx, %cr4                         # turn PSE on
-    movl $(page_directory + 0), %esi
-    movl $(page_directory + 2048), %edi
+    movl $(page_directory+0), %esi
+    movl $(page_directory+2048), %edi
     xorl %ecx, %ecx
     xorl %ebx, %ebx
 :
-    movl $((1 << 7) | (1 << 1) | (1 << 0)), %eax
+    movl $((1<<7)|(1<<0)), %eax
     orl %ebx, %eax
-    movl %eax, (%esi, %ecx, 4)                  # mapping 0x00000000 + %ecx * 4M => 0x00000000 + %ecx * 4M
-    movl %eax, (%edi, %ecx, 4)                  # mapping 0x80000000 + %ecx * 4M => 0x00000000 + %ecx * 4M
-    addl $(4 * 1024 * 1024), %ebx
+    movl %eax, (%esi,%ecx,4)                    # mapping 0x00000000+%ecx*4M => 0x00000000+%ecx*4M
+    movl %eax, (%edi,%ecx,4)                    # mapping 0x80000000+%ecx*4M => 0x00000000+%ecx*4M
+    addl $(4*1024*1024), %ebx
     incl %ecx
     cmpl $512, %ecx
 ,71 → 242,12
     movl %esi, %cr3
+    # turn paging on
     movl %cr0, %ebx
-    orl $(1 << 31), %ebx                        # turn paging on
+    orl $(1<<31), %ebx
     movl %ebx, %cr0
     ret
-# Print string from %esi to EGA display (in red) and halt
-error_halt:
-    movl $0xb8000, %edi                     # base of EGA text mode memory
-    xorl %eax, %eax
-    movw $0x3d4, %dx                        # read bits 8 - 15 of the cursor address
-    movb $0xe, %al
-    outb %al, %dx
-    movw $0x3d5, %dx
-    inb %dx, %al
-    shl $8, %ax
-    movw $0x3d4, %dx                        # read bits 0 - 7 of the cursor address
-    movb $0xf, %al
-    outb %al, %dx
-    movw $0x3d5, %dx
-    inb %dx, %al
-    cmp $1920, %ax
-    jbe cursor_ok
-        movw $1920, %ax                     # sanity check for the cursor on the last line
-    cursor_ok:
-    movw %ax, %bx
-    shl $1, %eax
-    addl %eax, %edi
-    movw $0x0c00, %ax                       # black background, light red foreground
-    cld
-    ploop:
-        lodsb
-        cmp $0, %al
-        je ploop_end
-        stosw
-        inc %bx
-        jmp ploop
-    ploop_end:
-    movw $0x3d4, %dx                        # write bits 8 - 15 of the cursor address
-    movb $0xe, %al
-    outb %al, %dx
-    movw $0x3d5, %dx
-    movb %bh, %al
-    outb %al, %dx
-    movw $0x3d4, %dx                        # write bits 0 - 7 of the cursor address
-    movb $0xf, %al
-    outb %al, %dx
-    movw $0x3d5, %dx
-    movb %bl, %al
-    outb %al, %dx
-    cli
-    hlt
 #ifdef CONFIG_FB
 vesa_init:
     jmp $selector(VESA_INIT_DES), $vesa_init_real - vesa_init
 ,12 → 278,11
 #define VESA_INFO_SIZE 1024
-#define VESA_MODE_ATTRIBUTES_OFFSET 0
 #define VESA_MODE_LIST_PTR_OFFSET 14
-#define VESA_MODE_SCANLINE_OFFSET 16
 #define VESA_MODE_WIDTH_OFFSET 18
 #define VESA_MODE_HEIGHT_OFFSET 20
 #define VESA_MODE_BPP_OFFSET 25
+#define VESA_MODE_SCANLINE_OFFSET 16
 #define VESA_MODE_PHADDR_OFFSET 40
 #define VESA_END_OF_MODES 0xffff
 ,10 → 292,12
 #define VESA_GET_INFO 0x4f00
 #define VESA_GET_MODE_INFO 0x4f01
 #define VESA_SET_MODE 0x4f02
-#define VESA_SET_PALETTE 0x4f09
+#define CONFIG_VESA_BPP_a 255
 #if CONFIG_VESA_BPP == 24
-#define CONFIG_VESA_BPP_VARIANT 32
+#undef CONFIG_VESA_BPP_a
+#define CONFIG_VESA_BPP_a 32
 #endif
     mov $VESA_GET_INFO, %ax
 ,21 → 338,18
     cmp VESA_MODE_WIDTH_OFFSET(%di), %ax
     jnz 1b
-    mov $CONFIG_VESA_HEIGHT, %ax
+    mov $CONFIG_VESA_HEIGHT,%ax
     cmp VESA_MODE_HEIGHT_OFFSET(%di), %ax
     jnz 1b
     mov $CONFIG_VESA_BPP, %al
     cmp VESA_MODE_BPP_OFFSET(%di), %al
-#ifdef CONFIG_VESA_BPP_VARIANT
     jz 2f
-    mov $CONFIG_VESA_BPP_VARIANT, %al
+    mov $CONFIG_VESA_BPP_a, %al
     cmp VESA_MODE_BPP_OFFSET(%di), %al
-#endif
     jnz 1b
 :
     mov %cx, %bx
 ,60 → 361,7
     pop %di
     cmp $VESA_OK, %al
     jnz 0f
-#if CONFIG_VESA_BPP == 8
-    # Set 3:2:3 VGA palette
-    mov VESA_MODE_ATTRIBUTES_OFFSET(%di), %ax
-    push %di
-    mov $vga323 - vesa_init, %di
-    mov $0x100, %ecx
-    bt $5, %ax                          # Test if VGA compatible registers are present
-    jnc vga_compat
-        # Try VESA routine to set palette
-        mov $VESA_SET_PALETTE, %ax
-        xor %bl, %bl
-        xor %dx, %dx
-        int $0x10
-        jmp vga_not_compat
-    vga_compat:
-        # Try VGA registers to set palette
-        movw $0x3c6, %dx                        # Set palette mask
-        movb $0xff, %al
-        outb %al, %dx
-        movw $0x3c8, %dx                        # First index to set
-        xor %al, %al
-        outb %al, %dx
-        movw $0x3c9, %dx                        # Data port
-        vga_loop:
-            movb %es:2(%di), %al
-            outb %al, %dx
-            movb %es:1(%di), %al
-            outb %al, %dx
-            movb %es:(%di), %al
-            outb %al, %dx
-            addw $4, %di
-            loop vga_loop
-    vga_not_compat:
-    pop %di
-#endif
     mov VESA_MODE_PHADDR_OFFSET(%di), %esi
     mov VESA_MODE_WIDTH_OFFSET(%di), %ax
     shl $16, %eax
 ,12 → 402,12
     mov $0xffffffff, %edi       # EGA text mode used, because of problems with VESA
     xor %ax, %ax
     jz 8b                       # Force relative jump
-vga323:
-#include "vga323.pal"
 .code32
 vesa_init_protect:
+    popl %esp
     movw $selector(KDATA_DES), %cx
     movw %cx, %es
     movw %cx, %fs
 ,8 → 415,6
     movw %cx, %ds                   # kernel data + stack
     movw %cx, %ss
-    movl $START_STACK, %esp         # initialize stack pointer
     jmpl $selector(KTEXT_DES), $vesa_meeting_point
 .align 4
 ,12 → 426,3
 .align 4096
 page_directory:
     .space 4096, 0
-grub_eax:
-    .long 0
-grub_ebx:
-    .long 0
-pse_msg:
-    .asciz "Page Size Extension not supported. System halted."

/branches/rcu/kernel/arch/ia32/include/types.h
62,7 → 62,6
typedef int32_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/ia32/include/asm.h
 ,12 → 59,12
  */
 static inline void cpu_halt(void)
 {
-    asm volatile ("hlt\n");
+    asm("hlt\n");
 };
 static inline void cpu_sleep(void)
 {
-    asm volatile ("hlt\n");
+    asm("hlt\n");
 };
 #define GEN_READ_REG(reg) static inline unative_t read_ ##reg (void) \

/branches/rcu/kernel/arch/arm32/include/types.h
62,7 → 62,6
typedef int32_t native_t;

typedef uint8_t bool;
typedef uint64_t thread_id_t;
typedef uint64_t task_id_t;
typedef uint32_t context_id_t;

 /branches/rcu/kernel/arch/arm32/src/arm32.c
 ,11 → 82,5
     /* TODO */
 }
-void arch_reboot(void)
-{
-    // TODO
-    while (1);
-}
 /** @}
  */

 /branches/rcu/kernel/test/tasklet/tasklet1.c
 ,7 → 43,6
 }
 bool gquiet;
-#ifdef CONFIG_SMP
 static void running_tasklet(void * data)
 {
 ,7 → 102,7
     if (!gquiet)
         printf("Done!\n");
 }
-#endif
 char * test_tasklet1(bool quiet)
 {
     gquiet = quiet;
 ,8 → 109,8
     waitq_t wq;
     waitq_initialize(&wq);
     tasklet_descriptor_t *tasklet_desc;
+    thread_t* second_thread = NULL;
 #ifdef CONFIG_SMP
-    thread_t* second_thread = NULL;
     if (!quiet)
         printf("cpus:%d\n", config.cpu_active);

 /branches/rcu/kernel/test/synch/rwlock3.c
 ,14 → 45,14
     thread_detach(THREAD);
     if (!sh_quiet)
-        printf("cpu%d, tid %llu: trying to lock rwlock for reading....\n", CPU->id, THREAD->tid);
+        printf("cpu%d, tid %d: trying to lock rwlock for reading....\n", CPU->id, THREAD->tid);
     rwlock_read_lock(&rwlock);
     rwlock_read_unlock(&rwlock);
     if (!sh_quiet) {
-        printf("cpu%d, tid %llu: success\n", CPU->id, THREAD->tid);
-        printf("cpu%d, tid %llu: trying to lock rwlock for writing....\n", CPU->id, THREAD->tid);
+        printf("cpu%d, tid %d: success\n", CPU->id, THREAD->tid);
+        printf("cpu%d, tid %d: trying to lock rwlock for writing....\n", CPU->id, THREAD->tid);
     }
     rwlock_write_lock(&rwlock);
 ,7 → 59,7
     rwlock_write_unlock(&rwlock);
     if (!sh_quiet)
-        printf("cpu%d, tid %llu: success\n", CPU->id, THREAD->tid);
+        printf("cpu%d, tid %d: success\n", CPU->id, THREAD->tid);
     atomic_dec(&thread_count);
 }

 /branches/rcu/kernel/test/synch/rwlock4.c
 ,18 → 74,18
     to = random(40000);
     if (!sh_quiet)
-        printf("cpu%d, tid %llu w+ (%d)\n", CPU->id, THREAD->tid, to);
+        printf("cpu%d, tid %d w+ (%d)\n", CPU->id, THREAD->tid, to);
     rc = rwlock_write_lock_timeout(&rwlock, to);
     if (SYNCH_FAILED(rc)) {
         if (!sh_quiet)
-            printf("cpu%d, tid %llu w!\n", CPU->id, THREAD->tid);
+            printf("cpu%d, tid %d w!\n", CPU->id, THREAD->tid);
         atomic_dec(&thread_count);
         return;
     }
     if (!sh_quiet)
-        printf("cpu%d, tid %llu w=\n", CPU->id, THREAD->tid);
+        printf("cpu%d, tid %d w=\n", CPU->id, THREAD->tid);
     if (rwlock.readers_in) {
         if (!sh_quiet)
 ,7 → 106,7
     rwlock_write_unlock(&rwlock);
     if (!sh_quiet)
-        printf("cpu%d, tid %llu w-\n", CPU->id, THREAD->tid);
+        printf("cpu%d, tid %d w-\n", CPU->id, THREAD->tid);
     atomic_dec(&thread_count);
 }
 ,24 → 119,24
     to = random(2000);
     if (!sh_quiet)
-        printf("cpu%d, tid %llu r+ (%d)\n", CPU->id, THREAD->tid, to);
+        printf("cpu%d, tid %d r+ (%d)\n", CPU->id, THREAD->tid, to);
     rc = rwlock_read_lock_timeout(&rwlock, to);
     if (SYNCH_FAILED(rc)) {
         if (!sh_quiet)
-            printf("cpu%d, tid %llu r!\n", CPU->id, THREAD->tid);
+            printf("cpu%d, tid %d r!\n", CPU->id, THREAD->tid);
         atomic_dec(&thread_count);
         return;
     }
     if (!sh_quiet)
-        printf("cpu%d, tid %llu r=\n", CPU->id, THREAD->tid);
+        printf("cpu%d, tid %d r=\n", CPU->id, THREAD->tid);
     thread_usleep(30000);
     rwlock_read_unlock(&rwlock);
     if (!sh_quiet)
-        printf("cpu%d, tid %llu r-\n", CPU->id, THREAD->tid);
+        printf("cpu%d, tid %d r-\n", CPU->id, THREAD->tid);
     atomic_dec(&thread_count);
 }

 /branches/rcu/kernel/test/synch/semaphore2.c
 ,18 → 67,18
     waitq_sleep(&can_start);
     to = random(20000);
-    printf("cpu%d, tid %llu down+ (%d)\n", CPU->id, THREAD->tid, to);
+    printf("cpu%d, tid %d down+ (%d)\n", CPU->id, THREAD->tid, to);
     rc = semaphore_down_timeout(&sem, to);
     if (SYNCH_FAILED(rc)) {
-        printf("cpu%d, tid %llu down!\n", CPU->id, THREAD->tid);
+        printf("cpu%d, tid %d down!\n", CPU->id, THREAD->tid);
         return;
     }
-    printf("cpu%d, tid %llu down=\n", CPU->id, THREAD->tid);
+    printf("cpu%d, tid %d down=\n", CPU->id, THREAD->tid);
     thread_usleep(random(30000));
     semaphore_up(&sem);
-    printf("cpu%d, tid %llu up\n", CPU->id, THREAD->tid);
+    printf("cpu%d, tid %d up\n", CPU->id, THREAD->tid);
 }
 char * test_semaphore2(bool quiet)

 /branches/rcu/kernel/test/thread/thread1.c
 ,8 → 48,8
     while (atomic_get(&finish)) {
         if (!sh_quiet)
-            printf("%llu ", THREAD->tid);
-        thread_usleep(100000);
+            printf("%d\n", (int) (THREAD->tid));
+        thread_usleep(100);
     }
     atomic_inc(&threads_finished);
 }

 /branches/rcu/kernel/test/mm/falloc2.c
 ,7 → 58,7
     uintptr_t * frames =  (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC);
     if (frames == NULL) {
         if (!sh_quiet)
-            printf("Thread #%llu (cpu%d): Unable to allocate frames\n", THREAD->tid, CPU->id);
+            printf("Thread #%d (cpu%d): Unable to allocate frames\n", THREAD->tid, CPU->id);
         atomic_inc(&thread_fail);
         atomic_dec(&thread_count);
         return;
 ,7 → 69,7
     for (run = 0; run < THREAD_RUNS; run++) {
         for (order = 0; order <= MAX_ORDER; order++) {
             if (!sh_quiet)
-                printf("Thread #%llu (cpu%d): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
+                printf("Thread #%d (cpu%d): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
             allocated = 0;
             for (i = 0; i < (MAX_FRAMES >> order); i++) {
 ,16 → 82,16
             }
             if (!sh_quiet)
-                printf("Thread #%llu (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
+                printf("Thread #%d (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
             if (!sh_quiet)
-                printf("Thread #%llu (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
+                printf("Thread #%d (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
             for (i = 0; i < allocated; i++) {
                 for (k = 0; k <= ((FRAME_SIZE << order) - 1); k++) {
                     if (((uint8_t *) frames[i])[k] != val) {
                         if (!sh_quiet)
-                            printf("Thread #%llu (cpu%d): Unexpected data (%d) in block %p offset %#zx\n", THREAD->tid, CPU->id, ((char *) frames[i])[k], frames[i], k);
+                            printf("Thread #%d (cpu%d): Unexpected data (%d) in block %p offset %#zx\n", THREAD->tid, CPU->id, ((char *) frames[i])[k], frames[i], k);
                         atomic_inc(&thread_fail);
                         goto cleanup;
                     }
 ,7 → 100,7
             }
             if (!sh_quiet)
-                printf("Thread #%llu (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
+                printf("Thread #%d (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
         }
     }
 ,7 → 108,7
     free(frames);
     if (!sh_quiet)
-        printf("Thread #%llu (cpu%d): Exiting\n", THREAD->tid, CPU->id);
+        printf("Thread #%d (cpu%d): Exiting\n", THREAD->tid, CPU->id);
     atomic_dec(&thread_count);
 }

 /branches/rcu/kernel/test/mm/slab1.c
 ,7 → 137,7
     thread_detach(THREAD);
     if (!sh_quiet)
-        printf("Starting thread #%llu...\n", THREAD->tid);
+        printf("Starting thread #%d...\n", THREAD->tid);
     for (j = 0; j < 10; j++) {
         for (i = 0; i < THR_MEM_COUNT; i++)
 ,7 → 151,7
     }
     if (!sh_quiet)
-        printf("Thread #%llu finished\n", THREAD->tid);
+        printf("Thread #%d finished\n", THREAD->tid);
     semaphore_up(&thr_sem);
 }

 /branches/rcu/kernel/test/mm/slab2.c
 ,11 → 150,11
     mutex_unlock(&starter_mutex);
     if (!sh_quiet)
-        printf("Starting thread #%llu...\n",THREAD->tid);
+        printf("Starting thread #%d...\n",THREAD->tid);
     /* Alloc all */
     if (!sh_quiet)
-        printf("Thread #%llu allocating...\n", THREAD->tid);
+        printf("Thread #%d allocating...\n", THREAD->tid);
     while (1) {
         /* Call with atomic to detect end of memory */
 ,7 → 166,7
     }
     if (!sh_quiet)
-        printf("Thread #%llu releasing...\n", THREAD->tid);
+        printf("Thread #%d releasing...\n", THREAD->tid);
     while (data) {
         new = *((void **)data);
 ,7 → 176,7
     }
     if (!sh_quiet)
-        printf("Thread #%llu allocating...\n", THREAD->tid);
+        printf("Thread #%d allocating...\n", THREAD->tid);
     while (1) {
         /* Call with atomic to detect end of memory */
 ,7 → 188,7
     }
     if (!sh_quiet)
-        printf("Thread #%llu releasing...\n", THREAD->tid);
+        printf("Thread #%d releasing...\n", THREAD->tid);
     while (data) {
         new = *((void **)data);
 ,7 → 198,7
     }
     if (!sh_quiet)
-        printf("Thread #%llu finished\n", THREAD->tid);
+        printf("Thread #%d finished\n", THREAD->tid);
     slab_print_list();
     semaphore_up(&thr_sem);

 /branches/rcu/kernel/test/fpu/mips2.c
 ,7 → 72,7
         if (arg != after_arg) {
             if (!sh_quiet)
-                printf("General reg tid%llu: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
+                printf("General reg tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
             atomic_inc(&threads_fault);
             break;
         }
 ,7 → 104,7
         if (arg != after_arg) {
             if (!sh_quiet)
-                printf("General reg tid%llu: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
+                printf("General reg tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
             atomic_inc(&threads_fault);
             break;
         }

 /branches/rcu/kernel/test/fpu/fpu1.c
 ,7 → 126,7
         if ((int) (100000000 * e) != E_10e8) {
             if (!sh_quiet)
-                printf("tid%llu: e*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (100000000 * e), (unative_t) E_10e8);
+                printf("tid%d: e*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (100000000 * e), (unative_t) E_10e8);
             atomic_inc(&threads_fault);
             break;
         }
 ,7 → 161,7
 #ifdef KERN_ia64_ARCH_H_
         if ((int) (1000000 * pi) != PI_10e8) {
             if (!sh_quiet)
-                printf("tid%llu: pi*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (1000000 * pi), (unative_t) (PI_10e8 / 100));
+                printf("tid%d: pi*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (1000000 * pi), (unative_t) (PI_10e8 / 100));
             atomic_inc(&threads_fault);
             break;
         }
 ,7 → 168,7
 #else
         if ((int) (100000000 * pi) != PI_10e8) {
             if (!sh_quiet)
-                printf("tid%llu: pi*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (100000000 * pi), (unative_t) PI_10e8);
+                printf("tid%d: pi*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (100000000 * pi), (unative_t) PI_10e8);
             atomic_inc(&threads_fault);
             break;
         }

 /branches/rcu/kernel/test/fpu/sse1.c
 ,7 → 72,7
         if (arg != after_arg) {
             if (!sh_quiet)
-                printf("tid%llu: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
+                printf("tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
             atomic_inc(&threads_fault);
             break;
         }
 ,7 → 104,7
         if (arg != after_arg) {
             if (!sh_quiet)
-                printf("tid%llu: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
+                printf("tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
             atomic_inc(&threads_fault);
             break;
         }

/branches/rcu/kernel/test/print/print1.c
25,7 → 25,6
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <print.h>
#include <test.h>

 /branches/rcu/kernel/genarch/src/acpi/acpi.c
 ,7 → 88,7
 static void map_sdt(struct acpi_sdt_header *sdt)
 {
-    page_mapping_insert(AS_KERNEL, (uintptr_t) sdt, (uintptr_t) sdt, PAGE_NOT_CACHEABLE | PAGE_WRITE);
+    page_mapping_insert(AS_KERNEL, (uintptr_t) sdt, (uintptr_t) sdt, PAGE_NOT_CACHEABLE);
     map_structure((uintptr_t) sdt, sdt->length);
 }

 /branches/rcu/kernel/Makefile
 ,7 → 156,6
     generic/src/main/kinit.c \
     generic/src/main/uinit.c \
     generic/src/main/version.c \
-    generic/src/main/shutdown.c \
     generic/src/proc/scheduler.c \
     generic/src/proc/thread.c \
     generic/src/proc/task.c \
 ,7 → 227,6
         test/mm/slab1.c \
         test/mm/slab2.c \
         test/mm/purge1.c \
-        test/synch/rcu1.c \
         test/synch/rwlock1.c \
         test/synch/rwlock2.c \
         test/synch/rwlock3.c \
 ,9 → 235,9
         test/synch/semaphore1.c \
         test/synch/semaphore2.c \
         test/print/print1.c \
-        test/tasklet/tasklet1.c \
         test/thread/thread1.c \
-        test/sysinfo/sysinfo1.c
+        test/sysinfo/sysinfo1.c \
+        test/tasklet/tasklet1.c
 endif
 ## Experimental features

 /branches/rcu/kernel/kernel.config
 ,6 → 92,9
 # Lazy FPU context switching
 ! [(ARCH=mips32&MACHINE!=msim&MACHINE!=simics)|ARCH=amd64|ARCH=ia32|ARCH=ia64|ARCH=sparc64|ARCH=ia32xen] CONFIG_FPU_LAZY (y/n)
+# Power off on halt
+! [ARCH=ppc32] CONFIG_POWEROFF (n/y)
 # Use VHPT
 ! [ARCH=ia64] CONFIG_VHPT (n/y)

 /branches/rcu/contrib/conf/msim.conf
 ,7 → 5,7
 add dcpu mips1
 add rwm mainmem     0x0         8M      load    "/dev/zero"
-add rom startmem    0x1fc00000  2048k   load    "image.boot"
+add rom startmem    0x1fc00000  1024k   load    "image.boot"
 add dprinter printer 0x10000000
 add dkeyboard keyboard 0x10000000 2

/branches/rcu/contrib/conf/ski.conf
6,6 → 6,6
romload HelenOS/uspace/kbd/kbd 0x1400000
romload HelenOS/uspace/tetris/tetris 0x1800000
romload HelenOS/uspace/klog/klog 0x1c00000
romload HelenOS/uspace/tester/tester 0x2000000
romload HelenOS/uspace/ipcc/ipcc 0x2000000

 /branches/rcu/uspace/fb/fb.c
 ,27 → 833,23
 copy_vp_to_pixmap(viewport_t *vport, pixmap_t *pmap)
 {
     int y;
-    int tmp, srcrowsize;
-    int realwidth, realheight, realrowsize;
+    int rowsize;
+    int tmp;
     int width = vport->width;
     int height = vport->height;
     if (width + vport->x > screen.xres)
         width = screen.xres - vport->x;
-    if (height + vport->y > screen.yres)
+    if (height + vport->y  > screen.yres)
         height = screen.yres - vport->y;
-    realwidth = pmap->width <= width ? pmap->width : width;
-    realheight = pmap->height <= height ? pmap->height : height;
-    srcrowsize = vport->width * screen.pixelbytes;
-    realrowsize = realwidth * screen.pixelbytes;
-    for (y = 0; y < realheight; y++) {
+    rowsize = width * screen.pixelbytes;
+    for (y = 0; y < height; y++) {
         tmp = (vport->y + y) * screen.scanline +
             vport->x * screen.pixelbytes;
-        memcpy(pmap->data + srcrowsize * y, screen.fbaddress + tmp,
-            realrowsize);
+        memcpy(pmap->data + rowsize * y, screen.fbaddress + tmp,
+            rowsize);
     }
 }

 /branches/rcu/uspace/libc/include/async.h
 ,13 → 116,12
 void async_msg_3(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2,
          ipcarg_t arg3);
 void async_msg_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2);
-#define async_msg(ph, m, a1) async_msg_2(ph, m, a1, 0)
+#define async_msg(ph,m,a1) async_msg_2(ph,m,a1,0)
 static inline void async_serialize_start(void)
 {
     psthread_inc_sercount();
 }
 static inline void async_serialize_end(void)
 {
     psthread_dec_sercount();

 /branches/rcu/uspace/libc/include/unistd.h
 ,9 → 44,8
 extern ssize_t write(int fd, const void * buf, size_t count);
 extern ssize_t read(int fd, void * buf, size_t count);
 extern void _exit(int status);
-extern void *sbrk(ssize_t incr);
-extern void usleep(unsigned long usec);
-extern unsigned int sleep(unsigned int seconds);
+void *sbrk(ssize_t incr);
+void usleep(unsigned long usec);
 #endif

 /branches/rcu/uspace/libc/include/thread.h
 ,16 → 39,11
 #include <libarch/thread.h>
 #include <types.h>
-typedef uint64_t thread_id_t;
 extern void __thread_entry(void);
 extern void __thread_main(uspace_arg_t *uarg);
-extern int thread_create(void (* function)(void *), void *arg, char *name, thread_id_t *tid);
+extern int thread_create(void (* function)(void *arg), void *arg, char *name);
 extern void thread_exit(int status);
-extern void thread_detach(thread_id_t thread);
-extern int thread_join(thread_id_t thread);
-extern thread_id_t thread_get_id(void);
 extern tcb_t * __make_tls(void);
 extern tcb_t * __alloc_tls(void **data, size_t size);
 extern void __free_tls(tcb_t *);

 /branches/rcu/uspace/libc/generic/time.c
 ,31 → 108,14
     return 0;
 }
-/** Wait unconditionally for specified number of microseconds */
+/** Wait unconditionally for specified microseconds */
 void usleep(unsigned long usec)
 {
     atomic_t futex = FUTEX_INITIALIZER;
-    futex_initialize(&futex, 0);
+    futex_initialize(&futex,0);
     futex_down_timeout(&futex, usec, 0);
 }
-/** Wait unconditionally for specified number of seconds */
-unsigned int sleep(unsigned int seconds)
-{
-    atomic_t futex = FUTEX_INITIALIZER;
-    futex_initialize(&futex, 0);
-    /* Sleep in 1000 second steps to support
-       full argument range */
-    while (seconds > 0) {
-        unsigned int period = (seconds > 1000) ? 1000 : seconds;
-        futex_down_timeout(&futex, period * 1000000, 0);
-        seconds -= period;
-    }
-}
 /** @}
  */

 /branches/rcu/uspace/libc/generic/thread.c
 ,11 → 124,10
  * @param function Function implementing the thread.
  * @param arg Argument to be passed to thread.
  * @param name Symbolic name of the thread.
- * @param tid Thread ID of the newly created thread.
  *
- * @return Zero on success or a code from @ref errno.h on failure.
+ * @return TID of the new thread on success or -1 on failure.
  */
-int thread_create(void (* function)(void *), void *arg, char *name, thread_id_t *tid)
+int thread_create(void (* function)(void *), void *arg, char *name)
 {
     char *stack;
     uspace_arg_t *uarg;
 ,7 → 148,7
     uarg->uspace_thread_arg = arg;
     uarg->uspace_uarg = uarg;
-    return __SYSCALL3(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name, (sysarg_t) tid);
+    return __SYSCALL2(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name);
 }
 /** Terminate current thread.
 ,40 → 160,5
     __SYSCALL1(SYS_THREAD_EXIT, (sysarg_t) status);
 }
-/** Detach thread.
- *
- * Currently not implemented.
- *
- * @param thread TID.
- */
-void thread_detach(thread_id_t thread)
-{
-}
-/** Join thread.
- *
- * Currently not implemented.
- *
- * @param thread TID.
- *
- * @return Thread exit status.
- */
-int thread_join(thread_id_t thread)
-{
-}
-/** Get current thread ID.
- *
- * @return Current thread ID.
- */
-thread_id_t thread_get_id(void)
-{
-    thread_id_t thread_id;
-    (void) __SYSCALL1(SYS_THREAD_GET_ID, (sysarg_t) &thread_id);
-    return thread_id;
-}
 /** @}
  */

 /branches/rcu/uspace/libc/generic/io/io.c
 ,17 → 37,18
 #include <stdio.h>
 #include <io/io.h>
-const static char nl = '\n';
+static char nl = '\n';
-int puts(const char *str)
+int puts(const char * str)
 {
     size_t count;
-    if (str == NULL)
-        return putnchars("(NULL)", 6);
+    if (str == NULL) {
+        return putnchars("(NULL)",6 );
+    }
     for (count = 0; str[count] != 0; count++);
-    if (write(1, (void *) str, count) == count) {
+    if (write(1, (void * ) str, count) == count) {
         if (write(1, &nl, 1) == 1)
             return 0;
     }
 ,10 → 61,11
  * @param count
  * @return 0 on succes, EOF on fail
  */
-int putnchars(const char *buf, size_t count)
+int putnchars(const char * buf, size_t count)
 {
-    if (write(1, (void *) buf, count) == count)
+    if (write(1, (void * ) buf, count) == count) {
             return 0;
+    }
     return EOF;
 }
 ,16 → 73,18
 /** Same as puts, but does not print newline at end
  *
  */
-int putstr(const char *str)
+int putstr(const char * str)
 {
     size_t count;
-    if (str == NULL)
-        return putnchars("(NULL)", 6);
+    if (str == NULL) {
+        return putnchars("(NULL)",6 );
+    }
     for (count = 0; str[count] != 0; count++);
-    if (write(1, (void *) str, count) == count)
+    if (write(1, (void * ) str, count) == count) {
             return 0;
+    }
     return EOF;
 }
 ,8 → 92,9
 int putchar(int c)
 {
     unsigned char ch = c;
-    if (write(1, (void *) &ch, 1) == 1)
+    if (write(1, (void *)&ch , 1) == 1) {
             return c;
+    }
     return EOF;
 }
 ,8 → 102,9
 int getchar(void)
 {
     unsigned char c;
-    if (read(0, (void *) &c, 1) == 1)
+    if (read(0, (void *)&c , 1) == 1) {
             return c;
+    }
     return EOF;
 }

 /branches/rcu/uspace/libc/generic/io/vprintf.c
 ,12 → 36,10
 #include <stdio.h>
 #include <unistd.h>
 #include <io/printf_core.h>
-#include <futex.h>
-#include <async.h>
-static atomic_t printf_futex = FUTEX_INITIALIZER;
+int vprintf_write(const char *str, size_t count, void *unused);
-static int vprintf_write(const char *str, size_t count, void *unused)
+int vprintf_write(const char *str, size_t count, void *unused)
 {
     return write(1, str, count);
 }
 ,23 → 51,9
  */
 int vprintf(const char *fmt, va_list ap)
 {
-    struct printf_spec ps = {
-        (int (*)(void *, size_t, void *)) vprintf_write,
-         NULL
-    };
-    /*
-     * Prevent other threads to execute printf_core()
-     */
-    futex_down(&printf_futex);
-    /*
-     * Prevent other pseudo threads of the same thread
-     * to execute printf_core()
-     */
-    async_serialize_start();
-    int ret = printf_core(fmt, &ps, ap);
-    async_serialize_end();
-    futex_up(&printf_futex);
-    return ret;
+    struct printf_spec ps = {(int(*)(void *, size_t, void *))vprintf_write, NULL};
+    return printf_core(fmt, &ps, ap);
 }
 /** @}

 /branches/rcu/uspace/libc/generic/io/vsnprintf.c
 ,6 → 43,8
     char *string; /* destination string */
 };
+int vsnprintf_write(const char *str, size_t count, struct vsnprintf_data *data);
 /** Write string to given buffer.
  * Write at most data->size characters including trailing zero. According to C99 has snprintf to return number
  * of characters that would have been written if enough space had been available. Hence the return value is not
 ,7 → 55,7
  * @param data structure with destination string, counter of used space and total string size.
  * @return number of characters to print (not characters really printed!)
  */
-static int vsnprintf_write(const char *str, size_t count, struct vsnprintf_data *data)
+int vsnprintf_write(const char *str, size_t count, struct vsnprintf_data *data)
 {
     size_t i;
     i = data->size - data->len;
 ,7 → 97,7
 int vsnprintf(char *str, size_t size, const char *fmt, va_list ap)
 {
     struct vsnprintf_data data = {size, 0, str};
-    struct printf_spec ps = {(int(*)(void *, size_t, void *)) vsnprintf_write, &data};
+    struct printf_spec ps = {(int(*)(void *, size_t, void *))vsnprintf_write, &data};
     /* Print 0 at end of string - fix the case that nothing will be printed */
     if (size > 0)

 /branches/rcu/uspace/libc/generic/io/printf_core.c
 ,6 → 40,8
 #include <io/printf_core.h>
 #include <ctype.h>
 #include <string.h>
+/* For serialization */
+#include <async.h>
 #define __PRINTF_FLAG_PREFIX        0x00000001  /**< show prefixes 0x or 0*/
 #define __PRINTF_FLAG_SIGNED        0x00000002  /**< signed / unsigned number */
 ,13 → 92,15
 {
     size_t count;
-    if (str == NULL)
+    if (str == NULL) {
         return printf_putnchars("(NULL)", 6, ps);
+    }
     for (count = 0; str[count] != 0; count++);
-    if (ps->write((void *) str, count, ps->data) == count)
+    if (ps->write((void *) str, count, ps->data) == count) {
         return 0;
+    }
     return EOF;
 }
 ,6 → 447,9
     int width, precision;
     uint64_t flags;
+    /* Don't let other threads interfere */
+    async_serialize_start();
     counter = 0;
     while ((c = fmt[i])) {
 ,8 → 681,10
         counter += retval;
     }
+    async_serialize_end();
     return counter;
 minus_out:
+    async_serialize_end();
     return -counter;
 }

 /branches/rcu/uspace/libc/generic/io/vsprintf.c
 ,7 → 44,7
  */
 int vsprintf(char *str, const char *fmt, va_list ap)
 {
-    return vsnprintf(str, (size_t) - 1, fmt, ap);
+    return vsnprintf(str, (size_t)-1, fmt, ap);
 }
 /** @}

 /branches/rcu/uspace/libc/arch/sparc64/include/atomic.h
 ,11 → 51,9
     uint64_t a, b;
     do {
-        volatile uintptr_t x = (uint64_t) &val->count;
-        a = *((uint64_t *) x);
+        a = val->count;
         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" (*val), "+r" (b) : "r" (a));
     } while (a != b);
     return a;

 /branches/rcu/uspace/libc/arch/sparc64/src/thread_entry.s
 ,7 → 34,7
 #
 #
 __thread_entry:
-    sethi %hi(_gp), %l7
+    sethi %hi(_gp), %l7
     call __thread_main      ! %o0 contains address of uarg
     or %l7, %lo(_gp), %l7

 /branches/rcu/uspace/Makefile
 ,7 → 41,7
     kbd \
     console \
     tetris \
-    tester \
+    ipcc \
     klog \
     rd \
     fs

 /branches/rcu/boot/arch/sparc64/loader/Makefile
 ,7 → 78,7
     $(USPACEDIR)/kbd/kbd \
     $(USPACEDIR)/console/console \
     $(USPACEDIR)/tetris/tetris \
-    $(USPACEDIR)/tester/tester \
+    $(USPACEDIR)/ipcc/ipcc \
     $(USPACEDIR)/klog/klog
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))

 /branches/rcu/boot/arch/sparc64/loader/main.c
 ,7 → 92,7
     unsigned int i;
     for (i = 0; i < COMPONENTS; i++)
         printf(" %P: %s image (size %d bytes)\n", components[i].start,
-            components[i].name, components[i].size);
+            components[i].name, components[i].size);
     void * base = (void *) KERNEL_VIRTUAL_ADDRESS;
     unsigned int top = 0;
 ,24 → 102,10
     for (i = 0; i < COMPONENTS; i++) {
         printf(" %s...", components[i].name);
         top = ALIGN_UP(top, PAGE_SIZE);
-        /*
-         * At this point, we claim the physical memory that we are
-         * going to use. We should be safe in case of the virtual
-         * address space because the OpenFirmware, according to its
-         * SPARC binding, should restrict its use of virtual memory
-         * to addresses from [0xffd00000; 0xffefffff] and
-         * [0xfe000000; 0xfeffffff].
-         */
-        (void) ofw_claim_phys(bootinfo.physmem_start + base + top,
-            ALIGN_UP(components[i].size, PAGE_SIZE));
         memcpy(base + top, components[i].start, components[i].size);
         if (i > 0) {
-            bootinfo.taskmap.tasks[bootinfo.taskmap.count].addr =
-                base + top;
-            bootinfo.taskmap.tasks[bootinfo.taskmap.count].size =
-                components[i].size;
+            bootinfo.taskmap.tasks[bootinfo.taskmap.count].addr = base + top;
+            bootinfo.taskmap.tasks[bootinfo.taskmap.count].size = components[i].size;
             bootinfo.taskmap.count++;
         }
         top += components[i].size;
 ,14 → 112,7
         printf("done.\n");
     }
-    /*
-     * Claim the physical memory for the boot allocator.
-     * Initialize the boot allocator.
-     */
-    (void) ofw_claim_phys(bootinfo.physmem_start +
-        base + ALIGN_UP(top, PAGE_SIZE), BALLOC_MAX_SIZE);
-    balloc_init(&bootinfo.ballocs, ALIGN_UP(((uintptr_t) base) + top,
-        PAGE_SIZE));
+    balloc_init(&bootinfo.ballocs, ALIGN_UP(((uintptr_t) base) + top, PAGE_SIZE));
     printf("\nCanonizing OpenFirmware device tree...");
     bootinfo.ofw_root = ofw_tree_build();
 ,7 → 127,5
     printf("\nBooting the kernel...\n");
     jump_to_kernel((void *) KERNEL_VIRTUAL_ADDRESS,
-        bootinfo.physmem_start | BSP_PROCESSOR, &bootinfo,
-        sizeof(bootinfo));
+        bootinfo.physmem_start | BSP_PROCESSOR, &bootinfo, sizeof(bootinfo));
 }

 /branches/rcu/boot/arch/ppc32/loader/Makefile
 ,7 → 75,7
     $(USPACEDIR)/kbd/kbd \
     $(USPACEDIR)/console/console \
     $(USPACEDIR)/tetris/tetris \
-    $(USPACEDIR)/tester/tester \
+    $(USPACEDIR)/ipcc/ipcc \
     $(USPACEDIR)/klog/klog
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))

 /branches/rcu/boot/arch/ppc64/loader/Makefile
 ,7 → 75,7
     $(USPACEDIR)/kbd/kbd \
     $(USPACEDIR)/console/console \
     $(USPACEDIR)/tetris/tetris \
-    $(USPACEDIR)/tester/tester \
+    $(USPACEDIR)/ipcc/ipcc \
     $(USPACEDIR)/klog/klog
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))

 /branches/rcu/boot/arch/mips32/loader/Makefile
 ,7 → 74,7
     $(USPACEDIR)/kbd/kbd \
     $(USPACEDIR)/console/console \
     $(USPACEDIR)/tetris/tetris \
-    $(USPACEDIR)/tester/tester \
+    $(USPACEDIR)/ipcc/ipcc \
     $(USPACEDIR)/klog/klog
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))

 /branches/rcu/boot/arch/ia32xen/Makefile.inc
 ,7 → 34,7
     $(USPACEDIR)/kbd/kbd \
     $(USPACEDIR)/console/console \
     $(USPACEDIR)/tetris/tetris \
-    $(USPACEDIR)/tester/tester \
+    $(USPACEDIR)/ipcc/ipcc \
     $(USPACEDIR)/klog/klog
 build: $(BASE)/image.iso

/branches/rcu/boot/arch/ia32xen/grub/menu.debug.lst
12,5 → 12,5
module /boot/kbd
module /boot/console
module /boot/tetris
module /boot/tester
module /boot/ipcc
module /boot/klog

/branches/rcu/boot/arch/ia32xen/grub/menu.lst
12,5 → 12,5
module /boot/kbd
module /boot/console
module /boot/tetris
module /boot/tester
module /boot/ipcc
module /boot/klog

 /branches/rcu/boot/arch/amd64/Makefile.inc
 ,7 → 34,7
     $(USPACEDIR)/kbd/kbd \
     $(USPACEDIR)/console/console \
     $(USPACEDIR)/tetris/tetris \
-    $(USPACEDIR)/tester/tester \
+    $(USPACEDIR)/ipcc/ipcc \
     $(USPACEDIR)/klog/klog
 build: $(BASE)/image.iso

/branches/rcu/boot/arch/amd64/grub/menu.lst
11,5 → 11,5
module /boot/kbd
module /boot/console
module /boot/tetris
module /boot/tester
module /boot/ipcc
module /boot/klog

 /branches/rcu/boot/arch/ia32/Makefile.inc
 ,7 → 34,7
     $(USPACEDIR)/kbd/kbd \
     $(USPACEDIR)/console/console \
     $(USPACEDIR)/tetris/tetris \
-    $(USPACEDIR)/tester/tester \
+    $(USPACEDIR)/ipcc/ipcc \
     $(USPACEDIR)/klog/klog
 build: $(BASE)/image.iso

/branches/rcu/boot/arch/ia32/grub/menu.lst
11,5 → 11,5
module /boot/kbd
module /boot/console
module /boot/tetris
module /boot/tester
module /boot/ipcc
module /boot/klog

 /branches/rcu/boot/genarch/ofw.h
 ,8 → 117,7
 extern unsigned int ofw_get_size_cells(const phandle device);
 extern void *ofw_translate(const void *virt);
 extern int ofw_translate_failed(ofw_arg_t flag);
-extern void *ofw_claim_virt(const void *virt, const int len);
-extern void *ofw_claim_phys(const void *virt, const int len);
+extern void *ofw_claim(const void *virt, const int len);
 extern int ofw_map(const void *phys, const void *virt, const int size, const int mode);
 extern int ofw_memmap(memmap_t *map);
 extern int ofw_screen(screen_t *screen);

 /branches/rcu/boot/genarch/balloc.h
 ,8 → 31,6
 #include <types.h>
-#define BALLOC_MAX_SIZE     (1024 * 1024)
 typedef struct {
     uintptr_t base;
     size_t size;

 /branches/rcu/boot/genarch/ofw.c
 ,7 → 38,6
 ihandle ofw_stdout;
 phandle ofw_root;
 ihandle ofw_mmu;
-ihandle ofw_memory_prop;
 phandle ofw_memory;
 phandle ofw_aliases;
 ,7 → 47,7
     if (ofw_chosen == -1)
         halt();
-    if (ofw_get_property(ofw_chosen, "stdout", &ofw_stdout, sizeof(ofw_stdout)) <= 0)
+    if (ofw_get_property(ofw_chosen, "stdout",  &ofw_stdout, sizeof(ofw_stdout)) <= 0)
         ofw_stdout = 0;
     ofw_root = ofw_find_device("/");
 ,14 → 56,10
         halt();
     }
-    if (ofw_get_property(ofw_chosen, "mmu", &ofw_mmu, sizeof(ofw_mmu)) <= 0) {
+    if (ofw_get_property(ofw_chosen, "mmu",  &ofw_mmu, sizeof(ofw_mmu)) <= 0) {
         puts("\r\nError: Unable to get mmu property, halted.\r\n");
         halt();
     }
-    if (ofw_get_property(ofw_chosen, "memory", &ofw_memory_prop, sizeof(ofw_memory_prop)) <= 0) {
-        puts("\r\nError: Unable to get memory property, halted.\r\n");
-        halt();
-    }
     ofw_memory = ofw_find_device("/memory");
     if (ofw_memory == -1) {
 ,12 → 200,13
     else
         shift = 0;
-    return (void *) ((result[2] << shift) | result[3]);
+    return (void *) ((result[2]<<shift)|result[3]);
 }
-void *ofw_claim_virt(const void *virt, const int len)
+void *ofw_claim(const void *virt, const int len)
 {
     ofw_arg_t retaddr;
+    int shift;
     if (ofw_call("call-method", 5, 2, &retaddr, "claim", ofw_mmu, 0, len, virt) != 0) {
         puts("Error: MMU method claim() failed, halting.\n");
 ,42 → 216,6
     return (void *) retaddr;
 }
-void *ofw_claim_phys(const void *phys, const int len)
-{
-    ofw_arg_t retaddr[2];
-    int shift;
-    if (sizeof(unative_t) == 8) {
-        shift = 32;
-        if (ofw_call("call-method", 6, 3, retaddr, "claim",
-            ofw_memory_prop, 0, len, ((uintptr_t) phys) >> shift,
-            ((uintptr_t) phys) & ((uint32_t) -1)) != 0) {
-            /*
-             * Note that this will help us to discover
-             * conflicts between OpenFirmware allocations
-             * and our use of physical memory.
-             * It is better to detect collisions here
-             * than to cope with weird errors later.
-             *
-             * So this is really not to make the loader
-             * more generic; it is here for debugging
-             * purposes.
-             */
-            puts("Error: memory method claim() failed, halting.\n");
-            halt();
-        }
-    } else {
-        shift = 0;
-        /*
-         * FIXME: the number of arguments is probably different...
-         */
-        puts("Error: 32-bit ofw_claim_phys not implemented.\n");
-        halt();
-    }
-    return (void *) ((retaddr[0] << shift) | retaddr[1]);
-}
 int ofw_map(const void *phys, const void *virt, const int size, const int mode)
 {
     uintptr_t phys_hi, phys_lo;
 ,7 → 230,7
     }
     return ofw_call("call-method", 7, 1, NULL, "map", ofw_mmu, mode, size, virt,
-        phys_hi, phys_lo);
+        phys_hi, phys_lo);
 }
 /** Save OpenFirmware physical memory map.
 ,8 → 252,8
     int pos;
     map->total = 0;
     map->count = 0;
-    for (pos = 0; (pos < ret / sizeof(uint32_t)) &&
-        (map->count < MEMMAP_MAX_RECORDS); pos += ac + sc) {
+    for (pos = 0; (pos < ret / sizeof(uint32_t)) && (map->count <
+        MEMMAP_MAX_RECORDS); pos += ac + sc) {
         void * start = (void *) ((uintptr_t) buf[pos + ac - 1]);
         unsigned int size = buf[pos + ac + sc - 1];

 /branches/rcu/boot/genarch/balloc.c
 ,10 → 47,7
     alignment = ALIGN_UP(alignment, 4);
     addr = ballocs->base + ALIGN_UP(ballocs->size, alignment);
-    if (ALIGN_UP(ballocs->size, alignment) + size > BALLOC_MAX_SIZE)
-        return NULL;
     ballocs->size = ALIGN_UP(ballocs->size, alignment) + size;
     return (void *) addr;

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 2307 → Rev 2306