[GitHub/mt8127/android_kernel_alcatel_ttab.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, 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;
	}

	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 (!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 (!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 >= FTRACE_SYSCALL_MAX)
		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 >= FTRACE_SYSCALL_MAX)
		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 >= FTRACE_SYSCALL_MAX)
		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 >= FTRACE_SYSCALL_MAX)
		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, 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_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 >= FTRACE_SYSCALL_MAX)
		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 >= 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_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 >= FTRACE_SYSCALL_MAX)
		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 >= 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_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;
	13	static int sys_refcount_exit;
	14	static DECLARE_BITMAP(enabled_enter_syscalls, FTRACE_SYSCALL_MAX);
	15	static DECLARE_BITMAP(enabled_exit_syscalls, FTRACE_SYSCALL_MAX);
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);
fb34a08c JB	230	if (!test_bit(syscall_nr, enabled_enter_syscalls))
fb34a08c JB	231	return;
ee08c6ec	232
bed1ffca FW	233	sys_data = syscall_nr_to_meta(syscall_nr);
	234	if (!sys_data)
	235	return;
	236
	237	size = sizeof(entry) + sizeof(unsigned long) sys_data->nb_args;
	238
64c12e04	239	event = trace_current_buffer_lock_reserve(sys_data->enter_id, size,
bed1ffca FW	240	0, 0);
	241	if (!event)
	242	return;
	243
	244	entry = ring_buffer_event_data(event);
	245	entry->nr = syscall_nr;
	246	syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);
	247
540b7b8d LZ	248	if (!filter_current_check_discard(sys_data->enter_event, entry, event))
540b7b8d LZ	249	trace_current_buffer_unlock_commit(event, 0, 0);
ee08c6ec FW	250	}
ee08c6ec FW	251
fb34a08c	252	void ftrace_syscall_exit(struct pt_regs *regs, long ret)
ee08c6ec	253	{
bed1ffca FW	254	struct syscall_trace_exit *entry;
	255	struct syscall_metadata *sys_data;
	256	struct ring_buffer_event *event;
ee08c6ec FW	257	int syscall_nr;
	258
	259	syscall_nr = syscall_get_nr(current, regs);
fb34a08c JB	260	if (!test_bit(syscall_nr, enabled_exit_syscalls))
fb34a08c JB	261	return;
ee08c6ec	262
bed1ffca FW	263	sys_data = syscall_nr_to_meta(syscall_nr);
	264	if (!sys_data)
	265	return;
	266
64c12e04	267	event = trace_current_buffer_lock_reserve(sys_data->exit_id,
bed1ffca FW	268	sizeof(*entry), 0, 0);
	269	if (!event)
	270	return;
	271
	272	entry = ring_buffer_event_data(event);
	273	entry->nr = syscall_nr;
	274	entry->ret = syscall_get_return_value(current, regs);
	275
540b7b8d LZ	276	if (!filter_current_check_discard(sys_data->exit_event, entry, event))
540b7b8d LZ	277	trace_current_buffer_unlock_commit(event, 0, 0);
ee08c6ec FW	278	}
ee08c6ec FW	279
fb34a08c	280	int reg_event_syscall_enter(void *ptr)
ee08c6ec	281	{
fb34a08c JB	282	int ret = 0;
	283	int num;
	284	char *name;
	285
	286	name = (char *)ptr;
	287	num = syscall_name_to_nr(name);
	288	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	289	return -ENOSYS;
	290	mutex_lock(&syscall_trace_lock);
	291	if (!sys_refcount_enter)
1c569f02	292	ret = register_trace_sys_enter(ftrace_syscall_enter);
fb34a08c JB	293	if (ret) {
	294	pr_info("event trace: Could not activate"
	295	"syscall entry trace point");
	296	} else {
	297	set_bit(num, enabled_enter_syscalls);
	298	sys_refcount_enter++;
	299	}
	300	mutex_unlock(&syscall_trace_lock);
	301	return ret;
ee08c6ec FW	302	}
ee08c6ec FW	303
fb34a08c	304	void unreg_event_syscall_enter(void *ptr)
ee08c6ec	305	{
fb34a08c JB	306	int num;
fb34a08c JB	307	char *name;
ee08c6ec	308
fb34a08c JB	309	name = (char *)ptr;
	310	num = syscall_name_to_nr(name);
	311	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	312	return;
	313	mutex_lock(&syscall_trace_lock);
	314	sys_refcount_enter--;
	315	clear_bit(num, enabled_enter_syscalls);
	316	if (!sys_refcount_enter)
1c569f02	317	unregister_trace_sys_enter(ftrace_syscall_enter);
fb34a08c JB	318	mutex_unlock(&syscall_trace_lock);
fb34a08c JB	319	}
ee08c6ec	320
fb34a08c	321	int reg_event_syscall_exit(void *ptr)
ee08c6ec	322	{
fb34a08c JB	323	int ret = 0;
	324	int num;
	325	char *name;
	326
	327	name = (char *)ptr;
	328	num = syscall_name_to_nr(name);
	329	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	330	return -ENOSYS;
	331	mutex_lock(&syscall_trace_lock);
	332	if (!sys_refcount_exit)
1c569f02	333	ret = register_trace_sys_exit(ftrace_syscall_exit);
fb34a08c JB	334	if (ret) {
	335	pr_info("event trace: Could not activate"
	336	"syscall exit trace point");
	337	} else {
	338	set_bit(num, enabled_exit_syscalls);
	339	sys_refcount_exit++;
ee08c6ec	340	}
fb34a08c JB	341	mutex_unlock(&syscall_trace_lock);
	342	return ret;
	343	}
