arch/x86/oprofile/backtrace.c

   1 /**
   2  * @file backtrace.c
   3  *
   4  * @remark Copyright 2002 OProfile authors
   5  * @remark Read the file COPYING
   6  *
   7  * @author John Levon
   8  * @author David Smith
   9  */
  10
  11 #include <linux/oprofile.h>
  12 #include <linux/sched.h>
  13 #include <linux/mm.h>
  14 #include <asm/ptrace.h>
  15 #include <asm/uaccess.h>
  16 #include <asm/stacktrace.h>
  17 #include <linux/compat.h>
  18
  19 static int backtrace_stack(void *data, char *name)
  20 {
  21         /* Yes, we want all stacks */
  22         return 0;
  23 }
  24
  25 static void backtrace_address(void *data, unsigned long addr, int reliable)
  26 {
  27         unsigned int *depth = data;
  28
  29         if ((*depth)--)
  30                 oprofile_add_trace(addr);
  31 }
  32
  33 static struct stacktrace_ops backtrace_ops = {
  34         .stack          = backtrace_stack,
  35         .address        = backtrace_address,
  36         .walk_stack     = print_context_stack,
  37 };
  38
  39 #ifdef CONFIG_COMPAT
  40 static struct stack_frame_ia32 *
  41 dump_user_backtrace_32(struct stack_frame_ia32 *head)
  42 {
  43         struct stack_frame_ia32 bufhead[2];
  44         struct stack_frame_ia32 *fp;
  45
  46         /* Also check accessibility of one struct frame_head beyond */
  47         if (!access_ok(VERIFY_READ, head, sizeof(bufhead)))
  48                 return NULL;
  49         if (__copy_from_user_inatomic(bufhead, head, sizeof(bufhead)))
  50                 return NULL;
  51
  52         fp = (struct stack_frame_ia32 *) compat_ptr(bufhead[0].next_frame);
  53
  54         oprofile_add_trace(bufhead[0].return_address);
  55
  56         /* frame pointers should strictly progress back up the stack
  57         * (towards higher addresses) */
  58         if (head >= fp)
  59                 return NULL;
  60
  61         return fp;
  62 }
  63
  64 static inline int
  65 x86_backtrace_32(struct pt_regs * const regs, unsigned int depth)
  66 {
  67         struct stack_frame_ia32 *head;
  68
  69         /* User process is 32-bit */
  70         if (!current || !test_thread_flag(TIF_IA32))
  71                 return 0;
  72
  73         head = (struct stack_frame_ia32 *) regs->bp;
  74         while (depth-- && head)
  75                 head = dump_user_backtrace_32(head);
  76
  77         return 1;
  78 }
  79
  80 #else
  81 static inline int
  82 x86_backtrace_32(struct pt_regs * const regs, unsigned int depth)
  83 {
  84         return 0;
  85 }
  86 #endif /* CONFIG_COMPAT */
  87
  88 static struct stack_frame *dump_user_backtrace(struct stack_frame *head)
  89 {
  90         struct stack_frame bufhead[2];
  91
  92         /* Also check accessibility of one struct stack_frame beyond */
  93         if (!access_ok(VERIFY_READ, head, sizeof(bufhead)))
  94                 return NULL;
  95         if (__copy_from_user_inatomic(bufhead, head, sizeof(bufhead)))
  96                 return NULL;
  97
  98         oprofile_add_trace(bufhead[0].return_address);
  99
 100         /* frame pointers should strictly progress back up the stack
 101          * (towards higher addresses) */
 102         if (head >= bufhead[0].next_frame)
 103                 return NULL;
 104
 105         return bufhead[0].next_frame;
 106 }
 107
 108 void
 109 x86_backtrace(struct pt_regs * const regs, unsigned int depth)
 110 {
 111         struct stack_frame *head = (struct stack_frame *)frame_pointer(regs);
 112
 113         if (!user_mode_vm(regs)) {
 114                 unsigned long stack = kernel_stack_pointer(regs);
 115                 if (depth)
 116                         dump_trace(NULL, regs, (unsigned long *)stack, 0,
 117                                    &backtrace_ops, &depth);
 118                 return;
 119         }
 120
 121         if (x86_backtrace_32(regs, depth))
 122                 return;
 123
 124         while (depth-- && head)
 125                 head = dump_user_backtrace(head);
 126 }