[f761f1eb] | 1 | /*
|
---|
[df4ed85] | 2 | * Copyright (c) 2001-2004 Jakub Jermar
|
---|
[f761f1eb] | 3 | * All rights reserved.
|
---|
| 4 | *
|
---|
| 5 | * Redistribution and use in source and binary forms, with or without
|
---|
| 6 | * modification, are permitted provided that the following conditions
|
---|
| 7 | * are met:
|
---|
| 8 | *
|
---|
| 9 | * - Redistributions of source code must retain the above copyright
|
---|
| 10 | * notice, this list of conditions and the following disclaimer.
|
---|
| 11 | * - Redistributions in binary form must reproduce the above copyright
|
---|
| 12 | * notice, this list of conditions and the following disclaimer in the
|
---|
| 13 | * documentation and/or other materials provided with the distribution.
|
---|
| 14 | * - The name of the author may not be used to endorse or promote products
|
---|
| 15 | * derived from this software without specific prior written permission.
|
---|
| 16 | *
|
---|
| 17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
---|
| 18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
---|
| 19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
---|
| 20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
---|
| 21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
---|
| 22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
---|
| 23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
---|
| 24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
---|
| 25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
---|
| 26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
---|
| 27 | */
|
---|
| 28 |
|
---|
[8e3bf3e2] | 29 | /** @addtogroup main
|
---|
[b45c443] | 30 | * @{
|
---|
| 31 | */
|
---|
| 32 |
|
---|
[9179d0a] | 33 | /**
|
---|
[b45c443] | 34 | * @file
|
---|
[9179d0a] | 35 | * @brief Main initialization kernel function for all processors.
|
---|
| 36 | *
|
---|
| 37 | * During kernel boot, all processors, after architecture dependent
|
---|
| 38 | * initialization, start executing code found in this file. After
|
---|
| 39 | * bringing up all subsystems, control is passed to scheduler().
|
---|
| 40 | *
|
---|
| 41 | * The bootstrap processor starts executing main_bsp() while
|
---|
| 42 | * the application processors start executing main_ap().
|
---|
| 43 | *
|
---|
| 44 | * @see scheduler()
|
---|
| 45 | * @see main_bsp()
|
---|
| 46 | * @see main_ap()
|
---|
| 47 | */
|
---|
| 48 |
|
---|
[f761f1eb] | 49 | #include <arch/asm.h>
|
---|
[d5d2a3f] | 50 | #include <context.h>
|
---|
[f761f1eb] | 51 | #include <print.h>
|
---|
[02a99d2] | 52 | #include <panic.h>
|
---|
[940cac0] | 53 | #include <debug.h>
|
---|
[f761f1eb] | 54 | #include <config.h>
|
---|
| 55 | #include <time/clock.h>
|
---|
[b3f8fb7] | 56 | #include <time/timeout.h>
|
---|
[f761f1eb] | 57 | #include <proc/scheduler.h>
|
---|
| 58 | #include <proc/thread.h>
|
---|
| 59 | #include <proc/task.h>
|
---|
| 60 | #include <main/kinit.h>
|
---|
[5fe5f1e] | 61 | #include <main/version.h>
|
---|
[f4338d2] | 62 | #include <console/kconsole.h>
|
---|
[f761f1eb] | 63 | #include <cpu.h>
|
---|
[e0cdb7b6] | 64 | #include <align.h>
|
---|
[aace6624] | 65 | #include <interrupt.h>
|
---|
[f761f1eb] | 66 | #include <mm/frame.h>
|
---|
| 67 | #include <mm/page.h>
|
---|
[6d7ffa65] | 68 | #include <genarch/mm/page_pt.h>
|
---|
[169587a] | 69 | #include <mm/tlb.h>
|
---|
[20d50a1] | 70 | #include <mm/as.h>
|
---|
[4e147a6] | 71 | #include <mm/slab.h>
|
---|
[f761f1eb] | 72 | #include <synch/waitq.h>
|
---|
[9aa72b4] | 73 | #include <synch/futex.h>
|
---|
[393f631] | 74 | #include <arch/arch.h>
|
---|
[f761f1eb] | 75 | #include <arch.h>
|
---|
[f2ffad4] | 76 | #include <arch/faddr.h>
|
---|
[6d9c49a] | 77 | #include <ipc/ipc.h>
|
---|
[93165be] | 78 | #include <macros.h>
|
---|
[2810636] | 79 | #include <adt/btree.h>
|
---|
[874621f] | 80 | #include <console/klog.h>
|
---|
[5fe5f1e] | 81 | #include <smp/smp.h>
|
---|
[f8ddd17] | 82 | #include <ddi/ddi.h>
|
---|
[5fe5f1e] | 83 |
|
---|
[e459f12] | 84 | /** Global configuration structure. */
|
---|
[cc73a8a1] | 85 | config_t config;
|
---|
[e459f12] | 86 |
|
---|
| 87 | /** Initial user-space tasks */
|
---|
| 88 | init_t init = {
|
---|
| 89 | 0
|
---|
| 90 | };
|
---|
[5fe5f1e] | 91 |
|
---|
[61e90dd] | 92 | /** Boot allocations. */
|
---|
| 93 | ballocs_t ballocs = {
|
---|
| 94 | .base = NULL,
|
---|
| 95 | .size = 0
|
---|
| 96 | };
|
---|
| 97 |
|
---|
[f761f1eb] | 98 | context_t ctx;
|
---|
| 99 |
|
---|
[cc73a8a1] | 100 | /*
|
---|
[880de6e] | 101 | * These 'hardcoded' variables will be intialized by
|
---|
[dcbc8be] | 102 | * the linker or the low level assembler code with
|
---|
| 103 | * appropriate sizes and addresses.
|
---|
[f761f1eb] | 104 | */
|
---|
[f8ddd17] | 105 | uintptr_t hardcoded_load_address = 0; /**< Virtual address of where the kernel
|
---|
| 106 | * is loaded. */
|
---|
| 107 | size_t hardcoded_ktext_size = 0; /**< Size of the kernel code in bytes.
|
---|
| 108 | */
|
---|
| 109 | size_t hardcoded_kdata_size = 0; /**< Size of the kernel data in bytes.
|
---|
| 110 | */
|
---|
| 111 | uintptr_t stack_safe = 0; /**< Lowest safe stack virtual address.
|
---|
| 112 | */
|
---|
[deaa22f] | 113 |
|
---|
[f761f1eb] | 114 | void main_bsp(void);
|
---|
| 115 | void main_ap(void);
|
---|
| 116 |
|
---|
| 117 | /*
|
---|
| 118 | * These two functions prevent stack from underflowing during the
|
---|
| 119 | * kernel boot phase when SP is set to the very top of the reserved
|
---|
| 120 | * space. The stack could get corrupted by a fooled compiler-generated
|
---|
| 121 | * pop sequence otherwise.
|
---|
| 122 | */
|
---|
| 123 | static void main_bsp_separated_stack(void);
|
---|
[80d2bdb] | 124 | #ifdef CONFIG_SMP
|
---|
[f761f1eb] | 125 | static void main_ap_separated_stack(void);
|
---|
[80d2bdb] | 126 | #endif
|
---|
[f761f1eb] | 127 |
|
---|
[771cd22] | 128 | #define CONFIG_STACK_SIZE ((1 << STACK_FRAMES) * STACK_SIZE)
|
---|
[b6d4566] | 129 |
|
---|
[7f0837c] | 130 | /** Main kernel routine for bootstrap CPU.
|
---|
[673104e] | 131 | *
|
---|
| 132 | * Initializes the kernel by bootstrap CPU.
|
---|
[5fe5f1e] | 133 | * This function passes control directly to
|
---|
| 134 | * main_bsp_separated_stack().
|
---|
[673104e] | 135 | *
|
---|
[22f7769] | 136 | * Assuming interrupts_disable().
|
---|
[673104e] | 137 | *
|
---|
[f761f1eb] | 138 | */
|
---|
| 139 | void main_bsp(void)
|
---|
| 140 | {
|
---|
| 141 | config.cpu_count = 1;
|
---|
| 142 | config.cpu_active = 1;
|
---|
[d6e8529] | 143 |
|
---|
[aed4eca] | 144 | config.base = hardcoded_load_address;
|
---|
[f8ddd17] | 145 | config.kernel_size = ALIGN_UP(hardcoded_ktext_size +
|
---|
[6f4495f5] | 146 | hardcoded_kdata_size, PAGE_SIZE);
|
---|
[deaa22f] | 147 | config.stack_size = CONFIG_STACK_SIZE;
|
---|
| 148 |
|
---|
| 149 | /* Initialy the stack is placed just after the kernel */
|
---|
| 150 | config.stack_base = config.base + config.kernel_size;
|
---|
[b6b576c] | 151 |
|
---|
[deaa22f] | 152 | /* Avoid placing stack on top of init */
|
---|
[b6b576c] | 153 | count_t i;
|
---|
[deaa22f] | 154 | for (i = 0; i < init.cnt; i++) {
|
---|
[f8ddd17] | 155 | if (PA_overlaps(config.stack_base, config.stack_size,
|
---|
[6f4495f5] | 156 | init.tasks[i].addr, init.tasks[i].size))
|
---|
[f8ddd17] | 157 | config.stack_base = ALIGN_UP(init.tasks[i].addr +
|
---|
[6f4495f5] | 158 | init.tasks[i].size, config.stack_size);
|
---|
[deaa22f] | 159 | }
|
---|
[61e90dd] | 160 |
|
---|
| 161 | /* Avoid placing stack on top of boot allocations. */
|
---|
| 162 | if (ballocs.size) {
|
---|
[f8ddd17] | 163 | if (PA_overlaps(config.stack_base, config.stack_size,
|
---|
[6f4495f5] | 164 | ballocs.base, ballocs.size))
|
---|
[f8ddd17] | 165 | config.stack_base = ALIGN_UP(ballocs.base +
|
---|
[6f4495f5] | 166 | ballocs.size, PAGE_SIZE);
|
---|
[61e90dd] | 167 | }
|
---|
[b6b576c] | 168 |
|
---|
[deaa22f] | 169 | if (config.stack_base < stack_safe)
|
---|
| 170 | config.stack_base = ALIGN_UP(stack_safe, PAGE_SIZE);
|
---|
[393f631] | 171 |
|
---|
[be50915] | 172 | context_save(&ctx);
|
---|
[f8ddd17] | 173 | context_set(&ctx, FADDR(main_bsp_separated_stack), config.stack_base,
|
---|
[6f4495f5] | 174 | THREAD_STACK_SIZE);
|
---|
[be50915] | 175 | context_restore(&ctx);
|
---|
[f761f1eb] | 176 | /* not reached */
|
---|
| 177 | }
|
---|
| 178 |
|
---|
[673104e] | 179 |
|
---|
[7f0837c] | 180 | /** Main kernel routine for bootstrap CPU using new stack.
|
---|
[673104e] | 181 | *
|
---|
| 182 | * Second part of main_bsp().
|
---|
| 183 | *
|
---|
| 184 | */
|
---|
[fde6429] | 185 | void main_bsp_separated_stack(void)
|
---|
| 186 | {
|
---|
[f761f1eb] | 187 | task_t *k;
|
---|
| 188 | thread_t *t;
|
---|
[9aa72b4] | 189 | count_t i;
|
---|
[8f91729] | 190 |
|
---|
[bcdd9aa] | 191 | the_initialize(THE);
|
---|
[9aa72b4] | 192 |
|
---|
[ff3b3197] | 193 | /*
|
---|
| 194 | * kconsole data structures must be initialized very early
|
---|
| 195 | * because other subsystems will register their respective
|
---|
| 196 | * commands.
|
---|
| 197 | */
|
---|
| 198 | kconsole_init();
|
---|
[b6b576c] | 199 |
|
---|
[ef67bab] | 200 | /*
|
---|
| 201 | * Exception handler initialization, before architecture
|
---|
[0132630] | 202 | * starts adding its own handlers
|
---|
[aace6624] | 203 | */
|
---|
| 204 | exc_init();
|
---|
[fc1e4f6] | 205 |
|
---|
| 206 | /*
|
---|
| 207 | * Memory management subsystems initialization.
|
---|
| 208 | */
|
---|
[1fbbcd6] | 209 | arch_pre_mm_init();
|
---|
[f8ddd17] | 210 | frame_init();
|
---|
| 211 | /* Initialize at least 1 memory segment big enough for slab to work. */
|
---|
[8e1ea655] | 212 | slab_cache_init();
|
---|
[2810636] | 213 | btree_init();
|
---|
[ef67bab] | 214 | as_init();
|
---|
[7eade45] | 215 | page_init();
|
---|
| 216 | tlb_init();
|
---|
[f8ddd17] | 217 | ddi_init();
|
---|
[d6e5cbc] | 218 | arch_post_mm_init();
|
---|
[71eef11] | 219 |
|
---|
[018d957e] | 220 | version_print();
|
---|
[71eef11] | 221 | printf("kernel: %.*p hardcoded_ktext_size=%zd KB, "
|
---|
| 222 | "hardcoded_kdata_size=%zd KB\n", sizeof(uintptr_t) * 2,
|
---|
| 223 | config.base, SIZE2KB(hardcoded_ktext_size),
|
---|
| 224 | SIZE2KB(hardcoded_kdata_size));
|
---|
| 225 | printf("stack: %.*p size=%zd KB\n", sizeof(uintptr_t) * 2,
|
---|
| 226 | config.stack_base, SIZE2KB(config.stack_size));
|
---|
| 227 |
|
---|
[7453929] | 228 | arch_pre_smp_init();
|
---|
[ed0dd65] | 229 | smp_init();
|
---|
[f8ddd17] | 230 | /* Slab must be initialized after we know the number of processors. */
|
---|
| 231 | slab_enable_cpucache();
|
---|
[71eef11] | 232 |
|
---|
| 233 | printf("Detected %zu CPU(s), %llu MB free memory\n",
|
---|
| 234 | config.cpu_count, SIZE2MB(zone_total_size()));
|
---|
[f761f1eb] | 235 | cpu_init();
|
---|
[6f8a426] | 236 |
|
---|
[f761f1eb] | 237 | calibrate_delay_loop();
|
---|
[d6e5cbc] | 238 | clock_counter_init();
|
---|
[f761f1eb] | 239 | timeout_init();
|
---|
| 240 | scheduler_init();
|
---|
| 241 | task_init();
|
---|
| 242 | thread_init();
|
---|
[9aa72b4] | 243 | futex_init();
|
---|
[874621f] | 244 | klog_init();
|
---|
[6c68b97] | 245 |
|
---|
[c06eb06] | 246 | if (init.cnt > 0) {
|
---|
| 247 | for (i = 0; i < init.cnt; i++)
|
---|
[f8ddd17] | 248 | printf("init[%zd].addr=%.*p, init[%zd].size=%zd\n", i,
|
---|
[6f4495f5] | 249 | sizeof(uintptr_t) * 2, init.tasks[i].addr, i,
|
---|
| 250 | init.tasks[i].size);
|
---|
[c06eb06] | 251 | } else
|
---|
[228b135] | 252 | printf("No init binaries found\n");
|
---|
[6d9c49a] | 253 |
|
---|
| 254 | ipc_init();
|
---|
[9aa72b4] | 255 |
|
---|
[f761f1eb] | 256 | /*
|
---|
| 257 | * Create kernel task.
|
---|
| 258 | */
|
---|
[0313ff0] | 259 | k = task_create(AS_KERNEL, "kernel");
|
---|
[393f631] | 260 | if (!k)
|
---|
| 261 | panic("can't create kernel task\n");
|
---|
[6f8a426] | 262 |
|
---|
[f761f1eb] | 263 | /*
|
---|
| 264 | * Create the first thread.
|
---|
| 265 | */
|
---|
[62b6d17] | 266 | t = thread_create(kinit, NULL, k, 0, "kinit", true);
|
---|
[393f631] | 267 | if (!t)
|
---|
| 268 | panic("can't create kinit thread\n");
|
---|
[f761f1eb] | 269 | thread_ready(t);
|
---|
[6f8a426] | 270 |
|
---|
[f761f1eb] | 271 | /*
|
---|
| 272 | * This call to scheduler() will return to kinit,
|
---|
| 273 | * starting the thread of kernel threads.
|
---|
| 274 | */
|
---|
| 275 | scheduler();
|
---|
| 276 | /* not reached */
|
---|
| 277 | }
|
---|
| 278 |
|
---|
[673104e] | 279 |
|
---|
[5f85c91] | 280 | #ifdef CONFIG_SMP
|
---|
[7f0837c] | 281 | /** Main kernel routine for application CPUs.
|
---|
[673104e] | 282 | *
|
---|
| 283 | * Executed by application processors, temporary stack
|
---|
[26678e5] | 284 | * is at ctx.sp which was set during BSP boot.
|
---|
[5fe5f1e] | 285 | * This function passes control directly to
|
---|
| 286 | * main_ap_separated_stack().
|
---|
[673104e] | 287 | *
|
---|
[22f7769] | 288 | * Assuming interrupts_disable()'d.
|
---|
[673104e] | 289 | *
|
---|
[f761f1eb] | 290 | */
|
---|
| 291 | void main_ap(void)
|
---|
| 292 | {
|
---|
| 293 | /*
|
---|
| 294 | * Incrementing the active CPU counter will guarantee that the
|
---|
[26678e5] | 295 | * *_init() functions can find out that they need to
|
---|
| 296 | * do initialization for AP only.
|
---|
[f761f1eb] | 297 | */
|
---|
| 298 | config.cpu_active++;
|
---|
| 299 |
|
---|
[7ce9284] | 300 | /*
|
---|
| 301 | * The THE structure is well defined because ctx.sp is used as stack.
|
---|
| 302 | */
|
---|
| 303 | the_initialize(THE);
|
---|
[c0b45fa] | 304 |
|
---|
[f07bba5] | 305 | arch_pre_mm_init();
|
---|
[f761f1eb] | 306 | frame_init();
|
---|
| 307 | page_init();
|
---|
[ce031f0] | 308 | tlb_init();
|
---|
[f07bba5] | 309 | arch_post_mm_init();
|
---|
[c0b45fa] | 310 |
|
---|
[f761f1eb] | 311 | cpu_init();
|
---|
| 312 | calibrate_delay_loop();
|
---|
[26678e5] | 313 | arch_post_cpu_init();
|
---|
[f761f1eb] | 314 |
|
---|
[7ce9284] | 315 | the_copy(THE, (the_t *) CPU->stack);
|
---|
[f761f1eb] | 316 |
|
---|
| 317 | /*
|
---|
| 318 | * If we woke kmp up before we left the kernel stack, we could
|
---|
| 319 | * collide with another CPU coming up. To prevent this, we
|
---|
| 320 | * switch to this cpu's private stack prior to waking kmp up.
|
---|
| 321 | */
|
---|
[f8ddd17] | 322 | context_set(&CPU->saved_context, FADDR(main_ap_separated_stack),
|
---|
[6f4495f5] | 323 | (uintptr_t) CPU->stack, CPU_STACK_SIZE);
|
---|
[be50915] | 324 | context_restore(&CPU->saved_context);
|
---|
[f761f1eb] | 325 | /* not reached */
|
---|
| 326 | }
|
---|
| 327 |
|
---|
[673104e] | 328 |
|
---|
[7f0837c] | 329 | /** Main kernel routine for application CPUs using new stack.
|
---|
[673104e] | 330 | *
|
---|
| 331 | * Second part of main_ap().
|
---|
| 332 | *
|
---|
| 333 | */
|
---|
[f761f1eb] | 334 | void main_ap_separated_stack(void)
|
---|
| 335 | {
|
---|
| 336 | /*
|
---|
| 337 | * Configure timeouts for this cpu.
|
---|
| 338 | */
|
---|
| 339 | timeout_init();
|
---|
| 340 |
|
---|
| 341 | waitq_wakeup(&ap_completion_wq, WAKEUP_FIRST);
|
---|
| 342 | scheduler();
|
---|
| 343 | /* not reached */
|
---|
| 344 | }
|
---|
[5f85c91] | 345 | #endif /* CONFIG_SMP */
|
---|
[b45c443] | 346 |
|
---|
[8e3bf3e2] | 347 | /** @}
|
---|
[b45c443] | 348 | */
|
---|