1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
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 <linux/fcntl.h>
22 #include <linux/mman.h>
23 #include <asm/ptrace.h>
24 #include <asm/syscall.h>
26 #include <lttng/bitfield.h>
27 #include <wrapper/tracepoint.h>
28 #include <wrapper/file.h>
29 #include <wrapper/rcu.h>
30 #include <wrapper/syscall.h>
31 #include <lttng/events.h>
32 #include <lttng/events-internal.h>
33 #include <lttng/utils.h>
35 #include "lttng-syscalls.h"
38 # ifndef is_compat_task
39 # define is_compat_task() (0)
43 /* in_compat_syscall appears in kernel 4.6. */
44 #ifndef in_compat_syscall
45 #define in_compat_syscall() is_compat_task()
55 #define SYSCALL_ENTRY_TOK syscall_entry_
56 #define COMPAT_SYSCALL_ENTRY_TOK compat_syscall_entry_
57 #define SYSCALL_EXIT_TOK syscall_exit_
58 #define COMPAT_SYSCALL_EXIT_TOK compat_syscall_exit_
60 #define SYSCALL_ENTRY_STR __stringify(SYSCALL_ENTRY_TOK)
61 #define COMPAT_SYSCALL_ENTRY_STR __stringify(COMPAT_SYSCALL_ENTRY_TOK)
62 #define SYSCALL_EXIT_STR __stringify(SYSCALL_EXIT_TOK)
63 #define COMPAT_SYSCALL_EXIT_STR __stringify(COMPAT_SYSCALL_EXIT_TOK)
65 void syscall_entry_event_probe(void *__data
, struct pt_regs
*regs
, long id
);
66 void syscall_exit_event_probe(void *__data
, struct pt_regs
*regs
, long ret
);
69 * Forward declarations for old kernels.
73 struct oldold_utsname
;
75 struct sel_arg_struct
;
76 struct mmap_arg_struct
;
81 * Forward declaration for kernels >= 5.6
88 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,6,0))
89 typedef __kernel_old_time_t
time_t;
92 #ifdef IA32_NR_syscalls
93 #define NR_compat_syscalls IA32_NR_syscalls
95 #define NR_compat_syscalls NR_syscalls
99 * Create LTTng tracepoint probes.
101 #define LTTNG_PACKAGE_BUILD
102 #define CREATE_TRACE_POINTS
103 #define TP_MODULE_NOINIT
104 #define TRACE_INCLUDE_PATH instrumentation/syscalls/headers
106 #define PARAMS(args...) args
108 /* Handle unknown syscalls */
110 #define TRACE_SYSTEM syscalls_unknown
111 #include <instrumentation/syscalls/headers/syscalls_unknown.h>
116 extern const struct trace_syscall_table sc_table
;
117 extern const struct trace_syscall_table compat_sc_table
;
119 /* Event syscall exit table */
120 extern const struct trace_syscall_table sc_exit_table
;
121 extern const struct trace_syscall_table compat_sc_exit_table
;
126 #undef CREATE_SYSCALL_TABLE
128 struct lttng_syscall_filter
{
129 DECLARE_BITMAP(sc_entry
, NR_syscalls
);
130 DECLARE_BITMAP(sc_exit
, NR_syscalls
);
131 DECLARE_BITMAP(sc_compat_entry
, NR_compat_syscalls
);
132 DECLARE_BITMAP(sc_compat_exit
, NR_compat_syscalls
);
136 int lttng_syscalls_create_matching_event_notifiers(struct lttng_event_enabler_common
*event_enabler
);
138 static void syscall_entry_event_unknown(struct hlist_head
*unknown_action_list_head
,
139 struct pt_regs
*regs
, long id
)
141 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
142 struct lttng_kernel_event_common_private
*event_priv
;
144 lttng_syscall_get_arguments(current
, regs
, args
);
145 lttng_hlist_for_each_entry_rcu(event_priv
, unknown_action_list_head
, u
.syscall
.node
) {
146 if (unlikely(in_compat_syscall()))
147 __event_probe__compat_syscall_entry_unknown(event_priv
->pub
, id
, args
);
149 __event_probe__syscall_entry_unknown(event_priv
->pub
, id
, args
);
153 static __always_inline
154 void syscall_entry_event_call_func(struct hlist_head
*action_list
,
155 void *func
, unsigned int nrargs
,
156 struct pt_regs
*regs
)
158 struct lttng_kernel_event_common_private
*event_priv
;
163 void (*fptr
)(void *__data
) = func
;
165 lttng_hlist_for_each_entry_rcu(event_priv
, action_list
, u
.syscall
.node
)
166 fptr(event_priv
->pub
);
171 void (*fptr
)(void *__data
, unsigned long arg0
) = func
;
172 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
174 lttng_syscall_get_arguments(current
, regs
, args
);
175 lttng_hlist_for_each_entry_rcu(event_priv
, action_list
, u
.syscall
.node
)
176 fptr(event_priv
->pub
, args
[0]);
181 void (*fptr
)(void *__data
,
183 unsigned long arg1
) = func
;
184 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
186 lttng_syscall_get_arguments(current
, regs
, args
);
187 lttng_hlist_for_each_entry_rcu(event_priv
, action_list
, u
.syscall
.node
)
188 fptr(event_priv
->pub
, args
[0], args
[1]);
193 void (*fptr
)(void *__data
,
196 unsigned long arg2
) = func
;
197 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
199 lttng_syscall_get_arguments(current
, regs
, args
);
200 lttng_hlist_for_each_entry_rcu(event_priv
, action_list
, u
.syscall
.node
)
201 fptr(event_priv
->pub
, args
[0], args
[1], args
[2]);
206 void (*fptr
)(void *__data
,
210 unsigned long arg3
) = func
;
211 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
213 lttng_syscall_get_arguments(current
, regs
, args
);
214 lttng_hlist_for_each_entry_rcu(event_priv
, action_list
, u
.syscall
.node
)
215 fptr(event_priv
->pub
, args
[0], args
[1], args
[2], args
[3]);
220 void (*fptr
)(void *__data
,
225 unsigned long arg4
) = func
;
226 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
228 lttng_syscall_get_arguments(current
, regs
, args
);
229 lttng_hlist_for_each_entry_rcu(event_priv
, action_list
, u
.syscall
.node
)
230 fptr(event_priv
->pub
, args
[0], args
[1], args
[2], args
[3], args
[4]);
235 void (*fptr
)(void *__data
,
241 unsigned long arg5
) = func
;
242 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
244 lttng_syscall_get_arguments(current
, regs
, args
);
245 lttng_hlist_for_each_entry_rcu(event_priv
, action_list
, u
.syscall
.node
)
246 fptr(event_priv
->pub
, args
[0], args
[1], args
[2],
247 args
[3], args
[4], args
[5]);
255 void syscall_entry_event_probe(void *__data
, struct pt_regs
*regs
, long id
)
257 struct lttng_kernel_syscall_table
*syscall_table
= __data
;
258 struct hlist_head
*action_list
, *unknown_action_list
;
259 const struct trace_syscall_entry
*table
, *entry
;
262 if (unlikely(in_compat_syscall())) {
263 struct lttng_syscall_filter
*filter
= syscall_table
->sc_filter
;
265 if (id
< 0 || id
>= NR_compat_syscalls
266 || (!READ_ONCE(syscall_table
->syscall_all_entry
) && !test_bit(id
, filter
->sc_compat_entry
))) {
267 /* System call filtered out. */
270 table
= compat_sc_table
.table
;
271 table_len
= compat_sc_table
.len
;
272 unknown_action_list
= &syscall_table
->compat_unknown_syscall_dispatch
;
274 struct lttng_syscall_filter
*filter
= syscall_table
->sc_filter
;
276 if (id
< 0 || id
>= NR_syscalls
277 || (!READ_ONCE(syscall_table
->syscall_all_entry
) && !test_bit(id
, filter
->sc_entry
))) {
278 /* System call filtered out. */
281 table
= sc_table
.table
;
282 table_len
= sc_table
.len
;
283 unknown_action_list
= &syscall_table
->unknown_syscall_dispatch
;
285 if (unlikely(id
< 0 || id
>= table_len
)) {
286 syscall_entry_event_unknown(unknown_action_list
, regs
, id
);
291 if (!entry
->event_func
) {
292 syscall_entry_event_unknown(unknown_action_list
, regs
, id
);
296 if (unlikely(in_compat_syscall())) {
297 action_list
= &syscall_table
->compat_syscall_dispatch
[id
];
299 action_list
= &syscall_table
->syscall_dispatch
[id
];
301 if (unlikely(hlist_empty(action_list
)))
304 syscall_entry_event_call_func(action_list
, entry
->event_func
, entry
->nrargs
, regs
);
307 static void syscall_exit_event_unknown(struct hlist_head
*unknown_action_list_head
,
308 struct pt_regs
*regs
, long id
, long ret
)
310 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
311 struct lttng_kernel_event_common_private
*event_priv
;
313 lttng_syscall_get_arguments(current
, regs
, args
);
314 lttng_hlist_for_each_entry_rcu(event_priv
, unknown_action_list_head
, u
.syscall
.node
) {
315 if (unlikely(in_compat_syscall()))
316 __event_probe__compat_syscall_exit_unknown(event_priv
->pub
, id
, ret
,
319 __event_probe__syscall_exit_unknown(event_priv
->pub
, id
, ret
, args
);
323 static __always_inline
324 void syscall_exit_event_call_func(struct hlist_head
*action_list
,
325 void *func
, unsigned int nrargs
,
326 struct pt_regs
*regs
, long ret
)
328 struct lttng_kernel_event_common_private
*event_priv
;
333 void (*fptr
)(void *__data
, long ret
) = func
;
335 lttng_hlist_for_each_entry_rcu(event_priv
, action_list
, u
.syscall
.node
)
336 fptr(event_priv
->pub
, ret
);
341 void (*fptr
)(void *__data
,
343 unsigned long arg0
) = func
;
344 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
346 lttng_syscall_get_arguments(current
, regs
, args
);
347 lttng_hlist_for_each_entry_rcu(event_priv
, action_list
, u
.syscall
.node
)
348 fptr(event_priv
->pub
, ret
, args
[0]);
353 void (*fptr
)(void *__data
,
356 unsigned long arg1
) = func
;
357 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
359 lttng_syscall_get_arguments(current
, regs
, args
);
360 lttng_hlist_for_each_entry_rcu(event_priv
, action_list
, u
.syscall
.node
)
361 fptr(event_priv
->pub
, ret
, args
[0], args
[1]);
366 void (*fptr
)(void *__data
,
370 unsigned long arg2
) = func
;
371 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
373 lttng_syscall_get_arguments(current
, regs
, args
);
374 lttng_hlist_for_each_entry_rcu(event_priv
, action_list
, u
.syscall
.node
)
375 fptr(event_priv
->pub
, ret
, args
[0], args
[1], args
[2]);
380 void (*fptr
)(void *__data
,
385 unsigned long arg3
) = func
;
386 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
388 lttng_syscall_get_arguments(current
, regs
, args
);
389 lttng_hlist_for_each_entry_rcu(event_priv
, action_list
, u
.syscall
.node
)
390 fptr(event_priv
->pub
, ret
, args
[0], args
[1], args
[2], args
[3]);
395 void (*fptr
)(void *__data
,
401 unsigned long arg4
) = func
;
402 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
404 lttng_syscall_get_arguments(current
, regs
, args
);
405 lttng_hlist_for_each_entry_rcu(event_priv
, action_list
, u
.syscall
.node
)
406 fptr(event_priv
->pub
, ret
, args
[0], args
[1], args
[2], args
[3], args
[4]);
411 void (*fptr
)(void *__data
,
418 unsigned long arg5
) = func
;
419 unsigned long args
[LTTNG_SYSCALL_NR_ARGS
];
421 lttng_syscall_get_arguments(current
, regs
, args
);
422 lttng_hlist_for_each_entry_rcu(event_priv
, action_list
, u
.syscall
.node
)
423 fptr(event_priv
->pub
, ret
, args
[0], args
[1], args
[2],
424 args
[3], args
[4], args
[5]);
432 void syscall_exit_event_probe(void *__data
, struct pt_regs
*regs
, long ret
)
434 struct lttng_kernel_syscall_table
*syscall_table
= __data
;
435 struct hlist_head
*action_list
, *unknown_action_list
;
436 const struct trace_syscall_entry
*table
, *entry
;
440 id
= syscall_get_nr(current
, regs
);
442 if (unlikely(in_compat_syscall())) {
443 struct lttng_syscall_filter
*filter
= syscall_table
->sc_filter
;
445 if (id
< 0 || id
>= NR_compat_syscalls
446 || (!READ_ONCE(syscall_table
->syscall_all_exit
) && !test_bit(id
, filter
->sc_compat_exit
))) {
447 /* System call filtered out. */
450 table
= compat_sc_exit_table
.table
;
451 table_len
= compat_sc_exit_table
.len
;
452 unknown_action_list
= &syscall_table
->compat_unknown_syscall_exit_dispatch
;
454 struct lttng_syscall_filter
*filter
= syscall_table
->sc_filter
;
456 if (id
< 0 || id
>= NR_syscalls
457 || (!READ_ONCE(syscall_table
->syscall_all_exit
) && !test_bit(id
, filter
->sc_exit
))) {
458 /* System call filtered out. */
461 table
= sc_exit_table
.table
;
462 table_len
= sc_exit_table
.len
;
463 unknown_action_list
= &syscall_table
->unknown_syscall_exit_dispatch
;
465 if (unlikely(id
< 0 || id
>= table_len
)) {
466 syscall_exit_event_unknown(unknown_action_list
, regs
, id
, ret
);
471 if (!entry
->event_func
) {
472 syscall_exit_event_unknown(unknown_action_list
, regs
, id
, ret
);
476 if (unlikely(in_compat_syscall())) {
477 action_list
= &syscall_table
->compat_syscall_exit_dispatch
[id
];
479 action_list
= &syscall_table
->syscall_exit_dispatch
[id
];
481 if (unlikely(hlist_empty(action_list
)))
484 syscall_exit_event_call_func(action_list
, entry
->event_func
, entry
->nrargs
,
489 struct lttng_kernel_syscall_table
*get_syscall_table_from_enabler(struct lttng_event_enabler_common
*event_enabler
)
491 switch (event_enabler
->enabler_type
) {
492 case LTTNG_EVENT_ENABLER_TYPE_RECORDER
:
494 struct lttng_event_recorder_enabler
*event_recorder_enabler
=
495 container_of(event_enabler
, struct lttng_event_recorder_enabler
, parent
);
496 return &event_recorder_enabler
->chan
->priv
->parent
.syscall_table
;
498 case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER
:
500 struct lttng_event_notifier_enabler
*event_notifier_enabler
=
501 container_of(event_enabler
, struct lttng_event_notifier_enabler
, parent
);
502 return &event_notifier_enabler
->group
->syscall_table
;
510 struct lttng_kernel_syscall_table
*get_syscall_table_from_event(struct lttng_kernel_event_common
*event
)
512 switch (event
->type
) {
513 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
515 struct lttng_kernel_event_recorder
*event_recorder
=
516 container_of(event
, struct lttng_kernel_event_recorder
, parent
);
517 return &event_recorder
->chan
->priv
->parent
.syscall_table
;
519 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
521 struct lttng_kernel_event_notifier
*event_notifier
=
522 container_of(event
, struct lttng_kernel_event_notifier
, parent
);
523 return &event_notifier
->priv
->group
->syscall_table
;
531 * noinline to diminish caller stack size.
532 * Should be called with sessions lock held.
535 int lttng_create_syscall_event_if_missing(const struct trace_syscall_entry
*table
, size_t table_len
,
536 struct hlist_head
*chan_table
, struct lttng_event_recorder_enabler
*syscall_event_enabler
,
539 struct lttng_event_ht
*events_ht
= lttng_get_event_ht_from_enabler(&syscall_event_enabler
->parent
);
540 struct lttng_kernel_channel_buffer
*chan
= syscall_event_enabler
->chan
;
543 /* Allocate events for each syscall matching enabler, insert into table */
544 for (i
= 0; i
< table_len
; i
++) {
545 const struct lttng_kernel_event_desc
*desc
= table
[i
].desc
;
546 struct lttng_event_recorder_enabler
*event_enabler
;
547 struct lttng_kernel_abi_event ev
;
548 struct lttng_kernel_event_common
*event
;
549 struct lttng_kernel_event_common_private
*event_priv
;
550 struct hlist_head
*head
;
554 /* Unknown syscall */
557 if (!lttng_desc_match_enabler(desc
,
558 lttng_event_recorder_enabler_as_enabler(syscall_event_enabler
)))
561 * Check if already created.
563 head
= utils_borrow_hash_table_bucket(events_ht
->table
, LTTNG_EVENT_HT_SIZE
, desc
->event_name
);
564 lttng_hlist_for_each_entry(event_priv
, head
, hlist_node
) {
565 if (lttng_event_enabler_desc_match_event(&syscall_event_enabler
->parent
, desc
, event_priv
->pub
))
571 /* We need to create an event for this syscall/enabler. */
572 memset(&ev
, 0, sizeof(ev
));
575 ev
.u
.syscall
.entryexit
= LTTNG_KERNEL_ABI_SYSCALL_ENTRY
;
576 ev
.u
.syscall
.abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE
;
579 ev
.u
.syscall
.entryexit
= LTTNG_KERNEL_ABI_SYSCALL_EXIT
;
580 ev
.u
.syscall
.abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE
;
582 case SC_TYPE_COMPAT_ENTRY
:
583 ev
.u
.syscall
.entryexit
= LTTNG_KERNEL_ABI_SYSCALL_ENTRY
;
584 ev
.u
.syscall
.abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT
;
586 case SC_TYPE_COMPAT_EXIT
:
587 ev
.u
.syscall
.entryexit
= LTTNG_KERNEL_ABI_SYSCALL_EXIT
;
588 ev
.u
.syscall
.abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT
;
591 strncpy(ev
.name
, desc
->event_name
, LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1);
592 ev
.name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
593 ev
.instrumentation
= LTTNG_KERNEL_ABI_SYSCALL
;
594 event_enabler
= lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME
, &ev
, chan
);
595 if (!event_enabler
) {
598 event
= _lttng_kernel_event_create(&event_enabler
->parent
, desc
);
599 WARN_ON_ONCE(!event
);
600 lttng_event_enabler_destroy(&event_enabler
->parent
);
603 * If something goes wrong in event registration
604 * after the first one, we have no choice but to
605 * leave the previous events in there, until
606 * deleted by session teardown.
608 return PTR_ERR(event
);
610 hlist_add_head(&event
->priv
->u
.syscall
.node
, &chan_table
[i
]);
616 int lttng_syscalls_populate_events(struct lttng_event_enabler_common
*syscall_event_enabler
)
618 struct lttng_kernel_syscall_table
*syscall_table
= get_syscall_table_from_enabler(syscall_event_enabler
);
619 struct lttng_event_recorder_enabler
*event_recorder_enabler
;
620 struct lttng_kernel_channel_buffer
*chan
;
621 struct lttng_kernel_abi_event ev
;
624 if (syscall_event_enabler
->enabler_type
!= LTTNG_EVENT_ENABLER_TYPE_RECORDER
)
626 event_recorder_enabler
= container_of(syscall_event_enabler
, struct lttng_event_recorder_enabler
, parent
);
627 chan
= event_recorder_enabler
->chan
;
629 if (hlist_empty(&syscall_table
->unknown_syscall_dispatch
)) {
630 const struct lttng_kernel_event_desc
*desc
=
631 &__event_desc___syscall_entry_unknown
;
632 struct lttng_kernel_event_common
*event
;
633 struct lttng_event_recorder_enabler
*event_enabler
;
635 memset(&ev
, 0, sizeof(ev
));
636 strncpy(ev
.name
, desc
->event_name
, LTTNG_KERNEL_ABI_SYM_NAME_LEN
);
637 ev
.name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
638 ev
.instrumentation
= LTTNG_KERNEL_ABI_SYSCALL
;
639 ev
.u
.syscall
.entryexit
= LTTNG_KERNEL_ABI_SYSCALL_ENTRY
;
640 ev
.u
.syscall
.abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE
;
641 event_enabler
= lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME
, &ev
, chan
);
642 if (!event_enabler
) {
645 event
= _lttng_kernel_event_create(&event_enabler
->parent
, desc
);
646 lttng_event_enabler_destroy(&event_enabler
->parent
);
647 WARN_ON_ONCE(!event
);
649 return PTR_ERR(event
);
651 hlist_add_head(&event
->priv
->u
.syscall
.node
, &syscall_table
->unknown_syscall_dispatch
);
654 if (hlist_empty(&syscall_table
->compat_unknown_syscall_dispatch
)) {
655 const struct lttng_kernel_event_desc
*desc
=
656 &__event_desc___compat_syscall_entry_unknown
;
657 struct lttng_kernel_event_common
*event
;
658 struct lttng_event_recorder_enabler
*event_enabler
;
660 memset(&ev
, 0, sizeof(ev
));
661 strncpy(ev
.name
, desc
->event_name
, LTTNG_KERNEL_ABI_SYM_NAME_LEN
);
662 ev
.name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
663 ev
.instrumentation
= LTTNG_KERNEL_ABI_SYSCALL
;
664 ev
.u
.syscall
.entryexit
= LTTNG_KERNEL_ABI_SYSCALL_ENTRY
;
665 ev
.u
.syscall
.abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT
;
666 event_enabler
= lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME
, &ev
, chan
);
667 if (!event_enabler
) {
670 event
= _lttng_kernel_event_create(&event_enabler
->parent
, desc
);
671 WARN_ON_ONCE(!event
);
672 lttng_event_enabler_destroy(&event_enabler
->parent
);
674 return PTR_ERR(event
);
676 hlist_add_head(&event
->priv
->u
.syscall
.node
, &syscall_table
->compat_unknown_syscall_dispatch
);
679 if (hlist_empty(&syscall_table
->compat_unknown_syscall_exit_dispatch
)) {
680 const struct lttng_kernel_event_desc
*desc
=
681 &__event_desc___compat_syscall_exit_unknown
;
682 struct lttng_kernel_event_common
*event
;
683 struct lttng_event_recorder_enabler
*event_enabler
;
685 memset(&ev
, 0, sizeof(ev
));
686 strncpy(ev
.name
, desc
->event_name
, LTTNG_KERNEL_ABI_SYM_NAME_LEN
);
687 ev
.name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
688 ev
.instrumentation
= LTTNG_KERNEL_ABI_SYSCALL
;
689 ev
.u
.syscall
.entryexit
= LTTNG_KERNEL_ABI_SYSCALL_EXIT
;
690 ev
.u
.syscall
.abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT
;
691 event_enabler
= lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME
, &ev
, chan
);
692 if (!event_enabler
) {
695 event
= _lttng_kernel_event_create(&event_enabler
->parent
, desc
);
696 WARN_ON_ONCE(!event
);
697 lttng_event_enabler_destroy(&event_enabler
->parent
);
699 return PTR_ERR(event
);
701 hlist_add_head(&event
->priv
->u
.syscall
.node
, &syscall_table
->compat_unknown_syscall_exit_dispatch
);
704 if (hlist_empty(&syscall_table
->unknown_syscall_exit_dispatch
)) {
705 const struct lttng_kernel_event_desc
*desc
=
706 &__event_desc___syscall_exit_unknown
;
707 struct lttng_kernel_event_common
*event
;
708 struct lttng_event_recorder_enabler
*event_enabler
;
710 memset(&ev
, 0, sizeof(ev
));
711 strncpy(ev
.name
, desc
->event_name
, LTTNG_KERNEL_ABI_SYM_NAME_LEN
);
712 ev
.name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
713 ev
.instrumentation
= LTTNG_KERNEL_ABI_SYSCALL
;
714 ev
.u
.syscall
.entryexit
= LTTNG_KERNEL_ABI_SYSCALL_EXIT
;
715 ev
.u
.syscall
.abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE
;
716 event_enabler
= lttng_event_recorder_enabler_create(LTTNG_ENABLER_FORMAT_NAME
, &ev
, chan
);
717 if (!event_enabler
) {
720 event
= _lttng_kernel_event_create(&event_enabler
->parent
, desc
);
721 WARN_ON_ONCE(!event
);
722 lttng_event_enabler_destroy(&event_enabler
->parent
);
724 return PTR_ERR(event
);
726 hlist_add_head(&event
->priv
->u
.syscall
.node
, &syscall_table
->unknown_syscall_exit_dispatch
);
729 ret
= lttng_create_syscall_event_if_missing(sc_table
.table
, sc_table
.len
,
730 syscall_table
->syscall_dispatch
, event_recorder_enabler
, SC_TYPE_ENTRY
);
733 ret
= lttng_create_syscall_event_if_missing(sc_exit_table
.table
, sc_exit_table
.len
,
734 syscall_table
->syscall_exit_dispatch
, event_recorder_enabler
, SC_TYPE_EXIT
);
739 ret
= lttng_create_syscall_event_if_missing(compat_sc_table
.table
, compat_sc_table
.len
,
740 syscall_table
->compat_syscall_dispatch
, event_recorder_enabler
, SC_TYPE_COMPAT_ENTRY
);
743 ret
= lttng_create_syscall_event_if_missing(compat_sc_exit_table
.table
, compat_sc_exit_table
.len
,
744 syscall_table
->compat_syscall_exit_dispatch
, event_recorder_enabler
, SC_TYPE_COMPAT_EXIT
);
752 * Should be called with sessions lock held.
754 int lttng_event_enabler_create_syscall_events_if_missing(struct lttng_event_enabler_common
*syscall_event_enabler
)
756 struct lttng_kernel_syscall_table
*syscall_table
= get_syscall_table_from_enabler(syscall_event_enabler
);
759 if (!syscall_table
->syscall_dispatch
) {
760 /* create syscall table mapping syscall to events */
761 syscall_table
->syscall_dispatch
= kzalloc(sizeof(struct hlist_head
) * sc_table
.len
, GFP_KERNEL
);
762 if (!syscall_table
->syscall_dispatch
)
765 if (!syscall_table
->syscall_exit_dispatch
) {
766 /* create syscall table mapping syscall to events */
767 syscall_table
->syscall_exit_dispatch
= kzalloc(sizeof(struct hlist_head
) * sc_exit_table
.len
, GFP_KERNEL
);
768 if (!syscall_table
->syscall_exit_dispatch
)
774 if (!syscall_table
->compat_syscall_dispatch
) {
775 /* create syscall table mapping compat syscall to events */
776 syscall_table
->compat_syscall_dispatch
= kzalloc(sizeof(struct hlist_head
) * compat_sc_table
.len
, GFP_KERNEL
);
777 if (!syscall_table
->compat_syscall_dispatch
)
781 if (!syscall_table
->compat_syscall_exit_dispatch
) {
782 /* create syscall table mapping compat syscall to events */
783 syscall_table
->compat_syscall_exit_dispatch
= kzalloc(sizeof(struct hlist_head
) * compat_sc_exit_table
.len
, GFP_KERNEL
);
784 if (!syscall_table
->compat_syscall_exit_dispatch
)
788 if (!syscall_table
->sc_filter
) {
789 syscall_table
->sc_filter
= kzalloc(sizeof(struct lttng_syscall_filter
),
791 if (!syscall_table
->sc_filter
)
795 ret
= lttng_syscalls_populate_events(syscall_event_enabler
);
799 if (!syscall_table
->sys_enter_registered
) {
800 ret
= lttng_wrapper_tracepoint_probe_register("sys_enter",
801 (void *) syscall_entry_event_probe
, syscall_table
);
804 syscall_table
->sys_enter_registered
= 1;
806 if (!syscall_table
->sys_exit_registered
) {
807 ret
= lttng_wrapper_tracepoint_probe_register("sys_exit",
808 (void *) syscall_exit_event_probe
, syscall_table
);
810 WARN_ON_ONCE(lttng_wrapper_tracepoint_probe_unregister("sys_enter",
811 (void *) syscall_entry_event_probe
, syscall_table
));
814 syscall_table
->sys_exit_registered
= 1;
817 ret
= lttng_syscalls_create_matching_event_notifiers(syscall_event_enabler
);
825 int create_unknown_event_notifier(
826 struct lttng_event_notifier_enabler
*event_notifier_enabler
,
829 struct lttng_event_ht
*events_ht
= lttng_get_event_ht_from_enabler(&event_notifier_enabler
->parent
);
830 struct lttng_kernel_event_common_private
*event_priv
;
831 struct lttng_kernel_event_common
*event
;
832 const struct lttng_kernel_event_desc
*desc
;
833 struct lttng_event_notifier_group
*group
= event_notifier_enabler
->group
;
834 struct lttng_kernel_syscall_table
*syscall_table
= &group
->syscall_table
;
835 struct lttng_kernel_abi_event_notifier event_notifier_param
;
836 uint64_t user_token
= event_notifier_enabler
->parent
.user_token
;
837 uint64_t error_counter_index
= event_notifier_enabler
->error_counter_index
;
838 struct lttng_event_enabler_common
*base_enabler
= lttng_event_notifier_enabler_as_enabler(
839 event_notifier_enabler
);
840 struct hlist_head
*unknown_dispatch_list
;
843 enum lttng_kernel_abi_syscall_abi abi
;
844 enum lttng_kernel_abi_syscall_entryexit entryexit
;
845 struct hlist_head
*head
;
849 desc
= &__event_desc___syscall_entry_unknown
;
850 unknown_dispatch_list
= &syscall_table
->unknown_syscall_dispatch
;
851 entryexit
= LTTNG_KERNEL_ABI_SYSCALL_ENTRY
;
852 abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE
;
855 desc
= &__event_desc___syscall_exit_unknown
;
856 unknown_dispatch_list
= &syscall_table
->unknown_syscall_exit_dispatch
;
857 entryexit
= LTTNG_KERNEL_ABI_SYSCALL_EXIT
;
858 abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE
;
860 case SC_TYPE_COMPAT_ENTRY
:
861 desc
= &__event_desc___compat_syscall_entry_unknown
;
862 unknown_dispatch_list
= &syscall_table
->compat_unknown_syscall_dispatch
;
863 entryexit
= LTTNG_KERNEL_ABI_SYSCALL_ENTRY
;
864 abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT
;
866 case SC_TYPE_COMPAT_EXIT
:
867 desc
= &__event_desc___compat_syscall_exit_unknown
;
868 unknown_dispatch_list
= &syscall_table
->compat_unknown_syscall_exit_dispatch
;
869 entryexit
= LTTNG_KERNEL_ABI_SYSCALL_EXIT
;
870 abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT
;
877 * Check if already created.
879 head
= utils_borrow_hash_table_bucket(events_ht
->table
, LTTNG_EVENT_HT_SIZE
, desc
->event_name
);
880 lttng_hlist_for_each_entry(event_priv
, head
, hlist_node
) {
881 if (lttng_event_enabler_desc_match_event(base_enabler
, desc
, event_priv
->pub
))
887 memset(&event_notifier_param
, 0, sizeof(event_notifier_param
));
888 strncat(event_notifier_param
.event
.name
, desc
->event_name
,
889 LTTNG_KERNEL_ABI_SYM_NAME_LEN
- strlen(event_notifier_param
.event
.name
) - 1);
891 event_notifier_param
.event
.name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
893 event_notifier_param
.event
.instrumentation
= LTTNG_KERNEL_ABI_SYSCALL
;
894 event_notifier_param
.event
.token
= user_token
;
895 event_notifier_param
.event
.u
.syscall
.abi
= abi
;
896 event_notifier_param
.event
.u
.syscall
.entryexit
= entryexit
;
897 event_notifier_param
.error_counter_index
= error_counter_index
;
899 event_notifier_enabler
= lttng_event_notifier_enabler_create(LTTNG_ENABLER_FORMAT_NAME
,
900 &event_notifier_param
, group
);
901 WARN_ON_ONCE(!event_notifier_enabler
);
902 event
= _lttng_kernel_event_create(&event_notifier_enabler
->parent
, desc
);
903 lttng_event_enabler_destroy(&event_notifier_enabler
->parent
);
905 printk(KERN_INFO
"Unable to create unknown notifier %s\n",
911 hlist_add_head_rcu(&event
->priv
->u
.syscall
.node
, unknown_dispatch_list
);
917 static int create_matching_event_notifiers(
918 struct lttng_event_notifier_enabler
*syscall_event_notifier_enabler
,
919 const struct trace_syscall_entry
*table
,
920 size_t table_len
, enum sc_type type
)
922 struct lttng_event_ht
*events_ht
= lttng_get_event_ht_from_enabler(&syscall_event_notifier_enabler
->parent
);
923 struct lttng_event_notifier_group
*group
= syscall_event_notifier_enabler
->group
;
924 const struct lttng_kernel_event_desc
*desc
;
925 uint64_t user_token
= syscall_event_notifier_enabler
->parent
.user_token
;
926 uint64_t error_counter_index
= syscall_event_notifier_enabler
->error_counter_index
;
930 /* iterate over all syscall and create event_notifier that match */
931 for (i
= 0; i
< table_len
; i
++) {
932 struct lttng_event_notifier_enabler
*event_notifier_enabler
;
933 struct lttng_kernel_event_common_private
*event_priv
;
934 struct lttng_kernel_event_common
*event
;
935 struct lttng_kernel_abi_event_notifier event_notifier_param
;
936 struct hlist_head
*head
;
939 desc
= table
[i
].desc
;
941 /* Unknown syscall */
945 if (!lttng_desc_match_enabler(desc
,
946 lttng_event_notifier_enabler_as_enabler(syscall_event_notifier_enabler
)))
950 * Check if already created.
952 head
= utils_borrow_hash_table_bucket(events_ht
->table
, LTTNG_EVENT_HT_SIZE
, desc
->event_name
);
953 lttng_hlist_for_each_entry(event_priv
, head
, hlist_node
) {
954 if (lttng_event_enabler_desc_match_event(&syscall_event_notifier_enabler
->parent
, desc
, event_priv
->pub
))
960 memset(&event_notifier_param
, 0, sizeof(event_notifier_param
));
963 event_notifier_param
.event
.u
.syscall
.entryexit
= LTTNG_KERNEL_ABI_SYSCALL_ENTRY
;
964 event_notifier_param
.event
.u
.syscall
.abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE
;
967 event_notifier_param
.event
.u
.syscall
.entryexit
= LTTNG_KERNEL_ABI_SYSCALL_EXIT
;
968 event_notifier_param
.event
.u
.syscall
.abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_NATIVE
;
970 case SC_TYPE_COMPAT_ENTRY
:
971 event_notifier_param
.event
.u
.syscall
.entryexit
= LTTNG_KERNEL_ABI_SYSCALL_ENTRY
;
972 event_notifier_param
.event
.u
.syscall
.abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT
;
974 case SC_TYPE_COMPAT_EXIT
:
975 event_notifier_param
.event
.u
.syscall
.entryexit
= LTTNG_KERNEL_ABI_SYSCALL_EXIT
;
976 event_notifier_param
.event
.u
.syscall
.abi
= LTTNG_KERNEL_ABI_SYSCALL_ABI_COMPAT
;
979 strncat(event_notifier_param
.event
.name
, desc
->event_name
,
980 LTTNG_KERNEL_ABI_SYM_NAME_LEN
- strlen(event_notifier_param
.event
.name
) - 1);
981 event_notifier_param
.event
.name
[LTTNG_KERNEL_ABI_SYM_NAME_LEN
- 1] = '\0';
982 event_notifier_param
.event
.instrumentation
= LTTNG_KERNEL_ABI_SYSCALL
;
983 event_notifier_param
.event
.token
= user_token
;
984 event_notifier_param
.error_counter_index
= error_counter_index
;
986 event_notifier_enabler
= lttng_event_notifier_enabler_create(LTTNG_ENABLER_FORMAT_NAME
,
987 &event_notifier_param
, group
);
988 WARN_ON_ONCE(!event_notifier_enabler
);
989 event
= _lttng_kernel_event_create(&event_notifier_enabler
->parent
, desc
);
990 lttng_event_enabler_destroy(&event_notifier_enabler
->parent
);
992 printk(KERN_INFO
"Unable to create event_notifier %s\n",
998 event
->priv
->u
.syscall
.syscall_id
= i
;
1007 int lttng_syscalls_create_matching_event_notifiers(struct lttng_event_enabler_common
*event_enabler
)
1010 enum lttng_kernel_abi_syscall_entryexit entryexit
=
1011 event_enabler
->event_param
.u
.syscall
.entryexit
;
1012 struct lttng_event_notifier_enabler
*event_notifier_enabler
;
1014 if (event_enabler
->enabler_type
!= LTTNG_EVENT_ENABLER_TYPE_NOTIFIER
)
1016 event_notifier_enabler
= container_of(event_enabler
, struct lttng_event_notifier_enabler
, parent
);
1018 if (entryexit
== LTTNG_KERNEL_ABI_SYSCALL_ENTRY
|| entryexit
== LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT
) {
1019 ret
= create_matching_event_notifiers(event_notifier_enabler
,
1020 sc_table
.table
, sc_table
.len
, SC_TYPE_ENTRY
);
1024 ret
= create_matching_event_notifiers(event_notifier_enabler
,
1025 compat_sc_table
.table
, compat_sc_table
.len
,
1026 SC_TYPE_COMPAT_ENTRY
);
1030 ret
= create_unknown_event_notifier(event_notifier_enabler
,
1035 ret
= create_unknown_event_notifier(event_notifier_enabler
,
1036 SC_TYPE_COMPAT_ENTRY
);
1041 if (entryexit
== LTTNG_KERNEL_ABI_SYSCALL_EXIT
|| entryexit
== LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT
) {
1042 ret
= create_matching_event_notifiers(event_notifier_enabler
,
1043 sc_exit_table
.table
, sc_exit_table
.len
,
1048 ret
= create_unknown_event_notifier(event_notifier_enabler
,
1053 ret
= create_matching_event_notifiers(event_notifier_enabler
,
1054 compat_sc_exit_table
.table
, compat_sc_exit_table
.len
,
1055 SC_TYPE_COMPAT_EXIT
);
1059 ret
= create_unknown_event_notifier(event_notifier_enabler
,
1060 SC_TYPE_COMPAT_EXIT
);
1069 int lttng_syscalls_unregister_syscall_table(struct lttng_kernel_syscall_table
*syscall_table
)
1073 if (!syscall_table
->syscall_dispatch
)
1075 if (syscall_table
->sys_enter_registered
) {
1076 ret
= lttng_wrapper_tracepoint_probe_unregister("sys_enter",
1077 (void *) syscall_entry_event_probe
, syscall_table
);
1080 syscall_table
->sys_enter_registered
= 0;
1082 if (syscall_table
->sys_exit_registered
) {
1083 ret
= lttng_wrapper_tracepoint_probe_unregister("sys_exit",
1084 (void *) syscall_exit_event_probe
, syscall_table
);
1087 syscall_table
->sys_exit_registered
= 0;
1092 int lttng_syscalls_destroy_syscall_table(struct lttng_kernel_syscall_table
*syscall_table
)
1094 kfree(syscall_table
->syscall_dispatch
);
1095 kfree(syscall_table
->syscall_exit_dispatch
);
1096 #ifdef CONFIG_COMPAT
1097 kfree(syscall_table
->compat_syscall_dispatch
);
1098 kfree(syscall_table
->compat_syscall_exit_dispatch
);
1100 kfree(syscall_table
->sc_filter
);
1105 int get_syscall_nr(const char *syscall_name
)
1107 int syscall_nr
= -1;
1110 for (i
= 0; i
< sc_table
.len
; i
++) {
1111 const struct trace_syscall_entry
*entry
;
1112 const char *it_name
;
1114 entry
= &sc_table
.table
[i
];
1117 it_name
= entry
->desc
->event_name
;
1118 it_name
+= strlen(SYSCALL_ENTRY_STR
);
1119 if (!strcmp(syscall_name
, it_name
)) {
1128 int get_compat_syscall_nr(const char *syscall_name
)
1130 int syscall_nr
= -1;
1133 for (i
= 0; i
< compat_sc_table
.len
; i
++) {
1134 const struct trace_syscall_entry
*entry
;
1135 const char *it_name
;
1137 entry
= &compat_sc_table
.table
[i
];
1140 it_name
= entry
->desc
->event_name
;
1141 it_name
+= strlen(COMPAT_SYSCALL_ENTRY_STR
);
1142 if (!strcmp(syscall_name
, it_name
)) {
1151 uint32_t get_sc_tables_len(void)
1153 return sc_table
.len
+ compat_sc_table
.len
;
1157 const char *get_syscall_name(const char *desc_name
,
1158 enum lttng_syscall_abi abi
,
1159 enum lttng_syscall_entryexit entryexit
)
1161 size_t prefix_len
= 0;
1164 switch (entryexit
) {
1165 case LTTNG_SYSCALL_ENTRY
:
1167 case LTTNG_SYSCALL_ABI_NATIVE
:
1168 prefix_len
= strlen(SYSCALL_ENTRY_STR
);
1170 case LTTNG_SYSCALL_ABI_COMPAT
:
1171 prefix_len
= strlen(COMPAT_SYSCALL_ENTRY_STR
);
1175 case LTTNG_SYSCALL_EXIT
:
1177 case LTTNG_SYSCALL_ABI_NATIVE
:
1178 prefix_len
= strlen(SYSCALL_EXIT_STR
);
1180 case LTTNG_SYSCALL_ABI_COMPAT
:
1181 prefix_len
= strlen(COMPAT_SYSCALL_EXIT_STR
);
1186 WARN_ON_ONCE(prefix_len
== 0);
1187 return desc_name
+ prefix_len
;
1191 int lttng_syscall_filter_enable(
1192 struct lttng_syscall_filter
*filter
,
1193 const char *desc_name
, enum lttng_syscall_abi abi
,
1194 enum lttng_syscall_entryexit entryexit
)
1196 const char *syscall_name
;
1197 unsigned long *bitmap
;
1200 syscall_name
= get_syscall_name(desc_name
, abi
, entryexit
);
1203 case LTTNG_SYSCALL_ABI_NATIVE
:
1204 syscall_nr
= get_syscall_nr(syscall_name
);
1206 case LTTNG_SYSCALL_ABI_COMPAT
:
1207 syscall_nr
= get_compat_syscall_nr(syscall_name
);
1215 switch (entryexit
) {
1216 case LTTNG_SYSCALL_ENTRY
:
1218 case LTTNG_SYSCALL_ABI_NATIVE
:
1219 bitmap
= filter
->sc_entry
;
1221 case LTTNG_SYSCALL_ABI_COMPAT
:
1222 bitmap
= filter
->sc_compat_entry
;
1228 case LTTNG_SYSCALL_EXIT
:
1230 case LTTNG_SYSCALL_ABI_NATIVE
:
1231 bitmap
= filter
->sc_exit
;
1233 case LTTNG_SYSCALL_ABI_COMPAT
:
1234 bitmap
= filter
->sc_compat_exit
;
1243 if (test_bit(syscall_nr
, bitmap
))
1245 bitmap_set(bitmap
, syscall_nr
, 1);
1249 int lttng_syscall_filter_enable_event(struct lttng_kernel_event_common
*event
)
1251 struct lttng_kernel_syscall_table
*syscall_table
= get_syscall_table_from_event(event
);
1254 WARN_ON_ONCE(event
->priv
->instrumentation
!= LTTNG_KERNEL_ABI_SYSCALL
);
1256 ret
= lttng_syscall_filter_enable(syscall_table
->sc_filter
,
1257 event
->priv
->desc
->event_name
, event
->priv
->u
.syscall
.abi
,
1258 event
->priv
->u
.syscall
.entryexit
);
1262 switch (event
->type
) {
1263 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
1265 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
1267 unsigned int syscall_id
= event
->priv
->u
.syscall
.syscall_id
;
1268 struct hlist_head
*dispatch_list
;
1270 switch (event
->priv
->u
.syscall
.entryexit
) {
1271 case LTTNG_SYSCALL_ENTRY
:
1272 switch (event
->priv
->u
.syscall
.abi
) {
1273 case LTTNG_SYSCALL_ABI_NATIVE
:
1274 dispatch_list
= &syscall_table
->syscall_dispatch
[syscall_id
];
1276 case LTTNG_SYSCALL_ABI_COMPAT
:
1277 dispatch_list
= &syscall_table
->compat_syscall_dispatch
[syscall_id
];
1284 case LTTNG_SYSCALL_EXIT
:
1285 switch (event
->priv
->u
.syscall
.abi
) {
1286 case LTTNG_SYSCALL_ABI_NATIVE
:
1287 dispatch_list
= &syscall_table
->syscall_exit_dispatch
[syscall_id
];
1289 case LTTNG_SYSCALL_ABI_COMPAT
:
1290 dispatch_list
= &syscall_table
->compat_syscall_exit_dispatch
[syscall_id
];
1302 hlist_add_head_rcu(&event
->priv
->u
.syscall
.node
, dispatch_list
);
1314 int lttng_syscall_filter_disable(struct lttng_syscall_filter
*filter
,
1315 const char *desc_name
, enum lttng_syscall_abi abi
,
1316 enum lttng_syscall_entryexit entryexit
)
1318 const char *syscall_name
;
1319 unsigned long *bitmap
;
1322 syscall_name
= get_syscall_name(desc_name
, abi
, entryexit
);
1325 case LTTNG_SYSCALL_ABI_NATIVE
:
1326 syscall_nr
= get_syscall_nr(syscall_name
);
1328 case LTTNG_SYSCALL_ABI_COMPAT
:
1329 syscall_nr
= get_compat_syscall_nr(syscall_name
);
1337 switch (entryexit
) {
1338 case LTTNG_SYSCALL_ENTRY
:
1340 case LTTNG_SYSCALL_ABI_NATIVE
:
1341 bitmap
= filter
->sc_entry
;
1343 case LTTNG_SYSCALL_ABI_COMPAT
:
1344 bitmap
= filter
->sc_compat_entry
;
1350 case LTTNG_SYSCALL_EXIT
:
1352 case LTTNG_SYSCALL_ABI_NATIVE
:
1353 bitmap
= filter
->sc_exit
;
1355 case LTTNG_SYSCALL_ABI_COMPAT
:
1356 bitmap
= filter
->sc_compat_exit
;
1365 if (!test_bit(syscall_nr
, bitmap
))
1367 bitmap_clear(bitmap
, syscall_nr
, 1);
1372 int lttng_syscall_filter_disable_event(struct lttng_kernel_event_common
*event
)
1374 struct lttng_kernel_syscall_table
*syscall_table
= get_syscall_table_from_event(event
);
1377 ret
= lttng_syscall_filter_disable(syscall_table
->sc_filter
,
1378 event
->priv
->desc
->event_name
, event
->priv
->u
.syscall
.abi
,
1379 event
->priv
->u
.syscall
.entryexit
);
1383 switch (event
->type
) {
1384 case LTTNG_KERNEL_EVENT_TYPE_RECORDER
:
1386 case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER
:
1388 hlist_del_rcu(&event
->priv
->u
.syscall
.node
);
1398 void lttng_syscall_table_set_wildcard_all(struct lttng_event_enabler_common
*event_enabler
)
1400 struct lttng_kernel_syscall_table
*syscall_table
= get_syscall_table_from_enabler(event_enabler
);
1401 enum lttng_kernel_abi_syscall_entryexit entryexit
;
1402 int enabled
= event_enabler
->enabled
;
1404 if (event_enabler
->event_param
.instrumentation
!= LTTNG_KERNEL_ABI_SYSCALL
)
1406 if (event_enabler
->event_param
.u
.syscall
.abi
!= LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL
)
1408 if (event_enabler
->event_param
.u
.syscall
.match
!= LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME
)
1410 if (strcmp(event_enabler
->event_param
.name
, "*"))
1413 entryexit
= event_enabler
->event_param
.u
.syscall
.entryexit
;
1414 if (entryexit
== LTTNG_KERNEL_ABI_SYSCALL_ENTRY
|| entryexit
== LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT
)
1415 WRITE_ONCE(syscall_table
->syscall_all_entry
, enabled
);
1417 if (entryexit
== LTTNG_KERNEL_ABI_SYSCALL_EXIT
|| entryexit
== LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT
)
1418 WRITE_ONCE(syscall_table
->syscall_all_exit
, enabled
);
1422 const struct trace_syscall_entry
*syscall_list_get_entry(loff_t
*pos
)
1424 const struct trace_syscall_entry
*entry
;
1427 for (entry
= sc_table
.table
;
1428 entry
< sc_table
.table
+ sc_table
.len
;
1433 for (entry
= compat_sc_table
.table
;
1434 entry
< compat_sc_table
.table
+ compat_sc_table
.len
;
1444 void *syscall_list_start(struct seq_file
*m
, loff_t
*pos
)
1446 return (void *) syscall_list_get_entry(pos
);
1450 void *syscall_list_next(struct seq_file
*m
, void *p
, loff_t
*ppos
)
1453 return (void *) syscall_list_get_entry(ppos
);
1457 void syscall_list_stop(struct seq_file
*m
, void *p
)
1462 int get_sc_table(const struct trace_syscall_entry
*entry
,
1463 const struct trace_syscall_entry
**table
,
1464 unsigned int *bitness
)
1466 if (entry
>= sc_table
.table
&& entry
< sc_table
.table
+ sc_table
.len
) {
1468 *bitness
= BITS_PER_LONG
;
1470 *table
= sc_table
.table
;
1473 if (!(entry
>= compat_sc_table
.table
1474 && entry
< compat_sc_table
.table
+ compat_sc_table
.len
)) {
1480 *table
= compat_sc_table
.table
;
1485 int syscall_list_show(struct seq_file
*m
, void *p
)
1487 const struct trace_syscall_entry
*table
, *entry
= p
;
1488 unsigned int bitness
;
1489 unsigned long index
;
1493 ret
= get_sc_table(entry
, &table
, &bitness
);
1498 if (table
== sc_table
.table
) {
1499 index
= entry
- table
;
1500 name
= &entry
->desc
->event_name
[strlen(SYSCALL_ENTRY_STR
)];
1502 index
= (entry
- table
) + sc_table
.len
;
1503 name
= &entry
->desc
->event_name
[strlen(COMPAT_SYSCALL_ENTRY_STR
)];
1505 seq_printf(m
, "syscall { index = %lu; name = %s; bitness = %u; };\n",
1506 index
, name
, bitness
);
1511 const struct seq_operations lttng_syscall_list_seq_ops
= {
1512 .start
= syscall_list_start
,
1513 .next
= syscall_list_next
,
1514 .stop
= syscall_list_stop
,
1515 .show
= syscall_list_show
,
1519 int lttng_syscall_list_open(struct inode
*inode
, struct file
*file
)
1521 return seq_open(file
, <tng_syscall_list_seq_ops
);
1524 const struct file_operations lttng_syscall_list_fops
= {
1525 .owner
= THIS_MODULE
,
1526 .open
= lttng_syscall_list_open
,
1528 .llseek
= seq_lseek
,
1529 .release
= seq_release
,
1533 * A syscall is enabled if it is traced for either entry or exit.
1535 long lttng_syscall_table_get_active_mask(struct lttng_kernel_syscall_table
*syscall_table
,
1536 struct lttng_kernel_abi_syscall_mask __user
*usyscall_mask
)
1538 uint32_t len
, sc_tables_len
, bitmask_len
;
1541 struct lttng_syscall_filter
*filter
;
1543 ret
= get_user(len
, &usyscall_mask
->len
);
1546 sc_tables_len
= get_sc_tables_len();
1547 bitmask_len
= ALIGN(sc_tables_len
, 8) >> 3;
1548 if (len
< sc_tables_len
) {
1549 return put_user(sc_tables_len
, &usyscall_mask
->len
);
1551 /* Array is large enough, we can copy array to user-space. */
1552 tmp_mask
= kzalloc(bitmask_len
, GFP_KERNEL
);
1555 filter
= syscall_table
->sc_filter
;
1557 for (bit
= 0; bit
< sc_table
.len
; bit
++) {
1560 if (syscall_table
->syscall_dispatch
) {
1561 if (!(READ_ONCE(syscall_table
->syscall_all_entry
)
1562 || READ_ONCE(syscall_table
->syscall_all_exit
)) && filter
)
1563 state
= test_bit(bit
, filter
->sc_entry
)
1564 || test_bit(bit
, filter
->sc_exit
);
1570 bt_bitfield_write_be(tmp_mask
, char, bit
, 1, state
);
1572 for (; bit
< sc_tables_len
; bit
++) {
1575 if (syscall_table
->compat_syscall_dispatch
) {
1576 if (!(READ_ONCE(syscall_table
->syscall_all_entry
)
1577 || READ_ONCE(syscall_table
->syscall_all_exit
)) && filter
)
1578 state
= test_bit(bit
- sc_table
.len
,
1579 filter
->sc_compat_entry
)
1580 || test_bit(bit
- sc_table
.len
,
1581 filter
->sc_compat_exit
);
1587 bt_bitfield_write_be(tmp_mask
, char, bit
, 1, state
);
1589 if (copy_to_user(usyscall_mask
->mask
, tmp_mask
, bitmask_len
))
1595 int lttng_abi_syscall_list(void)
1597 struct file
*syscall_list_file
;
1600 file_fd
= lttng_get_unused_fd();
1606 syscall_list_file
= anon_inode_getfile("[lttng_syscall_list]",
1607 <tng_syscall_list_fops
,
1609 if (IS_ERR(syscall_list_file
)) {
1610 ret
= PTR_ERR(syscall_list_file
);
1613 ret
= lttng_syscall_list_fops
.open(NULL
, syscall_list_file
);
1616 fd_install(file_fd
, syscall_list_file
);
1620 fput(syscall_list_file
);
1622 put_unused_fd(file_fd
);