~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/tile/kernel/stack.c

Version: ~ [ linux-5.1-rc1 ] ~ [ linux-5.0.3 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.30 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.107 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.164 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.176 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.136 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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);
540 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp