tracing: Minor fixes to the start up tests
Steven Rostedt
maintainercover tracing: Minor fixes to the start up tests
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
for-next
Head SHA1: 0cd8f5614fbf8a598a0a47526ac7dc42ab2ba8cd
Peter Zijlstra (1):
tracing: Robustify wait loop
Steven Rostedt (1):
tracing: Clean up scheduling in trace_wakeup_test_thread()
----
kernel/trace/trace_events.c | 5 ++++- kernel/trace/trace_selftest.c | 47 +++++++++++++++++++++++++++---------------- 2 files changed, 34 insertions(+), 18 deletions(-)
Steven Rostedt
maintainerPATCH 1/2 tracing: Robustify wait loop
From: Peter Zijlstra <[email protected]>
The pending nested sleep debugging triggered on the potential stale TASK_INTERRUPTIBLE in this code.
While there, fix the loop such that we won't revert to a while(1) yield() 'spin' loop if we ever get a spurious wakeup.
And fix the actual issue by properly terminating the 'wait' loop by setting TASK_RUNNING.
--- kernel/trace/trace_events.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
kernel/trace/trace_events.c +4 -1
@@ -2513,8 +2513,11 @@ static __init int event_test_thread(void *unused)kfree (test_malloc);set_current_state (TASK_INTERRUPTIBLE ); -while (!kthread_should_stop ()) +while (!kthread_should_stop ()) {schedule (); +set_current_state (TASK_INTERRUPTIBLE ); + } +__set_current_state (TASK_RUNNING );return 0 ; }
Signature · 1 line
2.0.1
Steven Rostedt
maintainerPATCH 2/2 tracing: Clean up scheduling in trace_wakeup_test_thread()
In reply to Steven RostedtFrom: Steven Rostedt <[email protected]>
Peter's new debugging tool triggers when tasks exit with !TASK_RUNNING. The code in trace_wakeup_test_thread() also has a single schedule() call that should be encompassed by a loop.
This cleans up the code a little to make it a bit more robust and also makes the return exit properly with TASK_RUNNING.
--- kernel/trace/trace_selftest.c | 47 +++++++++++++++++++++++++++---------------- 1 file changed, 30 insertions(+), 17 deletions(-)
kernel/trace/trace_selftest.c +30 -17
@@ -1025,6 +1025,12 @@ trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)#endif #ifdef CONFIG_SCHED_TRACER + +struct wakeup_test_data { +struct completion is_ready; +int go; +}; +static int trace_wakeup_test_thread (void *data) {/* Make this a -deadline thread */
@@ -1034,51 +1040,56 @@ static int trace_wakeup_test_thread(void *data) .sched_deadline = 10000000ULL, .sched_period = 10000000ULL }; -struct completion *x = data; +struct wakeup_test_data *x = data;sched_setattr (current, &attr);/* Make it know we have a new prio */ -complete (x); +complete (&x->is_ready);/* now go to sleep and let the test wake us up */ set_current_state (TASK_INTERRUPTIBLE ); -schedule (); +while (!x->go) { +schedule (); +set_current_state (TASK_INTERRUPTIBLE ); + } -complete (x); +complete (&x->is_ready); + +set_current_state (TASK_INTERRUPTIBLE );/* we are awake, now wait to disappear */ while (!kthread_should_stop ()) { -/* -* This will likely be the system top priority -* task, do short sleeps to let others run. -*/ -msleep (100 ); +schedule (); +set_current_state (TASK_INTERRUPTIBLE ); } +__set_current_state (TASK_RUNNING ); +return 0 ; } -int trace_selftest_startup_wakeup (struct tracer *trace,struct trace_array *tr) {unsigned long save_max = tr->max_latency;struct task_struct *p; -struct completion is_ready; +struct wakeup_test_data data;unsigned long count;int ret; -init_completion (&is_ready); +memset (&data,0 ,sizeof (data)); + +init_completion (&data.is_ready);/* create a -deadline thread */ - p =kthread_run (trace_wakeup_test_thread, &is_ready,"ftrace-test" ); + p =kthread_run (trace_wakeup_test_thread, &data,"ftrace-test" );if (IS_ERR (p)) {printk (KERN_CONT "Failed to create ftrace wakeup test thread " );return -1 ; }/* make sure the thread is running at -deadline policy */ -wait_for_completion (&is_ready); +wait_for_completion (&data.is_ready);/* start the tracing */ ret =tracer_init (trace, tr);
@@ -1099,18 +1110,20 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)msleep (100 ); } -init_completion (&is_ready); +init_completion (&data.is_ready); + + data.go =1 ; +/* memory barrier is in the wake_up_process() */ wake_up_process (p);/* Wait for the task to wake up */ -wait_for_completion (&is_ready); +wait_for_completion (&data.is_ready);/* stop the tracing. */ tracing_stop ();/* check both trace buffers */ ret =trace_test_buffer (&tr->trace_buffer,NULL ); -printk ("ret = %d\n" , ret);if (!ret) ret =trace_test_buffer (&tr->max_buffer, &count);
Signature · 1 line
2.0.1
Re: [for-next][PATCH 2/2] tracing: Clean up scheduling in trace_wakeup_test_thread()
Quoted 6 lines · Steven Rostedt
From: Steven Rostedt <[email protected]>
Peter's new debugging tool triggers when tasks exit with !TASK_RUNNING. The code in
trace_wakeup_test_thread()also has a singleschedule()call that should be encompassed by a loop.
Quoted 7 lines
This cleans up the code a little to make it a bit more robust and also makes the return exit properly with
TASK_RUNNING.Reported-by Peter Zijlstra <[email protected]>Signed-off-by Steven Rostedt <[email protected]>
Quoted 9 lines
--- kernel/trace/trace_selftest.c | 47 +++++++++++++++++++++++++++---------------- 1 file changed, 30 insertions(+), 17 deletions(-)kernel/trace/trace_selftest.c +0
-0
kernel/trace/trace_selftest.c trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr) · line 1032
Quoted 8 lines
kernel/trace/trace_selftest.c +5
-0@@ -1025,6 +1025,12 @@ trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)#endif #ifdef CONFIG_SCHED_TRACER + +struct wakeup_test_data { +struct completion is_ready; +int go; +};
Yeah that works..