Branch data Line data Source code
1 : : /*
2 : : * Copyright (c) 2010-2014 Wind River Systems, Inc.
3 : : *
4 : : * SPDX-License-Identifier: Apache-2.0
5 : : */
6 : :
7 : : /**
8 : : * @file
9 : : * @brief Kernel initialization module
10 : : *
11 : : * This module contains routines that are used to initialize the kernel.
12 : : */
13 : :
14 : : #include <ctype.h>
15 : : #include <stdbool.h>
16 : : #include <string.h>
17 : : #include <offsets_short.h>
18 : : #include <zephyr/kernel.h>
19 : : #include <zephyr/sys/printk.h>
20 : : #include <zephyr/debug/stack.h>
21 : : #include <zephyr/random/random.h>
22 : : #include <zephyr/linker/sections.h>
23 : : #include <zephyr/toolchain.h>
24 : : #include <zephyr/kernel_structs.h>
25 : : #include <zephyr/device.h>
26 : : #include <zephyr/init.h>
27 : : #include <zephyr/linker/linker-defs.h>
28 : : #include <zephyr/platform/hooks.h>
29 : : #include <ksched.h>
30 : : #include <kthread.h>
31 : : #include <zephyr/sys/dlist.h>
32 : : #include <kernel_internal.h>
33 : : #include <zephyr/drivers/entropy.h>
34 : : #include <zephyr/logging/log_ctrl.h>
35 : : #include <zephyr/tracing/tracing.h>
36 : : #include <zephyr/debug/gcov.h>
37 : : #include <kswap.h>
38 : : #include <zephyr/timing/timing.h>
39 : : #include <zephyr/logging/log.h>
40 : : #include <zephyr/pm/device_runtime.h>
41 : : #include <zephyr/internal/syscall_handler.h>
42 : : LOG_MODULE_REGISTER(os, CONFIG_KERNEL_LOG_LEVEL);
43 : :
44 : : BUILD_ASSERT(CONFIG_MP_NUM_CPUS == CONFIG_MP_MAX_NUM_CPUS,
45 : : "CONFIG_MP_NUM_CPUS and CONFIG_MP_MAX_NUM_CPUS need to be set the same");
46 : :
47 : : /* the only struct z_kernel instance */
48 : : __pinned_bss
49 : : struct z_kernel _kernel;
50 : :
51 : : #ifdef CONFIG_PM
52 : : __pinned_bss atomic_t _cpus_active;
53 : : #endif
54 : :
55 : : /* init/main and idle threads */
56 : : K_THREAD_PINNED_STACK_DEFINE(z_main_stack, CONFIG_MAIN_STACK_SIZE);
57 : : struct k_thread z_main_thread;
58 : :
59 : : #ifdef CONFIG_MULTITHREADING
60 : : __pinned_bss
61 : : struct k_thread z_idle_threads[CONFIG_MP_MAX_NUM_CPUS];
62 : :
63 : : static K_KERNEL_PINNED_STACK_ARRAY_DEFINE(z_idle_stacks,
64 : : CONFIG_MP_MAX_NUM_CPUS,
65 : : CONFIG_IDLE_STACK_SIZE);
66 : :
67 : 1 : static void z_init_static_threads(void)
68 : : {
69 [ - + - + ]: 1 : STRUCT_SECTION_FOREACH(_static_thread_data, thread_data) {
70 : 0 : z_setup_new_thread(
71 : : thread_data->init_thread,
72 : : thread_data->init_stack,
73 : : thread_data->init_stack_size,
74 : : thread_data->init_entry,
75 : : thread_data->init_p1,
76 : : thread_data->init_p2,
77 : : thread_data->init_p3,
78 : : thread_data->init_prio,
79 : : thread_data->init_options,
80 : : thread_data->init_name);
81 : :
82 : 0 : thread_data->init_thread->init_data = thread_data;
83 : : }
84 : :
85 : : #ifdef CONFIG_USERSPACE
86 : : STRUCT_SECTION_FOREACH(k_object_assignment, pos) {
87 : : for (int i = 0; pos->objects[i] != NULL; i++) {
88 : : k_object_access_grant(pos->objects[i],
89 : : pos->thread);
90 : : }
91 : : }
92 : : #endif /* CONFIG_USERSPACE */
93 : :
94 : : /*
95 : : * Non-legacy static threads may be started immediately or
96 : : * after a previously specified delay. Even though the
97 : : * scheduler is locked, ticks can still be delivered and
98 : : * processed. Take a sched lock to prevent them from running
99 : : * until they are all started.
100 : : *
101 : : * Note that static threads defined using the legacy API have a
102 : : * delay of K_FOREVER.
103 : : */
104 : 1 : k_sched_lock();
105 [ - + - + ]: 1 : STRUCT_SECTION_FOREACH(_static_thread_data, thread_data) {
106 : 0 : k_timeout_t init_delay = Z_THREAD_INIT_DELAY(thread_data);
107 : :
108 [ # # ]: 0 : if (!K_TIMEOUT_EQ(init_delay, K_FOREVER)) {
109 : 0 : thread_schedule_new(thread_data->init_thread,
110 : : init_delay);
111 : : }
112 : : }
113 : 1 : k_sched_unlock();
114 : 1 : }
115 : : #else
116 : : #define z_init_static_threads() do { } while (false)
117 : : #endif /* CONFIG_MULTITHREADING */
118 : :
119 : : extern const struct init_entry __init_start[];
120 : : extern const struct init_entry __init_EARLY_start[];
121 : : extern const struct init_entry __init_PRE_KERNEL_1_start[];
122 : : extern const struct init_entry __init_PRE_KERNEL_2_start[];
123 : : extern const struct init_entry __init_POST_KERNEL_start[];
124 : : extern const struct init_entry __init_APPLICATION_start[];
125 : : extern const struct init_entry __init_end[];
126 : :
127 : : enum init_level {
128 : : INIT_LEVEL_EARLY = 0,
129 : : INIT_LEVEL_PRE_KERNEL_1,
130 : : INIT_LEVEL_PRE_KERNEL_2,
131 : : INIT_LEVEL_POST_KERNEL,
132 : : INIT_LEVEL_APPLICATION,
133 : : #ifdef CONFIG_SMP
134 : : INIT_LEVEL_SMP,
135 : : #endif /* CONFIG_SMP */
136 : : };
137 : :
138 : : #ifdef CONFIG_SMP
139 : : extern const struct init_entry __init_SMP_start[];
140 : : #endif /* CONFIG_SMP */
141 : :
142 : : /*
143 : : * storage space for the interrupt stack
144 : : *
145 : : * Note: This area is used as the system stack during kernel initialization,
146 : : * since the kernel hasn't yet set up its own stack areas. The dual purposing
147 : : * of this area is safe since interrupts are disabled until the kernel context
148 : : * switches to the init thread.
149 : : */
150 : : K_KERNEL_PINNED_STACK_ARRAY_DEFINE(z_interrupt_stacks,
151 : : CONFIG_MP_MAX_NUM_CPUS,
152 : : CONFIG_ISR_STACK_SIZE);
153 : :
154 : : extern void idle(void *unused1, void *unused2, void *unused3);
155 : :
156 : : #ifdef CONFIG_OBJ_CORE_SYSTEM
157 : : static struct k_obj_type obj_type_cpu;
158 : : static struct k_obj_type obj_type_kernel;
159 : :
160 : : #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
161 : : static struct k_obj_core_stats_desc cpu_stats_desc = {
162 : : .raw_size = sizeof(struct k_cycle_stats),
163 : : .query_size = sizeof(struct k_thread_runtime_stats),
164 : : .raw = z_cpu_stats_raw,
165 : : .query = z_cpu_stats_query,
166 : : .reset = NULL,
167 : : .disable = NULL,
168 : : .enable = NULL,
169 : : };
170 : :
171 : : static struct k_obj_core_stats_desc kernel_stats_desc = {
172 : : .raw_size = sizeof(struct k_cycle_stats) * CONFIG_MP_MAX_NUM_CPUS,
173 : : .query_size = sizeof(struct k_thread_runtime_stats),
174 : : .raw = z_kernel_stats_raw,
175 : : .query = z_kernel_stats_query,
176 : : .reset = NULL,
177 : : .disable = NULL,
178 : : .enable = NULL,
179 : : };
180 : : #endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */
181 : : #endif /* CONFIG_OBJ_CORE_SYSTEM */
182 : :
183 : : /* LCOV_EXCL_START
184 : : *
185 : : * This code is called so early in the boot process that code coverage
186 : : * doesn't work properly. In addition, not all arches call this code,
187 : : * some like x86 do this with optimized assembly
188 : : */
189 : :
190 : : /**
191 : : * @brief equivalent of memset() for early boot usage
192 : : *
193 : : * Architectures that can't safely use the regular (optimized) memset very
194 : : * early during boot because e.g. hardware isn't yet sufficiently initialized
195 : : * may override this with their own safe implementation.
196 : : */
197 : : __boot_func
198 : : void __weak z_early_memset(void *dst, int c, size_t n)
199 : : {
200 : : (void) memset(dst, c, n);
201 : : }
202 : :
203 : : /**
204 : : * @brief equivalent of memcpy() for early boot usage
205 : : *
206 : : * Architectures that can't safely use the regular (optimized) memcpy very
207 : : * early during boot because e.g. hardware isn't yet sufficiently initialized
208 : : * may override this with their own safe implementation.
209 : : */
210 : : __boot_func
211 : : void __weak z_early_memcpy(void *dst, const void *src, size_t n)
212 : : {
213 : : (void) memcpy(dst, src, n);
214 : : }
215 : :
216 : : /**
217 : : * @brief Clear BSS
218 : : *
219 : : * This routine clears the BSS region, so all bytes are 0.
220 : : */
221 : : __boot_func
222 : : void z_bss_zero(void)
223 : : {
224 : : if (IS_ENABLED(CONFIG_SKIP_BSS_CLEAR)) {
225 : : return;
226 : : }
227 : :
228 : : z_early_memset(__bss_start, 0, __bss_end - __bss_start);
229 : : #if DT_NODE_HAS_STATUS(DT_CHOSEN(zephyr_ccm), okay)
230 : : z_early_memset(&__ccm_bss_start, 0,
231 : : (uintptr_t) &__ccm_bss_end
232 : : - (uintptr_t) &__ccm_bss_start);
233 : : #endif
234 : : #if DT_NODE_HAS_STATUS(DT_CHOSEN(zephyr_dtcm), okay)
235 : : z_early_memset(&__dtcm_bss_start, 0,
236 : : (uintptr_t) &__dtcm_bss_end
237 : : - (uintptr_t) &__dtcm_bss_start);
238 : : #endif
239 : : #if DT_NODE_HAS_STATUS(DT_CHOSEN(zephyr_ocm), okay)
240 : : z_early_memset(&__ocm_bss_start, 0,
241 : : (uintptr_t) &__ocm_bss_end
242 : : - (uintptr_t) &__ocm_bss_start);
243 : : #endif
244 : : #ifdef CONFIG_CODE_DATA_RELOCATION
245 : : extern void bss_zeroing_relocation(void);
246 : :
247 : : bss_zeroing_relocation();
248 : : #endif /* CONFIG_CODE_DATA_RELOCATION */
249 : : #ifdef CONFIG_COVERAGE_GCOV
250 : : z_early_memset(&__gcov_bss_start, 0,
251 : : ((uintptr_t) &__gcov_bss_end - (uintptr_t) &__gcov_bss_start));
252 : : #endif /* CONFIG_COVERAGE_GCOV */
253 : : }
254 : :
255 : : #ifdef CONFIG_LINKER_USE_BOOT_SECTION
256 : : /**
257 : : * @brief Clear BSS within the bot region
258 : : *
259 : : * This routine clears the BSS within the boot region.
260 : : * This is separate from z_bss_zero() as boot region may
261 : : * contain symbols required for the boot process before
262 : : * paging is initialized.
263 : : */
264 : : __boot_func
265 : : void z_bss_zero_boot(void)
266 : : {
267 : : z_early_memset(&lnkr_boot_bss_start, 0,
268 : : (uintptr_t)&lnkr_boot_bss_end
269 : : - (uintptr_t)&lnkr_boot_bss_start);
270 : : }
271 : : #endif /* CONFIG_LINKER_USE_BOOT_SECTION */
272 : :
273 : : #ifdef CONFIG_LINKER_USE_PINNED_SECTION
274 : : /**
275 : : * @brief Clear BSS within the pinned region
276 : : *
277 : : * This routine clears the BSS within the pinned region.
278 : : * This is separate from z_bss_zero() as pinned region may
279 : : * contain symbols required for the boot process before
280 : : * paging is initialized.
281 : : */
282 : : #ifdef CONFIG_LINKER_USE_BOOT_SECTION
283 : : __boot_func
284 : : #else
285 : : __pinned_func
286 : : #endif /* CONFIG_LINKER_USE_BOOT_SECTION */
287 : : void z_bss_zero_pinned(void)
288 : : {
289 : : z_early_memset(&lnkr_pinned_bss_start, 0,
290 : : (uintptr_t)&lnkr_pinned_bss_end
291 : : - (uintptr_t)&lnkr_pinned_bss_start);
292 : : }
293 : : #endif /* CONFIG_LINKER_USE_PINNED_SECTION */
294 : :
295 : : #ifdef CONFIG_STACK_CANARIES
296 : : #ifdef CONFIG_STACK_CANARIES_TLS
297 : : extern __thread volatile uintptr_t __stack_chk_guard;
298 : : #else
299 : : extern volatile uintptr_t __stack_chk_guard;
300 : : #endif /* CONFIG_STACK_CANARIES_TLS */
301 : : #endif /* CONFIG_STACK_CANARIES */
302 : :
303 : : /* LCOV_EXCL_STOP */
304 : :
305 : : __pinned_bss
306 : : bool z_sys_post_kernel;
307 : :
308 : 0 : static int do_device_init(const struct init_entry *entry)
309 : : {
310 : 0 : const struct device *dev = entry->dev;
311 : 0 : int rc = 0;
312 : :
313 [ # # ]: 0 : if (entry->init_fn.dev != NULL) {
314 : 0 : rc = entry->init_fn.dev(dev);
315 : : /* Mark device initialized. If initialization
316 : : * failed, record the error condition.
317 : : */
318 [ # # ]: 0 : if (rc != 0) {
319 : 0 : if (rc < 0) {
320 : : rc = -rc;
321 : : }
322 : 0 : if (rc > UINT8_MAX) {
323 : : rc = UINT8_MAX;
324 : : }
325 : 0 : dev->state->init_res = rc;
326 : : }
327 : : }
328 : :
329 : 0 : dev->state->initialized = true;
330 : :
331 : 0 : if (rc == 0) {
332 : : /* Run automatic device runtime enablement */
333 : : (void)pm_device_runtime_auto_enable(dev);
334 : : }
335 : :
336 : 0 : return rc;
337 : : }
338 : :
339 : : /**
340 : : * @brief Execute all the init entry initialization functions at a given level
341 : : *
342 : : * @details Invokes the initialization routine for each init entry object
343 : : * created by the INIT_ENTRY_DEFINE() macro using the specified level.
344 : : * The linker script places the init entry objects in memory in the order
345 : : * they need to be invoked, with symbols indicating where one level leaves
346 : : * off and the next one begins.
347 : : *
348 : : * @param level init level to run.
349 : : */
350 : 5 : static void z_sys_init_run_level(enum init_level level)
351 : : {
352 : 5 : static const struct init_entry *levels[] = {
353 : : __init_EARLY_start,
354 : : __init_PRE_KERNEL_1_start,
355 : : __init_PRE_KERNEL_2_start,
356 : : __init_POST_KERNEL_start,
357 : : __init_APPLICATION_start,
358 : : #ifdef CONFIG_SMP
359 : : __init_SMP_start,
360 : : #endif /* CONFIG_SMP */
361 : : /* End marker */
362 : : __init_end,
363 : : };
364 : 5 : const struct init_entry *entry;
365 : :
366 [ + + ]: 8 : for (entry = levels[level]; entry < levels[level+1]; entry++) {
367 : 3 : const struct device *dev = entry->dev;
368 : 3 : int result;
369 : :
370 : 3 : sys_trace_sys_init_enter(entry, level);
371 [ - + ]: 3 : if (dev != NULL) {
372 : 0 : result = do_device_init(entry);
373 : : } else {
374 : 3 : result = entry->init_fn.sys();
375 : : }
376 : 3 : sys_trace_sys_init_exit(entry, level, result);
377 : : }
378 : 5 : }
379 : :
380 : :
381 : 0 : int z_impl_device_init(const struct device *dev)
382 : : {
383 [ # # ]: 0 : if (dev == NULL) {
384 : : return -ENOENT;
385 : : }
386 : :
387 [ # # # # ]: 0 : STRUCT_SECTION_FOREACH_ALTERNATE(_deferred_init, init_entry, entry) {
388 [ # # ]: 0 : if (entry->dev == dev) {
389 : 0 : return do_device_init(entry);
390 : : }
391 : : }
392 : :
393 : : return -ENOENT;
394 : : }
395 : :
396 : : #ifdef CONFIG_USERSPACE
397 : : static inline int z_vrfy_device_init(const struct device *dev)
398 : : {
399 : : K_OOPS(K_SYSCALL_OBJ_INIT(dev, K_OBJ_ANY));
400 : :
401 : : return z_impl_device_init(dev);
402 : : }
403 : : #include <zephyr/syscalls/device_init_mrsh.c>
404 : : #endif
405 : :
406 : : extern void boot_banner(void);
407 : :
408 : : #ifdef CONFIG_BOOTARGS
409 : : extern const char *get_bootargs(void);
410 : : static char **prepare_main_args(int *argc)
411 : : {
412 : : #ifdef CONFIG_DYNAMIC_BOOTARGS
413 : : const char *bootargs = get_bootargs();
414 : : #else
415 : : const char bootargs[] = CONFIG_BOOTARGS_STRING;
416 : : #endif
417 : :
418 : : /* beginning of the buffer contains argument's strings, end of it contains argvs */
419 : : static char args_buf[CONFIG_BOOTARGS_ARGS_BUFFER_SIZE];
420 : : char *strings_end = (char *)args_buf;
421 : : char **argv_begin = (char **)WB_DN(
422 : : args_buf + CONFIG_BOOTARGS_ARGS_BUFFER_SIZE - sizeof(char *));
423 : : int i = 0;
424 : :
425 : : *argc = 0;
426 : : *argv_begin = NULL;
427 : :
428 : : #ifdef CONFIG_DYNAMIC_BOOTARGS
429 : : if (!bootargs) {
430 : : return argv_begin;
431 : : }
432 : : #endif
433 : :
434 : : while (1) {
435 : : while (isspace(bootargs[i])) {
436 : : i++;
437 : : }
438 : :
439 : : if (bootargs[i] == '\0') {
440 : : return argv_begin;
441 : : }
442 : :
443 : : if (strings_end + sizeof(char *) >= (char *)argv_begin) {
444 : : LOG_WRN("not enough space in args buffer to accommodate all bootargs"
445 : : " - bootargs truncated");
446 : : return argv_begin;
447 : : }
448 : :
449 : : argv_begin--;
450 : : memmove(argv_begin, argv_begin + 1, *argc * sizeof(char *));
451 : : argv_begin[*argc] = strings_end;
452 : :
453 : : bool quoted = false;
454 : :
455 : : if (bootargs[i] == '\"' || bootargs[i] == '\'') {
456 : : char delimiter = bootargs[i];
457 : :
458 : : for (int j = i + 1; bootargs[j] != '\0'; j++) {
459 : : if (bootargs[j] == delimiter) {
460 : : quoted = true;
461 : : break;
462 : : }
463 : : }
464 : : }
465 : :
466 : : if (quoted) {
467 : : char delimiter = bootargs[i];
468 : :
469 : : i++; /* strip quotes */
470 : : while (bootargs[i] != delimiter
471 : : && strings_end < (char *)argv_begin) {
472 : : *strings_end++ = bootargs[i++];
473 : : }
474 : : i++; /* strip quotes */
475 : : } else {
476 : : while (!isspace(bootargs[i])
477 : : && bootargs[i] != '\0'
478 : : && strings_end < (char *)argv_begin) {
479 : : *strings_end++ = bootargs[i++];
480 : : }
481 : : }
482 : :
483 : : if (strings_end < (char *)argv_begin) {
484 : : *strings_end++ = '\0';
485 : : } else {
486 : : LOG_WRN("not enough space in args buffer to accommodate all bootargs"
487 : : " - bootargs truncated");
488 : : argv_begin[*argc] = NULL;
489 : : return argv_begin;
490 : : }
491 : : (*argc)++;
492 : : }
493 : : }
494 : : #endif
495 : :
496 : : /**
497 : : * @brief Mainline for kernel's background thread
498 : : *
499 : : * This routine completes kernel initialization by invoking the remaining
500 : : * init functions, then invokes application's main() routine.
501 : : */
502 : : __boot_func
503 : 1 : static void bg_thread_main(void *unused1, void *unused2, void *unused3)
504 : : {
505 : 1 : ARG_UNUSED(unused1);
506 : 1 : ARG_UNUSED(unused2);
507 : 1 : ARG_UNUSED(unused3);
508 : :
509 : : #ifdef CONFIG_MMU
510 : : /* Invoked here such that backing store or eviction algorithms may
511 : : * initialize kernel objects, and that all POST_KERNEL and later tasks
512 : : * may perform memory management tasks (except for
513 : : * k_mem_map_phys_bare() which is allowed at any time)
514 : : */
515 : : z_mem_manage_init();
516 : : #endif /* CONFIG_MMU */
517 : 1 : z_sys_post_kernel = true;
518 : :
519 : 1 : z_sys_init_run_level(INIT_LEVEL_POST_KERNEL);
520 : : #if CONFIG_SOC_LATE_INIT_HOOK
521 : : soc_late_init_hook();
522 : : #endif
523 : : #if CONFIG_BOARD_LATE_INIT_HOOK
524 : : board_late_init_hook();
525 : : #endif
526 : :
527 : : #if defined(CONFIG_STACK_POINTER_RANDOM) && (CONFIG_STACK_POINTER_RANDOM != 0)
528 : : z_stack_adjust_initialized = 1;
529 : : #endif /* CONFIG_STACK_POINTER_RANDOM */
530 : 1 : boot_banner();
531 : :
532 : 1 : void z_init_static(void);
533 : 1 : z_init_static();
534 : :
535 : : /* Final init level before app starts */
536 : 1 : z_sys_init_run_level(INIT_LEVEL_APPLICATION);
537 : :
538 : 1 : z_init_static_threads();
539 : :
540 : : #ifdef CONFIG_KERNEL_COHERENCE
541 : : __ASSERT_NO_MSG(arch_mem_coherent(&_kernel));
542 : : #endif /* CONFIG_KERNEL_COHERENCE */
543 : :
544 : : #ifdef CONFIG_SMP
545 : : if (!IS_ENABLED(CONFIG_SMP_BOOT_DELAY)) {
546 : : z_smp_init();
547 : : }
548 : : z_sys_init_run_level(INIT_LEVEL_SMP);
549 : : #endif /* CONFIG_SMP */
550 : :
551 : : #ifdef CONFIG_MMU
552 : : z_mem_manage_boot_finish();
553 : : #endif /* CONFIG_MMU */
554 : :
555 : : #ifdef CONFIG_BOOTARGS
556 : : extern int main(int, char **);
557 : :
558 : : int argc = 0;
559 : : char **argv = prepare_main_args(&argc);
560 : : (void)main(argc, argv);
561 : : #else
562 : 1 : extern int main(void);
563 : :
564 : 1 : (void)main();
565 : : #endif /* CONFIG_BOOTARGS */
566 : :
567 : : /* Mark non-essential since main() has no more work to do */
568 : 0 : z_thread_essential_clear(&z_main_thread);
569 : :
570 : : #ifdef CONFIG_COVERAGE_DUMP
571 : : /* Dump coverage data once the main() has exited. */
572 : : gcov_coverage_dump();
573 : : #endif /* CONFIG_COVERAGE_DUMP */
574 : : } /* LCOV_EXCL_LINE ... because we just dumped final coverage data */
575 : :
576 : : #if defined(CONFIG_MULTITHREADING)
577 : : __boot_func
578 : 1 : static void init_idle_thread(int i)
579 : : {
580 : 1 : struct k_thread *thread = &z_idle_threads[i];
581 : 1 : k_thread_stack_t *stack = z_idle_stacks[i];
582 : 1 : size_t stack_size = K_KERNEL_STACK_SIZEOF(z_idle_stacks[i]);
583 : :
584 : : #ifdef CONFIG_THREAD_NAME
585 : :
586 : : #if CONFIG_MP_MAX_NUM_CPUS > 1
587 : : char tname[8];
588 : : snprintk(tname, 8, "idle %02d", i);
589 : : #else
590 : 1 : char *tname = "idle";
591 : : #endif /* CONFIG_MP_MAX_NUM_CPUS */
592 : :
593 : : #else
594 : : char *tname = NULL;
595 : : #endif /* CONFIG_THREAD_NAME */
596 : :
597 : 1 : z_setup_new_thread(thread, stack,
598 : 1 : stack_size, idle, &_kernel.cpus[i],
599 : : NULL, NULL, K_IDLE_PRIO, K_ESSENTIAL,
600 : : tname);
601 : 1 : z_mark_thread_as_started(thread);
602 : :
603 : : #ifdef CONFIG_SMP
604 : : thread->base.is_idle = 1U;
605 : : #endif /* CONFIG_SMP */
606 : 1 : }
607 : :
608 : 1 : void z_init_cpu(int id)
609 : : {
610 : 1 : init_idle_thread(id);
611 : 1 : _kernel.cpus[id].idle_thread = &z_idle_threads[id];
612 : 1 : _kernel.cpus[id].id = id;
613 : 1 : _kernel.cpus[id].irq_stack =
614 : 1 : (K_KERNEL_STACK_BUFFER(z_interrupt_stacks[id]) +
615 : : K_KERNEL_STACK_SIZEOF(z_interrupt_stacks[id]));
616 : : #ifdef CONFIG_SCHED_THREAD_USAGE_ALL
617 : : _kernel.cpus[id].usage = &_kernel.usage[id];
618 : : _kernel.cpus[id].usage->track_usage =
619 : : CONFIG_SCHED_THREAD_USAGE_AUTO_ENABLE;
620 : : #endif
621 : :
622 : : #ifdef CONFIG_PM
623 : : /*
624 : : * Increment number of CPUs active. The pm subsystem
625 : : * will keep track of this from here.
626 : : */
627 : : atomic_inc(&_cpus_active);
628 : : #endif
629 : :
630 : : #ifdef CONFIG_OBJ_CORE_SYSTEM
631 : : k_obj_core_init_and_link(K_OBJ_CORE(&_kernel.cpus[id]), &obj_type_cpu);
632 : : #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
633 : : k_obj_core_stats_register(K_OBJ_CORE(&_kernel.cpus[id]),
634 : : _kernel.cpus[id].usage,
635 : : sizeof(struct k_cycle_stats));
636 : : #endif
637 : : #endif
638 : 1 : }
639 : :
640 : : /**
641 : : *
642 : : * @brief Initializes kernel data structures
643 : : *
644 : : * This routine initializes various kernel data structures, including
645 : : * the init and idle threads and any architecture-specific initialization.
646 : : *
647 : : * Note that all fields of "_kernel" are set to zero on entry, which may
648 : : * be all the initialization many of them require.
649 : : *
650 : : * @return initial stack pointer for the main thread
651 : : */
652 : : __boot_func
653 : 1 : static char *prepare_multithreading(void)
654 : : {
655 : 1 : char *stack_ptr;
656 : :
657 : : /* _kernel.ready_q is all zeroes */
658 : 1 : z_sched_init();
659 : :
660 : : #ifndef CONFIG_SMP
661 : : /*
662 : : * prime the cache with the main thread since:
663 : : *
664 : : * - the cache can never be NULL
665 : : * - the main thread will be the one to run first
666 : : * - no other thread is initialized yet and thus their priority fields
667 : : * contain garbage, which would prevent the cache loading algorithm
668 : : * to work as intended
669 : : */
670 : 1 : _kernel.ready_q.cache = &z_main_thread;
671 : : #endif /* CONFIG_SMP */
672 : 1 : stack_ptr = z_setup_new_thread(&z_main_thread, z_main_stack,
673 : : K_THREAD_STACK_SIZEOF(z_main_stack),
674 : : bg_thread_main,
675 : : NULL, NULL, NULL,
676 : : CONFIG_MAIN_THREAD_PRIORITY,
677 : : K_ESSENTIAL, "main");
678 : 1 : z_mark_thread_as_started(&z_main_thread);
679 : 1 : z_ready_thread(&z_main_thread);
680 : :
681 : 1 : z_init_cpu(0);
682 : :
683 : 1 : return stack_ptr;
684 : : }
685 : :
686 : : __boot_func
687 : 1 : static FUNC_NORETURN void switch_to_main_thread(char *stack_ptr)
688 : : {
689 : : #ifdef CONFIG_ARCH_HAS_CUSTOM_SWAP_TO_MAIN
690 : 1 : arch_switch_to_main_thread(&z_main_thread, stack_ptr, bg_thread_main);
691 : : #else
692 : : ARG_UNUSED(stack_ptr);
693 : : /*
694 : : * Context switch to main task (entry function is _main()): the
695 : : * current fake thread is not on a wait queue or ready queue, so it
696 : : * will never be rescheduled in.
697 : : */
698 : : z_swap_unlocked();
699 : : #endif /* CONFIG_ARCH_HAS_CUSTOM_SWAP_TO_MAIN */
700 : : CODE_UNREACHABLE; /* LCOV_EXCL_LINE */
701 : : }
702 : : #endif /* CONFIG_MULTITHREADING */
703 : :
704 : : __boot_func
705 : 0 : void __weak z_early_rand_get(uint8_t *buf, size_t length)
706 : : {
707 : 0 : static uint64_t state = (uint64_t)CONFIG_TIMER_RANDOM_INITIAL_STATE;
708 : 0 : int rc;
709 : :
710 : : #ifdef CONFIG_ENTROPY_HAS_DRIVER
711 : : const struct device *const entropy = DEVICE_DT_GET_OR_NULL(DT_CHOSEN(zephyr_entropy));
712 : :
713 : : if ((entropy != NULL) && device_is_ready(entropy)) {
714 : : /* Try to see if driver provides an ISR-specific API */
715 : : rc = entropy_get_entropy_isr(entropy, buf, length, ENTROPY_BUSYWAIT);
716 : : if (rc > 0) {
717 : : length -= rc;
718 : : buf += rc;
719 : : }
720 : : }
721 : : #endif /* CONFIG_ENTROPY_HAS_DRIVER */
722 : :
723 [ # # ]: 0 : while (length > 0) {
724 : 0 : uint32_t val;
725 : :
726 : 0 : state = state + k_cycle_get_32();
727 : 0 : state = state * 2862933555777941757ULL + 3037000493ULL;
728 : 0 : val = (uint32_t)(state >> 32);
729 : 0 : rc = MIN(length, sizeof(val));
730 : 0 : z_early_memcpy((void *)buf, &val, rc);
731 : :
732 : 0 : length -= rc;
733 : 0 : buf += rc;
734 : : }
735 : 0 : }
736 : :
737 : : /**
738 : : *
739 : : * @brief Initialize kernel
740 : : *
741 : : * This routine is invoked when the system is ready to run C code. The
742 : : * processor must be running in 32-bit mode, and the BSS must have been
743 : : * cleared/zeroed.
744 : : *
745 : : * @return Does not return
746 : : */
747 : : __boot_func
748 : : FUNC_NO_STACK_PROTECTOR
749 : 1 : FUNC_NORETURN void z_cstart(void)
750 : : {
751 : : /* gcov hook needed to get the coverage report.*/
752 : 1 : gcov_static_init();
753 : :
754 : : /* initialize early init calls */
755 : 1 : z_sys_init_run_level(INIT_LEVEL_EARLY);
756 : :
757 : : /* perform any architecture-specific initialization */
758 : 1 : arch_kernel_init();
759 : :
760 : 1 : LOG_CORE_INIT();
761 : :
762 : : #if defined(CONFIG_MULTITHREADING)
763 : 1 : z_dummy_thread_init(&_thread_dummy);
764 : : #endif /* CONFIG_MULTITHREADING */
765 : : /* do any necessary initialization of static devices */
766 : 1 : z_device_state_init();
767 : :
768 : : #if CONFIG_SOC_EARLY_INIT_HOOK
769 : : soc_early_init_hook();
770 : : #endif
771 : : #if CONFIG_BOARD_EARLY_INIT_HOOK
772 : : board_early_init_hook();
773 : : #endif
774 : : /* perform basic hardware initialization */
775 : 1 : z_sys_init_run_level(INIT_LEVEL_PRE_KERNEL_1);
776 : : #if defined(CONFIG_SMP)
777 : : arch_smp_init();
778 : : #endif
779 : 1 : z_sys_init_run_level(INIT_LEVEL_PRE_KERNEL_2);
780 : :
781 : : #ifdef CONFIG_STACK_CANARIES
782 : : uintptr_t stack_guard;
783 : :
784 : : z_early_rand_get((uint8_t *)&stack_guard, sizeof(stack_guard));
785 : : __stack_chk_guard = stack_guard;
786 : : __stack_chk_guard <<= 8;
787 : : #endif /* CONFIG_STACK_CANARIES */
788 : :
789 : : #ifdef CONFIG_TIMING_FUNCTIONS_NEED_AT_BOOT
790 : : timing_init();
791 : : timing_start();
792 : : #endif /* CONFIG_TIMING_FUNCTIONS_NEED_AT_BOOT */
793 : :
794 : : #ifdef CONFIG_MULTITHREADING
795 : 1 : switch_to_main_thread(prepare_multithreading());
796 : : #else
797 : : #ifdef ARCH_SWITCH_TO_MAIN_NO_MULTITHREADING
798 : : /* Custom ARCH-specific routine to switch to main()
799 : : * in the case of no multi-threading.
800 : : */
801 : : ARCH_SWITCH_TO_MAIN_NO_MULTITHREADING(bg_thread_main,
802 : : NULL, NULL, NULL);
803 : : #else
804 : : bg_thread_main(NULL, NULL, NULL);
805 : :
806 : : /* LCOV_EXCL_START
807 : : * We've already dumped coverage data at this point.
808 : : */
809 : : irq_lock();
810 : : while (true) {
811 : : }
812 : : /* LCOV_EXCL_STOP */
813 : : #endif /* ARCH_SWITCH_TO_MAIN_NO_MULTITHREADING */
814 : : #endif /* CONFIG_MULTITHREADING */
815 : :
816 : : /*
817 : : * Compiler can't tell that the above routines won't return and issues
818 : : * a warning unless we explicitly tell it that control never gets this
819 : : * far.
820 : : */
821 : :
822 : : CODE_UNREACHABLE; /* LCOV_EXCL_LINE */
823 : : }
824 : :
825 : : #ifdef CONFIG_OBJ_CORE_SYSTEM
826 : : static int init_cpu_obj_core_list(void)
827 : : {
828 : : /* Initialize CPU object type */
829 : :
830 : : z_obj_type_init(&obj_type_cpu, K_OBJ_TYPE_CPU_ID,
831 : : offsetof(struct _cpu, obj_core));
832 : :
833 : : #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
834 : : k_obj_type_stats_init(&obj_type_cpu, &cpu_stats_desc);
835 : : #endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */
836 : :
837 : : return 0;
838 : : }
839 : :
840 : : static int init_kernel_obj_core_list(void)
841 : : {
842 : : /* Initialize kernel object type */
843 : :
844 : : z_obj_type_init(&obj_type_kernel, K_OBJ_TYPE_KERNEL_ID,
845 : : offsetof(struct z_kernel, obj_core));
846 : :
847 : : #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
848 : : k_obj_type_stats_init(&obj_type_kernel, &kernel_stats_desc);
849 : : #endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */
850 : :
851 : : k_obj_core_init_and_link(K_OBJ_CORE(&_kernel), &obj_type_kernel);
852 : : #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
853 : : k_obj_core_stats_register(K_OBJ_CORE(&_kernel), _kernel.usage,
854 : : sizeof(_kernel.usage));
855 : : #endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */
856 : :
857 : : return 0;
858 : : }
859 : :
860 : : SYS_INIT(init_cpu_obj_core_list, PRE_KERNEL_1,
861 : : CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
862 : :
863 : : SYS_INIT(init_kernel_obj_core_list, PRE_KERNEL_1,
864 : : CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
865 : : #endif /* CONFIG_OBJ_CORE_SYSTEM */
|
