[deliverable/linux.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_event.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_metadata *sys_data;
	struct syscall_trace_enter *rec;
	unsigned long flags;
	char *raw_data;
	int syscall_nr;
	int size;
	int cpu;

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

	if (WARN_ONCE(size > FTRACE_MAX_PROFILE_SIZE,
		      "profile buffer not large enough"))
		return;

	/* Protect the per cpu buffer, begin the rcu read side */
	local_irq_save(flags);

	cpu = smp_processor_id();

	if (in_nmi())
		raw_data = rcu_dereference(trace_profile_buf_nmi);
	else
		raw_data = rcu_dereference(trace_profile_buf);

	if (!raw_data)
		goto end;

	raw_data = per_cpu_ptr(raw_data, cpu);

	/* 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_tp_event(sys_data->enter_id, 0, 1, rec, size);

end:
	local_irq_restore(flags);
}

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;
	unsigned long flags;
	int syscall_nr;
	char *raw_data;
	int size;
	int cpu;

	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;

	/* We can probably do that at build time */
	size = ALIGN(sizeof(*rec) + sizeof(u32), sizeof(u64));
	size -= sizeof(u32);

	/*
	 * Impossible, but be paranoid with the future
	 * How to put this check outside runtime?
	 */
	if (WARN_ONCE(size > FTRACE_MAX_PROFILE_SIZE,
		"exit event has grown above profile buffer size"))
		return;

	/* Protect the per cpu buffer, begin the rcu read side */
	local_irq_save(flags);
	cpu = smp_processor_id();

	if (in_nmi())
		raw_data = rcu_dereference(trace_profile_buf_nmi);
	else
		raw_data = rcu_dereference(trace_profile_buf);

	if (!raw_data)
		goto end;

	raw_data = per_cpu_ptr(raw_data, cpu);

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

	rec = (struct syscall_trace_exit *)raw_data;

	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_tp_event(sys_data->exit_id, 0, 1, rec, size);

end:
	local_irq_restore(flags);
}

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>
cdd6c482	5	#include <linux/perf_event.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	{
	387	struct syscall_metadata *sys_data;
20ab4425 FW	388	struct syscall_trace_enter *rec;
	389	unsigned long flags;
	390	char *raw_data;
f4b5ffcc	391	int syscall_nr;
19007a67	392	int size;
20ab4425	393	int cpu;
f4b5ffcc JB	394
	395	syscall_nr = syscall_get_nr(current, regs);
	396	if (!test_bit(syscall_nr, enabled_prof_enter_syscalls))
	397	return;
	398
	399	sys_data = syscall_nr_to_meta(syscall_nr);
	400	if (!sys_data)
	401	return;
	402
19007a67 FW	403	/* get the size after alignment with the u32 buffer size field */
	404	size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec);
	405	size = ALIGN(size + sizeof(u32), sizeof(u64));
	406	size -= sizeof(u32);
	407
20ab4425 FW	408	if (WARN_ONCE(size > FTRACE_MAX_PROFILE_SIZE,
	409	"profile buffer not large enough"))
	410	return;
	411
	412	/* Protect the per cpu buffer, begin the rcu read side */
	413	local_irq_save(flags);
19007a67	414
20ab4425 FW	415	cpu = smp_processor_id();
	416
	417	if (in_nmi())
	418	raw_data = rcu_dereference(trace_profile_buf_nmi);
	419	else
	420	raw_data = rcu_dereference(trace_profile_buf);
	421
	422	if (!raw_data)
	423	goto end;
19007a67	424
20ab4425 FW	425	raw_data = per_cpu_ptr(raw_data, cpu);
	426
	427	/* zero the dead bytes from align to not leak stack to user */
	428	(u64 )(&raw_data[size - sizeof(u64)]) = 0ULL;
	429
	430	rec = (struct syscall_trace_enter *) raw_data;
	431	tracing_generic_entry_update(&rec->ent, 0, 0);
	432	rec->ent.type = sys_data->enter_id;
	433	rec->nr = syscall_nr;
	434	syscall_get_arguments(current, regs, 0, sys_data->nb_args,
	435	(unsigned long *)&rec->args);
43c1266c	436	perf_tp_event(sys_data->enter_id, 0, 1, rec, size);
20ab4425 FW	437
	438	end:
	439	local_irq_restore(flags);
