Changeset 8013637 in mainline for kernel/generic/src

Timestamp:

2012-07-20T13:51:28Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

8fccd42

Parents:

c5bff3c (diff), 7030bc9 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

More mainline changes.

Location:

kernel/generic/src

Files:

• adt/btree.c (modified) (1 diff)
• console/cmd.c (modified) (1 diff)
• console/kconsole.c (modified) (8 diffs)
• console/prompt.c (added)
• debug/symtab.c (modified) (5 diffs)
• ipc/ipc.c (modified) (1 diff)
• ipc/kbox.c (modified) (1 diff)
• ipc/sysipc.c (modified) (3 diffs)
• lib/ra.c (modified) (7 diffs)
• lib/rd.c (modified) (2 diffs)
• main/kinit.c (modified) (6 diffs)
• main/main.c (modified) (1 diff)
• main/uinit.c (modified) (2 diffs)
• mm/as.c (modified) (4 diffs)
• mm/frame.c (modified) (4 diffs)
• mm/slab.c (modified) (20 diffs)
• mm/tlb.c (modified) (2 diffs)
• proc/program.c (modified) (7 diffs)
• proc/scheduler.c (modified) (6 diffs)
• proc/task.c (modified) (1 diff)
• proc/thread.c (modified) (15 diffs)
• synch/mutex.c (modified) (3 diffs)
• synch/spinlock.c (modified) (3 diffs)
• sysinfo/sysinfo.c (modified) (1 diff)
• udebug/udebug.c (modified) (1 diff)
• udebug/udebug_ops.c (modified) (3 diffs)

kernel/generic/src/adt/btree.c

