Changes in kernel/generic/src/proc/thread.c [2d3ddad:7ed8530] in mainline

File:

• kernel/generic/src/proc/thread.c (modified) (31 diffs)

kernel/generic/src/proc/thread.c

@@ -33 +33 @@
 /**
  * @file
- * @brief Thread management functions.
+ * @brief       Thread management functions.
  */
 
@@ -94 +94 @@
  *
  * For locking rules, see declaration thereof.
- *
- */
-IRQ_SPINLOCK_INITIALIZE(threads_lock);
+ */
+SPINLOCK_INITIALIZE(threads_lock);
 
 /** AVL tree of all threads.
@@ -102 +101 @@
  * When a thread is found in the threads_tree AVL tree, it is guaranteed to
  * exist as long as the threads_lock is held.
- *
- */
-avltree_t threads_tree;
-
-IRQ_SPINLOCK_STATIC_INITIALIZE(tidlock);
-static thread_id_t last_tid = 0;
+ */
+avltree_t threads_tree;         
+
+SPINLOCK_INITIALIZE(tidlock);
+thread_id_t last_tid = 0;
 
 static slab_cache_t *thread_slab;
-
 #ifdef CONFIG_FPU
 slab_cache_t *fpu_context_slab;
@@ -128 +125 @@
         void *arg = THREAD->thread_arg;
         THREAD->last_cycle = get_cycle();
-        
+
         /* This is where each thread wakes up after its creation */
-        irq_spinlock_unlock(&THREAD->lock, false);
+        spinlock_unlock(&THREAD->lock);
         interrupts_enable();
-        
+
         f(arg);
         
         /* Accumulate accounting to the task */
-        irq_spinlock_lock(&THREAD->lock, true);
+        ipl_t ipl = interrupts_disable();
+        
+        spinlock_lock(&THREAD->lock);
         if (!THREAD->uncounted) {
                 thread_update_accounting(true);
@@ -143 +142 @@
                 uint64_t kcycles = THREAD->kcycles;
                 THREAD->kcycles = 0;
+
+                spinlock_unlock(&THREAD->lock);
                 
-                irq_spinlock_pass(&THREAD->lock, &TASK->lock);
+                spinlock_lock(&TASK->lock);
                 TASK->ucycles += ucycles;
                 TASK->kcycles += kcycles;
-                irq_spinlock_unlock(&TASK->lock, true);
+                spinlock_unlock(&TASK->lock);
         } else
-                irq_spinlock_unlock(&THREAD->lock, true);
+                spinlock_unlock(&THREAD->lock);
+        
+        interrupts_restore(ipl);
         
         thread_exit();
-        
-        /* Not reached */
-}
-
-/** Initialization and allocation for thread_t structure
- *
- */
-static int thr_constructor(void *obj, unsigned int kmflags)
-{
-        thread_t *thread = (thread_t *) obj;
-        
-        irq_spinlock_initialize(&thread->lock, "thread_t_lock");
-        link_initialize(&thread->rq_link);
-        link_initialize(&thread->wq_link);
-        link_initialize(&thread->th_link);
-        
+        /* not reached */
+}
+
+/** Initialization and allocation for thread_t structure */
+static int thr_constructor(void *obj, int kmflags)
+{
+        thread_t *t = (thread_t *) obj;
+
+        spinlock_initialize(&t->lock, "thread_t_lock");
+        link_initialize(&t->rq_link);
+        link_initialize(&t->wq_link);
+        link_initialize(&t->th_link);
+
         /* call the architecture-specific part of the constructor */
-        thr_constructor_arch(thread);
+        thr_constructor_arch(t);
         
 #ifdef CONFIG_FPU
 #ifdef CONFIG_FPU_LAZY
-        thread->saved_fpu_context = NULL;
-#else /* CONFIG_FPU_LAZY */
-        thread->saved_fpu_context = slab_alloc(fpu_context_slab, kmflags);
-        if (!thread->saved_fpu_context)
+        t->saved_fpu_context = NULL;
+#else
+        t->saved_fpu_context = slab_alloc(fpu_context_slab, kmflags);
+        if (!t->saved_fpu_context)
                 return -1;
-#endif /* CONFIG_FPU_LAZY */
-#endif /* CONFIG_FPU */
-        
-        thread->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);
-        if (!thread->kstack) {
+#endif
+#endif
+
+        t->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);
+        if (!t->kstack) {
 #ifdef CONFIG_FPU
-                if (thread->saved_fpu_context)
-                        slab_free(fpu_context_slab, thread->saved_fpu_context);
+                if (t->saved_fpu_context)
+                        slab_free(fpu_context_slab, t->saved_fpu_context);
 #endif
                 return -1;
         }
