![Steven Rostedt](/assets/img/avatar_default.png)
Have the ring buffer commit function use the irq_work infrastructure to wake up any waiters waiting on the ring buffer for new data. The irq_work was created for such a purpose, where doing the actual wake up at the time of adding data is too dangerous, as an event or function trace may be in the midst of the work queue locks and cause deadlocks. The irq_work will either delay the action to the next timer interrupt, or trigger an IPI to itself forcing an interrupt to do the work (in a safe location). With irq_work, all ring buffer commits can safely do wakeups, removing the need for the ring buffer commit "nowake" variants, which were used by events and function tracing. All commits can now safely use the normal commit, and the "nowake" variants can be removed. Cc: Peter Zijlstra <a.p.zijlstra@chello.nl> Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
1183 lines
26 KiB
C
1183 lines
26 KiB
C
/* Include in trace.c */
|
|
|
|
#include <linux/stringify.h>
|
|
#include <linux/kthread.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/slab.h>
|
|
|
|
static inline int trace_valid_entry(struct trace_entry *entry)
|
|
{
|
|
switch (entry->type) {
|
|
case TRACE_FN:
|
|
case TRACE_CTX:
|
|
case TRACE_WAKE:
|
|
case TRACE_STACK:
|
|
case TRACE_PRINT:
|
|
case TRACE_BRANCH:
|
|
case TRACE_GRAPH_ENT:
|
|
case TRACE_GRAPH_RET:
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int trace_test_buffer_cpu(struct trace_array *tr, int cpu)
|
|
{
|
|
struct ring_buffer_event *event;
|
|
struct trace_entry *entry;
|
|
unsigned int loops = 0;
|
|
|
|
while ((event = ring_buffer_consume(tr->buffer, cpu, NULL, NULL))) {
|
|
entry = ring_buffer_event_data(event);
|
|
|
|
/*
|
|
* The ring buffer is a size of trace_buf_size, if
|
|
* we loop more than the size, there's something wrong
|
|
* with the ring buffer.
|
|
*/
|
|
if (loops++ > trace_buf_size) {
|
|
printk(KERN_CONT ".. bad ring buffer ");
|
|
goto failed;
|
|
}
|
|
if (!trace_valid_entry(entry)) {
|
|
printk(KERN_CONT ".. invalid entry %d ",
|
|
entry->type);
|
|
goto failed;
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
failed:
|
|
/* disable tracing */
|
|
tracing_disabled = 1;
|
|
printk(KERN_CONT ".. corrupted trace buffer .. ");
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* Test the trace buffer to see if all the elements
|
|
* are still sane.
|
|
*/
|
|
static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
|
|
{
|
|
unsigned long flags, cnt = 0;
|
|
int cpu, ret = 0;
|
|
|
|
/* Don't allow flipping of max traces now */
|
|
local_irq_save(flags);
|
|
arch_spin_lock(&ftrace_max_lock);
|
|
|
|
cnt = ring_buffer_entries(tr->buffer);
|
|
|
|
/*
|
|
* The trace_test_buffer_cpu runs a while loop to consume all data.
|
|
* If the calling tracer is broken, and is constantly filling
|
|
* the buffer, this will run forever, and hard lock the box.
|
|
* We disable the ring buffer while we do this test to prevent
|
|
* a hard lock up.
|
|
*/
|
|
tracing_off();
|
|
for_each_possible_cpu(cpu) {
|
|
ret = trace_test_buffer_cpu(tr, cpu);
|
|
if (ret)
|
|
break;
|
|
}
|
|
tracing_on();
|
|
arch_spin_unlock(&ftrace_max_lock);
|
|
local_irq_restore(flags);
|
|
|
|
if (count)
|
|
*count = cnt;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static inline void warn_failed_init_tracer(struct tracer *trace, int init_ret)
|
|
{
|
|
printk(KERN_WARNING "Failed to init %s tracer, init returned %d\n",
|
|
trace->name, init_ret);
|
|
}
|
|
#ifdef CONFIG_FUNCTION_TRACER
|
|
|
|
#ifdef CONFIG_DYNAMIC_FTRACE
|
|
|
|
static int trace_selftest_test_probe1_cnt;
|
|
static void trace_selftest_test_probe1_func(unsigned long ip,
|
|
unsigned long pip,
|
|
struct ftrace_ops *op,
|
|
struct pt_regs *pt_regs)
|
|
{
|
|
trace_selftest_test_probe1_cnt++;
|
|
}
|
|
|
|
static int trace_selftest_test_probe2_cnt;
|
|
static void trace_selftest_test_probe2_func(unsigned long ip,
|
|
unsigned long pip,
|
|
struct ftrace_ops *op,
|
|
struct pt_regs *pt_regs)
|
|
{
|
|
trace_selftest_test_probe2_cnt++;
|
|
}
|
|
|
|
static int trace_selftest_test_probe3_cnt;
|
|
static void trace_selftest_test_probe3_func(unsigned long ip,
|
|
unsigned long pip,
|
|
struct ftrace_ops *op,
|
|
struct pt_regs *pt_regs)
|
|
{
|
|
trace_selftest_test_probe3_cnt++;
|
|
}
|
|
|
|
static int trace_selftest_test_global_cnt;
|
|
static void trace_selftest_test_global_func(unsigned long ip,
|
|
unsigned long pip,
|
|
struct ftrace_ops *op,
|
|
struct pt_regs *pt_regs)
|
|
{
|
|
trace_selftest_test_global_cnt++;
|
|
}
|
|
|
|
static int trace_selftest_test_dyn_cnt;
|
|
static void trace_selftest_test_dyn_func(unsigned long ip,
|
|
unsigned long pip,
|
|
struct ftrace_ops *op,
|
|
struct pt_regs *pt_regs)
|
|
{
|
|
trace_selftest_test_dyn_cnt++;
|
|
}
|
|
|
|
static struct ftrace_ops test_probe1 = {
|
|
.func = trace_selftest_test_probe1_func,
|
|
.flags = FTRACE_OPS_FL_RECURSION_SAFE,
|
|
};
|
|
|
|
static struct ftrace_ops test_probe2 = {
|
|
.func = trace_selftest_test_probe2_func,
|
|
.flags = FTRACE_OPS_FL_RECURSION_SAFE,
|
|
};
|
|
|
|
static struct ftrace_ops test_probe3 = {
|
|
.func = trace_selftest_test_probe3_func,
|
|
.flags = FTRACE_OPS_FL_RECURSION_SAFE,
|
|
};
|
|
|
|
static struct ftrace_ops test_global = {
|
|
.func = trace_selftest_test_global_func,
|
|
.flags = FTRACE_OPS_FL_GLOBAL | FTRACE_OPS_FL_RECURSION_SAFE,
|
|
};
|
|
|
|
static void print_counts(void)
|
|
{
|
|
printk("(%d %d %d %d %d) ",
|
|
trace_selftest_test_probe1_cnt,
|
|
trace_selftest_test_probe2_cnt,
|
|
trace_selftest_test_probe3_cnt,
|
|
trace_selftest_test_global_cnt,
|
|
trace_selftest_test_dyn_cnt);
|
|
}
|
|
|
|
static void reset_counts(void)
|
|
{
|
|
trace_selftest_test_probe1_cnt = 0;
|
|
trace_selftest_test_probe2_cnt = 0;
|
|
trace_selftest_test_probe3_cnt = 0;
|
|
trace_selftest_test_global_cnt = 0;
|
|
trace_selftest_test_dyn_cnt = 0;
|
|
}
|
|
|
|
static int trace_selftest_ops(int cnt)
|
|
{
|
|
int save_ftrace_enabled = ftrace_enabled;
|
|
struct ftrace_ops *dyn_ops;
|
|
char *func1_name;
|
|
char *func2_name;
|
|
int len1;
|
|
int len2;
|
|
int ret = -1;
|
|
|
|
printk(KERN_CONT "PASSED\n");
|
|
pr_info("Testing dynamic ftrace ops #%d: ", cnt);
|
|
|
|
ftrace_enabled = 1;
|
|
reset_counts();
|
|
|
|
/* Handle PPC64 '.' name */
|
|
func1_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
|
|
func2_name = "*" __stringify(DYN_FTRACE_TEST_NAME2);
|
|
len1 = strlen(func1_name);
|
|
len2 = strlen(func2_name);
|
|
|
|
/*
|
|
* Probe 1 will trace function 1.
|
|
* Probe 2 will trace function 2.
|
|
* Probe 3 will trace functions 1 and 2.
|
|
*/
|
|
ftrace_set_filter(&test_probe1, func1_name, len1, 1);
|
|
ftrace_set_filter(&test_probe2, func2_name, len2, 1);
|
|
ftrace_set_filter(&test_probe3, func1_name, len1, 1);
|
|
ftrace_set_filter(&test_probe3, func2_name, len2, 0);
|
|
|
|
register_ftrace_function(&test_probe1);
|
|
register_ftrace_function(&test_probe2);
|
|
register_ftrace_function(&test_probe3);
|
|
register_ftrace_function(&test_global);
|
|
|
|
DYN_FTRACE_TEST_NAME();
|
|
|
|
print_counts();
|
|
|
|
if (trace_selftest_test_probe1_cnt != 1)
|
|
goto out;
|
|
if (trace_selftest_test_probe2_cnt != 0)
|
|
goto out;
|
|
if (trace_selftest_test_probe3_cnt != 1)
|
|
goto out;
|
|
if (trace_selftest_test_global_cnt == 0)
|
|
goto out;
|
|
|
|
DYN_FTRACE_TEST_NAME2();
|
|
|
|
print_counts();
|
|
|
|
if (trace_selftest_test_probe1_cnt != 1)
|
|
goto out;
|
|
if (trace_selftest_test_probe2_cnt != 1)
|
|
goto out;
|
|
if (trace_selftest_test_probe3_cnt != 2)
|
|
goto out;
|
|
|
|
/* Add a dynamic probe */
|
|
dyn_ops = kzalloc(sizeof(*dyn_ops), GFP_KERNEL);
|
|
if (!dyn_ops) {
|
|
printk("MEMORY ERROR ");
|
|
goto out;
|
|
}
|
|
|
|
dyn_ops->func = trace_selftest_test_dyn_func;
|
|
|
|
register_ftrace_function(dyn_ops);
|
|
|
|
trace_selftest_test_global_cnt = 0;
|
|
|
|
DYN_FTRACE_TEST_NAME();
|
|
|
|
print_counts();
|
|
|
|
if (trace_selftest_test_probe1_cnt != 2)
|
|
goto out_free;
|
|
if (trace_selftest_test_probe2_cnt != 1)
|
|
goto out_free;
|
|
if (trace_selftest_test_probe3_cnt != 3)
|
|
goto out_free;
|
|
if (trace_selftest_test_global_cnt == 0)
|
|
goto out;
|
|
if (trace_selftest_test_dyn_cnt == 0)
|
|
goto out_free;
|
|
|
|
DYN_FTRACE_TEST_NAME2();
|
|
|
|
print_counts();
|
|
|
|
if (trace_selftest_test_probe1_cnt != 2)
|
|
goto out_free;
|
|
if (trace_selftest_test_probe2_cnt != 2)
|
|
goto out_free;
|
|
if (trace_selftest_test_probe3_cnt != 4)
|
|
goto out_free;
|
|
|
|
ret = 0;
|
|
out_free:
|
|
unregister_ftrace_function(dyn_ops);
|
|
kfree(dyn_ops);
|
|
|
|
out:
|
|
/* Purposely unregister in the same order */
|
|
unregister_ftrace_function(&test_probe1);
|
|
unregister_ftrace_function(&test_probe2);
|
|
unregister_ftrace_function(&test_probe3);
|
|
unregister_ftrace_function(&test_global);
|
|
|
|
/* Make sure everything is off */
|
|
reset_counts();
|
|
DYN_FTRACE_TEST_NAME();
|
|
DYN_FTRACE_TEST_NAME();
|
|
|
|
if (trace_selftest_test_probe1_cnt ||
|
|
trace_selftest_test_probe2_cnt ||
|
|
trace_selftest_test_probe3_cnt ||
|
|
trace_selftest_test_global_cnt ||
|
|
trace_selftest_test_dyn_cnt)
|
|
ret = -1;
|
|
|
|
ftrace_enabled = save_ftrace_enabled;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Test dynamic code modification and ftrace filters */
|
|
int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
|
|
struct trace_array *tr,
|
|
int (*func)(void))
|
|
{
|
|
int save_ftrace_enabled = ftrace_enabled;
|
|
unsigned long count;
|
|
char *func_name;
|
|
int ret;
|
|
|
|
/* The ftrace test PASSED */
|
|
printk(KERN_CONT "PASSED\n");
|
|
pr_info("Testing dynamic ftrace: ");
|
|
|
|
/* enable tracing, and record the filter function */
|
|
ftrace_enabled = 1;
|
|
|
|
/* passed in by parameter to fool gcc from optimizing */
|
|
func();
|
|
|
|
/*
|
|
* Some archs *cough*PowerPC*cough* add characters to the
|
|
* start of the function names. We simply put a '*' to
|
|
* accommodate them.
|
|
*/
|
|
func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
|
|
|
|
/* filter only on our function */
|
|
ftrace_set_global_filter(func_name, strlen(func_name), 1);
|
|
|
|
/* enable tracing */
|
|
ret = tracer_init(trace, tr);
|
|
if (ret) {
|
|
warn_failed_init_tracer(trace, ret);
|
|
goto out;
|
|
}
|
|
|
|
/* Sleep for a 1/10 of a second */
|
|
msleep(100);
|
|
|
|
/* we should have nothing in the buffer */
|
|
ret = trace_test_buffer(tr, &count);
|
|
if (ret)
|
|
goto out;
|
|
|
|
if (count) {
|
|
ret = -1;
|
|
printk(KERN_CONT ".. filter did not filter .. ");
|
|
goto out;
|
|
}
|
|
|
|
/* call our function again */
|
|
func();
|
|
|
|
/* sleep again */
|
|
msleep(100);
|
|
|
|
/* stop the tracing. */
|
|
tracing_stop();
|
|
ftrace_enabled = 0;
|
|
|
|
/* check the trace buffer */
|
|
ret = trace_test_buffer(tr, &count);
|
|
tracing_start();
|
|
|
|
/* we should only have one item */
|
|
if (!ret && count != 1) {
|
|
trace->reset(tr);
|
|
printk(KERN_CONT ".. filter failed count=%ld ..", count);
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
/* Test the ops with global tracing running */
|
|
ret = trace_selftest_ops(1);
|
|
trace->reset(tr);
|
|
|
|
out:
|
|
ftrace_enabled = save_ftrace_enabled;
|
|
|
|
/* Enable tracing on all functions again */
|
|
ftrace_set_global_filter(NULL, 0, 1);
|
|
|
|
/* Test the ops with global tracing off */
|
|
if (!ret)
|
|
ret = trace_selftest_ops(2);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int trace_selftest_recursion_cnt;
|
|
static void trace_selftest_test_recursion_func(unsigned long ip,
|
|
unsigned long pip,
|
|
struct ftrace_ops *op,
|
|
struct pt_regs *pt_regs)
|
|
{
|
|
/*
|
|
* This function is registered without the recursion safe flag.
|
|
* The ftrace infrastructure should provide the recursion
|
|
* protection. If not, this will crash the kernel!
|
|
*/
|
|
trace_selftest_recursion_cnt++;
|
|
DYN_FTRACE_TEST_NAME();
|
|
}
|
|
|
|
static void trace_selftest_test_recursion_safe_func(unsigned long ip,
|
|
unsigned long pip,
|
|
struct ftrace_ops *op,
|
|
struct pt_regs *pt_regs)
|
|
{
|
|
/*
|
|
* We said we would provide our own recursion. By calling
|
|
* this function again, we should recurse back into this function
|
|
* and count again. But this only happens if the arch supports
|
|
* all of ftrace features and nothing else is using the function
|
|
* tracing utility.
|
|
*/
|
|
if (trace_selftest_recursion_cnt++)
|
|
return;
|
|
DYN_FTRACE_TEST_NAME();
|
|
}
|
|
|
|
static struct ftrace_ops test_rec_probe = {
|
|
.func = trace_selftest_test_recursion_func,
|
|
};
|
|
|
|
static struct ftrace_ops test_recsafe_probe = {
|
|
.func = trace_selftest_test_recursion_safe_func,
|
|
.flags = FTRACE_OPS_FL_RECURSION_SAFE,
|
|
};
|
|
|
|
static int
|
|
trace_selftest_function_recursion(void)
|
|
{
|
|
int save_ftrace_enabled = ftrace_enabled;
|
|
char *func_name;
|
|
int len;
|
|
int ret;
|
|
int cnt;
|
|
|
|
/* The previous test PASSED */
|
|
pr_cont("PASSED\n");
|
|
pr_info("Testing ftrace recursion: ");
|
|
|
|
|
|
/* enable tracing, and record the filter function */
|
|
ftrace_enabled = 1;
|
|
|
|
/* Handle PPC64 '.' name */
|
|
func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
|
|
len = strlen(func_name);
|
|
|
|
ret = ftrace_set_filter(&test_rec_probe, func_name, len, 1);
|
|
if (ret) {
|
|
pr_cont("*Could not set filter* ");
|
|
goto out;
|
|
}
|
|
|
|
ret = register_ftrace_function(&test_rec_probe);
|
|
if (ret) {
|
|
pr_cont("*could not register callback* ");
|
|
goto out;
|
|
}
|
|
|
|
DYN_FTRACE_TEST_NAME();
|
|
|
|
unregister_ftrace_function(&test_rec_probe);
|
|
|
|
ret = -1;
|
|
if (trace_selftest_recursion_cnt != 1) {
|
|
pr_cont("*callback not called once (%d)* ",
|
|
trace_selftest_recursion_cnt);
|
|
goto out;
|
|
}
|
|
|
|
trace_selftest_recursion_cnt = 1;
|
|
|
|
pr_cont("PASSED\n");
|
|
pr_info("Testing ftrace recursion safe: ");
|
|
|
|
ret = ftrace_set_filter(&test_recsafe_probe, func_name, len, 1);
|
|
if (ret) {
|
|
pr_cont("*Could not set filter* ");
|
|
goto out;
|
|
}
|
|
|
|
ret = register_ftrace_function(&test_recsafe_probe);
|
|
if (ret) {
|
|
pr_cont("*could not register callback* ");
|
|
goto out;
|
|
}
|
|
|
|
DYN_FTRACE_TEST_NAME();
|
|
|
|
unregister_ftrace_function(&test_recsafe_probe);
|
|
|
|
/*
|
|
* If arch supports all ftrace features, and no other task
|
|
* was on the list, we should be fine.
|
|
*/
|
|
if (!ftrace_nr_registered_ops() && !FTRACE_FORCE_LIST_FUNC)
|
|
cnt = 2; /* Should have recursed */
|
|
else
|
|
cnt = 1;
|
|
|
|
ret = -1;
|
|
if (trace_selftest_recursion_cnt != cnt) {
|
|
pr_cont("*callback not called expected %d times (%d)* ",
|
|
cnt, trace_selftest_recursion_cnt);
|
|
goto out;
|
|
}
|
|
|
|
ret = 0;
|
|
out:
|
|
ftrace_enabled = save_ftrace_enabled;
|
|
|
|
return ret;
|
|
}
|
|
#else
|
|
# define trace_selftest_startup_dynamic_tracing(trace, tr, func) ({ 0; })
|
|
# define trace_selftest_function_recursion() ({ 0; })
|
|
#endif /* CONFIG_DYNAMIC_FTRACE */
|
|
|
|
static enum {
|
|
TRACE_SELFTEST_REGS_START,
|
|
TRACE_SELFTEST_REGS_FOUND,
|
|
TRACE_SELFTEST_REGS_NOT_FOUND,
|
|
} trace_selftest_regs_stat;
|
|
|
|
static void trace_selftest_test_regs_func(unsigned long ip,
|
|
unsigned long pip,
|
|
struct ftrace_ops *op,
|
|
struct pt_regs *pt_regs)
|
|
{
|
|
if (pt_regs)
|
|
trace_selftest_regs_stat = TRACE_SELFTEST_REGS_FOUND;
|
|
else
|
|
trace_selftest_regs_stat = TRACE_SELFTEST_REGS_NOT_FOUND;
|
|
}
|
|
|
|
static struct ftrace_ops test_regs_probe = {
|
|
.func = trace_selftest_test_regs_func,
|
|
.flags = FTRACE_OPS_FL_RECURSION_SAFE | FTRACE_OPS_FL_SAVE_REGS,
|
|
};
|
|
|
|
static int
|
|
trace_selftest_function_regs(void)
|
|
{
|
|
int save_ftrace_enabled = ftrace_enabled;
|
|
char *func_name;
|
|
int len;
|
|
int ret;
|
|
int supported = 0;
|
|
|
|
#ifdef ARCH_SUPPORTS_FTRACE_SAVE_REGS
|
|
supported = 1;
|
|
#endif
|
|
|
|
/* The previous test PASSED */
|
|
pr_cont("PASSED\n");
|
|
pr_info("Testing ftrace regs%s: ",
|
|
!supported ? "(no arch support)" : "");
|
|
|
|
/* enable tracing, and record the filter function */
|
|
ftrace_enabled = 1;
|
|
|
|
/* Handle PPC64 '.' name */
|
|
func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
|
|
len = strlen(func_name);
|
|
|
|
ret = ftrace_set_filter(&test_regs_probe, func_name, len, 1);
|
|
/*
|
|
* If DYNAMIC_FTRACE is not set, then we just trace all functions.
|
|
* This test really doesn't care.
|
|
*/
|
|
if (ret && ret != -ENODEV) {
|
|
pr_cont("*Could not set filter* ");
|
|
goto out;
|
|
}
|
|
|
|
ret = register_ftrace_function(&test_regs_probe);
|
|
/*
|
|
* Now if the arch does not support passing regs, then this should
|
|
* have failed.
|
|
*/
|
|
if (!supported) {
|
|
if (!ret) {
|
|
pr_cont("*registered save-regs without arch support* ");
|
|
goto out;
|
|
}
|
|
test_regs_probe.flags |= FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED;
|
|
ret = register_ftrace_function(&test_regs_probe);
|
|
}
|
|
if (ret) {
|
|
pr_cont("*could not register callback* ");
|
|
goto out;
|
|
}
|
|
|
|
|
|
DYN_FTRACE_TEST_NAME();
|
|
|
|
unregister_ftrace_function(&test_regs_probe);
|
|
|
|
ret = -1;
|
|
|
|
switch (trace_selftest_regs_stat) {
|
|
case TRACE_SELFTEST_REGS_START:
|
|
pr_cont("*callback never called* ");
|
|
goto out;
|
|
|
|
case TRACE_SELFTEST_REGS_FOUND:
|
|
if (supported)
|
|
break;
|
|
pr_cont("*callback received regs without arch support* ");
|
|
goto out;
|
|
|
|
case TRACE_SELFTEST_REGS_NOT_FOUND:
|
|
if (!supported)
|
|
break;
|
|
pr_cont("*callback received NULL regs* ");
|
|
goto out;
|
|
}
|
|
|
|
ret = 0;
|
|
out:
|
|
ftrace_enabled = save_ftrace_enabled;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Simple verification test of ftrace function tracer.
|
|
* Enable ftrace, sleep 1/10 second, and then read the trace
|
|
* buffer to see if all is in order.
|
|
*/
|
|
int
|
|
trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
|
|
{
|
|
int save_ftrace_enabled = ftrace_enabled;
|
|
unsigned long count;
|
|
int ret;
|
|
|
|
/* make sure msleep has been recorded */
|
|
msleep(1);
|
|
|
|
/* start the tracing */
|
|
ftrace_enabled = 1;
|
|
|
|
ret = tracer_init(trace, tr);
|
|
if (ret) {
|
|
warn_failed_init_tracer(trace, ret);
|
|
goto out;
|
|
}
|
|
|
|
/* Sleep for a 1/10 of a second */
|
|
msleep(100);
|
|
/* stop the tracing. */
|
|
tracing_stop();
|
|
ftrace_enabled = 0;
|
|
|
|
/* check the trace buffer */
|
|
ret = trace_test_buffer(tr, &count);
|
|
trace->reset(tr);
|
|
tracing_start();
|
|
|
|
if (!ret && !count) {
|
|
printk(KERN_CONT ".. no entries found ..");
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
ret = trace_selftest_startup_dynamic_tracing(trace, tr,
|
|
DYN_FTRACE_TEST_NAME);
|
|
if (ret)
|
|
goto out;
|
|
|
|
ret = trace_selftest_function_recursion();
|
|
if (ret)
|
|
goto out;
|
|
|
|
ret = trace_selftest_function_regs();
|
|
out:
|
|
ftrace_enabled = save_ftrace_enabled;
|
|
|
|
/* kill ftrace totally if we failed */
|
|
if (ret)
|
|
ftrace_kill();
|
|
|
|
return ret;
|
|
}
|
|
#endif /* CONFIG_FUNCTION_TRACER */
|
|
|
|
|
|
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
|
|
|
|
/* Maximum number of functions to trace before diagnosing a hang */
|
|
#define GRAPH_MAX_FUNC_TEST 100000000
|
|
|
|
static void
|
|
__ftrace_dump(bool disable_tracing, enum ftrace_dump_mode oops_dump_mode);
|
|
static unsigned int graph_hang_thresh;
|
|
|
|
/* Wrap the real function entry probe to avoid possible hanging */
|
|
static int trace_graph_entry_watchdog(struct ftrace_graph_ent *trace)
|
|
{
|
|
/* This is harmlessly racy, we want to approximately detect a hang */
|
|
if (unlikely(++graph_hang_thresh > GRAPH_MAX_FUNC_TEST)) {
|
|
ftrace_graph_stop();
|
|
printk(KERN_WARNING "BUG: Function graph tracer hang!\n");
|
|
if (ftrace_dump_on_oops)
|
|
__ftrace_dump(false, DUMP_ALL);
|
|
return 0;
|
|
}
|
|
|
|
return trace_graph_entry(trace);
|
|
}
|
|
|
|
/*
|
|
* Pretty much the same than for the function tracer from which the selftest
|
|
* has been borrowed.
|
|
*/
|
|
int
|
|
trace_selftest_startup_function_graph(struct tracer *trace,
|
|
struct trace_array *tr)
|
|
{
|
|
int ret;
|
|
unsigned long count;
|
|
|
|
/*
|
|
* Simulate the init() callback but we attach a watchdog callback
|
|
* to detect and recover from possible hangs
|
|
*/
|
|
tracing_reset_online_cpus(tr);
|
|
set_graph_array(tr);
|
|
ret = register_ftrace_graph(&trace_graph_return,
|
|
&trace_graph_entry_watchdog);
|
|
if (ret) {
|
|
warn_failed_init_tracer(trace, ret);
|
|
goto out;
|
|
}
|
|
tracing_start_cmdline_record();
|
|
|
|
/* Sleep for a 1/10 of a second */
|
|
msleep(100);
|
|
|
|
/* Have we just recovered from a hang? */
|
|
if (graph_hang_thresh > GRAPH_MAX_FUNC_TEST) {
|
|
tracing_selftest_disabled = true;
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
tracing_stop();
|
|
|
|
/* check the trace buffer */
|
|
ret = trace_test_buffer(tr, &count);
|
|
|
|
trace->reset(tr);
|
|
tracing_start();
|
|
|
|
if (!ret && !count) {
|
|
printk(KERN_CONT ".. no entries found ..");
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
/* Don't test dynamic tracing, the function tracer already did */
|
|
|
|
out:
|
|
/* Stop it if we failed */
|
|
if (ret)
|
|
ftrace_graph_stop();
|
|
|
|
return ret;
|
|
}
|
|
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
|
|
|
|
|
|
#ifdef CONFIG_IRQSOFF_TRACER
|
|
int
|
|
trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
|
|
{
|
|
unsigned long save_max = tracing_max_latency;
|
|
unsigned long count;
|
|
int ret;
|
|
|
|
/* start the tracing */
|
|
ret = tracer_init(trace, tr);
|
|
if (ret) {
|
|
warn_failed_init_tracer(trace, ret);
|
|
return ret;
|
|
}
|
|
|
|
/* reset the max latency */
|
|
tracing_max_latency = 0;
|
|
/* disable interrupts for a bit */
|
|
local_irq_disable();
|
|
udelay(100);
|
|
local_irq_enable();
|
|
|
|
/*
|
|
* Stop the tracer to avoid a warning subsequent
|
|
* to buffer flipping failure because tracing_stop()
|
|
* disables the tr and max buffers, making flipping impossible
|
|
* in case of parallels max irqs off latencies.
|
|
*/
|
|
trace->stop(tr);
|
|
/* stop the tracing. */
|
|
tracing_stop();
|
|
/* check both trace buffers */
|
|
ret = trace_test_buffer(tr, NULL);
|
|
if (!ret)
|
|
ret = trace_test_buffer(&max_tr, &count);
|
|
trace->reset(tr);
|
|
tracing_start();
|
|
|
|
if (!ret && !count) {
|
|
printk(KERN_CONT ".. no entries found ..");
|
|
ret = -1;
|
|
}
|
|
|
|
tracing_max_latency = save_max;
|
|
|
|
return ret;
|
|
}
|
|
#endif /* CONFIG_IRQSOFF_TRACER */
|
|
|
|
#ifdef CONFIG_PREEMPT_TRACER
|
|
int
|
|
trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
|
|
{
|
|
unsigned long save_max = tracing_max_latency;
|
|
unsigned long count;
|
|
int ret;
|
|
|
|
/*
|
|
* Now that the big kernel lock is no longer preemptable,
|
|
* and this is called with the BKL held, it will always
|
|
* fail. If preemption is already disabled, simply
|
|
* pass the test. When the BKL is removed, or becomes
|
|
* preemptible again, we will once again test this,
|
|
* so keep it in.
|
|
*/
|
|
if (preempt_count()) {
|
|
printk(KERN_CONT "can not test ... force ");
|
|
return 0;
|
|
}
|
|
|
|
/* start the tracing */
|
|
ret = tracer_init(trace, tr);
|
|
if (ret) {
|
|
warn_failed_init_tracer(trace, ret);
|
|
return ret;
|
|
}
|
|
|
|
/* reset the max latency */
|
|
tracing_max_latency = 0;
|
|
/* disable preemption for a bit */
|
|
preempt_disable();
|
|
udelay(100);
|
|
preempt_enable();
|
|
|
|
/*
|
|
* Stop the tracer to avoid a warning subsequent
|
|
* to buffer flipping failure because tracing_stop()
|
|
* disables the tr and max buffers, making flipping impossible
|
|
* in case of parallels max preempt off latencies.
|
|
*/
|
|
trace->stop(tr);
|
|
/* stop the tracing. */
|
|
tracing_stop();
|
|
/* check both trace buffers */
|
|
ret = trace_test_buffer(tr, NULL);
|
|
if (!ret)
|
|
ret = trace_test_buffer(&max_tr, &count);
|
|
trace->reset(tr);
|
|
tracing_start();
|
|
|
|
if (!ret && !count) {
|
|
printk(KERN_CONT ".. no entries found ..");
|
|
ret = -1;
|
|
}
|
|
|
|
tracing_max_latency = save_max;
|
|
|
|
return ret;
|
|
}
|
|
#endif /* CONFIG_PREEMPT_TRACER */
|
|
|
|
#if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER)
|
|
int
|
|
trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *tr)
|
|
{
|
|
unsigned long save_max = tracing_max_latency;
|
|
unsigned long count;
|
|
int ret;
|
|
|
|
/*
|
|
* Now that the big kernel lock is no longer preemptable,
|
|
* and this is called with the BKL held, it will always
|
|
* fail. If preemption is already disabled, simply
|
|
* pass the test. When the BKL is removed, or becomes
|
|
* preemptible again, we will once again test this,
|
|
* so keep it in.
|
|
*/
|
|
if (preempt_count()) {
|
|
printk(KERN_CONT "can not test ... force ");
|
|
return 0;
|
|
}
|
|
|
|
/* start the tracing */
|
|
ret = tracer_init(trace, tr);
|
|
if (ret) {
|
|
warn_failed_init_tracer(trace, ret);
|
|
goto out_no_start;
|
|
}
|
|
|
|
/* reset the max latency */
|
|
tracing_max_latency = 0;
|
|
|
|
/* disable preemption and interrupts for a bit */
|
|
preempt_disable();
|
|
local_irq_disable();
|
|
udelay(100);
|
|
preempt_enable();
|
|
/* reverse the order of preempt vs irqs */
|
|
local_irq_enable();
|
|
|
|
/*
|
|
* Stop the tracer to avoid a warning subsequent
|
|
* to buffer flipping failure because tracing_stop()
|
|
* disables the tr and max buffers, making flipping impossible
|
|
* in case of parallels max irqs/preempt off latencies.
|
|
*/
|
|
trace->stop(tr);
|
|
/* stop the tracing. */
|
|
tracing_stop();
|
|
/* check both trace buffers */
|
|
ret = trace_test_buffer(tr, NULL);
|
|
if (ret)
|
|
goto out;
|
|
|
|
ret = trace_test_buffer(&max_tr, &count);
|
|
if (ret)
|
|
goto out;
|
|
|
|
if (!ret && !count) {
|
|
printk(KERN_CONT ".. no entries found ..");
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
/* do the test by disabling interrupts first this time */
|
|
tracing_max_latency = 0;
|
|
tracing_start();
|
|
trace->start(tr);
|
|
|
|
preempt_disable();
|
|
local_irq_disable();
|
|
udelay(100);
|
|
preempt_enable();
|
|
/* reverse the order of preempt vs irqs */
|
|
local_irq_enable();
|
|
|
|
trace->stop(tr);
|
|
/* stop the tracing. */
|
|
tracing_stop();
|
|
/* check both trace buffers */
|
|
ret = trace_test_buffer(tr, NULL);
|
|
if (ret)
|
|
goto out;
|
|
|
|
ret = trace_test_buffer(&max_tr, &count);
|
|
|
|
if (!ret && !count) {
|
|
printk(KERN_CONT ".. no entries found ..");
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
out:
|
|
tracing_start();
|
|
out_no_start:
|
|
trace->reset(tr);
|
|
tracing_max_latency = save_max;
|
|
|
|
return ret;
|
|
}
|
|
#endif /* CONFIG_IRQSOFF_TRACER && CONFIG_PREEMPT_TRACER */
|
|
|
|
#ifdef CONFIG_NOP_TRACER
|
|
int
|
|
trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)
|
|
{
|
|
/* What could possibly go wrong? */
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_SCHED_TRACER
|
|
static int trace_wakeup_test_thread(void *data)
|
|
{
|
|
/* Make this a RT thread, doesn't need to be too high */
|
|
static const struct sched_param param = { .sched_priority = 5 };
|
|
struct completion *x = data;
|
|
|
|
sched_setscheduler(current, SCHED_FIFO, ¶m);
|
|
|
|
/* Make it know we have a new prio */
|
|
complete(x);
|
|
|
|
/* now go to sleep and let the test wake us up */
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
schedule();
|
|
|
|
complete(x);
|
|
|
|
/* we are awake, now wait to disappear */
|
|
while (!kthread_should_stop()) {
|
|
/*
|
|
* This is an RT task, do short sleeps to let
|
|
* others run.
|
|
*/
|
|
msleep(100);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
|
|
{
|
|
unsigned long save_max = tracing_max_latency;
|
|
struct task_struct *p;
|
|
struct completion isrt;
|
|
unsigned long count;
|
|
int ret;
|
|
|
|
init_completion(&isrt);
|
|
|
|
/* create a high prio thread */
|
|
p = kthread_run(trace_wakeup_test_thread, &isrt, "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 an RT prio */
|
|
wait_for_completion(&isrt);
|
|
|
|
/* start the tracing */
|
|
ret = tracer_init(trace, tr);
|
|
if (ret) {
|
|
warn_failed_init_tracer(trace, ret);
|
|
return ret;
|
|
}
|
|
|
|
/* reset the max latency */
|
|
tracing_max_latency = 0;
|
|
|
|
while (p->on_rq) {
|
|
/*
|
|
* Sleep to make sure the RT thread is asleep too.
|
|
* On virtual machines we can't rely on timings,
|
|
* but we want to make sure this test still works.
|
|
*/
|
|
msleep(100);
|
|
}
|
|
|
|
init_completion(&isrt);
|
|
|
|
wake_up_process(p);
|
|
|
|
/* Wait for the task to wake up */
|
|
wait_for_completion(&isrt);
|
|
|
|
/* stop the tracing. */
|
|
tracing_stop();
|
|
/* check both trace buffers */
|
|
ret = trace_test_buffer(tr, NULL);
|
|
printk("ret = %d\n", ret);
|
|
if (!ret)
|
|
ret = trace_test_buffer(&max_tr, &count);
|
|
|
|
|
|
trace->reset(tr);
|
|
tracing_start();
|
|
|
|
tracing_max_latency = save_max;
|
|
|
|
/* kill the thread */
|
|
kthread_stop(p);
|
|
|
|
if (!ret && !count) {
|
|
printk(KERN_CONT ".. no entries found ..");
|
|
ret = -1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif /* CONFIG_SCHED_TRACER */
|
|
|
|
#ifdef CONFIG_CONTEXT_SWITCH_TRACER
|
|
int
|
|
trace_selftest_startup_sched_switch(struct tracer *trace, struct trace_array *tr)
|
|
{
|
|
unsigned long count;
|
|
int ret;
|
|
|
|
/* start the tracing */
|
|
ret = tracer_init(trace, tr);
|
|
if (ret) {
|
|
warn_failed_init_tracer(trace, ret);
|
|
return ret;
|
|
}
|
|
|
|
/* Sleep for a 1/10 of a second */
|
|
msleep(100);
|
|
/* stop the tracing. */
|
|
tracing_stop();
|
|
/* check the trace buffer */
|
|
ret = trace_test_buffer(tr, &count);
|
|
trace->reset(tr);
|
|
tracing_start();
|
|
|
|
if (!ret && !count) {
|
|
printk(KERN_CONT ".. no entries found ..");
|
|
ret = -1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif /* CONFIG_CONTEXT_SWITCH_TRACER */
|
|
|
|
#ifdef CONFIG_BRANCH_TRACER
|
|
int
|
|
trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr)
|
|
{
|
|
unsigned long count;
|
|
int ret;
|
|
|
|
/* start the tracing */
|
|
ret = tracer_init(trace, tr);
|
|
if (ret) {
|
|
warn_failed_init_tracer(trace, ret);
|
|
return ret;
|
|
}
|
|
|
|
/* Sleep for a 1/10 of a second */
|
|
msleep(100);
|
|
/* stop the tracing. */
|
|
tracing_stop();
|
|
/* check the trace buffer */
|
|
ret = trace_test_buffer(tr, &count);
|
|
trace->reset(tr);
|
|
tracing_start();
|
|
|
|
if (!ret && !count) {
|
|
printk(KERN_CONT ".. no entries found ..");
|
|
ret = -1;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif /* CONFIG_BRANCH_TRACER */
|
|
|