root/arch/csky/kernel/perf_callchain.c

DEFINITIONS

1. unwind_frame_kernel
2. walk_stackframe
3. user_backtrace
4. perf_callchain_user
5. perf_callchain_kernel

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