[deliverable/linux.git] / include / trace / events / sched.h

#undef TRACE_SYSTEM
#define TRACE_SYSTEM sched

#if !defined(_TRACE_SCHED_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_SCHED_H

#include <linux/sched.h>
#include <linux/tracepoint.h>
#include <linux/binfmts.h>

/*
 * 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("comm=%s pid=%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 waking up a task:
 */
DECLARE_EVENT_CLASS(sched_wakeup_template,

	TP_PROTO(struct task_struct *p, int success),

	TP_ARGS(p, success),

	TP_STRUCT__entry(
		__array(	char,	comm,	TASK_COMM_LEN	)
		__field(	pid_t,	pid			)
		__field(	int,	prio			)
		__field(	int,	success			)
		__field(	int,	target_cpu		)
	),

	TP_fast_assign(
		memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
		__entry->pid		= p->pid;
		__entry->prio		= p->prio;
		__entry->success	= success;
		__entry->target_cpu	= task_cpu(p);
	)
	TP_perf_assign(
		__perf_task(p);
	),

	TP_printk("comm=%s pid=%d prio=%d success=%d target_cpu=%03d",
		  __entry->comm, __entry->pid, __entry->prio,
		  __entry->success, __entry->target_cpu)
);

DEFINE_EVENT(sched_wakeup_template, sched_wakeup,
	     TP_PROTO(struct task_struct *p, int success),
	     TP_ARGS(p, success));

/*
 * Tracepoint for waking up a new task:
 */
DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new,
	     TP_PROTO(struct task_struct *p, int success),
	     TP_ARGS(p, success));

#ifdef CREATE_TRACE_POINTS
static inline long __trace_sched_switch_state(struct task_struct *p)
{
	long state = p->state;

#ifdef CONFIG_PREEMPT
	/*
	 * For all intents and purposes a preempted task is a running task.
	 */
	if (task_thread_info(p)->preempt_count & PREEMPT_ACTIVE)
		state = TASK_RUNNING | TASK_STATE_MAX;
#endif

	return state;
}
#endif

/*
 * Tracepoint for task switches, performed by the scheduler:
 */
TRACE_EVENT(sched_switch,

	TP_PROTO(struct task_struct *prev,
		 struct task_struct *next),

	TP_ARGS(prev, next),

	TP_STRUCT__entry(
		__array(	char,	prev_comm,	TASK_COMM_LEN	)
		__field(	pid_t,	prev_pid			)
		__field(	int,	prev_prio			)
		__field(	long,	prev_state			)
		__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;
		__entry->prev_state	= __trace_sched_switch_state(prev);
		memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
		__entry->next_pid	= next->pid;
		__entry->next_prio	= next->prio;
	),

	TP_printk("prev_comm=%s prev_pid=%d prev_prio=%d prev_state=%s%s ==> next_comm=%s next_pid=%d next_prio=%d",
		__entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
		__entry->prev_state & (TASK_STATE_MAX-1) ?
		  __print_flags(__entry->prev_state & (TASK_STATE_MAX-1), "|",
				{ 1, "S"} , { 2, "D" }, { 4, "T" }, { 8, "t" },
				{ 16, "Z" }, { 32, "X" }, { 64, "x" },
				{ 128, "K" }, { 256, "W" }, { 512, "P" }) : "R",
		__entry->prev_state & TASK_STATE_MAX ? "+" : "",
		__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 dest_cpu),

	TP_ARGS(p, 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	= task_cpu(p);
		__entry->dest_cpu	= dest_cpu;
	),

	TP_printk("comm=%s pid=%d prio=%d orig_cpu=%d dest_cpu=%d",
		  __entry->comm, __entry->pid, __entry->prio,
		  __entry->orig_cpu, __entry->dest_cpu)
);

DECLARE_EVENT_CLASS(sched_process_template,

	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("comm=%s pid=%d prio=%d",
		  __entry->comm, __entry->pid, __entry->prio)
);

/*
 * Tracepoint for freeing a task:
 */
DEFINE_EVENT(sched_process_template, sched_process_free,
	     TP_PROTO(struct task_struct *p),
	     TP_ARGS(p));
	     

/*
 * Tracepoint for a task exiting:
 */
DEFINE_EVENT(sched_process_template, sched_process_exit,
	     TP_PROTO(struct task_struct *p),
	     TP_ARGS(p));

/*
 * Tracepoint for waiting on task to unschedule:
 */
