tracing: replace TP<var> with TP_<var>

Impact: clean up

The macros TPPROTO, TPARGS, TPFMT, TPRAWFMT, and TPCMD all look a bit
ugly. This patch adds an underscore to their names.

Signed-off-by: Steven Rostedt <srostedt@redhat.com>

6 files changed, 118 insertions, 118 deletions

diff --git a/include/trace/block.h b/include/trace/block.h
index 25c6a1fd5b77..25b7068b819e 100644
--- a/include/trace/block.h
+++ b/include/trace/block.h
@@ -5,72 +5,72 @@
 #include <linux/tracepoint.h>
 
 DECLARE_TRACE(block_rq_abort,
-        TPPROTO(struct request_queue *q, struct request *rq),
-                TPARGS(q, rq));
+        TP_PROTO(struct request_queue *q, struct request *rq),
+              TP_ARGS(q, rq));
 
 DECLARE_TRACE(block_rq_insert,
-        TPPROTO(struct request_queue *q, struct request *rq),
-                TPARGS(q, rq));
+        TP_PROTO(struct request_queue *q, struct request *rq),
+              TP_ARGS(q, rq));
 
 DECLARE_TRACE(block_rq_issue,
-        TPPROTO(struct request_queue *q, struct request *rq),
-                TPARGS(q, rq));
+        TP_PROTO(struct request_queue *q, struct request *rq),
+              TP_ARGS(q, rq));
 
 DECLARE_TRACE(block_rq_requeue,
-        TPPROTO(struct request_queue *q, struct request *rq),
-                TPARGS(q, rq));
+        TP_PROTO(struct request_queue *q, struct request *rq),
+              TP_ARGS(q, rq));
 
 DECLARE_TRACE(block_rq_complete,
-        TPPROTO(struct request_queue *q, struct request *rq),
-                TPARGS(q, rq));
+        TP_PROTO(struct request_queue *q, struct request *rq),
+              TP_ARGS(q, rq));
 
 DECLARE_TRACE(block_bio_bounce,
-        TPPROTO(struct request_queue *q, struct bio *bio),
-                TPARGS(q, bio));
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+              TP_ARGS(q, bio));
 
 DECLARE_TRACE(block_bio_complete,
-        TPPROTO(struct request_queue *q, struct bio *bio),
-                TPARGS(q, bio));
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+              TP_ARGS(q, bio));
 
 DECLARE_TRACE(block_bio_backmerge,
-        TPPROTO(struct request_queue *q, struct bio *bio),
-                TPARGS(q, bio));
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+              TP_ARGS(q, bio));
 
 DECLARE_TRACE(block_bio_frontmerge,
-        TPPROTO(struct request_queue *q, struct bio *bio),
-                TPARGS(q, bio));
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+              TP_ARGS(q, bio));
 
 DECLARE_TRACE(block_bio_queue,
-        TPPROTO(struct request_queue *q, struct bio *bio),
-                TPARGS(q, bio));
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+              TP_ARGS(q, bio));
 
 DECLARE_TRACE(block_getrq,
-        TPPROTO(struct request_queue *q, struct bio *bio, int rw),
-                TPARGS(q, bio, rw));
+        TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
+              TP_ARGS(q, bio, rw));
 
 DECLARE_TRACE(block_sleeprq,
-        TPPROTO(struct request_queue *q, struct bio *bio, int rw),
-                TPARGS(q, bio, rw));
+        TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
+              TP_ARGS(q, bio, rw));
 
 DECLARE_TRACE(block_plug,
-        TPPROTO(struct request_queue *q),
-                TPARGS(q));
+        TP_PROTO(struct request_queue *q),
+              TP_ARGS(q));
 
 DECLARE_TRACE(block_unplug_timer,
-        TPPROTO(struct request_queue *q),
-                TPARGS(q));
+        TP_PROTO(struct request_queue *q),
+              TP_ARGS(q));
 
 DECLARE_TRACE(block_unplug_io,
-        TPPROTO(struct request_queue *q),
-                TPARGS(q));
+        TP_PROTO(struct request_queue *q),
+              TP_ARGS(q));
 
 DECLARE_TRACE(block_split,
-        TPPROTO(struct request_queue *q, struct bio *bio, unsigned int pdu),
-                TPARGS(q, bio, pdu));
+        TP_PROTO(struct request_queue *q, struct bio *bio, unsigned int pdu),
+              TP_ARGS(q, bio, pdu));
 
 DECLARE_TRACE(block_remap,
-        TPPROTO(struct request_queue *q, struct bio *bio, dev_t dev,
-                sector_t from, sector_t to),
-                TPARGS(q, bio, dev, from, to));
+        TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev,
+                 sector_t from, sector_t to),
+              TP_ARGS(q, bio, dev, from, to));
 
 #endif
