source: mainline/kernel/generic/src/main/main.c@ 89ea2dc

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 89ea2dc was ce732e74, checked in by Jakub Jermar <jakub@…>, 8 years ago

Allocate capabilities from a dedicated slab cache
  • Property mode set to 100644
File size: 9.9 KB
Line 
1/*
2 * Copyright (c) 2001-2004 Jakub 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
29/** @addtogroup main
30 * @{
31 */
32
33/**
34 * @file
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
49#include <arch/asm.h>
50#include <debug.h>
51#include <context.h>
52#include <print.h>
53#include <panic.h>
54#include <assert.h>
55#include <config.h>
56#include <time/clock.h>
57#include <time/timeout.h>
58#include <proc/scheduler.h>
59#include <proc/thread.h>
60#include <proc/task.h>
61#include <main/kinit.h>
62#include <main/version.h>
63#include <console/kconsole.h>
64#include <console/console.h>
65#include <log.h>
66#include <cpu.h>
67#include <align.h>
68#include <interrupt.h>
69#include <mm/frame.h>
70#include <mm/page.h>
71#include <genarch/mm/page_pt.h>
72#include <mm/km.h>
73#include <mm/tlb.h>
74#include <mm/as.h>
75#include <mm/slab.h>
76#include <mm/reserve.h>
77#include <synch/waitq.h>
78#include <synch/futex.h>
79#include <synch/workqueue.h>
80#include <smp/smp_call.h>
81#include <arch/arch.h>
82#include <arch.h>
83#include <arch/faddr.h>
84#include <ipc/ipc.h>
85#include <macros.h>
86#include <adt/btree.h>
87#include <smp/smp.h>
88#include <ddi/ddi.h>
89#include <main/main.h>
90#include <ipc/event.h>
91#include <sysinfo/sysinfo.h>
92#include <sysinfo/stats.h>
93#include <lib/ra.h>
94#include <cap/cap.h>
95
96/* Ensure [u]int*_t types are of correct size.
97 *
98 * Probably, this is not the best place for such tests
99 * but this file is compiled on all architectures.
100 */
101#define CHECK_INT_TYPE_(signness, size) \
102 static_assert(sizeof(signness##size##_t) * 8 == size, \
103 #signness #size "_t does not have " #size " bits");
104
105#define CHECK_INT_TYPE(size) \
106 CHECK_INT_TYPE_(int, size); \
107 CHECK_INT_TYPE_(uint, size)
108
109CHECK_INT_TYPE(8);
110CHECK_INT_TYPE(16);
111CHECK_INT_TYPE(32);
112CHECK_INT_TYPE(64);
113
114/** Global configuration structure. */
115config_t config = {
116 .identity_configured = false,
117 .non_identity_configured = false,
118 .physmem_end = 0
119};
120
121/** Boot arguments. */
122char bargs[CONFIG_BOOT_ARGUMENTS_BUFLEN] = {};
123
124/** Initial user-space tasks */
125init_t init = {
126 .cnt = 0
127};
128
129/** Boot allocations. */
130ballocs_t ballocs = {
131 .base = (uintptr_t) NULL,
132 .size = 0
133};
134
135context_t ctx;
136
137/** Lowest safe stack virtual address. */
138uintptr_t stack_safe = 0;
139
140/*
141 * These two functions prevent stack from underflowing during the
142 * kernel boot phase when SP is set to the very top of the reserved
143 * space. The stack could get corrupted by a fooled compiler-generated
144 * pop sequence otherwise.
145 */
146static void main_bsp_separated_stack(void);
147
148#ifdef CONFIG_SMP
149static void main_ap_separated_stack(void);
150#endif
151
152/** Main kernel routine for bootstrap CPU.
153 *
154 * The code here still runs on the boot stack, which knows nothing about
155 * preemption counts. Because of that, this function cannot directly call
156 * functions that disable or enable preemption (e.g. spinlock_lock()). The
157 * primary task of this function is to calculate address of a new stack and
158 * switch to it.
159 *
160 * Assuming interrupts_disable().
161 *
162 */
163NO_TRACE void main_bsp(void)
164{
165 config.cpu_count = 1;
166 config.cpu_active = 1;
167
168 config.base = hardcoded_load_address;
169 config.kernel_size = ALIGN_UP(hardcoded_ktext_size +
170 hardcoded_kdata_size, PAGE_SIZE);
171 config.stack_size = STACK_SIZE;
172
173 /* Initialy the stack is placed just after the kernel */
174 config.stack_base = config.base + config.kernel_size;
175
176 /* Avoid placing stack on top of init */
177 size_t i;
178 for (i = 0; i < init.cnt; i++) {
179 if (overlaps(KA2PA(config.stack_base), config.stack_size,
180 init.tasks[i].paddr, init.tasks[i].size)) {
181 /*
182 * The init task overlaps with the memory behind the
183 * kernel image so it must be in low memory and we can
184 * use PA2KA on the init task's physical address.
185 */
186 config.stack_base = ALIGN_UP(
187 PA2KA(init.tasks[i].paddr) + init.tasks[i].size,
188 config.stack_size);
189 }
190 }
191
192 /* Avoid placing stack on top of boot allocations. */
193 if (ballocs.size) {
194 if (PA_OVERLAPS(config.stack_base, config.stack_size,
195 ballocs.base, ballocs.size))
196 config.stack_base = ALIGN_UP(ballocs.base +
197 ballocs.size, PAGE_SIZE);
198 }
199
200 if (config.stack_base < stack_safe)
201 config.stack_base = ALIGN_UP(stack_safe, PAGE_SIZE);
202
203 context_save(&ctx);
204 context_set(&ctx, FADDR(main_bsp_separated_stack),
205 config.stack_base, STACK_SIZE);
206 context_restore(&ctx);
207 /* not reached */
208}
209
210/** Main kernel routine for bootstrap CPU using new stack.
211 *
212 * Second part of main_bsp().
213 *
214 */
215void main_bsp_separated_stack(void)
216{
217 /* Keep this the first thing. */
218 the_initialize(THE);
219
220 version_print();
221
222 LOG("\nconfig.base=%p config.kernel_size=%zu"
223 "\nconfig.stack_base=%p config.stack_size=%zu",
224 (void *) config.base, config.kernel_size,
225 (void *) config.stack_base, config.stack_size);
226
227#ifdef CONFIG_KCONSOLE
228 /*
229 * kconsole data structures must be initialized very early
230 * because other subsystems will register their respective
231 * commands.
232 */
233 kconsole_init();
234#endif
235
236 /*
237 * Exception handler initialization, before architecture
238 * starts adding its own handlers
239 */
240 exc_init();
241
242 /*
243 * Memory management subsystems initialization.
244 */
245 ARCH_OP(pre_mm_init);
246 km_identity_init();
247 frame_init();
248 slab_cache_init();
249 ra_init();
250 sysinfo_init();
251 btree_init();
252 as_init();
253 page_init();
254 tlb_init();
255 km_non_identity_init();
256 ddi_init();
257 ARCH_OP(post_mm_init);
258 reserve_init();
259 ARCH_OP(pre_smp_init);
260 smp_init();
261
262 /* Slab must be initialized after we know the number of processors. */
263 slab_enable_cpucache();
264
265 uint64_t size;
266 const char *size_suffix;
267 bin_order_suffix(zones_total_size(), &size, &size_suffix, false);
268 printf("Detected %u CPU(s), %" PRIu64 " %s free memory\n",
269 config.cpu_count, size, size_suffix);
270
271 cpu_init();
272 calibrate_delay_loop();
273 ARCH_OP(post_cpu_init);
274
275 smp_call_init();
276 workq_global_init();
277 clock_counter_init();
278 timeout_init();
279 scheduler_init();
280 caps_init();
281 task_init();
282 thread_init();
283 futex_init();
284
285 sysinfo_set_item_data("boot_args", NULL, bargs, str_size(bargs) + 1);
286
287 if (init.cnt > 0) {
288 size_t i;
289 for (i = 0; i < init.cnt; i++)
290 LOG("init[%zu].addr=%p, init[%zu].size=%zu",
291 i, (void *) init.tasks[i].paddr, i, init.tasks[i].size);
292 } else
293 printf("No init binaries found.\n");
294
295 ipc_init();
296 event_init();
297 kio_init();
298 log_init();
299 stats_init();
300
301 /*
302 * Create kernel task.
303 */
304 task_t *kernel = task_create(AS_KERNEL, "kernel");
305 if (!kernel)
306 panic("Cannot create kernel task.");
307
308 /*
309 * Create the first thread.
310 */
311 thread_t *kinit_thread = thread_create(kinit, NULL, kernel,
312 THREAD_FLAG_UNCOUNTED, "kinit");
313 if (!kinit_thread)
314 panic("Cannot create kinit thread.");
315 thread_ready(kinit_thread);
316
317 /*
318 * This call to scheduler() will return to kinit,
319 * starting the thread of kernel threads.
320 */
321 scheduler();
322 /* not reached */
323}
324
325#ifdef CONFIG_SMP
326
327/** Main kernel routine for application CPUs.
328 *
329 * Executed by application processors, temporary stack
330 * is at ctx.sp which was set during BSP boot.
331 * This function passes control directly to
332 * main_ap_separated_stack().
333 *
334 * Assuming interrupts_disable()'d.
335 *
336 */
337void main_ap(void)
338{
339 /*
340 * Incrementing the active CPU counter will guarantee that the
341 * *_init() functions can find out that they need to
342 * do initialization for AP only.
343 */
344 config.cpu_active++;
345
346 /*
347 * The THE structure is well defined because ctx.sp is used as stack.
348 */
349 the_initialize(THE);
350
351 ARCH_OP(pre_mm_init);
352 frame_init();
353 page_init();
354 tlb_init();
355 ARCH_OP(post_mm_init);
356
357 cpu_init();
358 calibrate_delay_loop();
359 ARCH_OP(post_cpu_init);
360
361 the_copy(THE, (the_t *) CPU->stack);
362
363 /*
364 * If we woke kmp up before we left the kernel stack, we could
365 * collide with another CPU coming up. To prevent this, we
366 * switch to this cpu's private stack prior to waking kmp up.
367 */
368 context_save(&CPU->saved_context);
369 context_set(&CPU->saved_context, FADDR(main_ap_separated_stack),
370 (uintptr_t) CPU->stack, STACK_SIZE);
371 context_restore(&CPU->saved_context);
372 /* not reached */
373}
374
375/** Main kernel routine for application CPUs using new stack.
376 *
377 * Second part of main_ap().
378 *
379 */
380void main_ap_separated_stack(void)
381{
382 smp_call_init();
383
384 /*
385 * Configure timeouts for this cpu.
386 */
387 timeout_init();
388
389 waitq_wakeup(&ap_completion_wq, WAKEUP_FIRST);
390 scheduler();
391 /* not reached */
392}
393
394#endif /* CONFIG_SMP */
395
396/** @}
397 */
Note: See TracBrowser for help on using the repository browser.