[linux-2.6-block.git] / kernel / trace / trace_syscalls.c

#include <trace/syscall.h>
#include <linux/kernel.h>
#include <linux/ftrace.h>
#include <linux/perf_counter.h>
#include <asm/syscall.h>

#include "trace_output.h"
#include "trace.h"

static DEFINE_MUTEX(syscall_trace_lock);
static int sys_refcount_enter;
static int sys_refcount_exit;
static DECLARE_BITMAP(enabled_enter_syscalls, FTRACE_SYSCALL_MAX);
static DECLARE_BITMAP(enabled_exit_syscalls, FTRACE_SYSCALL_MAX);

enum print_line_t
print_syscall_enter(struct trace_iterator *iter, int flags)
{
	struct trace_seq *s = &iter->seq;
	struct trace_entry *ent = iter->ent;
	struct syscall_trace_enter *trace;
	struct syscall_metadata *entry;
	int i, ret, syscall;

	trace = (typeof(trace))ent;
	syscall = trace->nr;
	entry = syscall_nr_to_meta(syscall);

	if (!entry)
		goto end;

	if (entry->enter_id != ent->type) {
		WARN_ON_ONCE(1);
		goto end;
	}

	ret = trace_seq_printf(s, "%s(", entry->name);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	for (i = 0; i < entry->nb_args; i++) {
		/* parameter types */
		if (trace_flags & TRACE_ITER_VERBOSE) {
			ret = trace_seq_printf(s, "%s ", entry->types[i]);
			if (!ret)
				return TRACE_TYPE_PARTIAL_LINE;
		}
		/* parameter values */
		ret = trace_seq_printf(s, "%s: %lx%s ", entry->args[i],
				       trace->args[i],
				       i == entry->nb_args - 1 ? ")" : ",");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

end:
	trace_seq_printf(s, "\n");
	return TRACE_TYPE_HANDLED;
}

enum print_line_t
print_syscall_exit(struct trace_iterator *iter, int flags)
{
	struct trace_seq *s = &iter->seq;
	struct trace_entry *ent = iter->ent;
	struct syscall_trace_exit *trace;
	int syscall;
	struct syscall_metadata *entry;
	int ret;

	trace = (typeof(trace))ent;
	syscall = trace->nr;
	entry = syscall_nr_to_meta(syscall);

	if (!entry) {
		trace_seq_printf(s, "\n");
		return TRACE_TYPE_HANDLED;
	}

	if (entry->exit_id != ent->type) {
		WARN_ON_ONCE(1);
		return TRACE_TYPE_UNHANDLED;
	}

	ret = trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
				trace->ret);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

int ftrace_format_syscall(struct ftrace_event_call *call, struct trace_seq *s)
{
	int i;
	int nr;
	int ret = 0;
	struct syscall_metadata *entry;
	int offset = sizeof(struct trace_entry);

	nr = syscall_name_to_nr((char *)call->data);
	entry = syscall_nr_to_meta(nr);

	if (!entry)
		return ret;

	for (i = 0; i < entry->nb_args; i++) {
		ret = trace_seq_printf(s, "\tfield:%s %s;", entry->types[i],
				        entry->args[i]);
		if (!ret)
			return 0;
		ret = trace_seq_printf(s, "\toffset:%d;\tsize:%lu;\n", offset,
				       sizeof(unsigned long));
		if (!ret)
			return 0;
		offset += sizeof(unsigned long);
	}

	trace_seq_printf(s, "\nprint fmt: \"");
	for (i = 0; i < entry->nb_args; i++) {
		ret = trace_seq_printf(s, "%s: 0x%%0%lulx%s", entry->args[i],
				        sizeof(unsigned long),
					i == entry->nb_args - 1 ? "\", " : ", ");
		if (!ret)
			return 0;
	}

	for (i = 0; i < entry->nb_args; i++) {
		ret = trace_seq_printf(s, "((unsigned long)(REC->%s))%s",
				        entry->args[i],
					i == entry->nb_args - 1 ? "\n" : ", ");
		if (!ret)
			return 0;
	}

	return ret;
}

void ftrace_syscall_enter(struct pt_regs *regs, long id)
{
	struct syscall_trace_enter *entry;
	struct syscall_metadata *sys_data;
	struct ring_buffer_event *event;
	int size;
	int syscall_nr;

	syscall_nr = syscall_get_nr(current, regs);
	if (!test_bit(syscall_nr, enabled_enter_syscalls))
		return;

	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

	size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;

	event = trace_current_buffer_lock_reserve(sys_data->enter_id, size,
							0, 0);
	if (!event)
		return;

	entry = ring_buffer_event_data(event);
	entry->nr = syscall_nr;
	syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);

	trace_current_buffer_unlock_commit(event, 0, 0);
	trace_wake_up();
}

