cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

callchain_64.c (3260B)

      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}