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 */ 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 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 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 */ 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 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