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