tracing/events: move trace point headers into include/trace/events

Impact: clean up Create a sub directory in include/trace called events to keep the trace point headers in their own separate directory. Only headers that declare trace points should be defined in this directory. Cc: Peter Zijlstra <a.p.zijlstra@chello.nl> Cc: Thomas Gleixner <tglx@linutronix.de> Cc: Neil Horman <nhorman@tuxdriver.com> Cc: Zhao Lei <zhaolei@cn.fujitsu.com> Cc: Eduard - Gabriel Munteanu <eduard.munteanu@linux360.ro> Cc: Pekka Enberg <penberg@cs.helsinki.fi> Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

tracing/events: move trace point headers into include/trace/events
Impact: clean up Create a sub directory in include/trace called events to keep the trace point headers in their own separate directory. Only headers that declare trace points should be defined in this directory. Cc: Peter Zijlstra <a.p.zijlstra@chello.nl> Cc: Thomas Gleixner <tglx@linutronix.de> Cc: Neil Horman <nhorman@tuxdriver.com> Cc: Zhao Lei <zhaolei@cn.fujitsu.com> Cc: Eduard - Gabriel Munteanu <eduard.munteanu@linux360.ro> Cc: Pekka Enberg <penberg@cs.helsinki.fi> Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Steven Rostedt · Steven Rostedt
1 parent ecda8ae02a
Showing 27 changed files with 708 additions and 707 deletions Side-by-side Diff
include/linux/kmemtrace.h
include/trace/define_trace.h
include/trace/events/irq.h
include/trace/events/kmem.h
include/trace/events/lockdep.h
include/trace/events/sched.h
include/trace/events/skb.h
include/trace/irq.h
include/trace/kmem.h
include/trace/lockdep.h
include/trace/sched.h
include/trace/skb.h
kernel/exit.c
kernel/fork.c
kernel/irq/handle.c
kernel/kthread.c
kernel/lockdep.c
kernel/sched.c
kernel/signal.c
kernel/softirq.c
@@ -9,7 +9,7 @@
  
 #ifdef __KERNEL__
  
-#include <trace/kmem.h>
+#include <trace/events/kmem.h>
  
 #ifdef CONFIG_KMEMTRACE
 extern void kmemtrace_init(void);
@@ -43,7 +43,7 @@
 #endif
  
 #ifndef TRACE_INCLUDE_PATH
-# define __TRACE_INCLUDE(system) <trace/system.h>
+# define __TRACE_INCLUDE(system) <trace/events/system.h>
 # define UNDEF_TRACE_INCLUDE_FILE
 #else
 # define __TRACE_INCLUDE(system) __stringify(TRACE_INCLUDE_PATH/system.h)
