arch/sh/kernel/cpu/sh5/unwind.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * arch/sh/kernel/cpu/sh5/unwind.c
   4  *
   5  * Copyright (C) 2004  Paul Mundt
   6  * Copyright (C) 2004  Richard Curnow
   7  */
   8 #include <linux/kallsyms.h>
   9 #include <linux/kernel.h>
  10 #include <linux/types.h>
  11 #include <linux/errno.h>
  12 #include <asm/page.h>
  13 #include <asm/ptrace.h>
  14 #include <asm/processor.h>
  15 #include <asm/io.h>
  16 #include <asm/unwinder.h>
  17 #include <asm/stacktrace.h>
  18
  19 static u8 regcache[63];
  20
  21 /*
  22  * Finding the previous stack frame isn't horribly straightforward as it is
  23  * on some other platforms. In the sh64 case, we don't have "linked" stack
  24  * frames, so we need to do a bit of work to determine the previous frame,
  25  * and in turn, the previous r14/r18 pair.
  26  *
  27  * There are generally a few cases which determine where we can find out
  28  * the r14/r18 values. In the general case, this can be determined by poking
  29  * around the prologue of the symbol PC is in (note that we absolutely must
  30  * have frame pointer support as well as the kernel symbol table mapped,
  31  * otherwise we can't even get this far).
  32  *
  33  * In other cases, such as the interrupt/exception path, we can poke around
  34  * the sp/fp.
  35  *
  36  * Notably, this entire approach is somewhat error prone, and in the event
  37  * that the previous frame cannot be determined, that's all we can do.
  38  * Either way, this still leaves us with a more correct backtrace then what
  39  * we would be able to come up with by walking the stack (which is garbage
  40  * for anything beyond the first frame).
  41  *                                              -- PFM.
  42  */
  43 static int lookup_prev_stack_frame(unsigned long fp, unsigned long pc,
  44                       unsigned long *pprev_fp, unsigned long *pprev_pc,
  45                       struct pt_regs *regs)
  46 {
  47         const char *sym;
  48         char namebuf[128];
  49         unsigned long offset;
  50         unsigned long prologue = 0;
  51         unsigned long fp_displacement = 0;
  52         unsigned long fp_prev = 0;
  53         unsigned long offset_r14 = 0, offset_r18 = 0;
  54         int i, found_prologue_end = 0;
  55
  56         sym = kallsyms_lookup(pc, NULL, &offset, NULL, namebuf);
  57         if (!sym)
  58                 return -EINVAL;
  59
  60         prologue = pc - offset;
  61         if (!prologue)
  62                 return -EINVAL;
  63
  64         /* Validate fp, to avoid risk of dereferencing a bad pointer later.
  65            Assume 128Mb since that's the amount of RAM on a Cayman.  Modify
  66            when there is an SH-5 board with more. */
  67         if ((fp < (unsigned long) phys_to_virt(__MEMORY_START)) ||
  68             (fp >= (unsigned long)(phys_to_virt(__MEMORY_START)) + 128*1024*1024) ||
  69             ((fp & 7) != 0)) {
  70                 return -EINVAL;
  71         }
  72
  73         /*
  74          * Depth to walk, depth is completely arbitrary.
  75          */
  76         for (i = 0; i < 100; i++, prologue += sizeof(unsigned long)) {
  77                 unsigned long op;
  78                 u8 major, minor;
  79                 u8 src, dest, disp;
  80
  81                 op = *(unsigned long *)prologue;
  82
  83                 major = (op >> 26) & 0x3f;
  84                 src   = (op >> 20) & 0x3f;
  85                 minor = (op >> 16) & 0xf;
  86                 disp  = (op >> 10) & 0x3f;
  87                 dest  = (op >>  4) & 0x3f;
  88
  89                 /*
  90                  * Stack frame creation happens in a number of ways.. in the
  91                  * general case when the stack frame is less than 511 bytes,
  92                  * it's generally created by an addi or addi.l:
  93                  *
  94                  *      addi/addi.l r15, -FRAME_SIZE, r15
  95                  *
  96                  * in the event that the frame size is bigger than this, it's
  97                  * typically created using a movi/sub pair as follows:
  98                  *
  99                  *      movi    FRAME_SIZE, rX
 100                  *      sub     r15, rX, r15
 101                  */
 102
 103                 switch (major) {
 104                 case (0x00 >> 2):
 105                         switch (minor) {
 106                         case 0x8: /* add.l */
 107                         case 0x9: /* add */
 108                                 /* Look for r15, r63, r14 */
 109                                 if (src == 15 && disp == 63 && dest == 14)
 110                                         found_prologue_end = 1;
 111
 112                                 break;
 113                         case 0xa: /* sub.l */
 114                         case 0xb: /* sub */
 115                                 if (src != 15 || dest != 15)
 116                                         continue;
 117
 118                                 fp_displacement -= regcache[disp];
 119                                 fp_prev = fp - fp_displacement;
 120                                 break;
 121                         }
 122                         break;
 123                 case (0xa8 >> 2): /* st.l */
 124                         if (src != 15)
 125                                 continue;
 126
 127                         switch (dest) {
 128                         case 14:
 129                                 if (offset_r14 || fp_displacement == 0)
 130                                         continue;
 131
 132                                 offset_r14 = (u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54);
 133                                 offset_r14 *= sizeof(unsigned long);
 134                                 offset_r14 += fp_displacement;
 135                                 break;
 136                         case 18:
 137                                 if (offset_r18 || fp_displacement == 0)
 138                                         continue;
 139
 140                                 offset_r18 = (u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54);
 141                                 offset_r18 *= sizeof(unsigned long);
 142                                 offset_r18 += fp_displacement;
 143                                 break;
 144                         }
 145
 146                         break;
 147                 case (0xcc >> 2): /* movi */
 148                         if (dest >= 63) {
 149                                 printk(KERN_NOTICE "%s: Invalid dest reg %d "
 150                                        "specified in movi handler. Failed "
 151                                        "opcode was 0x%lx: ", __func__,
 152                                        dest, op);
 153
 154                                 continue;
 155                         }
 156
 157                         /* Sign extend */
 158                         regcache[dest] =
 159                                 sign_extend64((((u64)op >> 10) & 0xffff), 9);
 160                         break;
 161                 case (0xd0 >> 2): /* addi */
 162                 case (0xd4 >> 2): /* addi.l */
 163                         /* Look for r15, -FRAME_SIZE, r15 */
 164                         if (src != 15 || dest != 15)
 165                                 continue;
 166
 167                         /* Sign extended frame size.. */
 168                         fp_displacement +=
 169                                 (u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54);
 170                         fp_prev = fp - fp_displacement;
 171                         break;
 172                 }
 173
 174                 if (found_prologue_end && offset_r14 && (offset_r18 || *pprev_pc) && fp_prev)
 175                         break;
 176         }
 177
 178         if (offset_r14 == 0 || fp_prev == 0) {
 179                 if (!offset_r14)
 180                         pr_debug("Unable to find r14 offset\n");
 181                 if (!fp_prev)
 182                         pr_debug("Unable to find previous fp\n");
 183
 184                 return -EINVAL;
 185         }
 186
 187         /* For innermost leaf function, there might not be a offset_r18 */
 188         if (!*pprev_pc && (offset_r18 == 0))
 189                 return -EINVAL;
 190
 191         *pprev_fp = *(unsigned long *)(fp_prev + offset_r14);
 192
 193         if (offset_r18)
 194                 *pprev_pc = *(unsigned long *)(fp_prev + offset_r18);
 195
 196         *pprev_pc &= ~1;
 197
 198         return 0;
 199 }
 200
 201 /*
 202  * Don't put this on the stack since we'll want to call in to
 203  * sh64_unwinder_dump() when we're close to underflowing the stack
 204  * anyway.
 205  */
 206 static struct pt_regs here_regs;
 207
 208 extern const char syscall_ret;
 209 extern const char ret_from_syscall;
 210 extern const char ret_from_exception;
 211 extern const char ret_from_irq;
 212
 213 static void sh64_unwind_inner(const struct stacktrace_ops *ops,
 214                               void *data, struct pt_regs *regs);
 215
 216 static inline void unwind_nested(const struct stacktrace_ops *ops, void *data,
 217                                  unsigned long pc, unsigned long fp)
 218 {
 219         if ((fp >= __MEMORY_START) &&
 220             ((fp & 7) == 0))
 221                 sh64_unwind_inner(ops, data, (struct pt_regs *)fp);
 222 }
 223
 224 static void sh64_unwind_inner(const struct stacktrace_ops *ops,
 225                               void *data, struct pt_regs *regs)
 226 {
 227         unsigned long pc, fp;
 228         int ofs = 0;
 229         int first_pass;
 230
 231         pc = regs->pc & ~1;
 232         fp = regs->regs[14];
 233
 234         first_pass = 1;
 235         for (;;) {
 236                 int cond;
 237                 unsigned long next_fp, next_pc;
 238
 239                 if (pc == ((unsigned long)&syscall_ret & ~1)) {
 240                         printk("SYSCALL\n");
 241                         unwind_nested(ops, data, pc, fp);
 242                         return;
 243                 }
 244
 245                 if (pc == ((unsigned long)&ret_from_syscall & ~1)) {
 246                         printk("SYSCALL (PREEMPTED)\n");
 247                         unwind_nested(ops, data, pc, fp);
 248                         return;
 249                 }
 250
 251                 /* In this case, the PC is discovered by lookup_prev_stack_frame but
 252                    it has 4 taken off it to look like the 'caller' */
 253                 if (pc == ((unsigned long)&ret_from_exception & ~1)) {
 254                         printk("EXCEPTION\n");
 255                         unwind_nested(ops, data, pc, fp);
 256                         return;
 257                 }
 258
 259                 if (pc == ((unsigned long)&ret_from_irq & ~1)) {
 260                         printk("IRQ\n");
 261                         unwind_nested(ops, data, pc, fp);
 262                         return;
 263                 }
 264
 265                 cond = ((pc >= __MEMORY_START) && (fp >= __MEMORY_START) &&
 266                         ((pc & 3) == 0) && ((fp & 7) == 0));
 267
 268                 pc -= ofs;
 269
 270                 ops->address(data, pc, 1);
 271
 272                 if (first_pass) {
 273                         /* If the innermost frame is a leaf function, it's
 274                          * possible that r18 is never saved out to the stack.
 275                          */
 276                         next_pc = regs->regs[18];
 277                 } else {
 278                         next_pc = 0;
 279                 }
 280
 281                 if (lookup_prev_stack_frame(fp, pc, &next_fp, &next_pc, regs) == 0) {
 282                         ofs = sizeof(unsigned long);
 283                         pc = next_pc & ~1;
 284                         fp = next_fp;
 285                 } else {
 286                         printk("Unable to lookup previous stack frame\n");
 287                         break;
 288                 }
 289                 first_pass = 0;
 290         }
 291
 292         printk("\n");
 293 }
 294
 295 static void sh64_unwinder_dump(struct task_struct *task,
 296                                struct pt_regs *regs,
 297                                unsigned long *sp,
 298                                const struct stacktrace_ops *ops,
 299                                void *data)
 300 {
 301         if (!regs) {
 302                 /*
 303                  * Fetch current regs if we have no other saved state to back
 304                  * trace from.
 305                  */
 306                 regs = &here_regs;
 307
 308                 __asm__ __volatile__ ("ori r14, 0, %0" : "=r" (regs->regs[14]));
 309                 __asm__ __volatile__ ("ori r15, 0, %0" : "=r" (regs->regs[15]));
 310                 __asm__ __volatile__ ("ori r18, 0, %0" : "=r" (regs->regs[18]));
 311
 312                 __asm__ __volatile__ ("gettr tr0, %0" : "=r" (regs->tregs[0]));
 313                 __asm__ __volatile__ ("gettr tr1, %0" : "=r" (regs->tregs[1]));
 314                 __asm__ __volatile__ ("gettr tr2, %0" : "=r" (regs->tregs[2]));
 315                 __asm__ __volatile__ ("gettr tr3, %0" : "=r" (regs->tregs[3]));
 316                 __asm__ __volatile__ ("gettr tr4, %0" : "=r" (regs->tregs[4]));
 317                 __asm__ __volatile__ ("gettr tr5, %0" : "=r" (regs->tregs[5]));
 318                 __asm__ __volatile__ ("gettr tr6, %0" : "=r" (regs->tregs[6]));
 319                 __asm__ __volatile__ ("gettr tr7, %0" : "=r" (regs->tregs[7]));
 320
 321                 __asm__ __volatile__ (
 322                         "pta 0f, tr0\n\t"
 323                         "blink tr0, %0\n\t"
 324                         "0: nop"
 325                         : "=r" (regs->pc)
 326                 );
 327         }
 328
 329         sh64_unwind_inner(ops, data, regs);
 330 }
 331
 332 static struct unwinder sh64_unwinder = {
 333         .name   = "sh64-unwinder",
 334         .dump   = sh64_unwinder_dump,
 335         .rating = 150,
 336 };
 337
 338 static int __init sh64_unwinder_init(void)
 339 {
 340         return unwinder_register(&sh64_unwinder);
 341 }
 342 early_initcall(sh64_unwinder_init);