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