+#if !defined(_TRACE_IRQ_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_IRQ_H
+
+#include <linux/tracepoint.h>
+#include <linux/interrupt.h>
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM irq
+
+/*
+ * Tracepoint for entry of interrupt handler:
+ */
+TRACE_FORMAT(irq_handler_entry,
+	TP_PROTO(int irq, struct irqaction *action),
+	TP_ARGS(irq, action),
+	TP_FMT("irq=%d handler=%s", irq, action->name)
+	);
+
+/*
+ * Tracepoint for return of an interrupt handler:
+ */
+TRACE_EVENT(irq_handler_exit,
+
+	TP_PROTO(int irq, struct irqaction *action, int ret),
+
+	TP_ARGS(irq, action, ret),
+
+	TP_STRUCT__entry(
+		__field(	int,	irq	)
+		__field(	int,	ret	)
+	),
+
+	TP_fast_assign(
+		__entry->irq	= irq;
+		__entry->ret	= ret;
+	),
+
+	TP_printk("irq=%d return=%s",
+		  __entry->irq, __entry->ret ? "handled" : "unhandled")
+);
+
+TRACE_FORMAT(softirq_entry,
+	TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
+	TP_ARGS(h, vec),
+	TP_FMT("softirq=%d action=%s", (int)(h - vec), softirq_to_name[h-vec])
+	);
+
+TRACE_FORMAT(softirq_exit,
+	TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
+	TP_ARGS(h, vec),
+	TP_FMT("softirq=%d action=%s", (int)(h - vec), softirq_to_name[h-vec])
+	);
+
+#endif /*  _TRACE_IRQ_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
+#if !defined(_TRACE_KMEM_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_KMEM_H
+
+#include <linux/types.h>
+#include <linux/tracepoint.h>
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM kmem
+
+TRACE_EVENT(kmalloc,
+
+	TP_PROTO(unsigned long call_site,
+		 const void *ptr,
+		 size_t bytes_req,
+		 size_t bytes_alloc,
+		 gfp_t gfp_flags),
+
+	TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags),
+
+	TP_STRUCT__entry(
+		__field(	unsigned long,	call_site	)
+		__field(	const void *,	ptr		)
+		__field(	size_t,		bytes_req	)
+		__field(	size_t,		bytes_alloc	)
+		__field(	gfp_t,		gfp_flags	)
+	),
+
+	TP_fast_assign(
+		__entry->call_site	= call_site;
+		__entry->ptr		= ptr;
+		__entry->bytes_req	= bytes_req;
+		__entry->bytes_alloc	= bytes_alloc;
+		__entry->gfp_flags	= gfp_flags;
+	),
+
+	TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x",
+		__entry->call_site,
+		__entry->ptr,
+		__entry->bytes_req,
+		__entry->bytes_alloc,
+		__entry->gfp_flags)
+);
+
+TRACE_EVENT(kmem_cache_alloc,
+
+	TP_PROTO(unsigned long call_site,
+		 const void *ptr,
+		 size_t bytes_req,
+		 size_t bytes_alloc,
+		 gfp_t gfp_flags),
+
+	TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags),
+
+	TP_STRUCT__entry(
+		__field(	unsigned long,	call_site	)
+		__field(	const void *,	ptr		)
+		__field(	size_t,		bytes_req	)
+		__field(	size_t,		bytes_alloc	)
+		__field(	gfp_t,		gfp_flags	)
+	),
+
+	TP_fast_assign(
+		__entry->call_site	= call_site;
+		__entry->ptr		= ptr;
+		__entry->bytes_req	= bytes_req;
+		__entry->bytes_alloc	= bytes_alloc;
+		__entry->gfp_flags	= gfp_flags;
+	),
+
+	TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x",
+		__entry->call_site,
+		__entry->ptr,
+		__entry->bytes_req,
+		__entry->bytes_alloc,
+		__entry->gfp_flags)
+);
+
+TRACE_EVENT(kmalloc_node,
+
+	TP_PROTO(unsigned long call_site,
+		 const void *ptr,
+		 size_t bytes_req,
+		 size_t bytes_alloc,
+		 gfp_t gfp_flags,
+		 int node),
+
+	TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node),
+
+	TP_STRUCT__entry(
+		__field(	unsigned long,	call_site	)
+		__field(	const void *,	ptr		)
+		__field(	size_t,		bytes_req	)
+		__field(	size_t,		bytes_alloc	)
+		__field(	gfp_t,		gfp_flags	)
+		__field(	int,		node		)
+	),
+
+	TP_fast_assign(
+		__entry->call_site	= call_site;
+		__entry->ptr		= ptr;
+		__entry->bytes_req	= bytes_req;
+		__entry->bytes_alloc	= bytes_alloc;
+		__entry->gfp_flags	= gfp_flags;
+		__entry->node		= node;
+	),
+
+	TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x node=%d",
+		__entry->call_site,
+		__entry->ptr,
+		__entry->bytes_req,
+		__entry->bytes_alloc,
+		__entry->gfp_flags,
+		__entry->node)
+);
+
+TRACE_EVENT(kmem_cache_alloc_node,
+
+	TP_PROTO(unsigned long call_site,
+		 const void *ptr,
+		 size_t bytes_req,
+		 size_t bytes_alloc,
+		 gfp_t gfp_flags,
+		 int node),
+
+	TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node),
+
+	TP_STRUCT__entry(
+		__field(	unsigned long,	call_site	)
+		__field(	const void *,	ptr		)
+		__field(	size_t,		bytes_req	)
+		__field(	size_t,		bytes_alloc	)
+		__field(	gfp_t,		gfp_flags	)
+		__field(	int,		node		)
+	),
+
+	TP_fast_assign(
+		__entry->call_site	= call_site;
+		__entry->ptr		= ptr;
+		__entry->bytes_req	= bytes_req;
+		__entry->bytes_alloc	= bytes_alloc;
+		__entry->gfp_flags	= gfp_flags;
+		__entry->node		= node;
+	),
+
+	TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x node=%d",
+		__entry->call_site,
+		__entry->ptr,
+		__entry->bytes_req,
+		__entry->bytes_alloc,
+		__entry->gfp_flags,
+		__entry->node)
+);
+
+TRACE_EVENT(kfree,
+
+	TP_PROTO(unsigned long call_site, const void *ptr),
+
+	TP_ARGS(call_site, ptr),
+
+	TP_STRUCT__entry(
+		__field(	unsigned long,	call_site	)
+		__field(	const void *,	ptr		)
+	),
+
+	TP_fast_assign(
+		__entry->call_site	= call_site;
+		__entry->ptr		= ptr;
+	),
+
+	TP_printk("call_site=%lx ptr=%p", __entry->call_site, __entry->ptr)
+);
+
+TRACE_EVENT(kmem_cache_free,
+
+	TP_PROTO(unsigned long call_site, const void *ptr),
+
+	TP_ARGS(call_site, ptr),
+
+	TP_STRUCT__entry(
+		__field(	unsigned long,	call_site	)
+		__field(	const void *,	ptr		)
+	),
+
+	TP_fast_assign(
+		__entry->call_site	= call_site;
+		__entry->ptr		= ptr;
+	),
+
+	TP_printk("call_site=%lx ptr=%p", __entry->call_site, __entry->ptr)
+);
+#endif /* _TRACE_KMEM_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
+#if !defined(_TRACE_LOCKDEP_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_LOCKDEP_H
+
+#include <linux/lockdep.h>
+#include <linux/tracepoint.h>
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM lockdep
+
+#ifdef CONFIG_LOCKDEP
+
+TRACE_FORMAT(lock_acquire,
+	TP_PROTO(struct lockdep_map *lock, unsigned int subclass,
+		int trylock, int read, int check,
+		struct lockdep_map *next_lock, unsigned long ip),
+	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,
+	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,
+	TP_PROTO(struct lockdep_map *lock, unsigned long ip),
+	TP_ARGS(lock, ip),
+	TP_FMT("%s", lock->name)
+	);
+
+TRACE_EVENT(lock_acquired,
+	TP_PROTO(struct lockdep_map *lock, unsigned long ip, s64 waittime),
+
+	TP_ARGS(lock, ip, waittime),
+
+	TP_STRUCT__entry(
+		__field(const char *, name)
+		__field(unsigned long, wait_usec)
+		__field(unsigned long, wait_nsec_rem)
+	),
+	TP_fast_assign(
+		__entry->name = lock->name;
+		__entry->wait_nsec_rem = do_div(waittime, NSEC_PER_USEC);
+		__entry->wait_usec = (unsigned long) waittime;
+	),
+	TP_printk("%s (%lu.%03lu us)", __entry->name, __entry->wait_usec,
+				       __entry->wait_nsec_rem)
+);
+
+#endif
+#endif
+
+#endif /* _TRACE_LOCKDEP_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
+#if !defined(_TRACE_SCHED_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_SCHED_H
+
+#include <linux/sched.h>
+#include <linux/tracepoint.h>
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM sched
+
+/*
+ * Tracepoint for calling kthread_stop, performed to end a kthread:
+ */
+TRACE_EVENT(sched_kthread_stop,
+
+	TP_PROTO(struct task_struct *t),
+
+	TP_ARGS(t),
+
+	TP_STRUCT__entry(
+		__array(	char,	comm,	TASK_COMM_LEN	)
+		__field(	pid_t,	pid			)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->comm, t->comm, TASK_COMM_LEN);
+		__entry->pid	= t->pid;
+	),
+
+	TP_printk("task %s:%d", __entry->comm, __entry->pid)
+);
+
+/*
+ * Tracepoint for the return value of the kthread stopping:
+ */
+TRACE_EVENT(sched_kthread_stop_ret,
+
+	TP_PROTO(int ret),
+
+	TP_ARGS(ret),
+
+	TP_STRUCT__entry(
+		__field(	int,	ret	)
+	),
+
+	TP_fast_assign(
+		__entry->ret	= ret;
+	),
+
+	TP_printk("ret %d", __entry->ret)
+);
+
+/*
+ * Tracepoint for waiting on task to unschedule:
+ *
+ * (NOTE: the 'rq' argument is not used by generic trace events,
+ *        but used by the latency tracer plugin. )
+ */
+TRACE_EVENT(sched_wait_task,
+
+	TP_PROTO(struct rq *rq, struct task_struct *p),
+
+	TP_ARGS(rq, p),
+
+	TP_STRUCT__entry(
+		__array(	char,	comm,	TASK_COMM_LEN	)
+		__field(	pid_t,	pid			)
+		__field(	int,	prio			)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
+		__entry->pid	= p->pid;
+		__entry->prio	= p->prio;
+	),
+
+	TP_printk("task %s:%d [%d]",
+		  __entry->comm, __entry->pid, __entry->prio)
+);
+
+/*
+ * Tracepoint for waking up a task:
+ *
+ * (NOTE: the 'rq' argument is not used by generic trace events,
+ *        but used by the latency tracer plugin. )
+ */
+TRACE_EVENT(sched_wakeup,
+
+	TP_PROTO(struct rq *rq, struct task_struct *p, int success),
+
+	TP_ARGS(rq, p, success),
+
+	TP_STRUCT__entry(
+		__array(	char,	comm,	TASK_COMM_LEN	)
+		__field(	pid_t,	pid			)
+		__field(	int,	prio			)
+		__field(	int,	success			)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
+		__entry->pid		= p->pid;
+		__entry->prio		= p->prio;
+		__entry->success	= success;
+	),
+
+	TP_printk("task %s:%d [%d] success=%d",
+		  __entry->comm, __entry->pid, __entry->prio,
+		  __entry->success)
+);
+
+/*
+ * Tracepoint for waking up a new task:
+ *
+ * (NOTE: the 'rq' argument is not used by generic trace events,
+ *        but used by the latency tracer plugin. )
+ */
+TRACE_EVENT(sched_wakeup_new,
+
+	TP_PROTO(struct rq *rq, struct task_struct *p, int success),
+
+	TP_ARGS(rq, p, success),
+
+	TP_STRUCT__entry(
+		__array(	char,	comm,	TASK_COMM_LEN	)
+		__field(	pid_t,	pid			)
+		__field(	int,	prio			)
+		__field(	int,	success			)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
+		__entry->pid		= p->pid;
+		__entry->prio		= p->prio;
+		__entry->success	= success;
+	),
+
+	TP_printk("task %s:%d [%d] success=%d",
+		  __entry->comm, __entry->pid, __entry->prio,
+		  __entry->success)
+);
+
+/*
+ * Tracepoint for task switches, performed by the scheduler:
+ *
+ * (NOTE: the 'rq' argument is not used by generic trace events,
+ *        but used by the latency tracer plugin. )
+ */
+TRACE_EVENT(sched_switch,
+
+	TP_PROTO(struct rq *rq, struct task_struct *prev,
+		 struct task_struct *next),
+
+	TP_ARGS(rq, prev, next),
+
+	TP_STRUCT__entry(
+		__array(	char,	prev_comm,	TASK_COMM_LEN	)
+		__field(	pid_t,	prev_pid			)
+		__field(	int,	prev_prio			)
+		__array(	char,	next_comm,	TASK_COMM_LEN	)
+		__field(	pid_t,	next_pid			)
+		__field(	int,	next_prio			)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
+		__entry->prev_pid	= prev->pid;
+		__entry->prev_prio	= prev->prio;
+		memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
+		__entry->next_pid	= next->pid;
+		__entry->next_prio	= next->prio;
+	),
+
+	TP_printk("task %s:%d [%d] ==> %s:%d [%d]",
+		__entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
+		__entry->next_comm, __entry->next_pid, __entry->next_prio)
+);
+
+/*
+ * Tracepoint for a task being migrated:
+ */
+TRACE_EVENT(sched_migrate_task,
+
+	TP_PROTO(struct task_struct *p, int orig_cpu, int dest_cpu),
+
+	TP_ARGS(p, orig_cpu, dest_cpu),
+
+	TP_STRUCT__entry(
+		__array(	char,	comm,	TASK_COMM_LEN	)
+		__field(	pid_t,	pid			)
+		__field(	int,	prio			)
+		__field(	int,	orig_cpu		)
+		__field(	int,	dest_cpu		)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
+		__entry->pid		= p->pid;
+		__entry->prio		= p->prio;
+		__entry->orig_cpu	= orig_cpu;
+		__entry->dest_cpu	= dest_cpu;
+	),
+
+	TP_printk("task %s:%d [%d] from: %d  to: %d",
+		  __entry->comm, __entry->pid, __entry->prio,
+		  __entry->orig_cpu, __entry->dest_cpu)
+);
+
+/*
+ * Tracepoint for freeing a task:
+ */
+TRACE_EVENT(sched_process_free,
+
+	TP_PROTO(struct task_struct *p),
+
+	TP_ARGS(p),
+
+	TP_STRUCT__entry(
+		__array(	char,	comm,	TASK_COMM_LEN	)
+		__field(	pid_t,	pid			)
+		__field(	int,	prio			)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
+		__entry->pid		= p->pid;
+		__entry->prio		= p->prio;
+	),
+
+	TP_printk("task %s:%d [%d]",
+		  __entry->comm, __entry->pid, __entry->prio)
+);
+
+/*
+ * Tracepoint for a task exiting:
+ */
+TRACE_EVENT(sched_process_exit,
+
+	TP_PROTO(struct task_struct *p),
+
+	TP_ARGS(p),
+
+	TP_STRUCT__entry(
+		__array(	char,	comm,	TASK_COMM_LEN	)
+		__field(	pid_t,	pid			)
+		__field(	int,	prio			)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
+		__entry->pid		= p->pid;
+		__entry->prio		= p->prio;
+	),
+
+	TP_printk("task %s:%d [%d]",
+		  __entry->comm, __entry->pid, __entry->prio)
+);
+
+/*
+ * Tracepoint for a waiting task:
+ */
+TRACE_EVENT(sched_process_wait,
+
+	TP_PROTO(struct pid *pid),
+
+	TP_ARGS(pid),
+
+	TP_STRUCT__entry(
+		__array(	char,	comm,	TASK_COMM_LEN	)
+		__field(	pid_t,	pid			)
+		__field(	int,	prio			)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+		__entry->pid		= pid_nr(pid);
+		__entry->prio		= current->prio;
+	),
+
+	TP_printk("task %s:%d [%d]",
+		  __entry->comm, __entry->pid, __entry->prio)
+);
+
+/*
+ * Tracepoint for do_fork:
+ */
+TRACE_EVENT(sched_process_fork,
+
+	TP_PROTO(struct task_struct *parent, struct task_struct *child),
+
+	TP_ARGS(parent, child),
+
+	TP_STRUCT__entry(
+		__array(	char,	parent_comm,	TASK_COMM_LEN	)
+		__field(	pid_t,	parent_pid			)
+		__array(	char,	child_comm,	TASK_COMM_LEN	)
+		__field(	pid_t,	child_pid			)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->parent_comm, parent->comm, TASK_COMM_LEN);
+		__entry->parent_pid	= parent->pid;
+		memcpy(__entry->child_comm, child->comm, TASK_COMM_LEN);
+		__entry->child_pid	= child->pid;
+	),
+
+	TP_printk("parent %s:%d  child %s:%d",
+		__entry->parent_comm, __entry->parent_pid,
+		__entry->child_comm, __entry->child_pid)
+);
+
+/*
+ * Tracepoint for sending a signal:
+ */
+TRACE_EVENT(sched_signal_send,
+
+	TP_PROTO(int sig, struct task_struct *p),
+
+	TP_ARGS(sig, p),
+
+	TP_STRUCT__entry(
+		__field(	int,	sig			)
+		__array(	char,	comm,	TASK_COMM_LEN	)
+		__field(	pid_t,	pid			)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
+		__entry->pid	= p->pid;
+		__entry->sig	= sig;
+	),
+
+	TP_printk("sig: %d  task %s:%d",
+		  __entry->sig, __entry->comm, __entry->pid)
+);
+
+#endif /* _TRACE_SCHED_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
+#if !defined(_TRACE_SKB_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_SKB_H
+
+#include <linux/skbuff.h>
+#include <linux/tracepoint.h>
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM skb
+
+/*
+ * Tracepoint for free an sk_buff:
+ */
+TRACE_EVENT(kfree_skb,
+
+	TP_PROTO(struct sk_buff *skb, void *location),
+
+	TP_ARGS(skb, location),
+
+	TP_STRUCT__entry(
+		__field(	void *,		skbaddr		)
+		__field(	unsigned short,	protocol	)
+		__field(	void *,		location	)
+	),
+
+	TP_fast_assign(
+		__entry->skbaddr = skb;
+		if (skb) {
+			__entry->protocol = ntohs(skb->protocol);
+		}
+		__entry->location = location;
+	),
+
+	TP_printk("skbaddr=%p protocol=%u location=%p",
+		__entry->skbaddr, __entry->protocol, __entry->location)
+);
+
+#endif /* _TRACE_SKB_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
-#if !defined(_TRACE_IRQ_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_IRQ_H
-
-#include <linux/tracepoint.h>
-#include <linux/interrupt.h>
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM irq
-
-/*
- * Tracepoint for entry of interrupt handler:
- */
-TRACE_FORMAT(irq_handler_entry,
-	TP_PROTO(int irq, struct irqaction *action),
-	TP_ARGS(irq, action),
-	TP_FMT("irq=%d handler=%s", irq, action->name)
-	);
-
-/*
- * Tracepoint for return of an interrupt handler:
- */
-TRACE_EVENT(irq_handler_exit,
-
-	TP_PROTO(int irq, struct irqaction *action, int ret),
-
-	TP_ARGS(irq, action, ret),
-
-	TP_STRUCT__entry(
-		__field(	int,	irq	)
-		__field(	int,	ret	)
-	),
-
-	TP_fast_assign(
-		__entry->irq	= irq;
-		__entry->ret	= ret;
-	),
-
-	TP_printk("irq=%d return=%s",
-		  __entry->irq, __entry->ret ? "handled" : "unhandled")
-);
-
-TRACE_FORMAT(softirq_entry,
-	TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
-	TP_ARGS(h, vec),
-	TP_FMT("softirq=%d action=%s", (int)(h - vec), softirq_to_name[h-vec])
-	);
-
-TRACE_FORMAT(softirq_exit,
-	TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
-	TP_ARGS(h, vec),
-	TP_FMT("softirq=%d action=%s", (int)(h - vec), softirq_to_name[h-vec])
-	);
-
-#endif /*  _TRACE_IRQ_H */
-
-/* This part must be outside protection */
-#include <trace/define_trace.h>
-#if !defined(_TRACE_KMEM_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_KMEM_H
-
-#include <linux/types.h>
-#include <linux/tracepoint.h>
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM kmem
-
-TRACE_EVENT(kmalloc,
-
-	TP_PROTO(unsigned long call_site,
-		 const void *ptr,
-		 size_t bytes_req,
-		 size_t bytes_alloc,
-		 gfp_t gfp_flags),
-
-	TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags),
-
-	TP_STRUCT__entry(
-		__field(	unsigned long,	call_site	)
-		__field(	const void *,	ptr		)
-		__field(	size_t,		bytes_req	)
-		__field(	size_t,		bytes_alloc	)
-		__field(	gfp_t,		gfp_flags	)
-	),
-
-	TP_fast_assign(
-		__entry->call_site	= call_site;
-		__entry->ptr		= ptr;
-		__entry->bytes_req	= bytes_req;
-		__entry->bytes_alloc	= bytes_alloc;
-		__entry->gfp_flags	= gfp_flags;
-	),
-
-	TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x",
-		__entry->call_site,
-		__entry->ptr,
-		__entry->bytes_req,
-		__entry->bytes_alloc,
-		__entry->gfp_flags)
-);
-
-TRACE_EVENT(kmem_cache_alloc,
-
-	TP_PROTO(unsigned long call_site,
-		 const void *ptr,
-		 size_t bytes_req,
-		 size_t bytes_alloc,
-		 gfp_t gfp_flags),
-
-	TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags),
-
-	TP_STRUCT__entry(
-		__field(	unsigned long,	call_site	)
-		__field(	const void *,	ptr		)
-		__field(	size_t,		bytes_req	)
-		__field(	size_t,		bytes_alloc	)
-		__field(	gfp_t,		gfp_flags	)
-	),
-
-	TP_fast_assign(
-		__entry->call_site	= call_site;
-		__entry->ptr		= ptr;
-		__entry->bytes_req	= bytes_req;
-		__entry->bytes_alloc	= bytes_alloc;
-		__entry->gfp_flags	= gfp_flags;
-	),
-
-	TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x",
-		__entry->call_site,
-		__entry->ptr,
-		__entry->bytes_req,
-		__entry->bytes_alloc,
-		__entry->gfp_flags)
-);
-
-TRACE_EVENT(kmalloc_node,
-
-	TP_PROTO(unsigned long call_site,
-		 const void *ptr,
-		 size_t bytes_req,
-		 size_t bytes_alloc,
-		 gfp_t gfp_flags,
-		 int node),
-
-	TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node),
-
-	TP_STRUCT__entry(
-		__field(	unsigned long,	call_site	)
-		__field(	const void *,	ptr		)
-		__field(	size_t,		bytes_req	)
-		__field(	size_t,		bytes_alloc	)
-		__field(	gfp_t,		gfp_flags	)
-		__field(	int,		node		)
-	),
-
-	TP_fast_assign(
-		__entry->call_site	= call_site;
-		__entry->ptr		= ptr;
-		__entry->bytes_req	= bytes_req;
-		__entry->bytes_alloc	= bytes_alloc;
-		__entry->gfp_flags	= gfp_flags;
-		__entry->node		= node;
-	),
-
-	TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x node=%d",
-		__entry->call_site,
-		__entry->ptr,
-		__entry->bytes_req,
-		__entry->bytes_alloc,
-		__entry->gfp_flags,
-		__entry->node)
-);
-
-TRACE_EVENT(kmem_cache_alloc_node,
-
-	TP_PROTO(unsigned long call_site,
-		 const void *ptr,
-		 size_t bytes_req,
-		 size_t bytes_alloc,
-		 gfp_t gfp_flags,
-		 int node),
-
-	TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node),
-
-	TP_STRUCT__entry(
-		__field(	unsigned long,	call_site	)
-		__field(	const void *,	ptr		)
-		__field(	size_t,		bytes_req	)
-		__field(	size_t,		bytes_alloc	)
-		__field(	gfp_t,		gfp_flags	)
-		__field(	int,		node		)
-	),
-
-	TP_fast_assign(
-		__entry->call_site	= call_site;
-		__entry->ptr		= ptr;
-		__entry->bytes_req	= bytes_req;
-		__entry->bytes_alloc	= bytes_alloc;
-		__entry->gfp_flags	= gfp_flags;
-		__entry->node		= node;
-	),
-
-	TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x node=%d",
-		__entry->call_site,
-		__entry->ptr,
-		__entry->bytes_req,
-		__entry->bytes_alloc,
-		__entry->gfp_flags,
-		__entry->node)
-);
-
-TRACE_EVENT(kfree,
-
-	TP_PROTO(unsigned long call_site, const void *ptr),
-
-	TP_ARGS(call_site, ptr),
-
-	TP_STRUCT__entry(
-		__field(	unsigned long,	call_site	)
-		__field(	const void *,	ptr		)
-	),
-
-	TP_fast_assign(
-		__entry->call_site	= call_site;
-		__entry->ptr		= ptr;
-	),
-
-	TP_printk("call_site=%lx ptr=%p", __entry->call_site, __entry->ptr)
-);
-
-TRACE_EVENT(kmem_cache_free,
-
-	TP_PROTO(unsigned long call_site, const void *ptr),
-
-	TP_ARGS(call_site, ptr),
-
-	TP_STRUCT__entry(
-		__field(	unsigned long,	call_site	)
-		__field(	const void *,	ptr		)
-	),
-
-	TP_fast_assign(
-		__entry->call_site	= call_site;
-		__entry->ptr		= ptr;
-	),
-
-	TP_printk("call_site=%lx ptr=%p", __entry->call_site, __entry->ptr)
-);
-#endif /* _TRACE_KMEM_H */
-
-/* This part must be outside protection */
-#include <trace/define_trace.h>
-#if !defined(_TRACE_LOCKDEP_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_LOCKDEP_H
-
-#include <linux/lockdep.h>
-#include <linux/tracepoint.h>
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM lockdep
-
-#ifdef CONFIG_LOCKDEP
-
-TRACE_FORMAT(lock_acquire,
-	TP_PROTO(struct lockdep_map *lock, unsigned int subclass,
-		int trylock, int read, int check,
-		struct lockdep_map *next_lock, unsigned long ip),
-	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,
-	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,
-	TP_PROTO(struct lockdep_map *lock, unsigned long ip),
-	TP_ARGS(lock, ip),
-	TP_FMT("%s", lock->name)
-	);
-
-TRACE_EVENT(lock_acquired,
-	TP_PROTO(struct lockdep_map *lock, unsigned long ip, s64 waittime),
-
-	TP_ARGS(lock, ip, waittime),
-
-	TP_STRUCT__entry(
-		__field(const char *, name)
-		__field(unsigned long, wait_usec)
-		__field(unsigned long, wait_nsec_rem)
-	),
-	TP_fast_assign(
-		__entry->name = lock->name;
-		__entry->wait_nsec_rem = do_div(waittime, NSEC_PER_USEC);
-		__entry->wait_usec = (unsigned long) waittime;
-	),
-	TP_printk("%s (%lu.%03lu us)", __entry->name, __entry->wait_usec,
-				       __entry->wait_nsec_rem)
-);
-
-#endif
-#endif
-
-#endif /* _TRACE_LOCKDEP_H */
-
-/* This part must be outside protection */
-#include <trace/define_trace.h>
-#if !defined(_TRACE_SCHED_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_SCHED_H
-
-#include <linux/sched.h>
-#include <linux/tracepoint.h>
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM sched
-
-/*
- * Tracepoint for calling kthread_stop, performed to end a kthread:
- */
-TRACE_EVENT(sched_kthread_stop,
-
-	TP_PROTO(struct task_struct *t),
-
-	TP_ARGS(t),
-
-	TP_STRUCT__entry(
-		__array(	char,	comm,	TASK_COMM_LEN	)
-		__field(	pid_t,	pid			)
-	),
-
-	TP_fast_assign(
-		memcpy(__entry->comm, t->comm, TASK_COMM_LEN);
-		__entry->pid	= t->pid;
-	),
-
-	TP_printk("task %s:%d", __entry->comm, __entry->pid)
-);
-
-/*
- * Tracepoint for the return value of the kthread stopping:
- */
-TRACE_EVENT(sched_kthread_stop_ret,
-
-	TP_PROTO(int ret),
-
-	TP_ARGS(ret),
-
-	TP_STRUCT__entry(
-		__field(	int,	ret	)
-	),
-
-	TP_fast_assign(
-		__entry->ret	= ret;
-	),
-
-	TP_printk("ret %d", __entry->ret)
-);
-
-/*
- * Tracepoint for waiting on task to unschedule:
- *
- * (NOTE: the 'rq' argument is not used by generic trace events,
- *        but used by the latency tracer plugin. )
- */
-TRACE_EVENT(sched_wait_task,
-
-	TP_PROTO(struct rq *rq, struct task_struct *p),
-
-	TP_ARGS(rq, p),
-
-	TP_STRUCT__entry(
-		__array(	char,	comm,	TASK_COMM_LEN	)
-		__field(	pid_t,	pid			)
-		__field(	int,	prio			)
-	),
-
-	TP_fast_assign(
-		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
-		__entry->pid	= p->pid;
-		__entry->prio	= p->prio;
-	),
-
-	TP_printk("task %s:%d [%d]",
-		  __entry->comm, __entry->pid, __entry->prio)
-);
-
-/*
- * Tracepoint for waking up a task:
- *
- * (NOTE: the 'rq' argument is not used by generic trace events,
- *        but used by the latency tracer plugin. )
- */
-TRACE_EVENT(sched_wakeup,
-
-	TP_PROTO(struct rq *rq, struct task_struct *p, int success),
-
-	TP_ARGS(rq, p, success),
-
-	TP_STRUCT__entry(
-		__array(	char,	comm,	TASK_COMM_LEN	)
-		__field(	pid_t,	pid			)
-		__field(	int,	prio			)
-		__field(	int,	success			)
-	),
-
-	TP_fast_assign(
-		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
-		__entry->pid		= p->pid;
-		__entry->prio		= p->prio;
-		__entry->success	= success;
-	),
-
-	TP_printk("task %s:%d [%d] success=%d",
-		  __entry->comm, __entry->pid, __entry->prio,
-		  __entry->success)
-);
-
-/*
- * Tracepoint for waking up a new task:
- *
- * (NOTE: the 'rq' argument is not used by generic trace events,
- *        but used by the latency tracer plugin. )
- */
-TRACE_EVENT(sched_wakeup_new,
-
-	TP_PROTO(struct rq *rq, struct task_struct *p, int success),
-
-	TP_ARGS(rq, p, success),
-
-	TP_STRUCT__entry(
-		__array(	char,	comm,	TASK_COMM_LEN	)
-		__field(	pid_t,	pid			)
-		__field(	int,	prio			)
-		__field(	int,	success			)
-	),
-
-	TP_fast_assign(
-		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
-		__entry->pid		= p->pid;
-		__entry->prio		= p->prio;
-		__entry->success	= success;
-	),
-
-	TP_printk("task %s:%d [%d] success=%d",
-		  __entry->comm, __entry->pid, __entry->prio,
-		  __entry->success)
-);
-
-/*
- * Tracepoint for task switches, performed by the scheduler:
- *
- * (NOTE: the 'rq' argument is not used by generic trace events,
- *        but used by the latency tracer plugin. )
- */
-TRACE_EVENT(sched_switch,
-
-	TP_PROTO(struct rq *rq, struct task_struct *prev,
-		 struct task_struct *next),
-
-	TP_ARGS(rq, prev, next),
-
-	TP_STRUCT__entry(
-		__array(	char,	prev_comm,	TASK_COMM_LEN	)
-		__field(	pid_t,	prev_pid			)
-		__field(	int,	prev_prio			)
-		__array(	char,	next_comm,	TASK_COMM_LEN	)
-		__field(	pid_t,	next_pid			)
-		__field(	int,	next_prio			)
-	),
-
-	TP_fast_assign(
-		memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
-		__entry->prev_pid	= prev->pid;
-		__entry->prev_prio	= prev->prio;
-		memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
-		__entry->next_pid	= next->pid;
-		__entry->next_prio	= next->prio;
-	),
-
-	TP_printk("task %s:%d [%d] ==> %s:%d [%d]",
-		__entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
-		__entry->next_comm, __entry->next_pid, __entry->next_prio)
-);
-
-/*
- * Tracepoint for a task being migrated:
- */
-TRACE_EVENT(sched_migrate_task,
-
-	TP_PROTO(struct task_struct *p, int orig_cpu, int dest_cpu),
-
-	TP_ARGS(p, orig_cpu, dest_cpu),
-
-	TP_STRUCT__entry(
-		__array(	char,	comm,	TASK_COMM_LEN	)
-		__field(	pid_t,	pid			)
-		__field(	int,	prio			)
-		__field(	int,	orig_cpu		)
-		__field(	int,	dest_cpu		)
-	),
-
-	TP_fast_assign(
-		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
-		__entry->pid		= p->pid;
-		__entry->prio		= p->prio;
-		__entry->orig_cpu	= orig_cpu;
-		__entry->dest_cpu	= dest_cpu;
-	),
-
-	TP_printk("task %s:%d [%d] from: %d  to: %d",
-		  __entry->comm, __entry->pid, __entry->prio,
-		  __entry->orig_cpu, __entry->dest_cpu)
-);
-
-/*
- * Tracepoint for freeing a task:
- */
-TRACE_EVENT(sched_process_free,
-
-	TP_PROTO(struct task_struct *p),
-
-	TP_ARGS(p),
-
-	TP_STRUCT__entry(
-		__array(	char,	comm,	TASK_COMM_LEN	)
-		__field(	pid_t,	pid			)
-		__field(	int,	prio			)
-	),
-
-	TP_fast_assign(
-		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
-		__entry->pid		= p->pid;
-		__entry->prio		= p->prio;
-	),
-
-	TP_printk("task %s:%d [%d]",
-		  __entry->comm, __entry->pid, __entry->prio)
-);
-
-/*
- * Tracepoint for a task exiting:
- */
-TRACE_EVENT(sched_process_exit,
-
-	TP_PROTO(struct task_struct *p),
-
-	TP_ARGS(p),
-
-	TP_STRUCT__entry(
-		__array(	char,	comm,	TASK_COMM_LEN	)
-		__field(	pid_t,	pid			)
-		__field(	int,	prio			)
-	),
-
-	TP_fast_assign(
-		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
-		__entry->pid		= p->pid;
-		__entry->prio		= p->prio;
-	),
-
-	TP_printk("task %s:%d [%d]",
-		  __entry->comm, __entry->pid, __entry->prio)
-);
-
-/*
- * Tracepoint for a waiting task:
- */
-TRACE_EVENT(sched_process_wait,
-
-	TP_PROTO(struct pid *pid),
-
-	TP_ARGS(pid),
-
-	TP_STRUCT__entry(
-		__array(	char,	comm,	TASK_COMM_LEN	)
-		__field(	pid_t,	pid			)
-		__field(	int,	prio			)
-	),
-
-	TP_fast_assign(
-		memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
-		__entry->pid		= pid_nr(pid);
-		__entry->prio		= current->prio;
-	),
-
-	TP_printk("task %s:%d [%d]",
-		  __entry->comm, __entry->pid, __entry->prio)
-);
-
-/*
- * Tracepoint for do_fork:
- */
-TRACE_EVENT(sched_process_fork,
-
-	TP_PROTO(struct task_struct *parent, struct task_struct *child),
-
-	TP_ARGS(parent, child),
-
-	TP_STRUCT__entry(
-		__array(	char,	parent_comm,	TASK_COMM_LEN	)
-		__field(	pid_t,	parent_pid			)
-		__array(	char,	child_comm,	TASK_COMM_LEN	)
-		__field(	pid_t,	child_pid			)
-	),
-
-	TP_fast_assign(
-		memcpy(__entry->parent_comm, parent->comm, TASK_COMM_LEN);
-		__entry->parent_pid	= parent->pid;
-		memcpy(__entry->child_comm, child->comm, TASK_COMM_LEN);
-		__entry->child_pid	= child->pid;
-	),
-
-	TP_printk("parent %s:%d  child %s:%d",
-		__entry->parent_comm, __entry->parent_pid,
-		__entry->child_comm, __entry->child_pid)
-);
-
-/*
- * Tracepoint for sending a signal:
- */
-TRACE_EVENT(sched_signal_send,
-
-	TP_PROTO(int sig, struct task_struct *p),
-
-	TP_ARGS(sig, p),
-
-	TP_STRUCT__entry(
-		__field(	int,	sig			)
-		__array(	char,	comm,	TASK_COMM_LEN	)
-		__field(	pid_t,	pid			)
-	),
-
-	TP_fast_assign(
-		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
-		__entry->pid	= p->pid;
-		__entry->sig	= sig;
-	),
-
-	TP_printk("sig: %d  task %s:%d",
-		  __entry->sig, __entry->comm, __entry->pid)
-);
-
-#endif /* _TRACE_SCHED_H */
-
-/* This part must be outside protection */
-#include <trace/define_trace.h>
-#if !defined(_TRACE_SKB_H) || defined(TRACE_HEADER_MULTI_READ)
-#define _TRACE_SKB_H
-
-#include <linux/skbuff.h>
-#include <linux/tracepoint.h>
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM skb
-
-/*
- * Tracepoint for free an sk_buff:
- */
-TRACE_EVENT(kfree_skb,
-
-	TP_PROTO(struct sk_buff *skb, void *location),
-
-	TP_ARGS(skb, location),
-
-	TP_STRUCT__entry(
-		__field(	void *,		skbaddr		)
-		__field(	unsigned short,	protocol	)
-		__field(	void *,		location	)
-	),
-
-	TP_fast_assign(
-		__entry->skbaddr = skb;
-		if (skb) {
-			__entry->protocol = ntohs(skb->protocol);
-		}
-		__entry->location = location;
-	),
-
-	TP_printk("skbaddr=%p protocol=%u location=%p",
-		__entry->skbaddr, __entry->protocol, __entry->location)
-);
-
-#endif /* _TRACE_SKB_H */
-
-/* This part must be outside protection */
-#include <trace/define_trace.h>
@@ -48,7 +48,7 @@
 #include <linux/tracehook.h>
 #include <linux/fs_struct.h>
 #include <linux/init_task.h>
