linux-imx

// SPDX-License-Identifier: GPL-2.0

/*

 * Infrastructure to took into function calls and returns.

 * Copyright (c) 2008-2009 Frederic Weisbecker <fweisbec@gmail.com>

 * Mostly borrowed from function tracer which

 * is Copyright (c) Steven Rostedt <srostedt@redhat.com>

 *

 * Highly modified by Steven Rostedt (VMware).

 */

#include <linux/suspend.h>

#include <linux/ftrace.h>

#include <linux/slab.h>

​

#include <trace/events/sched.h>

​

#include "ftrace_internal.h"

​

#ifdef CONFIG_DYNAMIC_FTRACE

#define ASSIGN_OPS_HASH(opsname, val) \

    .func_hash      = val, \

    .local_hash.regex_lock  = __MUTEX_INITIALIZER(opsname.local_hash.regex_lock),

#else

#define ASSIGN_OPS_HASH(opsname, val)

#endif

​

static bool kill_ftrace_graph;

int ftrace_graph_active;

​

/* Both enabled by default (can be cleared by function_graph tracer flags */

static bool fgraph_sleep_time = true;

​

/**

 * ftrace_graph_is_dead - returns true if ftrace_graph_stop() was called

 *

 * ftrace_graph_stop() is called when a severe error is detected in

 * the function graph tracing. This function is called by the critical

 * paths of function graph to keep those paths from doing any more harm.

 */

bool ftrace_graph_is_dead(void)

{

    return kill_ftrace_graph;

}

​

/**

 * ftrace_graph_stop - set to permanently disable function graph tracincg

 *

 * In case of an error int function graph tracing, this is called

 * to try to keep function graph tracing from causing any more harm.

 * Usually this is pretty severe and this is called to try to at least

 * get a warning out to the user.

 */

void ftrace_graph_stop(void)

{

    kill_ftrace_graph = true;

}

​

/* Add a function return address to the trace stack on thread info.*/

static int

ftrace_push_return_trace(unsigned long ret, unsigned long func,

             unsigned long frame_pointer, unsigned long *retp)

{

    unsigned long long calltime;

    int index;

​

    if (unlikely(ftrace_graph_is_dead()))

        return -EBUSY;

​

    if (!current->ret_stack)

        return -EBUSY;

​

    /*

     * We must make sure the ret_stack is tested before we read

     * anything else.

     */

    smp_rmb();

​

    /* The return trace stack is full */

    if (current->curr_ret_stack == FTRACE_RETFUNC_DEPTH - 1) {

        atomic_inc(&current->trace_overrun);

        return -EBUSY;

    }

​

    calltime = trace_clock_local();

​

    index = ++current->curr_ret_stack;

    barrier();

    current->ret_stack[index].ret = ret;

    current->ret_stack[index].func = func;

    current->ret_stack[index].calltime = calltime;

#ifdef HAVE_FUNCTION_GRAPH_FP_TEST

    current->ret_stack[index].fp = frame_pointer;

#endif