DEFINE_EVENT(sched_process_template, sched_wait_task,
	TP_PROTO(struct task_struct *p),
	TP_ARGS(p));

/*
 * 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("comm=%s pid=%d prio=%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("comm=%s pid=%d child_comm=%s child_pid=%d",
		__entry->parent_comm, __entry->parent_pid,
		__entry->child_comm, __entry->child_pid)
);

/*
 * Tracepoint for exec:
 */
TRACE_EVENT(sched_process_exec,

	TP_PROTO(struct task_struct *p, pid_t old_pid,
		 struct linux_binprm *bprm),

	TP_ARGS(p, old_pid, bprm),

	TP_STRUCT__entry(
		__string(	filename,	bprm->filename	)
		__field(	pid_t,		pid		)
		__field(	pid_t,		old_pid		)
	),

	TP_fast_assign(
		__assign_str(filename, bprm->filename);
		__entry->pid		= p->pid;
		__entry->old_pid	= old_pid;
	),

	TP_printk("filename=%s pid=%d old_pid=%d", __get_str(filename),
		  __entry->pid, __entry->old_pid)
);

/*
 * XXX the below sched_stat tracepoints only apply to SCHED_OTHER/BATCH/IDLE
 *     adding sched_stat support to SCHED_FIFO/RR would be welcome.
 */
DECLARE_EVENT_CLASS(sched_stat_template,

	TP_PROTO(struct task_struct *tsk, u64 delay),

	TP_ARGS(tsk, delay),

	TP_STRUCT__entry(
		__array( char,	comm,	TASK_COMM_LEN	)
		__field( pid_t,	pid			)
		__field( u64,	delay			)
	),

	TP_fast_assign(
		memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
		__entry->pid	= tsk->pid;
		__entry->delay	= delay;
	)
	TP_perf_assign(
		__perf_count(delay);
		__perf_task(tsk);
	),

	TP_printk("comm=%s pid=%d delay=%Lu [ns]",
			__entry->comm, __entry->pid,
			(unsigned long long)__entry->delay)
);


/*
 * Tracepoint for accounting wait time (time the task is runnable
 * but not actually running due to scheduler contention).
 */
DEFINE_EVENT(sched_stat_template, sched_stat_wait,
	     TP_PROTO(struct task_struct *tsk, u64 delay),
	     TP_ARGS(tsk, delay));

/*
 * Tracepoint for accounting sleep time (time the task is not runnable,
 * including iowait, see below).
 */
DEFINE_EVENT(sched_stat_template, sched_stat_sleep,
	     TP_PROTO(struct task_struct *tsk, u64 delay),
	     TP_ARGS(tsk, delay));

/*
 * Tracepoint for accounting iowait time (time the task is not runnable
 * due to waiting on IO to complete).
 */
DEFINE_EVENT(sched_stat_template, sched_stat_iowait,
	     TP_PROTO(struct task_struct *tsk, u64 delay),
	     TP_ARGS(tsk, delay));

/*
 * Tracepoint for accounting blocked time (time the task is in uninterruptible).
 */
DEFINE_EVENT(sched_stat_template, sched_stat_blocked,
	     TP_PROTO(struct task_struct *tsk, u64 delay),
	     TP_ARGS(tsk, delay));

/*
 * Tracepoint for accounting runtime (time the task is executing
 * on a CPU).
 */
TRACE_EVENT(sched_stat_runtime,

	TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime),

	TP_ARGS(tsk, runtime, vruntime),

	TP_STRUCT__entry(
		__array( char,	comm,	TASK_COMM_LEN	)
		__field( pid_t,	pid			)
		__field( u64,	runtime			)
		__field( u64,	vruntime			)
	),

	TP_fast_assign(
		memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
		__entry->pid		= tsk->pid;
		__entry->runtime	= runtime;
		__entry->vruntime	= vruntime;
	)
	TP_perf_assign(
		__perf_count(runtime);
	),

	TP_printk("comm=%s pid=%d runtime=%Lu [ns] vruntime=%Lu [ns]",
			__entry->comm, __entry->pid,
			(unsigned long long)__entry->runtime,
			(unsigned long long)__entry->vruntime)
);

/*
 * Tracepoint for showing priority inheritance modifying a tasks
 * priority.
 */
TRACE_EVENT(sched_pi_setprio,

	TP_PROTO(struct task_struct *tsk, int newprio),

	TP_ARGS(tsk, newprio),

	TP_STRUCT__entry(
		__array( char,	comm,	TASK_COMM_LEN	)
		__field( pid_t,	pid			)
		__field( int,	oldprio			)
		__field( int,	newprio			)
	),

	TP_fast_assign(
		memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
		__entry->pid		= tsk->pid;
		__entry->oldprio	= tsk->prio;
		__entry->newprio	= newprio;
	),

	TP_printk("comm=%s pid=%d oldprio=%d newprio=%d",
			__entry->comm, __entry->pid,
			__entry->oldprio, __entry->newprio)
);

#endif /* _TRACE_SCHED_H */

/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
d0b6e04a LZ	1	#undef TRACE_SYSTEM
	2	#define TRACE_SYSTEM sched
	3
ea20d929	4	#if !defined(_TRACE_SCHED_H) \|\| defined(TRACE_HEADER_MULTI_READ)
0a16b607 MD	5	#define _TRACE_SCHED_H
	6
	7	#include <linux/sched.h>
	8	#include <linux/tracepoint.h>
4ff16c25	9	#include <linux/binfmts.h>
0a16b607	10
ea20d929 SR	11	/*
	12	* Tracepoint for calling kthread_stop, performed to end a kthread:
	13	*/
	14	TRACE_EVENT(sched_kthread_stop,
	15
	16	TP_PROTO(struct task_struct *t),
	17
	18	TP_ARGS(t),
	19
	20	TP_STRUCT__entry(
	21	__array( char, comm, TASK_COMM_LEN )
	22	__field( pid_t, pid )
	23	),
	24
	25	TP_fast_assign(
	26	memcpy(__entry->comm, t->comm, TASK_COMM_LEN);
	27	__entry->pid = t->pid;
	28	),
	29
434a83c3	30	TP_printk("comm=%s pid=%d", __entry->comm, __entry->pid)
ea20d929 SR	31	);
	32
	33	/*
	34	* Tracepoint for the return value of the kthread stopping:
	35	*/
	36	TRACE_EVENT(sched_kthread_stop_ret,
	37
	38	TP_PROTO(int ret),
	39
	40	TP_ARGS(ret),
	41
	42	TP_STRUCT__entry(
	43	__field( int, ret )
	44	),
	45
	46	TP_fast_assign(
	47	__entry->ret = ret;
	48	),
	49
434a83c3	50	TP_printk("ret=%d", __entry->ret)
ea20d929 SR	51	);
ea20d929 SR	52
ea20d929 SR	53	/*
ea20d929 SR	54	* Tracepoint for waking up a task:
ea20d929	55	*/
091ad365	56	DECLARE_EVENT_CLASS(sched_wakeup_template,
ea20d929	57
27a9da65	58	TP_PROTO(struct task_struct *p, int success),
ea20d929	59
27a9da65	60	TP_ARGS(p, success),
ea20d929 SR	61
	62	TP_STRUCT__entry(
	63	__array( char, comm, TASK_COMM_LEN )
	64	__field( pid_t, pid )
	65	__field( int, prio )
	66	__field( int, success )
434a83c3	67	__field( int, target_cpu )
ea20d929 SR	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	__entry->success = success;
434a83c3	75	__entry->target_cpu = task_cpu(p);
e6dab5ff AV	76	)
	77	TP_perf_assign(
	78	__perf_task(p);
ea20d929 SR	79	),
ea20d929 SR	80
434a83c3	81	TP_printk("comm=%s pid=%d prio=%d success=%d target_cpu=%03d",
ea20d929	82	__entry->comm, __entry->pid, __entry->prio,
434a83c3	83	__entry->success, __entry->target_cpu)
ea20d929 SR	84	);
ea20d929 SR	85
75ec29ab	86	DEFINE_EVENT(sched_wakeup_template, sched_wakeup,
27a9da65 PZ	87	TP_PROTO(struct task_struct *p, int success),
27a9da65 PZ	88	TP_ARGS(p, success));
75ec29ab	89
ea20d929 SR	90	/*
ea20d929 SR	91	* Tracepoint for waking up a new task:
ea20d929	92	*/
75ec29ab	93	DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new,
27a9da65 PZ	94	TP_PROTO(struct task_struct *p, int success),
27a9da65 PZ	95	TP_ARGS(p, success));
ea20d929	96
02f72694 PZ	97	#ifdef CREATE_TRACE_POINTS
	98	static inline long __trace_sched_switch_state(struct task_struct *p)
	99	{
	100	long state = p->state;
	101
	102	#ifdef CONFIG_PREEMPT
	103	/*
	104	* For all intents and purposes a preempted task is a running task.
	105	*/
	106	if (task_thread_info(p)->preempt_count & PREEMPT_ACTIVE)
557ab425	107	state = TASK_RUNNING \| TASK_STATE_MAX;
02f72694 PZ	108	#endif
	109
	110	return state;
	111	}
	112	#endif
	113
