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