]>
Commit | Line | Data |
---|---|---|
5933f6d2 | 1 | // SPDX-License-Identifier: GPL-2.0 |
bf61ad1f MF |
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> | |
4ab8f241 | 15 | #include <linux/module.h> |
bf61ad1f | 16 | #include <asm/unwinder.h> |
60063497 | 17 | #include <linux/atomic.h> |
bf61ad1f MF |
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 | ||
bf61ad1f MF |
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(&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(&ops->list, 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(u); | |
118 | if (!ret) | |
119 | curr_unwinder = select_unwinder(); | |
120 | spin_unlock_irqrestore(&unwinder_lock, flags); | |
121 | ||
122 | return ret; | |
123 | } | |
124 | ||
b344e24a MF |
125 | int unwinder_faulted = 0; |
126 | ||
bf61ad1f MF |
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 | */ | |
b344e24a | 149 | if (unwinder_faulted) { |
bf61ad1f MF |
150 | spin_lock_irqsave(&unwinder_lock, flags); |
151 | ||
b344e24a MF |
152 | /* Make sure no one beat us to changing the unwinder */ |
153 | if (unwinder_faulted && !list_is_singular(&unwinder_list)) { | |
bf61ad1f MF |
154 | list_del(&curr_unwinder->list); |
155 | curr_unwinder = select_unwinder(); | |
b344e24a MF |
156 | |
157 | unwinder_faulted = 0; | |
bf61ad1f MF |
158 | } |
159 | ||
160 | spin_unlock_irqrestore(&unwinder_lock, flags); | |
bf61ad1f MF |
161 | } |
162 | ||
163 | curr_unwinder->dump(task, regs, sp, ops, data); | |
b344e24a | 164 | } |
4ab8f241 | 165 | EXPORT_SYMBOL_GPL(unwind_stack); |