git.oblomov.eu Git - linux-2.6/blob - 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
  15 #define STACK_SP(STACK)         *(STACK)
  16
  17 #define STACK_LR64(STACK)       *((unsigned long *)(STACK) + 2)
  18 #define STACK_LR32(STACK)       *((unsigned int *)(STACK) + 1)
  19
  20 #ifdef CONFIG_PPC64
  21 #define STACK_LR(STACK)         STACK_LR64(STACK)
  22 #else
  23 #define STACK_LR(STACK)         STACK_LR32(STACK)
  24 #endif
  25
  26 static unsigned int user_getsp32(unsigned int sp, int is_first)
  27 {
  28         unsigned int stack_frame[2];
  29
  30         if (!access_ok(VERIFY_READ, sp, sizeof(stack_frame)))
  31                 return 0;
  32
  33         /*
  34          * The most likely reason for this is that we returned -EFAULT,
  35          * which means that we've done all that we can do from
  36          * interrupt context.
  37          */
  38         if (__copy_from_user_inatomic(stack_frame, (void *)(long)sp,
  39                                         sizeof(stack_frame)))
  40                 return 0;
  41
  42         if (!is_first)
  43                 oprofile_add_trace(STACK_LR32(stack_frame));
  44
  45         /*
  46          * We do not enforce increasing stack addresses here because
  47          * we may transition to a different stack, eg a signal handler.
  48          */
  49         return STACK_SP(stack_frame);
  50 }
  51
  52 #ifdef CONFIG_PPC64
  53 static unsigned long user_getsp64(unsigned long sp, int is_first)
  54 {
  55         unsigned long stack_frame[3];
  56
  57         if (!access_ok(VERIFY_READ, sp, sizeof(stack_frame)))
  58                 return 0;
  59
  60         if (__copy_from_user_inatomic(stack_frame, (void *)sp,
  61                                         sizeof(stack_frame)))
  62                 return 0;
  63
  64         if (!is_first)
  65                 oprofile_add_trace(STACK_LR64(stack_frame));
  66
  67         return STACK_SP(stack_frame);
  68 }
  69 #endif
  70
  71 static unsigned long kernel_getsp(unsigned long sp, int is_first)
  72 {
  73         unsigned long *stack_frame = (unsigned long *)sp;
  74
  75         if (!validate_sp(sp, current, STACK_FRAME_OVERHEAD))
  76                 return 0;
  77
  78         if (!is_first)
  79                 oprofile_add_trace(STACK_LR(stack_frame));
  80
  81         /*
  82          * We do not enforce increasing stack addresses here because
  83          * we might be transitioning from an interrupt stack to a kernel
  84          * stack. validate_sp() is designed to understand this, so just
  85          * use it.
  86          */
  87         return STACK_SP(stack_frame);
  88 }
  89
  90 void op_powerpc_backtrace(struct pt_regs * const regs, unsigned int depth)
  91 {
  92         unsigned long sp = regs->gpr[1];
  93         int first_frame = 1;
  94
  95         /* We ditch the top stackframe so need to loop through an extra time */
  96         depth += 1;
  97
  98         if (!user_mode(regs)) {
  99                 while (depth--) {
 100                         sp = kernel_getsp(sp, first_frame);
 101                         if (!sp)
 102                                 break;
 103                         first_frame = 0;
 104                 }
 105         } else {
 106 #ifdef CONFIG_PPC64
 107                 if (!test_thread_flag(TIF_32BIT)) {
 108                         while (depth--) {
 109                                 sp = user_getsp64(sp, first_frame);
 110                                 if (!sp)
 111                                         break;
 112                                 first_frame = 0;
 113                         }
 114
 115                         return;
 116                 }
 117 #endif
 118
 119                 while (depth--) {
 120                         sp = user_getsp32(sp, first_frame);
 121                         if (!sp)
 122                                 break;
 123                         first_frame = 0;
 124                 }
 125         }
 126 }