stacktrace: Consolidate stack trace usage
Subsystems (21)
v3 cover stacktrace: Consolidate stack trace usage
This is an update to V2 which can be found here:
https://lkml.kernel.org/r/[email protected]
Changes vs. V2:
- Fixed the kernel-doc issue pointed out by Mike
- Removed the '-1' oddity from the tracer
- Restricted the tracer nesting to 4
- Restored the lockdep magic to prevent redundant stack traces
- Addressed the small nitpicks here and there
- Picked up Acked/Reviewed tags
The series is based on:
git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git core/stacktrace
which contains the removal of the inconsistent and pointless ULONG_MAX termination of stacktraces.
It's also available from git:
git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git WIP.core/stacktrace
up to 5160eb663575 ("x86/stacktrace: Use common infrastructure")
Delta patch vs. v2 below.
Thanks,
tglx
8<-------------
include/linux/stacktrace.h +6 -5
@@ -32,14 +32,13 @@ unsigned int stack_trace_save_user(unsigned long *store, unsigned int size);* @reliable: True when the stack entry is reliable. Required by * some printk based consumers. * -* Returns: True, if the entry was consumed or skipped +* Return: True, if the entry was consumed or skipped * False, if there is no space left to store */ typedef bool (*stack_trace_consume_fn )(void *cookie,unsigned long addr,bool reliable);/** * arch_stack_walk - Architecture specific function to walk the stack -* @consume_entry: Callback which is invoked by the architecture code for * each entry. * @cookie: Caller supplied pointer which is handed back to
@@ -47,10 +46,12 @@ typedef bool (*stack_trace_consume_fn)(void *cookie, unsigned long addr,* @task: Pointer to a task struct, can be NULL * @regs: Pointer to registers, can be NULL * -* @task @regs: -* NULL NULL Stack trace from current +* ============ ======= ============================================ +* task regs +* ============ ======= ============================================ * task NULL Stack trace from task (can be current) -* NULL regs Stack trace starting on regs->stackpointer +* current regs Stack trace starting on regs->stackpointer +* ============ ======= ============================================ */ void arch_stack_walk (stack_trace_consume_fn consume_entry,void *cookie,struct task_struct *task,struct pt_regs *regs);
kernel/dma/debug.c +2 -1
@@ -705,7 +705,8 @@ static struct dma_debug_entry *dma_entry_alloc(void)#ifdef CONFIG_STACKTRACE entry->stack_len =stack_trace_save (entry->stack_entries, -ARRAY_SIZE (entry->stack_entries),1 ); +ARRAY_SIZE (entry->stack_entries), +1 );#endif return entry; }
kernel/locking/lockdep.c +17 -8
@@ -2160,12 +2160,11 @@ check_deadlock(struct task_struct *curr, struct held_lock *next,*/ static int check_prev_add (struct task_struct *curr,struct held_lock *prev, -struct held_lock *next,int distance) +struct held_lock *next,int distance,struct lock_trace *trace) {struct lock_list *uninitialized_var (target_entry );struct lock_list *entry;struct lock_list this; -struct lock_trace trace;int ret;if (!hlock_class (prev)->key || !hlock_class (next)->key) {
@@ -2198,8 +2197,17 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev, this.class =hlock_class (next); this.parent =NULL ; ret =check_noncircular (&this,hlock_class (prev), &target_entry); -if (unlikely (!ret)) +if (unlikely (!ret)) { +if (!trace->nr_entries) { +/* +* If save_trace fails here, the printing might +* trigger a WARN but because of the !nr_entries it +* should not do bad things. +*/ +save_trace (trace); + }return print_circular_bug (&this, target_entry, next, prev); + }else if (unlikely (ret <0 ))return print_bfs_bug (ret);
@@ -2246,7 +2254,7 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,return print_bfs_bug (ret); -if (!save_trace (&trace)) +if (!trace->nr_entries && !save_trace (trace))return 0 ;/*
@@ -2255,14 +2263,14 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,*/ ret =add_lock_to_list (hlock_class (next),hlock_class (prev), &hlock_class (prev)->locks_after, - next->acquire_ip, distance, &trace); + next->acquire_ip, distance, trace);if (!ret)return 0 ; ret =add_lock_to_list (hlock_class (prev),hlock_class (next), &hlock_class (next)->locks_before, - next->acquire_ip, distance, &trace); + next->acquire_ip, distance, trace);if (!ret)return 0 ;
@@ -2278,6 +2286,7 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,static int check_prevs_add (struct task_struct *curr,struct held_lock *next) { +struct lock_trace trace = { .nr_entries =0 };int depth = curr->lockdep_depth;struct held_lock *hlock;
@@ -2305,8 +2314,8 @@ check_prevs_add(struct task_struct *curr, struct held_lock *next)* added: */ if (hlock->read !=2 && hlock->check) { -int ret =check_prev_add (curr, hlock, next, distance); - +int ret =check_prev_add (curr, hlock, next, distance, + &trace);if (!ret)return 0 ;
kernel/stacktrace.c +17 -7
@@ -39,6 +39,8 @@ EXPORT_SYMBOL_GPL(stack_trace_print);* @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,unsigned long *entries,unsigned int nr_entries,int spaces)
@@ -48,7 +50,7 @@ int stack_trace_snprint(char *buf, size_t size, unsigned long *entries,if (WARN_ON (!entries))return 0 ; -for (i =0 ; i < nr_entries; i++) { +for (i =0 ; i < nr_entries && size; i++) { generated =snprintf (buf, size,"%*c%pS\n" ,1 + spaces,' ' , (void *)entries[i]);
@@ -105,7 +107,7 @@ static bool stack_trace_consume_entry_nosched(void *cookie, unsigned long addr,* @size: Size of the storage array * @skipnr: Number of entries to skip at the start of the stack trace * -* Returns number of entries stored. +* Return: Number of trace entries stored. */ unsigned int stack_trace_save (unsigned long *store,unsigned int size,unsigned int skipnr)
@@ -129,7 +131,7 @@ EXPORT_SYMBOL_GPL(stack_trace_save);* @size: Size of the storage array * @skipnr: Number of entries to skip at the start of the stack trace * -* Returns number of entries stored. +* 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)
@@ -156,7 +158,7 @@ unsigned int stack_trace_save_tsk(struct task_struct *tsk, unsigned long *store,* @size: Size of the storage array * @skipnr: Number of entries to skip at the start of the stack trace * -* Returns number of entries stored. +* 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)
@@ -179,7 +181,7 @@ unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store,* @store: Pointer to storage array * @size: Size of the storage array * -* Returns: An error if it detects any unreliable features of the +* 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. *
@@ -214,7 +216,7 @@ int stack_trace_save_tsk_reliable(struct task_struct *tsk, unsigned long *store,* @store: Pointer to storage array * @size: Size of the storage array * -* Returns number of entries stored. +* Return: Number of trace entries stored. */ unsigned int stack_trace_save_user (unsigned long *store,unsigned int size) {
@@ -265,6 +267,8 @@ save_stack_trace_tsk_reliable(struct task_struct *tsk,* @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)
@@ -286,6 +290,8 @@ EXPORT_SYMBOL_GPL(stack_trace_save);* @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,
@@ -307,6 +313,8 @@ unsigned int stack_trace_save_tsk(struct task_struct *task,* @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)
@@ -328,7 +336,7 @@ unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store,* @store: Pointer to storage array * @size: Size of the storage array * -* Returns: An error if it detects any unreliable features of the +* 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. *
@@ -352,6 +360,8 @@ int stack_trace_save_tsk_reliable(struct task_struct *tsk, unsigned long *store,* 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) {
kernel/trace/trace.c +4 -4
@@ -2751,15 +2751,15 @@ trace_function(struct trace_array *tr, #ifdef CONFIG_STACKTRACE -/* 64 entries for kernel stacks are plenty */ -#define FTRACE_KSTACK_ENTRIES 64 +/* Allow 4 levels of nesting: normal, softirq, irq, NMI */ +#define FTRACE_KSTACK_NESTING 4 + +#define FTRACE_KSTACK_ENTRIES (PAGE_SIZE / FTRACE_KSTACK_NESTING) struct ftrace_stack { unsigned long calls[FTRACE_KSTACK_ENTRIES]; }; -/* This allows 8 level nesting which is plenty */ -#define FTRACE_KSTACK_NESTING (PAGE_SIZE / sizeof(struct ftrace_stack)) struct ftrace_stacks { struct ftrace_stack stacks[FTRACE_KSTACK_NESTING];
kernel/trace/trace_stack.c +2 -1
@@ -394,7 +394,8 @@ stack_trace_sysctl(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos) { - int ret, was_enabled; + int was_enabled; +int ret;mutex_lock (&stack_sysctl_mutex); was_enabled = !!stack_tracer_enabled;
lib/stackdepot.c +5 -1
@@ -197,7 +197,11 @@ static inline struct stack_record *find_stack(struct stack_record *bucket,/** * stack_depot_fetch - Fetch stack entries from a depot * +* @handle: Stack depot handle which was returned from +* stack_depot_save(). * @entries: Pointer to store the entries address +* +* Return: The number of trace entries for this depot. */ unsigned int stack_depot_fetch (depot_stack_handle_t handle,unsigned long **entries)
@@ -219,7 +223,7 @@ EXPORT_SYMBOL_GPL(stack_depot_fetch);* @nr_entries: Size of the storage array * @alloc_flags: Allocation gfp flags * -* Returns the handle of the stack struct stored in depot +* Return: The handle of the stack struct stored in depot */ depot_stack_handle_t stack_depot_save(unsigned long *entries, unsigned int nr_entries,
PATCH v3 1/29 tracing: Cleanup stack trace code
- Remove the extra array member of stack_dump_trace[] along with the ARRAY_SIZE - 1 initialization for struct stack_trace :: max_entries.
Both are historical leftovers of no value. The stack tracer never exceeds the array and there is no extra storage requirement either.
- Make variables which are only used in trace_stack.c static.
- Simplify the enable/disable logic.
- Rename stack_trace_print() as it's using the stack_trace_ namespace. Free the name up for stack trace related functions.
---
V3: Remove the -1 init and split the variable declaration as requested by Steven.
V2: Add more cleanups and use print_max_stack() as requested by Steven.
--- include/linux/ftrace.h | 18 ++++-------------- kernel/trace/trace_stack.c | 42 +++++++++++++----------------------------- 2 files changed, 17 insertions(+), 43 deletions(-)
include/linux/ftrace.h +4 -14
@@ -241,21 +241,11 @@ static inline void ftrace_free_mem(struc#ifdef CONFIG_STACK_TRACER -#define STACK_TRACE_ENTRIES 500 - -struct stack_trace ; - -extern unsigned stack_trace_index[]; -extern struct stack_trace stack_trace_max; -extern unsigned long stack_trace_max_size; -extern arch_spinlock_t stack_trace_max_lock; -extern int stack_tracer_enabled; -void stack_trace_print (void ); -int -stack_trace_sysctl (struct ctl_table *table,int write, -void __user *buffer,size_t *lenp, -loff_t *ppos); + +int stack_trace_sysctl (struct ctl_table *table,int write, +void __user *buffer,size_t *lenp, +loff_t *ppos);/* DO NOT MODIFY THIS VARIABLE DIRECTLY! */ DECLARE_PER_CPU (int, disable_stack_tracer);
kernel/trace/trace_stack.c +13 -29
96 lines not on this page · raw message
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] tracing: Cleanup stack trace code
tracing: Cleanup stack trace code
Commit-ID: 3d9a8072915366b5932beeed97f158f8d4955768 Gitweb: https://git.kernel.org/tip/3d9a8072915366b5932beeed97f158f8d4955768 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:44:54 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:46 +0200
tracing: Cleanup stack trace code
- Remove the extra array member of stack_dump_trace[] along with the ARRAY_SIZE - 1 initialization for struct stack_trace :: max_entries.
Both are historical leftovers of no value. The stack tracer never exceeds the array and there is no extra storage requirement either.
- Make variables which are only used in trace_stack.c static.
- Simplify the enable/disable logic.
- Rename stack_trace_print() as it's using the stack_trace_ namespace. Free the name up for stack trace related functions.
--- include/linux/ftrace.h | 18 ++++-------------- kernel/trace/trace_stack.c | 42 +++++++++++++----------------------------- 2 files changed, 17 insertions(+), 43 deletions(-)
include/linux/ftrace.h +4 -14
@@ -241,21 +241,11 @@ static inline void ftrace_free_mem(struct module *mod, void *start, void *end) {#ifdef CONFIG_STACK_TRACER -#define STACK_TRACE_ENTRIES 500 - -struct stack_trace ; - -extern unsigned stack_trace_index[]; -extern struct stack_trace stack_trace_max; -extern unsigned long stack_trace_max_size; -extern arch_spinlock_t stack_trace_max_lock; -extern int stack_tracer_enabled; -void stack_trace_print (void ); -int -stack_trace_sysctl (struct ctl_table *table,int write, -void __user *buffer,size_t *lenp, -loff_t *ppos); + +int stack_trace_sysctl (struct ctl_table *table,int write, +void __user *buffer,size_t *lenp, +loff_t *ppos);/* DO NOT MODIFY THIS VARIABLE DIRECTLY! */ DECLARE_PER_CPU (int, disable_stack_tracer);
kernel/trace/trace_stack.c +13 -29
96 lines not on this page · raw message
PATCH v3 2/29 stacktrace: Provide helpers for common stack trace operations
In reply to Thomas GleixnerAll operations with stack traces are based on struct stack_trace. That's a horrible construct as the struct is a kitchen sink for input and output. Quite some usage sites embed it into their own data structures which creates weird indirections.
There is absolutely no point in doing so. For all use cases a storage array and the number of valid stack trace entries in the array is sufficient.
Provide helper functions which avoid the struct stack_trace indirection so the usage sites can be cleaned up.
---
V3: Fix kernel doc.
--- include/linux/stacktrace.h | 27 +++++++ kernel/stacktrace.c | 170 +++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 182 insertions(+), 15 deletions(-)
include/linux/stacktrace.h +27 -0
@@ -3,11 +3,26 @@#define __LINUX_STACKTRACE_H#include <linux/types.h> +#include <asm/errno.h> struct task_struct ;struct pt_regs ; #ifdef CONFIG_STACKTRACE +void stack_trace_print(unsigned long *trace, unsigned int nr_entries, + int spaces); +int stack_trace_snprint(char *buf, size_t size, unsigned long *entries, + unsigned int nr_entries, int spaces); +unsigned int stack_trace_save(unsigned long *store, unsigned int size, + unsigned int skipnr); +unsigned int stack_trace_save_tsk(struct task_struct *task, + unsigned long *store, unsigned int size, + unsigned int skipnr); +unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store, + unsigned int size, unsigned int skipnr); +unsigned int stack_trace_save_user(unsigned long *store, unsigned int size); + +/* Internal interfaces. Do not use in generic code */ struct stack_trace { unsigned int nr_entries, max_entries; unsigned long *entries;
@@ -41,4 +56,16 @@ extern void save_stack_trace_user(struct# define save_stack_trace_tsk_reliable (tsk, trace) ({ -ENOSYS; })#endif /* CONFIG_STACKTRACE */ +#if defined(CONFIG_STACKTRACE ) && defined(CONFIG_HAVE_RELIABLE_STACKTRACE ) +int stack_trace_save_tsk_reliable (struct task_struct *tsk,unsigned long *store, +unsigned int size); +#else +static inline int stack_trace_save_tsk_reliable (struct task_struct *tsk, +unsigned long *store, +unsigned int size) +{ +return -ENOSYS ; +} +#endif +#endif /* __LINUX_STACKTRACE_H */
kernel/stacktrace.c +155 -15
199 lines not on this page · raw message
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] stacktrace: Provide helpers for common stack trace operations
stacktrace: Provide helpers for common stack trace operations
Commit-ID: e9b98e162aa53cbea7c8b0d6c9d5dc6e0f822b9c Gitweb: https://git.kernel.org/tip/e9b98e162aa53cbea7c8b0d6c9d5dc6e0f822b9c Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:44:55 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:46 +0200
stacktrace: Provide helpers for common stack trace operations
All operations with stack traces are based on struct stack_trace. That's a horrible construct as the struct is a kitchen sink for input and output. Quite some usage sites embed it into their own data structures which creates weird indirections.
There is absolutely no point in doing so. For all use cases a storage array and the number of valid stack trace entries in the array is sufficient.
Provide helper functions which avoid the struct stack_trace indirection so the usage sites can be cleaned up.
--- include/linux/stacktrace.h | 27 +++++++ kernel/stacktrace.c | 170 +++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 182 insertions(+), 15 deletions(-)
include/linux/stacktrace.h +27 -0
@@ -3,11 +3,26 @@#define __LINUX_STACKTRACE_H#include <linux/types.h> +#include <asm/errno.h> struct task_struct ;struct pt_regs ; #ifdef CONFIG_STACKTRACE +void stack_trace_print(unsigned long *trace, unsigned int nr_entries, + int spaces); +int stack_trace_snprint(char *buf, size_t size, unsigned long *entries, + unsigned int nr_entries, int spaces); +unsigned int stack_trace_save(unsigned long *store, unsigned int size, + unsigned int skipnr); +unsigned int stack_trace_save_tsk(struct task_struct *task, + unsigned long *store, unsigned int size, + unsigned int skipnr); +unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store, + unsigned int size, unsigned int skipnr); +unsigned int stack_trace_save_user(unsigned long *store, unsigned int size); + +/* Internal interfaces. Do not use in generic code */ struct stack_trace { unsigned int nr_entries, max_entries; unsigned long *entries;
@@ -41,4 +56,16 @@ extern void save_stack_trace_user(struct stack_trace *trace);# define save_stack_trace_tsk_reliable (tsk, trace) ({ -ENOSYS; })#endif /* CONFIG_STACKTRACE */ +#if defined(CONFIG_STACKTRACE ) && defined(CONFIG_HAVE_RELIABLE_STACKTRACE ) +int stack_trace_save_tsk_reliable (struct task_struct *tsk,unsigned long *store, +unsigned int size); +#else +static inline int stack_trace_save_tsk_reliable (struct task_struct *tsk, +unsigned long *store, +unsigned int size) +{ +return -ENOSYS ; +} +#endif +#endif /* __LINUX_STACKTRACE_H */
kernel/stacktrace.c +155 -15
199 lines not on this page · raw message
PATCH v3 3/29 lib/stackdepot: Provide functions which operate on plain storage arrays
In reply to Thomas GleixnerThe struct stack_trace indirection in the stack depot functions is a truly pointless excercise which requires horrible code at the callsites.
Provide interfaces based on plain storage arrays.
---
V3: Fix kernel-doc
--- include/linux/stackdepot.h | 4 ++ lib/stackdepot.c | 70 ++++++++++++++++++++++++++++++++------------- 2 files changed, 55 insertions(+), 19 deletions(-)
include/linux/stackdepot.h +4 -0
@@ -26,7 +26,11 @@ typedef u32 depot_stack_handle_t;struct stack_trace ;depot_stack_handle_t depot_save_stack (struct stack_trace *trace,gfp_t flags); +depot_stack_handle_t stack_depot_save (unsigned long *entries, +unsigned int nr_entries,gfp_t gfp_flags);void depot_fetch_stack (depot_stack_handle_t handle,struct stack_trace *trace); +unsigned int stack_depot_fetch (depot_stack_handle_t handle, +unsigned long **entries);#endif
lib/stackdepot.c +51 -19
113 lines not on this page · raw message
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] lib/stackdepot: Provide functions which operate on plain storage arrays
lib/stackdepot: Provide functions which operate on plain storage arrays
Commit-ID: c0cfc337264c5e02e0bc79de6b62857999588879 Gitweb: https://git.kernel.org/tip/c0cfc337264c5e02e0bc79de6b62857999588879 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:44:56 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:47 +0200
lib/stackdepot: Provide functions which operate on plain storage arrays
The struct stack_trace indirection in the stack depot functions is a truly pointless excercise which requires horrible code at the callsites.
Provide interfaces based on plain storage arrays.
--- include/linux/stackdepot.h | 4 +++ lib/stackdepot.c | 70 +++++++++++++++++++++++++++++++++------------- 2 files changed, 55 insertions(+), 19 deletions(-)
include/linux/stackdepot.h +4 -0
@@ -26,7 +26,11 @@ typedef u32 depot_stack_handle_t;struct stack_trace ;depot_stack_handle_t depot_save_stack (struct stack_trace *trace,gfp_t flags); +depot_stack_handle_t stack_depot_save (unsigned long *entries, +unsigned int nr_entries,gfp_t gfp_flags);void depot_fetch_stack (depot_stack_handle_t handle,struct stack_trace *trace); +unsigned int stack_depot_fetch (depot_stack_handle_t handle, +unsigned long **entries);#endif
lib/stackdepot.c +51 -19
113 lines not on this page · raw message
PATCH v3 4/29 backtrace-test: Simplify stack trace handling
In reply to Thomas GleixnerReplace the indirection through struct stack_trace by using the storage array based interfaces.
--- kernel/backtracetest.c | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-)
kernel/backtracetest.c +3 -8
@@ -48,19 +48,14 @@ static void backtrace_test_irq(void)#ifdef CONFIG_STACKTRACE static void backtrace_test_saved (void ) { -struct stack_trace trace;unsigned long entries[8 ]; +unsigned int nr_entries;pr_info ("Testing a saved backtrace.\n" );pr_info ("The following trace is a kernel self test and not a bug!\n" ); - trace.nr_entries =0 ; - trace.max_entries =ARRAY_SIZE (entries); - trace.entries = entries; - trace.skip =0 ; - -save_stack_trace (&trace); -print_stack_trace (&trace,0 ); + nr_entries =stack_trace_save (entries,ARRAY_SIZE (entries),0 ); +stack_trace_print (entries, nr_entries,0 ); }#else static void backtrace_test_saved (void )
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] backtrace-test: Simplify stack trace handling
backtrace-test: Simplify stack trace handling
Commit-ID: 1b59562d3ab09dcef188eb8055d05f0336380394 Gitweb: https://git.kernel.org/tip/1b59562d3ab09dcef188eb8055d05f0336380394 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:44:57 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:47 +0200
backtrace-test: Simplify stack trace handling
Replace the indirection through struct stack_trace by using the storage array based interfaces.
--- kernel/backtracetest.c | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-)
kernel/backtracetest.c +3 -8
@@ -48,19 +48,14 @@ static void backtrace_test_irq(void)#ifdef CONFIG_STACKTRACE static void backtrace_test_saved (void ) { -struct stack_trace trace;unsigned long entries[8 ]; +unsigned int nr_entries;pr_info ("Testing a saved backtrace.\n" );pr_info ("The following trace is a kernel self test and not a bug!\n" ); - trace.nr_entries =0 ; - trace.max_entries =ARRAY_SIZE (entries); - trace.entries = entries; - trace.skip =0 ; - -save_stack_trace (&trace); -print_stack_trace (&trace,0 ); + nr_entries =stack_trace_save (entries,ARRAY_SIZE (entries),0 ); +stack_trace_print (entries, nr_entries,0 ); }#else static void backtrace_test_saved (void )
PATCH v3 5/29 proc: Simplify task stack retrieval
In reply to Thomas GleixnerReplace the indirection through struct stack_trace with an invocation of the storage array based interface.
--- fs/proc/base.c | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-)
fs/proc/base.c +5 -9
@@ -407,7 +407,6 @@ static void unlock_trace(struct task_strstatic int proc_pid_stack (struct seq_file *m,struct pid_namespace *ns,struct pid *pid,struct task_struct *task) { -struct stack_trace trace;unsigned long *entries;int err;
@@ -430,20 +429,17 @@ static int proc_pid_stack(struct seq_filif (!entries)return -ENOMEM ; - trace.nr_entries =0 ; - trace.max_entries =MAX_STACK_TRACE_DEPTH ; - trace.entries = entries; - trace.skip =0 ; - err =lock_trace (task);if (!err) { -unsigned int i; +unsigned int i, nr_entries; -save_stack_trace_tsk (task, &trace); + nr_entries =stack_trace_save_tsk (task, entries, +MAX_STACK_TRACE_DEPTH ,0 ); -for (i =0 ; i < trace.nr_entries; i++) { +for (i =0 ; i < nr_entries; i++) {seq_printf (m,"[<0>] %pB\n" , (void *)entries[i]); } +unlock_trace (task); }kfree (entries);
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] proc: Simplify task stack retrieval
proc: Simplify task stack retrieval
Commit-ID: e988e5ec18d6081efbef645fc2690298ee23a8db Gitweb: https://git.kernel.org/tip/e988e5ec18d6081efbef645fc2690298ee23a8db Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:44:58 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:48 +0200
proc: Simplify task stack retrieval
Replace the indirection through struct stack_trace with an invocation of the storage array based interface.
--- fs/proc/base.c | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-)
fs/proc/base.c +5 -9
@@ -407,7 +407,6 @@ static void unlock_trace(struct task_struct *task)static int proc_pid_stack (struct seq_file *m,struct pid_namespace *ns,struct pid *pid,struct task_struct *task) { -struct stack_trace trace;unsigned long *entries;int err;
@@ -430,20 +429,17 @@ static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns,if (!entries)return -ENOMEM ; - trace.nr_entries =0 ; - trace.max_entries =MAX_STACK_TRACE_DEPTH ; - trace.entries = entries; - trace.skip =0 ; - err =lock_trace (task);if (!err) { -unsigned int i; +unsigned int i, nr_entries; -save_stack_trace_tsk (task, &trace); + nr_entries =stack_trace_save_tsk (task, entries, +MAX_STACK_TRACE_DEPTH ,0 ); -for (i =0 ; i < trace.nr_entries; i++) { +for (i =0 ; i < nr_entries; i++) {seq_printf (m,"[<0>] %pB\n" , (void *)entries[i]); } +unlock_trace (task); }kfree (entries);
PATCH v3 6/29 latency_top: Simplify stack trace handling
In reply to Thomas GleixnerReplace the indirection through struct stack_trace with an invocation of the storage array based interface.
--- kernel/latencytop.c | 17 ++--------------- 1 file changed, 2 insertions(+), 15 deletions(-)
kernel/latencytop.c +2 -15
@@ -141,20 +141,6 @@ account_global_scheduler_latency(structmemcpy (&latency_record[i], lat,sizeof (struct latency_record )); } -/* -* Iterator to store a backtrace into a latency record entry -*/ -static inline void store_stacktrace (struct task_struct *tsk, -struct latency_record *lat) -{ -struct stack_trace trace; - -memset (&trace,0 ,sizeof (trace)); - trace.max_entries =LT_BACKTRACEDEPTH ; - trace.entries = &lat->backtrace[0 ]; -save_stack_trace_tsk (tsk, &trace); -} -/** * __account_scheduler_latency - record an occurred latency * @tsk - the task struct of the task hitting the latency
@@ -191,7 +177,8 @@ void __sched lat.count =1 ; lat.time = usecs; lat.max = usecs; -store_stacktrace (tsk, &lat); + +stack_trace_save_tsk (tsk, lat.backtrace,LT_BACKTRACEDEPTH ,0 );raw_spin_lock_irqsave (&latency_lock, flags);
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] latency_top: Simplify stack trace handling
latency_top: Simplify stack trace handling
Commit-ID: f93877214a83e88373b20801c2d671923d03d07d Gitweb: https://git.kernel.org/tip/f93877214a83e88373b20801c2d671923d03d07d Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:44:59 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:48 +0200
latency_top: Simplify stack trace handling
Replace the indirection through struct stack_trace with an invocation of the storage array based interface.
--- kernel/latencytop.c | 17 ++--------------- 1 file changed, 2 insertions(+), 15 deletions(-)
kernel/latencytop.c +2 -15
@@ -141,20 +141,6 @@ account_global_scheduler_latency(struct task_struct *tsk,memcpy (&latency_record[i], lat,sizeof (struct latency_record )); } -/* -* Iterator to store a backtrace into a latency record entry -*/ -static inline void store_stacktrace (struct task_struct *tsk, -struct latency_record *lat) -{ -struct stack_trace trace; - -memset (&trace,0 ,sizeof (trace)); - trace.max_entries =LT_BACKTRACEDEPTH ; - trace.entries = &lat->backtrace[0 ]; -save_stack_trace_tsk (tsk, &trace); -} -/** * __account_scheduler_latency - record an occurred latency * @tsk - the task struct of the task hitting the latency
@@ -191,7 +177,8 @@ __account_scheduler_latency(struct task_struct *tsk, int usecs, int inter) lat.count =1 ; lat.time = usecs; lat.max = usecs; -store_stacktrace (tsk, &lat); + +stack_trace_save_tsk (tsk, lat.backtrace,LT_BACKTRACEDEPTH ,0 );raw_spin_lock_irqsave (&latency_lock, flags);
PATCH v3 7/29 mm/slub: Simplify stack trace retrieval
In reply to Thomas GleixnerReplace the indirection through struct stack_trace with an invocation of the storage array based interface.
--- mm/slub.c | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-)
mm/slub.c +4 -8
@@ -552,18 +552,14 @@ static void set_track(struct kmem_cacheif (addr) {#ifdef CONFIG_STACKTRACE -struct stack_trace trace; +unsigned int nr_entries; - trace.nr_entries =0 ; - trace.max_entries =TRACK_ADDRS_COUNT ; - trace.entries = p->addrs; - trace.skip =3 ;metadata_access_enable (); -save_stack_trace (&trace); + nr_entries =stack_trace_save (p->addrs,TRACK_ADDRS_COUNT ,3 );metadata_access_disable (); -if (trace.nr_entries <TRACK_ADDRS_COUNT ) - p->addrs[trace.nr_entries] =0 ; +if (nr_entries <TRACK_ADDRS_COUNT ) + p->addrs[nr_entries] =0 ;#endif p->addr = addr; p->cpu =smp_processor_id ();
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] mm/slub: Simplify stack trace retrieval
mm/slub: Simplify stack trace retrieval
Commit-ID: 7971679994d3a239538ddcfea9f89468f0bd65e2 Gitweb: https://git.kernel.org/tip/7971679994d3a239538ddcfea9f89468f0bd65e2 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:00 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:48 +0200
mm/slub: Simplify stack trace retrieval
Replace the indirection through struct stack_trace with an invocation of the storage array based interface.
--- mm/slub.c | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-)
mm/slub.c +4 -8
@@ -552,18 +552,14 @@ static void set_track(struct kmem_cache *s, void *object,if (addr) {#ifdef CONFIG_STACKTRACE -struct stack_trace trace; +unsigned int nr_entries; - trace.nr_entries =0 ; - trace.max_entries =TRACK_ADDRS_COUNT ; - trace.entries = p->addrs; - trace.skip =3 ;metadata_access_enable (); -save_stack_trace (&trace); + nr_entries =stack_trace_save (p->addrs,TRACK_ADDRS_COUNT ,3 );metadata_access_disable (); -if (trace.nr_entries <TRACK_ADDRS_COUNT ) - p->addrs[trace.nr_entries] =0 ; +if (nr_entries <TRACK_ADDRS_COUNT ) + p->addrs[nr_entries] =0 ;#endif p->addr = addr; p->cpu =smp_processor_id ();
PATCH v3 8/29 mm/kmemleak: Simplify stacktrace handling
In reply to Thomas GleixnerReplace the indirection through struct stack_trace by using the storage array based interfaces.
--- mm/kmemleak.c | 24 +++--------------------- 1 file changed, 3 insertions(+), 21 deletions(-)
mm/kmemleak.c +3 -21
@@ -410,11 +410,6 @@ static void print_unreferenced(struct se*/ static void dump_object_info (struct kmemleak_object *object) { -struct stack_trace trace; - - trace.nr_entries = object->trace_len; - trace.entries = object->trace; -pr_notice ("Object 0x%08lx (size %zu):\n" , object->pointer, object->size); pr_notice(" comm \"%s\", pid %d, jiffies %lu\n",
@@ -424,7 +419,7 @@ static void dump_object_info(struct kmempr_notice (" flags = 0x%x\n" , object->flags);pr_notice (" checksum = %u\n" , object->checksum);pr_notice (" backtrace:\n" ); -print_stack_trace (&trace,4 ); +stack_trace_print (object->trace, object->trace_len,4 ); }/*
@@ -553,15 +548,7 @@ static struct kmemleak_object *find_and_*/ static int __save_stack_trace (unsigned long *trace) { -struct stack_trace stack_trace; - - stack_trace.max_entries =MAX_TRACE ; - stack_trace.nr_entries =0 ; - stack_trace.entries = trace; - stack_trace.skip =2 ; -save_stack_trace (&stack_trace); - -return stack_trace.nr_entries; +return stack_trace_save (trace,MAX_TRACE ,2 ); }/*
@@ -2019,13 +2006,8 @@ early_param("kmemleak", kmemleak_boot_costatic void __init print_log_trace (struct early_log *log) { -struct stack_trace trace; - - trace.nr_entries = log->trace_len; - trace.entries = log->trace; -pr_notice ("Early log backtrace:\n" ); -print_stack_trace (&trace,2 ); +stack_trace_print (log->trace, log->trace_len,2 ); }/*
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] mm/kmemleak: Simplify stacktrace handling
mm/kmemleak: Simplify stacktrace handling
Commit-ID: 07984aad1c7ed679596f849c0e7d5e029f76e0eb Gitweb: https://git.kernel.org/tip/07984aad1c7ed679596f849c0e7d5e029f76e0eb Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:01 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:49 +0200
mm/kmemleak: Simplify stacktrace handling
Replace the indirection through struct stack_trace by using the storage array based interfaces.
--- mm/kmemleak.c | 24 +++--------------------- 1 file changed, 3 insertions(+), 21 deletions(-)
mm/kmemleak.c +3 -21
@@ -410,11 +410,6 @@ static void print_unreferenced(struct seq_file *seq,*/ static void dump_object_info (struct kmemleak_object *object) { -struct stack_trace trace; - - trace.nr_entries = object->trace_len; - trace.entries = object->trace; -pr_notice ("Object 0x%08lx (size %zu):\n" , object->pointer, object->size); pr_notice(" comm \"%s\", pid %d, jiffies %lu\n",
@@ -424,7 +419,7 @@ static void dump_object_info(struct kmemleak_object *object)pr_notice (" flags = 0x%x\n" , object->flags);pr_notice (" checksum = %u\n" , object->checksum);pr_notice (" backtrace:\n" ); -print_stack_trace (&trace,4 ); +stack_trace_print (object->trace, object->trace_len,4 ); }/*
@@ -553,15 +548,7 @@ static struct kmemleak_object *find_and_remove_object(unsigned long ptr, int ali*/ static int __save_stack_trace (unsigned long *trace) { -struct stack_trace stack_trace; - - stack_trace.max_entries =MAX_TRACE ; - stack_trace.nr_entries =0 ; - stack_trace.entries = trace; - stack_trace.skip =2 ; -save_stack_trace (&stack_trace); - -return stack_trace.nr_entries; +return stack_trace_save (trace,MAX_TRACE ,2 ); }/*
@@ -2019,13 +2006,8 @@ early_param("kmemleak", kmemleak_boot_config);static void __init print_log_trace (struct early_log *log) { -struct stack_trace trace; - - trace.nr_entries = log->trace_len; - trace.entries = log->trace; -pr_notice ("Early log backtrace:\n" ); -print_stack_trace (&trace,2 ); +stack_trace_print (log->trace, log->trace_len,2 ); }/*
PATCH v3 9/29 mm/kasan: Simplify stacktrace handling
In reply to Thomas GleixnerReplace the indirection through struct stack_trace by using the storage array based interfaces.
--- mm/kasan/common.c | 30 ++++++++++++------------------ mm/kasan/report.c | 7 ++++--- 2 files changed, 16 insertions(+), 21 deletions(-)
mm/kasan/common.c +12 -18
@@ -48,34 +48,28 @@ static inline int in_irqentry_text(unsig ptr < (unsigned long)&__softirqentry_text_end); } -static inline void filter_irq_stacks (struct stack_trace *trace) +static inline unsigned int filter_irq_stacks (unsigned long *entries, +unsigned int nr_entries) { -int i; +unsigned int i; -if (!trace->nr_entries) -return ; -for (i =0 ; i < trace->nr_entries; i++) -if (in_irqentry_text (trace->entries[i])) { +for (i =0 ; i < nr_entries; i++) { +if (in_irqentry_text (entries[i])) {/* Include the irqentry function into the stack. */ - trace->nr_entries = i +1 ; -break ; +return i +1 ; } + } +return nr_entries; }static inline depot_stack_handle_t save_stack (gfp_t flags) {unsigned long entries[KASAN_STACK_DEPTH ]; -struct stack_trace trace = { - .nr_entries =0 , - .entries = entries, - .max_entries =KASAN_STACK_DEPTH , - .skip =0 - }; +unsigned int nr_entries; -save_stack_trace (&trace); -filter_irq_stacks (&trace); - -return depot_save_stack (&trace, flags); + nr_entries =stack_trace_save (entries,ARRAY_SIZE (entries),0 ); + nr_entries =filter_irq_stacks (entries, nr_entries); +return stack_depot_save (entries, nr_entries, flags); }static inline void set_track (struct kasan_track *track,gfp_t flags)
mm/kasan/report.c +4 -3
@@ -100,10 +100,11 @@ static void print_track(struct kasan_tra {pr_err ("%s by task %u:\n" , prefix, track->pid);if (track->stack) { -struct stack_trace trace; +unsigned long *entries; +unsigned int nr_entries; -depot_fetch_stack (track->stack, &trace); -print_stack_trace (&trace,0 ); + nr_entries =stack_depot_fetch (track->stack, &entries); +stack_trace_print (entries, nr_entries,0 ); }else {pr_err ("(stack is not available)\n" ); }
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] mm/kasan: Simplify stacktrace handling
mm/kasan: Simplify stacktrace handling
Commit-ID: 880e049c9ce9020384ce305c71375aa1cb54addb Gitweb: https://git.kernel.org/tip/880e049c9ce9020384ce305c71375aa1cb54addb Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:02 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:49 +0200
mm/kasan: Simplify stacktrace handling
Replace the indirection through struct stack_trace by using the storage array based interfaces.
--- mm/kasan/common.c | 30 ++++++++++++------------------ mm/kasan/report.c | 7 ++++--- 2 files changed, 16 insertions(+), 21 deletions(-)
mm/kasan/common.c +12 -18
@@ -48,34 +48,28 @@ static inline int in_irqentry_text(unsigned long ptr) ptr < (unsigned long)&__softirqentry_text_end); } -static inline void filter_irq_stacks (struct stack_trace *trace) +static inline unsigned int filter_irq_stacks (unsigned long *entries, +unsigned int nr_entries) { -int i; +unsigned int i; -if (!trace->nr_entries) -return ; -for (i =0 ; i < trace->nr_entries; i++) -if (in_irqentry_text (trace->entries[i])) { +for (i =0 ; i < nr_entries; i++) { +if (in_irqentry_text (entries[i])) {/* Include the irqentry function into the stack. */ - trace->nr_entries = i +1 ; -break ; +return i +1 ; } + } +return nr_entries; }static inline depot_stack_handle_t save_stack (gfp_t flags) {unsigned long entries[KASAN_STACK_DEPTH ]; -struct stack_trace trace = { - .nr_entries =0 , - .entries = entries, - .max_entries =KASAN_STACK_DEPTH , - .skip =0 - }; - -save_stack_trace (&trace); -filter_irq_stacks (&trace); +unsigned int nr_entries; -return depot_save_stack (&trace, flags); + nr_entries =stack_trace_save (entries,ARRAY_SIZE (entries),0 ); + nr_entries =filter_irq_stacks (entries, nr_entries); +return stack_depot_save (entries, nr_entries, flags); }static inline void set_track (struct kasan_track *track,gfp_t flags)
mm/kasan/report.c +4 -3
@@ -100,10 +100,11 @@ static void print_track(struct kasan_track *track, const char *prefix) {pr_err ("%s by task %u:\n" , prefix, track->pid);if (track->stack) { -struct stack_trace trace; +unsigned long *entries; +unsigned int nr_entries; -depot_fetch_stack (track->stack, &trace); -print_stack_trace (&trace,0 ); + nr_entries =stack_depot_fetch (track->stack, &entries); +stack_trace_print (entries, nr_entries,0 ); }else {pr_err ("(stack is not available)\n" ); }
PATCH v3 10/29 mm/page_owner: Simplify stack trace handling
In reply to Thomas GleixnerReplace the indirection through struct stack_trace by using the storage array based interfaces.
The original code in all printing functions is really wrong. It allocates a storage array on stack which is unused because depot_fetch_stack() does not store anything in it. It overwrites the entries pointer in the stack_trace struct so it points to the depot storage.
--- mm/page_owner.c | 79 +++++++++++++++++++------------------------------------- 1 file changed, 28 insertions(+), 51 deletions(-)
mm/page_owner.c +28 -51
@@ -58,15 +58,10 @@ static bool need_page_owner(void) static __always_inline depot_stack_handle_t create_dummy_stack(void) {unsigned long entries[4 ]; -struct stack_trace dummy; +unsigned int nr_entries; - dummy.nr_entries =0 ; - dummy.max_entries =ARRAY_SIZE (entries); - dummy.entries = &entries[0 ]; - dummy.skip =0 ; - -save_stack_trace (&dummy); -return depot_save_stack (&dummy,GFP_KERNEL ); + nr_entries =stack_trace_save (entries,ARRAY_SIZE (entries),0 ); +return stack_depot_save (entries, nr_entries,GFP_KERNEL ); } static noinline void register_dummy_stack(void)
@@ -120,46 +115,39 @@ void __reset_page_owner(struct page *pag } } -static inline bool check_recursive_alloc (struct stack_trace *trace, -unsigned long ip) +static inline bool check_recursive_alloc (unsigned long *entries, +unsigned int nr_entries, +unsigned long ip) { -int i; +unsigned int i; -if (!trace->nr_entries) -return false; - -for (i =0 ; i < trace->nr_entries; i++) { -if (trace->entries[i] == ip) +for (i =0 ; i < nr_entries; i++) { +if (entries[i] == ip)return true; } -return false; } static noinline depot_stack_handle_t save_stack(gfp_t flags) {unsigned long entries[PAGE_OWNER_STACK_DEPTH ]; -struct stack_trace trace = { - .nr_entries =0 , - .entries = entries, - .max_entries =PAGE_OWNER_STACK_DEPTH , - .skip =2 - };depot_stack_handle_t handle; +unsigned int nr_entries; -save_stack_trace (&trace); + nr_entries =stack_trace_save (entries,ARRAY_SIZE (entries),2 );/* -* We need to check recursion here because our request to stackdepot -* could trigger memory allocation to save new entry. New memory -* allocation would reach here and call depot_save_stack() again -* if we don't catch it. There is still not enough memory in stackdepot -* so it would try to allocate memory again and loop forever. +* We need to check recursion here because our request to +* stackdepot could trigger memory allocation to save new +* entry. New memory allocation would reach here and call +* stack_depot_save_entries() again if we don't catch it. There is +* still not enough memory in stackdepot so it would try to +* allocate memory again and loop forever. */ -if (check_recursive_alloc (&trace, _RET_IP_)) +if (check_recursive_alloc (entries, nr_entries, _RET_IP_))return dummy_handle; - handle =depot_save_stack (&trace, flags); + handle =stack_depot_save (entries, nr_entries, flags);if (!handle) handle = failure_handle;
@@ -337,16 +325,10 @@ print_page_owner(char __user *buf, size_ struct page *page, struct page_owner *page_owner, depot_stack_handle_t handle) { - int ret; -int pageblock_mt, page_mt; + int ret, pageblock_mt, page_mt; +unsigned long *entries; +unsigned int nr_entries;char *kbuf; -unsigned long entries[PAGE_OWNER_STACK_DEPTH ]; -struct stack_trace trace = { - .nr_entries =0 , - .entries = entries, - .max_entries =PAGE_OWNER_STACK_DEPTH , - .skip =0 - }; count =min_t (size_t, count,PAGE_SIZE ); kbuf =kmalloc (count,GFP_KERNEL );
@@ -375,8 +357,8 @@ print_page_owner(char __user *buf, size_if (ret >= count) goto err; -depot_fetch_stack (handle, &trace); - ret +=snprint_stack_trace (kbuf + ret, count - ret, &trace,0 ); + nr_entries =stack_depot_fetch (handle, &entries); + ret +=stack_trace_snprint (kbuf + ret, count - ret, entries, nr_entries,0 );if (ret >= count) goto err;
@@ -407,14 +389,9 @@ void __dump_page_owner(struct page *page {struct page_ext *page_ext =lookup_page_ext (page);struct page_owner *page_owner; -unsigned long entries[PAGE_OWNER_STACK_DEPTH ]; -struct stack_trace trace = { - .nr_entries =0 , - .entries = entries, - .max_entries =PAGE_OWNER_STACK_DEPTH , - .skip =0 - };depot_stack_handle_t handle; +unsigned long *entries; +unsigned int nr_entries;gfp_t gfp_mask;int mt;
@@ -438,10 +415,10 @@ void __dump_page_owner(struct page *pagereturn ; } -depot_fetch_stack (handle, &trace); + nr_entries =stack_depot_fetch (handle, &entries);pr_alert ("page allocated via order %u, migratetype %s, gfp_mask %#x(%pGg)\n" , page_owner->order, migratetype_names[mt], gfp_mask, &gfp_mask); -print_stack_trace (&trace,0 ); +stack_trace_print (entries, nr_entries,0 );if (page_owner->last_migrate_reason !=-1 ) pr_alert("page has been migrated, last migrate reason: %s\n",
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] mm/page_owner: Simplify stack trace handling
mm/page_owner: Simplify stack trace handling
Commit-ID: af52bf6b92f7d8783c1e712cad6ef7d37cd773b2 Gitweb: https://git.kernel.org/tip/af52bf6b92f7d8783c1e712cad6ef7d37cd773b2 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:03 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:50 +0200
mm/page_owner: Simplify stack trace handling
Replace the indirection through struct stack_trace by using the storage array based interfaces.
The original code in all printing functions is really wrong. It allocates a storage array on stack which is unused because depot_fetch_stack() does not store anything in it. It overwrites the entries pointer in the stack_trace struct so it points to the depot storage.
--- mm/page_owner.c | 79 ++++++++++++++++++++------------------------------------- 1 file changed, 28 insertions(+), 51 deletions(-)
mm/page_owner.c +28 -51
@@ -58,15 +58,10 @@ static bool need_page_owner(void) static __always_inline depot_stack_handle_t create_dummy_stack(void) {unsigned long entries[4 ]; -struct stack_trace dummy; +unsigned int nr_entries; - dummy.nr_entries =0 ; - dummy.max_entries =ARRAY_SIZE (entries); - dummy.entries = &entries[0 ]; - dummy.skip =0 ; - -save_stack_trace (&dummy); -return depot_save_stack (&dummy,GFP_KERNEL ); + nr_entries =stack_trace_save (entries,ARRAY_SIZE (entries),0 ); +return stack_depot_save (entries, nr_entries,GFP_KERNEL ); } static noinline void register_dummy_stack(void)
@@ -120,46 +115,39 @@ void __reset_page_owner(struct page *page, unsigned int order) } } -static inline bool check_recursive_alloc (struct stack_trace *trace, -unsigned long ip) +static inline bool check_recursive_alloc (unsigned long *entries, +unsigned int nr_entries, +unsigned long ip) { -int i; - -if (!trace->nr_entries) -return false; +unsigned int i; -for (i =0 ; i < trace->nr_entries; i++) { -if (trace->entries[i] == ip) +for (i =0 ; i < nr_entries; i++) { +if (entries[i] == ip)return true; } -return false; } static noinline depot_stack_handle_t save_stack(gfp_t flags) {unsigned long entries[PAGE_OWNER_STACK_DEPTH ]; -struct stack_trace trace = { - .nr_entries =0 , - .entries = entries, - .max_entries =PAGE_OWNER_STACK_DEPTH , - .skip =2 - };depot_stack_handle_t handle; +unsigned int nr_entries; -save_stack_trace (&trace); + nr_entries =stack_trace_save (entries,ARRAY_SIZE (entries),2 );/* -* We need to check recursion here because our request to stackdepot -* could trigger memory allocation to save new entry. New memory -* allocation would reach here and call depot_save_stack() again -* if we don't catch it. There is still not enough memory in stackdepot -* so it would try to allocate memory again and loop forever. +* We need to check recursion here because our request to +* stackdepot could trigger memory allocation to save new +* entry. New memory allocation would reach here and call +* stack_depot_save_entries() again if we don't catch it. There is +* still not enough memory in stackdepot so it would try to +* allocate memory again and loop forever. */ -if (check_recursive_alloc (&trace, _RET_IP_)) +if (check_recursive_alloc (entries, nr_entries, _RET_IP_))return dummy_handle; - handle =depot_save_stack (&trace, flags); + handle =stack_depot_save (entries, nr_entries, flags);if (!handle) handle = failure_handle;
@@ -337,16 +325,10 @@ print_page_owner(char __user *buf, size_t count, unsigned long pfn, struct page *page, struct page_owner *page_owner, depot_stack_handle_t handle) { - int ret; -int pageblock_mt, page_mt; + int ret, pageblock_mt, page_mt; +unsigned long *entries; +unsigned int nr_entries;char *kbuf; -unsigned long entries[PAGE_OWNER_STACK_DEPTH ]; -struct stack_trace trace = { - .nr_entries =0 , - .entries = entries, - .max_entries =PAGE_OWNER_STACK_DEPTH , - .skip =0 - }; count =min_t (size_t, count,PAGE_SIZE ); kbuf =kmalloc (count,GFP_KERNEL );
@@ -375,8 +357,8 @@ print_page_owner(char __user *buf, size_t count, unsigned long pfn,if (ret >= count) goto err; -depot_fetch_stack (handle, &trace); - ret +=snprint_stack_trace (kbuf + ret, count - ret, &trace,0 ); + nr_entries =stack_depot_fetch (handle, &entries); + ret +=stack_trace_snprint (kbuf + ret, count - ret, entries, nr_entries,0 );if (ret >= count) goto err;
@@ -407,14 +389,9 @@ void __dump_page_owner(struct page *page) {struct page_ext *page_ext =lookup_page_ext (page);struct page_owner *page_owner; -unsigned long entries[PAGE_OWNER_STACK_DEPTH ]; -struct stack_trace trace = { - .nr_entries =0 , - .entries = entries, - .max_entries =PAGE_OWNER_STACK_DEPTH , - .skip =0 - };depot_stack_handle_t handle; +unsigned long *entries; +unsigned int nr_entries;gfp_t gfp_mask;int mt;
@@ -438,10 +415,10 @@ void __dump_page_owner(struct page *page)return ; } -depot_fetch_stack (handle, &trace); + nr_entries =stack_depot_fetch (handle, &entries);pr_alert ("page allocated via order %u, migratetype %s, gfp_mask %#x(%pGg)\n" , page_owner->order, migratetype_names[mt], gfp_mask, &gfp_mask); -print_stack_trace (&trace,0 ); +stack_trace_print (entries, nr_entries,0 );if (page_owner->last_migrate_reason !=-1 ) pr_alert("page has been migrated, last migrate reason: %s\n",
PATCH v3 11/29 fault-inject: Simplify stacktrace retrieval
In reply to Thomas GleixnerReplace the indirection through struct stack_trace with an invocation of the storage array based interface.
--- lib/fault-inject.c | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-)
lib/fault-inject.c +3 -9
@@ -65,22 +65,16 @@ static bool fail_task(struct fault_attrstatic bool fail_stacktrace (struct fault_attr *attr) { -struct stack_trace trace;int depth = attr->stacktrace_depth;unsigned long entries[MAX_STACK_TRACE_DEPTH ]; -int n; +int n, nr_entries;bool found = (attr->require_start ==0 && attr->require_end ==ULONG_MAX );if (depth ==0 )return found; - trace.nr_entries =0 ; - trace.entries = entries; - trace.max_entries = depth; - trace.skip =1 ; - -save_stack_trace (&trace); -for (n =0 ; n < trace.nr_entries; n++) { + nr_entries =stack_trace_save (entries, depth,1 ); +for (n =0 ; n < nr_entries; n++) {if (attr->reject_start <= entries[n] && entries[n] < attr->reject_end)return false;
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] fault-inject: Simplify stacktrace retrieval
fault-inject: Simplify stacktrace retrieval
Commit-ID: 30191250c2b3ef772cc6125e1c31ac84123f1d20 Gitweb: https://git.kernel.org/tip/30191250c2b3ef772cc6125e1c31ac84123f1d20 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:04 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:50 +0200
fault-inject: Simplify stacktrace retrieval
Replace the indirection through struct stack_trace with an invocation of the storage array based interface.
--- lib/fault-inject.c | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-)
lib/fault-inject.c +3 -9
@@ -65,22 +65,16 @@ static bool fail_task(struct fault_attr *attr, struct task_struct *task)static bool fail_stacktrace (struct fault_attr *attr) { -struct stack_trace trace;int depth = attr->stacktrace_depth;unsigned long entries[MAX_STACK_TRACE_DEPTH ]; -int n; +int n, nr_entries;bool found = (attr->require_start ==0 && attr->require_end ==ULONG_MAX );if (depth ==0 )return found; - trace.nr_entries =0 ; - trace.entries = entries; - trace.max_entries = depth; - trace.skip =1 ; - -save_stack_trace (&trace); -for (n =0 ; n < trace.nr_entries; n++) { + nr_entries =stack_trace_save (entries, depth,1 ); +for (n =0 ; n < nr_entries; n++) {if (attr->reject_start <= entries[n] && entries[n] < attr->reject_end)return false;
PATCH v3 12/29 dma/debug: Simplify stracktrace retrieval
In reply to Thomas GleixnerReplace the indirection through struct stack_trace with an invocation of the storage array based interface.
--- kernel/dma/debug.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-)
kernel/dma/debug.c +6 -8
@@ -89,8 +89,8 @@ struct dma_debug_entry {int sg_mapped_ents;enum map_err_types map_err_type;#ifdef CONFIG_STACKTRACE -struct stack_trace stacktrace; -unsigned long st_entries[DMA_DEBUG_STACKTRACE_ENTRIES ]; +unsigned int stack_len; +unsigned long stack_entries[DMA_DEBUG_STACKTRACE_ENTRIES ];#endif };
@@ -174,7 +174,7 @@ static inline void dump_entry_trace(stru#ifdef CONFIG_STACKTRACE if (entry) {pr_warning ("Mapped at:\n" ); -print_stack_trace (&entry->stacktrace,0 ); +stack_trace_print (entry->stack_entries, entry->stack_len,0 ); }#endif }
@@ -704,12 +704,10 @@ static struct dma_debug_entry *dma_entryspin_unlock_irqrestore (&free_entries_lock, flags);#ifdef CONFIG_STACKTRACE - entry->stacktrace.max_entries =DMA_DEBUG_STACKTRACE_ENTRIES ; - entry->stacktrace.entries = entry->st_entries; - entry->stacktrace.skip =1 ; -save_stack_trace (&entry->stacktrace); + entry->stack_len =stack_trace_save (entry->stack_entries, +ARRAY_SIZE (entry->stack_entries), +1 );#endif -return entry; }
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] dma/debug: Simplify stracktrace retrieval
dma/debug: Simplify stracktrace retrieval
Commit-ID: 746017ed8d4d3c2070bb03aee9536f24da43c778 Gitweb: https://git.kernel.org/tip/746017ed8d4d3c2070bb03aee9536f24da43c778 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:05 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:50 +0200
dma/debug: Simplify stracktrace retrieval
Replace the indirection through struct stack_trace with an invocation of the storage array based interface.
--- kernel/dma/debug.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-)
kernel/dma/debug.c +6 -8
@@ -89,8 +89,8 @@ struct dma_debug_entry {int sg_mapped_ents;enum map_err_types map_err_type;#ifdef CONFIG_STACKTRACE -struct stack_trace stacktrace; -unsigned long st_entries[DMA_DEBUG_STACKTRACE_ENTRIES ]; +unsigned int stack_len; +unsigned long stack_entries[DMA_DEBUG_STACKTRACE_ENTRIES ];#endif };
@@ -174,7 +174,7 @@ static inline void dump_entry_trace(struct dma_debug_entry *entry)#ifdef CONFIG_STACKTRACE if (entry) {pr_warning ("Mapped at:\n" ); -print_stack_trace (&entry->stacktrace,0 ); +stack_trace_print (entry->stack_entries, entry->stack_len,0 ); }#endif }
@@ -704,12 +704,10 @@ static struct dma_debug_entry *dma_entry_alloc(void)spin_unlock_irqrestore (&free_entries_lock, flags);#ifdef CONFIG_STACKTRACE - entry->stacktrace.max_entries =DMA_DEBUG_STACKTRACE_ENTRIES ; - entry->stacktrace.entries = entry->st_entries; - entry->stacktrace.skip =1 ; -save_stack_trace (&entry->stacktrace); + entry->stack_len =stack_trace_save (entry->stack_entries, +ARRAY_SIZE (entry->stack_entries), +1 );#endif -return entry; }
PATCH v3 13/29 btrfs: ref-verify: Simplify stack trace retrieval
In reply to Thomas GleixnerReplace the indirection through struct stack_trace with an invocation of the storage array based interface.
--- fs/btrfs/ref-verify.c | 15 ++------------- 1 file changed, 2 insertions(+), 13 deletions(-)
fs/btrfs/ref-verify.c +2 -13
@@ -205,28 +205,17 @@ static struct root_entry *lookup_root_en#ifdef CONFIG_STACKTRACE static void __save_stack_trace (struct ref_action *ra) { -struct stack_trace stack_trace; - - stack_trace.max_entries =MAX_TRACE ; - stack_trace.nr_entries =0 ; - stack_trace.entries = ra->trace; - stack_trace.skip =2 ; -save_stack_trace (&stack_trace); - ra->trace_len = stack_trace.nr_entries; + ra->trace_len =stack_trace_save (ra->trace,MAX_TRACE ,2 ); }static void __print_stack_trace (struct btrfs_fs_info *fs_info,struct ref_action *ra) { -struct stack_trace trace; -if (ra->trace_len ==0 ) {btrfs_err (fs_info," ref-verify: no stacktrace" );return ; } - trace.nr_entries = ra->trace_len; - trace.entries = ra->trace; -print_stack_trace (&trace,2 ); +stack_trace_print (ra->trace, ra->trace_len,2 ); }#else static void inline __save_stack_trace (struct ref_action *ra)
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] btrfs: ref-verify: Simplify stack trace retrieval
btrfs: ref-verify: Simplify stack trace retrieval
Commit-ID: 6924f5feba21ea2bba64b4dc316ee046c48355ca Gitweb: https://git.kernel.org/tip/6924f5feba21ea2bba64b4dc316ee046c48355ca Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:06 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:51 +0200
btrfs: ref-verify: Simplify stack trace retrieval
Replace the indirection through struct stack_trace with an invocation of the storage array based interface.
--- fs/btrfs/ref-verify.c | 15 ++------------- 1 file changed, 2 insertions(+), 13 deletions(-)
fs/btrfs/ref-verify.c +2 -13
@@ -205,28 +205,17 @@ static struct root_entry *lookup_root_entry(struct rb_root *root, u64 objectid)#ifdef CONFIG_STACKTRACE static void __save_stack_trace (struct ref_action *ra) { -struct stack_trace stack_trace; - - stack_trace.max_entries =MAX_TRACE ; - stack_trace.nr_entries =0 ; - stack_trace.entries = ra->trace; - stack_trace.skip =2 ; -save_stack_trace (&stack_trace); - ra->trace_len = stack_trace.nr_entries; + ra->trace_len =stack_trace_save (ra->trace,MAX_TRACE ,2 ); }static void __print_stack_trace (struct btrfs_fs_info *fs_info,struct ref_action *ra) { -struct stack_trace trace; -if (ra->trace_len ==0 ) {btrfs_err (fs_info," ref-verify: no stacktrace" );return ; } - trace.nr_entries = ra->trace_len; - trace.entries = ra->trace; -print_stack_trace (&trace,2 ); +stack_trace_print (ra->trace, ra->trace_len,2 ); }#else static void inline __save_stack_trace (struct ref_action *ra)
PATCH v3 14/29 dm bufio: Simplify stack trace retrieval
In reply to Thomas GleixnerReplace the indirection through struct stack_trace with an invocation of the storage array based interface.
--- drivers/md/dm-bufio.c | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-)
drivers/md/dm-bufio.c +6 -9
@@ -150,7 +150,7 @@ struct dm_buffer {void (*end_io)(struct dm_buffer *,blk_status_t );#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING #define MAX_STACK 10 -struct stack_trace stack_trace; +unsigned int stack_len;unsigned long stack_entries[MAX_STACK ];#endif };
@@ -232,11 +232,7 @@ static DEFINE_MUTEX(dm_bufio_clients_loc#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING static void buffer_record_stack (struct dm_buffer *b) { - b->stack_trace.nr_entries =0 ; - b->stack_trace.max_entries =MAX_STACK ; - b->stack_trace.entries = b->stack_entries; - b->stack_trace.skip =2 ; -save_stack_trace (&b->stack_trace); + b->stack_len =stack_trace_save (b->stack_entries,MAX_STACK ,2 ); }#endif
@@ -438,7 +434,7 @@ static struct dm_buffer *alloc_buffer(stadjust_total_allocated (b->data_mode, (long )c->block_size);#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING -memset (&b->stack_trace,0 ,sizeof (b->stack_trace)); + b->stack_len =0 ;#endif return b; }
@@ -1520,8 +1516,9 @@ static void drop_buffers(struct dm_bufioDMERR ("leaked buffer %llx, hold count %u, list %d" , (unsigned long long )b->block, b->hold_count, i);#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING -print_stack_trace (&b->stack_trace,1 ); - b->hold_count =0 ;/* mark unclaimed to avoid BUG_ON below */ +stack_trace_print (b->stack_entries, b->stack_len,1 ); +/* mark unclaimed to avoid BUG_ON below */ + b->hold_count =0 ;#endif }
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] dm bufio: Simplify stack trace retrieval
dm bufio: Simplify stack trace retrieval
Commit-ID: 741b58f3e23673a666c700361711a91022a69e56 Gitweb: https://git.kernel.org/tip/741b58f3e23673a666c700361711a91022a69e56 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:07 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:52 +0200
dm bufio: Simplify stack trace retrieval
Replace the indirection through struct stack_trace with an invocation of the storage array based interface.
--- drivers/md/dm-bufio.c | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-)
drivers/md/dm-bufio.c +6 -9
@@ -150,7 +150,7 @@ struct dm_buffer {void (*end_io)(struct dm_buffer *,blk_status_t );#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING #define MAX_STACK 10 -struct stack_trace stack_trace; +unsigned int stack_len;unsigned long stack_entries[MAX_STACK ];#endif };
@@ -232,11 +232,7 @@ static DEFINE_MUTEX(dm_bufio_clients_lock);#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING static void buffer_record_stack (struct dm_buffer *b) { - b->stack_trace.nr_entries =0 ; - b->stack_trace.max_entries =MAX_STACK ; - b->stack_trace.entries = b->stack_entries; - b->stack_trace.skip =2 ; -save_stack_trace (&b->stack_trace); + b->stack_len =stack_trace_save (b->stack_entries,MAX_STACK ,2 ); }#endif
@@ -438,7 +434,7 @@ static struct dm_buffer *alloc_buffer(struct dm_bufio_client *c, gfp_t gfp_mask)adjust_total_allocated (b->data_mode, (long )c->block_size);#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING -memset (&b->stack_trace,0 ,sizeof (b->stack_trace)); + b->stack_len =0 ;#endif return b; }
@@ -1520,8 +1516,9 @@ static void drop_buffers(struct dm_bufio_client *c)DMERR ("leaked buffer %llx, hold count %u, list %d" , (unsigned long long )b->block, b->hold_count, i);#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING -print_stack_trace (&b->stack_trace,1 ); - b->hold_count =0 ;/* mark unclaimed to avoid BUG_ON below */ +stack_trace_print (b->stack_entries, b->stack_len,1 ); +/* mark unclaimed to avoid BUG_ON below */ + b->hold_count =0 ;#endif }
PATCH v3 15/29 dm persistent data: Simplify stack trace handling
In reply to Thomas GleixnerReplace the indirection through struct stack_trace with an invocation of the storage array based interface. This results in less storage space and indirection.
--- drivers/md/persistent-data/dm-block-manager.c | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-)
drivers/md/persistent-data/dm-block-manager.c +9 -10
@@ -35,7 +35,10 @@#define MAX_HOLDERS 4#define MAX_STACK 10 -typedef unsigned long stack_entries [MAX_STACK ]; +struct stack_store { +unsigned int nr_entries; +unsigned long entries[MAX_STACK ]; +};struct block_lock {spinlock_t lock;
@@ -44,8 +47,7 @@ struct block_lock {struct task_struct *holders[MAX_HOLDERS ];#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING -struct stack_trace traces[MAX_HOLDERS ]; -stack_entries entries[MAX_HOLDERS ]; +struct stack_store traces[MAX_HOLDERS ];#endif };
@@ -73,7 +75,7 @@ static void __add_holder(struct block_lo {unsigned h =__find_holder (lock,NULL );#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING -struct stack_trace *t; +struct stack_store *t;#endif get_task_struct (task);
@@ -81,11 +83,7 @@ static void __add_holder(struct block_lo#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING t = lock->traces + h; - t->nr_entries =0 ; - t->max_entries =MAX_STACK ; - t->entries = lock->entries[h]; - t->skip =2 ; -save_stack_trace (t); + t->nr_entries =stack_trace_save (t->entries,MAX_STACK ,2 );#endif }
@@ -106,7 +104,8 @@ static int __check_holder(struct block_lDMERR ("recursive lock detected in metadata" );#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING DMERR ("previously held here:" ); -print_stack_trace (lock->traces + i,4 ); +stack_trace_print (lock->traces[i].entries, + lock->traces[i].nr_entries,4 );DMERR ("subsequent acquisition attempted here:" );dump_stack ();
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] dm persistent data: Simplify stack trace handling
dm persistent data: Simplify stack trace handling
Commit-ID: be9c52ed84eb0949fed3d4140e35ea70eecb02a2 Gitweb: https://git.kernel.org/tip/be9c52ed84eb0949fed3d4140e35ea70eecb02a2 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:08 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:52 +0200
dm persistent data: Simplify stack trace handling
Replace the indirection through struct stack_trace with an invocation of the storage array based interface. This results in less storage space and indirection.
--- drivers/md/persistent-data/dm-block-manager.c | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-)
drivers/md/persistent-data/dm-block-manager.c +9 -10
@@ -35,7 +35,10 @@#define MAX_HOLDERS 4#define MAX_STACK 10 -typedef unsigned long stack_entries [MAX_STACK ]; +struct stack_store { +unsigned int nr_entries; +unsigned long entries[MAX_STACK ]; +};struct block_lock {spinlock_t lock;
@@ -44,8 +47,7 @@ struct block_lock {struct task_struct *holders[MAX_HOLDERS ];#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING -struct stack_trace traces[MAX_HOLDERS ]; -stack_entries entries[MAX_HOLDERS ]; +struct stack_store traces[MAX_HOLDERS ];#endif };
@@ -73,7 +75,7 @@ static void __add_holder(struct block_lock *lock, struct task_struct *task) {unsigned h =__find_holder (lock,NULL );#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING -struct stack_trace *t; +struct stack_store *t;#endif get_task_struct (task);
@@ -81,11 +83,7 @@ static void __add_holder(struct block_lock *lock, struct task_struct *task)#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING t = lock->traces + h; - t->nr_entries =0 ; - t->max_entries =MAX_STACK ; - t->entries = lock->entries[h]; - t->skip =2 ; -save_stack_trace (t); + t->nr_entries =stack_trace_save (t->entries,MAX_STACK ,2 );#endif }
@@ -106,7 +104,8 @@ static int __check_holder(struct block_lock *lock)DMERR ("recursive lock detected in metadata" );#ifdef CONFIG_DM_DEBUG_BLOCK_STACK_TRACING DMERR ("previously held here:" ); -print_stack_trace (lock->traces + i,4 ); +stack_trace_print (lock->traces[i].entries, + lock->traces[i].nr_entries,4 );DMERR ("subsequent acquisition attempted here:" );dump_stack ();
PATCH v3 16/29 drm: Simplify stacktrace handling
In reply to Thomas GleixnerReplace the indirection through struct stack_trace by using the storage array based interfaces.
The original code in all printing functions is really wrong. It allocates a storage array on stack which is unused because depot_fetch_stack() does not store anything in it. It overwrites the entries pointer in the stack_trace struct so it points to the depot storage.
--- drivers/gpu/drm/drm_mm.c | 22 +++++++--------------- drivers/gpu/drm/i915/i915_vma.c | 11 ++++------- drivers/gpu/drm/i915/intel_runtime_pm.c | 21 +++++++-------------- 3 files changed, 18 insertions(+), 36 deletions(-)
drivers/gpu/drm/drm_mm.c +7 -15
@@ -106,22 +106,19 @@ static noinline void save_stack(struct drm_mm_node *node) {unsigned long entries[STACKDEPTH ]; -struct stack_trace trace = { - .entries = entries, - .max_entries =STACKDEPTH , - .skip =1 - }; +unsigned int n; -save_stack_trace (&trace); + n =stack_trace_save (entries,ARRAY_SIZE (entries),1 );/* May be called under spinlock, so avoid sleeping */ - node->stack =depot_save_stack (&trace,GFP_NOWAIT ); + node->stack =stack_depot_save (entries, n,GFP_NOWAIT ); }static void show_leaks (struct drm_mm *mm) {struct drm_mm_node *node; -unsigned long entries[STACKDEPTH ]; +unsigned long *entries; +unsigned int nr_entries;char *buf; buf =kmalloc (BUFSZ ,GFP_KERNEL );
@@ -129,19 +126,14 @@ static void show_leaks(struct drm_mm *mmreturn ;list_for_each_entry (node,drm_mm_nodes (mm), node_list) { -struct stack_trace trace = { - .entries = entries, - .max_entries =STACKDEPTH - }; -if (!node->stack) {DRM_ERROR ("node [%08llx + %08llx]: unknown owner\n" , node->start, node->size);continue ; } -depot_fetch_stack (node->stack, &trace); -snprint_stack_trace (buf,BUFSZ , &trace,0 ); + nr_entries =stack_depot_fetch (node->stack, &entries); +stack_trace_snprint (buf,BUFSZ , entries, nr_entries,0 );DRM_ERROR ("node [%08llx + %08llx]: inserted at\n%s" , node->start, node->size, buf); }
drivers/gpu/drm/i915/i915_vma.c +4 -7
@@ -36,11 +36,8 @@static void vma_print_allocator (struct i915_vma *vma,const char *reason) { -unsigned long entries[12 ]; -struct stack_trace trace = { - .entries = entries, - .max_entries =ARRAY_SIZE (entries), - }; +unsigned long *entries; +unsigned int nr_entries;char buf[512 ];if (!vma->node.stack) {
@@ -49,8 +46,8 @@ static void vma_print_allocator(struct ireturn ; } -depot_fetch_stack (vma->node.stack, &trace); -snprint_stack_trace (buf,sizeof (buf), &trace,0 ); + nr_entries =stack_depot_fetch (vma->node.stack, &entries); +stack_trace_snprint (buf,sizeof (buf), entries, nr_entries,0 );DRM_DEBUG_DRIVER ("vma.node [%08llx + %08llx] %s: inserted at %s\n" , vma->node.start, vma->node.size, reason, buf); }
drivers/gpu/drm/i915/intel_runtime_pm.c +7 -14
@@ -60,27 +60,20 @@ static noinline depot_stack_handle_t __save_depot_stack(void) {unsigned long entries[STACKDEPTH ]; -struct stack_trace trace = { - .entries = entries, - .max_entries =ARRAY_SIZE (entries), - .skip =1 , - }; +unsigned int n; -save_stack_trace (&trace); -return depot_save_stack (&trace,GFP_NOWAIT | __GFP_NOWARN); + n =stack_trace_save (entries,ARRAY_SIZE (entries),1 ); +return stack_depot_save (entries, n,GFP_NOWAIT | __GFP_NOWARN); }static void __print_depot_stack (depot_stack_handle_t stack,char *buf,int sz,int indent) { -unsigned long entries[STACKDEPTH ]; -struct stack_trace trace = { - .entries = entries, - .max_entries =ARRAY_SIZE (entries), - }; +unsigned long *entries; +unsigned int nr_entries; -depot_fetch_stack (stack, &trace); -snprint_stack_trace (buf, sz, &trace, indent); + nr_entries =stack_depot_fetch (stack, &entries); +stack_trace_snprint (buf, sz, entries, nr_entries, indent); }static void init_intel_runtime_pm_wakeref (struct drm_i915_private *i915)
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] drm: Simplify stacktrace handling
drm: Simplify stacktrace handling
Commit-ID: 487f3c7fb1a07ceff78bb18688eb8538a4775227 Gitweb: https://git.kernel.org/tip/487f3c7fb1a07ceff78bb18688eb8538a4775227 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:09 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:53 +0200
drm: Simplify stacktrace handling
Replace the indirection through struct stack_trace by using the storage array based interfaces.
The original code in all printing functions is really wrong. It allocates a storage array on stack which is unused because depot_fetch_stack() does not store anything in it. It overwrites the entries pointer in the stack_trace struct so it points to the depot storage.
--- drivers/gpu/drm/drm_mm.c | 22 +++++++--------------- drivers/gpu/drm/i915/i915_vma.c | 11 ++++------- drivers/gpu/drm/i915/intel_runtime_pm.c | 21 +++++++-------------- 3 files changed, 18 insertions(+), 36 deletions(-)
drivers/gpu/drm/drm_mm.c +7 -15
@@ -106,22 +106,19 @@ static noinline void save_stack(struct drm_mm_node *node) {unsigned long entries[STACKDEPTH ]; -struct stack_trace trace = { - .entries = entries, - .max_entries =STACKDEPTH , - .skip =1 - }; +unsigned int n; -save_stack_trace (&trace); + n =stack_trace_save (entries,ARRAY_SIZE (entries),1 );/* May be called under spinlock, so avoid sleeping */ - node->stack =depot_save_stack (&trace,GFP_NOWAIT ); + node->stack =stack_depot_save (entries, n,GFP_NOWAIT ); }static void show_leaks (struct drm_mm *mm) {struct drm_mm_node *node; -unsigned long entries[STACKDEPTH ]; +unsigned long *entries; +unsigned int nr_entries;char *buf; buf =kmalloc (BUFSZ ,GFP_KERNEL );
@@ -129,19 +126,14 @@ static void show_leaks(struct drm_mm *mm)return ;list_for_each_entry (node,drm_mm_nodes (mm), node_list) { -struct stack_trace trace = { - .entries = entries, - .max_entries =STACKDEPTH - }; -if (!node->stack) {DRM_ERROR ("node [%08llx + %08llx]: unknown owner\n" , node->start, node->size);continue ; } -depot_fetch_stack (node->stack, &trace); -snprint_stack_trace (buf,BUFSZ , &trace,0 ); + nr_entries =stack_depot_fetch (node->stack, &entries); +stack_trace_snprint (buf,BUFSZ , entries, nr_entries,0 );DRM_ERROR ("node [%08llx + %08llx]: inserted at\n%s" , node->start, node->size, buf); }
drivers/gpu/drm/i915/i915_vma.c +4 -7
@@ -36,11 +36,8 @@static void vma_print_allocator (struct i915_vma *vma,const char *reason) { -unsigned long entries[12 ]; -struct stack_trace trace = { - .entries = entries, - .max_entries =ARRAY_SIZE (entries), - }; +unsigned long *entries; +unsigned int nr_entries;char buf[512 ];if (!vma->node.stack) {
@@ -49,8 +46,8 @@ static void vma_print_allocator(struct i915_vma *vma, const char *reason)return ; } -depot_fetch_stack (vma->node.stack, &trace); -snprint_stack_trace (buf,sizeof (buf), &trace,0 ); + nr_entries =stack_depot_fetch (vma->node.stack, &entries); +stack_trace_snprint (buf,sizeof (buf), entries, nr_entries,0 );DRM_DEBUG_DRIVER ("vma.node [%08llx + %08llx] %s: inserted at %s\n" , vma->node.start, vma->node.size, reason, buf); }
drivers/gpu/drm/i915/intel_runtime_pm.c +7 -14
@@ -60,27 +60,20 @@ static noinline depot_stack_handle_t __save_depot_stack(void) {unsigned long entries[STACKDEPTH ]; -struct stack_trace trace = { - .entries = entries, - .max_entries =ARRAY_SIZE (entries), - .skip =1 , - }; +unsigned int n; -save_stack_trace (&trace); -return depot_save_stack (&trace,GFP_NOWAIT | __GFP_NOWARN); + n =stack_trace_save (entries,ARRAY_SIZE (entries),1 ); +return stack_depot_save (entries, n,GFP_NOWAIT | __GFP_NOWARN); }static void __print_depot_stack (depot_stack_handle_t stack,char *buf,int sz,int indent) { -unsigned long entries[STACKDEPTH ]; -struct stack_trace trace = { - .entries = entries, - .max_entries =ARRAY_SIZE (entries), - }; +unsigned long *entries; +unsigned int nr_entries; -depot_fetch_stack (stack, &trace); -snprint_stack_trace (buf, sz, &trace, indent); + nr_entries =stack_depot_fetch (stack, &entries); +stack_trace_snprint (buf, sz, entries, nr_entries, indent); }static void init_intel_runtime_pm_wakeref (struct drm_i915_private *i915)
PATCH v3 17/29 lockdep: Remove unused trace argument from print_circular_bug()
In reply to Thomas Gleixner--- kernel/locking/lockdep.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)
kernel/locking/lockdep.c +4 -5
@@ -1522,10 +1522,9 @@ static inline int class_equal(struct loc } static noinline int print_circular_bug(struct lock_list *this, -struct lock_list *target, -struct held_lock *check_src, -struct held_lock *check_tgt, -struct stack_trace *trace) +struct lock_list *target, +struct held_lock *check_src, +struct held_lock *check_tgt) {struct task_struct *curr = current;struct lock_list *parent;
@@ -2206,7 +2205,7 @@ check_prev_add(struct task_struct *curr,*/ save (trace); } -return print_circular_bug (&this, target_entry, next, prev, trace); +return print_circular_bug (&this, target_entry, next, prev); }else if (unlikely (ret <0 ))return print_bfs_bug (ret);
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] lockdep: Remove unused trace argument from print_circular_bug()
lockdep: Remove unused trace argument from print_circular_bug()
Commit-ID: b1abe4622d4cc32b3b37cfefbc7ac070a8f868e0 Gitweb: https://git.kernel.org/tip/b1abe4622d4cc32b3b37cfefbc7ac070a8f868e0 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:10 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:53 +0200
lockdep: Remove unused trace argument from print_circular_bug()
--- kernel/locking/lockdep.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)
kernel/locking/lockdep.c +4 -5
@@ -1522,10 +1522,9 @@ static inline int class_equal(struct lock_list *entry, void *data) } static noinline int print_circular_bug(struct lock_list *this, -struct lock_list *target, -struct held_lock *check_src, -struct held_lock *check_tgt, -struct stack_trace *trace) +struct lock_list *target, +struct held_lock *check_src, +struct held_lock *check_tgt) {struct task_struct *curr = current;struct lock_list *parent;
@@ -2206,7 +2205,7 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,*/ save (trace); } -return print_circular_bug (&this, target_entry, next, prev, trace); +return print_circular_bug (&this, target_entry, next, prev); }else if (unlikely (ret <0 ))return print_bfs_bug (ret);
PATCH v3 18/29 lockdep: Remove save argument from check_prev_add()
In reply to Thomas GleixnerThere is only one caller which hands in save_trace as function pointer.
--- kernel/locking/lockdep.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
kernel/locking/lockdep.c +8 -8
@@ -2158,8 +2158,7 @@ check_deadlock(struct task_struct *curr,*/ static int check_prev_add (struct task_struct *curr,struct held_lock *prev, -struct held_lock *next,int distance,struct stack_trace *trace, -int (*save)(struct stack_trace *trace)) +struct held_lock *next,int distance,struct stack_trace *trace) {struct lock_list *uninitialized_var (target_entry );struct lock_list *entry;
@@ -2199,11 +2198,11 @@ check_prev_add(struct task_struct *curr,if (unlikely (!ret)) {if (!trace->entries) {/* -* If @save fails here, the printing might trigger -* a WARN but because of the !nr_entries it should -* not do bad things. +* If save_trace fails here, the printing might +* trigger a WARN but because of the !nr_entries it +* should not do bad things. */ -save (trace); +save_trace (trace); }return print_circular_bug (&this, target_entry, next, prev); }
@@ -2253,7 +2252,7 @@ check_prev_add(struct task_struct *curr,return print_bfs_bug (ret); -if (!trace->entries && !save (trace)) +if (!trace->entries && !save_trace (trace))return 0 ;/*
@@ -2318,7 +2317,8 @@ check_prevs_add(struct task_struct *curr* added: */ if (hlock->read !=2 && hlock->check) { -int ret =check_prev_add (curr, hlock, next, distance, &trace, save_trace); +int ret =check_prev_add (curr, hlock, next, distance, + &trace);if (!ret)return 0 ;
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [patch V3 18/29] lockdep: Remove save argument from check_prev_add()
Quoted 3 lines · Thomas Gleixner
There is only one caller which hands in
save_traceas function pointer.Signed-off-by Thomas Gleixner <[email protected]>
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] lockdep: Remove save argument from check_prev_add()
In reply to Thomas Gleixnerlockdep: Remove save argument from check_prev_add()
Commit-ID: 76b14436b4d98903fef723365170bedd6f28ab2c Gitweb: https://git.kernel.org/tip/76b14436b4d98903fef723365170bedd6f28ab2c Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:11 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:53 +0200
lockdep: Remove save argument from check_prev_add()
There is only one caller which hands in save_trace as function pointer.
--- kernel/locking/lockdep.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
kernel/locking/lockdep.c +8 -8
@@ -2158,8 +2158,7 @@ check_deadlock(struct task_struct *curr, struct held_lock *next,*/ static int check_prev_add (struct task_struct *curr,struct held_lock *prev, -struct held_lock *next,int distance,struct stack_trace *trace, -int (*save)(struct stack_trace *trace)) +struct held_lock *next,int distance,struct stack_trace *trace) {struct lock_list *uninitialized_var (target_entry );struct lock_list *entry;
@@ -2199,11 +2198,11 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,if (unlikely (!ret)) {if (!trace->entries) {/* -* If @save fails here, the printing might trigger -* a WARN but because of the !nr_entries it should -* not do bad things. +* If save_trace fails here, the printing might +* trigger a WARN but because of the !nr_entries it +* should not do bad things. */ -save (trace); +save_trace (trace); }return print_circular_bug (&this, target_entry, next, prev); }
@@ -2253,7 +2252,7 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,return print_bfs_bug (ret); -if (!trace->entries && !save (trace)) +if (!trace->entries && !save_trace (trace))return 0 ;/*
@@ -2318,7 +2317,8 @@ check_prevs_add(struct task_struct *curr, struct held_lock *next)* added: */ if (hlock->read !=2 && hlock->check) { -int ret =check_prev_add (curr, hlock, next, distance, &trace, save_trace); +int ret =check_prev_add (curr, hlock, next, distance, + &trace);if (!ret)return 0 ;
PATCH v3 19/29 lockdep: Simplify stack trace handling
In reply to Thomas GleixnerReplace the indirection through struct stack_trace by using the storage array based interfaces and storing the information is a small lockdep specific data structure.
--- include/linux/lockdep.h | 9 +++++-- kernel/locking/lockdep.c | 55 +++++++++++++++++++++++------------------------ 2 files changed, 35 insertions(+), 29 deletions(-)
include/linux/lockdep.h +7 -2
@@ -66,6 +66,11 @@ struct lock_class_key {extern struct lock_class_key __lockdep_no_validate__; +struct lock_trace { +unsigned int nr_entries; +unsigned int offset; +}; +#define LOCKSTAT_POINTS 4/*
@@ -100,7 +105,7 @@ struct lock_class {* IRQ/softirq usage tracking bits: */ unsigned long usage_mask; -struct stack_trace usage_traces[XXX_LOCK_USAGE_STATES ]; +struct lock_trace usage_traces[XXX_LOCK_USAGE_STATES ];/* * Generation counter, when doing certain classes of graph walking,
@@ -188,7 +193,7 @@ struct lock_list {struct list_head entry;struct lock_class *class;struct lock_class *links_to; -struct stack_trace trace; +struct lock_trace trace;int distance;/*
kernel/locking/lockdep.c +28 -27
143 lines not on this page · raw message
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] lockdep: Simplify stack trace handling
lockdep: Simplify stack trace handling
Commit-ID: c120bce78065cbea460a58b1572c215db9c148ba Gitweb: https://git.kernel.org/tip/c120bce78065cbea460a58b1572c215db9c148ba Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:12 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:54 +0200
lockdep: Simplify stack trace handling
Replace the indirection through struct stack_trace by using the storage array based interfaces and storing the information is a small lockdep specific data structure.
--- include/linux/lockdep.h | 9 ++++++-- kernel/locking/lockdep.c | 55 ++++++++++++++++++++++++------------------------ 2 files changed, 35 insertions(+), 29 deletions(-)
include/linux/lockdep.h +7 -2
@@ -66,6 +66,11 @@ struct lock_class_key {extern struct lock_class_key __lockdep_no_validate__; +struct lock_trace { +unsigned int nr_entries; +unsigned int offset; +}; +#define LOCKSTAT_POINTS 4/*
@@ -100,7 +105,7 @@ struct lock_class {* IRQ/softirq usage tracking bits: */ unsigned long usage_mask; -struct stack_trace usage_traces[XXX_LOCK_USAGE_STATES ]; +struct lock_trace usage_traces[XXX_LOCK_USAGE_STATES ];/* * Generation counter, when doing certain classes of graph walking,
@@ -188,7 +193,7 @@ struct lock_list {struct list_head entry;struct lock_class *class;struct lock_class *links_to; -struct stack_trace trace; +struct lock_trace trace;int distance;/*
kernel/locking/lockdep.c +28 -27
143 lines not on this page · raw message
PATCH v3 20/29 tracing: Simplify stacktrace retrieval in histograms
In reply to Thomas GleixnerThe indirection through struct stack_trace is not necessary at all. Use the storage array based interface.
--- kernel/trace/trace_events_hist.c | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-)
kernel/trace/trace_events_hist.c +3 -9
@@ -5186,7 +5186,6 @@ static void event_hist_trigger(struct evu64 var_ref_vals[TRACING_MAP_VARS_MAX ];char compound_key[HIST_KEY_SIZE_MAX ];struct tracing_map_elt *elt =NULL ; -struct stack_trace stacktrace;struct hist_field *key_field;u64 field_contents;void *key =NULL ;
@@ -5198,14 +5197,9 @@ static void event_hist_trigger(struct ev key_field = hist_data->fields[i];if (key_field->flags &HIST_FIELD_FL_STACKTRACE ) { - stacktrace.max_entries =HIST_STACKTRACE_DEPTH ; - stacktrace.entries = entries; - stacktrace.nr_entries =0 ; - stacktrace.skip =HIST_STACKTRACE_SKIP ; - -memset (stacktrace.entries,0 ,HIST_STACKTRACE_SIZE ); -save_stack_trace (&stacktrace); - +memset (entries,0 ,HIST_STACKTRACE_SIZE ); +stack_trace_save (entries,HIST_STACKTRACE_DEPTH , +HIST_STACKTRACE_SKIP ); key = entries; }else { field_contents = key_field->fn (key_field, elt, rbe, rec);
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] tracing: Simplify stacktrace retrieval in histograms
tracing: Simplify stacktrace retrieval in histograms
Commit-ID: e7d916632b528e8cccc8e9ccca81acfc591a5fde Gitweb: https://git.kernel.org/tip/e7d916632b528e8cccc8e9ccca81acfc591a5fde Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:13 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:54 +0200
tracing: Simplify stacktrace retrieval in histograms
The indirection through struct stack_trace is not necessary at all. Use the storage array based interface.
--- kernel/trace/trace_events_hist.c | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-)
kernel/trace/trace_events_hist.c +3 -9
@@ -5186,7 +5186,6 @@ static void event_hist_trigger(struct event_trigger_data *data, void *rec,u64 var_ref_vals[TRACING_MAP_VARS_MAX ];char compound_key[HIST_KEY_SIZE_MAX ];struct tracing_map_elt *elt =NULL ; -struct stack_trace stacktrace;struct hist_field *key_field;u64 field_contents;void *key =NULL ;
@@ -5198,14 +5197,9 @@ static void event_hist_trigger(struct event_trigger_data *data, void *rec, key_field = hist_data->fields[i];if (key_field->flags &HIST_FIELD_FL_STACKTRACE ) { - stacktrace.max_entries =HIST_STACKTRACE_DEPTH ; - stacktrace.entries = entries; - stacktrace.nr_entries =0 ; - stacktrace.skip =HIST_STACKTRACE_SKIP ; - -memset (stacktrace.entries,0 ,HIST_STACKTRACE_SIZE ); -save_stack_trace (&stacktrace); - +memset (entries,0 ,HIST_STACKTRACE_SIZE ); +stack_trace_save (entries,HIST_STACKTRACE_DEPTH , +HIST_STACKTRACE_SKIP ); key = entries; }else { field_contents = key_field->fn (key_field, elt, rbe, rec);
PATCH v3 21/29 tracing: Use percpu stack trace buffer more intelligently
In reply to Thomas GleixnerThe per cpu stack trace buffer usage pattern is odd at best. The buffer has place for 512 stack trace entries on 64-bit and 1024 on 32-bit. When interrupts or exceptions nest after the per cpu buffer was acquired the stacktrace length is hardcoded to 8 entries. 512/1024 stack trace entries in kernel stacks are unrealistic so the buffer is a complete waste.
Split the buffer into 4 nest levels, which are 128/256 entries per level. This allows nesting contexts (interrupts, exceptions) to utilize the cpu buffer for stack retrieval and avoids the fixed length allocation along with the conditional execution pathes.
---
V3: Limit to 4 nest levels and increase size per level.
--- kernel/trace/trace.c | 77 +++++++++++++++++++++++++-------------------------- 1 file changed, 39 insertions(+), 38 deletions(-)
kernel/trace/trace.c +39 -38
@@ -2749,12 +2749,21 @@ trace_function(struct trace_array *tr,#ifdef CONFIG_STACKTRACE -#define FTRACE_STACK_MAX_ENTRIES (PAGE_SIZE / sizeof(unsigned long)) +/* Allow 4 levels of nesting: normal, softirq, irq, NMI */ +#define FTRACE_KSTACK_NESTING 4 + +#define FTRACE_KSTACK_ENTRIES (PAGE_SIZE / FTRACE_KSTACK_NESTING) +struct ftrace_stack { -unsigned long calls[FTRACE_STACK_MAX_ENTRIES ]; +unsigned long calls[FTRACE_KSTACK_ENTRIES ]; +}; + + +struct ftrace_stacks { +struct ftrace_stack stacks[FTRACE_KSTACK_NESTING ]; }; -static DEFINE_PER_CPU(struct ftrace_stack, ftrace_stack); +static DEFINE_PER_CPU(struct ftrace_stacks, ftrace_stacks); static DEFINE_PER_CPU(int, ftrace_stack_reserve); static void __ftrace_trace_stack(struct ring_buffer *buffer,
@@ -2763,10 +2772,11 @@ static void __ftrace_trace_stack(struct {struct trace_event_call *call = &event_kernel_stack;struct ring_buffer_event *event; +struct ftrace_stack *fstack;struct stack_entry *entry;struct stack_trace trace; -int use_stack; -int size =FTRACE_STACK_ENTRIES ; +int size =FTRACE_KSTACK_ENTRIES ; +int stackidx; trace.nr_entries =0 ; trace.skip = skip;
@@ -2788,29 +2798,32 @@ static void __ftrace_trace_stack(struct*/ preempt_disable_notrace (); - use_stack =__this_cpu_inc_return (ftrace_stack_reserve); + stackidx =__this_cpu_inc_return (ftrace_stack_reserve); + +/* This should never happen. If it does, yell once and skip */ +if (WARN_ON_ONCE (stackidx >=FTRACE_KSTACK_NESTING )) + goto out; +/* -* We don't need any atomic variables, just a barrier. -* If an interrupt comes in, we don't care, because it would -* have exited and put the counter back to what we want. -* We just need a barrier to keep gcc from moving things -* around. +* The above __this_cpu_inc_return() is 'atomic' cpu local. An +* interrupt will either see the value pre increment or post +* increment. If the interrupt happens pre increment it will have +* restored the counter when it returns. We just need a barrier to +* keep gcc from moving things around. */ barrier (); -if (use_stack ==1 ) { - trace.entries =this_cpu_ptr (ftrace_stack.calls); - trace.max_entries =FTRACE_STACK_MAX_ENTRIES ; - -if (regs) -save_stack_trace_regs (regs, &trace); -else -save_stack_trace (&trace); - -if (trace.nr_entries > size) - size = trace.nr_entries; - }else -/* From now on, use_stack is a boolean */ - use_stack =0 ; + + fstack =this_cpu_ptr (ftrace_stacks.stacks) + (stackidx -1 ); + trace.entries = fstack->calls; + trace.max_entries =FTRACE_KSTACK_ENTRIES ; + +if (regs) +save_stack_trace_regs (regs, &trace); +else +save_stack_trace (&trace); + +if (trace.nr_entries > size) + size = trace.nr_entries; size *=sizeof (unsigned long );
@@ -2820,19 +2833,7 @@ static void __ftrace_trace_stack(struct goto out; entry =ring_buffer_event_data (event); -memset (&entry->caller,0 , size); - -if (use_stack) -memcpy (&entry->caller, trace.entries, - trace.nr_entries *sizeof (unsigned long )); -else { - trace.max_entries =FTRACE_STACK_ENTRIES ; - trace.entries = entry->caller; -if (regs) -save_stack_trace_regs (regs, &trace); -else -save_stack_trace (&trace); - } +memcpy (&entry->caller, trace.entries, size); entry->size = trace.nr_entries;
Re: [patch V3 21/29] tracing: Use percpu stack trace buffer more intelligently
Quoted 30 lines · Thomas Gleixner
(quoted diff) +11
-12@@ -2788,29 +2798,32 @@ static void __ftrace_trace_stack(struct */ preempt_disable_notrace(); - use_stack = __this_cpu_inc_return(ftrace_stack_reserve); + stackidx = __this_cpu_inc_return(ftrace_stack_reserve); + + /* This should never happen. If it does, yell once and skip */ + if (WARN_ON_ONCE(stackidx >= FTRACE_KSTACK_NESTING)) + goto out; + /* - * We don't need any atomic variables, just a barrier. - * If an interrupt comes in, we don't care, because it would - * have exited and put the counter back to what we want. - * We just need a barrier to keep gcc from moving things - * around. + * The above __this_cpu_inc_return() is 'atomic' cpu local. An + * interrupt will either see the value pre increment or post + * increment. If the interrupt happens pre increment it will have + * restored the counter when it returns. We just need a barrier to + * keep gcc from moving things around. */ barrier(); - if (use_stack == 1) { - trace.entries = this_cpu_ptr(ftrace_stack.calls); - trace.max_entries = FTRACE_STACK_MAX_ENTRIES; - - if (regs) - save_stack_trace_regs(regs, &trace);
Review static void __ftrace_trace_stack(struct · line 2816
Quoted 10 lines
(quoted diff) +2
-8- else - save_stack_trace(&trace); - - if (trace.nr_entries > size) - size = trace.nr_entries; - } else - /* From now on, use_stack is a boolean */ - use_stack = 0; + + fstack = this_cpu_ptr(ftrace_stacks.stacks) + (stackidx - 1);
nit: it would be slightly less surprising if stackidx were 0-based:
kernel/trace/trace.c +3 -3
@@ -2798,10 +2798,10 @@ static void __ftrace_trace_stack(struct ring_buffer *buffer,*/ preempt_disable_notrace (); - stackidx =__this_cpu_inc_return (ftrace_stack_reserve); + stackidx =__this_cpu_inc_return (ftrace_stack_reserve) -1 ;/* This should never happen. If it does, yell once and skip */ -if (WARN_ON_ONCE (stackidx >=FTRACE_KSTACK_NESTING )) +if (WARN_ON_ONCE (stackidx >FTRACE_KSTACK_NESTING )) goto out;/*
@@ -2813,7 +2813,7 @@ static void __ftrace_trace_stack(struct ring_buffer *buffer,*/ barrier (); - fstack =this_cpu_ptr (ftrace_stacks.stacks) + (stackidx -1 ); + fstack =this_cpu_ptr (ftrace_stacks.stacks) + stackidx; trace.entries = fstack->calls; trace.max_entries =FTRACE_KSTACK_ENTRIES ;
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] tracing: Use percpu stack trace buffer more intelligently
In reply to Thomas Gleixnertracing: Use percpu stack trace buffer more intelligently
Commit-ID: 2a820bf74918d61ea54f7c1001f4a6a2e457577c Gitweb: https://git.kernel.org/tip/2a820bf74918d61ea54f7c1001f4a6a2e457577c Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:14 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:55 +0200
tracing: Use percpu stack trace buffer more intelligently
The per cpu stack trace buffer usage pattern is odd at best. The buffer has place for 512 stack trace entries on 64-bit and 1024 on 32-bit. When interrupts or exceptions nest after the per cpu buffer was acquired the stacktrace length is hardcoded to 8 entries. 512/1024 stack trace entries in kernel stacks are unrealistic so the buffer is a complete waste.
Split the buffer into 4 nest levels, which are 128/256 entries per level. This allows nesting contexts (interrupts, exceptions) to utilize the cpu buffer for stack retrieval and avoids the fixed length allocation along with the conditional execution pathes.
--- kernel/trace/trace.c | 73 ++++++++++++++++++++++++++-------------------------- 1 file changed, 37 insertions(+), 36 deletions(-)
kernel/trace/trace.c +37 -36
@@ -2749,12 +2749,21 @@ trace_function(struct trace_array *tr,#ifdef CONFIG_STACKTRACE -#define FTRACE_STACK_MAX_ENTRIES (PAGE_SIZE / sizeof(unsigned long)) +/* Allow 4 levels of nesting: normal, softirq, irq, NMI */ +#define FTRACE_KSTACK_NESTING 4 + +#define FTRACE_KSTACK_ENTRIES (PAGE_SIZE / FTRACE_KSTACK_NESTING) +struct ftrace_stack { -unsigned long calls[FTRACE_STACK_MAX_ENTRIES ]; +unsigned long calls[FTRACE_KSTACK_ENTRIES ]; +}; + + +struct ftrace_stacks { +struct ftrace_stack stacks[FTRACE_KSTACK_NESTING ]; }; -static DEFINE_PER_CPU(struct ftrace_stack, ftrace_stack); +static DEFINE_PER_CPU(struct ftrace_stacks, ftrace_stacks); static DEFINE_PER_CPU(int, ftrace_stack_reserve); static void __ftrace_trace_stack(struct ring_buffer *buffer,
@@ -2763,10 +2772,11 @@ static void __ftrace_trace_stack(struct ring_buffer *buffer, {struct trace_event_call *call = &event_kernel_stack;struct ring_buffer_event *event; +struct ftrace_stack *fstack;struct stack_entry *entry;struct stack_trace trace; -int use_stack; -int size =FTRACE_STACK_ENTRIES ; +int size =FTRACE_KSTACK_ENTRIES ; +int stackidx; trace.nr_entries =0 ; trace.skip = skip;
@@ -2788,29 +2798,32 @@ static void __ftrace_trace_stack(struct ring_buffer *buffer,*/ preempt_disable_notrace (); - use_stack =__this_cpu_inc_return (ftrace_stack_reserve); + stackidx =__this_cpu_inc_return (ftrace_stack_reserve) -1 ; + +/* This should never happen. If it does, yell once and skip */ +if (WARN_ON_ONCE (stackidx >FTRACE_KSTACK_NESTING )) + goto out; +/* -* We don't need any atomic variables, just a barrier. -* If an interrupt comes in, we don't care, because it would -* have exited and put the counter back to what we want. -* We just need a barrier to keep gcc from moving things -* around. +* The above __this_cpu_inc_return() is 'atomic' cpu local. An +* interrupt will either see the value pre increment or post +* increment. If the interrupt happens pre increment it will have +* restored the counter when it returns. We just need a barrier to +* keep gcc from moving things around. */ barrier (); -if (use_stack ==1 ) { - trace.entries =this_cpu_ptr (ftrace_stack.calls); - trace.max_entries =FTRACE_STACK_MAX_ENTRIES ; -if (regs) -save_stack_trace_regs (regs, &trace); -else -save_stack_trace (&trace); + fstack =this_cpu_ptr (ftrace_stacks.stacks) + stackidx; + trace.entries = fstack->calls; + trace.max_entries =FTRACE_KSTACK_ENTRIES ; -if (trace.nr_entries > size) - size = trace.nr_entries; - }else -/* From now on, use_stack is a boolean */ - use_stack =0 ; +if (regs) +save_stack_trace_regs (regs, &trace); +else +save_stack_trace (&trace); + +if (trace.nr_entries > size) + size = trace.nr_entries; size *=sizeof (unsigned long );
@@ -2820,19 +2833,7 @@ static void __ftrace_trace_stack(struct ring_buffer *buffer, goto out; entry =ring_buffer_event_data (event); -memset (&entry->caller,0 , size); - -if (use_stack) -memcpy (&entry->caller, trace.entries, - trace.nr_entries *sizeof (unsigned long )); -else { - trace.max_entries =FTRACE_STACK_ENTRIES ; - trace.entries = entry->caller; -if (regs) -save_stack_trace_regs (regs, &trace); -else -save_stack_trace (&trace); - } +memcpy (&entry->caller, trace.entries, size); entry->size = trace.nr_entries;
PATCH v3 22/29 tracing: Make ftrace_trace_userstack() static and conditional
In reply to Thomas GleixnerIt's only used in trace.c and there is absolutely no point in compiling it in when user space stack traces are not supported.
--- kernel/trace/trace.c | 14 ++++++++------ kernel/trace/trace.h | 8 -------- 2 files changed, 8 insertions(+), 14 deletions(-)
kernel/trace/trace.c +8 -6
@@ -159,6 +159,8 @@ static union trace_eval_map_item *trace_#endif /* CONFIG_TRACE_EVAL_MAP_FILE */ static int tracing_set_tracer (struct trace_array *tr,const char *buf); +static void ftrace_trace_userstack (struct ring_buffer *buffer, +unsigned long flags,int pc);#define MAX_TRACER_SIZE 100static char bootup_tracer_buf[MAX_TRACER_SIZE ]__initdata ;
@@ -2905,9 +2907,10 @@ void trace_dump_stack(int skip) }EXPORT_SYMBOL_GPL (trace_dump_stack); +#ifdef CONFIG_USER_STACKTRACE_SUPPORT static DEFINE_PER_CPU(int, user_stack_count); -void +static void ftrace_trace_userstack (struct ring_buffer *buffer,unsigned long flags,int pc) {struct trace_event_call *call = &event_user_stack;
@@ -2958,13 +2961,12 @@ ftrace_trace_userstack(struct ring_buffe out:preempt_enable (); } - -#ifdef UNUSED -static void __trace_userstack (struct trace_array *tr,unsigned long flags) +#else /* CONFIG_USER_STACKTRACE_SUPPORT */ +static void ftrace_trace_userstack (struct ring_buffer *buffer, +unsigned long flags,int pc) { -ftrace_trace_userstack (tr, flags,preempt_count ()); } -#endif /* UNUSED */ +#endif /* !CONFIG_USER_STACKTRACE_SUPPORT */ #endif /* CONFIG_STACKTRACE */
kernel/trace/trace.h +0 -8
@@ -782,17 +782,9 @@ void update_max_tr_single(struct trace_a#endif /* CONFIG_TRACER_MAX_TRACE */ #ifdef CONFIG_STACKTRACE -void ftrace_trace_userstack (struct ring_buffer *buffer,unsigned long flags, -int pc); -void __trace_stack (struct trace_array *tr,unsigned long flags,int skip,int pc);#else -static inline void ftrace_trace_userstack (struct ring_buffer *buffer, -unsigned long flags,int pc) -{ -} -static inline void __trace_stack (struct trace_array *tr,unsigned long flags,int skip,int pc) {
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] tracing: Make ftrace_trace_userstack() static and conditional
tracing: Make ftrace_trace_userstack() static and conditional
Commit-ID: c438f140cc16d47fac808d893f5017f6d641cb46 Gitweb: https://git.kernel.org/tip/c438f140cc16d47fac808d893f5017f6d641cb46 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:15 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:55 +0200
tracing: Make ftrace_trace_userstack() static and conditional
It's only used in trace.c and there is absolutely no point in compiling it in when user space stack traces are not supported.
--- kernel/trace/trace.c | 14 ++++++++------ kernel/trace/trace.h | 8 -------- 2 files changed, 8 insertions(+), 14 deletions(-)
kernel/trace/trace.c +8 -6
@@ -159,6 +159,8 @@ static union trace_eval_map_item *trace_eval_maps;#endif /* CONFIG_TRACE_EVAL_MAP_FILE */ static int tracing_set_tracer (struct trace_array *tr,const char *buf); +static void ftrace_trace_userstack (struct ring_buffer *buffer, +unsigned long flags,int pc);#define MAX_TRACER_SIZE 100static char bootup_tracer_buf[MAX_TRACER_SIZE ]__initdata ;
@@ -2905,9 +2907,10 @@ void trace_dump_stack(int skip) }EXPORT_SYMBOL_GPL (trace_dump_stack); +#ifdef CONFIG_USER_STACKTRACE_SUPPORT static DEFINE_PER_CPU(int, user_stack_count); -void +static void ftrace_trace_userstack (struct ring_buffer *buffer,unsigned long flags,int pc) {struct trace_event_call *call = &event_user_stack;
@@ -2958,13 +2961,12 @@ ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags, int pc) out:preempt_enable (); } - -#ifdef UNUSED -static void __trace_userstack (struct trace_array *tr,unsigned long flags) +#else /* CONFIG_USER_STACKTRACE_SUPPORT */ +static void ftrace_trace_userstack (struct ring_buffer *buffer, +unsigned long flags,int pc) { -ftrace_trace_userstack (tr, flags,preempt_count ()); } -#endif /* UNUSED */ +#endif /* !CONFIG_USER_STACKTRACE_SUPPORT */ #endif /* CONFIG_STACKTRACE */
kernel/trace/trace.h +0 -8
@@ -782,17 +782,9 @@ void update_max_tr_single(struct trace_array *tr,#endif /* CONFIG_TRACER_MAX_TRACE */ #ifdef CONFIG_STACKTRACE -void ftrace_trace_userstack (struct ring_buffer *buffer,unsigned long flags, -int pc); -void __trace_stack (struct trace_array *tr,unsigned long flags,int skip,int pc);#else -static inline void ftrace_trace_userstack (struct ring_buffer *buffer, -unsigned long flags,int pc) -{ -} -static inline void __trace_stack (struct trace_array *tr,unsigned long flags,int skip,int pc) {
PATCH v3 23/29 tracing: Simplify stack trace retrieval
In reply to Thomas GleixnerReplace the indirection through struct stack_trace by using the storage array based interfaces.
--- kernel/trace/trace.c | 40 +++++++++++++--------------------------- 1 file changed, 13 insertions(+), 27 deletions(-)
kernel/trace/trace.c +13 -27
@@ -2774,22 +2774,18 @@ static void __ftrace_trace_stack(struct {struct trace_event_call *call = &event_kernel_stack;struct ring_buffer_event *event; +unsigned int size, nr_entries;struct ftrace_stack *fstack;struct stack_entry *entry; -struct stack_trace trace; -int size =FTRACE_KSTACK_ENTRIES ;int stackidx; - trace.nr_entries =0 ; - trace.skip = skip; -/* * Add one, for this function and the call to save_stack_trace() * If regs is set, then these functions will not be in the way. */ #ifndef CONFIG_UNWINDER_ORC if (!regs) - trace.skip++; + skip++;#endif /*
@@ -2816,28 +2812,24 @@ static void __ftrace_trace_stack(structbarrier (); fstack =this_cpu_ptr (ftrace_stacks.stacks) + (stackidx -1 ); - trace.entries = fstack->calls; - trace.max_entries =FTRACE_KSTACK_ENTRIES ; - -if (regs) -save_stack_trace_regs (regs, &trace); -else -save_stack_trace (&trace); - -if (trace.nr_entries > size) - size = trace.nr_entries; + size =ARRAY_SIZE (fstack->calls); - size *=sizeof (unsigned long ); +if (regs) { + nr_entries =stack_trace_save_regs (regs, fstack->calls, + size, skip); + }else { + nr_entries =stack_trace_save (fstack->calls, size, skip); + } + size = nr_entries *sizeof (unsigned long ); event =__trace_buffer_lock_reserve (buffer,TRACE_STACK ,sizeof (*entry) + size, flags, pc);if (!event) goto out; entry =ring_buffer_event_data (event); -memcpy (&entry->caller, trace.entries, size); - - entry->size = trace.nr_entries; +memcpy (&entry->caller, fstack->calls, size); + entry->size = nr_entries;if (!call_filter_check_discard (call, entry, buffer, event))__buffer_unlock_commit (buffer, event);
@@ -2916,7 +2908,6 @@ ftrace_trace_userstack(struct ring_buffestruct trace_event_call *call = &event_user_stack;struct ring_buffer_event *event;struct userstack_entry *entry; -struct stack_trace trace;if (!(global_trace.trace_flags &TRACE_ITER_USERSTACKTRACE ))return ;
@@ -2947,12 +2938,7 @@ ftrace_trace_userstack(struct ring_buffe entry->tgid = current->tgid;memset (&entry->caller,0 ,sizeof (entry->caller)); - trace.nr_entries =0 ; - trace.max_entries =FTRACE_STACK_ENTRIES ; - trace.skip =0 ; - trace.entries = entry->caller; - -save_stack_trace_user (&trace); +stack_trace_save_user (entry->caller,FTRACE_STACK_ENTRIES );if (!call_filter_check_discard (call, entry, buffer, event))__buffer_unlock_commit (buffer, event);
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] tracing: Simplify stack trace retrieval
tracing: Simplify stack trace retrieval
Commit-ID: ee6dd0db4d8de41a0a0bc37d8d87a0b1623f83b0 Gitweb: https://git.kernel.org/tip/ee6dd0db4d8de41a0a0bc37d8d87a0b1623f83b0 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:16 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:55 +0200
tracing: Simplify stack trace retrieval
Replace the indirection through struct stack_trace by using the storage array based interfaces.
--- kernel/trace/trace.c | 40 +++++++++++++--------------------------- 1 file changed, 13 insertions(+), 27 deletions(-)
kernel/trace/trace.c +13 -27
@@ -2774,22 +2774,18 @@ static void __ftrace_trace_stack(struct ring_buffer *buffer, {struct trace_event_call *call = &event_kernel_stack;struct ring_buffer_event *event; +unsigned int size, nr_entries;struct ftrace_stack *fstack;struct stack_entry *entry; -struct stack_trace trace; -int size =FTRACE_KSTACK_ENTRIES ;int stackidx; - trace.nr_entries =0 ; - trace.skip = skip; -/* * Add one, for this function and the call to save_stack_trace() * If regs is set, then these functions will not be in the way. */ #ifndef CONFIG_UNWINDER_ORC if (!regs) - trace.skip++; + skip++;#endif /*
@@ -2816,28 +2812,24 @@ static void __ftrace_trace_stack(struct ring_buffer *buffer,barrier (); fstack =this_cpu_ptr (ftrace_stacks.stacks) + stackidx; - trace.entries = fstack->calls; - trace.max_entries =FTRACE_KSTACK_ENTRIES ; - -if (regs) -save_stack_trace_regs (regs, &trace); -else -save_stack_trace (&trace); - -if (trace.nr_entries > size) - size = trace.nr_entries; + size =ARRAY_SIZE (fstack->calls); - size *=sizeof (unsigned long ); +if (regs) { + nr_entries =stack_trace_save_regs (regs, fstack->calls, + size, skip); + }else { + nr_entries =stack_trace_save (fstack->calls, size, skip); + } + size = nr_entries *sizeof (unsigned long ); event =__trace_buffer_lock_reserve (buffer,TRACE_STACK ,sizeof (*entry) + size, flags, pc);if (!event) goto out; entry =ring_buffer_event_data (event); -memcpy (&entry->caller, trace.entries, size); - - entry->size = trace.nr_entries; +memcpy (&entry->caller, fstack->calls, size); + entry->size = nr_entries;if (!call_filter_check_discard (call, entry, buffer, event))__buffer_unlock_commit (buffer, event);
@@ -2916,7 +2908,6 @@ ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags, int pc)struct trace_event_call *call = &event_user_stack;struct ring_buffer_event *event;struct userstack_entry *entry; -struct stack_trace trace;if (!(global_trace.trace_flags &TRACE_ITER_USERSTACKTRACE ))return ;
@@ -2947,12 +2938,7 @@ ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags, int pc) entry->tgid = current->tgid;memset (&entry->caller,0 ,sizeof (entry->caller)); - trace.nr_entries =0 ; - trace.max_entries =FTRACE_STACK_ENTRIES ; - trace.skip =0 ; - trace.entries = entry->caller; - -save_stack_trace_user (&trace); +stack_trace_save_user (entry->caller,FTRACE_STACK_ENTRIES );if (!call_filter_check_discard (call, entry, buffer, event))__buffer_unlock_commit (buffer, event);
PATCH v3 24/29 tracing: Remove the last struct stack_trace usage
In reply to Thomas GleixnerSimplify the stack retrieval code by using the storage array based interface.
--- kernel/trace/trace_stack.c | 37 ++++++++++++++++--------------------- 1 file changed, 16 insertions(+), 21 deletions(-)
kernel/trace/trace_stack.c +16 -21
@@ -23,11 +23,7 @@static unsigned long stack_dump_trace[STACK_TRACE_ENTRIES ];static unsigned stack_trace_index[STACK_TRACE_ENTRIES ]; -struct stack_trace stack_trace_max = { - .max_entries =STACK_TRACE_ENTRIES , - .entries = &stack_dump_trace[0 ], -}; - +static unsigned int stack_trace_entries;static unsigned long stack_trace_max_size;static arch_spinlock_t stack_trace_max_lock = (arch_spinlock_t )__ARCH_SPIN_LOCK_UNLOCKED;
@@ -44,10 +40,10 @@ static void print_max_stack(void)pr_emerg (" Depth Size Location (%d entries)\n" " ----- ---- --------\n" , - stack_trace_max.nr_entries); + stack_trace_entries); -for (i =0 ; i < stack_trace_max.nr_entries; i++) { -if (i +1 == stack_trace_max.nr_entries) +for (i =0 ; i < stack_trace_entries; i++) { +if (i +1 == stack_trace_entries) size = stack_trace_index[i];else size = stack_trace_index[i] - stack_trace_index[i+1 ];
@@ -93,13 +89,12 @@ static void check_stack(unsigned long ip stack_trace_max_size = this_size; - stack_trace_max.nr_entries =0 ; - stack_trace_max.skip =0 ; - -save_stack_trace (&stack_trace_max); + stack_trace_entries =stack_trace_save (stack_dump_trace, +ARRAY_SIZE (stack_dump_trace) -1 , +0 );/* Skip over the overhead of the stack tracer itself */ -for (i =0 ; i < stack_trace_max.nr_entries; i++) { +for (i =0 ; i < stack_trace_entries; i++) {if (stack_dump_trace[i] == ip)break ; }
@@ -108,7 +103,7 @@ static void check_stack(unsigned long ip* Some archs may not have the passed in ip in the dump. * If that happens, we need to show everything. */ -if (i == stack_trace_max.nr_entries) +if (i == stack_trace_entries) i =0 ;/*
@@ -126,13 +121,13 @@ static void check_stack(unsigned long ip* loop will only happen once. This code only takes place * on a new max, so it is far from a fast path. */ -while (i < stack_trace_max.nr_entries) { +while (i < stack_trace_entries) {int found =0 ; stack_trace_index[x] = this_size; p = start; -for (; p < top && i < stack_trace_max.nr_entries; p++) { +for (; p < top && i < stack_trace_entries; p++) {/* * The READ_ONCE_NOCHECK is used to let KASAN know that * this is not a stack-out-of-bounds error.
@@ -163,7 +158,7 @@ static void check_stack(unsigned long ip i++; } - stack_trace_max.nr_entries = x; + stack_trace_entries = x;if (task_stack_end_corrupted (current)) {print_max_stack ();
@@ -265,7 +260,7 @@ static void * {long n = *pos -1 ; -if (n >= stack_trace_max.nr_entries) +if (n >= stack_trace_entries)return NULL ; m->private = (void *)n;
@@ -329,7 +324,7 @@ static int t_show(struct seq_file *m, voseq_printf (m," Depth Size Location" " (%d entries)\n" " ----- ---- --------\n" , - stack_trace_max.nr_entries); + stack_trace_entries);if (!stack_tracer_enabled && !stack_trace_max_size)print_disabled (m);
@@ -339,10 +334,10 @@ static int t_show(struct seq_file *m, vo i = *(long *)v; -if (i >= stack_trace_max.nr_entries) +if (i >= stack_trace_entries)return 0 ; -if (i +1 == stack_trace_max.nr_entries) +if (i +1 == stack_trace_entries) size = stack_trace_index[i];else size = stack_trace_index[i] - stack_trace_index[i+1 ];
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [patch V3 24/29] tracing: Remove the last struct stack_trace usage
Quoted 12 lines · Thomas Gleixner
Simplify the stack retrieval code by using the storage array based interface.
Signed-off-by Thomas Gleixner <[email protected]>Reviewed-by Steven Rostedt (VMware) <[email protected]>--- kernel/trace/trace_stack.c | 37 ++++++++++++++++--------------------- 1 file changed, 16 insertions(+), 21 deletions(-)
kernel/trace/trace_stack.c line 26
Quoted 9 lines
kernel/trace/trace_stack.c +1
-5@@ -23,11 +23,7 @@static unsigned long stack_dump_trace[STACK_TRACE_ENTRIES ];static unsigned stack_trace_index[STACK_TRACE_ENTRIES ]; -struct stack_trace stack_trace_max = { - .max_entries =STACK_TRACE_ENTRIES , - .entries = &stack_dump_trace[0 ], -}; - +static unsigned int stack_trace_entries;
"stack_trace_entries" -> "nr_stack_trace_entries"
Signature · 1 line
Josh
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] tracing: Remove the last struct stack_trace usage
In reply to Thomas Gleixnertracing: Remove the last struct stack_trace usage
Commit-ID: 9f50c91b1195dfffd183d5d8505e45af86623532 Gitweb: https://git.kernel.org/tip/9f50c91b1195dfffd183d5d8505e45af86623532 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:17 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:56 +0200
tracing: Remove the last struct stack_trace usage
Simplify the stack retrieval code by using the storage array based interface.
--- kernel/trace/trace_stack.c | 37 ++++++++++++++++--------------------- 1 file changed, 16 insertions(+), 21 deletions(-)
kernel/trace/trace_stack.c +16 -21
@@ -23,11 +23,7 @@static unsigned long stack_dump_trace[STACK_TRACE_ENTRIES ];static unsigned stack_trace_index[STACK_TRACE_ENTRIES ]; -struct stack_trace stack_trace_max = { - .max_entries =STACK_TRACE_ENTRIES , - .entries = &stack_dump_trace[0 ], -}; - +static unsigned int stack_trace_nr_entries;static unsigned long stack_trace_max_size;static arch_spinlock_t stack_trace_max_lock = (arch_spinlock_t )__ARCH_SPIN_LOCK_UNLOCKED;
@@ -44,10 +40,10 @@ static void print_max_stack(void)pr_emerg (" Depth Size Location (%d entries)\n" " ----- ---- --------\n" , - stack_trace_max.nr_entries); + stack_trace_nr_entries); -for (i =0 ; i < stack_trace_max.nr_entries; i++) { -if (i +1 == stack_trace_max.nr_entries) +for (i =0 ; i < stack_trace_nr_entries; i++) { +if (i +1 == stack_trace_nr_entries) size = stack_trace_index[i];else size = stack_trace_index[i] - stack_trace_index[i+1 ];
@@ -93,13 +89,12 @@ static void check_stack(unsigned long ip, unsigned long *stack) stack_trace_max_size = this_size; - stack_trace_max.nr_entries =0 ; - stack_trace_max.skip =0 ; - -save_stack_trace (&stack_trace_max); + stack_trace_nr_entries =stack_trace_save (stack_dump_trace, +ARRAY_SIZE (stack_dump_trace) -1 , +0 );/* Skip over the overhead of the stack tracer itself */ -for (i =0 ; i < stack_trace_max.nr_entries; i++) { +for (i =0 ; i < stack_trace_nr_entries; i++) {if (stack_dump_trace[i] == ip)break ; }
@@ -108,7 +103,7 @@ static void check_stack(unsigned long ip, unsigned long *stack)* Some archs may not have the passed in ip in the dump. * If that happens, we need to show everything. */ -if (i == stack_trace_max.nr_entries) +if (i == stack_trace_nr_entries) i =0 ;/*
@@ -126,13 +121,13 @@ static void check_stack(unsigned long ip, unsigned long *stack)* loop will only happen once. This code only takes place * on a new max, so it is far from a fast path. */ -while (i < stack_trace_max.nr_entries) { +while (i < stack_trace_nr_entries) {int found =0 ; stack_trace_index[x] = this_size; p = start; -for (; p < top && i < stack_trace_max.nr_entries; p++) { +for (; p < top && i < stack_trace_nr_entries; p++) {/* * The READ_ONCE_NOCHECK is used to let KASAN know that * this is not a stack-out-of-bounds error.
@@ -163,7 +158,7 @@ static void check_stack(unsigned long ip, unsigned long *stack) i++; } - stack_trace_max.nr_entries = x; + stack_trace_nr_entries = x;if (task_stack_end_corrupted (current)) {print_max_stack ();
@@ -265,7 +260,7 @@ __next(struct seq_file *m, loff_t *pos) {long n = *pos -1 ; -if (n >= stack_trace_max.nr_entries) +if (n >= stack_trace_nr_entries)return NULL ; m->private = (void *)n;
@@ -329,7 +324,7 @@ static int t_show(struct seq_file *m, void *v)seq_printf (m," Depth Size Location" " (%d entries)\n" " ----- ---- --------\n" , - stack_trace_max.nr_entries); + stack_trace_nr_entries);if (!stack_tracer_enabled && !stack_trace_max_size)print_disabled (m);
@@ -339,10 +334,10 @@ static int t_show(struct seq_file *m, void *v) i = *(long *)v; -if (i >= stack_trace_max.nr_entries) +if (i >= stack_trace_nr_entries)return 0 ; -if (i +1 == stack_trace_max.nr_entries) +if (i +1 == stack_trace_nr_entries) size = stack_trace_index[i];else size = stack_trace_index[i] - stack_trace_index[i+1 ];
PATCH v3 25/29 livepatch: Simplify stack trace retrieval
In reply to Thomas GleixnerReplace the indirection through struct stack_trace by using the storage array based interfaces.
--- kernel/livepatch/transition.c | 22 +++++++++------------- 1 file changed, 9 insertions(+), 13 deletions(-)
kernel/livepatch/transition.c +9 -13
@@ -202,15 +202,15 @@ void klp_update_patch_state(struct task_* Determine whether the given stack trace includes any references to a * to-be-patched or to-be-unpatched function. */ -static int klp_check_stack_func (struct klp_func *func, -struct stack_trace *trace) +static int klp_check_stack_func (struct klp_func *func,unsigned long *entries, +unsigned int nr_entries) {unsigned long func_addr, func_size, address;struct klp_ops *ops;int i; -for (i =0 ; i < trace->nr_entries; i++) { - address = trace->entries[i]; +for (i =0 ; i < nr_entries; i++) { + address = entries[i];if (klp_target_state ==KLP_UNPATCHED ) {/*
@@ -254,29 +254,25 @@ static int klp_check_stack_func(struct kstatic int klp_check_stack (struct task_struct *task,char *err_buf) {static unsigned long entries[MAX_STACK_ENTRIES ]; -struct stack_trace trace;struct klp_object *obj;struct klp_func *func; -int ret; +int ret, nr_entries; - trace.skip =0 ; - trace.nr_entries =0 ; - trace.max_entries =MAX_STACK_ENTRIES ; - trace.entries = entries; - ret =save_stack_trace_tsk_reliable (task, &trace); + ret =stack_trace_save_tsk_reliable (task, entries,ARRAY_SIZE (entries));WARN_ON_ONCE (ret == -ENOSYS ); -if (ret) { +if (ret <0 ) {snprintf (err_buf,STACK_ERR_BUF_SIZE ,"%s: %s:%d has an unreliable stack\n" , __func__, task->comm, task->pid);return ret; } + nr_entries = ret;klp_for_each_object (klp_transition_patch, obj) {if (!obj->patched)continue ;klp_for_each_func (obj, func) { - ret =klp_check_stack_func (func, &trace); + ret =klp_check_stack_func (func, entries, nr_entries);if (ret) { snprintf(err_buf, STACK_ERR_BUF_SIZE, "%s: %s:%d is sleeping on function %s\n",
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] livepatch: Simplify stack trace retrieval
livepatch: Simplify stack trace retrieval
Commit-ID: 25e39e32b0a3f99b9db320605f20f91d425b6a65 Gitweb: https://git.kernel.org/tip/25e39e32b0a3f99b9db320605f20f91d425b6a65 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:18 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:56 +0200
livepatch: Simplify stack trace retrieval
Replace the indirection through struct stack_trace by using the storage array based interfaces.
--- kernel/livepatch/transition.c | 22 +++++++++------------- 1 file changed, 9 insertions(+), 13 deletions(-)
kernel/livepatch/transition.c +9 -13
@@ -202,15 +202,15 @@ void klp_update_patch_state(struct task_struct *task)* Determine whether the given stack trace includes any references to a * to-be-patched or to-be-unpatched function. */ -static int klp_check_stack_func (struct klp_func *func, -struct stack_trace *trace) +static int klp_check_stack_func (struct klp_func *func,unsigned long *entries, +unsigned int nr_entries) {unsigned long func_addr, func_size, address;struct klp_ops *ops;int i; -for (i =0 ; i < trace->nr_entries; i++) { - address = trace->entries[i]; +for (i =0 ; i < nr_entries; i++) { + address = entries[i];if (klp_target_state ==KLP_UNPATCHED ) {/*
@@ -254,29 +254,25 @@ static int klp_check_stack_func(struct klp_func *func,static int klp_check_stack (struct task_struct *task,char *err_buf) {static unsigned long entries[MAX_STACK_ENTRIES ]; -struct stack_trace trace;struct klp_object *obj;struct klp_func *func; -int ret; +int ret, nr_entries; - trace.skip =0 ; - trace.nr_entries =0 ; - trace.max_entries =MAX_STACK_ENTRIES ; - trace.entries = entries; - ret =save_stack_trace_tsk_reliable (task, &trace); + ret =stack_trace_save_tsk_reliable (task, entries,ARRAY_SIZE (entries));WARN_ON_ONCE (ret == -ENOSYS ); -if (ret) { +if (ret <0 ) {snprintf (err_buf,STACK_ERR_BUF_SIZE ,"%s: %s:%d has an unreliable stack\n" , __func__, task->comm, task->pid);return ret; } + nr_entries = ret;klp_for_each_object (klp_transition_patch, obj) {if (!obj->patched)continue ;klp_for_each_func (obj, func) { - ret =klp_check_stack_func (func, &trace); + ret =klp_check_stack_func (func, entries, nr_entries);if (ret) { snprintf(err_buf, STACK_ERR_BUF_SIZE, "%s: %s:%d is sleeping on function %s\n",
PATCH v3 26/29 stacktrace: Remove obsolete functions
In reply to Thomas GleixnerNo more users of the struct stack_trace based interfaces. Remove them.
Remove the macro stubs for !CONFIG_STACKTRACE as well as they are pointless because the storage on the call sites is conditional on CONFIG_STACKTRACE already. No point to be 'smart'.
--- include/linux/stacktrace.h | 17 ----------------- kernel/stacktrace.c | 14 -------------- 2 files changed, 31 deletions(-)
include/linux/stacktrace.h +0 -17
@@ -36,24 +36,7 @@ extern void save_stack_trace_tsk(struct struct stack_trace *trace);extern int save_stack_trace_tsk_reliable (struct task_struct *tsk,struct stack_trace *trace); - -extern void print_stack_trace (struct stack_trace *trace,int spaces); -extern int snprint_stack_trace (char *buf,size_t size, -struct stack_trace *trace,int spaces); - -#ifdef CONFIG_USER_STACKTRACE_SUPPORT extern void save_stack_trace_user (struct stack_trace *trace); -#else -# define save_stack_trace_user (trace) do { } while (0) -#endif - -#else /* !CONFIG_STACKTRACE */ -# define save_stack_trace (trace) do { } while (0) -# define save_stack_trace_tsk (tsk, trace) do { } while (0) -# define save_stack_trace_user (trace) do { } while (0) -# define print_stack_trace (trace, spaces) do { } while (0) -# define snprint_stack_trace (buf, size, trace, spaces) do { } while (0) -# define save_stack_trace_tsk_reliable (tsk, trace) ({ -ENOSYS; })#endif /* CONFIG_STACKTRACE */ #if defined(CONFIG_STACKTRACE ) && defined(CONFIG_HAVE_RELIABLE_STACKTRACE )
kernel/stacktrace.c +0 -14
@@ -30,12 +30,6 @@ void stack_trace_print(unsigned long *en }EXPORT_SYMBOL_GPL (stack_trace_print); -void print_stack_trace (struct stack_trace *trace,int spaces) -{ -stack_trace_print (trace->entries, trace->nr_entries, spaces); -} -EXPORT_SYMBOL_GPL (print_stack_trace); -/** * stack_trace_snprint - Print the entries in the stack trace into a buffer * @buf: Pointer to the print buffer
@@ -72,14 +66,6 @@ int stack_trace_snprint(char *buf, size_ }EXPORT_SYMBOL_GPL (stack_trace_snprint); -int snprint_stack_trace (char *buf,size_t size, -struct stack_trace *trace,int spaces) -{ -return stack_trace_snprint (buf, size, trace->entries, - trace->nr_entries, spaces); -} -EXPORT_SYMBOL_GPL (snprint_stack_trace); -/* * Architectures that do not implement save_stack_trace_*() * get these weak aliases and once-per-bootup warnings
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] stacktrace: Remove obsolete functions
stacktrace: Remove obsolete functions
Commit-ID: 988ec8841ca1e22b2978fce0134d8267e838770e Gitweb: https://git.kernel.org/tip/988ec8841ca1e22b2978fce0134d8267e838770e Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:19 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:57 +0200
stacktrace: Remove obsolete functions
No more users of the struct stack_trace based interfaces. Remove them.
Remove the macro stubs for !CONFIG_STACKTRACE as well as they are pointless because the storage on the call sites is conditional on CONFIG_STACKTRACE already. No point to be 'smart'.
--- include/linux/stacktrace.h | 17 ----------------- kernel/stacktrace.c | 14 -------------- 2 files changed, 31 deletions(-)
include/linux/stacktrace.h +0 -17
@@ -36,24 +36,7 @@ extern void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace);extern int save_stack_trace_tsk_reliable (struct task_struct *tsk,struct stack_trace *trace); - -extern void print_stack_trace (struct stack_trace *trace,int spaces); -extern int snprint_stack_trace (char *buf,size_t size, -struct stack_trace *trace,int spaces); - -#ifdef CONFIG_USER_STACKTRACE_SUPPORT extern void save_stack_trace_user (struct stack_trace *trace); -#else -# define save_stack_trace_user (trace) do { } while (0) -#endif - -#else /* !CONFIG_STACKTRACE */ -# define save_stack_trace (trace) do { } while (0) -# define save_stack_trace_tsk (tsk, trace) do { } while (0) -# define save_stack_trace_user (trace) do { } while (0) -# define print_stack_trace (trace, spaces) do { } while (0) -# define snprint_stack_trace (buf, size, trace, spaces) do { } while (0) -# define save_stack_trace_tsk_reliable (tsk, trace) ({ -ENOSYS; })#endif /* CONFIG_STACKTRACE */ #if defined(CONFIG_STACKTRACE ) && defined(CONFIG_HAVE_RELIABLE_STACKTRACE )
kernel/stacktrace.c +0 -14
@@ -30,12 +30,6 @@ void stack_trace_print(unsigned long *entries, unsigned int nr_entries, }EXPORT_SYMBOL_GPL (stack_trace_print); -void print_stack_trace (struct stack_trace *trace,int spaces) -{ -stack_trace_print (trace->entries, trace->nr_entries, spaces); -} -EXPORT_SYMBOL_GPL (print_stack_trace); -/** * stack_trace_snprint - Print the entries in the stack trace into a buffer * @buf: Pointer to the print buffer
@@ -72,14 +66,6 @@ int stack_trace_snprint(char *buf, size_t size, unsigned long *entries, }EXPORT_SYMBOL_GPL (stack_trace_snprint); -int snprint_stack_trace (char *buf,size_t size, -struct stack_trace *trace,int spaces) -{ -return stack_trace_snprint (buf, size, trace->entries, - trace->nr_entries, spaces); -} -EXPORT_SYMBOL_GPL (snprint_stack_trace); -/* * Architectures that do not implement save_stack_trace_*() * get these weak aliases and once-per-bootup warnings
PATCH v3 27/29 lib/stackdepot: Remove obsolete functions
In reply to Thomas GleixnerNo more users of the struct stack_trace based interfaces.
--- include/linux/stackdepot.h | 4 ---- lib/stackdepot.c | 20 -------------------- 2 files changed, 24 deletions(-)
include/linux/stackdepot.h +0 -4
@@ -23,13 +23,9 @@typedef u32 depot_stack_handle_t ; -struct stack_trace ; - -depot_stack_handle_t depot_save_stack (struct stack_trace *trace,gfp_t flags);depot_stack_handle_t stack_depot_save (unsigned long *entries,unsigned int nr_entries,gfp_t gfp_flags); -void depot_fetch_stack (depot_stack_handle_t handle,struct stack_trace *trace);unsigned int stack_depot_fetch (depot_stack_handle_t handle,unsigned long **entries);
lib/stackdepot.c +0 -20
@@ -216,14 +216,6 @@ unsigned int stack_depot_fetch(depot_sta }EXPORT_SYMBOL_GPL (stack_depot_fetch); -void depot_fetch_stack (depot_stack_handle_t handle,struct stack_trace *trace) -{ -unsigned int nent =stack_depot_fetch (handle, &trace->entries); - - trace->max_entries = trace->nr_entries = nent; -} -EXPORT_SYMBOL_GPL (depot_fetch_stack); -/** * stack_depot_save - Save a stack trace from an array *
@@ -318,15 +310,3 @@ depot_stack_handle_t stack_depot_save(unreturn retval; }EXPORT_SYMBOL_GPL (stack_depot_save); - -/** -* depot_save_stack - save stack in a stack depot. -* @trace - the stacktrace to save. -* @alloc_flags - flags for allocating additional memory if required. -*/ -depot_stack_handle_t depot_save_stack (struct stack_trace *trace, -gfp_t alloc_flags) -{ -return stack_depot_save (trace->entries, trace->nr_entries, alloc_flags); -} -EXPORT_SYMBOL_GPL (depot_save_stack);
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] lib/stackdepot: Remove obsolete functions
lib/stackdepot: Remove obsolete functions
Commit-ID: 56d8f079c51afc8b564b9fb0252d48e7b437c1e5 Gitweb: https://git.kernel.org/tip/56d8f079c51afc8b564b9fb0252d48e7b437c1e5 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:20 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:57 +0200
lib/stackdepot: Remove obsolete functions
No more users of the struct stack_trace based interfaces.
--- include/linux/stackdepot.h | 4 ---- lib/stackdepot.c | 20 -------------------- 2 files changed, 24 deletions(-)
include/linux/stackdepot.h +0 -4
@@ -23,13 +23,9 @@typedef u32 depot_stack_handle_t ; -struct stack_trace ; - -depot_stack_handle_t depot_save_stack (struct stack_trace *trace,gfp_t flags);depot_stack_handle_t stack_depot_save (unsigned long *entries,unsigned int nr_entries,gfp_t gfp_flags); -void depot_fetch_stack (depot_stack_handle_t handle,struct stack_trace *trace);unsigned int stack_depot_fetch (depot_stack_handle_t handle,unsigned long **entries);
lib/stackdepot.c +0 -20
@@ -216,14 +216,6 @@ unsigned int stack_depot_fetch(depot_stack_handle_t handle, }EXPORT_SYMBOL_GPL (stack_depot_fetch); -void depot_fetch_stack (depot_stack_handle_t handle,struct stack_trace *trace) -{ -unsigned int nent =stack_depot_fetch (handle, &trace->entries); - - trace->max_entries = trace->nr_entries = nent; -} -EXPORT_SYMBOL_GPL (depot_fetch_stack); -/** * stack_depot_save - Save a stack trace from an array *
@@ -318,15 +310,3 @@ fast_exit:return retval; }EXPORT_SYMBOL_GPL (stack_depot_save); - -/** -* depot_save_stack - save stack in a stack depot. -* @trace - the stacktrace to save. -* @alloc_flags - flags for allocating additional memory if required. -*/ -depot_stack_handle_t depot_save_stack (struct stack_trace *trace, -gfp_t alloc_flags) -{ -return stack_depot_save (trace->entries, trace->nr_entries, alloc_flags); -} -EXPORT_SYMBOL_GPL (depot_save_stack);
PATCH v3 28/29 stacktrace: Provide common infrastructure
In reply to Thomas GleixnerAll architectures which support stacktrace carry duplicated code and do the stack storage and filtering at the architecture side.
Provide a consolidated interface with a callback function for consuming the stack entries provided by the architecture specific stack walker. This removes lots of duplicated code and allows to implement better filtering than 'skip number of entries' in the future without touching any architecture specific code.
---
V3: Fix kernel doc
--- include/linux/stacktrace.h | 39 ++++++++++ kernel/stacktrace.c | 173 +++++++++++++++++++++++++++++++++++++++++++++ lib/Kconfig | 4 + 3 files changed, 216 insertions(+)
include/linux/stacktrace.h +39 -0
@@ -23,6 +23,44 @@ unsigned int stack_trace_save_regs(strucunsigned int stack_trace_save_user (unsigned long *store,unsigned int size);/* Internal interfaces. Do not use in generic code */ +#ifdef CONFIG_ARCH_STACKWALK + +/** + * stack_trace_consume_fn - Callback for arch_stack_walk() + * @cookie: Caller supplied pointer handed back by arch_stack_walk() + * @addr: The stack entry address to consume + * @reliable: True when the stack entry is reliable. Required by + * some printk based consumers. + * + * Return: True, if the entry was consumed or skipped + * False, if there is no space left to store + */ +typedef bool (*stack_trace_consume_fn)(void *cookie, unsigned long addr, + bool reliable); +/** + * arch_stack_walk - Architecture specific function to walk the stack + * @consume_entry: Callback which is invoked by the architecture code for + * each entry. + * @cookie: Caller supplied pointer which is handed back to + * @consume_entry + * @task: Pointer to a task struct, can be NULL + * @regs: Pointer to registers, can be NULL + * + * ============ ======= ============================================ + * task regs + * ============ ======= ============================================ + * task NULL Stack trace from task (can be current) + * current regs Stack trace starting on regs->stackpointer + * ============ ======= ============================================ + */ +void arch_stack_walk(stack_trace_consume_fn consume_entry, void *cookie, + struct task_struct *task, struct pt_regs *regs); +int arch_stack_walk_reliable(stack_trace_consume_fn consume_entry, void *cookie, + struct task_struct *task); +void arch_stack_walk_user(stack_trace_consume_fn consume_entry, void *cookie, + const struct pt_regs *regs); + +#else /* CONFIG_ARCH_STACKWALK */ struct stack_trace { unsigned int nr_entries, max_entries; unsigned long *entries;
@@ -37,6 +75,7 @@ extern void save_stack_trace_tsk(structextern int save_stack_trace_tsk_reliable (struct task_struct *tsk,struct stack_trace *trace);extern void save_stack_trace_user (struct stack_trace *trace); +#endif /* !CONFIG_ARCH_STACKWALK */ #endif /* CONFIG_STACKTRACE */ #if defined(CONFIG_STACKTRACE ) && defined(CONFIG_HAVE_RELIABLE_STACKTRACE )
kernel/stacktrace.c +173 -0
188 lines not on this page · raw message
lib/Kconfig +4 -0
@@ -597,6 +597,10 @@ config ARCH_HAS_UACCESS_FLUSHCACHE config ARCH_HAS_UACCESS_MCSAFE bool +# Temporary. Goes away when all archs are cleaned up +config ARCH_STACKWALK + bool + config STACKDEPOT bool select STACKTRACE
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] stacktrace: Provide common infrastructure
stacktrace: Provide common infrastructure
Commit-ID: 214d8ca6ee854f696f75e75511fe66b409e656db Gitweb: https://git.kernel.org/tip/214d8ca6ee854f696f75e75511fe66b409e656db Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:21 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:57 +0200
stacktrace: Provide common infrastructure
All architectures which support stacktrace carry duplicated code and do the stack storage and filtering at the architecture side.
Provide a consolidated interface with a callback function for consuming the stack entries provided by the architecture specific stack walker. This removes lots of duplicated code and allows to implement better filtering than 'skip number of entries' in the future without touching any architecture specific code.
--- include/linux/stacktrace.h | 39 ++++++++++ kernel/stacktrace.c | 173 +++++++++++++++++++++++++++++++++++++++++++++ lib/Kconfig | 4 ++ 3 files changed, 216 insertions(+)
include/linux/stacktrace.h +39 -0
@@ -23,6 +23,44 @@ unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store,unsigned int stack_trace_save_user (unsigned long *store,unsigned int size);/* Internal interfaces. Do not use in generic code */ +#ifdef CONFIG_ARCH_STACKWALK + +/** + * stack_trace_consume_fn - Callback for arch_stack_walk() + * @cookie: Caller supplied pointer handed back by arch_stack_walk() + * @addr: The stack entry address to consume + * @reliable: True when the stack entry is reliable. Required by + * some printk based consumers. + * + * Return: True, if the entry was consumed or skipped + * False, if there is no space left to store + */ +typedef bool (*stack_trace_consume_fn)(void *cookie, unsigned long addr, + bool reliable); +/** + * arch_stack_walk - Architecture specific function to walk the stack + * @consume_entry: Callback which is invoked by the architecture code for + * each entry. + * @cookie: Caller supplied pointer which is handed back to + * @consume_entry + * @task: Pointer to a task struct, can be NULL + * @regs: Pointer to registers, can be NULL + * + * ============ ======= ============================================ + * task regs + * ============ ======= ============================================ + * task NULL Stack trace from task (can be current) + * current regs Stack trace starting on regs->stackpointer + * ============ ======= ============================================ + */ +void arch_stack_walk(stack_trace_consume_fn consume_entry, void *cookie, + struct task_struct *task, struct pt_regs *regs); +int arch_stack_walk_reliable(stack_trace_consume_fn consume_entry, void *cookie, + struct task_struct *task); +void arch_stack_walk_user(stack_trace_consume_fn consume_entry, void *cookie, + const struct pt_regs *regs); + +#else /* CONFIG_ARCH_STACKWALK */ struct stack_trace { unsigned int nr_entries, max_entries; unsigned long *entries;
@@ -37,6 +75,7 @@ extern void save_stack_trace_tsk(struct task_struct *tsk,extern int save_stack_trace_tsk_reliable (struct task_struct *tsk,struct stack_trace *trace);extern void save_stack_trace_user (struct stack_trace *trace); +#endif /* !CONFIG_ARCH_STACKWALK */ #endif /* CONFIG_STACKTRACE */ #if defined(CONFIG_STACKTRACE ) && defined(CONFIG_HAVE_RELIABLE_STACKTRACE )
kernel/stacktrace.c +173 -0
188 lines not on this page · raw message
lib/Kconfig +4 -0
@@ -597,6 +597,10 @@ config ARCH_HAS_UACCESS_FLUSHCACHE config ARCH_HAS_UACCESS_MCSAFE bool +# Temporary. Goes away when all archs are cleaned up +config ARCH_STACKWALK + bool + config STACKDEPOT bool select STACKTRACE
PATCH v3 29/29 x86/stacktrace: Use common infrastructure
In reply to Thomas GleixnerReplace the stack_trace_save*() functions with the new arch_stack_walk() interfaces.
--- arch/x86/Kconfig | 1 arch/x86/kernel/stacktrace.c | 116 +++++++------------------------------------ 2 files changed, 20 insertions(+), 97 deletions(-)
arch/x86/Kconfig +1 -0
@@ -74,6 +74,7 @@ config X86 select ARCH_MIGHT_HAVE_ACPI_PDC if ACPI select ARCH_MIGHT_HAVE_PC_PARPORT select ARCH_MIGHT_HAVE_PC_SERIO + select ARCH_STACKWALK select ARCH_SUPPORTS_ACPI select ARCH_SUPPORTS_ATOMIC_RMW select ARCH_SUPPORTS_NUMA_BALANCING if X86_64
arch/x86/kernel/stacktrace.c +19 -97
167 lines not on this page · raw message
tip-bot for Thomas Gleixner
merge bot[tip:core/stacktrace] x86/stacktrace: Use common infrastructure
x86/stacktrace: Use common infrastructure
Commit-ID: 3599fe12a125fa7118da2bcc5033d7741fb5f3a1 Gitweb: https://git.kernel.org/tip/3599fe12a125fa7118da2bcc5033d7741fb5f3a1 Author: Thomas Gleixner <[email protected]> AuthorDate: Thu, 25 Apr 2019 11:45:22 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 29 Apr 2019 12:37:57 +0200
x86/stacktrace: Use common infrastructure
Replace the stack_trace_save*() functions with the new arch_stack_walk() interfaces.
--- arch/x86/Kconfig | 1 + arch/x86/kernel/stacktrace.c | 116 +++++++------------------------------------ 2 files changed, 20 insertions(+), 97 deletions(-)
arch/x86/Kconfig +1 -0
@@ -74,6 +74,7 @@ config X86 select ARCH_MIGHT_HAVE_ACPI_PDC if ACPI select ARCH_MIGHT_HAVE_PC_PARPORT select ARCH_MIGHT_HAVE_PC_SERIO + select ARCH_STACKWALK select ARCH_SUPPORTS_ACPI select ARCH_SUPPORTS_ATOMIC_RMW select ARCH_SUPPORTS_NUMA_BALANCING if X86_64
arch/x86/kernel/stacktrace.c +19 -97
167 lines not on this page · raw message
Quoted 4 lines · Thomas Gleixner
kernel/locking/lockdep.c +3
-1-if (unlikely (!ret)) +if (unlikely (!ret)) { +if (!trace->nr_entries) { +/*
kernel/locking/lockdep.c check_prev_add(struct task_struct *curr, struct held_lock *prev, · line 2212
Quoted 10 lines
kernel/locking/lockdep.c +7
-0+* If save_trace fails here, the printing might +* trigger a WARN but because of the !nr_entries it +* should not do bad things. +*/ +save_trace (trace); + }return print_circular_bug (&this, target_entry, next, prev); + }else if (unlikely (ret <0 ))return print_bfs_bug (ret);
Just a minor style nit: the 'else' should probably on the same line as the '}' it belongs to, to make it really obvious that the 'if' has an 'else' branch?
At that point the condition should probably also use balanced curly braces.
Interdiff looks good otherwise.
Thanks,
Ingo
Patchwork
CI✗ Fi.CI.BAT: failure for stacktrace: Consolidate stack trace usage (rev2)
In reply to Thomas Gleixner== Series Details ==
== Series Details ==
Series: stacktrace: Consolidate stack trace usage (rev2)
URL : https://patchwork.freedesktop.org/series/59699/
State : failure
== Summary ==
Applying: tracing: Cleanup stack trace code
error: sha1 information is lacking or useless (include/linux/ftrace.h).
error: could not build fake ancestor
hint: Use 'git am --show-current-patch' to see the failed patch Patch failed at 0001 tracing: Cleanup stack trace code
When you have resolved this problem, run "git am --continue". If you prefer to skip this patch, run "git am --skip" instead. To restore the original branch and stop patching, run "git am --abort".
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 10 lines · Thomas Gleixner
This is an update to V2 which can be found here:
https://lkml.kernel.org/r/[email protected]
Changes vs. V2:
- Fixed the kernel-doc issue pointed out by Mike
- Removed the '-1' oddity from the tracer
Quoted 7 lines
- Restricted the tracer nesting to 4
- Restored the lockdep magic to prevent redundant stack traces
- Addressed the small nitpicks here and there
- Picked up Acked/Reviewed tags
Other than the 2 minor nits:
Signature · 1 line
Josh
Patchwork
CI✗ Fi.CI.BAT: failure for stacktrace: Consolidate stack trace usage (rev3)
In reply to Thomas Gleixner== Series Details ==
== Series Details ==
Series: stacktrace: Consolidate stack trace usage (rev3)
URL : https://patchwork.freedesktop.org/series/59699/
State : failure
== Summary ==
Applying: tracing: Cleanup stack trace code
error: sha1 information is lacking or useless (include/linux/ftrace.h).
error: could not build fake ancestor
hint: Use 'git am --show-current-patch' to see the failed patch Patch failed at 0001 tracing: Cleanup stack trace code
When you have resolved this problem, run "git am --continue". If you prefer to skip this patch, run "git am --skip" instead. To restore the original branch and stop patching, run "git am --abort".
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx