Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405// SPDX-License-Identifier: GPL-2.0-only/* * kernel/stacktrace.c * * Stack trace management functions * * Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com> */#include <linux/sched/task_stack.h>#include <linux/sched/debug.h>#include <linux/sched.h>#include <linux/kernel.h>#include <linux/export.h>#include <linux/kallsyms.h>#include <linux/stacktrace.h>#include <linux/interrupt.h>
/** * stack_trace_print - Print the entries in the stack trace * @entries: Pointer to storage array * @nr_entries: Number of entries in the storage array * @spaces: Number of leading spaces to print */void stack_trace_print(const unsigned long *entries, unsigned int nr_entries, int spaces){ unsigned int i;
if (WARN_ON(!entries)) return;
for (i = 0; i < nr_entries; i++) printk("%*c%pS\n", 1 + spaces, ' ', (void *)entries[i]);}EXPORT_SYMBOL_GPL(stack_trace_print);
/** * stack_trace_snprint - Print the entries in the stack trace into a buffer * @buf: Pointer to the print buffer * @size: Size of the print buffer * @entries: Pointer to storage array * @nr_entries: Number of entries in the storage array * @spaces: Number of leading spaces to print * * Return: Number of bytes printed. */int stack_trace_snprint(char *buf, size_t size, const unsigned long *entries, unsigned int nr_entries, int spaces){ unsigned int generated, i, total = 0;
if (WARN_ON(!entries)) return 0;
for (i = 0; i < nr_entries && size; i++) { generated = snprintf(buf, size, "%*c%pS\n", 1 + spaces, ' ', (void *)entries[i]);
total += generated; if (generated >= size) { buf += size; size = 0; } else { buf += generated; size -= generated; } }
return total;}EXPORT_SYMBOL_GPL(stack_trace_snprint);
#ifdef CONFIG_ARCH_STACKWALK
struct stacktrace_cookie { unsigned long *store; unsigned int size; unsigned int skip; unsigned int len;};
static bool stack_trace_consume_entry(void *cookie, unsigned long addr){ struct stacktrace_cookie *c = cookie;
if (c->len >= c->size) return false;
if (c->skip > 0) { c->skip--; return true; } c->store[c->len++] = addr; return c->len < c->size;}
static bool stack_trace_consume_entry_nosched(void *cookie, unsigned long addr){ if (in_sched_functions(addr)) return true; return stack_trace_consume_entry(cookie, addr);}
/** * stack_trace_save - Save a stack trace into a storage array * @store: Pointer to storage array * @size: Size of the storage array * @skipnr: Number of entries to skip at the start of the stack trace * * Return: Number of trace entries stored. */unsigned int stack_trace_save(unsigned long *store, unsigned int size, unsigned int skipnr){ stack_trace_consume_fn consume_entry = stack_trace_consume_entry; struct stacktrace_cookie c = { .store = store, .size = size, .skip = skipnr + 1, };
arch_stack_walk(consume_entry, &c, current, NULL); return c.len;}EXPORT_SYMBOL_GPL(stack_trace_save);
/** * stack_trace_save_tsk - Save a task stack trace into a storage array * @tsk: The task to examine * @store: Pointer to storage array * @size: Size of the storage array * @skipnr: Number of entries to skip at the start of the stack trace * * Return: Number of trace entries stored. */unsigned int stack_trace_save_tsk(struct task_struct *tsk, unsigned long *store, unsigned int size, unsigned int skipnr){ stack_trace_consume_fn consume_entry = stack_trace_consume_entry_nosched; struct stacktrace_cookie c = { .store = store, .size = size, /* skip this function if they are tracing us */ .skip = skipnr + (current == tsk), };
if (!try_get_task_stack(tsk)) return 0;
arch_stack_walk(consume_entry, &c, tsk, NULL); put_task_stack(tsk); return c.len;}EXPORT_SYMBOL_GPL(stack_trace_save_tsk);
/** * stack_trace_save_regs - Save a stack trace based on pt_regs into a storage array * @regs: Pointer to pt_regs to examine * @store: Pointer to storage array * @size: Size of the storage array * @skipnr: Number of entries to skip at the start of the stack trace * * Return: Number of trace entries stored. */unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store, unsigned int size, unsigned int skipnr){ stack_trace_consume_fn consume_entry = stack_trace_consume_entry; struct stacktrace_cookie c = { .store = store, .size = size, .skip = skipnr, };
arch_stack_walk(consume_entry, &c, current, regs); return c.len;}
#ifdef CONFIG_HAVE_RELIABLE_STACKTRACE/** * stack_trace_save_tsk_reliable - Save task stack with verification * @tsk: Pointer to the task to examine * @store: Pointer to storage array * @size: Size of the storage array * * Return: An error if it detects any unreliable features of the * stack. Otherwise it guarantees that the stack trace is * reliable and returns the number of entries stored. * * If the task is not 'current', the caller *must* ensure the task is inactive. */int stack_trace_save_tsk_reliable(struct task_struct *tsk, unsigned long *store, unsigned int size){ stack_trace_consume_fn consume_entry = stack_trace_consume_entry; struct stacktrace_cookie c = { .store = store, .size = size, }; int ret;
/* * If the task doesn't have a stack (e.g., a zombie), the stack is * "reliably" empty. */ if (!try_get_task_stack(tsk)) return 0;
ret = arch_stack_walk_reliable(consume_entry, &c, tsk); put_task_stack(tsk); return ret ? ret : c.len;}#endif
#ifdef CONFIG_USER_STACKTRACE_SUPPORT/** * stack_trace_save_user - Save a user space stack trace into a storage array * @store: Pointer to storage array * @size: Size of the storage array * * Return: Number of trace entries stored. */unsigned int stack_trace_save_user(unsigned long *store, unsigned int size){ stack_trace_consume_fn consume_entry = stack_trace_consume_entry; struct stacktrace_cookie c = { .store = store, .size = size, };
/* Trace user stack if not a kernel thread */ if (current->flags & PF_KTHREAD) return 0;
arch_stack_walk_user(consume_entry, &c, task_pt_regs(current));
return c.len;}#endif
#else /* CONFIG_ARCH_STACKWALK */
/* * Architectures that do not implement save_stack_trace_*() * get these weak aliases and once-per-bootup warnings * (whenever this facility is utilized - for example by procfs): */__weak voidsave_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace){ WARN_ONCE(1, KERN_INFO "save_stack_trace_tsk() not implemented yet.\n");}
__weak voidsave_stack_trace_regs(struct pt_regs *regs, struct stack_trace *trace){ WARN_ONCE(1, KERN_INFO "save_stack_trace_regs() not implemented yet.\n");}
/** * stack_trace_save - Save a stack trace into a storage array * @store: Pointer to storage array * @size: Size of the storage array * @skipnr: Number of entries to skip at the start of the stack trace * * Return: Number of trace entries stored */unsigned int stack_trace_save(unsigned long *store, unsigned int size, unsigned int skipnr){ struct stack_trace trace = { .entries = store, .max_entries = size, .skip = skipnr + 1, };
save_stack_trace(&trace); return trace.nr_entries;}EXPORT_SYMBOL_GPL(stack_trace_save);
/** * stack_trace_save_tsk - Save a task stack trace into a storage array * @task: The task to examine * @store: Pointer to storage array * @size: Size of the storage array * @skipnr: Number of entries to skip at the start of the stack trace * * Return: Number of trace entries stored */unsigned int stack_trace_save_tsk(struct task_struct *task, unsigned long *store, unsigned int size, unsigned int skipnr){ struct stack_trace trace = { .entries = store, .max_entries = size, /* skip this function if they are tracing us */ .skip = skipnr + (current == task), };
save_stack_trace_tsk(task, &trace); return trace.nr_entries;}EXPORT_SYMBOL_GPL(stack_trace_save_tsk);
/** * stack_trace_save_regs - Save a stack trace based on pt_regs into a storage array * @regs: Pointer to pt_regs to examine * @store: Pointer to storage array * @size: Size of the storage array * @skipnr: Number of entries to skip at the start of the stack trace * * Return: Number of trace entries stored */unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store, unsigned int size, unsigned int skipnr){ struct stack_trace trace = { .entries = store, .max_entries = size, .skip = skipnr, };
save_stack_trace_regs(regs, &trace); return trace.nr_entries;}
#ifdef CONFIG_HAVE_RELIABLE_STACKTRACE/** * stack_trace_save_tsk_reliable - Save task stack with verification * @tsk: Pointer to the task to examine * @store: Pointer to storage array * @size: Size of the storage array * * Return: An error if it detects any unreliable features of the * stack. Otherwise it guarantees that the stack trace is * reliable and returns the number of entries stored. * * If the task is not 'current', the caller *must* ensure the task is inactive. */int stack_trace_save_tsk_reliable(struct task_struct *tsk, unsigned long *store, unsigned int size){ struct stack_trace trace = { .entries = store, .max_entries = size, }; int ret = save_stack_trace_tsk_reliable(tsk, &trace);
return ret ? ret : trace.nr_entries;}#endif
#ifdef CONFIG_USER_STACKTRACE_SUPPORT/** * stack_trace_save_user - Save a user space stack trace into a storage array * @store: Pointer to storage array * @size: Size of the storage array * * Return: Number of trace entries stored */unsigned int stack_trace_save_user(unsigned long *store, unsigned int size){ struct stack_trace trace = { .entries = store, .max_entries = size, };
save_stack_trace_user(&trace); return trace.nr_entries;}#endif /* CONFIG_USER_STACKTRACE_SUPPORT */
#endif /* !CONFIG_ARCH_STACKWALK */
static inline bool in_irqentry_text(unsigned long ptr){ return (ptr >= (unsigned long)&__irqentry_text_start && ptr < (unsigned long)&__irqentry_text_end) || (ptr >= (unsigned long)&__softirqentry_text_start && ptr < (unsigned long)&__softirqentry_text_end);}
/** * filter_irq_stacks - Find first IRQ stack entry in trace * @entries: Pointer to stack trace array * @nr_entries: Number of entries in the storage array * * Return: Number of trace entries until IRQ stack starts. */unsigned int filter_irq_stacks(unsigned long *entries, unsigned int nr_entries){ unsigned int i;
for (i = 0; i < nr_entries; i++) { if (in_irqentry_text(entries[i])) { /* Include the irqentry function into the stack. */ return i + 1; } } return nr_entries;}EXPORT_SYMBOL_GPL(filter_irq_stacks);