@@ -71 +71 @@
 void btree_init(void)
 {
-        btree_node_slab = slab_cache_create("btree_node_slab",
+        btree_node_slab = slab_cache_create("btree_node_t",
             sizeof(btree_node_t), 0, NULL, NULL, SLAB_CACHE_MAGDEFERRED);
 }

kernel/generic/src/console/cmd.c

@@ -724 +724 @@
                 thread_t *thread;
                 if ((thread = thread_create((void (*)(void *)) cmd_call0,
-                    (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
-                        irq_spinlock_lock(&thread->lock, true);
-                        thread->cpu = &cpus[i];
-                        irq_spinlock_unlock(&thread->lock, true);
-                        
+                    (void *) argv, TASK, THREAD_FLAG_NONE, "call0"))) {
                         printf("cpu%u: ", i);
-                        
+                        thread_wire(thread, &cpus[i]);
                         thread_ready(thread);
                         thread_join(thread);

kernel/generic/src/console/kconsole.c

@@ -43 +43 @@
 #include <console/chardev.h>
 #include <console/cmd.h>
+#include <console/prompt.h>
 #include <print.h>
 #include <panic.h>
@@ -201 +202 @@
  *
  */
-NO_TRACE static int cmdtab_compl(char *input, size_t size)
+NO_TRACE static int cmdtab_compl(char *input, size_t size, indev_t *indev)
 {
         const char *name = input;
         
         size_t found = 0;
+        
+        /*
+         * Maximum Match Length: Length of longest matching common
+         * substring in case more than one match is found.
+         */
+        size_t max_match_len = size;
+        size_t max_match_len_tmp = size;
+        size_t input_len = str_length(input);
         link_t *pos = NULL;
         const char *hint;
         char *output = malloc(MAX_CMDLINE, 0);
+        size_t hints_to_show = MAX_TAB_HINTS - 1;
+        size_t total_hints_shown = 0;
+        bool continue_showing_hints = true;
         
         output[0] = 0;
@@ -218 +230 @@
                 pos = pos->next;
                 found++;
+        }
+        
+        /*
+         * If the number of possible completions is more than MAX_TAB_HINTS,
+         * ask the user whether to display them or not.
+         */
+        if (found > MAX_TAB_HINTS) {
+                printf("\n");
+                continue_showing_hints =
+                    console_prompt_display_all_hints(indev, found);
         }
         
@@ -225 +247 @@
                 while (cmdtab_search_one(name, &pos)) {
                         cmd_info_t *hlp = list_get_instance(pos, cmd_info_t, link);
-                        printf("%s (%s)\n", hlp->name, hlp->description);
+                        
+                        if (continue_showing_hints) {
+                                printf("%s (%s)\n", hlp->name, hlp->description);
+                                --hints_to_show;
+                                ++total_hints_shown;
+                                
+                                if ((hints_to_show == 0) && (total_hints_shown != found)) {
+                                        /* Ask user to continue */
+                                        continue_showing_hints =
+                                            console_prompt_more_hints(indev, &hints_to_show);
+                                }
+                        }
+                        
                         pos = pos->next;
-                }
+                        
+                        for (max_match_len_tmp = 0;
+                            (output[max_match_len_tmp] ==
+                            hlp->name[input_len + max_match_len_tmp]) &&
+                            (max_match_len_tmp < max_match_len); ++max_match_len_tmp);
+                        
+                        max_match_len = max_match_len_tmp;
+                }
+                
+                /* Keep only the characters common in all completions */
+                output[max_match_len] = 0;
         }
         
@@ -280 +324 @@
                                 continue;
                         
-                        /* Find the beginning of the word
-                           and copy it to tmp */
+                        /*
+                         * Find the beginning of the word
+                         * and copy it to tmp
+                         */
                         size_t beg;
                         for (beg = position - 1; (beg > 0) && (!isspace(current[beg]));
@@ -294 +340 @@
                         if (beg == 0) {
                                 /* Command completion */
-                                found = cmdtab_compl(tmp, STR_BOUNDS(MAX_CMDLINE));
+                                found = cmdtab_compl(tmp, STR_BOUNDS(MAX_CMDLINE), indev);
                         } else {
                                 /* Symbol completion */
-                                found = symtab_compl(tmp, STR_BOUNDS(MAX_CMDLINE));
+                                found = symtab_compl(tmp, STR_BOUNDS(MAX_CMDLINE), indev);
                         }
                         
                         if (found == 0)
                                 continue;
-                        
-                        if (found > 1) {
-                                /* No unique hint, list was printed */
-                                printf("%s> ", prompt);
-                                printf("%ls", current);
-                                print_cc('\b', wstr_length(current) - position);
-                                continue;
-                        }
-                        
-                        /* We have a hint */
-                        
+
+                        /*
+                         * We have hints, possibly many. In case of more than one hint,
+                         * tmp will contain the common prefix.
+                         */
                         size_t off = 0;
                         size_t i = 0;
@@ -318 +358 @@
                                 if (!wstr_linsert(current, ch, position + i, MAX_CMDLINE))
                                         break;
+                                
                                 i++;
                         }
+                        
+                        if (found > 1) {
+                                /* No unique hint, list was printed */
+                                printf("%s> ", prompt);
+                                printf("%ls", current);
+                                position += str_length(tmp);
+                                print_cc('\b', wstr_length(current) - position);
+                                continue;
+                        }
+                        
+                        /* We have a hint */
                         
                         printf("%ls", current + position);
@@ -540 +592 @@
 /** Parse command line.
  *
- * @param cmdline Command line as read from input device. 
+ * @param cmdline Command line as read from input device.
  * @param size    Size (in bytes) of the string.
  *

kernel/generic/src/debug/symtab.c

@@ -43 +43 @@
 #include <typedefs.h>
 #include <errno.h>
+#include <console/prompt.h>
 
 /** Get name of a symbol that seems most likely to correspond to address.
@@ -209 +210 @@
  *
  */
-int symtab_compl(char *input, size_t size)
+int symtab_compl(char *input, size_t size, indev_t *indev)
 {
 #ifdef CONFIG_SYMTAB
@@ -227 +228 @@
         char output[MAX_SYMBOL_NAME];
         
+        /*
+         * Maximum Match Length: Length of longest matching common substring in
+         * case more than one match is found.
+         */
+        size_t max_match_len = size;
+        size_t max_match_len_tmp = size;
+        size_t input_len = str_length(input);
+        char *sym_name;
+        size_t hints_to_show = MAX_TAB_HINTS - 1;
+        size_t total_hints_shown = 0;
+        bool continue_showing_hints = true;
+        
         output[0] = 0;
+        
+        while ((hint = symtab_search_one(name, &pos)))
+                pos++;
+        
+        pos = 0;
         
         while ((hint = symtab_search_one(name, &pos))) {
@@ -235 +253 @@
                 pos++;
                 found++;
+        }
+        
+        /*
+         * If the number of possible completions is more than MAX_TAB_HINTS,
+         * ask the user whether to display them or not.
+         */
+        if (found > MAX_TAB_HINTS) {
+                printf("\n");
+                continue_showing_hints =
+                    console_prompt_display_all_hints(indev, found);
         }
         
@@ -241 +269 @@
                 pos = 0;
                 while (symtab_search_one(name, &pos)) {
-                        printf("%s\n", symbol_table[pos].symbol_name);
+                        sym_name = symbol_table[pos].symbol_name;
                         pos++;
+                        
+                        if (continue_showing_hints) {
+                                /* We are still showing hints */
+                                printf("%s\n", sym_name);
+                                --hints_to_show;
+                                ++total_hints_shown;
+                                
+                                if ((hints_to_show == 0) && (total_hints_shown != found)) {
+                                        /* Ask the user to continue */
+                                        continue_showing_hints =
+                                            console_prompt_more_hints(indev, &hints_to_show);
+                                }
+                        }
+                        
+                        for (max_match_len_tmp = 0;
+                            (output[max_match_len_tmp] ==
+                            sym_name[input_len + max_match_len_tmp]) &&
+                            (max_match_len_tmp < max_match_len); ++max_match_len_tmp);
+                        
+                        max_match_len = max_match_len_tmp;
                 }
+                
+                /* Keep only the characters common in all completions */
+                output[max_match_len] = 0;
         }
         

kernel/generic/src/ipc/ipc.c

@@ -670 +670 @@
 void ipc_init(void)
 {
-        ipc_call_slab = slab_cache_create("ipc_call", sizeof(call_t), 0, NULL,
+        ipc_call_slab = slab_cache_create("call_t", sizeof(call_t), 0, NULL,
             NULL, 0);
-        ipc_answerbox_slab = slab_cache_create("ipc_answerbox",
+        ipc_answerbox_slab = slab_cache_create("answerbox_t",
             sizeof(answerbox_t), 0, NULL, NULL, 0);
 }

kernel/generic/src/ipc/kbox.c

@@ -244 +244 @@
         
         /* Create a kbox thread */
-        thread_t *kb_thread = thread_create(kbox_thread_proc, NULL, task, 0,
-            "kbox", false);
+        thread_t *kb_thread = thread_create(kbox_thread_proc, NULL, task,
+            THREAD_FLAG_NONE, "kbox");
         if (!kb_thread) {
                 mutex_unlock(&task->kb.cleanup_lock);

kernel/generic/src/ipc/sysipc.c

@@ -597 +597 @@
         if (IPC_GET_IMETHOD(call->data) == IPC_M_CONNECT_TO_ME) {
                 int phoneid = phone_alloc(TASK);
-                if (phoneid < 0) { /* Failed to allocate phone */
+                if (phoneid < 0) {  /* Failed to allocate phone */
                         IPC_SET_RETVAL(call->data, ELIMIT);
                         ipc_answer(box, call);
@@ -883 +883 @@
         
         /*
-         * Userspace is not allowed to change interface and method of system
+         * User space is not allowed to change interface and method of system
          * methods on forward, allow changing ARG1, ARG2, ARG3 and ARG4 by
-         * means of method, arg1, arg2 and arg3.
+         * means of imethod, arg1, arg2 and arg3.
          * If the interface and method is immutable, don't change anything.
          */
@@ -897 +897 @@
                         IPC_SET_ARG3(call->data, arg2);
                         
-                        if (slow) {
+                        if (slow)
                                 IPC_SET_ARG4(call->data, arg3);
-                                /*
-                                 * For system methods we deliberately don't
-                                 * overwrite ARG5.
-                                 */
-                        }
+                        
+                        /*
+                         * For system methods we deliberately don't
+                         * overwrite ARG5.
+                         */
                 } else {
                         IPC_SET_IMETHOD(call->data, imethod);

kernel/generic/src/lib/ra.c

@@ -185 +185 @@
                 return NULL;
 
-        spinlock_initialize(&arena->lock, "arena_lock");
+        irq_spinlock_initialize(&arena->lock, "arena_lock");
         list_initialize(&arena->spans);
 
@@ -209 +209 @@
 
         /* TODO: check for overlaps */
-        spinlock_lock(&arena->lock);
+        irq_spinlock_lock(&arena->lock, true);
         list_append(&span->span_link, &arena->spans);
-        spinlock_unlock(&arena->lock);
+        irq_spinlock_unlock(&arena->lock, true);
         return true;
 }
@@ -390 +390 @@
         ASSERT(ispwr2(alignment));
 
-        spinlock_lock(&arena->lock);
+        irq_spinlock_lock(&arena->lock, true);
         list_foreach(arena->spans, cur) {
                 ra_span_t *span = list_get_instance(cur, ra_span_t, span_link);
@@ -398 +398 @@
                         break;
         }
-        spinlock_unlock(&arena->lock);
+        irq_spinlock_unlock(&arena->lock, true);
 
         return base;
@@ -406 +406 @@
 void ra_free(ra_arena_t *arena, uintptr_t base, size_t size)
 {
-        spinlock_lock(&arena->lock);
+        irq_spinlock_lock(&arena->lock, true);
         list_foreach(arena->spans, cur) {
                 ra_span_t *span = list_get_instance(cur, ra_span_t, span_link);
@@ -412 +412 @@
                 if (iswithin(span->base, span->size, base, size)) {
                         ra_span_free(span, base, size);
-                        spinlock_unlock(&arena->lock);
+                        irq_spinlock_unlock(&arena->lock, true);
                         return;
                 }
         }
-        spinlock_unlock(&arena->lock);
+        irq_spinlock_unlock(&arena->lock, true);
 
         panic("Freeing to wrong arena (base=%" PRIxn ", size=%" PRIdn ").",
@@ -424 +424 @@
 void ra_init(void)
 {
-        ra_segment_cache = slab_cache_create("segment_cache",
+        ra_segment_cache = slab_cache_create("ra_segment_t",
             sizeof(ra_segment_t), 0, NULL, NULL, SLAB_CACHE_MAGDEFERRED);
 }

kernel/generic/src/lib/rd.c

@@ -38 +38 @@
  */
 
+#include <print.h>
 #include <lib/rd.h>
 #include <mm/frame.h>
@@ -66 +67 @@
         sysinfo_set_item_val("rd.size", NULL, size);
         sysinfo_set_item_val("rd.address.physical", NULL, (sysarg_t) base);
+        
+        printf("RAM disk at %p (size %zu bytes)\n", (void *) base, size);
 }
 

kernel/generic/src/main/kinit.c

@@ -116 +116 @@
                  * Just a beautification.
                  */
-                thread = thread_create(kmp, NULL, TASK, THREAD_FLAG_WIRED, "kmp", true);
+                thread = thread_create(kmp, NULL, TASK,
+                    THREAD_FLAG_UNCOUNTED, "kmp");
                 if (thread != NULL) {
-                        irq_spinlock_lock(&thread->lock, false);
-                        thread->cpu = &cpus[0];
-                        irq_spinlock_unlock(&thread->lock, false);
+                        thread_wire(thread, &cpus[0]);
                         thread_ready(thread);
                 } else
@@ -134 +133 @@
                 
                 for (i = 0; i < config.cpu_count; i++) {
-                        thread = thread_create(kcpulb, NULL, TASK, THREAD_FLAG_WIRED, "kcpulb", true);
+                        thread = thread_create(kcpulb, NULL, TASK,
+                            THREAD_FLAG_UNCOUNTED, "kcpulb");
                         if (thread != NULL) {
-                                irq_spinlock_lock(&thread->lock, false);
-                                thread->cpu = &cpus[i];
-                                irq_spinlock_unlock(&thread->lock, false);
+                                thread_wire(thread, &cpus[i]);
                                 thread_ready(thread);
                         } else
@@ -152 +150 @@
         
         /* Start thread computing system load */
-        thread = thread_create(kload, NULL, TASK, 0, "kload", false);
+        thread = thread_create(kload, NULL, TASK, THREAD_FLAG_NONE,
+            "kload");
         if (thread != NULL)
                 thread_ready(thread);
@@ -163 +162 @@
                  * Create kernel console.
                  */
-                thread = thread_create(kconsole_thread, NULL, TASK, 0, "kconsole", false);
+                thread = thread_create(kconsole_thread, NULL, TASK,
+                    THREAD_FLAG_NONE, "kconsole");
                 if (thread != NULL)
                         thread_ready(thread);
@@ -201 +201 @@
                 str_cpy(namebuf + INIT_PREFIX_LEN,
                     TASK_NAME_BUFLEN - INIT_PREFIX_LEN, name);
-
+                
                 /*
                  * Create virtual memory mappings for init task images.
@@ -236 +236 @@
                         init_rd((void *) init.tasks[i].paddr, init.tasks[i].size);
                 } else
-                        printf("init[%zu]: Init binary load failed (error %d)\n", i, rc);
+                        printf("init[%zu]: Init binary load failed "
+                            "(error %d, loader status %u)\n", i, rc,
+                            programs[i].loader_status);
         }
         

kernel/generic/src/main/main.c

@@ -276 +276 @@
          * Create the first thread.
          */
-        thread_t *kinit_thread =
-            thread_create(kinit, NULL, kernel, 0, "kinit", true);
+        thread_t *kinit_thread = thread_create(kinit, NULL, kernel,
+            THREAD_FLAG_UNCOUNTED, "kinit");
         if (!kinit_thread)
                 panic("Cannot create kinit thread.");

kernel/generic/src/main/uinit.c

@@ -56 +56 @@
 void uinit(void *arg)
 {
-        uspace_arg_t uarg;
-        
         /*
          * So far, we don't have a use for joining userspace threads so we
@@ -72 +70 @@
 #endif
         
-        uarg.uspace_entry = ((uspace_arg_t *) arg)->uspace_entry;
-        uarg.uspace_stack = ((uspace_arg_t *) arg)->uspace_stack;
-        uarg.uspace_uarg = ((uspace_arg_t *) arg)->uspace_uarg;
-        uarg.uspace_thread_function = NULL;
-        uarg.uspace_thread_arg = NULL;
+        uspace_arg_t *uarg = (uspace_arg_t *) arg;
+        uspace_arg_t local_uarg;
         
-        free((uspace_arg_t *) arg);
+        local_uarg.uspace_entry = uarg->uspace_entry;
+        local_uarg.uspace_stack = uarg->uspace_stack;
+        local_uarg.uspace_stack_size = uarg->uspace_stack_size;
+        local_uarg.uspace_uarg = uarg->uspace_uarg;
+        local_uarg.uspace_thread_function = NULL;
+        local_uarg.uspace_thread_arg = NULL;
         
-        userspace(&uarg);
+        free(uarg);
+        
+        userspace(&local_uarg);
 }
 

kernel/generic/src/mm/as.c

@@ -130 +130 @@
         as_arch_init();
         
-        as_slab = slab_cache_create("as_slab", sizeof(as_t), 0,
+        as_slab = slab_cache_create("as_t", sizeof(as_t), 0,
             as_constructor, as_destructor, SLAB_CACHE_MAGDEFERRED);
         
@@ -665 +665 @@
                 
                 page_table_lock(as, false);
-                
-                /*
-                 * Start TLB shootdown sequence.
-                 */
-                ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid,
-                    area->base + P2SZ(pages), area->pages - pages);
                 
                 /*
@@ -726 +720 @@
                                 }
                                 
+                                /*
+                                 * Start TLB shootdown sequence.
+                                 *
+                                 * The sequence is rather short and can be
+                                 * repeated multiple times. The reason is that
+                                 * we don't want to have used_space_remove()
+                                 * inside the sequence as it may use a blocking
+                                 * memory allocation for its B+tree. Blocking
+                                 * while holding the tlblock spinlock is
+                                 * forbidden and would hit a kernel assertion.
+                                 */
+
+                                ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES,
+                                    as->asid, area->base + P2SZ(pages),
+                                    area->pages - pages);
+                
                                 for (; i < size; i++) {
                                         pte_t *pte = page_mapping_find(as,
@@ -743 +753 @@
                                         page_mapping_remove(as, ptr + P2SZ(i));
                                 }
+                
+                                /*
+                                 * Finish TLB shootdown sequence.
+                                 */
+                
+                                tlb_invalidate_pages(as->asid,
+                                    area->base + P2SZ(pages),
+                                    area->pages - pages);
+                
+                                /*
+                                 * Invalidate software translation caches
+                                 * (e.g. TSB on sparc64, PHT on ppc32).
+                                 */
+                                as_invalidate_translation_cache(as,
+                                    area->base + P2SZ(pages),
+                                    area->pages - pages);
+                                tlb_shootdown_finalize(ipl);
                         }
                 }
-                
-                /*
-                 * Finish TLB shootdown sequence.
-                 */
-                
-                tlb_invalidate_pages(as->asid, area->base + P2SZ(pages),
-                    area->pages - pages);
-                
-                /*
-                 * Invalidate software translation caches
-                 * (e.g. TSB on sparc64, PHT on ppc32).
-                 */
-                as_invalidate_translation_cache(as, area->base + P2SZ(pages),
-                    area->pages - pages);
-                tlb_shootdown_finalize(ipl);
-                
                 page_table_unlock(as, false);
         } else {

kernel/generic/src/mm/frame.c

@@ -1086 +1086 @@
 #endif
                 
+                /*
+                 * Since the mem_avail_mtx is an active mutex, we need to disable interrupts
+                 * to prevent deadlock with TLB shootdown.
+                 */
+                ipl_t ipl = interrupts_disable();
                 mutex_lock(&mem_avail_mtx);
                 
@@ -1098 +1103 @@
                 
                 mutex_unlock(&mem_avail_mtx);
+                interrupts_restore(ipl);
                 
 #ifdef CONFIG_DEBUG
@@ -1161 +1167 @@
          * Signal that some memory has been freed.
          */
+
+        
+        /*
+         * Since the mem_avail_mtx is an active mutex, we need to disable interrupts
+         * to prevent deadlock with TLB shootdown.
+         */
+        ipl_t ipl = interrupts_disable();
         mutex_lock(&mem_avail_mtx);
         if (mem_avail_req > 0)
@@ -1170 +1183 @@
         }
         mutex_unlock(&mem_avail_mtx);
+        interrupts_restore(ipl);
         
         if (!(flags & FRAME_NO_RESERVE))

kernel/generic/src/mm/slab.c

@@ -264 +264 @@
                 freed = cache->destructor(obj);
         
-        spinlock_lock(&cache->slablock);
+        irq_spinlock_lock(&cache->slablock, true);
         ASSERT(slab->available < cache->objects);
         
@@ -275 +275 @@
                 /* Free associated memory */
                 list_remove(&slab->link);
-                spinlock_unlock(&cache->slablock);
+                irq_spinlock_unlock(&cache->slablock, true);
                 
                 return freed + slab_space_free(cache, slab);
@@ -284 +284 @@
         }
         
-        spinlock_unlock(&cache->slablock);
+        irq_spinlock_unlock(&cache->slablock, true);
         return freed;
 }
@@ -295 +295 @@
 NO_TRACE static void *slab_obj_create(slab_cache_t *cache, unsigned int flags)
 {
-        spinlock_lock(&cache->slablock);
+        irq_spinlock_lock(&cache->slablock, true);
         
         slab_t *slab;
@@ -308 +308 @@
                  *
                  */
-                spinlock_unlock(&cache->slablock);
+                irq_spinlock_unlock(&cache->slablock, true);
                 slab = slab_space_alloc(cache, flags);
                 if (!slab)
                         return NULL;
                 
-                spinlock_lock(&cache->slablock);
+                irq_spinlock_lock(&cache->slablock, true);
         } else {
                 slab = list_get_instance(list_first(&cache->partial_slabs),
@@ -329 +329 @@
                 list_prepend(&slab->link, &cache->partial_slabs);
         
-        spinlock_unlock(&cache->slablock);
+        irq_spinlock_unlock(&cache->slablock, true);
         
         if ((cache->constructor) && (cache->constructor(obj, flags))) {
@@ -355 +355 @@
         link_t *cur;
         
-        spinlock_lock(&cache->maglock);
+        irq_spinlock_lock(&cache->maglock, true);
         if (!list_empty(&cache->magazines)) {
                 if (first)
@@ -366 +366 @@
                 atomic_dec(&cache->magazine_counter);
         }
-        
-        spinlock_unlock(&cache->maglock);
+        irq_spinlock_unlock(&cache->maglock, true);
+
         return mag;
 }
@@ -377 +377 @@
     slab_magazine_t *mag)
 {
-        spinlock_lock(&cache->maglock);
+        irq_spinlock_lock(&cache->maglock, true);
         
         list_prepend(&mag->link, &cache->magazines);
         atomic_inc(&cache->magazine_counter);
         
-        spinlock_unlock(&cache->maglock);
+        irq_spinlock_unlock(&cache->maglock, true);
 }
 
@@ -414 +414 @@
         slab_magazine_t *lastmag = cache->mag_cache[CPU->id].last;
         
-        ASSERT(spinlock_locked(&cache->mag_cache[CPU->id].lock));
+        ASSERT(irq_spinlock_locked(&cache->mag_cache[CPU->id].lock));
         
         if (cmag) { /* First try local CPU magazines */
@@ -451 +451 @@
                 return NULL;
         
-        spinlock_lock(&cache->mag_cache[CPU->id].lock);
+        irq_spinlock_lock(&cache->mag_cache[CPU->id].lock, true);
         
         slab_magazine_t *mag = get_full_current_mag(cache);
         if (!mag) {
-                spinlock_unlock(&cache->mag_cache[CPU->id].lock);
+                irq_spinlock_unlock(&cache->mag_cache[CPU->id].lock, true);
                 return NULL;
         }
         
         void *obj = mag->objs[--mag->busy];
-        spinlock_unlock(&cache->mag_cache[CPU->id].lock);
+        irq_spinlock_unlock(&cache->mag_cache[CPU->id].lock, true);
         
         atomic_dec(&cache->cached_objs);
@@ -481 +481 @@
         slab_magazine_t *lastmag = cache->mag_cache[CPU->id].last;
         
-        ASSERT(spinlock_locked(&cache->mag_cache[CPU->id].lock));
+        ASSERT(irq_spinlock_locked(&cache->mag_cache[CPU->id].lock));
         
         if (cmag) {
@@ -531 +531 @@
                 return -1;
         
-        spinlock_lock(&cache->mag_cache[CPU->id].lock);
+        irq_spinlock_lock(&cache->mag_cache[CPU->id].lock, true);
         
         slab_magazine_t *mag = make_empty_current_mag(cache);
         if (!mag) {
-                spinlock_unlock(&cache->mag_cache[CPU->id].lock);
+                irq_spinlock_unlock(&cache->mag_cache[CPU->id].lock, true);
                 return -1;
         }
@@ -541 +541 @@
         mag->objs[mag->busy++] = obj;
         
-        spinlock_unlock(&cache->mag_cache[CPU->id].lock);
+        irq_spinlock_unlock(&cache->mag_cache[CPU->id].lock, true);
         
         atomic_inc(&cache->cached_objs);
@@ -593 +593 @@
         for (i = 0; i < config.cpu_count; i++) {
                 memsetb(&cache->mag_cache[i], sizeof(cache->mag_cache[i]), 0);
-                spinlock_initialize(&cache->mag_cache[i].lock,
+                irq_spinlock_initialize(&cache->mag_cache[i].lock,
                     "slab.cache.mag_cache[].lock");
         }
@@ -624 +624 @@
         list_initialize(&cache->magazines);
         
-        spinlock_initialize(&cache->slablock, "slab.cache.slablock");
-        spinlock_initialize(&cache->maglock, "slab.cache.maglock");
+        irq_spinlock_initialize(&cache->slablock, "slab.cache.slablock");
+        irq_spinlock_initialize(&cache->maglock, "slab.cache.maglock");
         
         if (!(cache->flags & SLAB_CACHE_NOMAGAZINE))
@@ -704 +704 @@
                 size_t i;
                 for (i = 0; i < config.cpu_count; i++) {
-                        spinlock_lock(&cache->mag_cache[i].lock);
+                        irq_spinlock_lock(&cache->mag_cache[i].lock, true);
                         
                         mag = cache->mag_cache[i].current;
@@ -716 +716 @@
                         cache->mag_cache[i].last = NULL;
                         
-                        spinlock_unlock(&cache->mag_cache[i].lock);
+                        irq_spinlock_unlock(&cache->mag_cache[i].lock, true);
                 }
         }
@@ -891 +891 @@
 {
         /* Initialize magazine cache */
-        _slab_cache_create(&mag_cache, "slab_magazine",
+        _slab_cache_create(&mag_cache, "slab_magazine_t",
             sizeof(slab_magazine_t) + SLAB_MAG_SIZE * sizeof(void*),
             sizeof(uintptr_t), NULL, NULL, SLAB_CACHE_NOMAGAZINE |
@@ -897 +897 @@
         
         /* Initialize slab_cache cache */
-        _slab_cache_create(&slab_cache_cache, "slab_cache",
+        _slab_cache_create(&slab_cache_cache, "slab_cache_cache",
             sizeof(slab_cache_cache), sizeof(uintptr_t), NULL, NULL,
             SLAB_CACHE_NOMAGAZINE | SLAB_CACHE_SLINSIDE);
         
         /* Initialize external slab cache */
-        slab_extern_cache = slab_cache_create("slab_extern", sizeof(slab_t), 0,
+        slab_extern_cache = slab_cache_create("slab_t", sizeof(slab_t), 0,
             NULL, NULL, SLAB_CACHE_SLINSIDE | SLAB_CACHE_MAGDEFERRED);
         

kernel/generic/src/mm/tlb.c

@@ -162 +162 @@
         
         size_t i;
-        for (i = 0; i < CPU->tlb_messages_count; CPU->tlb_messages_count--) {
+        for (i = 0; i < CPU->tlb_messages_count; i++) {
                 tlb_invalidate_type_t type = CPU->tlb_messages[i].type;
                 asid_t asid = CPU->tlb_messages[i].asid;
@@ -188 +188 @@
         }
         
+        CPU->tlb_messages_count = 0;
         irq_spinlock_unlock(&CPU->lock, false);
         CPU->tlb_active = true;

kernel/generic/src/proc/program.c

@@ -71 +71 @@
 int program_create(as_t *as, uintptr_t entry_addr, char *name, program_t *prg)
 {
-        uspace_arg_t *kernel_uarg;
-        
-        kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
-        kernel_uarg->uspace_entry = (void *) entry_addr;
-        kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
-        kernel_uarg->uspace_thread_function = NULL;
-        kernel_uarg->uspace_thread_arg = NULL;
-        kernel_uarg->uspace_uarg = NULL;
-        
+        prg->loader_status = EE_OK;
         prg->task = task_create(as, name);
         if (!prg->task)
@@ -91 +83 @@
             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
             STACK_SIZE, AS_AREA_ATTR_NONE, &anon_backend, NULL, &virt, 0);
-        if (!area)
+        if (!area) {
+                task_destroy(prg->task);
                 return ENOMEM;
+        }
+        
+        uspace_arg_t *kernel_uarg = (uspace_arg_t *)
+            malloc(sizeof(uspace_arg_t), 0);
+        
+        kernel_uarg->uspace_entry = (void *) entry_addr;
+        kernel_uarg->uspace_stack = (void *) virt;
+        kernel_uarg->uspace_stack_size = STACK_SIZE;
+        kernel_uarg->uspace_thread_function = NULL;
+        kernel_uarg->uspace_thread_arg = NULL;
+        kernel_uarg->uspace_uarg = NULL;
         
         /*
@@ -98 +102 @@
          */
         prg->main_thread = thread_create(uinit, kernel_uarg, prg->task,
-            THREAD_FLAG_USPACE, "uinit", false);
-        if (!prg->main_thread)
+            THREAD_FLAG_USPACE, "uinit");
+        if (!prg->main_thread) {
+                free(kernel_uarg);
+                as_area_destroy(as, virt);
+                task_destroy(prg->task);
                 return ELIMIT;
+        }
         
         return EOK;
@@ -111 +119 @@
  * executable image. The task is returned in *task.
  *
- * @param image_addr Address of an executable program image.
- * @param name       Name to set for the program's task.
- * @param prg        Buffer for storing program info. If image_addr
- *                   points to a loader image, p->task will be set to
- *                   NULL and EOK will be returned.
+ * @param[in]  image_addr Address of an executable program image.
+ * @param[in]  name       Name to set for the program's task.
+ * @param[out] prg        Buffer for storing program info.
+ *                        If image_addr points to a loader image,
+ *                        prg->task will be set to NULL and EOK
+ *                        will be returned.
  *
  * @return EOK on success or negative error code.
@@ -126 +135 @@
                 return ENOMEM;
         
-        unsigned int rc = elf_load((elf_header_t *) image_addr, as, 0);
-        if (rc != EE_OK) {
+        prg->loader_status = elf_load((elf_header_t *) image_addr, as, 0);
+        if (prg->loader_status != EE_OK) {
                 as_destroy(as);
                 prg->task = NULL;
                 prg->main_thread = NULL;
                 
-                if (rc != EE_LOADER)
+                if (prg->loader_status != EE_LOADER)
                         return ENOTSUP;
                 
@@ -140 +149 @@
                 
                 program_loader = image_addr;
-                LOG("Registered program loader at %p",
-                    (void *) image_addr);
+                printf("Program loader at %p\n", (void *) image_addr);
                 
                 return EOK;
@@ -171 +179 @@
         }
         
-        unsigned int rc = elf_load((elf_header_t *) program_loader, as,
+        prg->loader_status = elf_load((elf_header_t *) program_loader, as,
             ELD_F_LOADER);
-        if (rc != EE_OK) {
+        if (prg->loader_status != EE_OK) {
                 as_destroy(as);
-                printf("Cannot spawn loader (%s)\n", elf_error(rc));
+                printf("Cannot spawn loader (%s)\n",
+                    elf_error(prg->loader_status));
                 return ENOENT;
         }

kernel/generic/src/proc/scheduler.c

@@ -98 +98 @@
         else {
                 fpu_init();
-                THREAD->fpu_context_exists = 1;
+                THREAD->fpu_context_exists = true;
         }
 #endif
@@ -142 +142 @@
                 
                 /* Don't prevent migration */
-                CPU->fpu_owner->fpu_context_engaged = 0;
+                CPU->fpu_owner->fpu_context_engaged = false;
                 irq_spinlock_unlock(&CPU->fpu_owner->lock, false);
                 CPU->fpu_owner = NULL;
@@ -163 +163 @@
                 }
                 fpu_init();
-                THREAD->fpu_context_exists = 1;
+                THREAD->fpu_context_exists = true;
         }
         
         CPU->fpu_owner = THREAD;
-        THREAD->fpu_context_engaged = 1;
+        THREAD->fpu_context_engaged = true;
         irq_spinlock_unlock(&THREAD->lock, false);
         
@@ -248 +248 @@
                 
                 /*
-                 * Clear the THREAD_FLAG_STOLEN flag so that t can be migrated
+                 * Clear the stolen flag so that it can be migrated
                  * when load balancing needs emerge.
                  */
-                thread->flags &= ~THREAD_FLAG_STOLEN;
+                thread->stolen = false;
                 irq_spinlock_unlock(&thread->lock, false);
                 
@@ -630 +630 @@
                                 irq_spinlock_lock(&thread->lock, false);
                                 
-                                if (!(thread->flags & THREAD_FLAG_WIRED) &&
-                                    !(thread->flags & THREAD_FLAG_STOLEN) &&
-                                    !thread->nomigrate &&
-                                    !thread->fpu_context_engaged) {
+                                if ((!thread->wired) && (!thread->stolen) &&
+                                    (!thread->nomigrate) &&
+                                    (!thread->fpu_context_engaged)) {
                                         /*
                                          * Remove thread from ready queue.
@@ -670 +669 @@
 #endif
                                 
-                                thread->flags |= THREAD_FLAG_STOLEN;
+                                thread->stolen = true;
                                 thread->state = Entering;
                                 

kernel/generic/src/proc/task.c

@@ -90 +90 @@
         TASK = NULL;
         avltree_create(&tasks_tree);
-        task_slab = slab_cache_create("task_slab", sizeof(task_t), 0,
+        task_slab = slab_cache_create("task_t", sizeof(task_t), 0,
             tsk_constructor, NULL, 0);
 }

kernel/generic/src/proc/thread.c

@@ -191 +191 @@
         kmflags |= FRAME_LOWMEM;
         kmflags &= ~FRAME_HIGHMEM;
-
+        
         thread->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);
         if (!thread->kstack) {
@@ -236 +236 @@
         
         atomic_set(&nrdy, 0);
-        thread_slab = slab_cache_create("thread_slab", sizeof(thread_t), 0,
+        thread_slab = slab_cache_create("thread_t", 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);
+        fpu_context_slab = slab_cache_create("fpu_context_t",
+            sizeof(fpu_context_t), FPU_CONTEXT_ALIGN, NULL, NULL, 0);
 #endif
         
@@ -247 +247 @@
 }
 
+/** Wire thread to the given CPU
+ *
+ * @param cpu CPU to wire the thread to.
+ *
+ */
+void thread_wire(thread_t *thread, cpu_t *cpu)
+{
+        irq_spinlock_lock(&thread->lock, true);
+        thread->cpu = cpu;
+        thread->wired = true;
+        irq_spinlock_unlock(&thread->lock, true);
+}
+
 /** Make thread ready
  *
@@ -260 +273 @@
         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) {
+        int i = (thread->priority < RQ_COUNT - 1) ?
+            ++thread->priority : thread->priority;
+        
+        cpu_t *cpu;
+        if (thread->wired || thread->nomigrate || thread->fpu_context_engaged) {
                 ASSERT(thread->cpu != NULL);
                 cpu = thread->cpu;
-        }
+        } else
+                cpu = CPU;
+        
         thread->state = Ready;
         
@@ -298 +313 @@
  * @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.
@@ -305 +318 @@
  */
 thread_t *thread_create(void (* func)(void *), void *arg, task_t *task,
-    unsigned int flags, const char *name, bool uncounted)
+    thread_flags_t flags, const char *name)
 {
         thread_t *thread = (thread_t *) slab_alloc(thread_slab, 0);
@@ -335 +348 @@
         thread->ucycles = 0;
         thread->kcycles = 0;
-        thread->uncounted = uncounted;
+        thread->uncounted =
+            ((flags & THREAD_FLAG_UNCOUNTED) == THREAD_FLAG_UNCOUNTED);
         thread->priority = -1;          /* Start in rq[0] */
         thread->cpu = NULL;
-        thread->flags = flags;
+        thread->wired = false;
+        thread->stolen = false;
+        thread->uspace =
+            ((flags & THREAD_FLAG_USPACE) == THREAD_FLAG_USPACE);
+        
         thread->nomigrate = 0;
         thread->state = Entering;
@@ -356 +374 @@
         thread->task = task;
         
-        thread->fpu_context_exists = 0;
-        thread->fpu_context_engaged = 0;
+        thread->fpu_context_exists = false;
+        thread->fpu_context_engaged = false;
         
         avltree_node_initialize(&thread->threads_tree_node);
@@ -371 +389 @@
         thread_create_arch(thread);
         
-        if (!(flags & THREAD_FLAG_NOATTACH))
+        if ((flags & THREAD_FLAG_NOATTACH) != THREAD_FLAG_NOATTACH)
                 thread_attach(thread, task);
         
@@ -437 +455 @@
         
         /* Must not count kbox thread into lifecount */
-        if (thread->flags & THREAD_FLAG_USPACE)
+        if (thread->uspace)
                 atomic_inc(&task->lifecount);
         
@@ -459 +477 @@
 void thread_exit(void)
 {
-        if (THREAD->flags & THREAD_FLAG_USPACE) {
+        if (THREAD->uspace) {
 #ifdef CONFIG_UDEBUG
                 /* Generate udebug THREAD_E event */
                 udebug_thread_e_event();
-
+                
                 /*
                  * This thread will not execute any code or system calls from
@@ -506 +524 @@
 {
         ASSERT(THREAD);
-
+        
         THREAD->nomigrate++;
 }
@@ -515 +533 @@
         ASSERT(THREAD);
         ASSERT(THREAD->nomigrate > 0);
-
-        THREAD->nomigrate--;
+        
+        if (THREAD->nomigrate > 0)
+                THREAD->nomigrate--;
 }
 
@@ -854 +873 @@
          * 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 =
@@ -866 +884 @@
         
         thread_t *thread = thread_create(uinit, kernel_uarg, TASK,
-            THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf, false);
+            THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf);
         if (thread) {
                 if (uspace_thread_id != NULL) {

kernel/generic/src/synch/mutex.c

@@ -40 +40 @@
 #include <debug.h>
 #include <arch.h>
+#include <stacktrace.h>
 
 /** Initialize mutex.
@@ -61 +62 @@
         return semaphore_count_get(&mtx->sem) <= 0;
 }
+
+#define MUTEX_DEADLOCK_THRESHOLD        100000000
 
 /** Acquire mutex.
@@ -87 +90 @@
                 ASSERT(!(flags & SYNCH_FLAGS_INTERRUPTIBLE));
                 
+                unsigned int cnt = 0;
+                bool deadlock_reported = false;
                 do {
+                        if (cnt++ > MUTEX_DEADLOCK_THRESHOLD) {
+                                printf("cpu%u: looping on active mutex %p\n",
+                                    CPU->id, mtx);
+                                stack_trace();
+                                cnt = 0;
+                                deadlock_reported = true;
+                        }
                         rc = semaphore_trydown(&mtx->sem);
                 } while (SYNCH_FAILED(rc) &&
                     !(flags & SYNCH_FLAGS_NON_BLOCKING));
+                if (deadlock_reported)
+                        printf("cpu%u: not deadlocked\n", CPU->id);
         }
 

kernel/generic/src/synch/spinlock.c

@@ -44 +44 @@
 #include <debug.h>
 #include <symtab.h>
+#include <stacktrace.h>
 
 #ifdef CONFIG_SMP
@@ -104 +105 @@
                             "caller=%p (%s)\n", CPU->id, lock, lock->name,
                             (void *) CALLER, symtab_fmt_name_lookup(CALLER));
+                        stack_trace();
                         
                         i = 0;
@@ -260 +262 @@
         int rc = spinlock_trylock(&(lock->lock));
         
-        ASSERT_IRQ_SPINLOCK(!lock->guard, lock);
+        ASSERT_IRQ_SPINLOCK((!rc) || (!lock->guard), lock);
         return rc;
 }

kernel/generic/src/sysinfo/sysinfo.c

@@ -97 +97 @@
 void sysinfo_init(void)
 {
-        sysinfo_item_slab = slab_cache_create("sysinfo_item_slab",
+        sysinfo_item_slab = slab_cache_create("sysinfo_item_t",
             sizeof(sysinfo_item_t), 0, sysinfo_item_constructor,
             sysinfo_item_destructor, SLAB_CACHE_MAGDEFERRED);

kernel/generic/src/udebug/udebug.c

@@ -410 +410 @@
                 
                 mutex_lock(&thread->udebug.lock);
-                unsigned int flags = thread->flags;
                 
                 /* Only process userspace threads. */
-                if ((flags & THREAD_FLAG_USPACE) != 0) {
+                if (thread->uspace) {
                         /* Prevent any further debug activity in thread. */
                         thread->udebug.active = false;

kernel/generic/src/udebug/udebug_ops.c

@@ -95 +95 @@
         
         /* Verify that 'thread' is a userspace thread. */
-        if ((thread->flags & THREAD_FLAG_USPACE) == 0) {
+        if (!thread->uspace) {
                 /* It's not, deny its existence */
                 irq_spinlock_unlock(&thread->lock, true);
@@ -200 +200 @@
                 
                 mutex_lock(&thread->udebug.lock);
-                if ((thread->flags & THREAD_FLAG_USPACE) != 0) {
+                if (thread->uspace) {
                         thread->udebug.active = true;
                         mutex_unlock(&thread->udebug.lock);
@@ -393 +393 @@
                 
                 irq_spinlock_lock(&thread->lock, false);
-                int flags = thread->flags;
+                bool uspace = thread->uspace;
                 irq_spinlock_unlock(&thread->lock, false);
                 
                 /* Not interested in kernel threads. */
-                if ((flags & THREAD_FLAG_USPACE) == 0)
+                if (!uspace)
                         continue;