Release 4.7 kernel/trace/trace_syscalls.c

Directory: kernel/trace
#include <trace/syscall.h>
#include <trace/events/syscalls.h>
#include <linux/syscalls.h>
#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/module.h>	/* for MODULE_NAME_LEN via KSYM_SYMBOL_LEN */
#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 syscall_enter_register(struct trace_event_call *event,
				 enum trace_reg type, void *data);
static int syscall_exit_register(struct trace_event_call *event,
				 enum trace_reg type, void *data);


static struct list_head *

syscall_get_enter_fields(struct trace_event_call *call)
{
	struct syscall_metadata *entry = call->data;

	return &entry->enter_fields;
}

Contributors
Person Tokens Prop Commits CommitProp
steven rostedt steven rostedt 28 100.00% 2 100.00%
Total 28 100.00% 2 100.00%

extern struct syscall_metadata *__start_syscalls_metadata[];
extern struct syscall_metadata *__stop_syscalls_metadata[];


static struct syscall_metadata **syscalls_metadata;

#ifndef ARCH_HAS_SYSCALL_MATCH_SYM_NAME


static inline bool arch_syscall_match_sym_name(const char *sym, const char *name)
{
	/*
         * Only compare after the "sys" prefix. Archs that use
         * syscall wrappers may have syscalls symbols aliases prefixed
         * with ".SyS" or ".sys" instead of "sys", leading to an unwanted
         * mismatch.
         */
	return !strcmp(sym + 3, name + 3);
}
Contributors
Person Tokens Prop Commits CommitProp
ian munsie ian munsie 30 96.77% 1 50.00%
jovi zhangwei jovi zhangwei 1 3.23% 1 50.00%
Total 31 100.00% 2 100.00%

#endif

#ifdef ARCH_TRACE_IGNORE_COMPAT_SYSCALLS
/*
 * Some architectures that allow for 32bit applications
 * to run on a 64bit kernel, do not map the syscalls for
 * the 32bit tasks the same as they do for 64bit tasks.
 *
 *     *cough*x86*cough*
 *
 * In such a case, instead of reporting the wrong syscalls,
 * simply ignore them.
 *
 * For an arch to ignore the compat syscalls it needs to
 * define ARCH_TRACE_IGNORE_COMPAT_SYSCALLS as well as
 * define the function arch_trace_is_compat_syscall() to let
 * the tracing system know that it should ignore it.
 */

static int

trace_get_syscall_nr(struct task_struct *task, struct pt_regs *regs)
{
	if (unlikely(arch_trace_is_compat_syscall(regs)))
		return -1;

	return syscall_get_nr(task, regs);
}
Contributors
Person Tokens Prop Commits CommitProp
steven rostedt steven rostedt 38 100.00% 1 100.00%
Total 38 100.00% 1 100.00%

#else

static inline int

trace_get_syscall_nr(struct task_struct *task, struct pt_regs *regs)
{
	return syscall_get_nr(task, regs);
}
Contributors
Person Tokens Prop Commits CommitProp
steven rostedt steven rostedt 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%

#endif /* ARCH_TRACE_IGNORE_COMPAT_SYSCALLS */

static __init struct syscall_metadata *

find_syscall_meta(unsigned long syscall)
{
        struct syscall_metadata **start;
        struct syscall_metadata **stop;
	char str[KSYM_SYMBOL_LEN];


	start = __start_syscalls_metadata;
	stop = __stop_syscalls_metadata;
	kallsyms_lookup(syscall, NULL, NULL, NULL, str);

	if (arch_syscall_match_sym_name(str, "sys_ni_syscall"))
		return NULL;

	for ( ; start < stop; start++) {
		if ((*start)->name && arch_syscall_match_sym_name(str, (*start)->name))
			return *start;
	}
	return NULL;

}

static 
struct syscall_metadata *syscall_nr_to_meta(int nr)
{
	if (!syscalls_metadata || nr >= NR_syscalls || nr < 0)
		return NULL;

	return syscalls_metadata[nr];
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 32 96.97% 1 50.00%
steven rostedt steven rostedt 1 3.03% 1 50.00%
Total 33 100.00% 2 100.00%



const char *get_syscall_name(int syscall)
{
	struct syscall_metadata *entry;

	entry = syscall_nr_to_meta(syscall);
	if (!entry)
		return NULL;

	return entry->name;
}

Contributors
Person Tokens Prop Commits CommitProp
tom zanussi tom zanussi 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%


static enum print_line_t

print_syscall_enter(struct trace_iterator *iter, int flags,
		    struct trace_event *event)
{
	struct trace_array *tr = iter->tr;
	struct trace_seq *s = &iter->seq;
	struct trace_entry *ent = iter->ent;
	struct syscall_trace_enter *trace;
	struct syscall_metadata *entry;
	int i, syscall;

