atomic: use <linux/atomic.h>
[linux-2.6.git] / arch / sh / kernel / unwinder.c
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  */
27 static struct list_head unwinder_list;
28 static 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  */
48 static struct unwinder *curr_unwinder = &stack_reader;
49
50 static struct list_head unwinder_list = {
51         .next = &stack_reader.list,
52         .prev = &stack_reader.list,
53 };
54
55 static 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  */
65 static 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  */
82 static 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  */
110 int 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
124 int 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  */
131 void 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 }
164 EXPORT_SYMBOL_GPL(unwind_stack);