root/arch/mips/oprofile/backtrace.c

DEFINITIONS

1. get_mem
2. is_ra_save_ins
3. is_sp_move_ins
4. is_end_of_function_marker
5. unwind_user_frame
6. do_user_backtrace
7. do_kernel_backtrace
8. do_kernel_backtrace
9. op_mips_backtrace

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/oprofile.h>
   3 #include <linux/sched.h>
   4 #include <linux/mm.h>
   5 #include <linux/uaccess.h>
   6 #include <asm/ptrace.h>
   7 #include <asm/stacktrace.h>
   8 #include <linux/stacktrace.h>
   9 #include <linux/kernel.h>
  10 #include <asm/sections.h>
  11 #include <asm/inst.h>
  12 
  13 struct stackframe {
  14         unsigned long sp;
  15         unsigned long pc;
  16         unsigned long ra;
  17 };
  18 
  19 static inline int get_mem(unsigned long addr, unsigned long *result)
  20 {
  21         unsigned long *address = (unsigned long *) addr;
  22         if (!access_ok(address, sizeof(unsigned long)))
  23                 return -1;
  24         if (__copy_from_user_inatomic(result, address, sizeof(unsigned long)))
  25                 return -3;
  26         return 0;
  27 }
  28 
  29 /*
  30  * These two instruction helpers were taken from process.c
  31  */
  32 static inline int is_ra_save_ins(union mips_instruction *ip)
  33 {
  34         /* sw / sd $ra, offset($sp) */
  35         return (ip->i_format.opcode == sw_op || ip->i_format.opcode == sd_op)
  36                 && ip->i_format.rs == 29 && ip->i_format.rt == 31;
  37 }
  38 
  39 static inline int is_sp_move_ins(union mips_instruction *ip)
  40 {
  41         /* addiu/daddiu sp,sp,-imm */
  42         if (ip->i_format.rs != 29 || ip->i_format.rt != 29)
  43                 return 0;
  44         if (ip->i_format.opcode == addiu_op || ip->i_format.opcode == daddiu_op)
  45                 return 1;
  46         return 0;
  47 }
  48 
  49 /*
  50  * Looks for specific instructions that mark the end of a function.
  51  * This usually means we ran into the code area of the previous function.
  52  */
  53 static inline int is_end_of_function_marker(union mips_instruction *ip)
  54 {
  55         /* jr ra */
  56         if (ip->r_format.func == jr_op && ip->r_format.rs == 31)
  57                 return 1;
  58         /* lui gp */
  59         if (ip->i_format.opcode == lui_op && ip->i_format.rt == 28)
  60                 return 1;
  61         return 0;
  62 }
  63 
  64 /*
  65  * TODO for userspace stack unwinding:
  66  * - handle cases where the stack is adjusted inside a function
  67  *     (generally doesn't happen)
  68  * - find optimal value for max_instr_check
  69  * - try to find a better way to handle leaf functions
  70  */
  71 
  72 static inline int unwind_user_frame(struct stackframe *old_frame,
  73                                     const unsigned int max_instr_check)
  74 {
  75         struct stackframe new_frame = *old_frame;
  76         off_t ra_offset = 0;
  77         size_t stack_size = 0;
  78         unsigned long addr;
  79 
  80         if (old_frame->pc == 0 || old_frame->sp == 0 || old_frame->ra == 0)
  81                 return -9;
  82 
  83         for (addr = new_frame.pc; (addr + max_instr_check > new_frame.pc)
  84                 && (!ra_offset || !stack_size); --addr) {
  85                 union mips_instruction ip;
  86 
  87                 if (get_mem(addr, (unsigned long *) &ip))
  88                         return -11;
  89 
  90                 if (is_sp_move_ins(&ip)) {
  91                         int stack_adjustment = ip.i_format.simmediate;
  92                         if (stack_adjustment > 0)
  93                                 /* This marks the end of the previous function,
  94                                    which means we overran. */
  95                                 break;
  96                         stack_size = (unsigned long) stack_adjustment;
  97                 } else if (is_ra_save_ins(&ip)) {
  98                         int ra_slot = ip.i_format.simmediate;
  99                         if (ra_slot < 0)
 100                                 /* This shouldn't happen. */
 101                                 break;
 102                         ra_offset = ra_slot;
 103                 } else if (is_end_of_function_marker(&ip))
 104                         break;
 105         }
 106 
 107         if (!ra_offset || !stack_size)
 108                 goto done;
 109 
 110         if (ra_offset) {
 111                 new_frame.ra = old_frame->sp + ra_offset;
 112                 if (get_mem(new_frame.ra, &(new_frame.ra)))
 113                         return -13;
 114         }
 115 
 116         if (stack_size) {
 117                 new_frame.sp = old_frame->sp + stack_size;
 118                 if (get_mem(new_frame.sp, &(new_frame.sp)))
 119                         return -14;
 120         }
 121 
 122         if (new_frame.sp > old_frame->sp)
 123                 return -2;
 124 
 125 done:
 126         new_frame.pc = old_frame->ra;
 127         *old_frame = new_frame;
 128 
 129         return 0;
 130 }
 131 
 132 static inline void do_user_backtrace(unsigned long low_addr,
 133                                      struct stackframe *frame,
 134                                      unsigned int depth)
 135 {
 136         const unsigned int max_instr_check = 512;
 137         const unsigned long high_addr = low_addr + THREAD_SIZE;
 138 
 139         while (depth-- && !unwind_user_frame(frame, max_instr_check)) {
 140                 oprofile_add_trace(frame->ra);
 141                 if (frame->sp < low_addr || frame->sp > high_addr)
 142                         break;
 143         }
 144 }
 145 
 146 #ifndef CONFIG_KALLSYMS
 147 static inline void do_kernel_backtrace(unsigned long low_addr,
 148                                        struct stackframe *frame,
 149                                        unsigned int depth) { }
 150 #else
 151 static inline void do_kernel_backtrace(unsigned long low_addr,
 152                                        struct stackframe *frame,
 153                                        unsigned int depth)
 154 {
 155         while (depth-- && frame->pc) {
 156                 frame->pc = unwind_stack_by_address(low_addr,
 157                                                     &(frame->sp),
 158                                                     frame->pc,
 159                                                     &(frame->ra));
 160                 oprofile_add_trace(frame->ra);
 161         }
 162 }
 163 #endif
 164 
 165 void notrace op_mips_backtrace(struct pt_regs *const regs, unsigned int depth)
 166 {
 167         struct stackframe frame = { .sp = regs->regs[29],
 168                                     .pc = regs->cp0_epc,
 169                                     .ra = regs->regs[31] };
 170         const int userspace = user_mode(regs);
 171         const unsigned long low_addr = ALIGN(frame.sp, THREAD_SIZE);
 172 
 173         if (userspace)
 174                 do_user_backtrace(low_addr, &frame, depth);
 175         else
 176                 do_kernel_backtrace(low_addr, &frame, depth);
 177 }