1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (C) 2009 Matt Fleming |
4 | * |
5 | * Based, in part, on kernel/time/clocksource.c. |
6 | * |
7 | * This file provides arbitration code for stack unwinders. |
8 | * |
9 | * Multiple stack unwinders can be available on a system, usually with |
10 | * the most accurate unwinder being the currently active one. |
11 | */ |
12 | #include <linux/errno.h> |
13 | #include <linux/list.h> |
14 | #include <linux/spinlock.h> |
15 | #include <linux/module.h> |
16 | #include <asm/unwinder.h> |
17 | #include <linux/atomic.h> |
18 | |
19 | /* |
20 | * This is the most basic stack unwinder an architecture can |
21 | * provide. For architectures without reliable frame pointers, e.g. |
22 | * RISC CPUs, it can be implemented by looking through the stack for |
23 | * addresses that lie within the kernel text section. |
24 | * |
25 | * Other CPUs, e.g. x86, can use their frame pointer register to |
26 | * construct more accurate stack traces. |
27 | */ |
28 | static struct list_head unwinder_list; |
29 | static struct unwinder stack_reader = { |
30 | .name = "stack-reader" , |
31 | .dump = stack_reader_dump, |
32 | .rating = 50, |
33 | .list = { |
34 | .next = &unwinder_list, |
35 | .prev = &unwinder_list, |
36 | }, |
37 | }; |
38 | |
39 | /* |
40 | * "curr_unwinder" points to the stack unwinder currently in use. This |
41 | * is the unwinder with the highest rating. |
42 | * |
43 | * "unwinder_list" is a linked-list of all available unwinders, sorted |
44 | * by rating. |
45 | * |
46 | * All modifications of "curr_unwinder" and "unwinder_list" must be |
47 | * performed whilst holding "unwinder_lock". |
48 | */ |
49 | static struct unwinder *curr_unwinder = &stack_reader; |
50 | |
51 | static struct list_head unwinder_list = { |
52 | .next = &stack_reader.list, |
53 | .prev = &stack_reader.list, |
54 | }; |
55 | |
56 | static DEFINE_SPINLOCK(unwinder_lock); |
57 | |
58 | /** |
59 | * select_unwinder - Select the best registered stack unwinder. |
60 | * |
61 | * Private function. Must hold unwinder_lock when called. |
62 | * |
63 | * Select the stack unwinder with the best rating. This is useful for |
64 | * setting up curr_unwinder. |
65 | */ |
66 | static struct unwinder *select_unwinder(void) |
67 | { |
68 | struct unwinder *best; |
69 | |
70 | if (list_empty(head: &unwinder_list)) |
71 | return NULL; |
72 | |
73 | best = list_entry(unwinder_list.next, struct unwinder, list); |
74 | if (best == curr_unwinder) |
75 | return NULL; |
76 | |
77 | return best; |
78 | } |
79 | |
80 | /* |
81 | * Enqueue the stack unwinder sorted by rating. |
82 | */ |
83 | static int unwinder_enqueue(struct unwinder *ops) |
84 | { |
85 | struct list_head *tmp, *entry = &unwinder_list; |
86 | |
87 | list_for_each(tmp, &unwinder_list) { |
88 | struct unwinder *o; |
89 | |
90 | o = list_entry(tmp, struct unwinder, list); |
91 | if (o == ops) |
92 | return -EBUSY; |
93 | /* Keep track of the place, where to insert */ |
94 | if (o->rating >= ops->rating) |
95 | entry = tmp; |
96 | } |
97 | list_add(new: &ops->list, head: entry); |
98 | |
99 | return 0; |
100 | } |
101 | |
102 | /** |
103 | * unwinder_register - Used to install new stack unwinder |
104 | * @u: unwinder to be registered |
105 | * |
106 | * Install the new stack unwinder on the unwinder list, which is sorted |
107 | * by rating. |
108 | * |
109 | * Returns -EBUSY if registration fails, zero otherwise. |
110 | */ |
111 | int unwinder_register(struct unwinder *u) |
112 | { |
113 | unsigned long flags; |
114 | int ret; |
115 | |
116 | spin_lock_irqsave(&unwinder_lock, flags); |
117 | ret = unwinder_enqueue(ops: u); |
118 | if (!ret) |
119 | curr_unwinder = select_unwinder(); |
120 | spin_unlock_irqrestore(lock: &unwinder_lock, flags); |
121 | |
122 | return ret; |
123 | } |
124 | |
125 | int unwinder_faulted = 0; |
126 | |
127 | /* |
128 | * Unwind the call stack and pass information to the stacktrace_ops |
129 | * functions. Also handle the case where we need to switch to a new |
130 | * stack dumper because the current one faulted unexpectedly. |
131 | */ |
132 | void unwind_stack(struct task_struct *task, struct pt_regs *regs, |
133 | unsigned long *sp, const struct stacktrace_ops *ops, |
134 | void *data) |
135 | { |
136 | unsigned long flags; |
137 | |
138 | /* |
139 | * The problem with unwinders with high ratings is that they are |
140 | * inherently more complicated than the simple ones with lower |
141 | * ratings. We are therefore more likely to fault in the |
142 | * complicated ones, e.g. hitting BUG()s. If we fault in the |
143 | * code for the current stack unwinder we try to downgrade to |
144 | * one with a lower rating. |
145 | * |
146 | * Hopefully this will give us a semi-reliable stacktrace so we |
147 | * can diagnose why curr_unwinder->dump() faulted. |
148 | */ |
149 | if (unwinder_faulted) { |
150 | spin_lock_irqsave(&unwinder_lock, flags); |
151 | |
152 | /* Make sure no one beat us to changing the unwinder */ |
153 | if (unwinder_faulted && !list_is_singular(head: &unwinder_list)) { |
154 | list_del(entry: &curr_unwinder->list); |
155 | curr_unwinder = select_unwinder(); |
156 | |
157 | unwinder_faulted = 0; |
158 | } |
159 | |
160 | spin_unlock_irqrestore(lock: &unwinder_lock, flags); |
161 | } |
162 | |
163 | curr_unwinder->dump(task, regs, sp, ops, data); |
164 | } |
165 | EXPORT_SYMBOL_GPL(unwind_stack); |
166 | |