[deliverable/linux.git] / kernel / trace / trace_functions.c

/*
 * ring buffer based function tracer
 *
 * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
 * Copyright (C) 2008 Ingo Molnar <mingo@redhat.com>
 *
 * Based on code from the latency_tracer, that is:
 *
 *  Copyright (C) 2004-2006 Ingo Molnar
 *  Copyright (C) 2004 Nadia Yvette Chambers
 */
#include <linux/ring_buffer.h>
#include <linux/debugfs.h>
#include <linux/uaccess.h>
#include <linux/ftrace.h>
#include <linux/slab.h>
#include <linux/fs.h>

#include "trace.h"

static void tracing_start_function_trace(struct trace_array *tr);
static void tracing_stop_function_trace(struct trace_array *tr);
static void
function_trace_call(unsigned long ip, unsigned long parent_ip,
		    struct ftrace_ops *op, struct pt_regs *pt_regs);
static void
function_stack_trace_call(unsigned long ip, unsigned long parent_ip,
			  struct ftrace_ops *op, struct pt_regs *pt_regs);
static struct tracer_flags func_flags;

/* Our option */
enum {
	TRACE_FUNC_OPT_STACK	= 0x1,
};

static int allocate_ftrace_ops(struct trace_array *tr)
{
	struct ftrace_ops *ops;

	ops = kzalloc(sizeof(*ops), GFP_KERNEL);
	if (!ops)
		return -ENOMEM;

	/* Currently only the non stack verision is supported */
	ops->func = function_trace_call;
	ops->flags = FTRACE_OPS_FL_RECURSION_SAFE;

	tr->ops = ops;
	ops->private = tr;
	return 0;
}


int ftrace_create_function_files(struct trace_array *tr,
				 struct dentry *parent)
{
	int ret;

	/*
	 * The top level array uses the "global_ops", and the files are
	 * created on boot up.
	 */
	if (tr->flags & TRACE_ARRAY_FL_GLOBAL)
		return 0;

	ret = allocate_ftrace_ops(tr);
	if (ret)
		return ret;

	ftrace_create_filter_files(tr->ops, parent);

	return 0;
}

void ftrace_destroy_function_files(struct trace_array *tr)
{
	ftrace_destroy_filter_files(tr->ops);
	kfree(tr->ops);
	tr->ops = NULL;
}

static int function_trace_init(struct trace_array *tr)
{
	ftrace_func_t func;

	/*
	 * Instance trace_arrays get their ops allocated
	 * at instance creation. Unless it failed
	 * the allocation.
	 */
	if (!tr->ops)
		return -ENOMEM;

	/* Currently only the global instance can do stack tracing */
	if (tr->flags & TRACE_ARRAY_FL_GLOBAL &&
	    func_flags.val & TRACE_FUNC_OPT_STACK)
		func = function_stack_trace_call;
	else
		func = function_trace_call;

	ftrace_init_array_ops(tr, func);

	tr->trace_buffer.cpu = get_cpu();
	put_cpu();

	tracing_start_cmdline_record();
	tracing_start_function_trace(tr);
	return 0;
}

static void function_trace_reset(struct trace_array *tr)
{
	tracing_stop_function_trace(tr);
	tracing_stop_cmdline_record();
	ftrace_reset_array_ops(tr);
}

static void function_trace_start(struct trace_array *tr)
{
	tracing_reset_online_cpus(&tr->trace_buffer);
}

static void
function_trace_call(unsigned long ip, unsigned long parent_ip,
		    struct ftrace_ops *op, struct pt_regs *pt_regs)
{
	struct trace_array *tr = op->private;
	struct trace_array_cpu *data;
	unsigned long flags;
	int bit;
	int cpu;
	int pc;

	if (unlikely(!tr->function_enabled))
		return;

	pc = preempt_count();
	preempt_disable_notrace();

	bit = trace_test_and_set_recursion(TRACE_FTRACE_START, TRACE_FTRACE_MAX);
	if (bit < 0)
		goto out;

	cpu = smp_processor_id();
	data = per_cpu_ptr(tr->trace_buffer.data, cpu);
	if (!atomic_read(&data->disabled)) {
		local_save_flags(flags);
		trace_function(tr, ip, parent_ip, flags, pc);
	}
	trace_clear_recursion(bit);

 out:
	preempt_enable_notrace();
}

static void
function_stack_trace_call(unsigned long ip, unsigned long parent_ip,
			  struct ftrace_ops *op, struct pt_regs *pt_regs)
{
	struct trace_array *tr = op->private;
	struct trace_array_cpu *data;
	unsigned long flags;
	long disabled;
	int cpu;
	int pc;

	if (unlikely(!tr->function_enabled))
		return;

	/*
	 * Need to use raw, since this must be called before the
	 * recursive protection is performed.
	 */
	local_irq_save(flags);
	cpu = raw_smp_processor_id();
	data = per_cpu_ptr(tr->trace_buffer.data, cpu);
	disabled = atomic_inc_return(&data->disabled);

