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
);
17 print_syscall_enter(struct trace_iterator
*iter
, int flags
)
19 struct trace_seq
*s
= &iter
->seq
;
20 struct trace_entry
*ent
= iter
->ent
;
21 struct syscall_trace_enter
*trace
;
22 struct syscall_metadata
*entry
;
25 trace
= (typeof(trace
))ent
;
27 entry
= syscall_nr_to_meta(syscall
);
32 if (entry
->enter_id
!= ent
->type
) {
37 ret
= trace_seq_printf(s
, "%s(", entry
->name
);
39 return TRACE_TYPE_PARTIAL_LINE
;
41 for (i
= 0; i
< entry
->nb_args
; i
++) {
43 if (trace_flags
& TRACE_ITER_VERBOSE
) {
44 ret
= trace_seq_printf(s
, "%s ", entry
->types
[i
]);
46 return TRACE_TYPE_PARTIAL_LINE
;
48 /* parameter values */
49 ret
= trace_seq_printf(s
, "%s: %lx%s ", entry
->args
[i
],
51 i
== entry
->nb_args
- 1 ? ")" : ",");
53 return TRACE_TYPE_PARTIAL_LINE
;
57 trace_seq_printf(s
, "\n");
58 return TRACE_TYPE_HANDLED
;
62 print_syscall_exit(struct trace_iterator
*iter
, int flags
)
64 struct trace_seq
*s
= &iter
->seq
;
65 struct trace_entry
*ent
= iter
->ent
;
66 struct syscall_trace_exit
*trace
;
68 struct syscall_metadata
*entry
;
71 trace
= (typeof(trace
))ent
;
73 entry
= syscall_nr_to_meta(syscall
);
76 trace_seq_printf(s
, "\n");
77 return TRACE_TYPE_HANDLED
;
80 if (entry
->exit_id
!= ent
->type
) {
82 return TRACE_TYPE_UNHANDLED
;
85 ret
= trace_seq_printf(s
, "%s -> 0x%lx\n", entry
->name
,
88 return TRACE_TYPE_PARTIAL_LINE
;
90 return TRACE_TYPE_HANDLED
;
93 extern char *__bad_type_size(void);
95 #define SYSCALL_FIELD(type, name) \
96 sizeof(type) != sizeof(trace.name) ? \
98 #type, #name, offsetof(typeof(trace), name), sizeof(trace.name)
100 int syscall_enter_format(struct ftrace_event_call
*call
, struct trace_seq
*s
)
105 struct syscall_metadata
*entry
;
106 struct syscall_trace_enter trace
;
107 int offset
= offsetof(struct syscall_trace_enter
, args
);
109 nr
= syscall_name_to_nr(call
->data
);
110 entry
= syscall_nr_to_meta(nr
);
115 ret
= trace_seq_printf(s
, "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n",
116 SYSCALL_FIELD(int, nr
));
120 for (i
= 0; i
< entry
->nb_args
; i
++) {
121 ret
= trace_seq_printf(s
, "\tfield:%s %s;", entry
->types
[i
],
125 ret
= trace_seq_printf(s
, "\toffset:%d;\tsize:%zu;\n", offset
,
126 sizeof(unsigned long));
129 offset
+= sizeof(unsigned long);
132 trace_seq_printf(s
, "\nprint fmt: \"");
133 for (i
= 0; i
< entry
->nb_args
; i
++) {
134 ret
= trace_seq_printf(s
, "%s: 0x%%0%zulx%s", entry
->args
[i
],
135 sizeof(unsigned long),
136 i
== entry
->nb_args
- 1 ? "\", " : ", ");
141 for (i
= 0; i
< entry
->nb_args
; i
++) {
142 ret
= trace_seq_printf(s
, "((unsigned long)(REC->%s))%s",
144 i
== entry
->nb_args
- 1 ? "\n" : ", ");
152 int syscall_exit_format(struct ftrace_event_call
*call
, struct trace_seq
*s
)
155 struct syscall_trace_exit trace
;
157 ret
= trace_seq_printf(s
,
158 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
159 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n",
160 SYSCALL_FIELD(int, nr
),
161 SYSCALL_FIELD(unsigned long, ret
));
165 return trace_seq_printf(s
, "\nprint fmt: \"0x%%lx\", REC->ret\n");
168 int syscall_enter_define_fields(struct ftrace_event_call
*call
)
170 struct syscall_trace_enter trace
;
171 struct syscall_metadata
*meta
;
175 int offset
= offsetof(typeof(trace
), args
);
177 nr
= syscall_name_to_nr(call
->data
);
178 meta
= syscall_nr_to_meta(nr
);
183 ret
= trace_define_common_fields(call
);
187 for (i
= 0; i
< meta
->nb_args
; i
++) {
188 ret
= trace_define_field(call
, meta
->types
[i
],
189 meta
->args
[i
], offset
,
190 sizeof(unsigned long), 0);
191 offset
+= sizeof(unsigned long);
197 int syscall_exit_define_fields(struct ftrace_event_call
*call
)
199 struct syscall_trace_exit trace
;
202 ret
= trace_define_common_fields(call
);
206 ret
= trace_define_field(call
, SYSCALL_FIELD(unsigned long, ret
), 0);
211 void ftrace_syscall_enter(struct pt_regs
*regs
, long id
)
213 struct syscall_trace_enter
*entry
;
214 struct syscall_metadata
*sys_data
;
215 struct ring_buffer_event
*event
;
219 syscall_nr
= syscall_get_nr(current
, regs
);
220 if (!test_bit(syscall_nr
, enabled_enter_syscalls
))
223 sys_data
= syscall_nr_to_meta(syscall_nr
);
227 size
= sizeof(*entry
) + sizeof(unsigned long) * sys_data
->nb_args
;
229 event
= trace_current_buffer_lock_reserve(sys_data
->enter_id
, size
,
234 entry
= ring_buffer_event_data(event
);
235 entry
->nr
= syscall_nr
;
236 syscall_get_arguments(current
, regs
, 0, sys_data
->nb_args
, entry
->args
);
238 if (!filter_current_check_discard(sys_data
->enter_event
, entry
, event
))
239 trace_current_buffer_unlock_commit(event
, 0, 0);
242 void ftrace_syscall_exit(struct pt_regs
*regs
, long ret
)
244 struct syscall_trace_exit
*entry
;
245 struct syscall_metadata
*sys_data
;
246 struct ring_buffer_event
*event
;
249 syscall_nr
= syscall_get_nr(current
, regs
);
250 if (!test_bit(syscall_nr
, enabled_exit_syscalls
))
253 sys_data
= syscall_nr_to_meta(syscall_nr
);
257 event
= trace_current_buffer_lock_reserve(sys_data
->exit_id
,
258 sizeof(*entry
), 0, 0);
262 entry
= ring_buffer_event_data(event
);
263 entry
->nr
= syscall_nr
;
264 entry
->ret
= syscall_get_return_value(current
, regs
);
266 if (!filter_current_check_discard(sys_data
->exit_event
, entry
, event
))
267 trace_current_buffer_unlock_commit(event
, 0, 0);
270 int reg_event_syscall_enter(void *ptr
)
277 num
= syscall_name_to_nr(name
);
278 if (num
< 0 || num
>= FTRACE_SYSCALL_MAX
)
280 mutex_lock(&syscall_trace_lock
);
281 if (!sys_refcount_enter
)
282 ret
= register_trace_syscall_enter(ftrace_syscall_enter
);
284 pr_info("event trace: Could not activate"
285 "syscall entry trace point");
287 set_bit(num
, enabled_enter_syscalls
);
288 sys_refcount_enter
++;
290 mutex_unlock(&syscall_trace_lock
);
294 void unreg_event_syscall_enter(void *ptr
)
300 num
= syscall_name_to_nr(name
);
301 if (num
< 0 || num
>= FTRACE_SYSCALL_MAX
)
303 mutex_lock(&syscall_trace_lock
);
304 sys_refcount_enter
--;
305 clear_bit(num
, enabled_enter_syscalls
);
306 if (!sys_refcount_enter
)
307 unregister_trace_syscall_enter(ftrace_syscall_enter
);
308 mutex_unlock(&syscall_trace_lock
);
311 int reg_event_syscall_exit(void *ptr
)
318 num
= syscall_name_to_nr(name
);
319 if (num
< 0 || num
>= FTRACE_SYSCALL_MAX
)
321 mutex_lock(&syscall_trace_lock
);
322 if (!sys_refcount_exit
)
323 ret
= register_trace_syscall_exit(ftrace_syscall_exit
);
325 pr_info("event trace: Could not activate"
326 "syscall exit trace point");
328 set_bit(num
, enabled_exit_syscalls
);
331 mutex_unlock(&syscall_trace_lock
);
335 void unreg_event_syscall_exit(void *ptr
)
341 num
= syscall_name_to_nr(name
);
342 if (num
< 0 || num
>= FTRACE_SYSCALL_MAX
)
344 mutex_lock(&syscall_trace_lock
);
346 clear_bit(num
, enabled_exit_syscalls
);
347 if (!sys_refcount_exit
)
348 unregister_trace_syscall_exit(ftrace_syscall_exit
);
349 mutex_unlock(&syscall_trace_lock
);
352 struct trace_event event_syscall_enter
= {
353 .trace
= print_syscall_enter
,
356 struct trace_event event_syscall_exit
= {
357 .trace
= print_syscall_exit
,
360 #ifdef CONFIG_EVENT_PROFILE
362 static DECLARE_BITMAP(enabled_prof_enter_syscalls
, FTRACE_SYSCALL_MAX
);
363 static DECLARE_BITMAP(enabled_prof_exit_syscalls
, FTRACE_SYSCALL_MAX
);
364 static int sys_prof_refcount_enter
;
365 static int sys_prof_refcount_exit
;
367 static void prof_syscall_enter(struct pt_regs
*regs
, long id
)
369 struct syscall_trace_enter
*rec
;
370 struct syscall_metadata
*sys_data
;
374 syscall_nr
= syscall_get_nr(current
, regs
);
375 if (!test_bit(syscall_nr
, enabled_prof_enter_syscalls
))
378 sys_data
= syscall_nr_to_meta(syscall_nr
);
382 /* get the size after alignment with the u32 buffer size field */
383 size
= sizeof(unsigned long) * sys_data
->nb_args
+ sizeof(*rec
);
384 size
= ALIGN(size
+ sizeof(u32
), sizeof(u64
));
390 /* zero the dead bytes from align to not leak stack to user */
391 *(u64
*)(&raw_data
[size
- sizeof(u64
)]) = 0ULL;
393 rec
= (struct syscall_trace_enter
*) raw_data
;
394 tracing_generic_entry_update(&rec
->ent
, 0, 0);
395 rec
->ent
.type
= sys_data
->enter_id
;
396 rec
->nr
= syscall_nr
;
397 syscall_get_arguments(current
, regs
, 0, sys_data
->nb_args
,
398 (unsigned long *)&rec
->args
);
399 perf_tpcounter_event(sys_data
->enter_id
, 0, 1, rec
, size
);
403 int reg_prof_syscall_enter(char *name
)
408 num
= syscall_name_to_nr(name
);
409 if (num
< 0 || num
>= FTRACE_SYSCALL_MAX
)
412 mutex_lock(&syscall_trace_lock
);
413 if (!sys_prof_refcount_enter
)
414 ret
= register_trace_syscall_enter(prof_syscall_enter
);
416 pr_info("event trace: Could not activate"
417 "syscall entry trace point");
419 set_bit(num
, enabled_prof_enter_syscalls
);
420 sys_prof_refcount_enter
++;
422 mutex_unlock(&syscall_trace_lock
);
426 void unreg_prof_syscall_enter(char *name
)
430 num
= syscall_name_to_nr(name
);
431 if (num
< 0 || num
>= FTRACE_SYSCALL_MAX
)
434 mutex_lock(&syscall_trace_lock
);
435 sys_prof_refcount_enter
--;
436 clear_bit(num
, enabled_prof_enter_syscalls
);
437 if (!sys_prof_refcount_enter
)
438 unregister_trace_syscall_enter(prof_syscall_enter
);
439 mutex_unlock(&syscall_trace_lock
);
442 static void prof_syscall_exit(struct pt_regs
*regs
, long ret
)
444 struct syscall_metadata
*sys_data
;
445 struct syscall_trace_exit rec
;
448 syscall_nr
= syscall_get_nr(current
, regs
);
449 if (!test_bit(syscall_nr
, enabled_prof_exit_syscalls
))
452 sys_data
= syscall_nr_to_meta(syscall_nr
);
456 tracing_generic_entry_update(&rec
.ent
, 0, 0);
457 rec
.ent
.type
= sys_data
->exit_id
;
459 rec
.ret
= syscall_get_return_value(current
, regs
);
461 perf_tpcounter_event(sys_data
->exit_id
, 0, 1, &rec
, sizeof(rec
));
464 int reg_prof_syscall_exit(char *name
)
469 num
= syscall_name_to_nr(name
);
470 if (num
< 0 || num
>= FTRACE_SYSCALL_MAX
)
473 mutex_lock(&syscall_trace_lock
);
474 if (!sys_prof_refcount_exit
)
475 ret
= register_trace_syscall_exit(prof_syscall_exit
);
477 pr_info("event trace: Could not activate"
478 "syscall entry trace point");
480 set_bit(num
, enabled_prof_exit_syscalls
);
481 sys_prof_refcount_exit
++;
483 mutex_unlock(&syscall_trace_lock
);
487 void unreg_prof_syscall_exit(char *name
)
491 num
= syscall_name_to_nr(name
);
492 if (num
< 0 || num
>= FTRACE_SYSCALL_MAX
)
495 mutex_lock(&syscall_trace_lock
);
496 sys_prof_refcount_exit
--;
497 clear_bit(num
, enabled_prof_exit_syscalls
);
498 if (!sys_prof_refcount_exit
)
499 unregister_trace_syscall_exit(prof_syscall_exit
);
500 mutex_unlock(&syscall_trace_lock
);