scsi: docs: convert st.txt to ReST

[linux-2.6-microblaze.git] / kernel / trace / trace_events.c

diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index c8622a4..f38234e 100644 (file)
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -238,7 +238,7 @@ bool trace_event_ignore_this_pid(struct trace_event_file *trace_file)
        if (!pid_list)
                return false;
 
-       data = this_cpu_ptr(tr->trace_buffer.data);
+       data = this_cpu_ptr(tr->array_buffer.data);
 
        return data->ignore_pid;
 }
@@ -273,6 +273,7 @@ void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer,
        if (!fbuffer->event)
                return NULL;
 
+       fbuffer->regs = NULL;
        fbuffer->entry = ring_buffer_event_data(fbuffer->event);
        return fbuffer->entry;
 }
@@ -547,7 +548,7 @@ event_filter_pid_sched_switch_probe_pre(void *data, bool preempt,
 
        pid_list = rcu_dereference_sched(tr->filtered_pids);
 
-       this_cpu_write(tr->trace_buffer.data->ignore_pid,
+       this_cpu_write(tr->array_buffer.data->ignore_pid,
                       trace_ignore_this_task(pid_list, prev) &&
                       trace_ignore_this_task(pid_list, next));
 }
@@ -561,7 +562,7 @@ event_filter_pid_sched_switch_probe_post(void *data, bool preempt,
 
        pid_list = rcu_dereference_sched(tr->filtered_pids);
 
-       this_cpu_write(tr->trace_buffer.data->ignore_pid,
+       this_cpu_write(tr->array_buffer.data->ignore_pid,
                       trace_ignore_this_task(pid_list, next));
 }
 
@@ -572,12 +573,12 @@ event_filter_pid_sched_wakeup_probe_pre(void *data, struct task_struct *task)
        struct trace_pid_list *pid_list;
 
        /* Nothing to do if we are already tracing */
-       if (!this_cpu_read(tr->trace_buffer.data->ignore_pid))
+       if (!this_cpu_read(tr->array_buffer.data->ignore_pid))
                return;
 
        pid_list = rcu_dereference_sched(tr->filtered_pids);
 
-       this_cpu_write(tr->trace_buffer.data->ignore_pid,
+       this_cpu_write(tr->array_buffer.data->ignore_pid,
                       trace_ignore_this_task(pid_list, task));
 }
 
@@ -588,13 +589,13 @@ event_filter_pid_sched_wakeup_probe_post(void *data, struct task_struct *task)
        struct trace_pid_list *pid_list;
 
        /* Nothing to do if we are not tracing */
-       if (this_cpu_read(tr->trace_buffer.data->ignore_pid))
+       if (this_cpu_read(tr->array_buffer.data->ignore_pid))
                return;
 
        pid_list = rcu_dereference_sched(tr->filtered_pids);
 
        /* Set tracing if current is enabled */
-       this_cpu_write(tr->trace_buffer.data->ignore_pid,
+       this_cpu_write(tr->array_buffer.data->ignore_pid,
                       trace_ignore_this_task(pid_list, current));
 }
 
@@ -626,7 +627,7 @@ static void __ftrace_clear_event_pids(struct trace_array *tr)
        }
 
        for_each_possible_cpu(cpu)
-               per_cpu_ptr(tr->trace_buffer.data, cpu)->ignore_pid = false;
+               per_cpu_ptr(tr->array_buffer.data, cpu)->ignore_pid = false;
 
        rcu_assign_pointer(tr->filtered_pids, NULL);
 
@@ -698,7 +699,7 @@ static void remove_subsystem(struct trace_subsystem_dir *dir)
                return;
 
        if (!--dir->nr_events) {
-               tracefs_remove_recursive(dir->entry);
+               tracefs_remove(dir->entry);
                list_del(&dir->list);
                __put_system_dir(dir);
        }
@@ -717,7 +718,7 @@ static void remove_event_file_dir(struct trace_event_file *file)
                }
                spin_unlock(&dir->d_lock);
 
-               tracefs_remove_recursive(dir);
+               tracefs_remove(dir);
        }
 
        list_del(&file->list);
