Bug fix.
[kvmfornfv.git] / kernel / 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 <linux/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                 pagefault_disable();
109 #ifdef CONFIG_PPC64
110                 if (!is_32bit_task()) {
111                         while (depth--) {
112                                 sp = user_getsp64(sp, first_frame);
113                                 if (!sp)
114                                         break;
115                                 first_frame = 0;
116                         }
117                         pagefault_enable();
118                         return;
119                 }
120 #endif
121
122                 while (depth--) {
123                         sp = user_getsp32(sp, first_frame);
124                         if (!sp)
125                                 break;
126                         first_frame = 0;
127                 }
128                 pagefault_enable();
129         }
130 }