Merge branch 'tip/perf/urgent-3' of git://git.kernel.org/pub/scm/linux/kernel/git...

[pandora-kernel.git] / kernel / trace / trace_events.c

diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index 45a8968..4c758f1 100644 (file)
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -28,8 +28,7 @@
 DEFINE_MUTEX(event_mutex);
 
 LIST_HEAD(ftrace_events);
 DEFINE_MUTEX(event_mutex);
 
 LIST_HEAD(ftrace_events);

-
-#define COMMON_FIELD_COUNT     5
+LIST_HEAD(ftrace_common_fields);

 
 struct list_head *
 trace_get_fields(struct ftrace_event_call *event_call)
 
 struct list_head *
 trace_get_fields(struct ftrace_event_call *event_call)


@@ -39,15 +38,11 @@ trace_get_fields(struct ftrace_event_call *event_call)
        return event_call->class->get_fields(event_call);
 }
 
        return event_call->class->get_fields(event_call);
 }
 

-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)
+static int __trace_define_field(struct list_head *head, const char *type,
+                               const char *name, int offset, int size,
+                               int is_signed, int filter_type)

 {
        struct ftrace_event_field *field;
 {
        struct ftrace_event_field *field;

-       struct list_head *head;
-
-       if (WARN_ON(!call->class))
-               return 0;

 
        field = kzalloc(sizeof(*field), GFP_KERNEL);
        if (!field)
 
        field = kzalloc(sizeof(*field), GFP_KERNEL);
        if (!field)


@@ -70,7 +65,6 @@ int trace_define_field(struct ftrace_event_call *call, const char *type,
        field->size = size;
        field->is_signed = is_signed;
 
        field->size = size;
        field->is_signed = is_signed;
 

-       head = trace_get_fields(call);

        list_add(&field->link, head);
 
        return 0;
        list_add(&field->link, head);
 
        return 0;


@@ -82,17 +76,32 @@ err:
 
        return -ENOMEM;
 }
 
        return -ENOMEM;
 }

+
+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)
+{
+       struct list_head *head;
+
+       if (WARN_ON(!call->class))
+               return 0;
+
+       head = trace_get_fields(call);
+       return __trace_define_field(head, type, name, offset, size,
+                                   is_signed, filter_type);
+}

 EXPORT_SYMBOL_GPL(trace_define_field);
 
 #define __common_field(type, item)                                     \
 EXPORT_SYMBOL_GPL(trace_define_field);
 
 #define __common_field(type, item)                                     \

-       ret = trace_define_field(call, #type, "common_" #item,          \
-                                offsetof(typeof(ent), item),           \
-                                sizeof(ent.item),                      \
-                                is_signed_type(type), FILTER_OTHER);   \
+       ret = __trace_define_field(&ftrace_common_fields, #type,        \
+                                  "common_" #item,                     \
+                                  offsetof(typeof(ent), item),         \
+                                  sizeof(ent.item),                    \
+                                  is_signed_type(type), FILTER_OTHER); \

        if (ret)                                                        \
                return ret;
 
        if (ret)                                                        \
                return ret;
 

-static int trace_define_common_fields(struct ftrace_event_call *call)
+static int trace_define_common_fields(void)

 {
        int ret;
        struct trace_entry ent;
 {
        int ret;
        struct trace_entry ent;


@@ -132,6 +141,55 @@ int trace_event_raw_init(struct ftrace_event_call *call)
 }
 EXPORT_SYMBOL_GPL(trace_event_raw_init);
 
 }
 EXPORT_SYMBOL_GPL(trace_event_raw_init);
 

