arch/tile/kernel/stack.c

   1 /*
   2  * Copyright 2010 Tilera Corporation. All Rights Reserved.
   3  *
   4  *   This program is free software; you can redistribute it and/or
   5  *   modify it under the terms of the GNU General Public License
   6  *   as published by the Free Software Foundation, version 2.
   7  *
   8  *   This program is distributed in the hope that it will be useful, but
   9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  11  *   NON INFRINGEMENT.  See the GNU General Public License for
  12  *   more details.
  13  */
  14
  15 #include <linux/sched.h>
  16 #include <linux/kernel.h>
  17 #include <linux/kprobes.h>
  18 #include <linux/module.h>
  19 #include <linux/pfn.h>
  20 #include <linux/kallsyms.h>
  21 #include <linux/stacktrace.h>
  22 #include <linux/uaccess.h>
  23 #include <linux/mmzone.h>
  24 #include <asm/backtrace.h>
  25 #include <asm/page.h>
  26 #include <asm/tlbflush.h>
  27 #include <asm/ucontext.h>
  28 #include <asm/sigframe.h>
  29 #include <asm/stack.h>
  30 #include <arch/abi.h>
  31 #include <arch/interrupts.h>
  32
  33 #define KBT_ONGOING     0  /* Backtrace still ongoing */
  34 #define KBT_DONE        1  /* Backtrace cleanly completed */
  35 #define KBT_RUNNING     2  /* Can't run backtrace on a running task */
  36 #define KBT_LOOP        3  /* Backtrace entered a loop */
  37
  38 /* Is address on the specified kernel stack? */
  39 static int in_kernel_stack(struct KBacktraceIterator *kbt, unsigned long sp)
  40 {
  41         ulong kstack_base = (ulong) kbt->task->stack;
  42         if (kstack_base == 0)  /* corrupt task pointer; just follow stack... */
  43                 return sp >= PAGE_OFFSET && sp < (unsigned long)high_memory;
  44         return sp >= kstack_base && sp < kstack_base + THREAD_SIZE;
  45 }
  46
  47 /* Is address valid for reading? */
  48 static int valid_address(struct KBacktraceIterator *kbt, unsigned long address)
  49 {
  50         HV_PTE *l1_pgtable = kbt->pgtable;
  51         HV_PTE *l2_pgtable;
  52         unsigned long pfn;
  53         HV_PTE pte;
  54         struct page *page;
  55
  56         if (l1_pgtable == NULL)
  57                 return 0;       /* can't read user space in other tasks */
  58
  59 #ifdef CONFIG_64BIT
  60         /* Find the real l1_pgtable by looking in the l0_pgtable. */
  61         pte = l1_pgtable[HV_L0_INDEX(address)];
  62         if (!hv_pte_get_present(pte))
  63                 return 0;
  64         pfn = hv_pte_get_pfn(pte);
  65         if (pte_huge(pte)) {
  66                 if (!pfn_valid(pfn)) {
  67                         pr_err("L0 huge page has bad pfn %#lx\n", pfn);
  68                         return 0;
  69                 }
  70                 return hv_pte_get_present(pte) && hv_pte_get_readable(pte);
  71         }
  72         page = pfn_to_page(pfn);
  73         BUG_ON(PageHighMem(page));  /* No HIGHMEM on 64-bit. */
  74         l1_pgtable = (HV_PTE *)pfn_to_kaddr(pfn);
  75 #endif
  76         pte = l1_pgtable[HV_L1_INDEX(address)];
  77         if (!hv_pte_get_present(pte))
  78                 return 0;
  79         pfn = hv_pte_get_pfn(pte);
  80         if (pte_huge(pte)) {
  81                 if (!pfn_valid(pfn)) {
  82                         pr_err("huge page has bad pfn %#lx\n", pfn);
  83                         return 0;
  84                 }
  85                 return hv_pte_get_present(pte) && hv_pte_get_readable(pte);
  86         }
  87
  88         page = pfn_to_page(pfn);
  89         if (PageHighMem(page)) {
  90                 pr_err("L2 page table not in LOWMEM (%#llx)\n",
  91                        HV_PFN_TO_CPA(pfn));
  92                 return 0;
  93         }
  94         l2_pgtable = (HV_PTE *)pfn_to_kaddr(pfn);
  95         pte = l2_pgtable[HV_L2_INDEX(address)];
  96         return hv_pte_get_present(pte) && hv_pte_get_readable(pte);
  97 }
  98
  99 /* Callback for backtracer; basically a glorified memcpy */
 100 static bool read_memory_func(void *result, unsigned long address,
 101                              unsigned int size, void *vkbt)
 102 {
 103         int retval;
 104         struct KBacktraceIterator *kbt = (struct KBacktraceIterator *)vkbt;
 105         if (__kernel_text_address(address)) {
 106                 /* OK to read kernel code. */
 107         } else if (address >= PAGE_OFFSET) {
 108                 /* We only tolerate kernel-space reads of this task's stack */
 109                 if (!in_kernel_stack(kbt, address))
 110                         return 0;
 111         } else if (!valid_address(kbt, address)) {
 112                 return 0;       /* invalid user-space address */
 113         }
 114         pagefault_disable();
 115         retval = __copy_from_user_inatomic(result,
 116                                            (void __user __force *)address,
 117                                            size);
 118         pagefault_enable();
 119         return (retval == 0);
 120 }
 121
 122 /* Return a pt_regs pointer for a valid fault handler frame */
 123 static struct pt_regs *valid_fault_handler(struct KBacktraceIterator* kbt)
 124 {
 125         const char *fault = NULL;  /* happy compiler */
 126         char fault_buf[64];
 127         unsigned long sp = kbt->it.sp;
 128         struct pt_regs *p;
 129
 130         if (!in_kernel_stack(kbt, sp))
 131                 return NULL;
 132         if (!in_kernel_stack(kbt, sp + C_ABI_SAVE_AREA_SIZE + PTREGS_SIZE-1))
 133                 return NULL;
 134         p = (struct pt_regs *)(sp + C_ABI_SAVE_AREA_SIZE);
 135         if (p->faultnum == INT_SWINT_1 || p->faultnum == INT_SWINT_1_SIGRETURN)
 136                 fault = "syscall";
 137         else {
 138                 if (kbt->verbose) {     /* else we aren't going to use it */
 139                         snprintf(fault_buf, sizeof(fault_buf),
 140                                  "interrupt %ld", p->faultnum);
 141                         fault = fault_buf;
 142                 }
 143         }
 144         if (EX1_PL(p->ex1) == KERNEL_PL &&
 145             __kernel_text_address(p->pc) &&
 146             in_kernel_stack(kbt, p->sp) &&
 147             p->sp >= sp) {
 148                 if (kbt->verbose)
 149                         pr_err("  <%s while in kernel mode>\n", fault);
 150         } else if (EX1_PL(p->ex1) == USER_PL &&
 151             p->pc < PAGE_OFFSET &&
 152             p->sp < PAGE_OFFSET) {
 153                 if (kbt->verbose)
 154                         pr_err("  <%s while in user mode>\n", fault);
 155         } else if (kbt->verbose) {
 156                 pr_err("  (odd fault: pc %#lx, sp %#lx, ex1 %#lx?)\n",
 157                        p->pc, p->sp, p->ex1);
 158                 p = NULL;
 159         }
 160         if (!kbt->profile || (INT_MASK(p->faultnum) & QUEUED_INTERRUPTS) == 0)
 161                 return p;
 162         return NULL;
 163 }
 164
 165 /* Is the pc pointing to a sigreturn trampoline? */
 166 static int is_sigreturn(unsigned long pc)
 167 {
 168         return (pc == VDSO_BASE);
 169 }
 170
 171 /* Return a pt_regs pointer for a valid signal handler frame */
 172 static struct pt_regs *valid_sigframe(struct KBacktraceIterator* kbt)
 173 {
 174         BacktraceIterator *b = &kbt->it;
 175
 176         if (b->pc == VDSO_BASE) {
 177                 struct rt_sigframe *frame;
 178                 unsigned long sigframe_top =
 179                         b->sp + sizeof(struct rt_sigframe) - 1;
 180                 if (!valid_address(kbt, b->sp) ||
 181                     !valid_address(kbt, sigframe_top)) {
 182                         if (kbt->verbose)
 183                                 pr_err("  (odd signal: sp %#lx?)\n",
 184                                        (unsigned long)(b->sp));
 185                         return NULL;
 186                 }
 187                 frame = (struct rt_sigframe *)b->sp;
 188                 if (kbt->verbose) {
 189                         pr_err("  <received signal %d>\n",
 190                                frame->info.si_signo);
 191                 }
 192                 return (struct pt_regs *)&frame->uc.uc_mcontext;
 193         }
 194         return NULL;
 195 }
 196
 197 static int KBacktraceIterator_is_sigreturn(struct KBacktraceIterator *kbt)
 198 {
 199         return is_sigreturn(kbt->it.pc);
 200 }
 201
 202 static int KBacktraceIterator_restart(struct KBacktraceIterator *kbt)
 203 {
 204         struct pt_regs *p;
 205
 206         p = valid_fault_handler(kbt);
 207         if (p == NULL)
 208                 p = valid_sigframe(kbt);
 209         if (p == NULL)
 210                 return 0;
 211         backtrace_init(&kbt->it, read_memory_func, kbt,
 212                        p->pc, p->lr, p->sp, p->regs[52]);
 213         kbt->new_context = 1;
 214         return 1;
 215 }
 216
 217 /* Find a frame that isn't a sigreturn, if there is one. */
 218 static int KBacktraceIterator_next_item_inclusive(
 219         struct KBacktraceIterator *kbt)
 220 {
 221         for (;;) {
 222                 do {
 223                         if (!KBacktraceIterator_is_sigreturn(kbt))
 224                                 return KBT_ONGOING;
 225                 } while (backtrace_next(&kbt->it));
 226
 227                 if (!KBacktraceIterator_restart(kbt))
 228                         return KBT_DONE;
 229         }
 230 }
 231
 232 /*
 233  * If the current sp is on a page different than what we recorded
 234  * as the top-of-kernel-stack last time we context switched, we have
 235  * probably blown the stack, and nothing is going to work out well.
 236  * If we can at least get out a warning, that may help the debug,
 237  * though we probably won't be able to backtrace into the code that
 238  * actually did the recursive damage.
 239  */
 240 static void validate_stack(struct pt_regs *regs)
 241 {
 242         int cpu = smp_processor_id();
 243         unsigned long ksp0 = get_current_ksp0();
 244         unsigned long ksp0_base = ksp0 - THREAD_SIZE;
 245         unsigned long sp = stack_pointer;
 246
 247         if (EX1_PL(regs->ex1) == KERNEL_PL && regs->sp >= ksp0) {
 248                 pr_err("WARNING: cpu %d: kernel stack page %#lx underrun!\n"
 249                        "  sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
 250                        cpu, ksp0_base, sp, regs->sp, regs->pc, regs->lr);
 251         }
 252
 253         else if (sp < ksp0_base + sizeof(struct thread_info)) {
 254                 pr_err("WARNING: cpu %d: kernel stack page %#lx overrun!\n"
 255                        "  sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
 256                        cpu, ksp0_base, sp, regs->sp, regs->pc, regs->lr);
 257         }
 258 }
 259
 260 void KBacktraceIterator_init(struct KBacktraceIterator *kbt,
 261                              struct task_struct *t, struct pt_regs *regs)
 262 {
 263         unsigned long pc, lr, sp, r52;
 264         int is_current;
 265
 266         /*
 267          * Set up callback information.  We grab the kernel stack base
 268          * so we will allow reads of that address range, and if we're
 269          * asking about the current process we grab the page table
 270          * so we can check user accesses before trying to read them.
 271          * We flush the TLB to avoid any weird skew issues.
 272          */
 273         is_current = (t == NULL);
 274         kbt->is_current = is_current;
 275         if (is_current)
 276                 t = validate_current();
 277         kbt->task = t;
 278         kbt->pgtable = NULL;
 279         kbt->verbose = 0;   /* override in caller if desired */
 280         kbt->profile = 0;   /* override in caller if desired */
 281         kbt->end = KBT_ONGOING;
 282         kbt->new_context = 0;
 283         if (is_current) {
 284                 HV_PhysAddr pgdir_pa = hv_inquire_context().page_table;
 285                 if (pgdir_pa == (unsigned long)swapper_pg_dir - PAGE_OFFSET) {
 286                         /*
 287                          * Not just an optimization: this also allows
 288                          * this to work at all before va/pa mappings
 289                          * are set up.
 290                          */
 291                         kbt->pgtable = swapper_pg_dir;
 292                 } else {
 293                         struct page *page = pfn_to_page(PFN_DOWN(pgdir_pa));
 294                         if (!PageHighMem(page))
 295                                 kbt->pgtable = __va(pgdir_pa);
 296                         else
 297                                 pr_err("page table not in LOWMEM"
 298                                        " (%#llx)\n", pgdir_pa);
 299                 }
 300                 local_flush_tlb_all();
 301                 validate_stack(regs);
 302         }
 303
 304         if (regs == NULL) {
 305                 if (is_current || t->state == TASK_RUNNING) {
 306                         /* Can't do this; we need registers */
 307                         kbt->end = KBT_RUNNING;
 308                         return;
 309                 }
 310                 pc = get_switch_to_pc();
 311                 lr = t->thread.pc;
 312                 sp = t->thread.ksp;
 313                 r52 = 0;
 314         } else {
 315                 pc = regs->pc;
 316                 lr = regs->lr;
 317                 sp = regs->sp;
 318                 r52 = regs->regs[52];
 319         }
 320
 321         backtrace_init(&kbt->it, read_memory_func, kbt, pc, lr, sp, r52);
 322         kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
 323 }
 324 EXPORT_SYMBOL(KBacktraceIterator_init);
 325
 326 int KBacktraceIterator_end(struct KBacktraceIterator *kbt)
 327 {
 328         return kbt->end != KBT_ONGOING;
 329 }
 330 EXPORT_SYMBOL(KBacktraceIterator_end);
 331
 332 void KBacktraceIterator_next(struct KBacktraceIterator *kbt)
 333 {
 334         unsigned long old_pc = kbt->it.pc, old_sp = kbt->it.sp;
 335         kbt->new_context = 0;
 336         if (!backtrace_next(&kbt->it) && !KBacktraceIterator_restart(kbt)) {
 337                 kbt->end = KBT_DONE;
 338                 return;
 339         }
 340         kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
 341         if (old_pc == kbt->it.pc && old_sp == kbt->it.sp) {
 342                 /* Trapped in a loop; give up. */
 343                 kbt->end = KBT_LOOP;
 344         }
 345 }
 346 EXPORT_SYMBOL(KBacktraceIterator_next);
 347
 348 /*
 349  * This method wraps the backtracer's more generic support.
 350  * It is only invoked from the architecture-specific code; show_stack()
 351  * and dump_stack() (in entry.S) are architecture-independent entry points.
 352  */
 353 void tile_show_stack(struct KBacktraceIterator *kbt, int headers)
 354 {
 355         int i;
 356
 357         if (headers) {
 358                 /*
 359                  * Add a blank line since if we are called from panic(),
 360                  * then bust_spinlocks() spit out a space in front of us
 361                  * and it will mess up our KERN_ERR.
 362                  */
 363                 pr_err("\n");
 364                 pr_err("Starting stack dump of tid %d, pid %d (%s)"
 365                        " on cpu %d at cycle %lld\n",
 366                        kbt->task->pid, kbt->task->tgid, kbt->task->comm,
 367                        smp_processor_id(), get_cycles());
 368         }
 369         kbt->verbose = 1;
 370         i = 0;
 371         for (; !KBacktraceIterator_end(kbt); KBacktraceIterator_next(kbt)) {
 372                 char *modname;
 373                 const char *name;
 374                 unsigned long address = kbt->it.pc;
 375                 unsigned long offset, size;
 376                 char namebuf[KSYM_NAME_LEN+100];
 377
 378                 if (address >= PAGE_OFFSET)
 379                         name = kallsyms_lookup(address, &size, &offset,
 380                                                &modname, namebuf);
 381                 else
 382                         name = NULL;
 383
 384                 if (!name)
 385                         namebuf[0] = '\0';
 386                 else {
 387                         size_t namelen = strlen(namebuf);
 388                         size_t remaining = (sizeof(namebuf) - 1) - namelen;
 389                         char *p = namebuf + namelen;
 390                         int rc = snprintf(p, remaining, "+%#lx/%#lx ",
 391                                           offset, size);
 392                         if (modname && rc < remaining)
 393                                 snprintf(p + rc, remaining - rc,
 394                                          "[%s] ", modname);
 395                         namebuf[sizeof(namebuf)-1] = '\0';
 396                 }
 397
 398                 pr_err("  frame %d: 0x%lx %s(sp 0x%lx)\n",
 399                        i++, address, namebuf, (unsigned long)(kbt->it.sp));
 400
 401                 if (i >= 100) {
 402                         pr_err("Stack dump truncated"
 403                                " (%d frames)\n", i);
 404                         break;
 405                 }
 406         }
 407         if (kbt->end == KBT_LOOP)
 408                 pr_err("Stack dump stopped; next frame identical to this one\n");
 409         if (headers)
 410                 pr_err("Stack dump complete\n");
 411 }
 412 EXPORT_SYMBOL(tile_show_stack);
 413
 414
 415 /* This is called from show_regs() and _dump_stack() */
 416 void dump_stack_regs(struct pt_regs *regs)
 417 {
 418         struct KBacktraceIterator kbt;
 419         KBacktraceIterator_init(&kbt, NULL, regs);
 420         tile_show_stack(&kbt, 1);
 421 }
 422 EXPORT_SYMBOL(dump_stack_regs);
 423
 424 static struct pt_regs *regs_to_pt_regs(struct pt_regs *regs,
 425                                        ulong pc, ulong lr, ulong sp, ulong r52)
 426 {
 427         memset(regs, 0, sizeof(struct pt_regs));
 428         regs->pc = pc;
 429         regs->lr = lr;
 430         regs->sp = sp;
 431         regs->regs[52] = r52;
 432         return regs;
 433 }
 434
 435 /* This is called from dump_stack() and just converts to pt_regs */
 436 void _dump_stack(int dummy, ulong pc, ulong lr, ulong sp, ulong r52)
 437 {
 438         struct pt_regs regs;
 439         dump_stack_regs(regs_to_pt_regs(&regs, pc, lr, sp, r52));
 440 }
 441
 442 /* This is called from KBacktraceIterator_init_current() */
 443 void _KBacktraceIterator_init_current(struct KBacktraceIterator *kbt, ulong pc,
 444                                       ulong lr, ulong sp, ulong r52)
 445 {
 446         struct pt_regs regs;
 447         KBacktraceIterator_init(kbt, NULL,
 448                                 regs_to_pt_regs(&regs, pc, lr, sp, r52));
 449 }
 450
 451 /* This is called only from kernel/sched.c, with esp == NULL */
 452 void show_stack(struct task_struct *task, unsigned long *esp)
 453 {
 454         struct KBacktraceIterator kbt;
 455         if (task == NULL || task == current)
 456                 KBacktraceIterator_init_current(&kbt);
 457         else
 458                 KBacktraceIterator_init(&kbt, task, NULL);
 459         tile_show_stack(&kbt, 0);
 460 }
 461
 462 #ifdef CONFIG_STACKTRACE
 463
 464 /* Support generic Linux stack API too */
 465
 466 void save_stack_trace_tsk(struct task_struct *task, struct stack_trace *trace)
 467 {
 468         struct KBacktraceIterator kbt;
 469         int skip = trace->skip;
 470         int i = 0;
 471
 472         if (task == NULL || task == current)
 473                 KBacktraceIterator_init_current(&kbt);
 474         else
 475                 KBacktraceIterator_init(&kbt, task, NULL);
 476         for (; !KBacktraceIterator_end(&kbt); KBacktraceIterator_next(&kbt)) {
 477                 if (skip) {
 478                         --skip;
 479                         continue;
 480                 }
 481                 if (i >= trace->max_entries || kbt.it.pc < PAGE_OFFSET)
 482                         break;
 483                 trace->entries[i++] = kbt.it.pc;
 484         }
 485         trace->nr_entries = i;
 486 }
 487 EXPORT_SYMBOL(save_stack_trace_tsk);
 488
 489 void save_stack_trace(struct stack_trace *trace)
 490 {
 491         save_stack_trace_tsk(NULL, trace);
 492 }
 493
 494 #endif
 495
 496 /* In entry.S */
 497 EXPORT_SYMBOL(KBacktraceIterator_init_current);