tracing: print event flags and symbols
Steven Rostedt
maintainerPATCH 3/5 tracing: add flag output for kmem events
In reply to Steven RostedtFrom: Steven Rostedt <[email protected]>
This patch changes the output for gfp_flags from being a simple hex value to the actual names.
gfp_flags=GFP_ATOMIC instead of gfp_flags=00000020
And even
gfp_flags=GFP_KERNEL instead of gfp_flags=000000d0
(Thanks to Frederic Weisbecker for pointing out that the first version
had a bad order of GFP masks)
[ Impact: more human readable output from tracer ]
--- include/trace/events/kmem.h | 53 ++++++++++++++++++++++++++++++++++++------ 1 files changed, 45 insertions(+), 8 deletions(-)
include/trace/events/kmem.h +45 -8
@@ -7,6 +7,43 @@#undef TRACE_SYSTEM#define TRACE_SYSTEM kmem +/* +* The order of these masks is important. Matching masks will be seen +* first and the left over flags will end up showing by themselves. +* +* For example, if we have GFP_KERNEL before GFP_USER we wil get: +* +* GFP_KERNEL|GFP_HARDWALL +* +* Thus most bits set go first. +*/ +#define show_gfp_flags (flags) \ + (flags) ? __print_flags(flags, "|", \ + {(unsigned long)GFP_HIGHUSER_MOVABLE, "GFP_HIGHUSER_MOVABLE"}, \ + {(unsigned long)GFP_HIGHUSER, "GFP_HIGHUSER"}, \ + {(unsigned long)GFP_USER, "GFP_USER"}, \ + {(unsigned long)GFP_TEMPORARY, "GFP_TEMPORARY"}, \ + {(unsigned long)GFP_KERNEL, "GFP_KERNEL"}, \ + {(unsigned long)GFP_NOFS, "GFP_NOFS"}, \ + {(unsigned long)GFP_ATOMIC, "GFP_ATOMIC"}, \ + {(unsigned long)GFP_NOIO, "GFP_NOIO"}, \ + {(unsigned long)__GFP_HIGH, "GFP_HIGH"}, \ + {(unsigned long)__GFP_WAIT, "GFP_WAIT"}, \ + {(unsigned long)__GFP_IO, "GFP_IO"}, \ + {(unsigned long)__GFP_COLD, "GFP_COLD"}, \ + {(unsigned long)__GFP_NOWARN, "GFP_NOWARN"}, \ + {(unsigned long)__GFP_REPEAT, "GFP_REPEAT"}, \ + {(unsigned long)__GFP_NOFAIL, "GFP_NOFAIL"}, \ + {(unsigned long)__GFP_NORETRY, "GFP_NORETRY"}, \ + {(unsigned long)__GFP_COMP, "GFP_COMP"}, \ + {(unsigned long)__GFP_ZERO, "GFP_ZERO"}, \ + {(unsigned long)__GFP_NOMEMALLOC, "GFP_NOMEMALLOC"}, \ + {(unsigned long)__GFP_HARDWALL, "GFP_HARDWALL"}, \ + {(unsigned long)__GFP_THISNODE, "GFP_THISNODE"}, \ + {(unsigned long)__GFP_RECLAIMABLE, "GFP_RECLAIMABLE"}, \ + {(unsigned long)__GFP_MOVABLE, "GFP_MOVABLE"} \ + ) : "GFP_NOWAIT" + TRACE_EVENT(kmalloc, TP_PROTO(unsigned long call_site,
@@ -33,12 +70,12 @@ TRACE_EVENT(kmalloc, __entry->gfp_flags = gfp_flags; ), -TP_printk ("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x" , +TP_printk ("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%s" , __entry->call_site, __entry->ptr, __entry->bytes_req, __entry->bytes_alloc, - __entry->gfp_flags) +show_gfp_flags (__entry->gfp_flags)) ); TRACE_EVENT(kmem_cache_alloc,
@@ -67,12 +104,12 @@ TRACE_EVENT(kmem_cache_alloc, __entry->gfp_flags = gfp_flags; ), -TP_printk ("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x" , +TP_printk ("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%s" , __entry->call_site, __entry->ptr, __entry->bytes_req, __entry->bytes_alloc, - __entry->gfp_flags) +show_gfp_flags (__entry->gfp_flags)) ); TRACE_EVENT(kmalloc_node,
@@ -104,12 +141,12 @@ TRACE_EVENT(kmalloc_node, __entry->node = node; ), -TP_printk ("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x node=%d" , +TP_printk ("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%s node=%d" , __entry->call_site, __entry->ptr, __entry->bytes_req, __entry->bytes_alloc, - __entry->gfp_flags, +show_gfp_flags (__entry->gfp_flags), __entry->node) );
@@ -142,12 +179,12 @@ TRACE_EVENT(kmem_cache_alloc_node, __entry->node = node; ), -TP_printk ("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%08x node=%d" , +TP_printk ("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%s node=%d" , __entry->call_site, __entry->ptr, __entry->bytes_req, __entry->bytes_alloc, - __entry->gfp_flags, +show_gfp_flags (__entry->gfp_flags), __entry->node) );
Signature · 3 lines
1.6.2.4 --
Steven Rostedt
maintainerIngo,
Please pull the latest tip/tracing/ftrace-1 tree, which can be found at:
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-2.6-trace.git
tip/tracing/ftrace-1
Steven Rostedt (5):
tracing: add __print_flags for events
tracing: add previous task state info to sched switch event
tracing: add flag output for kmem events
tracing: add __print_symbolic to trace events
tracing: convert irq events to use __print_symbolic
----
include/linux/ftrace_event.h | 16 ++++++++++- include/trace/events/irq.h | 23 +++++++++++---- include/trace/events/kmem.h | 53 ++++++++++++++++++++++++++++++----- include/trace/events/sched.h | 9 +++++- include/trace/ftrace.h | 22 ++++++++++++++ kernel/trace/trace_output.c | 63 ++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 170 insertions(+), 16 deletions(-)
Steven Rostedt
maintainerPATCH 4/5 tracing: add __print_symbolic to trace events
From: Steven Rostedt <[email protected]>
This patch adds __print_symbolic which is similar to __print_flags but works for an enumeration type instead. That is, there is only a one to one mapping between the values and the symbols. When a match is made, then it is printed, otherwise the hex value is outputed.
[ Impact: add interface for showing symbol names in events ]
--- include/linux/ftrace_event.h | 3 +++ include/trace/ftrace.h | 8 ++++++++ kernel/trace/trace_output.c | 25 +++++++++++++++++++++++++ 3 files changed, 36 insertions(+), 0 deletions(-)
include/linux/ftrace_event.h +3 -0
@@ -20,6 +20,9 @@ const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,unsigned long flags, const struct trace_print_flags *flag_array); +const char *ftrace_print_symbols_seq (struct trace_seq *p,unsigned long val, +const struct trace_print_flags *symbol_array); +/* * The trace entry - the most basic unit of tracing. This is what * is printed in the end as a single line in the trace output, such as:
include/trace/ftrace.h +8 -0
@@ -130,6 +130,14 @@ftrace_print_flags_seq (p, delim, flag, flags); \ }) +#undef __print_symbolic +#define __print_symbolic(value, symbol_array...) \ + ({ \ + static const struct trace_print_flags symbols[] = \ + { symbol_array, { -1, NULL }}; \ + ftrace_print_symbols_seq(p, value, symbols); \ + }) +#undef TRACE_EVENT#define TRACE_EVENT (call, proto, args, tstruct, assign, print) \ enum print_line_t \
kernel/trace/trace_output.c +25 -0
@@ -250,6 +250,31 @@ ftrace_print_flags_seq(struct trace_seq *p, const char *delim,return p->buffer; } +const char * +ftrace_print_symbols_seq (struct trace_seq *p,unsigned long val, +const struct trace_print_flags *symbol_array) +{ +int i; + +trace_seq_init (p); + +for (i =0 ; symbol_array[i].name; i++) { + +if (val != symbol_array[i].mask) +continue ; + +trace_seq_puts (p, symbol_array[i].name); +break ; + } + +if (!p->len) +trace_seq_printf (p,"0x%lx" , val); + +trace_seq_putc (p,0 ); + +return p->buffer; +} +#ifdef CONFIG_KRETPROBES static inline const char *kretprobed (const char *name) {
Signature · 3 lines
1.6.2.4 --
Steven Rostedt
maintainerPATCH 2/5 tracing: add previous task state info to sched switch event
In reply to Steven RostedtFrom: Steven Rostedt <[email protected]>
It is useful to see the state of a task that is being switched out. This patch adds the output of the state of the previous task in the context switch event.
[ Impact: see state of switched out task in context switch ]
--- include/trace/events/sched.h | 9 ++++++++- 1 files changed, 8 insertions(+), 1 deletions(-)
include/trace/events/sched.h +8 -1
@@ -156,6 +156,7 @@ TRACE_EVENT(sched_switch, __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 )
@@ -165,13 +166,19 @@ TRACE_EVENT(sched_switch,memcpy (__entry->next_comm, next->comm,TASK_COMM_LEN ); __entry->prev_pid = prev->pid; __entry->prev_prio = prev->prio; + __entry->prev_state = prev->state;memcpy (__entry->prev_comm, prev->comm,TASK_COMM_LEN ); __entry->next_pid = next->pid; __entry->next_prio = next->prio; ), -TP_printk ("task %s:%d [%d] ==> %s:%d [%d]" , +TP_printk ("task %s:%d [%d] (%s) ==> %s:%d [%d]" , __entry->prev_comm, __entry->prev_pid, __entry->prev_prio, + __entry->prev_state ? +__print_flags (__entry->prev_state,"|" , + { 1, "S"} , { 2, "D" }, { 4, "T" }, { 8, "t" }, + { 16, "Z" }, { 32, "X" }, { 64, "x" }, + { 128, "W" }) : "R", __entry->next_comm, __entry->next_pid, __entry->next_prio) );
Signature · 3 lines
1.6.2.4 --
Steven Rostedt
maintainerPATCH 1/5 tracing: add __print_flags for events
In reply to Steven RostedtFrom: Steven Rostedt <[email protected]>
Developers have been asking for the ability in the ftrace event tracer to display names of bits in a flags variable.
Instead of printing out c2, it would be easier to read FOO|BAR|GOO, assuming that FOO is bit 1, BAR is bit 6 and GOO is bit 7.
Some examples where this would be useful are the state flags in a context switch, kmalloc flags, and even permision flags in accessing files.
[
v2 changes include:
Frederic Weisbecker's idea of using a mask instead of bits, thus we can output GFP_KERNEL instead of GPF_WAIT|GFP_IO|GFP_FS.
Li Zefan's idea of allowing the caller of __print_flags to add their own delimiter (or no delimiter) where we can get for file permissions rwx instead of r|w|x.
]
[
v3 changes:
Christoph Hellwig's idea of using an array instead of va_args.
]
[ Impact: better displaying of flags in trace output ]
--- include/linux/ftrace_event.h | 13 ++++++++++++- include/trace/ftrace.h | 14 ++++++++++++++ kernel/trace/trace_output.c | 38 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 64 insertions(+), 1 deletions(-)
include/linux/ftrace_event.h +12 -1
@@ -3,12 +3,23 @@#include <linux/trace_seq.h> #include <linux/ring_buffer.h> - +#include <linux/percpu.h> struct trace_array ;struct tracer ;struct dentry ; +DECLARE_PER_CPU(struct trace_seq, ftrace_event_seq); + +struct trace_print_flags { +unsigned long mask; +const char *name; +}; + +const char *ftrace_print_flags_seq (struct trace_seq *p,const char *delim, +unsigned long flags, +const struct trace_print_flags *flag_array); +/* * The trace entry - the most basic unit of tracing. This is what * is printed in the end as a single line in the trace output, such as:
include/trace/ftrace.h +14 -0
@@ -87,6 +87,7 @@* struct trace_seq *s = &iter->seq; * struct ftrace_raw_<call> *field; <-- defined in stage 1 * struct trace_entry *entry; +* struct trace_seq *p; * int ret; * * entry = iter->ent;
@@ -98,7 +99,9 @@* * field = (typeof(field))entry; * +* p = get_cpu_var(ftrace_event_seq); * ret = trace_seq_printf(s, <TP_printk> "\n"); +* put_cpu(); * if (!ret) * return TRACE_TYPE_PARTIAL_LINE; *
@@ -119,6 +122,14 @@#undef __get_str#define __get_str (field) ((char *)__entry + __entry->__str_loc_##field) +#undef __print_flags +#define __print_flags(flag, delim, flag_array...) \ + ({ \ + static const struct trace_print_flags flags[] = \ + { flag_array, { -1, NULL }}; \ + ftrace_print_flags_seq(p, delim, flag, flags); \ + }) +#undef TRACE_EVENT#define TRACE_EVENT (call, proto, args, tstruct, assign, print) \ enum print_line_t \
@@ -127,6 +138,7 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags) \struct trace_seq *s = &iter->seq; \ struct ftrace_raw_##call *field; \struct trace_entry *entry; \ +struct trace_seq *p; \int ret; \ \ entry = iter->ent; \
@@ -138,7 +150,9 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags) \ \ field = (typeof (field ))entry; \ \ + p = &get_cpu_var (ftrace_event_seq); \ ret = trace_seq_printf(s, #call ": " print); \ +put_cpu (); \if (!ret) \return TRACE_TYPE_PARTIAL_LINE ; \ \
kernel/trace/trace_output.c +38 -0
@@ -14,6 +14,8 @@/* must be a power of 2 */ #define EVENT_HASHSIZE 128 +DEFINE_PER_CPU(struct trace_seq, ftrace_event_seq); +static DEFINE_MUTEX (trace_event_mutex);static struct hlist_head event_hash[EVENT_HASHSIZE ]__read_mostly ;
@@ -212,6 +214,42 @@ int trace_seq_path(struct trace_seq *s, struct path *path)return 0 ; } +const char * +ftrace_print_flags_seq (struct trace_seq *p,const char *delim, +unsigned long flags, +const struct trace_print_flags *flag_array) +{ +unsigned long mask; +const char *str; +int i; + +trace_seq_init (p); + +for (i =0 ; flag_array[i].name && flags; i++) { + + mask = flag_array[i].mask; +if ((flags & mask) != mask) +continue ; + + str = flag_array[i].name; + flags &= ~mask; +if (p->len && delim) +trace_seq_puts (p, delim); +trace_seq_puts (p, str); + } + +/* check for left over flags */ +if (flags) { +if (p->len && delim) +trace_seq_puts (p, delim); +trace_seq_printf (p,"0x%lx" , flags); + } + +trace_seq_putc (p,0 ); + +return p->buffer; +} +#ifdef CONFIG_KRETPROBES static inline const char *kretprobed (const char *name) {
Signature · 3 lines
1.6.2.4 --
Steven Rostedt
maintainerPATCH 5/5 tracing: convert irq events to use __print_symbolic
In reply to Steven RostedtFrom: Steven Rostedt <[email protected]>
The recording of the names at trace time is inefficient. This patch implements the softirq event recording to only record the vector and then use the __print_symbolic interface to print out the names.
[ Impact: faster recording of softirq events ]
--- include/trace/events/irq.h | 23 +++++++++++++++++------ 1 files changed, 17 insertions(+), 6 deletions(-)
include/trace/events/irq.h +17 -6
@@ -7,6 +7,19 @@#undef TRACE_SYSTEM#define TRACE_SYSTEM irq +#define softirq_name (sirq) { sirq, #sirq } +#define show_softirq_name (val) \ + __print_symbolic(val, \ + softirq_name(HI_SOFTIRQ), \ + softirq_name(TIMER_SOFTIRQ), \ + softirq_name(NET_TX_SOFTIRQ), \ + softirq_name(NET_RX_SOFTIRQ), \ + softirq_name(BLOCK_SOFTIRQ), \ + softirq_name(TASKLET_SOFTIRQ), \ + softirq_name(SCHED_SOFTIRQ), \ + softirq_name(HRTIMER_SOFTIRQ), \ + softirq_name(RCU_SOFTIRQ)) +/** * irq_handler_entry - called immediately before the irq action handler * @irq: irq number
@@ -87,15 +100,14 @@ TRACE_EVENT(softirq_entry,TP_STRUCT__entry (__field ( int, vec ) - __string( name, softirq_to_name[h-vec] ) ),TP_fast_assign ( __entry->vec = (int)(h - vec); -__assign_str (name, softirq_to_name[h-vec]); ), -TP_printk ("softirq=%d action=%s" , __entry->vec,__get_str (name)) +TP_printk ("softirq=%d action=%s" , __entry->vec, +show_softirq_name (__entry->vec)) );/**
@@ -117,15 +129,14 @@ TRACE_EVENT(softirq_exit,TP_STRUCT__entry (__field ( int, vec ) - __string( name, softirq_to_name[h-vec] ) ),TP_fast_assign ( __entry->vec = (int)(h - vec); -__assign_str (name, softirq_to_name[h-vec]); ), -TP_printk ("softirq=%d action=%s" , __entry->vec,__get_str (name)) +TP_printk ("softirq=%d action=%s" , __entry->vec, +show_softirq_name (__entry->vec)) );#endif /* _TRACE_IRQ_H */
Signature · 3 lines
1.6.2.4 --
Re: [PATCH 5/5] tracing: convert irq events to use __print_symbolic
include/trace/events/irq.h line 22
Quoted 13 lines
include/trace/events/irq.h +13
-0+#define softirq_name (sirq) { sirq, #sirq } +#define show_softirq_name (val) \ + __print_symbolic(val, \ + softirq_name(HI_SOFTIRQ), \ + softirq_name(TIMER_SOFTIRQ), \ + softirq_name(NET_TX_SOFTIRQ), \ + softirq_name(NET_RX_SOFTIRQ), \ + softirq_name(BLOCK_SOFTIRQ), \ + softirq_name(TASKLET_SOFTIRQ), \ + softirq_name(SCHED_SOFTIRQ), \ + softirq_name(HRTIMER_SOFTIRQ), \ + softirq_name(RCU_SOFTIRQ)) +
The ending "_SOFTIRQ" is just redundant.
And it's you that removed "_SOFTIRQ" in the output of irq trace events. ;)
==========
commit 899039e8746bb9a09b6487ddb8ab2275ce9d0256
Author: Steven Rostedt <[email protected]> Date: Fri Mar 13 00:43:33 2009 -0400
softirq: no need to have SOFTIRQ in softirq name
Impact: clean up
It is redundant to have 'SOFTIRQ' in the softirq names.
==========
How about:
#define softirq_name(sirq) { sirq ## _SOFTIRQ, #sirq }
#define show_softirq_name(val) \ __print_symbolic(val, \ softirq_name(HI), \
or:
#define softirq_name(sirq) { sirq, softirq_to_name[sirq] }