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
 21static int read_user_stack_64(const unsigned long __user *ptr, unsigned long *ret)
 22{
 23	return __read_user_stack(ptr, ret, sizeof(*ret));
 24}
 25
 26/*
 27 * 64-bit user processes use the same stack frame for RT and non-RT signals.
 28 */
 29struct signal_frame_64 {
 30	char		dummy[__SIGNAL_FRAMESIZE];
 31	struct ucontext	uc;
 32	unsigned long	unused[2];
 33	unsigned int	tramp[6];
 34	struct siginfo	*pinfo;
 35	void		*puc;
 36	struct siginfo	info;
 37	char		abigap[288];
 38};
 39
 40static int is_sigreturn_64_address(unsigned long nip, unsigned long fp)
 41{
 42	if (nip == fp + offsetof(struct signal_frame_64, tramp))
 43		return 1;
 44	if (current->mm->context.vdso &&
 45	    nip == VDSO64_SYMBOL(current->mm->context.vdso, sigtramp_rt64))
 46		return 1;
 47	return 0;
 48}
 49
 50/*
 51 * Do some sanity checking on the signal frame pointed to by sp.
 52 * We check the pinfo and puc pointers in the frame.
 53 */
 54static int sane_signal_64_frame(unsigned long sp)
 55{
 56	struct signal_frame_64 __user *sf;
 57	unsigned long pinfo, puc;
 58
 59	sf = (struct signal_frame_64 __user *) sp;
 60	if (read_user_stack_64((unsigned long __user *) &sf->pinfo, &pinfo) ||
 61	    read_user_stack_64((unsigned long __user *) &sf->puc, &puc))
 62		return 0;
 63	return pinfo == (unsigned long) &sf->info &&
 64		puc == (unsigned long) &sf->uc;
 65}
 66
 67void perf_callchain_user_64(struct perf_callchain_entry_ctx *entry,
 68			    struct pt_regs *regs)
 69{
 70	unsigned long sp, next_sp;
 71	unsigned long next_ip;
 72	unsigned long lr;
 73	long level = 0;
 74	struct signal_frame_64 __user *sigframe;
 75	unsigned long __user *fp, *uregs;
 76
 77	next_ip = perf_instruction_pointer(regs);
 78	lr = regs->link;
 79	sp = regs->gpr[1];
 80	perf_callchain_store(entry, next_ip);
 81
 82	while (entry->nr < entry->max_stack) {
 83		fp = (unsigned long __user *) sp;
 84		if (invalid_user_sp(sp) || read_user_stack_64(fp, &next_sp))
 85			return;
 86		if (level > 0 && read_user_stack_64(&fp[2], &next_ip))
 87			return;
 88
 89		/*
 90		 * Note: the next_sp - sp >= signal frame size check
 91		 * is true when next_sp < sp, which can happen when
 92		 * transitioning from an alternate signal stack to the
 93		 * normal stack.
 94		 */
 95		if (next_sp - sp >= sizeof(struct signal_frame_64) &&
 96		    (is_sigreturn_64_address(next_ip, sp) ||
 97		     (level <= 1 && is_sigreturn_64_address(lr, sp))) &&
 98		    sane_signal_64_frame(sp)) {
 99			/*
100			 * This looks like an signal frame
101			 */
102			sigframe = (struct signal_frame_64 __user *) sp;
103			uregs = sigframe->uc.uc_mcontext.gp_regs;
104			if (read_user_stack_64(&uregs[PT_NIP], &next_ip) ||
105			    read_user_stack_64(&uregs[PT_LNK], &lr) ||
106			    read_user_stack_64(&uregs[PT_R1], &sp))
107				return;
108			level = 0;
109			perf_callchain_store_context(entry, PERF_CONTEXT_USER);
110			perf_callchain_store(entry, next_ip);
111			continue;
112		}
113
114		if (level == 0)
115			next_ip = lr;
116		perf_callchain_store(entry, next_ip);
117		++level;
118		sp = next_sp;
119	}
120}