1 #include <trace/syscall.h>
2 #include <linux/kernel.h>
3 #include <linux/ftrace.h>
4 #include <linux/perf_counter.h>
5 #include <asm/syscall.h>
7 #include "trace_output.h"
10 static DEFINE_MUTEX(syscall_trace_lock);
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);
16 /* Option to display the parameters types */
18 TRACE_SYSCALLS_OPT_TYPES = 0x1,
21 static struct tracer_opt syscalls_opts[] = {
22 { TRACER_OPT(syscall_arg_type, TRACE_SYSCALLS_OPT_TYPES) },
26 static struct tracer_flags syscalls_flags = {
27 .val = 0, /* By default: no parameters types */
32 print_syscall_enter(struct trace_iterator *iter, int flags)
34 struct trace_seq *s = &iter->seq;
35 struct trace_entry *ent = iter->ent;
36 struct syscall_trace_enter *trace;
37 struct syscall_metadata *entry;
40 trace = (typeof(trace))ent;
42 entry = syscall_nr_to_meta(syscall);
47 if (entry->enter_id != ent->type) {
52 ret = trace_seq_printf(s, "%s(", entry->name);
54 return TRACE_TYPE_PARTIAL_LINE;
56 for (i = 0; i < entry->nb_args; i++) {
58 if (syscalls_flags.val & TRACE_SYSCALLS_OPT_TYPES) {
59 ret = trace_seq_printf(s, "%s ", entry->types[i]);
61 return TRACE_TYPE_PARTIAL_LINE;
63 /* parameter values */
64 ret = trace_seq_printf(s, "%s: %lx%s ", entry->args[i],
66 i == entry->nb_args - 1 ? ")" : ",");
68 return TRACE_TYPE_PARTIAL_LINE;
72 trace_seq_printf(s, "\n");
73 return TRACE_TYPE_HANDLED;
77 print_syscall_exit(struct trace_iterator *iter, int flags)
79 struct trace_seq *s = &iter->seq;
80 struct trace_entry *ent = iter->ent;
81 struct syscall_trace_exit *trace;
83 struct syscall_metadata *entry;
86 trace = (typeof(trace))ent;
88 entry = syscall_nr_to_meta(syscall);
91 trace_seq_printf(s, "\n");
92 return TRACE_TYPE_HANDLED;
95 if (entry->exit_id != ent->type) {
97 return TRACE_TYPE_UNHANDLED;
100 ret = trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
103 return TRACE_TYPE_PARTIAL_LINE;
105 return TRACE_TYPE_HANDLED;
108 int ftrace_format_syscall(struct ftrace_event_call *call, struct trace_seq *s)
113 struct syscall_metadata *entry;
114 int offset = sizeof(struct trace_entry);
116 nr = syscall_name_to_nr((char *)call->data);
117 entry = syscall_nr_to_meta(nr);
122 for (i = 0; i < entry->nb_args; i++) {
123 ret = trace_seq_printf(s, "\tfield:%s %s;", entry->types[i],
127 ret = trace_seq_printf(s, "\toffset:%d;\tsize:%lu;\n", offset,
128 sizeof(unsigned long));
131 offset += sizeof(unsigned long);
134 trace_seq_printf(s, "\nprint fmt: \"");
135 for (i = 0; i < entry->nb_args; i++) {
136 ret = trace_seq_printf(s, "%s: 0x%%0%lulx%s", entry->args[i],
137 sizeof(unsigned long),
138 i == entry->nb_args - 1 ? "\", " : ", ");
143 for (i = 0; i < entry->nb_args; i++) {
144 ret = trace_seq_printf(s, "((unsigned long)(REC->%s))%s",
146 i == entry->nb_args - 1 ? "\n" : ", ");
154 void ftrace_syscall_enter(struct pt_regs *regs, long id)
156 struct syscall_trace_enter *entry;
157 struct syscall_metadata *sys_data;
158 struct ring_buffer_event *event;
162 syscall_nr = syscall_get_nr(current, regs);
163 if (!test_bit(syscall_nr, enabled_enter_syscalls))
166 sys_data = syscall_nr_to_meta(syscall_nr);
170 size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;
172 event = trace_current_buffer_lock_reserve(sys_data->enter_id, size,
177 entry = ring_buffer_event_data(event);
178 entry->nr = syscall_nr;
179 syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);
181 trace_current_buffer_unlock_commit(event, 0, 0);
185 void ftrace_syscall_exit(struct pt_regs *regs, long ret)
187 struct syscall_trace_exit *entry;
188 struct syscall_metadata *sys_data;
189 struct ring_buffer_event *event;
192 syscall_nr = syscall_get_nr(current, regs);
193 if (!test_bit(syscall_nr, enabled_exit_syscalls))
196 sys_data = syscall_nr_to_meta(syscall_nr);
200 event = trace_current_buffer_lock_reserve(sys_data->exit_id,
201 sizeof(*entry), 0, 0);
205 entry = ring_buffer_event_data(event);
206 entry->nr = syscall_nr;
207 entry->ret = syscall_get_return_value(current, regs);
209 trace_current_buffer_unlock_commit(event, 0, 0);
213 int reg_event_syscall_enter(void *ptr)
220 num = syscall_name_to_nr(name);
221 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
223 mutex_lock(&syscall_trace_lock);
224 if (!sys_refcount_enter)
225 ret = register_trace_syscall_enter(ftrace_syscall_enter);
227 pr_info("event trace: Could not activate"
228 "syscall entry trace point");
230 set_bit(num, enabled_enter_syscalls);
231 sys_refcount_enter++;
233 mutex_unlock(&syscall_trace_lock);
237 void unreg_event_syscall_enter(void *ptr)
243 num = syscall_name_to_nr(name);
244 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
246 mutex_lock(&syscall_trace_lock);
247 sys_refcount_enter--;
248 clear_bit(num, enabled_enter_syscalls);
249 if (!sys_refcount_enter)
250 unregister_trace_syscall_enter(ftrace_syscall_enter);
251 mutex_unlock(&syscall_trace_lock);
254 int reg_event_syscall_exit(void *ptr)
261 num = syscall_name_to_nr(name);
262 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
264 mutex_lock(&syscall_trace_lock);
265 if (!sys_refcount_exit)
266 ret = register_trace_syscall_exit(ftrace_syscall_exit);
268 pr_info("event trace: Could not activate"
269 "syscall exit trace point");
271 set_bit(num, enabled_exit_syscalls);
274 mutex_unlock(&syscall_trace_lock);
278 void unreg_event_syscall_exit(void *ptr)
284 num = syscall_name_to_nr(name);
285 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
287 mutex_lock(&syscall_trace_lock);
289 clear_bit(num, enabled_exit_syscalls);
290 if (!sys_refcount_exit)
291 unregister_trace_syscall_exit(ftrace_syscall_exit);
292 mutex_unlock(&syscall_trace_lock);
295 struct trace_event event_syscall_enter = {
296 .trace = print_syscall_enter,
299 struct trace_event event_syscall_exit = {
300 .trace = print_syscall_exit,
303 #ifdef CONFIG_EVENT_PROFILE
304 static DECLARE_BITMAP(enabled_prof_enter_syscalls, FTRACE_SYSCALL_MAX);
305 static DECLARE_BITMAP(enabled_prof_exit_syscalls, FTRACE_SYSCALL_MAX);
306 static int sys_prof_refcount_enter;
307 static int sys_prof_refcount_exit;
309 static void prof_syscall_enter(struct pt_regs *regs, long id)
311 struct syscall_metadata *sys_data;
314 syscall_nr = syscall_get_nr(current, regs);
315 if (!test_bit(syscall_nr, enabled_prof_enter_syscalls))
318 sys_data = syscall_nr_to_meta(syscall_nr);
322 perf_tpcounter_event(sys_data->enter_id, 0, 1, NULL, 0);
325 int reg_prof_syscall_enter(char *name)
330 num = syscall_name_to_nr(name);
331 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
334 mutex_lock(&syscall_trace_lock);
335 if (!sys_prof_refcount_enter)
336 ret = register_trace_syscall_enter(prof_syscall_enter);
338 pr_info("event trace: Could not activate"
339 "syscall entry trace point");
341 set_bit(num, enabled_prof_enter_syscalls);
342 sys_prof_refcount_enter++;
344 mutex_unlock(&syscall_trace_lock);
348 void unreg_prof_syscall_enter(char *name)
352 num = syscall_name_to_nr(name);
353 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
356 mutex_lock(&syscall_trace_lock);
357 sys_prof_refcount_enter--;
358 clear_bit(num, enabled_prof_enter_syscalls);
359 if (!sys_prof_refcount_enter)
360 unregister_trace_syscall_enter(prof_syscall_enter);
361 mutex_unlock(&syscall_trace_lock);
364 static void prof_syscall_exit(struct pt_regs *regs, long ret)
366 struct syscall_metadata *sys_data;
369 syscall_nr = syscall_get_nr(current, regs);
370 if (!test_bit(syscall_nr, enabled_prof_exit_syscalls))
373 sys_data = syscall_nr_to_meta(syscall_nr);
377 perf_tpcounter_event(sys_data->exit_id, 0, 1, NULL, 0);
380 int reg_prof_syscall_exit(char *name)
385 num = syscall_name_to_nr(name);
386 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
389 mutex_lock(&syscall_trace_lock);
390 if (!sys_prof_refcount_exit)
391 ret = register_trace_syscall_exit(prof_syscall_exit);
393 pr_info("event trace: Could not activate"
394 "syscall entry trace point");
396 set_bit(num, enabled_prof_exit_syscalls);
397 sys_prof_refcount_exit++;
399 mutex_unlock(&syscall_trace_lock);
403 void unreg_prof_syscall_exit(char *name)
407 num = syscall_name_to_nr(name);
408 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
411 mutex_lock(&syscall_trace_lock);
412 sys_prof_refcount_exit--;
413 clear_bit(num, enabled_prof_exit_syscalls);
414 if (!sys_prof_refcount_exit)
415 unregister_trace_syscall_exit(prof_syscall_exit);
416 mutex_unlock(&syscall_trace_lock);