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);
165