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 <ipi.h>
32 #include <zephyr/sys/dlist.h>
33 #include <kernel_internal.h>
34 #include <zephyr/drivers/entropy.h>
35 #include <zephyr/logging/log_ctrl.h>
36 #include <zephyr/tracing/tracing.h>
37 #include <zephyr/debug/gcov.h>
38 #include <kswap.h>
39 #include <zephyr/timing/timing.h>
40 #include <zephyr/logging/log.h>
41 #include <zephyr/internal/syscall_handler.h>
42 #include <zephyr/arch/common/init.h>
43
44 LOG_MODULE_REGISTER(os, CONFIG_KERNEL_LOG_LEVEL);
45
46 /* the only struct z_kernel instance */
47 __pinned_bss
48 struct z_kernel _kernel;
49
50 #ifdef CONFIG_PM
51 __pinned_bss atomic_t _cpus_active;
52 #endif
53
54 /* init/main and idle threads */
55 K_THREAD_PINNED_STACK_DEFINE(z_main_stack, CONFIG_MAIN_STACK_SIZE);
56 struct k_thread z_main_thread;
57
58 #ifdef CONFIG_MULTITHREADING
59 __pinned_bss
60 struct k_thread z_idle_threads[CONFIG_MP_MAX_NUM_CPUS];
61
62 static K_KERNEL_PINNED_STACK_ARRAY_DEFINE(z_idle_stacks,
63 CONFIG_MP_MAX_NUM_CPUS,
64 CONFIG_IDLE_STACK_SIZE);
65
z_init_static_threads(void)66 static void z_init_static_threads(void)
67 {
68 STRUCT_SECTION_FOREACH(_static_thread_data, thread_data) {
69 z_setup_new_thread(
70 thread_data->init_thread,
71 thread_data->init_stack,
72 thread_data->init_stack_size,
73 thread_data->init_entry,
74 thread_data->init_p1,
75 thread_data->init_p2,
76 thread_data->init_p3,
77 thread_data->init_prio,
78 thread_data->init_options,
79 thread_data->init_name);
80
81 thread_data->init_thread->init_data = thread_data;
82 }
83
84 #ifdef CONFIG_USERSPACE
85 STRUCT_SECTION_FOREACH(k_object_assignment, pos) {
86 for (int i = 0; pos->objects[i] != NULL; i++) {
87 k_object_access_grant(pos->objects[i],
88 pos->thread);
89 }
90 }
91 #endif /* CONFIG_USERSPACE */
92
93 /*
94 * Non-legacy static threads may be started immediately or
95 * after a previously specified delay. Even though the
96 * scheduler is locked, ticks can still be delivered and
97 * processed. Take a sched lock to prevent them from running
98 * until they are all started.
99 *
100 * Note that static threads defined using the legacy API have a
101 * delay of K_FOREVER.
102 */
103 k_sched_lock();
104 STRUCT_SECTION_FOREACH(_static_thread_data, thread_data) {
105 k_timeout_t init_delay = Z_THREAD_INIT_DELAY(thread_data);
106
107 if (!K_TIMEOUT_EQ(init_delay, K_FOREVER)) {
108 thread_schedule_new(thread_data->init_thread,
109 init_delay);
110 }
111 }
112 k_sched_unlock();
113 }
114 #else
115 #define z_init_static_threads() do { } while (false)
116 #endif /* CONFIG_MULTITHREADING */
117
118 extern const struct init_entry __init_start[];
119 extern const struct init_entry __init_EARLY_start[];
120 extern const struct init_entry __init_PRE_KERNEL_1_start[];
121 extern const struct init_entry __init_PRE_KERNEL_2_start[];
122 extern const struct init_entry __init_POST_KERNEL_start[];
123 extern const struct init_entry __init_APPLICATION_start[];
124 extern const struct init_entry __init_end[];
125
126 enum init_level {
127 INIT_LEVEL_EARLY = 0,
128 INIT_LEVEL_PRE_KERNEL_1,
129 INIT_LEVEL_PRE_KERNEL_2,
130 INIT_LEVEL_POST_KERNEL,
131 INIT_LEVEL_APPLICATION,
132 #ifdef CONFIG_SMP
133 INIT_LEVEL_SMP,
134 #endif /* CONFIG_SMP */
135 };
136
137 #ifdef CONFIG_SMP
138 extern const struct init_entry __init_SMP_start[];
139 #endif /* CONFIG_SMP */
140
141 /*
142 * storage space for the interrupt stack
143 *
144 * Note: This area is used as the system stack during kernel initialization,
145 * since the kernel hasn't yet set up its own stack areas. The dual purposing
146 * of this area is safe since interrupts are disabled until the kernel context
147 * switches to the init thread.
148 */
149 K_KERNEL_PINNED_STACK_ARRAY_DEFINE(z_interrupt_stacks,
150 CONFIG_MP_MAX_NUM_CPUS,
151 CONFIG_ISR_STACK_SIZE);
152
153 extern void idle(void *unused1, void *unused2, void *unused3);
154
155 #ifdef CONFIG_OBJ_CORE_SYSTEM
156 static struct k_obj_type obj_type_cpu;
157 static struct k_obj_type obj_type_kernel;
158
159 #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
160 static struct k_obj_core_stats_desc cpu_stats_desc = {
161 .raw_size = sizeof(struct k_cycle_stats),
162 .query_size = sizeof(struct k_thread_runtime_stats),
163 .raw = z_cpu_stats_raw,
164 .query = z_cpu_stats_query,
165 .reset = NULL,
166 .disable = NULL,
167 .enable = NULL,
168 };
169
170 static struct k_obj_core_stats_desc kernel_stats_desc = {
171 .raw_size = sizeof(struct k_cycle_stats) * CONFIG_MP_MAX_NUM_CPUS,
172 .query_size = sizeof(struct k_thread_runtime_stats),
173 .raw = z_kernel_stats_raw,
174 .query = z_kernel_stats_query,
175 .reset = NULL,
176 .disable = NULL,
177 .enable = NULL,
178 };
179 #endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */
180 #endif /* CONFIG_OBJ_CORE_SYSTEM */
181
182 #ifdef CONFIG_REQUIRES_STACK_CANARIES
183 #ifdef CONFIG_STACK_CANARIES_TLS
184 extern Z_THREAD_LOCAL volatile uintptr_t __stack_chk_guard;
185 #else
186 extern volatile uintptr_t __stack_chk_guard;
187 #endif /* CONFIG_STACK_CANARIES_TLS */
188 #endif /* CONFIG_REQUIRES_STACK_CANARIES */
189
190 __pinned_bss
191 bool z_sys_post_kernel;
192
193 /* defined in device.c */
194 extern int do_device_init(const struct device *dev);
195
196 /**
197 * @brief Initialize state for all static devices.
198 *
199 * The state object is always zero-initialized, but this may not be
200 * sufficient.
201 */
z_device_state_init(void)202 static void z_device_state_init(void)
203 {
204 STRUCT_SECTION_FOREACH(device, dev) {
205 k_object_init(dev);
206 }
207 }
208
209 /**
210 * @brief Execute all the init entry initialization functions at a given level
211 *
212 * @details Invokes the initialization routine for each init entry object
213 * created by the INIT_ENTRY_DEFINE() macro using the specified level.
214 * The linker script places the init entry objects in memory in the order
215 * they need to be invoked, with symbols indicating where one level leaves
216 * off and the next one begins.
217 *
218 * @param level init level to run.
219 */
z_sys_init_run_level(enum init_level level)220 static void z_sys_init_run_level(enum init_level level)
221 {
222 static const struct init_entry *levels[] = {
223 __init_EARLY_start,
224 __init_PRE_KERNEL_1_start,
225 __init_PRE_KERNEL_2_start,
226 __init_POST_KERNEL_start,
227 __init_APPLICATION_start,
228 #ifdef CONFIG_SMP
229 __init_SMP_start,
230 #endif /* CONFIG_SMP */
231 /* End marker */
232 __init_end,
233 };
234 const struct init_entry *entry;
235
236 for (entry = levels[level]; entry < levels[level+1]; entry++) {
237 const struct device *dev = entry->dev;
238 int result = 0;
239
240 sys_trace_sys_init_enter(entry, level);
241 if (dev != NULL) {
242 if ((dev->flags & DEVICE_FLAG_INIT_DEFERRED) == 0U) {
243 result = do_device_init(dev);
244 }
245 } else {
246 result = entry->init_fn();
247 }
248 sys_trace_sys_init_exit(entry, level, result);
249 }
250 }
251
252 /* defined in banner.c */
253 extern void boot_banner(void);
254
255
256 #ifdef CONFIG_STATIC_INIT_GNU
257
258 extern void (*__zephyr_init_array_start[])();
259 extern void (*__zephyr_init_array_end[])();
260
z_static_init_gnu(void)261 static void z_static_init_gnu(void)
262 {
263 void (**fn)();
264
265 for (fn = __zephyr_init_array_start; fn != __zephyr_init_array_end; fn++) {
266 /* MWDT toolchain sticks a NULL at the end of the array */
267 if (*fn == NULL) {
268 break;
269 }
270 (**fn)();
271 }
272 }
273
274 #endif
275
276 /**
277 * @brief Mainline for kernel's background thread
278 *
279 * This routine completes kernel initialization by invoking the remaining
280 * init functions, then invokes application's main() routine.
281 */
282 __boot_func
bg_thread_main(void * unused1,void * unused2,void * unused3)283 static void bg_thread_main(void *unused1, void *unused2, void *unused3)
284 {
285 ARG_UNUSED(unused1);
286 ARG_UNUSED(unused2);
287 ARG_UNUSED(unused3);
288
289 #ifdef CONFIG_MMU
290 /* Invoked here such that backing store or eviction algorithms may
291 * initialize kernel objects, and that all POST_KERNEL and later tasks
292 * may perform memory management tasks (except for
293 * k_mem_map_phys_bare() which is allowed at any time)
294 */
295 z_mem_manage_init();
296 #endif /* CONFIG_MMU */
297 z_sys_post_kernel = true;
298
299 #if CONFIG_IRQ_OFFLOAD
300 arch_irq_offload_init();
301 #endif
302 z_sys_init_run_level(INIT_LEVEL_POST_KERNEL);
303
304 soc_late_init_hook();
305
306 board_late_init_hook();
307
308 #if defined(CONFIG_STACK_POINTER_RANDOM) && (CONFIG_STACK_POINTER_RANDOM != 0)
309 z_stack_adjust_initialized = 1;
310 #endif /* CONFIG_STACK_POINTER_RANDOM */
311 boot_banner();
312
313 #ifdef CONFIG_STATIC_INIT_GNU
314 z_static_init_gnu();
315 #endif /* CONFIG_STATIC_INIT_GNU */
316
317 /* Final init level before app starts */
318 z_sys_init_run_level(INIT_LEVEL_APPLICATION);
319
320 z_init_static_threads();
321
322 #ifdef CONFIG_KERNEL_COHERENCE
323 __ASSERT_NO_MSG(sys_cache_is_mem_coherent(&_kernel));
324 #endif /* CONFIG_KERNEL_COHERENCE */
325
326 #ifdef CONFIG_SMP
327 if (!IS_ENABLED(CONFIG_SMP_BOOT_DELAY)) {
328 z_smp_init();
329 }
330 z_sys_init_run_level(INIT_LEVEL_SMP);
331 #endif /* CONFIG_SMP */
332
333 #ifdef CONFIG_MMU
334 z_mem_manage_boot_finish();
335 #endif /* CONFIG_MMU */
336
337 #ifdef CONFIG_BOOTARGS
338 extern int main(int, char **);
339 extern char **prepare_main_args(int *argc);
340
341 int argc = 0;
342 char **argv = prepare_main_args(&argc);
343 (void)main(argc, argv);
344 #else
345 extern int main(void);
346
347 (void)main();
348 #endif /* CONFIG_BOOTARGS */
349
350 /* Mark non-essential since main() has no more work to do */
351 z_thread_essential_clear(&z_main_thread);
352
353 #ifdef CONFIG_COVERAGE_DUMP
354 /* Dump coverage data once the main() has exited. */
355 gcov_coverage_dump();
356 #elif defined(CONFIG_COVERAGE_SEMIHOST)
357 gcov_coverage_semihost();
358 #endif /* CONFIG_COVERAGE_DUMP */
359 } /* LCOV_EXCL_LINE ... because we just dumped final coverage data */
360
361 #if defined(CONFIG_MULTITHREADING)
362 __boot_func
init_idle_thread(int i)363 static void init_idle_thread(int i)
364 {
365 struct k_thread *thread = &z_idle_threads[i];
366 k_thread_stack_t *stack = z_idle_stacks[i];
367 size_t stack_size = K_KERNEL_STACK_SIZEOF(z_idle_stacks[i]);
368
369 #ifdef CONFIG_THREAD_NAME
370
371 #if CONFIG_MP_MAX_NUM_CPUS > 1
372 char tname[8];
373 snprintk(tname, 8, "idle %02d", i);
374 #else
375 char *tname = "idle";
376 #endif /* CONFIG_MP_MAX_NUM_CPUS */
377
378 #else
379 char *tname = NULL;
380 #endif /* CONFIG_THREAD_NAME */
381
382 z_setup_new_thread(thread, stack,
383 stack_size, idle, &_kernel.cpus[i],
384 NULL, NULL, K_IDLE_PRIO, K_ESSENTIAL,
385 tname);
386 z_mark_thread_as_not_sleeping(thread);
387
388 #ifdef CONFIG_SMP
389 thread->base.is_idle = 1U;
390 #endif /* CONFIG_SMP */
391 }
392
z_init_cpu(int id)393 void z_init_cpu(int id)
394 {
395 init_idle_thread(id);
396 _kernel.cpus[id].idle_thread = &z_idle_threads[id];
397 _kernel.cpus[id].id = id;
398 _kernel.cpus[id].irq_stack =
399 (K_KERNEL_STACK_BUFFER(z_interrupt_stacks[id]) +
400 K_KERNEL_STACK_SIZEOF(z_interrupt_stacks[id]));
401 #ifdef CONFIG_SCHED_THREAD_USAGE_ALL
402 _kernel.cpus[id].usage = &_kernel.usage[id];
403 _kernel.cpus[id].usage->track_usage =
404 CONFIG_SCHED_THREAD_USAGE_AUTO_ENABLE;
405 #endif
406
407 #ifdef CONFIG_PM
408 /*
409 * Increment number of CPUs active. The pm subsystem
410 * will keep track of this from here.
411 */
412 atomic_inc(&_cpus_active);
413 #endif
414
415 #ifdef CONFIG_OBJ_CORE_SYSTEM
416 k_obj_core_init_and_link(K_OBJ_CORE(&_kernel.cpus[id]), &obj_type_cpu);
417 #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
418 k_obj_core_stats_register(K_OBJ_CORE(&_kernel.cpus[id]),
419 _kernel.cpus[id].usage,
420 sizeof(struct k_cycle_stats));
421 #endif
422 #endif
423
424 #ifdef CONFIG_SCHED_IPI_SUPPORTED
425 sys_dlist_init(&_kernel.cpus[id].ipi_workq);
426 #endif
427 }
428
429 /**
430 *
431 * @brief Initializes kernel data structures
432 *
433 * This routine initializes various kernel data structures, including
434 * the init and idle threads and any architecture-specific initialization.
435 *
436 * Note that all fields of "_kernel" are set to zero on entry, which may
437 * be all the initialization many of them require.
438 *
439 * @return initial stack pointer for the main thread
440 */
441 __boot_func
prepare_multithreading(void)442 static char *prepare_multithreading(void)
443 {
444 char *stack_ptr;
445
446 /* _kernel.ready_q is all zeroes */
447 z_sched_init();
448
449 #ifndef CONFIG_SMP
450 /*
451 * prime the cache with the main thread since:
452 *
453 * - the cache can never be NULL
454 * - the main thread will be the one to run first
455 * - no other thread is initialized yet and thus their priority fields
456 * contain garbage, which would prevent the cache loading algorithm
457 * to work as intended
458 */
459 _kernel.ready_q.cache = &z_main_thread;
460 #endif /* CONFIG_SMP */
461 stack_ptr = z_setup_new_thread(&z_main_thread, z_main_stack,
462 K_THREAD_STACK_SIZEOF(z_main_stack),
463 bg_thread_main,
464 NULL, NULL, NULL,
465 CONFIG_MAIN_THREAD_PRIORITY,
466 K_ESSENTIAL, "main");
467 z_mark_thread_as_not_sleeping(&z_main_thread);
468 z_ready_thread(&z_main_thread);
469
470 z_init_cpu(0);
471
472 return stack_ptr;
473 }
474
475 __boot_func
switch_to_main_thread(char * stack_ptr)476 static FUNC_NORETURN void switch_to_main_thread(char *stack_ptr)
477 {
478 #ifdef CONFIG_ARCH_HAS_CUSTOM_SWAP_TO_MAIN
479 arch_switch_to_main_thread(&z_main_thread, stack_ptr, bg_thread_main);
480 #else
481 ARG_UNUSED(stack_ptr);
482 /*
483 * Context switch to main task (entry function is _main()): the
484 * current fake thread is not on a wait queue or ready queue, so it
485 * will never be rescheduled in.
486 */
487 z_swap_unlocked();
488 #endif /* CONFIG_ARCH_HAS_CUSTOM_SWAP_TO_MAIN */
489 CODE_UNREACHABLE; /* LCOV_EXCL_LINE */
490 }
491 #endif /* CONFIG_MULTITHREADING */
492
493 __boot_func
z_early_rand_get(uint8_t * buf,size_t length)494 void __weak z_early_rand_get(uint8_t *buf, size_t length)
495 {
496 static uint64_t state = (uint64_t)CONFIG_TIMER_RANDOM_INITIAL_STATE;
497 int rc;
498
499 #ifdef CONFIG_ENTROPY_HAS_DRIVER
500 const struct device *const entropy = DEVICE_DT_GET_OR_NULL(DT_CHOSEN(zephyr_entropy));
501
502 if ((entropy != NULL) && device_is_ready(entropy)) {
503 /* Try to see if driver provides an ISR-specific API */
504 rc = entropy_get_entropy_isr(entropy, buf, length, ENTROPY_BUSYWAIT);
505 if (rc > 0) {
506 length -= rc;
507 buf += rc;
508 }
509 }
510 #endif /* CONFIG_ENTROPY_HAS_DRIVER */
511
512 while (length > 0) {
513 uint32_t val;
514
515 state = state + k_cycle_get_32();
516 state = state * 2862933555777941757ULL + 3037000493ULL;
517 val = (uint32_t)(state >> 32);
518 rc = min(length, sizeof(val));
519 arch_early_memcpy((void *)buf, &val, rc);
520
521 length -= rc;
522 buf += rc;
523 }
524 }
525
526 /**
527 *
528 * @brief Initialize kernel
529 *
530 * This routine is invoked when the system is ready to run C code. The
531 * processor must be running in 32-bit mode, and the BSS must have been
532 * cleared/zeroed.
533 *
534 * @return Does not return
535 */
536 __boot_func
537 FUNC_NO_STACK_PROTECTOR
z_cstart(void)538 FUNC_NORETURN void z_cstart(void)
539 {
540 /* gcov hook needed to get the coverage report.*/
541 gcov_static_init();
542
543 /* initialize early init calls */
544 z_sys_init_run_level(INIT_LEVEL_EARLY);
545
546 /* perform any architecture-specific initialization */
547 arch_kernel_init();
548
549 LOG_CORE_INIT();
550
551 #if defined(CONFIG_MULTITHREADING)
552 z_dummy_thread_init(&_thread_dummy);
553 #endif /* CONFIG_MULTITHREADING */
554 /* do any necessary initialization of static devices */
555 z_device_state_init();
556
557 soc_early_init_hook();
558
559 board_early_init_hook();
560
561 /* perform basic hardware initialization */
562 z_sys_init_run_level(INIT_LEVEL_PRE_KERNEL_1);
563 #if defined(CONFIG_SMP)
564 arch_smp_init();
565 #endif
566 z_sys_init_run_level(INIT_LEVEL_PRE_KERNEL_2);
567
568 #ifdef CONFIG_REQUIRES_STACK_CANARIES
569 uintptr_t stack_guard;
570
571 z_early_rand_get((uint8_t *)&stack_guard, sizeof(stack_guard));
572 __stack_chk_guard = stack_guard;
573 __stack_chk_guard <<= 8;
574 #endif /* CONFIG_REQUIRES_STACK_CANARIES */
575
576 #ifdef CONFIG_TIMING_FUNCTIONS_NEED_AT_BOOT
577 timing_init();
578 timing_start();
579 #endif /* CONFIG_TIMING_FUNCTIONS_NEED_AT_BOOT */
580
581 #ifdef CONFIG_MULTITHREADING
582 switch_to_main_thread(prepare_multithreading());
583 #else
584 #ifdef ARCH_SWITCH_TO_MAIN_NO_MULTITHREADING
585 /* Custom ARCH-specific routine to switch to main()
586 * in the case of no multi-threading.
587 */
588 ARCH_SWITCH_TO_MAIN_NO_MULTITHREADING(bg_thread_main,
589 NULL, NULL, NULL);
590 #else
591 bg_thread_main(NULL, NULL, NULL);
592
593 /* LCOV_EXCL_START
594 * We've already dumped coverage data at this point.
595 */
596 irq_lock();
597 while (true) {
598 }
599 /* LCOV_EXCL_STOP */
600 #endif /* ARCH_SWITCH_TO_MAIN_NO_MULTITHREADING */
601 #endif /* CONFIG_MULTITHREADING */
602
603 /*
604 * Compiler can't tell that the above routines won't return and issues
605 * a warning unless we explicitly tell it that control never gets this
606 * far.
607 */
608
609 CODE_UNREACHABLE; /* LCOV_EXCL_LINE */
610 }
611
612 #ifdef CONFIG_OBJ_CORE_SYSTEM
init_cpu_obj_core_list(void)613 static int init_cpu_obj_core_list(void)
614 {
615 /* Initialize CPU object type */
616
617 z_obj_type_init(&obj_type_cpu, K_OBJ_TYPE_CPU_ID,
618 offsetof(struct _cpu, obj_core));
619
620 #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
621 k_obj_type_stats_init(&obj_type_cpu, &cpu_stats_desc);
622 #endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */
623
624 return 0;
625 }
626
init_kernel_obj_core_list(void)627 static int init_kernel_obj_core_list(void)
628 {
629 /* Initialize kernel object type */
630
631 z_obj_type_init(&obj_type_kernel, K_OBJ_TYPE_KERNEL_ID,
632 offsetof(struct z_kernel, obj_core));
633
634 #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
635 k_obj_type_stats_init(&obj_type_kernel, &kernel_stats_desc);
636 #endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */
637
638 k_obj_core_init_and_link(K_OBJ_CORE(&_kernel), &obj_type_kernel);
639 #ifdef CONFIG_OBJ_CORE_STATS_SYSTEM
640 k_obj_core_stats_register(K_OBJ_CORE(&_kernel), _kernel.usage,
641 sizeof(_kernel.usage));
642 #endif /* CONFIG_OBJ_CORE_STATS_SYSTEM */
643
644 return 0;
645 }
646
647 SYS_INIT(init_cpu_obj_core_list, PRE_KERNEL_1,
648 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
649
650 SYS_INIT(init_kernel_obj_core_list, PRE_KERNEL_1,
651 CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
652 #endif /* CONFIG_OBJ_CORE_SYSTEM */
653
