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 <linux/stringify.h>
32 #include <asm/ptrace.h>
33 #include <asm/syscall.h>
35 #include "lib/bitfield.h"
36 #include "wrapper/tracepoint.h"
37 #include "lttng-events.h"
40 # ifndef is_compat_task
41 # define is_compat_task() (0)
52 #define SYSCALL_ENTRY_TOK syscall_entry_
53 #define COMPAT_SYSCALL_ENTRY_TOK compat_syscall_entry_
54 #define SYSCALL_EXIT_TOK syscall_exit_
55 #define COMPAT_SYSCALL_EXIT_TOK compat_syscall_exit_
57 #define SYSCALL_ENTRY_STR __stringify(SYSCALL_ENTRY_TOK)
58 #define COMPAT_SYSCALL_ENTRY_STR __stringify(COMPAT_SYSCALL_ENTRY_TOK)
59 #define SYSCALL_EXIT_STR __stringify(SYSCALL_EXIT_TOK)
60 #define COMPAT_SYSCALL_EXIT_STR __stringify(COMPAT_SYSCALL_EXIT_TOK)
63 void syscall_entry_probe(void *__data
, struct pt_regs
*regs
, long id
);
65 void syscall_exit_probe(void *__data
, struct pt_regs
*regs
, long ret
);
68 * Forward declarations for old kernels.
72 struct oldold_utsname
;
74 struct sel_arg_struct
;
75 struct mmap_arg_struct
;
77 #ifdef IA32_NR_syscalls
78 #define NR_compat_syscalls IA32_NR_syscalls
80 #define NR_compat_syscalls NR_syscalls
84 * Create LTTng tracepoint probes.
86 #define LTTNG_PACKAGE_BUILD
87 #define CREATE_TRACE_POINTS
88 #define TP_MODULE_NOINIT
89 #define TRACE_INCLUDE_PATH ../instrumentation/syscalls/headers
91 #define PARAMS(args...) args
93 /* Handle unknown syscalls */
95 #define TRACE_SYSTEM syscalls_unknown
96 #include "instrumentation/syscalls/headers/syscalls_unknown.h"
104 #define sc_in(...) __VA_ARGS__
108 #define sc_inout(...) __VA_ARGS__
110 /* Hijack probe callback for system call enter */
112 #define TP_PROBE_CB(_template) &syscall_entry_probe
113 #define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _struct, _assign, _printk) \
114 LTTNG_TRACEPOINT_EVENT(syscall_entry_##_name, PARAMS(_proto), PARAMS(_args), \
115 PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
116 #define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code, _struct, _assign, _printk) \
117 LTTNG_TRACEPOINT_EVENT_CODE(syscall_entry_##_name, PARAMS(_proto), PARAMS(_args), \
118 PARAMS(_locvar), PARAMS(_code), \
119 PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
120 #define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _struct, _assign, _printk) \
121 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscall_entry_##_name, PARAMS(_struct), PARAMS(_assign), \
123 #define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
124 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscall_entry_##_template, syscall_entry_##_name)
126 #define TRACE_SYSTEM syscall_entry_integers
127 #define TRACE_INCLUDE_FILE syscalls_integers
128 #include "instrumentation/syscalls/headers/syscalls_integers.h"
129 #undef TRACE_INCLUDE_FILE
131 #define TRACE_SYSTEM syscall_entry_pointers
132 #define TRACE_INCLUDE_FILE syscalls_pointers
133 #include "instrumentation/syscalls/headers/syscalls_pointers.h"
134 #undef TRACE_INCLUDE_FILE
136 #undef SC_LTTNG_TRACEPOINT_EVENT_CODE
137 #undef SC_LTTNG_TRACEPOINT_EVENT
138 #undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
139 #undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
141 #undef _TRACE_SYSCALLS_INTEGERS_H
142 #undef _TRACE_SYSCALLS_POINTERS_H
144 /* Hijack probe callback for compat system call enter */
145 #define TP_PROBE_CB(_template) &syscall_entry_probe
146 #define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _struct, _assign, _printk) \
147 LTTNG_TRACEPOINT_EVENT(compat_syscall_entry_##_name, PARAMS(_proto), PARAMS(_args), \
148 PARAMS(_struct), PARAMS(_assign), \
150 #define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code, _struct, _assign, _printk) \
151 LTTNG_TRACEPOINT_EVENT_CODE(compat_syscall_entry_##_name, PARAMS(_proto), PARAMS(_args), \
152 PARAMS(_locvar), PARAMS(_code), \
153 PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
154 #define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _struct, _assign, _printk) \
155 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(compat_syscall_entry_##_name, PARAMS(_struct), \
156 PARAMS(_assign), PARAMS(_printk))
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 #define TRACE_SYSTEM compat_syscall_entry_integers
161 #define TRACE_INCLUDE_FILE compat_syscalls_integers
162 #include "instrumentation/syscalls/headers/compat_syscalls_integers.h"
163 #undef TRACE_INCLUDE_FILE
165 #define TRACE_SYSTEM compat_syscall_entry_pointers
166 #define TRACE_INCLUDE_FILE compat_syscalls_pointers
167 #include "instrumentation/syscalls/headers/compat_syscalls_pointers.h"
168 #undef TRACE_INCLUDE_FILE
170 #undef SC_LTTNG_TRACEPOINT_EVENT_CODE
171 #undef SC_LTTNG_TRACEPOINT_EVENT
172 #undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
173 #undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
175 #undef _TRACE_SYSCALLS_INTEGERS_H
176 #undef _TRACE_SYSCALLS_POINTERS_H
183 #define sc_exit(...) __VA_ARGS__
187 #define sc_out(...) __VA_ARGS__
189 #define sc_inout(...) __VA_ARGS__
191 /* Hijack probe callback for system call exit */
192 #define TP_PROBE_CB(_template) &syscall_exit_probe
193 #define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _struct, _assign, _printk) \
194 LTTNG_TRACEPOINT_EVENT(syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
195 PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
196 #define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code, _struct, _assign, _printk) \
197 LTTNG_TRACEPOINT_EVENT_CODE(syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
198 PARAMS(_locvar), PARAMS(_code), \
199 PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
200 #define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _struct, _assign, _printk) \
201 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(syscall_exit_##_name, PARAMS(_struct), \
202 PARAMS(_assign), PARAMS(_printk))
203 #define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
204 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(syscall_exit_##_template, \
205 syscall_exit_##_name)
206 #define TRACE_SYSTEM syscall_exit_integers
207 #define TRACE_INCLUDE_FILE syscalls_integers
208 #include "instrumentation/syscalls/headers/syscalls_integers.h"
209 #undef TRACE_INCLUDE_FILE
211 #define TRACE_SYSTEM syscall_exit_pointers
212 #define TRACE_INCLUDE_FILE syscalls_pointers
213 #include "instrumentation/syscalls/headers/syscalls_pointers.h"
214 #undef TRACE_INCLUDE_FILE
216 #undef SC_LTTNG_TRACEPOINT_EVENT_CODE
217 #undef SC_LTTNG_TRACEPOINT_EVENT
218 #undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
219 #undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
221 #undef _TRACE_SYSCALLS_INTEGERS_H
222 #undef _TRACE_SYSCALLS_POINTERS_H
225 /* Hijack probe callback for compat system call exit */
226 #define TP_PROBE_CB(_template) &syscall_exit_probe
227 #define SC_LTTNG_TRACEPOINT_EVENT(_name, _proto, _args, _struct, _assign, _printk) \
228 LTTNG_TRACEPOINT_EVENT(compat_syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
229 PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
230 #define SC_LTTNG_TRACEPOINT_EVENT_CODE(_name, _proto, _args, _locvar, _code, _struct, _assign, _printk) \
231 LTTNG_TRACEPOINT_EVENT_CODE(compat_syscall_exit_##_name, PARAMS(_proto), PARAMS(_args), \
232 PARAMS(_locvar), PARAMS(_code), \
233 PARAMS(_struct), PARAMS(_assign), PARAMS(_printk))
234 #define SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(_name, _struct, _assign, _printk) \
235 LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS(compat_syscall_exit_##_name, PARAMS(_struct), \
236 PARAMS(_assign), PARAMS(_printk))
237 #define SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(_template, _name) \
238 LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS(compat_syscall_exit_##_template, \
239 compat_syscall_exit_##_name)
240 #define TRACE_SYSTEM compat_syscall_exit_integers
241 #define TRACE_INCLUDE_FILE compat_syscalls_integers
242 #include "instrumentation/syscalls/headers/compat_syscalls_integers.h"
243 #undef TRACE_INCLUDE_FILE
245 #define TRACE_SYSTEM compat_syscall_exit_pointers
246 #define TRACE_INCLUDE_FILE compat_syscalls_pointers
247 #include "instrumentation/syscalls/headers/compat_syscalls_pointers.h"
248 #undef TRACE_INCLUDE_FILE
250 #undef SC_LTTNG_TRACEPOINT_EVENT_CODE
251 #undef SC_LTTNG_TRACEPOINT_EVENT
252 #undef SC_LTTNG_TRACEPOINT_EVENT_CLASS_NOARGS
253 #undef SC_LTTNG_TRACEPOINT_EVENT_INSTANCE_NOARGS
255 #undef _TRACE_SYSCALLS_INTEGERS_H
256 #undef _TRACE_SYSCALLS_POINTERS_H
260 #undef TP_MODULE_NOINIT
261 #undef LTTNG_PACKAGE_BUILD
262 #undef CREATE_TRACE_POINTS
264 struct trace_syscall_entry
{
266 const struct lttng_event_desc
*desc
;
267 const struct lttng_event_field
*fields
;
271 #define CREATE_SYSCALL_TABLE
278 #undef TRACE_SYSCALL_TABLE
279 #define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
281 .func = __event_probe__syscall_entry_##_template, \
282 .nrargs = (_nrargs), \
283 .fields = __event_fields___syscall_entry_##_template, \
284 .desc = &__event_desc___syscall_entry_##_name, \
287 /* Syscall enter tracing table */
288 static const struct trace_syscall_entry sc_table
[] = {
289 #include "instrumentation/syscalls/headers/syscalls_integers.h"
290 #include "instrumentation/syscalls/headers/syscalls_pointers.h"
293 #undef TRACE_SYSCALL_TABLE
294 #define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
296 .func = __event_probe__compat_syscall_entry_##_template, \
297 .nrargs = (_nrargs), \
298 .fields = __event_fields___compat_syscall_entry_##_template, \
299 .desc = &__event_desc___compat_syscall_entry_##_name, \
302 /* Compat syscall enter table */
303 const struct trace_syscall_entry compat_sc_table
[] = {
304 #include "instrumentation/syscalls/headers/compat_syscalls_integers.h"
305 #include "instrumentation/syscalls/headers/compat_syscalls_pointers.h"
313 #define sc_exit(...) __VA_ARGS__
315 #undef TRACE_SYSCALL_TABLE
316 #define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
318 .func = __event_probe__syscall_exit_##_template, \
319 .nrargs = (_nrargs), \
320 .fields = __event_fields___syscall_exit_##_template, \
321 .desc = &__event_desc___syscall_exit_##_name, \
324 /* Syscall exit table */
325 static const struct trace_syscall_entry sc_exit_table
[] = {
326 #include "instrumentation/syscalls/headers/syscalls_integers.h"
327 #include "instrumentation/syscalls/headers/syscalls_pointers.h"
330 #undef TRACE_SYSCALL_TABLE
331 #define TRACE_SYSCALL_TABLE(_template, _name, _nr, _nrargs) \
333 .func = __event_probe__compat_syscall_exit_##_template, \
334 .nrargs = (_nrargs), \
335 .fields = __event_fields___compat_syscall_exit_##_template, \
336 .desc = &__event_desc___compat_syscall_exit_##_name, \
339 /* Compat syscall exit table */
340 const struct trace_syscall_entry compat_sc_exit_table
[] = {
341 #include "instrumentation/syscalls/headers/compat_syscalls_integers.h"
342 #include "instrumentation/syscalls/headers/compat_syscalls_pointers.h"
347 #undef CREATE_SYSCALL_TABLE
349 struct lttng_syscall_filter
{
350 DECLARE_BITMAP(sc
, NR_syscalls
);
351 DECLARE_BITMAP(sc_compat
, NR_compat_syscalls
);
354 static void syscall_entry_unknown(struct lttng_event
*event
,
355 struct pt_regs
*regs
, unsigned int id
)
357 unsigned long args
[UNKNOWN_SYSCALL_NRARGS
];
359 syscall_get_arguments(current
, regs
, 0, UNKNOWN_SYSCALL_NRARGS
, args
);
360 if (unlikely(is_compat_task()))
361 __event_probe__compat_syscall_entry_unknown(event
, id
, args
);
363 __event_probe__syscall_entry_unknown(event
, id
, args
);
366 void syscall_entry_probe(void *__data
, struct pt_regs
*regs
, long id
)
368 struct lttng_channel
*chan
= __data
;
369 struct lttng_event
*event
, *unknown_event
;
370 const struct trace_syscall_entry
*table
, *entry
;
373 if (unlikely(is_compat_task())) {
374 struct lttng_syscall_filter
*filter
;
376 filter
= rcu_dereference(chan
->sc_filter
);
378 if (id
>= NR_compat_syscalls
379 || !test_bit(id
, filter
->sc_compat
)) {
380 /* System call filtered out. */
384 table
= compat_sc_table
;
385 table_len
= ARRAY_SIZE(compat_sc_table
);
386 unknown_event
= chan
->sc_compat_unknown
;
388 struct lttng_syscall_filter
*filter
;
390 filter
= rcu_dereference(chan
->sc_filter
);
392 if (id
>= NR_syscalls
393 || !test_bit(id
, filter
->sc
)) {
394 /* System call filtered out. */
399 table_len
= ARRAY_SIZE(sc_table
);
400 unknown_event
= chan
->sc_unknown
;
402 if (unlikely(id
>= table_len
)) {
403 syscall_entry_unknown(unknown_event
, regs
, id
);
406 if (unlikely(is_compat_task()))
407 event
= chan
->compat_sc_table
[id
];
409 event
= chan
->sc_table
[id
];
410 if (unlikely(!event
)) {
411 syscall_entry_unknown(unknown_event
, regs
, id
);
415 WARN_ON_ONCE(!entry
);
417 switch (entry
->nrargs
) {
420 void (*fptr
)(void *__data
) = entry
->func
;
427 void (*fptr
)(void *__data
, unsigned long arg0
) = entry
->func
;
428 unsigned long args
[1];
430 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
431 fptr(event
, args
[0]);
436 void (*fptr
)(void *__data
,
438 unsigned long arg1
) = entry
->func
;
439 unsigned long args
[2];
441 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
442 fptr(event
, args
[0], args
[1]);
447 void (*fptr
)(void *__data
,
450 unsigned long arg2
) = entry
->func
;
451 unsigned long args
[3];
453 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
454 fptr(event
, args
[0], args
[1], args
[2]);
459 void (*fptr
)(void *__data
,
463 unsigned long arg3
) = entry
->func
;
464 unsigned long args
[4];
466 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
467 fptr(event
, args
[0], args
[1], args
[2], args
[3]);
472 void (*fptr
)(void *__data
,
477 unsigned long arg4
) = entry
->func
;
478 unsigned long args
[5];
480 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
481 fptr(event
, args
[0], args
[1], args
[2], args
[3], args
[4]);
486 void (*fptr
)(void *__data
,
492 unsigned long arg5
) = entry
->func
;
493 unsigned long args
[6];
495 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
496 fptr(event
, args
[0], args
[1], args
[2],
497 args
[3], args
[4], args
[5]);
505 static void syscall_exit_unknown(struct lttng_event
*event
,
506 struct pt_regs
*regs
, unsigned int id
, long ret
)
508 unsigned long args
[UNKNOWN_SYSCALL_NRARGS
];
510 syscall_get_arguments(current
, regs
, 0, UNKNOWN_SYSCALL_NRARGS
, args
);
511 if (unlikely(is_compat_task()))
512 __event_probe__compat_syscall_exit_unknown(event
, id
, ret
,
515 __event_probe__syscall_exit_unknown(event
, id
, ret
, args
);
518 void syscall_exit_probe(void *__data
, struct pt_regs
*regs
, long ret
)
520 struct lttng_channel
*chan
= __data
;
521 struct lttng_event
*event
, *unknown_event
;
522 const struct trace_syscall_entry
*table
, *entry
;
526 id
= syscall_get_nr(current
, regs
);
527 if (unlikely(is_compat_task())) {
528 struct lttng_syscall_filter
*filter
;
530 filter
= rcu_dereference(chan
->sc_filter
);
532 if (id
>= NR_compat_syscalls
533 || !test_bit(id
, filter
->sc_compat
)) {
534 /* System call filtered out. */
538 table
= compat_sc_exit_table
;
539 table_len
= ARRAY_SIZE(compat_sc_exit_table
);
540 unknown_event
= chan
->compat_sc_exit_unknown
;
542 struct lttng_syscall_filter
*filter
;
544 filter
= rcu_dereference(chan
->sc_filter
);
546 if (id
>= NR_syscalls
547 || !test_bit(id
, filter
->sc
)) {
548 /* System call filtered out. */
552 table
= sc_exit_table
;
553 table_len
= ARRAY_SIZE(sc_exit_table
);
554 unknown_event
= chan
->sc_exit_unknown
;
556 if (unlikely(id
>= table_len
)) {
557 syscall_exit_unknown(unknown_event
, regs
, id
, ret
);
560 if (unlikely(is_compat_task()))
561 event
= chan
->compat_sc_exit_table
[id
];
563 event
= chan
->sc_exit_table
[id
];
564 if (unlikely(!event
)) {
565 syscall_exit_unknown(unknown_event
, regs
, id
, ret
);
569 WARN_ON_ONCE(!entry
);
571 switch (entry
->nrargs
) {
574 void (*fptr
)(void *__data
, long ret
) = entry
->func
;
581 void (*fptr
)(void *__data
,
583 unsigned long arg0
) = entry
->func
;
584 unsigned long args
[1];
586 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
587 fptr(event
, ret
, args
[0]);
592 void (*fptr
)(void *__data
,
595 unsigned long arg1
) = entry
->func
;
596 unsigned long args
[2];
598 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
599 fptr(event
, ret
, args
[0], args
[1]);
604 void (*fptr
)(void *__data
,
608 unsigned long arg2
) = entry
->func
;
609 unsigned long args
[3];
611 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
612 fptr(event
, ret
, args
[0], args
[1], args
[2]);
617 void (*fptr
)(void *__data
,
622 unsigned long arg3
) = entry
->func
;
623 unsigned long args
[4];
625 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
626 fptr(event
, ret
, args
[0], args
[1], args
[2], args
[3]);
631 void (*fptr
)(void *__data
,
637 unsigned long arg4
) = entry
->func
;
638 unsigned long args
[5];
640 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
641 fptr(event
, ret
, args
[0], args
[1], args
[2], args
[3], args
[4]);
646 void (*fptr
)(void *__data
,
653 unsigned long arg5
) = entry
->func
;
654 unsigned long args
[6];
656 syscall_get_arguments(current
, regs
, 0, entry
->nrargs
, args
);
657 fptr(event
, ret
, args
[0], args
[1], args
[2],
658 args
[3], args
[4], args
[5]);
666 /* noinline to diminish caller stack size */
668 int fill_table(const struct trace_syscall_entry
*table
, size_t table_len
,
669 struct lttng_event
**chan_table
, struct lttng_channel
*chan
,
670 void *filter
, enum sc_type type
)
672 const struct lttng_event_desc
*desc
;
675 /* Allocate events for each syscall, insert into table */
676 for (i
= 0; i
< table_len
; i
++) {
677 struct lttng_kernel_event ev
;
678 desc
= table
[i
].desc
;
681 /* Unknown syscall */
685 * Skip those already populated by previous failed
686 * register for this channel.
690 memset(&ev
, 0, sizeof(ev
));
693 strncpy(ev
.name
, SYSCALL_ENTRY_STR
,
694 LTTNG_KERNEL_SYM_NAME_LEN
);
697 strncpy(ev
.name
, SYSCALL_EXIT_STR
,
698 LTTNG_KERNEL_SYM_NAME_LEN
);
700 case SC_TYPE_COMPAT_ENTRY
:
701 strncpy(ev
.name
, COMPAT_SYSCALL_ENTRY_STR
,
702 LTTNG_KERNEL_SYM_NAME_LEN
);
704 case SC_TYPE_COMPAT_EXIT
:
705 strncpy(ev
.name
, COMPAT_SYSCALL_EXIT_STR
,
706 LTTNG_KERNEL_SYM_NAME_LEN
);
712 strncat(ev
.name
, desc
->name
,
713 LTTNG_KERNEL_SYM_NAME_LEN
- strlen(ev
.name
) - 1);
714 ev
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
715 ev
.instrumentation
= LTTNG_KERNEL_NOOP
;
716 chan_table
[i
] = lttng_event_create(chan
, &ev
, filter
,
718 WARN_ON_ONCE(!chan_table
[i
]);
719 if (IS_ERR(chan_table
[i
])) {
721 * If something goes wrong in event registration
722 * after the first one, we have no choice but to
723 * leave the previous events in there, until
724 * deleted by session teardown.
726 return PTR_ERR(chan_table
[i
]);
732 int lttng_syscalls_register(struct lttng_channel
*chan
, void *filter
)
734 struct lttng_kernel_event ev
;
737 wrapper_vmalloc_sync_all();
739 if (!chan
->sc_table
) {
740 /* create syscall table mapping syscall to events */
741 chan
->sc_table
= kzalloc(sizeof(struct lttng_event
*)
742 * ARRAY_SIZE(sc_table
), GFP_KERNEL
);
746 if (!chan
->sc_exit_table
) {
747 /* create syscall table mapping syscall to events */
748 chan
->sc_exit_table
= kzalloc(sizeof(struct lttng_event
*)
749 * ARRAY_SIZE(sc_exit_table
), GFP_KERNEL
);
750 if (!chan
->sc_exit_table
)
756 if (!chan
->compat_sc_table
) {
757 /* create syscall table mapping compat syscall to events */
758 chan
->compat_sc_table
= kzalloc(sizeof(struct lttng_event
*)
759 * ARRAY_SIZE(compat_sc_table
), GFP_KERNEL
);
760 if (!chan
->compat_sc_table
)
764 if (!chan
->compat_sc_exit_table
) {
765 /* create syscall table mapping compat syscall to events */
766 chan
->compat_sc_exit_table
= kzalloc(sizeof(struct lttng_event
*)
767 * ARRAY_SIZE(compat_sc_exit_table
), GFP_KERNEL
);
768 if (!chan
->compat_sc_exit_table
)
772 if (!chan
->sc_unknown
) {
773 const struct lttng_event_desc
*desc
=
774 &__event_desc___syscall_entry_unknown
;
776 memset(&ev
, 0, sizeof(ev
));
777 strncpy(ev
.name
, desc
->name
, LTTNG_KERNEL_SYM_NAME_LEN
);
778 ev
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
779 ev
.instrumentation
= LTTNG_KERNEL_NOOP
;
780 chan
->sc_unknown
= lttng_event_create(chan
, &ev
, filter
,
782 WARN_ON_ONCE(!chan
->sc_unknown
);
783 if (IS_ERR(chan
->sc_unknown
)) {
784 return PTR_ERR(chan
->sc_unknown
);
788 if (!chan
->sc_compat_unknown
) {
789 const struct lttng_event_desc
*desc
=
790 &__event_desc___compat_syscall_entry_unknown
;
792 memset(&ev
, 0, sizeof(ev
));
793 strncpy(ev
.name
, desc
->name
, LTTNG_KERNEL_SYM_NAME_LEN
);
794 ev
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
795 ev
.instrumentation
= LTTNG_KERNEL_NOOP
;
796 chan
->sc_compat_unknown
= lttng_event_create(chan
, &ev
, filter
,
798 WARN_ON_ONCE(!chan
->sc_unknown
);
799 if (IS_ERR(chan
->sc_compat_unknown
)) {
800 return PTR_ERR(chan
->sc_compat_unknown
);
804 if (!chan
->compat_sc_exit_unknown
) {
805 const struct lttng_event_desc
*desc
=
806 &__event_desc___compat_syscall_exit_unknown
;
808 memset(&ev
, 0, sizeof(ev
));
809 strncpy(ev
.name
, desc
->name
, LTTNG_KERNEL_SYM_NAME_LEN
);
810 ev
.name
[LTTNG_KERNEL_SYM_NAME_LEN
- 1] = '\0';
811 ev
.instrumentation
= LTTNG_KERNEL_NOOP
;
812 chan
->compat_sc_exit_unknown
= lttng_event_create(chan
, &ev
,
814 WARN_ON_ONCE(!chan
->compat_sc_exit_unknown
);
815 if (IS_ERR(chan
->compat_sc_exit_unknown
)) {
816 return PTR_ERR(chan
->compat_sc_exit_unknown
);
820 if (!chan
->sc_exit_unknown
) {
821 const struct lttng_event_desc
*desc
=
822 &__event_desc___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_NOOP
;
828 chan
->sc_exit_unknown
= lttng_event_create(chan
, &ev
, filter
,
830 WARN_ON_ONCE(!chan
->sc_exit_unknown
);
831 if (IS_ERR(chan
->sc_exit_unknown
)) {
832 return PTR_ERR(chan
->sc_exit_unknown
);
836 ret
= fill_table(sc_table
, ARRAY_SIZE(sc_table
),
837 chan
->sc_table
, chan
, filter
, SC_TYPE_ENTRY
);
840 ret
= fill_table(sc_exit_table
, ARRAY_SIZE(sc_exit_table
),
841 chan
->sc_exit_table
, chan
, filter
, SC_TYPE_EXIT
);
846 ret
= fill_table(compat_sc_table
, ARRAY_SIZE(compat_sc_table
),
847 chan
->compat_sc_table
, chan
, filter
,
848 SC_TYPE_COMPAT_ENTRY
);
851 ret
= fill_table(compat_sc_exit_table
, ARRAY_SIZE(compat_sc_exit_table
),
852 chan
->compat_sc_exit_table
, chan
, filter
,
853 SC_TYPE_COMPAT_EXIT
);
857 if (!chan
->sys_enter_registered
) {
858 ret
= lttng_wrapper_tracepoint_probe_register("sys_enter",
859 (void *) syscall_entry_probe
, chan
);
862 chan
->sys_enter_registered
= 1;
865 * We change the name of sys_exit tracepoint due to namespace
866 * conflict with sys_exit syscall entry.
868 if (!chan
->sys_exit_registered
) {
869 ret
= lttng_wrapper_tracepoint_probe_register("sys_exit",
870 (void *) syscall_exit_probe
, chan
);
872 WARN_ON_ONCE(lttng_wrapper_tracepoint_probe_unregister("sys_enter",
873 (void *) syscall_entry_probe
, chan
));
876 chan
->sys_exit_registered
= 1;
882 * Only called at session destruction.
884 int lttng_syscalls_unregister(struct lttng_channel
*chan
)
890 if (chan
->sys_enter_registered
) {
891 ret
= lttng_wrapper_tracepoint_probe_unregister("sys_exit",
892 (void *) syscall_exit_probe
, chan
);
895 chan
->sys_enter_registered
= 0;
897 if (chan
->sys_exit_registered
) {
898 ret
= lttng_wrapper_tracepoint_probe_unregister("sys_enter",
899 (void *) syscall_entry_probe
, chan
);
902 chan
->sys_exit_registered
= 0;
904 /* lttng_event destroy will be performed by lttng_session_destroy() */
905 kfree(chan
->sc_table
);
906 kfree(chan
->sc_exit_table
);
908 kfree(chan
->compat_sc_table
);
909 kfree(chan
->compat_sc_exit_table
);
911 kfree(chan
->sc_filter
);
916 int get_syscall_nr(const char *syscall_name
)
921 for (i
= 0; i
< ARRAY_SIZE(sc_table
); i
++) {
922 const struct trace_syscall_entry
*entry
;
925 entry
= &sc_table
[i
];
928 it_name
= entry
->desc
->name
;
929 it_name
+= strlen(SYSCALL_ENTRY_STR
);
930 if (!strcmp(syscall_name
, it_name
)) {
939 int get_compat_syscall_nr(const char *syscall_name
)
944 for (i
= 0; i
< ARRAY_SIZE(compat_sc_table
); i
++) {
945 const struct trace_syscall_entry
*entry
;
948 entry
= &compat_sc_table
[i
];
951 it_name
= entry
->desc
->name
;
952 it_name
+= strlen(COMPAT_SYSCALL_ENTRY_STR
);
953 if (!strcmp(syscall_name
, it_name
)) {
962 uint32_t get_sc_tables_len(void)
964 return ARRAY_SIZE(sc_table
) + ARRAY_SIZE(compat_sc_table
);
967 int lttng_syscall_filter_enable(struct lttng_channel
*chan
,
970 int syscall_nr
, compat_syscall_nr
, ret
;
971 struct lttng_syscall_filter
*filter
;
973 WARN_ON_ONCE(!chan
->sc_table
);
976 /* Enable all system calls by removing filter */
977 if (chan
->sc_filter
) {
978 filter
= chan
->sc_filter
;
979 rcu_assign_pointer(chan
->sc_filter
, NULL
);
983 chan
->syscall_all
= 1;
987 if (!chan
->sc_filter
) {
988 if (chan
->syscall_all
) {
990 * All syscalls are already enabled.
994 filter
= kzalloc(sizeof(struct lttng_syscall_filter
),
999 filter
= chan
->sc_filter
;
1001 syscall_nr
= get_syscall_nr(name
);
1002 compat_syscall_nr
= get_compat_syscall_nr(name
);
1003 if (syscall_nr
< 0 && compat_syscall_nr
< 0) {
1007 if (syscall_nr
>= 0) {
1008 if (test_bit(syscall_nr
, filter
->sc
)) {
1012 bitmap_set(filter
->sc
, syscall_nr
, 1);
1014 if (compat_syscall_nr
>= 0) {
1015 if (test_bit(compat_syscall_nr
, filter
->sc_compat
)) {
1019 bitmap_set(filter
->sc_compat
, compat_syscall_nr
, 1);
1021 if (!chan
->sc_filter
)
1022 rcu_assign_pointer(chan
->sc_filter
, filter
);
1026 if (!chan
->sc_filter
)
1031 int lttng_syscall_filter_disable(struct lttng_channel
*chan
,
1034 int syscall_nr
, compat_syscall_nr
, ret
;
1035 struct lttng_syscall_filter
*filter
;
1037 WARN_ON_ONCE(!chan
->sc_table
);
1039 if (!chan
->sc_filter
) {
1040 if (!chan
->syscall_all
)
1042 filter
= kzalloc(sizeof(struct lttng_syscall_filter
),
1046 /* Trace all system calls, then apply disable. */
1047 bitmap_set(filter
->sc
, 0, NR_syscalls
);
1048 bitmap_set(filter
->sc_compat
, 0, NR_compat_syscalls
);
1050 filter
= chan
->sc_filter
;
1054 /* Fail if all syscalls are already disabled. */
1055 if (bitmap_empty(filter
->sc
, NR_syscalls
)
1056 && bitmap_empty(filter
->sc_compat
,
1057 NR_compat_syscalls
)) {
1062 /* Disable all system calls */
1063 bitmap_clear(filter
->sc
, 0, NR_syscalls
);
1064 bitmap_clear(filter
->sc_compat
, 0, NR_compat_syscalls
);
1067 syscall_nr
= get_syscall_nr(name
);
1068 compat_syscall_nr
= get_compat_syscall_nr(name
);
1069 if (syscall_nr
< 0 && compat_syscall_nr
< 0) {
1073 if (syscall_nr
>= 0) {
1074 if (!test_bit(syscall_nr
, filter
->sc
)) {
1078 bitmap_clear(filter
->sc
, syscall_nr
, 1);
1080 if (compat_syscall_nr
>= 0) {
1081 if (!test_bit(compat_syscall_nr
, filter
->sc_compat
)) {
1085 bitmap_clear(filter
->sc_compat
, compat_syscall_nr
, 1);
1088 if (!chan
->sc_filter
)
1089 rcu_assign_pointer(chan
->sc_filter
, filter
);
1090 chan
->syscall_all
= 0;
1094 if (!chan
->sc_filter
)
1100 const struct trace_syscall_entry
*syscall_list_get_entry(loff_t
*pos
)
1102 const struct trace_syscall_entry
*entry
;
1105 for (entry
= sc_table
;
1106 entry
< sc_table
+ ARRAY_SIZE(sc_table
);
1111 for (entry
= compat_sc_table
;
1112 entry
< compat_sc_table
+ ARRAY_SIZE(compat_sc_table
);
1122 void *syscall_list_start(struct seq_file
*m
, loff_t
*pos
)
1124 return (void *) syscall_list_get_entry(pos
);
1128 void *syscall_list_next(struct seq_file
*m
, void *p
, loff_t
*ppos
)
1131 return (void *) syscall_list_get_entry(ppos
);
1135 void syscall_list_stop(struct seq_file
*m
, void *p
)
1140 int get_sc_table(const struct trace_syscall_entry
*entry
,
1141 const struct trace_syscall_entry
**table
,
1142 unsigned int *bitness
)
1144 if (entry
>= sc_table
&& entry
< sc_table
+ ARRAY_SIZE(sc_table
)) {
1146 *bitness
= BITS_PER_LONG
;
1151 if (!(entry
>= compat_sc_table
1152 && entry
< compat_sc_table
+ ARRAY_SIZE(compat_sc_table
))) {
1158 *table
= compat_sc_table
;
1163 int syscall_list_show(struct seq_file
*m
, void *p
)
1165 const struct trace_syscall_entry
*table
, *entry
= p
;
1166 unsigned int bitness
;
1167 unsigned long index
;
1171 ret
= get_sc_table(entry
, &table
, &bitness
);
1176 if (table
== sc_table
) {
1177 index
= entry
- table
;
1178 name
= &entry
->desc
->name
[strlen(SYSCALL_ENTRY_STR
)];
1180 index
= (entry
- table
) + ARRAY_SIZE(sc_table
);
1181 name
= &entry
->desc
->name
[strlen(COMPAT_SYSCALL_ENTRY_STR
)];
1183 seq_printf(m
, "syscall { index = %lu; name = %s; bitness = %u; };\n",
1184 index
, name
, bitness
);
1189 const struct seq_operations lttng_syscall_list_seq_ops
= {
1190 .start
= syscall_list_start
,
1191 .next
= syscall_list_next
,
1192 .stop
= syscall_list_stop
,
1193 .show
= syscall_list_show
,
1197 int lttng_syscall_list_open(struct inode
*inode
, struct file
*file
)
1199 return seq_open(file
, <tng_syscall_list_seq_ops
);
1202 const struct file_operations lttng_syscall_list_fops
= {
1203 .owner
= THIS_MODULE
,
1204 .open
= lttng_syscall_list_open
,
1206 .llseek
= seq_lseek
,
1207 .release
= seq_release
,
1210 long lttng_channel_syscall_mask(struct lttng_channel
*channel
,
1211 struct lttng_kernel_syscall_mask __user
*usyscall_mask
)
1213 uint32_t len
, sc_tables_len
, bitmask_len
;
1216 struct lttng_syscall_filter
*filter
;
1218 ret
= get_user(len
, &usyscall_mask
->len
);
1221 sc_tables_len
= get_sc_tables_len();
1222 bitmask_len
= ALIGN(sc_tables_len
, 8) >> 3;
1223 if (len
< sc_tables_len
) {
1224 return put_user(sc_tables_len
, &usyscall_mask
->len
);
1226 /* Array is large enough, we can copy array to user-space. */
1227 tmp_mask
= kzalloc(bitmask_len
, GFP_KERNEL
);
1230 filter
= channel
->sc_filter
;
1232 for (bit
= 0; bit
< ARRAY_SIZE(sc_table
); bit
++) {
1233 bt_bitfield_write_be(tmp_mask
, char, bit
, 1,
1234 filter
? test_bit(bit
, filter
->sc
) : 1);
1236 for (; bit
< sc_tables_len
; bit
++) {
1237 bt_bitfield_write_be(tmp_mask
, char, bit
, 1,
1238 filter
? test_bit(bit
- ARRAY_SIZE(sc_table
),
1239 filter
->sc_compat
) : 1);
1241 if (copy_to_user(usyscall_mask
->mask
, tmp_mask
, bitmask_len
))