forked from Minki/linux
186f43608a
Historically a lot of these existed because we did not have a distinction between what was modular code and what was providing support to modules via EXPORT_SYMBOL and friends. That changed when we forked out support for the latter into the export.h file. This means we should be able to reduce the usage of module.h in code that is obj-y Makefile or bool Kconfig. The advantage in doing so is that module.h itself sources about 15 other headers; adding significantly to what we feed cpp, and it can obscure what headers we are effectively using. Since module.h was the source for init.h (for __init) and for export.h (for EXPORT_SYMBOL) we consider each obj-y/bool instance for the presence of either and replace as needed. Build testing revealed some implicit header usage that was fixed up accordingly. Note that some bool/obj-y instances remain since module.h is the header for some exception table entry stuff, and for things like __init_or_module (code that is tossed when MODULES=n). Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com> Cc: Linus Torvalds <torvalds@linux-foundation.org> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Thomas Gleixner <tglx@linutronix.de> Link: http://lkml.kernel.org/r/20160714001901.31603-4-paul.gortmaker@windriver.com Signed-off-by: Ingo Molnar <mingo@kernel.org>
151 lines
3.6 KiB
C
151 lines
3.6 KiB
C
/*
|
|
* Stack trace management functions
|
|
*
|
|
* Copyright (C) 2006-2009 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
|
|
*/
|
|
#include <linux/sched.h>
|
|
#include <linux/stacktrace.h>
|
|
#include <linux/export.h>
|
|
#include <linux/uaccess.h>
|
|
#include <asm/stacktrace.h>
|
|
|
|
static int save_stack_stack(void *data, char *name)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
__save_stack_address(void *data, unsigned long addr, bool reliable, bool nosched)
|
|
{
|
|
struct stack_trace *trace = data;
|
|
#ifdef CONFIG_FRAME_POINTER
|
|
if (!reliable)
|
|
return 0;
|
|
#endif
|
|
if (nosched && in_sched_functions(addr))
|
|
return 0;
|
|
if (trace->skip > 0) {
|
|
trace->skip--;
|
|
return 0;
|
|
}
|
|
if (trace->nr_entries < trace->max_entries) {
|
|
trace->entries[trace->nr_entries++] = addr;
|
|
return 0;
|
|
} else {
|
|
return -1; /* no more room, stop walking the stack */
|
|
}
|
|
}
|
|
|
|
static int save_stack_address(void *data, unsigned long addr, int reliable)
|
|
{
|
|
return __save_stack_address(data, addr, reliable, false);
|
|
}
|
|
|
|
static int
|
|
save_stack_address_nosched(void *data, unsigned long addr, int reliable)
|
|
{
|
|
return __save_stack_address(data, addr, reliable, true);
|
|
}
|
|
|
|
static const struct stacktrace_ops save_stack_ops = {
|
|
.stack = save_stack_stack,
|
|
.address = save_stack_address,
|
|
.walk_stack = print_context_stack,
|
|
};
|
|
|
|
static const struct stacktrace_ops save_stack_ops_nosched = {
|
|
.stack = save_stack_stack,
|
|
.address = save_stack_address_nosched,
|
|
.walk_stack = print_context_stack,
|
|
};
|
|
|
|
/*
|
|
* Save stack-backtrace addresses into a stack_trace buffer.
|
|
*/
|
|
void save_stack_trace(struct stack_trace *trace)
|
|
{
|
|
dump_trace(current, NULL, NULL, 0, &save_stack_ops, trace);
|
|
if (trace->nr_entries < trace->max_entries)
|
|
trace->entries[trace->nr_entries++] = ULONG_MAX;
|
|
}
|
|
EXPORT_SYMBOL_GPL(save_stack_trace);
|
|
|
|
void save_stack_trace_regs(struct pt_regs *regs, struct stack_trace *trace)
|
|
{
|
|
dump_trace(current, regs, NULL, 0, &save_stack_ops, trace);
|
|
if (trace->nr_entries < trace->max_entries)
|
|
trace->entries[trace->nr_entries++] = ULONG_MAX;
|
|
}
|
|
|
|
void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
|
|
{
|
|
dump_trace(tsk, NULL, NULL, 0, &save_stack_ops_nosched, trace);
|
|
if (trace->nr_entries < trace->max_entries)
|
|
trace->entries[trace->nr_entries++] = ULONG_MAX;
|
|
}
|
|
EXPORT_SYMBOL_GPL(save_stack_trace_tsk);
|
|
|
|
/* Userspace stacktrace - based on kernel/trace/trace_sysprof.c */
|
|
|
|
struct stack_frame_user {
|
|
const void __user *next_fp;
|
|
unsigned long ret_addr;
|
|
};
|
|
|
|
static int
|
|
copy_stack_frame(const void __user *fp, struct stack_frame_user *frame)
|
|
{
|
|
int ret;
|
|
|
|
if (!access_ok(VERIFY_READ, fp, sizeof(*frame)))
|
|
return 0;
|
|
|
|
ret = 1;
|
|
pagefault_disable();
|
|
if (__copy_from_user_inatomic(frame, fp, sizeof(*frame)))
|
|
ret = 0;
|
|
pagefault_enable();
|
|
|
|
return ret;
|
|
}
|
|
|
|
static inline void __save_stack_trace_user(struct stack_trace *trace)
|
|
{
|
|
const struct pt_regs *regs = task_pt_regs(current);
|
|
const void __user *fp = (const void __user *)regs->bp;
|
|
|
|
if (trace->nr_entries < trace->max_entries)
|
|
trace->entries[trace->nr_entries++] = regs->ip;
|
|
|
|
while (trace->nr_entries < trace->max_entries) {
|
|
struct stack_frame_user frame;
|
|
|
|
frame.next_fp = NULL;
|
|
frame.ret_addr = 0;
|
|
if (!copy_stack_frame(fp, &frame))
|
|
break;
|
|
if ((unsigned long)fp < regs->sp)
|
|
break;
|
|
if (frame.ret_addr) {
|
|
trace->entries[trace->nr_entries++] =
|
|
frame.ret_addr;
|
|
}
|
|
if (fp == frame.next_fp)
|
|
break;
|
|
fp = frame.next_fp;
|
|
}
|
|
}
|
|
|
|
void save_stack_trace_user(struct stack_trace *trace)
|
|
{
|
|
/*
|
|
* Trace user stack if we are not a kernel thread
|
|
*/
|
|
if (current->mm) {
|
|
__save_stack_trace_user(trace);
|
|
}
|
|
if (trace->nr_entries < trace->max_entries)
|
|
trace->entries[trace->nr_entries++] = ULONG_MAX;
|
|
}
|
|
|