f4b5ffcc JB	440	}
	441
	442	int reg_prof_syscall_enter(char *name)
	443	{
	444	int ret = 0;
	445	int num;
	446
	447	num = syscall_name_to_nr(name);
57421dbb	448	if (num < 0 \|\| num >= NR_syscalls)
f4b5ffcc JB	449	return -ENOSYS;
	450
	451	mutex_lock(&syscall_trace_lock);
	452	if (!sys_prof_refcount_enter)
1c569f02	453	ret = register_trace_sys_enter(prof_syscall_enter);
f4b5ffcc JB	454	if (ret) {
	455	pr_info("event trace: Could not activate"
	456	"syscall entry trace point");
	457	} else {
	458	set_bit(num, enabled_prof_enter_syscalls);
	459	sys_prof_refcount_enter++;
	460	}
	461	mutex_unlock(&syscall_trace_lock);
	462	return ret;
	463	}
	464
	465	void unreg_prof_syscall_enter(char *name)
	466	{
	467	int num;
	468
	469	num = syscall_name_to_nr(name);
57421dbb	470	if (num < 0 \|\| num >= NR_syscalls)
f4b5ffcc JB	471	return;
	472
	473	mutex_lock(&syscall_trace_lock);
	474	sys_prof_refcount_enter--;
	475	clear_bit(num, enabled_prof_enter_syscalls);
	476	if (!sys_prof_refcount_enter)
1c569f02	477	unregister_trace_sys_enter(prof_syscall_enter);
f4b5ffcc JB	478	mutex_unlock(&syscall_trace_lock);
	479	}
	480
	481	static void prof_syscall_exit(struct pt_regs *regs, long ret)
	482	{
	483	struct syscall_metadata *sys_data;
20ab4425 FW	484	struct syscall_trace_exit *rec;
20ab4425 FW	485	unsigned long flags;
f4b5ffcc	486	int syscall_nr;
20ab4425 FW	487	char *raw_data;
	488	int size;
	489	int cpu;
f4b5ffcc JB	490
	491	syscall_nr = syscall_get_nr(current, regs);
	492	if (!test_bit(syscall_nr, enabled_prof_exit_syscalls))
	493	return;
	494
	495	sys_data = syscall_nr_to_meta(syscall_nr);
	496	if (!sys_data)
	497	return;
	498
20ab4425 FW	499	/* We can probably do that at build time */
	500	size = ALIGN(sizeof(*rec) + sizeof(u32), sizeof(u64));
	501	size -= sizeof(u32);
19007a67	502
20ab4425 FW	503	/*
	504	* Impossible, but be paranoid with the future
	505	* How to put this check outside runtime?
	506	*/
	507	if (WARN_ONCE(size > FTRACE_MAX_PROFILE_SIZE,
	508	"exit event has grown above profile buffer size"))
	509	return;
	510
	511	/* Protect the per cpu buffer, begin the rcu read side */
	512	local_irq_save(flags);
	513	cpu = smp_processor_id();
	514
	515	if (in_nmi())
	516	raw_data = rcu_dereference(trace_profile_buf_nmi);
	517	else
	518	raw_data = rcu_dereference(trace_profile_buf);
	519
	520	if (!raw_data)
	521	goto end;
	522
	523	raw_data = per_cpu_ptr(raw_data, cpu);
	524
	525	/* zero the dead bytes from align to not leak stack to user */
	526	(u64 )(&raw_data[size - sizeof(u64)]) = 0ULL;
	527
	528	rec = (struct syscall_trace_exit *)raw_data;
	529
	530	tracing_generic_entry_update(&rec->ent, 0, 0);
	531	rec->ent.type = sys_data->exit_id;
	532	rec->nr = syscall_nr;
	533	rec->ret = syscall_get_return_value(current, regs);
	534
43c1266c	535	perf_tp_event(sys_data->exit_id, 0, 1, rec, size);
20ab4425 FW	536
	537	end:
	538	local_irq_restore(flags);
f4b5ffcc JB	539	}
	540
	541	int reg_prof_syscall_exit(char *name)
	542	{
	543	int ret = 0;
	544	int num;
	545
	546	num = syscall_name_to_nr(name);
57421dbb	547	if (num < 0 \|\| num >= NR_syscalls)
f4b5ffcc JB	548	return -ENOSYS;
	549
	550	mutex_lock(&syscall_trace_lock);
	551	if (!sys_prof_refcount_exit)
1c569f02	552	ret = register_trace_sys_exit(prof_syscall_exit);
f4b5ffcc JB	553	if (ret) {
	554	pr_info("event trace: Could not activate"
	555	"syscall entry trace point");
	556	} else {
	557	set_bit(num, enabled_prof_exit_syscalls);
	558	sys_prof_refcount_exit++;
	559	}
	560	mutex_unlock(&syscall_trace_lock);
	561	return ret;
	562	}
	563
	564	void unreg_prof_syscall_exit(char *name)
	565	{
	566	int num;
	567
	568	num = syscall_name_to_nr(name);
57421dbb	569	if (num < 0 \|\| num >= NR_syscalls)
f4b5ffcc JB	570	return;
	571
	572	mutex_lock(&syscall_trace_lock);
	573	sys_prof_refcount_exit--;
	574	clear_bit(num, enabled_prof_exit_syscalls);
	575	if (!sys_prof_refcount_exit)
1c569f02	576	unregister_trace_sys_exit(prof_syscall_exit);
f4b5ffcc JB	577	mutex_unlock(&syscall_trace_lock);
	578	}
	579
	580	#endif
	581
	582