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 void backtrace_warning_symbol(void *data, char *msg,
  20                                      unsigned long symbol)
  21 {
  22         /* Ignore warnings */
  23 }
  24
  25 static void backtrace_warning(void *data, char *msg)
  26 {
  27         /* Ignore warnings */
  28 }
  29
  30 static int backtrace_stack(void *data, char *name)
  31 {
  32         /* Yes, we want all stacks */
  33         return 0;
  34 }
  35
  36 static void backtrace_address(void *data, unsigned long addr, int reliable)
  37 {
  38         unsigned int *depth = data;
  39
  40         if ((*depth)--)
  41                 oprofile_add_trace(addr);
  42 }
  43
  44 static struct stacktrace_ops backtrace_ops = {
  45         .warning        = backtrace_warning,
  46         .warning_symbol = backtrace_warning_symbol,
  47         .stack          = backtrace_stack,
  48         .address        = backtrace_address,
  49         .walk_stack     = print_context_stack,
  50 };
  51
  52 #ifdef CONFIG_COMPAT
  53 static struct stack_frame_ia32 *
  54 dump_user_backtrace_32(struct stack_frame_ia32 *head)
  55 {
  56         struct stack_frame_ia32 bufhead[2];
  57         struct stack_frame_ia32 *fp;
  58
  59         /* Also check accessibility of one struct frame_head beyond */
  60         if (!access_ok(VERIFY_READ, head, sizeof(bufhead)))
  61                 return NULL;
  62         if (__copy_from_user_inatomic(bufhead, head, sizeof(bufhead)))
  63                 return NULL;
  64
  65         fp = (struct stack_frame_ia32 *) compat_ptr(bufhead[0].next_frame);
  66
  67         oprofile_add_trace(bufhead[0].return_address);
  68
  69         /* frame pointers should strictly progress back up the stack
  70         * (towards higher addresses) */
  71         if (head >= fp)
  72                 return NULL;
  73
  74         return fp;
  75 }
  76
  77 static inline int
  78 x86_backtrace_32(struct pt_regs * const regs, unsigned int depth)
  79 {
  80         struct stack_frame_ia32 *head;
  81
  82         /* User process is 32-bit */
  83         if (!current || !test_thread_flag(TIF_IA32))
  84                 return 0;
  85
  86         head = (struct stack_frame_ia32 *) regs->bp;
  87         while (depth-- && head)
  88                 head = dump_user_backtrace_32(head);
  89
  90         return 1;
  91 }
  92
  93 #else
  94 static inline int
  95 x86_backtrace_32(struct pt_regs * const regs, unsigned int depth)
  96 {
  97         return 0;
  98 }
  99 #endif /* CONFIG_COMPAT */
 100
 101 static struct stack_frame *dump_user_backtrace(struct stack_frame *head)
 102 {
 103         struct stack_frame bufhead[2];
 104
 105         /* Also check accessibility of one struct stack_frame beyond */
 106         if (!access_ok(VERIFY_READ, head, sizeof(bufhead)))
 107                 return NULL;
 108         if (__copy_from_user_inatomic(bufhead, head, sizeof(bufhead)))
 109                 return NULL;
 110
 111         oprofile_add_trace(bufhead[0].return_address);
 112
 113         /* frame pointers should strictly progress back up the stack
 114          * (towards higher addresses) */
 115         if (head >= bufhead[0].next_frame)
 116                 return NULL;
 117
 118         return bufhead[0].next_frame;
 119 }
 120
 121 void
 122 x86_backtrace(struct pt_regs * const regs, unsigned int depth)
 123 {
 124         struct stack_frame *head = (struct stack_frame *)frame_pointer(regs);
 125
 126         if (!user_mode_vm(regs)) {
 127                 unsigned long stack = kernel_stack_pointer(regs);
 128                 if (depth)
 129                         dump_trace(NULL, regs, (unsigned long *)stack, 0,
 130                                    &backtrace_ops, &depth);
 131                 return;
 132         }
 133
 134         if (x86_backtrace_32(regs, depth))
 135                 return;
 136
 137         while (depth-- && head)
 138                 head = dump_user_backtrace(head);
 139 }