tracing: Use TRACE_DEFINE_ENUM() to show enum values
Subsystems (13)
Steven Rostedt
maintainerv2 cover tracing: Use TRACE_DEFINE_ENUM() to show enum values
As there are many tracepoints that use __print_symbolic() to translate numbers into ASCII strings, and several of these translate enums as well, it causes a problem for user space tools that read the tracepoint format files and have to translate the binary data to their associated strings.
For example, with the tlb_flush tracepoint, we have this in the format file:
print fmt: "pages:%ld reason:%s (%d)", REC->pages,
__print_symbolic(REC->reason,
{ TLB_FLUSH_ON_TASK_SWITCH, "flush on task switch" }, { TLB_REMOTE_SHOOTDOWN, "remote shootdown" },
{ TLB_LOCAL_SHOOTDOWN, "local shootdown" },
{ TLB_LOCAL_MM_SHOOTDOWN, "local mm shootdown" }), REC->reason
Now, userspace does not know what the value of TLB_REMOTE_SHOOTDOWN is. To solve this, a new macro is created as a helper to allow tracepoints to export enums they use to userspace. This macro is called, TRACE_DEFINE_ENUM(), such that
TRACE_DEFINE_ENUM(TLB_REMOTE_SHOOTDOWN);
will convert the "print fmt"s in the format files to its actual value and no longer display the enum name.
On boot up (or module load), the enums saved via TRACE_DEFINE_ENUM() will be searched for in the TP_printk()s of the tracepoints. Logic knows enough to ignore quoted text.
For debugging, a new file is still added in the tracing directory to show what enums were added, their values and the TRACE_SYSTEM that added them:
# cat /sys/kernel/debug/tracing/enum_map TLB_LOCAL_MM_SHOOTDOWN 3 (tlb) TLB_LOCAL_SHOOTDOWN 2 (tlb) TLB_REMOTE_SHOOTDOWN 1 (tlb) TLB_FLUSH_ON_TASK_SWITCH 0 (tlb)
And the output of the tlb_flush format is now:
print fmt: "pages:%ld reason:%s (%d)", REC->pages,
__print_symbolic(REC->reason,
{ 0, "flush on task switch" },
{ 1, "remote shootdown" },
{ 2, "local shootdown" },
{ 3, "local mm shootdown" }), REC->reason
And userspace tools can easily parse that without special handling.
Local SHA1: a6862181206543b6493c73690f322868c86de0ea
Steven Rostedt (Red Hat) (17):
tracing: Add TRACE_SYSTEM_VAR to intel-sst
tracing: Add TRACE_SYSTEM_VAR to kvm-s390
tracing: Add TRACE_SYSTEM_VAR to xhci-hcd
tracing: Give system name a pointer
tracing: Update trace-event-sample with TRACE_SYSTEM_VAR documentation
tracing: Add TRACE_DEFINE_ENUM() macro to map enums to their values
tracing: Allow for modules to export their trace enums as well tracing/samples: Update the trace-event-sample.h with TRACE_DEFINE_ENUM()
tracing: Show the mapped enums in enum_map file x86/tlb/trace: Export enums in used by tlb_flush tracepoint net/9p/tracing: Export enums in tracepoints to userspace
f2fs: Export the enums in the tracepoints to userspace irq/tracing: Export enums in tracepoints to user space
mm: tracing: Export enums in tracepoints to user space
SUNRPC: Export enums in tracepoints to user space
v4l: Export enums used by tracepoints to user space
writeback: Export enums used by tracepoint to user space
----
arch/s390/kvm/trace-s390.h | 7 + drivers/usb/host/xhci-trace.h | 7 + include/asm-generic/vmlinux.lds.h | 5 +- include/linux/ftrace_event.h | 4 +- include/linux/module.h | 2 + include/linux/tracepoint.h | 8 + include/trace/events/9p.h | 157 ++++++++-------- include/trace/events/f2fs.h | 30 ++++ include/trace/events/intel-sst.h | 7 + include/trace/events/irq.h | 39 ++-- include/trace/events/migrate.h | 42 +++-- include/trace/events/sunrpc.h | 62 +++++-- include/trace/events/tlb.h | 30 +++- include/trace/events/v4l2.h | 75 +++++--- include/trace/events/writeback.h | 33 +++- include/trace/ftrace.h | 41 ++++- kernel/module.c | 3 + kernel/trace/trace.c | 276 ++++++++++++++++++++++++++++- kernel/trace/trace.h | 2 + kernel/trace/trace_events.c | 98 +++++++++- samples/trace_events/trace-events-sample.h | 84 ++++++++- 21 files changed, 853 insertions(+), 159 deletions(-)
Steven Rostedt
maintainerRFC PATCH v2 1/17 tracing: Add TRACE_SYSTEM_VAR to intel-sst
From: "Steven Rostedt (Red Hat)" <[email protected]>
New code will require TRACE_SYSTEM to be a valid C variable name, but some tracepoints have TRACE_SYSTEM with '-' and not '_', so it can not be used. Instead, add a TRACE_SYSTEM_VAR that can give the tracing infrastructure a unique name for the trace system.
--- include/trace/events/intel-sst.h | 7 +++++++ 1 file changed, 7 insertions(+)
include/trace/events/intel-sst.h +7 -0
@@ -1,6 +1,13 @@#undef TRACE_SYSTEM#define TRACE_SYSTEM intel-sst +/* +* The TRACE_SYSTEM_VAR defaults to TRACE_SYSTEM, but must be a +* legitimate C variable. It is not exported to user space. +*/ +#undef TRACE_SYSTEM_VAR +#define TRACE_SYSTEM_VAR intel_sst +#if !defined(_TRACE_INTEL_SST_H) || defined(TRACE_HEADER_MULTI_READ )#define _TRACE_INTEL_SST_H
Signature · 1 line
2.1.4
A message that is not in the archive (sent off-list or not yet received): CADRr18NOdH3rqLeK3aJBaQ5ZfQSPDYiLdkDNshzSvUwctR8EEQ@mail.gmail.com
Steven Rostedt
maintainerRe: [RFC][PATCH 01/17 v2] tracing: Add TRACE_SYSTEM_VAR to intel-sst
Quoted 9 lines · On Thu, 2 Apr 2015 10:16:22 +0100 Mark Brown <[email protected]> wrote:
Quoted 7 lines · Steven Rostedt
From: "Steven Rostedt (Red Hat)" <[email protected]>
New code will require
TRACE_SYSTEMto be a valid C variable name, but some tracepoints haveTRACE_SYSTEMwith '-' and not '_', so it can not be used. Instead, add aTRACE_SYSTEM_VARthat can give the tracing infrastructure a unique name for the trace system.
Quoted 7 lines
Quoted 2 lines
Cc Mark Brown <[email protected]>I'm not sure why you're sending this to my work address but please use [email protected] for anything upstream (it's what's in
MAINTAINERSand what I've been using pretty consistently for e-mail).
Sorry, I got that from git log include/trace/events/intel-sst.h
I couldn't find anything in MAINTAINERS about that file, but I didn't look for your name though.
-- Steve
Steven Rostedt
maintainerRe: [RFC][PATCH 01/17 v2] tracing: Add TRACE_SYSTEM_VAR to intel-sst
Quoted 20 lines · On Thu, 2 Apr 2015 09:32:49 -0400 Steven Rostedt <[email protected]> wrote:
Quoted 9 lines · On Thu, 2 Apr 2015 10:16:22 +0100 Mark Brown <[email protected]> wrote:
Quoted 7 lines · Steven Rostedt
From: "Steven Rostedt (Red Hat)" <[email protected]>
New code will require
TRACE_SYSTEMto be a valid C variable name, but some tracepoints haveTRACE_SYSTEMwith '-' and not '_', so it can not be used. Instead, add aTRACE_SYSTEM_VARthat can give the tracing infrastructure a unique name for the trace system.Quoted 7 lines
Quoted 2 lines
Cc Mark Brown <[email protected]>I'm not sure why you're sending this to my work address but please use [email protected] for anything upstream (it's what's in
MAINTAINERSand what I've been using pretty consistently for e-mail).
Quoted 5 lines
Sorry, I got that from git log
include/trace/events/intel-sst.hI couldn't find anything in
MAINTAINERSabout that file, but I didn't look for your name though.
BTW, was that considered an Acked-by?
-- Steve
Re: [RFC][PATCH 01/17 v2] tracing: Add TRACE_SYSTEM_VAR to intel-sst
Quoted 6 lines · Steven Rostedt
Quoted 2 lines · Steven Rostedt
I couldn't find anything in
MAINTAINERSabout that file, but I didn't look for your name though.BTW, was that considered an Acked-by?
I guess, you probably want to ping the Intel guys though since it's them that would be affected by the interface change.
Steven Rostedt
maintainerRe: [RFC][PATCH 01/17 v2] tracing: Add TRACE_SYSTEM_VAR to intel-sst
Quoted 10 lines · On Thu, 2 Apr 2015 14:40:33 +0100 Mark Brown <[email protected]> wrote:
Quoted 6 lines · Steven Rostedt
Quoted 2 lines · Steven Rostedt
I couldn't find anything in
MAINTAINERSabout that file, but I didn't look for your name though.BTW, was that considered an Acked-by?
I guess, you probably want to ping the Intel guys though since it's them that would be affected by the interface change.
Actually, there's no interface change. This is the work-around patch to that. It's only internal to the kernel and userspace does not see any difference.
I just needed a unique TRACE_SYSTEM name that was also a valid C variable, and now use TRACE_SYSTEM_VAR.
The ftrace code now has:
#ifndef TRACE_SYSTEM_VAR
#define TRACE_SYSTEM_VAR TRACE_SYSTEM
#endif
And this allows trace headers (like intel-sst.h) to have a different VAR variable from the TRACE_SYSTEM name:
#define TRACE_SYSTEM intel-ssl
#define TRACE_SYSTEM_VAR intel_ssl
This lets me use something that will work and not need to change what the user space sees.
-- Steve
Re: [RFC][PATCH 01/17 v2] tracing: Add TRACE_SYSTEM_VAR to intel-sst
Quoted 8 lines · Steven Rostedt
Quoted 2 lines · Mark Brown
I guess, you probably want to ping the Intel guys though since it's them that would be affected by the interface change.
Actually, there's no interface change. This is the work-around patch to that. It's only internal to the kernel and userspace does not see any difference.
Ah, OK - that's definitely not an issue then.
Steven Rostedt
maintainerRe: [RFC][PATCH 01/17 v2] tracing: Add TRACE_SYSTEM_VAR to intel-sst
Quoted 11 lines · On Thu, 2 Apr 2015 14:59:33 +0100 Mark Brown <[email protected]> wrote:
Quoted 8 lines · Steven Rostedt
Quoted 2 lines · Mark Brown
I guess, you probably want to ping the Intel guys though since it's them that would be affected by the interface change.
Actually, there's no interface change. This is the work-around patch to that. It's only internal to the kernel and userspace does not see any difference.
Ah, OK - that's definitely not an issue then.
So that's an Acked-by then? :-)
-- Steve
Re: [RFC][PATCH 01/17 v2] tracing: Add TRACE_SYSTEM_VAR to intel-sst
Quoted 1 line · Steven Rostedt
So that's an Acked-by then? :-)
Sure.
Steven Rostedt
maintainerRFC PATCH v2 2/17 tracing: Add TRACE_SYSTEM_VAR to kvm-s390
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
New code will require TRACE_SYSTEM to be a valid C variable name, but some tracepoints have TRACE_SYSTEM with '-' and not '_', so it can not be used. Instead, add a TRACE_SYSTEM_VAR that can give the tracing infrastructure a unique name for the trace system.
--- arch/s390/kvm/trace-s390.h | 7 +++++++ 1 file changed, 7 insertions(+)
arch/s390/kvm/trace-s390.h +7 -0
@@ -10,6 +10,13 @@#define TRACE_INCLUDE_FILE trace-s390/* +* The TRACE_SYSTEM_VAR defaults to TRACE_SYSTEM, but must be a +* legitimate C variable. It is not exported to user space. +*/ +#undef TRACE_SYSTEM_VAR +#define TRACE_SYSTEM_VAR kvm_s390 + +/* * Trace point for the creation of the kvm instance. */ TRACE_EVENT(kvm_s390_create_vm,
Signature · 1 line
2.1.4
Re: [RFC][PATCH 02/17 v2] tracing: Add TRACE_SYSTEM_VAR to kvm-s390
Quoted 13 lines · On Wed, 01 Apr 2015 21:56:50 -0400 Steven Rostedt <[email protected]> wrote:
From: "Steven Rostedt (Red Hat)" <[email protected]>
New code will require
TRACE_SYSTEMto be a valid C variable name, but some tracepoints haveTRACE_SYSTEMwith '-' and not '_', so it can not be used. Instead, add aTRACE_SYSTEM_VARthat can give the tracing infrastructure a unique name for the trace system.Cc Martin Schwidefsky <[email protected]>Cc Heiko Carstens <[email protected]>Cc David Hildenbrand <[email protected]>Cc Cornelia Huck <[email protected]>Cc Christian Borntraeger <[email protected]>Signed-off-by Steven Rostedt <[email protected]>
Quoted 3 lines
--- arch/s390/kvm/trace-s390.h | 7 +++++++ 1 file changed, 7 insertions(+)
Steven Rostedt
maintainerRFC PATCH v2 3/17 tracing: Add TRACE_SYSTEM_VAR to xhci-hcd
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
New code will require TRACE_SYSTEM to be a valid C variable name, but some tracepoints have TRACE_SYSTEM with '-' and not '_', so it can not be used. Instead, add a TRACE_SYSTEM_VAR that can give the tracing infrastructure a unique name for the trace system.
--- drivers/usb/host/xhci-trace.h | 7 +++++++ 1 file changed, 7 insertions(+)
drivers/usb/host/xhci-trace.h +7 -0
@@ -14,6 +14,13 @@#undef TRACE_SYSTEM#define TRACE_SYSTEM xhci-hcd +/* +* The TRACE_SYSTEM_VAR defaults to TRACE_SYSTEM, but must be a +* legitimate C variable. It is not exported to user space. +*/ +#undef TRACE_SYSTEM_VAR +#define TRACE_SYSTEM_VAR xhci_hcd +#if !defined(__XHCI_TRACE_H) || defined(TRACE_HEADER_MULTI_READ )#define __XHCI_TRACE_H
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRFC PATCH v2 4/17 tracing: Give system name a pointer
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
Normally the compiler will use the same pointer for a string throughout the file. But there's no guarantee of that happening. Later changes will require that all events have the same pointer to the system string.
Name the system string and have all events point to it.
Testing this, it did not increases the size of the text, except for the notes section, which should not harm the real size any.
--- include/linux/ftrace_event.h | 2 +- include/trace/ftrace.h | 19 +++++++++++++++++-- 2 files changed, 18 insertions(+), 3 deletions(-)
include/linux/ftrace_event.h +1 -1
@@ -202,7 +202,7 @@ enum trace_reg {struct ftrace_event_call ;struct ftrace_event_class { -char *system; +const char *system;void *probe;#ifdef CONFIG_PERF_EVENTS void *perf_probe;
include/trace/ftrace.h +17 -2
@@ -18,6 +18,21 @@#include <linux/ftrace_event.h> +#ifndef TRACE_SYSTEM_VAR +#define TRACE_SYSTEM_VAR TRACE_SYSTEM +#endif + +#define __app__ (x, y) str__##x##y +#define __app (x, y) __app__(x, y) + +#define TRACE_SYSTEM_STRING __app(TRACE_SYSTEM_VAR,__trace_system_name) + +#define TRACE_MAKE_SYSTEM_STR () \ + static const char TRACE_SYSTEM_STRING[] = \ + __stringify(TRACE_SYSTEM) + +TRACE_MAKE_SYSTEM_STR (); +/* * DECLARE_EVENT_CLASS can be used to add a generic function * handlers for events. That is, if all events have the same
@@ -105,7 +120,6 @@#include TRACE_INCLUDE (TRACE_INCLUDE_FILE ) -/* * Stage 2 of the trace events. *
@@ -692,7 +706,7 @@ static inline void ftrace_test_probe_##call(void) \_TRACE_PERF_PROTO (call,PARAMS (proto)); \ static const char print_fmt_##call[] = print; \ static struct ftrace_event_class __used __refdata event_class_##call = { \ - .system = __stringify(TRACE_SYSTEM), \ + .system = TRACE_SYSTEM_STRING, \ .define_fields = ftrace_define_fields_##call, \ .fields = LIST_HEAD_INIT(event_class_##call.fields),\ .raw_init = trace_event_raw_init, \
@@ -735,6 +749,7 @@ __attribute__((section("_ftrace_events"))) *__event_##call = &event_##call#include TRACE_INCLUDE (TRACE_INCLUDE_FILE ) +#undef TRACE_SYSTEM_VAR#ifdef CONFIG_PERF_EVENTS
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRFC PATCH v2 5/17 tracing: Update trace-event-sample with TRACE_SYSTEM_VAR documentation
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
Add documentation about TRACE_SYSTEM needing to be alpha-numeric or with underscores, and that if it is not, then the use of TRACE_SYSTEM_VAR is required to make something that is.
An example of this is shown in samples/trace_events/trace-events-sample.h
--- samples/trace_events/trace-events-sample.h | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-)
samples/trace_events/trace-events-sample.h +19 -1
@@ -22,7 +22,25 @@* protection, just like TRACE_INCLUDE_FILE. */ #undef TRACE_SYSTEM -#define TRACE_SYSTEM sample +#define TRACE_SYSTEM sample-trace + +/* +* TRACE_SYSTEM is expected to be a C valid variable (alpha-numeric +* and underscore), although it may start with numbers. If for some +* reason it is not, you need to add the following lines: +*/ +#undef TRACE_SYSTEM_VAR +#define TRACE_SYSTEM_VAR sample_trace +/* +* But the above is only needed if TRACE_SYSTEM is not alpha-numeric +* and underscored. By default, TRACE_SYSTEM_VAR will be equal to +* TRACE_SYSTEM. As TRACE_SYSTEM_VAR must be alpha-numeric, if +* TRACE_SYSTEM is not, then TRACE_SYSTEM_VAR must be defined with +* only alpha-numeric and underscores. +* +* The TRACE_SYSTEM_VAR is only used internally and not visible to +* user space. +*/ /* * Notice that this file is not protected like a normal header.
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRFC PATCH v2 6/17 tracing: Add TRACE_DEFINE_ENUM() macro to map enums to their values
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
Several tracepoints use the helper functions __print_symbolic() or __print_flags() and pass in enums that do the mapping between the binary data stored and the value to print. This works well for reading the ASCII trace files, but when the data is read via userspace tools such as perf and trace-cmd, the conversion of the binary value to a human string format is lost if an enum is used, as userspace does not have access to what the ENUM is.
For example, the tracepoint trace_tlb_flush() has:
__print_symbolic(REC->reason,
{ TLB_FLUSH_ON_TASK_SWITCH, "flush on task switch" }, { TLB_REMOTE_SHOOTDOWN, "remote shootdown" }, { TLB_LOCAL_SHOOTDOWN, "local shootdown" }, { TLB_LOCAL_MM_SHOOTDOWN, "local mm shootdown" })
Which maps the enum values to the strings they represent. But perf and trace-cmd do no know what value TLB_LOCAL_MM_SHOOTDOWN is, and would not be able to map it.
With TRACE_DEFINE_ENUM(), developers can place these in the event header files and ftrace will convert the enums to their values:
By adding:
TRACE_DEFINE_ENUM(TLB_FLUSH_ON_TASK_SWITCH);
TRACE_DEFINE_ENUM(TLB_REMOTE_SHOOTDOWN);
TRACE_DEFINE_ENUM(TLB_LOCAL_SHOOTDOWN);
TRACE_DEFINE_ENUM(TLB_LOCAL_MM_SHOOTDOWN);
$ cat /sys/kernel/debug/tracing/events/tlb/tlb_flush/format
[...]
__print_symbolic(REC->reason,
{ 0, "flush on task switch" },
{ 1, "remote shootdown" },
{ 2, "local shootdown" },
{ 3, "local mm shootdown" })The above is what userspace expects to see, and tools do not need to be modified to parse them.
--- include/asm-generic/vmlinux.lds.h | 5 +- include/linux/ftrace_event.h | 2 +- include/linux/tracepoint.h | 8 ++++ include/trace/ftrace.h | 22 +++++++-- kernel/trace/trace.c | 43 +++++++++++++++++- kernel/trace/trace.h | 2 + kernel/trace/trace_events.c | 96 +++++++++++++++++++++++++++++++++++++++ 7 files changed, 172 insertions(+), 6 deletions(-)
include/asm-generic/vmlinux.lds.h +4 -1
@@ -124,7 +124,10 @@#define FTRACE_EVENTS () . = ALIGN(8); \ VMLINUX_SYMBOL(__start_ftrace_events) = .; \ *(_ftrace_events) \ - VMLINUX_SYMBOL(__stop_ftrace_events) = .; + VMLINUX_SYMBOL(__stop_ftrace_events) = .; \ + VMLINUX_SYMBOL(__start_ftrace_enum_maps) = .; \ + *(_ftrace_enum_map) \ + VMLINUX_SYMBOL(__stop_ftrace_enum_maps) = .;#else #define FTRACE_EVENTS ()#endif
include/linux/ftrace_event.h +1 -1
@@ -285,7 +285,7 @@ struct ftrace_event_call {struct tracepoint *tp; };struct trace_event event; -const char *print_fmt; +char *print_fmt;struct event_filter *filter;void *mod;void *data;
include/linux/tracepoint.h +8 -0
@@ -36,6 +36,12 @@ struct tracepoint {struct tracepoint_func __rcu *funcs; }; +struct trace_enum_map { +const char *system; +const char *enum_string; +unsigned long enum_value; +}; +extern int tracepoint_probe_register (struct tracepoint *tp,void *probe,void *data); extern int
@@ -87,6 +93,8 @@ extern void syscall_unregfunc(void); #define PARAMS(args...) args +#define TRACE_DEFINE_ENUM (x) +#endif /* _LINUX_TRACEPOINT_H */ /*
include/trace/ftrace.h +19 -3
@@ -33,6 +33,19 @@TRACE_MAKE_SYSTEM_STR (); +#undef TRACE_DEFINE_ENUM +#define TRACE_DEFINE_ENUM (a) \ + static struct trace_enum_map __used __initdata \ + __##TRACE_SYSTEM##_##a = \ + { \ + .system = TRACE_SYSTEM_STRING, \ + .enum_string = #a, \ + .enum_value = a \ + }; \ + static struct trace_enum_map __used \ + __attribute__((section("_ftrace_enum_map"))) \ + *TRACE_SYSTEM##_##a = &__##TRACE_SYSTEM##_##a +/* * DECLARE_EVENT_CLASS can be used to add a generic function * handlers for events. That is, if all events have the same
@@ -136,6 +149,9 @@ TRACE_MAKE_SYSTEM_STR();* The size of an array is also encoded, in the higher 16 bits of <item>. */ +#undef TRACE_DEFINE_ENUM +#define TRACE_DEFINE_ENUM (a) +#undef __field#define __field (type, item)
@@ -553,7 +569,7 @@ static inline notrace int ftrace_get_offsets_##call( \* .trace = ftrace_raw_output_<call>, <-- stage 2 * }; * -* static const char print_fmt_<call>[] = <TP_printk>; +* static char print_fmt_<call>[] = <TP_printk>; * * static struct ftrace_event_class __used event_class_<template> = { * .system = "<system>",
@@ -704,7 +720,7 @@ static inline void ftrace_test_probe_##call(void) \#undef DECLARE_EVENT_CLASS#define DECLARE_EVENT_CLASS (call, proto, args, tstruct, assign, print) \ _TRACE_PERF_PROTO(call, PARAMS(proto)); \ -static const char print_fmt_##call[] = print; \ +static char print_fmt_##call[] = print; \ static struct ftrace_event_class __used __refdata event_class_##call = { \ .system = TRACE_SYSTEM_STRING, \ .define_fields = ftrace_define_fields_##call, \
@@ -733,7 +749,7 @@ __attribute__((section("_ftrace_events"))) *__event_##call = &event_##call#undef DEFINE_EVENT_PRINT#define DEFINE_EVENT_PRINT (template, call, proto, args, print) \ \ -static const char print_fmt_##call[] = print; \ +static char print_fmt_##call[] = print; \ \ static struct ftrace_event_call __used event_##call = { \ .class = &event_class_##template, \
kernel/trace/trace.c +42 -1
73 lines not on this page · raw message
kernel/trace/trace.h +2 -0
@@ -1309,8 +1309,10 @@ static inline void init_ftrace_syscalls(void) { }#ifdef CONFIG_EVENT_TRACING void trace_event_init (void ); +void trace_event_enum_update (struct trace_enum_map *map,int len);#else static inline void __init trace_event_init (void ) { } +static inlin void trace_event_enum_update(struct trace_enum_map *map, int len) { }#endif extern struct trace_iterator *tracepoint_print_iter;
kernel/trace/trace_events.c +96 -0
102 lines not on this page · raw message
Signature · 1 line
2.1.4
Re: [RFC][PATCH 06/17 v2] tracing: Add TRACE_DEFINE_ENUM() macro to map enums to their values
Hi Steve,
Quoted 47 lines · Steven Rostedt
From: "Steven Rostedt (Red Hat)" <[email protected]>
Several tracepoints use the helper functions
__print_symbolic()or__print_flags()and pass in enums that do the mapping between the binary data stored and the value to print. This works well for reading the ASCII trace files, but when the data is read via userspace tools such as perf and trace-cmd, the conversion of the binary value to a human string format is lost if an enum is used, as userspace does not have access to what the ENUM is.For example, the tracepoint
trace_tlb_flush()has:__print_symbolic(REC->reason,
{TLB_FLUSH_ON_TASK_SWITCH, "flush on task switch" }, {TLB_REMOTE_SHOOTDOWN, "remote shootdown" }, {TLB_LOCAL_SHOOTDOWN, "local shootdown" }, {TLB_LOCAL_MM_SHOOTDOWN, "local mm shootdown" })Which maps the enum values to the strings they represent. But perf and trace-cmd do no know what value
TLB_LOCAL_MM_SHOOTDOWNis, and would not be able to map it.With
TRACE_DEFINE_ENUM(), developers can place these in the event header files and ftrace will convert the enums to their values:By adding:
TRACE_DEFINE_ENUM(TLB_FLUSH_ON_TASK_SWITCH);
TRACE_DEFINE_ENUM(TLB_REMOTE_SHOOTDOWN);
TRACE_DEFINE_ENUM(TLB_LOCAL_SHOOTDOWN);
TRACE_DEFINE_ENUM(TLB_LOCAL_MM_SHOOTDOWN);$ cat /sys/kernel/debug/tracing/events/tlb/tlb_flush/format [...] __print_symbolic(REC->reason, { 0, "flush on task switch" }, { 1, "remote shootdown" }, { 2, "local shootdown" }, { 3, "local mm shootdown" })The above is what userspace expects to see, and tools do not need to be modified to parse them.
Cc Guilherme Cox <[email protected]>Cc Tony Luck <[email protected]>Cc Xie XiuQi <[email protected]>Signed-off-by Steven Rostedt <[email protected]>
[SNIP]
Quoted 47 lines
kernel/trace/trace_events.c +39
-0@@ -1704,6 +1704,102 @@ __register_event(struct ftrace_event_call *call, struct module *mod)return 0 ; } +static char *enum_replace (char *ptr,struct trace_enum_map *map,int len) +{ +int rlen; +int elen; + +/* Find the length of the enum value as a string */ + elen =snprintf (ptr,0 ,"%ld" , map->enum_value); +/* Make sure there's enough room to replace the string with the value */ +if (len < elen) +return NULL ; + +snprintf (ptr, elen +1 ,"%ld" , map->enum_value); + +/* Get the rest of the string of ptr */ + rlen =strlen (ptr + len); +memmove (ptr + elen, ptr + len, rlen); +/* Make sure we end the new string */ + ptr[elen + rlen] =0 ; + +return ptr + elen; +} + +static void update_event_printk (struct ftrace_event_call *call, +struct trace_enum_map *map) +{ +char *ptr; +int quote =0 ; +int len =strlen (map->enum_string); + +for (ptr = call->print_fmt; *ptr; ptr++) { +if (*ptr =='\\' ) { + ptr++; +/* paranoid */ +if (!*ptr) +break ; +continue ; + } +if (*ptr =='"' ) { + quote ^=1 ;
kernel/trace/trace_events.c __register_event(struct ftrace_event_call *call, struct module *mod) · line 1755
Quoted 10 lines
kernel/trace/trace_events.c +10
-0+continue ; + } +if (quote) +continue ; +if (isdigit (*ptr)) { +/* skip numbers */ +do { + ptr++; + }while (isalnum (*ptr) || *ptr =='_' ); +/* we went one too many */
Hmm.. it looks like to skip variable name after a number. Shouldn't it be
do { ptr++; } while (isdigit(*ptr));?
kernel/trace/trace_events.c __register_event(struct ftrace_event_call *call, struct module *mod) · line 1766
Quoted 11 lines
kernel/trace/trace_events.c +11
-0+ ptr--; +continue ; + } +if (isalpha (*ptr) || *ptr =='_' ) { +if (strncmp (map->enum_string, ptr, len) ==0 && + !isalnum (ptr[len]) && ptr[len] !='_' ) { + ptr =enum_replace (ptr, map, len); +/* Hmm, enum string smaller than value */ +if (WARN_ON_ONCE (!ptr)) +return ; +continue ;
I guess it also needs to decrease the ptr here.
Quoted 13 lines
kernel/trace/trace_events.c +13
-0+ } +do { + ptr++; + }while (isalnum (*ptr) || *ptr =='_' ); +/* we went one too many */ + ptr--; +continue ; + } + } +} + +void trace_event_enum_update (struct trace_enum_map *map,int len) +{
kernel/trace/trace_events.c __register_event(struct ftrace_event_call *call, struct module *mod) · line 1789
Quoted 10 lines
kernel/trace/trace_events.c +10
-0+struct ftrace_event_call *call, *p; +const char *last_system =NULL ; +int last_i; +int i; + +down_write (&trace_event_sem); +list_for_each_entry_safe (call, p, &ftrace_events, list) { +/* events are usually grouped together with systems */ +if (!last_system || call->class->system != last_system) + last_i =0 ;
I think it needs to update the last_system here.
Thanks,
Namhyung
Quoted 25 lines
kernel/trace/trace_events.c +13
-0+ +for (i = last_i; i < len; i++) { +if (call->class->system == map[i].system) { +/* Save the first system if need be */ +if (!last_i) + last_i = i; +update_event_printk (call, &map[i]); + } + } + } +up_write (&trace_event_sem); +} +static struct ftrace_event_file *trace_create_new_event (struct ftrace_event_call *call,struct trace_array *tr)Signature · 8 lines
2.1.4 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
Steven Rostedt
maintainerRe: [RFC][PATCH 06/17 v2] tracing: Add TRACE_DEFINE_ENUM() macro to map enums to their values
Quoted 30 lines · On Thu, 2 Apr 2015 16:47:40 +0900 Namhyung Kim <[email protected]> wrote:
Quoted 17 lines
kernel/trace/trace_events.c +17
-0+static void update_event_printk (struct ftrace_event_call *call, +struct trace_enum_map *map) +{ +char *ptr; +int quote =0 ; +int len =strlen (map->enum_string); + +for (ptr = call->print_fmt; *ptr; ptr++) { +if (*ptr =='\\' ) { + ptr++; +/* paranoid */ +if (!*ptr) +break ; +continue ; + } +if (*ptr =='"' ) { + quote ^=1 ;kernel/trace/trace_events.c __register_event(struct ftrace_event_call *call, struct module *mod) · line 1755
Quoted 10 lines
kernel/trace/trace_events.c +10
-0+continue ; + } +if (quote) +continue ; +if (isdigit (*ptr)) { +/* skip numbers */ +do { + ptr++; + }while (isalnum (*ptr) || *ptr =='_' ); +/* we went one too many */ Hmm.. it looks like to skip variable name after a number. Shouldn't it be
Quoted 3 lines
do { ptr++; } while (isdigit(*ptr));?
A variable can not be appended to a number in C. But alpha characters like 1ULL can be, and they need to be skipped. Hmm, I probably could remove the check for '_' though.
Quoted 15 lines
kernel/trace/trace_events.c __register_event(struct ftrace_event_call *call, struct module *mod) · line 1766
Quoted 13 lines
kernel/trace/trace_events.c +11
-0+ ptr--; +continue ; + } +if (isalpha (*ptr) || *ptr =='_' ) { +if (strncmp (map->enum_string, ptr, len) ==0 && + !isalnum (ptr[len]) && ptr[len] !='_' ) { + ptr =enum_replace (ptr, map, len); +/* Hmm, enum string smaller than value */ +if (WARN_ON_ONCE (!ptr)) +return ; +continue ;I guess it also needs to decrease the ptr here.
I thought about this when writing it and realized that it just replaced a variable and two variables can not be bumped against each other. There must be something in between them, and we can skip whatever that something is.
I could add a comment about that.
Quoted 19 lines
Quoted 19 lines
kernel/trace/trace_events.c +17
-0+ } +do { + ptr++; + }while (isalnum (*ptr) || *ptr =='_' ); +/* we went one too many */ + ptr--; +continue ; + } + } +} + +void trace_event_enum_update (struct trace_enum_map *map,int len) +{ +struct ftrace_event_call *call, *p; +const char *last_system =NULL ; +int last_i; +int i;
Quoted 8 lines
kernel/trace/trace_events.c __register_event(struct ftrace_event_call *call, struct module *mod) · line 1789
Quoted 6 lines
kernel/trace/trace_events.c +6
-0+ +down_write (&trace_event_sem); +list_for_each_entry_safe (call, p, &ftrace_events, list) { +/* events are usually grouped together with systems */ +if (!last_system || call->class->system != last_system) + last_i =0 ;I think it needs to update the
last_systemhere.
Ouch, yeah you're right!
Will fix.
Thanks,
-- Steve
Steven Rostedt
maintainerRFC PATCH v3 6/17 tracing: Add TRACE_DEFINE_ENUM() macro to map enums to their values
Several tracepoints use the helper functions __print_symbolic() or __print_flags() and pass in enums that do the mapping between the binary data stored and the value to print. This works well for reading the ASCII trace files, but when the data is read via userspace tools such as perf and trace-cmd, the conversion of the binary value to a human string format is lost if an enum is used, as userspace does not have access to what the ENUM is.
For example, the tracepoint trace_tlb_flush() has:
__print_symbolic(REC->reason,
{ TLB_FLUSH_ON_TASK_SWITCH, "flush on task switch" }, { TLB_REMOTE_SHOOTDOWN, "remote shootdown" }, { TLB_LOCAL_SHOOTDOWN, "local shootdown" }, { TLB_LOCAL_MM_SHOOTDOWN, "local mm shootdown" })
Which maps the enum values to the strings they represent. But perf and trace-cmd do no know what value TLB_LOCAL_MM_SHOOTDOWN is, and would not be able to map it.
With TRACE_DEFINE_ENUM(), developers can place these in the event header files and ftrace will convert the enums to their values:
By adding:
TRACE_DEFINE_ENUM(TLB_FLUSH_ON_TASK_SWITCH);
TRACE_DEFINE_ENUM(TLB_REMOTE_SHOOTDOWN);
TRACE_DEFINE_ENUM(TLB_LOCAL_SHOOTDOWN);
TRACE_DEFINE_ENUM(TLB_LOCAL_MM_SHOOTDOWN);
$ cat /sys/kernel/debug/tracing/events/tlb/tlb_flush/format
[...]
__print_symbolic(REC->reason,
{ 0, "flush on task switch" },
{ 1, "remote shootdown" },
{ 2, "local shootdown" },
{ 3, "local mm shootdown" })The above is what userspace expects to see, and tools do not need to be modified to parse them.
--- include/asm-generic/vmlinux.lds.h | 5 +- include/linux/ftrace_event.h | 2 +- include/linux/tracepoint.h | 8 +++ include/trace/ftrace.h | 22 ++++++-- kernel/trace/trace.c | 43 +++++++++++++++- kernel/trace/trace.h | 2 + kernel/trace/trace_events.c | 106 ++++++++++++++++++++++++++++++++++++++ 7 files changed, 182 insertions(+), 6 deletions(-)
include/asm-generic/vmlinux.lds.h +4 -1
@@ -124,7 +124,10 @@#define FTRACE_EVENTS () . = ALIGN(8); \ VMLINUX_SYMBOL(__start_ftrace_events) = .; \ *(_ftrace_events) \ - VMLINUX_SYMBOL(__stop_ftrace_events) = .; + VMLINUX_SYMBOL(__stop_ftrace_events) = .; \ + VMLINUX_SYMBOL(__start_ftrace_enum_maps) = .; \ + *(_ftrace_enum_map) \ + VMLINUX_SYMBOL(__stop_ftrace_enum_maps) = .;#else #define FTRACE_EVENTS ()#endif
include/linux/ftrace_event.h +1 -1
@@ -285,7 +285,7 @@ struct ftrace_event_call {struct tracepoint *tp; };struct trace_event event; -const char *print_fmt; +char *print_fmt;struct event_filter *filter;void *mod;void *data;
include/linux/tracepoint.h +8 -0
@@ -36,6 +36,12 @@ struct tracepoint {struct tracepoint_func __rcu *funcs; }; +struct trace_enum_map { +const char *system; +const char *enum_string; +unsigned long enum_value; +}; +extern int tracepoint_probe_register (struct tracepoint *tp,void *probe,void *data); extern int
@@ -87,6 +93,8 @@ extern void syscall_unregfunc(void); #define PARAMS(args...) args +#define TRACE_DEFINE_ENUM (x) +#endif /* _LINUX_TRACEPOINT_H */ /*
include/trace/ftrace.h +19 -3
@@ -33,6 +33,19 @@TRACE_MAKE_SYSTEM_STR (); +#undef TRACE_DEFINE_ENUM +#define TRACE_DEFINE_ENUM (a) \ + static struct trace_enum_map __used __initdata \ + __##TRACE_SYSTEM##_##a = \ + { \ + .system = TRACE_SYSTEM_STRING, \ + .enum_string = #a, \ + .enum_value = a \ + }; \ + static struct trace_enum_map __used \ + __attribute__((section("_ftrace_enum_map"))) \ + *TRACE_SYSTEM##_##a = &__##TRACE_SYSTEM##_##a +/* * DECLARE_EVENT_CLASS can be used to add a generic function * handlers for events. That is, if all events have the same
@@ -136,6 +149,9 @@ TRACE_MAKE_SYSTEM_STR();* The size of an array is also encoded, in the higher 16 bits of <item>. */ +#undef TRACE_DEFINE_ENUM +#define TRACE_DEFINE_ENUM (a) +#undef __field#define __field (type, item)
@@ -553,7 +569,7 @@ static inline notrace int ftrace_get_offsets_##call( \* .trace = ftrace_raw_output_<call>, <-- stage 2 * }; * -* static const char print_fmt_<call>[] = <TP_printk>; +* static char print_fmt_<call>[] = <TP_printk>; * * static struct ftrace_event_class __used event_class_<template> = { * .system = "<system>",
@@ -704,7 +720,7 @@ static inline void ftrace_test_probe_##call(void) \#undef DECLARE_EVENT_CLASS#define DECLARE_EVENT_CLASS (call, proto, args, tstruct, assign, print) \ _TRACE_PERF_PROTO(call, PARAMS(proto)); \ -static const char print_fmt_##call[] = print; \ +static char print_fmt_##call[] = print; \ static struct ftrace_event_class __used __refdata event_class_##call = { \ .system = TRACE_SYSTEM_STRING, \ .define_fields = ftrace_define_fields_##call, \
@@ -733,7 +749,7 @@ __attribute__((section("_ftrace_events"))) *__event_##call = &event_##call#undef DEFINE_EVENT_PRINT#define DEFINE_EVENT_PRINT (template, call, proto, args, print) \ \ -static const char print_fmt_##call[] = print; \ +static char print_fmt_##call[] = print; \ \ static struct ftrace_event_call __used event_##call = { \ .class = &event_class_##template, \
kernel/trace/trace.c +42 -1
73 lines not on this page · raw message
kernel/trace/trace.h +2 -0
@@ -1309,8 +1309,10 @@ static inline void init_ftrace_syscalls(void) { }#ifdef CONFIG_EVENT_TRACING void trace_event_init (void ); +void trace_event_enum_update (struct trace_enum_map *map,int len);#else static inline void __init trace_event_init (void ) { } +static inlin void trace_event_enum_update(struct trace_enum_map *map, int len) { }#endif extern struct trace_iterator *tracepoint_print_iter;
kernel/trace/trace_events.c +106 -0
112 lines not on this page · raw message
Signature · 1 line
1.8.3.1
Steven Rostedt
maintainerRe: [RFC][PATCH 06/17 v3] tracing: Add TRACE_DEFINE_ENUM() macro to map enums to their values
I updated the function to handle structures that were saved as well. Just in case something like REC->my_enum does not get converted.
Also, I found that I never needed to decrement the pointer for those locations that I did so.
Here's the new function:
static void update_event_printk(struct ftrace_event_call *call,
struct trace_enum_map *map)
{
char *ptr;
int quote = 0;
int len = strlen(map->enum_string);
for (ptr = call->print_fmt; *ptr; ptr++) {
if (*ptr == '\\') {
ptr++;
/* paranoid */
if (!*ptr)
break;
continue;
}
if (*ptr == '"') {
quote ^= 1;
continue;
}
if (quote)
continue;
if (isdigit(*ptr)) {
/* skip numbers */
do {
ptr++;
/* Check for alpha chars like ULL */
} while (isalnum(*ptr));
/*
* A number must have some kind of delimiter after
* it, and we can ignore that too.
*/
continue;
}
if (isalpha(*ptr) || *ptr == '_') {
if (strncmp(map->enum_string, ptr, len) == 0 &&
!isalnum(ptr[len]) && ptr[len] != '_') {
ptr = enum_replace(ptr, map, len);
/* Hmm, enum string smaller than value */
if (WARN_ON_ONCE(!ptr))
return;
/*
* No need to decrement here, as enum_replace()
* returns the pointer to the character passed
* the enum, and two enums can not be placed
* back to back without something in between.
* We can skip that something in between.
*/
continue;
}
skip_more:
do {
ptr++;
} while (isalnum(*ptr) || *ptr == '_');
/*
* If what comes after this variable is a '.' or
* '->' then we can continue to ignore that string.
*/
if (*ptr == '.' || (ptr[0] == '-' && ptr[1] == '>')) {
ptr += *ptr == '.' ? 1 : 2;
goto skip_more;
}
/*
* Once again, we can skip the delimiter that came
* after the string.
*/
continue;
}
}
}Steven Rostedt
maintainerRFC PATCH v2 7/17 tracing: Allow for modules to export their trace enums as well
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
Update the infrastructure such that modules that declare TRACE_DEFINE_ENUM() will have those enums shown in the enum_map files in the tracing directory.
--- include/linux/module.h | 2 + kernel/module.c | 3 + kernel/trace/trace.c | 149 +++++++++++++++++++++++++++++++++++++++++--- kernel/trace/trace_events.c | 2 +- 4 files changed, 145 insertions(+), 11 deletions(-)
include/linux/module.h +2 -0
@@ -338,6 +338,8 @@ struct module {#ifdef CONFIG_EVENT_TRACING struct ftrace_event_call **trace_events;unsigned int num_trace_events; +struct trace_enum_map **trace_enums; +unsigned int num_trace_enums;#endif #ifdef CONFIG_FTRACE_MCOUNT_RECORD unsigned int num_ftrace_callsites;
kernel/module.c +3 -0
@@ -2753,6 +2753,9 @@ static int find_module_sections(struct module *mod, struct load_info *info) mod->trace_events =section_objs (info,"_ftrace_events" ,sizeof (*mod->trace_events), &mod->num_trace_events); + mod->trace_enums =section_objs (info,"_ftrace_enum_map" , +sizeof (*mod->trace_enums), + &mod->num_trace_enums);#endif #ifdef CONFIG_TRACING mod->trace_bprintk_fmt_start = section_objs(info, "__trace_printk_fmt",
kernel/trace/trace.c +139 -10
193 lines not on this page · raw message
kernel/trace/trace_events.c +1 -1
@@ -2011,7 +2011,7 @@ static int trace_module_notify(struct notifier_block *self,static struct notifier_block trace_module_nb = { .notifier_call = trace_module_notify, - .priority =0 , + .priority =1 ,/* higher than trace.c module notify */ };#endif /* CONFIG_MODULES */
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRFC PATCH v2 8/17 tracing/samples: Update the trace-event-sample.h with TRACE_DEFINE_ENUM()
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
Document the use of TRACE_DEFINE_ENUM() by adding enums to the trace-event-sample.h and using this macro to convert them in the format files.
Also update the comments and sho the use of __print_symbolic() and __print_flags() as well as adding comments abount __print_array().
--- samples/trace_events/trace-events-sample.h | 64 +++++++++++++++++++++++++++++- 1 file changed, 63 insertions(+), 1 deletion(-)
samples/trace_events/trace-events-sample.h +63 -1
@@ -198,8 +198,30 @@ static inline int __length_of(const int *list) ;return i; } + +enum { +TRACE_SAMPLE_FOO =2 , +TRACE_SAMPLE_BAR =4 , +TRACE_SAMPLE_ZOO =8 , +};#endif +/* +* If enums are used in the TP_printk(), their names will be shown in +* format files and not their values. This can cause problems with user +* space programs that parse the format files to know how to translate +* the raw binary trace output into human readable text. +* +* To help out user space programs, any enum that is used in the TP_printk() +* should be defined by TRACE_DEFINE_ENUM() macro. All that is needed to +* be done is to add this macro with the enum within it in the trace +* header file, and it will be converted in the output. +*/ + +TRACE_DEFINE_ENUM (TRACE_SAMPLE_FOO ); +TRACE_DEFINE_ENUM (TRACE_SAMPLE_BAR ); +TRACE_DEFINE_ENUM (TRACE_SAMPLE_ZOO ); + TRACE_EVENT(foo_bar, TP_PROTO(const char *foo, int bar, const int *lst,
@@ -224,7 +246,47 @@ TRACE_EVENT(foo_bar,__assign_bitmask (cpus,cpumask_bits (mask),num_possible_cpus ()); ), - TP_printk("foo %s %d %s %s (%s)", __entry->foo, __entry->bar, + TP_printk("foo %s %d %s %s %s %s (%s)", __entry->foo, __entry->bar, + +/* + * Notice here the use of some helper functions. This includes: + * + * __print_symbolic( variable, { value, "string" }, ... ), + * + * The variable is tested against each value of the { } pair. If + * the variable matches one of the values, then it will print the + * string in that pair. If non are matched, it returns a string + * version of the number (if __entry->bar == 7 then "7" is returned). + */ + __print_symbolic(__entry->bar, + { 0, "zero" }, + { TRACE_SAMPLE_FOO, "TWO" }, + { TRACE_SAMPLE_BAR, "FOUR" }, + { TRACE_SAMPLE_ZOO, "EIGHT" }, + { 10, "TEN" } + ), + +/* + * __print_flags( variable, "delim", { value, "flag" }, ... ), + * + * This is similar to __print_symbolic, except that it tests the bits + * of the value. If ((FLAG & variable) == FLAG) then the string is + * printed. If more than one flag matches, then each one that does is + * also printed with delim in between them. + * If not all bits are accounted for, then the not found bits will be + * added in hex format: 0x506 will show BIT2|BIT4|0x500 + */ + __print_flags(__entry->bar, "|", + { 1, "BIT1" }, + { 2, "BIT2" }, + { 4, "BIT3" }, + { 8, "BIT4" } + ), +/* + * __print_array( array, len, element_size ) + * + * This prints out the array that is defined by __array in a nice format. + */ __print_array(__get_dynamic_array(list), __get_dynamic_array_len(list), sizeof(int)),
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRFC PATCH v2 9/17 tracing: Show the mapped enums in enum_map file
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
Add a enum_map file in the tracing directory to see what enums have been saved to convert in the print fmt files.
--- kernel/trace/trace.c | 110 +++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 107 insertions(+), 3 deletions(-)
kernel/trace/trace.c +107 -3
@@ -123,7 +123,7 @@ enum ftrace_dump_mode ftrace_dump_on_oops;/* When set, tracing will stop when a WARN*() is hit */ int __disable_trace_on_warning; -/* Map of enums to their values */ +/* Map of enums to their values, for "enum_map" file */ struct trace_enum_map_head {struct module *mod;unsigned long length;
@@ -136,10 +136,12 @@ struct trace_enum_map_tail {* "end" is first and points to NULL as it must be different * than "mod" or "enum_string" */ -const char *end;/* points to NULL */ union trace_enum_map_item *next; +const char *end;/* points to NULL */ }; +static DEFINE_MUTEX (trace_enum_mutex); +/* * The trace_enum_maps are saved in an array with two extra elements, * one at the beginning, and one at the end. The beginning item contains
@@ -3940,6 +3942,97 @@ static const struct file_operations tracing_saved_cmdlines_size_fops = { .write = tracing_saved_cmdlines_size_write, }; +static union trace_enum_map_item * +update_enum_map (union trace_enum_map_item *ptr) +{ +if (!ptr->map.enum_string) { +if (ptr->tail.next) { + ptr = ptr->tail.next; +/* Set ptr to the next real item (skip head) */ + ptr++; + }else +return NULL ; + } +return ptr; +} + +static void *enum_map_next (struct seq_file *m,void *v,loff_t *pos) +{ +union trace_enum_map_item *ptr = v; + +/* +* Paranoid! If ptr points to end, we don't want to increment past it. +* This really should never happen. +*/ + ptr =update_enum_map (ptr); +if (WARN_ON_ONCE (!ptr)) +return NULL ; + + ptr++; + + (*pos)++; + + ptr =update_enum_map (ptr); + +return ptr; +} + +static void *enum_map_start (struct seq_file *m,loff_t *pos) +{ +union trace_enum_map_item *v; +loff_t l =0 ; + +mutex_lock (&trace_enum_mutex); + + v = trace_enum_maps; +if (v) + v++; + +while (v && l < *pos) { + v =enum_map_next (m, v, &l); + } + +return v; +} + +static void enum_map_stop (struct seq_file *m,void *v) +{ +mutex_unlock (&trace_enum_mutex); +} + +static int enum_map_show (struct seq_file *m,void *v) +{ +union trace_enum_map_item *ptr = v; + +seq_printf (m,"%s %ld (%s)\n" , + ptr->map.enum_string, ptr->map.enum_value, + ptr->map.system); + +return 0 ; +} + +static const struct seq_operations tracing_enum_map_seq_ops = { + .start = enum_map_start, + .next = enum_map_next, + .stop = enum_map_stop, + .show = enum_map_show, +}; + +static int tracing_enum_map_open (struct inode *inode,struct file *filp) +{ +if (tracing_disabled) +return -ENODEV ; + +return seq_open (filp, &tracing_enum_map_seq_ops); +} + +static const struct file_operations tracing_enum_map_fops = { + .open = tracing_enum_map_open, + .read = seq_read, + .llseek = seq_lseek, + .release = seq_release, +}; +static inline union trace_enum_map_item *trace_enum_jmp_to_tail (union trace_enum_map_item *ptr) {
@@ -3971,6 +4064,8 @@ static void trace_insert_enum_map(struct module *mod,return ; } +mutex_lock (&trace_enum_mutex); +if (!trace_enum_maps) trace_enum_maps = map_array;else {
@@ -3996,6 +4091,8 @@ static void trace_insert_enum_map(struct module *mod,/* Pass in the start of the array (-len) */ trace_event_enum_update (&map_array[-len].map, len); + +mutex_unlock (&trace_enum_mutex); } static ssize_t
@@ -6667,6 +6764,8 @@ static void trace_module_remove_enums(struct module *mod)if (!mod->num_trace_enums)return ; +mutex_lock (&trace_enum_mutex); + map = trace_enum_maps;while (map) {
@@ -6677,10 +6776,12 @@ static void trace_module_remove_enums(struct module *mod) map = map->tail.next; }if (!map) -return ; + goto out; *last =trace_enum_jmp_to_tail (map)->tail.next;kfree (map); + out: +mutex_unlock (&trace_enum_mutex); } static int trace_module_notify(struct notifier_block *self,
@@ -6732,6 +6833,9 @@ static __init int tracer_init_debugfs(void)trace_enum_init (); +trace_create_file ("enum_map" ,0444 , d_tracer, +NULL , &tracing_enum_map_fops); +#ifdef CONFIG_MODULES register_module_notifier (&trace_module_nb);#endif
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRe: [RFC][PATCH 09/17 v2] tracing: Show the mapped enums in enum_map file
Quoted 4 lines · On Wed, 01 Apr 2015 21:56:57 -0400 Steven Rostedt <[email protected]> wrote:
From: "Steven Rostedt (Red Hat)" <[email protected]>
Add a
enum_mapfile in the tracing directory to see what enums have been saved to convert in the print fmt files.
Hmm, I'm thinking of dropping this patch, and adding it later with a config option. This way, when it is not enabled, the data used for conversion can be freed. I rather have that then have this stuck as an API.
Adding it with a config option that states that it will waste memory lets the distros decide if they want the extra footprint or not.
-- Steve
Steven Rostedt
maintainerRFC PATCH v2 10/17 x86/tlb/trace: Export enums in used by tlb_flush tracepoint
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
Have the enums used in __print_symbolic() by the trace_tlb_flush() tracepoint exported to userpace such that they can be parsed by userspace tools.
--- include/trace/events/tlb.h | 30 +++++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-)
include/trace/events/tlb.h +25 -5
@@ -7,11 +7,31 @@#include <linux/mm_types.h> #include <linux/tracepoint.h> -#define TLB_FLUSH_REASON \ - { TLB_FLUSH_ON_TASK_SWITCH, "flush on task switch" }, \ - { TLB_REMOTE_SHOOTDOWN, "remote shootdown" }, \ - { TLB_LOCAL_SHOOTDOWN, "local shootdown" }, \ - { TLB_LOCAL_MM_SHOOTDOWN, "local mm shootdown" } +#define TLB_FLUSH_REASON \ + EM( TLB_FLUSH_ON_TASK_SWITCH, "flush on task switch" ) \ + EM( TLB_REMOTE_SHOOTDOWN, "remote shootdown" ) \ + EM( TLB_LOCAL_SHOOTDOWN, "local shootdown" ) \ + EMe( TLB_LOCAL_MM_SHOOTDOWN, "local mm shootdown" ) + +/* +* First define the enums in TLB_FLUSH_REASON to be exported to userspace +* via TRACE_DEFINE_ENUM(). +*/ +#undef EM +#undef EMe +#define EM (a,b) TRACE_DEFINE_ENUM(a); +#define EMe (a,b) TRACE_DEFINE_ENUM(a); + +TLB_FLUSH_REASON + +/* +* Now redefine the EM() and EMe() macros to map the enums to the strings +* that will be printed in the output. + */ +#undef EM +#undef EMe +#define EM (a,b) { a, b }, +#define EMe (a,b) { a, b } TRACE_EVENT_CONDITION(tlb_flush,
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRFC PATCH v2 11/17 net/9p/tracing: Export enums in tracepoints to userspace
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
The tracepoints in the 9p code use a lot of enums for the __print_symbolic() function. These enums are shown in the tracepoint format files, and user space tools such as trace-cmd does not have the information to parse it. Add helper macros to export the enums with TRACE_DEFINE_ENUM().
--- include/trace/events/9p.h | 157 ++++++++++++++++++++++++++-------------------- 1 file changed, 88 insertions(+), 69 deletions(-)
include/trace/events/9p.h +88 -69
@@ -6,76 +6,95 @@#include <linux/tracepoint.h> +#define P9_MSG_T \ + EM( P9_TLERROR, "P9_TLERROR" ) \ + EM( P9_RLERROR, "P9_RLERROR" ) \ + EM( P9_TSTATFS, "P9_TSTATFS" ) \ + EM( P9_RSTATFS, "P9_RSTATFS" ) \ + EM( P9_TLOPEN, "P9_TLOPEN" ) \ + EM( P9_RLOPEN, "P9_RLOPEN" ) \ + EM( P9_TLCREATE, "P9_TLCREATE" ) \ + EM( P9_RLCREATE, "P9_RLCREATE" ) \ + EM( P9_TSYMLINK, "P9_TSYMLINK" ) \ + EM( P9_RSYMLINK, "P9_RSYMLINK" ) \ + EM( P9_TMKNOD, "P9_TMKNOD" ) \ + EM( P9_RMKNOD, "P9_RMKNOD" ) \ + EM( P9_TRENAME, "P9_TRENAME" ) \ + EM( P9_RRENAME, "P9_RRENAME" ) \ + EM( P9_TREADLINK, "P9_TREADLINK" ) \ + EM( P9_RREADLINK, "P9_RREADLINK" ) \ + EM( P9_TGETATTR, "P9_TGETATTR" ) \ + EM( P9_RGETATTR, "P9_RGETATTR" ) \ + EM( P9_TSETATTR, "P9_TSETATTR" ) \ + EM( P9_RSETATTR, "P9_RSETATTR" ) \ + EM( P9_TXATTRWALK, "P9_TXATTRWALK" ) \ + EM( P9_RXATTRWALK, "P9_RXATTRWALK" ) \ + EM( P9_TXATTRCREATE, "P9_TXATTRCREATE" ) \ + EM( P9_RXATTRCREATE, "P9_RXATTRCREATE" ) \ + EM( P9_TREADDIR, "P9_TREADDIR" ) \ + EM( P9_RREADDIR, "P9_RREADDIR" ) \ + EM( P9_TFSYNC, "P9_TFSYNC" ) \ + EM( P9_RFSYNC, "P9_RFSYNC" ) \ + EM( P9_TLOCK, "P9_TLOCK" ) \ + EM( P9_RLOCK, "P9_RLOCK" ) \ + EM( P9_TGETLOCK, "P9_TGETLOCK" ) \ + EM( P9_RGETLOCK, "P9_RGETLOCK" ) \ + EM( P9_TLINK, "P9_TLINK" ) \ + EM( P9_RLINK, "P9_RLINK" ) \ + EM( P9_TMKDIR, "P9_TMKDIR" ) \ + EM( P9_RMKDIR, "P9_RMKDIR" ) \ + EM( P9_TRENAMEAT, "P9_TRENAMEAT" ) \ + EM( P9_RRENAMEAT, "P9_RRENAMEAT" ) \ + EM( P9_TUNLINKAT, "P9_TUNLINKAT" ) \ + EM( P9_RUNLINKAT, "P9_RUNLINKAT" ) \ + EM( P9_TVERSION, "P9_TVERSION" ) \ + EM( P9_RVERSION, "P9_RVERSION" ) \ + EM( P9_TAUTH, "P9_TAUTH" ) \ + EM( P9_RAUTH, "P9_RAUTH" ) \ + EM( P9_TATTACH, "P9_TATTACH" ) \ + EM( P9_RATTACH, "P9_RATTACH" ) \ + EM( P9_TERROR, "P9_TERROR" ) \ + EM( P9_RERROR, "P9_RERROR" ) \ + EM( P9_TFLUSH, "P9_TFLUSH" ) \ + EM( P9_RFLUSH, "P9_RFLUSH" ) \ + EM( P9_TWALK, "P9_TWALK" ) \ + EM( P9_RWALK, "P9_RWALK" ) \ + EM( P9_TOPEN, "P9_TOPEN" ) \ + EM( P9_ROPEN, "P9_ROPEN" ) \ + EM( P9_TCREATE, "P9_TCREATE" ) \ + EM( P9_RCREATE, "P9_RCREATE" ) \ + EM( P9_TREAD, "P9_TREAD" ) \ + EM( P9_RREAD, "P9_RREAD" ) \ + EM( P9_TWRITE, "P9_TWRITE" ) \ + EM( P9_RWRITE, "P9_RWRITE" ) \ + EM( P9_TCLUNK, "P9_TCLUNK" ) \ + EM( P9_RCLUNK, "P9_RCLUNK" ) \ + EM( P9_TREMOVE, "P9_TREMOVE" ) \ + EM( P9_RREMOVE, "P9_RREMOVE" ) \ + EM( P9_TSTAT, "P9_TSTAT" ) \ + EM( P9_RSTAT, "P9_RSTAT" ) \ + EM( P9_TWSTAT, "P9_TWSTAT" ) \ + EMe(P9_RWSTAT, "P9_RWSTAT" ) + +/* Define EM() to export the enums to userspace via TRACE_DEFINE_ENUM() */ +#undef EM +#undef EMe +#define EM (a, b) TRACE_DEFINE_ENUM(a); +#define EMe (a, b) TRACE_DEFINE_ENUM(a); + +P9_MSG_T + +/* +* Now redefine the EM() and EMe() macros to map the enums to the strings +* that will be printed in the output. + */ +#undef EM +#undef EMe +#define EM (a, b) { a, b }, +#define EMe (a, b) { a, b } +#define show_9p_op (type) \ - __print_symbolic(type, \ - { P9_TLERROR, "P9_TLERROR" }, \ - { P9_RLERROR, "P9_RLERROR" }, \ - { P9_TSTATFS, "P9_TSTATFS" }, \ - { P9_RSTATFS, "P9_RSTATFS" }, \ - { P9_TLOPEN, "P9_TLOPEN" }, \ - { P9_RLOPEN, "P9_RLOPEN" }, \ - { P9_TLCREATE, "P9_TLCREATE" }, \ - { P9_RLCREATE, "P9_RLCREATE" }, \ - { P9_TSYMLINK, "P9_TSYMLINK" }, \ - { P9_RSYMLINK, "P9_RSYMLINK" }, \ - { P9_TMKNOD, "P9_TMKNOD" }, \ - { P9_RMKNOD, "P9_RMKNOD" }, \ - { P9_TRENAME, "P9_TRENAME" }, \ - { P9_RRENAME, "P9_RRENAME" }, \ - { P9_TREADLINK, "P9_TREADLINK" }, \ - { P9_RREADLINK, "P9_RREADLINK" }, \ - { P9_TGETATTR, "P9_TGETATTR" }, \ - { P9_RGETATTR, "P9_RGETATTR" }, \ - { P9_TSETATTR, "P9_TSETATTR" }, \ - { P9_RSETATTR, "P9_RSETATTR" }, \ - { P9_TXATTRWALK, "P9_TXATTRWALK" }, \ - { P9_RXATTRWALK, "P9_RXATTRWALK" }, \ - { P9_TXATTRCREATE, "P9_TXATTRCREATE" }, \ - { P9_RXATTRCREATE, "P9_RXATTRCREATE" }, \ - { P9_TREADDIR, "P9_TREADDIR" }, \ - { P9_RREADDIR, "P9_RREADDIR" }, \ - { P9_TFSYNC, "P9_TFSYNC" }, \ - { P9_RFSYNC, "P9_RFSYNC" }, \ - { P9_TLOCK, "P9_TLOCK" }, \ - { P9_RLOCK, "P9_RLOCK" }, \ - { P9_TGETLOCK, "P9_TGETLOCK" }, \ - { P9_RGETLOCK, "P9_RGETLOCK" }, \ - { P9_TLINK, "P9_TLINK" }, \ - { P9_RLINK, "P9_RLINK" }, \ - { P9_TMKDIR, "P9_TMKDIR" }, \ - { P9_RMKDIR, "P9_RMKDIR" }, \ - { P9_TRENAMEAT, "P9_TRENAMEAT" }, \ - { P9_RRENAMEAT, "P9_RRENAMEAT" }, \ - { P9_TUNLINKAT, "P9_TUNLINKAT" }, \ - { P9_RUNLINKAT, "P9_RUNLINKAT" }, \ - { P9_TVERSION, "P9_TVERSION" }, \ - { P9_RVERSION, "P9_RVERSION" }, \ - { P9_TAUTH, "P9_TAUTH" }, \ - { P9_RAUTH, "P9_RAUTH" }, \ - { P9_TATTACH, "P9_TATTACH" }, \ - { P9_RATTACH, "P9_RATTACH" }, \ - { P9_TERROR, "P9_TERROR" }, \ - { P9_RERROR, "P9_RERROR" }, \ - { P9_TFLUSH, "P9_TFLUSH" }, \ - { P9_RFLUSH, "P9_RFLUSH" }, \ - { P9_TWALK, "P9_TWALK" }, \ - { P9_RWALK, "P9_RWALK" }, \ - { P9_TOPEN, "P9_TOPEN" }, \ - { P9_ROPEN, "P9_ROPEN" }, \ - { P9_TCREATE, "P9_TCREATE" }, \ - { P9_RCREATE, "P9_RCREATE" }, \ - { P9_TREAD, "P9_TREAD" }, \ - { P9_RREAD, "P9_RREAD" }, \ - { P9_TWRITE, "P9_TWRITE" }, \ - { P9_RWRITE, "P9_RWRITE" }, \ - { P9_TCLUNK, "P9_TCLUNK" }, \ - { P9_RCLUNK, "P9_RCLUNK" }, \ - { P9_TREMOVE, "P9_TREMOVE" }, \ - { P9_RREMOVE, "P9_RREMOVE" }, \ - { P9_TSTAT, "P9_TSTAT" }, \ - { P9_RSTAT, "P9_RSTAT" }, \ - { P9_TWSTAT, "P9_TWSTAT" }, \ - { P9_RWSTAT, "P9_RWSTAT" }) + __print_symbolic(type, P9_MSG_T) TRACE_EVENT(9p_client_req, TP_PROTO(struct p9_client *clnt, int8_t type, int tag),
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRFC PATCH v2 12/17 f2fs: Export the enums in the tracepoints to userspace
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
The tracepoints that use __print_symbolic() use enums as the value to convert to strings. Unfortunately, the format files for these tracepoints show the enum name and not their value. This causes some userspace tools not to know how to convert __print_symbolic() to their strings.
Add TRACE_DEFINE_ENUM() macros to export the enums used to userspace to let those tools know what those enum values are.
--- include/trace/events/f2fs.h | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+)
include/trace/events/f2fs.h +30 -0
@@ -9,6 +9,36 @@#define show_dev (entry) MAJOR(entry->dev), MINOR(entry->dev)#define show_dev_ino (entry) show_dev(entry), (unsigned long)entry->ino +TRACE_DEFINE_ENUM (NODE ); +TRACE_DEFINE_ENUM (DATA ); +TRACE_DEFINE_ENUM (META ); +TRACE_DEFINE_ENUM (META_FLUSH ); +TRACE_DEFINE_ENUM (CURSEG_HOT_DATA ); +TRACE_DEFINE_ENUM (CURSEG_WARM_DATA ); +TRACE_DEFINE_ENUM (CURSEG_COLD_DATA ); +TRACE_DEFINE_ENUM (CURSEG_HOT_NODE ); +TRACE_DEFINE_ENUM (CURSEG_WARM_NODE ); +TRACE_DEFINE_ENUM (CURSEG_COLD_NODE ); +TRACE_DEFINE_ENUM (NO_CHECK_TYPE ); +TRACE_DEFINE_ENUM (GC_GREEDY ); +TRACE_DEFINE_ENUM (GC_CB ); +TRACE_DEFINE_ENUM (FG_GC ); +TRACE_DEFINE_ENUM (BG_GC ); +TRACE_DEFINE_ENUM (LFS ); +TRACE_DEFINE_ENUM (SSR ); +TRACE_DEFINE_ENUM (__REQ_RAHEAD); +TRACE_DEFINE_ENUM (__REQ_WRITE); +TRACE_DEFINE_ENUM (__REQ_SYNC); +TRACE_DEFINE_ENUM (__REQ_NOIDLE); +TRACE_DEFINE_ENUM (__REQ_FLUSH); +TRACE_DEFINE_ENUM (__REQ_FUA); +TRACE_DEFINE_ENUM (__REQ_PRIO); +TRACE_DEFINE_ENUM (__REQ_META); +TRACE_DEFINE_ENUM (CP_UMOUNT ); +TRACE_DEFINE_ENUM (CP_FASTBOOT ); +TRACE_DEFINE_ENUM (CP_SYNC ); +TRACE_DEFINE_ENUM (CP_DISCARD ); +#define show_block_type (type) \ __print_symbolic(type, \ { NODE, "NODE" }, \
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRFC PATCH v2 13/17 irq/tracing: Export enums in tracepoints to user space
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
The enums used by the softirq mapping is what is shown in the output of the __print_symbolic() and not their values, that are needed to map them to their strings. Export them to userspace with the TRACE_DEFINE_ENUM() macro so that user space tools can map the enums with their values.
--- include/trace/events/irq.h | 39 +++++++++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 12 deletions(-)
include/trace/events/irq.h +27 -12
@@ -9,19 +9,34 @@struct irqaction ;struct softirq_action ; -#define softirq_name (sirq) { sirq##_SOFTIRQ, #sirq } +#define SOFTIRQ_NAME_LIST \ + softirq_name(HI) \ + softirq_name(TIMER) \ + softirq_name(NET_TX) \ + softirq_name(NET_RX) \ + softirq_name(BLOCK) \ + softirq_name(BLOCK_IOPOLL) \ + softirq_name(TASKLET) \ + softirq_name(SCHED) \ + softirq_name(HRTIMER) \ + softirq_name_end(RCU) + +#undef softirq_name +#undef softirq_name_end + +#define softirq_name (sirq) TRACE_DEFINE_ENUM(sirq##_SOFTIRQ); +#define softirq_name_end (sirq) TRACE_DEFINE_ENUM(sirq##_SOFTIRQ); + +SOFTIRQ_NAME_LIST + +#undef softirq_name +#undef softirq_name_end + +#define softirq_name (sirq) { sirq##_SOFTIRQ, #sirq }, +#define softirq_name_end (sirq) { sirq##_SOFTIRQ, #sirq } +#define show_softirq_name (val) \ - __print_symbolic(val, \ - softirq_name(HI), \ - softirq_name(TIMER), \ - softirq_name(NET_TX), \ - softirq_name(NET_RX), \ - softirq_name(BLOCK), \ - softirq_name(BLOCK_IOPOLL), \ - softirq_name(TASKLET), \ - softirq_name(SCHED), \ - softirq_name(HRTIMER), \ - softirq_name(RCU)) + __print_symbolic(val, SOFTIRQ_NAME_LIST)/** * irq_handler_entry - called immediately before the irq action handler
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRFC PATCH v2 14/17 mm: tracing: Export enums in tracepoints to user space
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
The enums used in tracepoints with __print_symbolic() have their names shown in the tracepoint format files and not their values. This makes it difficult for user space tools to convert the binary data to the strings as user space does not know what those enums are about.
By having them use TRACE_DEFINE_ENUM(), the names of the enums will be mapped to the values and shown to user space.
--- include/trace/events/migrate.h | 42 ++++++++++++++++++++++++++++++++---------- 1 file changed, 32 insertions(+), 10 deletions(-)
include/trace/events/migrate.h +32 -10
@@ -7,18 +7,40 @@#include <linux/tracepoint.h> #define MIGRATE_MODE \ - {MIGRATE_ASYNC, "MIGRATE_ASYNC"}, \ - {MIGRATE_SYNC_LIGHT, "MIGRATE_SYNC_LIGHT"}, \ - {MIGRATE_SYNC, "MIGRATE_SYNC"} + EM( MIGRATE_ASYNC, "MIGRATE_ASYNC") \ + EM( MIGRATE_SYNC_LIGHT, "MIGRATE_SYNC_LIGHT") \ + EMe(MIGRATE_SYNC, "MIGRATE_SYNC") +#define MIGRATE_REASON \ - {MR_COMPACTION, "compaction"}, \ - {MR_MEMORY_FAILURE, "memory_failure"}, \ - {MR_MEMORY_HOTPLUG, "memory_hotplug"}, \ - {MR_SYSCALL, "syscall_or_cpuset"}, \ - {MR_MEMPOLICY_MBIND, "mempolicy_mbind"}, \ - {MR_NUMA_MISPLACED, "numa_misplaced"}, \ - {MR_CMA, "cma"} + EM( MR_COMPACTION, "compaction") \ + EM( MR_MEMORY_FAILURE, "memory_failure") \ + EM( MR_MEMORY_HOTPLUG, "memory_hotplug") \ + EM( MR_SYSCALL, "syscall_or_cpuset") \ + EM( MR_MEMPOLICY_MBIND, "mempolicy_mbind") \ + EM( MR_NUMA_MISPLACED, "numa_misplaced") \ + EMe(MR_CMA, "cma") + +/* +* First define the enums in the above macros to be exported to userspace +* via TRACE_DEFINE_ENUM(). +*/ +#undef EM +#undef EMe +#define EM (a, b) TRACE_DEFINE_ENUM(a); +#define EMe (a, b) TRACE_DEFINE_ENUM(a); + +MIGRATE_MODE +MIGRATE_REASON + +/* +* Now redefine the EM() and EMe() macros to map the enums to the strings +* that will be printed in the output. + */ +#undef EM +#undef EMe +#define EM (a, b) {a, b}, +#define EMe (a, b) {a, b} TRACE_EVENT(mm_migrate_pages,
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRFC PATCH v2 15/17 SUNRPC: Export enums in tracepoints to user space
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
The enums used in the tracepoints for __print_symbolic() have their names shown in the tracepoint format files. User space tools do not know how to convert those names into their values to be able to convert the binary data.
Use TRACE_DEFINE_ENUM() to export the enum names to their values for userspace to do the parsing correctly.
--- include/trace/events/sunrpc.h | 62 ++++++++++++++++++++++++++++++------------- 1 file changed, 44 insertions(+), 18 deletions(-)
include/trace/events/sunrpc.h +44 -18
@@ -179,27 +179,53 @@ DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup, ); +/* +* First define the enums in the below macros to be exported to userspace +* via TRACE_DEFINE_ENUM(). +*/ +#undef EM +#undef EMe +#define EM (a, b) TRACE_DEFINE_ENUM(a); +#define EMe (a, b) TRACE_DEFINE_ENUM(a); + +#define RPC_SHOW_SOCKET \ + EM( SS_FREE, "FREE" ) \ + EM( SS_UNCONNECTED, "UNCONNECTED" ) \ + EM( SS_CONNECTING, "CONNECTING," ) \ + EM( SS_CONNECTED, "CONNECTED," ) \ + EMe(SS_DISCONNECTING, "DISCONNECTING" ) +#define rpc_show_socket_state (state) \ - __print_symbolic(state, \ - { SS_FREE, "FREE" }, \ - { SS_UNCONNECTED, "UNCONNECTED" }, \ - { SS_CONNECTING, "CONNECTING," }, \ - { SS_CONNECTED, "CONNECTED," }, \ - { SS_DISCONNECTING, "DISCONNECTING" }) + __print_symbolic(state, RPC_SHOW_SOCKET) + +RPC_SHOW_SOCKET + +#define RPC_SHOW_SOCK \ + EM( TCP_ESTABLISHED, "ESTABLISHED" ) \ + EM( TCP_SYN_SENT, "SYN_SENT" ) \ + EM( TCP_SYN_RECV, "SYN_RECV" ) \ + EM( TCP_FIN_WAIT1, "FIN_WAIT1" ) \ + EM( TCP_FIN_WAIT2, "FIN_WAIT2" ) \ + EM( TCP_TIME_WAIT, "TIME_WAIT" ) \ + EM( TCP_CLOSE, "CLOSE" ) \ + EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" ) \ + EM( TCP_LAST_ACK, "LAST_ACK" ) \ + EM( TCP_LISTEN, "LISTEN" ) \ + EMe( TCP_CLOSING, "CLOSING" )#define rpc_show_sock_state (state) \ - __print_symbolic(state, \ - { TCP_ESTABLISHED, "ESTABLISHED" }, \ - { TCP_SYN_SENT, "SYN_SENT" }, \ - { TCP_SYN_RECV, "SYN_RECV" }, \ - { TCP_FIN_WAIT1, "FIN_WAIT1" }, \ - { TCP_FIN_WAIT2, "FIN_WAIT2" }, \ - { TCP_TIME_WAIT, "TIME_WAIT" }, \ - { TCP_CLOSE, "CLOSE" }, \ - { TCP_CLOSE_WAIT, "CLOSE_WAIT" }, \ - { TCP_LAST_ACK, "LAST_ACK" }, \ - { TCP_LISTEN, "LISTEN" }, \ - { TCP_CLOSING, "CLOSING" }) + __print_symbolic(state, RPC_SHOW_SOCK) + +RPC_SHOW_SOCK + +/* +* Now redefine the EM() and EMe() macros to map the enums to the strings +* that will be printed in the output. + */ +#undef EM +#undef EMe +#define EM (a, b) {a, b}, +#define EMe (a, b) {a, b} DECLARE_EVENT_CLASS(xs_socket_event,
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRFC PATCH v2 16/17 v4l: Export enums used by tracepoints to user space
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
Enums used by tracepoints for __print_symbolic() are shown in the tracepoint format files with just their names and not their values. This makes it difficult for user space tools to know how to convert the binary data into their string representations.
By adding the use of TRACE_DEFINE_ENUM(), the enum names will be mapped to their values and shown in the tracing file system to let tools convert the data as necessary.
--- include/trace/events/v4l2.h | 75 ++++++++++++++++++++++++++++++--------------- 1 file changed, 50 insertions(+), 25 deletions(-)
include/trace/events/v4l2.h +50 -25
@@ -6,33 +6,58 @@#include <linux/tracepoint.h> -#define show_type (type) \ - __print_symbolic(type, \ - { V4L2_BUF_TYPE_VIDEO_CAPTURE, "VIDEO_CAPTURE" }, \ - { V4L2_BUF_TYPE_VIDEO_OUTPUT, "VIDEO_OUTPUT" }, \ - { V4L2_BUF_TYPE_VIDEO_OVERLAY, "VIDEO_OVERLAY" }, \ - { V4L2_BUF_TYPE_VBI_CAPTURE, "VBI_CAPTURE" }, \ - { V4L2_BUF_TYPE_VBI_OUTPUT, "VBI_OUTPUT" }, \ - { V4L2_BUF_TYPE_SLICED_VBI_CAPTURE, "SLICED_VBI_CAPTURE" }, \ - { V4L2_BUF_TYPE_SLICED_VBI_OUTPUT, "SLICED_VBI_OUTPUT" }, \ - { V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY, "VIDEO_OUTPUT_OVERLAY" },\ - { V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, "VIDEO_CAPTURE_MPLANE" },\ - { V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, "VIDEO_OUTPUT_MPLANE" }, \ - { V4L2_BUF_TYPE_SDR_CAPTURE, "SDR_CAPTURE" }, \ - { V4L2_BUF_TYPE_PRIVATE, "PRIVATE" }) +/* Enums require being exported to userspace, for user tool parsing */ +#undef EM +#undef EMe +#define EM (a, b) TRACE_DEFINE_ENUM(a); +#define EMe (a, b) TRACE_DEFINE_ENUM(a); + +#define show_type (type) \ + __print_symbolic(type, SHOW_TYPE) + +#define SHOW_TYPE \ + EM( V4L2_BUF_TYPE_VIDEO_CAPTURE, "VIDEO_CAPTURE" ) \ + EM( V4L2_BUF_TYPE_VIDEO_OUTPUT, "VIDEO_OUTPUT" ) \ + EM( V4L2_BUF_TYPE_VIDEO_OVERLAY, "VIDEO_OVERLAY" ) \ + EM( V4L2_BUF_TYPE_VBI_CAPTURE, "VBI_CAPTURE" ) \ + EM( V4L2_BUF_TYPE_VBI_OUTPUT, "VBI_OUTPUT" ) \ + EM( V4L2_BUF_TYPE_SLICED_VBI_CAPTURE, "SLICED_VBI_CAPTURE" ) \ + EM( V4L2_BUF_TYPE_SLICED_VBI_OUTPUT, "SLICED_VBI_OUTPUT" ) \ + EM( V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY, "VIDEO_OUTPUT_OVERLAY" ) \ + EM( V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, "VIDEO_CAPTURE_MPLANE" ) \ + EM( V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, "VIDEO_OUTPUT_MPLANE" ) \ + EM( V4L2_BUF_TYPE_SDR_CAPTURE, "SDR_CAPTURE" ) \ + EMe(V4L2_BUF_TYPE_PRIVATE, "PRIVATE" ) + +SHOW_TYPE#define show_field (field) \ - __print_symbolic(field, \ - { V4L2_FIELD_ANY, "ANY" }, \ - { V4L2_FIELD_NONE, "NONE" }, \ - { V4L2_FIELD_TOP, "TOP" }, \ - { V4L2_FIELD_BOTTOM, "BOTTOM" }, \ - { V4L2_FIELD_INTERLACED, "INTERLACED" }, \ - { V4L2_FIELD_SEQ_TB, "SEQ_TB" }, \ - { V4L2_FIELD_SEQ_BT, "SEQ_BT" }, \ - { V4L2_FIELD_ALTERNATE, "ALTERNATE" }, \ - { V4L2_FIELD_INTERLACED_TB, "INTERLACED_TB" }, \ - { V4L2_FIELD_INTERLACED_BT, "INTERLACED_BT" }) + __print_symbolic(field, SHOW_FIELD) + +#define SHOW_FIELD \ + EM( V4L2_FIELD_ANY, "ANY" ) \ + EM( V4L2_FIELD_NONE, "NONE" ) \ + EM( V4L2_FIELD_TOP, "TOP" ) \ + EM( V4L2_FIELD_BOTTOM, "BOTTOM" ) \ + EM( V4L2_FIELD_INTERLACED, "INTERLACED" ) \ + EM( V4L2_FIELD_SEQ_TB, "SEQ_TB" ) \ + EM( V4L2_FIELD_SEQ_BT, "SEQ_BT" ) \ + EM( V4L2_FIELD_ALTERNATE, "ALTERNATE" ) \ + EM( V4L2_FIELD_INTERLACED_TB, "INTERLACED_TB" ) \ + EMe( V4L2_FIELD_INTERLACED_BT, "INTERLACED_BT" ) + +SHOW_FIELD + +/* +* Now redefine the EM() and EMe() macros to map the enums to the strings +* that will be printed in the output. + */ +#undef EM +#undef EMe +#define EM (a, b) {a, b}, +#define EMe (a, b) {a, b} + +/* V4L2_TC_TYPE_* are macros, not defines, they do not need processing */ #define show_timecode_type (type) \ __print_symbolic(type, \
Signature · 1 line
2.1.4
Steven Rostedt
maintainerRFC PATCH v2 17/17 writeback: Export enums used by tracepoint to user space
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
The enums used in tracepoints for __print_symbolic() do not have their values shown in the tracepoint format files and this makes it difficult for user space tools to convert the binary values to the strings they are to represent.
Add TRACE_DEFINE_ENUM(x) macros to export the enum names to their values to make the tracing output from user space tools more robust.
--- include/trace/events/writeback.h | 33 +++++++++++++++++++++++++-------- 1 file changed, 25 insertions(+), 8 deletions(-)
include/trace/events/writeback.h +25 -8
@@ -23,15 +23,32 @@ {I_REFERENCED, "I_REFERENCED"} \ ) +/* enums need to be exported to user space */ +#undef EM +#undef EMe +#define EM (a,b) TRACE_DEFINE_ENUM(a); +#define EMe (a,b) TRACE_DEFINE_ENUM(a); +#define WB_WORK_REASON \ - {WB_REASON_BACKGROUND, "background"}, \ - {WB_REASON_TRY_TO_FREE_PAGES, "try_to_free_pages"}, \ - {WB_REASON_SYNC, "sync"}, \ - {WB_REASON_PERIODIC, "periodic"}, \ - {WB_REASON_LAPTOP_TIMER, "laptop_timer"}, \ - {WB_REASON_FREE_MORE_MEM, "free_more_memory"}, \ - {WB_REASON_FS_FREE_SPACE, "fs_free_space"}, \ - {WB_REASON_FORKER_THREAD, "forker_thread"} + EM( WB_REASON_BACKGROUND, "background") \ + EM( WB_REASON_TRY_TO_FREE_PAGES, "try_to_free_pages") \ + EM( WB_REASON_SYNC, "sync") \ + EM( WB_REASON_PERIODIC, "periodic") \ + EM( WB_REASON_LAPTOP_TIMER, "laptop_timer") \ + EM( WB_REASON_FREE_MORE_MEM, "free_more_memory") \ + EM( WB_REASON_FS_FREE_SPACE, "fs_free_space") \ + EMe(WB_REASON_FORKER_THREAD, "forker_thread") + +WB_WORK_REASON + +/* +* Now redefine the EM() and EMe() macros to map the enums to the strings +* that will be printed in the output. + */ +#undef EM +#undef EMe +#define EM (a,b) { a, b }, +#define EMe (a,b) { a, b }struct wb_writeback_work ;
Signature · 1 line
2.1.4
Quoted 42 lines · Steven Rostedt
As there are many tracepoints that use
__print_symbolic()to translate numbers into ASCII strings, and several of these translate enums as well, it causes a problem for user space tools that read the tracepoint format files and have to translate the binary data to their associated strings.For example, with the
tlb_flushtracepoint, we have this in the format file:print fmt: "pages:%ld reason:%s (%d)",
REC->pages,
__print_symbolic(REC->reason,
{TLB_FLUSH_ON_TASK_SWITCH, "flush on task switch" }, {TLB_REMOTE_SHOOTDOWN, "remote shootdown" },
{TLB_LOCAL_SHOOTDOWN, "local shootdown" },
{TLB_LOCAL_MM_SHOOTDOWN, "local mm shootdown" }),REC->reasonNow, userspace does not know what the value of
TLB_REMOTE_SHOOTDOWNis. To solve this, a new macro is created as a helper to allow tracepoints to export enums they use to userspace. This macro is called,TRACE_DEFINE_ENUM(), such that
TRACE_DEFINE_ENUM(TLB_REMOTE_SHOOTDOWN);will convert the "print fmt"s in the format files to its actual value and no longer display the enum name.
On boot up (or module load), the enums saved via
TRACE_DEFINE_ENUM()will be searched for in the TP_printk()s of the tracepoints. Logic knows enough to ignore quoted text.For debugging, a new file is still added in the tracing directory to show what enums were added, their values and the
TRACE_SYSTEMthat added them:# cat /sys/kernel/debug/tracing/enum_map TLB_LOCAL_MM_SHOOTDOWN 3 (tlb) TLB_LOCAL_SHOOTDOWN 2 (tlb) TLB_REMOTE_SHOOTDOWN 1 (tlb) TLB_FLUSH_ON_TASK_SWITCH 0 (tlb)And the output of the
tlb_flushformat is now:
Quoted 8 lines
print fmt: "pages:%ld reason:%s (%d)",
REC->pages,
__print_symbolic(REC->reason,
{ 0, "flush on task switch" },
{ 1, "remote shootdown" },
{ 2, "local shootdown" },
{ 3, "local mm shootdown" }),REC->reasonAnd userspace tools can easily parse that without special handling.
Great! :)
Thank you for updating the series :D
Now I'm OK for this series.
Quoted 48 lines
Local SHA1:
a6862181206543b6493c73690f322868c86de0eaSteven Rostedt (Red Hat) (17):
tracing: AddTRACE_SYSTEM_VARto intel-sst
tracing: AddTRACE_SYSTEM_VARto kvm-s390
tracing: AddTRACE_SYSTEM_VARto xhci-hcd
tracing: Give system name a pointer
tracing: Update trace-event-sample withTRACE_SYSTEM_VARdocumentation
tracing: AddTRACE_DEFINE_ENUM()macro to map enums to their values
tracing: Allow for modules to export their trace enums as well tracing/samples: Update thetrace-event-sample.hwithTRACE_DEFINE_ENUM()
tracing: Show the mapped enums inenum_mapfile x86/tlb/trace: Export enums in used bytlb_flushtracepointnet/9p/tracing: Export enums in tracepoints to userspace
f2fs: Export the enums in the tracepoints to userspace irq/tracing: Export enums in tracepoints to user space
mm: tracing: Export enums in tracepoints to user space
SUNRPC: Export enums in tracepoints to user space
v4l: Export enums used by tracepoints to user space
writeback: Export enums used by tracepoint to user space----
arch/s390/kvm/trace-s390.h | 7 + drivers/usb/host/xhci-trace.h | 7 + include/asm-generic/vmlinux.lds.h | 5 +- include/linux/ftrace_event.h | 4 +- include/linux/module.h | 2 + include/linux/tracepoint.h | 8 + include/trace/events/9p.h | 157 ++++++++-------- include/trace/events/f2fs.h | 30 ++++ include/trace/events/intel-sst.h | 7 + include/trace/events/irq.h | 39 ++-- include/trace/events/migrate.h | 42 +++-- include/trace/events/sunrpc.h | 62 +++++-- include/trace/events/tlb.h | 30 +++- include/trace/events/v4l2.h | 75 +++++--- include/trace/events/writeback.h | 33 +++- include/trace/ftrace.h | 41 ++++- kernel/module.c | 3 + kernel/trace/trace.c | 276 ++++++++++++++++++++++++++++- kernel/trace/trace.h | 2 + kernel/trace/trace_events.c | 98 +++++++++- samples/trace_events/trace-events-sample.h | 84 ++++++++- 21 files changed, 853 insertions(+), 159 deletions(-)
Signature · 5 lines
Masami HIRAMATSU Linux Technology Research Center, System Productivity Research Dept. Center for Technology Innovation - Systems Engineering Hitachi, Ltd., Research & Development Group E-mail: [email protected]