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