2009-04-09 02:40:59 +08:00
|
|
|
#include <trace/syscall.h>
|
2009-03-07 12:52:59 +08:00
|
|
|
#include <linux/kernel.h>
|
2009-08-11 04:52:47 +08:00
|
|
|
#include <linux/ftrace.h>
|
2009-08-11 04:53:02 +08:00
|
|
|
#include <linux/perf_counter.h>
|
2009-03-07 12:52:59 +08:00
|
|
|
#include <asm/syscall.h>
|
|
|
|
|
|
|
|
#include "trace_output.h"
|
|
|
|
#include "trace.h"
|
|
|
|
|
2009-03-16 05:10:37 +08:00
|
|
|
static DEFINE_MUTEX(syscall_trace_lock);
|
2009-08-11 04:52:47 +08:00
|
|
|
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);
|
2009-03-07 12:52:59 +08:00
|
|
|
|
2009-03-13 22:42:11 +08:00
|
|
|
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;
|
|
|
|
|
2009-08-11 04:52:53 +08:00
|
|
|
trace = (typeof(trace))ent;
|
2009-03-13 22:42:11 +08:00
|
|
|
syscall = trace->nr;
|
|
|
|
entry = syscall_nr_to_meta(syscall);
|
2009-08-11 04:52:53 +08:00
|
|
|
|
2009-03-13 22:42:11 +08:00
|
|
|
if (!entry)
|
|
|
|
goto end;
|
|
|
|
|
2009-08-11 04:52:53 +08:00
|
|
|
if (entry->enter_id != ent->type) {
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2009-03-13 22:42:11 +08:00
|
|
|
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 */
|
2009-08-17 16:55:18 +08:00
|
|
|
if (trace_flags & TRACE_ITER_VERBOSE) {
|
2009-03-13 22:42:11 +08:00
|
|
|
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;
|
|
|
|
|
2009-08-11 04:52:53 +08:00
|
|
|
trace = (typeof(trace))ent;
|
2009-03-13 22:42:11 +08:00
|
|
|
syscall = trace->nr;
|
|
|
|
entry = syscall_nr_to_meta(syscall);
|
2009-08-11 04:52:53 +08:00
|
|
|
|
2009-03-13 22:42:11 +08:00
|
|
|
if (!entry) {
|
|
|
|
trace_seq_printf(s, "\n");
|
|
|
|
return TRACE_TYPE_HANDLED;
|
|
|
|
}
|
|
|
|
|
2009-08-11 04:52:53 +08:00
|
|
|
if (entry->exit_id != ent->type) {
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return TRACE_TYPE_UNHANDLED;
|
|
|
|
}
|
|
|
|
|
2009-03-13 22:42:11 +08:00
|
|
|
ret = trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
|
|
|
|
trace->ret);
|
|
|
|
if (!ret)
|
|
|
|
return TRACE_TYPE_PARTIAL_LINE;
|
|
|
|
|
|
|
|
return TRACE_TYPE_HANDLED;
|
|
|
|
}
|
|
|
|
|
2009-08-12 01:03:54 +08:00
|
|
|
int ftrace_format_syscall(struct ftrace_event_call *call, struct trace_seq *s)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int nr;
|
|
|
|
int ret = 0;
|
|
|
|
struct syscall_metadata *entry;
|
|
|
|
int offset = sizeof(struct trace_entry);
|
|
|
|
|
|
|
|
nr = syscall_name_to_nr((char *)call->data);
|
|
|
|
entry = syscall_nr_to_meta(nr);
|
|
|
|
|
|
|
|
if (!entry)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
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:%lu;\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%lulx%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;
|
|
|
|
}
|
|
|
|
|
2009-08-11 04:52:47 +08:00
|
|
|
void ftrace_syscall_enter(struct pt_regs *regs, long id)
|
2009-03-07 12:52:59 +08:00
|
|
|
{
|
2009-03-13 22:42:11 +08:00
|
|
|
struct syscall_trace_enter *entry;
|
|
|
|
struct syscall_metadata *sys_data;
|
|
|
|
struct ring_buffer_event *event;
|
|
|
|
int size;
|
2009-03-07 12:52:59 +08:00
|
|
|
int syscall_nr;
|
|
|
|
|
|
|
|
syscall_nr = syscall_get_nr(current, regs);
|
2009-08-11 04:52:47 +08:00
|
|
|
if (!test_bit(syscall_nr, enabled_enter_syscalls))
|
|
|
|
return;
|
2009-03-07 12:52:59 +08:00
|
|
|
|
2009-03-13 22:42:11 +08:00
|
|
|
sys_data = syscall_nr_to_meta(syscall_nr);
|
|
|
|
if (!sys_data)
|
|
|
|
return;
|
|
|
|
|
|
|
|
size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;
|
|
|
|
|
2009-08-11 04:52:53 +08:00
|
|
|
event = trace_current_buffer_lock_reserve(sys_data->enter_id, size,
|
2009-03-13 22:42:11 +08:00
|
|
|
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();
|
2009-03-07 12:52:59 +08:00
|
|
|
}
|
|
|
|
|
2009-08-11 04:52:47 +08:00
|
|
|
void ftrace_syscall_exit(struct pt_regs *regs, long ret)
|
2009-03-07 12:52:59 +08:00
|
|
|
{
|
2009-03-13 22:42:11 +08:00
|
|
|
struct syscall_trace_exit *entry;
|
|
|
|
struct syscall_metadata *sys_data;
|
|
|
|
struct ring_buffer_event *event;
|
2009-03-07 12:52:59 +08:00
|
|
|
int syscall_nr;
|
|
|
|
|
|
|
|
syscall_nr = syscall_get_nr(current, regs);
|
2009-08-11 04:52:47 +08:00
|
|
|
if (!test_bit(syscall_nr, enabled_exit_syscalls))
|
|
|
|
return;
|
2009-03-07 12:52:59 +08:00
|
|
|
|
2009-03-13 22:42:11 +08:00
|
|
|
sys_data = syscall_nr_to_meta(syscall_nr);
|
|
|
|
if (!sys_data)
|
|
|
|
return;
|
|
|
|
|
2009-08-11 04:52:53 +08:00
|
|
|
event = trace_current_buffer_lock_reserve(sys_data->exit_id,
|
2009-03-13 22:42:11 +08:00
|
|
|
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();
|
2009-03-07 12:52:59 +08:00
|
|
|
}
|
|
|
|
|
2009-08-11 04:52:47 +08:00
|
|
|
int reg_event_syscall_enter(void *ptr)
|
2009-03-07 12:52:59 +08:00
|
|
|
{
|
2009-08-11 04:52:47 +08:00
|
|
|
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;
|
2009-03-07 12:52:59 +08:00
|
|
|
}
|
|
|
|
|
2009-08-11 04:52:47 +08:00
|
|
|
void unreg_event_syscall_enter(void *ptr)
|
2009-03-07 12:52:59 +08:00
|
|
|
{
|
2009-08-11 04:52:47 +08:00
|
|
|
int num;
|
|
|
|
char *name;
|
2009-03-07 12:52:59 +08:00
|
|
|
|
2009-08-11 04:52:47 +08:00
|
|
|
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);
|
|
|
|
}
|
2009-03-07 12:52:59 +08:00
|
|
|
|
2009-08-11 04:52:47 +08:00
|
|
|
int reg_event_syscall_exit(void *ptr)
|
2009-03-07 12:52:59 +08:00
|
|
|
{
|
2009-08-11 04:52:47 +08:00
|
|
|
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++;
|
2009-03-07 12:52:59 +08:00
|
|
|
}
|
2009-08-11 04:52:47 +08:00
|
|
|
mutex_unlock(&syscall_trace_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
2009-03-07 12:52:59 +08:00
|
|
|
|
2009-08-11 04:52:47 +08:00
|
|
|
void unreg_event_syscall_exit(void *ptr)
|
|
|
|
{
|
|
|
|
int num;
|
|
|
|
char *name;
|
2009-03-07 12:52:59 +08:00
|
|
|
|
2009-08-11 04:52:47 +08:00
|
|
|
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);
|
2009-03-07 12:52:59 +08:00
|
|
|
}
|
2009-08-11 04:52:47 +08:00
|
|
|
|
|
|
|
struct trace_event event_syscall_enter = {
|
|
|
|
.trace = print_syscall_enter,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct trace_event event_syscall_exit = {
|
|
|
|
.trace = print_syscall_exit,
|
|
|
|
};
|
2009-08-11 04:53:02 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_EVENT_PROFILE
|
2009-08-12 02:22:53 +08:00
|
|
|
|
|
|
|
struct syscall_enter_record {
|
|
|
|
struct trace_entry entry;
|
|
|
|
unsigned long args[0];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct syscall_exit_record {
|
|
|
|
struct trace_entry entry;
|
|
|
|
unsigned long ret;
|
|
|
|
};
|
|
|
|
|
2009-08-11 04:53:02 +08:00
|
|
|
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)
|
|
|
|
{
|
2009-08-12 02:22:53 +08:00
|
|
|
struct syscall_enter_record *rec;
|
2009-08-11 04:53:02 +08:00
|
|
|
struct syscall_metadata *sys_data;
|
|
|
|
int syscall_nr;
|
2009-08-12 02:22:53 +08:00
|
|
|
int size;
|
2009-08-11 04:53:02 +08:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2009-08-12 02:22:53 +08:00
|
|
|
/* 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_enter_record *) raw_data;
|
|
|
|
tracing_generic_entry_update(&rec->entry, 0, 0);
|
|
|
|
rec->entry.type = sys_data->enter_id;
|
|
|
|
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);
|
2009-08-11 04:53:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2009-08-12 02:22:53 +08:00
|
|
|
struct syscall_exit_record rec;
|
2009-08-11 04:53:02 +08:00
|
|
|
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;
|
|
|
|
|
2009-08-12 02:22:53 +08:00
|
|
|
tracing_generic_entry_update(&rec.entry, 0, 0);
|
|
|
|
rec.entry.type = sys_data->exit_id;
|
|
|
|
rec.ret = syscall_get_return_value(current, regs);
|
|
|
|
|
|
|
|
perf_tpcounter_event(sys_data->exit_id, 0, 1, &rec, sizeof(rec));
|
2009-08-11 04:53:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
|