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