perf, hw_breakpoint, kgdb: Do not take mutex for kernel debugger
authorJason Wessel <jason.wessel@windriver.com>
Thu, 28 Jan 2010 23:04:43 +0000 (17:04 -0600)
committerIngo Molnar <mingo@elte.hu>
Sat, 30 Jan 2010 07:42:21 +0000 (08:42 +0100)
This patch fixes the regression in functionality where the
kernel debugger and the perf API do not nicely share hw
breakpoint reservations.

The kernel debugger cannot use any mutex_lock() calls because it
can start the kernel running from an invalid context.

A mutex free version of the reservation API needed to get
created for the kernel debugger to safely update hw breakpoint
reservations.

The possibility for a breakpoint reservation to be concurrently
processed at the time that kgdb interrupts the system is
improbable. Should this corner case occur the end user is
warned, and the kernel debugger will prohibit updating the
hardware breakpoint reservations.

Any time the kernel debugger reserves a hardware breakpoint it
will be a system wide reservation.

Signed-off-by: Jason Wessel <jason.wessel@windriver.com>
Acked-by: Frederic Weisbecker <fweisbec@gmail.com>
Cc: kgdb-bugreport@lists.sourceforge.net
Cc: K.Prasad <prasad@linux.vnet.ibm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: torvalds@linux-foundation.org
LKML-Reference: <1264719883-7285-3-git-send-email-jason.wessel@windriver.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
arch/x86/kernel/kgdb.c
include/linux/hw_breakpoint.h
kernel/hw_breakpoint.c

index 62bea7307eaad9ba3b6d4774e0af7fd6fa92b547..bfba6019d762aa6652e58b3b09681a83b2e74525 100644 (file)
@@ -239,6 +239,49 @@ static void kgdb_correct_hw_break(void)
        hw_breakpoint_restore();
 }
 
+static int hw_break_reserve_slot(int breakno)
+{
+       int cpu;
+       int cnt = 0;
+       struct perf_event **pevent;
+
+       for_each_online_cpu(cpu) {
+               cnt++;
+               pevent = per_cpu_ptr(breakinfo[breakno].pev, cpu);
+               if (dbg_reserve_bp_slot(*pevent))
+                       goto fail;
+       }
+
+       return 0;
+
+fail:
+       for_each_online_cpu(cpu) {
+               cnt--;
+               if (!cnt)
+                       break;
+               pevent = per_cpu_ptr(breakinfo[breakno].pev, cpu);
+               dbg_release_bp_slot(*pevent);
+       }
+       return -1;
+}
+
+static int hw_break_release_slot(int breakno)
+{
+       struct perf_event **pevent;
+       int cpu;
+
+       for_each_online_cpu(cpu) {
+               pevent = per_cpu_ptr(breakinfo[breakno].pev, cpu);
+               if (dbg_release_bp_slot(*pevent))
+                       /*
+                        * The debugger is responisble for handing the retry on
+                        * remove failure.
+                        */
+                       return -1;
+       }
+       return 0;
+}
+
 static int
 kgdb_remove_hw_break(unsigned long addr, int len, enum kgdb_bptype bptype)
 {
@@ -250,6 +293,10 @@ kgdb_remove_hw_break(unsigned long addr, int len, enum kgdb_bptype bptype)
        if (i == 4)
                return -1;
 
+       if (hw_break_release_slot(i)) {
+               printk(KERN_ERR "Cannot remove hw breakpoint at %lx\n", addr);
+               return -1;
+       }
        breakinfo[i].enabled = 0;
 
        return 0;
@@ -316,6 +363,10 @@ kgdb_set_hw_break(unsigned long addr, int len, enum kgdb_bptype bptype)
                return -1;
        }
        breakinfo[i].addr = addr;
+       if (hw_break_reserve_slot(i)) {
+               breakinfo[i].addr = 0;
+               return -1;
+       }
        breakinfo[i].enabled = 1;
 
        return 0;
index 41235c93e4e95400bf0db52bf2f7b84399d22a39..070ba0621738d698523914f981eb2be15d092c95 100644 (file)
@@ -75,6 +75,8 @@ extern int __register_perf_hw_breakpoint(struct perf_event *bp);
 extern void unregister_hw_breakpoint(struct perf_event *bp);
 extern void unregister_wide_hw_breakpoint(struct perf_event **cpu_events);
 
+extern int dbg_reserve_bp_slot(struct perf_event *bp);
+extern int dbg_release_bp_slot(struct perf_event *bp);
 extern int reserve_bp_slot(struct perf_event *bp);
 extern void release_bp_slot(struct perf_event *bp);
 
index c030ae657f20f85d2665aa857794680c06c1dcd0..8a5c7d55ac9fab9bdbd97bb7701d92ed2b3fa310 100644 (file)
@@ -243,38 +243,70 @@ static void toggle_bp_slot(struct perf_event *bp, bool enable)
  *       ((per_cpu(nr_bp_flexible, *) > 1) + max(per_cpu(nr_cpu_bp_pinned, *))
  *            + max(per_cpu(nr_task_bp_pinned, *))) < HBP_NUM
  */
-int reserve_bp_slot(struct perf_event *bp)
+static int __reserve_bp_slot(struct perf_event *bp)
 {
        struct bp_busy_slots slots = {0};
-       int ret = 0;
-
-       mutex_lock(&nr_bp_mutex);
 
        fetch_bp_busy_slots(&slots, bp);
 
        /* Flexible counters need to keep at least one slot */
-       if (slots.pinned + (!!slots.flexible) == HBP_NUM) {
-               ret = -ENOSPC;
-               goto end;
-       }
+       if (slots.pinned + (!!slots.flexible) == HBP_NUM)
+               return -ENOSPC;
 
        toggle_bp_slot(bp, true);
 
-end:
+       return 0;
+}
+
+int reserve_bp_slot(struct perf_event *bp)
+{
+       int ret;
+
+       mutex_lock(&nr_bp_mutex);
+
+       ret = __reserve_bp_slot(bp);
+
        mutex_unlock(&nr_bp_mutex);
 
        return ret;
 }
 
+static void __release_bp_slot(struct perf_event *bp)
+{
+       toggle_bp_slot(bp, false);
+}
+
 void release_bp_slot(struct perf_event *bp)
 {
        mutex_lock(&nr_bp_mutex);
 
-       toggle_bp_slot(bp, false);
+       __release_bp_slot(bp);
 
        mutex_unlock(&nr_bp_mutex);
 }
 
+/*
+ * Allow the kernel debugger to reserve breakpoint slots without
+ * taking a lock using the dbg_* variant of for the reserve and
+ * release breakpoint slots.
+ */
+int dbg_reserve_bp_slot(struct perf_event *bp)
+{
+       if (mutex_is_locked(&nr_bp_mutex))
+               return -1;
+
+       return __reserve_bp_slot(bp);
+}
+
+int dbg_release_bp_slot(struct perf_event *bp)
+{
+       if (mutex_is_locked(&nr_bp_mutex))
+               return -1;
+
+       __release_bp_slot(bp);
+
+       return 0;
+}
 
 int register_perf_hw_breakpoint(struct perf_event *bp)
 {