Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / arch / x86 / kernel / stacktrace.c
1 /*
2  * Stack trace management functions
3  *
4  *  Copyright (C) 2006-2009 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 0;
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         .walk_stack     = print_context_stack,
61 };
62
63 static const struct stacktrace_ops save_stack_ops_nosched = {
64         .warning        = save_stack_warning,
65         .warning_symbol = save_stack_warning_symbol,
66         .stack          = save_stack_stack,
67         .address        = save_stack_address_nosched,
68         .walk_stack     = print_context_stack,
69 };
70
71 /*
72  * Save stack-backtrace addresses into a stack_trace buffer.
73  */
74 void save_stack_trace(struct stack_trace *trace)
75 {
76         dump_trace(current, NULL, NULL, 0, &save_stack_ops, trace);
77         if (trace->nr_entries < trace->max_entries)
78                 trace->entries[trace->nr_entries++] = ULONG_MAX;
79 }
80 EXPORT_SYMBOL_GPL(save_stack_trace);
81
82 void save_stack_trace_bp(struct stack_trace *trace, unsigned long bp)
83 {
84         dump_trace(current, NULL, NULL, bp, &save_stack_ops, trace);
85         if (trace->nr_entries < trace->max_entries)
86                 trace->entries[trace->nr_entries++] = ULONG_MAX;
87 }
88
89 void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
90 {
91         dump_trace(tsk, NULL, NULL, 0, &save_stack_ops_nosched, trace);
92         if (trace->nr_entries < trace->max_entries)
93                 trace->entries[trace->nr_entries++] = ULONG_MAX;
94 }
95 EXPORT_SYMBOL_GPL(save_stack_trace_tsk);
96
97 /* Userspace stacktrace - based on kernel/trace/trace_sysprof.c */
98
99 struct stack_frame {
100         const void __user       *next_fp;
101         unsigned long           ret_addr;
102 };
103
104 static int copy_stack_frame(const void __user *fp, struct stack_frame *frame)
105 {
106         int ret;
107
108         if (!access_ok(VERIFY_READ, fp, sizeof(*frame)))
109                 return 0;
110
111         ret = 1;
112         pagefault_disable();
113         if (__copy_from_user_inatomic(frame, fp, sizeof(*frame)))
114                 ret = 0;
115         pagefault_enable();
116
117         return ret;
118 }
119
120 static inline void __save_stack_trace_user(struct stack_trace *trace)
121 {
122         const struct pt_regs *regs = task_pt_regs(current);
123         const void __user *fp = (const void __user *)regs->bp;
124
125         if (trace->nr_entries < trace->max_entries)
126                 trace->entries[trace->nr_entries++] = regs->ip;
127
128         while (trace->nr_entries < trace->max_entries) {
129                 struct stack_frame frame;
130
131                 frame.next_fp = NULL;
132                 frame.ret_addr = 0;
133                 if (!copy_stack_frame(fp, &frame))
134                         break;
135                 if ((unsigned long)fp < regs->sp)
136                         break;
137                 if (frame.ret_addr) {
138                         trace->entries[trace->nr_entries++] =
139                                 frame.ret_addr;
140                 }
141                 if (fp == frame.next_fp)
142                         break;
143                 fp = frame.next_fp;
144         }
145 }
146
147 void save_stack_trace_user(struct stack_trace *trace)
148 {
149         /*
150          * Trace user stack if we are not a kernel thread
151          */
152         if (current->mm) {
153                 __save_stack_trace_user(trace);
154         }
155         if (trace->nr_entries < trace->max_entries)
156                 trace->entries[trace->nr_entries++] = ULONG_MAX;
157 }
158