arch/parisc/kernel/unwind.c

   1 /*
   2  * Kernel unwinding support
   3  *
   4  * (c) 2002-2004 Randolph Chung <tausq@debian.org>
   5  *
   6  * Derived partially from the IA64 implementation. The PA-RISC
   7  * Runtime Architecture Document is also a useful reference to
   8  * understand what is happening here
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/slab.h>
  14 #include <linux/kallsyms.h>
  15
  16 #include <asm/uaccess.h>
  17 #include <asm/assembly.h>
  18
  19 #include <asm/unwind.h>
  20
  21 /* #define DEBUG 1 */
  22 #ifdef DEBUG
  23 #define dbg(x...) printk(x)
  24 #else
  25 #define dbg(x...)
  26 #endif
  27
  28 extern struct unwind_table_entry __start___unwind[];
  29 extern struct unwind_table_entry __stop___unwind[];
  30
  31 static spinlock_t unwind_lock;
  32 /*
  33  * the kernel unwind block is not dynamically allocated so that
  34  * we can call unwind_init as early in the bootup process as
  35  * possible (before the slab allocator is initialized)
  36  */
  37 static struct unwind_table kernel_unwind_table __read_mostly;
  38 static LIST_HEAD(unwind_tables);
  39
  40 static inline const struct unwind_table_entry *
  41 find_unwind_entry_in_table(const struct unwind_table *table, unsigned long addr)
  42 {
  43         const struct unwind_table_entry *e = NULL;
  44         unsigned long lo, hi, mid;
  45
  46         lo = 0;
  47         hi = table->length - 1;
  48
  49         while (lo <= hi) {
  50                 mid = (hi - lo) / 2 + lo;
  51                 e = &table->table[mid];
  52                 if (addr < e->region_start)
  53                         hi = mid - 1;
  54                 else if (addr > e->region_end)
  55                         lo = mid + 1;
  56                 else
  57                         return e;
  58         }
  59
  60         return NULL;
  61 }
  62
  63 static const struct unwind_table_entry *
  64 find_unwind_entry(unsigned long addr)
  65 {
  66         struct unwind_table *table;
  67         const struct unwind_table_entry *e = NULL;
  68
  69         if (addr >= kernel_unwind_table.start &&
  70             addr <= kernel_unwind_table.end)
  71                 e = find_unwind_entry_in_table(&kernel_unwind_table, addr);
  72         else
  73                 list_for_each_entry(table, &unwind_tables, list) {
  74                         if (addr >= table->start &&
  75                             addr <= table->end)
  76                                 e = find_unwind_entry_in_table(table, addr);
  77                         if (e)
  78                                 break;
  79                 }
  80
  81         return e;
  82 }
  83
  84 static void
  85 unwind_table_init(struct unwind_table *table, const char *name,
  86                   unsigned long base_addr, unsigned long gp,
  87                   void *table_start, void *table_end)
  88 {
  89         struct unwind_table_entry *start = table_start;
  90         struct unwind_table_entry *end =
  91                 (struct unwind_table_entry *)table_end - 1;
  92
  93         table->name = name;
  94         table->base_addr = base_addr;
  95         table->gp = gp;
  96         table->start = base_addr + start->region_start;
  97         table->end = base_addr + end->region_end;
  98         table->table = (struct unwind_table_entry *)table_start;
  99         table->length = end - start + 1;
 100         INIT_LIST_HEAD(&table->list);
 101
 102         for (; start <= end; start++) {
 103                 if (start < end &&
 104                     start->region_end > (start+1)->region_start) {
 105                         printk("WARNING: Out of order unwind entry! %p and %p\n", start, start+1);
 106                 }
 107
 108                 start->region_start += base_addr;
 109                 start->region_end += base_addr;
 110         }
 111 }
 112
 113 static void
 114 unwind_table_sort(struct unwind_table_entry *start,
 115                   struct unwind_table_entry *finish)
 116 {
 117         struct unwind_table_entry el, *p, *q;
 118
 119         for (p = start + 1; p < finish; ++p) {
 120                 if (p[0].region_start < p[-1].region_start) {
 121                         el = *p;
 122                         q = p;
 123                         do {
 124                                 q[0] = q[-1];
 125                                 --q;
 126                         } while (q > start &&
 127                                  el.region_start < q[-1].region_start);
 128                         *q = el;
 129                 }
 130         }
 131 }
 132
 133 struct unwind_table *
 134 unwind_table_add(const char *name, unsigned long base_addr,
 135                  unsigned long gp,
 136                  void *start, void *end)
 137 {
 138         struct unwind_table *table;
 139         unsigned long flags;
 140         struct unwind_table_entry *s = (struct unwind_table_entry *)start;
 141         struct unwind_table_entry *e = (struct unwind_table_entry *)end;
 142
 143         unwind_table_sort(s, e);
 144
 145         table = kmalloc(sizeof(struct unwind_table), GFP_USER);
 146         if (table == NULL)
 147                 return NULL;
 148         unwind_table_init(table, name, base_addr, gp, start, end);
 149         spin_lock_irqsave(&unwind_lock, flags);
 150         list_add_tail(&table->list, &unwind_tables);
 151         spin_unlock_irqrestore(&unwind_lock, flags);
 152
 153         return table;
 154 }
 155
 156 void unwind_table_remove(struct unwind_table *table)
 157 {
 158         unsigned long flags;
 159
 160         spin_lock_irqsave(&unwind_lock, flags);
 161         list_del(&table->list);
 162         spin_unlock_irqrestore(&unwind_lock, flags);
 163
 164         kfree(table);
 165 }
 166
 167 /* Called from setup_arch to import the kernel unwind info */
 168 static int unwind_init(void)
 169 {
 170         long start, stop;
 171         register unsigned long gp __asm__ ("r27");
 172
 173         start = (long)&__start___unwind[0];
 174         stop = (long)&__stop___unwind[0];
 175
 176         spin_lock_init(&unwind_lock);
 177
 178         printk("unwind_init: start = 0x%lx, end = 0x%lx, entries = %lu\n",
 179             start, stop,
 180             (stop - start) / sizeof(struct unwind_table_entry));
 181
 182         unwind_table_init(&kernel_unwind_table, "kernel", KERNEL_START,
 183                           gp,
 184                           &__start___unwind[0], &__stop___unwind[0]);
 185 #if 0
 186         {
 187                 int i;
 188                 for (i = 0; i < 10; i++)
 189                 {
 190                         printk("region 0x%x-0x%x\n",
 191                                 __start___unwind[i].region_start,
 192                                 __start___unwind[i].region_end);
 193                 }
 194         }
 195 #endif
 196         return 0;
 197 }
 198
 199 static void unwind_frame_regs(struct unwind_frame_info *info)
 200 {
 201         const struct unwind_table_entry *e;
 202         unsigned long npc;
 203         unsigned int insn;
 204         long frame_size = 0;
 205         int looking_for_rp, rpoffset = 0;
 206
 207         e = find_unwind_entry(info->ip);
 208         if (e == NULL) {
 209                 unsigned long sp;
 210                 extern char _stext[], _etext[];
 211
 212                 dbg("Cannot find unwind entry for 0x%lx; forced unwinding\n", info->ip);
 213
 214 #ifdef CONFIG_KALLSYMS
 215                 /* Handle some frequent special cases.... */
 216                 {
 217                         char symname[KSYM_NAME_LEN+1];
 218                         char *modname;
 219                         unsigned long symsize, offset;
 220
 221                         kallsyms_lookup(info->ip, &symsize, &offset,
 222                                         &modname, symname);
 223
 224                         dbg("info->ip = 0x%lx, name = %s\n", info->ip, symname);
 225
 226                         if (strcmp(symname, "_switch_to_ret") == 0) {
 227                                 info->prev_sp = info->sp - CALLEE_SAVE_FRAME_SIZE;
 228                                 info->prev_ip = *(unsigned long *)(info->prev_sp - RP_OFFSET);
 229                                 dbg("_switch_to_ret @ %lx - setting "
 230                                     "prev_sp=%lx prev_ip=%lx\n",
 231                                     info->ip, info->prev_sp,
 232                                     info->prev_ip);
 233                                 return;
 234                         } else if (strcmp(symname, "ret_from_kernel_thread") == 0 ||
 235                                    strcmp(symname, "syscall_exit") == 0) {
 236                                 info->prev_ip = info->prev_sp = 0;
 237                                 return;
 238                         }
 239                 }
 240 #endif
 241
 242                 /* Since we are doing the unwinding blind, we don't know if
 243                    we are adjusting the stack correctly or extracting the rp
 244                    correctly. The rp is checked to see if it belongs to the
 245                    kernel text section, if not we assume we don't have a
 246                    correct stack frame and we continue to unwind the stack.
 247                    This is not quite correct, and will fail for loadable
 248                    modules. */
 249                 sp = info->sp & ~63;
 250                 do {
 251                         unsigned long tmp;
 252
 253                         info->prev_sp = sp - 64;
 254                         info->prev_ip = 0;
 255                         if (get_user(tmp, (unsigned long *)(info->prev_sp - RP_OFFSET)))
 256                                 break;
 257                         info->prev_ip = tmp;
 258                         sp = info->prev_sp;
 259                 } while (info->prev_ip < (unsigned long)_stext ||
 260                          info->prev_ip > (unsigned long)_etext);
 261
 262                 info->rp = 0;
 263
 264                 dbg("analyzing func @ %lx with no unwind info, setting "
 265                     "prev_sp=%lx prev_ip=%lx\n", info->ip,
 266                     info->prev_sp, info->prev_ip);
 267         } else {
 268                 dbg("e->start = 0x%x, e->end = 0x%x, Save_SP = %d, "
 269                     "Save_RP = %d, Millicode = %d size = %u\n",
 270                     e->region_start, e->region_end, e->Save_SP, e->Save_RP,
 271                     e->Millicode, e->Total_frame_size);
 272
 273                 looking_for_rp = e->Save_RP;
 274
 275                 for (npc = e->region_start;
 276                      (frame_size < (e->Total_frame_size << 3) ||
 277                       looking_for_rp) &&
 278                      npc < info->ip;
 279                      npc += 4) {
 280
 281                         insn = *(unsigned int *)npc;
 282
 283                         if ((insn & 0xffffc000) == 0x37de0000 ||
 284                             (insn & 0xffe00000) == 0x6fc00000) {
 285                                 /* ldo X(sp), sp, or stwm X,D(sp) */
 286                                 frame_size += (insn & 0x1 ? -1 << 13 : 0) |
 287                                         ((insn & 0x3fff) >> 1);
 288                                 dbg("analyzing func @ %lx, insn=%08x @ "
 289                                     "%lx, frame_size = %ld\n", info->ip,
 290                                     insn, npc, frame_size);
 291                         } else if ((insn & 0xffe00008) == 0x73c00008) {
 292                                 /* std,ma X,D(sp) */
 293                                 frame_size += (insn & 0x1 ? -1 << 13 : 0) |
 294                                         (((insn >> 4) & 0x3ff) << 3);
 295                                 dbg("analyzing func @ %lx, insn=%08x @ "
 296                                     "%lx, frame_size = %ld\n", info->ip,
 297                                     insn, npc, frame_size);
 298                         } else if (insn == 0x6bc23fd9) {
 299                                 /* stw rp,-20(sp) */
 300                                 rpoffset = 20;
 301                                 looking_for_rp = 0;
 302                                 dbg("analyzing func @ %lx, insn=stw rp,"
 303                                     "-20(sp) @ %lx\n", info->ip, npc);
 304                         } else if (insn == 0x0fc212c1) {
 305                                 /* std rp,-16(sr0,sp) */
 306                                 rpoffset = 16;
 307                                 looking_for_rp = 0;
 308                                 dbg("analyzing func @ %lx, insn=std rp,"
 309                                     "-16(sp) @ %lx\n", info->ip, npc);
 310                         }
 311                 }
 312
 313                 info->prev_sp = info->sp - frame_size;
 314                 if (e->Millicode)
 315                         info->rp = info->r31;
 316                 else if (rpoffset)
 317                         info->rp = *(unsigned long *)(info->prev_sp - rpoffset);
 318                 info->prev_ip = info->rp;
 319                 info->rp = 0;
 320
 321                 dbg("analyzing func @ %lx, setting prev_sp=%lx "
 322                     "prev_ip=%lx npc=%lx\n", info->ip, info->prev_sp,
 323                     info->prev_ip, npc);
 324         }
 325 }
 326
 327 void unwind_frame_init(struct unwind_frame_info *info, struct task_struct *t,
 328                        struct pt_regs *regs)
 329 {
 330         memset(info, 0, sizeof(struct unwind_frame_info));
 331         info->t = t;
 332         info->sp = regs->gr[30];
 333         info->ip = regs->iaoq[0];
 334         info->rp = regs->gr[2];
 335         info->r31 = regs->gr[31];
 336
 337         dbg("(%d) Start unwind from sp=%08lx ip=%08lx\n",
 338             t ? (int)t->pid : -1, info->sp, info->ip);
 339 }
 340
 341 void unwind_frame_init_from_blocked_task(struct unwind_frame_info *info, struct task_struct *t)
 342 {
 343         struct pt_regs *r = &t->thread.regs;
 344         struct pt_regs *r2;
 345
 346         r2 = (struct pt_regs *)kmalloc(sizeof(struct pt_regs), GFP_KERNEL);
 347         if (!r2)
 348                 return;
 349         *r2 = *r;
 350         r2->gr[30] = r->ksp;
 351         r2->iaoq[0] = r->kpc;
 352         unwind_frame_init(info, t, r2);
 353         kfree(r2);
 354 }
 355
 356 void unwind_frame_init_running(struct unwind_frame_info *info, struct pt_regs *regs)
 357 {
 358         unwind_frame_init(info, current, regs);
 359 }
 360
 361 int unwind_once(struct unwind_frame_info *next_frame)
 362 {
 363         unwind_frame_regs(next_frame);
 364
 365         if (next_frame->prev_sp == 0 ||
 366             next_frame->prev_ip == 0)
 367                 return -1;
 368
 369         next_frame->sp = next_frame->prev_sp;
 370         next_frame->ip = next_frame->prev_ip;
 371         next_frame->prev_sp = 0;
 372         next_frame->prev_ip = 0;
 373
 374         dbg("(%d) Continue unwind to sp=%08lx ip=%08lx\n",
 375             next_frame->t ? (int)next_frame->t->pid : -1,
 376             next_frame->sp, next_frame->ip);
 377
 378         return 0;
 379 }
 380
 381 int unwind_to_user(struct unwind_frame_info *info)
 382 {
 383         int ret;
 384
 385         do {
 386                 ret = unwind_once(info);
 387         } while (!ret && !(info->ip & 3));
 388
 389         return ret;
 390 }
 391
 392 module_init(unwind_init);