Merge branch 'devel' of master.kernel.org:/home/rmk/linux-2.6-serial
[linux-2.6] / arch / x86_64 / kernel / stacktrace.c
1 /*
2  * arch/x86_64/kernel/stacktrace.c
3  *
4  * Stack trace management functions
5  *
6  *  Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
7  */
8 #include <linux/sched.h>
9 #include <linux/stacktrace.h>
10
11 #include <asm/smp.h>
12
13 static inline int
14 in_range(unsigned long start, unsigned long addr, unsigned long end)
15 {
16         return addr >= start && addr <= end;
17 }
18
19 static unsigned long
20 get_stack_end(struct task_struct *task, unsigned long stack)
21 {
22         unsigned long stack_start, stack_end, flags;
23         int i, cpu;
24
25         /*
26          * The most common case is that we are in the task stack:
27          */
28         stack_start = (unsigned long)task->thread_info;
29         stack_end = stack_start + THREAD_SIZE;
30
31         if (in_range(stack_start, stack, stack_end))
32                 return stack_end;
33
34         /*
35          * We are in an interrupt if irqstackptr is set:
36          */
37         raw_local_irq_save(flags);
38         cpu = safe_smp_processor_id();
39         stack_end = (unsigned long)cpu_pda(cpu)->irqstackptr;
40
41         if (stack_end) {
42                 stack_start = stack_end & ~(IRQSTACKSIZE-1);
43                 if (in_range(stack_start, stack, stack_end))
44                         goto out_restore;
45                 /*
46                  * We get here if we are in an IRQ context but we
47                  * are also in an exception stack.
48                  */
49         }
50
51         /*
52          * Iterate over all exception stacks, and figure out whether
53          * 'stack' is in one of them:
54          */
55         for (i = 0; i < N_EXCEPTION_STACKS; i++) {
56                 /*
57                  * set 'end' to the end of the exception stack.
58                  */
59                 stack_end = per_cpu(init_tss, cpu).ist[i];
60                 stack_start = stack_end - EXCEPTION_STKSZ;
61
62                 /*
63                  * Is 'stack' above this exception frame's end?
64                  * If yes then skip to the next frame.
65                  */
66                 if (stack >= stack_end)
67                         continue;
68                 /*
69                  * Is 'stack' above this exception frame's start address?
70                  * If yes then we found the right frame.
71                  */
72                 if (stack >= stack_start)
73                         goto out_restore;
74
75                 /*
76                  * If this is a debug stack, and if it has a larger size than
77                  * the usual exception stacks, then 'stack' might still
78                  * be within the lower portion of the debug stack:
79                  */
80 #if DEBUG_STKSZ > EXCEPTION_STKSZ
81                 if (i == DEBUG_STACK - 1 && stack >= stack_end - DEBUG_STKSZ) {
82                         /*
83                          * Black magic. A large debug stack is composed of
84                          * multiple exception stack entries, which we
85                          * iterate through now. Dont look:
86                          */
87                         do {
88                                 stack_end -= EXCEPTION_STKSZ;
89                                 stack_start -= EXCEPTION_STKSZ;
90                         } while (stack < stack_start);
91
92                         goto out_restore;
93                 }
94 #endif
95         }
96         /*
97          * Ok, 'stack' is not pointing to any of the system stacks.
98          */
99         stack_end = 0;
100
101 out_restore:
102         raw_local_irq_restore(flags);
103
104         return stack_end;
105 }
106
107
108 /*
109  * Save stack-backtrace addresses into a stack_trace buffer:
110  */
111 static inline unsigned long
112 save_context_stack(struct stack_trace *trace, unsigned int skip,
113                    unsigned long stack, unsigned long stack_end)
114 {
115         unsigned long addr;
116
117 #ifdef CONFIG_FRAME_POINTER
118         unsigned long prev_stack = 0;
119
120         while (in_range(prev_stack, stack, stack_end)) {
121                 pr_debug("stack:          %p\n", (void *)stack);
122                 addr = (unsigned long)(((unsigned long *)stack)[1]);
123                 pr_debug("addr:           %p\n", (void *)addr);
124                 if (!skip)
125                         trace->entries[trace->nr_entries++] = addr-1;
126                 else
127                         skip--;
128                 if (trace->nr_entries >= trace->max_entries)
129                         break;
130                 if (!addr)
131                         return 0;
132                 /*
133                  * Stack frames must go forwards (otherwise a loop could
134                  * happen if the stackframe is corrupted), so we move
135                  * prev_stack forwards:
136                  */
137                 prev_stack = stack;
138                 stack = (unsigned long)(((unsigned long *)stack)[0]);
139         }
140         pr_debug("invalid:        %p\n", (void *)stack);
141 #else
142         while (stack < stack_end) {
143                 addr = ((unsigned long *)stack)[0];
144                 stack += sizeof(long);
145                 if (__kernel_text_address(addr)) {
146                         if (!skip)
147                                 trace->entries[trace->nr_entries++] = addr-1;
148                         else
149                                 skip--;
150                         if (trace->nr_entries >= trace->max_entries)
151                                 break;
152                 }
153         }
154 #endif
155         return stack;
156 }
157
158 #define MAX_STACKS 10
159
160 /*
161  * Save stack-backtrace addresses into a stack_trace buffer.
162  * If all_contexts is set, all contexts (hardirq, softirq and process)
163  * are saved. If not set then only the current context is saved.
164  */
165 void save_stack_trace(struct stack_trace *trace,
166                       struct task_struct *task, int all_contexts,
167                       unsigned int skip)
168 {
169         unsigned long stack = (unsigned long)&stack;
170         int i, nr_stacks = 0, stacks_done[MAX_STACKS];
171
172         WARN_ON(trace->nr_entries || !trace->max_entries);
173
174         if (!task)
175                 task = current;
176
177         pr_debug("task: %p, ti: %p\n", task, task->thread_info);
178
179         if (!task || task == current) {
180                 /* Grab rbp right from our regs: */
181                 asm ("mov %%rbp, %0" : "=r" (stack));
182                 pr_debug("rbp:            %p\n", (void *)stack);
183         } else {
184                 /* rbp is the last reg pushed by switch_to(): */
185                 stack = task->thread.rsp;
186                 pr_debug("other task rsp: %p\n", (void *)stack);
187                 stack = (unsigned long)(((unsigned long *)stack)[0]);
188                 pr_debug("other task rbp: %p\n", (void *)stack);
189         }
190
191         while (1) {
192                 unsigned long stack_end = get_stack_end(task, stack);
193
194                 pr_debug("stack:          %p\n", (void *)stack);
195                 pr_debug("stack end:      %p\n", (void *)stack_end);
196
197                 /*
198                  * Invalid stack addres?
199                  */
200                 if (!stack_end)
201                         return;
202                 /*
203                  * Were we in this stack already? (recursion)
204                  */
205                 for (i = 0; i < nr_stacks; i++)
206                         if (stacks_done[i] == stack_end)
207                                 return;
208                 stacks_done[nr_stacks] = stack_end;
209
210                 stack = save_context_stack(trace, skip, stack, stack_end);
211                 if (!all_contexts || !stack ||
212                                 trace->nr_entries >= trace->max_entries)
213                         return;
214                 trace->entries[trace->nr_entries++] = ULONG_MAX;
215                 if (trace->nr_entries >= trace->max_entries)
216                         return;
217                 if (++nr_stacks >= MAX_STACKS)
218                         return;
219         }
220 }
221