From 26bafa3b7880a323d83b8ea71bdb8e2118a5cba0 Mon Sep 17 00:00:00 2001 From: Andrea Bastoni Date: Sat, 11 Feb 2012 21:41:19 +0100 Subject: Add kernel-style events for sched_trace_XXX() functions Enable kernel-style events (tracepoint) for Litmus. Litmus events trace the same functions as the sched_trace_XXX(), but can be enabled independently. So, why another tracing infrastructure then: - Litmus tracepoints can be recorded and analyzed together (single time reference) with all other kernel tracing events (e.g., sched:sched_switch, etc.). It's easier to correlate the effects of kernel events on litmus tasks. - It enables a quick way to visualize and process schedule traces using trace-cmd utility and kernelshark visualizer. Kernelshark lacks unit-trace's schedule-correctness checks, but it enables a fast view of schedule traces and it has several filtering options (for all kernel events, not only Litmus'). --- include/trace/events/litmus.h | 231 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 231 insertions(+) create mode 100644 include/trace/events/litmus.h (limited to 'include/trace') diff --git a/include/trace/events/litmus.h b/include/trace/events/litmus.h new file mode 100644 index 00000000000..0fffcee02be --- /dev/null +++ b/include/trace/events/litmus.h @@ -0,0 +1,231 @@ +/* + * LITMUS^RT kernel style scheduling tracepoints + */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM litmus + +#if !defined(_SCHED_TASK_TRACEPOINT_H) || defined(TRACE_HEADER_MULTI_READ) +#define _SCHED_TASK_TRACEPOINT_H + +#include + +#include +#include + +/* + * Tracing task admission + */ +TRACE_EVENT(litmus_task_param, + + TP_PROTO(struct task_struct *t), + + TP_ARGS(t), + + TP_STRUCT__entry( + __field( pid_t, pid ) + __field( unsigned int, job ) + __field( lt_t, wcet ) + __field( lt_t, period ) + __field( lt_t, phase ) + __field( int, partition ) + ), + + TP_fast_assign( + __entry->pid = t ? t->pid : 0; + __entry->job = t ? t->rt_param.job_params.job_no : 0; + __entry->wcet = get_exec_cost(t); + __entry->period = get_rt_period(t); + __entry->phase = get_rt_phase(t); + __entry->partition = get_partition(t); + ), + + TP_printk("period(%d, %Lu).\nwcet(%d, %Lu).\n", + __entry->pid, __entry->period, + __entry->pid, __entry->wcet) +); + +/* + * Tracing jobs release + */ +TRACE_EVENT(litmus_task_release, + + TP_PROTO(struct task_struct *t), + + TP_ARGS(t), + + TP_STRUCT__entry( + __field( pid_t, pid ) + __field( unsigned int, job ) + __field( lt_t, release ) + __field( lt_t, deadline ) + ), + + TP_fast_assign( + __entry->pid = t ? t->pid : 0; + __entry->job = t ? t->rt_param.job_params.job_no : 0; + __entry->release = get_release(t); + __entry->deadline = get_deadline(t); + ), + + TP_printk("release(job(%u, %u)): %Lu\ndeadline(job(%u, %u)): %Lu\n", + __entry->pid, __entry->job, __entry->release, + __entry->pid, __entry->job, __entry->deadline) +); + +/* + * Tracepoint for switching to new task + */ +TRACE_EVENT(litmus_switch_to, + + TP_PROTO(struct task_struct *t), + + TP_ARGS(t), + + TP_STRUCT__entry( + __field( pid_t, pid ) + __field( unsigned int, job ) + __field( lt_t, when ) + __field( lt_t, exec_time ) + ), + + TP_fast_assign( + __entry->pid = is_realtime(t) ? t->pid : 0; + __entry->job = is_realtime(t) ? t->rt_param.job_params.job_no : 0; + __entry->when = litmus_clock(); + __entry->exec_time = get_exec_time(t); + ), + + TP_printk("switch_to(job(%u, %u)): %Lu (exec: %Lu)\n", + __entry->pid, __entry->job, + __entry->when, __entry->exec_time) +); + +/* + * Tracepoint for switching away previous task + */ +TRACE_EVENT(litmus_switch_away, + + TP_PROTO(struct task_struct *t), + + TP_ARGS(t), + + TP_STRUCT__entry( + __field( pid_t, pid ) + __field( unsigned int, job ) + __field( lt_t, when ) + __field( lt_t, exec_time ) + ), + + TP_fast_assign( + __entry->pid = is_realtime(t) ? t->pid : 0; + __entry->job = is_realtime(t) ? t->rt_param.job_params.job_no : 0; + __entry->when = litmus_clock(); + __entry->exec_time = get_exec_time(t); + ), + + TP_printk("switch_away(job(%u, %u)): %Lu (exec: %Lu)\n", + __entry->pid, __entry->job, + __entry->when, __entry->exec_time) +); + +/* + * Tracing jobs completion + */ +TRACE_EVENT(litmus_task_completion, + + TP_PROTO(struct task_struct *t, unsigned long forced), + + TP_ARGS(t, forced), + + TP_STRUCT__entry( + __field( pid_t, pid ) + __field( unsigned int, job ) + __field( lt_t, when ) + __field( unsigned long, forced ) + ), + + TP_fast_assign( + __entry->pid = t ? t->pid : 0; + __entry->job = t ? t->rt_param.job_params.job_no : 0; + __entry->when = litmus_clock(); + __entry->forced = forced; + ), + + TP_printk("completed(job(%u, %u)): %Lu (forced: %lu)\n", + __entry->pid, __entry->job, + __entry->when, __entry->forced) +); + +/* + * Trace blocking tasks. + */ +TRACE_EVENT(litmus_task_block, + + TP_PROTO(struct task_struct *t), + + TP_ARGS(t), + + TP_STRUCT__entry( + __field( pid_t, pid ) + __field( lt_t, when ) + ), + + TP_fast_assign( + __entry->pid = t ? t->pid : 0; + __entry->when = litmus_clock(); + ), + + TP_printk("(%u) blocks: %Lu\n", __entry->pid, __entry->when) +); + +/* + * Tracing jobs resume + */ +TRACE_EVENT(litmus_task_resume, + + TP_PROTO(struct task_struct *t), + + TP_ARGS(t), + + TP_STRUCT__entry( + __field( pid_t, pid ) + __field( unsigned int, job ) + __field( lt_t, when ) + ), + + TP_fast_assign( + __entry->pid = t ? t->pid : 0; + __entry->job = t ? t->rt_param.job_params.job_no : 0; + __entry->when = litmus_clock(); + ), + + TP_printk("resume(job(%u, %u)): %Lu\n", + __entry->pid, __entry->job, __entry->when) +); + +/* + * Trace synchronous release + */ +TRACE_EVENT(litmus_sys_release, + + TP_PROTO(lt_t *start), + + TP_ARGS(start), + + TP_STRUCT__entry( + __field( lt_t, rel ) + __field( lt_t, when ) + ), + + TP_fast_assign( + __entry->rel = *start; + __entry->when = litmus_clock(); + ), + + TP_printk("SynRelease(%Lu) at %Lu\n", __entry->rel, __entry->when) +); + +#endif /* _SCHED_TASK_TRACEPOINT_H */ + +/* Must stay outside the protection */ +#include -- cgit v1.2.2 From 94edd278631ff219b4907322e620d9ffebceef4a Mon Sep 17 00:00:00 2001 From: Jonathan Herman Date: Thu, 15 Nov 2012 15:41:54 -0500 Subject: Initial commit. --- include/trace/events/litmus.h | 177 ++++++++++++++++++++++++++++++++++++++++++ include/trace/ftrace.h | 5 +- 2 files changed, 180 insertions(+), 2 deletions(-) (limited to 'include/trace') diff --git a/include/trace/events/litmus.h b/include/trace/events/litmus.h index 0fffcee02be..e1843ad3750 100644 --- a/include/trace/events/litmus.h +++ b/include/trace/events/litmus.h @@ -225,6 +225,183 @@ TRACE_EVENT(litmus_sys_release, TP_printk("SynRelease(%Lu) at %Lu\n", __entry->rel, __entry->when) ); +/* + * Containers + */ +TRACE_EVENT(litmus_container_param, + + TP_PROTO(int cid, const char *name), + + TP_ARGS(cid, name), + + TP_STRUCT__entry( + __field( int, cid ) + __array( char, name, TASK_COMM_LEN ) + ), + + TP_fast_assign( + memcpy(__entry->name, name, TASK_COMM_LEN); + __entry->cid = cid; + ), + + TP_printk("container, name: %s, id: %d\n", __entry->name, __entry->cid) +); + +TRACE_EVENT(litmus_server_param, + + TP_PROTO(int sid, int cid, unsigned long long wcet, unsigned long long period), + + TP_ARGS(sid, cid, wcet, period), + + TP_STRUCT__entry( + __field( int, sid ) + __field( int, cid ) + __field( unsigned long long, wcet ) + __field( unsigned long long, period ) + ), + + TP_fast_assign( + __entry->cid = cid; + __entry->sid = sid; + __entry->wcet = wcet; + __entry->period = period; + ), + + TP_printk("server(%llu, %llu), sid: %llu, cont: %llu\n", + __entry->wcet, __entry->period, __entry->sid, __entry->cid) +); + +TRACE_EVENT(litmus_server_switch_to, + + TP_PROTO(int sid, unsigned int job, int tid, unsigned int tjob, int cpu), + + TP_ARGS(sid, job, tid, tjob, cpu), + + TP_STRUCT__entry( + __field( int, sid) + __field( unsigned int, job) + __field( int, tid) + __field( unsigned int, tjob) + __field( int, cpu) + ), + + TP_fast_assign( + __entry->sid = sid; + __entry->tid = tid; + __entry->job = job; + __entry->tjob = tjob; + __entry->cpu = cpu; + ), + + TP_printk("switch_to(server(%d, %u)): (%d, %d) on %d\n", + __entry->sid, __entry->job, __entry->tid, __entry->tjob, __entry->cpu) +); + +TRACE_EVENT(litmus_server_switch_away, + + TP_PROTO(int sid, unsigned int job, int tid, unsigned int tjob, int cpu), + + TP_ARGS(sid, job, tid, tjob, cpu), + + TP_STRUCT__entry( + __field( int, sid) + __field( unsigned int, job) + __field( int, tid) + __field( unsigned int, tjob) + __field( int, cpu) + ), + + TP_fast_assign( + __entry->sid = sid; + __entry->tid = tid; + __entry->job = job; + __entry->tjob = tjob; + __entry->cpu = cpu; + ), + + TP_printk("switch_away(server(%d, %u)): (%d, %d) on %d\n", + __entry->sid, __entry->job, __entry->tid, __entry->tjob, __entry->cpu) +); + +TRACE_EVENT(litmus_server_release, + + TP_PROTO(int sid, unsigned int job, + unsigned long long release, + unsigned long long deadline), + + TP_ARGS(sid, job, release, deadline), + + TP_STRUCT__entry( + __field( int, sid) + __field( unsigned int, job) + __field( unsigned long long, release) + __field( unsigned long long, deadline) + ), + + TP_fast_assign( + __entry->sid = sid; + __entry->job = job; + __entry->release = release; + __entry->deadline = deadline; + ), + + TP_printk("release(server(%d, %u)), release: %llu, deadline: %llu\n", + __entry->sid, __entry->job, __entry->release, __entry->deadline) +); + +TRACE_EVENT(litmus_server_completion, + + TP_PROTO(int sid, int job), + + TP_ARGS(sid, job), + + TP_STRUCT__entry( + __field( int, sid) + __field( unsigned int, job) + ), + + TP_fast_assign( + __entry->sid = sid; + __entry->job = job; + ), + + TP_printk("completion(server(%d, %d))\n", __entry->sid, __entry->job) +); + +TRACE_EVENT(litmus_server_resume, + + TP_PROTO(int sid), + + TP_ARGS(sid), + + TP_STRUCT__entry( + __field( int, sid) + ), + + TP_fast_assign( + __entry->sid = sid; + ), + + TP_printk("resume(server(%d))\n", __entry->sid) +); + +TRACE_EVENT(litmus_server_block, + + TP_PROTO(int sid), + + TP_ARGS(sid), + + TP_STRUCT__entry( + __field( int, sid) + ), + + TP_fast_assign( + __entry->sid = sid; + ), + + TP_printk("block(server(%d))\n", __entry->sid) +); + #endif /* _SCHED_TASK_TRACEPOINT_H */ /* Must stay outside the protection */ diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h index 533c49f4804..4d6f3474e8f 100644 --- a/include/trace/ftrace.h +++ b/include/trace/ftrace.h @@ -17,6 +17,7 @@ */ #include +#include /* * DECLARE_EVENT_CLASS can be used to add a generic function @@ -54,7 +55,7 @@ #define __string(item, src) __dynamic_array(char, item, -1) #undef TP_STRUCT__entry -#define TP_STRUCT__entry(args...) args +#define TP_STRUCT__entry(args...) args __field( unsigned long long, __rt_ts ) #undef DECLARE_EVENT_CLASS #define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print) \ @@ -507,7 +508,7 @@ static inline notrace int ftrace_get_offsets_##call( \ strcpy(__get_str(dst), src); #undef TP_fast_assign -#define TP_fast_assign(args...) args +#define TP_fast_assign(args...) args; __entry->__rt_ts = litmus_clock(); #undef TP_perf_assign #define TP_perf_assign(args...) -- cgit v1.2.2 From f2d0840115e68334af761b9fda6efd48a5918bd0 Mon Sep 17 00:00:00 2001 From: Jonathan Herman Date: Fri, 21 Sep 2012 14:15:30 -0400 Subject: Initial commit --- include/trace/events/litmus.h | 161 +++++++++++++++++++++--------------------- 1 file changed, 82 insertions(+), 79 deletions(-) (limited to 'include/trace') diff --git a/include/trace/events/litmus.h b/include/trace/events/litmus.h index e1843ad3750..b3a8f166e65 100644 --- a/include/trace/events/litmus.h +++ b/include/trace/events/litmus.h @@ -11,10 +11,6 @@ #include #include - -/* - * Tracing task admission - */ TRACE_EVENT(litmus_task_param, TP_PROTO(struct task_struct *t), @@ -24,9 +20,9 @@ TRACE_EVENT(litmus_task_param, TP_STRUCT__entry( __field( pid_t, pid ) __field( unsigned int, job ) - __field( lt_t, wcet ) - __field( lt_t, period ) - __field( lt_t, phase ) + __field( unsigned long long, wcet ) + __field( unsigned long long, period ) + __field( unsigned long long, phase ) __field( int, partition ) ), @@ -56,8 +52,8 @@ TRACE_EVENT(litmus_task_release, TP_STRUCT__entry( __field( pid_t, pid ) __field( unsigned int, job ) - __field( lt_t, release ) - __field( lt_t, deadline ) + __field( unsigned long long, release ) + __field( unsigned long long, deadline ) ), TP_fast_assign( @@ -84,8 +80,8 @@ TRACE_EVENT(litmus_switch_to, TP_STRUCT__entry( __field( pid_t, pid ) __field( unsigned int, job ) - __field( lt_t, when ) - __field( lt_t, exec_time ) + __field( unsigned long long, when ) + __field( unsigned long long, exec_time ) ), TP_fast_assign( @@ -112,8 +108,8 @@ TRACE_EVENT(litmus_switch_away, TP_STRUCT__entry( __field( pid_t, pid ) __field( unsigned int, job ) - __field( lt_t, when ) - __field( lt_t, exec_time ) + __field( unsigned long long, when ) + __field( unsigned long long, exec_time ) ), TP_fast_assign( @@ -140,7 +136,7 @@ TRACE_EVENT(litmus_task_completion, TP_STRUCT__entry( __field( pid_t, pid ) __field( unsigned int, job ) - __field( lt_t, when ) + __field( unsigned long long, when ) __field( unsigned long, forced ) ), @@ -161,21 +157,71 @@ TRACE_EVENT(litmus_task_completion, */ TRACE_EVENT(litmus_task_block, - TP_PROTO(struct task_struct *t), + TP_PROTO(struct task_struct *t, int lid), - TP_ARGS(t), + TP_ARGS(t, lid), + + TP_STRUCT__entry( + __field( pid_t, pid ) + __field( int, lid ) + __field( unsigned long long, when ) + ), + + TP_fast_assign( + __entry->pid = t ? t->pid : 0; + __entry->lid = lid; + __entry->when = litmus_clock(); + ), + + TP_printk("(%u) blocks on %d: %Lu\n", __entry->pid, + __entry->lid, __entry->when) +); + +/* + * Lock events + */ +TRACE_EVENT(litmus_resource_acquire, + + TP_PROTO(struct task_struct *t, int lid), + + TP_ARGS(t, lid), + + TP_STRUCT__entry( + __field( pid_t, pid ) + __field( int, lid ) + __field( unsigned long long, when ) + ), + + TP_fast_assign( + __entry->pid = t ? t->pid : 0; + __entry->lid = lid; + __entry->when = litmus_clock(); + ), + + TP_printk("(%u) acquires %d: %Lu\n", __entry->pid, + __entry->lid, __entry->when) +); + +TRACE_EVENT(litmus_resource_release, + + TP_PROTO(struct task_struct *t, int lid), + + TP_ARGS(t, lid), TP_STRUCT__entry( __field( pid_t, pid ) - __field( lt_t, when ) + __field( int, lid ) + __field( unsigned long long, when ) ), TP_fast_assign( __entry->pid = t ? t->pid : 0; + __entry->lid = lid; __entry->when = litmus_clock(); ), - TP_printk("(%u) blocks: %Lu\n", __entry->pid, __entry->when) + TP_printk("(%u) releases %d: %Lu\n", __entry->pid, + __entry->lid, __entry->when) ); /* @@ -183,24 +229,27 @@ TRACE_EVENT(litmus_task_block, */ TRACE_EVENT(litmus_task_resume, - TP_PROTO(struct task_struct *t), + TP_PROTO(struct task_struct *t, int lid), - TP_ARGS(t), + TP_ARGS(t, lid), TP_STRUCT__entry( __field( pid_t, pid ) + __field( int, lid ) __field( unsigned int, job ) - __field( lt_t, when ) + __field( unsigned long long, when ) ), TP_fast_assign( __entry->pid = t ? t->pid : 0; __entry->job = t ? t->rt_param.job_params.job_no : 0; __entry->when = litmus_clock(); + __entry->lid = lid; ), - TP_printk("resume(job(%u, %u)): %Lu\n", - __entry->pid, __entry->job, __entry->when) + TP_printk("resume(job(%u, %u)) on %d: %Lu\n", + __entry->pid, __entry->job, + __entry->lid, __entry->when) ); /* @@ -208,13 +257,13 @@ TRACE_EVENT(litmus_task_resume, */ TRACE_EVENT(litmus_sys_release, - TP_PROTO(lt_t *start), + TP_PROTO(unsigned long long *start), TP_ARGS(start), TP_STRUCT__entry( - __field( lt_t, rel ) - __field( lt_t, when ) + __field( unsigned long long, rel ) + __field( unsigned long long, when ) ), TP_fast_assign( @@ -273,54 +322,43 @@ TRACE_EVENT(litmus_server_param, TRACE_EVENT(litmus_server_switch_to, - TP_PROTO(int sid, unsigned int job, int tid, unsigned int tjob, int cpu), + TP_PROTO(int sid, unsigned int job, int tid), - TP_ARGS(sid, job, tid, tjob, cpu), + TP_ARGS(sid, job, tid), TP_STRUCT__entry( __field( int, sid) __field( unsigned int, job) __field( int, tid) - __field( unsigned int, tjob) - __field( int, cpu) ), TP_fast_assign( __entry->sid = sid; __entry->tid = tid; __entry->job = job; - __entry->tjob = tjob; - __entry->cpu = cpu; ), - TP_printk("switch_to(server(%d, %u)): (%d, %d) on %d\n", - __entry->sid, __entry->job, __entry->tid, __entry->tjob, __entry->cpu) + TP_printk("switch_to(server(%d, %u)): %d\n", __entry->sid, __entry->job, __entry->tid) ); TRACE_EVENT(litmus_server_switch_away, - TP_PROTO(int sid, unsigned int job, int tid, unsigned int tjob, int cpu), + TP_PROTO(int sid, unsigned int job, int tid), - TP_ARGS(sid, job, tid, tjob, cpu), + TP_ARGS(sid, job, tid), TP_STRUCT__entry( __field( int, sid) __field( unsigned int, job) __field( int, tid) - __field( unsigned int, tjob) - __field( int, cpu) ), TP_fast_assign( __entry->sid = sid; __entry->tid = tid; - __entry->job = job; - __entry->tjob = tjob; - __entry->cpu = cpu; ), - TP_printk("switch_away(server(%d, %u)): (%d, %d) on %d\n", - __entry->sid, __entry->job, __entry->tid, __entry->tjob, __entry->cpu) + TP_printk("switch_away(server(%d, %u)): %d\n", __entry->sid, __entry->job, __entry->tid) ); TRACE_EVENT(litmus_server_release, @@ -345,8 +383,7 @@ TRACE_EVENT(litmus_server_release, __entry->deadline = deadline; ), - TP_printk("release(server(%d, %u)), release: %llu, deadline: %llu\n", - __entry->sid, __entry->job, __entry->release, __entry->deadline) + TP_printk("release(server(%d, %u)), release: %llu, deadline: %llu\n", __entry->sid, __entry->job, __entry->release, __entry->deadline) ); TRACE_EVENT(litmus_server_completion, @@ -368,40 +405,6 @@ TRACE_EVENT(litmus_server_completion, TP_printk("completion(server(%d, %d))\n", __entry->sid, __entry->job) ); -TRACE_EVENT(litmus_server_resume, - - TP_PROTO(int sid), - - TP_ARGS(sid), - - TP_STRUCT__entry( - __field( int, sid) - ), - - TP_fast_assign( - __entry->sid = sid; - ), - - TP_printk("resume(server(%d))\n", __entry->sid) -); - -TRACE_EVENT(litmus_server_block, - - TP_PROTO(int sid), - - TP_ARGS(sid), - - TP_STRUCT__entry( - __field( int, sid) - ), - - TP_fast_assign( - __entry->sid = sid; - ), - - TP_printk("block(server(%d))\n", __entry->sid) -); - #endif /* _SCHED_TASK_TRACEPOINT_H */ /* Must stay outside the protection */ -- cgit v1.2.2 From 47fd5923596859cf71a1cab1a0271b5acf45fedb Mon Sep 17 00:00:00 2001 From: Christopher Kenna Date: Sun, 6 May 2012 21:18:33 -0400 Subject: Add task_exit event that records max exec time under color plugin. Conflicts: include/litmus/rt_param.h litmus/sched_color.c --- include/trace/events/litmus.h | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) (limited to 'include/trace') diff --git a/include/trace/events/litmus.h b/include/trace/events/litmus.h index b3a8f166e65..c3a92f8ec6e 100644 --- a/include/trace/events/litmus.h +++ b/include/trace/events/litmus.h @@ -274,6 +274,28 @@ TRACE_EVENT(litmus_sys_release, TP_printk("SynRelease(%Lu) at %Lu\n", __entry->rel, __entry->when) ); +/* + * Trace task exit + */ +TRACE_EVENT(litmus_task_exit, + + TP_PROTO(struct task_struct *t), + + TP_ARGS(t), + + TP_STRUCT__entry( + __field( pid_t, pid ) + __field( unsigned long long, max_exec_time ) + ), + + TP_fast_assign( + __entry->pid = t ? t->pid : 0; + __entry->max_exec_time = t ? t->rt_param.max_exec_time : 0; + ), + + TP_printk("(%u) exit\n", __entry->pid) +); + /* * Containers */ -- cgit v1.2.2 From 5848abe61548e8f5f4a98faf5364207fcb514545 Mon Sep 17 00:00:00 2001 From: Jonathan Herman Date: Thu, 15 Nov 2012 15:41:54 -0500 Subject: Merged with latest kernelshark branch. Conflicts: include/litmus/sched_trace.h include/trace/events/litmus.h --- include/trace/events/litmus.h | 50 +++++++++++++++++-------------------------- 1 file changed, 20 insertions(+), 30 deletions(-) (limited to 'include/trace') diff --git a/include/trace/events/litmus.h b/include/trace/events/litmus.h index c3a92f8ec6e..ba4217bc704 100644 --- a/include/trace/events/litmus.h +++ b/include/trace/events/litmus.h @@ -274,28 +274,6 @@ TRACE_EVENT(litmus_sys_release, TP_printk("SynRelease(%Lu) at %Lu\n", __entry->rel, __entry->when) ); -/* - * Trace task exit - */ -TRACE_EVENT(litmus_task_exit, - - TP_PROTO(struct task_struct *t), - - TP_ARGS(t), - - TP_STRUCT__entry( - __field( pid_t, pid ) - __field( unsigned long long, max_exec_time ) - ), - - TP_fast_assign( - __entry->pid = t ? t->pid : 0; - __entry->max_exec_time = t ? t->rt_param.max_exec_time : 0; - ), - - TP_printk("(%u) exit\n", __entry->pid) -); - /* * Containers */ @@ -344,43 +322,54 @@ TRACE_EVENT(litmus_server_param, TRACE_EVENT(litmus_server_switch_to, - TP_PROTO(int sid, unsigned int job, int tid), + TP_PROTO(int sid, unsigned int job, int tid, unsigned int tjob, int cpu), - TP_ARGS(sid, job, tid), + TP_ARGS(sid, job, tid, tjob, cpu), - TP_STRUCT__entry( + TP_STRUCT_entry( __field( int, sid) __field( unsigned int, job) __field( int, tid) + __field( unsigned int, tjob) + __field( int, cpu) ), TP_fast_assign( __entry->sid = sid; __entry->tid = tid; __entry->job = job; + __entry->tjob = tjob; + __entry->cpu = cpu; ), - TP_printk("switch_to(server(%d, %u)): %d\n", __entry->sid, __entry->job, __entry->tid) + TP_printk("switch_to(server(%d, %u)): (%d, %d) on %d\n", + __entry->sid, __entry->job, __entry->tid, __entry->tjob, __entry->cpu) ); TRACE_EVENT(litmus_server_switch_away, - TP_PROTO(int sid, unsigned int job, int tid), + TP_PROTO(int sid, unsigned int job, int tid, unsigned int tjob, int cpu), - TP_ARGS(sid, job, tid), + TP_ARGS(sid, job, tid, tjob, cpu), TP_STRUCT__entry( __field( int, sid) __field( unsigned int, job) __field( int, tid) + __field( unsigned int, tjob) + __field( int, cpu) ), TP_fast_assign( __entry->sid = sid; __entry->tid = tid; + __entry->job = job; + __entry->tjob = tjob; + __entry->cpu = cpu; ), - TP_printk("switch_away(server(%d, %u)): %d\n", __entry->sid, __entry->job, __entry->tid) + TP_printk("switch_away(server(%d, %u)): (%d, %d) on %d\n", + __entry->sid, __entry->job, __entry->tid, __entry->tjob, __entry->cpu) ); TRACE_EVENT(litmus_server_release, @@ -405,7 +394,8 @@ TRACE_EVENT(litmus_server_release, __entry->deadline = deadline; ), - TP_printk("release(server(%d, %u)), release: %llu, deadline: %llu\n", __entry->sid, __entry->job, __entry->release, __entry->deadline) + TP_printk("release(server(%d, %u)), release: %llu, deadline: %llu\n", + __entry->sid, __entry->job, __entry->release, __entry->deadline) ); TRACE_EVENT(litmus_server_completion, -- cgit v1.2.2 From 7ef4a793a624c6e66c16ca1051847f75161f5bec Mon Sep 17 00:00:00 2001 From: Jonathan Herman Date: Tue, 16 Apr 2013 23:36:44 -0400 Subject: Fixed the littlest typo. --- include/trace/events/litmus.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'include/trace') diff --git a/include/trace/events/litmus.h b/include/trace/events/litmus.h index ba4217bc704..ed50bc809e8 100644 --- a/include/trace/events/litmus.h +++ b/include/trace/events/litmus.h @@ -326,7 +326,7 @@ TRACE_EVENT(litmus_server_switch_to, TP_ARGS(sid, job, tid, tjob, cpu), - TP_STRUCT_entry( + TP_STRUCT__entry( __field( int, sid) __field( unsigned int, job) __field( int, tid) -- cgit v1.2.2