arch/csky/kernel/perf_callchain.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (C) 2019 Hangzhou C-SKY Microsystems co.,ltd.
   3
   4 #include <linux/perf_event.h>
   5 #include <linux/uaccess.h>
   6
   7 /* Kernel callchain */
   8 struct stackframe {
   9         unsigned long fp;
  10         unsigned long lr;
  11 };
  12
  13 static int unwind_frame_kernel(struct stackframe *frame)
  14 {
  15         if (kstack_end((void *)frame->fp))
  16                 return -EPERM;
  17         if (frame->fp & 0x3 || frame->fp < TASK_SIZE)
  18                 return -EPERM;
  19
  20         *frame = *(struct stackframe *)frame->fp;
  21         if (__kernel_text_address(frame->lr)) {
  22                 int graph = 0;
  23
  24                 frame->lr = ftrace_graph_ret_addr(NULL, &graph, frame->lr,
  25                                 NULL);
  26         }
  27         return 0;
  28 }
  29
  30 static void notrace walk_stackframe(struct stackframe *fr,
  31                         struct perf_callchain_entry_ctx *entry)
  32 {
  33         do {
  34                 perf_callchain_store(entry, fr->lr);
  35         } while (unwind_frame_kernel(fr) >= 0);
  36 }
  37
  38 /*
  39  * Get the return address for a single stackframe and return a pointer to the
  40  * next frame tail.
  41  */
  42 static unsigned long user_backtrace(struct perf_callchain_entry_ctx *entry,
  43                         unsigned long fp, unsigned long reg_lr)
  44 {
  45         struct stackframe buftail;
  46         unsigned long lr = 0;
  47         unsigned long *user_frame_tail = (unsigned long *)fp;
  48
  49         /* Check accessibility of one struct frame_tail beyond */
  50         if (!access_ok(user_frame_tail, sizeof(buftail)))
  51                 return 0;
  52         if (__copy_from_user_inatomic(&buftail, user_frame_tail,
  53                                       sizeof(buftail)))
  54                 return 0;
  55
  56         if (reg_lr != 0)
  57                 lr = reg_lr;
  58         else
  59                 lr = buftail.lr;
  60
  61         fp = buftail.fp;
  62         perf_callchain_store(entry, lr);
  63
  64         return fp;
  65 }
  66
  67 /*
  68  * This will be called when the target is in user mode
  69  * This function will only be called when we use
  70  * "PERF_SAMPLE_CALLCHAIN" in
  71  * kernel/events/core.c:perf_prepare_sample()
  72  *
  73  * How to trigger perf_callchain_[user/kernel] :
  74  * $ perf record -e cpu-clock --call-graph fp ./program
  75  * $ perf report --call-graph
  76  *
  77  * On C-SKY platform, the program being sampled and the C library
  78  * need to be compiled with * -mbacktrace, otherwise the user
  79  * stack will not contain function frame.
  80  */
  81 void perf_callchain_user(struct perf_callchain_entry_ctx *entry,
  82                          struct pt_regs *regs)
  83 {
  84         unsigned long fp = 0;
  85
  86         /* C-SKY does not support virtualization. */
  87         if (perf_guest_cbs && perf_guest_cbs->is_in_guest())
  88                 return;
  89
  90         fp = regs->regs[4];
  91         perf_callchain_store(entry, regs->pc);
  92
  93         /*
  94          * While backtrace from leaf function, lr is normally
  95          * not saved inside frame on C-SKY, so get lr from pt_regs
  96          * at the sample point. However, lr value can be incorrect if
  97          * lr is used as temp register
  98          */
  99         fp = user_backtrace(entry, fp, regs->lr);
 100
 101         while (fp && !(fp & 0x3) && entry->nr < entry->max_stack)
 102                 fp = user_backtrace(entry, fp, 0);
 103 }
 104
 105 void perf_callchain_kernel(struct perf_callchain_entry_ctx *entry,
 106                            struct pt_regs *regs)
 107 {
 108         struct stackframe fr;
 109
 110         /* C-SKY does not support virtualization. */
 111         if (perf_guest_cbs && perf_guest_cbs->is_in_guest()) {
 112                 pr_warn("C-SKY does not support perf in guest mode!");
 113                 return;
 114         }
 115
 116         fr.fp = regs->regs[4];
 117         fr.lr = regs->lr;
 118         walk_stackframe(&fr, entry);
 119 }