[mirror_ubuntu-bionic-kernel.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;
}

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

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

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

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

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_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_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_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
e6971969 LZ	93	extern char *__bad_type_size(void);
	94
	95	#define SYSCALL_FIELD(type, name) \
	96	sizeof(type) != sizeof(trace.name) ? \
	97	__bad_type_size() : \
	98	#type, #name, offsetof(typeof(trace), name), sizeof(trace.name)
	99
10a5b66f	100	int syscall_enter_format(struct ftrace_event_call call, struct trace_seq s)
dc4ddb4c FW	101	{
	102	int i;
	103	int nr;
e6971969	104	int ret;
dc4ddb4c	105	struct syscall_metadata *entry;
e6971969 LZ	106	struct syscall_trace_enter trace;
e6971969 LZ	107	int offset = offsetof(struct syscall_trace_enter, args);
dc4ddb4c	108
e6971969	109	nr = syscall_name_to_nr(call->data);
dc4ddb4c FW	110	entry = syscall_nr_to_meta(nr);
	111
	112	if (!entry)
e6971969 LZ	113	return 0;
	114
	115	ret = trace_seq_printf(s, "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n",
	116	SYSCALL_FIELD(int, nr));
	117	if (!ret)
	118	return 0;
dc4ddb4c FW	119
	120	for (i = 0; i < entry->nb_args; i++) {
	121	ret = trace_seq_printf(s, "\tfield:%s %s;", entry->types[i],
	122	entry->args[i]);
	123	if (!ret)
	124	return 0;
e6971969	125	ret = trace_seq_printf(s, "\toffset:%d;\tsize:%zu;\n", offset,
dc4ddb4c FW	126	sizeof(unsigned long));
	127	if (!ret)
	128	return 0;
	129	offset += sizeof(unsigned long);
	130	}
	131
	132	trace_seq_printf(s, "\nprint fmt: \"");
	133	for (i = 0; i < entry->nb_args; i++) {
e6971969	134	ret = trace_seq_printf(s, "%s: 0x%%0%zulx%s", entry->args[i],
dc4ddb4c FW	135	sizeof(unsigned long),
	136	i == entry->nb_args - 1 ? "\", " : ", ");
	137	if (!ret)
	138	return 0;
	139	}
	140
	141	for (i = 0; i < entry->nb_args; i++) {
	142	ret = trace_seq_printf(s, "((unsigned long)(REC->%s))%s",
	143	entry->args[i],
	144	i == entry->nb_args - 1 ? "\n" : ", ");
	145	if (!ret)
	146	return 0;
	147	}
	148
	149	return ret;
	150	}
	151
10a5b66f LZ	152	int syscall_exit_format(struct ftrace_event_call call, struct trace_seq s)
	153	{
	154	int ret;
	155	struct syscall_trace_exit trace;
	156
	157	ret = trace_seq_printf(s,
	158	"\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
	159	"\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n",
	160	SYSCALL_FIELD(int, nr),
	161	SYSCALL_FIELD(unsigned long, ret));
	162	if (!ret)
	163	return 0;
	164
	165	return trace_seq_printf(s, "\nprint fmt: \"0x%%lx\", REC->ret\n");
	166	}
	167
fb34a08c	168	void ftrace_syscall_enter(struct pt_regs *regs, long id)
ee08c6ec	169	{
bed1ffca FW	170	struct syscall_trace_enter *entry;
	171	struct syscall_metadata *sys_data;
	172	struct ring_buffer_event *event;
	173	int size;
ee08c6ec FW	174	int syscall_nr;
	175
	176	syscall_nr = syscall_get_nr(current, regs);
fb34a08c JB	177	if (!test_bit(syscall_nr, enabled_enter_syscalls))
fb34a08c JB	178	return;
ee08c6ec	179
bed1ffca FW	180	sys_data = syscall_nr_to_meta(syscall_nr);
	181	if (!sys_data)
	182	return;
	183
	184	size = sizeof(entry) + sizeof(unsigned long) sys_data->nb_args;
	185
64c12e04	186	event = trace_current_buffer_lock_reserve(sys_data->enter_id, size,
bed1ffca FW	187	0, 0);
	188	if (!event)
	189	return;
	190
	191	entry = ring_buffer_event_data(event);
	192	entry->nr = syscall_nr;
	193	syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);
	194
	195	trace_current_buffer_unlock_commit(event, 0, 0);
	196	trace_wake_up();
