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>

7 files changed, 293 insertions, 329 deletions

diff --git a/kernel/exit.c b/kernel/exit.c
index e61891f80123..266f8920628a 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -49,6 +49,7 @@
 #include <linux/init_task.h>
 #include <linux/perf_event.h>
 #include <trace/events/sched.h>
+#include <linux/hw_breakpoint.h>
 
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -980,6 +981,10 @@ NORET_TYPE void do_exit(long code)
         proc_exit_connector(tsk);
 
         /*
+         * FIXME: do that only when needed, using sched_exit tracepoint
+         */
+        flush_ptrace_hw_breakpoint(tsk);
+        /*
          * Flush inherited counters to the parent - before the parent
          * gets woken up by child-exit notifications.
          */
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
+};
diff --git a/kernel/perf_event.c b/kernel/perf_event.c
index 5087125e2a00..98dc56b2ebe4 100644
--- a/kernel/perf_event.c
+++ b/kernel/perf_event.c
@@ -29,6 +29,7 @@
 #include <linux/kernel_stat.h>
 #include <linux/perf_event.h>
 #include <linux/ftrace_event.h>
+#include <linux/hw_breakpoint.h>
 
 #include <asm/irq_regs.h>
 
@@ -4229,6 +4230,51 @@ static void perf_event_free_filter(struct perf_event *event)
 
 #endif /* CONFIG_EVENT_PROFILE */
 
+#ifdef CONFIG_HAVE_HW_BREAKPOINT
+static void bp_perf_event_destroy(struct perf_event *event)
+{
+        release_bp_slot(event);
+}
+
+static const struct pmu *bp_perf_event_init(struct perf_event *bp)
+{
+        int err;
+        /*
+         * The breakpoint is already filled if we haven't created the counter
+         * through perf syscall
+         * FIXME: manage to get trigerred to NULL if it comes from syscalls
+         */
+        if (!bp->callback)
+                err = register_perf_hw_breakpoint(bp);
+        else
+                err = __register_perf_hw_breakpoint(bp);
+        if (err)
+                return ERR_PTR(err);
+
+        bp->destroy = bp_perf_event_destroy;
+
+        return &perf_ops_bp;
+}
+
+void perf_bp_event(struct perf_event *bp, void *regs)
+{
+        /* TODO */
+}
+#else
+static void bp_perf_event_destroy(struct perf_event *event)
+{
+}
+
+static const struct pmu *bp_perf_event_init(struct perf_event *bp)
+{
+        return NULL;
+}
+
+void perf_bp_event(struct perf_event *bp, void *regs)
+{
+}
+#endif
+
 atomic_t perf_swevent_enabled[PERF_COUNT_SW_MAX];
 
 static void sw_perf_event_destroy(struct perf_event *event)
@@ -4375,6 +4421,11 @@ perf_event_alloc(struct perf_event_attr *attr,
                 pmu = tp_perf_event_init(event);
                 break;
 
+        case PERF_TYPE_BREAKPOINT:
+                pmu = bp_perf_event_init(event);
+                break;
+
+
         default:
                 break;
         }
