4 * LTTng syscall probes.
6 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; only
11 * version 2.1 of the License.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/compat.h>
26 #include <linux/err.h>
27 #include <linux/bitmap.h>
29 #include <linux/in6.h>
30 #include <linux/seq_file.h>
31 #include <asm/ptrace.h>
32 #include <asm/syscall.h>
34 #include "wrapper/tracepoint.h"
35 #include "lttng-events.h"
38 # ifndef is_compat_task
39 # define is_compat_task() (0)
50 #define SYSCALL_ENTRY_STR "syscall_entry_"
51 #define COMPAT_SYSCALL_ENTRY_STR "compat_syscall_entry_"
52 #define SYSCALL_EXIT_STR "syscall_exit_"
53 #define COMPAT_SYSCALL_EXIT_STR "compat_syscall_exit_"
56 void syscall_entry_probe(void *__data
, struct pt_regs
*regs
, long id
);
58 void syscall_exit_probe(void *__data
, struct pt_regs
*regs
, long ret
);
61 * Forward declarations for old kernels.
65 struct oldold_utsname
;
67 struct sel_arg_struct
;
68 struct mmap_arg_struct
;
70 #ifdef IA32_NR_syscalls
71 #define NR_compat_syscalls IA32_NR_syscalls
73 #define NR_compat_syscalls NR_syscalls
77 * Create LTTng tracepoint probes.
79 #define LTTNG_PACKAGE_BUILD
80 #define CREATE_TRACE_POINTS
81 #define TP_MODULE_NOINIT
82 #define TRACE_INCLUDE_PATH ../instrumentation/syscalls/headers
84 #define PARAMS(args...) args
86 /* Handle unknown syscalls */
87 #define TRACE_SYSTEM syscalls_unknown
88 #include "instrumentation/syscalls/headers/syscalls_unknown.h"
96 #define sc_in(...) __VA_ARGS__
100 #define sc_inout(...) __VA_ARGS__
102 /* Hijack probe callback for system call enter */
104 #define TP_PROBE_CB(_template) &syscall_entry_probe
105 #define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _struct, _assign, _printk) \
106 LTTNG_TRACEPOINT_EVENT(syscall_enter_##_name, PARAMS(_proto), PARAMS(_args), \
107 PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
108 #define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code, _struct, _assign, _printk) \
109 LTTNG_TRACEPOINT_EVENT_CODE(syscall_enter_##_name, PARAMS(_proto), PARAMS(_args), \
110 PARAMS(_locvar), PARAMS(_code), \
111 PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
112 #define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _struct, _assign, _printk) \
113 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscall_enter_##_name, PARAMS(_struct), PARAMS(_assign), \
115 #define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
116 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscall_enter_##_template, syscall_enter_##_name)
118 #define TRACE_SYSTEM syscall_enter_integers
119 #define TRACE_INCLUDE_FILE syscalls_integers
120 #include "instrumentation/syscalls/headers/syscalls_integers.h"
121 #undef TRACE_INCLUDE_FILE
123 #define TRACE_SYSTEM syscall_enter_pointers
124 #define TRACE_INCLUDE_FILE syscalls_pointers
125 #include "instrumentation/syscalls/headers/syscalls_pointers.h"
126 #undef TRACE_INCLUDE_FILE
128 #undef SC_LTTNG_TRACEPOINT_EVENT_CODE
129 #undef SC_LTTNG_TRACEPOINT_EVENT
130 #undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
131 #undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
133 #undef _TRACE_SYSCALLS_INTEGERS_H
134 #undef _TRACE_SYSCALLS_POINTERS_H
136 /* Hijack probe callback for compat system call enter */
137 #define TP_PROBE_CB(_template) &syscall_entry_probe
138 #define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _struct, _assign, _printk) \
139 LTTNG_TRACEPOINT_EVENT(compat_syscall_enter_##_name, PARAMS(_proto), PARAMS(_args), \
140 PARAMS(_struct), PARAMS(_assign), \
142 #define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code, _struct, _assign, _printk) \
143 LTTNG_TRACEPOINT_EVENT_CODE(compat_syscall_enter_##_name, PARAMS(_proto), PARAMS(_args), \
144 PARAMS(_locvar), PARAMS(_code), \
145 PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
146 #define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _struct, _assign, _printk) \
147 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(compat_syscall_enter_##_name, PARAMS(_struct), \
148 PARAMS(_assign), PARAMS(_printk))
149 #define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
150 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(compat_syscall_enter_##_template, \
151 compat_syscall_enter_##_name)
152 #define TRACE_SYSTEM compat_syscall_enter_integers
153 #define TRACE_INCLUDE_FILE compat_syscalls_integers
154 #include "instrumentation/syscalls/headers/compat_syscalls_integers.h"
155 #undef TRACE_INCLUDE_FILE
157 #define TRACE_SYSTEM compat_syscall_enter_pointers
158 #define TRACE_INCLUDE_FILE compat_syscalls_pointers
159 #include "instrumentation/syscalls/headers/compat_syscalls_pointers.h"
160 #undef TRACE_INCLUDE_FILE
162 #undef SC_LTTNG_TRACEPOINT_EVENT_CODE
163 #undef SC_LTTNG_TRACEPOINT_EVENT
164 #undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
165 #undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
167 #undef _TRACE_SYSCALLS_INTEGERS_H
168 #undef _TRACE_SYSCALLS_POINTERS_H
175 #define sc_exit(...) __VA_ARGS__
179 #define sc_out(...) __VA_ARGS__
181 #define sc_inout(...) __VA_ARGS__
183 /* Hijack probe callback for system call exit */
184 #define TP_PROBE_CB(_template) &syscall_exit_probe
185 #define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _struct, _assign, _printk) \
186 LTTNG_TRACEPOINT_EVENT(syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
187 PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
188 #define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code, _struct, _assign, _printk) \
189 LTTNG_TRACEPOINT_EVENT_CODE(syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
190 PARAMS(_locvar), PARAMS(_code), \
191 PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
192 #define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _struct, _assign, _printk) \
193 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscall_exit_##_name, PARAMS(_struct), \
194 PARAMS(_assign), PARAMS(_printk))
195 #define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
196 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscall_exit_##_template, \
197 syscall_exit_##_name)
198 #define TRACE_SYSTEM syscall_exit_integers
199 #define TRACE_INCLUDE_FILE syscalls_integers
200 #include "instrumentation/syscalls/headers/syscalls_integers.h"
201 #undef TRACE_INCLUDE_FILE
203 #define TRACE_SYSTEM syscall_exit_pointers
204 #define TRACE_INCLUDE_FILE syscalls_pointers
205 #include "instrumentation/syscalls/headers/syscalls_pointers.h"
206 #undef TRACE_INCLUDE_FILE
208 #undef SC_LTTNG_TRACEPOINT_EVENT_CODE
209 #undef SC_LTTNG_TRACEPOINT_EVENT
210 #undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
211 #undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
213 #undef _TRACE_SYSCALLS_INTEGERS_H
214 #undef _TRACE_SYSCALLS_POINTERS_H
217 /* Hijack probe callback for compat system call exit */
218 #define TP_PROBE_CB(_template) &syscall_exit_probe
219 #define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _struct, _assign, _printk) \
220 LTTNG_TRACEPOINT_EVENT(compat_syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
221 PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
222 #define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code, _struct, _assign, _printk) \
223 LTTNG_TRACEPOINT_EVENT_CODE(compat_syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
224 PARAMS(_locvar), PARAMS(_code), \
225 PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
226 #define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _struct, _assign, _printk) \
227 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(compat_syscall_exit_##_name, PARAMS(_struct), \
228 PARAMS(_assign), PARAMS(_printk))
229 #define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
230 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(compat_syscall_exit_##_template, \
231 compat_syscall_exit_##_name)
232 #define TRACE_SYSTEM compat_syscall_exit_integers
233 #define TRACE_INCLUDE_FILE compat_syscalls_integers
234 #include "instrumentation/syscalls/headers/compat_syscalls_integers.h"
235 #undef TRACE_INCLUDE_FILE
237 #define TRACE_SYSTEM compat_syscall_exit_pointers
238 #define TRACE_INCLUDE_FILE compat_syscalls_pointers
239 #include "instrumentation/syscalls/headers/compat_syscalls_pointers.h"
240 #undef TRACE_INCLUDE_FILE
242 #undef SC_LTTNG_TRACEPOINT_EVENT_CODE
243 #undef SC_LTTNG_TRACEPOINT_EVENT
244 #undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
245 #undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
247 #undef _TRACE_SYSCALLS_INTEGERS_H
248 #undef _TRACE_SYSCALLS_POINTERS_H
252 #undef TP_MODULE_NOINIT
253 #undef LTTNG_PACKAGE_BUILD
254 #undef CREATE_TRACE_POINTS
256 struct trace_syscall_entry
{
258 const struct lttng_event_desc
*desc
;
259 const struct lttng_event_field
*fields
;
263 #define CREATE_SYSCALL_TABLE
270 #undef TRACE_SYSCALL_TABLE
271 #define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
273 .func = __event_probe__syscall_enter_##_template, \
274 .nrargs = (_nrargs), \
275 .fields = __event_fields___syscall_enter_##_template, \
276 .desc = &__event_desc___syscall_enter_##_name, \
279 /* Syscall enter tracing table */
280 static const struct trace_syscall_entry sc_table
[] = {
281 #include "instrumentation/syscalls/headers/syscalls_integers.h"
282 #include "instrumentation/syscalls/headers/syscalls_pointers.h"
285 #undef TRACE_SYSCALL_TABLE
286 #define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
288 .func = __event_probe__compat_syscall_enter_##_template, \
289 .nrargs = (_nrargs), \
290 .fields = __event_fields___compat_syscall_enter_##_template, \
291 .desc = &__event_desc___compat_syscall_enter_##_name, \
294 /* Compat syscall enter table */
295 const struct trace_syscall_entry compat_sc_table
[] = {
296 #include "instrumentation/syscalls/headers/compat_syscalls_integers.h"
297 #include "instrumentation/syscalls/headers/compat_syscalls_pointers.h"
305 #define sc_exit(...) __VA_ARGS__
307 #undef TRACE_SYSCALL_TABLE
308 #define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
310 .func = __event_probe__syscall_exit_##_template, \
311 .nrargs = (_nrargs), \
312 .fields = __event_fields___syscall_exit_##_template, \
313 .desc = &__event_desc___syscall_exit_##_name, \
316 /* Syscall exit table */
317 static const struct trace_syscall_entry sc_exit_table
[] = {
318 #include "instrumentation/syscalls/headers/syscalls_integers.h"
319 #include "instrumentation/syscalls/headers/syscalls_pointers.h"
322 #undef TRACE_SYSCALL_TABLE
323 #define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
325 .func = __event_probe__compat_syscall_exit_##_template, \
326 .nrargs = (_nrargs), \
327 .fields = __event_fields___compat_syscall_exit_##_template, \
328 .desc = &__event_desc___compat_syscall_exit_##_name, \
331 /* Compat syscall exit table */
332 const struct trace_syscall_entry compat_sc_exit_table
[] = {
333 #include "instrumentation/syscalls/headers/compat_syscalls_integers.h"
334 #include "instrumentation/syscalls/headers/compat_syscalls_pointers.h"
339 #undef CREATE_SYSCALL_TABLE
341 struct lttng_syscall_filter
{
342 DECLARE_BITMAP(sc
, NR_syscalls
);
343 DECLARE_BITMAP(sc_compat
, NR_compat_syscalls
);
346 static void syscall_entry_unknown(struct lttng_event
*event
,
347 struct pt_regs
*regs
, unsigned int id
)
349 unsigned long args
[UNKNOWN_SYSCALL_NRARGS
];
351 syscall_get_arguments(current
, regs
, 0, UNKNOWN_SYSCALL_NRARGS
, args
);
352 if (unlikely(is_compat_task()))
353 __event_probe__compat_syscall_enter_unknown(event
, id
, args
);
355 __event_probe__syscall_enter_unknown(event
, id
, args
);
358 void syscall_entry_probe(void *__data
, struct pt_regs
*regs
, long id
)
360 struct lttng_channel
*chan
= __data
;
361 struct lttng_event
*event
, *unknown_event
;
362 const struct trace_syscall_entry
*table
, *entry
;
365 if (unlikely(is_compat_task())) {
366 struct lttng_syscall_filter
*filter
;
368 filter
= rcu_dereference(chan
->sc_filter
);
370 if (id
>= NR_compat_syscalls
371 || !test_bit(id
, filter
->sc_compat
)) {
372 /* System call filtered out. */
376 table
= compat_sc_table
;
377 table_len
= ARRAY_SIZE(compat_sc_table
);
378 unknown_event
= chan
->sc_compat_unknown
;
380 struct lttng_syscall_filter
*filter
;
382 filter
= rcu_dereference(chan
->sc_filter
);
384 if (id
>= NR_syscalls
385 || !test_bit(id
, filter
->sc
)) {
386 /* System call filtered out. */
391 table_len
= ARRAY_SIZE(sc_table
);
392 unknown_event
= chan
->sc_unknown
;
394 if (unlikely(id
>= table_len
)) {
395 syscall_entry_unknown(unknown_event
, regs
, id
);
398 if (unlikely(is_compat_task()))
399 event
= chan
->compat_sc_table
[id
];
401 event
= chan
->sc_table
[id
];
402 if (unlikely(!event
)) {
403 syscall_entry_unknown(unknown_event
, regs
, id
);
407 WARN_ON_ONCE(!entry
);
409 switch (entry
->nrargs
) {
412 void (*fptr
)(void *__data
) = entry
->func
;
419 void (*fptr
)(void *__data
, unsigned long arg0
) = entry
->func
;
420 unsigned long args
[1];
422 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
423 fptr(event
, args
[0]);
428 void (*fptr
)(void *__data
,
430 unsigned long arg1
) = entry
->func
;
431 unsigned long args
[2];
433 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
434 fptr(event
, args
[0], args
[1]);
439 void (*fptr
)(void *__data
,
442 unsigned long arg2
) = entry
->func
;
443 unsigned long args
[3];
445 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
446 fptr(event
, args
[0], args
[1], args
[2]);
451 void (*fptr
)(void *__data
,
455 unsigned long arg3
) = entry
->func
;
456 unsigned long args
[4];
458 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
459 fptr(event
, args
[0], args
[1], args
[2], args
[3]);
464 void (*fptr
)(void *__data
,
469 unsigned long arg4
) = entry
->func
;
470 unsigned long args
[5];
472 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
473 fptr(event
, args
[0], args
[1], args
[2], args
[3], args
[4]);
478 void (*fptr
)(void *__data
,
484 unsigned long arg5
) = entry
->func
;
485 unsigned long args
[6];
487 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
488 fptr(event
, args
[0], args
[1], args
[2],
489 args
[3], args
[4], args
[5]);
497 static void syscall_exit_unknown(struct lttng_event
*event
,
498 struct pt_regs
*regs
, unsigned int id
, long ret
)
500 unsigned long args
[UNKNOWN_SYSCALL_NRARGS
];
502 syscall_get_arguments(current
, regs
, 0, UNKNOWN_SYSCALL_NRARGS
, args
);
503 if (unlikely(is_compat_task()))
504 __event_probe__compat_syscall_exit_unknown(event
, id
, ret
,
507 __event_probe__syscall_exit_unknown(event
, id
, ret
, args
);
510 void syscall_exit_probe(void *__data
, struct pt_regs
*regs
, long ret
)
512 struct lttng_channel
*chan
= __data
;
513 struct lttng_event
*event
, *unknown_event
;
514 const struct trace_syscall_entry
*table
, *entry
;
518 id
= syscall_get_nr(current
, regs
);
519 if (unlikely(is_compat_task())) {
520 struct lttng_syscall_filter
*filter
;
522 filter
= rcu_dereference(chan
->sc_filter
);
524 if (id
>= NR_compat_syscalls
525 || !test_bit(id
, filter
->sc_compat
)) {
526 /* System call filtered out. */
530 table
= compat_sc_exit_table
;
531 table_len
= ARRAY_SIZE(compat_sc_exit_table
);
532 unknown_event
= chan
->compat_sc_exit_unknown
;
534 struct lttng_syscall_filter
*filter
;
536 filter
= rcu_dereference(chan
->sc_filter
);
538 if (id
>= NR_syscalls
539 || !test_bit(id
, filter
->sc
)) {
540 /* System call filtered out. */
544 table
= sc_exit_table
;
545 table_len
= ARRAY_SIZE(sc_exit_table
);
546 unknown_event
= chan
->sc_exit_unknown
;
548 if (unlikely(id
>= table_len
)) {
549 syscall_exit_unknown(unknown_event
, regs
, id
, ret
);
552 if (unlikely(is_compat_task()))
553 event
= chan
->compat_sc_exit_table
[id
];
555 event
= chan
->sc_exit_table
[id
];
556 if (unlikely(!event
)) {
557 syscall_exit_unknown(unknown_event
, regs
, id
, ret
);
561 WARN_ON_ONCE(!entry
);
563 switch (entry
->nrargs
) {
566 void (*fptr
)(void *__data
, long ret
) = entry
->func
;
573 void (*fptr
)(void *__data
,
575 unsigned long arg0
) = entry
->func
;
576 unsigned long args
[1];
578 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
579 fptr(event
, ret
, args
[0]);
584 void (*fptr
)(void *__data
,
587 unsigned long arg1
) = entry
->func
;
588 unsigned long args
[2];
590 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
591 fptr(event
, ret
, args
[0], args
[1]);
596 void (*fptr
)(void *__data
,
600 unsigned long arg2
) = entry
->func
;
601 unsigned long args
[3];
603 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
604 fptr(event
, ret
, args
[0], args
[1], args
[2]);
609 void (*fptr
)(void *__data
,
614 unsigned long arg3
) = entry
->func
;
615 unsigned long args
[4];
617 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
618 fptr(event
, ret
, args
[0], args
[1], args
[2], args
[3]);
623 void (*fptr
)(void *__data
,
629 unsigned long arg4
) = entry
->func
;
630 unsigned long args
[5];
632 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
633 fptr(event
, ret
, args
[0], args
[1], args
[2], args
[3], args
[4]);
638 void (*fptr
)(void *__data
,
645 unsigned long arg5
) = entry
->func
;
646 unsigned long args
[6];
648 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
649 fptr(event
, ret
, args
[0], args
[1], args
[2],
650 args
[3], args
[4], args
[5]);
658 /* noinline to diminish caller stack size */
660 int fill_table(const struct trace_syscall_entry
*table
, size_t table_len
,
661 struct lttng_event
**chan_table
, struct lttng_channel
*chan
,
662 void *filter
, enum sc_type type
)
664 const struct lttng_event_desc
*desc
;
667 /* Allocate events for each syscall, insert into table */
668 for (i
= 0; i
< table_len
; i
++) {
669 struct lttng_kernel_event ev
;
670 desc
= table
[i
].desc
;
673 /* Unknown syscall */
677 * Skip those already populated by previous failed
678 * register for this channel.
682 memset(&ev
, 0, sizeof(ev
));
685 strncpy(ev
.name
, SYSCALL_ENTRY_STR
,
686 LTTNG_KERNEL_SYM_NAME_LEN
);
689 strncpy(ev
.name
, SYSCALL_EXIT_STR
,
690 LTTNG_KERNEL_SYM_NAME_LEN
);
692 case SC_TYPE_COMPAT_ENTRY
:
693 strncpy(ev
.name
, COMPAT_SYSCALL_ENTRY_STR
,
694 LTTNG_KERNEL_SYM_NAME_LEN
);
696 case SC_TYPE_COMPAT_EXIT
:
697 strncpy(ev
.name
, COMPAT_SYSCALL_EXIT_STR
,
698 LTTNG_KERNEL_SYM_NAME_LEN
);
704 strncat(ev
.name
, desc
->name
,
705 LTTNG_KERNEL_SYM_NAME_LEN
- strlen(ev
.name
) - 1);
706 ev
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
707 ev
.instrumentation
= LTTNG_KERNEL_NOOP
;
708 chan_table
[i
] = lttng_event_create(chan
, &ev
, filter
,
710 WARN_ON_ONCE(!chan_table
[i
]);
711 if (IS_ERR(chan_table
[i
])) {
713 * If something goes wrong in event registration
714 * after the first one, we have no choice but to
715 * leave the previous events in there, until
716 * deleted by session teardown.
718 return PTR_ERR(chan_table
[i
]);
724 int lttng_syscalls_register(struct lttng_channel
*chan
, void *filter
)
726 struct lttng_kernel_event ev
;
729 wrapper_vmalloc_sync_all();
731 if (!chan
->sc_table
) {
732 /* create syscall table mapping syscall to events */
733 chan
->sc_table
= kzalloc(sizeof(struct lttng_event
*)
734 * ARRAY_SIZE(sc_table
), GFP_KERNEL
);
738 if (!chan
->sc_exit_table
) {
739 /* create syscall table mapping syscall to events */
740 chan
->sc_exit_table
= kzalloc(sizeof(struct lttng_event
*)
741 * ARRAY_SIZE(sc_exit_table
), GFP_KERNEL
);
742 if (!chan
->sc_exit_table
)
748 if (!chan
->compat_sc_table
) {
749 /* create syscall table mapping compat syscall to events */
750 chan
->compat_sc_table
= kzalloc(sizeof(struct lttng_event
*)
751 * ARRAY_SIZE(compat_sc_table
), GFP_KERNEL
);
752 if (!chan
->compat_sc_table
)
756 if (!chan
->compat_sc_exit_table
) {
757 /* create syscall table mapping compat syscall to events */
758 chan
->compat_sc_exit_table
= kzalloc(sizeof(struct lttng_event
*)
759 * ARRAY_SIZE(compat_sc_exit_table
), GFP_KERNEL
);
760 if (!chan
->compat_sc_exit_table
)
764 if (!chan
->sc_unknown
) {
765 const struct lttng_event_desc
*desc
=
766 &__event_desc___syscall_enter_unknown
;
768 memset(&ev
, 0, sizeof(ev
));
769 strncpy(ev
.name
, desc
->name
, LTTNG_KERNEL_SYM_NAME_LEN
);
770 ev
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
771 ev
.instrumentation
= LTTNG_KERNEL_NOOP
;
772 chan
->sc_unknown
= lttng_event_create(chan
, &ev
, filter
,
774 WARN_ON_ONCE(!chan
->sc_unknown
);
775 if (IS_ERR(chan
->sc_unknown
)) {
776 return PTR_ERR(chan
->sc_unknown
);
780 if (!chan
->sc_compat_unknown
) {
781 const struct lttng_event_desc
*desc
=
782 &__event_desc___compat_syscall_enter_unknown
;
784 memset(&ev
, 0, sizeof(ev
));
785 strncpy(ev
.name
, desc
->name
, LTTNG_KERNEL_SYM_NAME_LEN
);
786 ev
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
787 ev
.instrumentation
= LTTNG_KERNEL_NOOP
;
788 chan
->sc_compat_unknown
= lttng_event_create(chan
, &ev
, filter
,
790 WARN_ON_ONCE(!chan
->sc_unknown
);
791 if (IS_ERR(chan
->sc_compat_unknown
)) {
792 return PTR_ERR(chan
->sc_compat_unknown
);
796 if (!chan
->compat_sc_exit_unknown
) {
797 const struct lttng_event_desc
*desc
=
798 &__event_desc___compat_syscall_exit_unknown
;
800 memset(&ev
, 0, sizeof(ev
));
801 strncpy(ev
.name
, desc
->name
, LTTNG_KERNEL_SYM_NAME_LEN
);
802 ev
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
803 ev
.instrumentation
= LTTNG_KERNEL_NOOP
;
804 chan
->compat_sc_exit_unknown
= lttng_event_create(chan
, &ev
,
806 WARN_ON_ONCE(!chan
->compat_sc_exit_unknown
);
807 if (IS_ERR(chan
->compat_sc_exit_unknown
)) {
808 return PTR_ERR(chan
->compat_sc_exit_unknown
);
812 if (!chan
->sc_exit_unknown
) {
813 const struct lttng_event_desc
*desc
=
814 &__event_desc___syscall_exit_unknown
;
816 memset(&ev
, 0, sizeof(ev
));
817 strncpy(ev
.name
, desc
->name
, LTTNG_KERNEL_SYM_NAME_LEN
);
818 ev
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
819 ev
.instrumentation
= LTTNG_KERNEL_NOOP
;
820 chan
->sc_exit_unknown
= lttng_event_create(chan
, &ev
, filter
,
822 WARN_ON_ONCE(!chan
->sc_exit_unknown
);
823 if (IS_ERR(chan
->sc_exit_unknown
)) {
824 return PTR_ERR(chan
->sc_exit_unknown
);
828 ret
= fill_table(sc_table
, ARRAY_SIZE(sc_table
),
829 chan
->sc_table
, chan
, filter
, SC_TYPE_ENTRY
);
832 ret
= fill_table(sc_exit_table
, ARRAY_SIZE(sc_exit_table
),
833 chan
->sc_exit_table
, chan
, filter
, SC_TYPE_EXIT
);
838 ret
= fill_table(compat_sc_table
, ARRAY_SIZE(compat_sc_table
),
839 chan
->compat_sc_table
, chan
, filter
,
840 SC_TYPE_COMPAT_ENTRY
);
843 ret
= fill_table(compat_sc_exit_table
, ARRAY_SIZE(compat_sc_exit_table
),
844 chan
->compat_sc_exit_table
, chan
, filter
,
845 SC_TYPE_COMPAT_EXIT
);
849 if (!chan
->sys_enter_registered
) {
850 ret
= lttng_wrapper_tracepoint_probe_register("sys_enter",
851 (void *) syscall_entry_probe
, chan
);
854 chan
->sys_enter_registered
= 1;
857 * We change the name of sys_exit tracepoint due to namespace
858 * conflict with sys_exit syscall entry.
860 if (!chan
->sys_exit_registered
) {
861 ret
= lttng_wrapper_tracepoint_probe_register("sys_exit",
862 (void *) syscall_exit_probe
, chan
);
864 WARN_ON_ONCE(lttng_wrapper_tracepoint_probe_unregister("sys_enter",
865 (void *) syscall_entry_probe
, chan
));
868 chan
->sys_exit_registered
= 1;
874 * Only called at session destruction.
876 int lttng_syscalls_unregister(struct lttng_channel
*chan
)
882 if (chan
->sys_enter_registered
) {
883 ret
= lttng_wrapper_tracepoint_probe_unregister("sys_exit",
884 (void *) syscall_exit_probe
, chan
);
887 chan
->sys_enter_registered
= 0;
889 if (chan
->sys_exit_registered
) {
890 ret
= lttng_wrapper_tracepoint_probe_unregister("sys_enter",
891 (void *) syscall_entry_probe
, chan
);
894 chan
->sys_exit_registered
= 0;
896 /* lttng_event destroy will be performed by lttng_session_destroy() */
897 kfree(chan
->sc_table
);
898 kfree(chan
->sc_exit_table
);
900 kfree(chan
->compat_sc_table
);
901 kfree(chan
->compat_sc_exit_table
);
903 kfree(chan
->sc_filter
);
908 int get_syscall_nr(const char *syscall_name
)
913 for (i
= 0; i
< ARRAY_SIZE(sc_table
); i
++) {
914 const struct trace_syscall_entry
*entry
;
917 entry
= &sc_table
[i
];
920 it_name
= entry
->desc
->name
;
921 it_name
+= strlen(SYSCALL_ENTRY_STR
);
922 if (!strcmp(syscall_name
, it_name
)) {
931 int get_compat_syscall_nr(const char *syscall_name
)
936 for (i
= 0; i
< ARRAY_SIZE(compat_sc_table
); i
++) {
937 const struct trace_syscall_entry
*entry
;
940 entry
= &compat_sc_table
[i
];
943 it_name
= entry
->desc
->name
;
944 it_name
+= strlen(COMPAT_SYSCALL_ENTRY_STR
);
945 if (!strcmp(syscall_name
, it_name
)) {
953 int lttng_syscall_filter_enable(struct lttng_channel
*chan
,
956 int syscall_nr
, compat_syscall_nr
, ret
;
957 struct lttng_syscall_filter
*filter
;
959 WARN_ON_ONCE(!chan
->sc_table
);
962 /* Enable all system calls by removing filter */
963 if (chan
->sc_filter
) {
964 filter
= chan
->sc_filter
;
965 rcu_assign_pointer(chan
->sc_filter
, NULL
);
969 chan
->syscall_all
= 1;
973 if (!chan
->sc_filter
) {
974 if (chan
->syscall_all
) {
976 * All syscalls are already enabled.
980 filter
= kzalloc(sizeof(struct lttng_syscall_filter
),
985 filter
= chan
->sc_filter
;
987 syscall_nr
= get_syscall_nr(name
);
988 compat_syscall_nr
= get_compat_syscall_nr(name
);
989 if (syscall_nr
< 0 && compat_syscall_nr
< 0) {
993 if (syscall_nr
>= 0) {
994 if (test_bit(syscall_nr
, filter
->sc
)) {
998 bitmap_set(filter
->sc
, syscall_nr
, 1);
1000 if (compat_syscall_nr
>= 0) {
1001 if (test_bit(compat_syscall_nr
, filter
->sc_compat
)) {
1005 bitmap_set(filter
->sc_compat
, compat_syscall_nr
, 1);
1007 if (!chan
->sc_filter
)
1008 rcu_assign_pointer(chan
->sc_filter
, filter
);
1012 if (!chan
->sc_filter
)
1017 int lttng_syscall_filter_disable(struct lttng_channel
*chan
,
1020 int syscall_nr
, compat_syscall_nr
, ret
;
1021 struct lttng_syscall_filter
*filter
;
1023 WARN_ON_ONCE(!chan
->sc_table
);
1025 if (!chan
->sc_filter
) {
1026 filter
= kzalloc(sizeof(struct lttng_syscall_filter
),
1030 /* Trace all system calls, then apply disable. */
1031 bitmap_set(filter
->sc
, 0, NR_syscalls
);
1032 bitmap_set(filter
->sc_compat
, 0, NR_compat_syscalls
);
1034 filter
= chan
->sc_filter
;
1038 /* Disable all system calls */
1039 bitmap_clear(filter
->sc
, 0, NR_syscalls
);
1040 bitmap_clear(filter
->sc_compat
, 0, NR_compat_syscalls
);
1043 syscall_nr
= get_syscall_nr(name
);
1044 compat_syscall_nr
= get_compat_syscall_nr(name
);
1045 if (syscall_nr
< 0 && compat_syscall_nr
< 0) {
1049 if (syscall_nr
>= 0) {
1050 if (!test_bit(syscall_nr
, chan
->sc_filter
->sc
)) {
1054 bitmap_clear(chan
->sc_filter
->sc
, syscall_nr
, 1);
1056 if (compat_syscall_nr
>= 0) {
1057 if (!test_bit(compat_syscall_nr
, chan
->sc_filter
->sc_compat
)) {
1061 bitmap_clear(chan
->sc_filter
->sc_compat
, compat_syscall_nr
, 1);
1064 if (!chan
->sc_filter
)
1065 rcu_assign_pointer(chan
->sc_filter
, filter
);
1066 chan
->syscall_all
= 0;
1070 if (!chan
->sc_filter
)
1076 const struct trace_syscall_entry
*syscall_list_get_entry(loff_t
*pos
)
1078 const struct trace_syscall_entry
*entry
;
1081 for (entry
= sc_table
;
1082 entry
< sc_table
+ ARRAY_SIZE(sc_table
);
1087 for (entry
= compat_sc_table
;
1088 entry
< compat_sc_table
+ ARRAY_SIZE(compat_sc_table
);
1098 void *syscall_list_start(struct seq_file
*m
, loff_t
*pos
)
1100 return (void *) syscall_list_get_entry(pos
);
1104 void *syscall_list_next(struct seq_file
*m
, void *p
, loff_t
*ppos
)
1107 return (void *) syscall_list_get_entry(ppos
);
1111 void syscall_list_stop(struct seq_file
*m
, void *p
)
1116 int syscall_list_show(struct seq_file
*m
, void *p
)
1118 const struct trace_syscall_entry
*table
, *entry
= p
;
1119 unsigned int bitness
;
1121 if (entry
>= sc_table
&& entry
< sc_table
+ ARRAY_SIZE(sc_table
)) {
1122 bitness
= BITS_PER_LONG
;
1126 table
= compat_sc_table
;
1127 WARN_ON_ONCE(!(entry
>= compat_sc_table
1128 && entry
< compat_sc_table
+ ARRAY_SIZE(compat_sc_table
)));
1130 seq_printf(m
, "syscall { name = %s; bitness = %u; };\n",
1137 const struct seq_operations lttng_syscall_list_seq_ops
= {
1138 .start
= syscall_list_start
,
1139 .next
= syscall_list_next
,
1140 .stop
= syscall_list_stop
,
1141 .show
= syscall_list_show
,
1145 int lttng_syscall_list_open(struct inode
*inode
, struct file
*file
)
1147 return seq_open(file
, <tng_syscall_list_seq_ops
);
1150 const struct file_operations lttng_syscall_list_fops
= {
1151 .owner
= THIS_MODULE
,
1152 .open
= lttng_syscall_list_open
,
1154 .llseek
= seq_lseek
,
1155 .release
= seq_release
,