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