[net-next-2.6.git] / kernel / trace / trace_syscalls.c

#include <trace/syscall.h>
#include <trace/events/syscalls.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, NR_syscalls);
static DECLARE_BITMAP(enabled_exit_syscalls, NR_syscalls);

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;
	}

	ret = trace_seq_putc(s, ')');
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

end:
	ret =  trace_seq_putc(s, '\n');
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	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;
}

extern char *__bad_type_size(void);

#define SYSCALL_FIELD(type, name)					\
	sizeof(type) != sizeof(trace.name) ?				\
		__bad_type_size() :					\
		#type, #name, offsetof(typeof(trace), name), sizeof(trace.name)

int syscall_enter_format(struct ftrace_event_call *call, struct trace_seq *s)
{
	int i;
	int nr;
	int ret;
	struct syscall_metadata *entry;
	struct syscall_trace_enter trace;
	int offset = offsetof(struct syscall_trace_enter, args);

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

	if (!entry)
		return 0;

	ret = trace_seq_printf(s, "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n",
			       SYSCALL_FIELD(int, nr));
	if (!ret)
		return 0;

	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:%zu;\n", offset,
				       sizeof(unsigned long));
		if (!ret)
			return 0;
		offset += sizeof(unsigned long);
	}

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

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

	return trace_seq_putc(s, '\n');
}

int syscall_exit_format(struct ftrace_event_call *call, struct trace_seq *s)
{
	int ret;
	struct syscall_trace_exit trace;

	ret = trace_seq_printf(s,
			       "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
			       "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n",
			       SYSCALL_FIELD(int, nr),
			       SYSCALL_FIELD(unsigned long, ret));
	if (!ret)
		return 0;

	return trace_seq_printf(s, "\nprint fmt: \"0x%%lx\", REC->ret\n");
}

int syscall_enter_define_fields(struct ftrace_event_call *call)
{
	struct syscall_trace_enter trace;
	struct syscall_metadata *meta;
	int ret;
	int nr;
	int i;
	int offset = offsetof(typeof(trace), args);

	nr = syscall_name_to_nr(call->data);
	meta = syscall_nr_to_meta(nr);

	if (!meta)
		return 0;

	ret = trace_define_common_fields(call);
	if (ret)
		return ret;

	for (i = 0; i < meta->nb_args; i++) {
		ret = trace_define_field(call, meta->types[i],
					 meta->args[i], offset,
					 sizeof(unsigned long), 0,
					 FILTER_OTHER);
		offset += sizeof(unsigned long);
	}

	return ret;
}

int syscall_exit_define_fields(struct ftrace_event_call *call)
{
	struct syscall_trace_exit trace;
	int ret;

	ret = trace_define_common_fields(call);
	if (ret)
		return ret;

	ret = trace_define_field(call, SYSCALL_FIELD(unsigned long, ret), 0,
				 FILTER_OTHER);

	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 (syscall_nr < 0)
		return;
	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);

	if (!filter_current_check_discard(sys_data->enter_event, entry, event))
		trace_current_buffer_unlock_commit(event, 0, 0);
}

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 (syscall_nr < 0)
		return;
	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);

	if (!filter_current_check_discard(sys_data->exit_event, entry, event))
		trace_current_buffer_unlock_commit(event, 0, 0);
}

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 >= NR_syscalls)
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
	if (!sys_refcount_enter)
		ret = register_trace_sys_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 >= NR_syscalls)
		return;
	mutex_lock(&syscall_trace_lock);
	sys_refcount_enter--;
	clear_bit(num, enabled_enter_syscalls);
	if (!sys_refcount_enter)
		unregister_trace_sys_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 >= NR_syscalls)
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
	if (!sys_refcount_exit)
		ret = register_trace_sys_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 >= NR_syscalls)
		return;
	mutex_lock(&syscall_trace_lock);
	sys_refcount_exit--;
	clear_bit(num, enabled_exit_syscalls);
	if (!sys_refcount_exit)
		unregister_trace_sys_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

static DECLARE_BITMAP(enabled_prof_enter_syscalls, NR_syscalls);
static DECLARE_BITMAP(enabled_prof_exit_syscalls, NR_syscalls);
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_trace_enter *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_trace_enter *) raw_data;
		tracing_generic_entry_update(&rec->ent, 0, 0);
		rec->ent.type = sys_data->enter_id;
		rec->nr = syscall_nr;
		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 >= NR_syscalls)
		return -ENOSYS;

	mutex_lock(&syscall_trace_lock);
	if (!sys_prof_refcount_enter)
		ret = register_trace_sys_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 >= NR_syscalls)
		return;

	mutex_lock(&syscall_trace_lock);
	sys_prof_refcount_enter--;
	clear_bit(num, enabled_prof_enter_syscalls);
	if (!sys_prof_refcount_enter)
		unregister_trace_sys_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_trace_exit 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.ent, 0, 0);
	rec.ent.type = sys_data->exit_id;
	rec.nr = syscall_nr;
	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 >= NR_syscalls)
		return -ENOSYS;

	mutex_lock(&syscall_trace_lock);
	if (!sys_prof_refcount_exit)
		ret = register_trace_sys_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 >= NR_syscalls)
		return;

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

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