ea20d929 SR	114	/*
ea20d929 SR	115	* Tracepoint for task switches, performed by the scheduler:
ea20d929 SR	116	*/
	117	TRACE_EVENT(sched_switch,
	118
27a9da65	119	TP_PROTO(struct task_struct *prev,
ea20d929 SR	120	struct task_struct *next),
ea20d929 SR	121
27a9da65	122	TP_ARGS(prev, next),
ea20d929 SR	123
	124	TP_STRUCT__entry(
	125	__array( char, prev_comm, TASK_COMM_LEN )
	126	__field( pid_t, prev_pid )
	127	__field( int, prev_prio )
937cdb9d	128	__field( long, prev_state )
ea20d929 SR	129	__array( char, next_comm, TASK_COMM_LEN )
	130	__field( pid_t, next_pid )
	131	__field( int, next_prio )
	132	),
	133
	134	TP_fast_assign(
	135	memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
	136	__entry->prev_pid = prev->pid;
	137	__entry->prev_prio = prev->prio;
02f72694	138	__entry->prev_state = __trace_sched_switch_state(prev);
ea20d929 SR	139	memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
	140	__entry->next_pid = next->pid;
	141	__entry->next_prio = next->prio;
	142	),
	143
557ab425	144	TP_printk("prev_comm=%s prev_pid=%d prev_prio=%d prev_state=%s%s ==> next_comm=%s next_pid=%d next_prio=%d",
ea20d929	145	__entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
557ab425 PZ	146	__entry->prev_state & (TASK_STATE_MAX-1) ?
557ab425 PZ	147	__print_flags(__entry->prev_state & (TASK_STATE_MAX-1), "\|",
937cdb9d SR	148	{ 1, "S"} , { 2, "D" }, { 4, "T" }, { 8, "t" },
937cdb9d SR	149	{ 16, "Z" }, { 32, "X" }, { 64, "x" },
f2530dc7	150	{ 128, "K" }, { 256, "W" }, { 512, "P" }) : "R",
557ab425	151	__entry->prev_state & TASK_STATE_MAX ? "+" : "",
ea20d929 SR	152	__entry->next_comm, __entry->next_pid, __entry->next_prio)
	153	);
	154
	155	/*
	156	* Tracepoint for a task being migrated:
	157	*/
	158	TRACE_EVENT(sched_migrate_task,
	159
de1d7286	160	TP_PROTO(struct task_struct *p, int dest_cpu),
ea20d929	161
de1d7286	162	TP_ARGS(p, dest_cpu),
ea20d929 SR	163
	164	TP_STRUCT__entry(
	165	__array( char, comm, TASK_COMM_LEN )
	166	__field( pid_t, pid )
	167	__field( int, prio )
	168	__field( int, orig_cpu )
	169	__field( int, dest_cpu )
	170	),
	171
	172	TP_fast_assign(
	173	memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
	174	__entry->pid = p->pid;
	175	__entry->prio = p->prio;
de1d7286	176	__entry->orig_cpu = task_cpu(p);
ea20d929 SR	177	__entry->dest_cpu = dest_cpu;
	178	),
	179
434a83c3	180	TP_printk("comm=%s pid=%d prio=%d orig_cpu=%d dest_cpu=%d",
ea20d929 SR	181	__entry->comm, __entry->pid, __entry->prio,
	182	__entry->orig_cpu, __entry->dest_cpu)
	183	);
	184
091ad365	185	DECLARE_EVENT_CLASS(sched_process_template,
ea20d929 SR	186
	187	TP_PROTO(struct task_struct *p),
	188
	189	TP_ARGS(p),
	190
	191	TP_STRUCT__entry(
	192	__array( char, comm, TASK_COMM_LEN )
	193	__field( pid_t, pid )
	194	__field( int, prio )
	195	),
	196
	197	TP_fast_assign(
	198	memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
	199	__entry->pid = p->pid;
	200	__entry->prio = p->prio;
	201	),
	202
434a83c3	203	TP_printk("comm=%s pid=%d prio=%d",
ea20d929 SR	204	__entry->comm, __entry->pid, __entry->prio)
	205	);
	206
	207	/*
75ec29ab	208	* Tracepoint for freeing a task:
ea20d929	209	*/
75ec29ab SR	210	DEFINE_EVENT(sched_process_template, sched_process_free,
	211	TP_PROTO(struct task_struct *p),
	212	TP_ARGS(p));
	213
