tracing: Updates for 3.20
Subsystems (3)
Steven Rostedt
maintainercover tracing: Updates for 3.20
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
for-next
Head SHA1: 7eeafbcab47fe9860e5106286db83d60e3f35644
Borislav Petkov (1):
tracing: Remove newline from trace_printk warning banner
Dave Martin (1):
tracing: Add array printing helper
Steven Rostedt (Red Hat) (2):
tracing: Make tracing_init_dentry_tr() static
tracing: Separate out initializing top level dir from instances
Tina Ruchandani (1):
trace: Use 64-bit timekeeping
----
include/linux/ftrace_event.h | 4 +++ include/trace/ftrace.h | 9 ++++++ kernel/trace/ring_buffer_benchmark.c | 18 ++++++------ kernel/trace/trace.c | 54 +++++++++++++++++++++--------------- kernel/trace/trace.h | 1 - kernel/trace/trace_output.c | 44 +++++++++++++++++++++++++++++ 6 files changed, 97 insertions(+), 33 deletions(-)
Steven Rostedt
maintainerPATCH 1/5 tracing: Remove newline from trace_printk warning banner
From: Borislav Petkov <[email protected]>
Remove the output-confusing newline below:
[ 0.191328] ********************************************************** [ 0.191493] ** NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE ** [ 0.191586] ** **
...
--- kernel/trace/trace.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
kernel/trace/trace.c +2 -1
@@ -2036,7 +2036,8 @@ void trace_printk_init_buffers(void)/* trace_printk() is for debug use only. Don't use it in production. */ -pr_warning ("\n**********************************************************\n" ); +pr_warning ("\n" ); +pr_warning ("**********************************************************\n" );pr_warning ("** NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE **\n" );pr_warning ("** **\n" );pr_warning ("** trace_printk() being used. Allocating extra memory. **\n" );
Signature · 1 line
2.1.4
Steven Rostedt
maintainerPATCH 2/5 tracing: Add array printing helper
In reply to Steven RostedtFrom: Dave Martin <[email protected]>
If a trace event contains an array, there is currently no standard way to format this for text output. Drivers are currently hacking around this by a) local hacks that use the trace_seq functionailty directly, or b) just not printing that information. For fixed size arrays, formatting of the elements can be open-coded, but this gets cumbersome for arrays of non-trivial size.
These approaches result in non-standard content of the event format description delivered to userspace, so userland tools needs to be taught to understand and parse each array printing method individually.
This patch implements a __print_array() helper that tracepoint implementations can use instead of reinventing it. A simple C-style syntax is used to delimit the array and its elements {like,this}.
So that the helpers can be used with large static arrays as well as dynamic arrays, they take a pointer and element count: they can be used with __get_dynamic_array() for use with dynamic arrays.
--- include/linux/ftrace_event.h | 4 ++++ include/trace/ftrace.h | 9 +++++++++ kernel/trace/trace_output.c | 44 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 57 insertions(+)
include/linux/ftrace_event.h +4 -0
@@ -44,6 +44,10 @@ const char *ftrace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr,const char *ftrace_print_hex_seq (struct trace_seq *p,const unsigned char *buf,int len); +const char *ftrace_print_array_seq (struct trace_seq *p, +const void *buf,int buf_len, +size_t el_size); +struct trace_iterator ;struct trace_event ;
include/trace/ftrace.h +9 -0
@@ -263,6 +263,14 @@#undef __print_hex#define __print_hex (buf, buf_len) ftrace_print_hex_seq(p, buf, buf_len) +#undef __print_array +#define __print_array (array, count, el_size) \ + ({ \ + BUILD_BUG_ON(el_size != 1 && el_size != 2 && \ + el_size != 4 && el_size != 8); \ + ftrace_print_array_seq(p, array, count, el_size); \ + }) +#undef DECLARE_EVENT_CLASS#define DECLARE_EVENT_CLASS (call, proto, args, tstruct, assign, print) \ static notrace enum print_line_t \
@@ -674,6 +682,7 @@ static inline void ftrace_test_probe_##call(void) \#undef __get_dynamic_array_len#undef __get_str#undef __get_bitmask +#undef __print_array#undef TP_printk #define TP_printk(fmt, args...) "\"" fmt "\", " __stringify(args)
kernel/trace/trace_output.c +44 -0
50 lines not on this page · raw message
Signature · 1 line
2.1.4
Steven Rostedt
maintainerPATCH 3/5 trace: Use 64-bit timekeeping
In reply to Steven RostedtFrom: Tina Ruchandani <[email protected]>
The ring_buffer_producer uses 'struct timeval' to measure its start and end times. 'struct timeval' on 32-bit systems will have its tv_sec value overflow in year 2038 and beyond. This patch replaces struct timeval with 'ktime_t' which uses 64-bit representation for nanoseconds.
--- kernel/trace/ring_buffer_benchmark.c | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-)
kernel/trace/ring_buffer_benchmark.c +8 -10
@@ -7,7 +7,7 @@#include <linux/completion.h> #include <linux/kthread.h> #include <linux/module.h> -#include <linux/time.h> +#include <linux/ktime.h> #include <asm/local.h> struct rb_page {
@@ -17,7 +17,7 @@ struct rb_page { };/* run time and sleep time in seconds */ -#define RUN_TIME 10 +#define RUN_TIME 10ULL#define SLEEP_TIME 10/* number of events for writer to wake up the reader */
@@ -212,8 +212,7 @@ static void ring_buffer_consumer(void)static void ring_buffer_producer (void ) { -struct timeval start_tv; -struct timeval end_tv; +ktime_t start_time, end_time, timeout;unsigned long long time;unsigned long long entries;unsigned long long overruns;
@@ -227,7 +226,8 @@ static void ring_buffer_producer(void)* make the system stall) */ trace_printk ("Starting ring buffer hammer\n" ); -do_gettimeofday (&start_tv); + start_time =ktime_get (); + timeout =ktime_add_ns (start_time,RUN_TIME *NSEC_PER_SEC ); do { struct ring_buffer_event *event; int *entry;
@@ -244,7 +244,7 @@ static void ring_buffer_producer(void)ring_buffer_unlock_commit (buffer, event); } } -do_gettimeofday (&end_tv); + end_time =ktime_get (); cnt++;if (consumer && !(cnt % wakeup_interval))
@@ -264,7 +264,7 @@ static void ring_buffer_producer(void)cond_resched ();#endif - }while (end_tv.tv_sec < (start_tv.tv_sec +RUN_TIME ) && !kill_test); + }while (ktime_before (end_time, timeout) && !kill_test);trace_printk ("End ring buffer hammer\n" );if (consumer) {
@@ -280,9 +280,7 @@ static void ring_buffer_producer(void)wait_for_completion (&read_done); } - time = end_tv.tv_sec - start_tv.tv_sec; - time *=USEC_PER_SEC ; - time += (long long )((long )end_tv.tv_usec - (long )start_tv.tv_usec); + time =ktime_us_delta (end_time, start_time); entries =ring_buffer_entries (buffer); overruns =ring_buffer_overruns (buffer);
Signature · 1 line
2.1.4
Steven Rostedt
maintainerPATCH 4/5 tracing: Make tracing_init_dentry_tr() static
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
tracing_init_dentry_tr() is not used outside of trace.c, it should be static.
--- kernel/trace/trace.c | 2 +- kernel/trace/trace.h | 1 - 2 files changed, 1 insertion(+), 2 deletions(-)
kernel/trace/trace.c +1 -1
@@ -5815,7 +5815,7 @@ static __init int register_snapshot_cmd(void)static inline __init int register_snapshot_cmd (void ) {return 0 ; }#endif /* defined(CONFIG_TRACER_SNAPSHOT) && defined(CONFIG_DYNAMIC_FTRACE) */ -struct dentry *tracing_init_dentry_tr (struct trace_array *tr) +static struct dentry *tracing_init_dentry_tr (struct trace_array *tr) {if (tr->dir)return tr->dir;
kernel/trace/trace.h +0 -1
@@ -542,7 +542,6 @@ struct dentry *trace_create_file(const char *name,void *data, const struct file_operations *fops); -struct dentry *tracing_init_dentry_tr (struct trace_array *tr);struct dentry *tracing_init_dentry (void );struct ring_buffer_event ;
Signature · 1 line
2.1.4
Steven Rostedt
maintainerPATCH 5/5 tracing: Separate out initializing top level dir from instances
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
The top level trace array is treated a little different than the instances, as it has to deal with more of the general tracing. The tr->dir is the tracing directory, which is an immutable dentry, where as the tr->dir of instances are the dentry that was created, and can be destroyed later. These should have different functions accessing them.
As only tracing_init_dentry() deals with the top level array, fold the code for it into that function, and remove the trace_init_dentry_tr() that was also used by the instances to get their directory dentry.
Add a tracing_get_dentry() to just get the tracing dir entry for instances as well as the top level array.
--- kernel/trace/trace.c | 51 ++++++++++++++++++++++++++++++--------------------- 1 file changed, 30 insertions(+), 21 deletions(-)
kernel/trace/trace.c +30 -21
@@ -5815,28 +5815,11 @@ static __init int register_snapshot_cmd(void)static inline __init int register_snapshot_cmd (void ) {return 0 ; }#endif /* defined(CONFIG_TRACER_SNAPSHOT) && defined(CONFIG_DYNAMIC_FTRACE) */ -static struct dentry *tracing_init_dentry_tr (struct trace_array *tr) +static struct dentry *tracing_get_dentry (struct trace_array *tr) { -if (tr->dir) -return tr->dir; - -if (!debugfs_initialized ()) -return ERR_PTR (-ENODEV ); - -if (tr->flags &TRACE_ARRAY_FL_GLOBAL ) - tr->dir =debugfs_create_dir ("tracing" ,NULL ); - -if (!tr->dir) -pr_warn_once ("Could not create debugfs directory 'tracing'\n" ); -return tr->dir; } -struct dentry *tracing_init_dentry (void ) -{ -return tracing_init_dentry_tr (&global_trace); -} -static struct dentry *tracing_dentry_percpu (struct trace_array *tr,int cpu) {struct dentry *d_tracer;
@@ -5844,7 +5827,7 @@ static struct dentry *tracing_dentry_percpu(struct trace_array *tr, int cpu)if (tr->percpu_dir)return tr->percpu_dir; - d_tracer =tracing_init_dentry_tr (tr); + d_tracer =tracing_get_dentry (tr);if (IS_ERR (d_tracer))return NULL ;
@@ -6047,7 +6030,7 @@ static struct dentry *trace_options_init_dentry(struct trace_array *tr)if (tr->options)return tr->options; - d_tracer =tracing_init_dentry_tr (tr); + d_tracer =tracing_get_dentry (tr);if (IS_ERR (d_tracer))return NULL ;
@@ -6532,6 +6515,33 @@ init_tracer_debugfs(struct trace_array *tr, struct dentry *d_tracer) } +/** +* tracing_init_dentry - initialize top level trace array +* +* This is called when creating files or directories in the tracing +* directory. It is called via fs_initcall() by any of the boot up code +* and expects to return the dentry of the top level tracing directory. +*/ +struct dentry *tracing_init_dentry (void ) +{ +struct trace_array *tr = &global_trace; + +if (tr->dir) +return tr->dir; + +if (WARN_ON (!debugfs_initialized ())) +return ERR_PTR (-ENODEV ); + + tr->dir =debugfs_create_dir ("tracing" ,NULL ); + +if (!tr->dir) { +pr_warn_once ("Could not create debugfs directory 'tracing'\n" ); +return ERR_PTR (-ENOMEM ); + } + +return tr->dir; +} +static __init int tracer_init_debugfs (void ) {struct dentry *d_tracer;
@@ -6772,7 +6782,6 @@ __init static int tracer_alloc_buffers(void)int ring_buf_size;int ret = -ENOMEM ; -if (!alloc_cpumask_var (&tracing_buffer_mask,GFP_KERNEL )) goto out;
Signature · 1 line
2.1.4