	trace = (typeof(trace))ent;
	syscall = trace->nr;
	entry = syscall_nr_to_meta(syscall);

	if (!entry)
		goto end;

	if (entry->enter_event->event.type != ent->type) {
		WARN_ON_ONCE(1);
		goto end;
	}

	trace_seq_printf(s, "%s(", entry->name);

	for (i = 0; i < entry->nb_args; i++) {

		if (trace_seq_has_overflowed(s))
			goto end;

		/* parameter types */
		if (tr->trace_flags & TRACE_ITER_VERBOSE)
			trace_seq_printf(s, "%s ", entry->types[i]);

		/* parameter values */
		trace_seq_printf(s, "%s: %lx%s", entry->args[i],
				 trace->args[i],
				 i == entry->nb_args - 1 ? "" : ", ");
	}

	trace_seq_putc(s, ')');
end:
	trace_seq_putc(s, '\n');

	return trace_handle_return(s);
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 159 67.66% 1 10.00%
steven rostedt steven rostedt 33 14.04% 4 40.00%
jason baron jason baron 25 10.64% 1 10.00%
li zefan li zefan 15 6.38% 2 20.00%
lai jiangshan lai jiangshan 2 0.85% 1 10.00%
fengguang wu fengguang wu 1 0.43% 1 10.00%
Total 235 100.00% 10 100.00%


static enum print_line_t

print_syscall_exit(struct trace_iterator *iter, int flags,
		   struct trace_event *event)
{
	struct trace_seq *s = &iter->seq;
	struct trace_entry *ent = iter->ent;
	struct syscall_trace_exit *trace;
	int syscall;
	struct syscall_metadata *entry;

	trace = (typeof(trace))ent;
	syscall = trace->nr;
	entry = syscall_nr_to_meta(syscall);

	if (!entry) {
		trace_seq_putc(s, '\n');
		goto out;
	}

	if (entry->exit_event->event.type != ent->type) {
		WARN_ON_ONCE(1);
		return TRACE_TYPE_UNHANDLED;
	}

	trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
				trace->ret);

