x86, percpu: fix kexec with vmlinux
[linux-2.6] / arch / x86 / kernel / stacktrace.c
1 /*
2  * Stack trace management functions
3  *
4  *  Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
5  */
6 #include <linux/sched.h>
7 #include <linux/stacktrace.h>
8 #include <linux/module.h>
9 #include <linux/uaccess.h>
10 #include <asm/stacktrace.h>
11
12 static void save_stack_warning(void *data, char *msg)
13 {
14 }
15
16 static void
17 save_stack_warning_symbol(void *data, char *msg, unsigned long symbol)
18 {
19 }
20
21 static int save_stack_stack(void *data, char *name)
22 {
23         return -1;
24 }
25
26 static void save_stack_address(void *data, unsigned long addr, int reliable)
27 {
28         struct stack_trace *trace = data;
29         if (!reliable)
30                 return;
31         if (trace->skip > 0) {
32                 trace->skip--;
33                 return;
34         }
35         if (trace->nr_entries < trace->max_entries)
36                 trace->entries[trace->nr_entries++] = addr;
37 }
38
39 static void
40 save_stack_address_nosched(void *data, unsigned long addr, int reliable)
41 {
42         struct stack_trace *trace = (struct stack_trace *)data;
43         if (!reliable)
44                 return;
45         if (in_sched_functions(addr))
46                 return;
47         if (trace->skip > 0) {
48                 trace->skip--;
49                 return;
50         }
51         if (trace->nr_entries < trace->max_entries)
52                 trace->entries[trace->nr_entries++] = addr;
53 }
54
55 static const struct stacktrace_ops save_stack_ops = {
56         .warning = save_stack_warning,
57         .warning_symbol = save_stack_warning_symbol,
58         .stack = save_stack_stack,
59         .address = save_stack_address,
60 };
61
62 static const struct stacktrace_ops save_stack_ops_nosched = {
63         .warning = save_stack_warning,
64         .warning_symbol = save_stack_warning_symbol,
65         .stack = save_stack_stack,
66         .address = save_stack_address_nosched,
67 };
68
69 /*
70  * Save stack-backtrace addresses into a stack_trace buffer.
71  */
72 void save_stack_trace(struct stack_trace *trace)
73 {
74         dump_trace(current, NULL, NULL, 0, &save_stack_ops, trace);
75         if (trace->nr_entries < trace->max_entries)
76                 trace->entries[trace->nr_entries++] = ULONG_MAX;
77 }
78 EXPORT_SYMBOL_GPL(save_stack_trace);
79
80 void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
81 {
82         dump_trace(tsk, NULL, NULL, 0, &save_stack_ops_nosched, trace);
83         if (trace->nr_entries < trace->max_entries)
84                 trace->entries[trace->nr_entries++] = ULONG_MAX;
85 }
86 EXPORT_SYMBOL_GPL(save_stack_trace_tsk);
87
88 /* Userspace stacktrace - based on kernel/trace/trace_sysprof.c */
89
90 struct stack_frame {
91         const void __user       *next_fp;
92         unsigned long           ret_addr;
93 };
94
95 static int copy_stack_frame(const void __user *fp, struct stack_frame *frame)
96 {
97         int ret;
98
99         if (!access_ok(VERIFY_READ, fp, sizeof(*frame)))
100                 return 0;
101
102         ret = 1;
103         pagefault_disable();
104         if (__copy_from_user_inatomic(frame, fp, sizeof(*frame)))
105                 ret = 0;
106         pagefault_enable();
107
108         return ret;
109 }
110
111 static inline void __save_stack_trace_user(struct stack_trace *trace)
112 {
113         const struct pt_regs *regs = task_pt_regs(current);
114         const void __user *fp = (const void __user *)regs->bp;
115
116         if (trace->nr_entries < trace->max_entries)
117                 trace->entries[trace->nr_entries++] = regs->ip;
118
119         while (trace->nr_entries < trace->max_entries) {
120                 struct stack_frame frame;
121
122                 frame.next_fp = NULL;
123                 frame.ret_addr = 0;
124                 if (!copy_stack_frame(fp, &frame))
125                         break;
126                 if ((unsigned long)fp < regs->sp)
127                         break;
128                 if (frame.ret_addr) {
129                         trace->entries[trace->nr_entries++] =
130                                 frame.ret_addr;
131                 }
132                 if (fp == frame.next_fp)
133                         break;
134                 fp = frame.next_fp;
135         }
136 }
137
138 void save_stack_trace_user(struct stack_trace *trace)
139 {
140         /*
141          * Trace user stack if we are not a kernel thread
142          */
143         if (current->mm) {
144                 __save_stack_trace_user(trace);
145         }
146         if (trace->nr_entries < trace->max_entries)
147                 trace->entries[trace->nr_entries++] = ULONG_MAX;
148 }
149