ee08c6ec FW	197	}
ee08c6ec FW	198
fb34a08c	199	void ftrace_syscall_exit(struct pt_regs *regs, long ret)
ee08c6ec	200	{
bed1ffca FW	201	struct syscall_trace_exit *entry;
	202	struct syscall_metadata *sys_data;
	203	struct ring_buffer_event *event;
ee08c6ec FW	204	int syscall_nr;
	205
	206	syscall_nr = syscall_get_nr(current, regs);
fb34a08c JB	207	if (!test_bit(syscall_nr, enabled_exit_syscalls))
fb34a08c JB	208	return;
ee08c6ec	209
bed1ffca FW	210	sys_data = syscall_nr_to_meta(syscall_nr);
	211	if (!sys_data)
	212	return;
	213
64c12e04	214	event = trace_current_buffer_lock_reserve(sys_data->exit_id,
bed1ffca FW	215	sizeof(*entry), 0, 0);
	216	if (!event)
	217	return;
	218
	219	entry = ring_buffer_event_data(event);
	220	entry->nr = syscall_nr;
	221	entry->ret = syscall_get_return_value(current, regs);
	222
	223	trace_current_buffer_unlock_commit(event, 0, 0);
	224	trace_wake_up();
ee08c6ec FW	225	}
ee08c6ec FW	226
fb34a08c	227	int reg_event_syscall_enter(void *ptr)
ee08c6ec	228	{
fb34a08c JB	229	int ret = 0;
	230	int num;
	231	char *name;
	232
	233	name = (char *)ptr;
	234	num = syscall_name_to_nr(name);
	235	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	236	return -ENOSYS;
	237	mutex_lock(&syscall_trace_lock);
	238	if (!sys_refcount_enter)
	239	ret = register_trace_syscall_enter(ftrace_syscall_enter);
	240	if (ret) {
	241	pr_info("event trace: Could not activate"
	242	"syscall entry trace point");
	243	} else {
	244	set_bit(num, enabled_enter_syscalls);
	245	sys_refcount_enter++;
	246	}
	247	mutex_unlock(&syscall_trace_lock);
	248	return ret;
ee08c6ec FW	249	}
ee08c6ec FW	250
fb34a08c	251	void unreg_event_syscall_enter(void *ptr)
ee08c6ec	252	{
fb34a08c JB	253	int num;
fb34a08c JB	254	char *name;
ee08c6ec	255
fb34a08c JB	256	name = (char *)ptr;
	257	num = syscall_name_to_nr(name);
	258	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	259	return;
	260	mutex_lock(&syscall_trace_lock);
	261	sys_refcount_enter--;
	262	clear_bit(num, enabled_enter_syscalls);
	263	if (!sys_refcount_enter)
	264	unregister_trace_syscall_enter(ftrace_syscall_enter);
	265	mutex_unlock(&syscall_trace_lock);
	266	}
ee08c6ec	267
fb34a08c	268	int reg_event_syscall_exit(void *ptr)
ee08c6ec	269	{
fb34a08c JB	270	int ret = 0;
	271	int num;
	272	char *name;
	273
	274	name = (char *)ptr;
	275	num = syscall_name_to_nr(name);
	276	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	277	return -ENOSYS;
	278	mutex_lock(&syscall_trace_lock);
	279	if (!sys_refcount_exit)
	280	ret = register_trace_syscall_exit(ftrace_syscall_exit);
	281	if (ret) {
	282	pr_info("event trace: Could not activate"
	283	"syscall exit trace point");
	284	} else {
	285	set_bit(num, enabled_exit_syscalls);
	286	sys_refcount_exit++;
ee08c6ec	287	}
fb34a08c JB	288	mutex_unlock(&syscall_trace_lock);
	289	return ret;
	290	}
ee08c6ec	291
fb34a08c JB	292	void unreg_event_syscall_exit(void *ptr)
	293	{
	294	int num;
	295	char *name;
ee08c6ec	296
fb34a08c JB	297	name = (char *)ptr;
	298	num = syscall_name_to_nr(name);
	299	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	300	return;
	301	mutex_lock(&syscall_trace_lock);
	302	sys_refcount_exit--;
	303	clear_bit(num, enabled_exit_syscalls);
	304	if (!sys_refcount_exit)
	305	unregister_trace_syscall_exit(ftrace_syscall_exit);
	306	mutex_unlock(&syscall_trace_lock);
ee08c6ec	307	}
fb34a08c JB	308
	309	struct trace_event event_syscall_enter = {
	310	.trace = print_syscall_enter,
fb34a08c JB	311	};
	312
	313	struct trace_event event_syscall_exit = {
	314	.trace = print_syscall_exit,
fb34a08c	315	};
f4b5ffcc JB	316
f4b5ffcc JB	317	#ifdef CONFIG_EVENT_PROFILE
19007a67	318
f4b5ffcc JB	319	static DECLARE_BITMAP(enabled_prof_enter_syscalls, FTRACE_SYSCALL_MAX);
	320	static DECLARE_BITMAP(enabled_prof_exit_syscalls, FTRACE_SYSCALL_MAX);
	321	static int sys_prof_refcount_enter;
	322	static int sys_prof_refcount_exit;
	323
	324	static void prof_syscall_enter(struct pt_regs *regs, long id)
	325	{
e6971969	326	struct syscall_trace_enter *rec;
f4b5ffcc JB	327	struct syscall_metadata *sys_data;
f4b5ffcc JB	328	int syscall_nr;
19007a67	329	int size;
f4b5ffcc JB	330
	331	syscall_nr = syscall_get_nr(current, regs);
	332	if (!test_bit(syscall_nr, enabled_prof_enter_syscalls))
	333	return;
	334
	335	sys_data = syscall_nr_to_meta(syscall_nr);
	336	if (!sys_data)
	337	return;
	338
19007a67 FW	339	/* get the size after alignment with the u32 buffer size field */
	340	size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec);
	341	size = ALIGN(size + sizeof(u32), sizeof(u64));
	342	size -= sizeof(u32);
	343
	344	do {
	345	char raw_data[size];
	346
	347	/* zero the dead bytes from align to not leak stack to user */
	348	(u64 )(&raw_data[size - sizeof(u64)]) = 0ULL;
	349
e6971969 LZ	350	rec = (struct syscall_trace_enter *) raw_data;
	351	tracing_generic_entry_update(&rec->ent, 0, 0);
	352	rec->ent.type = sys_data->enter_id;
	353	rec->nr = syscall_nr;
19007a67 FW	354	syscall_get_arguments(current, regs, 0, sys_data->nb_args,
	355	(unsigned long *)&rec->args);
	356	perf_tpcounter_event(sys_data->enter_id, 0, 1, rec, size);
	357	} while(0);
