Merge branch 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip

* 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip: (470 commits)
  x86: Fix comments of register/stack access functions
  perf tools: Replace %m with %a in sscanf
  hw-breakpoints: Keep track of user disabled breakpoints
  tracing/syscalls: Make syscall events print callbacks static
  tracing: Add DEFINE_EVENT(), DEFINE_SINGLE_EVENT() support to docbook
  perf: Don't free perf_mmap_data until work has been done
  perf_event: Fix compile error
  perf tools: Fix _GNU_SOURCE macro related strndup() build error
  trace_syscalls: Remove unused syscall_name_to_nr()
  trace_syscalls: Simplify syscall profile
  trace_syscalls: Remove duplicate init_enter_##sname()
  trace_syscalls: Add syscall_nr field to struct syscall_metadata
  trace_syscalls: Remove enter_id exit_id
  trace_syscalls: Set event_enter_##sname->data to its metadata
  trace_syscalls: Remove unused event_syscall_enter and event_syscall_exit
  perf_event: Initialize data.period in perf_swevent_hrtimer()
  perf probe: Simplify event naming
  perf probe: Add --list option for listing current probe events
  perf probe: Add argv_split() from lib/argv_split.c
  perf probe: Move probe event utility functions to probe-event.c
  ...

7 files changed, 236 insertions, 80 deletions

diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index 4ec5e67e18cf..47bbdf9c38d0 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -117,12 +117,12 @@ struct ftrace_event_call {
         struct dentry           *dir;
         struct trace_event      *event;
         int                     enabled;
-        int                     (*regfunc)(void *);
-        void                    (*unregfunc)(void *);
+        int                     (*regfunc)(struct ftrace_event_call *);
+        void                    (*unregfunc)(struct ftrace_event_call *);
         int                     id;
-        int                     (*raw_init)(void);
-        int                     (*show_format)(struct ftrace_event_call *call,
-                                               struct trace_seq *s);
+        int                     (*raw_init)(struct ftrace_event_call *);
+        int                     (*show_format)(struct ftrace_event_call *,
+                                               struct trace_seq *);
         int                     (*define_fields)(struct ftrace_event_call *);
         struct list_head        fields;
         int                     filter_active;
@@ -131,20 +131,20 @@ struct ftrace_event_call {
         void                    *data;
 
         atomic_t                profile_count;
-        int                     (*profile_enable)(void);
-        void                    (*profile_disable)(void);
+        int                     (*profile_enable)(struct ftrace_event_call *);
+        void                    (*profile_disable)(struct ftrace_event_call *);
 };
 
 #define FTRACE_MAX_PROFILE_SIZE 2048
 
-extern char                     *trace_profile_buf;
-extern char                     *trace_profile_buf_nmi;
+extern char *perf_trace_buf;
+extern char *perf_trace_buf_nmi;
 
 #define MAX_FILTER_PRED         32
 #define MAX_FILTER_STR_VAL      256     /* Should handle KSYM_SYMBOL_LEN */
 
 extern void destroy_preds(struct ftrace_event_call *call);
-extern int filter_match_preds(struct ftrace_event_call *call, void *rec);
+extern int filter_match_preds(struct event_filter *filter, void *rec);
 extern int filter_current_check_discard(struct ring_buffer *buffer,
                                         struct ftrace_event_call *call,
                                         void *rec,
@@ -157,11 +157,12 @@ enum {
         FILTER_PTR_STRING,
 };
 
-extern int trace_define_field(struct ftrace_event_call *call,
-                              const char *type, const char *name,
-                              int offset, int size, int is_signed,
-                              int filter_type);
 extern int trace_define_common_fields(struct ftrace_event_call *call);
+extern int trace_define_field(struct ftrace_event_call *call, const char *type,
+                              const char *name, int offset, int size,
+                              int is_signed, int filter_type);
+extern int trace_add_event_call(struct ftrace_event_call *call);
+extern void trace_remove_event_call(struct ftrace_event_call *call);
 
 #define is_signed_type(type)    (((type)(-1)) < 0)
 
@@ -186,4 +187,13 @@ do {									\
                 __trace_printk(ip, fmt, ##args);                        \
 } while (0)
 
+#ifdef CONFIG_EVENT_PROFILE
+struct perf_event;
+extern int ftrace_profile_enable(int event_id);
+extern void ftrace_profile_disable(int event_id);
+extern int ftrace_profile_set_filter(struct perf_event *event, int event_id,
+                                     char *filter_str);
+extern void ftrace_profile_free_filter(struct perf_event *event);
+#endif
+
 #endif /* _LINUX_FTRACE_EVENT_H */
diff --git a/include/linux/hw_breakpoint.h b/include/linux/hw_breakpoint.h
new file mode 100644
index 000000000000..a03daed08c59
--- /dev/null
+++ b/include/linux/hw_breakpoint.h
@@ -0,0 +1,131 @@
+#ifndef _LINUX_HW_BREAKPOINT_H
+#define _LINUX_HW_BREAKPOINT_H
+
+enum {
+        HW_BREAKPOINT_LEN_1 = 1,
+        HW_BREAKPOINT_LEN_2 = 2,
+        HW_BREAKPOINT_LEN_4 = 4,
+        HW_BREAKPOINT_LEN_8 = 8,
+};
+
+enum {
+        HW_BREAKPOINT_R = 1,
+        HW_BREAKPOINT_W = 2,
+        HW_BREAKPOINT_X = 4,
+};
+
+#ifdef __KERNEL__
+
+#include <linux/perf_event.h>
+
+#ifdef CONFIG_HAVE_HW_BREAKPOINT
+
+/* As it's for in-kernel or ptrace use, we want it to be pinned */
+#define DEFINE_BREAKPOINT_ATTR(name)    \
+struct perf_event_attr name = {         \
+        .type = PERF_TYPE_BREAKPOINT,   \
+        .size = sizeof(name),           \
+        .pinned = 1,                    \
+};
+
+static inline void hw_breakpoint_init(struct perf_event_attr *attr)
+{
+        attr->type = PERF_TYPE_BREAKPOINT;
+        attr->size = sizeof(*attr);
+        attr->pinned = 1;
+}
+
+static inline unsigned long hw_breakpoint_addr(struct perf_event *bp)
+{
+        return bp->attr.bp_addr;
+}
+
+static inline int hw_breakpoint_type(struct perf_event *bp)
+{
+        return bp->attr.bp_type;
+}
+
+static inline int hw_breakpoint_len(struct perf_event *bp)
+{
+        return bp->attr.bp_len;
+}
+
+extern struct perf_event *
+register_user_hw_breakpoint(struct perf_event_attr *attr,
+                            perf_callback_t triggered,
+                            struct task_struct *tsk);
+
+/* FIXME: only change from the attr, and don't unregister */
+extern struct perf_event *
+modify_user_hw_breakpoint(struct perf_event *bp,
+                          struct perf_event_attr *attr,
+                          perf_callback_t triggered,
+                          struct task_struct *tsk);
+
+/*
+ * Kernel breakpoints are not associated with any particular thread.
+ */
+extern struct perf_event *
+register_wide_hw_breakpoint_cpu(struct perf_event_attr *attr,
+                                perf_callback_t triggered,
+                                int cpu);
+
+extern struct perf_event **
+register_wide_hw_breakpoint(struct perf_event_attr *attr,
+                            perf_callback_t triggered);
+
+extern int register_perf_hw_breakpoint(struct perf_event *bp);
+extern int __register_perf_hw_breakpoint(struct perf_event *bp);
+extern void unregister_hw_breakpoint(struct perf_event *bp);
+extern void unregister_wide_hw_breakpoint(struct perf_event **cpu_events);
+
+extern int reserve_bp_slot(struct perf_event *bp);
+extern void release_bp_slot(struct perf_event *bp);
+
+extern void flush_ptrace_hw_breakpoint(struct task_struct *tsk);
+
+static inline struct arch_hw_breakpoint *counter_arch_bp(struct perf_event *bp)
+{
+        return &bp->hw.info;
+}
+
+#else /* !CONFIG_HAVE_HW_BREAKPOINT */
+
+static inline struct perf_event *
+register_user_hw_breakpoint(struct perf_event_attr *attr,
+                            perf_callback_t triggered,
+                            struct task_struct *tsk)    { return NULL; }
+static inline struct perf_event *
+modify_user_hw_breakpoint(struct perf_event *bp,
+                          struct perf_event_attr *attr,
+                          perf_callback_t triggered,
+                          struct task_struct *tsk)      { return NULL; }
+static inline struct perf_event *
+register_wide_hw_breakpoint_cpu(struct perf_event_attr *attr,
+                                perf_callback_t triggered,
+                                int cpu)                { return NULL; }
+static inline struct perf_event **
+register_wide_hw_breakpoint(struct perf_event_attr *attr,
+                            perf_callback_t triggered)  { return NULL; }
+static inline int
+register_perf_hw_breakpoint(struct perf_event *bp)      { return -ENOSYS; }
+static inline int
+__register_perf_hw_breakpoint(struct perf_event *bp)    { return -ENOSYS; }
+static inline void unregister_hw_breakpoint(struct perf_event *bp)      { }
+static inline void
+unregister_wide_hw_breakpoint(struct perf_event **cpu_events)           { }
+static inline int
+reserve_bp_slot(struct perf_event *bp)                  {return -ENOSYS; }
+static inline void release_bp_slot(struct perf_event *bp)               { }
+
+static inline void flush_ptrace_hw_breakpoint(struct task_struct *tsk)  { }
+
+static inline struct arch_hw_breakpoint *counter_arch_bp(struct perf_event *bp)
+{
+        return NULL;
+}
+
+#endif /* CONFIG_HAVE_HW_BREAKPOINT */
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_HW_BREAKPOINT_H */
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
index 3a46b7b7abb2..1b672f74a32f 100644
--- a/include/linux/kprobes.h
+++ b/include/linux/kprobes.h
@@ -296,6 +296,8 @@ void recycle_rp_inst(struct kretprobe_instance *ri, struct hlist_head *head);
 int disable_kprobe(struct kprobe *kp);
 int enable_kprobe(struct kprobe *kp);
 
+void dump_kprobe(struct kprobe *kp);
+
 #else /* !CONFIG_KPROBES: */
 
 static inline int kprobes_built_in(void)
diff --git a/include/linux/perf_counter.h b/include/linux/perf_counter.h
index 7b7fbf433cff..e3fb25606706 100644
--- a/include/linux/perf_counter.h
+++ b/include/linux/perf_counter.h
@@ -106,6 +106,8 @@ enum perf_sw_ids {
         PERF_COUNT_SW_CPU_MIGRATIONS            = 4,
         PERF_COUNT_SW_PAGE_FAULTS_MIN           = 5,
         PERF_COUNT_SW_PAGE_FAULTS_MAJ           = 6,
+        PERF_COUNT_SW_ALIGNMENT_FAULTS          = 7,
+        PERF_COUNT_SW_EMULATION_FAULTS          = 8,
 
         PERF_COUNT_SW_MAX,                      /* non-ABI */
 };
@@ -225,6 +227,7 @@ struct perf_counter_attr {
 #define PERF_COUNTER_IOC_RESET          _IO ('$', 3)
 #define PERF_COUNTER_IOC_PERIOD         _IOW('$', 4, u64)
 #define PERF_COUNTER_IOC_SET_OUTPUT     _IO ('$', 5)
+#define PERF_COUNTER_IOC_SET_FILTER     _IOW('$', 6, char *)
 
 enum perf_counter_ioc_flags {
         PERF_IOC_FLAG_GROUP             = 1U << 0,
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index 9e7012689a84..43adbd7f0010 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -18,6 +18,10 @@
 #include <linux/ioctl.h>
 #include <asm/byteorder.h>
 
+#ifdef CONFIG_HAVE_HW_BREAKPOINT
+#include <asm/hw_breakpoint.h>
+#endif
+
 /*
  * User-space ABI bits:
  */
@@ -31,6 +35,7 @@ enum perf_type_id {
         PERF_TYPE_TRACEPOINT                    = 2,
         PERF_TYPE_HW_CACHE                      = 3,
         PERF_TYPE_RAW                           = 4,
+        PERF_TYPE_BREAKPOINT                    = 5,
 
         PERF_TYPE_MAX,                          /* non-ABI */
 };
@@ -102,6 +107,8 @@ enum perf_sw_ids {
         PERF_COUNT_SW_CPU_MIGRATIONS            = 4,
         PERF_COUNT_SW_PAGE_FAULTS_MIN           = 5,
         PERF_COUNT_SW_PAGE_FAULTS_MAJ           = 6,
+        PERF_COUNT_SW_ALIGNMENT_FAULTS          = 7,
+        PERF_COUNT_SW_EMULATION_FAULTS          = 8,
 
         PERF_COUNT_SW_MAX,                      /* non-ABI */
 };
@@ -207,6 +214,15 @@ struct perf_event_attr {
                 __u32           wakeup_events;    /* wakeup every n events */
                 __u32           wakeup_watermark; /* bytes before wakeup   */
         };
+
+        union {
+                struct { /* Hardware breakpoint info */
+                        __u64           bp_addr;
+                        __u32           bp_type;
+                        __u32           bp_len;
+                };
+        };
+
         __u32                   __reserved_2;
 
         __u64                   __reserved_3;
@@ -219,8 +235,9 @@ struct perf_event_attr {
 #define PERF_EVENT_IOC_DISABLE          _IO ('$', 1)
 #define PERF_EVENT_IOC_REFRESH          _IO ('$', 2)
 #define PERF_EVENT_IOC_RESET            _IO ('$', 3)
-#define PERF_EVENT_IOC_PERIOD           _IOW('$', 4, u64)
+#define PERF_EVENT_IOC_PERIOD           _IOW('$', 4, __u64)
 #define PERF_EVENT_IOC_SET_OUTPUT       _IO ('$', 5)
+#define PERF_EVENT_IOC_SET_FILTER       _IOW('$', 6, char *)
 
 enum perf_event_ioc_flags {
         PERF_IOC_FLAG_GROUP             = 1U << 0,
@@ -475,6 +492,11 @@ struct hw_perf_event {
                         s64             remaining;
                         struct hrtimer  hrtimer;
                 };
+#ifdef CONFIG_HAVE_HW_BREAKPOINT
+                union { /* breakpoint */
+                        struct arch_hw_breakpoint       info;
+                };
+#endif
         };
         atomic64_t                      prev_count;
         u64                             sample_period;
@@ -543,6 +565,10 @@ struct perf_pending_entry {
         void (*func)(struct perf_pending_entry *);
 };
 
+typedef void (*perf_callback_t)(struct perf_event *, void *);
+
+struct perf_sample_data;
+
 /**
  * struct perf_event - performance event kernel representation:
  */
@@ -585,7 +611,7 @@ struct perf_event {
         u64                             tstamp_running;
         u64                             tstamp_stopped;
 
-        struct perf_event_attr  attr;
+        struct perf_event_attr          attr;
         struct hw_perf_event            hw;
 
         struct perf_event_context       *ctx;
@@ -633,7 +659,20 @@ struct perf_event {
 
         struct pid_namespace            *ns;
         u64                             id;
+
+        void (*overflow_handler)(struct perf_event *event,
+                        int nmi, struct perf_sample_data *data,
+                        struct pt_regs *regs);
+
+#ifdef CONFIG_EVENT_PROFILE
+        struct event_filter             *filter;
 #endif
+
+        perf_callback_t                 callback;
+
+        perf_callback_t                 event_callback;
+
+#endif /* CONFIG_PERF_EVENTS */
 };
 
 /**
@@ -706,7 +745,6 @@ struct perf_output_handle {
         int                             nmi;
         int                             sample;
         int                             locked;
-        unsigned long                   flags;
 };
 
 #ifdef CONFIG_PERF_EVENTS
@@ -738,6 +776,14 @@ extern int hw_perf_group_sched_in(struct perf_event *group_leader,
                struct perf_cpu_context *cpuctx,
                struct perf_event_context *ctx, int cpu);
 extern void perf_event_update_userpage(struct perf_event *event);
+extern int perf_event_release_kernel(struct perf_event *event);
+extern struct perf_event *
+perf_event_create_kernel_counter(struct perf_event_attr *attr,
+                                int cpu,
+                                pid_t pid,
+                                perf_callback_t callback);
+extern u64 perf_event_read_value(struct perf_event *event,
+                                 u64 *enabled, u64 *running);
 
 struct perf_sample_data {
         u64                             type;
@@ -814,6 +860,7 @@ extern int sysctl_perf_event_sample_rate;
 extern void perf_event_init(void);
 extern void perf_tp_event(int event_id, u64 addr, u64 count,
                                  void *record, int entry_size);
+extern void perf_bp_event(struct perf_event *event, void *data);
 
 #ifndef perf_misc_flags
 #define perf_misc_flags(regs)   (user_mode(regs) ? PERF_RECORD_MISC_USER : \
@@ -827,6 +874,8 @@ extern int perf_output_begin(struct perf_output_handle *handle,
 extern void perf_output_end(struct perf_output_handle *handle);
 extern void perf_output_copy(struct perf_output_handle *handle,
                              const void *buf, unsigned int len);
+extern int perf_swevent_get_recursion_context(void);
+extern void perf_swevent_put_recursion_context(int rctx);
 #else
 static inline void
 perf_event_task_sched_in(struct task_struct *task, int cpu)             { }
@@ -848,11 +897,15 @@ static inline int perf_event_task_enable(void)				{ return -EINVAL; }
 static inline void
 perf_sw_event(u32 event_id, u64 nr, int nmi,
                      struct pt_regs *regs, u64 addr)                    { }
+static inline void
+perf_bp_event(struct perf_event *event, void *data)             { }
 
 static inline void perf_event_mmap(struct vm_area_struct *vma)          { }
 static inline void perf_event_comm(struct task_struct *tsk)             { }
 static inline void perf_event_fork(struct task_struct *tsk)             { }
 static inline void perf_event_init(void)                                { }
+static inline int  perf_swevent_get_recursion_context(void)  { return -1; }
+static inline void perf_swevent_put_recursion_context(int rctx)         { }
 
 #endif
 
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index a990ace1a838..e79e2f3ccc51 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -99,37 +99,16 @@ struct perf_event_attr;
 #define __SC_TEST6(t6, a6, ...) __SC_TEST(t6); __SC_TEST5(__VA_ARGS__)
 
 #ifdef CONFIG_EVENT_PROFILE
-#define TRACE_SYS_ENTER_PROFILE(sname)                                         \
-static int prof_sysenter_enable_##sname(void)                                  \
-{                                                                              \
-        return reg_prof_syscall_enter("sys"#sname);                            \
-}                                                                              \
-                                                                               \
-static void prof_sysenter_disable_##sname(void)                                \
-{                                                                              \
-        unreg_prof_syscall_enter("sys"#sname);                                 \
-}
-
-#define TRACE_SYS_EXIT_PROFILE(sname)                                          \
-static int prof_sysexit_enable_##sname(void)                                   \
-{                                                                              \
-        return reg_prof_syscall_exit("sys"#sname);                             \
-}                                                                              \
-                                                                               \
-static void prof_sysexit_disable_##sname(void)                                 \
-{                                                                              \
-        unreg_prof_syscall_exit("sys"#sname);                                  \
-}
 
 #define TRACE_SYS_ENTER_PROFILE_INIT(sname)                                    \
         .profile_count = ATOMIC_INIT(-1),                                      \
-        .profile_enable = prof_sysenter_enable_##sname,                        \
-        .profile_disable = prof_sysenter_disable_##sname,
+        .profile_enable = prof_sysenter_enable,                                \
+        .profile_disable = prof_sysenter_disable,
 
 #define TRACE_SYS_EXIT_PROFILE_INIT(sname)                                     \
         .profile_count = ATOMIC_INIT(-1),                                      \
-        .profile_enable = prof_sysexit_enable_##sname,                         \
-        .profile_disable = prof_sysexit_disable_##sname,
+        .profile_enable = prof_sysexit_enable,                                 \
+        .profile_disable = prof_sysexit_disable,
 #else
 #define TRACE_SYS_ENTER_PROFILE(sname)
 #define TRACE_SYS_ENTER_PROFILE_INIT(sname)
@@ -153,74 +132,46 @@ static void prof_sysexit_disable_##sname(void)				       \
 #define __SC_STR_TDECL6(t, a, ...)      #t, __SC_STR_TDECL5(__VA_ARGS__)
 
 #define SYSCALL_TRACE_ENTER_EVENT(sname)                                \
+        static const struct syscall_metadata __syscall_meta_##sname;    \
         static struct ftrace_event_call event_enter_##sname;            \
-        struct trace_event enter_syscall_print_##sname = {              \
+        static struct trace_event enter_syscall_print_##sname = {       \
                 .trace                  = print_syscall_enter,          \
         };                                                              \
-        static int init_enter_##sname(void)                             \
-        {                                                               \
-                int num, id;                                            \
-                num = syscall_name_to_nr("sys"#sname);                  \
-                if (num < 0)                                            \
-                        return -ENOSYS;                                 \
-                id = register_ftrace_event(&enter_syscall_print_##sname);\
-                if (!id)                                                \
-                        return -ENODEV;                                 \
-                event_enter_##sname.id = id;                            \
-                set_syscall_enter_id(num, id);                          \
-                INIT_LIST_HEAD(&event_enter_##sname.fields);            \
-                return 0;                                               \
-        }                                                               \
-        TRACE_SYS_ENTER_PROFILE(sname);                                 \
         static struct ftrace_event_call __used                          \
           __attribute__((__aligned__(4)))                               \
           __attribute__((section("_ftrace_events")))                    \
           event_enter_##sname = {                                       \
                 .name                   = "sys_enter"#sname,            \
                 .system                 = "syscalls",                   \
-                .event                  = &event_syscall_enter,         \
-                .raw_init               = init_enter_##sname,           \
+                .event                  = &enter_syscall_print_##sname, \
+                .raw_init               = init_syscall_trace,           \
                 .show_format            = syscall_enter_format,         \
                 .define_fields          = syscall_enter_define_fields,  \
                 .regfunc                = reg_event_syscall_enter,      \
                 .unregfunc              = unreg_event_syscall_enter,    \
-                .data                   = "sys"#sname,                  \
+                .data                   = (void *)&__syscall_meta_##sname,\
                 TRACE_SYS_ENTER_PROFILE_INIT(sname)                     \
         }
 
 #define SYSCALL_TRACE_EXIT_EVENT(sname)                                 \
+        static const struct syscall_metadata __syscall_meta_##sname;    \
         static struct ftrace_event_call event_exit_##sname;             \
-        struct trace_event exit_syscall_print_##sname = {               \
+        static struct trace_event exit_syscall_print_##sname = {        \
                 .trace                  = print_syscall_exit,           \
         };                                                              \
-        static int init_exit_##sname(void)                              \
-        {                                                               \
-                int num, id;                                            \
-                num = syscall_name_to_nr("sys"#sname);                  \
-                if (num < 0)                                            \
-                        return -ENOSYS;                                 \
-                id = register_ftrace_event(&exit_syscall_print_##sname);\
-                if (!id)                                                \
-                        return -ENODEV;                                 \
-                event_exit_##sname.id = id;                             \
-                set_syscall_exit_id(num, id);                           \
-                INIT_LIST_HEAD(&event_exit_##sname.fields);             \
-                return 0;                                               \
-        }                                                               \
-        TRACE_SYS_EXIT_PROFILE(sname);                                  \
         static struct ftrace_event_call __used                          \
           __attribute__((__aligned__(4)))                               \
           __attribute__((section("_ftrace_events")))                    \
           event_exit_##sname = {                                        \
                 .name                   = "sys_exit"#sname,             \
                 .system                 = "syscalls",                   \
-                .event                  = &event_syscall_exit,          \
-                .raw_init               = init_exit_##sname,            \
+                .event                  = &exit_syscall_print_##sname,  \
+                .raw_init               = init_syscall_trace,           \
                 .show_format            = syscall_exit_format,          \
                 .define_fields          = syscall_exit_define_fields,   \
                 .regfunc                = reg_event_syscall_exit,       \
                 .unregfunc              = unreg_event_syscall_exit,     \
-                .data                   = "sys"#sname,                  \
+                .data                   = (void *)&__syscall_meta_##sname,\
                 TRACE_SYS_EXIT_PROFILE_INIT(sname)                      \
         }
 
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index 2aac8a83e89b..f59604ed0ec6 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -280,6 +280,12 @@ static inline void tracepoint_synchronize_unregister(void)
  * TRACE_EVENT_FN to perform any (un)registration work.
  */
 
+#define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print)
+#define DEFINE_EVENT(template, name, proto, args)               \
+        DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
+#define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
+        DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
+
 #define TRACE_EVENT(name, proto, args, struct, assign, print)   \
         DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
 #define TRACE_EVENT_FN(name, proto, args, struct,               \