GNU Linux-libre 6.1.91-gnu
[releases.git] / arch / arm64 / kernel / stacktrace.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Stack tracing support
4  *
5  * Copyright (C) 2012 ARM Ltd.
6  */
7 #include <linux/kernel.h>
8 #include <linux/efi.h>
9 #include <linux/export.h>
10 #include <linux/ftrace.h>
11 #include <linux/sched.h>
12 #include <linux/sched/debug.h>
13 #include <linux/sched/task_stack.h>
14 #include <linux/stacktrace.h>
15
16 #include <asm/efi.h>
17 #include <asm/irq.h>
18 #include <asm/stack_pointer.h>
19 #include <asm/stacktrace.h>
20
21 /*
22  * Start an unwind from a pt_regs.
23  *
24  * The unwind will begin at the PC within the regs.
25  *
26  * The regs must be on a stack currently owned by the calling task.
27  */
28 static __always_inline void unwind_init_from_regs(struct unwind_state *state,
29                                                   struct pt_regs *regs)
30 {
31         unwind_init_common(state, current);
32
33         state->fp = regs->regs[29];
34         state->pc = regs->pc;
35 }
36
37 /*
38  * Start an unwind from a caller.
39  *
40  * The unwind will begin at the caller of whichever function this is inlined
41  * into.
42  *
43  * The function which invokes this must be noinline.
44  */
45 static __always_inline void unwind_init_from_caller(struct unwind_state *state)
46 {
47         unwind_init_common(state, current);
48
49         state->fp = (unsigned long)__builtin_frame_address(1);
50         state->pc = (unsigned long)__builtin_return_address(0);
51 }
52
53 /*
54  * Start an unwind from a blocked task.
55  *
56  * The unwind will begin at the blocked tasks saved PC (i.e. the caller of
57  * cpu_switch_to()).
58  *
59  * The caller should ensure the task is blocked in cpu_switch_to() for the
60  * duration of the unwind, or the unwind will be bogus. It is never valid to
61  * call this for the current task.
62  */
63 static __always_inline void unwind_init_from_task(struct unwind_state *state,
64                                                   struct task_struct *task)
65 {
66         unwind_init_common(state, task);
67
68         state->fp = thread_saved_fp(task);
69         state->pc = thread_saved_pc(task);
70 }
71
72 /*
73  * Unwind from one frame record (A) to the next frame record (B).
74  *
75  * We terminate early if the location of B indicates a malformed chain of frame
76  * records (e.g. a cycle), determined based on the location and fp value of A
77  * and the location (but not the fp value) of B.
78  */
79 static int notrace unwind_next(struct unwind_state *state)
80 {
81         struct task_struct *tsk = state->task;
82         unsigned long fp = state->fp;
83         int err;
84
85         /* Final frame; nothing to unwind */
86         if (fp == (unsigned long)task_pt_regs(tsk)->stackframe)
87                 return -ENOENT;
88
89         err = unwind_next_frame_record(state);
90         if (err)
91                 return err;
92
93         state->pc = ptrauth_strip_insn_pac(state->pc);
94
95 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
96         if (tsk->ret_stack &&
97                 (state->pc == (unsigned long)return_to_handler)) {
98                 unsigned long orig_pc;
99                 /*
100                  * This is a case where function graph tracer has
101                  * modified a return address (LR) in a stack frame
102                  * to hook a function return.
103                  * So replace it to an original value.
104                  */
105                 orig_pc = ftrace_graph_ret_addr(tsk, NULL, state->pc,
106                                                 (void *)state->fp);
107                 if (WARN_ON_ONCE(state->pc == orig_pc))
108                         return -EINVAL;
109                 state->pc = orig_pc;
110         }
111 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
112 #ifdef CONFIG_KRETPROBES
113         if (is_kretprobe_trampoline(state->pc))
114                 state->pc = kretprobe_find_ret_addr(tsk, (void *)state->fp, &state->kr_cur);
115 #endif
116
117         return 0;
118 }
119 NOKPROBE_SYMBOL(unwind_next);
120
121 static void notrace unwind(struct unwind_state *state,
122                            stack_trace_consume_fn consume_entry, void *cookie)
123 {
124         while (1) {
125                 int ret;
126
127                 if (!consume_entry(cookie, state->pc))
128                         break;
129                 ret = unwind_next(state);
130                 if (ret < 0)
131                         break;
132         }
133 }
134 NOKPROBE_SYMBOL(unwind);
135
136 static bool dump_backtrace_entry(void *arg, unsigned long where)
137 {
138         char *loglvl = arg;
139         printk("%s %pSb\n", loglvl, (void *)where);
140         return true;
141 }
142
143 void dump_backtrace(struct pt_regs *regs, struct task_struct *tsk,
144                     const char *loglvl)
145 {
146         pr_debug("%s(regs = %p tsk = %p)\n", __func__, regs, tsk);
147
148         if (regs && user_mode(regs))
149                 return;
150
151         if (!tsk)
152                 tsk = current;
153
154         if (!try_get_task_stack(tsk))
155                 return;
156
157         printk("%sCall trace:\n", loglvl);
158         arch_stack_walk(dump_backtrace_entry, (void *)loglvl, tsk, regs);
159
160         put_task_stack(tsk);
161 }
162
163 void show_stack(struct task_struct *tsk, unsigned long *sp, const char *loglvl)
164 {
165         dump_backtrace(NULL, tsk, loglvl);
166         barrier();
167 }
168
169 /*
170  * Per-cpu stacks are only accessible when unwinding the current task in a
171  * non-preemptible context.
172  */
173 #define STACKINFO_CPU(name)                                     \
174         ({                                                      \
175                 ((task == current) && !preemptible())           \
176                         ? stackinfo_get_##name()                \
177                         : stackinfo_get_unknown();              \
178         })
179
180 /*
181  * SDEI stacks are only accessible when unwinding the current task in an NMI
182  * context.
183  */
184 #define STACKINFO_SDEI(name)                                    \
185         ({                                                      \
186                 ((task == current) && in_nmi())                 \
187                         ? stackinfo_get_sdei_##name()           \
188                         : stackinfo_get_unknown();              \
189         })
190
191 #define STACKINFO_EFI                                           \
192         ({                                                      \
193                 ((task == current) && current_in_efi())         \
194                         ? stackinfo_get_efi()                   \
195                         : stackinfo_get_unknown();              \
196         })
197
198 noinline noinstr void arch_stack_walk(stack_trace_consume_fn consume_entry,
199                               void *cookie, struct task_struct *task,
200                               struct pt_regs *regs)
201 {
202         struct stack_info stacks[] = {
203                 stackinfo_get_task(task),
204                 STACKINFO_CPU(irq),
205 #if defined(CONFIG_VMAP_STACK)
206                 STACKINFO_CPU(overflow),
207 #endif
208 #if defined(CONFIG_VMAP_STACK) && defined(CONFIG_ARM_SDE_INTERFACE)
209                 STACKINFO_SDEI(normal),
210                 STACKINFO_SDEI(critical),
211 #endif
212 #ifdef CONFIG_EFI
213                 STACKINFO_EFI,
214 #endif
215         };
216         struct unwind_state state = {
217                 .stacks = stacks,
218                 .nr_stacks = ARRAY_SIZE(stacks),
219         };
220
221         if (regs) {
222                 if (task != current)
223                         return;
224                 unwind_init_from_regs(&state, regs);
225         } else if (task == current) {
226                 unwind_init_from_caller(&state);
227         } else {
228                 unwind_init_from_task(&state, task);
229         }
230
231         unwind(&state, consume_entry, cookie);
232 }