1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 1991, 1992 Linus Torvalds 4 * Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs 5 */ 6 #include <linux/sched/debug.h> 7 #include <linux/kallsyms.h> 8 #include <linux/kprobes.h> 9 #include <linux/uaccess.h> 10 #include <linux/hardirq.h> 11 #include <linux/kdebug.h> 12 #include <linux/export.h> 13 #include <linux/ptrace.h> 14 #include <linux/kexec.h> 15 #include <linux/sysfs.h> 16 #include <linux/bug.h> 17 #include <linux/nmi.h> 18 19 #include <asm/cpu_entry_area.h> 20 #include <asm/stacktrace.h> 21 22 static const char * const exception_stack_names[] = { 23 [ ESTACK_DF ] = "#DF", 24 [ ESTACK_NMI ] = "NMI", 25 [ ESTACK_DB ] = "#DB", 26 [ ESTACK_MCE ] = "#MC", 27 [ ESTACK_VC ] = "#VC", 28 [ ESTACK_VC2 ] = "#VC2", 29 }; 30 31 const char *stack_type_name(enum stack_type type) 32 { 33 BUILD_BUG_ON(N_EXCEPTION_STACKS != 6); 34 35 if (type == STACK_TYPE_IRQ) 36 return "IRQ"; 37 38 if (type == STACK_TYPE_ENTRY) { 39 /* 40 * On 64-bit, we have a generic entry stack that we 41 * use for all the kernel entry points, including 42 * SYSENTER. 43 */ 44 return "ENTRY_TRAMPOLINE"; 45 } 46 47 if (type >= STACK_TYPE_EXCEPTION && type <= STACK_TYPE_EXCEPTION_LAST) 48 return exception_stack_names[type - STACK_TYPE_EXCEPTION]; 49 50 return NULL; 51 } 52 53 /** 54 * struct estack_pages - Page descriptor for exception stacks 55 * @offs: Offset from the start of the exception stack area 56 * @size: Size of the exception stack 57 * @type: Type to store in the stack_info struct 58 */ 59 struct estack_pages { 60 u32 offs; 61 u16 size; 62 u16 type; 63 }; 64 65 #define EPAGERANGE(st) \ 66 [PFN_DOWN(CEA_ESTACK_OFFS(st)) ... \ 67 PFN_DOWN(CEA_ESTACK_OFFS(st) + CEA_ESTACK_SIZE(st) - 1)] = { \ 68 .offs = CEA_ESTACK_OFFS(st), \ 69 .size = CEA_ESTACK_SIZE(st), \ 70 .type = STACK_TYPE_EXCEPTION + ESTACK_ ##st, } 71 72 /* 73 * Array of exception stack page descriptors. If the stack is larger than 74 * PAGE_SIZE, all pages covering a particular stack will have the same 75 * info. The guard pages including the not mapped DB2 stack are zeroed 76 * out. 77 */ 78 static const 79 struct estack_pages estack_pages[CEA_ESTACK_PAGES] ____cacheline_aligned = { 80 EPAGERANGE(DF), 81 EPAGERANGE(NMI), 82 EPAGERANGE(DB), 83 EPAGERANGE(MCE), 84 EPAGERANGE(VC), 85 EPAGERANGE(VC2), 86 }; 87 88 static __always_inline bool in_exception_stack(unsigned long *stack, struct stack_info *info) 89 { 90 unsigned long begin, end, stk = (unsigned long)stack; 91 const struct estack_pages *ep; 92 struct pt_regs *regs; 93 unsigned int k; 94 95 BUILD_BUG_ON(N_EXCEPTION_STACKS != 6); 96 97 begin = (unsigned long)__this_cpu_read(cea_exception_stacks); 98 /* 99 * Handle the case where stack trace is collected _before_ 100 * cea_exception_stacks had been initialized. 101 */ 102 if (!begin) 103 return false; 104 105 end = begin + sizeof(struct cea_exception_stacks); 106 /* Bail if @stack is outside the exception stack area. */ 107 if (stk < begin || stk >= end) 108 return false; 109 110 /* Calc page offset from start of exception stacks */ 111 k = (stk - begin) >> PAGE_SHIFT; 112 /* Lookup the page descriptor */ 113 ep = &estack_pages[k]; 114 /* Guard page? */ 115 if (!ep->size) 116 return false; 117 118 begin += (unsigned long)ep->offs; 119 end = begin + (unsigned long)ep->size; 120 regs = (struct pt_regs *)end - 1; 121 122 info->type = ep->type; 123 info->begin = (unsigned long *)begin; 124 info->end = (unsigned long *)end; 125 info->next_sp = (unsigned long *)regs->sp; 126 return true; 127 } 128 129 static __always_inline bool in_irq_stack(unsigned long *stack, struct stack_info *info) 130 { 131 unsigned long *end = (unsigned long *)this_cpu_read(hardirq_stack_ptr); 132 unsigned long *begin = end - (IRQ_STACK_SIZE / sizeof(long)); 133 134 /* 135 * This is a software stack, so 'end' can be a valid stack pointer. 136 * It just means the stack is empty. 137 */ 138 if (stack < begin || stack >= end) 139 return false; 140 141 info->type = STACK_TYPE_IRQ; 142 info->begin = begin; 143 info->end = end; 144 145 /* 146 * The next stack pointer is the first thing pushed by the entry code 147 * after switching to the irq stack. 148 */ 149 info->next_sp = (unsigned long *)*(end - 1); 150 151 return true; 152 } 153 154 bool noinstr get_stack_info_noinstr(unsigned long *stack, struct task_struct *task, 155 struct stack_info *info) 156 { 157 if (in_task_stack(stack, task, info)) 158 return true; 159 160 if (task != current) 161 return false; 162 163 if (in_exception_stack(stack, info)) 164 return true; 165 166 if (in_irq_stack(stack, info)) 167 return true; 168 169 if (in_entry_stack(stack, info)) 170 return true; 171 172 return false; 173 } 174 175 int get_stack_info(unsigned long *stack, struct task_struct *task, 176 struct stack_info *info, unsigned long *visit_mask) 177 { 178 task = task ? : current; 179 180 if (!stack) 181 goto unknown; 182 183 if (!get_stack_info_noinstr(stack, task, info)) 184 goto unknown; 185 186 /* 187 * Make sure we don't iterate through any given stack more than once. 188 * If it comes up a second time then there's something wrong going on: 189 * just break out and report an unknown stack type. 190 */ 191 if (visit_mask) { 192 if (*visit_mask & (1UL << info->type)) { 193 if (task == current) 194 printk_deferred_once(KERN_WARNING "WARNING: stack recursion on stack type %d\n", info->type); 195 goto unknown; 196 } 197 *visit_mask |= 1UL << info->type; 198 } 199 200 return 0; 201 202 unknown: 203 info->type = STACK_TYPE_UNKNOWN; 204 return -EINVAL; 205 } 206