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>
11 
unwind_get_return_address(struct unwind_state * state)12 unsigned long unwind_get_return_address(struct unwind_state *state)
13 {
14 	if (unwind_done(state))
15 		return 0;
16 	return __kernel_text_address(state->ip) ? state->ip : 0;
17 }
18 EXPORT_SYMBOL_GPL(unwind_get_return_address);
19 
outside_of_stack(struct unwind_state * state,unsigned long sp)20 static bool outside_of_stack(struct unwind_state *state, unsigned long sp)
21 {
22 	return (sp <= state->sp) ||
23 		(sp > state->stack_info.end - sizeof(struct stack_frame));
24 }
25 
update_stack_info(struct unwind_state * state,unsigned long sp)26 static bool update_stack_info(struct unwind_state *state, unsigned long sp)
27 {
28 	struct stack_info *info = &state->stack_info;
29 	unsigned long *mask = &state->stack_mask;
30 
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 */
35 		return false;
36 	return true;
37 }
38 
is_final_pt_regs(struct unwind_state * state,struct pt_regs * regs)39 static inline bool is_final_pt_regs(struct unwind_state *state,
40 				    struct pt_regs *regs)
41 {
42 	/* user mode or kernel thread pt_regs at the bottom of task stack */
43 	if (task_pt_regs(state->task) == regs)
44 		return true;
45 
46 	/* user mode pt_regs at the bottom of irq stack */
47 	return state->stack_info.type == STACK_TYPE_IRQ &&
48 	       state->stack_info.end - sizeof(struct pt_regs) == (unsigned long)regs &&
49 	       READ_ONCE_NOCHECK(regs->psw.mask) & PSW_MASK_PSTATE;
50 }
51 
unwind_next_frame(struct unwind_state * state)52 bool unwind_next_frame(struct unwind_state *state)
53 {
54 	struct stack_info *info = &state->stack_info;
55 	struct stack_frame *sf;
56 	struct pt_regs *regs;
57 	unsigned long sp, ip;
58 	bool reliable;
59 
60 	regs = state->regs;
61 	if (unlikely(regs)) {
62 		sp = state->sp;
63 		sf = (struct stack_frame *) sp;
64 		ip = READ_ONCE_NOCHECK(sf->gprs[8]);
65 		reliable = false;
66 		regs = NULL;
67 		/* skip bogus %r14 or if is the same as regs->psw.addr */
68 		if (!__kernel_text_address(ip) || state->ip == unwind_recover_ret_addr(state, ip)) {
69 			state->regs = NULL;
70 			return unwind_next_frame(state);
71 		}
72 	} else {
73 		sf = (struct stack_frame *) state->sp;
74 		sp = READ_ONCE_NOCHECK(sf->back_chain);
75 		if (likely(sp)) {
76 			/* Non-zero back-chain points to the previous frame */
77 			if (unlikely(outside_of_stack(state, sp))) {
78 				if (!update_stack_info(state, sp))
79 					goto out_err;
80 			}
81 			sf = (struct stack_frame *) sp;
82 			ip = READ_ONCE_NOCHECK(sf->gprs[8]);
83 			reliable = true;
84 		} else {
85 			/* No back-chain, look for a pt_regs structure */
86 			sp = state->sp + STACK_FRAME_OVERHEAD;
87 			if (!on_stack(info, sp, sizeof(struct pt_regs)))
88 				goto out_err;
89 			regs = (struct pt_regs *) sp;
90 			if (is_final_pt_regs(state, regs))
91 				goto out_stop;
92 			ip = READ_ONCE_NOCHECK(regs->psw.addr);
93 			sp = READ_ONCE_NOCHECK(regs->gprs[15]);
94 			if (unlikely(outside_of_stack(state, sp))) {
95 				if (!update_stack_info(state, sp))
96 					goto out_err;
97 			}
98 			reliable = true;
99 		}
100 	}
101 
102 	/* Sanity check: ABI requires SP to be aligned 8 bytes. */
103 	if (sp & 0x7)
104 		goto out_err;
105 
106 	/* Update unwind state */
107 	state->sp = sp;
108 	state->regs = regs;
109 	state->reliable = reliable;
110 	state->ip = unwind_recover_ret_addr(state, ip);
111 	return true;
112 
113 out_err:
114 	state->error = true;
115 out_stop:
116 	state->stack_info.type = STACK_TYPE_UNKNOWN;
117 	return false;
118 }
119 EXPORT_SYMBOL_GPL(unwind_next_frame);
120 
__unwind_start(struct unwind_state * state,struct task_struct * task,struct pt_regs * regs,unsigned long first_frame)121 void __unwind_start(struct unwind_state *state, struct task_struct *task,
122 		    struct pt_regs *regs, unsigned long first_frame)
123 {
124 	struct stack_info *info = &state->stack_info;
125 	struct stack_frame *sf;
126 	unsigned long ip, sp;
127 
128 	memset(state, 0, sizeof(*state));
129 	state->task = task;
130 	state->regs = regs;
131 
132 	/* Don't even attempt to start from user mode regs: */
133 	if (regs && user_mode(regs)) {
134 		info->type = STACK_TYPE_UNKNOWN;
135 		return;
136 	}
137 
138 	/* Get the instruction pointer from pt_regs or the stack frame */
139 	if (regs) {
140 		ip = regs->psw.addr;
141 		sp = regs->gprs[15];
142 	} else if (task == current) {
143 		sp = current_frame_address();
144 	} else {
145 		sp = task->thread.ksp;
146 	}
147 
148 	/* Get current stack pointer and initialize stack info */
149 	if (!update_stack_info(state, sp)) {
150 		/* Something is wrong with the stack pointer */
151 		info->type = STACK_TYPE_UNKNOWN;
152 		state->error = true;
153 		return;
154 	}
155 
156 	if (!regs) {
157 		/* Stack frame is within valid stack */
158 		sf = (struct stack_frame *)sp;
159 		ip = READ_ONCE_NOCHECK(sf->gprs[8]);
160 	}
161 
162 	/* Update unwind state */
163 	state->sp = sp;
164 	state->reliable = true;
165 	state->ip = unwind_recover_ret_addr(state, ip);
166 
167 	if (!first_frame)
168 		return;
169 	/* Skip through the call chain to the specified starting frame */
170 	while (!unwind_done(state)) {
171 		if (on_stack(&state->stack_info, first_frame, sizeof(struct stack_frame))) {
172 			if (state->sp >= first_frame)
173 				break;
174 		}
175 		unwind_next_frame(state);
176 	}
177 }
178 EXPORT_SYMBOL_GPL(__unwind_start);
179