-        
+
 #ifdef CONFIG_UDEBUG
-        mutex_initialize(&thread->udebug.lock, MUTEX_PASSIVE);
-#endif
-        
+        mutex_initialize(&t->udebug.lock, MUTEX_PASSIVE);
+#endif
+
         return 0;
 }
 
 /** Destruction of thread_t object */
-static size_t thr_destructor(void *obj)
-{
-        thread_t *thread = (thread_t *) obj;
-        
+static int thr_destructor(void *obj)
+{
+        thread_t *t = (thread_t *) obj;
+
         /* call the architecture-specific part of the destructor */
-        thr_destructor_arch(thread);
-        
-        frame_free(KA2PA(thread->kstack));
-        
+        thr_destructor_arch(t);
+
+        frame_free(KA2PA(t->kstack));
 #ifdef CONFIG_FPU
-        if (thread->saved_fpu_context)
-                slab_free(fpu_context_slab, thread->saved_fpu_context);
-#endif
-        
-        return 1;  /* One page freed */
+        if (t->saved_fpu_context)
+                slab_free(fpu_context_slab, t->saved_fpu_context);
+#endif
+        return 1; /* One page freed */
 }
 
@@ -223 +221 @@
 {
         THREAD = NULL;
-        
         atomic_set(&nrdy, 0);
         thread_slab = slab_cache_create("thread_slab", sizeof(thread_t), 0,
             thr_constructor, thr_destructor, 0);
-        
+
 #ifdef CONFIG_FPU
         fpu_context_slab = slab_cache_create("fpu_slab", sizeof(fpu_context_t),
             FPU_CONTEXT_ALIGN, NULL, NULL, 0);
 #endif
-        
+
         avltree_create(&threads_tree);
 }
@@ -238 +235 @@
 /** Make thread ready
  *
- * Switch thread to the ready state.
+ * Switch thread t to the ready state.
  *
  * @param t Thread to make ready.
  *
  */
-void thread_ready(thread_t *thread)
-{
-        irq_spinlock_lock(&thread->lock, true);
-        
-        ASSERT(!(thread->state == Ready));
-        
-        int i = (thread->priority < RQ_COUNT - 1)
-            ? ++thread->priority : thread->priority;
-        
-        cpu_t *cpu = CPU;
-        if (thread->flags & THREAD_FLAG_WIRED) {
-                ASSERT(thread->cpu != NULL);
-                cpu = thread->cpu;
-        }
-        thread->state = Ready;
-        
-        irq_spinlock_pass(&thread->lock, &(cpu->rq[i].lock));
+void thread_ready(thread_t *t)
+{
+        cpu_t *cpu;
+        runq_t *r;
+        ipl_t ipl;
+        int i, avg;
+
+        ipl = interrupts_disable();
+
+        spinlock_lock(&t->lock);
+
+        ASSERT(!(t->state == Ready));
+
+        i = (t->priority < RQ_COUNT - 1) ? ++t->priority : t->priority;
+        
+        cpu = CPU;
+        if (t->flags & THREAD_FLAG_WIRED) {
+                ASSERT(t->cpu != NULL);
+                cpu = t->cpu;
+        }
+        t->state = Ready;
+        spinlock_unlock(&t->lock);
         
         /*
-         * Append thread to respective ready queue
-         * on respective processor.
+         * Append t to respective ready queue on respective processor.
          */
-        
-        list_append(&thread->rq_link, &cpu->rq[i].rq_head);
-        cpu->rq[i].n++;
-        irq_spinlock_unlock(&(cpu->rq[i].lock), true);
-        
+        r = &cpu->rq[i];
+        spinlock_lock(&r->lock);
+        list_append(&t->rq_link, &r->rq_head);
+        r->n++;
+        spinlock_unlock(&r->lock);
+
         atomic_inc(&nrdy);
-        // FIXME: Why is the avg value not used
-        // avg = atomic_get(&nrdy) / config.cpu_active;
+        // FIXME: Why is the avg value never read?
+        avg = atomic_get(&nrdy) / config.cpu_active;
         atomic_inc(&cpu->nrdy);
+
+        interrupts_restore(ipl);
 }
 
@@ -280 +284 @@
  * Create a new thread.
  *
- * @param func      Thread's implementing function.
- * @param arg       Thread's implementing function argument.
- * @param task      Task to which the thread belongs. The caller must
- *                  guarantee that the task won't cease to exist during the
- *                  call. The task's lock may not be held.
- * @param flags     Thread flags.
- * @param name      Symbolic name (a copy is made).
- * @param uncounted Thread's accounting doesn't affect accumulated task
- *                  accounting.
- *
- * @return New thread's structure on success, NULL on failure.
+ * @param func          Thread's implementing function.
+ * @param arg           Thread's implementing function argument.
+ * @param task          Task to which the thread belongs. The caller must
+ *                      guarantee that the task won't cease to exist during the
+ *                      call. The task's lock may not be held.
+ * @param flags         Thread flags.
+ * @param name          Symbolic name (a copy is made).
+ * @param uncounted     Thread's accounting doesn't affect accumulated task
+ *                      accounting.
+ *
+ * @return              New thread's structure on success, NULL on failure.
  *
  */
 thread_t *thread_create(void (* func)(void *), void *arg, task_t *task,
-    unsigned int flags, const char *name, bool uncounted)
-{
-        thread_t *thread = (thread_t *) slab_alloc(thread_slab, 0);
-        if (!thread)
+    int flags, const char *name, bool uncounted)
+{
+        thread_t *t;
+        ipl_t ipl;
+        
+        t = (thread_t *) slab_alloc(thread_slab, 0);
+        if (!t)
                 return NULL;
         
         /* Not needed, but good for debugging */
-        memsetb(thread->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES, 0);
-        
-        irq_spinlock_lock(&tidlock, true);
-        thread->tid = ++last_tid;
-        irq_spinlock_unlock(&tidlock, true);
-        
-        context_save(&thread->saved_context);
-        context_set(&thread->saved_context, FADDR(cushion),
-            (uintptr_t) thread->kstack, THREAD_STACK_SIZE);
-        
-        the_initialize((the_t *) thread->kstack);
-        
-        ipl_t ipl = interrupts_disable();
-        thread->saved_context.ipl = interrupts_read();
+        memsetb(t->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES, 0);
+        
+        ipl = interrupts_disable();
+        spinlock_lock(&tidlock);
+        t->tid = ++last_tid;
+        spinlock_unlock(&tidlock);
         interrupts_restore(ipl);
         
-        str_cpy(thread->name, THREAD_NAME_BUFLEN, name);
-        
-        thread->thread_code = func;
-        thread->thread_arg = arg;
-        thread->ticks = -1;
-        thread->ucycles = 0;
-        thread->kcycles = 0;
-        thread->uncounted = uncounted;
-        thread->priority = -1;          /* Start in rq[0] */
-        thread->cpu = NULL;
-        thread->flags = flags;
-        thread->state = Entering;
-        thread->call_me = NULL;
-        thread->call_me_with = NULL;
-        
-        timeout_initialize(&thread->sleep_timeout);
-        thread->sleep_interruptible = false;
-        thread->sleep_queue = NULL;
-        thread->timeout_pending = false;
-        
-        thread->in_copy_from_uspace = false;
-        thread->in_copy_to_uspace = false;
-        
-        thread->interrupted = false;
-        thread->detached = false;
-        waitq_initialize(&thread->join_wq);
-        
-        thread->rwlock_holder_type = RWLOCK_NONE;
-        
-        thread->task = task;
-        
-        thread->fpu_context_exists = 0;
-        thread->fpu_context_engaged = 0;
-        
-        avltree_node_initialize(&thread->threads_tree_node);
-        thread->threads_tree_node.key = (uintptr_t) thread;
-        
+        context_save(&t->saved_context);
+        context_set(&t->saved_context, FADDR(cushion), (uintptr_t) t->kstack,
+            THREAD_STACK_SIZE);
+        
+        the_initialize((the_t *) t->kstack);
+        
+        ipl = interrupts_disable();
+        t->saved_context.ipl = interrupts_read();
+        interrupts_restore(ipl);
+        
+        memcpy(t->name, name, THREAD_NAME_BUFLEN);
+        t->name[THREAD_NAME_BUFLEN - 1] = 0;
+        
+        t->thread_code = func;
+        t->thread_arg = arg;
+        t->ticks = -1;
+        t->ucycles = 0;
+        t->kcycles = 0;
+        t->uncounted = uncounted;
+        t->priority = -1;               /* start in rq[0] */
+        t->cpu = NULL;
+        t->flags = flags;
+        t->state = Entering;
+        t->call_me = NULL;
+        t->call_me_with = NULL;
+        
+        timeout_initialize(&t->sleep_timeout);
+        t->sleep_interruptible = false;
+        t->sleep_queue = NULL;
+        t->timeout_pending = 0;
+
+        t->in_copy_from_uspace = false;
+        t->in_copy_to_uspace = false;
+
+        t->interrupted = false; 
+        t->detached = false;
+        waitq_initialize(&t->join_wq);
+        
+        t->rwlock_holder_type = RWLOCK_NONE;
+                
+        t->task = task;
+        
+        t->fpu_context_exists = 0;
+        t->fpu_context_engaged = 0;
+
+        avltree_node_initialize(&t->threads_tree_node);
+        t->threads_tree_node.key = (uintptr_t) t;
+
 #ifdef CONFIG_UDEBUG
         /* Init debugging stuff */
-        udebug_thread_initialize(&thread->udebug);
-#endif
-        
-        /* Might depend on previous initialization */
-        thread_create_arch(thread);
-        
+        udebug_thread_initialize(&t->udebug);
+#endif
+
+        /* might depend on previous initialization */
+        thread_create_arch(t);  
+
         if (!(flags & THREAD_FLAG_NOATTACH))
-                thread_attach(thread, task);
-        
-        return thread;
+                thread_attach(t, task);
+
+        return t;
 }
 
@@ -372 +382 @@
  * Detach thread from all queues, cpus etc. and destroy it.
  *
- * @param thread  Thread to be destroyed.
- * @param irq_res Indicate whether it should unlock thread->lock
- *                in interrupts-restore mode.
- *
- */
-void thread_destroy(thread_t *thread, bool irq_res)
-{
-        ASSERT(irq_spinlock_locked(&thread->lock));
-        ASSERT((thread->state == Exiting) || (thread->state == Lingering));
-        ASSERT(thread->task);
-        ASSERT(thread->cpu);
-        
-        irq_spinlock_lock(&thread->cpu->lock, false);
-        if (thread->cpu->fpu_owner == thread)
-                thread->cpu->fpu_owner = NULL;
-        irq_spinlock_unlock(&thread->cpu->lock, false);
-        
-        irq_spinlock_pass(&thread->lock, &threads_lock);
-        
-        avltree_delete(&threads_tree, &thread->threads_tree_node);
-        
-        irq_spinlock_pass(&threads_lock, &thread->task->lock);
-        
+ * Assume thread->lock is held!!
+ */
+void thread_destroy(thread_t *t)
+{
+        ASSERT(t->state == Exiting || t->state == Lingering);
+        ASSERT(t->task);
+        ASSERT(t->cpu);
+
+        spinlock_lock(&t->cpu->lock);
+        if (t->cpu->fpu_owner == t)
+                t->cpu->fpu_owner = NULL;
+        spinlock_unlock(&t->cpu->lock);
+
+        spinlock_unlock(&t->lock);
+
+        spinlock_lock(&threads_lock);
+        avltree_delete(&threads_tree, &t->threads_tree_node);
+        spinlock_unlock(&threads_lock);
+
         /*
          * Detach from the containing task.
          */
-        list_remove(&thread->th_link);
-        irq_spinlock_unlock(&thread->task->lock, irq_res);
-        
+        spinlock_lock(&t->task->lock);
+        list_remove(&t->th_link);
+        spinlock_unlock(&t->task->lock);        
+
         /*
          * Drop the reference to the containing task.
          */
-        task_release(thread->task);
-        slab_free(thread_slab, thread);
+        task_release(t->task);
+        
+        slab_free(thread_slab, t);
 }
 
@@ -413 +421 @@
  * threads_tree.
  *
- * @param t    Thread to be attached to the task.
- * @param task Task to which the thread is to be attached.
- *
- */
-void thread_attach(thread_t *thread, task_t *task)
-{
+ * @param t     Thread to be attached to the task.
+ * @param task  Task to which the thread is to be attached.
+ */
+void thread_attach(thread_t *t, task_t *task)
+{
+        ipl_t ipl;
+
         /*
          * Attach to the specified task.
          */
-        irq_spinlock_lock(&task->lock, true);
-        
+        ipl = interrupts_disable();
+        spinlock_lock(&task->lock);
+
         /* Hold a reference to the task. */
         task_hold(task);
-        
+
         /* Must not count kbox thread into lifecount */
-        if (thread->flags & THREAD_FLAG_USPACE)
+        if (t->flags & THREAD_FLAG_USPACE)
                 atomic_inc(&task->lifecount);
-        
-        list_append(&thread->th_link, &task->th_head);
-        
-        irq_spinlock_pass(&task->lock, &threads_lock);
-        
+
+        list_append(&t->th_link, &task->th_head);
+        spinlock_unlock(&task->lock);
+
         /*
          * Register this thread in the system-wide list.
          */
-        avltree_insert(&threads_tree, &thread->threads_tree_node);
-        irq_spinlock_unlock(&threads_lock, true);
+        spinlock_lock(&threads_lock);
+        avltree_insert(&threads_tree, &t->threads_tree_node);
+        spinlock_unlock(&threads_lock);
+        
+        interrupts_restore(ipl);
 }
 
 /** Terminate thread.
  *
- * End current thread execution and switch it to the exiting state.
- * All pending timeouts are executed.
- *
+ * End current thread execution and switch it to the exiting state. All pending
+ * timeouts are executed.
  */
 void thread_exit(void)
 {
+        ipl_t ipl;
+
         if (THREAD->flags & THREAD_FLAG_USPACE) {
 #ifdef CONFIG_UDEBUG
                 /* Generate udebug THREAD_E event */
                 udebug_thread_e_event();
-
-                /*
-                 * This thread will not execute any code or system calls from
-                 * now on.
-                 */
-                udebug_stoppable_begin();
 #endif
                 if (atomic_predec(&TASK->lifecount) == 0) {
@@ -468 +475 @@
                          * can only be created by threads of the same task.
                          * We are safe to perform cleanup.
-                         *
                          */
                         ipc_cleanup();
@@ -475 +481 @@
                 }
         }
-        
+
 restart:
-        irq_spinlock_lock(&THREAD->lock, true);
-        if (THREAD->timeout_pending) {
-                /* Busy waiting for timeouts in progress */
-                irq_spinlock_unlock(&THREAD->lock, true);
+        ipl = interrupts_disable();
+        spinlock_lock(&THREAD->lock);
+        if (THREAD->timeout_pending) { 
+                /* busy waiting for timeouts in progress */
+                spinlock_unlock(&THREAD->lock);
+                interrupts_restore(ipl);
                 goto restart;
         }
         
         THREAD->state = Exiting;
-        irq_spinlock_unlock(&THREAD->lock, true);
-        
+        spinlock_unlock(&THREAD->lock);
         scheduler();
-        
+
         /* Not reached */
-        while (true);
-}
+        while (1)
+                ;
+}
+
 
 /** Thread sleep
@@ -506 +515 @@
         while (sec > 0) {
                 uint32_t period = (sec > 1000) ? 1000 : sec;
-                
+        
                 thread_usleep(period * 1000000);
                 sec -= period;
@@ -514 +523 @@
 /** Wait for another thread to exit.
  *
- * @param thread Thread to join on exit.
- * @param usec   Timeout in microseconds.
- * @param flags  Mode of operation.
+ * @param t Thread to join on exit.
+ * @param usec Timeout in microseconds.
+ * @param flags Mode of operation.
  *
  * @return An error code from errno.h or an error code from synch.h.
- *
- */
-int thread_join_timeout(thread_t *thread, uint32_t usec, unsigned int flags)
-{
-        if (thread == THREAD)
+ */
+int thread_join_timeout(thread_t *t, uint32_t usec, int flags)
+{
+        ipl_t ipl;
+        int rc;
+
+        if (t == THREAD)
                 return EINVAL;
-        
+
         /*
          * Since thread join can only be called once on an undetached thread,
@@ -531 +542 @@
          */
         
-        irq_spinlock_lock(&thread->lock, true);
-        ASSERT(!thread->detached);
-        irq_spinlock_unlock(&thread->lock, true);
-        
-        return waitq_sleep_timeout(&thread->join_wq, usec, flags);
+        ipl = interrupts_disable();
+        spinlock_lock(&t->lock);
+        ASSERT(!t->detached);
+        spinlock_unlock(&t->lock);
+        interrupts_restore(ipl);
+        
+        rc = waitq_sleep_timeout(&t->join_wq, usec, flags);
+        
+        return rc;      
 }
 
@@ -543 +558 @@
  * state, deallocate its resources.
  *
- * @param thread Thread to be detached.
- *
- */
-void thread_detach(thread_t *thread)
-{
+ * @param t Thread to be detached.
+ */
+void thread_detach(thread_t *t)
+{
+        ipl_t ipl;
+
         /*
          * Since the thread is expected not to be already detached,
          * pointer to it must be still valid.
          */
-        irq_spinlock_lock(&thread->lock, true);
-        ASSERT(!thread->detached);
-        
-        if (thread->state == Lingering) {
-                /*
-                 * Unlock &thread->lock and restore
-                 * interrupts in thread_destroy().
-                 */
-                thread_destroy(thread, true);
+        ipl = interrupts_disable();
+        spinlock_lock(&t->lock);
+        ASSERT(!t->detached);
+        if (t->state == Lingering) {
+                thread_destroy(t);      /* unlocks &t->lock */
+                interrupts_restore(ipl);
                 return;
         } else {
-                thread->detached = true;
-        }
-        
-        irq_spinlock_unlock(&thread->lock, true);
+                t->detached = true;
+        }
+        spinlock_unlock(&t->lock);
+        interrupts_restore(ipl);
 }
 
@@ -588 +601 @@
  *
  * Register a function and its argument to be executed
- * on next context switch to the current thread. Must
- * be called with interrupts disabled.
+ * on next context switch to the current thread.
  *
  * @param call_me      Out-of-context function.
@@ -597 +609 @@
 void thread_register_call_me(void (* call_me)(void *), void *call_me_with)
 {
-        irq_spinlock_lock(&THREAD->lock, false);
+        ipl_t ipl;
+        
+        ipl = interrupts_disable();
+        spinlock_lock(&THREAD->lock);
         THREAD->call_me = call_me;
         THREAD->call_me_with = call_me_with;
-        irq_spinlock_unlock(&THREAD->lock, false);
+        spinlock_unlock(&THREAD->lock);
+        interrupts_restore(ipl);
 }
 
 static bool thread_walker(avltree_node_t *node, void *arg)
 {
-        thread_t *thread = avltree_get_instance(node, thread_t, threads_tree_node);
+        thread_t *t = avltree_get_instance(node, thread_t, threads_tree_node);
         
         uint64_t ucycles, kcycles;
         char usuffix, ksuffix;
-        order_suffix(thread->ucycles, &ucycles, &usuffix);
-        order_suffix(thread->kcycles, &kcycles, &ksuffix);
-        
+        order_suffix(t->ucycles, &ucycles, &usuffix);
+        order_suffix(t->kcycles, &kcycles, &ksuffix);
+
 #ifdef __32_BITS__
         printf("%-6" PRIu64" %-10s %10p %-8s %10p %-3" PRIu32 " %10p %10p %9"
-                PRIu64 "%c %9" PRIu64 "%c ", thread->tid, thread->name, thread,
-                thread_states[thread->state], thread->task, thread->task->context,
-                thread->thread_code, thread->kstack, ucycles, usuffix, kcycles, ksuffix);
-#endif
-        
+                PRIu64 "%c %9" PRIu64 "%c ", t->tid, t->name, t,
+                thread_states[t->state], t->task, t->task->context, t->thread_code,
+                t->kstack, ucycles, usuffix, kcycles, ksuffix);
+#endif
+
 #ifdef __64_BITS__
         printf("%-6" PRIu64" %-10s %18p %-8s %18p %-3" PRIu32 " %18p %18p %9"
-                PRIu64 "%c %9" PRIu64 "%c ", thread->tid, thread->name, thread,
-                thread_states[thread->state], thread->task, thread->task->context,
-                thread->thread_code, thread->kstack, ucycles, usuffix, kcycles, ksuffix);
-#endif
-        
-        if (thread->cpu)
-                printf("%-4u", thread->cpu->id);
+                PRIu64 "%c %9" PRIu64 "%c ", t->tid, t->name, t,
+                thread_states[t->state], t->task, t->task->context, t->thread_code,
+                t->kstack, ucycles, usuffix, kcycles, ksuffix);
+#endif
+                        
+        if (t->cpu)
+                printf("%-4u", t->cpu->id);
         else
                 printf("none");
-        
-        if (thread->state == Sleeping) {
+                        
+        if (t->state == Sleeping) {
 #ifdef __32_BITS__
-                printf(" %10p", thread->sleep_queue);
-#endif
-                
+                printf(" %10p", t->sleep_queue);
+#endif
+
 #ifdef __64_BITS__
-                printf(" %18p", thread->sleep_queue);
-#endif
-        }
-        
+                printf(" %18p", t->sleep_queue);
+#endif
+        }
+                        
         printf("\n");
-        
+
         return true;
 }
 
-/** Print list of threads debug info
- *
- */
+/** Print list of threads debug info */
 void thread_print_list(void)
 {
+        ipl_t ipl;
+        
         /* Messing with thread structures, avoid deadlock */
-        irq_spinlock_lock(&threads_lock, true);
-        
-#ifdef __32_BITS__
+        ipl = interrupts_disable();
+        spinlock_lock(&threads_lock);
+
+#ifdef __32_BITS__      
         printf("tid    name       address    state    task       "
                 "ctx code       stack      ucycles    kcycles    cpu  "
@@ -662 +679 @@
                 "----------\n");
 #endif
-        
+
 #ifdef __64_BITS__
         printf("tid    name       address            state    task               "
@@ -671 +688 @@
                 "------------------\n");
 #endif
-        
+
         avltree_walk(&threads_tree, thread_walker, NULL);
-        
-        irq_spinlock_unlock(&threads_lock, true);
+
+        spinlock_unlock(&threads_lock);
+        interrupts_restore(ipl);
 }
 
@@ -682 +700 @@
  * interrupts must be already disabled.
  *
- * @param thread Pointer to thread.
+ * @param t Pointer to thread.
  *
  * @return True if thread t is known to the system, false otherwise.
- *
- */
-bool thread_exists(thread_t *thread)
-{
-        ASSERT(interrupts_disabled());
-        ASSERT(irq_spinlock_locked(&threads_lock));
-
-        avltree_node_t *node =
-            avltree_search(&threads_tree, (avltree_key_t) ((uintptr_t) thread));
+ */
+bool thread_exists(thread_t *t)
+{
+        avltree_node_t *node;
+
+        node = avltree_search(&threads_tree, (avltree_key_t) ((uintptr_t) t));
         
         return node != NULL;
@@ -703 +718 @@
  * interrupts must be already disabled.
  *
- * @param user True to update user accounting, false for kernel.
- *
+ * @param user  True to update user accounting, false for kernel.
  */
 void thread_update_accounting(bool user)
 {
         uint64_t time = get_cycle();
-
-        ASSERT(interrupts_disabled());
-        ASSERT(irq_spinlock_locked(&THREAD->lock));
-        
-        if (user)
+        if (user) {
                 THREAD->ucycles += time - THREAD->last_cycle;
-        else
+        } else {
                 THREAD->kcycles += time - THREAD->last_cycle;
-        
+        }
         THREAD->last_cycle = time;
 }
@@ -747 +757 @@
 thread_t *thread_find_by_id(thread_id_t thread_id)
 {
-        ASSERT(interrupts_disabled());
-        ASSERT(irq_spinlock_locked(&threads_lock));
-
         thread_iterator_t iterator;
         
@@ -767 +774 @@
     size_t name_len, thread_id_t *uspace_thread_id)
 {
+        thread_t *t;
+        char namebuf[THREAD_NAME_BUFLEN];
+        uspace_arg_t *kernel_uarg;
+        int rc;
+
         if (name_len > THREAD_NAME_BUFLEN - 1)
                 name_len = THREAD_NAME_BUFLEN - 1;
-        
-        char namebuf[THREAD_NAME_BUFLEN];
-        int rc = copy_from_uspace(namebuf, uspace_name, name_len);
+
+        rc = copy_from_uspace(namebuf, uspace_name, name_len);
         if (rc != 0)
                 return (unative_t) rc;
-        
+
         namebuf[name_len] = 0;
-        
+
         /*
          * In case of failure, kernel_uarg will be deallocated in this function.
          * In case of success, kernel_uarg will be freed in uinit().
-         *
          */
-        uspace_arg_t *kernel_uarg =
-            (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
+        kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
         
         rc = copy_from_uspace(kernel_uarg, uspace_uarg, sizeof(uspace_arg_t));
@@ -790 +799 @@
                 return (unative_t) rc;
         }
-        
-        thread_t *thread = thread_create(uinit, kernel_uarg, TASK,
+
+        t = thread_create(uinit, kernel_uarg, TASK,
             THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf, false);
-        if (thread) {
+        if (t) {
                 if (uspace_thread_id != NULL) {
-                        rc = copy_to_uspace(uspace_thread_id, &thread->tid,
-                            sizeof(thread->tid));
+                        int rc;
+
+                        rc = copy_to_uspace(uspace_thread_id, &t->tid,
+                            sizeof(t->tid));
                         if (rc != 0) {
                                 /*
@@ -802 +813 @@
                                  * has already been created. We need to undo its
                                  * creation now.
-                                 *
                                  */
-                                
+
                                 /*
                                  * The new thread structure is initialized, but
@@ -810 +820 @@
                                  * We can safely deallocate it.
                                  */
-                                slab_free(thread_slab, thread);
-                                free(kernel_uarg);
-                                
+                                slab_free(thread_slab, t);
+                                free(kernel_uarg);
+
                                 return (unative_t) rc;
                          }
                 }
-                
 #ifdef CONFIG_UDEBUG
                 /*
@@ -824 +833 @@
                  * THREAD_B events for threads that already existed
                  * and could be detected with THREAD_READ before.
-                 *
                  */
-                udebug_thread_b_event_attach(thread, TASK);
+                udebug_thread_b_event_attach(t, TASK);
 #else
-                thread_attach(thread, TASK);
-#endif
-                thread_ready(thread);
-                
+                thread_attach(t, TASK);
+#endif
+                thread_ready(t);
+
                 return 0;
         } else
                 free(kernel_uarg);
-        
+
         return (unative_t) ENOMEM;
 }
@@ -845 +853 @@
 {
         thread_exit();
-        
         /* Unreachable */
         return 0;
@@ -856 +863 @@
  *
  * @return 0 on success or an error code from @ref errno.h.
- *
  */
 unative_t sys_thread_get_id(thread_id_t *uspace_thread_id)
@@ -863 +869 @@
          * 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,