linux-imx

// SPDX-License-Identifier: GPL-2.0

/*

 * unlikely profiler

 *

 * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>

 */

#include <linux/kallsyms.h>

#include <linux/seq_file.h>

#include <linux/spinlock.h>

#include <linux/irqflags.h>

#include <linux/uaccess.h>

#include <linux/module.h>

#include <linux/ftrace.h>

#include <linux/hash.h>

#include <linux/fs.h>

#include <asm/local.h>

​

#include "trace.h"

#include "trace_stat.h"

#include "trace_output.h"

​

#ifdef CONFIG_BRANCH_TRACER

​

static struct tracer branch_trace;

static int branch_tracing_enabled __read_mostly;

static DEFINE_MUTEX(branch_tracing_mutex);

​

static struct trace_array *branch_tracer;

​

static void

probe_likely_condition(struct ftrace_likely_data *f, int val, int expect)

{

    struct trace_event_call *call = &event_branch;

    struct trace_array *tr = branch_tracer;

    struct trace_array_cpu *data;

    struct ring_buffer_event *event;

    struct trace_branch *entry;

    struct ring_buffer *buffer;

    unsigned long flags;

    int pc;

    const char *p;

​

    if (current->trace_recursion & TRACE_BRANCH_BIT)

        return;

​

    /*

     * I would love to save just the ftrace_likely_data pointer, but

     * this code can also be used by modules. Ugly things can happen

     * if the module is unloaded, and then we go and read the

     * pointer.  This is slower, but much safer.

     */

​

    if (unlikely(!tr))

        return;

​

    raw_local_irq_save(flags);

    current->trace_recursion |= TRACE_BRANCH_BIT;

    data = this_cpu_ptr(tr->trace_buffer.data);

    if (atomic_read(&data->disabled))

        goto out;

​

    pc = preempt_count();

    buffer = tr->trace_buffer.buffer;

    event = trace_buffer_lock_reserve(buffer, TRACE_BRANCH,

                      sizeof(*entry), flags, pc);

    if (!event)

        goto out;

​

    entry   = ring_buffer_event_data(event);

​

    /* Strip off the path, only save the file */

    p = f->data.file + strlen(f->data.file);

    while (p >= f->data.file && *p != '/')

        p--;

    p++;

​

    strncpy(entry->func, f->data.func, TRACE_FUNC_SIZE);

    strncpy(entry->file, p, TRACE_FILE_SIZE);

    entry->func[TRACE_FUNC_SIZE] = 0;

    entry->file[TRACE_FILE_SIZE] = 0;

    entry->constant = f->constant;

    entry->line = f->data.line;

    entry->correct = val == expect;

​

    if (!call_filter_check_discard(call, entry, buffer, event))

        trace_buffer_unlock_commit_nostack(buffer, event);

​

 out:

    current->trace_recursion &= ~TRACE_BRANCH_BIT;

    raw_local_irq_restore(flags);

}

​