1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */
3 #ifndef CREATE_SYSCALL_TABLE
5 #define OVERRIDE_32_execve
6 #define OVERRIDE_64_execve
7 SC_LTTNG_TRACEPOINT_EVENT(execve
,
8 TP_PROTO(sc_exit(long ret
,) const char *filename
, char *const *argv
, char *const *envp
),
9 TP_ARGS(sc_exit(ret
,) filename
, argv
, envp
),
10 TP_FIELDS(sc_exit(ctf_integer(long, ret
, ret
))
11 sc_in(ctf_user_string(filename
, filename
))
12 sc_in(ctf_integer_hex(char *const *, argv
, argv
))
13 sc_in(ctf_integer_hex(char *const *, envp
, envp
))
18 * Clone()'s `flags` field has two parts:
19 * 1. exit signal: the least significant byte of the `unsigned long` is
20 * the signal the kernel must send to the parent process on child
22 * 2. clone options: the remaining bytes of the `unsigned long` is used a
23 * bitwise flag for the clone options.
25 #define CLONE_EXIT_SIGNAL_FLAG_RESERVED_BITS 8
26 #define LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(x) ((x) >> CLONE_EXIT_SIGNAL_FLAG_RESERVED_BITS)
28 SC_LTTNG_TRACEPOINT_ENUM(lttng_clone_exit_signal_flags
,
30 ctf_enum_value("SIGHUP", SIGHUP
)
31 ctf_enum_value("SIGINT", SIGINT
)
32 ctf_enum_value("SIGQUIT", SIGQUIT
)
33 ctf_enum_value("SIGILL", SIGILL
)
34 ctf_enum_value("SIGTRAP", SIGTRAP
)
35 ctf_enum_value("SIGABRT", SIGABRT
)
36 ctf_enum_value("SIGIOT", SIGIOT
)
37 ctf_enum_value("SIGBUS", SIGBUS
)
39 ctf_enum_value("SIGEMT", SIGEMT
)
40 #endif /* #ifdef SIGEMT */
41 ctf_enum_value("SIGFPE", SIGFPE
)
42 ctf_enum_value("SIGKILL", SIGKILL
)
43 ctf_enum_value("SIGUSR1", SIGUSR1
)
44 ctf_enum_value("SIGSEGV", SIGSEGV
)
45 ctf_enum_value("SIGUSR2", SIGUSR2
)
46 ctf_enum_value("SIGPIPE", SIGPIPE
)
47 ctf_enum_value("SIGALRM", SIGALRM
)
48 ctf_enum_value("SIGTERM", SIGTERM
)
50 ctf_enum_value("SIGSTKFLT", SIGSTKFLT
)
51 #endif /* #ifdef SIGSTKFLT */
52 ctf_enum_value("SIGCHLD", SIGCHLD
)
54 ctf_enum_value("SIGCLD", SIGCLD
)
55 #endif /* #ifdef SIGCLD */
56 ctf_enum_value("SIGCONT", SIGCONT
)
57 ctf_enum_value("SIGSTOP", SIGSTOP
)
58 ctf_enum_value("SIGTSTP", SIGTSTP
)
59 ctf_enum_value("SIGTTIN", SIGTTIN
)
60 ctf_enum_value("SIGTTOU", SIGTTOU
)
61 ctf_enum_value("SIGURG", SIGURG
)
62 ctf_enum_value("SIGXCPU", SIGXCPU
)
63 ctf_enum_value("SIGXFSZ", SIGXFSZ
)
64 ctf_enum_value("SIGVTALR", SIGVTALRM
)
65 ctf_enum_value("SIGPROF", SIGPROF
)
66 ctf_enum_value("SIGWINCH", SIGWINCH
)
67 ctf_enum_value("SIGIO", SIGIO
)
68 ctf_enum_value("SIGPOLL", SIGPOLL
)
69 ctf_enum_value("SIGPWR", SIGPWR
)
71 ctf_enum_value("SIGINFO", SIGINFO
)
72 #endif /* #ifdef SIGINFO */
74 ctf_enum_value("SIGLOST", SIGLOST
)
75 #endif /* #ifdef SIGLOST */
76 ctf_enum_value("SIGSYS", SIGSYS
)
78 ctf_enum_value("SIGUNUSED", SIGUNUSED
)
79 #endif /* #ifdef SIGUNUSED */
83 SC_LTTNG_TRACEPOINT_ENUM(lttng_clone_option_flags
,
85 ctf_enum_value("CLONE_CHILD_CLEARTID", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_CHILD_CLEARTID
))
86 ctf_enum_value("CLONE_CHILD_SETTID", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_CHILD_SETTID
))
87 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,5,0))
88 ctf_enum_value("CLONE_CLEAR_SIGHAND", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_CLEAR_SIGHAND
))
89 #endif /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,5,0)) */
90 ctf_enum_value("CLONE_DETACHED", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_DETACHED
))
91 ctf_enum_value("CLONE_FILES", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_FILES
))
92 ctf_enum_value("CLONE_FS", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_FS
))
93 ctf_enum_value("CLONE_IO", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_IO
))
94 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,6,0))
95 ctf_enum_value("CLONE_NEWCGROUP", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_NEWCGROUP
))
96 #endif /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,6,0)) */
97 ctf_enum_value("CLONE_NEWIPC", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_NEWIPC
))
98 ctf_enum_value("CLONE_NEWNET", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_NEWNET
))
99 ctf_enum_value("CLONE_NEWNS", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_NEWNS
))
100 ctf_enum_value("CLONE_NEWPID", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_NEWPID
))
101 ctf_enum_value("CLONE_NEWUSER", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_NEWUSER
))
102 ctf_enum_value("CLONE_NEWUTS", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_NEWUTS
))
103 ctf_enum_value("CLONE_PARENT", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_PARENT
))
104 ctf_enum_value("CLONE_PARENT_SETTID", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_PARENT_SETTID
))
105 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,2,0))
106 ctf_enum_value("CLONE_PIDFD", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_PIDFD
))
107 #endif /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,2,0)) */
108 ctf_enum_value("CLONE_PTRACE", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_PTRACE
))
109 ctf_enum_value("CLONE_SETTLS", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_SETTLS
))
110 ctf_enum_value("CLONE_SIGHAND", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_SIGHAND
))
111 ctf_enum_value("CLONE_SYSVSEM", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_SYSVSEM
))
112 ctf_enum_value("CLONE_THREAD", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_THREAD
))
113 ctf_enum_value("CLONE_UNTRACED", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_UNTRACED
))
114 ctf_enum_value("CLONE_VFORK", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_VFORK
))
115 ctf_enum_value("CLONE_VM", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_VM
))
119 #define LTTNG_CLONE_FLAGS_EXIT_SIGNAL \
120 lttng_kernel_static_event_field("exit_signal", \
121 lttng_kernel_static_type_enum(&__enum_lttng_clone_exit_signal_flags, \
122 lttng_kernel_static_type_integer(CLONE_EXIT_SIGNAL_FLAG_RESERVED_BITS, \
123 1, 0, __BYTE_ORDER, 16)), \
126 #define LTTNG_CLONE_FLAGS_OPTIONS \
127 lttng_kernel_static_event_field("options", \
128 lttng_kernel_static_type_enum(&__enum_lttng_clone_option_flags, \
129 lttng_kernel_static_type_integer( \
130 sizeof(unsigned long) * CHAR_BIT - CLONE_EXIT_SIGNAL_FLAG_RESERVED_BITS, \
131 1, 0, __BYTE_ORDER, 16)), \
134 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
135 #define LTTNG_CLONE_FLAGS \
136 lttng_kernel_static_event_field_array( \
137 [0] = LTTNG_CLONE_FLAGS_EXIT_SIGNAL, \
138 [1] = LTTNG_CLONE_FLAGS_OPTIONS, \
141 #define LTTNG_CLONE_FLAGS \
142 lttng_kernel_static_event_field_array( \
143 [0] = LTTNG_CLONE_FLAGS_OPTIONS, \
144 [1] = LTTNG_CLONE_FLAGS_EXIT_SIGNAL, \
149 #define OVERRIDE_32_clone
150 #define OVERRIDE_64_clone
151 SC_LTTNG_TRACEPOINT_EVENT(clone
,
152 TP_PROTO(sc_exit(long ret
,) unsigned long clone_flags
, unsigned long newsp
,
153 void __user
*parent_tid
,
154 void __user
*child_tid
),
155 TP_ARGS(sc_exit(ret
,) clone_flags
, newsp
, parent_tid
, child_tid
),
157 sc_exit(ctf_integer(long, ret
, ret
))
161 lttng_kernel_static_type_struct(2, LTTNG_CLONE_FLAGS
, lttng_alignof(unsigned long) * CHAR_BIT
)
165 ctf_integer_type(unsigned long, clone_flags
)
169 sc_in(ctf_integer_hex(unsigned long, newsp
, newsp
))
170 sc_in(ctf_integer_hex(void *, parent_tid
, parent_tid
))
171 sc_in(ctf_integer_hex(void *, child_tid
, child_tid
))
175 /* present in 32, missing in 64 due to old kernel headers */
176 #define OVERRIDE_32_getcpu
177 #define OVERRIDE_64_getcpu
178 SC_LTTNG_TRACEPOINT_EVENT(getcpu
,
179 TP_PROTO(sc_exit(long ret
,) unsigned __user
*cpup
, unsigned __user
*nodep
, void *tcache
),
180 TP_ARGS(sc_exit(ret
,) cpup
, nodep
, tcache
),
182 sc_exit(ctf_integer(long, ret
, ret
))
183 sc_out(ctf_integer_hex(unsigned *, cpup
, cpup
))
184 sc_out(ctf_integer_hex(unsigned *, nodep
, nodep
))
185 sc_inout(ctf_integer_hex(void *, tcache
, tcache
))
189 #define OVERRIDE_32_pipe2
190 #define OVERRIDE_64_pipe2
191 SC_LTTNG_TRACEPOINT_EVENT(pipe2
,
192 TP_PROTO(sc_exit(long ret
,) int * fildes
, int flags
),
193 TP_ARGS(sc_exit(ret
,) fildes
, flags
),
194 TP_FIELDS(sc_exit(ctf_integer(long, ret
, ret
))
195 sc_out(ctf_user_array(int, fildes
, fildes
, 2))
196 sc_in(ctf_integer(int, flags
, flags
))
200 #define LTTNG_SYSCALL_SELECT_locvar \
201 unsigned long *fds_in, *fds_out, *fds_ex; \
202 unsigned long nr_bytes, nr_ulong; \
205 #define LTTNG_SYSCALL_SELECT_code_pre \
209 unsigned int n_in_bytes; \
211 tp_locvar->fds_in = NULL; \
212 tp_locvar->fds_out = NULL; \
213 tp_locvar->fds_ex = NULL; \
214 tp_locvar->overflow = 0; \
224 /* On error or bogus input, don't copy anything. */ \
225 if (n >__FD_SETSIZE) \
228 n_in_bytes = DIV_ROUND_UP((unsigned int) n, BITS_PER_BYTE); \
231 * Limit atomic memory allocation to one page, since n \
232 * is limited to 1024 and the smallest page size on Linux \
233 * is 4k, this should not happen, don't try to make it work. \
235 if (n_in_bytes > PAGE_SIZE) { \
237 /* Inform the user that we did not output everything. */ \
238 tp_locvar->overflow = 1; \
241 tp_locvar->nr_bytes = n_in_bytes; \
242 tp_locvar->nr_ulong = DIV_ROUND_UP(n_in_bytes, \
243 sizeof(unsigned long)); \
247 tp_locvar->fds_in = lttng_tp_mempool_alloc( \
248 tp_locvar->nr_ulong * sizeof(unsigned long)); \
249 if (!tp_locvar->fds_in) \
252 err = lib_ring_buffer_copy_from_user_check_nofault( \
253 tp_locvar->fds_in, inp, \
254 tp_locvar->nr_ulong * sizeof(unsigned long)); \
259 tp_locvar->fds_out = lttng_tp_mempool_alloc( \
260 tp_locvar->nr_ulong * sizeof(unsigned long)); \
261 if (!tp_locvar->fds_out) \
264 err = lib_ring_buffer_copy_from_user_check_nofault( \
265 tp_locvar->fds_out, outp, \
266 tp_locvar->nr_ulong * sizeof(unsigned long)); \
271 tp_locvar->fds_ex = lttng_tp_mempool_alloc( \
272 tp_locvar->nr_ulong * sizeof(unsigned long)); \
273 if (!tp_locvar->fds_ex) \
276 err = lib_ring_buffer_copy_from_user_check_nofault( \
277 tp_locvar->fds_ex, exp, \
278 tp_locvar->nr_ulong * sizeof(unsigned long)); \
285 tp_locvar->nr_bytes = 0; \
286 tp_locvar->nr_ulong = 0; \
287 end: ; /* Label at end of compound statement. */ \
291 #define LTTNG_SYSCALL_SELECT_fds_field_LE(name, input) \
294 lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 10) \
296 _ ## name ## _length, \
299 ctf_integer_type(uint8_t, tp_locvar->nr_bytes) \
302 ctf_integer_type(uint8_t, 0) \
309 lttng_kernel_static_type_sequence( \
310 "_" #name "_length", \
311 lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 16), \
318 unsigned int nr_bytes_out = 0; \
323 for (src = 0; src < tp_locvar->nr_ulong; src++) { \
325 for (dst = 0; dst < sizeof(long); dst++) { \
326 if (nr_bytes_out++ >= tp_locvar->nr_bytes) { \
329 ctf_user_integer_type(uint8_t, \
330 ((uint8_t __user *) (input->fds_bits + src))[dst]); \
337 #define LTTNG_SYSCALL_SELECT_fds_field_BE(name, input) \
340 lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 10) \
342 _ ## name ## _length, \
345 ctf_integer_type(uint8_t, tp_locvar->nr_bytes) \
348 ctf_integer_type(uint8_t, 0) \
355 lttng_kernel_static_type_sequence("_" #name "_length", \
356 lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 16), \
362 unsigned int src, nr_bytes_out = 0; \
367 for (src = 0; src < tp_locvar->nr_ulong; src++) { \
369 for (dst = sizeof(long); dst >= 0; dst--) { \
370 if (nr_bytes_out++ >= tp_locvar->nr_bytes) { \
373 ctf_user_integer_type(uint8_t, \
374 ((uint8_t __user *) (input->fds_bits + src))[dst]); \
381 #define LTTNG_SYSCALL_SELECT_code_post \
382 lttng_tp_mempool_free(tp_locvar->fds_in); \
383 lttng_tp_mempool_free(tp_locvar->fds_out); \
384 lttng_tp_mempool_free(tp_locvar->fds_ex);
386 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM)
387 #define OVERRIDE_32_select
388 #define OVERRIDE_64_select
389 SC_LTTNG_TRACEPOINT_EVENT_CODE(select
,
390 TP_PROTO(sc_exit(long ret
,) int n
, fd_set __user
*inp
, fd_set __user
*outp
,
391 fd_set __user
*exp
, struct timeval
*tvp
),
392 TP_ARGS(sc_exit(ret
,) n
, inp
, outp
, exp
, tvp
),
394 LTTNG_SYSCALL_SELECT_locvar
397 LTTNG_SYSCALL_SELECT_code_pre
400 sc_exit(ctf_integer(long, ret
, ret
))
401 sc_in(ctf_integer(int, n
, n
))
402 sc_inout(ctf_integer(uint8_t, overflow
, tp_locvar
->overflow
))
403 sc_inout(ctf_integer(struct timeval
*, tvp
, tvp
))
406 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
407 LTTNG_SYSCALL_SELECT_fds_field_LE(readfds
, inp
)
408 LTTNG_SYSCALL_SELECT_fds_field_LE(writefds
, outp
)
409 LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds
, exp
)
411 LTTNG_SYSCALL_SELECT_fds_field_BE(readfds
, inp
)
412 LTTNG_SYSCALL_SELECT_fds_field_BE(writefds
, outp
)
413 LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds
, exp
)
418 LTTNG_SYSCALL_SELECT_code_post
421 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */
423 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
424 #define OVERRIDE_32_pselect6
425 #define OVERRIDE_64_pselect6
426 SC_LTTNG_TRACEPOINT_EVENT_CODE(pselect6
,
427 TP_PROTO(sc_exit(long ret
,) int n
, fd_set __user
* inp
, fd_set __user
* outp
,
428 fd_set __user
* exp
, struct timeval __user
* tvp
, void __user
* sig
),
429 TP_ARGS(sc_exit(ret
,) n
, inp
, outp
, exp
, tvp
, sig
),
431 LTTNG_SYSCALL_SELECT_locvar
434 LTTNG_SYSCALL_SELECT_code_pre
437 sc_exit(ctf_integer(long, ret
, ret
))
438 sc_in(ctf_integer(int, n
, n
))
439 sc_inout(ctf_integer(uint8_t, overflow
, tp_locvar
->overflow
))
440 sc_inout(ctf_integer(struct timeval
*, tvp
, tvp
))
441 sc_in(ctf_integer_hex(void *, sig
, sig
))
444 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
445 LTTNG_SYSCALL_SELECT_fds_field_LE(readfds
, inp
)
446 LTTNG_SYSCALL_SELECT_fds_field_LE(writefds
, outp
)
447 LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds
, exp
)
449 LTTNG_SYSCALL_SELECT_fds_field_BE(readfds
, inp
)
450 LTTNG_SYSCALL_SELECT_fds_field_BE(writefds
, outp
)
451 LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds
, exp
)
456 LTTNG_SYSCALL_SELECT_code_post
459 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
461 #ifndef ONCE_LTTNG_TRACE_POLL_H
462 #define ONCE_LTTNG_TRACE_POLL_H
464 #define LTTNG_POLL_NRFLAGS (POLLNVAL + 1)
465 #define POLL_FLAGS_PADDING_SIZE (sizeof(uint8_t) * BITS_PER_BYTE) - \
466 ilog2(LTTNG_POLL_NRFLAGS - 1)
469 * Only extract the values specified by iBCS2 for now.
471 static const struct lttng_kernel_event_field
*lttng_pollfd_flag_fields
[] = {
472 [ilog2(POLLIN
)] = lttng_kernel_static_event_field("POLLIN",
473 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
474 false, false, false),
475 [ilog2(POLLPRI
)] = lttng_kernel_static_event_field("POLLPRI",
476 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
477 false, false, false),
478 [ilog2(POLLOUT
)] = lttng_kernel_static_event_field("POLLOUT",
479 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
480 false, false, false),
481 [ilog2(POLLERR
)] = lttng_kernel_static_event_field("POLLERR",
482 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
483 false, false, false),
484 [ilog2(POLLHUP
)] = lttng_kernel_static_event_field("POLLHUP",
485 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
486 false, false, false),
487 [ilog2(POLLNVAL
)] = lttng_kernel_static_event_field("POLLNVAL",
488 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
489 false, false, false),
490 [ilog2(LTTNG_POLL_NRFLAGS
)] = lttng_kernel_static_event_field("padding",
491 lttng_kernel_static_type_integer(POLL_FLAGS_PADDING_SIZE
, 1, 0, __LITTLE_ENDIAN
, 10),
492 false, false, false),
495 static const struct lttng_kernel_event_field
*lttng_pollfd_fields
[] = {
496 [0] = lttng_kernel_static_event_field("fd", lttng_kernel_static_type_integer_from_type(int, __BYTE_ORDER
, 10),
497 false, false, false),
498 [1] = lttng_kernel_static_event_field("raw_events", lttng_kernel_static_type_integer_from_type(uint16_t, __BYTE_ORDER
, 16),
499 false, false, false),
500 [2] = lttng_kernel_static_event_field("events",
501 lttng_kernel_static_type_struct(ARRAY_SIZE(lttng_pollfd_flag_fields
),
502 lttng_pollfd_flag_fields
, 0),
503 false, false, false),
506 #endif /* ONCE_LTTNG_TRACE_POLL_H */
508 #define LTTNG_SYSCALL_POLL_locvar \
509 unsigned int fds_length, fds_max_len, alloc_fds; \
510 struct pollfd *fds; \
513 #define LTTNG_SYSCALL_POLL_code_pre \
514 BUILD_BUG_ON(((ARRAY_SIZE(lttng_pollfd_flag_fields) - 1) + \
515 POLL_FLAGS_PADDING_SIZE) != \
516 sizeof(uint8_t) * BITS_PER_BYTE); \
517 tp_locvar->fds = NULL; \
518 tp_locvar->overflow = 0; \
521 if (nfds > PAGE_SIZE / sizeof(struct pollfd)) { \
522 tp_locvar->fds_length = PAGE_SIZE / sizeof(struct pollfd); \
523 tp_locvar->fds_max_len = PAGE_SIZE / sizeof(struct pollfd); \
524 tp_locvar->overflow = 1; \
526 tp_locvar->fds_length = nfds; \
527 tp_locvar->fds_max_len = nfds; \
529 tp_locvar->alloc_fds = tp_locvar->fds_length * sizeof(struct pollfd); \
532 * On exit, the number of active FDs is determined by ret, \
533 * nfds stays the same as the entry, but we only want to \
534 * output the FDs that are relevant. \
537 if (ret <= 0 || ret > nfds) \
540 if (nfds > PAGE_SIZE / sizeof(struct pollfd)) { \
541 tp_locvar->fds_length = PAGE_SIZE / sizeof(struct pollfd); \
542 tp_locvar->fds_max_len = PAGE_SIZE / sizeof(struct pollfd); \
543 tp_locvar->overflow = 1; \
545 tp_locvar->fds_length = ret; \
546 tp_locvar->fds_max_len = nfds; \
548 tp_locvar->alloc_fds = tp_locvar->fds_max_len * sizeof(struct pollfd); \
553 tp_locvar->fds = lttng_tp_mempool_alloc(tp_locvar->alloc_fds); \
554 if (!tp_locvar->fds) \
556 err = lib_ring_buffer_copy_from_user_check_nofault( \
557 tp_locvar->fds, ufds, tp_locvar->alloc_fds); \
564 tp_locvar->fds_length = 0; \
565 tp_locvar->fds_max_len = 0; \
569 #define LTTNG_SYSCALL_POLL_fds_field \
573 lttng_kernel_static_type_sequence("fds_length", \
574 lttng_kernel_static_type_struct(ARRAY_SIZE(lttng_pollfd_fields), lttng_pollfd_fields, 0), \
582 ctf_align(int) /* Align on largest field in struct. */ \
583 for (i = 0; i < tp_locvar->fds_length; i++) { \
584 ctf_integer_type(int, tp_locvar->fds[i].fd) \
585 ctf_integer_type(short, tp_locvar->fds[i].events) \
586 ctf_integer_bitfield_type(uint8_t, \
587 (uint8_t) tp_locvar->fds[i].events) \
595 lttng_kernel_static_type_sequence("fds_length", \
596 lttng_kernel_static_type_struct(ARRAY_SIZE(lttng_pollfd_fields), lttng_pollfd_fields, 0), \
602 unsigned int i, nr = 0; \
604 ctf_align(int) /* Align on largest field in struct. */ \
606 * Iterate over the complete array, but only output \
607 * "ret" active FDs. \
609 for (i = 0; i < tp_locvar->fds_max_len; i++) { \
610 if (!tp_locvar->fds[i].revents) \
612 if (nr++ >= tp_locvar->fds_length) \
614 ctf_integer_type(int, tp_locvar->fds[i].fd) \
615 ctf_integer_type(short, tp_locvar->fds[i].revents) \
616 ctf_integer_bitfield_type(uint8_t, \
617 (uint8_t) tp_locvar->fds[i].revents) \
620 * If there is a discrepancy between ret and the \
621 * content of revents (e.g. caused by userspace corrupting \
622 * the array from a concurrent thread), we have to output \
623 * zeros to keep the trace readable. \
625 for (i = nr; i < tp_locvar->fds_length; i++) { \
626 ctf_integer_type(int, 0) \
627 ctf_integer_type(short, 0) \
628 ctf_integer_bitfield_type(uint8_t, 0) \
634 #define LTTNG_SYSCALL_POLL_code_post \
635 lttng_tp_mempool_free(tp_locvar->fds);
637 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM)
638 #define OVERRIDE_32_poll
639 #define OVERRIDE_64_poll
640 SC_LTTNG_TRACEPOINT_EVENT_CODE(poll
,
641 TP_PROTO(sc_exit(long ret
,) struct pollfd __user
* ufds
,
642 unsigned int nfds
, int timeout_msecs
),
643 TP_ARGS(sc_exit(ret
,) ufds
, nfds
, timeout_msecs
),
645 LTTNG_SYSCALL_POLL_locvar
648 LTTNG_SYSCALL_POLL_code_pre
651 sc_exit(ctf_integer(long, ret
, ret
))
652 sc_in(ctf_integer(int, timeout_msecs
, timeout_msecs
))
653 sc_inout(ctf_integer(unsigned int, nfds
, nfds
))
654 sc_inout(ctf_integer(unsigned int, fds_length
, tp_locvar
->fds_length
))
655 sc_in(ctf_integer(uint8_t, overflow
, tp_locvar
->overflow
))
656 LTTNG_SYSCALL_POLL_fds_field
659 LTTNG_SYSCALL_POLL_code_post
662 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */
664 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
665 #define OVERRIDE_32_ppoll
666 #define OVERRIDE_64_ppoll
667 SC_LTTNG_TRACEPOINT_EVENT_CODE(ppoll
,
668 TP_PROTO(sc_exit(long ret
,) struct pollfd __user
* ufds
,
669 unsigned int nfds
, struct timespec
* tsp
, const sigset_t
* sigmask
, size_t sigsetsize
),
670 TP_ARGS(sc_exit(ret
,) ufds
, nfds
, tsp
, sigmask
, sigsetsize
),
672 LTTNG_SYSCALL_POLL_locvar
675 LTTNG_SYSCALL_POLL_code_pre
678 sc_exit(ctf_integer(long, ret
, ret
))
679 sc_in(ctf_integer(struct timespec
*, tsp
, tsp
))
680 sc_in(ctf_integer(const sigset_t
*, sigmask
, sigmask
))
681 sc_in(ctf_integer(size_t, sigsetsize
, sigsetsize
))
682 sc_inout(ctf_integer(unsigned int, nfds
, nfds
))
683 sc_inout(ctf_integer(unsigned int, fds_length
, tp_locvar
->fds_length
))
684 sc_inout(ctf_integer(uint8_t, overflow
, tp_locvar
->overflow
))
685 LTTNG_SYSCALL_POLL_fds_field
688 LTTNG_SYSCALL_POLL_code_post
691 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
693 #include <linux/eventpoll.h>
695 SC_LTTNG_TRACEPOINT_ENUM(lttng_epoll_op
,
697 ctf_enum_value("EPOLL_CTL_ADD", EPOLL_CTL_ADD
)
698 ctf_enum_value("EPOLL_CTL_DEL", EPOLL_CTL_DEL
)
699 ctf_enum_value("EPOLL_CTL_MOD", EPOLL_CTL_MOD
)
703 #ifndef ONCE_LTTNG_TRACE_EPOLL_CTL_H
704 #define ONCE_LTTNG_TRACE_EPOLL_CTL_H
706 #define LTTNG_EPOLL_NRFLAGS (POLLHUP + 1)
707 #define EPOLL_FLAGS_PADDING_SIZE (sizeof(uint8_t) * BITS_PER_BYTE) - \
708 ilog2(LTTNG_EPOLL_NRFLAGS - 1)
711 * Only extract the values specified by iBCS2 for now.
713 static const struct lttng_kernel_event_field
*lttng_epoll_ctl_events_fields
[] = {
715 [ilog2(POLLIN
)] = lttng_kernel_static_event_field("EPOLLIN",
716 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
717 false, false, false),
719 [ilog2(POLLPRI
)] = lttng_kernel_static_event_field("EPOLLPRI",
720 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
721 false, false, false),
723 [ilog2(POLLOUT
)] = lttng_kernel_static_event_field("EPOLLOUT",
724 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
725 false, false, false),
727 [ilog2(POLLERR
)] = lttng_kernel_static_event_field("EPOLLERR",
728 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
729 false, false, false),
731 [ilog2(POLLHUP
)] = lttng_kernel_static_event_field("EPOLLHUP",
732 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
733 false, false, false),
734 [ilog2(LTTNG_EPOLL_NRFLAGS
)] = lttng_kernel_static_event_field("padding",
735 lttng_kernel_static_type_integer(EPOLL_FLAGS_PADDING_SIZE
, 1, 0, __LITTLE_ENDIAN
, 10),
736 false, false, false),
739 static const struct lttng_kernel_event_field
*lttng_epoll_data_fields
[] = {
740 [0] = lttng_kernel_static_event_field("u64",
741 lttng_kernel_static_type_integer_from_type(uint64_t, __BYTE_ORDER
, 16),
742 false, false, false),
743 [1] = lttng_kernel_static_event_field("fd",
744 lttng_kernel_static_type_integer_from_type(int, __BYTE_ORDER
, 10),
745 false, false, false),
748 static const struct lttng_kernel_event_field
*epoll_ctl_fields
[] = {
749 [0] = lttng_kernel_static_event_field("data_union",
750 lttng_kernel_static_type_struct(ARRAY_SIZE(lttng_epoll_data_fields
),
751 lttng_epoll_data_fields
,
753 false, false, false),
754 [1] = lttng_kernel_static_event_field("raw_events",
755 lttng_kernel_static_type_integer_from_type(uint32_t, __BYTE_ORDER
, 16),
756 false, false, false),
757 [2] = lttng_kernel_static_event_field("events",
758 lttng_kernel_static_type_struct(ARRAY_SIZE(lttng_epoll_ctl_events_fields
),
759 lttng_epoll_ctl_events_fields
,
761 false, false, false),
763 #endif /* ONCE_LTTNG_TRACE_EPOLL_CTL_H */
765 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
766 #define OVERRIDE_32_epoll_ctl
767 #define OVERRIDE_64_epoll_ctl
768 SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_ctl
,
769 TP_PROTO(sc_exit(long ret
,) int epfd
, int op
, int fd
,
770 struct epoll_event __user
* uevent
),
771 TP_ARGS(sc_exit(ret
,) epfd
, op
, fd
, uevent
),
773 struct epoll_event event
;
777 tp_locvar
->err
= lib_ring_buffer_copy_from_user_check_nofault(
778 &tp_locvar
->event
, uevent
, sizeof(struct epoll_event
));
781 sc_exit(ctf_integer(long, ret
, ret
))
782 sc_in(ctf_integer(int, epfd
, epfd
))
783 sc_in(ctf_enum(lttng_epoll_op
, int, op_enum
, op
))
784 sc_in(ctf_integer(int, fd
, fd
))
788 lttng_kernel_static_type_struct(ARRAY_SIZE(epoll_ctl_fields
), epoll_ctl_fields
, 0)
793 if (!tp_locvar
->err
) {
794 ctf_integer_type(uint64_t, tp_locvar
->event
.data
)
795 ctf_integer_type(int, tp_locvar
->event
.data
)
796 ctf_integer_bitfield_type(uint32_t,
797 tp_locvar
->event
.events
)
798 ctf_integer_bitfield_type(uint8_t,
799 (uint8_t) tp_locvar
->event
.events
)
801 ctf_integer_type(uint64_t, 0)
802 ctf_integer_type(int, 0)
803 ctf_integer_bitfield_type(uint32_t, 0)
804 ctf_integer_bitfield_type(uint8_t, 0)
812 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
814 #ifndef ONCE_LTTNG_TRACE_EPOLL_H
815 #define ONCE_LTTNG_TRACE_EPOLL_H
817 static const struct lttng_kernel_event_field
*lttng_epoll_wait_fields
[] = lttng_kernel_static_event_field_array(
818 [0] = lttng_kernel_static_event_field("data_union",
819 lttng_kernel_static_type_struct(ARRAY_SIZE(lttng_epoll_data_fields
), lttng_epoll_data_fields
, 0),
820 false, false, false),
821 [1] = lttng_kernel_static_event_field("raw_events", lttng_kernel_static_type_integer_from_type(uint32_t, __BYTE_ORDER
, 16),
822 false, false, false),
823 [2] = lttng_kernel_static_event_field("events",
824 lttng_kernel_static_type_struct(ARRAY_SIZE(lttng_epoll_ctl_events_fields
), lttng_epoll_ctl_events_fields
, 0),
825 false, false, false),
828 #endif /* ONCE_LTTNG_TRACE_EPOLL_H */
830 #define LTTNG_SYSCALL_EPOLL_WAIT_locvar \
832 unsigned int fds_length; \
834 struct epoll_event *events; \
837 #define LTTNG_SYSCALL_EPOLL_WAIT_code_pre \
838 BUILD_BUG_ON(((ARRAY_SIZE(lttng_epoll_ctl_events_fields) - 1) + \
839 EPOLL_FLAGS_PADDING_SIZE) != \
840 sizeof(uint8_t) * BITS_PER_BYTE); \
843 unsigned long maxalloc; \
845 tp_locvar->fds_length = 0; \
846 tp_locvar->events = NULL; \
847 tp_locvar->overflow = 0; \
849 if (maxevents <= 0 || ret <= 0 || ret > maxevents) \
852 if (maxevents > PAGE_SIZE / sizeof(struct epoll_event)) { \
853 maxalloc = PAGE_SIZE / sizeof(struct epoll_event); \
855 maxalloc = maxevents; \
858 if (ret > maxalloc) { \
859 tp_locvar->fds_length = maxalloc; \
860 tp_locvar->overflow = 1; \
862 tp_locvar->fds_length = ret; \
865 tp_locvar->events = lttng_tp_mempool_alloc( \
866 maxalloc * sizeof(struct epoll_event)); \
867 if (!tp_locvar->events) { \
868 tp_locvar->fds_length = 0; \
872 err = lib_ring_buffer_copy_from_user_check_nofault( \
873 tp_locvar->events, uevents, \
874 maxalloc * sizeof(struct epoll_event)); \
876 tp_locvar->fds_length = 0; \
881 #define LTTNG_SYSCALL_EPOLL_WAIT_fds_field \
884 lttng_kernel_static_type_sequence("fds_length", \
885 lttng_kernel_static_type_struct(ARRAY_SIZE(lttng_epoll_wait_fields), lttng_epoll_wait_fields, 0), \
893 ctf_align(uint64_t) \
894 for (i = 0; i < tp_locvar->fds_length; i++) { \
895 ctf_integer_type(uint64_t, tp_locvar->events[i].data) \
896 ctf_integer_type(int, tp_locvar->events[i].data) \
897 ctf_integer_bitfield_type(uint32_t, \
898 tp_locvar->events[i].events) \
899 ctf_integer_bitfield_type(uint8_t, \
900 (uint8_t) tp_locvar->events[i].events) \
905 #define LTTNG_SYSCALL_EPOLL_WAIT_code_post \
907 lttng_tp_mempool_free(tp_locvar->events); \
911 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM)
912 #define OVERRIDE_32_epoll_wait
913 #define OVERRIDE_64_epoll_wait
914 SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_wait
,
915 TP_PROTO(sc_exit(long ret
,) int epfd
, struct epoll_event __user
* uevents
,
916 int maxevents
, int timeout
),
917 TP_ARGS(sc_exit(ret
,) epfd
, uevents
, maxevents
, timeout
),
919 LTTNG_SYSCALL_EPOLL_WAIT_locvar
922 LTTNG_SYSCALL_EPOLL_WAIT_code_pre
925 sc_exit(ctf_integer(long, ret
, ret
))
926 sc_in(ctf_integer(int, epfd
, epfd
))
927 sc_in(ctf_integer(int, maxevents
, maxevents
))
928 sc_in(ctf_integer(int, timeout
, timeout
))
929 sc_out(ctf_integer(unsigned int, fds_length
, tp_locvar
->fds_length
))
930 sc_out(ctf_integer(uint8_t, overflow
, tp_locvar
->overflow
))
932 LTTNG_SYSCALL_EPOLL_WAIT_fds_field
936 LTTNG_SYSCALL_EPOLL_WAIT_code_post
939 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */
941 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
942 #define OVERRIDE_32_epoll_pwait
943 #define OVERRIDE_64_epoll_pwait
944 SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_pwait
,
945 TP_PROTO(sc_exit(long ret
,) int epfd
, struct epoll_event __user
* uevents
,
946 int maxevents
, int timeout
, const sigset_t __user
* sigmask
, size_t sigsetsize
),
947 TP_ARGS(sc_exit(ret
,) epfd
, uevents
, maxevents
, timeout
, sigmask
, sigsetsize
),
949 LTTNG_SYSCALL_EPOLL_WAIT_locvar
952 LTTNG_SYSCALL_EPOLL_WAIT_code_pre
955 sc_exit(ctf_integer(long, ret
, ret
))
956 sc_in(ctf_integer(int, epfd
, epfd
))
957 sc_in(ctf_integer(int, maxevents
, maxevents
))
958 sc_in(ctf_integer(int, timeout
, timeout
))
959 sc_in(ctf_integer_hex(const sigset_t
*, sigmask
, sigmask
))
960 sc_in(ctf_integer(size_t, sigsetsize
, sigsetsize
))
961 sc_out(ctf_integer(unsigned int, fds_length
, tp_locvar
->fds_length
))
962 sc_out(ctf_integer(uint8_t, overflow
, tp_locvar
->overflow
))
964 LTTNG_SYSCALL_EPOLL_WAIT_fds_field
968 LTTNG_SYSCALL_EPOLL_WAIT_code_post
971 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
973 #if (defined(CONFIG_X86_64) && !defined(LTTNG_SC_COMPAT)) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
974 #define OVERRIDE_32_socketpair
975 #define OVERRIDE_64_socketpair
976 SC_LTTNG_TRACEPOINT_EVENT(socketpair
,
977 TP_PROTO(sc_exit(long ret
,) int family
, int type
, int protocol
, int *usockvec
),
978 TP_ARGS(sc_exit(ret
,) family
, type
, protocol
, usockvec
),
980 sc_exit(ctf_integer(long, ret
, ret
))
981 sc_in(ctf_integer(int, family
, family
))
982 sc_in(ctf_integer(int, type
, type
))
983 sc_in(ctf_integer(int, protocol
, protocol
))
984 sc_out(ctf_user_array(int, socket
, usockvec
, 2))
987 #endif /* (defined(CONFIG_X86_64) && !defined(LTTNG_SC_COMPAT)) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
990 * Enumeration of the open flags, as described in the 'open'
991 * system call man page.
993 SC_LTTNG_TRACEPOINT_ENUM(lttng_file_status_flags
,
995 ctf_enum_value("O_RDONLY", O_RDONLY
)
996 ctf_enum_value("O_WRONLY", O_WRONLY
)
997 ctf_enum_value("O_RDWR", O_RDWR
)
998 ctf_enum_value("O_CREAT", O_CREAT
)
999 ctf_enum_value("O_EXCL", O_EXCL
)
1000 ctf_enum_value("O_NOCTTY", O_NOCTTY
)
1001 ctf_enum_value("O_TRUNC", O_TRUNC
)
1002 ctf_enum_value("O_APPEND", O_APPEND
)
1003 ctf_enum_value("O_NONBLOCK", O_NONBLOCK
)
1004 ctf_enum_value("O_DSYNC", O_DSYNC
)
1005 ctf_enum_value("FASYNC", FASYNC
)
1006 ctf_enum_value("O_DIRECT", O_DIRECT
)
1007 ctf_enum_value("O_LARGEFILE", O_LARGEFILE
)
1008 ctf_enum_value("O_DIRECTORY", O_DIRECTORY
)
1009 ctf_enum_value("O_NOFOLLOW", O_NOFOLLOW
)
1010 ctf_enum_value("O_NOATIME", O_NOATIME
)
1011 ctf_enum_value("O_CLOEXEC", O_CLOEXEC
)
1012 ctf_enum_value("O_SYNC", __O_SYNC
)
1013 ctf_enum_value("O_PATH", O_PATH
)
1014 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,11,0))
1015 ctf_enum_value("O_TMPFILE", __O_TMPFILE
)
1016 #endif /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,11,0)) */
1021 * Enumeration of the open flags, as described in the 'open'
1022 * system call man page.
1024 SC_LTTNG_TRACEPOINT_ENUM(lttng_file_mode
,
1026 ctf_enum_value("S_IRWXU", S_IRWXU
)
1027 ctf_enum_value("S_IRUSR", S_IRUSR
)
1028 ctf_enum_value("S_IWUSR", S_IWUSR
)
1029 ctf_enum_value("S_IXUSR", S_IXUSR
)
1030 ctf_enum_value("S_IRWXG", S_IRWXG
)
1031 ctf_enum_value("S_IRGRP", S_IRGRP
)
1032 ctf_enum_value("S_IWGRP", S_IWGRP
)
1033 ctf_enum_value("S_IXGRP", S_IXGRP
)
1034 ctf_enum_value("S_IRWXO", S_IRWXO
)
1035 ctf_enum_value("S_IROTH", S_IROTH
)
1036 ctf_enum_value("S_IWOTH", S_IWOTH
)
1037 ctf_enum_value("S_IXOTH", S_IXOTH
)
1038 ctf_enum_value("S_ISUID", S_ISUID
)
1039 ctf_enum_value("S_ISGID", S_ISGID
)
1040 ctf_enum_value("S_ISVTX", S_ISVTX
)
1044 #define OVERRIDE_32_openat
1045 #define OVERRIDE_64_openat
1046 SC_LTTNG_TRACEPOINT_EVENT(openat
,
1047 TP_PROTO(sc_exit(long ret
,) int dfd
, const char * filename
, int flags
, umode_t mode
),
1048 TP_ARGS(sc_exit(ret
,) dfd
, filename
, flags
, mode
),
1050 sc_exit(ctf_integer(long, ret
, ret
))
1051 sc_in(ctf_integer(int, dfd
, dfd
))
1052 sc_in(ctf_user_string(filename
, filename
))
1053 sc_in(ctf_enum(lttng_file_status_flags
, int, flags
, flags
))
1054 sc_in(ctf_enum(lttng_file_mode
, umode_t
, mode
, mode
))
1058 #define OVERRIDE_32_open
1059 #define OVERRIDE_64_open
1060 SC_LTTNG_TRACEPOINT_EVENT(open
,
1061 TP_PROTO(sc_exit(long ret
,) const char * filename
, int flags
, umode_t mode
),
1062 TP_ARGS(sc_exit(ret
,) filename
, flags
, mode
),
1064 sc_exit(ctf_integer(long, ret
, ret
))
1065 sc_in(ctf_user_string(filename
, filename
))
1066 sc_in(ctf_enum(lttng_file_status_flags
, int, flags
, flags
))
1067 sc_in(ctf_enum(lttng_file_mode
, umode_t
, mode
, mode
))
1071 #endif /* CREATE_SYSCALL_TABLE */