 out:
	return trace_handle_return(s);
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 92 66.19% 1 12.50%
jason baron jason baron 25 17.99% 1 12.50%
steven rostedt steven rostedt 17 12.23% 3 37.50%
jovi zhangwei jovi zhangwei 2 1.44% 1 12.50%
lai jiangshan lai jiangshan 2 1.44% 1 12.50%
fengguang wu fengguang wu 1 0.72% 1 12.50%
Total 139 100.00% 8 100.00%

extern char *__bad_type_size(void);


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


static int __init

__set_enter_print_fmt(struct syscall_metadata *entry, char *buf, int len)
{
	int i;
	int pos = 0;

	/* When len=0, we just calculate the needed length */

#define LEN_OR_ZERO (len ? len - pos : 0)

	pos += snprintf(buf + pos, LEN_OR_ZERO, "\"");
	for (i = 0; i < entry->nb_args; i++) {
		pos += snprintf(buf + pos, LEN_OR_ZERO, "%s: 0x%%0%zulx%s",
				entry->args[i], sizeof(unsigned long),
				i == entry->nb_args - 1 ? "" : ", ");
	}
	pos += snprintf(buf + pos, LEN_OR_ZERO, "\"");

	for (i = 0; i < entry->nb_args; i++) {
		pos += snprintf(buf + pos, LEN_OR_ZERO,
				", ((unsigned long)(REC->%s))", entry->args[i]);
	}


#undef LEN_OR_ZERO

	/* return the length of print_fmt */
	return pos;
}

Contributors
Person Tokens Prop Commits CommitProp
lai jiangshan lai jiangshan 156 99.36% 1 50.00%
li zefan li zefan 1 0.64% 1 50.00%
Total 157 100.00% 2 100.00%



static int __init set_syscall_print_fmt(struct trace_event_call *call)
{
	char *print_fmt;
	int len;
	struct syscall_metadata *entry = call->data;

	if (entry->enter_event != call) {
		call->print_fmt = "\"0x%lx\", REC->ret";
		return 0;
	}

	/* First: called with 0 length to calculate the needed length */
	len = __set_enter_print_fmt(entry, NULL, 0);

	print_fmt = kmalloc(len + 1, GFP_KERNEL);
	if (!print_fmt)
		return -ENOMEM;

	/* Second: actually write the @print_fmt */
	__set_enter_print_fmt(entry, print_fmt, len + 1);
	call->print_fmt = print_fmt;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
lai jiangshan lai jiangshan 98 98.00% 1 33.33%
steven rostedt steven rostedt 1 1.00% 1 33.33%
li zefan li zefan 1 1.00% 1 33.33%
Total 100 100.00% 3 100.00%



static void __init free_syscall_print_fmt(struct trace_event_call *call)
{
	struct syscall_metadata *entry = call->data;

	if (entry->enter_event == call)
		kfree(call->print_fmt);
}

Contributors
Person Tokens Prop Commits CommitProp
lai jiangshan lai jiangshan 34 94.44% 1 33.33%
steven rostedt steven rostedt 1 2.78% 1 33.33%
li zefan li zefan 1 2.78% 1 33.33%
Total 36 100.00% 3 100.00%



static int __init syscall_enter_define_fields(struct trace_event_call *call)
{
	struct syscall_trace_enter trace;
	struct syscall_metadata *meta = call->data;
	int ret;
	int i;
	int offset = offsetof(typeof(trace), args);

	ret = trace_define_field(call, SYSCALL_FIELD(int, nr, __syscall_nr),
				 FILTER_OTHER);
	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;
}

Contributors
Person Tokens Prop Commits CommitProp
li zefan li zefan 101 77.69% 3 37.50%
lai jiangshan lai jiangshan 25 19.23% 2 25.00%
taeung song taeung song 2 1.54% 1 12.50%
steven rostedt steven rostedt 2 1.54% 2 25.00%
Total 130 100.00% 8 100.00%



static int __init syscall_exit_define_fields(struct trace_event_call *call)
{
	struct syscall_trace_exit trace;
	int ret;

	ret = trace_define_field(call, SYSCALL_FIELD(int, nr, __syscall_nr),
				 FILTER_OTHER);
	if (ret)
		return ret;

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

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
li zefan li zefan 34 52.31% 3 37.50%
lai jiangshan lai jiangshan 23 35.38% 1 12.50%
taeung song taeung song 4 6.15% 1 12.50%
steven rostedt steven rostedt 2 3.08% 2 25.00%
tom zanussi tom zanussi 2 3.08% 1 12.50%
Total 65 100.00% 8 100.00%



static void ftrace_syscall_enter(void *data, struct pt_regs *regs, long id)
{
	struct trace_array *tr = data;
	struct trace_event_file *trace_file;
	struct syscall_trace_enter *entry;
	struct syscall_metadata *sys_data;
	struct ring_buffer_event *event;
	struct ring_buffer *buffer;
	unsigned long irq_flags;
	int pc;
	int syscall_nr;
	int size;

	syscall_nr = trace_get_syscall_nr(current, regs);
	if (syscall_nr < 0 || syscall_nr >= NR_syscalls)
		return;

	/* Here we're inside tp handler's rcu_read_lock_sched (__DO_TRACE) */
	trace_file = rcu_dereference_sched(tr->enter_syscall_files[syscall_nr]);
	if (!trace_file)
		return;

	if (trace_trigger_soft_disabled(trace_file))
		return;

	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

	size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;

	local_save_flags(irq_flags);
	pc = preempt_count();

	buffer = tr->trace_buffer.buffer;
	event = trace_buffer_lock_reserve(buffer,
			sys_data->enter_event->event.type, size, irq_flags, pc);
	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);

	event_trigger_unlock_commit(trace_file, buffer, event, entry,
				    irq_flags, pc);
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 116 50.22% 2 9.09%
steven rostedt steven rostedt 41 17.75% 9 40.91%
tom zanussi tom zanussi 26 11.26% 3 13.64%
jovi zhangwei jovi zhangwei 21 9.09% 1 4.55%
jason baron jason baron 10 4.33% 2 9.09%
hendrik brueckner hendrik brueckner 7 3.03% 1 4.55%
rabin vincent rabin vincent 4 1.73% 1 4.55%
li zefan li zefan 3 1.30% 1 4.55%
lai jiangshan lai jiangshan 2 0.87% 1 4.55%
fengguang wu fengguang wu 1 0.43% 1 4.55%
Total 231 100.00% 22 100.00%



static void ftrace_syscall_exit(void *data, struct pt_regs *regs, long ret)
{
	struct trace_array *tr = data;
	struct trace_event_file *trace_file;
	struct syscall_trace_exit *entry;
	struct syscall_metadata *sys_data;
	struct ring_buffer_event *event;
	struct ring_buffer *buffer;
	unsigned long irq_flags;
	int pc;
	int syscall_nr;

	syscall_nr = trace_get_syscall_nr(current, regs);
	if (syscall_nr < 0 || syscall_nr >= NR_syscalls)
		return;

	/* Here we're inside tp handler's rcu_read_lock_sched (__DO_TRACE()) */
	trace_file = rcu_dereference_sched(tr->exit_syscall_files[syscall_nr]);
	if (!trace_file)
		return;

	if (trace_trigger_soft_disabled(trace_file))
		return;

	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

	local_save_flags(irq_flags);
	pc = preempt_count();

	buffer = tr->trace_buffer.buffer;
	event = trace_buffer_lock_reserve(buffer,
			sys_data->exit_event->event.type, sizeof(*entry),
			irq_flags, pc);
	if (!event)
		return;

	entry = ring_buffer_event_data(event);
	entry->nr = syscall_nr;
	entry->ret = syscall_get_return_value(current, regs);

	event_trigger_unlock_commit(trace_file, buffer, event, entry,
				    irq_flags, pc);
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 95 45.67% 2 9.09%
steven rostedt steven rostedt 39 18.75% 9 40.91%
tom zanussi tom zanussi 26 12.50% 3 13.64%
jovi zhangwei jovi zhangwei 21 10.10% 1 4.55%
jason baron jason baron 10 4.81% 2 9.09%
hendrik brueckner hendrik brueckner 7 3.37% 1 4.55%
rabin vincent rabin vincent 4 1.92% 1 4.55%
li zefan li zefan 3 1.44% 1 4.55%
lai jiangshan lai jiangshan 2 0.96% 1 4.55%
fengguang wu fengguang wu 1 0.48% 1 4.55%
Total 208 100.00% 22 100.00%



static int reg_event_syscall_enter(struct trace_event_file *file,
				   struct trace_event_call *call)
{
	struct trace_array *tr = file->tr;
	int ret = 0;
	int num;

	num = ((struct syscall_metadata *)call->data)->syscall_nr;
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
	if (!tr->sys_refcount_enter)
		ret = register_trace_sys_enter(ftrace_syscall_enter, tr);
	if (!ret) {
		rcu_assign_pointer(tr->enter_syscall_files[num], file);
		tr->sys_refcount_enter++;
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
jason baron jason baron 60 50.00% 2 12.50%
steven rostedt steven rostedt 23 19.17% 4 25.00%
frederic weisbecker frederic weisbecker 12 10.00% 2 12.50%
tom zanussi tom zanussi 7 5.83% 1 6.25%
lai jiangshan lai jiangshan 7 5.83% 2 12.50%
masami hiramatsu masami hiramatsu 5 4.17% 1 6.25%
ian munsie ian munsie 3 2.50% 1 6.25%
fengguang wu fengguang wu 1 0.83% 1 6.25%
josh stone josh stone 1 0.83% 1 6.25%
li zefan li zefan 1 0.83% 1 6.25%
Total 120 100.00% 16 100.00%



static void unreg_event_syscall_enter(struct trace_event_file *file,
				      struct trace_event_call *call)
{
	struct trace_array *tr = file->tr;
	int num;

	num = ((struct syscall_metadata *)call->data)->syscall_nr;
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
		return;
	mutex_lock(&syscall_trace_lock);
	tr->sys_refcount_enter--;
	RCU_INIT_POINTER(tr->enter_syscall_files[num], NULL);
	if (!tr->sys_refcount_enter)
		unregister_trace_sys_enter(ftrace_syscall_enter, tr);
	mutex_unlock(&syscall_trace_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
jason baron jason baron 49 49.00% 2 12.50%
steven rostedt steven rostedt 23 23.00% 4 25.00%
lai jiangshan lai jiangshan 7 7.00% 2 12.50%
tom zanussi tom zanussi 6 6.00% 1 6.25%
masami hiramatsu masami hiramatsu 5 5.00% 1 6.25%
frederic weisbecker frederic weisbecker 4 4.00% 2 12.50%
ian munsie ian munsie 3 3.00% 1 6.25%
fengguang wu fengguang wu 1 1.00% 1 6.25%
josh stone josh stone 1 1.00% 1 6.25%
andreea-cristina bernat andreea-cristina bernat 1 1.00% 1 6.25%
Total 100 100.00% 16 100.00%



static int reg_event_syscall_exit(struct trace_event_file *file,
				  struct trace_event_call *call)
{
	struct trace_array *tr = file->tr;
	int ret = 0;
	int num;

	num = ((struct syscall_metadata *)call->data)->syscall_nr;
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
	if (!tr->sys_refcount_exit)
		ret = register_trace_sys_exit(ftrace_syscall_exit, tr);
	if (!ret) {
		rcu_assign_pointer(tr->exit_syscall_files[num], file);
		tr->sys_refcount_exit++;
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
jason baron jason baron 46 38.33% 2 13.33%
frederic weisbecker frederic weisbecker 23 19.17% 1 6.67%
steven rostedt steven rostedt 23 19.17% 4 26.67%
lai jiangshan lai jiangshan 10 8.33% 2 13.33%
tom zanussi tom zanussi 7 5.83% 1 6.67%
masami hiramatsu masami hiramatsu 5 4.17% 1 6.67%
ian munsie ian munsie 3 2.50% 1 6.67%
li zefan li zefan 1 0.83% 1 6.67%
josh stone josh stone 1 0.83% 1 6.67%
fengguang wu fengguang wu 1 0.83% 1 6.67%
Total 120 100.00% 15 100.00%



static void unreg_event_syscall_exit(struct trace_event_file *file,
				     struct trace_event_call *call)
{
	struct trace_array *tr = file->tr;
	int num;

	num = ((struct syscall_metadata *)call->data)->syscall_nr;
	if (WARN_ON_ONCE(num < 0 || num >= NR_syscalls))
		return;
	mutex_lock(&syscall_trace_lock);
	tr->sys_refcount_exit--;
	RCU_INIT_POINTER(tr->exit_syscall_files[num], NULL);
	if (!tr->sys_refcount_exit)
		unregister_trace_sys_exit(ftrace_syscall_exit, tr);
	mutex_unlock(&syscall_trace_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
jason baron jason baron 36 36.00% 2 13.33%
steven rostedt steven rostedt 23 23.00% 4 26.67%
frederic weisbecker frederic weisbecker 14 14.00% 1 6.67%
lai jiangshan lai jiangshan 10 10.00% 2 13.33%
tom zanussi tom zanussi 6 6.00% 1 6.67%
masami hiramatsu masami hiramatsu 5 5.00% 1 6.67%
ian munsie ian munsie 3 3.00% 1 6.67%
josh stone josh stone 1 1.00% 1 6.67%
andreea-cristina bernat andreea-cristina bernat 1 1.00% 1 6.67%
fengguang wu fengguang wu 1 1.00% 1 6.67%
Total 100 100.00% 15 100.00%



static int __init init_syscall_trace(struct trace_event_call *call)
{
	int id;
	int num;

	num = ((struct syscall_metadata *)call->data)->syscall_nr;
	if (num < 0 || num >= NR_syscalls) {
		pr_debug("syscall %s metadata not mapped, disabling ftrace event\n",
				((struct syscall_metadata *)call->data)->name);
		return -ENOSYS;
	}

	if (set_syscall_print_fmt(call) < 0)
		return -ENOMEM;

	id = trace_event_raw_init(call);

	if (id < 0) {
		free_syscall_print_fmt(call);
		return id;
	}

	return id;
}

Contributors
Person Tokens Prop Commits CommitProp
ian munsie ian munsie 52 49.06% 1 14.29%
lai jiangshan lai jiangshan 46 43.40% 2 28.57%
steven rostedt steven rostedt 6 5.66% 2 28.57%
vaibhav nagarnaik vaibhav nagarnaik 1 0.94% 1 14.29%
li zefan li zefan 1 0.94% 1 14.29%
Total 106 100.00% 7 100.00%


struct trace_event_functions enter_syscall_print_funcs = {
	.trace		= print_syscall_enter,
};


struct trace_event_functions exit_syscall_print_funcs = {
	.trace		= print_syscall_exit,
};


struct trace_event_class __refdata event_class_syscall_enter = {
	.system		= "syscalls",
	.reg		= syscall_enter_register,
	.define_fields	= syscall_enter_define_fields,
	.get_fields	= syscall_get_enter_fields,
	.raw_init	= init_syscall_trace,
};


struct trace_event_class __refdata event_class_syscall_exit = {
	.system		= "syscalls",
	.reg		= syscall_exit_register,
	.define_fields	= syscall_exit_define_fields,
	.fields		= LIST_HEAD_INIT(event_class_syscall_exit.fields),
	.raw_init	= init_syscall_trace,
};



unsigned long __init __weak arch_syscall_addr(int nr)
{
	return (unsigned long)sys_call_table[nr];
}

Contributors
Person Tokens Prop Commits CommitProp
mike frysinger mike frysinger 20 95.24% 1 50.00%
ian munsie ian munsie 1 4.76% 1 50.00%
Total 21 100.00% 2 100.00%



void __init init_ftrace_syscalls(void)
{
	struct syscall_metadata *meta;
	unsigned long addr;
	int i;

	syscalls_metadata = kcalloc(NR_syscalls, sizeof(*syscalls_metadata),
				    GFP_KERNEL);
	if (!syscalls_metadata) {
		WARN_ON(1);
		return;
	}

	for (i = 0; i < NR_syscalls; i++) {
		addr = arch_syscall_addr(i);
		meta = find_syscall_meta(addr);
		if (!meta)
			continue;

		meta->syscall_nr = i;
		syscalls_metadata[i] = meta;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 79 82.29% 1 25.00%
lai jiangshan lai jiangshan 12 12.50% 1 25.00%
thomas meyer thomas meyer 3 3.12% 1 25.00%
steven rostedt steven rostedt 2 2.08% 1 25.00%
Total 96 100.00% 4 100.00%

#ifdef CONFIG_PERF_EVENTS

static DECLARE_BITMAP(enabled_perf_enter_syscalls, NR_syscalls);
static DECLARE_BITMAP(enabled_perf_exit_syscalls, NR_syscalls);

static int sys_perf_refcount_enter;

static int sys_perf_refcount_exit;



static void perf_syscall_enter(void *ignore, struct pt_regs *regs, long id)
{
	struct syscall_metadata *sys_data;
	struct syscall_trace_enter *rec;
	struct hlist_head *head;
	int syscall_nr;
	int rctx;
	int size;

	syscall_nr = trace_get_syscall_nr(current, regs);
	if (syscall_nr < 0 || syscall_nr >= NR_syscalls)
		return;
	if (!test_bit(syscall_nr, enabled_perf_enter_syscalls))
		return;

	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

	head = this_cpu_ptr(sys_data->enter_event->perf_events);
	if (hlist_empty(head))
		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);

	rec = perf_trace_buf_alloc(size, NULL, &rctx);
	if (!rec)
		return;

	rec->nr = syscall_nr;
	syscall_get_arguments(current, regs, 0, sys_data->nb_args,
			       (unsigned long *)&rec->args);
	perf_trace_buf_submit(rec, size, rctx,
			      sys_data->enter_event->event.type, 1, regs,
			      head, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 92 41.82% 5 25.00%
jason baron jason baron 51 23.18% 1 5.00%
oleg nesterov oleg nesterov 19 8.64% 1 5.00%
xiao guangrong xiao guangrong 15 6.82% 1 5.00%
peter zijlstra peter zijlstra 10 4.55% 5 25.00%
alexei starovoitov alexei starovoitov 8 3.64% 1 5.00%
li zefan li zefan 7 3.18% 1 5.00%
will deacon will deacon 7 3.18% 1 5.00%
steven rostedt steven rostedt 5 2.27% 2 10.00%
rabin vincent rabin vincent 4 1.82% 1 5.00%
andrey vagin andrey vagin 2 0.91% 1 5.00%
Total 220 100.00% 20 100.00%



static int perf_sysenter_enable(struct trace_event_call *call)
{
	int ret = 0;
	int num;

	num = ((struct syscall_metadata *)call->data)->syscall_nr;

	mutex_lock(&syscall_trace_lock);
	if (!sys_perf_refcount_enter)
		ret = register_trace_sys_enter(perf_syscall_enter, NULL);
	if (ret) {
		pr_info("event trace: Could not activate"
				"syscall entry trace point");
	} else {
		set_bit(num, enabled_perf_enter_syscalls);
		sys_perf_refcount_enter++;
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
jason baron jason baron 64 72.73% 1 14.29%
lai jiangshan lai jiangshan 14 15.91% 1 14.29%
frederic weisbecker frederic weisbecker 5 5.68% 1 14.29%
steven rostedt steven rostedt 3 3.41% 2 28.57%
josh stone josh stone 1 1.14% 1 14.29%
vaibhav nagarnaik vaibhav nagarnaik 1 1.14% 1 14.29%
Total 88 100.00% 7 100.00%



static void perf_sysenter_disable(struct trace_event_call *call)
{
	int num;

	num = ((struct syscall_metadata *)call->data)->syscall_nr;

	mutex_lock(&syscall_trace_lock);
	sys_perf_refcount_enter--;
	clear_bit(num, enabled_perf_enter_syscalls);
	if (!sys_perf_refcount_enter)
		unregister_trace_sys_enter(perf_syscall_enter, NULL);
	mutex_unlock(&syscall_trace_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
jason baron jason baron 39 61.90% 1 14.29%
lai jiangshan lai jiangshan 14 22.22% 1 14.29%
frederic weisbecker frederic weisbecker 5 7.94% 1 14.29%
steven rostedt steven rostedt 3 4.76% 2 28.57%
vaibhav nagarnaik vaibhav nagarnaik 1 1.59% 1 14.29%
josh stone josh stone 1 1.59% 1 14.29%
Total 63 100.00% 7 100.00%



static void perf_syscall_exit(void *ignore, struct pt_regs *regs, long ret)
{
	struct syscall_metadata *sys_data;
	struct syscall_trace_exit *rec;
	struct hlist_head *head;
	int syscall_nr;
	int rctx;
	int size;

	syscall_nr = trace_get_syscall_nr(current, regs);
	if (syscall_nr < 0 || syscall_nr >= NR_syscalls)
		return;
	if (!test_bit(syscall_nr, enabled_perf_exit_syscalls))
		return;

	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

	head = this_cpu_ptr(sys_data->exit_event->perf_events);
	if (hlist_empty(head))
		return;

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

	rec = perf_trace_buf_alloc(size, NULL, &rctx);
	if (!rec)
		return;

	rec->nr = syscall_nr;
	rec->ret = syscall_get_return_value(current, regs);
	perf_trace_buf_submit(rec, size, rctx, sys_data->exit_event->event.type,
			      1, regs, head, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 60 30.93% 5 25.00%
jason baron jason baron 59 30.41% 1 5.00%
oleg nesterov oleg nesterov 19 9.79% 1 5.00%
xiao guangrong xiao guangrong 15 7.73% 1 5.00%
peter zijlstra peter zijlstra 9 4.64% 5 25.00%
alexei starovoitov alexei starovoitov 8 4.12% 1 5.00%
will deacon will deacon 7 3.61% 1 5.00%
li zefan li zefan 6 3.09% 1 5.00%
steven rostedt steven rostedt 5 2.58% 2 10.00%
rabin vincent rabin vincent 4 2.06% 1 5.00%
andrey vagin andrey vagin 2 1.03% 1 5.00%
Total 194 100.00% 20 100.00%



static int perf_sysexit_enable(struct trace_event_call *call)
{
	int ret = 0;
	int num;

	num = ((struct syscall_metadata *)call->data)->syscall_nr;

	mutex_lock(&syscall_trace_lock);
	if (!sys_perf_refcount_exit)
		ret = register_trace_sys_exit(perf_syscall_exit, NULL);
	if (ret) {
		pr_info("event trace: Could not activate"
				"syscall exit trace point");
	} else {
		set_bit(num, enabled_perf_exit_syscalls);
		sys_perf_refcount_exit++;
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
jason baron jason baron 63 71.59% 1 12.50%
lai jiangshan lai jiangshan 14 15.91% 1 12.50%
frederic weisbecker frederic weisbecker 5 5.68% 1 12.50%
steven rostedt steven rostedt 3 3.41% 2 25.00%
josh stone josh stone 1 1.14% 1 12.50%
wenji huang wenji huang 1 1.14% 1 12.50%
vaibhav nagarnaik vaibhav nagarnaik 1 1.14% 1 12.50%
Total 88 100.00% 8 100.00%



static void perf_sysexit_disable(struct trace_event_call *call)
{
	int num;

	num = ((struct syscall_metadata *)call->data)->syscall_nr;

	mutex_lock(&syscall_trace_lock);
	sys_perf_refcount_exit--;
	clear_bit(num, enabled_perf_exit_syscalls);
	if (!sys_perf_refcount_exit)
		unregister_trace_sys_exit(perf_syscall_exit, NULL);
	mutex_unlock(&syscall_trace_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
jason baron jason baron 39 61.90% 1 14.29%
lai jiangshan lai jiangshan 14 22.22% 1 14.29%
frederic weisbecker frederic weisbecker 5 7.94% 1 14.29%
steven rostedt steven rostedt 3 4.76% 2 28.57%
vaibhav nagarnaik vaibhav nagarnaik 1 1.59% 1 14.29%
josh stone josh stone 1 1.59% 1 14.29%
Total 63 100.00% 7 100.00%

#endif /* CONFIG_PERF_EVENTS */



static int syscall_enter_register(struct trace_event_call *event,
				 enum trace_reg type, void *data)
{
	struct trace_event_file *file = data;

	switch (type) {
	case TRACE_REG_REGISTER:
		return reg_event_syscall_enter(file, event);
	case TRACE_REG_UNREGISTER:
		unreg_event_syscall_enter(file, event);
		return 0;

#ifdef CONFIG_PERF_EVENTS
	case TRACE_REG_PERF_REGISTER:
		return perf_sysenter_enable(event);
	case TRACE_REG_PERF_UNREGISTER:
		perf_sysenter_disable(event);
		return 0;
	case TRACE_REG_PERF_OPEN:
	case TRACE_REG_PERF_CLOSE:
	case TRACE_REG_PERF_ADD:
	case TRACE_REG_PERF_DEL:
		return 0;
#endif
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
steven rostedt steven rostedt 80 80.81% 4 66.67%
jiri olsa jiri olsa 19 19.19% 2 33.33%
Total 99 100.00% 6 100.00%



static int syscall_exit_register(struct trace_event_call *event,
				 enum trace_reg type, void *data)
{
	struct trace_event_file *file = data;

	switch (type) {
	case TRACE_REG_REGISTER:
		return reg_event_syscall_exit(file, event);
	case TRACE_REG_UNREGISTER:
		unreg_event_syscall_exit(file, event);
		return 0;

#ifdef CONFIG_PERF_EVENTS
	case TRACE_REG_PERF_REGISTER:
		return perf_sysexit_enable(event);
	case TRACE_REG_PERF_UNREGISTER:
		perf_sysexit_disable(event);
		return 0;
	case TRACE_REG_PERF_OPEN:
	case TRACE_REG_PERF_CLOSE:
	case TRACE_REG_PERF_ADD:
	case TRACE_REG_PERF_DEL:
		return 0;
#endif
	}
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
steven rostedt steven rostedt 80 80.81% 4 66.67%
jiri olsa jiri olsa 19 19.19% 2 33.33%
Total 99 100.00% 6 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 892 26.09% 10 11.36%
jason baron jason baron 611 17.87% 4 4.55%
steven rostedt steven rostedt 582 17.02% 18 20.45%
lai jiangshan lai jiangshan 492 14.39% 7 7.95%
li zefan li zefan 196 5.73% 10 11.36%
tom zanussi tom zanussi 115 3.36% 5 5.68%
ian munsie ian munsie 115 3.36% 5 5.68%
vaibhav nagarnaik vaibhav nagarnaik 92 2.69% 1 1.14%
jiri olsa jiri olsa 46 1.35% 2 2.27%
jovi zhangwei jovi zhangwei 45 1.32% 3 3.41%
oleg nesterov oleg nesterov 38 1.11% 1 1.14%
xiao guangrong xiao guangrong 30 0.88% 1 1.14%
masami hiramatsu masami hiramatsu 20 0.58% 1 1.14%
mike frysinger mike frysinger 20 0.58% 1 1.14%
peter zijlstra peter zijlstra 19 0.56% 5 5.68%
rabin vincent rabin vincent 16 0.47% 1 1.14%
alexei starovoitov alexei starovoitov 16 0.47% 1 1.14%
will deacon will deacon 14 0.41% 1 1.14%
hendrik brueckner hendrik brueckner 14 0.41% 1 1.14%
josh stone josh stone 11 0.32% 1 1.14%
taeung song taeung song 9 0.26% 1 1.14%
fengguang wu fengguang wu 8 0.23% 1 1.14%
andrey vagin andrey vagin 4 0.12% 1 1.14%
paul gortmaker paul gortmaker 4 0.12% 1 1.14%
thomas meyer thomas meyer 3 0.09% 1 1.14%
tejun heo tejun heo 3 0.09% 1 1.14%
andreea-cristina bernat andreea-cristina bernat 2 0.06% 1 1.14%
ingo molnar ingo molnar 1 0.03% 1 1.14%
wenji huang wenji huang 1 0.03% 1 1.14%
Total 3419 100.00% 88 100.00%
  Directory: kernel/trace

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
steven rostedt	steven rostedt	28	100.00%	2	100.00%
	Total	28	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 kernel/trace/trace_syscalls.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
