arch/powerpc/oprofile/backtrace.c

   1 /**
   2  * Copyright (C) 2005 Brian Rogan <bcr6@cornell.edu>, IBM
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version
   7  * 2 of the License, or (at your option) any later version.
   8 **/
   9
  10 #include <linux/oprofile.h>
  11 #include <linux/sched.h>
  12 #include <asm/processor.h>
  13 #include <asm/uaccess.h>
  14 #include <asm/compat.h>
  15 #include <asm/oprofile_impl.h>
  16
  17 #define STACK_SP(STACK)         *(STACK)
  18
  19 #define STACK_LR64(STACK)       *((unsigned long *)(STACK) + 2)
  20 #define STACK_LR32(STACK)       *((unsigned int *)(STACK) + 1)
  21
  22 #ifdef CONFIG_PPC64
  23 #define STACK_LR(STACK)         STACK_LR64(STACK)
  24 #else
  25 #define STACK_LR(STACK)         STACK_LR32(STACK)
  26 #endif
  27
  28 static unsigned int user_getsp32(unsigned int sp, int is_first)
  29 {
  30         unsigned int stack_frame[2];
  31         void __user *p = compat_ptr(sp);
  32
  33         if (!access_ok(VERIFY_READ, p, sizeof(stack_frame)))
  34                 return 0;
  35
  36         /*
  37          * The most likely reason for this is that we returned -EFAULT,
  38          * which means that we've done all that we can do from
  39          * interrupt context.
  40          */
  41         if (__copy_from_user_inatomic(stack_frame, p, sizeof(stack_frame)))
  42                 return 0;
  43
  44         if (!is_first)
  45                 oprofile_add_trace(STACK_LR32(stack_frame));
  46
  47         /*
  48          * We do not enforce increasing stack addresses here because
  49          * we may transition to a different stack, eg a signal handler.
  50          */
  51         return STACK_SP(stack_frame);
  52 }
  53
  54 #ifdef CONFIG_PPC64
  55 static unsigned long user_getsp64(unsigned long sp, int is_first)
  56 {
  57         unsigned long stack_frame[3];
  58
  59         if (!access_ok(VERIFY_READ, (void __user *)sp, sizeof(stack_frame)))
  60                 return 0;
  61
  62         if (__copy_from_user_inatomic(stack_frame, (void __user *)sp,
  63                                         sizeof(stack_frame)))
  64                 return 0;
  65
  66         if (!is_first)
  67                 oprofile_add_trace(STACK_LR64(stack_frame));
  68
  69         return STACK_SP(stack_frame);
  70 }
  71 #endif
  72
  73 static unsigned long kernel_getsp(unsigned long sp, int is_first)
  74 {
  75         unsigned long *stack_frame = (unsigned long *)sp;
  76
  77         if (!validate_sp(sp, current, STACK_FRAME_OVERHEAD))
  78                 return 0;
  79
  80         if (!is_first)
  81                 oprofile_add_trace(STACK_LR(stack_frame));
  82
  83         /*
  84          * We do not enforce increasing stack addresses here because
  85          * we might be transitioning from an interrupt stack to a kernel
  86          * stack. validate_sp() is designed to understand this, so just
  87          * use it.
  88          */
  89         return STACK_SP(stack_frame);
  90 }
  91
  92 void op_powerpc_backtrace(struct pt_regs * const regs, unsigned int depth)
  93 {
  94         unsigned long sp = regs->gpr[1];
  95         int first_frame = 1;
  96
  97         /* We ditch the top stackframe so need to loop through an extra time */
  98         depth += 1;
  99
 100         if (!user_mode(regs)) {
 101                 while (depth--) {
 102                         sp = kernel_getsp(sp, first_frame);
 103                         if (!sp)
 104                                 break;
 105                         first_frame = 0;
 106                 }
 107         } else {
 108 #ifdef CONFIG_PPC64
 109                 if (!is_32bit_task()) {
 110                         while (depth--) {
 111                                 sp = user_getsp64(sp, first_frame);
 112                                 if (!sp)
 113                                         break;
 114                                 first_frame = 0;
 115                         }
 116
 117                         return;
 118                 }
 119 #endif
 120
 121                 while (depth--) {
 122                         sp = user_getsp32(sp, first_frame);
 123                         if (!sp)
 124                                 break;
 125                         first_frame = 0;
 126                 }
 127         }
 128 }