Skip to contentSkip to conversation

ftrace: Have callbacks handle their own recursion

PATCH Superseded Steven Rostedt 5 participants 24 messages Oct 28, 2020 – Nov 2, 2020

Subsystems (10)
Documentation x86 PowerPC Tracing +6 more subsystems

v1 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
author maintainer
#8 lore raw

PATCH 5/9 kprobes/ftrace: Add recursion protection to the ftrace callback

In reply to Steven Rostedt

From: "Steven Rostedt (VMware)" <[email protected]>

If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.

The default for ftrace_ops is going to assume recursion protection unless otherwise specified.

Cc Masami Hiramatsu <[email protected]>
Cc Guo Ren <[email protected]>
Cc "James E.J. Bottomley" <[email protected]>
Cc Helge Deller <[email protected]>
Cc Michael Ellerman <[email protected]>
Cc Benjamin Herrenschmidt <[email protected]>
Cc Paul Mackerras <[email protected]>
Cc Heiko Carstens <[email protected]>
Cc Vasily Gorbik <[email protected]>
Cc Christian Borntraeger <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc "H. Peter Anvin" <[email protected]>
Cc "Naveen N. Rao" <[email protected]>
Cc Anil S Keshavamurthy <[email protected]>
Cc "David S. Miller" <[email protected]>
---
 arch/csky/kernel/probes/ftrace.c     | 12 ++++++++++--
 arch/parisc/kernel/ftrace.c          | 13 +++++++++++--
 arch/powerpc/kernel/kprobes-ftrace.c | 11 ++++++++++-
 arch/s390/kernel/ftrace.c            | 13 +++++++++++--
 arch/x86/kernel/kprobes/ftrace.c     | 12 ++++++++++--
 5 files changed, 52 insertions(+), 9 deletions(-)
arch/csky/kernel/probes/ftrace.c +10 -2
index 5264763d05be..5eb2604fdf71 100644
@@ -13,16 +13,21 @@ int arch_check_ftrace_location(struct kprobe *p)
 void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 			   struct ftrace_ops *ops, struct pt_regs *regs)
 {
+	int bit;
 	bool lr_saver = false;
 	struct kprobe *p;
 	struct kprobe_ctlblk *kcb;
 
-	/* Preempt is disabled by ftrace */
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;
+
+	preempt_disable_notrace();
 	p = get_kprobe((kprobe_opcode_t *)ip);
 	if (!p) {
 		p = get_kprobe((kprobe_opcode_t *)(ip - MCOUNT_INSN_SIZE));
 		if (unlikely(!p) || kprobe_disabled(p))
-			return;
+			goto out;
 		lr_saver = true;
 	}
 
@@ -56,6 +61,9 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 		 */
 		__this_cpu_write(current_kprobe, NULL);
 	}
+out:
+	preempt_enable_notrace();
+	ftrace_test_recursion_unlock(bit);
 }
 NOKPROBE_SYMBOL(kprobe_ftrace_handler);
 
arch/parisc/kernel/ftrace.c +11 -2
index 4bab21c71055..5f7742b225a5 100644
@@ -208,13 +208,19 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 {
 	struct kprobe_ctlblk *kcb;
 	struct kprobe *p = get_kprobe((kprobe_opcode_t *)ip);
+	int bit;
 
-	if (unlikely(!p) || kprobe_disabled(p))
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
 		return;
 
+	preempt_disable_notrace();
+	if (unlikely(!p) || kprobe_disabled(p))
+		goto out;
+
 	if (kprobe_running()) {
 		kprobes_inc_nmissed_count(p);
-		return;
+		goto out;
 	}
 
 	__this_cpu_write(current_kprobe, p);
@@ -235,6 +241,9 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 		}
 	}
 	__this_cpu_write(current_kprobe, NULL);
+out:
+	preempt_enable_notrace();
+	ftrace_test_recursion_unlock(bit);
 }
 NOKPROBE_SYMBOL(kprobe_ftrace_handler);
 
arch/powerpc/kernel/kprobes-ftrace.c +10 -1
index 972cb28174b2..5df8d50c65ae 100644
@@ -18,10 +18,16 @@ void kprobe_ftrace_handler(unsigned long nip, unsigned long parent_nip,
 {
 	struct kprobe *p;
 	struct kprobe_ctlblk *kcb;
+	int bit;
 
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;
+
+	preempt_disable_notrace();
 	p = get_kprobe((kprobe_opcode_t *)nip);
 	if (unlikely(!p) || kprobe_disabled(p))
-		return;
+		goto out;
 
 	kcb = get_kprobe_ctlblk();
 	if (kprobe_running()) {
@@ -52,6 +58,9 @@ void kprobe_ftrace_handler(unsigned long nip, unsigned long parent_nip,
 		 */
 		__this_cpu_write(current_kprobe, NULL);
 	}
+out:
+	preempt_enable_notrace();
+	ftrace_test_recursion_unlock(bit);
 }
 NOKPROBE_SYMBOL(kprobe_ftrace_handler);
 
arch/s390/kernel/ftrace.c +11 -2
index b388e87a08bf..88466d7fb6b2 100644
@@ -202,13 +202,19 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 {
 	struct kprobe_ctlblk *kcb;
 	struct kprobe *p = get_kprobe((kprobe_opcode_t *)ip);
+	int bit;
 
-	if (unlikely(!p) || kprobe_disabled(p))
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
 		return;
 
+	preempt_disable_notrace();
+	if (unlikely(!p) || kprobe_disabled(p))
+		goto out;
+
 	if (kprobe_running()) {
 		kprobes_inc_nmissed_count(p);
-		return;
+		goto out;
 	}
 
 	__this_cpu_write(current_kprobe, p);
@@ -228,6 +234,9 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 		}
 	}
 	__this_cpu_write(current_kprobe, NULL);
+out:
+	preempt_enable_notrace();
+	ftrace_test_recursion_unlock(bit);
 }
 NOKPROBE_SYMBOL(kprobe_ftrace_handler);
 
arch/x86/kernel/kprobes/ftrace.c +10 -2
index 681a4b36e9bb..a40a6cdfcca3 100644
@@ -18,11 +18,16 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 {
 	struct kprobe *p;
 	struct kprobe_ctlblk *kcb;
+	int bit;
 
-	/* Preempt is disabled by ftrace */
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;
+
+	preempt_disable_notrace();
 	p = get_kprobe((kprobe_opcode_t *)ip);
 	if (unlikely(!p) || kprobe_disabled(p))
-		return;
+		goto out;
 
 	kcb = get_kprobe_ctlblk();
 	if (kprobe_running()) {
@@ -52,6 +57,9 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 		 */
 		__this_cpu_write(current_kprobe, NULL);
 	}
+out:
+	preempt_enable_notrace();
+	ftrace_test_recursion_unlock(bit);
 }
 NOKPROBE_SYMBOL(kprobe_ftrace_handler);
 
Signature · 1 line
2.28.0
author maintainer
#22 lore raw

PATCH 8/9 perf/ftrace: Check for rcu_is_watching() in callback function

In reply to Steven Rostedt

From: "Steven Rostedt (VMware)" <[email protected]>

If a ftrace callback requires "rcu_is_watching", then it adds the FTRACE_OPS_FL_RCU flag and it will not be called if RCU is not "watching". But this means that it will use a trampoline when called, and this slows down the function tracing a tad. By checking rcu_is_watching() from within the callback, it no longer needs the RCU flag set in the ftrace_ops and it can be safely called directly.

---
 kernel/trace/trace_event_perf.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)
