source: mainline/kernel/generic/src/main/main.c@ 8ccd2ea

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 8ccd2ea was 71eef11, checked in by Martin Decky <martin@…>, 17 years ago

remove config.memory_size, get_memory_size() and memory_init.{c|d}
the amount of available memory can be calculated from the sizes of the zones
add FRAMES2SIZE, SIZE2KB and SIZE2MB functions/macros (code readability)

  • Property mode set to 100644
File size: 8.7 KB
RevLine 
[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]85config_t config;
[e459f12]86
87/** Initial user-space tasks */
88init_t init = {
89 0
90};
[5fe5f1e]91
[61e90dd]92/** Boot allocations. */
93ballocs_t ballocs = {
94 .base = NULL,
95 .size = 0
96};
97
[f761f1eb]98context_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]105uintptr_t hardcoded_load_address = 0; /**< Virtual address of where the kernel
106 * is loaded. */
107size_t hardcoded_ktext_size = 0; /**< Size of the kernel code in bytes.
108 */
109size_t hardcoded_kdata_size = 0; /**< Size of the kernel data in bytes.
110 */
111uintptr_t stack_safe = 0; /**< Lowest safe stack virtual address.
112 */
[deaa22f]113
[f761f1eb]114void main_bsp(void);
115void 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 */
123static void main_bsp_separated_stack(void);
[80d2bdb]124#ifdef CONFIG_SMP
[f761f1eb]125static 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 */
139void 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]185void 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 */
291void 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]334void 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 */
Note: See TracBrowser for help on using the repository browser.