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_DB2 ] = "#DB2", 26 [ ESTACK_DB1 ] = "#DB1", 27 [ ESTACK_DB ] = "#DB", 28 [ ESTACK_MCE ] = "#MC", 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(DB1), 83 EPAGERANGE(DB), 84 EPAGERANGE(MCE), 85 }; 86 87 static bool in_exception_stack(unsigned long *stack, struct stack_info *info) 88 { 89 unsigned long begin, end, stk = (unsigned long)stack; 90 const struct estack_pages *ep; 91 struct pt_regs *regs; 92 unsigned int k; 93 94 BUILD_BUG_ON(N_EXCEPTION_STACKS != 6); 95 96 begin = (unsigned long)__this_cpu_read(cea_exception_stacks); 97 end = begin + sizeof(struct cea_exception_stacks); 98 /* Bail if @stack is outside the exception stack area. */ 99 if (stk < begin || stk >= end) 100 return false; 101 102 /* Calc page offset from start of exception stacks */ 103 k = (stk - begin) >> PAGE_SHIFT; 104 /* Lookup the page descriptor */ 105 ep = &estack_pages[k]; 106 /* Guard page? */ 107 if (!ep->size) 108 return false; 109 110 begin += (unsigned long)ep->offs; 111 end = begin + (unsigned long)ep->size; 112 regs = (struct pt_regs *)end - 1; 113 114 info->type = ep->type; 115 info->begin = (unsigned long *)begin; 116 info->end = (unsigned long *)end; 117 info->next_sp = (unsigned long *)regs->sp; 118 return true; 119 } 120 121 static bool in_irq_stack(unsigned long *stack, struct stack_info *info) 122 { 123 unsigned long *end = (unsigned long *)this_cpu_read(hardirq_stack_ptr); 124 unsigned long *begin = end - (IRQ_STACK_SIZE / sizeof(long)); 125 126 /* 127 * This is a software stack, so 'end' can be a valid stack pointer. 128 * It just means the stack is empty. 129 */ 130 if (stack < begin || stack >= end) 131 return false; 132 133 info->type = STACK_TYPE_IRQ; 134 info->begin = begin; 135 info->end = end; 136 137 /* 138 * The next stack pointer is the first thing pushed by the entry code 139 * after switching to the irq stack. 140 */ 141 info->next_sp = (unsigned long *)*(end - 1); 142 143 return true; 144 } 145 146 int get_stack_info(unsigned long *stack, struct task_struct *task, 147 struct stack_info *info, unsigned long *visit_mask) 148 { 149 if (!stack) 150 goto unknown; 151 152 task = task ? : current; 153 154 if (in_task_stack(stack, task, info)) 155 goto recursion_check; 156 157 if (task != current) 158 goto unknown; 159 160 if (in_exception_stack(stack, info)) 161 goto recursion_check; 162 163 if (in_irq_stack(stack, info)) 164 goto recursion_check; 165 166 if (in_entry_stack(stack, info)) 167 goto recursion_check; 168 169 goto unknown; 170 171 recursion_check: 172 /* 173 * Make sure we don't iterate through any given stack more than once. 174 * If it comes up a second time then there's something wrong going on: 175 * just break out and report an unknown stack type. 176 */ 177 if (visit_mask) { 178 if (*visit_mask & (1UL << info->type)) { 179 printk_deferred_once(KERN_WARNING "WARNING: stack recursion on stack type %d\n", info->type); 180 goto unknown; 181 } 182 *visit_mask |= 1UL << info->type; 183 } 184 185 return 0; 186 187 unknown: 188 info->type = STACK_TYPE_UNKNOWN; 189 return -EINVAL; 190 } 191