2009-07-13 02:33:21 +00:00
|
|
|
#undef TRACE_SYSTEM
|
|
|
|
|
#define TRACE_SYSTEM sched
|
|
|
|
|
|
2009-04-10 12:54:16 +00:00
|
|
|
#if !defined(_TRACE_SCHED_H) || defined(TRACE_HEADER_MULTI_READ)
|
tracing, sched: LTTng instrumentation - scheduler
Instrument the scheduler activity (sched_switch, migration, wakeups,
wait for a task, signal delivery) and process/thread
creation/destruction (fork, exit, kthread stop). Actually, kthread
creation is not instrumented in this patch because it is architecture
dependent. It allows to connect tracers such as ftrace which detects
scheduling latencies, good/bad scheduler decisions. Tools like LTTng can
export this scheduler information along with instrumentation of the rest
of the kernel activity to perform post-mortem analysis on the scheduler
activity.
About the performance impact of tracepoints (which is comparable to
markers), even without immediate values optimizations, tests done by
Hideo Aoki on ia64 show no regression. His test case was using hackbench
on a kernel where scheduler instrumentation (about 5 events in code
scheduler code) was added. See the "Tracepoints" patch header for
performance result detail.
Changelog :
- Change instrumentation location and parameter to match ftrace
instrumentation, previously done with kernel markers.
[ mingo@elte.hu: conflict resolutions ]
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
Acked-by: 'Peter Zijlstra' <peterz@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-18 16:16:17 +00:00
|
|
|
#define _TRACE_SCHED_H
|
|
|
|
|
|
|
|
|
|
#include <linux/sched.h>
|
|
|
|
|
#include <linux/tracepoint.h>
|
2012-02-07 16:11:05 +00:00
|
|
|
#include <linux/binfmts.h>
|
tracing, sched: LTTng instrumentation - scheduler
Instrument the scheduler activity (sched_switch, migration, wakeups,
wait for a task, signal delivery) and process/thread
creation/destruction (fork, exit, kthread stop). Actually, kthread
creation is not instrumented in this patch because it is architecture
dependent. It allows to connect tracers such as ftrace which detects
scheduling latencies, good/bad scheduler decisions. Tools like LTTng can
export this scheduler information along with instrumentation of the rest
of the kernel activity to perform post-mortem analysis on the scheduler
activity.
About the performance impact of tracepoints (which is comparable to
markers), even without immediate values optimizations, tests done by
Hideo Aoki on ia64 show no regression. His test case was using hackbench
on a kernel where scheduler instrumentation (about 5 events in code
scheduler code) was added. See the "Tracepoints" patch header for
performance result detail.
Changelog :
- Change instrumentation location and parameter to match ftrace
instrumentation, previously done with kernel markers.
[ mingo@elte.hu: conflict resolutions ]
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
Acked-by: 'Peter Zijlstra' <peterz@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-18 16:16:17 +00:00
|
|
|
|
2009-04-10 12:54:16 +00:00
|
|
|
/*
|
|
|
|
|
* 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;
|
|
|
|
|
),
|
|
|
|
|
|
events: Harmonize event field names and print output names
Now that we can filter based on fields via perf record, people
will start using filter expressions and will expect them to
be obvious.
The primary way to see which fields are available is by looking
at the trace output, such as:
gcc-18676 [000] 343.011728: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.012727: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.032692: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.033690: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.034687: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.035686: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.036684: irq_handler_entry: irq=0 handler=timer
While 'irq==0' filters work, the 'handler==<x>' filter expression
does not work:
$ perf record -R -f -a -e irq:irq_handler_entry --filter handler=timer sleep 1
Error: failed to set filter with 22 (Invalid argument)
The problem is that while an 'irq' field exists and is recognized
as a filter field - 'handler' does not exist - its name is 'name'
in the output.
To solve this, we need to synchronize the printout and the field
names, wherever possible.
In cases where the printout prints a non-field, we enclose
that information in square brackets, such as:
perf-1380 [013] 724.903505: softirq_exit: vec=9 [action=RCU]
perf-1380 [013] 724.904482: softirq_exit: vec=1 [action=TIMER]
This way users can use filter expressions more intuitively: all
fields that show up as 'primary' (non-bracketed) information is
filterable.
This patch harmonizes the field names for all irq, bkl, power,
sched and timer events.
We might in fact think about dropping the print format bit of
generic tracepoints altogether, and just print the fields that
are being recorded.
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-15 09:50:39 +00:00
|
|
|
TP_printk("comm=%s pid=%d", __entry->comm, __entry->pid)
|
2009-04-10 12:54:16 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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;
|
|
|
|
|
),
|
|
|
|
|
|
events: Harmonize event field names and print output names
Now that we can filter based on fields via perf record, people
will start using filter expressions and will expect them to
be obvious.
The primary way to see which fields are available is by looking
at the trace output, such as:
gcc-18676 [000] 343.011728: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.012727: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.032692: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.033690: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.034687: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.035686: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.036684: irq_handler_entry: irq=0 handler=timer
While 'irq==0' filters work, the 'handler==<x>' filter expression
does not work:
$ perf record -R -f -a -e irq:irq_handler_entry --filter handler=timer sleep 1
Error: failed to set filter with 22 (Invalid argument)
The problem is that while an 'irq' field exists and is recognized
as a filter field - 'handler' does not exist - its name is 'name'
in the output.
To solve this, we need to synchronize the printout and the field
names, wherever possible.
In cases where the printout prints a non-field, we enclose
that information in square brackets, such as:
perf-1380 [013] 724.903505: softirq_exit: vec=9 [action=RCU]
perf-1380 [013] 724.904482: softirq_exit: vec=1 [action=TIMER]
This way users can use filter expressions more intuitively: all
fields that show up as 'primary' (non-bracketed) information is
filterable.
This patch harmonizes the field names for all irq, bkl, power,
sched and timer events.
We might in fact think about dropping the print format bit of
generic tracepoints altogether, and just print the fields that
are being recorded.
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-15 09:50:39 +00:00
|
|
|
TP_printk("ret=%d", __entry->ret)
|
2009-04-10 12:54:16 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Tracepoint for waking up a task:
|
|
|
|
|
*/
|
2009-11-26 08:04:55 +00:00
|
|
|
DECLARE_EVENT_CLASS(sched_wakeup_template,
|
2009-04-10 12:54:16 +00:00
|
|
|
|
2010-05-04 18:36:56 +00:00
|
|
|
TP_PROTO(struct task_struct *p, int success),
|
2009-04-10 12:54:16 +00:00
|
|
|
|
2013-08-06 16:08:44 +00:00
|
|
|
TP_ARGS(__perf_task(p), success),
|
2009-04-10 12:54:16 +00:00
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
|
|
|
__field( pid_t, pid )
|
|
|
|
|
__field( int, prio )
|
|
|
|
|
__field( int, success )
|
events: Harmonize event field names and print output names
Now that we can filter based on fields via perf record, people
will start using filter expressions and will expect them to
be obvious.
The primary way to see which fields are available is by looking
at the trace output, such as:
gcc-18676 [000] 343.011728: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.012727: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.032692: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.033690: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.034687: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.035686: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.036684: irq_handler_entry: irq=0 handler=timer
While 'irq==0' filters work, the 'handler==<x>' filter expression
does not work:
$ perf record -R -f -a -e irq:irq_handler_entry --filter handler=timer sleep 1
Error: failed to set filter with 22 (Invalid argument)
The problem is that while an 'irq' field exists and is recognized
as a filter field - 'handler' does not exist - its name is 'name'
in the output.
To solve this, we need to synchronize the printout and the field
names, wherever possible.
In cases where the printout prints a non-field, we enclose
that information in square brackets, such as:
perf-1380 [013] 724.903505: softirq_exit: vec=9 [action=RCU]
perf-1380 [013] 724.904482: softirq_exit: vec=1 [action=TIMER]
This way users can use filter expressions more intuitively: all
fields that show up as 'primary' (non-bracketed) information is
filterable.
This patch harmonizes the field names for all irq, bkl, power,
sched and timer events.
We might in fact think about dropping the print format bit of
generic tracepoints altogether, and just print the fields that
are being recorded.
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-15 09:50:39 +00:00
|
|
|
__field( int, target_cpu )
|
2009-04-10 12:54:16 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
|
|
|
|
|
__entry->pid = p->pid;
|
|
|
|
|
__entry->prio = p->prio;
|
|
|
|
|
__entry->success = success;
|
events: Harmonize event field names and print output names
Now that we can filter based on fields via perf record, people
will start using filter expressions and will expect them to
be obvious.
The primary way to see which fields are available is by looking
at the trace output, such as:
gcc-18676 [000] 343.011728: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.012727: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.032692: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.033690: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.034687: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.035686: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.036684: irq_handler_entry: irq=0 handler=timer
While 'irq==0' filters work, the 'handler==<x>' filter expression
does not work:
$ perf record -R -f -a -e irq:irq_handler_entry --filter handler=timer sleep 1
Error: failed to set filter with 22 (Invalid argument)
The problem is that while an 'irq' field exists and is recognized
as a filter field - 'handler' does not exist - its name is 'name'
in the output.
To solve this, we need to synchronize the printout and the field
names, wherever possible.
In cases where the printout prints a non-field, we enclose
that information in square brackets, such as:
perf-1380 [013] 724.903505: softirq_exit: vec=9 [action=RCU]
perf-1380 [013] 724.904482: softirq_exit: vec=1 [action=TIMER]
This way users can use filter expressions more intuitively: all
fields that show up as 'primary' (non-bracketed) information is
filterable.
This patch harmonizes the field names for all irq, bkl, power,
sched and timer events.
We might in fact think about dropping the print format bit of
generic tracepoints altogether, and just print the fields that
are being recorded.
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-15 09:50:39 +00:00
|
|
|
__entry->target_cpu = task_cpu(p);
|
2009-04-10 12:54:16 +00:00
|
|
|
),
|
|
|
|
|
|
events: Harmonize event field names and print output names
Now that we can filter based on fields via perf record, people
will start using filter expressions and will expect them to
be obvious.
The primary way to see which fields are available is by looking
at the trace output, such as:
gcc-18676 [000] 343.011728: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.012727: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.032692: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.033690: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.034687: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.035686: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.036684: irq_handler_entry: irq=0 handler=timer
While 'irq==0' filters work, the 'handler==<x>' filter expression
does not work:
$ perf record -R -f -a -e irq:irq_handler_entry --filter handler=timer sleep 1
Error: failed to set filter with 22 (Invalid argument)
The problem is that while an 'irq' field exists and is recognized
as a filter field - 'handler' does not exist - its name is 'name'
in the output.
To solve this, we need to synchronize the printout and the field
names, wherever possible.
In cases where the printout prints a non-field, we enclose
that information in square brackets, such as:
perf-1380 [013] 724.903505: softirq_exit: vec=9 [action=RCU]
perf-1380 [013] 724.904482: softirq_exit: vec=1 [action=TIMER]
This way users can use filter expressions more intuitively: all
fields that show up as 'primary' (non-bracketed) information is
filterable.
This patch harmonizes the field names for all irq, bkl, power,
sched and timer events.
We might in fact think about dropping the print format bit of
generic tracepoints altogether, and just print the fields that
are being recorded.
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-15 09:50:39 +00:00
|
|
|
TP_printk("comm=%s pid=%d prio=%d success=%d target_cpu=%03d",
|
2009-04-10 12:54:16 +00:00
|
|
|
__entry->comm, __entry->pid, __entry->prio,
|
events: Harmonize event field names and print output names
Now that we can filter based on fields via perf record, people
will start using filter expressions and will expect them to
be obvious.
The primary way to see which fields are available is by looking
at the trace output, such as:
gcc-18676 [000] 343.011728: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.012727: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.032692: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.033690: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.034687: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.035686: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.036684: irq_handler_entry: irq=0 handler=timer
While 'irq==0' filters work, the 'handler==<x>' filter expression
does not work:
$ perf record -R -f -a -e irq:irq_handler_entry --filter handler=timer sleep 1
Error: failed to set filter with 22 (Invalid argument)
The problem is that while an 'irq' field exists and is recognized
as a filter field - 'handler' does not exist - its name is 'name'
in the output.
To solve this, we need to synchronize the printout and the field
names, wherever possible.
In cases where the printout prints a non-field, we enclose
that information in square brackets, such as:
perf-1380 [013] 724.903505: softirq_exit: vec=9 [action=RCU]
perf-1380 [013] 724.904482: softirq_exit: vec=1 [action=TIMER]
This way users can use filter expressions more intuitively: all
fields that show up as 'primary' (non-bracketed) information is
filterable.
This patch harmonizes the field names for all irq, bkl, power,
sched and timer events.
We might in fact think about dropping the print format bit of
generic tracepoints altogether, and just print the fields that
are being recorded.
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-15 09:50:39 +00:00
|
|
|
__entry->success, __entry->target_cpu)
|
2009-04-10 12:54:16 +00:00
|
|
|
);
|
|
|
|
|
|
2009-11-19 01:48:08 +00:00
|
|
|
DEFINE_EVENT(sched_wakeup_template, sched_wakeup,
|
2010-05-04 18:36:56 +00:00
|
|
|
TP_PROTO(struct task_struct *p, int success),
|
|
|
|
|
TP_ARGS(p, success));
|
2009-11-19 01:48:08 +00:00
|
|
|
|
2009-04-10 12:54:16 +00:00
|
|
|
/*
|
|
|
|
|
* Tracepoint for waking up a new task:
|
|
|
|
|
*/
|
2009-11-19 01:48:08 +00:00
|
|
|
DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new,
|
2010-05-04 18:36:56 +00:00
|
|
|
TP_PROTO(struct task_struct *p, int success),
|
|
|
|
|
TP_ARGS(p, success));
|
2009-04-10 12:54:16 +00:00
|
|
|
|
2010-05-31 16:13:25 +00:00
|
|
|
#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.
|
|
|
|
|
*/
|
2013-08-14 12:55:46 +00:00
|
|
|
if (task_preempt_count(p) & PREEMPT_ACTIVE)
|
2011-09-16 09:16:43 +00:00
|
|
|
state = TASK_RUNNING | TASK_STATE_MAX;
|
2010-05-31 16:13:25 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return state;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2009-04-10 12:54:16 +00:00
|
|
|
/*
|
|
|
|
|
* Tracepoint for task switches, performed by the scheduler:
|
|
|
|
|
*/
|
|
|
|
|
TRACE_EVENT(sched_switch,
|
|
|
|
|
|
2010-05-04 18:36:56 +00:00
|
|
|
TP_PROTO(struct task_struct *prev,
|
2009-04-10 12:54:16 +00:00
|
|
|
struct task_struct *next),
|
|
|
|
|
|
2010-05-04 18:36:56 +00:00
|
|
|
TP_ARGS(prev, next),
|
2009-04-10 12:54:16 +00:00
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__array( char, prev_comm, TASK_COMM_LEN )
|
|
|
|
|
__field( pid_t, prev_pid )
|
|
|
|
|
__field( int, prev_prio )
|
2009-05-15 14:51:13 +00:00
|
|
|
__field( long, prev_state )
|
2009-04-10 12:54:16 +00:00
|
|
|
__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;
|
2010-05-31 16:13:25 +00:00
|
|
|
__entry->prev_state = __trace_sched_switch_state(prev);
|
2009-04-10 12:54:16 +00:00
|
|
|
memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
|
|
|
|
|
__entry->next_pid = next->pid;
|
|
|
|
|
__entry->next_prio = next->prio;
|
|
|
|
|
),
|
|
|
|
|
|
2011-09-16 09:16:43 +00:00
|
|
|
TP_printk("prev_comm=%s prev_pid=%d prev_prio=%d prev_state=%s%s ==> next_comm=%s next_pid=%d next_prio=%d",
|
2009-04-10 12:54:16 +00:00
|
|
|
__entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
|
2011-09-16 09:16:43 +00:00
|
|
|
__entry->prev_state & (TASK_STATE_MAX-1) ?
|
|
|
|
|
__print_flags(__entry->prev_state & (TASK_STATE_MAX-1), "|",
|
2009-05-15 14:51:13 +00:00
|
|
|
{ 1, "S"} , { 2, "D" }, { 4, "T" }, { 8, "t" },
|
|
|
|
|
{ 16, "Z" }, { 32, "X" }, { 64, "x" },
|
2013-04-09 07:33:34 +00:00
|
|
|
{ 128, "K" }, { 256, "W" }, { 512, "P" }) : "R",
|
2011-09-16 09:16:43 +00:00
|
|
|
__entry->prev_state & TASK_STATE_MAX ? "+" : "",
|
2009-04-10 12:54:16 +00:00
|
|
|
__entry->next_comm, __entry->next_pid, __entry->next_prio)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Tracepoint for a task being migrated:
|
|
|
|
|
*/
|
|
|
|
|
TRACE_EVENT(sched_migrate_task,
|
|
|
|
|
|
2009-05-05 08:49:59 +00:00
|
|
|
TP_PROTO(struct task_struct *p, int dest_cpu),
|
2009-04-10 12:54:16 +00:00
|
|
|
|
2009-05-05 08:49:59 +00:00
|
|
|
TP_ARGS(p, dest_cpu),
|
2009-04-10 12:54:16 +00:00
|
|
|
|
|
|
|
|
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;
|
2009-05-05 08:49:59 +00:00
|
|
|
__entry->orig_cpu = task_cpu(p);
|
2009-04-10 12:54:16 +00:00
|
|
|
__entry->dest_cpu = dest_cpu;
|
|
|
|
|
),
|
|
|
|
|
|
events: Harmonize event field names and print output names
Now that we can filter based on fields via perf record, people
will start using filter expressions and will expect them to
be obvious.
The primary way to see which fields are available is by looking
at the trace output, such as:
gcc-18676 [000] 343.011728: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.012727: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.032692: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.033690: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.034687: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.035686: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.036684: irq_handler_entry: irq=0 handler=timer
While 'irq==0' filters work, the 'handler==<x>' filter expression
does not work:
$ perf record -R -f -a -e irq:irq_handler_entry --filter handler=timer sleep 1
Error: failed to set filter with 22 (Invalid argument)
The problem is that while an 'irq' field exists and is recognized
as a filter field - 'handler' does not exist - its name is 'name'
in the output.
To solve this, we need to synchronize the printout and the field
names, wherever possible.
In cases where the printout prints a non-field, we enclose
that information in square brackets, such as:
perf-1380 [013] 724.903505: softirq_exit: vec=9 [action=RCU]
perf-1380 [013] 724.904482: softirq_exit: vec=1 [action=TIMER]
This way users can use filter expressions more intuitively: all
fields that show up as 'primary' (non-bracketed) information is
filterable.
This patch harmonizes the field names for all irq, bkl, power,
sched and timer events.
We might in fact think about dropping the print format bit of
generic tracepoints altogether, and just print the fields that
are being recorded.
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-15 09:50:39 +00:00
|
|
|
TP_printk("comm=%s pid=%d prio=%d orig_cpu=%d dest_cpu=%d",
|
2009-04-10 12:54:16 +00:00
|
|
|
__entry->comm, __entry->pid, __entry->prio,
|
|
|
|
|
__entry->orig_cpu, __entry->dest_cpu)
|
|
|
|
|
);
|
|
|
|
|
|
2009-11-26 08:04:55 +00:00
|
|
|
DECLARE_EVENT_CLASS(sched_process_template,
|
2009-04-10 12:54:16 +00:00
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
),
|
|
|
|
|
|
events: Harmonize event field names and print output names
Now that we can filter based on fields via perf record, people
will start using filter expressions and will expect them to
be obvious.
The primary way to see which fields are available is by looking
at the trace output, such as:
gcc-18676 [000] 343.011728: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.012727: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.032692: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.033690: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.034687: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.035686: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.036684: irq_handler_entry: irq=0 handler=timer
While 'irq==0' filters work, the 'handler==<x>' filter expression
does not work:
$ perf record -R -f -a -e irq:irq_handler_entry --filter handler=timer sleep 1
Error: failed to set filter with 22 (Invalid argument)
The problem is that while an 'irq' field exists and is recognized
as a filter field - 'handler' does not exist - its name is 'name'
in the output.
To solve this, we need to synchronize the printout and the field
names, wherever possible.
In cases where the printout prints a non-field, we enclose
that information in square brackets, such as:
perf-1380 [013] 724.903505: softirq_exit: vec=9 [action=RCU]
perf-1380 [013] 724.904482: softirq_exit: vec=1 [action=TIMER]
This way users can use filter expressions more intuitively: all
fields that show up as 'primary' (non-bracketed) information is
filterable.
This patch harmonizes the field names for all irq, bkl, power,
sched and timer events.
We might in fact think about dropping the print format bit of
generic tracepoints altogether, and just print the fields that
are being recorded.
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-15 09:50:39 +00:00
|
|
|
TP_printk("comm=%s pid=%d prio=%d",
|
2009-04-10 12:54:16 +00:00
|
|
|
__entry->comm, __entry->pid, __entry->prio)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
/*
|
2009-11-19 01:48:08 +00:00
|
|
|
* Tracepoint for freeing a task:
|
2009-04-10 12:54:16 +00:00
|
|
|
*/
|
2009-11-19 01:48:08 +00:00
|
|
|
DEFINE_EVENT(sched_process_template, sched_process_free,
|
|
|
|
|
TP_PROTO(struct task_struct *p),
|
|
|
|
|
TP_ARGS(p));
|
|
|
|
|
|
2009-04-10 12:54:16 +00:00
|
|
|
|
2009-11-19 01:48:08 +00:00
|
|
|
/*
|
|
|
|
|
* Tracepoint for a task exiting:
|
|
|
|
|
*/
|
|
|
|
|
DEFINE_EVENT(sched_process_template, sched_process_exit,
|
|
|
|
|
TP_PROTO(struct task_struct *p),
|
|
|
|
|
TP_ARGS(p));
|
2009-04-10 12:54:16 +00:00
|
|
|
|
2010-05-24 08:23:35 +00:00
|
|
|
/*
|
|
|
|
|
* Tracepoint for waiting on task to unschedule:
|
|
|
|
|
*/
|
|
|
|
|
DEFINE_EVENT(sched_process_template, sched_wait_task,
|
|
|
|
|
TP_PROTO(struct task_struct *p),
|
|
|
|
|
TP_ARGS(p));
|
|
|
|
|
|
2009-04-10 12:54:16 +00:00
|
|
|
/*
|
|
|
|
|
* 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;
|
|
|
|
|
),
|
|
|
|
|
|
events: Harmonize event field names and print output names
Now that we can filter based on fields via perf record, people
will start using filter expressions and will expect them to
be obvious.
The primary way to see which fields are available is by looking
at the trace output, such as:
gcc-18676 [000] 343.011728: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.012727: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.032692: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.033690: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.034687: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.035686: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.036684: irq_handler_entry: irq=0 handler=timer
While 'irq==0' filters work, the 'handler==<x>' filter expression
does not work:
$ perf record -R -f -a -e irq:irq_handler_entry --filter handler=timer sleep 1
Error: failed to set filter with 22 (Invalid argument)
The problem is that while an 'irq' field exists and is recognized
as a filter field - 'handler' does not exist - its name is 'name'
in the output.
To solve this, we need to synchronize the printout and the field
names, wherever possible.
In cases where the printout prints a non-field, we enclose
that information in square brackets, such as:
perf-1380 [013] 724.903505: softirq_exit: vec=9 [action=RCU]
perf-1380 [013] 724.904482: softirq_exit: vec=1 [action=TIMER]
This way users can use filter expressions more intuitively: all
fields that show up as 'primary' (non-bracketed) information is
filterable.
This patch harmonizes the field names for all irq, bkl, power,
sched and timer events.
We might in fact think about dropping the print format bit of
generic tracepoints altogether, and just print the fields that
are being recorded.
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-15 09:50:39 +00:00
|
|
|
TP_printk("comm=%s pid=%d prio=%d",
|
2009-04-10 12:54:16 +00:00
|
|
|
__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;
|
|
|
|
|
),
|
|
|
|
|
|
events: Harmonize event field names and print output names
Now that we can filter based on fields via perf record, people
will start using filter expressions and will expect them to
be obvious.
The primary way to see which fields are available is by looking
at the trace output, such as:
gcc-18676 [000] 343.011728: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.012727: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.032692: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.033690: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.034687: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.035686: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.036684: irq_handler_entry: irq=0 handler=timer
While 'irq==0' filters work, the 'handler==<x>' filter expression
does not work:
$ perf record -R -f -a -e irq:irq_handler_entry --filter handler=timer sleep 1
Error: failed to set filter with 22 (Invalid argument)
The problem is that while an 'irq' field exists and is recognized
as a filter field - 'handler' does not exist - its name is 'name'
in the output.
To solve this, we need to synchronize the printout and the field
names, wherever possible.
In cases where the printout prints a non-field, we enclose
that information in square brackets, such as:
perf-1380 [013] 724.903505: softirq_exit: vec=9 [action=RCU]
perf-1380 [013] 724.904482: softirq_exit: vec=1 [action=TIMER]
This way users can use filter expressions more intuitively: all
fields that show up as 'primary' (non-bracketed) information is
filterable.
This patch harmonizes the field names for all irq, bkl, power,
sched and timer events.
We might in fact think about dropping the print format bit of
generic tracepoints altogether, and just print the fields that
are being recorded.
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-15 09:50:39 +00:00
|
|
|
TP_printk("comm=%s pid=%d child_comm=%s child_pid=%d",
|
2009-04-10 12:54:16 +00:00
|
|
|
__entry->parent_comm, __entry->parent_pid,
|
|
|
|
|
__entry->child_comm, __entry->child_pid)
|
|
|
|
|
);
|
|
|
|
|
|
2012-02-07 16:11:05 +00:00
|
|
|
/*
|
|
|
|
|
* 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;
|
2012-03-30 16:26:36 +00:00
|
|
|
__entry->old_pid = old_pid;
|
2012-02-07 16:11:05 +00:00
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("filename=%s pid=%d old_pid=%d", __get_str(filename),
|
|
|
|
|
__entry->pid, __entry->old_pid)
|
|
|
|
|
);
|
|
|
|
|
|
2009-07-23 18:13:26 +00:00
|
|
|
/*
|
|
|
|
|
* XXX the below sched_stat tracepoints only apply to SCHED_OTHER/BATCH/IDLE
|
|
|
|
|
* adding sched_stat support to SCHED_FIFO/RR would be welcome.
|
|
|
|
|
*/
|
2009-11-26 08:04:55 +00:00
|
|
|
DECLARE_EVENT_CLASS(sched_stat_template,
|
2009-07-23 18:13:26 +00:00
|
|
|
|
|
|
|
|
TP_PROTO(struct task_struct *tsk, u64 delay),
|
|
|
|
|
|
2013-08-06 16:08:44 +00:00
|
|
|
TP_ARGS(__perf_task(tsk), __perf_count(delay)),
|
2009-07-23 18:13:26 +00:00
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
),
|
|
|
|
|
|
events: Harmonize event field names and print output names
Now that we can filter based on fields via perf record, people
will start using filter expressions and will expect them to
be obvious.
The primary way to see which fields are available is by looking
at the trace output, such as:
gcc-18676 [000] 343.011728: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.012727: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.032692: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.033690: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.034687: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.035686: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.036684: irq_handler_entry: irq=0 handler=timer
While 'irq==0' filters work, the 'handler==<x>' filter expression
does not work:
$ perf record -R -f -a -e irq:irq_handler_entry --filter handler=timer sleep 1
Error: failed to set filter with 22 (Invalid argument)
The problem is that while an 'irq' field exists and is recognized
as a filter field - 'handler' does not exist - its name is 'name'
in the output.
To solve this, we need to synchronize the printout and the field
names, wherever possible.
In cases where the printout prints a non-field, we enclose
that information in square brackets, such as:
perf-1380 [013] 724.903505: softirq_exit: vec=9 [action=RCU]
perf-1380 [013] 724.904482: softirq_exit: vec=1 [action=TIMER]
This way users can use filter expressions more intuitively: all
fields that show up as 'primary' (non-bracketed) information is
filterable.
This patch harmonizes the field names for all irq, bkl, power,
sched and timer events.
We might in fact think about dropping the print format bit of
generic tracepoints altogether, and just print the fields that
are being recorded.
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-15 09:50:39 +00:00
|
|
|
TP_printk("comm=%s pid=%d delay=%Lu [ns]",
|
2009-07-23 18:13:26 +00:00
|
|
|
__entry->comm, __entry->pid,
|
|
|
|
|
(unsigned long long)__entry->delay)
|
|
|
|
|
);
|
|
|
|
|
|
2009-11-19 01:48:08 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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).
|
|
|
|
|
*/
|
2009-11-26 07:08:01 +00:00
|
|
|
DEFINE_EVENT(sched_stat_template, sched_stat_sleep,
|
|
|
|
|
TP_PROTO(struct task_struct *tsk, u64 delay),
|
|
|
|
|
TP_ARGS(tsk, delay));
|
2009-11-19 01:48:08 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Tracepoint for accounting iowait time (time the task is not runnable
|
|
|
|
|
* due to waiting on IO to complete).
|
|
|
|
|
*/
|
2009-11-26 07:08:01 +00:00
|
|
|
DEFINE_EVENT(sched_stat_template, sched_stat_iowait,
|
|
|
|
|
TP_PROTO(struct task_struct *tsk, u64 delay),
|
|
|
|
|
TP_ARGS(tsk, delay));
|
2009-11-19 01:48:08 +00:00
|
|
|
|
2011-11-28 09:03:35 +00:00
|
|
|
/*
|
|
|
|
|
* 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));
|
|
|
|
|
|
2009-09-13 16:15:54 +00:00
|
|
|
/*
|
|
|
|
|
* Tracepoint for accounting runtime (time the task is executing
|
|
|
|
|
* on a CPU).
|
|
|
|
|
*/
|
2013-08-06 16:08:41 +00:00
|
|
|
DECLARE_EVENT_CLASS(sched_stat_runtime,
|
2009-09-13 16:15:54 +00:00
|
|
|
|
|
|
|
|
TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime),
|
|
|
|
|
|
2013-08-06 16:08:44 +00:00
|
|
|
TP_ARGS(tsk, __perf_count(runtime), vruntime),
|
2009-09-13 16:15:54 +00:00
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
),
|
|
|
|
|
|
events: Harmonize event field names and print output names
Now that we can filter based on fields via perf record, people
will start using filter expressions and will expect them to
be obvious.
The primary way to see which fields are available is by looking
at the trace output, such as:
gcc-18676 [000] 343.011728: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.012727: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.032692: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.033690: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.034687: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.035686: irq_handler_entry: irq=0 handler=timer
cc1-18677 [000] 343.036684: irq_handler_entry: irq=0 handler=timer
While 'irq==0' filters work, the 'handler==<x>' filter expression
does not work:
$ perf record -R -f -a -e irq:irq_handler_entry --filter handler=timer sleep 1
Error: failed to set filter with 22 (Invalid argument)
The problem is that while an 'irq' field exists and is recognized
as a filter field - 'handler' does not exist - its name is 'name'
in the output.
To solve this, we need to synchronize the printout and the field
names, wherever possible.
In cases where the printout prints a non-field, we enclose
that information in square brackets, such as:
perf-1380 [013] 724.903505: softirq_exit: vec=9 [action=RCU]
perf-1380 [013] 724.904482: softirq_exit: vec=1 [action=TIMER]
This way users can use filter expressions more intuitively: all
fields that show up as 'primary' (non-bracketed) information is
filterable.
This patch harmonizes the field names for all irq, bkl, power,
sched and timer events.
We might in fact think about dropping the print format bit of
generic tracepoints altogether, and just print the fields that
are being recorded.
Cc: Li Zefan <lizf@cn.fujitsu.com>
Cc: Tom Zanussi <tzanussi@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-15 09:50:39 +00:00
|
|
|
TP_printk("comm=%s pid=%d runtime=%Lu [ns] vruntime=%Lu [ns]",
|
2009-09-13 16:15:54 +00:00
|
|
|
__entry->comm, __entry->pid,
|
|
|
|
|
(unsigned long long)__entry->runtime,
|
|
|
|
|
(unsigned long long)__entry->vruntime)
|
|
|
|
|
);
|
|
|
|
|
|
2013-08-06 16:08:41 +00:00
|
|
|
DEFINE_EVENT(sched_stat_runtime, sched_stat_runtime,
|
|
|
|
|
TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime),
|
|
|
|
|
TP_ARGS(tsk, runtime, vruntime));
|
|
|
|
|
|
2010-09-20 19:13:34 +00:00
|
|
|
/*
|
|
|
|
|
* 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)
|
|
|
|
|
);
|
|
|
|
|
|
2013-10-19 16:18:28 +00:00
|
|
|
#ifdef CONFIG_DETECT_HUNG_TASK
|
|
|
|
|
TRACE_EVENT(sched_process_hang,
|
|
|
|
|
TP_PROTO(struct task_struct *tsk),
|
|
|
|
|
TP_ARGS(tsk),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__array( char, comm, TASK_COMM_LEN )
|
|
|
|
|
__field( pid_t, pid )
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
|
|
|
|
|
__entry->pid = tsk->pid;
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("comm=%s pid=%d", __entry->comm, __entry->pid)
|
|
|
|
|
);
|
|
|
|
|
#endif /* CONFIG_DETECT_HUNG_TASK */
|
|
|
|
|
|
2014-01-21 23:51:03 +00:00
|
|
|
DECLARE_EVENT_CLASS(sched_move_task_template,
|
|
|
|
|
|
|
|
|
|
TP_PROTO(struct task_struct *tsk, int src_cpu, int dst_cpu),
|
|
|
|
|
|
|
|
|
|
TP_ARGS(tsk, src_cpu, dst_cpu),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field( pid_t, pid )
|
|
|
|
|
__field( pid_t, tgid )
|
|
|
|
|
__field( pid_t, ngid )
|
|
|
|
|
__field( int, src_cpu )
|
|
|
|
|
__field( int, src_nid )
|
|
|
|
|
__field( int, dst_cpu )
|
|
|
|
|
__field( int, dst_nid )
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->pid = task_pid_nr(tsk);
|
|
|
|
|
__entry->tgid = task_tgid_nr(tsk);
|
|
|
|
|
__entry->ngid = task_numa_group_id(tsk);
|
|
|
|
|
__entry->src_cpu = src_cpu;
|
|
|
|
|
__entry->src_nid = cpu_to_node(src_cpu);
|
|
|
|
|
__entry->dst_cpu = dst_cpu;
|
|
|
|
|
__entry->dst_nid = cpu_to_node(dst_cpu);
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("pid=%d tgid=%d ngid=%d src_cpu=%d src_nid=%d dst_cpu=%d dst_nid=%d",
|
|
|
|
|
__entry->pid, __entry->tgid, __entry->ngid,
|
|
|
|
|
__entry->src_cpu, __entry->src_nid,
|
|
|
|
|
__entry->dst_cpu, __entry->dst_nid)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Tracks migration of tasks from one runqueue to another. Can be used to
|
|
|
|
|
* detect if automatic NUMA balancing is bouncing between nodes
|
|
|
|
|
*/
|
|
|
|
|
DEFINE_EVENT(sched_move_task_template, sched_move_numa,
|
|
|
|
|
TP_PROTO(struct task_struct *tsk, int src_cpu, int dst_cpu),
|
|
|
|
|
|
|
|
|
|
TP_ARGS(tsk, src_cpu, dst_cpu)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
DEFINE_EVENT(sched_move_task_template, sched_stick_numa,
|
|
|
|
|
TP_PROTO(struct task_struct *tsk, int src_cpu, int dst_cpu),
|
|
|
|
|
|
|
|
|
|
TP_ARGS(tsk, src_cpu, dst_cpu)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
TRACE_EVENT(sched_swap_numa,
|
|
|
|
|
|
|
|
|
|
TP_PROTO(struct task_struct *src_tsk, int src_cpu,
|
|
|
|
|
struct task_struct *dst_tsk, int dst_cpu),
|
|
|
|
|
|
|
|
|
|
TP_ARGS(src_tsk, src_cpu, dst_tsk, dst_cpu),
|
|
|
|
|
|
|
|
|
|
TP_STRUCT__entry(
|
|
|
|
|
__field( pid_t, src_pid )
|
|
|
|
|
__field( pid_t, src_tgid )
|
|
|
|
|
__field( pid_t, src_ngid )
|
|
|
|
|
__field( int, src_cpu )
|
|
|
|
|
__field( int, src_nid )
|
|
|
|
|
__field( pid_t, dst_pid )
|
|
|
|
|
__field( pid_t, dst_tgid )
|
|
|
|
|
__field( pid_t, dst_ngid )
|
|
|
|
|
__field( int, dst_cpu )
|
|
|
|
|
__field( int, dst_nid )
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_fast_assign(
|
|
|
|
|
__entry->src_pid = task_pid_nr(src_tsk);
|
|
|
|
|
__entry->src_tgid = task_tgid_nr(src_tsk);
|
|
|
|
|
__entry->src_ngid = task_numa_group_id(src_tsk);
|
|
|
|
|
__entry->src_cpu = src_cpu;
|
|
|
|
|
__entry->src_nid = cpu_to_node(src_cpu);
|
|
|
|
|
__entry->dst_pid = task_pid_nr(dst_tsk);
|
|
|
|
|
__entry->dst_tgid = task_tgid_nr(dst_tsk);
|
|
|
|
|
__entry->dst_ngid = task_numa_group_id(dst_tsk);
|
|
|
|
|
__entry->dst_cpu = dst_cpu;
|
|
|
|
|
__entry->dst_nid = cpu_to_node(dst_cpu);
|
|
|
|
|
),
|
|
|
|
|
|
|
|
|
|
TP_printk("src_pid=%d src_tgid=%d src_ngid=%d src_cpu=%d src_nid=%d dst_pid=%d dst_tgid=%d dst_ngid=%d dst_cpu=%d dst_nid=%d",
|
|
|
|
|
__entry->src_pid, __entry->src_tgid, __entry->src_ngid,
|
|
|
|
|
__entry->src_cpu, __entry->src_nid,
|
|
|
|
|
__entry->dst_pid, __entry->dst_tgid, __entry->dst_ngid,
|
|
|
|
|
__entry->dst_cpu, __entry->dst_nid)
|
|
|
|
|
);
|
2009-04-10 12:54:16 +00:00
|
|
|
#endif /* _TRACE_SCHED_H */
|
2009-04-10 13:36:00 +00:00
|
|
|
|
|
|
|
|
/* This part must be outside protection */
|
|
|
|
|
#include <trace/define_trace.h>
|