-#include <trace/sched.h>
+#include <trace/events/sched.h>
  
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -61,7 +61,6 @@
 #include <linux/proc_fs.h>
 #include <linux/blkdev.h>
 #include <linux/fs_struct.h>
-#include <trace/sched.h>
 #include <linux/magic.h>
  
 #include <asm/pgtable.h>
@@ -70,6 +69,8 @@
 #include <asm/mmu_context.h>
 #include <asm/cacheflush.h>
 #include <asm/tlbflush.h>
+
+#include <trace/events/sched.h>
  
 /*
  * Protected counters by write_lock_irq(&tasklist_lock)
@@ -20,7 +20,7 @@
 #include <linux/bootmem.h>
  
 #define CREATE_TRACE_POINTS
-#include <trace/irq.h>
+#include <trace/events/irq.h>
  
 #include "internals.h"
  
@@ -13,7 +13,7 @@
 #include <linux/file.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
-#include <trace/sched.h>
+#include <trace/events/sched.h>
  
 #define KTHREAD_NICE_LEVEL (-5)
  
@@ -48,7 +48,7 @@
 #include "lockdep_internals.h"
  
 #define CREATE_TRACE_POINTS
-#include <trace/lockdep.h>
+#include <trace/events/lockdep.h>
  
 #ifdef CONFIG_PROVE_LOCKING
 int prove_locking = 1;
@@ -79,7 +79,7 @@
 #include "sched_cpupri.h"
  
 #define CREATE_TRACE_POINTS
-#include <trace/sched.h>
+#include <trace/events/sched.h>
  
 /*
  * Convert user-nice values [ -20 ... 0 ... 19 ]
@@ -27,7 +27,7 @@
 #include <linux/freezer.h>
 #include <linux/pid_namespace.h>
 #include <linux/nsproxy.h>
-#include <trace/sched.h>
+#include <trace/events/sched.h>
  
 #include <asm/param.h>
 #include <asm/uaccess.h>
@@ -24,7 +24,7 @@
 #include <linux/ftrace.h>
 #include <linux/smp.h>
 #include <linux/tick.h>
-#include <trace/irq.h>
+#include <trace/events/irq.h>
  
 #include <asm/irq.h>
 /*
@@ -29,7 +29,7 @@
 #include <linux/list.h>
 #include <linux/hash.h>
  
-#include <trace/sched.h>
+#include <trace/events/sched.h>
  
 #include <asm/ftrace.h>
  
@@ -10,7 +10,7 @@
 #include <linux/kallsyms.h>
 #include <linux/uaccess.h>
 #include <linux/ftrace.h>
-#include <trace/sched.h>
+#include <trace/events/sched.h>
  
 #include "trace.h"
  
@@ -15,7 +15,7 @@
 #include <linux/kallsyms.h>
 #include <linux/uaccess.h>
 #include <linux/ftrace.h>
-#include <trace/sched.h>
+#include <trace/events/sched.h>
  
 #include "trace.h"
  
@@ -7,7 +7,7 @@
 #include <asm/uaccess.h>
  
 #define CREATE_TRACE_POINTS
-#include <trace/kmem.h>
+#include <trace/events/kmem.h>
  
 /**
  * kstrdup - allocate space for and copy an existing string
@@ -23,7 +23,7 @@
 #include <linux/bitops.h>
 #include <net/genetlink.h>
  
-#include <trace/skb.h>
+#include <trace/events/skb.h>
  
 #include <asm/unaligned.h>
  
@@ -24,7 +24,7 @@
 #include <asm/bitops.h>
  
 #define CREATE_TRACE_POINTS
-#include <trace/skb.h>
+#include <trace/events/skb.h>
  
 EXPORT_TRACEPOINT_SYMBOL_GPL(kfree_skb);
@@ -65,7 +65,7 @@
  
 #include <asm/uaccess.h>
 #include <asm/system.h>
-#include <trace/skb.h>
+#include <trace/events/skb.h>
  
 #include "kmap_skb.h"
...	...	@@ -9,7 +9,7 @@
9	9
10	10	#ifdef __KERNEL__
11	11
12		-#include <trace/kmem.h>
	12	+#include <trace/events/kmem.h>
13	13
14	14	#ifdef CONFIG_KMEMTRACE
15	15	extern void kmemtrace_init(void);
...	...	@@ -43,7 +43,7 @@
43	43	#endif
44	44
45	45	#ifndef TRACE_INCLUDE_PATH
46		-# define __TRACE_INCLUDE(system) <trace/system.h>
	46	+# define __TRACE_INCLUDE(system) <trace/events/system.h>
47	47	# define UNDEF_TRACE_INCLUDE_FILE
48	48	#else
49	49	# define __TRACE_INCLUDE(system) __stringify(TRACE_INCLUDE_PATH/system.h)
	1	+#if !defined(_TRACE_IRQ_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	2	+#define _TRACE_IRQ_H
	3	+
	4	+#include <linux/tracepoint.h>
	5	+#include <linux/interrupt.h>
	6	+
	7	+#undef TRACE_SYSTEM
	8	+#define TRACE_SYSTEM irq
	9	+
	10	+/*
	11	+ * Tracepoint for entry of interrupt handler:
	12	+ */
	13	+TRACE_FORMAT(irq_handler_entry,
	14	+ TP_PROTO(int irq, struct irqaction *action),
	15	+ TP_ARGS(irq, action),
	16	+ TP_FMT("irq=%d handler=%s", irq, action->name)
	17	+ );
	18	+
	19	+/*
	20	+ * Tracepoint for return of an interrupt handler:
	21	+ */
	22	+TRACE_EVENT(irq_handler_exit,
	23	+
	24	+ TP_PROTO(int irq, struct irqaction *action, int ret),
	25	+
	26	+ TP_ARGS(irq, action, ret),
	27	+
	28	+ TP_STRUCT__entry(
	29	+ __field( int, irq )
	30	+ __field( int, ret )
	31	+ ),
	32	+
	33	+ TP_fast_assign(
	34	+ __entry->irq = irq;
	35	+ __entry->ret = ret;
	36	+ ),
	37	+
	38	+ TP_printk("irq=%d return=%s",
	39	+ __entry->irq, __entry->ret ? "handled" : "unhandled")
	40	+);
	41	+
	42	+TRACE_FORMAT(softirq_entry,
	43	+ TP_PROTO(struct softirq_action h, struct softirq_action vec),
	44	+ TP_ARGS(h, vec),
	45	+ TP_FMT("softirq=%d action=%s", (int)(h - vec), softirq_to_name[h-vec])
	46	+ );
	47	+
	48	+TRACE_FORMAT(softirq_exit,
	49	+ TP_PROTO(struct softirq_action h, struct softirq_action vec),
	50	+ TP_ARGS(h, vec),
	51	+ TP_FMT("softirq=%d action=%s", (int)(h - vec), softirq_to_name[h-vec])
	52	+ );
	53	+
	54	+#endif /* _TRACE_IRQ_H */
	55	+
	56	+/* This part must be outside protection */
	57	+#include <trace/define_trace.h>
	1	+#if !defined(_TRACE_KMEM_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	2	+#define _TRACE_KMEM_H
	3	+
	4	+#include <linux/types.h>
	5	+#include <linux/tracepoint.h>
	6	+
	7	+#undef TRACE_SYSTEM
	8	+#define TRACE_SYSTEM kmem
	9	+
	10	+TRACE_EVENT(kmalloc,
	11	+
	12	+ TP_PROTO(unsigned long call_site,
	13	+ const void *ptr,
	14	+ size_t bytes_req,
	15	+ size_t bytes_alloc,
	16	+ gfp_t gfp_flags),
	17	+
	18	+ TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags),
	19	+
	20	+ TP_STRUCT__entry(
	21	+ __field( unsigned long, call_site )
	22	+ __field( const void *, ptr )
	23	+ __field( size_t, bytes_req )
	24	+ __field( size_t, bytes_alloc )
	25	+ __field( gfp_t, gfp_flags )
	26	+ ),
	27	+
	28	+ TP_fast_assign(
	29	+ __entry->call_site = call_site;
	30	+ __entry->ptr = ptr;
	31	+ __entry->bytes_req = bytes_req;
	32	+ __entry->bytes_alloc = bytes_alloc;
	33	+ __entry->gfp_flags = gfp_flags;
	34	+ ),
	35	+
	36	+ TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x",
	37	+ __entry->call_site,
	38	+ __entry->ptr,
	39	+ __entry->bytes_req,
	40	+ __entry->bytes_alloc,
	41	+ __entry->gfp_flags)
	42	+);
	43	+
	44	+TRACE_EVENT(kmem_cache_alloc,
	45	+
	46	+ TP_PROTO(unsigned long call_site,
	47	+ const void *ptr,
	48	+ size_t bytes_req,
	49	+ size_t bytes_alloc,
	50	+ gfp_t gfp_flags),
	51	+
	52	+ TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags),
	53	+
	54	+ TP_STRUCT__entry(
	55	+ __field( unsigned long, call_site )
	56	+ __field( const void *, ptr )
	57	+ __field( size_t, bytes_req )
	58	+ __field( size_t, bytes_alloc )
	59	+ __field( gfp_t, gfp_flags )
	60	+ ),
	61	+
	62	+ TP_fast_assign(
	63	+ __entry->call_site = call_site;
	64	+ __entry->ptr = ptr;
	65	+ __entry->bytes_req = bytes_req;
	66	+ __entry->bytes_alloc = bytes_alloc;
	67	+ __entry->gfp_flags = gfp_flags;
	68	+ ),
	69	+
	70	+ TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x",
	71	+ __entry->call_site,
	72	+ __entry->ptr,
	73	+ __entry->bytes_req,
	74	+ __entry->bytes_alloc,
	75	+ __entry->gfp_flags)
	76	+);
	77	+
	78	+TRACE_EVENT(kmalloc_node,
	79	+
	80	+ TP_PROTO(unsigned long call_site,
	81	+ const void *ptr,
	82	+ size_t bytes_req,
	83	+ size_t bytes_alloc,
	84	+ gfp_t gfp_flags,
	85	+ int node),
	86	+
	87	+ TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node),
	88	+
	89	+ TP_STRUCT__entry(
	90	+ __field( unsigned long, call_site )
	91	+ __field( const void *, ptr )
	92	+ __field( size_t, bytes_req )
	93	+ __field( size_t, bytes_alloc )
	94	+ __field( gfp_t, gfp_flags )
	95	+ __field( int, node )
	96	+ ),
	97	+
	98	+ TP_fast_assign(
	99	+ __entry->call_site = call_site;
	100	+ __entry->ptr = ptr;
	101	+ __entry->bytes_req = bytes_req;
	102	+ __entry->bytes_alloc = bytes_alloc;
	103	+ __entry->gfp_flags = gfp_flags;
	104	+ __entry->node = node;
	105	+ ),
	106	+
	107	+ TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x node=%d",
	108	+ __entry->call_site,
	109	+ __entry->ptr,
	110	+ __entry->bytes_req,
	111	+ __entry->bytes_alloc,
	112	+ __entry->gfp_flags,
	113	+ __entry->node)
	114	+);
	115	+
	116	+TRACE_EVENT(kmem_cache_alloc_node,
	117	+
	118	+ TP_PROTO(unsigned long call_site,
	119	+ const void *ptr,
	120	+ size_t bytes_req,
	121	+ size_t bytes_alloc,
	122	+ gfp_t gfp_flags,
	123	+ int node),
	124	+
	125	+ TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node),
	126	+
	127	+ TP_STRUCT__entry(
	128	+ __field( unsigned long, call_site )
	129	+ __field( const void *, ptr )
	130	+ __field( size_t, bytes_req )
	131	+ __field( size_t, bytes_alloc )
	132	+ __field( gfp_t, gfp_flags )
	133	+ __field( int, node )
	134	+ ),
	135	+
	136	+ TP_fast_assign(
	137	+ __entry->call_site = call_site;
	138	+ __entry->ptr = ptr;
	139	+ __entry->bytes_req = bytes_req;
	140	+ __entry->bytes_alloc = bytes_alloc;
	141	+ __entry->gfp_flags = gfp_flags;
	142	+ __entry->node = node;
	143	+ ),
	144	+
	145	+ TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x node=%d",
	146	+ __entry->call_site,
	147	+ __entry->ptr,
	148	+ __entry->bytes_req,
	149	+ __entry->bytes_alloc,
	150	+ __entry->gfp_flags,
	151	+ __entry->node)
	152	+);
	153	+
	154	+TRACE_EVENT(kfree,
	155	+
	156	+ TP_PROTO(unsigned long call_site, const void *ptr),
	157	+
	158	+ TP_ARGS(call_site, ptr),
	159	+
	160	+ TP_STRUCT__entry(
	161	+ __field( unsigned long, call_site )
	162	+ __field( const void *, ptr )
	163	+ ),
	164	+
	165	+ TP_fast_assign(
	166	+ __entry->call_site = call_site;
	167	+ __entry->ptr = ptr;
	168	+ ),
	169	+
	170	+ TP_printk("call_site=%lx ptr=%p", __entry->call_site, __entry->ptr)
	171	+);
	172	+
	173	+TRACE_EVENT(kmem_cache_free,
	174	+
	175	+ TP_PROTO(unsigned long call_site, const void *ptr),
	176	+
	177	+ TP_ARGS(call_site, ptr),
	178	+
	179	+ TP_STRUCT__entry(
	180	+ __field( unsigned long, call_site )
	181	+ __field( const void *, ptr )
	182	+ ),
	183	+
	184	+ TP_fast_assign(
	185	+ __entry->call_site = call_site;
	186	+ __entry->ptr = ptr;
	187	+ ),
	188	+
	189	+ TP_printk("call_site=%lx ptr=%p", __entry->call_site, __entry->ptr)
	190	+);
	191	+#endif /* _TRACE_KMEM_H */
	192	+
	193	+/* This part must be outside protection */
	194	+#include <trace/define_trace.h>
	1	+#if !defined(_TRACE_LOCKDEP_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	2	+#define _TRACE_LOCKDEP_H
	3	+
	4	+#include <linux/lockdep.h>
	5	+#include <linux/tracepoint.h>
	6	+
	7	+#undef TRACE_SYSTEM
	8	+#define TRACE_SYSTEM lockdep
	9	+
	10	+#ifdef CONFIG_LOCKDEP
	11	+
	12	+TRACE_FORMAT(lock_acquire,
	13	+ TP_PROTO(struct lockdep_map *lock, unsigned int subclass,
	14	+ int trylock, int read, int check,
	15	+ struct lockdep_map *next_lock, unsigned long ip),
	16	+ TP_ARGS(lock, subclass, trylock, read, check, next_lock, ip),
	17	+ TP_FMT("%s%s%s", trylock ? "try " : "",
	18	+ read ? "read " : "", lock->name)
	19	+ );
	20	+
	21	+TRACE_FORMAT(lock_release,
	22	+ TP_PROTO(struct lockdep_map *lock, int nested, unsigned long ip),
	23	+ TP_ARGS(lock, nested, ip),
	24	+ TP_FMT("%s", lock->name)
	25	+ );
	26	+
	27	+#ifdef CONFIG_LOCK_STAT
	28	+
	29	+TRACE_FORMAT(lock_contended,
	30	+ TP_PROTO(struct lockdep_map *lock, unsigned long ip),
	31	+ TP_ARGS(lock, ip),
	32	+ TP_FMT("%s", lock->name)
	33	+ );
	34	+
	35	+TRACE_EVENT(lock_acquired,
	36	+ TP_PROTO(struct lockdep_map *lock, unsigned long ip, s64 waittime),
	37	+
	38	+ TP_ARGS(lock, ip, waittime),
	39	+
	40	+ TP_STRUCT__entry(
	41	+ __field(const char *, name)
	42	+ __field(unsigned long, wait_usec)
	43	+ __field(unsigned long, wait_nsec_rem)
	44	+ ),
	45	+ TP_fast_assign(
	46	+ __entry->name = lock->name;
	47	+ __entry->wait_nsec_rem = do_div(waittime, NSEC_PER_USEC);
	48	+ __entry->wait_usec = (unsigned long) waittime;
	49	+ ),
	50	+ TP_printk("%s (%lu.%03lu us)", __entry->name, __entry->wait_usec,
	51	+ __entry->wait_nsec_rem)
	52	+);
	53	+
	54	+#endif
	55	+#endif
	56	+
	57	+#endif /* _TRACE_LOCKDEP_H */
	58	+
	59	+/* This part must be outside protection */
	60	+#include <trace/define_trace.h>
	1	+#if !defined(_TRACE_SCHED_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	2	+#define _TRACE_SCHED_H
	3	+
	4	+#include <linux/sched.h>
	5	+#include <linux/tracepoint.h>
	6	+
	7	+#undef TRACE_SYSTEM
	8	+#define TRACE_SYSTEM sched
	9	+
	10	+/*
	11	+ * Tracepoint for calling kthread_stop, performed to end a kthread:
	12	+ */
	13	+TRACE_EVENT(sched_kthread_stop,
	14	+
	15	+ TP_PROTO(struct task_struct *t),
	16	+
	17	+ TP_ARGS(t),
	18	+
	19	+ TP_STRUCT__entry(
	20	+ __array( char, comm, TASK_COMM_LEN )
	21	+ __field( pid_t, pid )
	22	+ ),
	23	+
	24	+ TP_fast_assign(
	25	+ memcpy(__entry->comm, t->comm, TASK_COMM_LEN);
	26	+ __entry->pid = t->pid;
	27	+ ),
	28	+
	29	+ TP_printk("task %s:%d", __entry->comm, __entry->pid)
	30	+);
	31	+
	32	+/*
	33	+ * Tracepoint for the return value of the kthread stopping:
	34	+ */
	35	+TRACE_EVENT(sched_kthread_stop_ret,
	36	+
	37	+ TP_PROTO(int ret),
	38	+
	39	+ TP_ARGS(ret),
	40	+
	41	+ TP_STRUCT__entry(
	42	+ __field( int, ret )
	43	+ ),
	44	+
	45	+ TP_fast_assign(
	46	+ __entry->ret = ret;
	47	+ ),
	48	+
	49	+ TP_printk("ret %d", __entry->ret)
	50	+);
	51	+
	52	+/*
	53	+ * Tracepoint for waiting on task to unschedule:
	54	+ *
	55	+ * (NOTE: the 'rq' argument is not used by generic trace events,
	56	+ * but used by the latency tracer plugin. )
	57	+ */
	58	+TRACE_EVENT(sched_wait_task,
	59	+
	60	+ TP_PROTO(struct rq rq, struct task_struct p),
	61	+
	62	+ TP_ARGS(rq, p),
	63	+
	64	+ TP_STRUCT__entry(
	65	+ __array( char, comm, TASK_COMM_LEN )
	66	+ __field( pid_t, pid )
	67	+ __field( int, prio )
	68	+ ),
	69	+
	70	+ TP_fast_assign(
	71	+ memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
	72	+ __entry->pid = p->pid;
	73	+ __entry->prio = p->prio;
	74	+ ),
	75	+
	76	+ TP_printk("task %s:%d [%d]",
	77	+ __entry->comm, __entry->pid, __entry->prio)
	78	+);
	79	+
	80	+/*
	81	+ * Tracepoint for waking up a task:
	82	+ *
	83	+ * (NOTE: the 'rq' argument is not used by generic trace events,
	84	+ * but used by the latency tracer plugin. )
	85	+ */
	86	+TRACE_EVENT(sched_wakeup,
	87	+
	88	+ TP_PROTO(struct rq rq, struct task_struct p, int success),
	89	+
	90	+ TP_ARGS(rq, p, success),
	91	+
	92	+ TP_STRUCT__entry(
	93	+ __array( char, comm, TASK_COMM_LEN )
	94	+ __field( pid_t, pid )
	95	+ __field( int, prio )
	96	+ __field( int, success )
	97	+ ),
	98	+
	99	+ TP_fast_assign(
	100	+ memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
	101	+ __entry->pid = p->pid;
	102	+ __entry->prio = p->prio;
	103	+ __entry->success = success;
	104	+ ),
	105	+
	106	+ TP_printk("task %s:%d [%d] success=%d",
	107	+ __entry->comm, __entry->pid, __entry->prio,
	108	+ __entry->success)
	109	+);
	110	+
	111	+/*
	112	+ * Tracepoint for waking up a new task:
	113	+ *
	114	+ * (NOTE: the 'rq' argument is not used by generic trace events,
	115	+ * but used by the latency tracer plugin. )
	116	+ */
	117	+TRACE_EVENT(sched_wakeup_new,
	118	+
	119	+ TP_PROTO(struct rq rq, struct task_struct p, int success),
	120	+
	121	+ TP_ARGS(rq, p, success),
	122	+
	123	+ TP_STRUCT__entry(
	124	+ __array( char, comm, TASK_COMM_LEN )
	125	+ __field( pid_t, pid )
	126	+ __field( int, prio )
	127	+ __field( int, success )
	128	+ ),
	129	+
	130	+ TP_fast_assign(
	131	+ memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
	132	+ __entry->pid = p->pid;
	133	+ __entry->prio = p->prio;
	134	+ __entry->success = success;
	135	+ ),
	136	+
	137	+ TP_printk("task %s:%d [%d] success=%d",
	138	+ __entry->comm, __entry->pid, __entry->prio,
	139	+ __entry->success)
	140	+);
	141	+
	142	+/*
	143	+ * Tracepoint for task switches, performed by the scheduler:
	144	+ *
	145	+ * (NOTE: the 'rq' argument is not used by generic trace events,
	146	+ * but used by the latency tracer plugin. )
	147	+ */
	148	+TRACE_EVENT(sched_switch,
	149	+
	150	+ TP_PROTO(struct rq rq, struct task_struct prev,
	151	+ struct task_struct *next),
	152	+
	153	+ TP_ARGS(rq, prev, next),
	154	+
	155	+ TP_STRUCT__entry(
	156	+ __array( char, prev_comm, TASK_COMM_LEN )
	157	+ __field( pid_t, prev_pid )
	158	+ __field( int, prev_prio )
	159	+ __array( char, next_comm, TASK_COMM_LEN )
	160	+ __field( pid_t, next_pid )
	161	+ __field( int, next_prio )
	162	+ ),
	163	+
	164	+ TP_fast_assign(
	165	+ memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
	166	+ __entry->prev_pid = prev->pid;
	167	+ __entry->prev_prio = prev->prio;
	168	+ memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
	169	+ __entry->next_pid = next->pid;
	170	+ __entry->next_prio = next->prio;
	171	+ ),
	172	+
	173	+ TP_printk("task %s:%d [%d] ==> %s:%d [%d]",
	174	+ __entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
	175	+ __entry->next_comm, __entry->next_pid, __entry->next_prio)
	176	+);
	177	+
	178	+/*
	179	+ * Tracepoint for a task being migrated:
	180	+ */
	181	+TRACE_EVENT(sched_migrate_task,
	182	+
	183	+ TP_PROTO(struct task_struct *p, int orig_cpu, int dest_cpu),
	184	+
	185	+ TP_ARGS(p, orig_cpu, dest_cpu),
	186	+
	187	+ TP_STRUCT__entry(
	188	+ __array( char, comm, TASK_COMM_LEN )
	189	+ __field( pid_t, pid )
	190	+ __field( int, prio )
	191	+ __field( int, orig_cpu )
	192	+ __field( int, dest_cpu )
	193	+ ),
	194	+
	195	+ TP_fast_assign(
	196	+ memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
	197	+ __entry->pid = p->pid;
	198	+ __entry->prio = p->prio;
	199	+ __entry->orig_cpu = orig_cpu;
	200	+ __entry->dest_cpu = dest_cpu;
	201	+ ),
	202	+
	203	+ TP_printk("task %s:%d [%d] from: %d to: %d",
	204	+ __entry->comm, __entry->pid, __entry->prio,
	205	+ __entry->orig_cpu, __entry->dest_cpu)
	206	+);
	207	+
	208	+/*
	209	+ * Tracepoint for freeing a task:
	210	+ */
	211	+TRACE_EVENT(sched_process_free,
	212	+
	213	+ TP_PROTO(struct task_struct *p),
	214	+
	215	+ TP_ARGS(p),
	216	+
	217	+ TP_STRUCT__entry(
	218	+ __array( char, comm, TASK_COMM_LEN )
	219	+ __field( pid_t, pid )
	220	+ __field( int, prio )
	221	+ ),
	222	+
	223	+ TP_fast_assign(
	224	+ memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
	225	+ __entry->pid = p->pid;
	226	+ __entry->prio = p->prio;
	227	+ ),
	228	+
	229	+ TP_printk("task %s:%d [%d]",
	230	+ __entry->comm, __entry->pid, __entry->prio)
	231	+);
	232	+
	233	+/*
	234	+ * Tracepoint for a task exiting:
	235	+ */
	236	+TRACE_EVENT(sched_process_exit,
	237	+
	238	+ TP_PROTO(struct task_struct *p),
	239	+
	240	+ TP_ARGS(p),
	241	+
	242	+ TP_STRUCT__entry(
	243	+ __array( char, comm, TASK_COMM_LEN )
	244	+ __field( pid_t, pid )
	245	+ __field( int, prio )
	246	+ ),
	247	+
	248	+ TP_fast_assign(
	249	+ memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
	250	+ __entry->pid = p->pid;
	251	+ __entry->prio = p->prio;
	252	+ ),
	253	+
	254	+ TP_printk("task %s:%d [%d]",
	255	+ __entry->comm, __entry->pid, __entry->prio)
	256	+);
	257	+
	258	+/*
	259	+ * Tracepoint for a waiting task:
	260	+ */
	261	+TRACE_EVENT(sched_process_wait,
	262	+
	263	+ TP_PROTO(struct pid *pid),
	264	+
	265	+ TP_ARGS(pid),
	266	+
	267	+ TP_STRUCT__entry(
	268	+ __array( char, comm, TASK_COMM_LEN )
	269	+ __field( pid_t, pid )
	270	+ __field( int, prio )
	271	+ ),
	272	+
	273	+ TP_fast_assign(
	274	+ memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
	275	+ __entry->pid = pid_nr(pid);
	276	+ __entry->prio = current->prio;
	277	+ ),
	278	+
	279	+ TP_printk("task %s:%d [%d]",
	280	+ __entry->comm, __entry->pid, __entry->prio)
	281	+);
	282	+
	283	+/*
	284	+ * Tracepoint for do_fork:
	285	+ */
	286	+TRACE_EVENT(sched_process_fork,
	287	+
	288	+ TP_PROTO(struct task_struct parent, struct task_struct child),
	289	+
	290	+ TP_ARGS(parent, child),
	291	+
	292	+ TP_STRUCT__entry(
	293	+ __array( char, parent_comm, TASK_COMM_LEN )
	294	+ __field( pid_t, parent_pid )
	295	+ __array( char, child_comm, TASK_COMM_LEN )
	296	+ __field( pid_t, child_pid )
	297	+ ),
	298	+
	299	+ TP_fast_assign(
	300	+ memcpy(__entry->parent_comm, parent->comm, TASK_COMM_LEN);
	301	+ __entry->parent_pid = parent->pid;
	302	+ memcpy(__entry->child_comm, child->comm, TASK_COMM_LEN);
	303	+ __entry->child_pid = child->pid;
	304	+ ),
	305	+
	306	+ TP_printk("parent %s:%d child %s:%d",
	307	+ __entry->parent_comm, __entry->parent_pid,
	308	+ __entry->child_comm, __entry->child_pid)
	309	+);
	310	+
	311	+/*
	312	+ * Tracepoint for sending a signal:
	313	+ */
	314	+TRACE_EVENT(sched_signal_send,
	315	+
	316	+ TP_PROTO(int sig, struct task_struct *p),
	317	+
	318	+ TP_ARGS(sig, p),
	319	+
	320	+ TP_STRUCT__entry(
	321	+ __field( int, sig )
	322	+ __array( char, comm, TASK_COMM_LEN )
	323	+ __field( pid_t, pid )
	324	+ ),
	325	+
	326	+ TP_fast_assign(
	327	+ memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
	328	+ __entry->pid = p->pid;
	329	+ __entry->sig = sig;
	330	+ ),
	331	+
	332	+ TP_printk("sig: %d task %s:%d",
	333	+ __entry->sig, __entry->comm, __entry->pid)
	334	+);
	335	+
	336	+#endif /* _TRACE_SCHED_H */
	337	+
	338	+/* This part must be outside protection */
	339	+#include <trace/define_trace.h>
	1	+#if !defined(_TRACE_SKB_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	2	+#define _TRACE_SKB_H
	3	+
	4	+#include <linux/skbuff.h>
	5	+#include <linux/tracepoint.h>
	6	+
	7	+#undef TRACE_SYSTEM
	8	+#define TRACE_SYSTEM skb
	9	+
	10	+/*
	11	+ * Tracepoint for free an sk_buff:
	12	+ */
	13	+TRACE_EVENT(kfree_skb,
	14	+
	15	+ TP_PROTO(struct sk_buff skb, void location),
	16	+
	17	+ TP_ARGS(skb, location),
	18	+
	19	+ TP_STRUCT__entry(
	20	+ __field( void *, skbaddr )
	21	+ __field( unsigned short, protocol )
	22	+ __field( void *, location )
	23	+ ),
	24	+
	25	+ TP_fast_assign(
	26	+ __entry->skbaddr = skb;
	27	+ if (skb) {
	28	+ __entry->protocol = ntohs(skb->protocol);
	29	+ }
	30	+ __entry->location = location;
	31	+ ),
	32	+
	33	+ TP_printk("skbaddr=%p protocol=%u location=%p",
	34	+ __entry->skbaddr, __entry->protocol, __entry->location)
	35	+);
	36	+
	37	+#endif /* _TRACE_SKB_H */
	38	+
	39	+/* This part must be outside protection */
	40	+#include <trace/define_trace.h>
