Changes in kernel/generic/src/main/main.c [25939997:128359eb] in mainline

File:

• kernel/generic/src/main/main.c (modified) (8 diffs)

kernel/generic/src/main/main.c

@@ -80 +80 @@
 #include <arch/arch.h>
 #include <arch.h>
+#include <arch/faddr.h>
 #include <ipc/ipc.h>
 #include <macros.h>
@@ -131 +132 @@
 };
 
-static context_t ctx;
-
-// NOTE: All kernel stacks must be aligned to STACK_SIZE, see CURRENT.
-static const size_t bootstrap_stack_size = STACK_SIZE;
-static _Alignas(STACK_SIZE) uint8_t bootstrap_stack[STACK_SIZE];
-
-/* Just a convenient value for some assembly code. */
-uint8_t *const bootstrap_stack_top = bootstrap_stack + STACK_SIZE;
+context_t ctx;
+
+/** Lowest safe stack virtual address. */
+uintptr_t stack_safe = 0;
 
 /*
@@ -173 +170 @@
             ALIGN_UP((uintptr_t) kdata_end - config.base, PAGE_SIZE);
 
-        context_create(&ctx, main_bsp_separated_stack,
-            bootstrap_stack, bootstrap_stack_size);
+        /*
+         * NOTE: All kernel stacks must be aligned to STACK_SIZE,
+         *       see CURRENT.
+         */
+
+        /* Place the stack after the kernel, init and ballocs. */
+        config.stack_base =
+            ALIGN_UP(config.base + config.kernel_size, STACK_SIZE);
+        config.stack_size = STACK_SIZE;
+
+        /* Avoid placing stack on top of init */
+        size_t i;
+        for (i = 0; i < init.cnt; i++) {
+                uintptr_t p = init.tasks[i].paddr + init.tasks[i].size;
+                uintptr_t bottom = PA2KA(ALIGN_UP(p, STACK_SIZE));
+
+                if (config.stack_base < bottom)
+                        config.stack_base = bottom;
+        }
+
+        /* Avoid placing stack on top of boot allocations. */
+        if (ballocs.size) {
+                uintptr_t bottom =
+                    ALIGN_UP(ballocs.base + ballocs.size, STACK_SIZE);
+                if (config.stack_base < bottom)
+                        config.stack_base = bottom;
+        }
+
+        if (config.stack_base < stack_safe)
+                config.stack_base = ALIGN_UP(stack_safe, STACK_SIZE);
+
+        context_save(&ctx);
+        context_set(&ctx, FADDR(main_bsp_separated_stack),
+            config.stack_base, STACK_SIZE);
         context_restore(&ctx);
         /* not reached */
@@ -191 +220 @@
         version_print();
 
-        LOG("\nconfig.base=%p config.kernel_size=%zu",
-            (void *) config.base, config.kernel_size);
+        LOG("\nconfig.base=%p config.kernel_size=%zu"
+            "\nconfig.stack_base=%p config.stack_size=%zu",
+            (void *) config.base, config.kernel_size,
+            (void *) config.stack_base, config.stack_size);
 
 #ifdef CONFIG_KCONSOLE
@@ -280 +311 @@
         if (!kinit_thread)
                 panic("Cannot create kinit thread.");
-        thread_start(kinit_thread);
-        thread_detach(kinit_thread);
-
-        /*
-         * This call to scheduler_run() will return to kinit,
+        thread_ready(kinit_thread);
+
+        /*
+         * This call to scheduler() will return to kinit,
          * starting the thread of kernel threads.
          */
-        current_copy(CURRENT, (current_t *) CPU_LOCAL->stack);
-        context_replace(scheduler_run, CPU_LOCAL->stack, STACK_SIZE);
+        scheduler();
         /* not reached */
 }
@@ -328 +357 @@
         ARCH_OP(post_cpu_init);
 
+        current_copy(CURRENT, (current_t *) CPU->stack);
+
         /*
          * If we woke kmp up before we left the kernel stack, we could
@@ -333 +364 @@
          * switch to this cpu's private stack prior to waking kmp up.
          */
-        current_copy(CURRENT, (current_t *) CPU_LOCAL->stack);
-        context_replace(main_ap_separated_stack, CPU_LOCAL->stack, STACK_SIZE);
+        context_save(&CPU->saved_context);
+        context_set(&CPU->saved_context, FADDR(main_ap_separated_stack),
+            (uintptr_t) CPU->stack, STACK_SIZE);
+        context_restore(&CPU->saved_context);
         /* not reached */
 }
@@ -350 +383 @@
         timeout_init();
 
-        semaphore_up(&ap_completion_semaphore);
-        scheduler_run();
+        waitq_wakeup(&ap_completion_wq, WAKEUP_FIRST);
+        scheduler();
         /* not reached */
 }