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/sched/debug.h>
  17 #include <linux/sched/task_stack.h>
  18 #include <linux/kernel.h>
  19 #include <linux/kprobes.h>
  20 #include <linux/module.h>
  21 #include <linux/pfn.h>
  22 #include <linux/kallsyms.h>
  23 #include <linux/stacktrace.h>
  24 #include <linux/uaccess.h>
  25 #include <linux/mmzone.h>
  26 #include <linux/dcache.h>
  27 #include <linux/fs.h>
  28 #include <linux/hardirq.h>
  29 #include <linux/string.h>
  30 #include <asm/backtrace.h>
  31 #include <asm/page.h>
  32 #include <asm/ucontext.h>
  33 #include <asm/switch_to.h>
  34 #include <asm/sigframe.h>
  35 #include <asm/stack.h>
  36 #include <asm/vdso.h>
  37 #include <arch/abi.h>
  38 #include <arch/interrupts.h>
  39
  40 #define KBT_ONGOING     0  /* Backtrace still ongoing */
  41 #define KBT_DONE        1  /* Backtrace cleanly completed */
  42 #define KBT_RUNNING     2  /* Can't run backtrace on a running task */
  43 #define KBT_LOOP        3  /* Backtrace entered a loop */
  44
  45 /* Is address on the specified kernel stack? */
  46 static int in_kernel_stack(struct KBacktraceIterator *kbt, unsigned long sp)
  47 {
  48         ulong kstack_base = (ulong) kbt->task->stack;
  49         if (kstack_base == 0)  /* corrupt task pointer; just follow stack... */
  50                 return sp >= PAGE_OFFSET && sp < (unsigned long)high_memory;
  51         return sp >= kstack_base && sp < kstack_base + THREAD_SIZE;
  52 }
  53
  54 /* Callback for backtracer; basically a glorified memcpy */
  55 static bool read_memory_func(void *result, unsigned long address,
  56                              unsigned int size, void *vkbt)
  57 {
  58         int retval;
  59         struct KBacktraceIterator *kbt = (struct KBacktraceIterator *)vkbt;
  60
  61         if (address == 0)
  62                 return 0;
  63         if (__kernel_text_address(address)) {
  64                 /* OK to read kernel code. */
  65         } else if (address >= PAGE_OFFSET) {
  66                 /* We only tolerate kernel-space reads of this task's stack */
  67                 if (!in_kernel_stack(kbt, address))
  68                         return 0;
  69         } else if (!kbt->is_current) {
  70                 return 0;       /* can't read from other user address spaces */
  71         }
  72         pagefault_disable();
  73         retval = __copy_from_user_inatomic(result,
  74                                            (void __user __force *)address,
  75                                            size);
  76         pagefault_enable();
  77         return (retval == 0);
  78 }
  79
  80 /* Return a pt_regs pointer for a valid fault handler frame */
  81 static struct pt_regs *valid_fault_handler(struct KBacktraceIterator* kbt)
  82 {
  83         char fault[64];
  84         unsigned long sp = kbt->it.sp;
  85         struct pt_regs *p;
  86
  87         if (sp % sizeof(long) != 0)
  88                 return NULL;
  89         if (!in_kernel_stack(kbt, sp))
  90                 return NULL;
  91         if (!in_kernel_stack(kbt, sp + C_ABI_SAVE_AREA_SIZE + PTREGS_SIZE-1))
  92                 return NULL;
  93         p = (struct pt_regs *)(sp + C_ABI_SAVE_AREA_SIZE);
  94         if (kbt->verbose) {     /* else we aren't going to use it */
  95                 if (p->faultnum == INT_SWINT_1 ||
  96                     p->faultnum == INT_SWINT_1_SIGRETURN)
  97                         snprintf(fault, sizeof(fault),
  98                                  "syscall %ld", p->regs[TREG_SYSCALL_NR]);
  99                 else
 100                         snprintf(fault, sizeof(fault),
 101                                  "interrupt %ld", p->faultnum);
 102         }
 103         if (EX1_PL(p->ex1) == KERNEL_PL &&
 104             __kernel_text_address(p->pc) &&
 105             in_kernel_stack(kbt, p->sp) &&
 106             p->sp >= sp) {
 107                 if (kbt->verbose)
 108                         pr_err("  <%s while in kernel mode>\n", fault);
 109         } else if (user_mode(p) &&
 110                    p->sp < PAGE_OFFSET && p->sp != 0) {
 111                 if (kbt->verbose)
 112                         pr_err("  <%s while in user mode>\n", fault);
 113         } else {
 114                 if (kbt->verbose && (p->pc != 0 || p->sp != 0 || p->ex1 != 0))
 115                         pr_err("  (odd fault: pc %#lx, sp %#lx, ex1 %#lx?)\n",
 116                                p->pc, p->sp, p->ex1);
 117                 return NULL;
 118         }
 119         if (kbt->profile && ((1ULL << p->faultnum) & QUEUED_INTERRUPTS) != 0)
 120                 return NULL;
 121         return p;
 122 }
 123
 124 /* Is the iterator pointing to a sigreturn trampoline? */
 125 static int is_sigreturn(struct KBacktraceIterator *kbt)
 126 {
 127         return kbt->task->mm &&
 128                 (kbt->it.pc == ((ulong)kbt->task->mm->context.vdso_base +
 129                                 (ulong)&__vdso_rt_sigreturn));
 130 }
 131
 132 /* Return a pt_regs pointer for a valid signal handler frame */
 133 static struct pt_regs *valid_sigframe(struct KBacktraceIterator* kbt,
 134                                       struct rt_sigframe* kframe)
 135 {
 136         BacktraceIterator *b = &kbt->it;
 137
 138         if (is_sigreturn(kbt) && b->sp < PAGE_OFFSET &&
 139             b->sp % sizeof(long) == 0) {
 140                 int retval;
 141                 pagefault_disable();
 142                 retval = __copy_from_user_inatomic(
 143                         kframe, (void __user __force *)b->sp,
 144                         sizeof(*kframe));
 145                 pagefault_enable();
 146                 if (retval != 0 ||
 147                     (unsigned int)(kframe->info.si_signo) >= _NSIG)
 148                         return NULL;
 149                 if (kbt->verbose) {
 150                         pr_err("  <received signal %d>\n",
 151                                kframe->info.si_signo);
 152                 }
 153                 return (struct pt_regs *)&kframe->uc.uc_mcontext;
 154         }
 155         return NULL;
 156 }
 157
 158 static int KBacktraceIterator_restart(struct KBacktraceIterator *kbt)
 159 {
 160         struct pt_regs *p;
 161         struct rt_sigframe kframe;
 162
 163         p = valid_fault_handler(kbt);
 164         if (p == NULL)
 165                 p = valid_sigframe(kbt, &kframe);
 166         if (p == NULL)
 167                 return 0;
 168         backtrace_init(&kbt->it, read_memory_func, kbt,
 169                        p->pc, p->lr, p->sp, p->regs[52]);
 170         kbt->new_context = 1;
 171         return 1;
 172 }
 173
 174 /* Find a frame that isn't a sigreturn, if there is one. */
 175 static int KBacktraceIterator_next_item_inclusive(
 176         struct KBacktraceIterator *kbt)
 177 {
 178         for (;;) {
 179                 do {
 180                         if (!is_sigreturn(kbt))
 181                                 return KBT_ONGOING;
 182                 } while (backtrace_next(&kbt->it));
 183
 184                 if (!KBacktraceIterator_restart(kbt))
 185                         return KBT_DONE;
 186         }
 187 }
 188
 189 /*
 190  * If the current sp is on a page different than what we recorded
 191  * as the top-of-kernel-stack last time we context switched, we have
 192  * probably blown the stack, and nothing is going to work out well.
 193  * If we can at least get out a warning, that may help the debug,
 194  * though we probably won't be able to backtrace into the code that
 195  * actually did the recursive damage.
 196  */
 197 static void validate_stack(struct pt_regs *regs)
 198 {
 199         int cpu = raw_smp_processor_id();
 200         unsigned long ksp0 = get_current_ksp0();
 201         unsigned long ksp0_base = ksp0 & -THREAD_SIZE;
 202         unsigned long sp = stack_pointer;
 203
 204         if (EX1_PL(regs->ex1) == KERNEL_PL && regs->sp >= ksp0) {
 205                 pr_err("WARNING: cpu %d: kernel stack %#lx..%#lx underrun!\n"
 206                        "  sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
 207                        cpu, ksp0_base, ksp0, sp, regs->sp, regs->pc, regs->lr);
 208         }
 209
 210         else if (sp < ksp0_base + sizeof(struct thread_info)) {
 211                 pr_err("WARNING: cpu %d: kernel stack %#lx..%#lx overrun!\n"
 212                        "  sp %#lx (%#lx in caller), caller pc %#lx, lr %#lx\n",
 213                        cpu, ksp0_base, ksp0, sp, regs->sp, regs->pc, regs->lr);
 214         }
 215 }
 216
 217 void KBacktraceIterator_init(struct KBacktraceIterator *kbt,
 218                              struct task_struct *t, struct pt_regs *regs)
 219 {
 220         unsigned long pc, lr, sp, r52;
 221         int is_current;
 222
 223         /*
 224          * Set up callback information.  We grab the kernel stack base
 225          * so we will allow reads of that address range.
 226          */
 227         is_current = (t == NULL || t == current);
 228         kbt->is_current = is_current;
 229         if (is_current)
 230                 t = validate_current();
 231         kbt->task = t;
 232         kbt->verbose = 0;   /* override in caller if desired */
 233         kbt->profile = 0;   /* override in caller if desired */
 234         kbt->end = KBT_ONGOING;
 235         kbt->new_context = 1;
 236         if (is_current)
 237                 validate_stack(regs);
 238
 239         if (regs == NULL) {
 240                 if (is_current || t->state == TASK_RUNNING) {
 241                         /* Can't do this; we need registers */
 242                         kbt->end = KBT_RUNNING;
 243                         return;
 244                 }
 245                 pc = get_switch_to_pc();
 246                 lr = t->thread.pc;
 247                 sp = t->thread.ksp;
 248                 r52 = 0;
 249         } else {
 250                 pc = regs->pc;
 251                 lr = regs->lr;
 252                 sp = regs->sp;
 253                 r52 = regs->regs[52];
 254         }
 255
 256         backtrace_init(&kbt->it, read_memory_func, kbt, pc, lr, sp, r52);
 257         kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
 258 }
 259 EXPORT_SYMBOL(KBacktraceIterator_init);
 260
 261 int KBacktraceIterator_end(struct KBacktraceIterator *kbt)
 262 {
 263         return kbt->end != KBT_ONGOING;
 264 }
 265 EXPORT_SYMBOL(KBacktraceIterator_end);
 266
 267 void KBacktraceIterator_next(struct KBacktraceIterator *kbt)
 268 {
 269         unsigned long old_pc = kbt->it.pc, old_sp = kbt->it.sp;
 270         kbt->new_context = 0;
 271         if (!backtrace_next(&kbt->it) && !KBacktraceIterator_restart(kbt)) {
 272                 kbt->end = KBT_DONE;
 273                 return;
 274         }
 275         kbt->end = KBacktraceIterator_next_item_inclusive(kbt);
 276         if (old_pc == kbt->it.pc && old_sp == kbt->it.sp) {
 277                 /* Trapped in a loop; give up. */
 278                 kbt->end = KBT_LOOP;
 279         }
 280 }
 281 EXPORT_SYMBOL(KBacktraceIterator_next);
 282
 283 static void describe_addr(struct KBacktraceIterator *kbt,
 284                           unsigned long address,
 285                           int have_mmap_sem, char *buf, size_t bufsize)
 286 {
 287         struct vm_area_struct *vma;
 288         size_t namelen, remaining;
 289         unsigned long size, offset, adjust;
 290         char *p, *modname;
 291         const char *name;
 292         int rc;
 293
 294         /*
 295          * Look one byte back for every caller frame (i.e. those that
 296          * aren't a new context) so we look up symbol data for the
 297          * call itself, not the following instruction, which may be on
 298          * a different line (or in a different function).
 299          */
 300         adjust = !kbt->new_context;
 301         address -= adjust;
 302
 303         if (address >= PAGE_OFFSET) {
 304                 /* Handle kernel symbols. */
 305                 BUG_ON(bufsize < KSYM_NAME_LEN);
 306                 name = kallsyms_lookup(address, &size, &offset,
 307                                        &modname, buf);
 308                 if (name == NULL) {
 309                         buf[0] = '\0';
 310                         return;
 311                 }
 312                 namelen = strlen(buf);
 313                 remaining = (bufsize - 1) - namelen;
 314                 p = buf + namelen;
 315                 rc = snprintf(p, remaining, "+%#lx/%#lx ",
 316                               offset + adjust, size);
 317                 if (modname && rc < remaining)
 318                         snprintf(p + rc, remaining - rc, "[%s] ", modname);
 319                 buf[bufsize-1] = '\0';
 320                 return;
 321         }
 322
 323         /* If we don't have the mmap_sem, we can't show any more info. */
 324         buf[0] = '\0';
 325         if (!have_mmap_sem)
 326                 return;
 327
 328         /* Find vma info. */
 329         vma = find_vma(kbt->task->mm, address);
 330         if (vma == NULL || address < vma->vm_start) {
 331                 snprintf(buf, bufsize, "[unmapped address] ");
 332                 return;
 333         }
 334
 335         if (vma->vm_file) {
 336                 p = file_path(vma->vm_file, buf, bufsize);
 337                 if (IS_ERR(p))
 338                         p = "?";
 339                 name = kbasename(p);
 340         } else {
 341                 name = "anon";
 342         }
 343
 344         /* Generate a string description of the vma info. */
 345         namelen = strlen(name);
 346         remaining = (bufsize - 1) - namelen;
 347         memmove(buf, name, namelen);
 348         snprintf(buf + namelen, remaining, "[%lx+%lx] ",
 349                  vma->vm_start, vma->vm_end - vma->vm_start);
 350 }
 351
 352 /*
 353  * Avoid possible crash recursion during backtrace.  If it happens, it
 354  * makes it easy to lose the actual root cause of the failure, so we
 355  * put a simple guard on all the backtrace loops.
 356  */
 357 static bool start_backtrace(void)
 358 {
 359         if (current_thread_info()->in_backtrace) {
 360                 pr_err("Backtrace requested while in backtrace!\n");
 361                 return false;
 362         }
 363         current_thread_info()->in_backtrace = true;
 364         return true;
 365 }
 366
 367 static void end_backtrace(void)
 368 {
 369         current_thread_info()->in_backtrace = false;
 370 }
 371
 372 /*
 373  * This method wraps the backtracer's more generic support.
 374  * It is only invoked from the architecture-specific code; show_stack()
 375  * and dump_stack() are architecture-independent entry points.
 376  */
 377 void tile_show_stack(struct KBacktraceIterator *kbt)
 378 {
 379         int i;
 380         int have_mmap_sem = 0;
 381
 382         if (!start_backtrace())
 383                 return;
 384         kbt->verbose = 1;
 385         i = 0;
 386         for (; !KBacktraceIterator_end(kbt); KBacktraceIterator_next(kbt)) {
 387                 char namebuf[KSYM_NAME_LEN+100];
 388                 unsigned long address = kbt->it.pc;
 389
 390                 /*
 391                  * Try to acquire the mmap_sem as we pass into userspace.
 392                  * If we're in an interrupt context, don't even try, since
 393                  * it's not safe to call e.g. d_path() from an interrupt,
 394                  * since it uses spin locks without disabling interrupts.
 395                  * Note we test "kbt->task == current", not "kbt->is_current",
 396                  * since we're checking that "current" will work in d_path().
 397                  */
 398                 if (kbt->task == current && address < PAGE_OFFSET &&
 399                     !have_mmap_sem && kbt->task->mm && !in_interrupt()) {
 400                         have_mmap_sem =
 401                                 down_read_trylock(&kbt->task->mm->mmap_sem);
 402                 }
 403
 404                 describe_addr(kbt, address, have_mmap_sem,
 405                               namebuf, sizeof(namebuf));
 406
 407                 pr_err("  frame %d: 0x%lx %s(sp 0x%lx)\n",
 408                        i++, address, namebuf, (unsigned long)(kbt->it.sp));
 409
 410                 if (i >= 100) {
 411                         pr_err("Stack dump truncated (%d frames)\n", i);
 412                         break;
 413                 }
 414         }
 415         if (kbt->end == KBT_LOOP)
 416                 pr_err("Stack dump stopped; next frame identical to this one\n");
 417         if (have_mmap_sem)
 418                 up_read(&kbt->task->mm->mmap_sem);
 419         end_backtrace();
 420 }
 421 EXPORT_SYMBOL(tile_show_stack);
 422
 423 static struct pt_regs *regs_to_pt_regs(struct pt_regs *regs,
 424                                        ulong pc, ulong lr, ulong sp, ulong r52)
 425 {
 426         memset(regs, 0, sizeof(struct pt_regs));
 427         regs->pc = pc;
 428         regs->lr = lr;
 429         regs->sp = sp;
 430         regs->regs[52] = r52;
 431         return regs;
 432 }
 433
 434 /* Deprecated function currently only used by kernel_double_fault(). */
 435 void _dump_stack(int dummy, ulong pc, ulong lr, ulong sp, ulong r52)
 436 {
 437         struct KBacktraceIterator kbt;
 438         struct pt_regs regs;
 439
 440         regs_to_pt_regs(&regs, pc, lr, sp, r52);
 441         KBacktraceIterator_init(&kbt, NULL, &regs);
 442         tile_show_stack(&kbt);
 443 }
 444
 445 /* This is called from KBacktraceIterator_init_current() */
 446 void _KBacktraceIterator_init_current(struct KBacktraceIterator *kbt, ulong pc,
 447                                       ulong lr, ulong sp, ulong r52)
 448 {
 449         struct pt_regs regs;
 450         KBacktraceIterator_init(kbt, NULL,
 451                                 regs_to_pt_regs(&regs, pc, lr, sp, r52));
 452 }
 453
 454 /*
 455  * Called from sched_show_task() with task != NULL, or dump_stack()
 456  * with task == NULL.  The esp argument is always NULL.
 457  */
 458 void show_stack(struct task_struct *task, unsigned long *esp)
 459 {
 460         struct KBacktraceIterator kbt;
 461         if (task == NULL || task == current) {
 462                 KBacktraceIterator_init_current(&kbt);
 463                 KBacktraceIterator_next(&kbt);  /* don't show first frame */
 464         } else {
 465                 KBacktraceIterator_init(&kbt, task, NULL);
 466         }
 467         tile_show_stack(&kbt);
 468 }
 469
 470 #ifdef CONFIG_STACKTRACE
 471
 472 /* Support generic Linux stack API too */
 473
 474 static void save_stack_trace_common(struct task_struct *task,
 475                                     struct pt_regs *regs,
 476                                     bool user,
 477                                     struct stack_trace *trace)
 478 {
 479         struct KBacktraceIterator kbt;
 480         int skip = trace->skip;
 481         int i = 0;
 482
 483         if (!start_backtrace())
 484                 goto done;
 485         if (regs != NULL) {
 486                 KBacktraceIterator_init(&kbt, NULL, regs);
 487         } else if (task == NULL || task == current) {
 488                 KBacktraceIterator_init_current(&kbt);
 489                 skip++;  /* don't show KBacktraceIterator_init_current */
 490         } else {
 491                 KBacktraceIterator_init(&kbt, task, NULL);
 492         }
 493         for (; !KBacktraceIterator_end(&kbt); KBacktraceIterator_next(&kbt)) {
 494                 if (skip) {
 495                         --skip;
 496                         continue;
 497                 }
 498                 if (i >= trace->max_entries ||
 499                     (!user && kbt.it.pc < PAGE_OFFSET))
 500                         break;
 501                 trace->entries[i++] = kbt.it.pc;
 502         }
 503         end_backtrace();
 504 done:
 505         if (i < trace->max_entries)
 506                 trace->entries[i++] = ULONG_MAX;
 507         trace->nr_entries = i;
 508 }
 509
 510 void save_stack_trace_tsk(struct task_struct *task, struct stack_trace *trace)
 511 {
 512         save_stack_trace_common(task, NULL, false, trace);
 513 }
 514 EXPORT_SYMBOL(save_stack_trace_tsk);
 515
 516 void save_stack_trace(struct stack_trace *trace)
 517 {
 518         save_stack_trace_common(NULL, NULL, false, trace);
 519 }
 520 EXPORT_SYMBOL_GPL(save_stack_trace);
 521
 522 void save_stack_trace_regs(struct pt_regs *regs, struct stack_trace *trace)
 523 {
 524         save_stack_trace_common(NULL, regs, false, trace);
 525 }
 526
 527 void save_stack_trace_user(struct stack_trace *trace)
 528 {
 529         /* Trace user stack if we are not a kernel thread. */
 530         if (current->mm)
 531                 save_stack_trace_common(NULL, task_pt_regs(current),
 532                                         true, trace);
 533         else if (trace->nr_entries < trace->max_entries)
 534                 trace->entries[trace->nr_entries++] = ULONG_MAX;
 535 }
 536 #endif
 537
 538 /* In entry.S */
 539 EXPORT_SYMBOL(KBacktraceIterator_init_current);