Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
2bc5f927 AH |
2 | /* |
3 | * Copyright (C) 1991, 1992 Linus Torvalds | |
4 | * Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs | |
5 | */ | |
b17b0153 | 6 | #include <linux/sched/debug.h> |
2bc5f927 AH |
7 | #include <linux/kallsyms.h> |
8 | #include <linux/kprobes.h> | |
9 | #include <linux/uaccess.h> | |
2bc5f927 AH |
10 | #include <linux/hardirq.h> |
11 | #include <linux/kdebug.h> | |
186f4360 | 12 | #include <linux/export.h> |
2bc5f927 AH |
13 | #include <linux/ptrace.h> |
14 | #include <linux/kexec.h> | |
b8030906 | 15 | #include <linux/sysfs.h> |
2bc5f927 AH |
16 | #include <linux/bug.h> |
17 | #include <linux/nmi.h> | |
18 | ||
19 | #include <asm/stacktrace.h> | |
20 | ||
3d02a9c4 | 21 | const char *stack_type_name(enum stack_type type) |
198d208d | 22 | { |
3d02a9c4 JP |
23 | if (type == STACK_TYPE_IRQ) |
24 | return "IRQ"; | |
25 | ||
26 | if (type == STACK_TYPE_SOFTIRQ) | |
27 | return "SOFTIRQ"; | |
28 | ||
4fe2d8b1 DH |
29 | if (type == STACK_TYPE_ENTRY) |
30 | return "ENTRY_TRAMPOLINE"; | |
33a2f1a6 | 31 | |
3d02a9c4 | 32 | return NULL; |
198d208d SR |
33 | } |
34 | ||
cb76c939 JP |
35 | static bool in_hardirq_stack(unsigned long *stack, struct stack_info *info) |
36 | { | |
37 | unsigned long *begin = (unsigned long *)this_cpu_read(hardirq_stack); | |
38 | unsigned long *end = begin + (THREAD_SIZE / sizeof(long)); | |
39 | ||
5fe599e0 JP |
40 | /* |
41 | * This is a software stack, so 'end' can be a valid stack pointer. | |
42 | * It just means the stack is empty. | |
43 | */ | |
5a3cf869 | 44 | if (stack <= begin || stack > end) |
cb76c939 JP |
45 | return false; |
46 | ||
47 | info->type = STACK_TYPE_IRQ; | |
48 | info->begin = begin; | |
49 | info->end = end; | |
50 | ||
51 | /* | |
52 | * See irq_32.c -- the next stack pointer is stored at the beginning of | |
53 | * the stack. | |
54 | */ | |
55 | info->next_sp = (unsigned long *)*begin; | |
198d208d | 56 | |
cb76c939 JP |
57 | return true; |
58 | } | |
59 | ||
60 | static bool in_softirq_stack(unsigned long *stack, struct stack_info *info) | |
198d208d | 61 | { |
cb76c939 JP |
62 | unsigned long *begin = (unsigned long *)this_cpu_read(softirq_stack); |
63 | unsigned long *end = begin + (THREAD_SIZE / sizeof(long)); | |
64 | ||
5fe599e0 JP |
65 | /* |
66 | * This is a software stack, so 'end' can be a valid stack pointer. | |
67 | * It just means the stack is empty. | |
68 | */ | |
5a3cf869 | 69 | if (stack <= begin || stack > end) |
cb76c939 JP |
70 | return false; |
71 | ||
72 | info->type = STACK_TYPE_SOFTIRQ; | |
73 | info->begin = begin; | |
74 | info->end = end; | |
75 | ||
76 | /* | |
77 | * The next stack pointer is stored at the beginning of the stack. | |
78 | * See irq_32.c. | |
79 | */ | |
80 | info->next_sp = (unsigned long *)*begin; | |
198d208d | 81 | |
cb76c939 | 82 | return true; |
198d208d SR |
83 | } |
84 | ||
cb76c939 JP |
85 | int get_stack_info(unsigned long *stack, struct task_struct *task, |
86 | struct stack_info *info, unsigned long *visit_mask) | |
198d208d | 87 | { |
cb76c939 JP |
88 | if (!stack) |
89 | goto unknown; | |
198d208d | 90 | |
cb76c939 JP |
91 | task = task ? : current; |
92 | ||
93 | if (in_task_stack(stack, task, info)) | |
fcd709ef | 94 | goto recursion_check; |
cb76c939 JP |
95 | |
96 | if (task != current) | |
97 | goto unknown; | |
98 | ||
4fe2d8b1 | 99 | if (in_entry_stack(stack, info)) |
33a2f1a6 AL |
100 | goto recursion_check; |
101 | ||
cb76c939 | 102 | if (in_hardirq_stack(stack, info)) |
fcd709ef | 103 | goto recursion_check; |
cb76c939 JP |
104 | |
105 | if (in_softirq_stack(stack, info)) | |
fcd709ef JP |
106 | goto recursion_check; |
107 | ||
108 | goto unknown; | |
109 | ||
110 | recursion_check: | |
111 | /* | |
112 | * Make sure we don't iterate through any given stack more than once. | |
113 | * If it comes up a second time then there's something wrong going on: | |
114 | * just break out and report an unknown stack type. | |
115 | */ | |
116 | if (visit_mask) { | |
0d2b8579 JP |
117 | if (*visit_mask & (1UL << info->type)) { |
118 | printk_deferred_once(KERN_WARNING "WARNING: stack recursion on stack type %d\n", info->type); | |
fcd709ef | 119 | goto unknown; |
0d2b8579 | 120 | } |
fcd709ef JP |
121 | *visit_mask |= 1UL << info->type; |
122 | } | |
123 | ||
124 | return 0; | |
cb76c939 JP |
125 | |
126 | unknown: | |
127 | info->type = STACK_TYPE_UNKNOWN; | |
128 | return -EINVAL; | |
198d208d | 129 | } |
0406ca6d | 130 | |
57da8b96 | 131 | void show_regs(struct pt_regs *regs) |
2bc5f927 AH |
132 | { |
133 | int i; | |
134 | ||
a43cb95d | 135 | show_regs_print_info(KERN_EMERG); |
f39b6f0e | 136 | __show_regs(regs, !user_mode(regs)); |
2bc5f927 | 137 | |
2bc5f927 AH |
138 | /* |
139 | * When in-kernel, we also print out the stack and code at the | |
140 | * time of the fault.. | |
141 | */ | |
f39b6f0e | 142 | if (!user_mode(regs)) { |
2bc5f927 AH |
143 | unsigned int code_prologue = code_bytes * 43 / 64; |
144 | unsigned int code_len = code_bytes; | |
145 | unsigned char c; | |
146 | u8 *ip; | |
147 | ||
0ee1dd9f | 148 | show_trace_log_lvl(current, regs, NULL, KERN_EMERG); |
2bc5f927 | 149 | |
c767a54b | 150 | pr_emerg("Code:"); |
2bc5f927 AH |
151 | |
152 | ip = (u8 *)regs->ip - code_prologue; | |
153 | if (ip < (u8 *)PAGE_OFFSET || probe_kernel_address(ip, c)) { | |
8a541665 | 154 | /* try starting at IP */ |
2bc5f927 AH |
155 | ip = (u8 *)regs->ip; |
156 | code_len = code_len - code_prologue + 1; | |
157 | } | |
158 | for (i = 0; i < code_len; i++, ip++) { | |
159 | if (ip < (u8 *)PAGE_OFFSET || | |
160 | probe_kernel_address(ip, c)) { | |
c767a54b | 161 | pr_cont(" Bad EIP value."); |
2bc5f927 AH |
162 | break; |
163 | } | |
164 | if (ip == (u8 *)regs->ip) | |
c767a54b | 165 | pr_cont(" <%02x>", c); |
2bc5f927 | 166 | else |
c767a54b | 167 | pr_cont(" %02x", c); |
2bc5f927 AH |
168 | } |
169 | } | |
c767a54b | 170 | pr_cont("\n"); |
2bc5f927 | 171 | } |