~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/trace/trace_stack.c

Version: ~ [ linux-5.1-rc1 ] ~ [ linux-5.0.3 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.30 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.107 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.164 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.176 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.136 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
  3  *
  4  */
  5 #include <linux/stacktrace.h>
  6 #include <linux/kallsyms.h>
  7 #include <linux/seq_file.h>
  8 #include <linux/spinlock.h>
  9 #include <linux/uaccess.h>
 10 #include <linux/debugfs.h>
 11 #include <linux/ftrace.h>
 12 #include <linux/module.h>
 13 #include <linux/sysctl.h>
 14 #include <linux/init.h>
 15 #include <linux/fs.h>
 16 #include "trace.h"
 17 
 18 #define STACK_TRACE_ENTRIES 500
 19 
 20 #ifdef CC_USING_FENTRY
 21 # define fentry         1
 22 #else
 23 # define fentry         0
 24 #endif
 25 
 26 static unsigned long stack_dump_trace[STACK_TRACE_ENTRIES+1] =
 27          { [0 ... (STACK_TRACE_ENTRIES)] = ULONG_MAX };
 28 static unsigned stack_dump_index[STACK_TRACE_ENTRIES];
 29 
 30 /*
 31  * Reserve one entry for the passed in ip. This will allow
 32  * us to remove most or all of the stack size overhead
 33  * added by the stack tracer itself.
 34  */
 35 static struct stack_trace max_stack_trace = {
 36         .max_entries            = STACK_TRACE_ENTRIES - 1,
 37         .entries                = &stack_dump_trace[1],
 38 };
 39 
 40 static unsigned long max_stack_size;
 41 static arch_spinlock_t max_stack_lock =
 42         (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
 43 
 44 static int stack_trace_disabled __read_mostly;
 45 static DEFINE_PER_CPU(int, trace_active);
 46 static DEFINE_MUTEX(stack_sysctl_mutex);
 47 
 48 int stack_tracer_enabled;
 49 static int last_stack_tracer_enabled;
 50 
 51 static inline void
 52 check_stack(unsigned long ip, unsigned long *stack)
 53 {
 54         unsigned long this_size, flags;
 55         unsigned long *p, *top, *start;
 56         static int tracer_frame;
 57         int frame_size = ACCESS_ONCE(tracer_frame);
 58         int i;
 59 
 60         this_size = ((unsigned long)stack) & (THREAD_SIZE-1);
 61         this_size = THREAD_SIZE - this_size;
 62         /* Remove the frame of the tracer */
 63         this_size -= frame_size;
 64 
 65         if (this_size <= max_stack_size)
 66                 return;
 67 
 68         /* we do not handle interrupt stacks yet */
 69         if (!object_is_on_stack(stack))
 70                 return;
 71 
 72         local_irq_save(flags);
 73         arch_spin_lock(&max_stack_lock);
 74 
 75         /* In case another CPU set the tracer_frame on us */
 76         if (unlikely(!frame_size))
 77                 this_size -= tracer_frame;
 78 
 79         /* a race could have already updated it */
 80         if (this_size <= max_stack_size)
 81                 goto out;
 82 
 83         max_stack_size = this_size;
 84 
 85         max_stack_trace.nr_entries      = 0;
 86         max_stack_trace.skip            = 3;
 87 
 88         save_stack_trace(&max_stack_trace);
 89 
 90         /*
 91          * Add the passed in ip from the function tracer.
 92          * Searching for this on the stack will skip over
 93          * most of the overhead from the stack tracer itself.
 94          */
 95         stack_dump_trace[0] = ip;
 96         max_stack_trace.nr_entries++;
 97 
 98         /*
 99          * Now find where in the stack these are.
100          */
101         i = 0;
102         start = stack;
103         top = (unsigned long *)
104                 (((unsigned long)start & ~(THREAD_SIZE-1)) + THREAD_SIZE);
105 
106         /*
107          * Loop through all the entries. One of the entries may
108          * for some reason be missed on the stack, so we may
109          * have to account for them. If they are all there, this
110          * loop will only happen once. This code only takes place
111          * on a new max, so it is far from a fast path.
112          */
113         while (i < max_stack_trace.nr_entries) {
114                 int found = 0;
115 
116                 stack_dump_index[i] = this_size;
117                 p = start;
118 
119                 for (; p < top && i < max_stack_trace.nr_entries; p++) {
120                         if (*p == stack_dump_trace[i]) {
121                                 this_size = stack_dump_index[i++] =
122                                         (top - p) * sizeof(unsigned long);
123                                 found = 1;
124                                 /* Start the search from here */
125                                 start = p + 1;
126                                 /*
127                                  * We do not want to show the overhead
128                                  * of the stack tracer stack in the
129                                  * max stack. If we haven't figured
130                                  * out what that is, then figure it out
131                                  * now.
132                                  */
133                                 if (unlikely(!tracer_frame) && i == 1) {
134                                         tracer_frame = (p - stack) *
135                                                 sizeof(unsigned long);
136                                         max_stack_size -= tracer_frame;
137                                 }
138                         }
139                 }
140 
141                 if (!found)
142                         i++;
143         }
144 
145  out:
146         arch_spin_unlock(&max_stack_lock);
147         local_irq_restore(flags);
148 }
149 
150 static void
151 stack_trace_call(unsigned long ip, unsigned long parent_ip)
152 {
153         unsigned long stack;
154         int cpu;
155 
156         if (unlikely(!ftrace_enabled || stack_trace_disabled))
157                 return;
158 
159         preempt_disable_notrace();
160 
161         cpu = raw_smp_processor_id();
162         /* no atomic needed, we only modify this variable by this cpu */
163         if (per_cpu(trace_active, cpu)++ != 0)
164                 goto out;
165 
166         /*
167          * When fentry is used, the traced function does not get
168          * its stack frame set up, and we lose the parent.
169          * The ip is pretty useless because the function tracer
170          * was called before that function set up its stack frame.
171          * In this case, we use the parent ip.
172          *
173          * By adding the return address of either the parent ip
174          * or the current ip we can disregard most of the stack usage
175          * caused by the stack tracer itself.
176          *
177          * The function tracer always reports the address of where the
178          * mcount call was, but the stack will hold the return address.
179          */
180         if (fentry)
181                 ip = parent_ip;
182         else
183                 ip += MCOUNT_INSN_SIZE;
184 
185         check_stack(ip, &stack);
186 
187  out:
188         per_cpu(trace_active, cpu)--;
189         /* prevent recursion in schedule */
190         preempt_enable_notrace();
191 }
192 
193 static struct ftrace_ops trace_ops __read_mostly =
194 {
195         .func = stack_trace_call,
196         .flags = FTRACE_OPS_FL_GLOBAL,
197 };
198 
199 static ssize_t
200 stack_max_size_read(struct file *filp, char __user *ubuf,
201                     size_t count, loff_t *ppos)
202 {
203         unsigned long *ptr = filp->private_data;
204         char buf[64];
205         int r;
206 
207         r = snprintf(buf, sizeof(buf), "%ld\n", *ptr);
208         if (r > sizeof(buf))
209                 r = sizeof(buf);
210         return simple_read_from_buffer(ubuf, count, ppos, buf, r);
211 }
212 
213 static ssize_t
214 stack_max_size_write(struct file *filp, const char __user *ubuf,
215                      size_t count, loff_t *ppos)
216 {
217         long *ptr = filp->private_data;
218         unsigned long val, flags;
219         char buf[64];
220         int ret;
221         int cpu;
222 
223         if (count >= sizeof(buf))
224                 return -EINVAL;
225 
226         if (copy_from_user(&buf, ubuf, count))
227                 return -EFAULT;
228 
229         buf[count] = 0;
230 
231         ret = strict_strtoul(buf, 10, &val);
232         if (ret < 0)
233                 return ret;
234 
235         local_irq_save(flags);
236 
237         /*
238          * In case we trace inside arch_spin_lock() or after (NMI),
239          * we will cause circular lock, so we also need to increase
240          * the percpu trace_active here.
241          */
242         cpu = smp_processor_id();
243         per_cpu(trace_active, cpu)++;
244 
245         arch_spin_lock(&max_stack_lock);
246         *ptr = val;
247         arch_spin_unlock(&max_stack_lock);
248 
249         per_cpu(trace_active, cpu)--;
250         local_irq_restore(flags);
251 
252         return count;
253 }
254 
255 static const struct file_operations stack_max_size_fops = {
256         .open           = tracing_open_generic,
257         .read           = stack_max_size_read,
258         .write          = stack_max_size_write,
259         .llseek         = default_llseek,
260 };
261 
262 static void *
263 __next(struct seq_file *m, loff_t *pos)
264 {
265         long n = *pos - 1;
266 
267         if (n >= max_stack_trace.nr_entries || stack_dump_trace[n] == ULONG_MAX)
268                 return NULL;
269 
270         m->private = (void *)n;
271         return &m->private;
272 }
273 
274 static void *
275 t_next(struct seq_file *m, void *v, loff_t *pos)
276 {
277         (*pos)++;
278         return __next(m, pos);
279 }
280 
281 static void *t_start(struct seq_file *m, loff_t *pos)
282 {
283         int cpu;
284 
285         local_irq_disable();
286 
287         cpu = smp_processor_id();
288         per_cpu(trace_active, cpu)++;
289 
290         arch_spin_lock(&max_stack_lock);
291 
292         if (*pos == 0)
293                 return SEQ_START_TOKEN;
294 
295         return __next(m, pos);
296 }
297 
298 static void t_stop(struct seq_file *m, void *p)
299 {
300         int cpu;
301 
302         arch_spin_unlock(&max_stack_lock);
303 
304         cpu = smp_processor_id();
305         per_cpu(trace_active, cpu)--;
306 
307         local_irq_enable();
308 }
309 
310 static int trace_lookup_stack(struct seq_file *m, long i)
311 {
312         unsigned long addr = stack_dump_trace[i];
313 
314         return seq_printf(m, "%pS\n", (void *)addr);
315 }
316 
317 static void print_disabled(struct seq_file *m)
318 {
319         seq_puts(m, "#\n"
320                  "#  Stack tracer disabled\n"
321                  "#\n"
322                  "# To enable the stack tracer, either add 'stacktrace' to the\n"
323                  "# kernel command line\n"
324                  "# or 'echo 1 > /proc/sys/kernel/stack_tracer_enabled'\n"
325                  "#\n");
326 }
327 
328 static int t_show(struct seq_file *m, void *v)
329 {
330         long i;
331         int size;
332 
333         if (v == SEQ_START_TOKEN) {
334                 seq_printf(m, "        Depth    Size   Location"
335                            "    (%d entries)\n"
336                            "        -----    ----   --------\n",
337                            max_stack_trace.nr_entries - 1);
338 
339                 if (!stack_tracer_enabled && !max_stack_size)
340                         print_disabled(m);
341 
342                 return 0;
343         }
344 
345         i = *(long *)v;
346 
347         if (i >= max_stack_trace.nr_entries ||
348             stack_dump_trace[i] == ULONG_MAX)
349                 return 0;
350 
351         if (i+1 == max_stack_trace.nr_entries ||
352             stack_dump_trace[i+1] == ULONG_MAX)
353                 size = stack_dump_index[i];
354         else
355                 size = stack_dump_index[i] - stack_dump_index[i+1];
356 
357         seq_printf(m, "%3ld) %8d   %5d   ", i, stack_dump_index[i], size);
358 
359         trace_lookup_stack(m, i);
360 
361         return 0;
362 }
363 
364 static const struct seq_operations stack_trace_seq_ops = {
365         .start          = t_start,
366         .next           = t_next,
367         .stop           = t_stop,
368         .show           = t_show,
369 };
370 
371 static int stack_trace_open(struct inode *inode, struct file *file)
372 {
373         return seq_open(file, &stack_trace_seq_ops);
374 }
375 
376 static const struct file_operations stack_trace_fops = {
377         .open           = stack_trace_open,
378         .read           = seq_read,
379         .llseek         = seq_lseek,
380         .release        = seq_release,
381 };
382 
383 int
384 stack_trace_sysctl(struct ctl_table *table, int write,
385                    void __user *buffer, size_t *lenp,
386                    loff_t *ppos)
387 {
388         int ret;
389 
390         mutex_lock(&stack_sysctl_mutex);
391 
392         ret = proc_dointvec(table, write, buffer, lenp, ppos);
393 
394         if (ret || !write ||
395             (last_stack_tracer_enabled == !!stack_tracer_enabled))
396                 goto out;
397 
398         last_stack_tracer_enabled = !!stack_tracer_enabled;
399 
400         if (stack_tracer_enabled)
401                 register_ftrace_function(&trace_ops);
402         else
403                 unregister_ftrace_function(&trace_ops);
404 
405  out:
406         mutex_unlock(&stack_sysctl_mutex);
407         return ret;
408 }
409 
410 static __init int enable_stacktrace(char *str)
411 {
412         stack_tracer_enabled = 1;
413         last_stack_tracer_enabled = 1;
414         return 1;
415 }
416 __setup("stacktrace", enable_stacktrace);
417 
418 static __init int stack_trace_init(void)
419 {
420         struct dentry *d_tracer;
421 
422         d_tracer = tracing_init_dentry();
423         if (!d_tracer)
424                 return 0;
425 
426         trace_create_file("stack_max_size", 0644, d_tracer,
427                         &max_stack_size, &stack_max_size_fops);
428 
429         trace_create_file("stack_trace", 0444, d_tracer,
430                         NULL, &stack_trace_fops);
431 
432         if (stack_tracer_enabled)
433                 register_ftrace_function(&trace_ops);
434 
435         return 0;
436 }
437 
438 device_initcall(stack_trace_init);
439 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp