| 78,9 → 78,9 |
|---|
| #include <ipc/ipc.h> |
| #include <macros.h> |
| #include <adt/btree.h> |
| #include <console/klog.h> |
| #include <smp/smp.h> |
| #include <ddi/ddi.h> |
| #include <console/console.h> |
| |
| /** Global configuration structure. */ |
| config_t config; |
| 131,9 → 131,11 |
|---|
| |
| /** Main kernel routine for bootstrap CPU. |
| * |
| * Initializes the kernel by bootstrap CPU. |
| * This function passes control directly to |
| * main_bsp_separated_stack(). |
| * The code here still runs on the boot stack, which knows nothing about |
| * preemption counts. Because of that, this function cannot directly call |
| * functions that disable or enable preemption (e.g. spinlock_lock()). The |
| * primary task of this function is to calculate address of a new stack and |
| * switch to it. |
| * |
| * Assuming interrupts_disable(). |
| * |
| 186,90 → 188,93 |
|---|
| */ |
| void main_bsp_separated_stack(void) |
| { |
| task_t *k; |
| thread_t *t; |
| count_t i; |
| |
| /* Keep this the first thing. */ |
| the_initialize(THE); |
| |
| LOG(); |
| |
| version_print(); |
| |
| LOG("\nconfig.base=%#" PRIp " config.kernel_size=%" PRIs |
| "\nconfig.stack_base=%#" PRIp " config.stack_size=%" PRIs, |
| config.base, config.kernel_size, config.stack_base, |
| config.stack_size); |
| |
| |
| /* |
| * kconsole data structures must be initialized very early |
| * because other subsystems will register their respective |
| * commands. |
| */ |
| kconsole_init(); |
| LOG_EXEC(kconsole_init()); |
| |
| /* |
| * Exception handler initialization, before architecture |
| * starts adding its own handlers |
| */ |
| exc_init(); |
| LOG_EXEC(exc_init()); |
| |
| /* |
| * Memory management subsystems initialization. |
| */ |
| arch_pre_mm_init(); |
| frame_init(); |
| */ |
| LOG_EXEC(arch_pre_mm_init()); |
| LOG_EXEC(frame_init()); |
| |
| /* Initialize at least 1 memory segment big enough for slab to work. */ |
| slab_cache_init(); |
| btree_init(); |
| as_init(); |
| page_init(); |
| tlb_init(); |
| ddi_init(); |
| tasklet_init(); |
| arch_post_mm_init(); |
| LOG_EXEC(slab_cache_init()); |
| LOG_EXEC(btree_init()); |
| LOG_EXEC(as_init()); |
| LOG_EXEC(page_init()); |
| LOG_EXEC(tlb_init()); |
| LOG_EXEC(ddi_init()); |
| LOG_EXEC(tasklet_init()); |
| LOG_EXEC(arch_post_mm_init()); |
| LOG_EXEC(arch_pre_smp_init()); |
| LOG_EXEC(smp_init()); |
| |
| version_print(); |
| printf("kernel: %.*p hardcoded_ktext_size=%zd KB, " |
| "hardcoded_kdata_size=%zd KB\n", sizeof(uintptr_t) * 2, |
| config.base, SIZE2KB(hardcoded_ktext_size), |
| SIZE2KB(hardcoded_kdata_size)); |
| printf("stack: %.*p size=%zd KB\n", sizeof(uintptr_t) * 2, |
| config.stack_base, SIZE2KB(config.stack_size)); |
| |
| arch_pre_smp_init(); |
| smp_init(); |
| /* Slab must be initialized after we know the number of processors. */ |
| slab_enable_cpucache(); |
| LOG_EXEC(slab_enable_cpucache()); |
| |
| printf("Detected %zu CPU(s), %llu MB free memory\n", |
| printf("Detected %" PRIc " CPU(s), %" PRIu64" MB free memory\n", |
| config.cpu_count, SIZE2MB(zone_total_size())); |
| cpu_init(); |
| |
| calibrate_delay_loop(); |
| clock_counter_init(); |
| timeout_init(); |
| scheduler_init(); |
| task_init(); |
| thread_init(); |
| futex_init(); |
| klog_init(); |
| LOG_EXEC(cpu_init()); |
| |
| LOG_EXEC(calibrate_delay_loop()); |
| LOG_EXEC(clock_counter_init()); |
| LOG_EXEC(timeout_init()); |
| LOG_EXEC(scheduler_init()); |
| LOG_EXEC(task_init()); |
| LOG_EXEC(thread_init()); |
| LOG_EXEC(futex_init()); |
| |
| if (init.cnt > 0) { |
| count_t i; |
| for (i = 0; i < init.cnt; i++) |
| printf("init[%zd].addr=%.*p, init[%zd].size=%zd\n", i, |
| sizeof(uintptr_t) * 2, init.tasks[i].addr, i, |
| init.tasks[i].size); |
| printf("init[%" PRIc "].addr=%#" PRIp ", init[%" PRIc |
| "].size=%#" PRIs "\n", i, init.tasks[i].addr, |
| i, init.tasks[i].size); |
| } else |
| printf("No init binaries found\n"); |
| |
| ipc_init(); |
| LOG_EXEC(ipc_init()); |
| LOG_EXEC(klog_init()); |
| |
| /* |
| * Create kernel task. |
| */ |
| k = task_create(AS_KERNEL, "kernel"); |
| if (!k) |
| panic("can't create kernel task\n"); |
| task_t *kernel = task_create(AS_KERNEL, "kernel"); |
| if (!kernel) |
| panic("Can't create kernel task\n"); |
| |
| /* |
| * Create the first thread. |
| */ |
| t = thread_create(kinit, NULL, k, 0, "kinit", true); |
| if (!t) |
| panic("can't create kinit thread\n"); |
| thread_ready(t); |
| thread_t *kinit_thread = thread_create(kinit, NULL, kernel, 0, "kinit", |
| true); |
| if (!kinit_thread) |
| panic("Can't create kinit thread\n"); |
| LOG_EXEC(thread_ready(kinit_thread)); |
| |
| /* |
| * This call to scheduler() will return to kinit, |