Branch data Line data Source code
1 : : /*
2 : : * Copyright (c) 2019 Intel Corporation.
3 : : *
4 : : * SPDX-License-Identifier: Apache-2.0
5 : : */
6 : :
7 : : #include <zephyr/kernel.h>
8 : :
9 : : #include <kernel_internal.h>
10 : : #include <zephyr/kernel_structs.h>
11 : : #include <zephyr/sys/__assert.h>
12 : : #include <zephyr/arch/cpu.h>
13 : : #include <zephyr/logging/log_ctrl.h>
14 : : #include <zephyr/logging/log.h>
15 : : #include <zephyr/fatal.h>
16 : : #include <zephyr/debug/coredump.h>
17 : :
18 : : LOG_MODULE_DECLARE(os, CONFIG_KERNEL_LOG_LEVEL);
19 : :
20 : : /* LCOV_EXCL_START */
21 : : FUNC_NORETURN __weak void arch_system_halt(unsigned int reason)
22 : : {
23 : : ARG_UNUSED(reason);
24 : :
25 : : /* TODO: What's the best way to totally halt the system if SMP
26 : : * is enabled?
27 : : */
28 : :
29 : : (void)arch_irq_lock();
30 : : for (;;) {
31 : : /* Spin endlessly */
32 : : }
33 : : }
34 : : /* LCOV_EXCL_STOP */
35 : :
36 : : /* LCOV_EXCL_START */
37 : : __weak void k_sys_fatal_error_handler(unsigned int reason,
38 : : const struct arch_esf *esf)
39 : : {
40 : : ARG_UNUSED(esf);
41 : :
42 : : LOG_PANIC();
43 : : LOG_ERR("Halting system");
44 : : arch_system_halt(reason);
45 : : CODE_UNREACHABLE;
46 : : }
47 : : /* LCOV_EXCL_STOP */
48 : :
49 : 0 : static const char *thread_name_get(struct k_thread *thread)
50 : : {
51 [ # # ]: 0 : const char *thread_name = (thread != NULL) ? k_thread_name_get(thread) : NULL;
52 : :
53 [ # # # # ]: 0 : if ((thread_name == NULL) || (thread_name[0] == '\0')) {
54 : : thread_name = "unknown";
55 : : }
56 : :
57 : 0 : return thread_name;
58 : : }
59 : :
60 : 0 : static const char *reason_to_str(unsigned int reason)
61 : : {
62 [ # # ]: 0 : switch (reason) {
63 : : case K_ERR_CPU_EXCEPTION:
64 : : return "CPU exception";
65 : : case K_ERR_SPURIOUS_IRQ:
66 : : return "Unhandled interrupt";
67 : : case K_ERR_STACK_CHK_FAIL:
68 : : return "Stack overflow";
69 : : case K_ERR_KERNEL_OOPS:
70 : : return "Kernel oops";
71 : : case K_ERR_KERNEL_PANIC:
72 : : return "Kernel panic";
73 : : default:
74 : : return "Unknown error";
75 : : }
76 : : }
77 : :
78 : : /* LCOV_EXCL_START */
79 : : FUNC_NORETURN void k_fatal_halt(unsigned int reason)
80 : : {
81 : : arch_system_halt(reason);
82 : : }
83 : : /* LCOV_EXCL_STOP */
84 : :
85 : 0 : void z_fatal_error(unsigned int reason, const struct arch_esf *esf)
86 : : {
87 : : /* We can't allow this code to be preempted, but don't need to
88 : : * synchronize between CPUs, so an arch-layer lock is
89 : : * appropriate.
90 : : */
91 : 0 : unsigned int key = arch_irq_lock();
92 : 0 : struct k_thread *thread = IS_ENABLED(CONFIG_MULTITHREADING) ?
93 : : _current : NULL;
94 : :
95 : : /* twister looks for the "ZEPHYR FATAL ERROR" string, don't
96 : : * change it without also updating twister
97 : : */
98 : 0 : LOG_ERR(">>> ZEPHYR FATAL ERROR %d: %s on CPU %d", reason,
99 : : reason_to_str(reason), _current_cpu->id);
100 : :
101 : : /* FIXME: This doesn't seem to work as expected on all arches.
102 : : * Need a reliable way to determine whether the fault happened when
103 : : * an IRQ or exception was being handled, or thread context.
104 : : *
105 : : * See #17656
106 : : */
107 : : #if defined(CONFIG_ARCH_HAS_NESTED_EXCEPTION_DETECTION)
108 : : if ((esf != NULL) && arch_is_in_nested_exception(esf)) {
109 : : LOG_ERR("Fault during interrupt handling\n");
110 : : }
111 : : #endif /* CONFIG_ARCH_HAS_NESTED_EXCEPTION_DETECTION */
112 : :
113 : 0 : if (IS_ENABLED(CONFIG_MULTITHREADING)) {
114 : 0 : LOG_ERR("Current thread: %p (%s)", thread, thread_name_get(thread));
115 : : }
116 : :
117 : 0 : coredump(reason, esf, thread);
118 : :
119 : 0 : k_sys_fatal_error_handler(reason, esf);
120 : :
121 : : /* If the system fatal error handler returns, then kill the faulting
122 : : * thread; a policy decision was made not to hang the system.
123 : : *
124 : : * Policy for fatal errors in ISRs: unconditionally panic.
125 : : *
126 : : * There is one exception to this policy: a stack sentinel
127 : : * check may be performed (on behalf of the current thread)
128 : : * during ISR exit, but in this case the thread should be
129 : : * aborted.
130 : : *
131 : : * Note that k_thread_abort() returns on some architectures but
132 : : * not others; e.g. on ARC, x86_64, Xtensa with ASM2, ARM
133 : : */
134 : 0 : if (!IS_ENABLED(CONFIG_TEST)) {
135 : : __ASSERT(reason != K_ERR_KERNEL_PANIC,
136 : : "Attempted to recover from a kernel panic condition");
137 : : /* FIXME: #17656 */
138 : : #if defined(CONFIG_ARCH_HAS_NESTED_EXCEPTION_DETECTION)
139 : : if ((esf != NULL) && arch_is_in_nested_exception(esf)) {
140 : : #if defined(CONFIG_STACK_SENTINEL)
141 : : if (reason != K_ERR_STACK_CHK_FAIL) {
142 : : __ASSERT(0,
143 : : "Attempted to recover from a fatal error in ISR");
144 : : }
145 : : #endif /* CONFIG_STACK_SENTINEL */
146 : : }
147 : : #endif /* CONFIG_ARCH_HAS_NESTED_EXCEPTION_DETECTION */
148 : : } else {
149 : : /* Test mode */
150 : : #if defined(CONFIG_ARCH_HAS_NESTED_EXCEPTION_DETECTION)
151 : : if ((esf != NULL) && arch_is_in_nested_exception(esf)) {
152 : : /* Abort the thread only on STACK Sentinel check fail. */
153 : : #if defined(CONFIG_STACK_SENTINEL)
154 : : if (reason != K_ERR_STACK_CHK_FAIL) {
155 : : arch_irq_unlock(key);
156 : : return;
157 : : }
158 : : #else
159 : : arch_irq_unlock(key);
160 : : return;
161 : : #endif /* CONFIG_STACK_SENTINEL */
162 : : } else {
163 : : /* Abort the thread only if the fault is not due to
164 : : * a spurious ISR handler triggered.
165 : : */
166 : : if (reason == K_ERR_SPURIOUS_IRQ) {
167 : : arch_irq_unlock(key);
168 : : return;
169 : : }
170 : : }
171 : : #endif /*CONFIG_ARCH_HAS_NESTED_EXCEPTION_DETECTION */
172 : 0 : }
173 : :
174 : 0 : arch_irq_unlock(key);
175 : :
176 : 0 : if (IS_ENABLED(CONFIG_MULTITHREADING)) {
177 : 0 : k_thread_abort(thread);
178 : : }
179 : 0 : }
|
