arch/sh/kernel/dumpstack.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  Copyright (C) 1991, 1992  Linus Torvalds
   4  *  Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
   5  *  Copyright (C) 2009  Matt Fleming
   6  *  Copyright (C) 2002 - 2012  Paul Mundt
   7  */
   8 #include <linux/kallsyms.h>
   9 #include <linux/ftrace.h>
  10 #include <linux/debug_locks.h>
  11 #include <linux/sched/debug.h>
  12 #include <linux/sched/task_stack.h>
  13 #include <linux/kdebug.h>
  14 #include <linux/export.h>
  15 #include <linux/uaccess.h>
  16 #include <asm/unwinder.h>
  17 #include <asm/stacktrace.h>
  18
  19 void dump_mem(const char *str, const char *loglvl, unsigned long bottom,
  20               unsigned long top)
  21 {
  22         unsigned long p;
  23         int i;
  24
  25         printk("%s%s(0x%08lx to 0x%08lx)\n", loglvl, str, bottom, top);
  26
  27         for (p = bottom & ~31; p < top; ) {
  28                 printk("%s%04lx: ", loglvl,  p & 0xffff);
  29
  30                 for (i = 0; i < 8; i++, p += 4) {
  31                         unsigned int val;
  32
  33                         if (p < bottom || p >= top)
  34                                 pr_cont("         ");
  35                         else {
  36                                 if (__get_user(val, (unsigned int __user *)p)) {
  37                                         pr_cont("\n");
  38                                         return;
  39                                 }
  40                                 pr_cont("%08x ", val);
  41                         }
  42                 }
  43                 pr_cont("\n");
  44         }
  45 }
  46
  47 void printk_address(unsigned long address, int reliable)
  48 {
  49         pr_cont(" [<%px>] %s%pS\n", (void *) address,
  50                 reliable ? "" : "? ", (void *) address);
  51 }
  52
  53 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
  54 static void
  55 print_ftrace_graph_addr(unsigned long addr, void *data,
  56                         const struct stacktrace_ops *ops,
  57                         struct thread_info *tinfo, int *graph)
  58 {
  59         struct task_struct *task = tinfo->task;
  60         struct ftrace_ret_stack *ret_stack;
  61         unsigned long ret_addr;
  62
  63         if (addr != (unsigned long)return_to_handler)
  64                 return;
  65
  66         if (!task->ret_stack)
  67                 return;
  68
  69         ret_stack = ftrace_graph_get_ret_stack(task, *graph);
  70         if (!ret_stack)
  71                 return;
  72
  73         ret_addr = ret_stack->ret;
  74
  75         ops->address(data, ret_addr, 1);
  76
  77         (*graph)++;
  78 }
  79 #else
  80 static inline void
  81 print_ftrace_graph_addr(unsigned long addr, void *data,
  82                         const struct stacktrace_ops *ops,
  83                         struct thread_info *tinfo, int *graph)
  84 { }
  85 #endif
  86
  87 void
  88 stack_reader_dump(struct task_struct *task, struct pt_regs *regs,
  89                   unsigned long *sp, const struct stacktrace_ops *ops,
  90                   void *data)
  91 {
  92         struct thread_info *context;
  93         int graph = 0;
  94
  95         context = (struct thread_info *)
  96                 ((unsigned long)sp & (~(THREAD_SIZE - 1)));
  97
  98         while (!kstack_end(sp)) {
  99                 unsigned long addr = *sp++;
 100
 101                 if (__kernel_text_address(addr)) {
 102                         ops->address(data, addr, 1);
 103
 104                         print_ftrace_graph_addr(addr, data, ops,
 105                                                 context, &graph);
 106                 }
 107         }
 108 }
 109
 110 /*
 111  * Print one address/symbol entries per line.
 112  */
 113 static void print_trace_address(void *data, unsigned long addr, int reliable)
 114 {
 115         printk("%s", (char *)data);
 116         printk_address(addr, reliable);
 117 }
 118
 119 static const struct stacktrace_ops print_trace_ops = {
 120         .address = print_trace_address,
 121 };
 122
 123 void show_trace(struct task_struct *tsk, unsigned long *sp,
 124                 struct pt_regs *regs, const char *loglvl)
 125 {
 126         if (regs && user_mode(regs))
 127                 return;
 128
 129         printk("%s\nCall trace:\n", loglvl);
 130
 131         unwind_stack(tsk, regs, sp, &print_trace_ops, (void *)loglvl);
 132
 133         pr_cont("\n");
 134
 135         if (!tsk)
 136                 tsk = current;
 137
 138         debug_show_held_locks(tsk);
 139 }
 140
 141 void show_stack(struct task_struct *tsk, unsigned long *sp, const char *loglvl)
 142 {
 143         unsigned long stack;
 144
 145         if (!tsk)
 146                 tsk = current;
 147         if (tsk == current)
 148                 sp = (unsigned long *)current_stack_pointer;
 149         else
 150                 sp = (unsigned long *)tsk->thread.sp;
 151
 152         stack = (unsigned long)sp;
 153         dump_mem("Stack: ", loglvl, stack, THREAD_SIZE +
 154                  (unsigned long)task_stack_page(tsk));
 155         show_trace(tsk, sp, NULL, loglvl);
 156 }