sched: Always check the integrity of the canary
Subsystems (8)
cover sched: Always check the integrity of the canary
Currently in the event of a stack overrun a call to schedule() does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.
The first patch provides a helper to determine the integrity of the canary. While the second patch checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
Aaron Tomlin (2):
sched: Add helper for task stack page overrun checking
sched: BUG when stack end location is over written
arch/powerpc/mm/fault.c | 6 ++---- arch/x86/mm/fault.c | 5 +---- include/linux/sched.h | 3 +++ kernel/sched/core.c | 3 +++ kernel/trace/trace_stack.c | 5 ++--- 5 files changed, 11 insertions(+), 11 deletions(-)
Signature · 1 line
1.9.3
PATCH 1/2 sched: Add helper for task stack page overrun checking
This facility is used in a few places so let's introduce a helper function to improve readability.
--- arch/powerpc/mm/fault.c | 6 ++---- arch/x86/mm/fault.c | 5 +---- include/linux/sched.h | 3 +++ kernel/trace/trace_stack.c | 5 ++--- 4 files changed, 8 insertions(+), 11 deletions(-)
arch/powerpc/mm/fault.c +2 -4
@@ -30,7 +30,6 @@#include <linux/kprobes.h> #include <linux/kdebug.h> #include <linux/perf_event.h> -#include <linux/magic.h> #include <linux/ratelimit.h> #include <linux/context_tracking.h>
@@ -508,7 +507,6 @@ bail:void bad_page_fault (struct pt_regs *regs,unsigned long address,int sig) {const struct exception_table_entry *entry; -unsigned long *stackend;/* Are we prepared to handle this fault? */ if ((entry =search_exception_tables (regs->nip)) !=NULL ) {
@@ -537,8 +535,8 @@ void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)printk (KERN_ALERT "Faulting instruction address: 0x%08lx\n" , regs->nip); - stackend =end_of_stack (current); -if (current != &init_task && *stackend !=STACK_END_MAGIC ) +if (current != &init_task && +task_stack_end_corrupted (current))printk (KERN_ALERT "Thread overran stack, or stack corrupted\n" );die ("Kernel access of bad area" , regs, sig);
arch/x86/mm/fault.c +1 -4
@@ -3,7 +3,6 @@* Copyright (C) 2001, 2002 Andi Kleen, SuSE Labs. * Copyright (C) 2008-2009, Red Hat Inc., Ingo Molnar */ -#include <linux/magic.h> /* STACK_END_MAGIC */ #include <linux/sched.h> /* test_thread_flag(), ... */ #include <linux/kdebug.h> /* oops_begin/end, ... */ #include <linux/module.h> /* search_exception_table */
@@ -649,7 +648,6 @@ no_context(struct pt_regs *regs, unsigned long error_code, unsigned long address, int signal, int si_code) { struct task_struct *tsk = current; -unsigned long *stackend;unsigned long flags;int sig;
@@ -709,8 +707,7 @@ no_context(struct pt_regs *regs, unsigned long error_code,show_fault_oops (regs, error_code, address); - stackend =end_of_stack (tsk); -if (tsk != &init_task && *stackend !=STACK_END_MAGIC ) +if (tsk != &init_task &&task_stack_end_corrupted (tsk))printk (KERN_EMERG "Thread overran stack, or stack corrupted\n" ); tsk->thread.cr2 = address;
include/linux/sched.h +3 -0
@@ -57,6 +57,7 @@ struct sched_param {#include <linux/llist.h> #include <linux/uidgid.h> #include <linux/gfp.h> +#include <linux/magic.h> #include <asm/processor.h>
@@ -2614,6 +2615,8 @@ static inline unsigned long *end_of_stack(struct task_struct *p) }#endif +#define task_stack_end_corrupted (task) \ + (*(end_of_stack(task)) != STACK_END_MAGIC)static inline int object_is_on_stack (void *obj) {
kernel/trace/trace_stack.c +2 -3
@@ -13,7 +13,6 @@#include <linux/sysctl.h> #include <linux/init.h> #include <linux/fs.h> -#include <linux/magic.h> #include <asm/setup.h>
@@ -171,8 +170,8 @@ check_stack(unsigned long ip, unsigned long *stack) i++; } -if ((current != &init_task && - *(end_of_stack (current)) !=STACK_END_MAGIC )) { +if (current != &init_task && +task_stack_end_corrupted (current)) {print_max_stack ();BUG (); }
Signature · 1 line
1.9.3
Re: [PATCH 1/2] sched: Add helper for task stack page overrun checking
include/linux/sched.h static inline unsigned long *end_of_stack(struct task_struct *p) · line 2619
Quoted 3 lines · Aaron Tomlin
include/linux/sched.h +2
-0+#define task_stack_end_corrupted (task) \ + (*(end_of_stack(task)) != STACK_END_MAGIC)
and it is always used along with "tsk != init_task".
But why we exclude swapper/0? Can't we add
end_of_stack(current) = STACK_END_MAGIC;
somewhere at the start of start_kernel() ?
If not, perhaps this new helper should check "task != &init_task" itself so that we can simplify its users?
Oleg.
Quoted 29 lines
static inline int
object_is_on_stack(void *obj)
{kernel/trace/trace_stack.c +2
-3@@ -13,7 +13,6 @@#include <linux/sysctl.h> #include <linux/init.h> #include <linux/fs.h> -#include <linux/magic.h> #include <asm/setup.h> @@ -171,8 +170,8 @@ check_stack(unsigned long ip, unsigned long *stack) i++; } -if ((current != &init_task && - *(end_of_stack (current)) !=STACK_END_MAGIC )) { +if (current != &init_task && +task_stack_end_corrupted (current)) {print_max_stack ();BUG (); }Signature · 1 line
1.9.3
Re: [PATCH 1/2] sched: Add helper for task stack page overrun checking
Quoted 7 lines · Oleg Nesterov
include/linux/sched.h static inline unsigned long *end_of_stack(struct task_struct *p) · line 2619
Quoted 3 lines · Aaron Tomlin
include/linux/sched.h +2
-0+#define task_stack_end_corrupted (task) \ + (*(end_of_stack(task)) != STACK_END_MAGIC)and it is always used along with "tsk !=
init_task".
Quoted 5 lines
But why we exclude swapper/0? Can't we add
end_of_stack(current) = STACK_END_MAGIC;somewhere at the start of
start_kernel()?
Good point. I can look into it.
Quoted 35 lines
If not, perhaps this new helper should check "task !=
&init_task" itself so that we can simplify its users?Oleg.
Quoted 29 lines
static inline int
object_is_on_stack(void *obj)
{kernel/trace/trace_stack.c +2
-3@@ -13,7 +13,6 @@#include <linux/sysctl.h> #include <linux/init.h> #include <linux/fs.h> -#include <linux/magic.h> #include <asm/setup.h> @@ -171,8 +170,8 @@ check_stack(unsigned long ip, unsigned long *stack) i++; } -if ((current != &init_task && - *(end_of_stack (current)) !=STACK_END_MAGIC )) { +if (current != &init_task && +task_stack_end_corrupted (current)) {print_max_stack ();BUG (); }Signature · 1 line
1.9.3
Signature · 1 line
Aaron Tomlin
Peter Zijlstra
maintainerRe: [PATCH 1/2] sched: Add helper for task stack page overrun checking
In reply to Aaron Tomlinarch/powerpc/mm/fault.c void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig) · line 539
Quoted 8 lines · Aaron Tomlin
arch/powerpc/mm/fault.c +2
-2@@ -537,8 +535,8 @@ void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)printk (KERN_ALERT "Faulting instruction address: 0x%08lx\n" , regs->nip); - stackend =end_of_stack (current); -if (current != &init_task && *stackend !=STACK_END_MAGIC ) +if (current != &init_task && +task_stack_end_corrupted (current))
superfluous linebreak.
Review static inline unsigned long *end_of_stack(struct task_struct *p) · line 2617
Quoted 4 lines
(quoted diff) +0
-0@@ -2614,6 +2615,8 @@ static inline unsigned long *end_of_stack(struct task_struct *p) } #endif
Here otoh we could do with some extra whitespace
kernel/trace/trace_stack.c check_stack(unsigned long ip, unsigned long *stack) · line 174
Quoted 8 lines
kernel/trace/trace_stack.c +2
-2@@ -171,8 +170,8 @@ check_stack(unsigned long ip, unsigned long *stack) i++; } -if ((current != &init_task && - *(end_of_stack (current)) !=STACK_END_MAGIC )) { +if (current != &init_task && +task_stack_end_corrupted (current)) {
Again, superfluous linebreak.
PATCH 2/2 sched: BUG when stack end location is over written
In reply to Aaron TomlinCurrently in the event of a stack overrun a call to schedule() does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.
This patch checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
--- kernel/sched/core.c | 3 +++ 1 file changed, 3 insertions(+)
kernel/sched/core.c +3 -0
@@ -2660,6 +2660,9 @@ static noinline void __schedule_bug(struct task_struct *prev)*/ static inline void schedule_debug (struct task_struct *prev) { +if (unlikely (prev != &init_task && +task_stack_end_corrupted (prev))) +BUG ();/* * Test if we are atomic. Since do_exit() needs to call into * schedule() atomically, we ignore that path. Otherwise whine
Signature · 1 line
1.9.3
Peter Zijlstra
maintainerRe: [PATCH 2/2] sched: BUG when stack end location is over written
Quoted 21 lines · Aaron Tomlin
Currently in the event of a stack overrun a call to
schedule()does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.This patch checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
Signed-off-by Aaron Tomlin <[email protected]>--- kernel/sched/core.c | 3 +++ 1 file changed, 3 insertions(+)kernel/sched/core.c +0
-0
kernel/sched/core.c static noinline void __schedule_bug(struct task_struct *prev) · line 2665
Quoted 6 lines
kernel/sched/core.c +3
-0@@ -2660,6 +2660,9 @@ static noinline void __schedule_bug(struct task_struct *prev)*/ static inline void schedule_debug (struct task_struct *prev) { +if (unlikely (prev != &init_task && +task_stack_end_corrupted (prev))) +BUG ();
superfluous linebreak, also we appear to have BUG_ON() for situations just like these.
secondly, while I appreciate the 'feature' you're making schedule() slower for everybody, what do you propose to do about that?
Re: [PATCH 2/2] sched: BUG when stack end location is over written
Quoted 32 lines · Peter Zijlstra
Quoted 21 lines · Aaron Tomlin
Currently in the event of a stack overrun a call to
schedule()does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.This patch checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
Signed-off-by Aaron Tomlin <[email protected]>--- kernel/sched/core.c | 3 +++ 1 file changed, 3 insertions(+)kernel/sched/core.c +0
-0kernel/sched/core.c static noinline void __schedule_bug(struct task_struct *prev) · line 2665
Quoted 6 lines
kernel/sched/core.c +3
-0@@ -2660,6 +2660,9 @@ static noinline void __schedule_bug(struct task_struct *prev)*/ static inline void schedule_debug (struct task_struct *prev) { +if (unlikely (prev != &init_task && +task_stack_end_corrupted (prev))) +BUG ();superfluous linebreak, also we appear to have
BUG_ON()for situations just like these.
Quoted 2 lines
secondly, while I appreciate the 'feature' you're making
schedule()slower for everybody, what do you propose to do about that?
Understood. I will wrap this with a suitable Kconfig option.
Signature · 1 line
Aaron Tomlin
v2 cover sched: Always check the integrity of the canary
Currently in the event of a stack overrun a call to schedule() does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.
The first patch adds a canary to init_task's end of stack. While the second patch provides a helper to determine the integrity of the canary. The third checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
Changes since v1:
* Rebased against v3.17-rc4
* Add a canary to init_task - Oleg Nesterov
* Fix various code formatting issues - Peter Zijlstra
* Introduce Kconfig option - Peter Zijlstra
Aaron Tomlin (3):
init/main.c: Give init_task a canary
sched: Add helper for task stack page overrun checking
sched: BUG when stack end location is over written
arch/powerpc/mm/fault.c | 5 +---- arch/x86/mm/fault.c | 5 +---- include/linux/sched.h | 4 ++++ init/main.c | 1 + kernel/fork.c | 12 +++++++++--- kernel/sched/core.c | 4 ++++ kernel/trace/trace_stack.c | 4 +--- lib/Kconfig.debug | 12 ++++++++++++ 8 files changed, 33 insertions(+), 14 deletions(-)
Signature · 1 line
1.9.3
PATCH v2 1/3 init/main.c: Give init_task a canary
Tasks get their end of stack set to STACK_END_MAGIC with the aim to catch stack overruns. Currently this feature does not apply to init_task. This patch removes this restriction.
Note that a similar patch was posted by Prarit Bhargava [1] some time ago but was never merged.
[1]: http://marc.info/?l=linux-kernel&m=127144305403241&w=2
--- arch/powerpc/mm/fault.c | 3 +-- arch/x86/mm/fault.c | 3 +-- include/linux/sched.h | 2 ++ init/main.c | 1 + kernel/fork.c | 12 +++++++++--- kernel/trace/trace_stack.c | 4 +--- 6 files changed, 15 insertions(+), 10 deletions(-)
arch/powerpc/mm/fault.c +1 -2
@@ -30,7 +30,6 @@#include <linux/kprobes.h> #include <linux/kdebug.h> #include <linux/perf_event.h> -#include <linux/magic.h> #include <linux/ratelimit.h> #include <linux/context_tracking.h>
@@ -538,7 +537,7 @@ void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig) regs->nip); stackend =end_of_stack (current); -if (current != &init_task && *stackend !=STACK_END_MAGIC ) +if (*stackend !=STACK_END_MAGIC )printk (KERN_ALERT "Thread overran stack, or stack corrupted\n" );die ("Kernel access of bad area" , regs, sig);
arch/x86/mm/fault.c +1 -2
@@ -3,7 +3,6 @@* Copyright (C) 2001, 2002 Andi Kleen, SuSE Labs. * Copyright (C) 2008-2009, Red Hat Inc., Ingo Molnar */ -#include <linux/magic.h> /* STACK_END_MAGIC */ #include <linux/sched.h> /* test_thread_flag(), ... */ #include <linux/kdebug.h> /* oops_begin/end, ... */ #include <linux/module.h> /* search_exception_table */
@@ -710,7 +709,7 @@ no_context(struct pt_regs *regs, unsigned long error_code,show_fault_oops (regs, error_code, address); stackend =end_of_stack (tsk); -if (tsk != &init_task && *stackend !=STACK_END_MAGIC ) +if (*stackend !=STACK_END_MAGIC )printk (KERN_EMERG "Thread overran stack, or stack corrupted\n" ); tsk->thread.cr2 = address;
include/linux/sched.h +2 -0
@@ -57,6 +57,7 @@ struct sched_param {#include <linux/llist.h> #include <linux/uidgid.h> #include <linux/gfp.h> +#include <linux/magic.h> #include <asm/processor.h>
@@ -2636,6 +2637,7 @@ static inline unsigned long stack_not_used(struct task_struct *p) return (unsigned long)n - (unsigned long)end_of_stack(p); }#endif +extern void task_stack_end_magic (struct task_struct *tsk);/* set thread flags in other task's structures * - see asm/thread_info.h for TIF_xxxx flags available
init/main.c +1 -0
@@ -508,6 +508,7 @@ asmlinkage __visible void __init start_kernel(void)* lockdep hash: */ lockdep_init (); +task_stack_end_magic (&init_task);smp_setup_processor_id ();debug_objects_early_init ();
kernel/fork.c +9 -3
@@ -294,11 +294,18 @@ int __weak arch_dup_task_struct(struct task_struct *dst,return 0 ; } +void task_stack_end_magic (struct task_struct *tsk) +{ +unsigned long *stackend; + + stackend =end_of_stack (tsk); + *stackend =STACK_END_MAGIC ;/* for overflow detection */ +} +static struct task_struct *dup_task_struct (struct task_struct *orig) {struct task_struct *tsk;struct thread_info *ti; -unsigned long *stackend;int node =tsk_fork_get_node (orig);int err;
@@ -328,8 +335,7 @@ static struct task_struct *dup_task_struct(struct task_struct *orig)setup_thread_stack (tsk, orig);clear_user_return_notifier (tsk);clear_tsk_need_resched (tsk); - stackend =end_of_stack (tsk); - *stackend =STACK_END_MAGIC ;/* for overflow detection */ +task_stack_end_magic (tsk);#ifdef CONFIG_CC_STACKPROTECTOR tsk->stack_canary =get_random_int ();
kernel/trace/trace_stack.c +1 -3
@@ -13,7 +13,6 @@#include <linux/sysctl.h> #include <linux/init.h> #include <linux/fs.h> -#include <linux/magic.h> #include <asm/setup.h>
@@ -171,8 +170,7 @@ check_stack(unsigned long ip, unsigned long *stack) i++; } -if ((current != &init_task && - *(end_of_stack (current)) !=STACK_END_MAGIC )) { +if (*end_of_stack (current) !=STACK_END_MAGIC ) {print_max_stack ();BUG (); }
Signature · 1 line
1.9.3
PATCH v2 2/3 sched: Add helper for task stack page overrun checking
In reply to Aaron TomlinThis facility is used in a few places so let's introduce a helper function to improve code readability.
--- arch/powerpc/mm/fault.c | 4 +--- arch/x86/mm/fault.c | 4 +--- include/linux/sched.h | 2 ++ kernel/trace/trace_stack.c | 2 +- 4 files changed, 5 insertions(+), 7 deletions(-)
arch/powerpc/mm/fault.c +1 -3
@@ -507,7 +507,6 @@ bail:void bad_page_fault (struct pt_regs *regs,unsigned long address,int sig) {const struct exception_table_entry *entry; -unsigned long *stackend;/* Are we prepared to handle this fault? */ if ((entry =search_exception_tables (regs->nip)) !=NULL ) {
@@ -536,8 +535,7 @@ void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)printk (KERN_ALERT "Faulting instruction address: 0x%08lx\n" , regs->nip); - stackend =end_of_stack (current); -if (*stackend !=STACK_END_MAGIC ) +if (task_stack_end_corrupted (current))printk (KERN_ALERT "Thread overran stack, or stack corrupted\n" );die ("Kernel access of bad area" , regs, sig);
arch/x86/mm/fault.c +1 -3
@@ -648,7 +648,6 @@ no_context(struct pt_regs *regs, unsigned long error_code, unsigned long address, int signal, int si_code) { struct task_struct *tsk = current; -unsigned long *stackend;unsigned long flags;int sig;
@@ -708,8 +707,7 @@ no_context(struct pt_regs *regs, unsigned long error_code,show_fault_oops (regs, error_code, address); - stackend =end_of_stack (tsk); -if (*stackend !=STACK_END_MAGIC ) +if (task_stack_end_corrupted (tsk))printk (KERN_EMERG "Thread overran stack, or stack corrupted\n" ); tsk->thread.cr2 = address;
include/linux/sched.h +2 -0
@@ -2615,6 +2615,8 @@ static inline unsigned long *end_of_stack(struct task_struct *p) }#endif +#define task_stack_end_corrupted (task) \ + (*(end_of_stack(task)) != STACK_END_MAGIC)static inline int object_is_on_stack (void *obj) {
kernel/trace/trace_stack.c +1 -1
@@ -170,7 +170,7 @@ check_stack(unsigned long ip, unsigned long *stack) i++; } -if (*end_of_stack (current) !=STACK_END_MAGIC ) { +if (task_stack_end_corrupted (current)) {print_max_stack ();BUG (); }
Signature · 1 line
1.9.3
PATCH v2 3/3 sched: BUG when stack end location is over written
In reply to Aaron TomlinCurrently in the event of a stack overrun a call to schedule() does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.
This patch checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
--- kernel/sched/core.c | 4 ++++ lib/Kconfig.debug | 12 ++++++++++++ 2 files changed, 16 insertions(+)
kernel/sched/core.c +4 -0
@@ -2660,6 +2660,10 @@ static noinline void __schedule_bug(struct task_struct *prev)*/ static inline void schedule_debug (struct task_struct *prev) { +#ifdef CONFIG_SCHED_STACK_END_CHECK +if (unlikely (task_stack_end_corrupted (prev))) +BUG (); +#endif /* * Test if we are atomic. Since do_exit() needs to call into * schedule() atomically, we ignore that path. Otherwise whine
lib/Kconfig.debug +12 -0
@@ -824,6 +824,18 @@ config SCHEDSTATS application, you can say N to avoid the very slight overhead this adds. +config SCHED_STACK_END_CHECK + bool "Detect stack corruption on calls to schedule()" + depends on DEBUG_KERNEL + default y + help + This option checks for a stack overrun on calls to schedule(). + If the stack end location is found to be over written always panic as + the content of the corrupted region can no longer be trusted. + This is to ensure no erroneous behaviour occurs which could result in + data corruption or a sporadic crash at a later stage once the region + is examined. The runtime overhead introduced is minimal. + config TIMER_STATS bool "Collect kernel timers statistics" depends on DEBUG_KERNEL && PROC_FS
Signature · 1 line
1.9.3
v2 cover sched: Always check the integrity of the canary
In reply to Aaron TomlinResending with "v2" added to each subject line:
Currently in the event of a stack overrun a call to schedule() does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.
The first patch adds a canary to init_task's end of stack. While the second patch provides a helper to determine the integrity of the canary. The third checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
Changes since v1:
* Rebased against v3.17-rc4
* Add a canary to init_task - Oleg Nesterov
* Fix various code formatting issues - Peter Zijlstra
* Introduce Kconfig option - Peter Zijlstra
Aaron Tomlin (3):
init/main.c: Give init_task a canary
sched: Add helper for task stack page overrun checking
sched: BUG when stack end location is over written
arch/powerpc/mm/fault.c | 5 +---- arch/x86/mm/fault.c | 5 +---- include/linux/sched.h | 4 ++++ init/main.c | 1 + kernel/fork.c | 12 +++++++++--- kernel/sched/core.c | 4 ++++ kernel/trace/trace_stack.c | 4 +--- lib/Kconfig.debug | 12 ++++++++++++ 8 files changed, 33 insertions(+), 14 deletions(-)
Signature · 1 line
1.9.3
PATCH v2 1/3 init/main.c: Give init_task a canary
Tasks get their end of stack set to STACK_END_MAGIC with the aim to catch stack overruns. Currently this feature does not apply to init_task. This patch removes this restriction.
Note that a similar patch was posted by Prarit Bhargava [1] some time ago but was never merged.
[1]: http://marc.info/?l=linux-kernel&m=127144305403241&w=2
--- arch/powerpc/mm/fault.c | 3 +-- arch/x86/mm/fault.c | 3 +-- include/linux/sched.h | 2 ++ init/main.c | 1 + kernel/fork.c | 12 +++++++++--- kernel/trace/trace_stack.c | 4 +--- 6 files changed, 15 insertions(+), 10 deletions(-)
arch/powerpc/mm/fault.c +1 -2
@@ -30,7 +30,6 @@#include <linux/kprobes.h> #include <linux/kdebug.h> #include <linux/perf_event.h> -#include <linux/magic.h> #include <linux/ratelimit.h> #include <linux/context_tracking.h>
@@ -538,7 +537,7 @@ void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig) regs->nip); stackend =end_of_stack (current); -if (current != &init_task && *stackend !=STACK_END_MAGIC ) +if (*stackend !=STACK_END_MAGIC )printk (KERN_ALERT "Thread overran stack, or stack corrupted\n" );die ("Kernel access of bad area" , regs, sig);
arch/x86/mm/fault.c +1 -2
@@ -3,7 +3,6 @@* Copyright (C) 2001, 2002 Andi Kleen, SuSE Labs. * Copyright (C) 2008-2009, Red Hat Inc., Ingo Molnar */ -#include <linux/magic.h> /* STACK_END_MAGIC */ #include <linux/sched.h> /* test_thread_flag(), ... */ #include <linux/kdebug.h> /* oops_begin/end, ... */ #include <linux/module.h> /* search_exception_table */
@@ -710,7 +709,7 @@ no_context(struct pt_regs *regs, unsigned long error_code,show_fault_oops (regs, error_code, address); stackend =end_of_stack (tsk); -if (tsk != &init_task && *stackend !=STACK_END_MAGIC ) +if (*stackend !=STACK_END_MAGIC )printk (KERN_EMERG "Thread overran stack, or stack corrupted\n" ); tsk->thread.cr2 = address;
include/linux/sched.h +2 -0
@@ -57,6 +57,7 @@ struct sched_param {#include <linux/llist.h> #include <linux/uidgid.h> #include <linux/gfp.h> +#include <linux/magic.h> #include <asm/processor.h>
@@ -2636,6 +2637,7 @@ static inline unsigned long stack_not_used(struct task_struct *p) return (unsigned long)n - (unsigned long)end_of_stack(p); }#endif +extern void task_stack_end_magic (struct task_struct *tsk);/* set thread flags in other task's structures * - see asm/thread_info.h for TIF_xxxx flags available
init/main.c +1 -0
@@ -508,6 +508,7 @@ asmlinkage __visible void __init start_kernel(void)* lockdep hash: */ lockdep_init (); +task_stack_end_magic (&init_task);smp_setup_processor_id ();debug_objects_early_init ();
kernel/fork.c +9 -3
@@ -294,11 +294,18 @@ int __weak arch_dup_task_struct(struct task_struct *dst,return 0 ; } +void task_stack_end_magic (struct task_struct *tsk) +{ +unsigned long *stackend; + + stackend =end_of_stack (tsk); + *stackend =STACK_END_MAGIC ;/* for overflow detection */ +} +static struct task_struct *dup_task_struct (struct task_struct *orig) {struct task_struct *tsk;struct thread_info *ti; -unsigned long *stackend;int node =tsk_fork_get_node (orig);int err;
@@ -328,8 +335,7 @@ static struct task_struct *dup_task_struct(struct task_struct *orig)setup_thread_stack (tsk, orig);clear_user_return_notifier (tsk);clear_tsk_need_resched (tsk); - stackend =end_of_stack (tsk); - *stackend =STACK_END_MAGIC ;/* for overflow detection */ +task_stack_end_magic (tsk);#ifdef CONFIG_CC_STACKPROTECTOR tsk->stack_canary =get_random_int ();
kernel/trace/trace_stack.c +1 -3
@@ -13,7 +13,6 @@#include <linux/sysctl.h> #include <linux/init.h> #include <linux/fs.h> -#include <linux/magic.h> #include <asm/setup.h>
@@ -171,8 +170,7 @@ check_stack(unsigned long ip, unsigned long *stack) i++; } -if ((current != &init_task && - *(end_of_stack (current)) !=STACK_END_MAGIC )) { +if (*end_of_stack (current) !=STACK_END_MAGIC ) {print_max_stack ();BUG (); }
Signature · 1 line
1.9.3
Re: [PATCH v2 1/3] init/main.c: Give init_task a canary
kernel/fork.c int __weak arch_dup_task_struct(struct task_struct *dst, · line 304
Quoted 8 lines · On Tue, 9 Sep 2014 10:42:27 +0100 Aaron Tomlin <[email protected]> wrote:
kernel/fork.c +8
-0+void task_stack_end_magic (struct task_struct *tsk) +{ +unsigned long *stackend; + + stackend =end_of_stack (tsk); + *stackend =STACK_END_MAGIC ;/* for overflow detection */ +} +
For clarity this should probably be called set_task_stack_end_magic().
And has this been tested on parisc and metag, which use STACK_GROWSUP ? I can't see how end_of_stack() as it's defined now could work on those archs.
Re: [PATCH v2 1/3] init/main.c: Give init_task a canary
Quoted 13 lines · Chuck Ebbert
kernel/fork.c int __weak arch_dup_task_struct(struct task_struct *dst, · line 304
Quoted 8 lines · On Tue, 9 Sep 2014 10:42:27 +0100 Aaron Tomlin <[email protected]> wrote:
kernel/fork.c +8
-0+void task_stack_end_magic (struct task_struct *tsk) +{ +unsigned long *stackend; + + stackend =end_of_stack (tsk); + *stackend =STACK_END_MAGIC ;/* for overflow detection */ +} +For clarity this should probably be called
set_task_stack_end_magic().
Agreed.
Quoted 2 lines
And has this been tested on parisc and metag, which use
STACK_GROWSUP? I can't see howend_of_stack()as it's defined now could work on those archs.
AFAIU, dup_task_struct() has always done this explicitly. I see no reason why init_task requires special attention.
Signature · 1 line
Aaron Tomlin
Re: [PATCH v2 1/3] init/main.c: Give init_task a canary
Quoted 7 lines · On Wed, 10 Sep 2014 14:29:33 +0100 Aaron Tomlin <[email protected]> wrote:
Quoted 2 lines · Chuck Ebbert
And has this been tested on parisc and metag, which use
STACK_GROWSUP? I can't see howend_of_stack()as it's defined now could work on those archs.AFAIU,
dup_task_struct()has always done this explicitly. I see no reason whyinit_taskrequires special attention.
I guess what I'm saying is, I can't see how the stack canary could have ever detected any problems on parisc and metag. How did you test your patches on x86? Maybe someone could run tests on those other archs.
Re: [PATCH v2 1/3] init/main.c: Give init_task a canary
Quoted 7 lines · Chuck Ebbert
Quoted 4 lines · On Wed, 10 Sep 2014 14:29:33 +0100 Aaron Tomlin <[email protected]> wrote:
Quoted 2 lines · Chuck Ebbert
And has this been tested on parisc and metag, which use
STACK_GROWSUP? I can't see howend_of_stack()as it's defined now could work on those archs.
Quoted 6 lines
Quoted 3 lines
AFAIU,
dup_task_struct()has always done this explicitly. I see no reason whyinit_taskrequires special attention.I guess what I'm saying is, I can't see how the stack canary could have ever detected any problems on parisc and metag. How did you test your patches on x86?
Yes - under x86 only.
Quoted 1 line
Maybe someone could run tests on those other archs.
As I said, I can't see why it wouldn't work given
dup_task_struct()'s behaviour.
Signature · 1 line
Aaron Tomlin
PATCH v2 2/3 sched: Add helper for task stack page overrun checking
In reply to Aaron TomlinThis facility is used in a few places so let's introduce a helper function to improve code readability.
--- arch/powerpc/mm/fault.c | 4 +--- arch/x86/mm/fault.c | 4 +--- include/linux/sched.h | 2 ++ kernel/trace/trace_stack.c | 2 +- 4 files changed, 5 insertions(+), 7 deletions(-)
arch/powerpc/mm/fault.c +1 -3
@@ -507,7 +507,6 @@ bail:void bad_page_fault (struct pt_regs *regs,unsigned long address,int sig) {const struct exception_table_entry *entry; -unsigned long *stackend;/* Are we prepared to handle this fault? */ if ((entry =search_exception_tables (regs->nip)) !=NULL ) {
@@ -536,8 +535,7 @@ void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)printk (KERN_ALERT "Faulting instruction address: 0x%08lx\n" , regs->nip); - stackend =end_of_stack (current); -if (*stackend !=STACK_END_MAGIC ) +if (task_stack_end_corrupted (current))printk (KERN_ALERT "Thread overran stack, or stack corrupted\n" );die ("Kernel access of bad area" , regs, sig);
arch/x86/mm/fault.c +1 -3
@@ -648,7 +648,6 @@ no_context(struct pt_regs *regs, unsigned long error_code, unsigned long address, int signal, int si_code) { struct task_struct *tsk = current; -unsigned long *stackend;unsigned long flags;int sig;
@@ -708,8 +707,7 @@ no_context(struct pt_regs *regs, unsigned long error_code,show_fault_oops (regs, error_code, address); - stackend =end_of_stack (tsk); -if (*stackend !=STACK_END_MAGIC ) +if (task_stack_end_corrupted (tsk))printk (KERN_EMERG "Thread overran stack, or stack corrupted\n" ); tsk->thread.cr2 = address;
include/linux/sched.h +2 -0
@@ -2615,6 +2615,8 @@ static inline unsigned long *end_of_stack(struct task_struct *p) }#endif +#define task_stack_end_corrupted (task) \ + (*(end_of_stack(task)) != STACK_END_MAGIC)static inline int object_is_on_stack (void *obj) {
kernel/trace/trace_stack.c +1 -1
@@ -170,7 +170,7 @@ check_stack(unsigned long ip, unsigned long *stack) i++; } -if (*end_of_stack (current) !=STACK_END_MAGIC ) { +if (task_stack_end_corrupted (current)) {print_max_stack ();BUG (); }
Signature · 1 line
1.9.3
PATCH v2 3/3 sched: BUG when stack end location is over written
In reply to Aaron TomlinCurrently in the event of a stack overrun a call to schedule() does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.
This patch checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
--- kernel/sched/core.c | 4 ++++ lib/Kconfig.debug | 12 ++++++++++++ 2 files changed, 16 insertions(+)
kernel/sched/core.c +4 -0
@@ -2660,6 +2660,10 @@ static noinline void __schedule_bug(struct task_struct *prev)*/ static inline void schedule_debug (struct task_struct *prev) { +#ifdef CONFIG_SCHED_STACK_END_CHECK +if (unlikely (task_stack_end_corrupted (prev))) +BUG (); +#endif /* * Test if we are atomic. Since do_exit() needs to call into * schedule() atomically, we ignore that path. Otherwise whine
lib/Kconfig.debug +12 -0
@@ -824,6 +824,18 @@ config SCHEDSTATS application, you can say N to avoid the very slight overhead this adds. +config SCHED_STACK_END_CHECK + bool "Detect stack corruption on calls to schedule()" + depends on DEBUG_KERNEL + default y + help + This option checks for a stack overrun on calls to schedule(). + If the stack end location is found to be over written always panic as + the content of the corrupted region can no longer be trusted. + This is to ensure no erroneous behaviour occurs which could result in + data corruption or a sporadic crash at a later stage once the region + is examined. The runtime overhead introduced is minimal. + config TIMER_STATS bool "Collect kernel timers statistics" depends on DEBUG_KERNEL && PROC_FS
Signature · 1 line
1.9.3
v3 cover sched: Always check the integrity of the canary
In reply to Aaron TomlinHi Peter,
Please let me know if this iteration is satisfactory. Thanks.
Currently in the event of a stack overrun a call to schedule() does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.
The first patch adds a canary to init_task's end of stack. While the second patch provides a helper to determine the integrity of the canary. The third checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
Changes since v2:
* Use BUG_ON in schedule_debug() - Peter Zijlstra
* Use a more explicit function
name for setting the canary - Chuck Ebbert
Changes since v1:
* Rebased against v3.17-rc4
* Add a canary to init_task - Oleg Nesterov
* Fix various code formatting issues - Peter Zijlstra
* Introduce Kconfig option - Peter Zijlstra
Aaron Tomlin (3):
init/main.c: Give init_task a canary
sched: Add helper for task stack page overrun checking
sched: BUG when stack end location is over written
arch/powerpc/mm/fault.c | 5 +---- arch/x86/mm/fault.c | 5 +---- include/linux/sched.h | 4 ++++ init/main.c | 1 + kernel/fork.c | 12 +++++++++--- kernel/sched/core.c | 3 +++ kernel/trace/trace_stack.c | 4 +--- lib/Kconfig.debug | 12 ++++++++++++ 8 files changed, 32 insertions(+), 14 deletions(-)
Signature · 1 line
1.9.3
PATCH v3 1/3 init/main.c: Give init_task a canary
Tasks get their end of stack set to STACK_END_MAGIC with the aim to catch stack overruns. Currently this feature does not apply to init_task. This patch removes this restriction.
Note that a similar patch was posted by Prarit Bhargava [1] some time ago but was never merged.
[1]: http://marc.info/?l=linux-kernel&m=127144305403241&w=2
--- arch/powerpc/mm/fault.c | 3 +-- arch/x86/mm/fault.c | 3 +-- include/linux/sched.h | 2 ++ init/main.c | 1 + kernel/fork.c | 12 +++++++++--- kernel/trace/trace_stack.c | 4 +--- 6 files changed, 15 insertions(+), 10 deletions(-)
arch/powerpc/mm/fault.c +1 -2
@@ -30,7 +30,6 @@#include <linux/kprobes.h> #include <linux/kdebug.h> #include <linux/perf_event.h> -#include <linux/magic.h> #include <linux/ratelimit.h> #include <linux/context_tracking.h>
@@ -538,7 +537,7 @@ void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig) regs->nip); stackend =end_of_stack (current); -if (current != &init_task && *stackend !=STACK_END_MAGIC ) +if (*stackend !=STACK_END_MAGIC )printk (KERN_ALERT "Thread overran stack, or stack corrupted\n" );die ("Kernel access of bad area" , regs, sig);
arch/x86/mm/fault.c +1 -2
@@ -3,7 +3,6 @@* Copyright (C) 2001, 2002 Andi Kleen, SuSE Labs. * Copyright (C) 2008-2009, Red Hat Inc., Ingo Molnar */ -#include <linux/magic.h> /* STACK_END_MAGIC */ #include <linux/sched.h> /* test_thread_flag(), ... */ #include <linux/kdebug.h> /* oops_begin/end, ... */ #include <linux/module.h> /* search_exception_table */
@@ -710,7 +709,7 @@ no_context(struct pt_regs *regs, unsigned long error_code,show_fault_oops (regs, error_code, address); stackend =end_of_stack (tsk); -if (tsk != &init_task && *stackend !=STACK_END_MAGIC ) +if (*stackend !=STACK_END_MAGIC )printk (KERN_EMERG "Thread overran stack, or stack corrupted\n" ); tsk->thread.cr2 = address;
include/linux/sched.h +2 -0
@@ -57,6 +57,7 @@ struct sched_param {#include <linux/llist.h> #include <linux/uidgid.h> #include <linux/gfp.h> +#include <linux/magic.h> #include <asm/processor.h>
@@ -2636,6 +2637,7 @@ static inline unsigned long stack_not_used(struct task_struct *p) return (unsigned long)n - (unsigned long)end_of_stack(p); }#endif +extern void set_task_stack_end_magic (struct task_struct *tsk);/* set thread flags in other task's structures * - see asm/thread_info.h for TIF_xxxx flags available
init/main.c +1 -0
@@ -508,6 +508,7 @@ asmlinkage __visible void __init start_kernel(void)* lockdep hash: */ lockdep_init (); +set_task_stack_end_magic (&init_task);smp_setup_processor_id ();debug_objects_early_init ();
kernel/fork.c +9 -3
@@ -294,11 +294,18 @@ int __weak arch_dup_task_struct(struct task_struct *dst,return 0 ; } +void set_task_stack_end_magic (struct task_struct *tsk) +{ +unsigned long *stackend; + + stackend =end_of_stack (tsk); + *stackend =STACK_END_MAGIC ;/* for overflow detection */ +} +static struct task_struct *dup_task_struct (struct task_struct *orig) {struct task_struct *tsk;struct thread_info *ti; -unsigned long *stackend;int node =tsk_fork_get_node (orig);int err;
@@ -328,8 +335,7 @@ static struct task_struct *dup_task_struct(struct task_struct *orig)setup_thread_stack (tsk, orig);clear_user_return_notifier (tsk);clear_tsk_need_resched (tsk); - stackend =end_of_stack (tsk); - *stackend =STACK_END_MAGIC ;/* for overflow detection */ +set_task_stack_end_magic (tsk);#ifdef CONFIG_CC_STACKPROTECTOR tsk->stack_canary =get_random_int ();
kernel/trace/trace_stack.c +1 -3
@@ -13,7 +13,6 @@#include <linux/sysctl.h> #include <linux/init.h> #include <linux/fs.h> -#include <linux/magic.h> #include <asm/setup.h>
@@ -171,8 +170,7 @@ check_stack(unsigned long ip, unsigned long *stack) i++; } -if ((current != &init_task && - *(end_of_stack (current)) !=STACK_END_MAGIC )) { +if (*end_of_stack (current) !=STACK_END_MAGIC ) {print_max_stack ();BUG (); }
Signature · 1 line
1.9.3
Re: [PATCH v3 1/3] init/main.c: Give init_task a canary
Quoted 17 lines · Aaron Tomlin
Tasks get their end of stack set to
STACK_END_MAGICwith the aim to catch stack overruns. Currently this feature does not apply toinit_task. This patch removes this restriction.arch/powerpc/mm/fault.c +0
-1@@ -30,7 +30,6 @@#include <linux/kprobes.h> #include <linux/kdebug.h> #include <linux/perf_event.h> -#include <linux/magic.h> #include <linux/ratelimit.h> #include <linux/context_tracking.h>
arch/powerpc/mm/fault.c void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig) · line 541
Quoted 6 lines
arch/powerpc/mm/fault.c +1
-1@@ -538,7 +537,7 @@ void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig) regs->nip); stackend =end_of_stack (current); -if (current != &init_task && *stackend !=STACK_END_MAGIC ) +if (*stackend !=STACK_END_MAGIC )printk (KERN_ALERT "Thread overran stack, or stack corrupted\n" );
This part looks fine.
cheers
PATCH v3 2/3 sched: Add helper for task stack page overrun checking
In reply to Aaron TomlinThis facility is used in a few places so let's introduce a helper function to improve code readability.
--- arch/powerpc/mm/fault.c | 4 +--- arch/x86/mm/fault.c | 4 +--- include/linux/sched.h | 2 ++ kernel/trace/trace_stack.c | 2 +- 4 files changed, 5 insertions(+), 7 deletions(-)
arch/powerpc/mm/fault.c +1 -3
@@ -507,7 +507,6 @@ bail:void bad_page_fault (struct pt_regs *regs,unsigned long address,int sig) {const struct exception_table_entry *entry; -unsigned long *stackend;/* Are we prepared to handle this fault? */ if ((entry =search_exception_tables (regs->nip)) !=NULL ) {
@@ -536,8 +535,7 @@ void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)printk (KERN_ALERT "Faulting instruction address: 0x%08lx\n" , regs->nip); - stackend =end_of_stack (current); -if (*stackend !=STACK_END_MAGIC ) +if (task_stack_end_corrupted (current))printk (KERN_ALERT "Thread overran stack, or stack corrupted\n" );die ("Kernel access of bad area" , regs, sig);
arch/x86/mm/fault.c +1 -3
@@ -648,7 +648,6 @@ no_context(struct pt_regs *regs, unsigned long error_code, unsigned long address, int signal, int si_code) { struct task_struct *tsk = current; -unsigned long *stackend;unsigned long flags;int sig;
@@ -708,8 +707,7 @@ no_context(struct pt_regs *regs, unsigned long error_code,show_fault_oops (regs, error_code, address); - stackend =end_of_stack (tsk); -if (*stackend !=STACK_END_MAGIC ) +if (task_stack_end_corrupted (tsk))printk (KERN_EMERG "Thread overran stack, or stack corrupted\n" ); tsk->thread.cr2 = address;
include/linux/sched.h +2 -0
@@ -2615,6 +2615,8 @@ static inline unsigned long *end_of_stack(struct task_struct *p) }#endif +#define task_stack_end_corrupted (task) \ + (*(end_of_stack(task)) != STACK_END_MAGIC)static inline int object_is_on_stack (void *obj) {
kernel/trace/trace_stack.c +1 -1
@@ -170,7 +170,7 @@ check_stack(unsigned long ip, unsigned long *stack) i++; } -if (*end_of_stack (current) !=STACK_END_MAGIC ) { +if (task_stack_end_corrupted (current)) {print_max_stack ();BUG (); }
Signature · 1 line
1.9.3
PATCH v3 3/3 sched: BUG when stack end location is over written
In reply to Aaron TomlinCurrently in the event of a stack overrun a call to schedule() does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.
This patch checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
--- kernel/sched/core.c | 3 +++ lib/Kconfig.debug | 12 ++++++++++++ 2 files changed, 15 insertions(+)
kernel/sched/core.c +3 -0
@@ -2660,6 +2660,9 @@ static noinline void __schedule_bug(struct task_struct *prev)*/ static inline void schedule_debug (struct task_struct *prev) { +#ifdef CONFIG_SCHED_STACK_END_CHECK + BUG_ON(unlikely(task_stack_end_corrupted(prev))) +#endif /* * Test if we are atomic. Since do_exit() needs to call into * schedule() atomically, we ignore that path. Otherwise whine
lib/Kconfig.debug +12 -0
@@ -824,6 +824,18 @@ config SCHEDSTATS application, you can say N to avoid the very slight overhead this adds. +config SCHED_STACK_END_CHECK + bool "Detect stack corruption on calls to schedule()" + depends on DEBUG_KERNEL + default y + help + This option checks for a stack overrun on calls to schedule(). + If the stack end location is found to be over written always panic as + the content of the corrupted region can no longer be trusted. + This is to ensure no erroneous behaviour occurs which could result in + data corruption or a sporadic crash at a later stage once the region + is examined. The runtime overhead introduced is minimal. + config TIMER_STATS bool "Collect kernel timers statistics" depends on DEBUG_KERNEL && PROC_FS
Signature · 1 line
1.9.3
Michael Ellerman
reviewerRe: [PATCH v3 3/3] sched: BUG when stack end location is over written
lib/Kconfig.debug config SCHEDSTATS · line 830
Quoted 12 lines · Aaron Tomlin
lib/Kconfig.debug +4
-0@@ -824,6 +824,18 @@ config SCHEDSTATS application, you can say N to avoid the very slight overhead this adds. +config SCHED_STACK_END_CHECK + bool "Detect stack corruption on calls to schedule()" + depends on DEBUG_KERNEL + default y
Did you really mean default y?
Doing so means it will be turned on more or less everywhere, which defeats the purpose of having a config option in the first place.
kernel/sched/core.c static noinline void __schedule_bug(struct task_struct *prev) · line 2665
Quoted 11 lines
kernel/sched/core.c +3
-0@@ -2660,6 +2660,9 @@ static noinline void __schedule_bug(struct task_struct *prev)*/ static inline void schedule_debug (struct task_struct *prev) { +#ifdef CONFIG_SCHED_STACK_END_CHECK + BUG_ON(unlikely(task_stack_end_corrupted(prev))) +#endif
If this was my code I'd make you put that in a static inline.
cheers
Re: [PATCH v3 3/3] sched: BUG when stack end location is over written
Quoted 16 lines · Michael Ellerman
lib/Kconfig.debug config SCHEDSTATS · line 830
Quoted 12 lines · Aaron Tomlin
lib/Kconfig.debug +4
-0@@ -824,6 +824,18 @@ config SCHEDSTATS application, you can say N to avoid the very slight overhead this adds. +config SCHED_STACK_END_CHECK + bool "Detect stack corruption on calls to schedule()" + depends on DEBUG_KERNEL + default yDid you really mean default y?
Quoted 2 lines
Doing so means it will be turned on more or less everywhere, which defeats the purpose of having a config option in the first place.
Only if Kconfig CONFIG_DEBUG_KERNEL is enabled in the first place.
Signature · 1 line
Aaron Tomlin
Re: [PATCH v3 3/3] sched: BUG when stack end location is over written
Quoted 17 lines · Aaron Tomlin
Quoted 16 lines · Michael Ellerman
lib/Kconfig.debug config SCHEDSTATS · line 830
Quoted 12 lines · Aaron Tomlin
lib/Kconfig.debug +4
-0@@ -824,6 +824,18 @@ config SCHEDSTATS application, you can say N to avoid the very slight overhead this adds. +config SCHED_STACK_END_CHECK + bool "Detect stack corruption on calls to schedule()" + depends on DEBUG_KERNEL + default yDid you really mean default y?
Quoted 4 lines
Quoted 2 lines
Doing so means it will be turned on more or less everywhere, which defeats the purpose of having a config option in the first place.
Only if
KconfigCONFIG_DEBUG_KERNELis enabled in the first place.
Which is likely enabled just about everywhere on the planet.
-Mike
Michael Ellerman
reviewerRe: [PATCH v3 3/3] sched: BUG when stack end location is over written
Quoted 18 lines · Mike Galbraith
Quoted 17 lines · Aaron Tomlin
Quoted 16 lines · Michael Ellerman
lib/Kconfig.debug config SCHEDSTATS · line 830
Quoted 12 lines · Aaron Tomlin
lib/Kconfig.debug +4
-0@@ -824,6 +824,18 @@ config SCHEDSTATS application, you can say N to avoid the very slight overhead this adds. +config SCHED_STACK_END_CHECK + bool "Detect stack corruption on calls to schedule()" + depends on DEBUG_KERNEL + default yDid you really mean default y?
Quoted 6 lines
Quoted 4 lines
Quoted 2 lines
Doing so means it will be turned on more or less everywhere, which defeats the purpose of having a config option in the first place.
Only if
KconfigCONFIG_DEBUG_KERNELis enabled in the first place.Which is likely enabled just about everywhere on the planet.
Yes, including all distros I'm aware of.
cheers
Michael Ellerman
reviewerRe: [PATCH v3 3/3] sched: BUG when stack end location is over written
In reply to Aaron TomlinQuoted 22 lines · Aaron Tomlin
Currently in the event of a stack overrun a call to
schedule()does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.This patch checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
Signed-off-by Aaron Tomlin <[email protected]>--- kernel/sched/core.c | 3 +++ lib/Kconfig.debug | 12 ++++++++++++ 2 files changed, 15 insertions(+)kernel/sched/core.c +0
-0
kernel/sched/core.c static noinline void __schedule_bug(struct task_struct *prev) · line 2665
Quoted 6 lines
kernel/sched/core.c +3
-0@@ -2660,6 +2660,9 @@ static noinline void __schedule_bug(struct task_struct *prev)*/ static inline void schedule_debug (struct task_struct *prev) { +#ifdef CONFIG_SCHED_STACK_END_CHECK + BUG_ON(unlikely(task_stack_end_corrupted(prev))) +#endif
Spot the bug? Please compile your code in future.
../kernel/sched/core.c: In function ‘schedule_debug’:../kernel/sched/core.c:2671:2: error: expected ‘;’ before ‘if’
if (unlikely(in_atomic_preempt_off() && prev->state != TASK_DEAD))
^../kernel/sched/core.c: At top level:../kernel/sched/core.c:2635:22: warning: ‘__schedule_bug’ defined but not used [-Wunused-function]
static noinline void __schedule_bug(struct task_struct *prev)
^
make[3]: *** [kernel/sched/core.o] Error 1 make[2]: *** [kernel/sched] Error 2 make[1]: *** [kernel] Error 2
make: *** [sub-make] Error 2
cheers
Re: [PATCH v3 3/3] sched: BUG when stack end location is over written
Quoted 18 lines · Michael Ellerman
Quoted 17 lines · Aaron Tomlin
Currently in the event of a stack overrun a call to
schedule()does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.This patch checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
Signed-off-by Aaron Tomlin <[email protected]>--- kernel/sched/core.c | 3 +++ lib/Kconfig.debug | 12 ++++++++++++ 2 files changed, 15 insertions(+)
Quoted 13 lines
kernel/sched/core.c static noinline void __schedule_bug(struct task_struct *prev) · line 2665
Quoted 11 lines
kernel/sched/core.c +3
-0@@ -2660,6 +2660,9 @@ static noinline void __schedule_bug(struct task_struct *prev)*/ static inline void schedule_debug (struct task_struct *prev) { +#ifdef CONFIG_SCHED_STACK_END_CHECK + BUG_ON(unlikely(task_stack_end_corrupted(prev))) +#endif Spot the bug? Please compile your code in future.
Oops! Sorry about that.
Signature · 1 line
Aaron Tomlin
Peter Zijlstra
maintainerWhat's with the threading all versions together? Please don't do that -- also don't post a new version just for this though.
Quoted 3 lines · Peter Zijlstra
What's with the threading all versions together? Please don't do that -- also don't post a new version just for this though.
Sorry about that. Noted.
Signature · 1 line
Aaron Tomlin
RnJvbTogQWFyb24gVG9tbGluDQo+IEN1cnJlbnRseSBpbiB0aGUgZXZlbnQgb2YgYSBzdGFjayBv dmVycnVuIGEgY2FsbCB0byBzY2hlZHVsZSgpDQo+IGRvZXMgbm90IGNoZWNrIGZvciB0aGlzIHR5 cGUgb2YgY29ycnVwdGlvbi4gVGhpcyBjb3JydXB0aW9uIGlzDQo+IG9mdGVuIHNpbGVudCBhbmQg Y2FuIGdvIHVubm90aWNlZC4gSG93ZXZlciBvbmNlIHRoZSBjb3JydXB0ZWQNCj4gcmVnaW9uIGlz IGV4YW1pbmVkIGF0IGEgbGF0ZXIgc3RhZ2UsIHRoZSBvdXRjb21lIGlzIHVuZGVmaW5lZA0KPiBh bmQgb2Z0ZW4gcmVzdWx0cyBpbiBhIHNwb3JhZGljIHBhZ2UgZmF1bHQgd2hpY2ggY2Fubm90IGJl DQo+IGhhbmRsZWQuDQo+IA0KPiBUaGUgZmlyc3QgcGF0Y2ggYWRkcyBhIGNhbmFyeSB0byBpbml0 X3Rhc2sncyBlbmQgb2Ygc3RhY2suDQo+IFdoaWxlIHRoZSBzZWNvbmQgcGF0Y2ggcHJvdmlkZXMg YSBoZWxwZXIgdG8gZGV0ZXJtaW5lIHRoZQ0KPiBpbnRlZ3JpdHkgb2YgdGhlIGNhbmFyeS4gVGhl IHRoaXJkIGNoZWNrcyBmb3IgYSBzdGFjaw0KPiBvdmVycnVuIGFuZCB0YWtlcyBhcHByb3ByaWF0 ZSBhY3Rpb24gc2luY2UgdGhlIGRhbWFnZQ0KPiBpcyBhbHJlYWR5IGRvbmUsIHRoZXJlIGlzIG5v IHBvaW50IGluIGNvbnRpbnVpbmcuDQoNCkNsZWFybHkgeW91J3ZlIGp1c3QgYmVlbiAnYml0dGVu JyBieSBhIGtlcm5lbCBzdGFjayBvdmVyZmxvdy4NCkJ1dCBhIHNpbXBsZSAnY2FuYXJ5JyBpc24n dCBnb2luZyB0byBmaW5kIG1vc3Qgb2YgdGhlIG92ZXJmbG93cw0KYW5kIHdpbGwgZ2l2ZSBhbiBp bmNvcnJlY3QgJ3NlbnNlIG9mIHNlY3VyaXR5Jy4NCg0KVGhlIGNhbmFyeSB3aWxsIG9ubHkgd29y ayBpZiB0aGUgc3RhY2sgaXMgZGVuc2VseSB3cml0dGVuLg0KSW4gcHJhY3Rpc2UgdGhlIHN0YWNr IGFsaWdubWVudCBydWxlcyBjcmVhdGUgZ2FwcywgYW5kIHRoZQ0KbW9zdCBsaWtlbHkgcmVhc29u IGZvciBvdmVyZmxvdyBpcyBhIGxhcmdlIG9uLXN0YWNrIGJ1ZmZlcg0KdGhhdCBpc24ndCBhY3R1 YWxseSB3cml0dGVuIHRvLg0KDQpUaGUgb25seSByZWFsIHdheSB0byBkZXRlY3Qga2VybmVsIHN0 YWNrIG92ZXJmbG93IGlzIHRvIGFycmFuZ2UNCmZvciBhbiB1bm1hcHBlZCBwYWdlIGJleW9uZCB0 aGUgc3RhY2suDQpUaGF0IGNvc3RzIEtWQSwgYnV0IG5vdCBtdWNoIGVsc2UuDQoNCglEYXZpZA0K DQo=
Quoted 18 lines · On Thu, 11 Sep 2014 16:02:45 +0000 David Laight <[email protected]> wrote:
From: Aaron Tomlin
Quoted 7 lines
Currently in the event of a stack overrun a call to
schedule()does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.Quoted 5 lines
The first patch adds a canary to init_task's end of stack. While the second patch provides a helper to determine the integrity of the canary. The third checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
Clearly you've just been 'bitten' by a kernel stack overflow. But a simple 'canary' isn't going to find most of the overflows and will give an incorrect 'sense of security'.
Quoted 9 lines
The canary will only work if the stack is densely written. In practise the stack alignment rules create gaps, and the most likely reason for overflow is a large on-stack buffer that isn't actually written to.
The only real way to detect kernel stack overflow is to arrange for an unmapped page beyond the stack.
That costs KVA, but not much else.
That doesn't work either, because the threadinfo sits between the end of the stack and the beginning of the next page, making it possible to corrupt critical data without running off the page.
From: Chuck Ebbert=20
Quoted 25 lines
David Laight <[email protected]> wrote:
=20Quoted 23 lines
From: Aaron Tomlin
Quoted 7 lines
Currently in the event of a stack overrun a call to
schedule()does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.Quoted 5 lines
The first patch adds a canary to init_task's end of stack. While the second patch provides a helper to determine the integrity of the canary. The third checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
Clearly you've just been 'bitten' by a kernel stack overflow. But a simple 'canary' isn't going to find most of the overflows and will give an incorrect 'sense of security'.
The canary will only work if the stack is densely written. In practise the stack alignment rules create gaps, and the most likely reason for overflow is a large on-stack buffer that isn't actually written to.
Quoted 6 lines
Quoted 4 lines
The only real way to detect kernel stack overflow is to arrange for an unmapped page beyond the stack.
That costs KVA, but not much else.=20
That doesn't work either, because the threadinfo sits between the end of =
the
Quoted 1 line
stack and the beginning of the next page, making it possible to corrupt c=
ritical
Quoted 1 line
data without running off the page.
Then flip the order of the allocations so that the threadinfo is at the oth= er end.
I'm not sure how many per-lwp structures the linux kernel has, but I know that on netbsd the main thing the kernel stack hits is the fpu save area - the end of that is the avx area which won't be needed when the stack usage is large.
Everything else could be moved from the stack pages to the lwp struct itsel= f.
David
Quoted 14 lines · David Laight
From: Aaron Tomlin
Quoted 7 lines
Currently in the event of a stack overrun a call to
schedule()does not check for this type of corruption. This corruption is often silent and can go unnoticed. However once the corrupted region is examined at a later stage, the outcome is undefined and often results in a sporadic page fault which cannot be handled.Quoted 5 lines
The first patch adds a canary to init_task's end of stack. While the second patch provides a helper to determine the integrity of the canary. The third checks for a stack overrun and takes appropriate action since the damage is already done, there is no point in continuing.
Quoted 3 lines
Clearly you've just been 'bitten' by a kernel stack overflow. But a simple 'canary' isn't going to find most of the overflows and will give an incorrect 'sense of security'.
Please note that this is not suppose to be a 'perfect' solution. Rather a worth while check in this particular code path. Let's assume that the canary is damaged. In this situation it is rather likely that the thread_info object has been compromised too.
Signature · 1 line
Aaron Tomlin