hw-breakpoints: Rewrite the hw-breakpoints layer on top of perf events

This patch rebase the implementation of the breakpoints API on top of
perf events instances.

Each breakpoints are now perf events that handle the
register scheduling, thread/cpu attachment, etc..

The new layering is now made as follows:

       ptrace       kgdb      ftrace   perf syscall
          \          |          /         /
           \         |         /         /
                                        /
            Core breakpoint API        /
                                      /
                     |               /
                     |              /

              Breakpoints perf events

                     |
                     |

               Breakpoints PMU ---- Debug Register constraints handling
                                    (Part of core breakpoint API)
                     |
                     |

             Hardware debug registers

Reasons of this rewrite:

- Use the centralized/optimized pmu registers scheduling,
  implying an easier arch integration
- More powerful register handling: perf attributes (pinned/flexible
  events, exclusive/non-exclusive, tunable period, etc...)

Impact:

- New perf ABI: the hardware breakpoints counters
- Ptrace breakpoints setting remains tricky and still needs some per
  thread breakpoints references.

Todo (in the order):

- Support breakpoints perf counter events for perf tools (ie: implement
  perf_bpcounter_event())
- Support from perf tools

Changes in v2:

- Follow the perf "event " rename
- The ptrace regression have been fixed (ptrace breakpoint perf events
  weren't released when a task ended)
- Drop the struct hw_breakpoint and store generic fields in
  perf_event_attr.
- Separate core and arch specific headers, drop
  asm-generic/hw_breakpoint.h and create linux/hw_breakpoint.h
- Use new generic len/type for breakpoint
- Handle off case: when breakpoints api is not supported by an arch

Changes in v3:

- Fix broken CONFIG_KVM, we need to propagate the breakpoint api
  changes to kvm when we exit the guest and restore the bp registers
  to the host.

Changes in v4:

- Drop the hw_breakpoint_restore() stub as it is only used by KVM
- EXPORT_SYMBOL_GPL hw_breakpoint_restore() as KVM can be built as a
  module
- Restore the breakpoints unconditionally on kvm guest exit:
  TIF_DEBUG_THREAD doesn't anymore cover every cases of running
  breakpoints and vcpu->arch.switch_db_regs might not always be
  set when the guest used debug registers.
  (Waiting for a reliable optimization)

Changes in v5:

- Split-up the asm-generic/hw-breakpoint.h moving to
  linux/hw_breakpoint.h into a separate patch
- Optimize the breakpoints restoring while switching from kvm guest
  to host. We only want to restore the state if we have active
  breakpoints to the host, otherwise we don't care about messed-up
  address registers.
- Add asm/hw_breakpoint.h to Kbuild
- Fix bad breakpoint type in trace_selftest.c

Changes in v6:

- Fix wrong header inclusion in trace.h (triggered a build
  error with CONFIG_FTRACE_SELFTEST

Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Prasad <prasad@linux.vnet.ibm.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Jan Kiszka <jan.kiszka@web.de>
Cc: Jiri Slaby <jirislaby@gmail.com>
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Avi Kivity <avi@redhat.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Masami Hiramatsu <mhiramat@redhat.com>
Cc: Paul Mundt <lethal@linux-sh.org>

1 files changed, 170 insertions, 254 deletions

diff --git a/kernel/hw_breakpoint.c b/kernel/hw_breakpoint.c
index c1f64e65a9f3..08f6d0163201 100644
--- a/kernel/hw_breakpoint.c
+++ b/kernel/hw_breakpoint.c
@@ -15,6 +15,7 @@
  *
  * Copyright (C) 2007 Alan Stern
  * Copyright (C) IBM Corporation, 2009
+ * Copyright (C) 2009, Frederic Weisbecker <fweisbec@gmail.com>
  */
 
 /*
@@ -35,334 +36,242 @@
 #include <linux/init.h>
 #include <linux/smp.h>
 
-#include <asm/hw_breakpoint.h>
+#include <linux/hw_breakpoint.h>
+
 #include <asm/processor.h>
 
 #ifdef CONFIG_X86
 #include <asm/debugreg.h>
 #endif
-/*
- * Spinlock that protects all (un)register operations over kernel/user-space
- * breakpoint requests
- */
-static DEFINE_SPINLOCK(hw_breakpoint_lock);
-
-/* Array of kernel-space breakpoint structures */
-struct hw_breakpoint *hbp_kernel[HBP_NUM];
-
-/*
- * Per-processor copy of hbp_kernel[]. Used only when hbp_kernel is being
- * modified but we need the older copy to handle any hbp exceptions. It will
- * sync with hbp_kernel[] value after updation is done through IPIs.
- */
-DEFINE_PER_CPU(struct hw_breakpoint*, this_hbp_kernel[HBP_NUM]);
-
-/*
- * Kernel breakpoints grow downwards, starting from HBP_NUM
- * 'hbp_kernel_pos' denotes lowest numbered breakpoint register occupied for
- * kernel-space request. We will initialise it here and not in an __init
- * routine because load_debug_registers(), which uses this variable can be
- * called very early during CPU initialisation.
- */
-unsigned int hbp_kernel_pos = HBP_NUM;
 
-/*
- * An array containing refcount of threads using a given bkpt register
- * Accesses are synchronised by acquiring hw_breakpoint_lock
- */
-unsigned int hbp_user_refcount[HBP_NUM];
+static atomic_t bp_slot;
 
-/*
- * Load the debug registers during startup of a CPU.
- */
-void load_debug_registers(void)
+int reserve_bp_slot(struct perf_event *bp)
 {
-        unsigned long flags;
-        struct task_struct *tsk = current;
-
-        spin_lock_bh(&hw_breakpoint_lock);
-
-        /* Prevent IPIs for new kernel breakpoint updates */
-        local_irq_save(flags);
-        arch_update_kernel_hw_breakpoint(NULL);
-        local_irq_restore(flags);
-
-        if (test_tsk_thread_flag(tsk, TIF_DEBUG))
-                arch_install_thread_hw_breakpoint(tsk);
-
-        spin_unlock_bh(&hw_breakpoint_lock);
-}
+        if (atomic_inc_return(&bp_slot) == HBP_NUM) {
+                atomic_dec(&bp_slot);
 
-/*
- * Erase all the hardware breakpoint info associated with a thread.
- *
- * If tsk != current then tsk must not be usable (for example, a
- * child being cleaned up from a failed fork).
- */
-void flush_thread_hw_breakpoint(struct task_struct *tsk)
-{
-        int i;
-        struct thread_struct *thread = &(tsk->thread);
-
-        spin_lock_bh(&hw_breakpoint_lock);
-
-        /* The thread no longer has any breakpoints associated with it */
-        clear_tsk_thread_flag(tsk, TIF_DEBUG);
-        for (i = 0; i < HBP_NUM; i++) {
-                if (thread->hbp[i]) {
-                        hbp_user_refcount[i]--;
-                        kfree(thread->hbp[i]);
-                        thread->hbp[i] = NULL;
-                }
+                return -ENOSPC;
         }
 
-        arch_flush_thread_hw_breakpoint(tsk);
-
-        /* Actually uninstall the breakpoints if necessary */
-        if (tsk == current)
-                arch_uninstall_thread_hw_breakpoint();
-        spin_unlock_bh(&hw_breakpoint_lock);
+        return 0;
 }
 
-/*
- * Copy the hardware breakpoint info from a thread to its cloned child.
- */
-int copy_thread_hw_breakpoint(struct task_struct *tsk,
-                struct task_struct *child, unsigned long clone_flags)
+void release_bp_slot(struct perf_event *bp)
 {
-        /*
-         * We will assume that breakpoint settings are not inherited
-         * and the child starts out with no debug registers set.
-         * But what about CLONE_PTRACE?
-         */
-        clear_tsk_thread_flag(child, TIF_DEBUG);
-
-        /* We will call flush routine since the debugregs are not inherited */
-        arch_flush_thread_hw_breakpoint(child);
-
-        return 0;
+        atomic_dec(&bp_slot);
 }
 
-static int __register_user_hw_breakpoint(int pos, struct task_struct *tsk,
-                                        struct hw_breakpoint *bp)
+int __register_perf_hw_breakpoint(struct perf_event *bp)
 {
-        struct thread_struct *thread = &(tsk->thread);
-        int rc;
+        int ret;
 
-        /* Do not overcommit. Fail if kernel has used the hbp registers */
-        if (pos >= hbp_kernel_pos)
-                return -ENOSPC;
+        ret = reserve_bp_slot(bp);
+        if (ret)
+                return ret;
 
-        rc = arch_validate_hwbkpt_settings(bp, tsk);
-        if (rc)
-                return rc;
+        if (!bp->attr.disabled)
+                ret = arch_validate_hwbkpt_settings(bp, bp->ctx->task);
 
-        thread->hbp[pos] = bp;
-        hbp_user_refcount[pos]++;
+        return ret;
+}
 
-        arch_update_user_hw_breakpoint(pos, tsk);
-        /*
-         * Does it need to be installed right now?
-         * Otherwise it will get installed the next time tsk runs
-         */
-        if (tsk == current)
-                arch_install_thread_hw_breakpoint(tsk);
+int register_perf_hw_breakpoint(struct perf_event *bp)
+{
+        bp->callback = perf_bp_event;
 
-        return rc;
+        return __register_perf_hw_breakpoint(bp);
 }
 
 /*
- * Modify the address of a hbp register already in use by the task
- * Do not invoke this in-lieu of a __unregister_user_hw_breakpoint()
+ * Register a breakpoint bound to a task and a given cpu.
+ * If cpu is -1, the breakpoint is active for the task in every cpu
+ * If the task is -1, the breakpoint is active for every tasks in the given
+ * cpu.
  */
-static int __modify_user_hw_breakpoint(int pos, struct task_struct *tsk,
-                                        struct hw_breakpoint *bp)
+static struct perf_event *
+register_user_hw_breakpoint_cpu(unsigned long addr,
+                                int len,
+                                int type,
+                                perf_callback_t triggered,
+                                pid_t pid,
+                                int cpu,
+                                bool active)
 {
-        struct thread_struct *thread = &(tsk->thread);
-
-        if ((pos >= hbp_kernel_pos) || (arch_validate_hwbkpt_settings(bp, tsk)))
-                return -EINVAL;
-
-        if (thread->hbp[pos] == NULL)
-                return -EINVAL;
-
-        thread->hbp[pos] = bp;
+        struct perf_event_attr *attr;
+        struct perf_event *bp;
+
+        attr = kzalloc(sizeof(*attr), GFP_KERNEL);
+        if (!attr)
+                return ERR_PTR(-ENOMEM);
+
+        attr->type = PERF_TYPE_BREAKPOINT;
+        attr->size = sizeof(*attr);
+        attr->bp_addr = addr;
+        attr->bp_len = len;
+        attr->bp_type = type;
         /*
-         * 'pos' must be that of a hbp register already used by 'tsk'
-         * Otherwise arch_modify_user_hw_breakpoint() will fail
+         * Such breakpoints are used by debuggers to trigger signals when
+         * we hit the excepted memory op. We can't miss such events, they
+         * must be pinned.
          */
-        arch_update_user_hw_breakpoint(pos, tsk);
+        attr->pinned = 1;
 
-        if (tsk == current)
-                arch_install_thread_hw_breakpoint(tsk);
+        if (!active)
+                attr->disabled = 1;
 
-        return 0;
-}
-
-static void __unregister_user_hw_breakpoint(int pos, struct task_struct *tsk)
-{
-        hbp_user_refcount[pos]--;
-        tsk->thread.hbp[pos] = NULL;
+        bp = perf_event_create_kernel_counter(attr, cpu, pid, triggered);
+        kfree(attr);
 
-        arch_update_user_hw_breakpoint(pos, tsk);
-
-        if (tsk == current)
-                arch_install_thread_hw_breakpoint(tsk);
+        return bp;
 }
 
 /**
  * register_user_hw_breakpoint - register a hardware breakpoint for user space
+ * @addr: is the memory address that triggers the breakpoint
+ * @len: the length of the access to the memory (1 byte, 2 bytes etc...)
+ * @type: the type of the access to the memory (read/write/exec)
+ * @triggered: callback to trigger when we hit the breakpoint
  * @tsk: pointer to 'task_struct' of the process to which the address belongs
- * @bp: the breakpoint structure to register
- *
- * @bp.info->name or @bp.info->address, @bp.info->len, @bp.info->type and
- * @bp->triggered must be set properly before invocation
+ * @active: should we activate it while registering it
  *
  */
-int register_user_hw_breakpoint(struct task_struct *tsk,
-                                        struct hw_breakpoint *bp)
+struct perf_event *
+register_user_hw_breakpoint(unsigned long addr,
+                            int len,
+                            int type,
+                            perf_callback_t triggered,
+                            struct task_struct *tsk,
+                            bool active)
 {
-        struct thread_struct *thread = &(tsk->thread);
-        int i, rc = -ENOSPC;
-
-        spin_lock_bh(&hw_breakpoint_lock);
-
-        for (i = 0; i < hbp_kernel_pos; i++) {
-                if (!thread->hbp[i]) {
-                        rc = __register_user_hw_breakpoint(i, tsk, bp);
-                        break;
-                }
-        }
-        if (!rc)
-                set_tsk_thread_flag(tsk, TIF_DEBUG);
-
-        spin_unlock_bh(&hw_breakpoint_lock);
-        return rc;
+        return register_user_hw_breakpoint_cpu(addr, len, type, triggered,
+                                               tsk->pid, -1, active);
 }
 EXPORT_SYMBOL_GPL(register_user_hw_breakpoint);
 
 /**
  * modify_user_hw_breakpoint - modify a user-space hardware breakpoint
+ * @bp: the breakpoint structure to modify
+ * @addr: is the memory address that triggers the breakpoint
+ * @len: the length of the access to the memory (1 byte, 2 bytes etc...)
+ * @type: the type of the access to the memory (read/write/exec)
+ * @triggered: callback to trigger when we hit the breakpoint
  * @tsk: pointer to 'task_struct' of the process to which the address belongs
- * @bp: the breakpoint structure to unregister
- *
+ * @active: should we activate it while registering it
  */
-int modify_user_hw_breakpoint(struct task_struct *tsk, struct hw_breakpoint *bp)
+struct perf_event *
+modify_user_hw_breakpoint(struct perf_event *bp,
+                          unsigned long addr,
+                          int len,
+                          int type,
+                          perf_callback_t triggered,
+                          struct task_struct *tsk,
+                          bool active)
 {
-        struct thread_struct *thread = &(tsk->thread);
-        int i, ret = -ENOENT;
+        /*
+         * FIXME: do it without unregistering
+         * - We don't want to lose our slot
+         * - If the new bp is incorrect, don't lose the older one
+         */
+        unregister_hw_breakpoint(bp);
 
-        spin_lock_bh(&hw_breakpoint_lock);
-        for (i = 0; i < hbp_kernel_pos; i++) {
-                if (bp == thread->hbp[i]) {
-                        ret = __modify_user_hw_breakpoint(i, tsk, bp);
-                        break;
-                }
-        }
-        spin_unlock_bh(&hw_breakpoint_lock);
-        return ret;
+        return register_user_hw_breakpoint(addr, len, type, triggered,
+                                           tsk, active);
 }
 EXPORT_SYMBOL_GPL(modify_user_hw_breakpoint);
 
 /**
- * unregister_user_hw_breakpoint - unregister a user-space hardware breakpoint
- * @tsk: pointer to 'task_struct' of the process to which the address belongs
+ * unregister_hw_breakpoint - unregister a user-space hardware breakpoint
  * @bp: the breakpoint structure to unregister
- *
  */
-void unregister_user_hw_breakpoint(struct task_struct *tsk,
-                                                struct hw_breakpoint *bp)
+void unregister_hw_breakpoint(struct perf_event *bp)
 {
-        struct thread_struct *thread = &(tsk->thread);
-        int i, pos = -1, hbp_counter = 0;
-
-        spin_lock_bh(&hw_breakpoint_lock);
-        for (i = 0; i < hbp_kernel_pos; i++) {
-                if (thread->hbp[i])
-                        hbp_counter++;
-                if (bp == thread->hbp[i])
-                        pos = i;
-        }
-        if (pos >= 0) {
-                __unregister_user_hw_breakpoint(pos, tsk);
-                hbp_counter--;
-        }
-        if (!hbp_counter)
-                clear_tsk_thread_flag(tsk, TIF_DEBUG);
-
-        spin_unlock_bh(&hw_breakpoint_lock);
+        if (!bp)
+                return;
+        perf_event_release_kernel(bp);
+}
+EXPORT_SYMBOL_GPL(unregister_hw_breakpoint);
+
+static struct perf_event *
+register_kernel_hw_breakpoint_cpu(unsigned long addr,
+                                  int len,
+                                  int type,
+                                  perf_callback_t triggered,
+                                  int cpu,
+                                  bool active)
+{
+        return register_user_hw_breakpoint_cpu(addr, len, type, triggered,
+                                               -1, cpu, active);
 }
-EXPORT_SYMBOL_GPL(unregister_user_hw_breakpoint);
 
 /**
- * register_kernel_hw_breakpoint - register a hardware breakpoint for kernel space
- * @bp: the breakpoint structure to register
- *
- * @bp.info->name or @bp.info->address, @bp.info->len, @bp.info->type and
- * @bp->triggered must be set properly before invocation
+ * register_wide_hw_breakpoint - register a wide breakpoint in the kernel
+ * @addr: is the memory address that triggers the breakpoint
+ * @len: the length of the access to the memory (1 byte, 2 bytes etc...)
+ * @type: the type of the access to the memory (read/write/exec)
+ * @triggered: callback to trigger when we hit the breakpoint
+ * @active: should we activate it while registering it
  *
+ * @return a set of per_cpu pointers to perf events
  */
-int register_kernel_hw_breakpoint(struct hw_breakpoint *bp)
+struct perf_event **
+register_wide_hw_breakpoint(unsigned long addr,
+                            int len,
+                            int type,
+                            perf_callback_t triggered,
+                            bool active)
 {
-        int rc;
+        struct perf_event **cpu_events, **pevent, *bp;
+        long err;
+        int cpu;
+
+        cpu_events = alloc_percpu(typeof(*cpu_events));
+        if (!cpu_events)
+                return ERR_PTR(-ENOMEM);
 
-        rc = arch_validate_hwbkpt_settings(bp, NULL);
-        if (rc)
-                return rc;
+        for_each_possible_cpu(cpu) {
+                pevent = per_cpu_ptr(cpu_events, cpu);
+                bp = register_kernel_hw_breakpoint_cpu(addr, len, type,
+                                        triggered, cpu, active);
 
-        spin_lock_bh(&hw_breakpoint_lock);
+                *pevent = bp;
 
-        rc = -ENOSPC;
-        /* Check if we are over-committing */
-        if ((hbp_kernel_pos > 0) && (!hbp_user_refcount[hbp_kernel_pos-1])) {
-                hbp_kernel_pos--;
-                hbp_kernel[hbp_kernel_pos] = bp;
-                on_each_cpu(arch_update_kernel_hw_breakpoint, NULL, 1);
-                rc = 0;
+                if (IS_ERR(bp) || !bp) {
+                        err = PTR_ERR(bp);
+                        goto fail;
+                }
         }
 
-        spin_unlock_bh(&hw_breakpoint_lock);
-        return rc;
+        return cpu_events;
+
+fail:
+        for_each_possible_cpu(cpu) {
+                pevent = per_cpu_ptr(cpu_events, cpu);
+                if (IS_ERR(*pevent) || !*pevent)
+                        break;
+                unregister_hw_breakpoint(*pevent);
+        }
+        free_percpu(cpu_events);
+        /* return the error if any */
+        return ERR_PTR(err);
 }
-EXPORT_SYMBOL_GPL(register_kernel_hw_breakpoint);
 
 /**
- * unregister_kernel_hw_breakpoint - unregister a HW breakpoint for kernel space
- * @bp: the breakpoint structure to unregister
- *
- * Uninstalls and unregisters @bp.
+ * unregister_wide_hw_breakpoint - unregister a wide breakpoint in the kernel
+ * @cpu_events: the per cpu set of events to unregister
  */
-void unregister_kernel_hw_breakpoint(struct hw_breakpoint *bp)
+void unregister_wide_hw_breakpoint(struct perf_event **cpu_events)
 {
-        int i, j;
-
-        spin_lock_bh(&hw_breakpoint_lock);
-
-        /* Find the 'bp' in our list of breakpoints for kernel */
-        for (i = hbp_kernel_pos; i < HBP_NUM; i++)
-                if (bp == hbp_kernel[i])
-                        break;
+        int cpu;
+        struct perf_event **pevent;
 
-        /* Check if we did not find a match for 'bp'. If so return early */
-        if (i == HBP_NUM) {
-                spin_unlock_bh(&hw_breakpoint_lock);
-                return;
+        for_each_possible_cpu(cpu) {
+                pevent = per_cpu_ptr(cpu_events, cpu);
+                unregister_hw_breakpoint(*pevent);
         }
-
-        /*
-         * We'll shift the breakpoints one-level above to compact if
-         * unregistration creates a hole
-         */
-        for (j = i; j > hbp_kernel_pos; j--)
-                hbp_kernel[j] = hbp_kernel[j-1];
-
-        hbp_kernel[hbp_kernel_pos] = NULL;
-        on_each_cpu(arch_update_kernel_hw_breakpoint, NULL, 1);
-        hbp_kernel_pos++;
-
-        spin_unlock_bh(&hw_breakpoint_lock);
+        free_percpu(cpu_events);
 }
-EXPORT_SYMBOL_GPL(unregister_kernel_hw_breakpoint);
+
 
 static struct notifier_block hw_breakpoint_exceptions_nb = {
         .notifier_call = hw_breakpoint_exceptions_notify,
@@ -374,5 +283,12 @@ static int __init init_hw_breakpoint(void)
 {
         return register_die_notifier(&hw_breakpoint_exceptions_nb);
 }
-
 core_initcall(init_hw_breakpoint);
+
+
+struct pmu perf_ops_bp = {
+        .enable         = arch_install_hw_breakpoint,
+        .disable        = arch_uninstall_hw_breakpoint,
+        .read           = hw_breakpoint_pmu_read,
+        .unthrottle     = hw_breakpoint_pmu_unthrottle
+};