diff --git a/include/trace/irq_event_types.h b/include/trace/irq_event_types.h
index 65850bc5ea06..0147d9eef5f4 100644
--- a/include/trace/irq_event_types.h
+++ b/include/trace/irq_event_types.h
@@ -9,25 +9,25 @@
 #define TRACE_SYSTEM irq
 
 TRACE_EVENT_FORMAT(irq_handler_entry,
-        TPPROTO(int irq, struct irqaction *action),
-        TPARGS(irq, action),
-        TPFMT("irq=%d handler=%s", irq, action->name),
+        TP_PROTO(int irq, struct irqaction *action),
+        TP_ARGS(irq, action),
+        TP_FMT("irq=%d handler=%s", irq, action->name),
         TRACE_STRUCT(
                 TRACE_FIELD(int, irq, irq)
         ),
-        TPRAWFMT("irq %d")
+        TP_RAW_FMT("irq %d")
         );
 
 TRACE_EVENT_FORMAT(irq_handler_exit,
-        TPPROTO(int irq, struct irqaction *action, int ret),
-        TPARGS(irq, action, ret),
-        TPFMT("irq=%d handler=%s return=%s",
+        TP_PROTO(int irq, struct irqaction *action, int ret),
+        TP_ARGS(irq, action, ret),
+        TP_FMT("irq=%d handler=%s return=%s",
                 irq, action->name, ret ? "handled" : "unhandled"),
         TRACE_STRUCT(
                 TRACE_FIELD(int, irq, irq)
                 TRACE_FIELD(int, ret, ret)
         ),
-        TPRAWFMT("irq %d ret %d")
+        TP_RAW_FMT("irq %d ret %d")
         );
 
 #undef TRACE_SYSTEM
diff --git a/include/trace/lockdep_event_types.h b/include/trace/lockdep_event_types.h
index f713d74a82b4..1f00e8b3543e 100644
--- a/include/trace/lockdep_event_types.h
+++ b/include/trace/lockdep_event_types.h
@@ -10,32 +10,32 @@
 #ifdef CONFIG_LOCKDEP
 
 TRACE_FORMAT(lock_acquire,
-        TPPROTO(struct lockdep_map *lock, unsigned int subclass,
+        TP_PROTO(struct lockdep_map *lock, unsigned int subclass,
                 int trylock, int read, int check,
                 struct lockdep_map *next_lock, unsigned long ip),
-        TPARGS(lock, subclass, trylock, read, check, next_lock, ip),
-        TPFMT("%s%s%s", trylock ? "try " : "",
+        TP_ARGS(lock, subclass, trylock, read, check, next_lock, ip),
+        TP_FMT("%s%s%s", trylock ? "try " : "",
                 read ? "read " : "", lock->name)
         );
 
 TRACE_FORMAT(lock_release,
-        TPPROTO(struct lockdep_map *lock, int nested, unsigned long ip),
-        TPARGS(lock, nested, ip),
-        TPFMT("%s", lock->name)
+        TP_PROTO(struct lockdep_map *lock, int nested, unsigned long ip),
+        TP_ARGS(lock, nested, ip),
+        TP_FMT("%s", lock->name)
         );
 
 #ifdef CONFIG_LOCK_STAT
 
 TRACE_FORMAT(lock_contended,
-        TPPROTO(struct lockdep_map *lock, unsigned long ip),
-        TPARGS(lock, ip),
-        TPFMT("%s", lock->name)
+        TP_PROTO(struct lockdep_map *lock, unsigned long ip),
+        TP_ARGS(lock, ip),
+        TP_FMT("%s", lock->name)
         );
 
 TRACE_FORMAT(lock_acquired,
-        TPPROTO(struct lockdep_map *lock, unsigned long ip),
-        TPARGS(lock, ip),
-        TPFMT("%s", lock->name)
+        TP_PROTO(struct lockdep_map *lock, unsigned long ip),
+        TP_ARGS(lock, ip),
+        TP_FMT("%s", lock->name)
         );
 
 #endif
diff --git a/include/trace/power.h b/include/trace/power.h
index 38aca537e497..ef204666e983 100644
--- a/include/trace/power.h
+++ b/include/trace/power.h
@@ -18,15 +18,15 @@ struct power_trace {
 };
 
 DECLARE_TRACE(power_start,
-        TPPROTO(struct power_trace *it, unsigned int type, unsigned int state),
-                TPARGS(it, type, state));
+        TP_PROTO(struct power_trace *it, unsigned int type, unsigned int state),
+              TP_ARGS(it, type, state));
 
 DECLARE_TRACE(power_mark,
-        TPPROTO(struct power_trace *it, unsigned int type, unsigned int state),
-                TPARGS(it, type, state));
+        TP_PROTO(struct power_trace *it, unsigned int type, unsigned int state),
+              TP_ARGS(it, type, state));
 
 DECLARE_TRACE(power_end,
-        TPPROTO(struct power_trace *it),
-                TPARGS(it));
+        TP_PROTO(struct power_trace *it),
+              TP_ARGS(it));
 
 #endif /* _TRACE_POWER_H */
