Linux Audio

Check our new training course

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