ea20d929	214
75ec29ab SR	215	/*
	216	* Tracepoint for a task exiting:
	217	*/
	218	DEFINE_EVENT(sched_process_template, sched_process_exit,
	219	TP_PROTO(struct task_struct *p),
	220	TP_ARGS(p));
ea20d929	221
210f7669 LZ	222	/*
	223	* Tracepoint for waiting on task to unschedule:
	224	*/
	225	DEFINE_EVENT(sched_process_template, sched_wait_task,
	226	TP_PROTO(struct task_struct *p),
	227	TP_ARGS(p));
	228
ea20d929 SR	229	/*
	230	* Tracepoint for a waiting task:
	231	*/
	232	TRACE_EVENT(sched_process_wait,
	233
	234	TP_PROTO(struct pid *pid),
	235
	236	TP_ARGS(pid),
	237
	238	TP_STRUCT__entry(
	239	__array( char, comm, TASK_COMM_LEN )
	240	__field( pid_t, pid )
	241	__field( int, prio )
	242	),
	243
	244	TP_fast_assign(
	245	memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
	246	__entry->pid = pid_nr(pid);
	247	__entry->prio = current->prio;
	248	),
	249
434a83c3	250	TP_printk("comm=%s pid=%d prio=%d",
ea20d929 SR	251	__entry->comm, __entry->pid, __entry->prio)
	252	);
	253
	254	/*
	255	* Tracepoint for do_fork:
	256	*/
	257	TRACE_EVENT(sched_process_fork,
	258
	259	TP_PROTO(struct task_struct parent, struct task_struct child),
	260
	261	TP_ARGS(parent, child),
	262
	263	TP_STRUCT__entry(
	264	__array( char, parent_comm, TASK_COMM_LEN )
	265	__field( pid_t, parent_pid )
	266	__array( char, child_comm, TASK_COMM_LEN )
	267	__field( pid_t, child_pid )
	268	),
	269
	270	TP_fast_assign(
	271	memcpy(__entry->parent_comm, parent->comm, TASK_COMM_LEN);
	272	__entry->parent_pid = parent->pid;
	273	memcpy(__entry->child_comm, child->comm, TASK_COMM_LEN);
	274	__entry->child_pid = child->pid;
	275	),
	276
434a83c3	277	TP_printk("comm=%s pid=%d child_comm=%s child_pid=%d",
ea20d929 SR	278	__entry->parent_comm, __entry->parent_pid,
	279	__entry->child_comm, __entry->child_pid)
	280	);
	281
4ff16c25 DS	282	/*
	283	* Tracepoint for exec:
	284	*/
	285	TRACE_EVENT(sched_process_exec,
	286
	287	TP_PROTO(struct task_struct *p, pid_t old_pid,
	288	struct linux_binprm *bprm),
	289
	290	TP_ARGS(p, old_pid, bprm),
	291
	292	TP_STRUCT__entry(
	293	__string( filename, bprm->filename )
	294	__field( pid_t, pid )
	295	__field( pid_t, old_pid )
	296	),
	297
	298	TP_fast_assign(
	299	__assign_str(filename, bprm->filename);
	300	__entry->pid = p->pid;
6308191f	301	__entry->old_pid = old_pid;
4ff16c25 DS	302	),
	303
	304	TP_printk("filename=%s pid=%d old_pid=%d", __get_str(filename),
	305	__entry->pid, __entry->old_pid)
	306	);
	307
768d0c27 PZ	308	/*
	309	* XXX the below sched_stat tracepoints only apply to SCHED_OTHER/BATCH/IDLE
	310	* adding sched_stat support to SCHED_FIFO/RR would be welcome.
	311	*/