@@ -1595,7 +1596,7 @@ static void ignore_task_cpu(void *data)
        pid_list = rcu_dereference_protected(tr->filtered_pids,
                                             mutex_is_locked(&event_mutex));
 
-       this_cpu_write(tr->trace_buffer.data->ignore_pid,
+       this_cpu_write(tr->array_buffer.data->ignore_pid,
                       trace_ignore_this_task(pid_list, current));
 }
 
@@ -2553,6 +2554,91 @@ find_event_file(struct trace_array *tr, const char *system, const char *event)
        return file;
 }
 
+/**
+ * trace_get_event_file - Find and return a trace event file
+ * @instance: The name of the trace instance containing the event
+ * @system: The name of the system containing the event
+ * @event: The name of the event
+ *
+ * Return a trace event file given the trace instance name, trace
+ * system, and trace event name.  If the instance name is NULL, it
+ * refers to the top-level trace array.
+ *
+ * This function will look it up and return it if found, after calling
+ * trace_array_get() to prevent the instance from going away, and
+ * increment the event's module refcount to prevent it from being
+ * removed.
+ *
+ * To release the file, call trace_put_event_file(), which will call
+ * trace_array_put() and decrement the event's module refcount.
+ *
+ * Return: The trace event on success, ERR_PTR otherwise.
+ */
+struct trace_event_file *trace_get_event_file(const char *instance,
+                                             const char *system,
+                                             const char *event)
+{
+       struct trace_array *tr = top_trace_array();
+       struct trace_event_file *file = NULL;
+       int ret = -EINVAL;
+
+       if (instance) {
+               tr = trace_array_find_get(instance);
+               if (!tr)
+                       return ERR_PTR(-ENOENT);
+       } else {
+               ret = trace_array_get(tr);
+               if (ret)
+                       return ERR_PTR(ret);
+       }
+
+       mutex_lock(&event_mutex);
+
+       file = find_event_file(tr, system, event);
+       if (!file) {
+               trace_array_put(tr);
+               ret = -EINVAL;
+               goto out;
+       }
+
+       /* Don't let event modules unload while in use */
+       ret = try_module_get(file->event_call->mod);
+       if (!ret) {
+               trace_array_put(tr);
+               ret = -EBUSY;
+               goto out;
+       }
+
+       ret = 0;
+ out:
+       mutex_unlock(&event_mutex);
+
+       if (ret)
+               file = ERR_PTR(ret);
+
+       return file;
+}
+EXPORT_SYMBOL_GPL(trace_get_event_file);
+
+/**
+ * trace_put_event_file - Release a file from trace_get_event_file()
+ * @file: The trace event file
+ *
+ * If a file was retrieved using trace_get_event_file(), this should
+ * be called when it's no longer needed.  It will cancel the previous
+ * trace_array_get() called by that function, and decrement the
+ * event's module refcount.
+ */
+void trace_put_event_file(struct trace_event_file *file)
+{
+       mutex_lock(&event_mutex);
+       module_put(file->event_call->mod);
+       mutex_unlock(&event_mutex);
+
+       trace_array_put(file->tr);
+}
+EXPORT_SYMBOL_GPL(trace_put_event_file);
+
 #ifdef CONFIG_DYNAMIC_FTRACE
 
 /* Avoid typos */
@@ -3082,7 +3168,7 @@ int event_trace_del_tracer(struct trace_array *tr)
 
        down_write(&trace_event_sem);
        __trace_remove_event_dirs(tr);
-       tracefs_remove_recursive(tr->event_dir);
+       tracefs_remove(tr->event_dir);
        up_write(&trace_event_sem);
 
        tr->event_dir = NULL;
@@ -3409,8 +3495,8 @@ static void __init
 function_test_events_call(unsigned long ip, unsigned long parent_ip,
                          struct ftrace_ops *op, struct pt_regs *pt_regs)
 {
+       struct trace_buffer *buffer;
        struct ring_buffer_event *event;
-       struct ring_buffer *buffer;
        struct ftrace_entry *entry;
        unsigned long flags;
        long disabled;