Merge remote-tracking branch 'regulator/for-5.15' into regulator-next
[linux-2.6-microblaze.git] / arch / s390 / kernel / unwind_bc.c
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
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
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
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
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
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                 if (!__kernel_text_address(ip)) {
68                         /* skip bogus %r14 */
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         ip = ftrace_graph_ret_addr(state->task, &state->graph_idx, ip, (void *) sp);
107
108         /* Update unwind state */
109         state->sp = sp;
110         state->ip = ip;
111         state->regs = regs;
112         state->reliable = reliable;
113         return true;
114
115 out_err:
116         state->error = true;
117 out_stop:
118         state->stack_info.type = STACK_TYPE_UNKNOWN;
119         return false;
120 }
121 EXPORT_SYMBOL_GPL(unwind_next_frame);
122
123 void __unwind_start(struct unwind_state *state, struct task_struct *task,
124                     struct pt_regs *regs, unsigned long first_frame)
125 {
126         struct stack_info *info = &state->stack_info;
127         struct stack_frame *sf;
128         unsigned long ip, sp;
129
130         memset(state, 0, sizeof(*state));
131         state->task = task;
132         state->regs = regs;
133
134         /* Don't even attempt to start from user mode regs: */
135         if (regs && user_mode(regs)) {
136                 info->type = STACK_TYPE_UNKNOWN;
137                 return;
138         }
139
140         /* Get the instruction pointer from pt_regs or the stack frame */
141         if (regs) {
142                 ip = regs->psw.addr;
143                 sp = regs->gprs[15];
144         } else if (task == current) {
145                 sp = current_frame_address();
146         } else {
147                 sp = task->thread.ksp;
148         }
149
150         /* Get current stack pointer and initialize stack info */
151         if (!update_stack_info(state, sp)) {
152                 /* Something is wrong with the stack pointer */
153                 info->type = STACK_TYPE_UNKNOWN;
154                 state->error = true;
155                 return;
156         }
157
158         if (!regs) {
159                 /* Stack frame is within valid stack */
160                 sf = (struct stack_frame *)sp;
161                 ip = READ_ONCE_NOCHECK(sf->gprs[8]);
162         }
163
164         ip = ftrace_graph_ret_addr(state->task, &state->graph_idx, ip, NULL);
165
166         /* Update unwind state */
167         state->sp = sp;
168         state->ip = ip;
169         state->reliable = true;
170
171         if (!first_frame)
172                 return;
173         /* Skip through the call chain to the specified starting frame */
174         while (!unwind_done(state)) {
175                 if (on_stack(&state->stack_info, first_frame, sizeof(struct stack_frame))) {
176                         if (state->sp >= first_frame)
177                                 break;
178                 }
179                 unwind_next_frame(state);
180         }
181 }
182 EXPORT_SYMBOL_GPL(__unwind_start);