Rev 3424 | Rev 3597 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1 | jermar | 1 | /* |
2071 | jermar | 2 | * Copyright (c) 2001-2004 Jakub Jermar |
1 | jermar | 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 | |||
1729 | decky | 29 | /** @addtogroup main |
1702 | cejka | 30 | * @{ |
31 | */ |
||
32 | |||
1248 | jermar | 33 | /** |
1702 | cejka | 34 | * @file |
1248 | jermar | 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 | |||
1 | jermar | 49 | #include <arch/asm.h> |
97 | jermar | 50 | #include <context.h> |
1 | jermar | 51 | #include <print.h> |
68 | decky | 52 | #include <panic.h> |
561 | decky | 53 | #include <debug.h> |
1 | jermar | 54 | #include <config.h> |
55 | #include <time/clock.h> |
||
2089 | decky | 56 | #include <time/timeout.h> |
1 | jermar | 57 | #include <proc/scheduler.h> |
58 | #include <proc/thread.h> |
||
59 | #include <proc/task.h> |
||
2746 | decky | 60 | #include <proc/tasklet.h> |
1 | jermar | 61 | #include <main/kinit.h> |
675 | jermar | 62 | #include <main/version.h> |
518 | jermar | 63 | #include <console/kconsole.h> |
3425 | svoboda | 64 | #include <console/console.h> |
1 | jermar | 65 | #include <cpu.h> |
402 | jermar | 66 | #include <align.h> |
578 | palkovsky | 67 | #include <interrupt.h> |
1 | jermar | 68 | #include <mm/frame.h> |
69 | #include <mm/page.h> |
||
684 | jermar | 70 | #include <genarch/mm/page_pt.h> |
5 | jermar | 71 | #include <mm/tlb.h> |
703 | jermar | 72 | #include <mm/as.h> |
759 | palkovsky | 73 | #include <mm/slab.h> |
1 | jermar | 74 | #include <synch/waitq.h> |
1109 | jermar | 75 | #include <synch/futex.h> |
210 | decky | 76 | #include <arch/arch.h> |
1 | jermar | 77 | #include <arch.h> |
76 | jermar | 78 | #include <arch/faddr.h> |
955 | palkovsky | 79 | #include <ipc/ipc.h> |
1063 | palkovsky | 80 | #include <macros.h> |
1164 | jermar | 81 | #include <adt/btree.h> |
675 | jermar | 82 | #include <smp/smp.h> |
2015 | jermar | 83 | #include <ddi/ddi.h> |
675 | jermar | 84 | |
3425 | svoboda | 85 | |
1315 | jermar | 86 | /** Global configuration structure. */ |
1757 | jermar | 87 | config_t config; |
675 | jermar | 88 | |
1315 | jermar | 89 | /** Initial user-space tasks */ |
90 | init_t init = { |
||
2745 | decky | 91 | .cnt = 0 |
1315 | jermar | 92 | }; |
93 | |||
1894 | jermar | 94 | /** Boot allocations. */ |
95 | ballocs_t ballocs = { |
||
96 | .base = NULL, |
||
97 | .size = 0 |
||
98 | }; |
||
99 | |||
1 | jermar | 100 | context_t ctx; |
101 | |||
1757 | jermar | 102 | /* |
523 | jermar | 103 | * These 'hardcoded' variables will be intialized by |
105 | jermar | 104 | * the linker or the low level assembler code with |
105 | * appropriate sizes and addresses. |
||
1 | jermar | 106 | */ |
107 | |||
2746 | decky | 108 | /**< Virtual address of where the kernel is loaded. */ |
109 | uintptr_t hardcoded_load_address = 0; |
||
110 | /**< Size of the kernel code in bytes. */ |
||
111 | size_t hardcoded_ktext_size = 0; |
||
112 | /**< Size of the kernel data in bytes. */ |
||
113 | size_t hardcoded_kdata_size = 0; |
||
114 | /**< Lowest safe stack virtual address. */ |
||
115 | uintptr_t stack_safe = 0; |
||
116 | |||
1 | jermar | 117 | void main_bsp(void); |
118 | void main_ap(void); |
||
119 | |||
120 | /* |
||
121 | * These two functions prevent stack from underflowing during the |
||
122 | * kernel boot phase when SP is set to the very top of the reserved |
||
123 | * space. The stack could get corrupted by a fooled compiler-generated |
||
124 | * pop sequence otherwise. |
||
125 | */ |
||
126 | static void main_bsp_separated_stack(void); |
||
625 | palkovsky | 127 | #ifdef CONFIG_SMP |
1 | jermar | 128 | static void main_ap_separated_stack(void); |
625 | palkovsky | 129 | #endif |
1 | jermar | 130 | |
2048 | jermar | 131 | #define CONFIG_STACK_SIZE ((1 << STACK_FRAMES) * STACK_SIZE) |
1138 | jermar | 132 | |
1229 | jermar | 133 | /** Main kernel routine for bootstrap CPU. |
108 | decky | 134 | * |
3424 | svoboda | 135 | * The code here still runs on the boot stack, which knows nothing about |
136 | * preemption counts. Because of that, this function cannot directly call |
||
137 | * functions that disable or enable preemption (e.g. spinlock_lock()). The |
||
138 | * primary task of this function is to calculate address of a new stack and |
||
139 | * switch to it. |
||
108 | decky | 140 | * |
413 | jermar | 141 | * Assuming interrupts_disable(). |
108 | decky | 142 | * |
1 | jermar | 143 | */ |
144 | void main_bsp(void) |
||
145 | { |
||
146 | config.cpu_count = 1; |
||
147 | config.cpu_active = 1; |
||
651 | decky | 148 | |
369 | jermar | 149 | config.base = hardcoded_load_address; |
2015 | jermar | 150 | config.kernel_size = ALIGN_UP(hardcoded_ktext_size + |
2087 | jermar | 151 | hardcoded_kdata_size, PAGE_SIZE); |
1833 | decky | 152 | config.stack_size = CONFIG_STACK_SIZE; |
1037 | decky | 153 | |
1833 | decky | 154 | /* Initialy the stack is placed just after the kernel */ |
155 | config.stack_base = config.base + config.kernel_size; |
||
156 | |||
157 | /* Avoid placing stack on top of init */ |
||
1037 | decky | 158 | count_t i; |
1833 | decky | 159 | for (i = 0; i < init.cnt; i++) { |
2015 | jermar | 160 | if (PA_overlaps(config.stack_base, config.stack_size, |
2087 | jermar | 161 | init.tasks[i].addr, init.tasks[i].size)) |
2015 | jermar | 162 | config.stack_base = ALIGN_UP(init.tasks[i].addr + |
2087 | jermar | 163 | init.tasks[i].size, config.stack_size); |
1833 | decky | 164 | } |
1894 | jermar | 165 | |
166 | /* Avoid placing stack on top of boot allocations. */ |
||
167 | if (ballocs.size) { |
||
2015 | jermar | 168 | if (PA_overlaps(config.stack_base, config.stack_size, |
2087 | jermar | 169 | ballocs.base, ballocs.size)) |
2015 | jermar | 170 | config.stack_base = ALIGN_UP(ballocs.base + |
2087 | jermar | 171 | ballocs.size, PAGE_SIZE); |
1894 | jermar | 172 | } |
1037 | decky | 173 | |
1833 | decky | 174 | if (config.stack_base < stack_safe) |
175 | config.stack_base = ALIGN_UP(stack_safe, PAGE_SIZE); |
||
210 | decky | 176 | |
47 | jermar | 177 | context_save(&ctx); |
2015 | jermar | 178 | context_set(&ctx, FADDR(main_bsp_separated_stack), config.stack_base, |
2087 | jermar | 179 | THREAD_STACK_SIZE); |
47 | jermar | 180 | context_restore(&ctx); |
1 | jermar | 181 | /* not reached */ |
182 | } |
||
183 | |||
108 | decky | 184 | |
1229 | jermar | 185 | /** Main kernel routine for bootstrap CPU using new stack. |
108 | decky | 186 | * |
187 | * Second part of main_bsp(). |
||
188 | * |
||
189 | */ |
||
174 | jermar | 190 | void main_bsp_separated_stack(void) |
191 | { |
||
3424 | svoboda | 192 | /* Keep this the first thing. */ |
184 | jermar | 193 | the_initialize(THE); |
1109 | jermar | 194 | |
3424 | svoboda | 195 | LOG(); |
196 | |||
197 | version_print(); |
||
198 | |||
199 | LOG("\nconfig.base=%#" PRIp " config.kernel_size=%" PRIs |
||
200 | "\nconfig.stack_base=%#" PRIp " config.stack_size=%" PRIs, |
||
201 | config.base, config.kernel_size, config.stack_base, |
||
202 | config.stack_size); |
||
203 | |||
204 | |||
517 | jermar | 205 | /* |
206 | * kconsole data structures must be initialized very early |
||
207 | * because other subsystems will register their respective |
||
208 | * commands. |
||
209 | */ |
||
3424 | svoboda | 210 | LOG_EXEC(kconsole_init()); |
1037 | decky | 211 | |
756 | jermar | 212 | /* |
213 | * Exception handler initialization, before architecture |
||
673 | jermar | 214 | * starts adding its own handlers |
578 | palkovsky | 215 | */ |
3424 | svoboda | 216 | LOG_EXEC(exc_init()); |
755 | jermar | 217 | |
218 | /* |
||
219 | * Memory management subsystems initialization. |
||
3424 | svoboda | 220 | */ |
221 | LOG_EXEC(arch_pre_mm_init()); |
||
222 | LOG_EXEC(frame_init()); |
||
223 | |||
2015 | jermar | 224 | /* Initialize at least 1 memory segment big enough for slab to work. */ |
3424 | svoboda | 225 | LOG_EXEC(slab_cache_init()); |
226 | LOG_EXEC(btree_init()); |
||
227 | LOG_EXEC(as_init()); |
||
228 | LOG_EXEC(page_init()); |
||
229 | LOG_EXEC(tlb_init()); |
||
230 | LOG_EXEC(ddi_init()); |
||
231 | LOG_EXEC(tasklet_init()); |
||
232 | LOG_EXEC(arch_post_mm_init()); |
||
233 | LOG_EXEC(arch_pre_smp_init()); |
||
234 | LOG_EXEC(smp_init()); |
||
2725 | decky | 235 | |
2015 | jermar | 236 | /* Slab must be initialized after we know the number of processors. */ |
3424 | svoboda | 237 | LOG_EXEC(slab_enable_cpucache()); |
2725 | decky | 238 | |
3425 | svoboda | 239 | printf("Detected %" PRIc " CPU(s), %" PRIu64" MiB free memory\n", |
240 | config.cpu_count, SIZE2MB(zone_total_size())); |
||
860 | decky | 241 | |
3424 | svoboda | 242 | LOG_EXEC(cpu_init()); |
628 | decky | 243 | |
3424 | svoboda | 244 | LOG_EXEC(calibrate_delay_loop()); |
245 | LOG_EXEC(clock_counter_init()); |
||
246 | LOG_EXEC(timeout_init()); |
||
247 | LOG_EXEC(scheduler_init()); |
||
248 | LOG_EXEC(task_init()); |
||
249 | LOG_EXEC(thread_init()); |
||
250 | LOG_EXEC(futex_init()); |
||
251 | |||
1826 | decky | 252 | if (init.cnt > 0) { |
3424 | svoboda | 253 | count_t i; |
1826 | decky | 254 | for (i = 0; i < init.cnt; i++) |
3424 | svoboda | 255 | printf("init[%" PRIc "].addr=%#" PRIp ", init[%" PRIc |
3425 | svoboda | 256 | "].size=%#" PRIs "\n", i, init.tasks[i].addr, i, |
257 | init.tasks[i].size); |
||
1826 | decky | 258 | } else |
1999 | decky | 259 | printf("No init binaries found\n"); |
955 | palkovsky | 260 | |
3424 | svoboda | 261 | LOG_EXEC(ipc_init()); |
262 | LOG_EXEC(klog_init()); |
||
1109 | jermar | 263 | |
1 | jermar | 264 | /* |
265 | * Create kernel task. |
||
266 | */ |
||
3424 | svoboda | 267 | task_t *kernel = task_create(AS_KERNEL, "kernel"); |
268 | if (!kernel) |
||
269 | panic("Can't create kernel task\n"); |
||
860 | decky | 270 | |
1 | jermar | 271 | /* |
272 | * Create the first thread. |
||
273 | */ |
||
3424 | svoboda | 274 | thread_t *kinit_thread = thread_create(kinit, NULL, kernel, 0, "kinit", |
275 | true); |
||
276 | if (!kinit_thread) |
||
277 | panic("Can't create kinit thread\n"); |
||
278 | LOG_EXEC(thread_ready(kinit_thread)); |
||
860 | decky | 279 | |
1 | jermar | 280 | /* |
281 | * This call to scheduler() will return to kinit, |
||
282 | * starting the thread of kernel threads. |
||
283 | */ |
||
284 | scheduler(); |
||
285 | /* not reached */ |
||
286 | } |
||
287 | |||
108 | decky | 288 | |
458 | decky | 289 | #ifdef CONFIG_SMP |
1229 | jermar | 290 | /** Main kernel routine for application CPUs. |
108 | decky | 291 | * |
292 | * Executed by application processors, temporary stack |
||
1901 | jermar | 293 | * is at ctx.sp which was set during BSP boot. |
675 | jermar | 294 | * This function passes control directly to |
295 | * main_ap_separated_stack(). |
||
108 | decky | 296 | * |
413 | jermar | 297 | * Assuming interrupts_disable()'d. |
108 | decky | 298 | * |
1 | jermar | 299 | */ |
300 | void main_ap(void) |
||
301 | { |
||
302 | /* |
||
303 | * Incrementing the active CPU counter will guarantee that the |
||
1901 | jermar | 304 | * *_init() functions can find out that they need to |
305 | * do initialization for AP only. |
||
1 | jermar | 306 | */ |
307 | config.cpu_active++; |
||
308 | |||
192 | jermar | 309 | /* |
310 | * The THE structure is well defined because ctx.sp is used as stack. |
||
311 | */ |
||
312 | the_initialize(THE); |
||
298 | decky | 313 | |
26 | jermar | 314 | arch_pre_mm_init(); |
1 | jermar | 315 | frame_init(); |
316 | page_init(); |
||
389 | jermar | 317 | tlb_init(); |
26 | jermar | 318 | arch_post_mm_init(); |
298 | decky | 319 | |
1 | jermar | 320 | cpu_init(); |
321 | calibrate_delay_loop(); |
||
1901 | jermar | 322 | arch_post_cpu_init(); |
1 | jermar | 323 | |
192 | jermar | 324 | the_copy(THE, (the_t *) CPU->stack); |
1 | jermar | 325 | |
326 | /* |
||
327 | * If we woke kmp up before we left the kernel stack, we could |
||
328 | * collide with another CPU coming up. To prevent this, we |
||
329 | * switch to this cpu's private stack prior to waking kmp up. |
||
330 | */ |
||
2015 | jermar | 331 | context_set(&CPU->saved_context, FADDR(main_ap_separated_stack), |
2087 | jermar | 332 | (uintptr_t) CPU->stack, CPU_STACK_SIZE); |
47 | jermar | 333 | context_restore(&CPU->saved_context); |
1 | jermar | 334 | /* not reached */ |
335 | } |
||
336 | |||
108 | decky | 337 | |
1229 | jermar | 338 | /** Main kernel routine for application CPUs using new stack. |
108 | decky | 339 | * |
340 | * Second part of main_ap(). |
||
341 | * |
||
342 | */ |
||
1 | jermar | 343 | void main_ap_separated_stack(void) |
344 | { |
||
345 | /* |
||
346 | * Configure timeouts for this cpu. |
||
347 | */ |
||
348 | timeout_init(); |
||
349 | |||
350 | waitq_wakeup(&ap_completion_wq, WAKEUP_FIRST); |
||
351 | scheduler(); |
||
352 | /* not reached */ |
||
353 | } |
||
458 | decky | 354 | #endif /* CONFIG_SMP */ |
1702 | cejka | 355 | |
1729 | decky | 356 | /** @} |
1702 | cejka | 357 | */ |