+int ftrace_event_reg(struct ftrace_event_call *call, enum trace_reg type)
+{
+       switch (type) {
+       case TRACE_REG_REGISTER:
+               return tracepoint_probe_register(call->name,
+                                                call->class->probe,
+                                                call);
+       case TRACE_REG_UNREGISTER:
+               tracepoint_probe_unregister(call->name,
+                                           call->class->probe,
+                                           call);
+               return 0;
+
+#ifdef CONFIG_PERF_EVENTS
+       case TRACE_REG_PERF_REGISTER:
+               return tracepoint_probe_register(call->name,
+                                                call->class->perf_probe,
+                                                call);
+       case TRACE_REG_PERF_UNREGISTER:
+               tracepoint_probe_unregister(call->name,
+                                           call->class->perf_probe,
+                                           call);
+               return 0;
+#endif
+       }
+       return 0;
+}
+EXPORT_SYMBOL_GPL(ftrace_event_reg);
+
+void trace_event_enable_cmd_record(bool enable)
+{
+       struct ftrace_event_call *call;
+
+       mutex_lock(&event_mutex);
+       list_for_each_entry(call, &ftrace_events, list) {
+               if (!(call->flags & TRACE_EVENT_FL_ENABLED))
+                       continue;
+
+               if (enable) {
+                       tracing_start_cmdline_record();
+                       call->flags |= TRACE_EVENT_FL_RECORDED_CMD;
+               } else {
+                       tracing_stop_cmdline_record();
+                       call->flags &= ~TRACE_EVENT_FL_RECORDED_CMD;
+               }
+       }
+       mutex_unlock(&event_mutex);
+}
+

 static int ftrace_event_enable_disable(struct ftrace_event_call *call,
                                        int enable)
 {
 static int ftrace_event_enable_disable(struct ftrace_event_call *call,
                                        int enable)
 {


@@ -141,24 +199,20 @@ static int ftrace_event_enable_disable(struct ftrace_event_call *call,
        case 0:
                if (call->flags & TRACE_EVENT_FL_ENABLED) {
                        call->flags &= ~TRACE_EVENT_FL_ENABLED;
        case 0:
                if (call->flags & TRACE_EVENT_FL_ENABLED) {
                        call->flags &= ~TRACE_EVENT_FL_ENABLED;

-                       tracing_stop_cmdline_record();
-                       if (call->class->reg)
-                               call->class->reg(call, TRACE_REG_UNREGISTER);
-                       else
-                               tracepoint_probe_unregister(call->name,
-                                                           call->class->probe,
-                                                           call);
+                       if (call->flags & TRACE_EVENT_FL_RECORDED_CMD) {
+                               tracing_stop_cmdline_record();
+                               call->flags &= ~TRACE_EVENT_FL_RECORDED_CMD;
+                       }
+                       call->class->reg(call, TRACE_REG_UNREGISTER);

                }
                break;
        case 1:
                if (!(call->flags & TRACE_EVENT_FL_ENABLED)) {
                }
                break;
        case 1:
                if (!(call->flags & TRACE_EVENT_FL_ENABLED)) {

-                       tracing_start_cmdline_record();
-                       if (call->class->reg)
-                               ret = call->class->reg(call, TRACE_REG_REGISTER);
-                       else
-                               ret = tracepoint_probe_register(call->name,
-                                                               call->class->probe,
-                                                               call);
+                       if (trace_flags & TRACE_ITER_RECORD_CMD) {
+                               tracing_start_cmdline_record();
+                               call->flags |= TRACE_EVENT_FL_RECORDED_CMD;
+                       }
+                       ret = call->class->reg(call, TRACE_REG_REGISTER);

                        if (ret) {
                                tracing_stop_cmdline_record();
                                pr_info("event trace: Could not enable event "
                        if (ret) {
                                tracing_stop_cmdline_record();
                                pr_info("event trace: Could not enable event "


@@ -196,8 +250,7 @@ static int __ftrace_set_clr_event(const char *match, const char *sub,
        mutex_lock(&event_mutex);
        list_for_each_entry(call, &ftrace_events, list) {
 
        mutex_lock(&event_mutex);
        list_for_each_entry(call, &ftrace_events, list) {
 

-               if (!call->name || !call->class ||
-                   (!call->class->probe && !call->class->reg))
+               if (!call->name || !call->class || !call->class->reg)

                        continue;
 
                if (match &&
                        continue;
 
                if (match &&


@@ -323,7 +376,7 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
                 * The ftrace subsystem is for showing formats only.
                 * They can not be enabled or disabled via the event files.
                 */
                 * The ftrace subsystem is for showing formats only.
                 * They can not be enabled or disabled via the event files.
                 */

-               if (call->class && (call->class->probe || call->class->reg))
+               if (call->class && call->class->reg)

                        return call;
        }
 
                        return call;
        }
 


@@ -476,8 +529,7 @@ system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
 
        mutex_lock(&event_mutex);
        list_for_each_entry(call, &ftrace_events, list) {
 
        mutex_lock(&event_mutex);
        list_for_each_entry(call, &ftrace_events, list) {

-               if (!call->name || !call->class ||
-                   (!call->class->probe && !call->class->reg))
+               if (!call->name || !call->class || !call->class->reg)

                        continue;
 
                if (system && strcmp(call->class->system, system) != 0)
                        continue;
 
                if (system && strcmp(call->class->system, system) != 0)


@@ -556,14 +608,12 @@ static void *f_next(struct seq_file *m, void *v, loff_t *pos)
        struct ftrace_event_call *call = m->private;
        struct ftrace_event_field *field;
        struct list_head *head;
        struct ftrace_event_call *call = m->private;
        struct ftrace_event_field *field;
        struct list_head *head;

-       loff_t index = *pos;

 
        (*pos)++;
 
 
        (*pos)++;
 

-       head = trace_get_fields(call);
-

        switch ((unsigned long)v) {
        case FORMAT_HEADER:
        switch ((unsigned long)v) {
        case FORMAT_HEADER:

+               head = &ftrace_common_fields;

 
                if (unlikely(list_empty(head)))
                        return NULL;
 
                if (unlikely(list_empty(head)))
                        return NULL;


@@ -576,6 +626,8 @@ static void *f_next(struct seq_file *m, void *v, loff_t *pos)
                return NULL;
        }
 
                return NULL;
        }
 

+       head = trace_get_fields(call);
+

        /*
         * To separate common fields from event fields, the
         * LSB is set on the first event field. Clear it in case.
        /*
         * To separate common fields from event fields, the
         * LSB is set on the first event field. Clear it in case.


@@ -583,16 +635,26 @@ static void *f_next(struct seq_file *m, void *v, loff_t *pos)
        v = (void *)((unsigned long)v & ~1L);
 
        field = v;
        v = (void *)((unsigned long)v & ~1L);
 
        field = v;

+       /*
+        * If this is a common field, and at the end of the list, then
+        * continue with main list.
+        */
+       if (field->link.prev == &ftrace_common_fields) {
+               if (unlikely(list_empty(head)))
+                       return NULL;
+               field = list_entry(head->prev, struct ftrace_event_field, link);
+               /* Set the LSB to notify f_show to print an extra newline */
+               field = (struct ftrace_event_field *)
+                       ((unsigned long)field | 1);
+               return field;
+       }
+
+       /* If we are done tell f_show to print the format */

        if (field->link.prev == head)
                return (void *)FORMAT_PRINTFMT;
 
        field = list_entry(field->link.prev, struct ftrace_event_field, link);
 
        if (field->link.prev == head)
                return (void *)FORMAT_PRINTFMT;
 
        field = list_entry(field->link.prev, struct ftrace_event_field, link);
 

-       /* Set the LSB to notify f_show to print an extra newline */
-       if (index == COMMON_FIELD_COUNT)
-               field = (struct ftrace_event_field *)
-                       ((unsigned long)field | 1);
-

        return field;
 }
 
        return field;
 }
 


@@ -1037,35 +1099,31 @@ event_create_dir(struct ftrace_event_call *call, struct dentry *d_events,
                return -1;
        }
 
                return -1;
        }
 

-       if (call->class->probe || call->class->reg)
+       if (call->class->reg)

                trace_create_file("enable", 0644, call->dir, call,
                                  enable);
 
 #ifdef CONFIG_PERF_EVENTS
                trace_create_file("enable", 0644, call->dir, call,
                                  enable);
 
 #ifdef CONFIG_PERF_EVENTS

-       if (call->event.type && (call->class->perf_probe || call->class->reg))
+       if (call->event.type && call->class->reg)

                trace_create_file("id", 0444, call->dir, call,
                                  id);
 #endif
 
                trace_create_file("id", 0444, call->dir, call,
                                  id);
 #endif
 

-       if (call->class->define_fields) {
-               /*
-                * Other events may have the same class. Only update
-                * the fields if they are not already defined.
-                */
-               head = trace_get_fields(call);
-               if (list_empty(head)) {
-                       ret = trace_define_common_fields(call);
-                       if (!ret)
-                               ret = call->class->define_fields(call);
-                       if (ret < 0) {
-                               pr_warning("Could not initialize trace point"
-                                          " events/%s\n", call->name);
-                               return ret;
-                       }
+       /*
+        * Other events may have the same class. Only update
+        * the fields if they are not already defined.
+        */
+       head = trace_get_fields(call);
+       if (list_empty(head)) {
+               ret = call->class->define_fields(call);
+               if (ret < 0) {
+                       pr_warning("Could not initialize trace point"
+                                  " events/%s\n", call->name);
+                       return ret;

                }
                }

-               trace_create_file("filter", 0644, call->dir, call,
-                                 filter);

        }
        }

+       trace_create_file("filter", 0644, call->dir, call,
+                         filter);

 
        trace_create_file("format", 0444, call->dir, call,
                          format);
 
        trace_create_file("format", 0444, call->dir, call,
                          format);


@@ -1073,11 +1131,17 @@ event_create_dir(struct ftrace_event_call *call, struct dentry *d_events,
        return 0;
 }
 
        return 0;
 }
 

-static int __trace_add_event_call(struct ftrace_event_call *call)
+static int
+__trace_add_event_call(struct ftrace_event_call *call, struct module *mod,
+                      const struct file_operations *id,
+                      const struct file_operations *enable,
+                      const struct file_operations *filter,
+                      const struct file_operations *format)

 {
        struct dentry *d_events;
        int ret;
 
 {
        struct dentry *d_events;
        int ret;
 

+       /* The linker may leave blanks */

        if (!call->name)
                return -EINVAL;
 
        if (!call->name)
                return -EINVAL;
 


@@ -1085,8 +1149,8 @@ static int __trace_add_event_call(struct ftrace_event_call *call)
                ret = call->class->raw_init(call);
                if (ret < 0) {
                        if (ret != -ENOSYS)
                ret = call->class->raw_init(call);
                if (ret < 0) {
                        if (ret != -ENOSYS)

-                               pr_warning("Could not initialize trace "
-                               "events/%s\n", call->name);
+                               pr_warning("Could not initialize trace events/%s\n",
+                                          call->name);

                        return ret;
                }
        }
                        return ret;
                }
        }


@@ -1095,11 +1159,10 @@ static int __trace_add_event_call(struct ftrace_event_call *call)
        if (!d_events)
                return -ENOENT;
 
        if (!d_events)
                return -ENOENT;
 

-       ret = event_create_dir(call, d_events, &ftrace_event_id_fops,
-                               &ftrace_enable_fops, &ftrace_event_filter_fops,
-                               &ftrace_event_format_fops);
+       ret = event_create_dir(call, d_events, id, enable, filter, format);

        if (!ret)
                list_add(&call->list, &ftrace_events);
        if (!ret)
                list_add(&call->list, &ftrace_events);

+       call->mod = mod;

 
        return ret;
 }
 
        return ret;
 }


@@ -1109,7 +1172,10 @@ int trace_add_event_call(struct ftrace_event_call *call)
 {
        int ret;
        mutex_lock(&event_mutex);
 {
        int ret;
        mutex_lock(&event_mutex);

-       ret = __trace_add_event_call(call);
+       ret = __trace_add_event_call(call, NULL, &ftrace_event_id_fops,
+                                    &ftrace_enable_fops,
+                                    &ftrace_event_filter_fops,
+                                    &ftrace_event_format_fops);

        mutex_unlock(&event_mutex);
        return ret;
 }
        mutex_unlock(&event_mutex);
        return ret;
 }


@@ -1226,8 +1292,6 @@ static void trace_module_add_events(struct module *mod)
 {
        struct ftrace_module_file_ops *file_ops = NULL;
        struct ftrace_event_call *call, *start, *end;
 {
        struct ftrace_module_file_ops *file_ops = NULL;
        struct ftrace_event_call *call, *start, *end;

-       struct dentry *d_events;
-       int ret;

 
        start = mod->trace_events;
        end = mod->trace_events + mod->num_trace_events;
 
        start = mod->trace_events;
        end = mod->trace_events + mod->num_trace_events;


@@ -1235,38 +1299,14 @@ static void trace_module_add_events(struct module *mod)
        if (start == end)
                return;
 
        if (start == end)
                return;
 

-       d_events = event_trace_events_dir();
-       if (!d_events)
+       file_ops = trace_create_file_ops(mod);
+       if (!file_ops)

                return;
 
        for_each_event(call, start, end) {
                return;
 
        for_each_event(call, start, end) {

-               /* The linker may leave blanks */
-               if (!call->name)
-                       continue;
-               if (call->class->raw_init) {
-                       ret = call->class->raw_init(call);
-                       if (ret < 0) {
-                               if (ret != -ENOSYS)
-                                       pr_warning("Could not initialize trace "
-                                       "point events/%s\n", call->name);
-                               continue;
-                       }
-               }
-               /*
-                * This module has events, create file ops for this module
-                * if not already done.
-                */
-               if (!file_ops) {
-                       file_ops = trace_create_file_ops(mod);
-                       if (!file_ops)
-                               return;
-               }
-               call->mod = mod;
-               ret = event_create_dir(call, d_events,
+               __trace_add_event_call(call, mod,

                                       &file_ops->id, &file_ops->enable,
                                       &file_ops->filter, &file_ops->format);
                                       &file_ops->id, &file_ops->enable,
                                       &file_ops->filter, &file_ops->format);

-               if (!ret)
-                       list_add(&call->list, &ftrace_events);

        }
 }
 
        }
 }
 


@@ -1393,25 +1433,14 @@ static __init int event_trace_init(void)
        trace_create_file("enable", 0644, d_events,
                          NULL, &ftrace_system_enable_fops);
 
        trace_create_file("enable", 0644, d_events,
                          NULL, &ftrace_system_enable_fops);
 

+       if (trace_define_common_fields())
+               pr_warning("tracing: Failed to allocate common fields");
+

        for_each_event(call, __start_ftrace_events, __stop_ftrace_events) {
        for_each_event(call, __start_ftrace_events, __stop_ftrace_events) {

-               /* The linker may leave blanks */
-               if (!call->name)
-                       continue;
-               if (call->class->raw_init) {
-                       ret = call->class->raw_init(call);
-                       if (ret < 0) {
-                               if (ret != -ENOSYS)
-                                       pr_warning("Could not initialize trace "
-                                       "point events/%s\n", call->name);
-                               continue;
-                       }
-               }
-               ret = event_create_dir(call, d_events, &ftrace_event_id_fops,
+               __trace_add_event_call(call, NULL, &ftrace_event_id_fops,

                                       &ftrace_enable_fops,
                                       &ftrace_event_filter_fops,
                                       &ftrace_event_format_fops);
                                       &ftrace_enable_fops,
                                       &ftrace_event_filter_fops,
                                       &ftrace_event_format_fops);

-               if (!ret)
-                       list_add(&call->list, &ftrace_events);

        }
 
        while (true) {
        }
 
        while (true) {


@@ -1598,12 +1627,11 @@ function_test_events_call(unsigned long ip, unsigned long parent_ip)
        struct ftrace_entry *entry;
        unsigned long flags;
        long disabled;
        struct ftrace_entry *entry;
        unsigned long flags;
        long disabled;

-       int resched;

        int cpu;
        int pc;
 
        pc = preempt_count();
        int cpu;
        int pc;
 
        pc = preempt_count();

-       resched = ftrace_preempt_disable();
+       preempt_disable_notrace();

        cpu = raw_smp_processor_id();
        disabled = atomic_inc_return(&per_cpu(ftrace_test_event_disable, cpu));
 
        cpu = raw_smp_processor_id();
        disabled = atomic_inc_return(&per_cpu(ftrace_test_event_disable, cpu));
 


@@ -1625,7 +1653,7 @@ function_test_events_call(unsigned long ip, unsigned long parent_ip)
 
  out:
        atomic_dec(&per_cpu(ftrace_test_event_disable, cpu));
 
  out:
        atomic_dec(&per_cpu(ftrace_test_event_disable, cpu));

-       ftrace_preempt_enable(resched);
+       preempt_enable_notrace();

 }
 
 static struct ftrace_ops trace_ops __initdata  =
 }
 
 static struct ftrace_ops trace_ops __initdata  =