arch/powerpc/perf/callchain_64.c

   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 static 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  */
  29 struct 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
  40 static 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  */
  54 static 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
  67 void 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 }