kernel/trace/trace_event_perf.c +3 -1
index fd58d83861d8..a2b9fddb8148 100644
@@ -441,6 +441,9 @@ perf_ftrace_function_call(unsigned long ip, unsigned long parent_ip,
 	int rctx;
 	int bit;
 
+	if (!rcu_is_watching())
+		return;
+
 	if ((unsigned long)ops->private != smp_processor_id())
 		return;
 
@@ -484,7 +487,6 @@ static int perf_ftrace_function_register(struct perf_event *event)
 {
 	struct ftrace_ops *ops = &event->ftrace_ops;
 
-	ops->flags   = FTRACE_OPS_FL_RCU;
 	ops->func    = perf_ftrace_function_call;
 	ops->private = (void *)(unsigned long)nr_cpu_ids;
 
Signature · 1 line
2.28.0
author maintainer
#21 lore raw

PATCH 7/9 perf/ftrace: Add recursion protection to the ftrace callback

In reply to Steven Rostedt

From: "Steven Rostedt (VMware)" <[email protected]>

If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.

The default for ftrace_ops is going to assume recursion protection unless otherwise specified.

---
 kernel/trace/trace_event_perf.c | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)
kernel/trace/trace_event_perf.c +8 -1
index 643e0b19920d..fd58d83861d8 100644
@@ -439,10 +439,15 @@ perf_ftrace_function_call(unsigned long ip, unsigned long parent_ip,
 	struct hlist_head head;
 	struct pt_regs regs;
 	int rctx;
+	int bit;
 
 	if ((unsigned long)ops->private != smp_processor_id())
 		return;
 
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;
+
 	event = container_of(ops, struct perf_event, ftrace_ops);
 
 	/*
@@ -463,13 +468,15 @@ perf_ftrace_function_call(unsigned long ip, unsigned long parent_ip,
 
 	entry = perf_trace_buf_alloc(ENTRY_SIZE, NULL, &rctx);
 	if (!entry)
-		return;
+		goto out;
 
 	entry->ip = ip;
 	entry->parent_ip = parent_ip;
 	perf_trace_buf_submit(entry, ENTRY_SIZE, rctx, TRACE_FN,
 			      1, &regs, &head, NULL);
 
+out:
+	ftrace_test_recursion_unlock(bit);
 #undef ENTRY_SIZE
 }
 
Signature · 1 line
2.28.0
author maintainer
#1 lore raw

PATCH 1/9 ftrace: Move the recursion testing into global headers

In reply to Steven Rostedt

From: "Steven Rostedt (VMware)" <[email protected]>

Currently, if a callback is registered to a ftrace function and its ftrace_ops does not have the RECURSION flag set, it is encapsulated in a helper function that does the recursion for it.

Really, all the callbacks should have their own recursion protection for performance reasons. But they should not all implement their own. Move the recursion helpers to global headers, so that all callbacks can use them.

---
 include/linux/ftrace.h          |   1 +
 include/linux/trace_recursion.h | 167 ++++++++++++++++++++++++++++++++
 kernel/trace/trace.h            | 156 -----------------------------
 3 files changed, 168 insertions(+), 156 deletions(-)
 create mode 100644 include/linux/trace_recursion.h
include/linux/ftrace.h +1 -0
index 1bd3a0356ae4..0e4164a7f56d 100644
@@ -7,6 +7,7 @@
 #ifndef _LINUX_FTRACE_H
 #define _LINUX_FTRACE_H
 
+#include <linux/trace_recursion.h>
 #include <linux/trace_clock.h>
 #include <linux/kallsyms.h>
 #include <linux/linkage.h>
include/linux/trace_recursion.h new file +167 -0

167 lines not on this page · raw message

kernel/trace/trace.h +0 -156

162 lines not on this page · raw message

Signature · 1 line
2.28.0
Reviewed-by on v1 4/9
#7 lore raw

Re: [PATCH 4/9] pstore/ftrace: Add recursion protection to the ftrace callback

In reply to Steven Rostedt
Quoted 7 lines · Steven Rostedt

From: "Steven Rostedt (VMware)" <[email protected]>

If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.

Quoted 6 lines

The default for ftrace_ops is going to assume recursion protection unless otherwise specified.

Signature · 1 line
Kees Cook

Steven Rostedt

author maintainer
#0 lore raw

cover ftrace: Have callbacks handle their own recursion

I found that having the ftrace infrastructure use its own trampoline to handle recursion and RCU by defaulte unless the ftrace_ops set the appropriate flags, was an issue that nobody set those flags. But then their callbacks would suffer from an unnecessary overhead instead of simply handling the recursion itself.

This series makes it mandatory that ftrace callbacks handle recursion or set a flag asking ftrace to do it for it. It also creates helper functions to help these callbacks to have recursion protection.

Steven Rostedt (VMware) (9):
ftrace: Move the recursion testing into global headers
ftrace: Add ftrace_test_recursion_trylock() helper function
ftrace: Optimize testing what context current is in pstore/ftrace: Add recursion protection to the ftrace callback kprobes/ftrace: Add recursion protection to the ftrace callback livepatch/ftrace: Add recursion protection to the ftrace callback perf/ftrace: Add recursion protection to the ftrace callback perf/ftrace: Check for rcu_is_watching() in callback function
ftrace: Reverse what the RECURSION flag means in the ftrace_ops

----

 Documentation/trace/ftrace-uses.rst  |  82 +++++++++++----
 arch/csky/kernel/probes/ftrace.c     |  12 ++-
 arch/parisc/kernel/ftrace.c          |  13 ++-
 arch/powerpc/kernel/kprobes-ftrace.c |  11 +-
 arch/s390/kernel/ftrace.c            |  13 ++-
 arch/x86/kernel/kprobes/ftrace.c     |  12 ++-
 fs/pstore/ftrace.c                   |   6 ++
 include/linux/ftrace.h               |  13 +--
 include/linux/trace_recursion.h      | 199 +++++++++++++++++++++++++++++++++++
 kernel/livepatch/patch.c             |   5 +
 kernel/trace/fgraph.c                |   3 +-
 kernel/trace/ftrace.c                |  20 ++--
 kernel/trace/trace.h                 | 156 ---------------------------
 kernel/trace/trace_event_perf.c      |  13 ++-
 kernel/trace/trace_events.c          |   1 -
 kernel/trace/trace_functions.c       |  14 ++-
 kernel/trace/trace_selftest.c        |   7 +-
 kernel/trace/trace_stack.c           |   1 -
 18 files changed, 358 insertions(+), 223 deletions(-)
 create mode 100644 include/linux/trace_recursion.h
author maintainer
#5 lore raw

PATCH 3/9 ftrace: Optimize testing what context current is in

From: "Steven Rostedt (VMware)" <[email protected]>

The preempt_count() is not a simple location in memory, it could be part of per_cpu code or more. Each access to preempt_count(), or one of its accessor functions (like in_interrupt()) takes several cycles. By reading preempt_count() once, and then doing tests to find the context against the value return is slightly faster than using in_nmi() and in_interrupt().

---
 include/linux/trace_recursion.h | 33 ++++++++++++++++++++-------------
 1 file changed, 20 insertions(+), 13 deletions(-)
include/linux/trace_recursion.h +20 -13
index da17a1144bf4..04d21e9ec48b 100644
@@ -111,22 +111,29 @@ enum {
 
 #define TRACE_CONTEXT_MASK	TRACE_LIST_MAX
 
+/*
+ * Used for setting context
+ *  NMI     = 0
+ *  IRQ     = 1
+ *  SOFTIRQ = 2
+ *  NORMAL  = 3
+ */
+enum {
+	TRACE_CTX_NMI,
+	TRACE_CTX_IRQ,
+	TRACE_CTX_SOFTIRQ,
+	TRACE_CTX_NORMAL,
+};
+
 static __always_inline int trace_get_context_bit(void)
 {
-	int bit;
-
-	if (in_interrupt()) {
-		if (in_nmi())
-			bit = 0;
+	unsigned long pc = preempt_count();
 
-		else if (in_irq())
-			bit = 1;
-		else
-			bit = 2;
-	} else
-		bit = 3;
-
-	return bit;
+	if (!(pc & (NMI_MASK | HARDIRQ_MASK | SOFTIRQ_OFFSET)))
+		return TRACE_CTX_NORMAL;
+	else
+		return pc & NMI_MASK ? TRACE_CTX_NMI :
+			pc & HARDIRQ_MASK ? TRACE_CTX_IRQ : TRACE_CTX_SOFTIRQ;
 }
 
 static __always_inline int trace_test_and_set_recursion(int start, int max)
Signature · 1 line
2.28.0
author maintainer
#23 lore raw

PATCH 9/9 ftrace: Reverse what the RECURSION flag means in the ftrace_ops

In reply to Steven Rostedt

From: "Steven Rostedt (VMware)" <[email protected]>

Now that all callbacks are recursion safe, reverse the meaning of the RECURSION flag and rename it from RECURSION_SAFE to simply RECURSION. Now only callbacks that request to have recursion protecting it will have the added trampoline to do so.

Also remove the outdated comment about "PER_CPU" when determining to use the ftrace_ops_assist_func.

Cc Jonathan Corbet <[email protected]>
Cc Sebastian Andrzej Siewior <[email protected]>
Cc Miroslav Benes <[email protected]>
Cc Kamalesh Babulal <[email protected]>
Cc Petr Mladek <[email protected]>
---
 Documentation/trace/ftrace-uses.rst | 82 +++++++++++++++++++++--------
 include/linux/ftrace.h              | 12 ++---
 kernel/trace/fgraph.c               |  3 +-
 kernel/trace/ftrace.c               | 20 ++++---
 kernel/trace/trace_events.c         |  1 -
 kernel/trace/trace_functions.c      |  2 +-
 kernel/trace/trace_selftest.c       |  7 +--
 kernel/trace/trace_stack.c          |  1 -
 8 files changed, 79 insertions(+), 49 deletions(-)
Documentation/trace/ftrace-uses.rst +60 -22
index 2a05e770618a..cce218d65f40 100644
@@ -30,8 +30,8 @@ The ftrace context
   This requires extra care to what can be done inside a callback. A callback
   can be called outside the protective scope of RCU.
 
-The ftrace infrastructure has some protections against recursions and RCU
-but one must still be very careful how they use the callbacks.
+There are helper functions to help against recursion, and making sure
+RCU is watching. These are explained below.
 
 
 The ftrace_ops structure
@@ -108,6 +108,50 @@ The prototype of the callback function is as follows (as of v4.14):
 	at the start of the function where ftrace was tracing. Otherwise it
 	either contains garbage, or NULL.
 
+Protect your callback
+=====================
+
+As functions can be called from anywhere, and it is possible that a function
+called by a callback may also be traced, and call that same callback,
+recursion protection must be used. There are two helper functions that
+can help in this regard. If you start your code with:
+
+	int bit;
+
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;
+
+and end it with:
+
+	ftrace_test_recursion_unlock(bit);
+
+The code in between will be safe to use, even if it ends up calling a
+function that the callback is tracing. Note, on success, 
+ftrace_test_recursion_trylock() will disable preemption, and the
+ftrace_test_recursion_unlock() will enable it again (if it was previously
+enabled).
+
+Alternatively, if the FTRACE_OPS_FL_RECURSION flag is set on the ftrace_ops
+(as explained below), then a helper trampoline will be used to test
+for recursion for the callback and no recursion test needs to be done.
+But this is at the expense of a slightly more overhead from an extra
+function call.
+
+If your callback accesses any data or critical section that requires RCU
+protection, it is best to make sure that RCU is "watching", otherwise
+that data or critical section will not be protected as expected. In this
+case add:
+
+	if (!rcu_is_watching())
+		return;
+
+Alternatively, if the FTRACE_OPS_FL_RCU flag is set on the ftrace_ops
+(as explained below), then a helper trampoline will be used to test
+for rcu_is_watching for the callback and no other test needs to be done.
+But this is at the expense of a slightly more overhead from an extra
+function call.
+
 
 The ftrace FLAGS
 ================
@@ -128,26 +172,20 @@ FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED
 	will not fail with this flag set. But the callback must check if
 	regs is NULL or not to determine if the architecture supports it.
 
-FTRACE_OPS_FL_RECURSION_SAFE
-	By default, a wrapper is added around the callback to
-	make sure that recursion of the function does not occur. That is,
-	if a function that is called as a result of the callback's execution
-	is also traced, ftrace will prevent the callback from being called
-	again. But this wrapper adds some overhead, and if the callback is
-	safe from recursion, it can set this flag to disable the ftrace
-	protection.
-
-	Note, if this flag is set, and recursion does occur, it could cause
-	the system to crash, and possibly reboot via a triple fault.
-
-	It is OK if another callback traces a function that is called by a
-	callback that is marked recursion safe. Recursion safe callbacks
-	must never trace any function that are called by the callback
-	itself or any nested functions that those functions call.
-
-	If this flag is set, it is possible that the callback will also
-	be called with preemption enabled (when CONFIG_PREEMPTION is set),
-	but this is not guaranteed.
+FTRACE_OPS_FL_RECURSION
+	By default, it is expected that the callback can handle recursion.
+	But if the callback is not that worried about overehead, then
+	setting this bit will add the recursion protection around the
+	callback by calling a helper function that will do the recursion
+	protection and only call the callback if it did not recurse.
+
+	Note, if this flag is not set, and recursion does occur, it could
+	cause the system to crash, and possibly reboot via a triple fault.
+
+	Not, if this flag is set, then the callback will always be called
+	with preemption disabled. If it is not set, then it is possible
+	(but not guaranteed) that the callback will be called in
+	preemptable context.
 
 FTRACE_OPS_FL_IPMODIFY
 	Requires FTRACE_OPS_FL_SAVE_REGS set. If the callback is to "hijack"
include/linux/ftrace.h +6 -6
index 0e4164a7f56d..806196345c3f 100644
@@ -98,7 +98,7 @@ ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops);
 /*
  * FTRACE_OPS_FL_* bits denote the state of ftrace_ops struct and are
  * set in the flags member.
- * CONTROL, SAVE_REGS, SAVE_REGS_IF_SUPPORTED, RECURSION_SAFE, STUB and
+ * CONTROL, SAVE_REGS, SAVE_REGS_IF_SUPPORTED, RECURSION, STUB and
  * IPMODIFY are a kind of attribute flags which can be set only before
  * registering the ftrace_ops, and can not be modified while registered.
  * Changing those attribute flags after registering ftrace_ops will
@@ -121,10 +121,10 @@ ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops);
  *            passing regs to the handler.
  *            Note, if this flag is set, the SAVE_REGS flag will automatically
  *            get set upon registering the ftrace_ops, if the arch supports it.
- * RECURSION_SAFE - The ftrace_ops can set this to tell the ftrace infrastructure
- *            that the call back has its own recursion protection. If it does
- *            not set this, then the ftrace infrastructure will add recursion
- *            protection for the caller.
+ * RECURSION - The ftrace_ops can set this to tell the ftrace infrastructure
+ *            that the call back needs recursion protection. If it does
+ *            not set this, then the ftrace infrastructure will assume
+ *            that the callback can handle recursion on its own.
  * STUB   - The ftrace_ops is just a place holder.
  * INITIALIZED - The ftrace_ops has already been initialized (first use time
  *            register_ftrace_function() is called, it will initialized the ops)
@@ -156,7 +156,7 @@ enum {
 	FTRACE_OPS_FL_DYNAMIC			= BIT(1),
 	FTRACE_OPS_FL_SAVE_REGS			= BIT(2),
 	FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED	= BIT(3),
-	FTRACE_OPS_FL_RECURSION_SAFE		= BIT(4),
+	FTRACE_OPS_FL_RECURSION			= BIT(4),
 	FTRACE_OPS_FL_STUB			= BIT(5),
 	FTRACE_OPS_FL_INITIALIZED		= BIT(6),
 	FTRACE_OPS_FL_DELETED			= BIT(7),
kernel/trace/fgraph.c +1 -2
index 5658f13037b3..73edb9e4f354 100644
@@ -334,8 +334,7 @@ unsigned long ftrace_graph_ret_addr(struct task_struct *task, int *idx,
 
 static struct ftrace_ops graph_ops = {
 	.func			= ftrace_stub,
-	.flags			= FTRACE_OPS_FL_RECURSION_SAFE |
-				   FTRACE_OPS_FL_INITIALIZED |
+	.flags			= FTRACE_OPS_FL_INITIALIZED |
 				   FTRACE_OPS_FL_PID |
 				   FTRACE_OPS_FL_STUB,
 #ifdef FTRACE_GRAPH_TRAMP_ADDR
kernel/trace/ftrace.c +9 -11
index 4833b6a82ce7..2dcae8251104 100644
@@ -80,7 +80,7 @@ enum {
 
 struct ftrace_ops ftrace_list_end __read_mostly = {
 	.func		= ftrace_stub,
-	.flags		= FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_STUB,
+	.flags		= FTRACE_OPS_FL_STUB,
 	INIT_OPS_HASH(ftrace_list_end)
 };
 
@@ -866,7 +866,7 @@ static void unregister_ftrace_profiler(void)
 #else
 static struct ftrace_ops ftrace_profile_ops __read_mostly = {
 	.func		= function_profile_call,
-	.flags		= FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_INITIALIZED,
+	.flags		= FTRACE_OPS_FL_INITIALIZED,
 	INIT_OPS_HASH(ftrace_profile_ops)
 };
 
@@ -1040,8 +1040,7 @@ struct ftrace_ops global_ops = {
 	.local_hash.notrace_hash	= EMPTY_HASH,
 	.local_hash.filter_hash		= EMPTY_HASH,
 	INIT_OPS_HASH(global_ops)
-	.flags				= FTRACE_OPS_FL_RECURSION_SAFE |
-					  FTRACE_OPS_FL_INITIALIZED |
+	.flags				= FTRACE_OPS_FL_INITIALIZED |
 					  FTRACE_OPS_FL_PID,
 };
 
@@ -2382,7 +2381,7 @@ static void call_direct_funcs(unsigned long ip, unsigned long pip,
 
 struct ftrace_ops direct_ops = {
 	.func		= call_direct_funcs,
-	.flags		= FTRACE_OPS_FL_IPMODIFY | FTRACE_OPS_FL_RECURSION_SAFE
+	.flags		= FTRACE_OPS_FL_IPMODIFY
 			  | FTRACE_OPS_FL_DIRECT | FTRACE_OPS_FL_SAVE_REGS
 			  | FTRACE_OPS_FL_PERMANENT,
 	/*
@@ -6864,8 +6863,7 @@ void ftrace_init_trace_array(struct trace_array *tr)
 
 struct ftrace_ops global_ops = {
 	.func			= ftrace_stub,
-	.flags			= FTRACE_OPS_FL_RECURSION_SAFE |
-				  FTRACE_OPS_FL_INITIALIZED |
+	.flags			= FTRACE_OPS_FL_INITIALIZED |
 				  FTRACE_OPS_FL_PID,
 };
 
@@ -7025,11 +7023,11 @@ NOKPROBE_SYMBOL(ftrace_ops_assist_func);
 ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops)
 {
 	/*
-	 * If the function does not handle recursion, needs to be RCU safe,
-	 * or does per cpu logic, then we need to call the assist handler.
+	 * If the function does not handle recursion or needs to be RCU safe,
+	 * then we need to call the assist handler.
 	 */
-	if (!(ops->flags & FTRACE_OPS_FL_RECURSION_SAFE) ||
-	    ops->flags & FTRACE_OPS_FL_RCU)
+	if (ops->flags & (FTRACE_OPS_FL_RECURSION |
+			  FTRACE_OPS_FL_RCU))
 		return ftrace_ops_assist_func;
 
 	return ops->func;
kernel/trace/trace_events.c +0 -1
index e705f06c68c6..4a9a2a9853bc 100644
@@ -3712,7 +3712,6 @@ function_test_events_call(unsigned long ip, unsigned long parent_ip,
 static struct ftrace_ops trace_ops __initdata  =
 {
 	.func = function_test_events_call,
-	.flags = FTRACE_OPS_FL_RECURSION_SAFE,
 };
 
 static __init void event_trace_self_test_with_function(void)
kernel/trace/trace_functions.c +1 -1
index 943756c01190..89c414ce1388 100644
@@ -48,7 +48,7 @@ int ftrace_allocate_ftrace_ops(struct trace_array *tr)
 
 	/* Currently only the non stack version is supported */
 	ops->func = function_trace_call;
-	ops->flags = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_PID;
+	ops->flags = FTRACE_OPS_FL_PID;
 
 	tr->ops = ops;
 	ops->private = tr;
kernel/trace/trace_selftest.c +2 -5
index b5e3496cf803..50dd913d23e7 100644
@@ -150,17 +150,14 @@ static void trace_selftest_test_dyn_func(unsigned long ip,
 
 static struct ftrace_ops test_probe1 = {
 	.func			= trace_selftest_test_probe1_func,
-	.flags			= FTRACE_OPS_FL_RECURSION_SAFE,
 };
 
 static struct ftrace_ops test_probe2 = {
 	.func			= trace_selftest_test_probe2_func,
-	.flags			= FTRACE_OPS_FL_RECURSION_SAFE,
 };
 
 static struct ftrace_ops test_probe3 = {
 	.func			= trace_selftest_test_probe3_func,
-	.flags			= FTRACE_OPS_FL_RECURSION_SAFE,
 };
 
 static void print_counts(void)
@@ -448,11 +445,11 @@ static void trace_selftest_test_recursion_safe_func(unsigned long ip,
 
 static struct ftrace_ops test_rec_probe = {
 	.func			= trace_selftest_test_recursion_func,
+	.flags			= FTRACE_OPS_FL_RECURSION,
 };
 
 static struct ftrace_ops test_recsafe_probe = {
 	.func			= trace_selftest_test_recursion_safe_func,
-	.flags			= FTRACE_OPS_FL_RECURSION_SAFE,
 };
 
 static int
@@ -556,7 +553,7 @@ static void trace_selftest_test_regs_func(unsigned long ip,
 
 static struct ftrace_ops test_regs_probe = {
 	.func		= trace_selftest_test_regs_func,
-	.flags		= FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_SAVE_REGS,
+	.flags		= FTRACE_OPS_FL_SAVE_REGS,
 };
 
 static int
kernel/trace/trace_stack.c +0 -1
index c408423e5d65..969db526a563 100644
@@ -318,7 +318,6 @@ stack_trace_call(unsigned long ip, unsigned long parent_ip,
 static struct ftrace_ops trace_ops __read_mostly =
 {
 	.func = stack_trace_call,
-	.flags = FTRACE_OPS_FL_RECURSION_SAFE,
 };
 
 static ssize_t
Signature · 1 line
2.28.0
author maintainer
#6 lore raw

PATCH 4/9 pstore/ftrace: Add recursion protection to the ftrace callback

In reply to Steven Rostedt

From: "Steven Rostedt (VMware)" <[email protected]>

If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.

The default for ftrace_ops is going to assume recursion protection unless otherwise specified.

---
 fs/pstore/ftrace.c | 6 ++++++
 1 file changed, 6 insertions(+)
fs/pstore/ftrace.c +6 -0
index 5c0450701293..816210fc5d3a 100644
@@ -28,6 +28,7 @@ static void notrace pstore_ftrace_call(unsigned long ip,
 				       struct ftrace_ops *op,
 				       struct pt_regs *regs)
 {
+	int bit;
 	unsigned long flags;
 	struct pstore_ftrace_record rec = {};
 	struct pstore_record record = {
@@ -40,6 +41,10 @@ static void notrace pstore_ftrace_call(unsigned long ip,
 	if (unlikely(oops_in_progress))
 		return;
 
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;
+
 	local_irq_save(flags);
 
 	rec.ip = ip;
@@ -49,6 +54,7 @@ static void notrace pstore_ftrace_call(unsigned long ip,
 	psinfo->write(&record);
 
 	local_irq_restore(flags);
+	ftrace_test_recursion_unlock(bit);
 }
 
 static struct ftrace_ops pstore_ftrace_ops __read_mostly = {
Signature · 1 line
2.28.0
author maintainer
#12 lore raw

PATCH 6/9 livepatch/ftrace: Add recursion protection to the ftrace callback

In reply to Steven Rostedt

From: "Steven Rostedt (VMware)" <[email protected]>

If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.

The default for ftrace_ops is going to assume recursion protection unless otherwise specified.

Cc Josh Poimboeuf <[email protected]>
Cc Jiri Kosina <[email protected]>
Cc Miroslav Benes <[email protected]>
Cc Petr Mladek <[email protected]>
Cc Joe Lawrence <[email protected]>
---
 kernel/livepatch/patch.c | 5 +++++
 1 file changed, 5 insertions(+)
kernel/livepatch/patch.c +5 -0
index b552cf2d85f8..6c0164d24bbd 100644
@@ -45,9 +45,13 @@ static void notrace klp_ftrace_handler(unsigned long ip,
 	struct klp_ops *ops;
 	struct klp_func *func;
 	int patch_state;
+	int bit;
 
 	ops = container_of(fops, struct klp_ops, fops);
 
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;
 	/*
 	 * A variant of synchronize_rcu() is used to allow patching functions
 	 * where RCU is not watching, see klp_synchronize_transition().
@@ -117,6 +121,7 @@ static void notrace klp_ftrace_handler(unsigned long ip,
 
 unlock:
 	preempt_enable_notrace();
+	ftrace_test_recursion_unlock(bit);
 }
 
 /*
Signature · 1 line
2.28.0
author maintainer
#4 lore raw

PATCH 2/9 ftrace: Add ftrace_test_recursion_trylock() helper function

In reply to Steven Rostedt

From: "Steven Rostedt (VMware)" <[email protected]>

To make it easier for ftrace callbacks to have recursion protection, provide a ftrace_test_recursion_trylock() and ftrace_test_recursion_unlock() helper that tests for recursion.

---
 include/linux/trace_recursion.h | 25 +++++++++++++++++++++++++
 kernel/trace/trace_functions.c  | 12 +++++-------
 2 files changed, 30 insertions(+), 7 deletions(-)
include/linux/trace_recursion.h +25 -0
index 6c94c2ece9f0..da17a1144bf4 100644
@@ -163,5 +163,30 @@ static __always_inline void trace_clear_recursion(int bit)
 	current->trace_recursion = val;
 }
 
+/**
+ * ftrace_test_recursion_trylock - tests for recursion in same context
+ *
+ * Use this for ftrace callbacks. This will detect if the function
+ * tracing recursed in the same context (normal vs interrupt),
+ *
+ * Returns: -1 if a recursion happened.
+ *           >= 0 if no recursion
+ */
+static __always_inline int ftrace_test_recursion_trylock(void)
+{
+	return trace_test_and_set_recursion(TRACE_FTRACE_START, TRACE_FTRACE_MAX);
+}
+
+/**
+ * ftrace_test_recursion_unlock - called when function callback is complete
+ * @bit: The return of a successful ftrace_test_recursion_trylock()
+ *
+ * This is used at the end of a ftrace callback.
+ */
+static __always_inline void ftrace_test_recursion_unlock(int bit)
+{
+	trace_clear_recursion(bit);
+}
+
 #endif /* CONFIG_TRACING */
 #endif /* _LINUX_TRACE_RECURSION_H */
kernel/trace/trace_functions.c +5 -7
index 2c2126e1871d..943756c01190 100644
@@ -141,22 +141,20 @@ function_trace_call(unsigned long ip, unsigned long parent_ip,
 	if (unlikely(!tr->function_enabled))
 		return;
 
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;
+
 	pc = preempt_count();
 	preempt_disable_notrace();
 
-	bit = trace_test_and_set_recursion(TRACE_FTRACE_START, TRACE_FTRACE_MAX);
-	if (bit < 0)
-		goto out;
-
 	cpu = smp_processor_id();
 	data = per_cpu_ptr(tr->array_buffer.data, cpu);
 	if (!atomic_read(&data->disabled)) {
 		local_save_flags(flags);
 		trace_function(tr, ip, parent_ip, flags, pc);
 	}
-	trace_clear_recursion(bit);
-
- out:
+	ftrace_test_recursion_unlock(bit);
 	preempt_enable_notrace();
 }
 
Signature · 1 line
2.28.0
maintainer
#9 lore raw

Re: [PATCH 5/9] kprobes/ftrace: Add recursion protection to the ftrace callback

In reply to Steven Rostedt

Hi Steve,

Quoted 6 lines · On Wed, 28 Oct 2020 07:52:49 -0400 Steven Rostedt <[email protected]> wrote:

From: "Steven Rostedt (VMware)" <[email protected]>

If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.

So in that case the handlers will be called without preempt disabled?

Quoted 2 lines

The default for ftrace_ops is going to assume recursion protection unless otherwise specified.

This seems to skip entier handler if ftrace finds recursion. I would like to increment the missed counter even in that case.

[...]
e.g.

Quoted 16 lines
arch/csky/kernel/probes/ftrace.c +2 -1
index 5264763d05be..5eb2604fdf71 100644
@@ -13,16 +13,21 @@ int arch_check_ftrace_location(struct kprobe *p)
 void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 			   struct ftrace_ops *ops, struct pt_regs *regs)
 {
+	int bit;
 	bool lr_saver = false;
 	struct kprobe *p;
 	struct kprobe_ctlblk *kcb;
 
-	/* Preempt is disabled by ftrace */
+	bit = ftrace_test_recursion_trylock();
 

arch/csky/kernel/probes/ftrace.c int arch_check_ftrace_location(struct kprobe *p) · line 31

Quoted 10 lines
arch/csky/kernel/probes/ftrace.c +3 -1
+
+	preempt_disable_notrace();
 	p = get_kprobe((kprobe_opcode_t *)ip);
 	if (!p) {
 		p = get_kprobe((kprobe_opcode_t *)(ip - MCOUNT_INSN_SIZE));
 		if (unlikely(!p) || kprobe_disabled(p))
-			return;
+			goto out;
 		lr_saver = true;
 	}
	if (bit < 0) {
		kprobes_inc_nmissed_count(p);
		goto out;
	}

arch/csky/kernel/probes/ftrace.c void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip, · line 65

Quoted 7 lines
arch/csky/kernel/probes/ftrace.c +2 -0
@@ -56,6 +61,9 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 		 */
 		__this_cpu_write(current_kprobe, NULL);
 	}
+out:
+	preempt_enable_notrace();
	if (bit >= 0)
		ftrace_test_recursion_unlock(bit);

arch/csky/kernel/probes/ftrace.c void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip, · line 69

Quoted 3 lines
arch/csky/kernel/probes/ftrace.c +0 -0
 }
 NOKPROBE_SYMBOL(kprobe_ftrace_handler);
 

Or, we can also introduce a support function,

static inline void kprobes_inc_nmissed_ip(unsigned long ip)

{
	struct kprobe *p;

	preempt_disable_notrace();
	p = get_kprobe((kprobe_opcode_t *)ip);
	if (p)
		kprobes_inc_nmissed_count(p);
	preempt_enable_notrace();
}

arch/parisc/kernel/ftrace.c void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip, · line 210

Quoted 8 lines
arch/parisc/kernel/ftrace.c +0 -0
index 4bab21c71055..5f7742b225a5 100644
@@ -208,13 +208,19 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 {
 	struct kprobe_ctlblk *kcb;
 	struct kprobe *p = get_kprobe((kprobe_opcode_t *)ip);

(BTW, here is a bug... get_kprobe() must be called with preempt disabled.)

arch/parisc/kernel/ftrace.c void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip, · line 213

Quoted 4 lines
arch/parisc/kernel/ftrace.c +2 -1
+	int bit;
 
-	if (unlikely(!p) || kprobe_disabled(p))
+	bit = ftrace_test_recursion_trylock();
	if (bit < 0) {
		kprobes_inc_nmissed_ip(ip);

arch/parisc/kernel/ftrace.c void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip, · line 214

Quoted 1 line
arch/parisc/kernel/ftrace.c +0 -0
 		return;
	}

This may easier for you ?

Thank you,

Quoted 127 lines
arch/parisc/kernel/ftrace.c +8 -1
+	preempt_disable_notrace();
+	if (unlikely(!p) || kprobe_disabled(p))
+		goto out;
+
 	if (kprobe_running()) {
 		kprobes_inc_nmissed_count(p);
-		return;
+		goto out;
 	}
 
 	__this_cpu_write(current_kprobe, p);
@@ -235,6 +241,9 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 		}
 	}
 	__this_cpu_write(current_kprobe, NULL);
+out:
+	preempt_enable_notrace();
+	ftrace_test_recursion_unlock(bit);
 }
 NOKPROBE_SYMBOL(kprobe_ftrace_handler);
 
arch/powerpc/kernel/kprobes-ftrace.c +10 -1
index 972cb28174b2..5df8d50c65ae 100644
@@ -18,10 +18,16 @@ void kprobe_ftrace_handler(unsigned long nip, unsigned long parent_nip,
 {
 	struct kprobe *p;
 	struct kprobe_ctlblk *kcb;
+	int bit;
 
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;
+
+	preempt_disable_notrace();
 	p = get_kprobe((kprobe_opcode_t *)nip);
 	if (unlikely(!p) || kprobe_disabled(p))
-		return;
+		goto out;
 
 	kcb = get_kprobe_ctlblk();
 	if (kprobe_running()) {
@@ -52,6 +58,9 @@ void kprobe_ftrace_handler(unsigned long nip, unsigned long parent_nip,
 		 */
 		__this_cpu_write(current_kprobe, NULL);
 	}
+out:
+	preempt_enable_notrace();
+	ftrace_test_recursion_unlock(bit);
 }
 NOKPROBE_SYMBOL(kprobe_ftrace_handler);
 
arch/s390/kernel/ftrace.c +11 -2
index b388e87a08bf..88466d7fb6b2 100644
@@ -202,13 +202,19 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 {
 	struct kprobe_ctlblk *kcb;
 	struct kprobe *p = get_kprobe((kprobe_opcode_t *)ip);
+	int bit;
 
-	if (unlikely(!p) || kprobe_disabled(p))
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
 		return;
 
+	preempt_disable_notrace();
+	if (unlikely(!p) || kprobe_disabled(p))
+		goto out;
+
 	if (kprobe_running()) {
 		kprobes_inc_nmissed_count(p);
-		return;
+		goto out;
 	}
 
 	__this_cpu_write(current_kprobe, p);
@@ -228,6 +234,9 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 		}
 	}
 	__this_cpu_write(current_kprobe, NULL);
+out:
+	preempt_enable_notrace();
+	ftrace_test_recursion_unlock(bit);
 }
 NOKPROBE_SYMBOL(kprobe_ftrace_handler);
 
arch/x86/kernel/kprobes/ftrace.c +10 -2
index 681a4b36e9bb..a40a6cdfcca3 100644
@@ -18,11 +18,16 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 {
 	struct kprobe *p;
 	struct kprobe_ctlblk *kcb;
+	int bit;
 
-	/* Preempt is disabled by ftrace */
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;
+
+	preempt_disable_notrace();
 	p = get_kprobe((kprobe_opcode_t *)ip);
 	if (unlikely(!p) || kprobe_disabled(p))
-		return;
+		goto out;
 
 	kcb = get_kprobe_ctlblk();
 	if (kprobe_running()) {
@@ -52,6 +57,9 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 		 */
 		__this_cpu_write(current_kprobe, NULL);
 	}
+out:
+	preempt_enable_notrace();
+	ftrace_test_recursion_unlock(bit);
 }
 NOKPROBE_SYMBOL(kprobe_ftrace_handler);
 
Signature · 1 line
2.28.0
Signature · 1 line
Masami Hiramatsu <[email protected]>
author maintainer
#10 lore raw

Re: [PATCH 5/9] kprobes/ftrace: Add recursion protection to the ftrace callback

Quoted 12 lines · On Thu, 29 Oct 2020 16:58:03 +0900 Masami Hiramatsu <[email protected]> wrote:

Hi Steve,

Quoted 6 lines · On Wed, 28 Oct 2020 07:52:49 -0400 Steven Rostedt <[email protected]> wrote:

From: "Steven Rostedt (VMware)" <[email protected]>

If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.

Quoted 8 lines

So in that case the handlers will be called without preempt disabled?

Quoted 2 lines

The default for ftrace_ops is going to assume recursion protection unless otherwise specified.

This seems to skip entier handler if ftrace finds recursion. I would like to increment the missed counter even in that case.

Note, this code does not change the functionality at this point, because without having the FL_RECURSION flag set (which kprobes does not even in this patch), it always gets called from the helper function that does this:

	bit = trace_test_and_set_recursion(TRACE_LIST_START, TRACE_LIST_MAX);
	if (bit < 0)
		return;

	preempt_disable_notrace();

	op->func(ip, parent_ip, op, regs);

	preempt_enable_notrace();
	trace_clear_recursion(bit);

Where this function gets called by op->func().

In other words, you don't get that count anyway, and I don't think you want it. Because it means you traced something that your callback calls.

That bit check is basically a nop, because the last patch in this series will make the default that everything has recursion protection, but at this patch the test does this:

	/* A previous recursion check was made */
	if ((val & TRACE_CONTEXT_MASK) > max)
		return 0;

Which would always return true, because this function is called via the helper that already did the trace_test_and_set_recursion() which, if it made it this far, the val would always be greater than max.

Quoted 20 lines

[...]
e.g.

Quoted 15 lines
arch/csky/kernel/probes/ftrace.c +2 -1
index 5264763d05be..5eb2604fdf71 100644
@@ -13,16 +13,21 @@ int arch_check_ftrace_location(struct kprobe *p)
 void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 			   struct ftrace_ops *ops, struct pt_regs *regs)
 {
+	int bit;
 	bool lr_saver = false;
 	struct kprobe *p;
 	struct kprobe_ctlblk *kcb;
 
-	/* Preempt is disabled by ftrace */
+	bit = ftrace_test_recursion_trylock();  
Quoted 15 lines

arch/csky/kernel/probes/ftrace.c int arch_check_ftrace_location(struct kprobe *p) · line 32

Quoted 10 lines
arch/csky/kernel/probes/ftrace.c +3 -1
+
+	preempt_disable_notrace();
 	p = get_kprobe((kprobe_opcode_t *)ip);
 	if (!p) {
 		p = get_kprobe((kprobe_opcode_t *)(ip - MCOUNT_INSN_SIZE));
 		if (unlikely(!p) || kprobe_disabled(p))
-			return;
+			goto out;
 		lr_saver = true;
 	}  
	if (bit < 0) {
		kprobes_inc_nmissed_count(p);
		goto out;
	}

If anything called in get_kprobe() or kprobes_inc_nmissed_count() gets traced here, you have zero recursion protection, and this will crash the machine with a likely reboot (triple fault).

Note, the recursion handles interrupts and wont stop them. bit < 0 only happens if you recurse because this function called something that ends up calling itself. Really, why would you care about missing a kprobe on the same kprobe?

-- Steve

maintainer
#13 lore raw

Re: [PATCH 6/9] livepatch/ftrace: Add recursion protection to the ftrace callback

In reply to Steven Rostedt
Quoted 9 lines · Steven Rostedt

From: "Steven Rostedt (VMware)" <[email protected]>

If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.

The default for ftrace_ops is going to assume recursion protection unless otherwise specified.

Hm, I've always thought that we did not need any kind of recursion protection for our callback. It is marked as notrace and it does not call anything traceable. In fact, it does not call anything. I even have a note in my todo list to mark the callback as RECURSION_SAFE :)

At the same time, it probably does not hurt and the patch is still better than what we have now without RECURSION_SAFE if I understand the patch set correctly.

Quoted 16 lines
Cc Josh Poimboeuf <[email protected]>
Cc Jiri Kosina <[email protected]>
Cc Miroslav Benes <[email protected]>
Cc Petr Mladek <[email protected]>
Cc Joe Lawrence <[email protected]>
---
 kernel/livepatch/patch.c | 5 +++++
 1 file changed, 5 insertions(+)
kernel/livepatch/patch.c +0 -0
index b552cf2d85f8..6c0164d24bbd 100644

kernel/livepatch/patch.c static void notrace klp_ftrace_handler(unsigned long ip, · line 54

Quoted 10 lines
kernel/livepatch/patch.c +4 -0
@@ -45,9 +45,13 @@ static void notrace klp_ftrace_handler(unsigned long ip,
 	struct klp_ops *ops;
 	struct klp_func *func;
 	int patch_state;
+	int bit;
 
 	ops = container_of(fops, struct klp_ops, fops);
 
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;

This means that the original function will be called in case of recursion. That's probably fair, but I'm wondering if we should at least WARN about it.

Thanks
Miroslav

author maintainer
#14 lore raw

Re: [PATCH 6/9] livepatch/ftrace: Add recursion protection to the ftrace callback

Quoted 11 lines · On Thu, 29 Oct 2020 14:51:06 +0100 (CET) Miroslav Benes <[email protected]> wrote:
Quoted 11 lines

index b552cf2d85f8..6c0164d24bbd 100644

kernel/livepatch/patch.c +1 -0
@@ -45,9 +45,13 @@ static void notrace klp_ftrace_handler(unsigned long ip,
 	struct klp_ops *ops;
 	struct klp_func *func;
 	int patch_state;
+	int bit;
 
 	ops = container_of(fops, struct klp_ops, fops);
 
Quoted 7 lines

kernel/livepatch/patch.c static void notrace klp_ftrace_handler(unsigned long ip, · line 54

Quoted 3 lines
kernel/livepatch/patch.c +3 -0
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;  

This means that the original function will be called in case of recursion. That's probably fair, but I'm wondering if we should at least WARN about it.

It's probably what happens today. But if you add a WARN_ON_ONCE() it may not hurt.

I also plan on adding code that reports when recursion has happened, because even if it's not a problem, recursion adds extra overhead.

-- Steve

maintainer
#16 lore raw

Re: [PATCH 6/9] livepatch/ftrace: Add recursion protection to the ftrace callback

In reply to Miroslav Benes
Quoted 11 lines · Miroslav Benes
Quoted 9 lines · Steven Rostedt

From: "Steven Rostedt (VMware)" <[email protected]>

If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.

The default for ftrace_ops is going to assume recursion protection unless otherwise specified.

It might be my lack skills to read English. But the above sentence sounds ambiguous to me. It is not clear to me who provides the recursion protection by default. Could you please make it more explicit, for example by:

"The default for ftrace_ops is going to change. It will expect that handlers provide their own recursion protection."

Quoted 4 lines

Hm, I've always thought that we did not need any kind of recursion protection for our callback. It is marked as notrace and it does not call anything traceable. In fact, it does not call anything. I even have a note in my todo list to mark the callback as RECURSION_SAFE :)

Well, it calls WARN_ON_ONCE() ;-)

Quoted 3 lines

At the same time, it probably does not hurt and the patch is still better than what we have now without RECURSION_SAFE if I understand the patch set correctly.

And better be on the safe side.

Quoted 23 lines
Quoted 23 lines
Cc Josh Poimboeuf <[email protected]>
Cc Jiri Kosina <[email protected]>
Cc Miroslav Benes <[email protected]>
Cc Petr Mladek <[email protected]>
Cc Joe Lawrence <[email protected]>
---
 kernel/livepatch/patch.c | 5 +++++
 1 file changed, 5 insertions(+)
kernel/livepatch/patch.c +1 -0
index b552cf2d85f8..6c0164d24bbd 100644
@@ -45,9 +45,13 @@ static void notrace klp_ftrace_handler(unsigned long ip,
 	struct klp_ops *ops;
 	struct klp_func *func;
 	int patch_state;
+	int bit;
 
 	ops = container_of(fops, struct klp_ops, fops);
 
Quoted 7 lines

kernel/livepatch/patch.c static void notrace klp_ftrace_handler(unsigned long ip, · line 54

Quoted 3 lines
kernel/livepatch/patch.c +3 -0
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;

This means that the original function will be called in case of recursion. That's probably fair, but I'm wondering if we should at least WARN about it.

Yeah, the early return might break the consistency model and unexpected things might happen. We should be aware of it. Please use:

	if (WARN_ON_ONCE(bit < 0))
		return;

WARN_ON_ONCE() might be part of the recursion. But it should happen only once. IMHO, it is worth the risk.

Otherwise it looks good.

Best Regards,
Petr

maintainer
#17 lore raw

Re: [PATCH 6/9] livepatch/ftrace: Add recursion protection to the ftrace callback

Quoted 9 lines · Petr Mladek
Quoted 6 lines · Miroslav Benes

On Wed, 28 Oct 2020, Steven Rostedt wrote:

Hm, I've always thought that we did not need any kind of recursion protection for our callback. It is marked as notrace and it does not call anything traceable. In fact, it does not call anything. I even have a note in my todo list to mark the callback as RECURSION_SAFE :)

Well, it calls WARN_ON_ONCE() ;-)

Oh my, I learned to ignore these. Of course there is printk hidden everywhere.

Quoted 5 lines
Quoted 3 lines

At the same time, it probably does not hurt and the patch is still better than what we have now without RECURSION_SAFE if I understand the patch set correctly.

And better be on the safe side.

Agreed.

Quoted 35 lines
Quoted 23 lines
Quoted 23 lines
Cc Josh Poimboeuf <[email protected]>
Cc Jiri Kosina <[email protected]>
Cc Miroslav Benes <[email protected]>
Cc Petr Mladek <[email protected]>
Cc Joe Lawrence <[email protected]>
---
 kernel/livepatch/patch.c | 5 +++++
 1 file changed, 5 insertions(+)
kernel/livepatch/patch.c +1 -0
index b552cf2d85f8..6c0164d24bbd 100644
@@ -45,9 +45,13 @@ static void notrace klp_ftrace_handler(unsigned long ip,
 	struct klp_ops *ops;
 	struct klp_func *func;
 	int patch_state;
+	int bit;
 
 	ops = container_of(fops, struct klp_ops, fops);
 
Quoted 7 lines

kernel/livepatch/patch.c static void notrace klp_ftrace_handler(unsigned long ip, · line 54

Quoted 3 lines
kernel/livepatch/patch.c +3 -0
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;

This means that the original function will be called in case of recursion. That's probably fair, but I'm wondering if we should at least WARN about it.

Yeah, the early return might break the consistency model and unexpected things might happen. We should be aware of it. Please use:

Quoted 5 lines
	if (WARN_ON_ONCE(bit < 0))
		return;

WARN_ON_ONCE() might be part of the recursion. But it should happen only once. IMHO, it is worth the risk.

Agreed.

Miroslav

author maintainer
#18 lore raw

Re: [PATCH 6/9] livepatch/ftrace: Add recursion protection to the ftrace callback

In reply to Petr Mladek
Quoted 13 lines · On Thu, 29 Oct 2020 15:57:09 +0100 Petr Mladek <[email protected]> wrote:
Quoted 11 lines · Miroslav Benes
Quoted 9 lines · Steven Rostedt

From: "Steven Rostedt (VMware)" <[email protected]>

If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.

The default for ftrace_ops is going to assume recursion protection unless otherwise specified.

Quoted 7 lines

It might be my lack skills to read English. But the above sentence sounds ambiguous to me. It is not clear to me who provides the recursion protection by default. Could you please make it more explicit, for example by:

"The default for ftrace_ops is going to change. It will expect that handlers provide their own recursion protection."

It was originally written as something else, as my first series (that I didn't post) added the recursion flag, and then I needed one big nasty patch to remove them. Then I realized it would be fine to just keep the double recursion testing and remove the flag when it was no longer used. I then went back and wrote up that sentence, and yeah, it wasn't the best explanation.

Your sentence is better, I'll update it.

Quoted 7 lines
Quoted 6 lines

Hm, I've always thought that we did not need any kind of recursion protection for our callback. It is marked as notrace and it does not call anything traceable. In fact, it does not call anything. I even have a note in my todo list to mark the callback as RECURSION_SAFE :)

Quoted 7 lines

Well, it calls WARN_ON_ONCE() ;-)

Quoted 3 lines

At the same time, it probably does not hurt and the patch is still better than what we have now without RECURSION_SAFE if I understand the patch set correctly.

And better be on the safe side.

And the WARN_ON_ONCE() use to cause a problem, until I fixed it:

dfbf2897d0049 ("bug: set warn variable before calling WARN()")

Quoted 37 lines
Quoted 25 lines
Quoted 25 lines
Cc Josh Poimboeuf <[email protected]>
Cc Jiri Kosina <[email protected]>
Cc Miroslav Benes <[email protected]>
Cc Petr Mladek <[email protected]>
Cc Joe Lawrence <[email protected]>
---
 kernel/livepatch/patch.c | 5 +++++
 1 file changed, 5 insertions(+)
kernel/livepatch/patch.c +1 -0
index b552cf2d85f8..6c0164d24bbd 100644
@@ -45,9 +45,13 @@ static void notrace klp_ftrace_handler(unsigned long ip,
 	struct klp_ops *ops;
 	struct klp_func *func;
 	int patch_state;
+	int bit;
 
 	ops = container_of(fops, struct klp_ops, fops);
 
Quoted 7 lines

kernel/livepatch/patch.c static void notrace klp_ftrace_handler(unsigned long ip, · line 54

Quoted 3 lines
kernel/livepatch/patch.c +3 -0
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;  

This means that the original function will be called in case of recursion. That's probably fair, but I'm wondering if we should at least WARN about it.

Yeah, the early return might break the consistency model and unexpected things might happen. We should be aware of it. Please use:

Quoted 7 lines
	if (WARN_ON_ONCE(bit < 0))
		return;

WARN_ON_ONCE() might be part of the recursion. But it should happen only once. IMHO, it is worth the risk.

Otherwise it looks good.

Perhaps we can add that as a separate patch, because this patch doesn't add any real functionality change. It only moves the recursion testing from the helper function (which ftrace wraps all callbacks that do not have the RECURSION flags set, including this one) down to your callback.

In keeping with one patch to do one thing principle, the added of WARN_ON_ONCE() should be a separate patch, as that will change the functionality.

If that WARN_ON_ONCE() breaks things, I'd like it to be bisected to another patch other than this one.

-- Steve

maintainer
#2 lore raw

Re: [PATCH 1/9] ftrace: Move the recursion testing into global headers

In reply to Steven Rostedt

Hi,

Quoted 27 lines
include/linux/trace_recursion.h new file +27 -0
+static __always_inline int trace_get_context_bit(void)
+{
+	int bit;
+
+	if (in_interrupt()) {
+		if (in_nmi())
+			bit = 0;
+
+		else if (in_irq())
+			bit = 1;
+		else
+			bit = 2;
+	} else
+		bit = 3;
+
+	return bit;
+}
+
+static __always_inline int trace_test_and_set_recursion(int start, int max)
+{
+	unsigned int val = current->trace_recursion;
+	int bit;
+
+	/* A previous recursion check was made */
+	if ((val & TRACE_CONTEXT_MASK) > max)
+		return 0;
+

include/linux/trace_recursion.h line 150

Quoted 10 lines
include/linux/trace_recursion.h new file +10 -0
+	bit = trace_get_context_bit() + start;
+	if (unlikely(val & (1 << bit)))
+		return -1;
+
+	val |= 1 << bit;
+	current->trace_recursion = val;
+	barrier();
+
+	return bit;
+}

how does this work in case of NMI? trace_get_context_bit() returns 0 (it does not change later in the patch set). "start" in trace_test_and_set_recursion() is 0 zero too as used later in the patch set by ftrace_test_recursion_trylock(). So trace_test_and_set_recursion() returns 0. That is perfectly sane, but then...

include/linux/trace_recursion.h line 157

Quoted 6 lines
include/linux/trace_recursion.h new file +6 -0
+static __always_inline void trace_clear_recursion(int bit)
+{
+	unsigned int val = current->trace_recursion;
+
+	if (!bit)
+		return;

... the bit is not cleared here.

include/linux/trace_recursion.h line 164

Quoted 6 lines
include/linux/trace_recursion.h new file +6 -0
+	bit = 1 << bit;
+	val &= ~bit;
+
+	barrier();
+	current->trace_recursion = val;
+}

Thanks
Miroslav

maintainer
#19 lore raw

Re: [PATCH 6/9] livepatch/ftrace: Add recursion protection to the ftrace callback

In reply to Steven Rostedt
Quoted 25 lines
Quoted 12 lines
Quoted 7 lines

kernel/livepatch/patch.c static void notrace klp_ftrace_handler(unsigned long ip, · line 54

Quoted 3 lines
kernel/livepatch/patch.c +3 -0
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;  

This means that the original function will be called in case of recursion. That's probably fair, but I'm wondering if we should at least WARN about it.

Yeah, the early return might break the consistency model and unexpected things might happen. We should be aware of it. Please use:

Quoted 7 lines
	if (WARN_ON_ONCE(bit < 0))
		return;

WARN_ON_ONCE() might be part of the recursion. But it should happen only once. IMHO, it is worth the risk.

Otherwise it looks good.

Perhaps we can add that as a separate patch, because this patch doesn't add any real functionality change. It only moves the recursion testing from the helper function (which ftrace wraps all callbacks that do not have the RECURSION flags set, including this one) down to your callback.

Quoted 6 lines

In keeping with one patch to do one thing principle, the added of WARN_ON_ONCE() should be a separate patch, as that will change the functionality.

If that WARN_ON_ONCE() breaks things, I'd like it to be bisected to another patch other than this one.

Works for me.

Miroslav

maintainer Reviewed-by
#20 lore raw

Re: [PATCH 6/9] livepatch/ftrace: Add recursion protection to the ftrace callback

Quoted 25 lines · Miroslav Benes
Quoted 25 lines
Quoted 12 lines
Quoted 7 lines

kernel/livepatch/patch.c static void notrace klp_ftrace_handler(unsigned long ip, · line 54

Quoted 3 lines
kernel/livepatch/patch.c +3 -0
+	bit = ftrace_test_recursion_trylock();
+	if (bit < 0)
+		return;  

This means that the original function will be called in case of recursion. That's probably fair, but I'm wondering if we should at least WARN about it.

Yeah, the early return might break the consistency model and unexpected things might happen. We should be aware of it. Please use:

Quoted 7 lines
	if (WARN_ON_ONCE(bit < 0))
		return;

WARN_ON_ONCE() might be part of the recursion. But it should happen only once. IMHO, it is worth the risk.

Otherwise it looks good.

Perhaps we can add that as a separate patch, because this patch doesn't add any real functionality change. It only moves the recursion testing from the helper function (which ftrace wraps all callbacks that do not have the RECURSION flags set, including this one) down to your callback.

Quoted 8 lines
Quoted 6 lines

In keeping with one patch to do one thing principle, the added of WARN_ON_ONCE() should be a separate patch, as that will change the functionality.

If that WARN_ON_ONCE() breaks things, I'd like it to be bisected to another patch other than this one.

Works for me.

+1

So, with the updated commit message:

Best Regards,
Petr

author maintainer
#15 lore raw

Re: [PATCH 6/9] livepatch/ftrace: Add recursion protection to the ftrace callback

In reply to Steven Rostedt
Quoted 2 lines · On Thu, 29 Oct 2020 10:37:44 -0400 Steven Rostedt <[email protected]> wrote:

I also plan on adding code that reports when recursion has happened, because even if it's not a problem, recursion adds extra overhead.

I did the above (will be posting that later, maybe next week), and found two bugs with the recursion code. :-/

One was in the nmi handling, where it never cleared the nmi bit (because it was zero, and thus ignored), and that caused all functions in NMI handlers to not be traced (because it thought it was a recursion).
(see https://lore.kernel.org/r/[email protected])

The second was the recursion algorithm depends on the preempt_count() being accurate, but when it transitions between context, and there's tracing in that transition, it could falsely record it as a recursion.

I have a fix for both of these bugs and will be sending them up marked for stable after I finish testing them.

This goes to show that the recursion reported should be implemented (but that will be for the next merge window).

-- Steve

author maintainer
#3 lore raw

Re: [PATCH 1/9] ftrace: Move the recursion testing into global headers

In reply to Miroslav Benes
Quoted 6 lines · On Fri, 30 Oct 2020 10:13:50 +0100 (CET) Miroslav Benes <[email protected]> wrote:

how does this work in case of NMI? trace_get_context_bit() returns 0 (it does not change later in the patch set). "start" in trace_test_and_set_recursion() is 0 zero too as used later in the patch set by ftrace_test_recursion_trylock(). So trace_test_and_set_recursion() returns 0. That is perfectly sane, but then...

Quoted 8 lines

include/linux/trace_recursion.h line 157

Quoted 6 lines
include/linux/trace_recursion.h new file +6 -0
+static __always_inline void trace_clear_recursion(int bit)
+{
+	unsigned int val = current->trace_recursion;
+
+	if (!bit)
+		return;  

... the bit is not cleared here.

Yeah, I found that and fixed it yesterday, which discovered stack overflow in perf:

https://lore.kernel.org/r/[email protected]

There's another bug that causes a false positive during interrupt context transition. I have a fix for that too.

-- Steve

maintainer
#11 lore raw

Re: [PATCH 5/9] kprobes/ftrace: Add recursion protection to the ftrace callback

In reply to Steven Rostedt
Quoted 39 lines · On Thu, 29 Oct 2020 09:40:01 -0400 Steven Rostedt <[email protected]> wrote:
Quoted 12 lines · On Thu, 29 Oct 2020 16:58:03 +0900 Masami Hiramatsu <[email protected]> wrote:

Hi Steve,

Quoted 6 lines · On Wed, 28 Oct 2020 07:52:49 -0400 Steven Rostedt <[email protected]> wrote:

From: "Steven Rostedt (VMware)" <[email protected]>

If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.

Quoted 8 lines

So in that case the handlers will be called without preempt disabled?

Quoted 2 lines

The default for ftrace_ops is going to assume recursion protection unless otherwise specified.

This seems to skip entier handler if ftrace finds recursion. I would like to increment the missed counter even in that case.

Note, this code does not change the functionality at this point, because without having the FL_RECURSION flag set (which kprobes does not even in this patch), it always gets called from the helper function that does this:

	bit = trace_test_and_set_recursion(TRACE_LIST_START, TRACE_LIST_MAX);
	if (bit < 0)
		return;

	preempt_disable_notrace();

	op->func(ip, parent_ip, op, regs);

	preempt_enable_notrace();
	trace_clear_recursion(bit);
Quoted 4 lines

Where this function gets called by op->func().

In other words, you don't get that count anyway, and I don't think you want it. Because it means you traced something that your callback calls.

Got it. So nmissed count increment will be an improvement.

Quoted 5 lines

That bit check is basically a nop, because the last patch in this series will make the default that everything has recursion protection, but at this patch the test does this:

Quoted 7 lines
	/* A previous recursion check was made */
	if ((val & TRACE_CONTEXT_MASK) > max)
		return 0;

Which would always return true, because this function is called via the helper that already did the trace_test_and_set_recursion() which, if it made it this far, the val would always be greater than max.

OK, let me check the last patch too.

Quoted 37 lines
Quoted 21 lines

[...]
e.g.

Quoted 15 lines
arch/csky/kernel/probes/ftrace.c +2 -1
index 5264763d05be..5eb2604fdf71 100644
@@ -13,16 +13,21 @@ int arch_check_ftrace_location(struct kprobe *p)
 void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 			   struct ftrace_ops *ops, struct pt_regs *regs)
 {
+	int bit;
 	bool lr_saver = false;
 	struct kprobe *p;
 	struct kprobe_ctlblk *kcb;
 
-	/* Preempt is disabled by ftrace */
+	bit = ftrace_test_recursion_trylock();  
Quoted 15 lines

arch/csky/kernel/probes/ftrace.c int arch_check_ftrace_location(struct kprobe *p) · line 32

Quoted 10 lines
arch/csky/kernel/probes/ftrace.c +3 -1
+
+	preempt_disable_notrace();
 	p = get_kprobe((kprobe_opcode_t *)ip);
 	if (!p) {
 		p = get_kprobe((kprobe_opcode_t *)(ip - MCOUNT_INSN_SIZE));
 		if (unlikely(!p) || kprobe_disabled(p))
-			return;
+			goto out;
 		lr_saver = true;
 	}  
	if (bit < 0) {
		kprobes_inc_nmissed_count(p);
		goto out;
	}
Quoted 3 lines

If anything called in get_kprobe() or kprobes_inc_nmissed_count() gets traced here, you have zero recursion protection, and this will crash the machine with a likely reboot (triple fault).

Oops, ok, those can be traced.

Quoted 5 lines

Note, the recursion handles interrupts and wont stop them. bit < 0 only happens if you recurse because this function called something that ends up calling itself. Really, why would you care about missing a kprobe on the same kprobe?

Usually, sw-breakpoint based kprobes will count that case. Moreover, kprobes shares one ftrace_ops among all kprobes. I guess in that case any kprobes in kprobes (e.g. recursive call inside kprobe pre_handlers) will be skipped by ftrace_test_recursion_trylock(), is that correct?

Thank you,

Quoted 2 lines

-- Steve

Signature · 1 line
Masami Hiramatsu <[email protected]>