1 /* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1)
5 * LTTng syscall probes.
7 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
10 #include <linux/module.h>
11 #include <linux/slab.h>
12 #include <linux/compat.h>
13 #include <linux/err.h>
14 #include <linux/bitmap.h>
16 #include <linux/in6.h>
17 #include <linux/seq_file.h>
18 #include <linux/stringify.h>
19 #include <linux/file.h>
20 #include <linux/anon_inodes.h>
21 #include <asm/ptrace.h>
22 #include <asm/syscall.h>
24 #include <lib/bitfield.h>
25 #include <wrapper/tracepoint.h>
26 #include <wrapper/file.h>
27 #include <wrapper/rcu.h>
28 #include <wrapper/syscall.h>
29 #include <lttng-events.h>
32 # ifndef is_compat_task
33 # define is_compat_task() (0)
37 /* in_compat_syscall appears in kernel 4.6. */
38 #ifndef in_compat_syscall
39 #define in_compat_syscall() is_compat_task()
49 #define SYSCALL_ENTRY_TOK syscall_entry_
50 #define COMPAT_SYSCALL_ENTRY_TOK compat_syscall_entry_
51 #define SYSCALL_EXIT_TOK syscall_exit_
52 #define COMPAT_SYSCALL_EXIT_TOK compat_syscall_exit_
54 #define SYSCALL_ENTRY_STR __stringify(SYSCALL_ENTRY_TOK)
55 #define COMPAT_SYSCALL_ENTRY_STR __stringify(COMPAT_SYSCALL_ENTRY_TOK)
56 #define SYSCALL_EXIT_STR __stringify(SYSCALL_EXIT_TOK)
57 #define COMPAT_SYSCALL_EXIT_STR __stringify(COMPAT_SYSCALL_EXIT_TOK)
60 void syscall_entry_probe(void *__data
, struct pt_regs
*regs
, long id
);
62 void syscall_exit_probe(void *__data
, struct pt_regs
*regs
, long ret
);
65 * Forward declarations for old kernels.
69 struct oldold_utsname
;
71 struct sel_arg_struct
;
72 struct mmap_arg_struct
;
76 #ifdef IA32_NR_syscalls
77 #define NR_compat_syscalls IA32_NR_syscalls
79 #define NR_compat_syscalls NR_syscalls
83 * Create LTTng tracepoint probes.
85 #define LTTNG_PACKAGE_BUILD
86 #define CREATE_TRACE_POINTS
87 #define TP_MODULE_NOINIT
88 #define TRACE_INCLUDE_PATH instrumentation/syscalls/headers
90 #define PARAMS(args...) args
92 /* Handle unknown syscalls */
94 #define TRACE_SYSTEM syscalls_unknown
95 #include <instrumentation/syscalls/headers/syscalls_unknown.h>
103 #define sc_in(...) __VA_ARGS__
107 #define sc_inout(...) __VA_ARGS__
109 /* Hijack probe callback for system call enter */
111 #define TP_PROBE_CB(_template) &syscall_entry_probe
112 #define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _fields) \
113 LTTNG_TRACEPOINT_EVENT(syscall_entry_##_name, PARAMS(_proto), PARAMS(_args), \
115 #define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \
116 LTTNG_TRACEPOINT_EVENT_CODE(syscall_entry_##_name, PARAMS(_proto), PARAMS(_args), \
117 PARAMS(_locvar), PARAMS(_code_pre), \
118 PARAMS(_fields), PARAMS(_code_post))
119 #define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _fields) \
120 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscall_entry_##_name, PARAMS(_fields))
121 #define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
122 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscall_entry_##_template, syscall_entry_##_name)
123 /* Enumerations only defined at first inclusion. */
124 #define SC_LTTNG_TRACEPOINT_ENUM(_name, _values) \
125 LTTNG_TRACEPOINT_ENUM(_name, PARAMS(_values))
127 #define TRACE_SYSTEM syscall_entry_integers
128 #define TRACE_INCLUDE_FILE syscalls_integers
129 #include <instrumentation/syscalls/headers/syscalls_integers.h>
130 #undef TRACE_INCLUDE_FILE
132 #define TRACE_SYSTEM syscall_entry_pointers
133 #define TRACE_INCLUDE_FILE syscalls_pointers
134 #include <instrumentation/syscalls/headers/syscalls_pointers.h>
135 #undef TRACE_INCLUDE_FILE
137 #undef SC_LTTNG_TRACEPOINT_ENUM
138 #undef SC_LTTNG_TRACEPOINT_EVENT_CODE
139 #undef SC_LTTNG_TRACEPOINT_EVENT
140 #undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
141 #undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
143 #undef _TRACE_SYSCALLS_INTEGERS_H
144 #undef _TRACE_SYSCALLS_POINTERS_H
146 /* Hijack probe callback for compat system call enter */
147 #define TP_PROBE_CB(_template) &syscall_entry_probe
148 #define LTTNG_SC_COMPAT
149 #define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _fields) \
150 LTTNG_TRACEPOINT_EVENT(compat_syscall_entry_##_name, PARAMS(_proto), PARAMS(_args), \
152 #define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \
153 LTTNG_TRACEPOINT_EVENT_CODE(compat_syscall_entry_##_name, PARAMS(_proto), PARAMS(_args), \
154 PARAMS(_locvar), PARAMS(_code_pre), PARAMS(_fields), PARAMS(_code_post))
155 #define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _fields) \
156 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(compat_syscall_entry_##_name, PARAMS(_fields))
157 #define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
158 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(compat_syscall_entry_##_template, \
159 compat_syscall_entry_##_name)
160 /* Enumerations only defined at inital inclusion (not here). */
161 #define SC_LTTNG_TRACEPOINT_ENUM(_name, _values)
162 #define TRACE_SYSTEM compat_syscall_entry_integers
163 #define TRACE_INCLUDE_FILE compat_syscalls_integers
164 #include <instrumentation/syscalls/headers/compat_syscalls_integers.h>
165 #undef TRACE_INCLUDE_FILE
167 #define TRACE_SYSTEM compat_syscall_entry_pointers
168 #define TRACE_INCLUDE_FILE compat_syscalls_pointers
169 #include <instrumentation/syscalls/headers/compat_syscalls_pointers.h>
170 #undef TRACE_INCLUDE_FILE
172 #undef SC_LTTNG_TRACEPOINT_ENUM
173 #undef SC_LTTNG_TRACEPOINT_EVENT_CODE
174 #undef SC_LTTNG_TRACEPOINT_EVENT
175 #undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
176 #undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
178 #undef _TRACE_SYSCALLS_INTEGERS_H
179 #undef _TRACE_SYSCALLS_POINTERS_H
180 #undef LTTNG_SC_COMPAT
187 #define sc_exit(...) __VA_ARGS__
191 #define sc_out(...) __VA_ARGS__
193 #define sc_inout(...) __VA_ARGS__
195 /* Hijack probe callback for system call exit */
196 #define TP_PROBE_CB(_template) &syscall_exit_probe
197 #define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _fields) \
198 LTTNG_TRACEPOINT_EVENT(syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
200 #define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \
201 LTTNG_TRACEPOINT_EVENT_CODE(syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
202 PARAMS(_locvar), PARAMS(_code_pre), PARAMS(_fields), PARAMS(_code_post))
203 #define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _fields) \
204 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscall_exit_##_name, PARAMS(_fields))
205 #define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
206 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscall_exit_##_template, \
207 syscall_exit_##_name)
208 /* Enumerations only defined at inital inclusion (not here). */
209 #define SC_LTTNG_TRACEPOINT_ENUM(_name, _values)
210 #define TRACE_SYSTEM syscall_exit_integers
211 #define TRACE_INCLUDE_FILE syscalls_integers
212 #include <instrumentation/syscalls/headers/syscalls_integers.h>
213 #undef TRACE_INCLUDE_FILE
215 #define TRACE_SYSTEM syscall_exit_pointers
216 #define TRACE_INCLUDE_FILE syscalls_pointers
217 #include <instrumentation/syscalls/headers/syscalls_pointers.h>
218 #undef TRACE_INCLUDE_FILE
220 #undef SC_LTTNG_TRACEPOINT_ENUM
221 #undef SC_LTTNG_TRACEPOINT_EVENT_CODE
222 #undef SC_LTTNG_TRACEPOINT_EVENT
223 #undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
224 #undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
226 #undef _TRACE_SYSCALLS_INTEGERS_H
227 #undef _TRACE_SYSCALLS_POINTERS_H
230 /* Hijack probe callback for compat system call exit */
231 #define TP_PROBE_CB(_template) &syscall_exit_probe
232 #define LTTNG_SC_COMPAT
233 #define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _fields) \
234 LTTNG_TRACEPOINT_EVENT(compat_syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
236 #define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \
237 LTTNG_TRACEPOINT_EVENT_CODE(compat_syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
238 PARAMS(_locvar), PARAMS(_code_pre), PARAMS(_fields), PARAMS(_code_post))
239 #define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _fields) \
240 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(compat_syscall_exit_##_name, PARAMS(_fields))
241 #define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
242 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(compat_syscall_exit_##_template, \
243 compat_syscall_exit_##_name)
244 /* Enumerations only defined at inital inclusion (not here). */
245 #define SC_LTTNG_TRACEPOINT_ENUM(_name, _values)
246 #define TRACE_SYSTEM compat_syscall_exit_integers
247 #define TRACE_INCLUDE_FILE compat_syscalls_integers
248 #include <instrumentation/syscalls/headers/compat_syscalls_integers.h>
249 #undef TRACE_INCLUDE_FILE
251 #define TRACE_SYSTEM compat_syscall_exit_pointers
252 #define TRACE_INCLUDE_FILE compat_syscalls_pointers
253 #include <instrumentation/syscalls/headers/compat_syscalls_pointers.h>
254 #undef TRACE_INCLUDE_FILE
256 #undef SC_LTTNG_TRACEPOINT_ENUM
257 #undef SC_LTTNG_TRACEPOINT_EVENT_CODE
258 #undef SC_LTTNG_TRACEPOINT_EVENT
259 #undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
260 #undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
262 #undef _TRACE_SYSCALLS_INTEGERS_H
263 #undef _TRACE_SYSCALLS_POINTERS_H
264 #undef LTTNG_SC_COMPAT
268 #undef TP_MODULE_NOINIT
269 #undef LTTNG_PACKAGE_BUILD
270 #undef CREATE_TRACE_POINTS
272 struct trace_syscall_entry
{
274 const struct lttng_event_desc
*desc
;
275 const struct lttng_event_field
*fields
;
279 #define CREATE_SYSCALL_TABLE
286 #undef TRACE_SYSCALL_TABLE
287 #define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
289 .func = __event_probe__syscall_entry_##_template, \
290 .nrargs = (_nrargs), \
291 .fields = __event_fields___syscall_entry_##_template, \
292 .desc = &__event_desc___syscall_entry_##_name, \
295 /* Syscall enter tracing table */
296 static const struct trace_syscall_entry sc_table
[] = {
297 #include <instrumentation/syscalls/headers/syscalls_integers.h>
298 #include <instrumentation/syscalls/headers/syscalls_pointers.h>
301 #undef TRACE_SYSCALL_TABLE
302 #define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
304 .func = __event_probe__compat_syscall_entry_##_template, \
305 .nrargs = (_nrargs), \
306 .fields = __event_fields___compat_syscall_entry_##_template, \
307 .desc = &__event_desc___compat_syscall_entry_##_name, \
310 /* Compat syscall enter table */
311 const struct trace_syscall_entry compat_sc_table
[] = {
312 #include <instrumentation/syscalls/headers/compat_syscalls_integers.h>
313 #include <instrumentation/syscalls/headers/compat_syscalls_pointers.h>
321 #define sc_exit(...) __VA_ARGS__
323 #undef TRACE_SYSCALL_TABLE
324 #define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
326 .func = __event_probe__syscall_exit_##_template, \
327 .nrargs = (_nrargs), \
328 .fields = __event_fields___syscall_exit_##_template, \
329 .desc = &__event_desc___syscall_exit_##_name, \
332 /* Syscall exit table */
333 static const struct trace_syscall_entry sc_exit_table
[] = {
334 #include <instrumentation/syscalls/headers/syscalls_integers.h>
335 #include <instrumentation/syscalls/headers/syscalls_pointers.h>
338 #undef TRACE_SYSCALL_TABLE
339 #define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
341 .func = __event_probe__compat_syscall_exit_##_template, \
342 .nrargs = (_nrargs), \
343 .fields = __event_fields___compat_syscall_exit_##_template, \
344 .desc = &__event_desc___compat_syscall_exit_##_name, \
347 /* Compat syscall exit table */
348 const struct trace_syscall_entry compat_sc_exit_table
[] = {
349 #include <instrumentation/syscalls/headers/compat_syscalls_integers.h>
350 #include <instrumentation/syscalls/headers/compat_syscalls_pointers.h>
355 #undef CREATE_SYSCALL_TABLE
357 struct lttng_syscall_filter
{
358 DECLARE_BITMAP(sc
, NR_syscalls
);
359 DECLARE_BITMAP(sc_compat
, NR_compat_syscalls
);
362 static void syscall_entry_unknown(struct lttng_event
*event
,
363 struct pt_regs
*regs
, unsigned int id
)
365 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
367 lttng_syscall_get_arguments(current
, regs
, args
);
368 if (unlikely(in_compat_syscall()))
369 __event_probe__compat_syscall_entry_unknown(event
, id
, args
);
371 __event_probe__syscall_entry_unknown(event
, id
, args
);
374 void syscall_entry_probe(void *__data
, struct pt_regs
*regs
, long id
)
376 struct lttng_channel
*chan
= __data
;
377 struct lttng_event
*event
, *unknown_event
;
378 const struct trace_syscall_entry
*table
, *entry
;
381 if (unlikely(in_compat_syscall())) {
382 struct lttng_syscall_filter
*filter
;
384 filter
= lttng_rcu_dereference(chan
->sc_filter
);
386 if (id
< 0 || id
>= NR_compat_syscalls
387 || !test_bit(id
, filter
->sc_compat
)) {
388 /* System call filtered out. */
392 table
= compat_sc_table
;
393 table_len
= ARRAY_SIZE(compat_sc_table
);
394 unknown_event
= chan
->sc_compat_unknown
;
396 struct lttng_syscall_filter
*filter
;
398 filter
= lttng_rcu_dereference(chan
->sc_filter
);
400 if (id
< 0 || id
>= NR_syscalls
401 || !test_bit(id
, filter
->sc
)) {
402 /* System call filtered out. */
407 table_len
= ARRAY_SIZE(sc_table
);
408 unknown_event
= chan
->sc_unknown
;
410 if (unlikely(id
< 0 || id
>= table_len
)) {
411 syscall_entry_unknown(unknown_event
, regs
, id
);
414 if (unlikely(in_compat_syscall()))
415 event
= chan
->compat_sc_table
[id
];
417 event
= chan
->sc_table
[id
];
418 if (unlikely(!event
)) {
419 syscall_entry_unknown(unknown_event
, regs
, id
);
423 WARN_ON_ONCE(!entry
);
425 switch (entry
->nrargs
) {
428 void (*fptr
)(void *__data
) = entry
->func
;
435 void (*fptr
)(void *__data
, unsigned long arg0
) = entry
->func
;
436 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
438 lttng_syscall_get_arguments(current
, regs
, args
);
439 fptr(event
, args
[0]);
444 void (*fptr
)(void *__data
,
446 unsigned long arg1
) = entry
->func
;
447 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
449 lttng_syscall_get_arguments(current
, regs
, args
);
450 fptr(event
, args
[0], args
[1]);
455 void (*fptr
)(void *__data
,
458 unsigned long arg2
) = entry
->func
;
459 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
461 lttng_syscall_get_arguments(current
, regs
, args
);
462 fptr(event
, args
[0], args
[1], args
[2]);
467 void (*fptr
)(void *__data
,
471 unsigned long arg3
) = entry
->func
;
472 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
474 lttng_syscall_get_arguments(current
, regs
, args
);
475 fptr(event
, args
[0], args
[1], args
[2], args
[3]);
480 void (*fptr
)(void *__data
,
485 unsigned long arg4
) = entry
->func
;
486 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
488 lttng_syscall_get_arguments(current
, regs
, args
);
489 fptr(event
, args
[0], args
[1], args
[2], args
[3], args
[4]);
494 void (*fptr
)(void *__data
,
500 unsigned long arg5
) = entry
->func
;
501 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
503 lttng_syscall_get_arguments(current
, regs
, args
);
504 fptr(event
, args
[0], args
[1], args
[2],
505 args
[3], args
[4], args
[5]);
513 static void syscall_exit_unknown(struct lttng_event
*event
,
514 struct pt_regs
*regs
, int id
, long ret
)
516 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
518 lttng_syscall_get_arguments(current
, regs
, args
);
519 if (unlikely(in_compat_syscall()))
520 __event_probe__compat_syscall_exit_unknown(event
, id
, ret
,
523 __event_probe__syscall_exit_unknown(event
, id
, ret
, args
);
526 void syscall_exit_probe(void *__data
, struct pt_regs
*regs
, long ret
)
528 struct lttng_channel
*chan
= __data
;
529 struct lttng_event
*event
, *unknown_event
;
530 const struct trace_syscall_entry
*table
, *entry
;
534 id
= syscall_get_nr(current
, regs
);
535 if (unlikely(in_compat_syscall())) {
536 struct lttng_syscall_filter
*filter
;
538 filter
= lttng_rcu_dereference(chan
->sc_filter
);
540 if (id
< 0 || id
>= NR_compat_syscalls
541 || !test_bit(id
, filter
->sc_compat
)) {
542 /* System call filtered out. */
546 table
= compat_sc_exit_table
;
547 table_len
= ARRAY_SIZE(compat_sc_exit_table
);
548 unknown_event
= chan
->compat_sc_exit_unknown
;
550 struct lttng_syscall_filter
*filter
;
552 filter
= lttng_rcu_dereference(chan
->sc_filter
);
554 if (id
< 0 || id
>= NR_syscalls
555 || !test_bit(id
, filter
->sc
)) {
556 /* System call filtered out. */
560 table
= sc_exit_table
;
561 table_len
= ARRAY_SIZE(sc_exit_table
);
562 unknown_event
= chan
->sc_exit_unknown
;
564 if (unlikely(id
< 0 || id
>= table_len
)) {
565 syscall_exit_unknown(unknown_event
, regs
, id
, ret
);
568 if (unlikely(in_compat_syscall()))
569 event
= chan
->compat_sc_exit_table
[id
];
571 event
= chan
->sc_exit_table
[id
];
572 if (unlikely(!event
)) {
573 syscall_exit_unknown(unknown_event
, regs
, id
, ret
);
577 WARN_ON_ONCE(!entry
);
579 switch (entry
->nrargs
) {
582 void (*fptr
)(void *__data
, long ret
) = entry
->func
;
589 void (*fptr
)(void *__data
,
591 unsigned long arg0
) = entry
->func
;
592 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
594 lttng_syscall_get_arguments(current
, regs
, args
);
595 fptr(event
, ret
, args
[0]);
600 void (*fptr
)(void *__data
,
603 unsigned long arg1
) = entry
->func
;
604 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
606 lttng_syscall_get_arguments(current
, regs
, args
);
607 fptr(event
, ret
, args
[0], args
[1]);
612 void (*fptr
)(void *__data
,
616 unsigned long arg2
) = entry
->func
;
617 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
619 lttng_syscall_get_arguments(current
, regs
, args
);
620 fptr(event
, ret
, args
[0], args
[1], args
[2]);
625 void (*fptr
)(void *__data
,
630 unsigned long arg3
) = entry
->func
;
631 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
633 lttng_syscall_get_arguments(current
, regs
, args
);
634 fptr(event
, ret
, args
[0], args
[1], args
[2], args
[3]);
639 void (*fptr
)(void *__data
,
645 unsigned long arg4
) = entry
->func
;
646 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
648 lttng_syscall_get_arguments(current
, regs
, args
);
649 fptr(event
, ret
, args
[0], args
[1], args
[2], args
[3], args
[4]);
654 void (*fptr
)(void *__data
,
661 unsigned long arg5
) = entry
->func
;
662 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
664 lttng_syscall_get_arguments(current
, regs
, args
);
665 fptr(event
, ret
, args
[0], args
[1], args
[2],
666 args
[3], args
[4], args
[5]);
675 * noinline to diminish caller stack size.
676 * Should be called with sessions lock held.
679 int fill_table(const struct trace_syscall_entry
*table
, size_t table_len
,
680 struct lttng_event
**chan_table
, struct lttng_channel
*chan
,
681 void *filter
, enum sc_type type
)
683 const struct lttng_event_desc
*desc
;
686 /* Allocate events for each syscall, insert into table */
687 for (i
= 0; i
< table_len
; i
++) {
688 struct lttng_kernel_event ev
;
689 desc
= table
[i
].desc
;
692 /* Unknown syscall */
696 * Skip those already populated by previous failed
697 * register for this channel.
701 memset(&ev
, 0, sizeof(ev
));
704 strncpy(ev
.name
, SYSCALL_ENTRY_STR
,
705 LTTNG_KERNEL_SYM_NAME_LEN
);
708 strncpy(ev
.name
, SYSCALL_EXIT_STR
,
709 LTTNG_KERNEL_SYM_NAME_LEN
);
711 case SC_TYPE_COMPAT_ENTRY
:
712 strncpy(ev
.name
, COMPAT_SYSCALL_ENTRY_STR
,
713 LTTNG_KERNEL_SYM_NAME_LEN
);
715 case SC_TYPE_COMPAT_EXIT
:
716 strncpy(ev
.name
, COMPAT_SYSCALL_EXIT_STR
,
717 LTTNG_KERNEL_SYM_NAME_LEN
);
723 strncat(ev
.name
, desc
->name
,
724 LTTNG_KERNEL_SYM_NAME_LEN
- strlen(ev
.name
) - 1);
725 ev
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
726 ev
.instrumentation
= LTTNG_KERNEL_SYSCALL
;
727 chan_table
[i
] = _lttng_event_create(chan
, &ev
, filter
,
728 desc
, ev
.instrumentation
);
729 WARN_ON_ONCE(!chan_table
[i
]);
730 if (IS_ERR(chan_table
[i
])) {
732 * If something goes wrong in event registration
733 * after the first one, we have no choice but to
734 * leave the previous events in there, until
735 * deleted by session teardown.
737 return PTR_ERR(chan_table
[i
]);
744 * Should be called with sessions lock held.
746 int lttng_syscalls_register(struct lttng_channel
*chan
, void *filter
)
748 struct lttng_kernel_event ev
;
751 wrapper_vmalloc_sync_all();
753 if (!chan
->sc_table
) {
754 /* create syscall table mapping syscall to events */
755 chan
->sc_table
= kzalloc(sizeof(struct lttng_event
*)
756 * ARRAY_SIZE(sc_table
), GFP_KERNEL
);
760 if (!chan
->sc_exit_table
) {
761 /* create syscall table mapping syscall to events */
762 chan
->sc_exit_table
= kzalloc(sizeof(struct lttng_event
*)
763 * ARRAY_SIZE(sc_exit_table
), GFP_KERNEL
);
764 if (!chan
->sc_exit_table
)
770 if (!chan
->compat_sc_table
) {
771 /* create syscall table mapping compat syscall to events */
772 chan
->compat_sc_table
= kzalloc(sizeof(struct lttng_event
*)
773 * ARRAY_SIZE(compat_sc_table
), GFP_KERNEL
);
774 if (!chan
->compat_sc_table
)
778 if (!chan
->compat_sc_exit_table
) {
779 /* create syscall table mapping compat syscall to events */
780 chan
->compat_sc_exit_table
= kzalloc(sizeof(struct lttng_event
*)
781 * ARRAY_SIZE(compat_sc_exit_table
), GFP_KERNEL
);
782 if (!chan
->compat_sc_exit_table
)
786 if (!chan
->sc_unknown
) {
787 const struct lttng_event_desc
*desc
=
788 &__event_desc___syscall_entry_unknown
;
790 memset(&ev
, 0, sizeof(ev
));
791 strncpy(ev
.name
, desc
->name
, LTTNG_KERNEL_SYM_NAME_LEN
);
792 ev
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
793 ev
.instrumentation
= LTTNG_KERNEL_SYSCALL
;
794 chan
->sc_unknown
= _lttng_event_create(chan
, &ev
, filter
,
797 WARN_ON_ONCE(!chan
->sc_unknown
);
798 if (IS_ERR(chan
->sc_unknown
)) {
799 return PTR_ERR(chan
->sc_unknown
);
803 if (!chan
->sc_compat_unknown
) {
804 const struct lttng_event_desc
*desc
=
805 &__event_desc___compat_syscall_entry_unknown
;
807 memset(&ev
, 0, sizeof(ev
));
808 strncpy(ev
.name
, desc
->name
, LTTNG_KERNEL_SYM_NAME_LEN
);
809 ev
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
810 ev
.instrumentation
= LTTNG_KERNEL_SYSCALL
;
811 chan
->sc_compat_unknown
= _lttng_event_create(chan
, &ev
, filter
,
814 WARN_ON_ONCE(!chan
->sc_unknown
);
815 if (IS_ERR(chan
->sc_compat_unknown
)) {
816 return PTR_ERR(chan
->sc_compat_unknown
);
820 if (!chan
->compat_sc_exit_unknown
) {
821 const struct lttng_event_desc
*desc
=
822 &__event_desc___compat_syscall_exit_unknown
;
824 memset(&ev
, 0, sizeof(ev
));
825 strncpy(ev
.name
, desc
->name
, LTTNG_KERNEL_SYM_NAME_LEN
);
826 ev
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
827 ev
.instrumentation
= LTTNG_KERNEL_SYSCALL
;
828 chan
->compat_sc_exit_unknown
= _lttng_event_create(chan
, &ev
,
831 WARN_ON_ONCE(!chan
->compat_sc_exit_unknown
);
832 if (IS_ERR(chan
->compat_sc_exit_unknown
)) {
833 return PTR_ERR(chan
->compat_sc_exit_unknown
);
837 if (!chan
->sc_exit_unknown
) {
838 const struct lttng_event_desc
*desc
=
839 &__event_desc___syscall_exit_unknown
;
841 memset(&ev
, 0, sizeof(ev
));
842 strncpy(ev
.name
, desc
->name
, LTTNG_KERNEL_SYM_NAME_LEN
);
843 ev
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
844 ev
.instrumentation
= LTTNG_KERNEL_SYSCALL
;
845 chan
->sc_exit_unknown
= _lttng_event_create(chan
, &ev
, filter
,
846 desc
, ev
.instrumentation
);
847 WARN_ON_ONCE(!chan
->sc_exit_unknown
);
848 if (IS_ERR(chan
->sc_exit_unknown
)) {
849 return PTR_ERR(chan
->sc_exit_unknown
);
853 ret
= fill_table(sc_table
, ARRAY_SIZE(sc_table
),
854 chan
->sc_table
, chan
, filter
, SC_TYPE_ENTRY
);
857 ret
= fill_table(sc_exit_table
, ARRAY_SIZE(sc_exit_table
),
858 chan
->sc_exit_table
, chan
, filter
, SC_TYPE_EXIT
);
863 ret
= fill_table(compat_sc_table
, ARRAY_SIZE(compat_sc_table
),
864 chan
->compat_sc_table
, chan
, filter
,
865 SC_TYPE_COMPAT_ENTRY
);
868 ret
= fill_table(compat_sc_exit_table
, ARRAY_SIZE(compat_sc_exit_table
),
869 chan
->compat_sc_exit_table
, chan
, filter
,
870 SC_TYPE_COMPAT_EXIT
);
874 if (!chan
->sys_enter_registered
) {
875 ret
= lttng_wrapper_tracepoint_probe_register("sys_enter",
876 (void *) syscall_entry_probe
, chan
);
879 chan
->sys_enter_registered
= 1;
882 * We change the name of sys_exit tracepoint due to namespace
883 * conflict with sys_exit syscall entry.
885 if (!chan
->sys_exit_registered
) {
886 ret
= lttng_wrapper_tracepoint_probe_register("sys_exit",
887 (void *) syscall_exit_probe
, chan
);
889 WARN_ON_ONCE(lttng_wrapper_tracepoint_probe_unregister("sys_enter",
890 (void *) syscall_entry_probe
, chan
));
893 chan
->sys_exit_registered
= 1;
899 * Only called at session destruction.
901 int lttng_syscalls_unregister(struct lttng_channel
*chan
)
907 if (chan
->sys_enter_registered
) {
908 ret
= lttng_wrapper_tracepoint_probe_unregister("sys_exit",
909 (void *) syscall_exit_probe
, chan
);
912 chan
->sys_enter_registered
= 0;
914 if (chan
->sys_exit_registered
) {
915 ret
= lttng_wrapper_tracepoint_probe_unregister("sys_enter",
916 (void *) syscall_entry_probe
, chan
);
919 chan
->sys_exit_registered
= 0;
921 /* lttng_event destroy will be performed by lttng_session_destroy() */
922 kfree(chan
->sc_table
);
923 kfree(chan
->sc_exit_table
);
925 kfree(chan
->compat_sc_table
);
926 kfree(chan
->compat_sc_exit_table
);
928 kfree(chan
->sc_filter
);
933 int get_syscall_nr(const char *syscall_name
)
938 for (i
= 0; i
< ARRAY_SIZE(sc_table
); i
++) {
939 const struct trace_syscall_entry
*entry
;
942 entry
= &sc_table
[i
];
945 it_name
= entry
->desc
->name
;
946 it_name
+= strlen(SYSCALL_ENTRY_STR
);
947 if (!strcmp(syscall_name
, it_name
)) {
956 int get_compat_syscall_nr(const char *syscall_name
)
961 for (i
= 0; i
< ARRAY_SIZE(compat_sc_table
); i
++) {
962 const struct trace_syscall_entry
*entry
;
965 entry
= &compat_sc_table
[i
];
968 it_name
= entry
->desc
->name
;
969 it_name
+= strlen(COMPAT_SYSCALL_ENTRY_STR
);
970 if (!strcmp(syscall_name
, it_name
)) {
979 uint32_t get_sc_tables_len(void)
981 return ARRAY_SIZE(sc_table
) + ARRAY_SIZE(compat_sc_table
);
984 int lttng_syscall_filter_enable(struct lttng_channel
*chan
,
987 int syscall_nr
, compat_syscall_nr
, ret
;
988 struct lttng_syscall_filter
*filter
;
990 WARN_ON_ONCE(!chan
->sc_table
);
993 /* Enable all system calls by removing filter */
994 if (chan
->sc_filter
) {
995 filter
= chan
->sc_filter
;
996 rcu_assign_pointer(chan
->sc_filter
, NULL
);
1000 chan
->syscall_all
= 1;
1004 if (!chan
->sc_filter
) {
1005 if (chan
->syscall_all
) {
1007 * All syscalls are already enabled.
1011 filter
= kzalloc(sizeof(struct lttng_syscall_filter
),
1016 filter
= chan
->sc_filter
;
1018 syscall_nr
= get_syscall_nr(name
);
1019 compat_syscall_nr
= get_compat_syscall_nr(name
);
1020 if (syscall_nr
< 0 && compat_syscall_nr
< 0) {
1024 if (syscall_nr
>= 0) {
1025 if (test_bit(syscall_nr
, filter
->sc
)) {
1029 bitmap_set(filter
->sc
, syscall_nr
, 1);
1031 if (compat_syscall_nr
>= 0) {
1032 if (test_bit(compat_syscall_nr
, filter
->sc_compat
)) {
1036 bitmap_set(filter
->sc_compat
, compat_syscall_nr
, 1);
1038 if (!chan
->sc_filter
)
1039 rcu_assign_pointer(chan
->sc_filter
, filter
);
1043 if (!chan
->sc_filter
)
1048 int lttng_syscall_filter_disable(struct lttng_channel
*chan
,
1051 int syscall_nr
, compat_syscall_nr
, ret
;
1052 struct lttng_syscall_filter
*filter
;
1054 WARN_ON_ONCE(!chan
->sc_table
);
1056 if (!chan
->sc_filter
) {
1057 if (!chan
->syscall_all
)
1059 filter
= kzalloc(sizeof(struct lttng_syscall_filter
),
1063 /* Trace all system calls, then apply disable. */
1064 bitmap_set(filter
->sc
, 0, NR_syscalls
);
1065 bitmap_set(filter
->sc_compat
, 0, NR_compat_syscalls
);
1067 filter
= chan
->sc_filter
;
1071 /* Fail if all syscalls are already disabled. */
1072 if (bitmap_empty(filter
->sc
, NR_syscalls
)
1073 && bitmap_empty(filter
->sc_compat
,
1074 NR_compat_syscalls
)) {
1079 /* Disable all system calls */
1080 bitmap_clear(filter
->sc
, 0, NR_syscalls
);
1081 bitmap_clear(filter
->sc_compat
, 0, NR_compat_syscalls
);
1084 syscall_nr
= get_syscall_nr(name
);
1085 compat_syscall_nr
= get_compat_syscall_nr(name
);
1086 if (syscall_nr
< 0 && compat_syscall_nr
< 0) {
1090 if (syscall_nr
>= 0) {
1091 if (!test_bit(syscall_nr
, filter
->sc
)) {
1095 bitmap_clear(filter
->sc
, syscall_nr
, 1);
1097 if (compat_syscall_nr
>= 0) {
1098 if (!test_bit(compat_syscall_nr
, filter
->sc_compat
)) {
1102 bitmap_clear(filter
->sc_compat
, compat_syscall_nr
, 1);
1105 if (!chan
->sc_filter
)
1106 rcu_assign_pointer(chan
->sc_filter
, filter
);
1107 chan
->syscall_all
= 0;
1111 if (!chan
->sc_filter
)
1117 const struct trace_syscall_entry
*syscall_list_get_entry(loff_t
*pos
)
1119 const struct trace_syscall_entry
*entry
;
1122 for (entry
= sc_table
;
1123 entry
< sc_table
+ ARRAY_SIZE(sc_table
);
1128 for (entry
= compat_sc_table
;
1129 entry
< compat_sc_table
+ ARRAY_SIZE(compat_sc_table
);
1139 void *syscall_list_start(struct seq_file
*m
, loff_t
*pos
)
1141 return (void *) syscall_list_get_entry(pos
);
1145 void *syscall_list_next(struct seq_file
*m
, void *p
, loff_t
*ppos
)
1148 return (void *) syscall_list_get_entry(ppos
);
1152 void syscall_list_stop(struct seq_file
*m
, void *p
)
1157 int get_sc_table(const struct trace_syscall_entry
*entry
,
1158 const struct trace_syscall_entry
**table
,
1159 unsigned int *bitness
)
1161 if (entry
>= sc_table
&& entry
< sc_table
+ ARRAY_SIZE(sc_table
)) {
1163 *bitness
= BITS_PER_LONG
;
1168 if (!(entry
>= compat_sc_table
1169 && entry
< compat_sc_table
+ ARRAY_SIZE(compat_sc_table
))) {
1175 *table
= compat_sc_table
;
1180 int syscall_list_show(struct seq_file
*m
, void *p
)
1182 const struct trace_syscall_entry
*table
, *entry
= p
;
1183 unsigned int bitness
;
1184 unsigned long index
;
1188 ret
= get_sc_table(entry
, &table
, &bitness
);
1193 if (table
== sc_table
) {
1194 index
= entry
- table
;
1195 name
= &entry
->desc
->name
[strlen(SYSCALL_ENTRY_STR
)];
1197 index
= (entry
- table
) + ARRAY_SIZE(sc_table
);
1198 name
= &entry
->desc
->name
[strlen(COMPAT_SYSCALL_ENTRY_STR
)];
1200 seq_printf(m
, "syscall { index = %lu; name = %s; bitness = %u; };\n",
1201 index
, name
, bitness
);
1206 const struct seq_operations lttng_syscall_list_seq_ops
= {
1207 .start
= syscall_list_start
,
1208 .next
= syscall_list_next
,
1209 .stop
= syscall_list_stop
,
1210 .show
= syscall_list_show
,
1214 int lttng_syscall_list_open(struct inode
*inode
, struct file
*file
)
1216 return seq_open(file
, <tng_syscall_list_seq_ops
);
1219 const struct file_operations lttng_syscall_list_fops
= {
1220 .owner
= THIS_MODULE
,
1221 .open
= lttng_syscall_list_open
,
1223 .llseek
= seq_lseek
,
1224 .release
= seq_release
,
1227 long lttng_channel_syscall_mask(struct lttng_channel
*channel
,
1228 struct lttng_kernel_syscall_mask __user
*usyscall_mask
)
1230 uint32_t len
, sc_tables_len
, bitmask_len
;
1233 struct lttng_syscall_filter
*filter
;
1235 ret
= get_user(len
, &usyscall_mask
->len
);
1238 sc_tables_len
= get_sc_tables_len();
1239 bitmask_len
= ALIGN(sc_tables_len
, 8) >> 3;
1240 if (len
< sc_tables_len
) {
1241 return put_user(sc_tables_len
, &usyscall_mask
->len
);
1243 /* Array is large enough, we can copy array to user-space. */
1244 tmp_mask
= kzalloc(bitmask_len
, GFP_KERNEL
);
1247 filter
= channel
->sc_filter
;
1249 for (bit
= 0; bit
< ARRAY_SIZE(sc_table
); bit
++) {
1252 if (channel
->sc_table
) {
1254 state
= test_bit(bit
, filter
->sc
);
1260 bt_bitfield_write_be(tmp_mask
, char, bit
, 1, state
);
1262 for (; bit
< sc_tables_len
; bit
++) {
1265 if (channel
->compat_sc_table
) {
1267 state
= test_bit(bit
- ARRAY_SIZE(sc_table
),
1274 bt_bitfield_write_be(tmp_mask
, char, bit
, 1, state
);
1276 if (copy_to_user(usyscall_mask
->mask
, tmp_mask
, bitmask_len
))
1282 int lttng_abi_syscall_list(void)
1284 struct file
*syscall_list_file
;
1287 file_fd
= lttng_get_unused_fd();
1293 syscall_list_file
= anon_inode_getfile("[lttng_syscall_list]",
1294 <tng_syscall_list_fops
,
1296 if (IS_ERR(syscall_list_file
)) {
1297 ret
= PTR_ERR(syscall_list_file
);
1300 ret
= lttng_syscall_list_fops
.open(NULL
, syscall_list_file
);
1303 fd_install(file_fd
, syscall_list_file
);
1307 fput(syscall_list_file
);
1309 put_unused_fd(file_fd
);