WebSVN – HelenOS – Diff – /branches/dd/kernel/generic/src/main/kinit.c

  * @{
  */
 /**
  * @file
- * @brief   Kernel initialization thread.
+ * @brief Kernel initialization thread.
+ *
  * This file contains kinit kernel thread which carries out
  * high level system initialization.
+ *
  * This file is responsible for finishing SMP configuration
 #include <config.h>
 #include <arch.h>
 #include <proc/scheduler.h>
 #include <proc/task.h>
 #include <proc/thread.h>
+#include <proc/program.h>
 #include <panic.h>
 #include <func.h>
 #include <cpu.h>
 #include <arch/asm.h>
 #include <mm/page.h>
 #include <interrupt.h>
 #include <console/kconsole.h>
 #include <security/cap.h>
 #include <lib/rd.h>
 #include <ipc/ipc.h>
+#include <debug.h>
+#include <string.h>
 #ifdef CONFIG_SMP
 #include <smp/smp.h>
 #endif /* CONFIG_SMP */
 #include <synch/waitq.h>
 #include <synch/spinlock.h>
+#define ALIVE_CHARS  4
+#ifdef CONFIG_KCONSOLE
+static char alive[ALIVE_CHARS] = "-\\|/";
+#endif
+#define INIT_PREFIX      "init:"
+#define INIT_PREFIX_LEN  5
 /** Kernel initialization thread.
+ *
  * kinit takes care of higher level kernel
  * initialization (i.e. thread creation,
  * userspace initialization etc.).
+ *
  * @param arg Not used.
  */
 void kinit(void *arg)
+{
-    thread_t *t;
+#if defined(CONFIG_SMP) || defined(CONFIG_KCONSOLE)
+    thread_t *thread;
+#endif
     /*
      * Detach kinit as nobody will call thread_join_timeout() on it.
      */
     thread_detach(THREAD);
     interrupts_disable();
 #ifdef CONFIG_SMP
     if (config.cpu_count > 1) {
         waitq_initialize(&ap_completion_wq);
         /*
          * Create the kmp thread and wait for its completion.
          * cpu1 through cpuN-1 will come up consecutively and
          * not mess together with kcpulb threads.
          * Just a beautification.
          */
-        if ((t = thread_create(kmp, NULL, TASK, THREAD_FLAG_WIRED,
+        thread = thread_create(kmp, NULL, TASK, THREAD_FLAG_WIRED, "kmp", true);
-            "kmp", true))) {
+        if (thread != NULL) {
-            spinlock_lock(&t->lock);
+            spinlock_lock(&thread->lock);
-            t->cpu = &cpus[0];
+            thread->cpu = &cpus[0];
-            spinlock_unlock(&t->lock);
+            spinlock_unlock(&thread->lock);
-            thread_ready(t);
+            thread_ready(thread);
         } else
-            panic("thread_create/kmp\n");
+            panic("Unable to create kmp thread.");
-        thread_join(t);
+        thread_join(thread);
-        thread_detach(t);
+        thread_detach(thread);
+    }
-#endif /* CONFIG_SMP */
-    /*
-     * Now that all CPUs are up, we can report what we've found.
-     */
-    cpu_list();
-#ifdef CONFIG_SMP
     if (config.cpu_count > 1) {
         count_t i;
         /*
          * For each CPU, create its load balancing thread.
          */
         for (i = 0; i < config.cpu_count; i++) {
-            if ((t = thread_create(kcpulb, NULL, TASK,
+            thread = thread_create(kcpulb, NULL, TASK, THREAD_FLAG_WIRED, "kcpulb", true);
-                THREAD_FLAG_WIRED, "kcpulb", true))) {
+            if (thread != NULL) {
-                spinlock_lock(&t->lock);
+                spinlock_lock(&thread->lock);
-                t->cpu = &cpus[i];
+                thread->cpu = &cpus[i];
-                spinlock_unlock(&t->lock);
+                spinlock_unlock(&thread->lock);
-                thread_ready(t);
+                thread_ready(thread);
             } else
-                panic("thread_create/kcpulb\n");
+                printf("Unable to create kcpulb thread for cpu" PRIc "\n", i);
+        }
+    }
 #endif /* CONFIG_SMP */
     /*
      * At this point SMP, if present, is configured.
      */
     arch_post_smp_init();
+#ifdef CONFIG_KCONSOLE
+    if (stdin) {
+        /*
+         * Create kernel console.
+         */
+        thread = thread_create(kconsole_thread, NULL, TASK, 0, "kconsole", false);
+        if (thread != NULL)
+            thread_ready(thread);
+        else
+            printf("Unable to create kconsole thread\n");
+    }
+#endif /* CONFIG_KCONSOLE */
+    interrupts_enable();
     /*
-     * Create kernel console.
+     * Create user tasks, load RAM disk images.
      */
-    t = thread_create(kconsole, (void *) "kconsole", TASK, 0, "kconsole", false);
-    if (t)
-        thread_ready(t);
-    else
-        panic("thread_create/kconsole\n");
-    interrupts_enable();
     count_t i;
+    program_t programs[CONFIG_INIT_TASKS];
     for (i = 0; i < init.cnt; i++) {
-        /*
-         * Run user tasks, load RAM disk images.
-         */
         if (init.tasks[i].addr % FRAME_SIZE) {
-            printf("init[%d].addr is not frame aligned", i);
+            printf("init[%" PRIc "].addr is not frame aligned\n", i);
             continue;
+        }
-        task_t *utask = task_run_program((void *) init.tasks[i].addr,
-            "uspace");
+        /*
+         * Construct task name from the 'init:' prefix and the
+         * name stored in the init structure (if any).
+         */
+        char namebuf[TASK_NAME_BUFLEN];
+        char *name;
+        name = init.tasks[i].name;
-        if (utask) {
+        if (name[0] == '\0')
+            name = "<unknown>";
+        ASSERT(TASK_NAME_BUFLEN >= INIT_PREFIX_LEN);
+        strncpy(namebuf, INIT_PREFIX, TASK_NAME_BUFLEN);
+        strncpy(namebuf + INIT_PREFIX_LEN, name,
+            TASK_NAME_BUFLEN - INIT_PREFIX_LEN);
+        int rc = program_create_from_image((void *) init.tasks[i].addr,
+            namebuf, &programs[i]);
+        if ((rc == 0) && (programs[i].task != NULL)) {
             /*
              * Set capabilities to init userspace tasks.
              */
-            cap_set(utask, CAP_CAP | CAP_MEM_MANAGER |
+            cap_set(programs[i].task, CAP_CAP | CAP_MEM_MANAGER |
                 CAP_IO_MANAGER | CAP_PREEMPT_CONTROL | CAP_IRQ_REG);
             if (!ipc_phone_0)
-                ipc_phone_0 = &utask->answerbox;
+                ipc_phone_0 = &programs[i].task->answerbox;
+        } else if (rc == 0) {
+            /* It was the program loader and was registered */
         } else {
+            /* RAM disk image */
-            int rd = init_rd((rd_header *) init.tasks[i].addr,
+            int rd = init_rd((rd_header_t *) init.tasks[i].addr, init.tasks[i].size);
-                init.tasks[i].size);
             if (rd != RE_OK)
-                printf("Init binary %zd not used, error code %d.\n", i, rd);
+                printf("Init binary %" PRIc " not used (error %d)\n", i, rd);
+        }
+    }
+    /*
+     * Run user tasks with small delays
+     * to avoid intermixed klog output.
+     *
+     * TODO: This certainly does not guarantee
+     *       anything, it just works in most of the
+     *       cases. Some better way how to achieve
+     *       nice klog output should be found.
+     */
+    for (i = 0; i < init.cnt; i++) {
+        if (programs[i].task != NULL) {
+            program_ready(&programs[i]);
+            thread_usleep(10000);
+        }
+    }
+#ifdef CONFIG_KCONSOLE
     if (!stdin) {
+        thread_sleep(10);
+        printf("kinit: No stdin\nKernel alive: .");
+        unsigned int i = 0;
-        while (1) {
+        while (true) {
+            printf("\b%c", alive[i % ALIVE_CHARS]);
             thread_sleep(1);
-            printf("kinit... ");
+            i++;
+        }
+    }
+#endif /* CONFIG_KCONSOLE */
+}
 /** @}
  */

Subversion Repositories HelenOS

(root)/branches/dd/kernel/generic/src/main/kinit.c – Rev 3022 → 4055