Changeset 90478727 in mainline for kernel/generic/src

Timestamp:

2012-08-12T11:46:44Z (13 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

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

Children:

41b764b7

Parents:

e1e4192 (diff), 371cb6c (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:

merge 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)
• interrupt/interrupt.c (modified) (3 diffs)
• ipc/ipc.c (modified) (1 diff)
• ipc/irq.c (modified) (18 diffs)
• ipc/kbox.c (modified) (1 diff)
• lib/ra.c (modified) (1 diff)
• lib/str.c (modified) (3 diffs)
• main/kinit.c (modified) (4 diffs)
• main/main.c (modified) (1 diff)
• main/uinit.c (modified) (2 diffs)
• mm/as.c (modified) (4 diffs)
• mm/slab.c (modified) (2 diffs)
• mm/tlb.c (modified) (2 diffs)
• proc/program.c (modified) (3 diffs)
• proc/scheduler.c (modified) (6 diffs)
• proc/task.c (modified) (1 diff)
• proc/thread.c (modified) (15 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/interrupt/interrupt.c

@@ -50 +50 @@
 #include <panic.h>
 #include <print.h>
+#include <stdarg.h>
 #include <symtab.h>
 #include <proc/thread.h>
@@ -165 +166 @@
 }
 
-/** Terminate thread and task if exception came from userspace.
- *
- */
-NO_TRACE void fault_if_from_uspace(istate_t *istate, const char *fmt, ...)
-{
-        if (!istate_from_uspace(istate))
-                return;
-        
+static NO_TRACE void fault_from_uspace_core(istate_t *istate, const char *fmt, va_list args)
+{
         printf("Task %s (%" PRIu64 ") killed due to an exception at "
             "program counter %p.\n", TASK->name, TASK->taskid,
@@ -181 +176 @@
         
         printf("Kill message: ");
+        vprintf(fmt, args);
+        printf("\n");
+        
+        task_kill_self(true);
+}
+
+/** Terminate thread and task after the exception came from userspace.
+ *
+ */
+NO_TRACE void fault_from_uspace(istate_t *istate, const char *fmt, ...)
+{
+        va_list args;
+
+        va_start(args, fmt);
+        fault_from_uspace_core(istate, fmt, args);
+        va_end(args);
+}
+
+/** Terminate thread and task if exception came from userspace.
+ *
+ */
+NO_TRACE void fault_if_from_uspace(istate_t *istate, const char *fmt, ...)
+{
+        if (!istate_from_uspace(istate))
+                return;
         
         va_list args;
         va_start(args, fmt);
-        vprintf(fmt, args);
+        fault_from_uspace_core(istate, fmt, args);
         va_end(args);
-        printf("\n");
-        
-        task_kill_self(true);
 }
 

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/irq.c

@@ -39 +39 @@
  * when interrupt is detected. The application may provide a simple 'top-half'
  * handler as part of its registration, which can perform simple operations
- * (read/write port/memory, add information to notification ipc message).
+ * (read/write port/memory, add information to notification IPC message).
  *
  * The structure of a notification message is as follows:
  * - IMETHOD: interface and method as registered by
  *            the SYS_IRQ_REGISTER syscall
- * - ARG1: payload modified by a 'top-half' handler
- * - ARG2: payload modified by a 'top-half' handler
- * - ARG3: payload modified by a 'top-half' handler
- * - ARG4: payload modified by a 'top-half' handler
- * - ARG5: payload modified by a 'top-half' handler
+ * - ARG1: payload modified by a 'top-half' handler (scratch[1])
+ * - ARG2: payload modified by a 'top-half' handler (scratch[2])
+ * - ARG3: payload modified by a 'top-half' handler (scratch[3])
+ * - ARG4: payload modified by a 'top-half' handler (scratch[4])
+ * - ARG5: payload modified by a 'top-half' handler (scratch[5])
  * - in_phone_hash: interrupt counter (may be needed to assure correct order
  *                  in multithreaded drivers)
@@ -87 +87 @@
 static void ranges_unmap(irq_pio_range_t *ranges, size_t rangecount)
 {
-        size_t i;
-
-        for (i = 0; i < rangecount; i++) {
+        for (size_t i = 0; i < rangecount; i++) {
 #ifdef IO_SPACE_BOUNDARY
                 if ((void *) ranges[i].base >= IO_SPACE_BOUNDARY)
@@ -100 +98 @@
     irq_cmd_t *cmds, size_t cmdcount)
 {
-        uintptr_t *pbase;
-        size_t i, j;
-
         /* Copy the physical base addresses aside. */
-        pbase = malloc(rangecount * sizeof(uintptr_t), 0);
-        for (i = 0; i < rangecount; i++)
+        uintptr_t *pbase = malloc(rangecount * sizeof(uintptr_t), 0);
+        for (size_t i = 0; i < rangecount; i++)
                 pbase[i] = ranges[i].base;
-
+        
         /* Map the PIO ranges into the kernel virtual address space. */
-        for (i = 0; i < rangecount; i++) {
+        for (size_t i = 0; i < rangecount; i++) {
 #ifdef IO_SPACE_BOUNDARY
                 if ((void *) ranges[i].base < IO_SPACE_BOUNDARY)
@@ -122 +117 @@
                 }
         }
-
+        
         /* Rewrite the pseudocode addresses from physical to kernel virtual. */
-        for (i = 0; i < cmdcount; i++) {
+        for (size_t i = 0; i < cmdcount; i++) {
                 uintptr_t addr;
                 size_t size;
-
+                
                 /* Process only commands that use an address. */
                 switch (cmds[i].cmd) {
                 case CMD_PIO_READ_8:
-                case CMD_PIO_WRITE_8:
-                case CMD_PIO_WRITE_A_8:
+                case CMD_PIO_WRITE_8:
+                case CMD_PIO_WRITE_A_8:
                         size = 1;
                         break;
-                case CMD_PIO_READ_16:
-                case CMD_PIO_WRITE_16:
-                case CMD_PIO_WRITE_A_16:
+                case CMD_PIO_READ_16:
+                case CMD_PIO_WRITE_16:
+                case CMD_PIO_WRITE_A_16:
                         size = 2;
                         break;
-                case CMD_PIO_READ_32:
-                case CMD_PIO_WRITE_32:
-                case CMD_PIO_WRITE_A_32:
+                case CMD_PIO_READ_32:
+                case CMD_PIO_WRITE_32:
+                case CMD_PIO_WRITE_A_32:
                         size = 4;
                         break;
@@ -149 +144 @@
                         continue;
                 }
-
+                
                 addr = (uintptr_t) cmds[i].addr;
                 
+                size_t j;
                 for (j = 0; j < rangecount; j++) {
-
                         /* Find the matching range. */
                         if (!iswithin(pbase[j], ranges[j].size, addr, size))
                                 continue;
-
+                        
                         /* Switch the command to a kernel virtual address. */
                         addr -= pbase[j];
                         addr += ranges[j].base;
-
+                        
                         cmds[i].addr = (void *) addr;
                         break;
                 }
-
+                
                 if (j == rangecount) {
                         /*
@@ -176 +171 @@
                 }
         }
-
+        
         free(pbase);
+        return EOK;
+}
+
+/** Statically check the top-half pseudocode
+ *
+ * Check the top-half pseudocode for invalid or unsafe
+ * constructs.
+ *
+ */
+static int code_check(irq_cmd_t *cmds, size_t cmdcount)
+{
+        for (size_t i = 0; i < cmdcount; i++) {
+                /*
+                 * Check for accepted ranges.
+                 */
+                if (cmds[i].cmd >= CMD_LAST)
+                        return EINVAL;
+                
+                if (cmds[i].srcarg >= IPC_CALL_LEN)
+                        return EINVAL;
+                
+                if (cmds[i].dstarg >= IPC_CALL_LEN)
+                        return EINVAL;
+                
+                switch (cmds[i].cmd) {
+                case CMD_PREDICATE:
+                        /*
+                         * Check for control flow overflow.
+                         * Note that jumping just beyond the last
+                         * command is a correct behaviour.
+                         */
+                        if (i + cmds[i].value > cmdcount)
+                                return EINVAL;
+                        
+                        break;
+                default:
+                        break;
+                }
+        }
+        
         return EOK;
 }
@@ -207 +242 @@
         irq_pio_range_t *ranges = NULL;
         irq_cmd_t *cmds = NULL;
-
+        
         irq_code_t *code = malloc(sizeof(*code), 0);
         int rc = copy_from_uspace(code, ucode, sizeof(*code));
@@ -222 +257 @@
         if (rc != EOK)
                 goto error;
-
+        
         cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount, 0);
         rc = copy_from_uspace(cmds, code->cmds,
@@ -228 +263 @@
         if (rc != EOK)
                 goto error;
-
+        
+        rc = code_check(cmds, code->cmdcount);
+        if (rc != EOK)
+                goto error;
+        
         rc = ranges_map_and_apply(ranges, code->rangecount, cmds,
             code->cmdcount);
         if (rc != EOK)
                 goto error;
-
+        
         code->ranges = ranges;
         code->cmds = cmds;
-
+        
         return code;
-
+        
 error:
         if (cmds)
                 free(cmds);
+        
         if (ranges)
                 free(ranges);
+        
         free(code);
         return NULL;
@@ -250 +291 @@
 /** Register an answerbox as a receiving end for IRQ notifications.
  *
- * @param box           Receiving answerbox.
- * @param inr           IRQ number.
- * @param devno         Device number.
- * @param imethod       Interface and method to be associated with the
- *                      notification.
- * @param ucode         Uspace pointer to top-half pseudocode.
- * @return              EOK on success or a negative error code.
+ * @param box     Receiving answerbox.
+ * @param inr     IRQ number.
+ * @param devno   Device number.
+ * @param imethod Interface and method to be associated with the
+ *                notification.
+ * @param ucode   Uspace pointer to top-half pseudocode.
+ *
+ * @return EOK on success or a negative error code.
  *
  */
@@ -266 +308 @@
                 (sysarg_t) devno
         };
-
+        
         if ((inr < 0) || (inr > last_inr))
                 return ELIMIT;
@@ -329 +371 @@
 /** Unregister task from IRQ notification.
  *
- * @param box           Answerbox associated with the notification.
- * @param inr           IRQ number.
- * @param devno         Device number.
- * @return              EOK on success or a negative error code.
+ * @param box   Answerbox associated with the notification.
+ * @param inr   IRQ number.
+ * @param devno Device number.
+ *
+ * @return EOK on success or a negative error code.
+ *
  */
 int ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno)
@@ -340 +384 @@
                 (sysarg_t) devno
         };
-
+        
         if ((inr < 0) || (inr > last_inr))
                 return ELIMIT;
@@ -436 +480 @@
                 /* Remove from the hash table. */
                 hash_table_remove(&irq_uspace_hash_table, key, 2);
-
+                
                 /*
                  * Release both locks so that we can free the pseudo code.
@@ -442 +486 @@
                 irq_spinlock_unlock(&box->irq_lock, false);
                 irq_spinlock_unlock(&irq_uspace_hash_table_lock, true);
-
+                
                 code_free(irq->notif_cfg.code);
                 free(irq);
@@ -492 +536 @@
         
         for (size_t i = 0; i < code->cmdcount; i++) {
-                uint32_t dstval;
-                
                 uintptr_t srcarg = code->cmds[i].srcarg;
                 uintptr_t dstarg = code->cmds[i].dstarg;
                 
-                if (srcarg >= IPC_CALL_LEN)
-                        break;
-                
-                if (dstarg >= IPC_CALL_LEN)
-                        break;
-        
                 switch (code->cmds[i].cmd) {
                 case CMD_PIO_READ_8:
-                        dstval = pio_read_8((ioport8_t *) code->cmds[i].addr);
-                        if (dstarg)
-                                scratch[dstarg] = dstval;
+                        scratch[dstarg] =
+                            pio_read_8((ioport8_t *) code->cmds[i].addr);
                         break;
                 case CMD_PIO_READ_16:
-                        dstval = pio_read_16((ioport16_t *) code->cmds[i].addr);
-                        if (dstarg)
-                                scratch[dstarg] = dstval;
+                        scratch[dstarg] =
+                            pio_read_16((ioport16_t *) code->cmds[i].addr);
                         break;
                 case CMD_PIO_READ_32:
-                        dstval = pio_read_32((ioport32_t *) code->cmds[i].addr);
-                        if (dstarg)
-                                scratch[dstarg] = dstval;
+                        scratch[dstarg] =
+                            pio_read_32((ioport32_t *) code->cmds[i].addr);
                         break;
                 case CMD_PIO_WRITE_8:
@@ -532 +565 @@
                         break;
                 case CMD_PIO_WRITE_A_8:
-                        if (srcarg) {
-                                pio_write_8((ioport8_t *) code->cmds[i].addr,
-                                    (uint8_t) scratch[srcarg]);
-                        }
+                        pio_write_8((ioport8_t *) code->cmds[i].addr,
+                            (uint8_t) scratch[srcarg]);
                         break;
                 case CMD_PIO_WRITE_A_16:
-                        if (srcarg) {
-                                pio_write_16((ioport16_t *) code->cmds[i].addr,
-                                    (uint16_t) scratch[srcarg]);
-                        }
+                        pio_write_16((ioport16_t *) code->cmds[i].addr,
+                            (uint16_t) scratch[srcarg]);
                         break;
                 case CMD_PIO_WRITE_A_32:
-                        if (srcarg) {
-                                pio_write_32((ioport32_t *) code->cmds[i].addr,
-                                    (uint32_t) scratch[srcarg]);
-                        }
-                        break;
-                case CMD_BTEST:
-                        if ((srcarg) && (dstarg)) {
-                                dstval = scratch[srcarg] & code->cmds[i].value;
-                                scratch[dstarg] = dstval;
-                        }
+                        pio_write_32((ioport32_t *) code->cmds[i].addr,
+                            (uint32_t) scratch[srcarg]);
+                        break;
+                case CMD_LOAD:
+                        scratch[dstarg] = code->cmds[i].value;
+                        break;
+                case CMD_AND:
+                        scratch[dstarg] = scratch[srcarg] &
+                            code->cmds[i].value;
                         break;
                 case CMD_PREDICATE:
-                        if ((srcarg) && (!scratch[srcarg])) {
+                        if (scratch[srcarg] == 0)
                                 i += code->cmds[i].value;
-                                continue;
-                        }
+                        
                         break;
                 case CMD_ACCEPT:
@@ -582 +609 @@
 {
         ASSERT(irq);
-
+        
         ASSERT(interrupts_disabled());
         ASSERT(irq_spinlock_locked(&irq->lock));

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/lib/ra.c

@@ -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/str.c

@@ -456 +456 @@
  *
  * Do a char-by-char comparison of two NULL-terminated strings.
- * The strings are considered equal iff they consist of the same
- * characters on the minimum of their lengths.
+ * The strings are considered equal iff their length is equal
+ * and both strings consist of the same sequence of characters.
+ *
+ * A string S1 is less than another string S2 if it has a character with
+ * lower value at the first character position where the strings differ.
+ * If the strings differ in length, the shorter one is treated as if
+ * padded by characters with a value of zero.
  *
  * @param s1 First string to compare.
  * @param s2 Second string to compare.
  *
- * @return 0 if the strings are equal, -1 if first is smaller,
- *         1 if second smaller.
+ * @return 0 if the strings are equal, -1 if the first is less than the second,
+ *         1 if the second is less than the first.
  *
  */
@@ -494 +499 @@
  *
  * Do a char-by-char comparison of two NULL-terminated strings.
- * The strings are considered equal iff they consist of the same
- * characters on the minimum of their lengths and the length limit.
+ * The strings are considered equal iff
+ * min(str_length(s1), max_len) == min(str_length(s2), max_len)
+ * and both strings consist of the same sequence of characters,
+ * up to max_len characters.
+ *
+ * A string S1 is less than another string S2 if it has a character with
+ * lower value at the first character position where the strings differ.
+ * If the strings differ in length, the shorter one is treated as if
+ * padded by characters with a value of zero. Only the first max_len
+ * characters are considered.
  *
  * @param s1      First string to compare.
@@ -501 +514 @@
  * @param max_len Maximum number of characters to consider.
  *
- * @return 0 if the strings are equal, -1 if first is smaller,
- *         1 if second smaller.
+ * @return 0 if the strings are equal, -1 if the first is less than the second,
+ *         1 if the second is less than the first.
  *
  */

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);

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/slab.c

@@ -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);
@@ -92 +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;
         
         /*
@@ -99 +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;

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/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;