1 /* SPDX-License-Identifier: GPL-2.0 */
2 #include <linux/sched.h>
3 #include <linux/sched/task.h>
4 #include <linux/sched/task_stack.h>
5 #include <linux/interrupt.h>
6 #include <asm/sections.h>
7 #include <asm/ptrace.h>
8 #include <asm/bitops.h>
9 #include <asm/stacktrace.h>
10 #include <asm/unwind.h>
12 unsigned long unwind_get_return_address(struct unwind_state *state)
14 if (unwind_done(state))
16 return __kernel_text_address(state->ip) ? state->ip : 0;
18 EXPORT_SYMBOL_GPL(unwind_get_return_address);
20 static bool outside_of_stack(struct unwind_state *state, unsigned long sp)
22 return (sp <= state->sp) ||
23 (sp > state->stack_info.end - sizeof(struct stack_frame));
26 static bool update_stack_info(struct unwind_state *state, unsigned long sp)
28 struct stack_info *info = &state->stack_info;
29 unsigned long *mask = &state->stack_mask;
31 /* New stack pointer leaves the current stack */
32 if (get_stack_info(sp, state->task, info, mask) != 0 ||
33 !on_stack(info, sp, sizeof(struct stack_frame)))
34 /* 'sp' does not point to a valid stack */
39 static inline bool is_task_pt_regs(struct unwind_state *state,
42 return task_pt_regs(state->task) == regs;
45 bool unwind_next_frame(struct unwind_state *state)
47 struct stack_info *info = &state->stack_info;
48 struct stack_frame *sf;
56 sf = (struct stack_frame *) sp;
57 ip = READ_ONCE_NOCHECK(sf->gprs[8]);
60 if (!__kernel_text_address(ip)) {
63 return unwind_next_frame(state);
66 sf = (struct stack_frame *) state->sp;
67 sp = READ_ONCE_NOCHECK(sf->back_chain);
69 /* Non-zero back-chain points to the previous frame */
70 if (unlikely(outside_of_stack(state, sp))) {
71 if (!update_stack_info(state, sp))
74 sf = (struct stack_frame *) sp;
75 ip = READ_ONCE_NOCHECK(sf->gprs[8]);
78 /* No back-chain, look for a pt_regs structure */
79 sp = state->sp + STACK_FRAME_OVERHEAD;
80 if (!on_stack(info, sp, sizeof(struct pt_regs)))
82 regs = (struct pt_regs *) sp;
83 if (is_task_pt_regs(state, regs))
85 ip = READ_ONCE_NOCHECK(regs->psw.addr);
86 sp = READ_ONCE_NOCHECK(regs->gprs[15]);
87 if (unlikely(outside_of_stack(state, sp))) {
88 if (!update_stack_info(state, sp))
95 /* Sanity check: ABI requires SP to be aligned 8 bytes. */
99 ip = ftrace_graph_ret_addr(state->task, &state->graph_idx, ip, (void *) sp);
101 /* Update unwind state */
105 state->reliable = reliable;
111 state->stack_info.type = STACK_TYPE_UNKNOWN;
114 EXPORT_SYMBOL_GPL(unwind_next_frame);
116 void __unwind_start(struct unwind_state *state, struct task_struct *task,
117 struct pt_regs *regs, unsigned long first_frame)
119 struct stack_info *info = &state->stack_info;
120 struct stack_frame *sf;
121 unsigned long ip, sp;
123 memset(state, 0, sizeof(*state));
127 /* Don't even attempt to start from user mode regs: */
128 if (regs && user_mode(regs)) {
129 info->type = STACK_TYPE_UNKNOWN;
133 /* Get the instruction pointer from pt_regs or the stack frame */
137 } else if (task == current) {
138 sp = current_frame_address();
140 sp = task->thread.ksp;
143 /* Get current stack pointer and initialize stack info */
144 if (!update_stack_info(state, sp)) {
145 /* Something is wrong with the stack pointer */
146 info->type = STACK_TYPE_UNKNOWN;
152 /* Stack frame is within valid stack */
153 sf = (struct stack_frame *)sp;
154 ip = READ_ONCE_NOCHECK(sf->gprs[8]);
157 ip = ftrace_graph_ret_addr(state->task, &state->graph_idx, ip, NULL);
159 /* Update unwind state */
162 state->reliable = true;
166 /* Skip through the call chain to the specified starting frame */
167 while (!unwind_done(state)) {
168 if (on_stack(&state->stack_info, first_frame, sizeof(struct stack_frame))) {
169 if (state->sp >= first_frame)
172 unwind_next_frame(state);
175 EXPORT_SYMBOL_GPL(__unwind_start);