diff --git a/include/trace/sched_event_types.h b/include/trace/sched_event_types.h
index a6de5c1601a0..71b14828a957 100644
--- a/include/trace/sched_event_types.h
+++ b/include/trace/sched_event_types.h
@@ -9,143 +9,143 @@
 #define TRACE_SYSTEM sched
 
 TRACE_EVENT_FORMAT(sched_kthread_stop,
-        TPPROTO(struct task_struct *t),
-        TPARGS(t),
-        TPFMT("task %s:%d", t->comm, t->pid),
+        TP_PROTO(struct task_struct *t),
+        TP_ARGS(t),
+        TP_FMT("task %s:%d", t->comm, t->pid),
         TRACE_STRUCT(
                 TRACE_FIELD(pid_t, pid, t->pid)
         ),
-        TPRAWFMT("task %d")
+        TP_RAW_FMT("task %d")
         );
 
 TRACE_EVENT_FORMAT(sched_kthread_stop_ret,
-        TPPROTO(int ret),
-        TPARGS(ret),
-        TPFMT("ret=%d", ret),
+        TP_PROTO(int ret),
+        TP_ARGS(ret),
+        TP_FMT("ret=%d", ret),
         TRACE_STRUCT(
                 TRACE_FIELD(int, ret, ret)
         ),
-        TPRAWFMT("ret=%d")
+        TP_RAW_FMT("ret=%d")
         );
 
 TRACE_EVENT_FORMAT(sched_wait_task,
-        TPPROTO(struct rq *rq, struct task_struct *p),
-        TPARGS(rq, p),
-        TPFMT("task %s:%d", p->comm, p->pid),
+        TP_PROTO(struct rq *rq, struct task_struct *p),
+        TP_ARGS(rq, p),
+        TP_FMT("task %s:%d", p->comm, p->pid),
         TRACE_STRUCT(
                 TRACE_FIELD(pid_t, pid, p->pid)
         ),
-        TPRAWFMT("task %d")
+        TP_RAW_FMT("task %d")
         );
 
 TRACE_EVENT_FORMAT(sched_wakeup,
-        TPPROTO(struct rq *rq, struct task_struct *p, int success),
-        TPARGS(rq, p, success),
-        TPFMT("task %s:%d %s",
+        TP_PROTO(struct rq *rq, struct task_struct *p, int success),
+        TP_ARGS(rq, p, success),
+        TP_FMT("task %s:%d %s",
               p->comm, p->pid, success ? "succeeded" : "failed"),
         TRACE_STRUCT(
                 TRACE_FIELD(pid_t, pid, p->pid)
                 TRACE_FIELD(int, success, success)
         ),
-        TPRAWFMT("task %d success=%d")
+        TP_RAW_FMT("task %d success=%d")
         );
 
 TRACE_EVENT_FORMAT(sched_wakeup_new,
-        TPPROTO(struct rq *rq, struct task_struct *p, int success),
-        TPARGS(rq, p, success),
-        TPFMT("task %s:%d",
+        TP_PROTO(struct rq *rq, struct task_struct *p, int success),
+        TP_ARGS(rq, p, success),
+        TP_FMT("task %s:%d",
               p->comm, p->pid, success ? "succeeded" : "failed"),
         TRACE_STRUCT(
                 TRACE_FIELD(pid_t, pid, p->pid)
                 TRACE_FIELD(int, success, success)
         ),
-        TPRAWFMT("task %d success=%d")
+        TP_RAW_FMT("task %d success=%d")
         );
 
 TRACE_EVENT_FORMAT(sched_switch,
-        TPPROTO(struct rq *rq, struct task_struct *prev,
+        TP_PROTO(struct rq *rq, struct task_struct *prev,
                 struct task_struct *next),
-        TPARGS(rq, prev, next),
-        TPFMT("task %s:%d ==> %s:%d",
+        TP_ARGS(rq, prev, next),
+        TP_FMT("task %s:%d ==> %s:%d",
               prev->comm, prev->pid, next->comm, next->pid),
         TRACE_STRUCT(
                 TRACE_FIELD(pid_t, prev_pid, prev->pid)
                 TRACE_FIELD(int, prev_prio, prev->prio)
                 TRACE_FIELD_SPECIAL(char next_comm[TASK_COMM_LEN],
                                     next_comm,
-                                    TPCMD(memcpy(TRACE_ENTRY->next_comm,
+                                    TP_CMD(memcpy(TRACE_ENTRY->next_comm,
                                                  next->comm,
                                                  TASK_COMM_LEN)))
                 TRACE_FIELD(pid_t, next_pid, next->pid)
                 TRACE_FIELD(int, next_prio, next->prio)
         ),
-        TPRAWFMT("prev %d:%d ==> next %s:%d:%d")
+        TP_RAW_FMT("prev %d:%d ==> next %s:%d:%d")
         );
 
 TRACE_EVENT_FORMAT(sched_migrate_task,
-        TPPROTO(struct task_struct *p, int orig_cpu, int dest_cpu),
-        TPARGS(p, orig_cpu, dest_cpu),
-        TPFMT("task %s:%d from: %d  to: %d",
+        TP_PROTO(struct task_struct *p, int orig_cpu, int dest_cpu),
+        TP_ARGS(p, orig_cpu, dest_cpu),
+        TP_FMT("task %s:%d from: %d  to: %d",
               p->comm, p->pid, orig_cpu, dest_cpu),
         TRACE_STRUCT(
                 TRACE_FIELD(pid_t, pid, p->pid)
                 TRACE_FIELD(int, orig_cpu, orig_cpu)
                 TRACE_FIELD(int, dest_cpu, dest_cpu)
         ),
-        TPRAWFMT("task %d  from: %d to: %d")
+        TP_RAW_FMT("task %d  from: %d to: %d")
         );
 
 TRACE_EVENT_FORMAT(sched_process_free,
-        TPPROTO(struct task_struct *p),
-        TPARGS(p),
-        TPFMT("task %s:%d", p->comm, p->pid),
+        TP_PROTO(struct task_struct *p),
+        TP_ARGS(p),
+        TP_FMT("task %s:%d", p->comm, p->pid),
         TRACE_STRUCT(
                 TRACE_FIELD(pid_t, pid, p->pid)
         ),
-        TPRAWFMT("task %d")
+        TP_RAW_FMT("task %d")
         );
 
 TRACE_EVENT_FORMAT(sched_process_exit,
-        TPPROTO(struct task_struct *p),
-        TPARGS(p),
-        TPFMT("task %s:%d", p->comm, p->pid),
+        TP_PROTO(struct task_struct *p),
+        TP_ARGS(p),
+        TP_FMT("task %s:%d", p->comm, p->pid),
         TRACE_STRUCT(
                 TRACE_FIELD(pid_t, pid, p->pid)
         ),
-        TPRAWFMT("task %d")
+        TP_RAW_FMT("task %d")
         );
 
 TRACE_EVENT_FORMAT(sched_process_wait,
-        TPPROTO(struct pid *pid),
-        TPARGS(pid),
-        TPFMT("pid %d", pid_nr(pid)),
+        TP_PROTO(struct pid *pid),
+        TP_ARGS(pid),
+        TP_FMT("pid %d", pid_nr(pid)),
         TRACE_STRUCT(
                 TRACE_FIELD(pid_t, pid, pid_nr(pid))
         ),
-        TPRAWFMT("task %d")
+        TP_RAW_FMT("task %d")
         );
 
 TRACE_EVENT_FORMAT(sched_process_fork,
-        TPPROTO(struct task_struct *parent, struct task_struct *child),
-        TPARGS(parent, child),
-        TPFMT("parent %s:%d  child %s:%d",
+        TP_PROTO(struct task_struct *parent, struct task_struct *child),
+        TP_ARGS(parent, child),
+        TP_FMT("parent %s:%d  child %s:%d",
               parent->comm, parent->pid, child->comm, child->pid),
         TRACE_STRUCT(
                 TRACE_FIELD(pid_t, parent, parent->pid)
                 TRACE_FIELD(pid_t, child, child->pid)
         ),
-        TPRAWFMT("parent %d  child %d")
+        TP_RAW_FMT("parent %d  child %d")
         );
 
 TRACE_EVENT_FORMAT(sched_signal_send,
-        TPPROTO(int sig, struct task_struct *p),
-        TPARGS(sig, p),
-        TPFMT("sig: %d   task %s:%d", sig, p->comm, p->pid),
+        TP_PROTO(int sig, struct task_struct *p),
+        TP_ARGS(sig, p),
+        TP_FMT("sig: %d   task %s:%d", sig, p->comm, p->pid),
         TRACE_STRUCT(
                 TRACE_FIELD(int, sig, sig)
                 TRACE_FIELD(pid_t, pid, p->pid)
         ),
-        TPRAWFMT("sig: %d  task %d")
+        TP_RAW_FMT("sig: %d  task %d")
         );
 
 #undef TRACE_SYSTEM
diff --git a/include/trace/workqueue.h b/include/trace/workqueue.h
index 867829df4571..7626523deeba 100644
--- a/include/trace/workqueue.h
+++ b/include/trace/workqueue.h
@@ -6,20 +6,20 @@
 #include <linux/sched.h>
 
 DECLARE_TRACE(workqueue_insertion,
-           TPPROTO(struct task_struct *wq_thread, struct work_struct *work),
-           TPARGS(wq_thread, work));
+           TP_PROTO(struct task_struct *wq_thread, struct work_struct *work),
+           TP_ARGS(wq_thread, work));
 
 DECLARE_TRACE(workqueue_execution,
-           TPPROTO(struct task_struct *wq_thread, struct work_struct *work),
-           TPARGS(wq_thread, work));
+           TP_PROTO(struct task_struct *wq_thread, struct work_struct *work),
+           TP_ARGS(wq_thread, work));
 
 /* Trace the creation of one workqueue thread on a cpu */
 DECLARE_TRACE(workqueue_creation,
-           TPPROTO(struct task_struct *wq_thread, int cpu),
-           TPARGS(wq_thread, cpu));
+           TP_PROTO(struct task_struct *wq_thread, int cpu),
+           TP_ARGS(wq_thread, cpu));
 
 DECLARE_TRACE(workqueue_destruction,
-           TPPROTO(struct task_struct *wq_thread),
-           TPARGS(wq_thread));
+           TP_PROTO(struct task_struct *wq_thread),
+           TP_ARGS(wq_thread));
 
 #endif /* __TRACE_WORKQUEUE_H */