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>

4 files changed, 66 insertions, 74 deletions

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