091ad365	312	DECLARE_EVENT_CLASS(sched_stat_template,
768d0c27 PZ	313
	314	TP_PROTO(struct task_struct *tsk, u64 delay),
	315
	316	TP_ARGS(tsk, delay),
	317
	318	TP_STRUCT__entry(
	319	__array( char, comm, TASK_COMM_LEN )
	320	__field( pid_t, pid )
	321	__field( u64, delay )
	322	),
	323
	324	TP_fast_assign(
	325	memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
	326	__entry->pid = tsk->pid;
	327	__entry->delay = delay;
	328	)
	329	TP_perf_assign(
	330	__perf_count(delay);
e6dab5ff	331	__perf_task(tsk);
768d0c27 PZ	332	),
768d0c27 PZ	333
434a83c3	334	TP_printk("comm=%s pid=%d delay=%Lu [ns]",
768d0c27 PZ	335	__entry->comm, __entry->pid,
	336	(unsigned long long)__entry->delay)
	337	);
	338
75ec29ab SR	339
	340	/*
	341	* Tracepoint for accounting wait time (time the task is runnable
	342	* but not actually running due to scheduler contention).
	343	*/
	344	DEFINE_EVENT(sched_stat_template, sched_stat_wait,
	345	TP_PROTO(struct task_struct *tsk, u64 delay),
	346	TP_ARGS(tsk, delay));
	347
	348	/*
	349	* Tracepoint for accounting sleep time (time the task is not runnable,
	350	* including iowait, see below).
	351	*/
470dda74 LZ	352	DEFINE_EVENT(sched_stat_template, sched_stat_sleep,
	353	TP_PROTO(struct task_struct *tsk, u64 delay),
	354	TP_ARGS(tsk, delay));
75ec29ab SR	355
	356	/*
	357	* Tracepoint for accounting iowait time (time the task is not runnable
	358	* due to waiting on IO to complete).
	359	*/
470dda74 LZ	360	DEFINE_EVENT(sched_stat_template, sched_stat_iowait,
	361	TP_PROTO(struct task_struct *tsk, u64 delay),
	362	TP_ARGS(tsk, delay));
75ec29ab	363
b781a602 AV	364	/*
	365	* Tracepoint for accounting blocked time (time the task is in uninterruptible).
	366	*/
	367	DEFINE_EVENT(sched_stat_template, sched_stat_blocked,
	368	TP_PROTO(struct task_struct *tsk, u64 delay),
	369	TP_ARGS(tsk, delay));
	370
f977bb49 IM	371	/*
	372	* Tracepoint for accounting runtime (time the task is executing
	373	* on a CPU).
	374	*/
	375	TRACE_EVENT(sched_stat_runtime,
	376
	377	TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime),
	378
	379	TP_ARGS(tsk, runtime, vruntime),
	380
	381	TP_STRUCT__entry(
	382	__array( char, comm, TASK_COMM_LEN )
	383	__field( pid_t, pid )
	384	__field( u64, runtime )
	385	__field( u64, vruntime )
	386	),
	387
	388	TP_fast_assign(
	389	memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
	390	__entry->pid = tsk->pid;
	391	__entry->runtime = runtime;
	392	__entry->vruntime = vruntime;
	393	)
	394	TP_perf_assign(
	395	__perf_count(runtime);
	396	),
	397
434a83c3	398	TP_printk("comm=%s pid=%d runtime=%Lu [ns] vruntime=%Lu [ns]",
f977bb49 IM	399	__entry->comm, __entry->pid,
	400	(unsigned long long)__entry->runtime,
	401	(unsigned long long)__entry->vruntime)
	402	);
	403
a8027073 SR	404	/*
	405	* Tracepoint for showing priority inheritance modifying a tasks
	406	* priority.
	407	*/
	408	TRACE_EVENT(sched_pi_setprio,
	409
	410	TP_PROTO(struct task_struct *tsk, int newprio),
	411
	412	TP_ARGS(tsk, newprio),
	413
	414	TP_STRUCT__entry(
	415	__array( char, comm, TASK_COMM_LEN )
	416	__field( pid_t, pid )
	417	__field( int, oldprio )
	418	__field( int, newprio )
	419	),
	420
	421	TP_fast_assign(
	422	memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
	423	__entry->pid = tsk->pid;
	424	__entry->oldprio = tsk->prio;
	425	__entry->newprio = newprio;
	426	),
	427
	428	TP_printk("comm=%s pid=%d oldprio=%d newprio=%d",
	429	__entry->comm, __entry->pid,
	430	__entry->oldprio, __entry->newprio)
	431	);
	432
ea20d929	433	#endif /* _TRACE_SCHED_H */
a8d154b0 SR	434
	435	/* This part must be outside protection */
	436	#include <trace/define_trace.h>