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 /* 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 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