arch/arm64/kernel/perf_callchain.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * arm64 callchain support
   4  *
   5  * Copyright (C) 2015 ARM Limited
   6  */
   7 #include <linux/perf_event.h>
   8 #include <linux/stacktrace.h>
   9 #include <linux/uaccess.h>
  10
  11 #include <asm/pointer_auth.h>
  12
  13 struct frame_tail {
  14         struct frame_tail       __user *fp;
  15         unsigned long           lr;
  16 } __attribute__((packed));
  17
  18 /*
  19  * Get the return address for a single stackframe and return a pointer to the
  20  * next frame tail.
  21  */
  22 static struct frame_tail __user *
  23 user_backtrace(struct frame_tail __user *tail,
  24                struct perf_callchain_entry_ctx *entry)
  25 {
  26         struct frame_tail buftail;
  27         unsigned long err;
  28         unsigned long lr;
  29
  30         /* Also check accessibility of one struct frame_tail beyond */
  31         if (!access_ok(tail, sizeof(buftail)))
  32                 return NULL;
  33
  34         pagefault_disable();
  35         err = __copy_from_user_inatomic(&buftail, tail, sizeof(buftail));
  36         pagefault_enable();
  37
  38         if (err)
  39                 return NULL;
  40
  41         lr = ptrauth_strip_user_insn_pac(buftail.lr);
  42
  43         perf_callchain_store(entry, lr);
  44
  45         /*
  46          * Frame pointers should strictly progress back up the stack
  47          * (towards higher addresses).
  48          */
  49         if (tail >= buftail.fp)
  50                 return NULL;
  51
  52         return buftail.fp;
  53 }
  54
  55 #ifdef CONFIG_COMPAT
  56 /*
  57  * The registers we're interested in are at the end of the variable
  58  * length saved register structure. The fp points at the end of this
  59  * structure so the address of this struct is:
  60  * (struct compat_frame_tail *)(xxx->fp)-1
  61  *
  62  * This code has been adapted from the ARM OProfile support.
  63  */
  64 struct compat_frame_tail {
  65         compat_uptr_t   fp; /* a (struct compat_frame_tail *) in compat mode */
  66         u32             sp;
  67         u32             lr;
  68 } __attribute__((packed));
  69
  70 static struct compat_frame_tail __user *
  71 compat_user_backtrace(struct compat_frame_tail __user *tail,
  72                       struct perf_callchain_entry_ctx *entry)
  73 {
  74         struct compat_frame_tail buftail;
  75         unsigned long err;
  76
  77         /* Also check accessibility of one struct frame_tail beyond */
  78         if (!access_ok(tail, sizeof(buftail)))
  79                 return NULL;
  80
  81         pagefault_disable();
  82         err = __copy_from_user_inatomic(&buftail, tail, sizeof(buftail));
  83         pagefault_enable();
  84
  85         if (err)
  86                 return NULL;
  87
  88         perf_callchain_store(entry, buftail.lr);
  89
  90         /*
  91          * Frame pointers should strictly progress back up the stack
  92          * (towards higher addresses).
  93          */
  94         if (tail + 1 >= (struct compat_frame_tail __user *)
  95                         compat_ptr(buftail.fp))
  96                 return NULL;
  97
  98         return (struct compat_frame_tail __user *)compat_ptr(buftail.fp) - 1;
  99 }
 100 #endif /* CONFIG_COMPAT */
 101
 102 void perf_callchain_user(struct perf_callchain_entry_ctx *entry,
 103                          struct pt_regs *regs)
 104 {
 105         if (perf_guest_state()) {
 106                 /* We don't support guest os callchain now */
 107                 return;
 108         }
 109
 110         perf_callchain_store(entry, regs->pc);
 111
 112         if (!compat_user_mode(regs)) {
 113                 /* AARCH64 mode */
 114                 struct frame_tail __user *tail;
 115
 116                 tail = (struct frame_tail __user *)regs->regs[29];
 117
 118                 while (entry->nr < entry->max_stack &&
 119                        tail && !((unsigned long)tail & 0x7))
 120                         tail = user_backtrace(tail, entry);
 121         } else {
 122 #ifdef CONFIG_COMPAT
 123                 /* AARCH32 compat mode */
 124                 struct compat_frame_tail __user *tail;
 125
 126                 tail = (struct compat_frame_tail __user *)regs->compat_fp - 1;
 127
 128                 while ((entry->nr < entry->max_stack) &&
 129                         tail && !((unsigned long)tail & 0x3))
 130                         tail = compat_user_backtrace(tail, entry);
 131 #endif
 132         }
 133 }
 134
 135 static bool callchain_trace(void *data, unsigned long pc)
 136 {
 137         struct perf_callchain_entry_ctx *entry = data;
 138         return perf_callchain_store(entry, pc) == 0;
 139 }
 140
 141 void perf_callchain_kernel(struct perf_callchain_entry_ctx *entry,
 142                            struct pt_regs *regs)
 143 {
 144         if (perf_guest_state()) {
 145                 /* We don't support guest os callchain now */
 146                 return;
 147         }
 148
 149         arch_stack_walk(callchain_trace, entry, current, regs);
 150 }
 151
 152 unsigned long perf_instruction_pointer(struct pt_regs *regs)
 153 {
 154         if (perf_guest_state())
 155                 return perf_guest_get_ip();
 156
 157         return instruction_pointer(regs);
 158 }
 159
 160 unsigned long perf_misc_flags(struct pt_regs *regs)
 161 {
 162         unsigned int guest_state = perf_guest_state();
 163         int misc = 0;
 164
 165         if (guest_state) {
 166                 if (guest_state & PERF_GUEST_USER)
 167                         misc |= PERF_RECORD_MISC_GUEST_USER;
 168                 else
 169                         misc |= PERF_RECORD_MISC_GUEST_KERNEL;
 170         } else {
 171                 if (user_mode(regs))
 172                         misc |= PERF_RECORD_MISC_USER;
 173                 else
 174                         misc |= PERF_RECORD_MISC_KERNEL;
 175         }
 176
 177         return misc;
 178 }