	if (likely(disabled == 1)) {
		pc = preempt_count();
		trace_function(tr, ip, parent_ip, flags, pc);
		/*
		 * skip over 5 funcs:
		 *    __ftrace_trace_stack,
		 *    __trace_stack,
		 *    function_stack_trace_call
		 *    ftrace_list_func
		 *    ftrace_call
		 */
		__trace_stack(tr, flags, 5, pc);
	}

	atomic_dec(&data->disabled);
	local_irq_restore(flags);
}

static struct tracer_opt func_opts[] = {
#ifdef CONFIG_STACKTRACE
	{ TRACER_OPT(func_stack_trace, TRACE_FUNC_OPT_STACK) },
#endif
	{ } /* Always set a last empty entry */
};

static struct tracer_flags func_flags = {
	.val = 0, /* By default: all flags disabled */
	.opts = func_opts
};

static void tracing_start_function_trace(struct trace_array *tr)
{
	tr->function_enabled = 0;
	register_ftrace_function(tr->ops);
	tr->function_enabled = 1;
}

static void tracing_stop_function_trace(struct trace_array *tr)
{
	tr->function_enabled = 0;
	unregister_ftrace_function(tr->ops);
}

static int
func_set_flag(struct trace_array *tr, u32 old_flags, u32 bit, int set)
{
	switch (bit) {
	case TRACE_FUNC_OPT_STACK:
		/* do nothing if already set */
		if (!!set == !!(func_flags.val & TRACE_FUNC_OPT_STACK))
			break;

		unregister_ftrace_function(tr->ops);

		if (set) {
			tr->ops->func = function_stack_trace_call;
			register_ftrace_function(tr->ops);
		} else {
			tr->ops->func = function_trace_call;
			register_ftrace_function(tr->ops);
		}

		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static struct tracer function_trace __tracer_data =
{
	.name		= "function",
	.init		= function_trace_init,
	.reset		= function_trace_reset,
	.start		= function_trace_start,
	.flags		= &func_flags,
	.set_flag	= func_set_flag,
	.allow_instances = true,
#ifdef CONFIG_FTRACE_SELFTEST
	.selftest	= trace_selftest_startup_function,
#endif
};

#ifdef CONFIG_DYNAMIC_FTRACE
static int update_count(void **data)
{
	unsigned long *count = (long *)data;

	if (!*count)
		return 0;

	if (*count != -1)
		(*count)--;

	return 1;
}

static void
ftrace_traceon_count(unsigned long ip, unsigned long parent_ip, void **data)
{
	if (tracing_is_on())
		return;

	if (update_count(data))
		tracing_on();
}

static void
ftrace_traceoff_count(unsigned long ip, unsigned long parent_ip, void **data)
{
	if (!tracing_is_on())
		return;

	if (update_count(data))
		tracing_off();
}

static void
ftrace_traceon(unsigned long ip, unsigned long parent_ip, void **data)
{
	if (tracing_is_on())
		return;

	tracing_on();
}

static void
ftrace_traceoff(unsigned long ip, unsigned long parent_ip, void **data)
{
	if (!tracing_is_on())
		return;

	tracing_off();
}

/*
 * Skip 4:
 *   ftrace_stacktrace()
 *   function_trace_probe_call()
 *   ftrace_ops_list_func()
 *   ftrace_call()
 */
#define STACK_SKIP 4

static void
ftrace_stacktrace(unsigned long ip, unsigned long parent_ip, void **data)
{
	trace_dump_stack(STACK_SKIP);
}

static void
ftrace_stacktrace_count(unsigned long ip, unsigned long parent_ip, void **data)
{
	if (!tracing_is_on())
		return;

	if (update_count(data))
		trace_dump_stack(STACK_SKIP);
}

static void
ftrace_dump_probe(unsigned long ip, unsigned long parent_ip, void **data)
{
	if (update_count(data))
		ftrace_dump(DUMP_ALL);
}

/* Only dump the current CPU buffer. */
static void
ftrace_cpudump_probe(unsigned long ip, unsigned long parent_ip, void **data)
{
	if (update_count(data))
		ftrace_dump(DUMP_ORIG);
}

static int
ftrace_probe_print(const char *name, struct seq_file *m,
		   unsigned long ip, void *data)
{
	long count = (long)data;

	seq_printf(m, "%ps:%s", (void *)ip, name);

	if (count == -1)
		seq_printf(m, ":unlimited\n");
	else
		seq_printf(m, ":count=%ld\n", count);

	return 0;
}

static int
ftrace_traceon_print(struct seq_file *m, unsigned long ip,
			 struct ftrace_probe_ops *ops, void *data)
{
	return ftrace_probe_print("traceon", m, ip, data);
}

static int
ftrace_traceoff_print(struct seq_file *m, unsigned long ip,
			 struct ftrace_probe_ops *ops, void *data)
{
	return ftrace_probe_print("traceoff", m, ip, data);
}

static int
ftrace_stacktrace_print(struct seq_file *m, unsigned long ip,
			struct ftrace_probe_ops *ops, void *data)
{
	return ftrace_probe_print("stacktrace", m, ip, data);
}

static int
ftrace_dump_print(struct seq_file *m, unsigned long ip,
			struct ftrace_probe_ops *ops, void *data)
{
	return ftrace_probe_print("dump", m, ip, data);
}

static int
ftrace_cpudump_print(struct seq_file *m, unsigned long ip,
			struct ftrace_probe_ops *ops, void *data)
{
	return ftrace_probe_print("cpudump", m, ip, data);
}

static struct ftrace_probe_ops traceon_count_probe_ops = {
	.func			= ftrace_traceon_count,
	.print			= ftrace_traceon_print,
};

static struct ftrace_probe_ops traceoff_count_probe_ops = {
	.func			= ftrace_traceoff_count,
	.print			= ftrace_traceoff_print,
};

static struct ftrace_probe_ops stacktrace_count_probe_ops = {
	.func			= ftrace_stacktrace_count,
	.print			= ftrace_stacktrace_print,
};

static struct ftrace_probe_ops dump_probe_ops = {
	.func			= ftrace_dump_probe,
	.print			= ftrace_dump_print,
};

static struct ftrace_probe_ops cpudump_probe_ops = {
	.func			= ftrace_cpudump_probe,
	.print			= ftrace_cpudump_print,
};

static struct ftrace_probe_ops traceon_probe_ops = {
	.func			= ftrace_traceon,
	.print			= ftrace_traceon_print,
};

static struct ftrace_probe_ops traceoff_probe_ops = {
	.func			= ftrace_traceoff,
	.print			= ftrace_traceoff_print,
};

static struct ftrace_probe_ops stacktrace_probe_ops = {
	.func			= ftrace_stacktrace,
	.print			= ftrace_stacktrace_print,
};

static int
ftrace_trace_probe_callback(struct ftrace_probe_ops *ops,
			    struct ftrace_hash *hash, char *glob,
			    char *cmd, char *param, int enable)
{
	void *count = (void *)-1;
	char *number;
	int ret;

	/* hash funcs only work with set_ftrace_filter */
	if (!enable)
		return -EINVAL;

	if (glob[0] == '!') {
		unregister_ftrace_function_probe_func(glob+1, ops);
		return 0;
	}

	if (!param)
		goto out_reg;

	number = strsep(&param, ":");

	if (!strlen(number))
		goto out_reg;

	/*
	 * We use the callback data field (which is a pointer)
	 * as our counter.
	 */
	ret = kstrtoul(number, 0, (unsigned long *)&count);
	if (ret)
		return ret;

 out_reg:
	ret = register_ftrace_function_probe(glob, ops, count);

	return ret < 0 ? ret : 0;
}

static int
ftrace_trace_onoff_callback(struct ftrace_hash *hash,
			    char *glob, char *cmd, char *param, int enable)
{
	struct ftrace_probe_ops *ops;

	/* we register both traceon and traceoff to this callback */
	if (strcmp(cmd, "traceon") == 0)
		ops = param ? &traceon_count_probe_ops : &traceon_probe_ops;
	else
		ops = param ? &traceoff_count_probe_ops : &traceoff_probe_ops;

	return ftrace_trace_probe_callback(ops, hash, glob, cmd,
					   param, enable);
}

static int
ftrace_stacktrace_callback(struct ftrace_hash *hash,
			   char *glob, char *cmd, char *param, int enable)
{
	struct ftrace_probe_ops *ops;

	ops = param ? &stacktrace_count_probe_ops : &stacktrace_probe_ops;

	return ftrace_trace_probe_callback(ops, hash, glob, cmd,
					   param, enable);
}

static int
ftrace_dump_callback(struct ftrace_hash *hash,
			   char *glob, char *cmd, char *param, int enable)
{
	struct ftrace_probe_ops *ops;

	ops = &dump_probe_ops;

	/* Only dump once. */
	return ftrace_trace_probe_callback(ops, hash, glob, cmd,
					   "1", enable);
}

static int
ftrace_cpudump_callback(struct ftrace_hash *hash,
			   char *glob, char *cmd, char *param, int enable)
{
	struct ftrace_probe_ops *ops;

	ops = &cpudump_probe_ops;

	/* Only dump once. */
	return ftrace_trace_probe_callback(ops, hash, glob, cmd,
					   "1", enable);
}

static struct ftrace_func_command ftrace_traceon_cmd = {
	.name			= "traceon",
	.func			= ftrace_trace_onoff_callback,
};

static struct ftrace_func_command ftrace_traceoff_cmd = {
	.name			= "traceoff",
	.func			= ftrace_trace_onoff_callback,
};

static struct ftrace_func_command ftrace_stacktrace_cmd = {
	.name			= "stacktrace",
	.func			= ftrace_stacktrace_callback,
};

static struct ftrace_func_command ftrace_dump_cmd = {
	.name			= "dump",
	.func			= ftrace_dump_callback,
};

static struct ftrace_func_command ftrace_cpudump_cmd = {
	.name			= "cpudump",
	.func			= ftrace_cpudump_callback,
};

static int __init init_func_cmd_traceon(void)
{
	int ret;

	ret = register_ftrace_command(&ftrace_traceoff_cmd);
	if (ret)
		return ret;

	ret = register_ftrace_command(&ftrace_traceon_cmd);
	if (ret)
		goto out_free_traceoff;

	ret = register_ftrace_command(&ftrace_stacktrace_cmd);
	if (ret)
		goto out_free_traceon;

	ret = register_ftrace_command(&ftrace_dump_cmd);
	if (ret)
		goto out_free_stacktrace;

	ret = register_ftrace_command(&ftrace_cpudump_cmd);
	if (ret)
		goto out_free_dump;

	return 0;

 out_free_dump:
	unregister_ftrace_command(&ftrace_dump_cmd);
 out_free_stacktrace:
	unregister_ftrace_command(&ftrace_stacktrace_cmd);
 out_free_traceon:
	unregister_ftrace_command(&ftrace_traceon_cmd);
 out_free_traceoff:
	unregister_ftrace_command(&ftrace_traceoff_cmd);

	return ret;
}
#else
static inline int init_func_cmd_traceon(void)
{
	return 0;
}
#endif /* CONFIG_DYNAMIC_FTRACE */

static __init int init_function_trace(void)
{
	init_func_cmd_traceon();
	return register_tracer(&function_trace);
}
core_initcall(init_function_trace);
Commit	Line	Data
1b29b018 SR	1	/*
	2	* ring buffer based function tracer
	3	*
	4	* Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
	5	* Copyright (C) 2008 Ingo Molnar <mingo@redhat.com>
	6	*
	7	* Based on code from the latency_tracer, that is:
	8	*
	9	* Copyright (C) 2004-2006 Ingo Molnar
6d49e352	10	* Copyright (C) 2004 Nadia Yvette Chambers
1b29b018	11	*/
23b4ff3a	12	#include <linux/ring_buffer.h>
1b29b018 SR	13	#include <linux/debugfs.h>
	14	#include <linux/uaccess.h>
	15	#include <linux/ftrace.h>
f20a5806	16	#include <linux/slab.h>
2e0f5761	17	#include <linux/fs.h>
1b29b018 SR	18
	19	#include "trace.h"
	20
f20a5806 SRRH	21	static void tracing_start_function_trace(struct trace_array *tr);
	22	static void tracing_stop_function_trace(struct trace_array *tr);
	23	static void
	24	function_trace_call(unsigned long ip, unsigned long parent_ip,
	25	struct ftrace_ops op, struct pt_regs pt_regs);
	26	static void
	27	function_stack_trace_call(unsigned long ip, unsigned long parent_ip,
	28	struct ftrace_ops op, struct pt_regs pt_regs);
f20a5806 SRRH	29	static struct tracer_flags func_flags;
	30
	31	/* Our option */
	32	enum {
	33	TRACE_FUNC_OPT_STACK = 0x1,
	34	};
	35
	36	static int allocate_ftrace_ops(struct trace_array *tr)
	37	{
	38	struct ftrace_ops *ops;
a225cdd2	39
f20a5806 SRRH	40	ops = kzalloc(sizeof(*ops), GFP_KERNEL);
	41	if (!ops)
	42	return -ENOMEM;
53614991	43
f20a5806 SRRH	44	/* Currently only the non stack verision is supported */
	45	ops->func = function_trace_call;
	46	ops->flags = FTRACE_OPS_FL_RECURSION_SAFE;
	47
	48	tr->ops = ops;
	49	ops->private = tr;
	50	return 0;
	51	}
a225cdd2	52
591dffda SRRH	53
	54	int ftrace_create_function_files(struct trace_array *tr,
	55	struct dentry *parent)
	56	{
	57	int ret;
	58
5d6c97c5 SRRH	59	/*
	60	* The top level array uses the "global_ops", and the files are
	61	* created on boot up.
	62	*/
	63	if (tr->flags & TRACE_ARRAY_FL_GLOBAL)
	64	return 0;
	65
	66	ret = allocate_ftrace_ops(tr);
	67	if (ret)
	68	return ret;
591dffda SRRH	69
	70	ftrace_create_filter_files(tr->ops, parent);
	71
	72	return 0;
	73	}
	74
	75	void ftrace_destroy_function_files(struct trace_array *tr)
	76	{
	77	ftrace_destroy_filter_files(tr->ops);
	78	kfree(tr->ops);
	79	tr->ops = NULL;
	80	}
	81
b6f11df2	82	static int function_trace_init(struct trace_array *tr)
1b29b018	83	{
4104d326	84	ftrace_func_t func;
f20a5806	85
4104d326 SRRH	86	/*
	87	* Instance trace_arrays get their ops allocated
	88	* at instance creation. Unless it failed
	89	* the allocation.
	90	*/
	91	if (!tr->ops)
591dffda	92	return -ENOMEM;
4104d326 SRRH	93
	94	/* Currently only the global instance can do stack tracing */
	95	if (tr->flags & TRACE_ARRAY_FL_GLOBAL &&
	96	func_flags.val & TRACE_FUNC_OPT_STACK)
	97	func = function_stack_trace_call;
	98	else
	99	func = function_trace_call;
	100
	101	ftrace_init_array_ops(tr, func);
f20a5806	102
12883efb	103	tr->trace_buffer.cpu = get_cpu();
26bc83f4 SR	104	put_cpu();
26bc83f4 SR	105
41bc8144	106	tracing_start_cmdline_record();
f20a5806	107	tracing_start_function_trace(tr);
1c80025a	108	return 0;
1b29b018 SR	109	}
1b29b018 SR	110
e309b41d	111	static void function_trace_reset(struct trace_array *tr)
1b29b018	112	{
f20a5806	113	tracing_stop_function_trace(tr);
b6f11df2	114	tracing_stop_cmdline_record();
4104d326	115	ftrace_reset_array_ops(tr);
1b29b018 SR	116	}
1b29b018 SR	117
9036990d SR	118	static void function_trace_start(struct trace_array *tr)
9036990d SR	119	{
12883efb	120	tracing_reset_online_cpus(&tr->trace_buffer);
9036990d SR	121	}
9036990d SR	122
bb3c3c95	123	static void
2f5f6ad9	124	function_trace_call(unsigned long ip, unsigned long parent_ip,
a1e2e31d	125	struct ftrace_ops op, struct pt_regs pt_regs)
bb3c3c95	126	{
f20a5806	127	struct trace_array *tr = op->private;
bb3c3c95 SR	128	struct trace_array_cpu *data;
bb3c3c95 SR	129	unsigned long flags;
d41032a8	130	int bit;
bb3c3c95 SR	131	int cpu;
	132	int pc;
	133
f20a5806	134	if (unlikely(!tr->function_enabled))
bb3c3c95 SR	135	return;
bb3c3c95 SR	136
897f68a4 SR	137	pc = preempt_count();
897f68a4 SR	138	preempt_disable_notrace();
bb3c3c95	139
897f68a4 SR	140	bit = trace_test_and_set_recursion(TRACE_FTRACE_START, TRACE_FTRACE_MAX);
	141	if (bit < 0)
	142	goto out;
	143
	144	cpu = smp_processor_id();
12883efb	145	data = per_cpu_ptr(tr->trace_buffer.data, cpu);
897f68a4 SR	146	if (!atomic_read(&data->disabled)) {
897f68a4 SR	147	local_save_flags(flags);
7be42151	148	trace_function(tr, ip, parent_ip, flags, pc);
bb3c3c95	149	}
897f68a4	150	trace_clear_recursion(bit);
bb3c3c95	151
897f68a4 SR	152	out:
897f68a4 SR	153	preempt_enable_notrace();
bb3c3c95 SR	154	}
bb3c3c95 SR	155
53614991	156	static void
2f5f6ad9	157	function_stack_trace_call(unsigned long ip, unsigned long parent_ip,
a1e2e31d	158	struct ftrace_ops op, struct pt_regs pt_regs)
53614991	159	{
f20a5806	160	struct trace_array *tr = op->private;
53614991 SR	161	struct trace_array_cpu *data;
	162	unsigned long flags;
	163	long disabled;
	164	int cpu;
	165	int pc;
	166
f20a5806	167	if (unlikely(!tr->function_enabled))
53614991 SR	168	return;
	169
	170	/*
	171	* Need to use raw, since this must be called before the
	172	* recursive protection is performed.
	173	*/
	174	local_irq_save(flags);
	175	cpu = raw_smp_processor_id();
12883efb	176	data = per_cpu_ptr(tr->trace_buffer.data, cpu);
53614991 SR	177	disabled = atomic_inc_return(&data->disabled);
	178
	179	if (likely(disabled == 1)) {
	180	pc = preempt_count();
7be42151	181	trace_function(tr, ip, parent_ip, flags, pc);
53614991 SR	182	/*
	183	* skip over 5 funcs:
	184	* __ftrace_trace_stack,
	185	* __trace_stack,
	186	* function_stack_trace_call
	187	* ftrace_list_func
	188	* ftrace_call
	189	*/
7be42151	190	__trace_stack(tr, flags, 5, pc);
53614991 SR	191	}
	192
	193	atomic_dec(&data->disabled);
	194	local_irq_restore(flags);
	195	}
	196
53614991 SR	197	static struct tracer_opt func_opts[] = {
	198	#ifdef CONFIG_STACKTRACE
	199	{ TRACER_OPT(func_stack_trace, TRACE_FUNC_OPT_STACK) },
	200	#endif
	201	{ } /* Always set a last empty entry */
	202	};
	203
	204	static struct tracer_flags func_flags = {
	205	.val = 0, /* By default: all flags disabled */
	206	.opts = func_opts
	207	};
	208
f20a5806	209	static void tracing_start_function_trace(struct trace_array *tr)
3eb36aa0	210	{
f20a5806 SRRH	211	tr->function_enabled = 0;
	212	register_ftrace_function(tr->ops);
	213	tr->function_enabled = 1;
3eb36aa0 SR	214	}
3eb36aa0 SR	215
f20a5806	216	static void tracing_stop_function_trace(struct trace_array *tr)
3eb36aa0	217	{
f20a5806 SRRH	218	tr->function_enabled = 0;
f20a5806 SRRH	219	unregister_ftrace_function(tr->ops);
3eb36aa0 SR	220	}
3eb36aa0 SR	221
8c1a49ae SRRH	222	static int
8c1a49ae SRRH	223	func_set_flag(struct trace_array *tr, u32 old_flags, u32 bit, int set)
53614991	224	{
f555f123 AV	225	switch (bit) {
f555f123 AV	226	case TRACE_FUNC_OPT_STACK:
53614991 SR	227	/* do nothing if already set */
53614991 SR	228	if (!!set == !!(func_flags.val & TRACE_FUNC_OPT_STACK))
f555f123	229	break;
53614991	230
f20a5806 SRRH	231	unregister_ftrace_function(tr->ops);
f20a5806 SRRH	232
3eb36aa0	233	if (set) {
4104d326	234	tr->ops->func = function_stack_trace_call;
f20a5806	235	register_ftrace_function(tr->ops);
3eb36aa0	236	} else {
4104d326	237	tr->ops->func = function_trace_call;
f20a5806	238	register_ftrace_function(tr->ops);
3eb36aa0	239	}
53614991	240
f555f123 AV	241	break;
	242	default:
	243	return -EINVAL;
53614991 SR	244	}
53614991 SR	245
f555f123	246	return 0;
53614991 SR	247	}
53614991 SR	248
8f768993	249	static struct tracer function_trace __tracer_data =
1b29b018	250	{
3eb36aa0 SR	251	.name = "function",
	252	.init = function_trace_init,
	253	.reset = function_trace_reset,
	254	.start = function_trace_start,
53614991 SR	255	.flags = &func_flags,
53614991 SR	256	.set_flag = func_set_flag,
f20a5806	257	.allow_instances = true,
60a11774	258	#ifdef CONFIG_FTRACE_SELFTEST
3eb36aa0	259	.selftest = trace_selftest_startup_function,
60a11774	260	#endif
1b29b018 SR	261	};
1b29b018 SR	262
23b4ff3a	263	#ifdef CONFIG_DYNAMIC_FTRACE
1c317143	264	static int update_count(void **data)
23b4ff3a	265	{
1c317143	266	unsigned long count = (long )data;
23b4ff3a SR	267
23b4ff3a SR	268	if (!*count)
1c317143	269	return 0;
23b4ff3a SR	270
	271	if (*count != -1)
	272	(*count)--;
	273
1c317143	274	return 1;
23b4ff3a SR	275	}
	276
	277	static void
8380d248	278	ftrace_traceon_count(unsigned long ip, unsigned long parent_ip, void **data)
23b4ff3a	279	{
1c317143	280	if (tracing_is_on())
23b4ff3a SR	281	return;
23b4ff3a SR	282
1c317143 SRRH	283	if (update_count(data))
	284	tracing_on();
	285	}
23b4ff3a	286
1c317143	287	static void
8380d248	288	ftrace_traceoff_count(unsigned long ip, unsigned long parent_ip, void **data)
1c317143 SRRH	289	{
	290	if (!tracing_is_on())
	291	return;
23b4ff3a	292
1c317143 SRRH	293	if (update_count(data))
1c317143 SRRH	294	tracing_off();
23b4ff3a SR	295	}
23b4ff3a SR	296
8380d248 SRRH	297	static void
	298	ftrace_traceon(unsigned long ip, unsigned long parent_ip, void **data)
	299	{
	300	if (tracing_is_on())
	301	return;
	302
	303	tracing_on();
	304	}
	305
	306	static void
	307	ftrace_traceoff(unsigned long ip, unsigned long parent_ip, void **data)
	308	{
	309	if (!tracing_is_on())
	310	return;
	311
	312	tracing_off();
	313	}
	314
dd42cd3e SRRH	315	/*
	316	* Skip 4:
	317	* ftrace_stacktrace()
	318	* function_trace_probe_call()
	319	* ftrace_ops_list_func()
	320	* ftrace_call()
	321	*/
	322	#define STACK_SKIP 4
	323
	324	static void
	325	ftrace_stacktrace(unsigned long ip, unsigned long parent_ip, void **data)
	326	{
	327	trace_dump_stack(STACK_SKIP);
	328	}
	329
	330	static void
	331	ftrace_stacktrace_count(unsigned long ip, unsigned long parent_ip, void **data)
	332	{
	333	if (!tracing_is_on())
	334	return;
	335
	336	if (update_count(data))
	337	trace_dump_stack(STACK_SKIP);
	338	}
	339
ad71d889 SRRH	340	static void
	341	ftrace_dump_probe(unsigned long ip, unsigned long parent_ip, void **data)
	342	{
	343	if (update_count(data))
	344	ftrace_dump(DUMP_ALL);
	345	}
	346
90e3c03c SRRH	347	/* Only dump the current CPU buffer. */
	348	static void
	349	ftrace_cpudump_probe(unsigned long ip, unsigned long parent_ip, void **data)
	350	{
	351	if (update_count(data))
	352	ftrace_dump(DUMP_ORIG);
	353	}
	354
e110e3d1	355	static int
dd42cd3e SRRH	356	ftrace_probe_print(const char name, struct seq_file m,
	357	unsigned long ip, void *data)
	358	{
	359	long count = (long)data;
	360
	361	seq_printf(m, "%ps:%s", (void *)ip, name);
	362
	363	if (count == -1)
	364	seq_printf(m, ":unlimited\n");
	365	else
	366	seq_printf(m, ":count=%ld\n", count);
	367
	368	return 0;
	369	}
	370
	371	static int
	372	ftrace_traceon_print(struct seq_file *m, unsigned long ip,
	373	struct ftrace_probe_ops ops, void data)
	374	{
	375	return ftrace_probe_print("traceon", m, ip, data);
	376	}
	377
	378	static int
	379	ftrace_traceoff_print(struct seq_file *m, unsigned long ip,
	380	struct ftrace_probe_ops ops, void data)
	381	{
	382	return ftrace_probe_print("traceoff", m, ip, data);
	383	}
	384
	385	static int
	386	ftrace_stacktrace_print(struct seq_file *m, unsigned long ip,
	387	struct ftrace_probe_ops ops, void data)
	388	{
	389	return ftrace_probe_print("stacktrace", m, ip, data);
	390	}
e110e3d1	391
ad71d889 SRRH	392	static int
	393	ftrace_dump_print(struct seq_file *m, unsigned long ip,
	394	struct ftrace_probe_ops ops, void data)
	395	{
	396	return ftrace_probe_print("dump", m, ip, data);
	397	}
	398
90e3c03c SRRH	399	static int
	400	ftrace_cpudump_print(struct seq_file *m, unsigned long ip,
	401	struct ftrace_probe_ops ops, void data)
	402	{
	403	return ftrace_probe_print("cpudump", m, ip, data);
	404	}
	405
8380d248 SRRH	406	static struct ftrace_probe_ops traceon_count_probe_ops = {
8380d248 SRRH	407	.func = ftrace_traceon_count,
dd42cd3e	408	.print = ftrace_traceon_print,
8380d248 SRRH	409	};
	410
	411	static struct ftrace_probe_ops traceoff_count_probe_ops = {
	412	.func = ftrace_traceoff_count,
dd42cd3e SRRH	413	.print = ftrace_traceoff_print,
	414	};
	415
	416	static struct ftrace_probe_ops stacktrace_count_probe_ops = {
	417	.func = ftrace_stacktrace_count,
	418	.print = ftrace_stacktrace_print,
8380d248 SRRH	419	};
8380d248 SRRH	420
ad71d889 SRRH	421	static struct ftrace_probe_ops dump_probe_ops = {
	422	.func = ftrace_dump_probe,
	423	.print = ftrace_dump_print,
	424	};
	425
90e3c03c SRRH	426	static struct ftrace_probe_ops cpudump_probe_ops = {
	427	.func = ftrace_cpudump_probe,
	428	.print = ftrace_cpudump_print,
	429	};
	430
b6887d79	431	static struct ftrace_probe_ops traceon_probe_ops = {
23b4ff3a	432	.func = ftrace_traceon,
dd42cd3e	433	.print = ftrace_traceon_print,
23b4ff3a SR	434	};
23b4ff3a SR	435
b6887d79	436	static struct ftrace_probe_ops traceoff_probe_ops = {
23b4ff3a	437	.func = ftrace_traceoff,
dd42cd3e	438	.print = ftrace_traceoff_print,
23b4ff3a SR	439	};
23b4ff3a SR	440
dd42cd3e SRRH	441	static struct ftrace_probe_ops stacktrace_probe_ops = {
	442	.func = ftrace_stacktrace,
	443	.print = ftrace_stacktrace_print,
	444	};
e110e3d1	445
23b4ff3a	446	static int
dd42cd3e SRRH	447	ftrace_trace_probe_callback(struct ftrace_probe_ops *ops,
	448	struct ftrace_hash hash, char glob,
	449	char cmd, char param, int enable)
23b4ff3a	450	{
23b4ff3a SR	451	void count = (void )-1;
	452	char *number;
	453	int ret;
	454
	455	/* hash funcs only work with set_ftrace_filter */
	456	if (!enable)
	457	return -EINVAL;
	458
8b8fa62c SRRH	459	if (glob[0] == '!') {
	460	unregister_ftrace_function_probe_func(glob+1, ops);
	461	return 0;
	462	}
	463
23b4ff3a SR	464	if (!param)
	465	goto out_reg;
	466
	467	number = strsep(&param, ":");
	468
	469	if (!strlen(number))
	470	goto out_reg;
	471
	472	/*
	473	* We use the callback data field (which is a pointer)
	474	* as our counter.
	475	*/
bcd83ea6	476	ret = kstrtoul(number, 0, (unsigned long *)&count);
23b4ff3a SR	477	if (ret)
	478	return ret;
	479
	480	out_reg:
b6887d79	481	ret = register_ftrace_function_probe(glob, ops, count);
23b4ff3a	482
04aef32d	483	return ret < 0 ? ret : 0;
23b4ff3a SR	484	}
23b4ff3a SR	485
dd42cd3e SRRH	486	static int
	487	ftrace_trace_onoff_callback(struct ftrace_hash *hash,
	488	char glob, char cmd, char *param, int enable)
	489	{
	490	struct ftrace_probe_ops *ops;
	491
	492	/* we register both traceon and traceoff to this callback */
	493	if (strcmp(cmd, "traceon") == 0)
	494	ops = param ? &traceon_count_probe_ops : &traceon_probe_ops;
	495	else
	496	ops = param ? &traceoff_count_probe_ops : &traceoff_probe_ops;
	497
	498	return ftrace_trace_probe_callback(ops, hash, glob, cmd,
	499	param, enable);
	500	}
	501
	502	static int
	503	ftrace_stacktrace_callback(struct ftrace_hash *hash,
	504	char glob, char cmd, char *param, int enable)
	505	{
	506	struct ftrace_probe_ops *ops;
	507
	508	ops = param ? &stacktrace_count_probe_ops : &stacktrace_probe_ops;
	509
	510	return ftrace_trace_probe_callback(ops, hash, glob, cmd,
	511	param, enable);
	512	}
	513
ad71d889 SRRH	514	static int
	515	ftrace_dump_callback(struct ftrace_hash *hash,
	516	char glob, char cmd, char *param, int enable)
	517	{
	518	struct ftrace_probe_ops *ops;
	519
	520	ops = &dump_probe_ops;
	521
	522	/* Only dump once. */
	523	return ftrace_trace_probe_callback(ops, hash, glob, cmd,
	524	"1", enable);
	525	}
	526
90e3c03c SRRH	527	static int
	528	ftrace_cpudump_callback(struct ftrace_hash *hash,
	529	char glob, char cmd, char *param, int enable)
	530	{
	531	struct ftrace_probe_ops *ops;
	532
	533	ops = &cpudump_probe_ops;
	534
	535	/* Only dump once. */
	536	return ftrace_trace_probe_callback(ops, hash, glob, cmd,
	537	"1", enable);
	538	}
	539
23b4ff3a SR	540	static struct ftrace_func_command ftrace_traceon_cmd = {
	541	.name = "traceon",
	542	.func = ftrace_trace_onoff_callback,
	543	};
	544
	545	static struct ftrace_func_command ftrace_traceoff_cmd = {
	546	.name = "traceoff",
	547	.func = ftrace_trace_onoff_callback,
	548	};
	549
dd42cd3e SRRH	550	static struct ftrace_func_command ftrace_stacktrace_cmd = {
	551	.name = "stacktrace",
	552	.func = ftrace_stacktrace_callback,
	553	};
	554
ad71d889 SRRH	555	static struct ftrace_func_command ftrace_dump_cmd = {
	556	.name = "dump",
	557	.func = ftrace_dump_callback,
	558	};
	559
90e3c03c SRRH	560	static struct ftrace_func_command ftrace_cpudump_cmd = {
	561	.name = "cpudump",
	562	.func = ftrace_cpudump_callback,
	563	};
	564
23b4ff3a SR	565	static int __init init_func_cmd_traceon(void)
	566	{
	567	int ret;
	568
	569	ret = register_ftrace_command(&ftrace_traceoff_cmd);
	570	if (ret)
	571	return ret;
	572
	573	ret = register_ftrace_command(&ftrace_traceon_cmd);
	574	if (ret)
ad71d889	575	goto out_free_traceoff;
dd42cd3e SRRH	576
dd42cd3e SRRH	577	ret = register_ftrace_command(&ftrace_stacktrace_cmd);
ad71d889 SRRH	578	if (ret)
	579	goto out_free_traceon;
	580
	581	ret = register_ftrace_command(&ftrace_dump_cmd);
	582	if (ret)
	583	goto out_free_stacktrace;
	584
90e3c03c SRRH	585	ret = register_ftrace_command(&ftrace_cpudump_cmd);
	586	if (ret)
	587	goto out_free_dump;
	588
ad71d889 SRRH	589	return 0;
ad71d889 SRRH	590
90e3c03c SRRH	591	out_free_dump:
90e3c03c SRRH	592	unregister_ftrace_command(&ftrace_dump_cmd);
ad71d889 SRRH	593	out_free_stacktrace:
	594	unregister_ftrace_command(&ftrace_stacktrace_cmd);
	595	out_free_traceon:
	596	unregister_ftrace_command(&ftrace_traceon_cmd);
	597	out_free_traceoff:
	598	unregister_ftrace_command(&ftrace_traceoff_cmd);
	599
23b4ff3a SR	600	return ret;
	601	}
	602	#else
	603	static inline int init_func_cmd_traceon(void)
	604	{
	605	return 0;
	606	}
	607	#endif /* CONFIG_DYNAMIC_FTRACE */
	608
1b29b018 SR	609	static __init int init_function_trace(void)
1b29b018 SR	610	{
23b4ff3a	611	init_func_cmd_traceon();
1b29b018 SR	612	return register_tracer(&function_trace);
1b29b018 SR	613	}
6f415672	614	core_initcall(init_function_trace);