f4b5ffcc JB	358	}
	359
	360	int reg_prof_syscall_enter(char *name)
	361	{
	362	int ret = 0;
	363	int num;
	364
	365	num = syscall_name_to_nr(name);
	366	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	367	return -ENOSYS;
	368
	369	mutex_lock(&syscall_trace_lock);
	370	if (!sys_prof_refcount_enter)
	371	ret = register_trace_syscall_enter(prof_syscall_enter);
	372	if (ret) {
	373	pr_info("event trace: Could not activate"
	374	"syscall entry trace point");
	375	} else {
	376	set_bit(num, enabled_prof_enter_syscalls);
	377	sys_prof_refcount_enter++;
	378	}
	379	mutex_unlock(&syscall_trace_lock);
	380	return ret;
	381	}
	382
	383	void unreg_prof_syscall_enter(char *name)
	384	{
	385	int num;
	386
	387	num = syscall_name_to_nr(name);
	388	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	389	return;
	390
	391	mutex_lock(&syscall_trace_lock);
	392	sys_prof_refcount_enter--;
	393	clear_bit(num, enabled_prof_enter_syscalls);
	394	if (!sys_prof_refcount_enter)
	395	unregister_trace_syscall_enter(prof_syscall_enter);
	396	mutex_unlock(&syscall_trace_lock);
	397	}
	398
	399	static void prof_syscall_exit(struct pt_regs *regs, long ret)
	400	{
	401	struct syscall_metadata *sys_data;
e6971969	402	struct syscall_trace_exit rec;
f4b5ffcc JB	403	int syscall_nr;
	404
	405	syscall_nr = syscall_get_nr(current, regs);
	406	if (!test_bit(syscall_nr, enabled_prof_exit_syscalls))
	407	return;
	408
	409	sys_data = syscall_nr_to_meta(syscall_nr);
	410	if (!sys_data)
	411	return;
	412
e6971969 LZ	413	tracing_generic_entry_update(&rec.ent, 0, 0);
	414	rec.ent.type = sys_data->exit_id;
	415	rec.nr = syscall_nr;
19007a67 FW	416	rec.ret = syscall_get_return_value(current, regs);
	417
	418	perf_tpcounter_event(sys_data->exit_id, 0, 1, &rec, sizeof(rec));
f4b5ffcc JB	419	}
	420
	421	int reg_prof_syscall_exit(char *name)
	422	{
	423	int ret = 0;
	424	int num;
	425
	426	num = syscall_name_to_nr(name);
	427	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	428	return -ENOSYS;
	429
	430	mutex_lock(&syscall_trace_lock);
	431	if (!sys_prof_refcount_exit)
	432	ret = register_trace_syscall_exit(prof_syscall_exit);
	433	if (ret) {
	434	pr_info("event trace: Could not activate"
	435	"syscall entry trace point");
	436	} else {
	437	set_bit(num, enabled_prof_exit_syscalls);
	438	sys_prof_refcount_exit++;
	439	}
	440	mutex_unlock(&syscall_trace_lock);
	441	return ret;
	442	}
	443
	444	void unreg_prof_syscall_exit(char *name)
	445	{
	446	int num;
	447
	448	num = syscall_name_to_nr(name);
	449	if (num < 0 \|\| num >= FTRACE_SYSCALL_MAX)
	450	return;
	451
	452	mutex_lock(&syscall_trace_lock);
	453	sys_prof_refcount_exit--;
	454	clear_bit(num, enabled_prof_exit_syscalls);
	455	if (!sys_prof_refcount_exit)
	456	unregister_trace_syscall_exit(prof_syscall_exit);
	457	mutex_unlock(&syscall_trace_lock);
	458	}
	459
	460	#endif
	461
	462