ee08c6ec	344
fb34a08c JB	345	void unreg_event_syscall_exit(void *ptr)
	346	{
	347	int num;
	348	char *name;
ee08c6ec	349
fb34a08c JB	350	name = (char *)ptr;
	351	num = syscall_name_to_nr(name);
	352	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	353	return;
	354	mutex_lock(&syscall_trace_lock);
	355	sys_refcount_exit--;
	356	clear_bit(num, enabled_exit_syscalls);
	357	if (!sys_refcount_exit)
1c569f02	358	unregister_trace_sys_exit(ftrace_syscall_exit);
fb34a08c	359	mutex_unlock(&syscall_trace_lock);
ee08c6ec	360	}
fb34a08c JB	361
	362	struct trace_event event_syscall_enter = {
	363	.trace = print_syscall_enter,
fb34a08c JB	364	};
	365
	366	struct trace_event event_syscall_exit = {
	367	.trace = print_syscall_exit,
fb34a08c	368	};
f4b5ffcc JB	369
f4b5ffcc JB	370	#ifdef CONFIG_EVENT_PROFILE
19007a67	371
f4b5ffcc JB	372	static DECLARE_BITMAP(enabled_prof_enter_syscalls, FTRACE_SYSCALL_MAX);
	373	static DECLARE_BITMAP(enabled_prof_exit_syscalls, FTRACE_SYSCALL_MAX);
	374	static int sys_prof_refcount_enter;
	375	static int sys_prof_refcount_exit;
	376
	377	static void prof_syscall_enter(struct pt_regs *regs, long id)
	378	{
e6971969	379	struct syscall_trace_enter *rec;
f4b5ffcc JB	380	struct syscall_metadata *sys_data;
f4b5ffcc JB	381	int syscall_nr;
19007a67	382	int size;
f4b5ffcc JB	383
	384	syscall_nr = syscall_get_nr(current, regs);
	385	if (!test_bit(syscall_nr, enabled_prof_enter_syscalls))
	386	return;
	387
	388	sys_data = syscall_nr_to_meta(syscall_nr);
	389	if (!sys_data)
	390	return;
	391
19007a67 FW	392	/* get the size after alignment with the u32 buffer size field */
	393	size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec);
	394	size = ALIGN(size + sizeof(u32), sizeof(u64));
	395	size -= sizeof(u32);
	396
	397	do {
	398	char raw_data[size];
	399
	400	/* zero the dead bytes from align to not leak stack to user */
	401	(u64 )(&raw_data[size - sizeof(u64)]) = 0ULL;
	402
e6971969 LZ	403	rec = (struct syscall_trace_enter *) raw_data;
	404	tracing_generic_entry_update(&rec->ent, 0, 0);
	405	rec->ent.type = sys_data->enter_id;
	406	rec->nr = syscall_nr;
19007a67 FW	407	syscall_get_arguments(current, regs, 0, sys_data->nb_args,
	408	(unsigned long *)&rec->args);
	409	perf_tpcounter_event(sys_data->enter_id, 0, 1, rec, size);
	410	} while(0);
