* [PATCH 0/2] A couple of unwinder fixes
@ 2017-05-23 15:37 Josh Poimboeuf
2017-05-23 15:37 ` [PATCH 1/2] Revert "x86/entry: Fix the end of the stack for newly forked tasks" Josh Poimboeuf
` (2 more replies)
0 siblings, 3 replies; 6+ messages in thread
From: Josh Poimboeuf @ 2017-05-23 15:37 UTC (permalink / raw)
To: x86; +Cc: Petr Mladek, Dave Jones, Steven Rostedt, linux-kernel, live-patching
Patch 1 reverts a previous fix because it introduced a new bug.
Patch 2 re-fixes the original bug.
Josh Poimboeuf (2):
Revert "x86/entry: Fix the end of the stack for newly forked tasks"
x86/unwind: Add end-of-stack check for ftrace handlers
arch/x86/entry/entry_32.S | 30 ++++++++++++++++----------
arch/x86/entry/entry_64.S | 11 ++++------
arch/x86/kernel/unwind_frame.c | 49 ++++++++++++++++++++++++++++++++++--------
3 files changed, 63 insertions(+), 27 deletions(-)
--
2.7.4
^ permalink raw reply [flat|nested] 6+ messages in thread* [PATCH 1/2] Revert "x86/entry: Fix the end of the stack for newly forked tasks" 2017-05-23 15:37 [PATCH 0/2] A couple of unwinder fixes Josh Poimboeuf @ 2017-05-23 15:37 ` Josh Poimboeuf 2017-05-24 10:16 ` [tip:x86/urgent] " tip-bot for Josh Poimboeuf 2017-05-23 15:37 ` [PATCH 2/2] x86/unwind: Add end-of-stack check for ftrace handlers Josh Poimboeuf 2017-05-24 11:47 ` [PATCH 0/2] A couple of unwinder fixes Petr Mladek 2 siblings, 1 reply; 6+ messages in thread From: Josh Poimboeuf @ 2017-05-23 15:37 UTC (permalink / raw) To: x86; +Cc: Petr Mladek, Dave Jones, Steven Rostedt, linux-kernel, live-patching Petr Mladek reported the following warning when loading the livepatch sample module: WARNING: CPU: 1 PID: 3699 at arch/x86/kernel/stacktrace.c:132 save_stack_trace_tsk_reliable+0x133/0x1a0 ... Call Trace: __schedule+0x273/0x820 schedule+0x36/0x80 kthreadd+0x305/0x310 ? kthread_create_on_cpu+0x80/0x80 ? icmp_echo.part.32+0x50/0x50 ret_from_fork+0x2c/0x40 That warning means the end of the stack is no longer recognized as such for newly forked tasks. The problem was introduced with the following commit: ff3f7e2475bb ("x86/entry: Fix the end of the stack for newly forked tasks") ... which was completely misguided. It only partially fixed the reported issue, and it introduced another bug in the process. None of the other entry code saves the frame pointer before calling into C code, so it doesn't make sense for ret_from_fork to do so either. Contrary to what I originally thought, the original issue wasn't related to newly forked tasks. It was actually related to ftrace. When entry code calls into a function which then calls into an ftrace handler, the stack frame looks different than normal. The original issue will be fixed in the unwinder, in a subsequent patch. Reported-by: Petr Mladek <pmladek@suse.com> Fixes: ff3f7e2475bb ("x86/entry: Fix the end of the stack for newly forked tasks") Signed-off-by: Josh Poimboeuf <jpoimboe@redhat.com> --- arch/x86/entry/entry_32.S | 30 +++++++++++++++++++----------- arch/x86/entry/entry_64.S | 11 ++++------- 2 files changed, 23 insertions(+), 18 deletions(-) diff --git a/arch/x86/entry/entry_32.S b/arch/x86/entry/entry_32.S index 50bc269..48ef7bb 100644 --- a/arch/x86/entry/entry_32.S +++ b/arch/x86/entry/entry_32.S @@ -252,6 +252,23 @@ ENTRY(__switch_to_asm) END(__switch_to_asm) /* + * The unwinder expects the last frame on the stack to always be at the same + * offset from the end of the page, which allows it to validate the stack. + * Calling schedule_tail() directly would break that convention because its an + * asmlinkage function so its argument has to be pushed on the stack. This + * wrapper creates a proper "end of stack" frame header before the call. + */ +ENTRY(schedule_tail_wrapper) + FRAME_BEGIN + + pushl %eax + call schedule_tail + popl %eax + + FRAME_END + ret +ENDPROC(schedule_tail_wrapper) +/* * A newly forked process directly context switches into this address. * * eax: prev task we switched from @@ -259,24 +276,15 @@ END(__switch_to_asm) * edi: kernel thread arg */ ENTRY(ret_from_fork) - FRAME_BEGIN /* help unwinder find end of stack */ - - /* - * schedule_tail() is asmlinkage so we have to put its 'prev' argument - * on the stack. - */ - pushl %eax - call schedule_tail - popl %eax + call schedule_tail_wrapper testl %ebx, %ebx jnz 1f /* kernel threads are uncommon */ 2: /* When we fork, we trace the syscall return in the child, too. */ - leal FRAME_OFFSET(%esp), %eax + movl %esp, %eax call syscall_return_slowpath - FRAME_END jmp restore_all /* kernel thread */ diff --git a/arch/x86/entry/entry_64.S b/arch/x86/entry/entry_64.S index 607d72c..4a4c083 100644 --- a/arch/x86/entry/entry_64.S +++ b/arch/x86/entry/entry_64.S @@ -36,7 +36,6 @@ #include <asm/smap.h> #include <asm/pgtable_types.h> #include <asm/export.h> -#include <asm/frame.h> #include <linux/err.h> .code64 @@ -406,19 +405,17 @@ END(__switch_to_asm) * r12: kernel thread arg */ ENTRY(ret_from_fork) - FRAME_BEGIN /* help unwinder find end of stack */ movq %rax, %rdi - call schedule_tail /* rdi: 'prev' task parameter */ + call schedule_tail /* rdi: 'prev' task parameter */ - testq %rbx, %rbx /* from kernel_thread? */ - jnz 1f /* kernel threads are uncommon */ + testq %rbx, %rbx /* from kernel_thread? */ + jnz 1f /* kernel threads are uncommon */ 2: - leaq FRAME_OFFSET(%rsp),%rdi /* pt_regs pointer */ + movq %rsp, %rdi call syscall_return_slowpath /* returns with IRQs disabled */ TRACE_IRQS_ON /* user mode is traced as IRQS on */ SWAPGS - FRAME_END jmp restore_regs_and_iret 1: -- 2.7.4 ^ permalink raw reply [flat|nested] 6+ messages in thread
* [tip:x86/urgent] Revert "x86/entry: Fix the end of the stack for newly forked tasks" 2017-05-23 15:37 ` [PATCH 1/2] Revert "x86/entry: Fix the end of the stack for newly forked tasks" Josh Poimboeuf @ 2017-05-24 10:16 ` tip-bot for Josh Poimboeuf 0 siblings, 0 replies; 6+ messages in thread From: tip-bot for Josh Poimboeuf @ 2017-05-24 10:16 UTC (permalink / raw) To: linux-tip-commits Cc: davej, hpa, peterz, tglx, linux-kernel, pmladek, jpoimboe, rostedt, torvalds, mingo Commit-ID: ebd574994c63164d538a197172157318f58ac647 Gitweb: http://git.kernel.org/tip/ebd574994c63164d538a197172157318f58ac647 Author: Josh Poimboeuf <jpoimboe@redhat.com> AuthorDate: Tue, 23 May 2017 10:37:29 -0500 Committer: Ingo Molnar <mingo@kernel.org> CommitDate: Wed, 24 May 2017 09:05:16 +0200 Revert "x86/entry: Fix the end of the stack for newly forked tasks" Petr Mladek reported the following warning when loading the livepatch sample module: WARNING: CPU: 1 PID: 3699 at arch/x86/kernel/stacktrace.c:132 save_stack_trace_tsk_reliable+0x133/0x1a0 ... Call Trace: __schedule+0x273/0x820 schedule+0x36/0x80 kthreadd+0x305/0x310 ? kthread_create_on_cpu+0x80/0x80 ? icmp_echo.part.32+0x50/0x50 ret_from_fork+0x2c/0x40 That warning means the end of the stack is no longer recognized as such for newly forked tasks. The problem was introduced with the following commit: ff3f7e2475bb ("x86/entry: Fix the end of the stack for newly forked tasks") ... which was completely misguided. It only partially fixed the reported issue, and it introduced another bug in the process. None of the other entry code saves the frame pointer before calling into C code, so it doesn't make sense for ret_from_fork to do so either. Contrary to what I originally thought, the original issue wasn't related to newly forked tasks. It was actually related to ftrace. When entry code calls into a function which then calls into an ftrace handler, the stack frame looks different than normal. The original issue will be fixed in the unwinder, in a subsequent patch. Reported-by: Petr Mladek <pmladek@suse.com> Signed-off-by: Josh Poimboeuf <jpoimboe@redhat.com> Acked-by: Thomas Gleixner <tglx@linutronix.de> Cc: Dave Jones <davej@codemonkey.org.uk> Cc: Linus Torvalds <torvalds@linux-foundation.org> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Steven Rostedt <rostedt@goodmis.org> Cc: live-patching@vger.kernel.org Fixes: ff3f7e2475bb ("x86/entry: Fix the end of the stack for newly forked tasks") Link: http://lkml.kernel.org/r/f350760f7e82f0750c8d1dd093456eb212751caa.1495553739.git.jpoimboe@redhat.com Signed-off-by: Ingo Molnar <mingo@kernel.org> --- arch/x86/entry/entry_32.S | 30 +++++++++++++++++++----------- arch/x86/entry/entry_64.S | 11 ++++------- 2 files changed, 23 insertions(+), 18 deletions(-) diff --git a/arch/x86/entry/entry_32.S b/arch/x86/entry/entry_32.S index 50bc269..48ef7bb 100644 --- a/arch/x86/entry/entry_32.S +++ b/arch/x86/entry/entry_32.S @@ -252,6 +252,23 @@ ENTRY(__switch_to_asm) END(__switch_to_asm) /* + * The unwinder expects the last frame on the stack to always be at the same + * offset from the end of the page, which allows it to validate the stack. + * Calling schedule_tail() directly would break that convention because its an + * asmlinkage function so its argument has to be pushed on the stack. This + * wrapper creates a proper "end of stack" frame header before the call. + */ +ENTRY(schedule_tail_wrapper) + FRAME_BEGIN + + pushl %eax + call schedule_tail + popl %eax + + FRAME_END + ret +ENDPROC(schedule_tail_wrapper) +/* * A newly forked process directly context switches into this address. * * eax: prev task we switched from @@ -259,24 +276,15 @@ END(__switch_to_asm) * edi: kernel thread arg */ ENTRY(ret_from_fork) - FRAME_BEGIN /* help unwinder find end of stack */ - - /* - * schedule_tail() is asmlinkage so we have to put its 'prev' argument - * on the stack. - */ - pushl %eax - call schedule_tail - popl %eax + call schedule_tail_wrapper testl %ebx, %ebx jnz 1f /* kernel threads are uncommon */ 2: /* When we fork, we trace the syscall return in the child, too. */ - leal FRAME_OFFSET(%esp), %eax + movl %esp, %eax call syscall_return_slowpath - FRAME_END jmp restore_all /* kernel thread */ diff --git a/arch/x86/entry/entry_64.S b/arch/x86/entry/entry_64.S index 607d72c..4a4c083 100644 --- a/arch/x86/entry/entry_64.S +++ b/arch/x86/entry/entry_64.S @@ -36,7 +36,6 @@ #include <asm/smap.h> #include <asm/pgtable_types.h> #include <asm/export.h> -#include <asm/frame.h> #include <linux/err.h> .code64 @@ -406,19 +405,17 @@ END(__switch_to_asm) * r12: kernel thread arg */ ENTRY(ret_from_fork) - FRAME_BEGIN /* help unwinder find end of stack */ movq %rax, %rdi - call schedule_tail /* rdi: 'prev' task parameter */ + call schedule_tail /* rdi: 'prev' task parameter */ - testq %rbx, %rbx /* from kernel_thread? */ - jnz 1f /* kernel threads are uncommon */ + testq %rbx, %rbx /* from kernel_thread? */ + jnz 1f /* kernel threads are uncommon */ 2: - leaq FRAME_OFFSET(%rsp),%rdi /* pt_regs pointer */ + movq %rsp, %rdi call syscall_return_slowpath /* returns with IRQs disabled */ TRACE_IRQS_ON /* user mode is traced as IRQS on */ SWAPGS - FRAME_END jmp restore_regs_and_iret 1: ^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH 2/2] x86/unwind: Add end-of-stack check for ftrace handlers 2017-05-23 15:37 [PATCH 0/2] A couple of unwinder fixes Josh Poimboeuf 2017-05-23 15:37 ` [PATCH 1/2] Revert "x86/entry: Fix the end of the stack for newly forked tasks" Josh Poimboeuf @ 2017-05-23 15:37 ` Josh Poimboeuf 2017-05-24 10:17 ` [tip:x86/urgent] " tip-bot for Josh Poimboeuf 2017-05-24 11:47 ` [PATCH 0/2] A couple of unwinder fixes Petr Mladek 2 siblings, 1 reply; 6+ messages in thread From: Josh Poimboeuf @ 2017-05-23 15:37 UTC (permalink / raw) To: x86; +Cc: Petr Mladek, Dave Jones, Steven Rostedt, linux-kernel, live-patching Dave Jones and Steven Rostedt reported unwinder warnings like the following: WARNING: kernel stack frame pointer at ffff8800bda0ff30 in sshd:1090 has bad value 000055b32abf1fa8 In both cases, the unwinder was attempting to unwind from an ftrace handler into entry code. The callchain was something like: syscall entry code C function ftrace handler save_stack_trace() The problem is that the unwinder's end-of-stack logic gets confused by the way ftrace lays out the stack frame (with fentry enabled). I was able to recreate this warning with: echo call_usermodehelper_exec_async:stacktrace > /sys/kernel/debug/tracing/set_ftrace_filter (exit login session) I considered fixing this by changing the ftrace code to rewrite the stack to make the unwinder happy. But that seemed too intrusive after I implemented it. Instead, just add another check to the unwinder's end-of-stack logic to detect this special case. Side note: We could probably get rid of these end-of-stack checks by encoding the frame pointer for syscall entry just like we do for interrupt entry. That would be simpler, but it would also be a lot more intrusive since it would slightly affect the performance of every syscall. Reported-by: Dave Jones <davej@codemonkey.org.uk> Reported-by: Steven Rostedt <rostedt@goodmis.org> Fixes: c32c47c68a0a ("x86/unwind: Warn on bad frame pointer") Signed-off-by: Josh Poimboeuf <jpoimboe@redhat.com> --- arch/x86/kernel/unwind_frame.c | 49 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 40 insertions(+), 9 deletions(-) diff --git a/arch/x86/kernel/unwind_frame.c b/arch/x86/kernel/unwind_frame.c index 82c6d7f..b9389d7 100644 --- a/arch/x86/kernel/unwind_frame.c +++ b/arch/x86/kernel/unwind_frame.c @@ -104,6 +104,11 @@ static inline unsigned long *last_frame(struct unwind_state *state) return (unsigned long *)task_pt_regs(state->task) - 2; } +static bool is_last_frame(struct unwind_state *state) +{ + return state->bp == last_frame(state); +} + #ifdef CONFIG_X86_32 #define GCC_REALIGN_WORDS 3 #else @@ -115,16 +120,15 @@ static inline unsigned long *last_aligned_frame(struct unwind_state *state) return last_frame(state) - GCC_REALIGN_WORDS; } -static bool is_last_task_frame(struct unwind_state *state) +static bool is_last_aligned_frame(struct unwind_state *state) { unsigned long *last_bp = last_frame(state); unsigned long *aligned_bp = last_aligned_frame(state); /* - * We have to check for the last task frame at two different locations - * because gcc can occasionally decide to realign the stack pointer and - * change the offset of the stack frame in the prologue of a function - * called by head/entry code. Examples: + * GCC can occasionally decide to realign the stack pointer and change + * the offset of the stack frame in the prologue of a function called + * by head/entry code. Examples: * * <start_secondary>: * push %edi @@ -141,11 +145,38 @@ static bool is_last_task_frame(struct unwind_state *state) * push %rbp * mov %rsp,%rbp * - * Note that after aligning the stack, it pushes a duplicate copy of - * the return address before pushing the frame pointer. + * After aligning the stack, it pushes a duplicate copy of the return + * address before pushing the frame pointer. + */ + return (state->bp == aligned_bp && *(aligned_bp + 1) == *(last_bp + 1)); +} + +static bool is_last_ftrace_frame(struct unwind_state *state) +{ + unsigned long *last_bp = last_frame(state); + unsigned long *last_ftrace_bp = last_bp - 3; + + /* + * When unwinding from an ftrace handler of a function called by entry + * code, the stack layout of the last frame is: + * + * bp + * parent ret addr + * bp + * function ret addr + * parent ret addr + * pt_regs + * ----------------- */ - return (state->bp == last_bp || - (state->bp == aligned_bp && *(aligned_bp+1) == *(last_bp+1))); + return (state->bp == last_ftrace_bp && + *state->bp == *(state->bp + 2) && + *(state->bp + 1) == *(state->bp + 4)); +} + +static bool is_last_task_frame(struct unwind_state *state) +{ + return is_last_frame(state) || is_last_aligned_frame(state) || + is_last_ftrace_frame(state); } /* -- 2.7.4 ^ permalink raw reply [flat|nested] 6+ messages in thread
* [tip:x86/urgent] x86/unwind: Add end-of-stack check for ftrace handlers 2017-05-23 15:37 ` [PATCH 2/2] x86/unwind: Add end-of-stack check for ftrace handlers Josh Poimboeuf @ 2017-05-24 10:17 ` tip-bot for Josh Poimboeuf 0 siblings, 0 replies; 6+ messages in thread From: tip-bot for Josh Poimboeuf @ 2017-05-24 10:17 UTC (permalink / raw) To: linux-tip-commits Cc: mingo, pmladek, linux-kernel, jpoimboe, peterz, davej, torvalds, rostedt, tglx, hpa Commit-ID: 519fb5c3350d1b5225b27b1cac55144f79351718 Gitweb: http://git.kernel.org/tip/519fb5c3350d1b5225b27b1cac55144f79351718 Author: Josh Poimboeuf <jpoimboe@redhat.com> AuthorDate: Tue, 23 May 2017 10:37:30 -0500 Committer: Ingo Molnar <mingo@kernel.org> CommitDate: Wed, 24 May 2017 09:05:16 +0200 x86/unwind: Add end-of-stack check for ftrace handlers Dave Jones and Steven Rostedt reported unwinder warnings like the following: WARNING: kernel stack frame pointer at ffff8800bda0ff30 in sshd:1090 has bad value 000055b32abf1fa8 In both cases, the unwinder was attempting to unwind from an ftrace handler into entry code. The callchain was something like: syscall entry code C function ftrace handler save_stack_trace() The problem is that the unwinder's end-of-stack logic gets confused by the way ftrace lays out the stack frame (with fentry enabled). I was able to recreate this warning with: echo call_usermodehelper_exec_async:stacktrace > /sys/kernel/debug/tracing/set_ftrace_filter (exit login session) I considered fixing this by changing the ftrace code to rewrite the stack to make the unwinder happy. But that seemed too intrusive after I implemented it. Instead, just add another check to the unwinder's end-of-stack logic to detect this special case. Side note: We could probably get rid of these end-of-stack checks by encoding the frame pointer for syscall entry just like we do for interrupt entry. That would be simpler, but it would also be a lot more intrusive since it would slightly affect the performance of every syscall. Reported-by: Dave Jones <davej@codemonkey.org.uk> Reported-by: Steven Rostedt <rostedt@goodmis.org> Signed-off-by: Josh Poimboeuf <jpoimboe@redhat.com> Acked-by: Thomas Gleixner <tglx@linutronix.de> Cc: Linus Torvalds <torvalds@linux-foundation.org> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Petr Mladek <pmladek@suse.com> Cc: live-patching@vger.kernel.org Fixes: c32c47c68a0a ("x86/unwind: Warn on bad frame pointer") Link: http://lkml.kernel.org/r/671ba22fbc0156b8f7e0cfa5ab2a795e08bc37e1.1495553739.git.jpoimboe@redhat.com Signed-off-by: Ingo Molnar <mingo@kernel.org> --- arch/x86/kernel/unwind_frame.c | 49 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 40 insertions(+), 9 deletions(-) diff --git a/arch/x86/kernel/unwind_frame.c b/arch/x86/kernel/unwind_frame.c index 82c6d7f..b9389d7 100644 --- a/arch/x86/kernel/unwind_frame.c +++ b/arch/x86/kernel/unwind_frame.c @@ -104,6 +104,11 @@ static inline unsigned long *last_frame(struct unwind_state *state) return (unsigned long *)task_pt_regs(state->task) - 2; } +static bool is_last_frame(struct unwind_state *state) +{ + return state->bp == last_frame(state); +} + #ifdef CONFIG_X86_32 #define GCC_REALIGN_WORDS 3 #else @@ -115,16 +120,15 @@ static inline unsigned long *last_aligned_frame(struct unwind_state *state) return last_frame(state) - GCC_REALIGN_WORDS; } -static bool is_last_task_frame(struct unwind_state *state) +static bool is_last_aligned_frame(struct unwind_state *state) { unsigned long *last_bp = last_frame(state); unsigned long *aligned_bp = last_aligned_frame(state); /* - * We have to check for the last task frame at two different locations - * because gcc can occasionally decide to realign the stack pointer and - * change the offset of the stack frame in the prologue of a function - * called by head/entry code. Examples: + * GCC can occasionally decide to realign the stack pointer and change + * the offset of the stack frame in the prologue of a function called + * by head/entry code. Examples: * * <start_secondary>: * push %edi @@ -141,11 +145,38 @@ static bool is_last_task_frame(struct unwind_state *state) * push %rbp * mov %rsp,%rbp * - * Note that after aligning the stack, it pushes a duplicate copy of - * the return address before pushing the frame pointer. + * After aligning the stack, it pushes a duplicate copy of the return + * address before pushing the frame pointer. + */ + return (state->bp == aligned_bp && *(aligned_bp + 1) == *(last_bp + 1)); +} + +static bool is_last_ftrace_frame(struct unwind_state *state) +{ + unsigned long *last_bp = last_frame(state); + unsigned long *last_ftrace_bp = last_bp - 3; + + /* + * When unwinding from an ftrace handler of a function called by entry + * code, the stack layout of the last frame is: + * + * bp + * parent ret addr + * bp + * function ret addr + * parent ret addr + * pt_regs + * ----------------- */ - return (state->bp == last_bp || - (state->bp == aligned_bp && *(aligned_bp+1) == *(last_bp+1))); + return (state->bp == last_ftrace_bp && + *state->bp == *(state->bp + 2) && + *(state->bp + 1) == *(state->bp + 4)); +} + +static bool is_last_task_frame(struct unwind_state *state) +{ + return is_last_frame(state) || is_last_aligned_frame(state) || + is_last_ftrace_frame(state); } /* ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 0/2] A couple of unwinder fixes 2017-05-23 15:37 [PATCH 0/2] A couple of unwinder fixes Josh Poimboeuf 2017-05-23 15:37 ` [PATCH 1/2] Revert "x86/entry: Fix the end of the stack for newly forked tasks" Josh Poimboeuf 2017-05-23 15:37 ` [PATCH 2/2] x86/unwind: Add end-of-stack check for ftrace handlers Josh Poimboeuf @ 2017-05-24 11:47 ` Petr Mladek 2 siblings, 0 replies; 6+ messages in thread From: Petr Mladek @ 2017-05-24 11:47 UTC (permalink / raw) To: Josh Poimboeuf Cc: x86, Dave Jones, Steven Rostedt, linux-kernel, live-patching On Tue 2017-05-23 10:37:28, Josh Poimboeuf wrote: > Patch 1 reverts a previous fix because it introduced a new bug. > > Patch 2 re-fixes the original bug. I could confirm that the new bug has gone after applying both patches. Also I think that I have reproduced the original bug and it seems to have gone as well. Therefore feel free to use for both patches: Tested-by: Petr Mladek <pmladek@suse.com> Best Regards, Petr > Josh Poimboeuf (2): > Revert "x86/entry: Fix the end of the stack for newly forked tasks" > x86/unwind: Add end-of-stack check for ftrace handlers > > arch/x86/entry/entry_32.S | 30 ++++++++++++++++---------- > arch/x86/entry/entry_64.S | 11 ++++------ > arch/x86/kernel/unwind_frame.c | 49 ++++++++++++++++++++++++++++++++++-------- > 3 files changed, 63 insertions(+), 27 deletions(-) > > -- > 2.7.4 > ^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2017-05-24 11:48 UTC | newest] Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2017-05-23 15:37 [PATCH 0/2] A couple of unwinder fixes Josh Poimboeuf 2017-05-23 15:37 ` [PATCH 1/2] Revert "x86/entry: Fix the end of the stack for newly forked tasks" Josh Poimboeuf 2017-05-24 10:16 ` [tip:x86/urgent] " tip-bot for Josh Poimboeuf 2017-05-23 15:37 ` [PATCH 2/2] x86/unwind: Add end-of-stack check for ftrace handlers Josh Poimboeuf 2017-05-24 10:17 ` [tip:x86/urgent] " tip-bot for Josh Poimboeuf 2017-05-24 11:47 ` [PATCH 0/2] A couple of unwinder fixes Petr Mladek
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox
Powered by JetHome