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 void ftrace_syscall_enter(struct pt_regs *regs, long id)
110 struct syscall_trace_enter *entry;
111 struct syscall_metadata *sys_data;
112 struct ring_buffer_event *event;
116 syscall_nr = syscall_get_nr(current, regs);
117 if (!test_bit(syscall_nr, enabled_enter_syscalls))
120 sys_data = syscall_nr_to_meta(syscall_nr);
124 size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;
126 event = trace_current_buffer_lock_reserve(sys_data->enter_id, size,
131 entry = ring_buffer_event_data(event);
132 entry->nr = syscall_nr;
133 syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);
135 trace_current_buffer_unlock_commit(event, 0, 0);
139 void ftrace_syscall_exit(struct pt_regs *regs, long ret)
141 struct syscall_trace_exit *entry;
142 struct syscall_metadata *sys_data;
143 struct ring_buffer_event *event;
146 syscall_nr = syscall_get_nr(current, regs);
147 if (!test_bit(syscall_nr, enabled_exit_syscalls))
150 sys_data = syscall_nr_to_meta(syscall_nr);
154 event = trace_current_buffer_lock_reserve(sys_data->exit_id,
155 sizeof(*entry), 0, 0);
159 entry = ring_buffer_event_data(event);
160 entry->nr = syscall_nr;
161 entry->ret = syscall_get_return_value(current, regs);
163 trace_current_buffer_unlock_commit(event, 0, 0);
167 int reg_event_syscall_enter(void *ptr)
174 num = syscall_name_to_nr(name);
175 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
177 mutex_lock(&syscall_trace_lock);
178 if (!sys_refcount_enter)
179 ret = register_trace_syscall_enter(ftrace_syscall_enter);
181 pr_info("event trace: Could not activate"
182 "syscall entry trace point");
184 set_bit(num, enabled_enter_syscalls);
185 sys_refcount_enter++;
187 mutex_unlock(&syscall_trace_lock);
191 void unreg_event_syscall_enter(void *ptr)
197 num = syscall_name_to_nr(name);
198 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
200 mutex_lock(&syscall_trace_lock);
201 sys_refcount_enter--;
202 clear_bit(num, enabled_enter_syscalls);
203 if (!sys_refcount_enter)
204 unregister_trace_syscall_enter(ftrace_syscall_enter);
205 mutex_unlock(&syscall_trace_lock);
208 int reg_event_syscall_exit(void *ptr)
215 num = syscall_name_to_nr(name);
216 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
218 mutex_lock(&syscall_trace_lock);
219 if (!sys_refcount_exit)
220 ret = register_trace_syscall_exit(ftrace_syscall_exit);
222 pr_info("event trace: Could not activate"
223 "syscall exit trace point");
225 set_bit(num, enabled_exit_syscalls);
228 mutex_unlock(&syscall_trace_lock);
232 void unreg_event_syscall_exit(void *ptr)
238 num = syscall_name_to_nr(name);
239 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
241 mutex_lock(&syscall_trace_lock);
243 clear_bit(num, enabled_exit_syscalls);
244 if (!sys_refcount_exit)
245 unregister_trace_syscall_exit(ftrace_syscall_exit);
246 mutex_unlock(&syscall_trace_lock);
249 struct trace_event event_syscall_enter = {
250 .trace = print_syscall_enter,
253 struct trace_event event_syscall_exit = {
254 .trace = print_syscall_exit,
257 #ifdef CONFIG_EVENT_PROFILE
258 static DECLARE_BITMAP(enabled_prof_enter_syscalls, FTRACE_SYSCALL_MAX);
259 static DECLARE_BITMAP(enabled_prof_exit_syscalls, FTRACE_SYSCALL_MAX);
260 static int sys_prof_refcount_enter;
261 static int sys_prof_refcount_exit;
263 static void prof_syscall_enter(struct pt_regs *regs, long id)
265 struct syscall_metadata *sys_data;
268 syscall_nr = syscall_get_nr(current, regs);
269 if (!test_bit(syscall_nr, enabled_prof_enter_syscalls))
272 sys_data = syscall_nr_to_meta(syscall_nr);
276 perf_tpcounter_event(sys_data->enter_id, 0, 1, NULL, 0);
279 int reg_prof_syscall_enter(char *name)
284 num = syscall_name_to_nr(name);
285 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
288 mutex_lock(&syscall_trace_lock);
289 if (!sys_prof_refcount_enter)
290 ret = register_trace_syscall_enter(prof_syscall_enter);
292 pr_info("event trace: Could not activate"
293 "syscall entry trace point");
295 set_bit(num, enabled_prof_enter_syscalls);
296 sys_prof_refcount_enter++;
298 mutex_unlock(&syscall_trace_lock);
302 void unreg_prof_syscall_enter(char *name)
306 num = syscall_name_to_nr(name);
307 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
310 mutex_lock(&syscall_trace_lock);
311 sys_prof_refcount_enter--;
312 clear_bit(num, enabled_prof_enter_syscalls);
313 if (!sys_prof_refcount_enter)
314 unregister_trace_syscall_enter(prof_syscall_enter);
315 mutex_unlock(&syscall_trace_lock);
318 static void prof_syscall_exit(struct pt_regs *regs, long ret)
320 struct syscall_metadata *sys_data;
323 syscall_nr = syscall_get_nr(current, regs);
324 if (!test_bit(syscall_nr, enabled_prof_exit_syscalls))
327 sys_data = syscall_nr_to_meta(syscall_nr);
331 perf_tpcounter_event(sys_data->exit_id, 0, 1, NULL, 0);
334 int reg_prof_syscall_exit(char *name)
339 num = syscall_name_to_nr(name);
340 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
343 mutex_lock(&syscall_trace_lock);
344 if (!sys_prof_refcount_exit)
345 ret = register_trace_syscall_exit(prof_syscall_exit);
347 pr_info("event trace: Could not activate"
348 "syscall entry trace point");
350 set_bit(num, enabled_prof_exit_syscalls);
351 sys_prof_refcount_exit++;
353 mutex_unlock(&syscall_trace_lock);
357 void unreg_prof_syscall_exit(char *name)
361 num = syscall_name_to_nr(name);
362 if (num < 0 || num >= FTRACE_SYSCALL_MAX)
365 mutex_lock(&syscall_trace_lock);
366 sys_prof_refcount_exit--;
367 clear_bit(num, enabled_prof_exit_syscalls);
368 if (!sys_prof_refcount_exit)
369 unregister_trace_syscall_exit(prof_syscall_exit);
370 mutex_unlock(&syscall_trace_lock);