f4b5ffcc JB	411	}
	412
	413	int reg_prof_syscall_enter(char *name)
	414	{
	415	int ret = 0;
	416	int num;
	417
	418	num = syscall_name_to_nr(name);
	419	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	420	return -ENOSYS;
	421
	422	mutex_lock(&syscall_trace_lock);
	423	if (!sys_prof_refcount_enter)
1c569f02	424	ret = register_trace_sys_enter(prof_syscall_enter);
f4b5ffcc JB	425	if (ret) {
	426	pr_info("event trace: Could not activate"
	427	"syscall entry trace point");
	428	} else {
	429	set_bit(num, enabled_prof_enter_syscalls);
	430	sys_prof_refcount_enter++;
	431	}
	432	mutex_unlock(&syscall_trace_lock);
	433	return ret;
	434	}
	435
	436	void unreg_prof_syscall_enter(char *name)
	437	{
	438	int num;
	439
	440	num = syscall_name_to_nr(name);
	441	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	442	return;
	443
	444	mutex_lock(&syscall_trace_lock);
	445	sys_prof_refcount_enter--;
	446	clear_bit(num, enabled_prof_enter_syscalls);
	447	if (!sys_prof_refcount_enter)
1c569f02	448	unregister_trace_sys_enter(prof_syscall_enter);
f4b5ffcc JB	449	mutex_unlock(&syscall_trace_lock);
	450	}
	451
	452	static void prof_syscall_exit(struct pt_regs *regs, long ret)
	453	{
	454	struct syscall_metadata *sys_data;
e6971969	455	struct syscall_trace_exit rec;
f4b5ffcc JB	456	int syscall_nr;
	457
	458	syscall_nr = syscall_get_nr(current, regs);
	459	if (!test_bit(syscall_nr, enabled_prof_exit_syscalls))
	460	return;
	461
	462	sys_data = syscall_nr_to_meta(syscall_nr);
	463	if (!sys_data)
	464	return;
	465
e6971969 LZ	466	tracing_generic_entry_update(&rec.ent, 0, 0);
	467	rec.ent.type = sys_data->exit_id;
	468	rec.nr = syscall_nr;
19007a67 FW	469	rec.ret = syscall_get_return_value(current, regs);
	470
	471	perf_tpcounter_event(sys_data->exit_id, 0, 1, &rec, sizeof(rec));
f4b5ffcc JB	472	}
	473
	474	int reg_prof_syscall_exit(char *name)
	475	{
	476	int ret = 0;
	477	int num;
	478
	479	num = syscall_name_to_nr(name);
	480	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	481	return -ENOSYS;
	482
	483	mutex_lock(&syscall_trace_lock);
	484	if (!sys_prof_refcount_exit)
1c569f02	485	ret = register_trace_sys_exit(prof_syscall_exit);
f4b5ffcc JB	486	if (ret) {
	487	pr_info("event trace: Could not activate"
	488	"syscall entry trace point");
	489	} else {
	490	set_bit(num, enabled_prof_exit_syscalls);
	491	sys_prof_refcount_exit++;
	492	}
	493	mutex_unlock(&syscall_trace_lock);
	494	return ret;
	495	}
	496
	497	void unreg_prof_syscall_exit(char *name)
	498	{
	499	int num;
	500
	501	num = syscall_name_to_nr(name);
	502	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	503	return;
	504
	505	mutex_lock(&syscall_trace_lock);
	506	sys_prof_refcount_exit--;
	507	clear_bit(num, enabled_prof_exit_syscalls);
	508	if (!sys_prof_refcount_exit)
1c569f02	509	unregister_trace_sys_exit(prof_syscall_exit);
f4b5ffcc JB	510	mutex_unlock(&syscall_trace_lock);
	511	}
	512
	513	#endif
	514
	515