1		-#if !defined(_TRACE_IRQ_H) \|\| defined(TRACE_HEADER_MULTI_READ)
2		-#define _TRACE_IRQ_H
3		-
4		-#include <linux/tracepoint.h>
5		-#include <linux/interrupt.h>
6		-
7		-#undef TRACE_SYSTEM
8		-#define TRACE_SYSTEM irq
9		-
10		-/*
11		- * Tracepoint for entry of interrupt handler:
12		- */
13		-TRACE_FORMAT(irq_handler_entry,
14		- TP_PROTO(int irq, struct irqaction *action),
15		- TP_ARGS(irq, action),
16		- TP_FMT("irq=%d handler=%s", irq, action->name)
17		- );
18		-
19		-/*
20		- * Tracepoint for return of an interrupt handler:
21		- */
22		-TRACE_EVENT(irq_handler_exit,
23		-
24		- TP_PROTO(int irq, struct irqaction *action, int ret),
25		-
26		- TP_ARGS(irq, action, ret),
27		-
28		- TP_STRUCT__entry(
29		- __field( int, irq )
30		- __field( int, ret )
31		- ),
32		-
33		- TP_fast_assign(
34		- __entry->irq = irq;
35		- __entry->ret = ret;
36		- ),
37		-
38		- TP_printk("irq=%d return=%s",
39		- __entry->irq, __entry->ret ? "handled" : "unhandled")
40		-);
41		-
42		-TRACE_FORMAT(softirq_entry,
43		- TP_PROTO(struct softirq_action h, struct softirq_action vec),
44		- TP_ARGS(h, vec),
45		- TP_FMT("softirq=%d action=%s", (int)(h - vec), softirq_to_name[h-vec])
46		- );
47		-
48		-TRACE_FORMAT(softirq_exit,
49		- TP_PROTO(struct softirq_action h, struct softirq_action vec),
50		- TP_ARGS(h, vec),
51		- TP_FMT("softirq=%d action=%s", (int)(h - vec), softirq_to_name[h-vec])
52		- );
53		-
54		-#endif /* _TRACE_IRQ_H */
55		-
56		-/* This part must be outside protection */
57		-#include <trace/define_trace.h>
1		-#if !defined(_TRACE_KMEM_H) \|\| defined(TRACE_HEADER_MULTI_READ)
2		-#define _TRACE_KMEM_H
3		-
4		-#include <linux/types.h>
5		-#include <linux/tracepoint.h>
6		-
7		-#undef TRACE_SYSTEM
8		-#define TRACE_SYSTEM kmem
9		-
10		-TRACE_EVENT(kmalloc,
11		-
12		- TP_PROTO(unsigned long call_site,
13		- const void *ptr,
14		- size_t bytes_req,
15		- size_t bytes_alloc,
16		- gfp_t gfp_flags),
17		-
18		- TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags),
19		-
20		- TP_STRUCT__entry(
21		- __field( unsigned long, call_site )
22		- __field( const void *, ptr )
23		- __field( size_t, bytes_req )
24		- __field( size_t, bytes_alloc )
25		- __field( gfp_t, gfp_flags )
26		- ),
27		-
28		- TP_fast_assign(
29		- __entry->call_site = call_site;
30		- __entry->ptr = ptr;
31		- __entry->bytes_req = bytes_req;
32		- __entry->bytes_alloc = bytes_alloc;
33		- __entry->gfp_flags = gfp_flags;
34		- ),
35		-
36		- TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x",
37		- __entry->call_site,
38		- __entry->ptr,
39		- __entry->bytes_req,
40		- __entry->bytes_alloc,
41		- __entry->gfp_flags)
42		-);
43		-
44		-TRACE_EVENT(kmem_cache_alloc,
45		-
46		- TP_PROTO(unsigned long call_site,
47		- const void *ptr,
48		- size_t bytes_req,
49		- size_t bytes_alloc,
50		- gfp_t gfp_flags),
51		-
52		- TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags),
53		-
54		- TP_STRUCT__entry(
55		- __field( unsigned long, call_site )
56		- __field( const void *, ptr )
57		- __field( size_t, bytes_req )
58		- __field( size_t, bytes_alloc )
59		- __field( gfp_t, gfp_flags )
60		- ),
61		-
62		- TP_fast_assign(
63		- __entry->call_site = call_site;
64		- __entry->ptr = ptr;
65		- __entry->bytes_req = bytes_req;
66		- __entry->bytes_alloc = bytes_alloc;
67		- __entry->gfp_flags = gfp_flags;
68		- ),
69		-
70		- TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x",
71		- __entry->call_site,
72		- __entry->ptr,
73		- __entry->bytes_req,
74		- __entry->bytes_alloc,
75		- __entry->gfp_flags)
76		-);
77		-
78		-TRACE_EVENT(kmalloc_node,
79		-
80		- TP_PROTO(unsigned long call_site,
81		- const void *ptr,
82		- size_t bytes_req,
83		- size_t bytes_alloc,
84		- gfp_t gfp_flags,
85		- int node),
86		-
87		- TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node),
88		-
89		- TP_STRUCT__entry(
90		- __field( unsigned long, call_site )
91		- __field( const void *, ptr )
92		- __field( size_t, bytes_req )
93		- __field( size_t, bytes_alloc )
94		- __field( gfp_t, gfp_flags )
95		- __field( int, node )
96		- ),
97		-
98		- TP_fast_assign(
99		- __entry->call_site = call_site;
100		- __entry->ptr = ptr;
101		- __entry->bytes_req = bytes_req;
102		- __entry->bytes_alloc = bytes_alloc;
103		- __entry->gfp_flags = gfp_flags;
104		- __entry->node = node;
105		- ),
106		-
107		- TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x node=%d",
108		- __entry->call_site,
109		- __entry->ptr,
110		- __entry->bytes_req,
111		- __entry->bytes_alloc,
112		- __entry->gfp_flags,
113		- __entry->node)
114		-);
115		-
116		-TRACE_EVENT(kmem_cache_alloc_node,
117		-
118		- TP_PROTO(unsigned long call_site,
119		- const void *ptr,
120		- size_t bytes_req,
121		- size_t bytes_alloc,
122		- gfp_t gfp_flags,
123		- int node),
124		-
125		- TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node),
126		-
127		- TP_STRUCT__entry(
128		- __field( unsigned long, call_site )
129		- __field( const void *, ptr )
130		- __field( size_t, bytes_req )
131		- __field( size_t, bytes_alloc )
132		- __field( gfp_t, gfp_flags )
133		- __field( int, node )
134		- ),
135		-
136		- TP_fast_assign(
137		- __entry->call_site = call_site;
138		- __entry->ptr = ptr;
139		- __entry->bytes_req = bytes_req;
140		- __entry->bytes_alloc = bytes_alloc;
141		- __entry->gfp_flags = gfp_flags;
142		- __entry->node = node;
143		- ),
144		-
145		- TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x node=%d",
146		- __entry->call_site,
147		- __entry->ptr,
148		- __entry->bytes_req,
149		- __entry->bytes_alloc,
150		- __entry->gfp_flags,
151		- __entry->node)
152		-);
153		-
154		-TRACE_EVENT(kfree,
155		-
156		- TP_PROTO(unsigned long call_site, const void *ptr),
157		-
158		- TP_ARGS(call_site, ptr),
159		-
160		- TP_STRUCT__entry(
161		- __field( unsigned long, call_site )
162		- __field( const void *, ptr )
163		- ),
164		-
165		- TP_fast_assign(
166		- __entry->call_site = call_site;
167		- __entry->ptr = ptr;
168		- ),
169		-
170		- TP_printk("call_site=%lx ptr=%p", __entry->call_site, __entry->ptr)
171		-);
172		-
173		-TRACE_EVENT(kmem_cache_free,
174		-
175		- TP_PROTO(unsigned long call_site, const void *ptr),
176		-
177		- TP_ARGS(call_site, ptr),
178		-
179		- TP_STRUCT__entry(
180		- __field( unsigned long, call_site )
181		- __field( const void *, ptr )
182		- ),
183		-
184		- TP_fast_assign(
185		- __entry->call_site = call_site;
186		- __entry->ptr = ptr;
187		- ),
188		-
189		- TP_printk("call_site=%lx ptr=%p", __entry->call_site, __entry->ptr)
190		-);
191		-#endif /* _TRACE_KMEM_H */
192		-
193		-/* This part must be outside protection */
194		-#include <trace/define_trace.h>
1		-#if !defined(_TRACE_LOCKDEP_H) \|\| defined(TRACE_HEADER_MULTI_READ)
2		-#define _TRACE_LOCKDEP_H
3		-
4		-#include <linux/lockdep.h>
5		-#include <linux/tracepoint.h>
6		-
7		-#undef TRACE_SYSTEM
8		-#define TRACE_SYSTEM lockdep
9		-
10		-#ifdef CONFIG_LOCKDEP
11		-
12		-TRACE_FORMAT(lock_acquire,
13		- TP_PROTO(struct lockdep_map *lock, unsigned int subclass,
14		- int trylock, int read, int check,
15		- struct lockdep_map *next_lock, unsigned long ip),
16		- TP_ARGS(lock, subclass, trylock, read, check, next_lock, ip),
17		- TP_FMT("%s%s%s", trylock ? "try " : "",
18		- read ? "read " : "", lock->name)
19		- );
20		-
21		-TRACE_FORMAT(lock_release,
22		- TP_PROTO(struct lockdep_map *lock, int nested, unsigned long ip),
23		- TP_ARGS(lock, nested, ip),
24		- TP_FMT("%s", lock->name)
25		- );
26		-
27		-#ifdef CONFIG_LOCK_STAT
28		-
29		-TRACE_FORMAT(lock_contended,
30		- TP_PROTO(struct lockdep_map *lock, unsigned long ip),
31		- TP_ARGS(lock, ip),
32		- TP_FMT("%s", lock->name)
33		- );
34		-
35		-TRACE_EVENT(lock_acquired,
36		- TP_PROTO(struct lockdep_map *lock, unsigned long ip, s64 waittime),
37		-
38		- TP_ARGS(lock, ip, waittime),
39		-
40		- TP_STRUCT__entry(
41		- __field(const char *, name)
42		- __field(unsigned long, wait_usec)
43		- __field(unsigned long, wait_nsec_rem)
44		- ),
45		- TP_fast_assign(
46		- __entry->name = lock->name;
47		- __entry->wait_nsec_rem = do_div(waittime, NSEC_PER_USEC);
48		- __entry->wait_usec = (unsigned long) waittime;
49		- ),
50		- TP_printk("%s (%lu.%03lu us)", __entry->name, __entry->wait_usec,
51		- __entry->wait_nsec_rem)
52		-);
53		-
54		-#endif
55		-#endif
56		-
57		-#endif /* _TRACE_LOCKDEP_H */
58		-
59		-/* This part must be outside protection */
60		-#include <trace/define_trace.h>