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