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/stacktrace.h> 20 21 static char *exception_stack_names[N_EXCEPTION_STACKS] = { 22 [ DOUBLEFAULT_STACK-1 ] = "#DF", 23 [ NMI_STACK-1 ] = "NMI", 24 [ DEBUG_STACK-1 ] = "#DB", 25 [ MCE_STACK-1 ] = "#MC", 26 }; 27 28 static unsigned long exception_stack_sizes[N_EXCEPTION_STACKS] = { 29 [0 ... N_EXCEPTION_STACKS - 1] = EXCEPTION_STKSZ, 30 [DEBUG_STACK - 1] = DEBUG_STKSZ 31 }; 32 33 const char *stack_type_name(enum stack_type type) 34 { 35 BUILD_BUG_ON(N_EXCEPTION_STACKS != 4); 36 37 if (type == STACK_TYPE_IRQ) 38 return "IRQ"; 39 40 if (type == STACK_TYPE_SYSENTER) 41 return "SYSENTER"; 42 43 if (type >= STACK_TYPE_EXCEPTION && type <= STACK_TYPE_EXCEPTION_LAST) 44 return exception_stack_names[type - STACK_TYPE_EXCEPTION]; 45 46 return NULL; 47 } 48 49 static bool in_exception_stack(unsigned long *stack, struct stack_info *info) 50 { 51 unsigned long *begin, *end; 52 struct pt_regs *regs; 53 unsigned k; 54 55 BUILD_BUG_ON(N_EXCEPTION_STACKS != 4); 56 57 for (k = 0; k < N_EXCEPTION_STACKS; k++) { 58 end = (unsigned long *)raw_cpu_ptr(&orig_ist)->ist[k]; 59 begin = end - (exception_stack_sizes[k] / sizeof(long)); 60 regs = (struct pt_regs *)end - 1; 61 62 if (stack <= begin || stack >= end) 63 continue; 64 65 info->type = STACK_TYPE_EXCEPTION + k; 66 info->begin = begin; 67 info->end = end; 68 info->next_sp = (unsigned long *)regs->sp; 69 70 return true; 71 } 72 73 return false; 74 } 75 76 static bool in_irq_stack(unsigned long *stack, struct stack_info *info) 77 { 78 unsigned long *end = (unsigned long *)this_cpu_read(irq_stack_ptr); 79 unsigned long *begin = end - (IRQ_STACK_SIZE / sizeof(long)); 80 81 /* 82 * This is a software stack, so 'end' can be a valid stack pointer. 83 * It just means the stack is empty. 84 */ 85 if (stack <= begin || stack > end) 86 return false; 87 88 info->type = STACK_TYPE_IRQ; 89 info->begin = begin; 90 info->end = end; 91 92 /* 93 * The next stack pointer is the first thing pushed by the entry code 94 * after switching to the irq stack. 95 */ 96 info->next_sp = (unsigned long *)*(end - 1); 97 98 return true; 99 } 100 101 int get_stack_info(unsigned long *stack, struct task_struct *task, 102 struct stack_info *info, unsigned long *visit_mask) 103 { 104 if (!stack) 105 goto unknown; 106 107 task = task ? : current; 108 109 if (in_task_stack(stack, task, info)) 110 goto recursion_check; 111 112 if (task != current) 113 goto unknown; 114 115 if (in_exception_stack(stack, info)) 116 goto recursion_check; 117 118 if (in_irq_stack(stack, info)) 119 goto recursion_check; 120 121 if (in_sysenter_stack(stack, info)) 122 goto recursion_check; 123 124 goto unknown; 125 126 recursion_check: 127 /* 128 * Make sure we don't iterate through any given stack more than once. 129 * If it comes up a second time then there's something wrong going on: 130 * just break out and report an unknown stack type. 131 */ 132 if (visit_mask) { 133 if (*visit_mask & (1UL << info->type)) { 134 printk_deferred_once(KERN_WARNING "WARNING: stack recursion on stack type %d\n", info->type); 135 goto unknown; 136 } 137 *visit_mask |= 1UL << info->type; 138 } 139 140 return 0; 141 142 unknown: 143 info->type = STACK_TYPE_UNKNOWN; 144 return -EINVAL; 145 } 146 147 void show_regs(struct pt_regs *regs) 148 { 149 int i; 150 151 show_regs_print_info(KERN_DEFAULT); 152 __show_regs(regs, 1); 153 154 /* 155 * When in-kernel, we also print out the stack and code at the 156 * time of the fault.. 157 */ 158 if (!user_mode(regs)) { 159 unsigned int code_prologue = code_bytes * 43 / 64; 160 unsigned int code_len = code_bytes; 161 unsigned char c; 162 u8 *ip; 163 164 show_trace_log_lvl(current, regs, NULL, KERN_DEFAULT); 165 166 printk(KERN_DEFAULT "Code: "); 167 168 ip = (u8 *)regs->ip - code_prologue; 169 if (ip < (u8 *)PAGE_OFFSET || probe_kernel_address(ip, c)) { 170 /* try starting at IP */ 171 ip = (u8 *)regs->ip; 172 code_len = code_len - code_prologue + 1; 173 } 174 for (i = 0; i < code_len; i++, ip++) { 175 if (ip < (u8 *)PAGE_OFFSET || 176 probe_kernel_address(ip, c)) { 177 pr_cont(" Bad RIP value."); 178 break; 179 } 180 if (ip == (u8 *)regs->ip) 181 pr_cont("<%02x> ", c); 182 else 183 pr_cont("%02x ", c); 184 } 185 } 186 pr_cont("\n"); 187 } 188