@@ -4686,7 +4737,7 @@ perf_event_create_kernel_counter(struct perf_event_attr *attr, int cpu,
 
         ctx = find_get_context(pid, cpu);
         if (IS_ERR(ctx))
-                return NULL ;
+                return NULL;
 
         event = perf_event_alloc(attr, cpu, ctx, NULL,
                                      NULL, callback, GFP_KERNEL);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 91c3d0e9a5a1..d72f06ff263f 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -11,14 +11,11 @@
 #include <linux/ftrace.h>
 #include <trace/boot.h>
 #include <linux/kmemtrace.h>
+#include <linux/hw_breakpoint.h>
 
 #include <linux/trace_seq.h>
 #include <linux/ftrace_event.h>
 
-#ifdef CONFIG_KSYM_TRACER
-#include <asm/hw_breakpoint.h>
-#endif
-
 enum trace_type {
         __TRACE_FIRST_TYPE = 0,
 
diff --git a/kernel/trace/trace_entries.h b/kernel/trace/trace_entries.h
index e19747d4f860..c16a08f399df 100644
--- a/kernel/trace/trace_entries.h
+++ b/kernel/trace/trace_entries.h
@@ -372,11 +372,11 @@ FTRACE_ENTRY(ksym_trace, ksym_trace_entry,
         F_STRUCT(
                 __field(        unsigned long,  ip                        )
                 __field(        unsigned char,  type                      )
-                __array(        char         ,  ksym_name, KSYM_NAME_LEN  )
                 __array(        char         ,  cmd,       TASK_COMM_LEN  )
+                __field(        unsigned long,  addr                      )
         ),
 
-        F_printk("ip: %pF type: %d ksym_name: %s cmd: %s",
+        F_printk("ip: %pF type: %d ksym_name: %pS cmd: %s",
                 (void *)__entry->ip, (unsigned int)__entry->type,
-                __entry->ksym_name, __entry->cmd)
+                (void *)__entry->addr,  __entry->cmd)
 );
diff --git a/kernel/trace/trace_ksym.c b/kernel/trace/trace_ksym.c
index 6d5609c67378..fea83eeeef09 100644
--- a/kernel/trace/trace_ksym.c
+++ b/kernel/trace/trace_ksym.c
@@ -29,7 +29,11 @@
 #include "trace_stat.h"
 #include "trace.h"
 
-/* For now, let us restrict the no. of symbols traced simultaneously to number
+#include <linux/hw_breakpoint.h>
+#include <asm/hw_breakpoint.h>
+
+/*
+ * For now, let us restrict the no. of symbols traced simultaneously to number
  * of available hardware breakpoint registers.
  */
 #define KSYM_TRACER_MAX HBP_NUM
@@ -37,8 +41,10 @@
 #define KSYM_TRACER_OP_LEN 3 /* rw- */
 
 struct trace_ksym {
-        struct hw_breakpoint    *ksym_hbp;
+        struct perf_event       **ksym_hbp;
         unsigned long           ksym_addr;
+        int                     type;
+        int                     len;
 #ifdef CONFIG_PROFILE_KSYM_TRACER
         unsigned long           counter;
 #endif
@@ -75,10 +81,11 @@ void ksym_collect_stats(unsigned long hbp_hit_addr)
 }
 #endif /* CONFIG_PROFILE_KSYM_TRACER */
 
-void ksym_hbp_handler(struct hw_breakpoint *hbp, struct pt_regs *regs)
+void ksym_hbp_handler(struct perf_event *hbp, void *data)
 {
         struct ring_buffer_event *event;
         struct ksym_trace_entry *entry;
+        struct pt_regs *regs = data;
         struct ring_buffer *buffer;
         int pc;
 
@@ -96,12 +103,12 @@ void ksym_hbp_handler(struct hw_breakpoint *hbp, struct pt_regs *regs)
 
         entry           = ring_buffer_event_data(event);
         entry->ip       = instruction_pointer(regs);
-        entry->type     = hbp->info.type;
-        strlcpy(entry->ksym_name, hbp->info.name, KSYM_SYMBOL_LEN);
+        entry->type     = hw_breakpoint_type(hbp);
+        entry->addr     = hw_breakpoint_addr(hbp);
         strlcpy(entry->cmd, current->comm, TASK_COMM_LEN);
 
 #ifdef CONFIG_PROFILE_KSYM_TRACER
-        ksym_collect_stats(hbp->info.address);
+        ksym_collect_stats(hw_breakpoint_addr(hbp));
 #endif /* CONFIG_PROFILE_KSYM_TRACER */
 
         trace_buffer_unlock_commit(buffer, event, 0, pc);
@@ -120,31 +127,21 @@ static int ksym_trace_get_access_type(char *str)
         int access = 0;
 
         if (str[0] == 'r')
-                access += 4;
-        else if (str[0] != '-')
-                return -EINVAL;
+                access |= HW_BREAKPOINT_R;
 
         if (str[1] == 'w')
-                access += 2;
-        else if (str[1] != '-')
-                return -EINVAL;
+                access |= HW_BREAKPOINT_W;
 
-        if (str[2] != '-')
-                return -EINVAL;
+        if (str[2] == 'x')
+                access |= HW_BREAKPOINT_X;
 
         switch (access) {
-        case 6:
-                access = HW_BREAKPOINT_RW;
-                break;
-        case 4:
-                access = -EINVAL;
-                break;
-        case 2:
-                access = HW_BREAKPOINT_WRITE;
-                break;
+        case HW_BREAKPOINT_W:
+        case HW_BREAKPOINT_W | HW_BREAKPOINT_R:
+                return access;
+        default:
+                return -EINVAL;
         }
-
-        return access;
 }
 
 /*
@@ -194,36 +191,33 @@ int process_new_ksym_entry(char *ksymname, int op, unsigned long addr)
         if (!entry)
                 return -ENOMEM;
 
-        entry->ksym_hbp = kzalloc(sizeof(struct hw_breakpoint), GFP_KERNEL);
-        if (!entry->ksym_hbp)
-                goto err;
-
-        entry->ksym_hbp->info.name = kstrdup(ksymname, GFP_KERNEL);
-        if (!entry->ksym_hbp->info.name)
-                goto err;
-
-        entry->ksym_hbp->info.type = op;
-        entry->ksym_addr = entry->ksym_hbp->info.address = addr;
-#ifdef CONFIG_X86
-        entry->ksym_hbp->info.len = HW_BREAKPOINT_LEN_4;
-#endif
-        entry->ksym_hbp->triggered = (void *)ksym_hbp_handler;
+        entry->type = op;
+        entry->ksym_addr = addr;
+        entry->len = HW_BREAKPOINT_LEN_4;
+
+        ret = -EAGAIN;
+        entry->ksym_hbp = register_wide_hw_breakpoint(entry->ksym_addr,
+                                        entry->len, entry->type,
+                                        ksym_hbp_handler, true);
+        if (IS_ERR(entry->ksym_hbp)) {
+                entry->ksym_hbp = NULL;
+                ret = PTR_ERR(entry->ksym_hbp);
+        }
 
-        ret = register_kernel_hw_breakpoint(entry->ksym_hbp);
-        if (ret < 0) {
+        if (!entry->ksym_hbp) {
                 printk(KERN_INFO "ksym_tracer request failed. Try again"
                                         " later!!\n");
-                ret = -EAGAIN;
                 goto err;
         }
+
         hlist_add_head_rcu(&(entry->ksym_hlist), &ksym_filter_head);
         ksym_filter_entry_count++;
+
         return 0;
+
 err:
-        if (entry->ksym_hbp)
-                kfree(entry->ksym_hbp->info.name);
-        kfree(entry->ksym_hbp);
         kfree(entry);
+
         return ret;
 }
 
@@ -244,10 +238,10 @@ static ssize_t ksym_trace_filter_read(struct file *filp, char __user *ubuf,
         mutex_lock(&ksym_tracer_mutex);
 
         hlist_for_each_entry(entry, node, &ksym_filter_head, ksym_hlist) {
-                ret = trace_seq_printf(s, "%s:", entry->ksym_hbp->info.name);
-                if (entry->ksym_hbp->info.type == HW_BREAKPOINT_WRITE)
+                ret = trace_seq_printf(s, "%pS:", (void *)entry->ksym_addr);
+                if (entry->type == HW_BREAKPOINT_W)
                         ret = trace_seq_puts(s, "-w-\n");
-                else if (entry->ksym_hbp->info.type == HW_BREAKPOINT_RW)
+                else if (entry->type == (HW_BREAKPOINT_W | HW_BREAKPOINT_R))
                         ret = trace_seq_puts(s, "rw-\n");
                 WARN_ON_ONCE(!ret);
         }
@@ -269,12 +263,10 @@ static void __ksym_trace_reset(void)
         mutex_lock(&ksym_tracer_mutex);
         hlist_for_each_entry_safe(entry, node, node1, &ksym_filter_head,
                                                                 ksym_hlist) {
-                unregister_kernel_hw_breakpoint(entry->ksym_hbp);
+                unregister_wide_hw_breakpoint(entry->ksym_hbp);
                 ksym_filter_entry_count--;
                 hlist_del_rcu(&(entry->ksym_hlist));
                 synchronize_rcu();
-                kfree(entry->ksym_hbp->info.name);
-                kfree(entry->ksym_hbp);
                 kfree(entry);
         }
         mutex_unlock(&ksym_tracer_mutex);
@@ -327,7 +319,7 @@ static ssize_t ksym_trace_filter_write(struct file *file,
         hlist_for_each_entry(entry, node, &ksym_filter_head, ksym_hlist) {
                 if (entry->ksym_addr == ksym_addr) {
                         /* Check for malformed request: (6) */
-                        if (entry->ksym_hbp->info.type != op)
+                        if (entry->type != op)
                                 changed = 1;
                         else
                                 goto out;
@@ -335,18 +327,21 @@ static ssize_t ksym_trace_filter_write(struct file *file,
                 }
         }
         if (changed) {
-                unregister_kernel_hw_breakpoint(entry->ksym_hbp);
-                entry->ksym_hbp->info.type = op;
+                unregister_wide_hw_breakpoint(entry->ksym_hbp);
+                entry->type = op;
                 if (op > 0) {
-                        ret = register_kernel_hw_breakpoint(entry->ksym_hbp);
-                        if (ret == 0)
+                        entry->ksym_hbp =
+                                register_wide_hw_breakpoint(entry->ksym_addr,
+                                        entry->len, entry->type,
+                                        ksym_hbp_handler, true);
+                        if (IS_ERR(entry->ksym_hbp))
+                                entry->ksym_hbp = NULL;
+                        if (!entry->ksym_hbp)
                                 goto out;
                 }
                 ksym_filter_entry_count--;
                 hlist_del_rcu(&(entry->ksym_hlist));
                 synchronize_rcu();
-                kfree(entry->ksym_hbp->info.name);
-                kfree(entry->ksym_hbp);
                 kfree(entry);
                 ret = 0;
                 goto out;
@@ -413,16 +408,16 @@ static enum print_line_t ksym_trace_output(struct trace_iterator *iter)
 
         trace_assign_type(field, entry);
 
-        ret = trace_seq_printf(s, "%11s-%-5d [%03d] %-30s ", field->cmd,
-                                entry->pid, iter->cpu, field->ksym_name);
+        ret = trace_seq_printf(s, "%11s-%-5d [%03d] %pS", field->cmd,
+                                entry->pid, iter->cpu, (char *)field->addr);
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
         switch (field->type) {
-        case HW_BREAKPOINT_WRITE:
+        case HW_BREAKPOINT_W:
                 ret = trace_seq_printf(s, " W  ");
                 break;
-        case HW_BREAKPOINT_RW:
+        case HW_BREAKPOINT_R | HW_BREAKPOINT_W:
                 ret = trace_seq_printf(s, " RW ");
                 break;
         default:
@@ -490,14 +485,13 @@ static int ksym_tracer_stat_show(struct seq_file *m, void *v)
 
         entry = hlist_entry(stat, struct trace_ksym, ksym_hlist);
 
-        if (entry->ksym_hbp)
-                access_type = entry->ksym_hbp->info.type;
+        access_type = entry->type;
 
         switch (access_type) {
-        case HW_BREAKPOINT_WRITE:
+        case HW_BREAKPOINT_W:
                 seq_puts(m, "  W           ");
                 break;
-        case HW_BREAKPOINT_RW:
+        case HW_BREAKPOINT_R | HW_BREAKPOINT_W:
                 seq_puts(m, "  RW          ");
                 break;
         default:
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index 7179c12e4f0f..27c5072c2e6b 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -828,7 +828,8 @@ trace_selftest_startup_ksym(struct tracer *trace, struct trace_array *tr)
 
         ksym_selftest_dummy = 0;
         /* Register the read-write tracing request */
-        ret = process_new_ksym_entry(KSYM_SELFTEST_ENTRY, HW_BREAKPOINT_RW,
+        ret = process_new_ksym_entry(KSYM_SELFTEST_ENTRY,
+                                     HW_BREAKPOINT_R | HW_BREAKPOINT_W,
                                         (unsigned long)(&ksym_selftest_dummy));
 
         if (ret < 0) {