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) {