hw_breakpoint: fix single-stepping when using bpf_overflow_handler

[ Upstream commit d11a69873d9a7435fe6a48531e165ab80a8b1221 ]

Arm platforms use is_default_overflow_handler() to determine if the
hw_breakpoint code should single-step over the breakpoint trigger or
let the custom handler deal with it.

Since bpf_overflow_handler() currently isn't recognized as a default
handler, attaching a BPF program to a PERF_TYPE_BREAKPOINT event causes
it to keep firing (the instruction triggering the data abort exception
is never skipped). For example:

  # bpftrace -e 'watchpoint:0x10000:4:w { print("hit") }' -c ./test
  Attaching 1 probe...
  hit
  hit
  [...]
  ^C

(./test performs a single 4-byte store to 0x10000)

This patch replaces the check with uses_default_overflow_handler(),
which accounts for the bpf_overflow_handler() case by also testing
if one of the perf_event_output functions gets invoked indirectly,
via orig_default_handler.

Signed-off-by: Tomislav Novak <tnovak@meta.com>
Tested-by: Samuel Gosselin <sgosselin@google.com> # arm64
Reviewed-by: Catalin Marinas <catalin.marinas@arm.com>
Acked-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/linux-arm-kernel/20220923203644.2731604-1-tnovak@fb.com/
Link: https://lore.kernel.org/r/20230605191923.1219974-1-tnovak@meta.com
Signed-off-by: Will Deacon <will@kernel.org>
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/arch/arm/kernel/hw_breakpoint.c b/arch/arm/kernel/hw_breakpoint.c
index 054e9199f30db654e3fba1116b48ccf9ae7bafb6..dc0fb7a8137150d945aa83feae12e17569800694 100644 (file)
--- a/arch/arm/kernel/hw_breakpoint.c
+++ b/arch/arm/kernel/hw_breakpoint.c
@@ -626,7 +626,7 @@ int hw_breakpoint_arch_parse(struct perf_event *bp,
        hw->address &= ~alignment_mask;
        hw->ctrl.len <<= offset;
 
-       if (is_default_overflow_handler(bp)) {
+       if (uses_default_overflow_handler(bp)) {
                /*
                 * Mismatch breakpoints are required for single-stepping
                 * breakpoints.
@@ -798,7 +798,7 @@ static void watchpoint_handler(unsigned long addr, unsigned int fsr,
                 * Otherwise, insert a temporary mismatch breakpoint so that
                 * we can single-step over the watchpoint trigger.
                 */
-               if (!is_default_overflow_handler(wp))
+               if (!uses_default_overflow_handler(wp))
                        continue;
 step:
                enable_single_step(wp, instruction_pointer(regs));
@@ -811,7 +811,7 @@ step:
                info->trigger = addr;
                pr_debug("watchpoint fired: address = 0x%x\n", info->trigger);
                perf_bp_event(wp, regs);
-               if (is_default_overflow_handler(wp))
+               if (uses_default_overflow_handler(wp))
                        enable_single_step(wp, instruction_pointer(regs));
        }
 
@@ -886,7 +886,7 @@ static void breakpoint_handler(unsigned long unknown, struct pt_regs *regs)
                        info->trigger = addr;
                        pr_debug("breakpoint fired: address = 0x%x\n", addr);
                        perf_bp_event(bp, regs);
-                       if (is_default_overflow_handler(bp))
+                       if (uses_default_overflow_handler(bp))
                                enable_single_step(bp, addr);
                        goto unlock;
                }

diff --git a/arch/arm64/kernel/hw_breakpoint.c b/arch/arm64/kernel/hw_breakpoint.c
index b29a311bb055216aa4ab111cf10c322e4042c923..9659a9555c63a356566c22cab4f9d124803523b0 100644 (file)
--- a/arch/arm64/kernel/hw_breakpoint.c
+++ b/arch/arm64/kernel/hw_breakpoint.c
@@ -654,7 +654,7 @@ static int breakpoint_handler(unsigned long unused, unsigned long esr,
                perf_bp_event(bp, regs);
 
                /* Do we need to handle the stepping? */
-               if (is_default_overflow_handler(bp))
+               if (uses_default_overflow_handler(bp))
                        step = 1;
 unlock:
                rcu_read_unlock();
@@ -733,7 +733,7 @@ static u64 get_distance_from_watchpoint(unsigned long addr, u64 val,
 static int watchpoint_report(struct perf_event *wp, unsigned long addr,
                             struct pt_regs *regs)
 {
-       int step = is_default_overflow_handler(wp);
+       int step = uses_default_overflow_handler(wp);
        struct arch_hw_breakpoint *info = counter_arch_bp(wp);
 
        info->trigger = addr;

diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index 0031f7b4d9aba0407f98da14c6b0ee70176a4a9c..63fae3c7ae430d1eb1fca9d9ba1c621ecfc755c0 100644 (file)
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -1139,15 +1139,31 @@ extern int perf_event_output(struct perf_event *event,
                             struct pt_regs *regs);
 
 static inline bool
-is_default_overflow_handler(struct perf_event *event)
+__is_default_overflow_handler(perf_overflow_handler_t overflow_handler)
 {
-       if (likely(event->overflow_handler == perf_event_output_forward))
+       if (likely(overflow_handler == perf_event_output_forward))
                return true;
-       if (unlikely(event->overflow_handler == perf_event_output_backward))
+       if (unlikely(overflow_handler == perf_event_output_backward))
                return true;
        return false;
 }
 
+#define is_default_overflow_handler(event) \
+       __is_default_overflow_handler((event)->overflow_handler)
+
+#ifdef CONFIG_BPF_SYSCALL
+static inline bool uses_default_overflow_handler(struct perf_event *event)
+{
+       if (likely(is_default_overflow_handler(event)))
+               return true;
+
+       return __is_default_overflow_handler(event->orig_overflow_handler);
+}
+#else
+#define uses_default_overflow_handler(event) \
+       is_default_overflow_handler(event)
+#endif
+
 extern void
 perf_event_header__init_id(struct perf_event_header *header,
                           struct perf_sample_data *data,