[PATCH 10/10] uprobes/x86: Change arch_uretprobe_is_alive() to take !chained into account

[Oleg Nesterov <oleg@redhat.com>]

The previous change documents that cleanup_return_instances() can't
always detect the dead frames, the stack can grow. But there is one
special case which imho worth fixing: arch_uretprobe_is_alive() can
return true when the stack didn't actually grow, but the next "call"
insn uses the already invalidated frame.

Test-case:

	#include <stdio.h>
	#include <setjmp.h>

	jmp_buf jmp;
	int nr = 1024;

	void func_2(void)
	{
		if (--nr == 0)
			return;
		longjmp(jmp, 1);
	}

	void func_1(void)
	{
		setjmp(jmp);
		func_2();
	}

	int main(void)
	{
		func_1();
		return 0;
	}

If you ret-probe func_1() and func_2() prepare_uretprobe() hits the
MAX_URETPROBE_DEPTH limit and "return" from func_2() is not reported.

Add the new "bool on_call" argument to arch_uretprobe_is_alive().
prepare_uretprobe()->cleanup_return_instances() path passes "true"
when we know that we can do a more strict check to detect the dead
frames: chained == F. In this case "sp" points to the new ret-addr,
so every frame which uses the same "sp" must be dead.

Note: arch_uretprobe_is_alive() could also re-read *sp and check if
this word is still trampoline_vaddr. This could obviously improve the
logic, but I'd like to avoid another copy_from_user() especially in
a case when we can't avoid the false "alive == T" positives.

Signed-off-by: Oleg Nesterov <oleg@redhat.com>
---
 arch/x86/kernel/uprobes.c |   10 ++++++++--
 include/linux/uprobes.h   |    3 ++-
 kernel/events/uprobes.c   |   12 +++++++-----
 3 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/arch/x86/kernel/uprobes.c b/arch/x86/kernel/uprobes.c
index 868dc47..f0ace39 100644
--- a/arch/x86/kernel/uprobes.c
+++ b/arch/x86/kernel/uprobes.c
@@ -929,7 +929,13 @@ arch_uretprobe_hijack_return_addr(struct arch_uretprobe *auret,
 	return -1;
 }
 
-bool arch_uretprobe_is_alive(struct arch_uretprobe *auret, struct pt_regs *regs)
+bool arch_uretprobe_is_alive(struct arch_uretprobe *auret,
+				bool on_call, struct pt_regs *regs)
 {
-	return regs->sp <= auret->sp;
+	unsigned long sp = regs->sp;
+
+	if (on_call) /* ->sp was just decremented by "call" insn */
+		sp += sizeof_long();
+
+	return sp <= auret->sp;
 }
diff --git a/include/linux/uprobes.h b/include/linux/uprobes.h
index 1ed7502..9907be4 100644
--- a/include/linux/uprobes.h
+++ b/include/linux/uprobes.h
@@ -129,7 +129,8 @@ extern int  arch_uprobe_exception_notify(struct notifier_block *self, unsigned l
 extern void arch_uprobe_abort_xol(struct arch_uprobe *aup, struct pt_regs *regs);
 extern unsigned long arch_uretprobe_hijack_return_addr(struct arch_uretprobe *auret,
 					unsigned long trampoline_vaddr, struct pt_regs *regs);
-extern bool arch_uretprobe_is_alive(struct arch_uretprobe *auret, struct pt_regs *regs);
+extern bool arch_uretprobe_is_alive(struct arch_uretprobe *auret,
+					bool on_call, struct pt_regs *regs);
 extern bool arch_uprobe_ignore(struct arch_uprobe *aup, struct pt_regs *regs);
 extern void arch_uprobe_copy_ixol(struct page *page, unsigned long vaddr,
 					 void *src, unsigned long len);
diff --git a/kernel/events/uprobes.c b/kernel/events/uprobes.c
index b6433fb..ec697da 100644
--- a/kernel/events/uprobes.c
+++ b/kernel/events/uprobes.c
@@ -1522,10 +1522,11 @@ static unsigned long get_trampoline_vaddr(void)
 	return trampoline_vaddr;
 }
 
-static void cleanup_return_instances(struct uprobe_task *utask, struct pt_regs *regs)
+static void cleanup_return_instances(struct uprobe_task *utask,
+					bool on_call, struct pt_regs *regs)
 {
 	struct return_instance *ri = utask->return_instances;
-	while (ri && !arch_uretprobe_is_alive(&ri->auret, regs)) {
+	while (ri && !arch_uretprobe_is_alive(&ri->auret, on_call, regs)) {
 		ri = free_ret_instance(ri);
 		utask->depth--;
 	}
@@ -1587,7 +1588,7 @@ static void prepare_uretprobe(struct uprobe *uprobe, struct pt_regs *regs)
 	ri->chained = chained;
 
 	if (utask->depth) /* drop the entries invalidated by longjmp() */
-		cleanup_return_instances(utask, regs);
+		cleanup_return_instances(utask, !chained, regs);
 
 	utask->depth++;
 	ri->next = utask->return_instances;
@@ -1815,7 +1816,7 @@ static void handle_trampoline(struct pt_regs *regs)
 		 * could hit this trampoline on return. TODO: sigaltstack().
 		 */
 		next = find_next_ret_chain(ri);
-		valid = !next || arch_uretprobe_is_alive(&next->auret, regs);
+		valid = !next || arch_uretprobe_is_alive(&next->auret, false, regs);
 
 		instruction_pointer_set(regs, ri->orig_ret_vaddr);
 		do {
@@ -1840,7 +1841,8 @@ bool __weak arch_uprobe_ignore(struct arch_uprobe *aup, struct pt_regs *regs)
 	return false;
 }
 
-bool __weak arch_uretprobe_is_alive(struct arch_uretprobe *auret, struct pt_regs *regs)
+bool __weak arch_uretprobe_is_alive(struct arch_uretprobe *auret,
+					bool on_call, struct pt_regs *regs)
 {
 	return true;
 }
-- 
1.5.5.1