void ftrace_syscall_exit(struct pt_regs *regs, long ret)
{
	struct syscall_trace_exit *entry;
	struct syscall_metadata *sys_data;
	struct ring_buffer_event *event;
	int syscall_nr;

	syscall_nr = syscall_get_nr(current, regs);
	if (!test_bit(syscall_nr, enabled_exit_syscalls))
		return;

	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

	event = trace_current_buffer_lock_reserve(sys_data->exit_id,
				sizeof(*entry), 0, 0);
	if (!event)
		return;

	entry = ring_buffer_event_data(event);
	entry->nr = syscall_nr;
	entry->ret = syscall_get_return_value(current, regs);

	trace_current_buffer_unlock_commit(event, 0, 0);
	trace_wake_up();
}

int reg_event_syscall_enter(void *ptr)
{
	int ret = 0;
	int num;
	char *name;

	name = (char *)ptr;
	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
	if (!sys_refcount_enter)
		ret = register_trace_syscall_enter(ftrace_syscall_enter);
	if (ret) {
		pr_info("event trace: Could not activate"
				"syscall entry trace point");
	} else {
		set_bit(num, enabled_enter_syscalls);
		sys_refcount_enter++;
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

void unreg_event_syscall_enter(void *ptr)
{
	int num;
	char *name;

	name = (char *)ptr;
	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return;
	mutex_lock(&syscall_trace_lock);
	sys_refcount_enter--;
	clear_bit(num, enabled_enter_syscalls);
	if (!sys_refcount_enter)
		unregister_trace_syscall_enter(ftrace_syscall_enter);
	mutex_unlock(&syscall_trace_lock);
}

int reg_event_syscall_exit(void *ptr)
{
	int ret = 0;
	int num;
	char *name;

	name = (char *)ptr;
	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
	if (!sys_refcount_exit)
		ret = register_trace_syscall_exit(ftrace_syscall_exit);
	if (ret) {
		pr_info("event trace: Could not activate"
				"syscall exit trace point");
	} else {
		set_bit(num, enabled_exit_syscalls);
		sys_refcount_exit++;
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

void unreg_event_syscall_exit(void *ptr)
{
	int num;
	char *name;

	name = (char *)ptr;
	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return;
	mutex_lock(&syscall_trace_lock);
	sys_refcount_exit--;
	clear_bit(num, enabled_exit_syscalls);
	if (!sys_refcount_exit)
		unregister_trace_syscall_exit(ftrace_syscall_exit);
	mutex_unlock(&syscall_trace_lock);
}

struct trace_event event_syscall_enter = {
	.trace			= print_syscall_enter,
};

struct trace_event event_syscall_exit = {
	.trace			= print_syscall_exit,
};

#ifdef CONFIG_EVENT_PROFILE

struct syscall_enter_record {
	struct trace_entry	entry;
	unsigned long		args[0];
};

struct syscall_exit_record {
	struct trace_entry	entry;
	unsigned long		ret;
};

static DECLARE_BITMAP(enabled_prof_enter_syscalls, FTRACE_SYSCALL_MAX);
static DECLARE_BITMAP(enabled_prof_exit_syscalls, FTRACE_SYSCALL_MAX);
static int sys_prof_refcount_enter;
static int sys_prof_refcount_exit;

static void prof_syscall_enter(struct pt_regs *regs, long id)
{
	struct syscall_enter_record *rec;
	struct syscall_metadata *sys_data;
	int syscall_nr;
	int size;

	syscall_nr = syscall_get_nr(current, regs);
	if (!test_bit(syscall_nr, enabled_prof_enter_syscalls))
		return;

	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

	/* get the size after alignment with the u32 buffer size field */
	size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec);
	size = ALIGN(size + sizeof(u32), sizeof(u64));
	size -= sizeof(u32);

	do {
		char raw_data[size];

		/* zero the dead bytes from align to not leak stack to user */
		*(u64 *)(&raw_data[size - sizeof(u64)]) = 0ULL;

		rec = (struct syscall_enter_record *) raw_data;
		tracing_generic_entry_update(&rec->entry, 0, 0);
		rec->entry.type = sys_data->enter_id;
		syscall_get_arguments(current, regs, 0, sys_data->nb_args,
				       (unsigned long *)&rec->args);
		perf_tpcounter_event(sys_data->enter_id, 0, 1, rec, size);
	} while(0);
}

int reg_prof_syscall_enter(char *name)
{
	int ret = 0;
	int num;

	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return -ENOSYS;

	mutex_lock(&syscall_trace_lock);
	if (!sys_prof_refcount_enter)
		ret = register_trace_syscall_enter(prof_syscall_enter);
	if (ret) {
		pr_info("event trace: Could not activate"
				"syscall entry trace point");
	} else {
		set_bit(num, enabled_prof_enter_syscalls);
		sys_prof_refcount_enter++;
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

void unreg_prof_syscall_enter(char *name)
{
	int num;

	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return;

	mutex_lock(&syscall_trace_lock);
	sys_prof_refcount_enter--;
	clear_bit(num, enabled_prof_enter_syscalls);
	if (!sys_prof_refcount_enter)
		unregister_trace_syscall_enter(prof_syscall_enter);
	mutex_unlock(&syscall_trace_lock);
}

static void prof_syscall_exit(struct pt_regs *regs, long ret)
{
	struct syscall_metadata *sys_data;
	struct syscall_exit_record rec;
	int syscall_nr;

	syscall_nr = syscall_get_nr(current, regs);
	if (!test_bit(syscall_nr, enabled_prof_exit_syscalls))
		return;

	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

	tracing_generic_entry_update(&rec.entry, 0, 0);
	rec.entry.type = sys_data->exit_id;
	rec.ret = syscall_get_return_value(current, regs);

	perf_tpcounter_event(sys_data->exit_id, 0, 1, &rec, sizeof(rec));
}

int reg_prof_syscall_exit(char *name)
{
	int ret = 0;
	int num;

	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return -ENOSYS;

	mutex_lock(&syscall_trace_lock);
	if (!sys_prof_refcount_exit)
		ret = register_trace_syscall_exit(prof_syscall_exit);
	if (ret) {
		pr_info("event trace: Could not activate"
				"syscall entry trace point");
	} else {
		set_bit(num, enabled_prof_exit_syscalls);
		sys_prof_refcount_exit++;
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

void unreg_prof_syscall_exit(char *name)
{
	int num;

	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return;

	mutex_lock(&syscall_trace_lock);
	sys_prof_refcount_exit--;
	clear_bit(num, enabled_prof_exit_syscalls);
	if (!sys_prof_refcount_exit)
		unregister_trace_syscall_exit(prof_syscall_exit);
	mutex_unlock(&syscall_trace_lock);
}

#endif
Commit	Line	Data
47788c58	1	#include <trace/syscall.h>
ee08c6ec	2	#include <linux/kernel.h>
fb34a08c	3	#include <linux/ftrace.h>
f4b5ffcc	4	#include <linux/perf_counter.h>
ee08c6ec FW	5	#include <asm/syscall.h>
	6
	7	#include "trace_output.h"
	8	#include "trace.h"
	9
5be71b61	10	static DEFINE_MUTEX(syscall_trace_lock);
fb34a08c JB	11	static int sys_refcount_enter;
	12	static int sys_refcount_exit;
	13	static DECLARE_BITMAP(enabled_enter_syscalls, FTRACE_SYSCALL_MAX);
	14	static DECLARE_BITMAP(enabled_exit_syscalls, FTRACE_SYSCALL_MAX);
ee08c6ec	15
bed1ffca FW	16	enum print_line_t
	17	print_syscall_enter(struct trace_iterator *iter, int flags)
	18	{
	19	struct trace_seq *s = &iter->seq;
	20	struct trace_entry *ent = iter->ent;
	21	struct syscall_trace_enter *trace;
	22	struct syscall_metadata *entry;
	23	int i, ret, syscall;
	24
64c12e04	25	trace = (typeof(trace))ent;
bed1ffca	26	syscall = trace->nr;
bed1ffca	27	entry = syscall_nr_to_meta(syscall);
64c12e04	28
bed1ffca FW	29	if (!entry)
	30	goto end;
	31
64c12e04 JB	32	if (entry->enter_id != ent->type) {
	33	WARN_ON_ONCE(1);
	34	goto end;
	35	}
	36
bed1ffca FW	37	ret = trace_seq_printf(s, "%s(", entry->name);
	38	if (!ret)
	39	return TRACE_TYPE_PARTIAL_LINE;
	40
	41	for (i = 0; i < entry->nb_args; i++) {
	42	/* parameter types */
ba8b3a40	43	if (trace_flags & TRACE_ITER_VERBOSE) {
bed1ffca FW	44	ret = trace_seq_printf(s, "%s ", entry->types[i]);
	45	if (!ret)
	46	return TRACE_TYPE_PARTIAL_LINE;
	47	}
	48	/* parameter values */
	49	ret = trace_seq_printf(s, "%s: %lx%s ", entry->args[i],
	50	trace->args[i],
	51	i == entry->nb_args - 1 ? ")" : ",");
	52	if (!ret)
	53	return TRACE_TYPE_PARTIAL_LINE;
	54	}
	55
	56	end:
	57	trace_seq_printf(s, "\n");
	58	return TRACE_TYPE_HANDLED;
	59	}
	60
	61	enum print_line_t
	62	print_syscall_exit(struct trace_iterator *iter, int flags)
	63	{
	64	struct trace_seq *s = &iter->seq;
	65	struct trace_entry *ent = iter->ent;
	66	struct syscall_trace_exit *trace;
	67	int syscall;
	68	struct syscall_metadata *entry;
	69	int ret;
	70
64c12e04	71	trace = (typeof(trace))ent;
bed1ffca	72	syscall = trace->nr;
bed1ffca	73	entry = syscall_nr_to_meta(syscall);
64c12e04	74
bed1ffca FW	75	if (!entry) {
	76	trace_seq_printf(s, "\n");
	77	return TRACE_TYPE_HANDLED;
	78	}
	79
64c12e04 JB	80	if (entry->exit_id != ent->type) {
	81	WARN_ON_ONCE(1);
	82	return TRACE_TYPE_UNHANDLED;
	83	}
	84
bed1ffca FW	85	ret = trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
	86	trace->ret);
	87	if (!ret)
	88	return TRACE_TYPE_PARTIAL_LINE;
	89
	90	return TRACE_TYPE_HANDLED;
	91	}
	92
dc4ddb4c FW	93	int ftrace_format_syscall(struct ftrace_event_call call, struct trace_seq s)
	94	{
	95	int i;
	96	int nr;
	97	int ret = 0;
	98	struct syscall_metadata *entry;
	99	int offset = sizeof(struct trace_entry);
	100
	101	nr = syscall_name_to_nr((char *)call->data);
	102	entry = syscall_nr_to_meta(nr);
	103
	104	if (!entry)
	105	return ret;
	106
	107	for (i = 0; i < entry->nb_args; i++) {
	108	ret = trace_seq_printf(s, "\tfield:%s %s;", entry->types[i],
	109	entry->args[i]);
	110	if (!ret)
	111	return 0;
	112	ret = trace_seq_printf(s, "\toffset:%d;\tsize:%lu;\n", offset,
	113	sizeof(unsigned long));
	114	if (!ret)
	115	return 0;
	116	offset += sizeof(unsigned long);
	117	}
	118
	119	trace_seq_printf(s, "\nprint fmt: \"");
	120	for (i = 0; i < entry->nb_args; i++) {
	121	ret = trace_seq_printf(s, "%s: 0x%%0%lulx%s", entry->args[i],
	122	sizeof(unsigned long),
	123	i == entry->nb_args - 1 ? "\", " : ", ");
	124	if (!ret)
	125	return 0;
	126	}
	127
	128	for (i = 0; i < entry->nb_args; i++) {
	129	ret = trace_seq_printf(s, "((unsigned long)(REC->%s))%s",
	130	entry->args[i],
	131	i == entry->nb_args - 1 ? "\n" : ", ");
	132	if (!ret)
	133	return 0;
	134	}
	135
	136	return ret;
	137	}
	138
fb34a08c	139	void ftrace_syscall_enter(struct pt_regs *regs, long id)
ee08c6ec	140	{
bed1ffca FW	141	struct syscall_trace_enter *entry;
	142	struct syscall_metadata *sys_data;
	143	struct ring_buffer_event *event;
	144	int size;
ee08c6ec FW	145	int syscall_nr;
	146
	147	syscall_nr = syscall_get_nr(current, regs);
fb34a08c JB	148	if (!test_bit(syscall_nr, enabled_enter_syscalls))
fb34a08c JB	149	return;
ee08c6ec	150
bed1ffca FW	151	sys_data = syscall_nr_to_meta(syscall_nr);
	152	if (!sys_data)
	153	return;
	154
	155	size = sizeof(entry) + sizeof(unsigned long) sys_data->nb_args;
	156
64c12e04	157	event = trace_current_buffer_lock_reserve(sys_data->enter_id, size,
bed1ffca FW	158	0, 0);
	159	if (!event)
	160	return;
	161
	162	entry = ring_buffer_event_data(event);
	163	entry->nr = syscall_nr;
	164	syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);
	165
	166	trace_current_buffer_unlock_commit(event, 0, 0);
	167	trace_wake_up();
ee08c6ec FW	168	}
ee08c6ec FW	169
fb34a08c	170	void ftrace_syscall_exit(struct pt_regs *regs, long ret)
ee08c6ec	171	{
bed1ffca FW	172	struct syscall_trace_exit *entry;
	173	struct syscall_metadata *sys_data;
	174	struct ring_buffer_event *event;
ee08c6ec FW	175	int syscall_nr;
	176
	177	syscall_nr = syscall_get_nr(current, regs);
fb34a08c JB	178	if (!test_bit(syscall_nr, enabled_exit_syscalls))
fb34a08c JB	179	return;
ee08c6ec	180
bed1ffca FW	181	sys_data = syscall_nr_to_meta(syscall_nr);
	182	if (!sys_data)
	183	return;
	184
64c12e04	185	event = trace_current_buffer_lock_reserve(sys_data->exit_id,
bed1ffca FW	186	sizeof(*entry), 0, 0);
	187	if (!event)
	188	return;
	189
	190	entry = ring_buffer_event_data(event);
	191	entry->nr = syscall_nr;
	192	entry->ret = syscall_get_return_value(current, regs);
	193
	194	trace_current_buffer_unlock_commit(event, 0, 0);
	195	trace_wake_up();
ee08c6ec FW	196	}
ee08c6ec FW	197
fb34a08c	198	int reg_event_syscall_enter(void *ptr)
ee08c6ec	199	{
fb34a08c JB	200	int ret = 0;
	201	int num;
	202	char *name;
	203
	204	name = (char *)ptr;
	205	num = syscall_name_to_nr(name);
	206	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	207	return -ENOSYS;
	208	mutex_lock(&syscall_trace_lock);
	209	if (!sys_refcount_enter)
	210	ret = register_trace_syscall_enter(ftrace_syscall_enter);
	211	if (ret) {
	212	pr_info("event trace: Could not activate"
	213	"syscall entry trace point");
	214	} else {
	215	set_bit(num, enabled_enter_syscalls);
	216	sys_refcount_enter++;
	217	}
	218	mutex_unlock(&syscall_trace_lock);
	219	return ret;
ee08c6ec FW	220	}
ee08c6ec FW	221
fb34a08c	222	void unreg_event_syscall_enter(void *ptr)
ee08c6ec	223	{
fb34a08c JB	224	int num;
fb34a08c JB	225	char *name;
ee08c6ec	226
fb34a08c JB	227	name = (char *)ptr;
	228	num = syscall_name_to_nr(name);
	229	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	230	return;
	231	mutex_lock(&syscall_trace_lock);
	232	sys_refcount_enter--;
	233	clear_bit(num, enabled_enter_syscalls);
	234	if (!sys_refcount_enter)
	235	unregister_trace_syscall_enter(ftrace_syscall_enter);
	236	mutex_unlock(&syscall_trace_lock);
	237	}
ee08c6ec	238
fb34a08c	239	int reg_event_syscall_exit(void *ptr)
ee08c6ec	240	{
fb34a08c JB	241	int ret = 0;
	242	int num;
	243	char *name;
	244
	245	name = (char *)ptr;
	246	num = syscall_name_to_nr(name);
	247	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	248	return -ENOSYS;
	249	mutex_lock(&syscall_trace_lock);
	250	if (!sys_refcount_exit)
	251	ret = register_trace_syscall_exit(ftrace_syscall_exit);
	252	if (ret) {
	253	pr_info("event trace: Could not activate"
	254	"syscall exit trace point");
	255	} else {
	256	set_bit(num, enabled_exit_syscalls);
	257	sys_refcount_exit++;
ee08c6ec	258	}
fb34a08c JB	259	mutex_unlock(&syscall_trace_lock);
	260	return ret;
	261	}
ee08c6ec	262
fb34a08c JB	263	void unreg_event_syscall_exit(void *ptr)
	264	{
	265	int num;
	266	char *name;
ee08c6ec	267
fb34a08c JB	268	name = (char *)ptr;
	269	num = syscall_name_to_nr(name);
	270	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	271	return;
	272	mutex_lock(&syscall_trace_lock);
	273	sys_refcount_exit--;
	274	clear_bit(num, enabled_exit_syscalls);
	275	if (!sys_refcount_exit)
	276	unregister_trace_syscall_exit(ftrace_syscall_exit);
	277	mutex_unlock(&syscall_trace_lock);
ee08c6ec	278	}
fb34a08c JB	279
	280	struct trace_event event_syscall_enter = {
	281	.trace = print_syscall_enter,
fb34a08c JB	282	};
	283
	284	struct trace_event event_syscall_exit = {
	285	.trace = print_syscall_exit,
fb34a08c	286	};
f4b5ffcc JB	287
f4b5ffcc JB	288	#ifdef CONFIG_EVENT_PROFILE
19007a67 FW	289
	290	struct syscall_enter_record {
	291	struct trace_entry entry;
	292	unsigned long args[0];
	293	};
	294
	295	struct syscall_exit_record {
	296	struct trace_entry entry;
	297	unsigned long ret;
	298	};
	299
f4b5ffcc JB	300	static DECLARE_BITMAP(enabled_prof_enter_syscalls, FTRACE_SYSCALL_MAX);
	301	static DECLARE_BITMAP(enabled_prof_exit_syscalls, FTRACE_SYSCALL_MAX);
	302	static int sys_prof_refcount_enter;
	303	static int sys_prof_refcount_exit;
	304
	305	static void prof_syscall_enter(struct pt_regs *regs, long id)
	306	{
19007a67	307	struct syscall_enter_record *rec;
f4b5ffcc JB	308	struct syscall_metadata *sys_data;
f4b5ffcc JB	309	int syscall_nr;
19007a67	310	int size;
f4b5ffcc JB	311
	312	syscall_nr = syscall_get_nr(current, regs);
	313	if (!test_bit(syscall_nr, enabled_prof_enter_syscalls))
	314	return;
	315
	316	sys_data = syscall_nr_to_meta(syscall_nr);
	317	if (!sys_data)
	318	return;
	319
19007a67 FW	320	/* get the size after alignment with the u32 buffer size field */
	321	size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec);
	322	size = ALIGN(size + sizeof(u32), sizeof(u64));
	323	size -= sizeof(u32);
	324
	325	do {
	326	char raw_data[size];
	327
	328	/* zero the dead bytes from align to not leak stack to user */
	329	(u64 )(&raw_data[size - sizeof(u64)]) = 0ULL;
	330
	331	rec = (struct syscall_enter_record *) raw_data;
	332	tracing_generic_entry_update(&rec->entry, 0, 0);
	333	rec->entry.type = sys_data->enter_id;
	334	syscall_get_arguments(current, regs, 0, sys_data->nb_args,
	335	(unsigned long *)&rec->args);
	336	perf_tpcounter_event(sys_data->enter_id, 0, 1, rec, size);
	337	} while(0);
f4b5ffcc JB	338	}
	339
	340	int reg_prof_syscall_enter(char *name)
	341	{
	342	int ret = 0;
	343	int num;
	344
	345	num = syscall_name_to_nr(name);
	346	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	347	return -ENOSYS;
	348
	349	mutex_lock(&syscall_trace_lock);
	350	if (!sys_prof_refcount_enter)
	351	ret = register_trace_syscall_enter(prof_syscall_enter);
	352	if (ret) {
	353	pr_info("event trace: Could not activate"
	354	"syscall entry trace point");
	355	} else {
	356	set_bit(num, enabled_prof_enter_syscalls);
	357	sys_prof_refcount_enter++;
	358	}
	359	mutex_unlock(&syscall_trace_lock);
	360	return ret;
	361	}
	362
	363	void unreg_prof_syscall_enter(char *name)
	364	{
	365	int num;
	366
	367	num = syscall_name_to_nr(name);
	368	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	369	return;
	370
	371	mutex_lock(&syscall_trace_lock);
	372	sys_prof_refcount_enter--;
	373	clear_bit(num, enabled_prof_enter_syscalls);
	374	if (!sys_prof_refcount_enter)
	375	unregister_trace_syscall_enter(prof_syscall_enter);
	376	mutex_unlock(&syscall_trace_lock);
	377	}
	378
	379	static void prof_syscall_exit(struct pt_regs *regs, long ret)
	380	{
	381	struct syscall_metadata *sys_data;
19007a67	382	struct syscall_exit_record rec;
f4b5ffcc JB	383	int syscall_nr;
	384
	385	syscall_nr = syscall_get_nr(current, regs);
	386	if (!test_bit(syscall_nr, enabled_prof_exit_syscalls))
	387	return;
	388
	389	sys_data = syscall_nr_to_meta(syscall_nr);
	390	if (!sys_data)
	391	return;
	392
19007a67 FW	393	tracing_generic_entry_update(&rec.entry, 0, 0);
	394	rec.entry.type = sys_data->exit_id;
	395	rec.ret = syscall_get_return_value(current, regs);
	396
	397	perf_tpcounter_event(sys_data->exit_id, 0, 1, &rec, sizeof(rec));
f4b5ffcc JB	398	}
	399
	400	int reg_prof_syscall_exit(char *name)
	401	{
	402	int ret = 0;
	403	int num;
	404
	405	num = syscall_name_to_nr(name);
	406	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	407	return -ENOSYS;
	408
	409	mutex_lock(&syscall_trace_lock);
	410	if (!sys_prof_refcount_exit)
	411	ret = register_trace_syscall_exit(prof_syscall_exit);
	412	if (ret) {
	413	pr_info("event trace: Could not activate"
	414	"syscall entry trace point");
	415	} else {
	416	set_bit(num, enabled_prof_exit_syscalls);
	417	sys_prof_refcount_exit++;
	418	}
	419	mutex_unlock(&syscall_trace_lock);
	420	return ret;
	421	}
	422
	423	void unreg_prof_syscall_exit(char *name)
	424	{
	425	int num;
	426
	427	num = syscall_name_to_nr(name);
	428	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	429	return;
	430
	431	mutex_lock(&syscall_trace_lock);
	432	sys_prof_refcount_exit--;
	433	clear_bit(num, enabled_prof_exit_syscalls);
	434	if (!sys_prof_refcount_exit)
	435	unregister_trace_syscall_exit(prof_syscall_exit);
	436	mutex_unlock(&syscall_trace_lock);
	437	}
	438
	439	#endif
	440
	441