1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Performance counter callchain support - powerpc architecture code
4 *
5 * Copyright © 2009 Paul Mackerras, IBM Corporation.
6 */
7 #include <linux/kernel.h>
8 #include <linux/sched.h>
9 #include <linux/perf_event.h>
10 #include <linux/percpu.h>
11 #include <linux/uaccess.h>
12 #include <linux/mm.h>
13 #include <asm/ptrace.h>
14 #include <asm/sigcontext.h>
15 #include <asm/ucontext.h>
16 #include <asm/vdso.h>
17 #include <asm/pte-walk.h>
18
19 #include "callchain.h"
20
21 /*
22 * On 64-bit we don't want to invoke hash_page on user addresses from
23 * interrupt context, so if the access faults, we read the page tables
24 * to find which page (if any) is mapped and access it directly. Radix
25 * has no need for this so it doesn't use read_user_stack_slow.
26 */
read_user_stack_slow(const void __user * ptr,void * buf,int nb)27 int read_user_stack_slow(const void __user *ptr, void *buf, int nb)
28 {
29
30 unsigned long addr = (unsigned long) ptr;
31 unsigned long offset;
32 struct page *page;
33 void *kaddr;
34
35 if (get_user_page_fast_only(addr, FOLL_WRITE, &page)) {
36 kaddr = page_address(page);
37
38 /* align address to page boundary */
39 offset = addr & ~PAGE_MASK;
40
41 memcpy(buf, kaddr + offset, nb);
42 put_page(page);
43 return 0;
44 }
45 return -EFAULT;
46 }
47
read_user_stack_64(const unsigned long __user * ptr,unsigned long * ret)48 static int read_user_stack_64(const unsigned long __user *ptr, unsigned long *ret)
49 {
50 return __read_user_stack(ptr, ret, sizeof(*ret));
51 }
52
53 /*
54 * 64-bit user processes use the same stack frame for RT and non-RT signals.
55 */
56 struct signal_frame_64 {
57 char dummy[__SIGNAL_FRAMESIZE];
58 struct ucontext uc;
59 unsigned long unused[2];
60 unsigned int tramp[6];
61 struct siginfo *pinfo;
62 void *puc;
63 struct siginfo info;
64 char abigap[288];
65 };
66
is_sigreturn_64_address(unsigned long nip,unsigned long fp)67 static int is_sigreturn_64_address(unsigned long nip, unsigned long fp)
68 {
69 if (nip == fp + offsetof(struct signal_frame_64, tramp))
70 return 1;
71 if (current->mm->context.vdso &&
72 nip == VDSO64_SYMBOL(current->mm->context.vdso, sigtramp_rt64))
73 return 1;
74 return 0;
75 }
76
77 /*
78 * Do some sanity checking on the signal frame pointed to by sp.
79 * We check the pinfo and puc pointers in the frame.
80 */
sane_signal_64_frame(unsigned long sp)81 static int sane_signal_64_frame(unsigned long sp)
82 {
83 struct signal_frame_64 __user *sf;
84 unsigned long pinfo, puc;
85
86 sf = (struct signal_frame_64 __user *) sp;
87 if (read_user_stack_64((unsigned long __user *) &sf->pinfo, &pinfo) ||
88 read_user_stack_64((unsigned long __user *) &sf->puc, &puc))
89 return 0;
90 return pinfo == (unsigned long) &sf->info &&
91 puc == (unsigned long) &sf->uc;
92 }
93
perf_callchain_user_64(struct perf_callchain_entry_ctx * entry,struct pt_regs * regs)94 void perf_callchain_user_64(struct perf_callchain_entry_ctx *entry,
95 struct pt_regs *regs)
96 {
97 unsigned long sp, next_sp;
98 unsigned long next_ip;
99 unsigned long lr;
100 long level = 0;
101 struct signal_frame_64 __user *sigframe;
102 unsigned long __user *fp, *uregs;
103
104 next_ip = perf_instruction_pointer(regs);
105 lr = regs->link;
106 sp = regs->gpr[1];
107 perf_callchain_store(entry, next_ip);
108
109 while (entry->nr < entry->max_stack) {
110 fp = (unsigned long __user *) sp;
111 if (invalid_user_sp(sp) || read_user_stack_64(fp, &next_sp))
112 return;
113 if (level > 0 && read_user_stack_64(&fp[2], &next_ip))
114 return;
115
116 /*
117 * Note: the next_sp - sp >= signal frame size check
118 * is true when next_sp < sp, which can happen when
119 * transitioning from an alternate signal stack to the
120 * normal stack.
121 */
122 if (next_sp - sp >= sizeof(struct signal_frame_64) &&
123 (is_sigreturn_64_address(next_ip, sp) ||
124 (level <= 1 && is_sigreturn_64_address(lr, sp))) &&
125 sane_signal_64_frame(sp)) {
126 /*
127 * This looks like an signal frame
128 */
129 sigframe = (struct signal_frame_64 __user *) sp;
130 uregs = sigframe->uc.uc_mcontext.gp_regs;
131 if (read_user_stack_64(&uregs[PT_NIP], &next_ip) ||
132 read_user_stack_64(&uregs[PT_LNK], &lr) ||
133 read_user_stack_64(&uregs[PT_R1], &sp))
134 return;
135 level = 0;
136 perf_callchain_store_context(entry, PERF_CONTEXT_USER);
137 perf_callchain_store(entry, next_ip);
138 continue;
139 }
140
141 if (level == 0)
142 next_ip = lr;
143 perf_callchain_store(entry, next_ip);
144 ++level;
145 sp = next_sp;
146 }
147 }
148