tracing/filters: Defer pred allocation

[linux-2.6/mini2440.git] / kernel / trace / trace_selftest.c

/* Include in trace.c */

#include <linux/stringify.h>
#include <linux/kthread.h>
#include <linux/delay.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_SPECIAL:
        case TRACE_BRANCH:
        case TRACE_GRAPH_ENT:
        case TRACE_GRAPH_RET:
        case TRACE_HW_BRANCHES:
                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))) {
                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);
        __raw_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();
        __raw_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

/* 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;
        int save_tracer_enabled = tracer_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;
        tracer_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_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);
        trace->reset(tr);
        tracing_start();

        /* we should only have one item */
        if (!ret && count != 1) {
                printk(KERN_CONT ".. filter failed count=%ld ..", count);
                ret = -1;
                goto out;
        }

 out:
        ftrace_enabled = save_ftrace_enabled;
        tracer_enabled = save_tracer_enabled;

        /* Enable tracing on all functions again */
        ftrace_set_filter(NULL, 0, 1);

        return ret;
}
#else
# define trace_selftest_startup_dynamic_tracing(trace, tr, func) ({ 0; })
#endif /* CONFIG_DYNAMIC_FTRACE */

/*
 * 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;
        int save_tracer_enabled = tracer_enabled;
        unsigned long count;
        int ret;

        /* make sure msleep has been recorded */
        msleep(1);

        /* start the tracing */
        ftrace_enabled = 1;
        tracer_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);

 out:
        ftrace_enabled = save_ftrace_enabled;
        tracer_enabled = save_tracer_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);
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);
                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 */
        struct sched_param param = { .sched_priority = 5 };
        struct completion *x = data;

        sched_setscheduler(current, SCHED_FIFO, &param);

        /* 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();

        /* 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;

        /* sleep to let the RT thread sleep too */
        msleep(100);

        /*
         * Yes this is slightly racy. It is possible that for some
         * strange reason that the RT thread we created, did not
         * call schedule for 100ms after doing the completion,
         * and we do a wakeup on a task that already is awake.
         * But that is extremely unlikely, and the worst thing that
         * happens in such a case, is that we disable tracing.
         * Honestly, if this race does happen something is horrible
         * wrong with the system.
         */

        wake_up_process(p);

        /* give a little time to let the thread wake up */
        msleep(100);

        /* 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();

        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_SYSPROF_TRACER
int
trace_selftest_startup_sysprof(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_SYSPROF_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 */

#ifdef CONFIG_HW_BRANCH_TRACER
int
trace_selftest_startup_hw_branches(struct tracer *trace,
                                   struct trace_array *tr)
{
        struct trace_iterator *iter;
        struct tracer tracer;
        unsigned long count;
        int ret;

        if (!trace->open) {
                printk(KERN_CONT "missing open function...");
                return -1;
        }

        ret = tracer_init(trace, tr);
        if (ret) {
                warn_failed_init_tracer(trace, ret);
                return ret;
        }

        /*
         * The hw-branch tracer needs to collect the trace from the various
         * cpu trace buffers - before tracing is stopped.
         */
        iter = kzalloc(sizeof(*iter), GFP_KERNEL);
        if (!iter)
                return -ENOMEM;

        memcpy(&tracer, trace, sizeof(tracer));

        iter->trace = &tracer;
        iter->tr = tr;
        iter->pos = -1;
        mutex_init(&iter->mutex);

        trace->open(iter);

        mutex_destroy(&iter->mutex);
        kfree(iter);

        tracing_stop();

        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_HW_BRANCH_TRACER */