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