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
))
17 #ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
20 * Clone()'s `flags` field has two parts:
21 * 1. exit signal: the least significant byte of the `unsigned long` is
22 * the signal the kernel must send to the parent process on child
24 * 2. clone options: the remaining bytes of the `unsigned long` is used a
25 * bitwise flag for the clone options.
27 #define CLONE_EXIT_SIGNAL_FLAG_RESERVED_BITS 8
28 #define LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(x) ((x) >> CLONE_EXIT_SIGNAL_FLAG_RESERVED_BITS)
30 SC_LTTNG_TRACEPOINT_ENUM(lttng_clone_exit_signal_flags
,
32 ctf_enum_value("SIGHUP", SIGHUP
)
33 ctf_enum_value("SIGINT", SIGINT
)
34 ctf_enum_value("SIGQUIT", SIGQUIT
)
35 ctf_enum_value("SIGILL", SIGILL
)
36 ctf_enum_value("SIGTRAP", SIGTRAP
)
37 ctf_enum_value("SIGABRT", SIGABRT
)
38 ctf_enum_value("SIGIOT", SIGIOT
)
39 ctf_enum_value("SIGBUS", SIGBUS
)
41 ctf_enum_value("SIGEMT", SIGEMT
)
42 #endif /* #ifdef SIGEMT */
43 ctf_enum_value("SIGFPE", SIGFPE
)
44 ctf_enum_value("SIGKILL", SIGKILL
)
45 ctf_enum_value("SIGUSR1", SIGUSR1
)
46 ctf_enum_value("SIGSEGV", SIGSEGV
)
47 ctf_enum_value("SIGUSR2", SIGUSR2
)
48 ctf_enum_value("SIGPIPE", SIGPIPE
)
49 ctf_enum_value("SIGALRM", SIGALRM
)
50 ctf_enum_value("SIGTERM", SIGTERM
)
52 ctf_enum_value("SIGSTKFLT", SIGSTKFLT
)
53 #endif /* #ifdef SIGSTKFLT */
54 ctf_enum_value("SIGCHLD", SIGCHLD
)
56 ctf_enum_value("SIGCLD", SIGCLD
)
57 #endif /* #ifdef SIGCLD */
58 ctf_enum_value("SIGCONT", SIGCONT
)
59 ctf_enum_value("SIGSTOP", SIGSTOP
)
60 ctf_enum_value("SIGTSTP", SIGTSTP
)
61 ctf_enum_value("SIGTTIN", SIGTTIN
)
62 ctf_enum_value("SIGTTOU", SIGTTOU
)
63 ctf_enum_value("SIGURG", SIGURG
)
64 ctf_enum_value("SIGXCPU", SIGXCPU
)
65 ctf_enum_value("SIGXFSZ", SIGXFSZ
)
66 ctf_enum_value("SIGVTALR", SIGVTALRM
)
67 ctf_enum_value("SIGPROF", SIGPROF
)
68 ctf_enum_value("SIGWINCH", SIGWINCH
)
69 ctf_enum_value("SIGIO", SIGIO
)
70 ctf_enum_value("SIGPOLL", SIGPOLL
)
71 ctf_enum_value("SIGPWR", SIGPWR
)
73 ctf_enum_value("SIGINFO", SIGINFO
)
74 #endif /* #ifdef SIGINFO */
76 ctf_enum_value("SIGLOST", SIGLOST
)
77 #endif /* #ifdef SIGLOST */
78 ctf_enum_value("SIGSYS", SIGSYS
)
80 ctf_enum_value("SIGUNUSED", SIGUNUSED
)
81 #endif /* #ifdef SIGUNUSED */
85 SC_LTTNG_TRACEPOINT_ENUM(lttng_clone_option_flags
,
87 ctf_enum_value("CLONE_CHILD_CLEARTID", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_CHILD_CLEARTID
))
88 ctf_enum_value("CLONE_CHILD_SETTID", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_CHILD_SETTID
))
89 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,5,0))
90 ctf_enum_value("CLONE_CLEAR_SIGHAND", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_CLEAR_SIGHAND
))
91 #endif /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,5,0)) */
92 ctf_enum_value("CLONE_DETACHED", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_DETACHED
))
93 ctf_enum_value("CLONE_FILES", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_FILES
))
94 ctf_enum_value("CLONE_FS", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_FS
))
95 ctf_enum_value("CLONE_IO", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_IO
))
96 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,6,0))
97 ctf_enum_value("CLONE_NEWCGROUP", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_NEWCGROUP
))
98 #endif /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,6,0)) */
99 ctf_enum_value("CLONE_NEWIPC", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_NEWIPC
))
100 ctf_enum_value("CLONE_NEWNET", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_NEWNET
))
101 ctf_enum_value("CLONE_NEWNS", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_NEWNS
))
102 ctf_enum_value("CLONE_NEWPID", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_NEWPID
))
103 ctf_enum_value("CLONE_NEWUSER", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_NEWUSER
))
104 ctf_enum_value("CLONE_NEWUTS", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_NEWUTS
))
105 ctf_enum_value("CLONE_PARENT", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_PARENT
))
106 ctf_enum_value("CLONE_PARENT_SETTID", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_PARENT_SETTID
))
107 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,2,0))
108 ctf_enum_value("CLONE_PIDFD", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_PIDFD
))
109 #endif /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,2,0)) */
110 ctf_enum_value("CLONE_PTRACE", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_PTRACE
))
111 ctf_enum_value("CLONE_SETTLS", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_SETTLS
))
112 ctf_enum_value("CLONE_SIGHAND", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_SIGHAND
))
113 ctf_enum_value("CLONE_SYSVSEM", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_SYSVSEM
))
114 ctf_enum_value("CLONE_THREAD", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_THREAD
))
115 ctf_enum_value("CLONE_UNTRACED", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_UNTRACED
))
116 ctf_enum_value("CLONE_VFORK", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_VFORK
))
117 ctf_enum_value("CLONE_VM", LTTNG_CLONE_OPTIONS_FLAGS_TO_CTF(CLONE_VM
))
121 #define LTTNG_CLONE_FLAGS_EXIT_SIGNAL \
122 lttng_kernel_static_event_field("exit_signal", \
123 lttng_kernel_static_type_enum(&__enum_lttng_clone_exit_signal_flags, \
124 lttng_kernel_static_type_integer(CLONE_EXIT_SIGNAL_FLAG_RESERVED_BITS, \
125 1, 0, __BYTE_ORDER, 16)), \
128 #define LTTNG_CLONE_FLAGS_OPTIONS \
129 lttng_kernel_static_event_field("options", \
130 lttng_kernel_static_type_enum(&__enum_lttng_clone_option_flags, \
131 lttng_kernel_static_type_integer( \
132 sizeof(unsigned long) * CHAR_BIT - CLONE_EXIT_SIGNAL_FLAG_RESERVED_BITS, \
133 1, 0, __BYTE_ORDER, 16)), \
136 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
137 #define LTTNG_CLONE_FLAGS \
138 lttng_kernel_static_event_field_array( \
139 [0] = LTTNG_CLONE_FLAGS_EXIT_SIGNAL, \
140 [1] = LTTNG_CLONE_FLAGS_OPTIONS, \
143 #define LTTNG_CLONE_FLAGS \
144 lttng_kernel_static_event_field_array( \
145 [0] = LTTNG_CLONE_FLAGS_OPTIONS, \
146 [1] = LTTNG_CLONE_FLAGS_EXIT_SIGNAL, \
150 #endif /* CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM */
152 #define OVERRIDE_32_clone
153 #define OVERRIDE_64_clone
154 SC_LTTNG_TRACEPOINT_EVENT(clone
,
155 TP_PROTO(sc_exit(long ret
,) unsigned long clone_flags
, unsigned long newsp
,
156 void __user
*parent_tid
,
157 void __user
*child_tid
),
158 TP_ARGS(sc_exit(ret
,) clone_flags
, newsp
, parent_tid
, child_tid
),
160 sc_exit(ctf_integer(long, ret
, ret
))
162 #ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
165 lttng_kernel_static_type_struct(2, LTTNG_CLONE_FLAGS
, lttng_alignof(unsigned long) * CHAR_BIT
)
169 ctf_integer_type(unsigned long, clone_flags
)
173 ctf_integer_hex(unsigned long, flags
, clone_flags
)
176 sc_in(ctf_integer_hex(unsigned long, newsp
, newsp
))
177 sc_in(ctf_integer_hex(void *, parent_tid
, parent_tid
))
178 sc_in(ctf_integer_hex(void *, child_tid
, child_tid
))
182 /* present in 32, missing in 64 due to old kernel headers */
183 #define OVERRIDE_32_getcpu
184 #define OVERRIDE_64_getcpu
185 SC_LTTNG_TRACEPOINT_EVENT(getcpu
,
186 TP_PROTO(sc_exit(long ret
,) unsigned __user
*cpup
, unsigned __user
*nodep
, void *tcache
),
187 TP_ARGS(sc_exit(ret
,) cpup
, nodep
, tcache
),
189 sc_exit(ctf_integer(long, ret
, ret
))
190 sc_out(ctf_integer_hex(unsigned *, cpup
, cpup
))
191 sc_out(ctf_integer_hex(unsigned *, nodep
, nodep
))
192 sc_inout(ctf_integer_hex(void *, tcache
, tcache
))
197 * Override 'pipe2' to set the output field 'fildes' to an array of 2 integers
198 * instead of the default integer pointer.
200 #define OVERRIDE_32_pipe2
201 #define OVERRIDE_64_pipe2
202 SC_LTTNG_TRACEPOINT_EVENT(pipe2
,
203 TP_PROTO(sc_exit(long ret
,) int * fildes
, int flags
),
204 TP_ARGS(sc_exit(ret
,) fildes
, flags
),
205 TP_FIELDS(sc_exit(ctf_integer(long, ret
, ret
))
206 sc_out(ctf_user_array(int, fildes
, fildes
, 2))
207 sc_in(ctf_integer(int, flags
, flags
))
211 #define LTTNG_SYSCALL_SELECT_locvar \
212 unsigned long *fds_in, *fds_out, *fds_ex; \
213 unsigned long nr_bytes, nr_ulong; \
216 #define LTTNG_SYSCALL_SELECT_code_pre \
220 unsigned int n_in_bytes; \
222 tp_locvar->fds_in = NULL; \
223 tp_locvar->fds_out = NULL; \
224 tp_locvar->fds_ex = NULL; \
225 tp_locvar->overflow = 0; \
235 /* On error or bogus input, don't copy anything. */ \
236 if (n >__FD_SETSIZE) \
239 n_in_bytes = DIV_ROUND_UP((unsigned int) n, BITS_PER_BYTE); \
242 * Limit atomic memory allocation to one page, since n \
243 * is limited to 1024 and the smallest page size on Linux \
244 * is 4k, this should not happen, don't try to make it work. \
246 if (n_in_bytes > PAGE_SIZE) { \
248 /* Inform the user that we did not output everything. */ \
249 tp_locvar->overflow = 1; \
252 tp_locvar->nr_bytes = n_in_bytes; \
253 tp_locvar->nr_ulong = DIV_ROUND_UP(n_in_bytes, \
254 sizeof(unsigned long)); \
258 tp_locvar->fds_in = lttng_tp_mempool_alloc( \
259 tp_locvar->nr_ulong * sizeof(unsigned long)); \
260 if (!tp_locvar->fds_in) \
263 err = lib_ring_buffer_copy_from_user_check_nofault( \
264 tp_locvar->fds_in, inp, \
265 tp_locvar->nr_ulong * sizeof(unsigned long)); \
270 tp_locvar->fds_out = lttng_tp_mempool_alloc( \
271 tp_locvar->nr_ulong * sizeof(unsigned long)); \
272 if (!tp_locvar->fds_out) \
275 err = lib_ring_buffer_copy_from_user_check_nofault( \
276 tp_locvar->fds_out, outp, \
277 tp_locvar->nr_ulong * sizeof(unsigned long)); \
282 tp_locvar->fds_ex = lttng_tp_mempool_alloc( \
283 tp_locvar->nr_ulong * sizeof(unsigned long)); \
284 if (!tp_locvar->fds_ex) \
287 err = lib_ring_buffer_copy_from_user_check_nofault( \
288 tp_locvar->fds_ex, exp, \
289 tp_locvar->nr_ulong * sizeof(unsigned long)); \
296 tp_locvar->nr_bytes = 0; \
297 tp_locvar->nr_ulong = 0; \
298 end: ; /* Label at end of compound statement. */ \
302 #define LTTNG_SYSCALL_SELECT_fds_field_LE(name, input) \
305 lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 10) \
307 _ ## name ## _length, \
310 ctf_integer_type(uint8_t, tp_locvar->nr_bytes) \
313 ctf_integer_type(uint8_t, 0) \
320 lttng_kernel_static_type_sequence(NULL, \
321 lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 16), \
328 unsigned int nr_bytes_out = 0; \
333 for (src = 0; src < tp_locvar->nr_ulong; src++) { \
335 for (dst = 0; dst < sizeof(long); dst++) { \
336 if (nr_bytes_out++ >= tp_locvar->nr_bytes) { \
339 ctf_user_integer_type(uint8_t, \
340 ((uint8_t __user *) (input->fds_bits + src))[dst]); \
347 #define LTTNG_SYSCALL_SELECT_fds_field_BE(name, input) \
350 lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 10) \
352 _ ## name ## _length, \
355 ctf_integer_type(uint8_t, tp_locvar->nr_bytes) \
358 ctf_integer_type(uint8_t, 0) \
365 lttng_kernel_static_type_sequence(NULL, \
366 lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 16), \
372 unsigned int src, nr_bytes_out = 0; \
377 for (src = 0; src < tp_locvar->nr_ulong; src++) { \
379 for (dst = sizeof(long); dst >= 0; dst--) { \
380 if (nr_bytes_out++ >= tp_locvar->nr_bytes) { \
383 ctf_user_integer_type(uint8_t, \
384 ((uint8_t __user *) (input->fds_bits + src))[dst]); \
391 #define LTTNG_SYSCALL_SELECT_code_post \
392 lttng_tp_mempool_free(tp_locvar->fds_in); \
393 lttng_tp_mempool_free(tp_locvar->fds_out); \
394 lttng_tp_mempool_free(tp_locvar->fds_ex);
396 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM)
398 * Instead of extracting the user-space pointers of the 3 fd_set,
399 * extract the bitmask of the FDs in the sets (in, out, ex) in the form
400 * of an array of uint8_t (1024 FDs is the limit in the kernel).
402 #define OVERRIDE_32_select
403 #define OVERRIDE_64_select
404 SC_LTTNG_TRACEPOINT_EVENT_CODE(select
,
405 TP_PROTO(sc_exit(long ret
,) int n
, fd_set __user
*inp
, fd_set __user
*outp
,
406 fd_set __user
*exp
, struct timeval
*tvp
),
407 TP_ARGS(sc_exit(ret
,) n
, inp
, outp
, exp
, tvp
),
409 LTTNG_SYSCALL_SELECT_locvar
412 LTTNG_SYSCALL_SELECT_code_pre
415 sc_exit(ctf_integer(long, ret
, ret
))
416 sc_in(ctf_integer(int, n
, n
))
417 sc_inout(ctf_integer(uint8_t, overflow
, tp_locvar
->overflow
))
418 sc_inout(ctf_integer(struct timeval
*, tvp
, tvp
))
421 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
422 LTTNG_SYSCALL_SELECT_fds_field_LE(readfds
, inp
)
423 LTTNG_SYSCALL_SELECT_fds_field_LE(writefds
, outp
)
424 LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds
, exp
)
426 LTTNG_SYSCALL_SELECT_fds_field_BE(readfds
, inp
)
427 LTTNG_SYSCALL_SELECT_fds_field_BE(writefds
, outp
)
428 LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds
, exp
)
433 LTTNG_SYSCALL_SELECT_code_post
436 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */
438 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
440 * Instead of extracting the user-space pointers of the 3 fd_set,
441 * extract the bitmask of the FDs in the sets (in, out, ex) in the form
442 * of an array of uint8_t (1024 FDs is the limit in the kernel).
444 #define OVERRIDE_32_pselect6
445 #define OVERRIDE_64_pselect6
446 SC_LTTNG_TRACEPOINT_EVENT_CODE(pselect6
,
447 TP_PROTO(sc_exit(long ret
,) int n
, fd_set __user
* inp
, fd_set __user
* outp
,
448 fd_set __user
* exp
, struct timeval __user
* tvp
, void __user
* sig
),
449 TP_ARGS(sc_exit(ret
,) n
, inp
, outp
, exp
, tvp
, sig
),
451 LTTNG_SYSCALL_SELECT_locvar
454 LTTNG_SYSCALL_SELECT_code_pre
457 sc_exit(ctf_integer(long, ret
, ret
))
458 sc_in(ctf_integer(int, n
, n
))
459 sc_inout(ctf_integer(uint8_t, overflow
, tp_locvar
->overflow
))
460 sc_inout(ctf_integer(struct timeval
*, tvp
, tvp
))
461 sc_in(ctf_integer_hex(void *, sig
, sig
))
464 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
465 LTTNG_SYSCALL_SELECT_fds_field_LE(readfds
, inp
)
466 LTTNG_SYSCALL_SELECT_fds_field_LE(writefds
, outp
)
467 LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds
, exp
)
469 LTTNG_SYSCALL_SELECT_fds_field_BE(readfds
, inp
)
470 LTTNG_SYSCALL_SELECT_fds_field_BE(writefds
, outp
)
471 LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds
, exp
)
476 LTTNG_SYSCALL_SELECT_code_post
479 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
481 #if defined(CONFIG_X86_32) || defined(CONFIG_ARM)
483 * Instead of extracting the user-space pointers of the 3 fd_set,
484 * extract the bitmask of the FDs in the sets (in, out, ex) in the form
485 * of an array of uint8_t (1024 FDs is the limit in the kernel).
487 #define OVERRIDE_32_pselect6_time32
488 SC_LTTNG_TRACEPOINT_EVENT_CODE(pselect6_time32
,
489 TP_PROTO(sc_exit(long ret
,) int n
, fd_set __user
* inp
, fd_set __user
* outp
,
490 fd_set __user
* exp
, struct old_timespec32 __user
* tvp
, void __user
* sig
),
491 TP_ARGS(sc_exit(ret
,) n
, inp
, outp
, exp
, tvp
, sig
),
493 LTTNG_SYSCALL_SELECT_locvar
496 LTTNG_SYSCALL_SELECT_code_pre
499 sc_exit(ctf_integer(long, ret
, ret
))
500 sc_in(ctf_integer(int, n
, n
))
501 sc_inout(ctf_integer(uint8_t, overflow
, tp_locvar
->overflow
))
502 sc_inout(ctf_integer(struct old_timespec32
*, tvp
, tvp
))
503 sc_in(ctf_integer_hex(void *, sig
, sig
))
506 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
507 LTTNG_SYSCALL_SELECT_fds_field_LE(readfds
, inp
)
508 LTTNG_SYSCALL_SELECT_fds_field_LE(writefds
, outp
)
509 LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds
, exp
)
511 LTTNG_SYSCALL_SELECT_fds_field_BE(readfds
, inp
)
512 LTTNG_SYSCALL_SELECT_fds_field_BE(writefds
, outp
)
513 LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds
, exp
)
518 LTTNG_SYSCALL_SELECT_code_post
521 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_ARM) */
523 #ifdef LTTNG_CREATE_FIELD_METADATA
524 #ifndef ONCE_LTTNG_TRACE_POLL_H
525 #define ONCE_LTTNG_TRACE_POLL_H
527 #define LTTNG_POLL_NRFLAGS (POLLNVAL + 1)
528 #define POLL_FLAGS_PADDING_SIZE (sizeof(uint8_t) * BITS_PER_BYTE) - \
529 ilog2(LTTNG_POLL_NRFLAGS - 1)
531 #ifndef LTTNG_TRACEPOINT_TYPE_EXTERN
533 * Only extract the values specified by iBCS2 for now.
535 static const struct lttng_kernel_event_field
*lttng_pollfd_flag_fields
[] = {
536 [ilog2(POLLIN
)] = lttng_kernel_static_event_field("POLLIN",
537 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
539 [ilog2(POLLPRI
)] = lttng_kernel_static_event_field("POLLPRI",
540 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
542 [ilog2(POLLOUT
)] = lttng_kernel_static_event_field("POLLOUT",
543 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
545 [ilog2(POLLERR
)] = lttng_kernel_static_event_field("POLLERR",
546 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
548 [ilog2(POLLHUP
)] = lttng_kernel_static_event_field("POLLHUP",
549 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
551 [ilog2(POLLNVAL
)] = lttng_kernel_static_event_field("POLLNVAL",
552 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
554 [ilog2(LTTNG_POLL_NRFLAGS
)] = lttng_kernel_static_event_field("padding",
555 lttng_kernel_static_type_integer(POLL_FLAGS_PADDING_SIZE
, 1, 0, __LITTLE_ENDIAN
, 10),
559 static_assert(((ARRAY_SIZE(lttng_pollfd_flag_fields
) - 1) + POLL_FLAGS_PADDING_SIZE
) == sizeof(uint8_t) * BITS_PER_BYTE
);
561 #endif /* LTTNG_TRACEPOINT_TYPE_EXTERN */
563 LTTNG_TRACEPOINT_TYPE(PARAMS(const struct lttng_kernel_type_struct lttng_pollfd_flag_fields_struct
),
564 PARAMS(lttng_kernel_static_type_struct_init(ARRAY_SIZE(lttng_pollfd_flag_fields
), lttng_pollfd_flag_fields
, 0)))
566 #ifndef LTTNG_TRACEPOINT_TYPE_EXTERN
567 static const struct lttng_kernel_event_field
*lttng_pollfd_fields
[] = {
568 [0] = lttng_kernel_static_event_field("fd", lttng_kernel_static_type_integer_from_type(int, __BYTE_ORDER
, 10),
570 [1] = lttng_kernel_static_event_field("raw_events", lttng_kernel_static_type_integer_from_type(uint16_t, __BYTE_ORDER
, 16),
572 [2] = lttng_kernel_static_event_field("events",
573 (const struct lttng_kernel_type_common
*) <tng_pollfd_flag_fields_struct
,
576 #endif /* LTTNG_TRACEPOINT_TYPE_EXTERN */
578 LTTNG_TRACEPOINT_TYPE(PARAMS(const struct lttng_kernel_type_struct lttng_pollfd_fields_struct
),
579 PARAMS(lttng_kernel_static_type_struct_init(ARRAY_SIZE(lttng_pollfd_fields
), lttng_pollfd_fields
, 0)))
581 #endif /* ONCE_LTTNG_TRACE_POLL_H */
582 #endif /* LTTNG_CREATE_FIELD_METADATA */
584 #define LTTNG_SYSCALL_POLL_locvar \
585 unsigned int fds_length, fds_max_len, alloc_fds; \
586 struct pollfd *fds; \
589 #define LTTNG_SYSCALL_POLL_code_pre \
590 tp_locvar->fds = NULL; \
591 tp_locvar->overflow = 0; \
594 if (nfds > PAGE_SIZE / sizeof(struct pollfd)) { \
595 tp_locvar->fds_length = PAGE_SIZE / sizeof(struct pollfd); \
596 tp_locvar->fds_max_len = PAGE_SIZE / sizeof(struct pollfd); \
597 tp_locvar->overflow = 1; \
599 tp_locvar->fds_length = nfds; \
600 tp_locvar->fds_max_len = nfds; \
602 tp_locvar->alloc_fds = tp_locvar->fds_length * sizeof(struct pollfd); \
605 * On exit, the number of active FDs is determined by ret, \
606 * nfds stays the same as the entry, but we only want to \
607 * output the FDs that are relevant. \
610 if (ret <= 0 || ret > nfds) \
613 if (nfds > PAGE_SIZE / sizeof(struct pollfd)) { \
614 tp_locvar->fds_length = PAGE_SIZE / sizeof(struct pollfd); \
615 tp_locvar->fds_max_len = PAGE_SIZE / sizeof(struct pollfd); \
616 tp_locvar->overflow = 1; \
618 tp_locvar->fds_length = ret; \
619 tp_locvar->fds_max_len = nfds; \
621 tp_locvar->alloc_fds = tp_locvar->fds_max_len * sizeof(struct pollfd); \
626 tp_locvar->fds = lttng_tp_mempool_alloc(tp_locvar->alloc_fds); \
627 if (!tp_locvar->fds) \
629 err = lib_ring_buffer_copy_from_user_check_nofault( \
630 tp_locvar->fds, ufds, tp_locvar->alloc_fds); \
637 tp_locvar->fds_length = 0; \
638 tp_locvar->fds_max_len = 0; \
642 #define LTTNG_SYSCALL_POLL_fds_field \
646 lttng_kernel_static_type_sequence("fds_length", \
647 (const struct lttng_kernel_type_common *) <tng_pollfd_fields_struct, \
655 ctf_align(int) /* Align on largest field in struct. */ \
656 for (i = 0; i < tp_locvar->fds_length; i++) { \
657 ctf_integer_type(int, tp_locvar->fds[i].fd) \
658 ctf_integer_type(short, tp_locvar->fds[i].events) \
659 ctf_integer_bitfield_type(uint8_t, \
660 (uint8_t) tp_locvar->fds[i].events) \
668 lttng_kernel_static_type_sequence("fds_length", \
669 (const struct lttng_kernel_type_common *) <tng_pollfd_fields_struct, \
675 unsigned int i, nr = 0; \
677 ctf_align(int) /* Align on largest field in struct. */ \
679 * Iterate over the complete array, but only output \
680 * "ret" active FDs. \
682 for (i = 0; i < tp_locvar->fds_max_len; i++) { \
683 if (!tp_locvar->fds[i].revents) \
685 if (nr++ >= tp_locvar->fds_length) \
687 ctf_integer_type(int, tp_locvar->fds[i].fd) \
688 ctf_integer_type(short, tp_locvar->fds[i].revents) \
689 ctf_integer_bitfield_type(uint8_t, \
690 (uint8_t) tp_locvar->fds[i].revents) \
693 * If there is a discrepancy between ret and the \
694 * content of revents (e.g. caused by userspace corrupting \
695 * the array from a concurrent thread), we have to output \
696 * zeros to keep the trace readable. \
698 for (i = nr; i < tp_locvar->fds_length; i++) { \
699 ctf_integer_type(int, 0) \
700 ctf_integer_type(short, 0) \
701 ctf_integer_bitfield_type(uint8_t, 0) \
707 #define LTTNG_SYSCALL_POLL_code_post \
708 lttng_tp_mempool_free(tp_locvar->fds);
710 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM)
712 * Instead of printing the pointer address of the poll set, extract all the FDs
713 * and flags from the poll set. For now, only output the standardized
714 * set of events to limit the verbosity of the output, and also extract
715 * the raw value. In the future, moving to CTF2 will allow hiding unset
716 * fields and then allow extracting all the fields.
718 #define OVERRIDE_32_poll
719 #define OVERRIDE_64_poll
720 SC_LTTNG_TRACEPOINT_EVENT_CODE(poll
,
721 TP_PROTO(sc_exit(long ret
,) struct pollfd __user
* ufds
,
722 unsigned int nfds
, int timeout_msecs
),
723 TP_ARGS(sc_exit(ret
,) ufds
, nfds
, timeout_msecs
),
725 LTTNG_SYSCALL_POLL_locvar
728 LTTNG_SYSCALL_POLL_code_pre
731 sc_exit(ctf_integer(long, ret
, ret
))
732 sc_in(ctf_integer(int, timeout_msecs
, timeout_msecs
))
733 sc_inout(ctf_integer(unsigned int, nfds
, nfds
))
734 sc_inout(ctf_integer(unsigned int, fds_length
, tp_locvar
->fds_length
))
735 sc_in(ctf_integer(uint8_t, overflow
, tp_locvar
->overflow
))
736 LTTNG_SYSCALL_POLL_fds_field
739 LTTNG_SYSCALL_POLL_code_post
742 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */
744 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
746 * Instead of printing the pointer address of the poll set, extract all the FDs
747 * and flags from the poll set. For now, only output the standardized
748 * set of events to limit the verbosity of the output, and also extract
749 * the raw value. In the future, moving to CTF2 will allow hiding unset
750 * fields and then allow extracting all the fields.
752 #define OVERRIDE_32_ppoll
753 #define OVERRIDE_64_ppoll
754 SC_LTTNG_TRACEPOINT_EVENT_CODE(ppoll
,
755 TP_PROTO(sc_exit(long ret
,) struct pollfd __user
* ufds
,
756 unsigned int nfds
, struct timespec
* tsp
, const sigset_t
* sigmask
, size_t sigsetsize
),
757 TP_ARGS(sc_exit(ret
,) ufds
, nfds
, tsp
, sigmask
, sigsetsize
),
759 LTTNG_SYSCALL_POLL_locvar
762 LTTNG_SYSCALL_POLL_code_pre
765 sc_exit(ctf_integer(long, ret
, ret
))
766 sc_in(ctf_integer(struct timespec
*, tsp
, tsp
))
767 sc_in(ctf_integer(const sigset_t
*, sigmask
, sigmask
))
768 sc_in(ctf_integer(size_t, sigsetsize
, sigsetsize
))
769 sc_inout(ctf_integer(unsigned int, nfds
, nfds
))
770 sc_inout(ctf_integer(unsigned int, fds_length
, tp_locvar
->fds_length
))
771 sc_inout(ctf_integer(uint8_t, overflow
, tp_locvar
->overflow
))
772 LTTNG_SYSCALL_POLL_fds_field
775 LTTNG_SYSCALL_POLL_code_post
778 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
780 #if defined(CONFIG_X86_32) || defined(CONFIG_ARM)
782 * Instead of printing the pointer address of the poll set, extract all the FDs
783 * and flags from the poll set. For now, only output the standardized
784 * set of events to limit the verbosity of the output, and also extract
785 * the raw value. In the future, moving to CTF2 will allow hiding unset
786 * fields and then allow extracting all the fields.
788 #define OVERRIDE_32_ppoll_time32
789 SC_LTTNG_TRACEPOINT_EVENT_CODE(ppoll_time32
,
790 TP_PROTO(sc_exit(long ret
,) struct pollfd __user
* ufds
,
791 unsigned int nfds
, struct old_timespec32
* tsp
, const sigset_t
* sigmask
, size_t sigsetsize
),
792 TP_ARGS(sc_exit(ret
,) ufds
, nfds
, tsp
, sigmask
, sigsetsize
),
794 LTTNG_SYSCALL_POLL_locvar
797 LTTNG_SYSCALL_POLL_code_pre
800 sc_exit(ctf_integer(long, ret
, ret
))
801 sc_in(ctf_integer(struct old_timespec32
*, tsp
, tsp
))
802 sc_in(ctf_integer(const sigset_t
*, sigmask
, sigmask
))
803 sc_in(ctf_integer(size_t, sigsetsize
, sigsetsize
))
804 sc_inout(ctf_integer(unsigned int, nfds
, nfds
))
805 sc_inout(ctf_integer(unsigned int, fds_length
, tp_locvar
->fds_length
))
806 sc_inout(ctf_integer(uint8_t, overflow
, tp_locvar
->overflow
))
807 LTTNG_SYSCALL_POLL_fds_field
810 LTTNG_SYSCALL_POLL_code_post
813 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_ARM) */
815 #include <linux/eventpoll.h>
817 SC_LTTNG_TRACEPOINT_ENUM(lttng_epoll_op
,
819 ctf_enum_value("EPOLL_CTL_ADD", EPOLL_CTL_ADD
)
820 ctf_enum_value("EPOLL_CTL_DEL", EPOLL_CTL_DEL
)
821 ctf_enum_value("EPOLL_CTL_MOD", EPOLL_CTL_MOD
)
825 #ifdef LTTNG_CREATE_FIELD_METADATA
827 #ifndef ONCE_LTTNG_TRACE_EPOLL_CTL_H
828 #define ONCE_LTTNG_TRACE_EPOLL_CTL_H
830 #define LTTNG_EPOLL_NRFLAGS (POLLHUP + 1)
831 #define EPOLL_FLAGS_PADDING_SIZE (sizeof(uint8_t) * BITS_PER_BYTE) - \
832 ilog2(LTTNG_EPOLL_NRFLAGS - 1)
834 #ifndef LTTNG_TRACEPOINT_TYPE_EXTERN
836 * Only extract the values specified by iBCS2 for now.
838 static const struct lttng_kernel_event_field
*lttng_epoll_ctl_events_fields
[] = {
840 [ilog2(POLLIN
)] = lttng_kernel_static_event_field("EPOLLIN",
841 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
844 [ilog2(POLLPRI
)] = lttng_kernel_static_event_field("EPOLLPRI",
845 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
848 [ilog2(POLLOUT
)] = lttng_kernel_static_event_field("EPOLLOUT",
849 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
852 [ilog2(POLLERR
)] = lttng_kernel_static_event_field("EPOLLERR",
853 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
856 [ilog2(POLLHUP
)] = lttng_kernel_static_event_field("EPOLLHUP",
857 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN
, 10),
859 [ilog2(LTTNG_EPOLL_NRFLAGS
)] = lttng_kernel_static_event_field("padding",
860 lttng_kernel_static_type_integer(EPOLL_FLAGS_PADDING_SIZE
, 1, 0, __LITTLE_ENDIAN
, 10),
863 #endif /* LTTNG_TRACEPOINT_TYPE_EXTERN */
865 LTTNG_TRACEPOINT_TYPE(PARAMS(const struct lttng_kernel_type_struct lttng_epoll_ctl_events_fields_struct
),
866 PARAMS(lttng_kernel_static_type_struct_init(ARRAY_SIZE(lttng_epoll_ctl_events_fields
), lttng_epoll_ctl_events_fields
, 0)))
868 #ifndef LTTNG_TRACEPOINT_TYPE_EXTERN
869 static const struct lttng_kernel_event_field
*lttng_epoll_data_fields
[] = {
870 [0] = lttng_kernel_static_event_field("u64",
871 lttng_kernel_static_type_integer_from_type(uint64_t, __BYTE_ORDER
, 16),
873 [1] = lttng_kernel_static_event_field("fd",
874 lttng_kernel_static_type_integer_from_type(int, __BYTE_ORDER
, 10),
877 #endif /* LTTNG_TRACEPOINT_TYPE_EXTERN */
879 LTTNG_TRACEPOINT_TYPE(PARAMS(const struct lttng_kernel_type_struct lttng_epoll_data_fields_struct
),
880 PARAMS(lttng_kernel_static_type_struct_init(ARRAY_SIZE(lttng_epoll_data_fields
), lttng_epoll_data_fields
, 0)))
882 #ifndef LTTNG_TRACEPOINT_TYPE_EXTERN
883 static const struct lttng_kernel_event_field
*epoll_ctl_fields
[] = {
884 [0] = lttng_kernel_static_event_field("data_union",
885 (const struct lttng_kernel_type_common
*) <tng_epoll_data_fields_struct
,
887 [1] = lttng_kernel_static_event_field("raw_events",
888 lttng_kernel_static_type_integer_from_type(uint32_t, __BYTE_ORDER
, 16),
890 [2] = lttng_kernel_static_event_field("events",
891 (const struct lttng_kernel_type_common
*) <tng_epoll_ctl_events_fields_struct
,
894 #endif /* LTTNG_TRACEPOINT_TYPE_EXTERN */
896 LTTNG_TRACEPOINT_TYPE(PARAMS(const struct lttng_kernel_type_struct epoll_ctl_fields_struct
),
897 PARAMS(lttng_kernel_static_type_struct_init(ARRAY_SIZE(epoll_ctl_fields
), epoll_ctl_fields
, 0)))
899 #endif /* ONCE_LTTNG_TRACE_EPOLL_CTL_H */
900 #endif /* LTTNG_CREATE_FIELD_METADATA */
902 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
903 #define OVERRIDE_32_epoll_ctl
904 #define OVERRIDE_64_epoll_ctl
905 SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_ctl
,
906 TP_PROTO(sc_exit(long ret
,) int epfd
, int op
, int fd
,
907 struct epoll_event __user
* uevent
),
908 TP_ARGS(sc_exit(ret
,) epfd
, op
, fd
, uevent
),
910 struct epoll_event event
;
914 tp_locvar
->err
= lib_ring_buffer_copy_from_user_check_nofault(
915 &tp_locvar
->event
, uevent
, sizeof(struct epoll_event
));
918 sc_exit(ctf_integer(long, ret
, ret
))
919 sc_in(ctf_integer(int, epfd
, epfd
))
920 sc_in(ctf_enum(lttng_epoll_op
, int, op_enum
, op
))
921 sc_in(ctf_integer(int, fd
, fd
))
925 (const struct lttng_kernel_type_common
*) &epoll_ctl_fields_struct
930 if (!tp_locvar
->err
) {
931 ctf_integer_type(uint64_t, tp_locvar
->event
.data
)
932 ctf_integer_type(int, tp_locvar
->event
.data
)
933 ctf_integer_bitfield_type(uint32_t,
934 tp_locvar
->event
.events
)
935 ctf_integer_bitfield_type(uint8_t,
936 (uint8_t) tp_locvar
->event
.events
)
938 ctf_integer_type(uint64_t, 0)
939 ctf_integer_type(int, 0)
940 ctf_integer_bitfield_type(uint32_t, 0)
941 ctf_integer_bitfield_type(uint8_t, 0)
949 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
951 #ifdef LTTNG_CREATE_FIELD_METADATA
952 #ifndef ONCE_LTTNG_TRACE_EPOLL_H
953 #define ONCE_LTTNG_TRACE_EPOLL_H
955 #ifndef LTTNG_TRACEPOINT_TYPE_EXTERN
956 static const struct lttng_kernel_event_field
*lttng_epoll_wait_fields
[] = lttng_kernel_static_event_field_array(
957 [0] = lttng_kernel_static_event_field("data_union",
958 (const struct lttng_kernel_type_common
*) <tng_epoll_data_fields_struct
,
960 [1] = lttng_kernel_static_event_field("raw_events", lttng_kernel_static_type_integer_from_type(uint32_t, __BYTE_ORDER
, 16),
962 [2] = lttng_kernel_static_event_field("events",
963 (const struct lttng_kernel_type_common
*) <tng_epoll_ctl_events_fields_struct
,
967 static_assert(((ARRAY_SIZE(lttng_epoll_ctl_events_fields
) - 1) + EPOLL_FLAGS_PADDING_SIZE
) == sizeof(uint8_t) * BITS_PER_BYTE
);
969 #endif /* LTTNG_TRACEPOINT_TYPE_EXTERN */
971 LTTNG_TRACEPOINT_TYPE(PARAMS(const struct lttng_kernel_type_struct lttng_epoll_wait_fields_struct
),
972 PARAMS(lttng_kernel_static_type_struct_init(ARRAY_SIZE(lttng_epoll_wait_fields
), lttng_epoll_wait_fields
, 0)))
974 #endif /* ONCE_LTTNG_TRACE_EPOLL_H */
975 #endif /* LTTNG_CREATE_FIELD_METADATA */
977 #define LTTNG_SYSCALL_EPOLL_WAIT_locvar \
979 unsigned int fds_length; \
981 struct epoll_event *events; \
984 #define LTTNG_SYSCALL_EPOLL_WAIT_code_pre \
987 unsigned long maxalloc; \
989 tp_locvar->fds_length = 0; \
990 tp_locvar->events = NULL; \
991 tp_locvar->overflow = 0; \
993 if (maxevents <= 0 || ret <= 0 || ret > maxevents) \
996 if (maxevents > PAGE_SIZE / sizeof(struct epoll_event)) { \
997 maxalloc = PAGE_SIZE / sizeof(struct epoll_event); \
999 maxalloc = maxevents; \
1002 if (ret > maxalloc) { \
1003 tp_locvar->fds_length = maxalloc; \
1004 tp_locvar->overflow = 1; \
1006 tp_locvar->fds_length = ret; \
1009 tp_locvar->events = lttng_tp_mempool_alloc( \
1010 maxalloc * sizeof(struct epoll_event)); \
1011 if (!tp_locvar->events) { \
1012 tp_locvar->fds_length = 0; \
1016 err = lib_ring_buffer_copy_from_user_check_nofault( \
1017 tp_locvar->events, uevents, \
1018 maxalloc * sizeof(struct epoll_event)); \
1020 tp_locvar->fds_length = 0; \
1025 #define LTTNG_SYSCALL_EPOLL_WAIT_fds_field \
1028 lttng_kernel_static_type_sequence("fds_length", \
1029 (const struct lttng_kernel_type_common *) <tng_epoll_wait_fields_struct, \
1037 ctf_align(uint64_t) \
1038 for (i = 0; i < tp_locvar->fds_length; i++) { \
1039 ctf_integer_type(uint64_t, tp_locvar->events[i].data) \
1040 ctf_integer_type(int, tp_locvar->events[i].data) \
1041 ctf_integer_bitfield_type(uint32_t, \
1042 tp_locvar->events[i].events) \
1043 ctf_integer_bitfield_type(uint8_t, \
1044 (uint8_t) tp_locvar->events[i].events) \
1049 #define LTTNG_SYSCALL_EPOLL_WAIT_code_post \
1051 lttng_tp_mempool_free(tp_locvar->events); \
1055 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM)
1056 #define OVERRIDE_32_epoll_wait
1057 #define OVERRIDE_64_epoll_wait
1058 SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_wait
,
1059 TP_PROTO(sc_exit(long ret
,) int epfd
, struct epoll_event __user
* uevents
,
1060 int maxevents
, int timeout
),
1061 TP_ARGS(sc_exit(ret
,) epfd
, uevents
, maxevents
, timeout
),
1063 LTTNG_SYSCALL_EPOLL_WAIT_locvar
1066 LTTNG_SYSCALL_EPOLL_WAIT_code_pre
1069 sc_exit(ctf_integer(long, ret
, ret
))
1070 sc_in(ctf_integer(int, epfd
, epfd
))
1071 sc_in(ctf_integer(int, maxevents
, maxevents
))
1072 sc_in(ctf_integer(int, timeout
, timeout
))
1073 sc_out(ctf_integer(unsigned int, fds_length
, tp_locvar
->fds_length
))
1074 sc_out(ctf_integer(uint8_t, overflow
, tp_locvar
->overflow
))
1076 LTTNG_SYSCALL_EPOLL_WAIT_fds_field
1080 LTTNG_SYSCALL_EPOLL_WAIT_code_post
1083 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */
1085 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
1086 #define OVERRIDE_32_epoll_pwait
1087 #define OVERRIDE_64_epoll_pwait
1088 SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_pwait
,
1089 TP_PROTO(sc_exit(long ret
,) int epfd
, struct epoll_event __user
* uevents
,
1090 int maxevents
, int timeout
, const sigset_t __user
* sigmask
, size_t sigsetsize
),
1091 TP_ARGS(sc_exit(ret
,) epfd
, uevents
, maxevents
, timeout
, sigmask
, sigsetsize
),
1093 LTTNG_SYSCALL_EPOLL_WAIT_locvar
1096 LTTNG_SYSCALL_EPOLL_WAIT_code_pre
1099 sc_exit(ctf_integer(long, ret
, ret
))
1100 sc_in(ctf_integer(int, epfd
, epfd
))
1101 sc_in(ctf_integer(int, maxevents
, maxevents
))
1102 sc_in(ctf_integer(int, timeout
, timeout
))
1103 sc_in(ctf_integer_hex(const sigset_t
*, sigmask
, sigmask
))
1104 sc_in(ctf_integer(size_t, sigsetsize
, sigsetsize
))
1105 sc_out(ctf_integer(unsigned int, fds_length
, tp_locvar
->fds_length
))
1106 sc_out(ctf_integer(uint8_t, overflow
, tp_locvar
->overflow
))
1108 LTTNG_SYSCALL_EPOLL_WAIT_fds_field
1112 LTTNG_SYSCALL_EPOLL_WAIT_code_post
1115 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
1117 #if (defined(CONFIG_X86_64) && !defined(LTTNG_SC_COMPAT)) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
1118 #define OVERRIDE_32_socketpair
1119 #define OVERRIDE_64_socketpair
1120 SC_LTTNG_TRACEPOINT_EVENT(socketpair
,
1121 TP_PROTO(sc_exit(long ret
,) int family
, int type
, int protocol
, int *usockvec
),
1122 TP_ARGS(sc_exit(ret
,) family
, type
, protocol
, usockvec
),
1124 sc_exit(ctf_integer(long, ret
, ret
))
1125 sc_in(ctf_integer(int, family
, family
))
1126 sc_in(ctf_integer(int, type
, type
))
1127 sc_in(ctf_integer(int, protocol
, protocol
))
1128 sc_out(ctf_user_array(int, socket
, usockvec
, 2))
1131 #endif /* (defined(CONFIG_X86_64) && !defined(LTTNG_SC_COMPAT)) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
1133 #ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
1135 * Enumeration of the open flags, as described in the 'open'
1136 * system call man page.
1138 SC_LTTNG_TRACEPOINT_ENUM(lttng_file_status_flags
,
1140 ctf_enum_value("O_RDONLY", O_RDONLY
)
1141 ctf_enum_value("O_WRONLY", O_WRONLY
)
1142 ctf_enum_value("O_RDWR", O_RDWR
)
1143 ctf_enum_value("O_CREAT", O_CREAT
)
1144 ctf_enum_value("O_EXCL", O_EXCL
)
1145 ctf_enum_value("O_NOCTTY", O_NOCTTY
)
1146 ctf_enum_value("O_TRUNC", O_TRUNC
)
1147 ctf_enum_value("O_APPEND", O_APPEND
)
1148 ctf_enum_value("O_NONBLOCK", O_NONBLOCK
)
1149 ctf_enum_value("O_DSYNC", O_DSYNC
)
1150 ctf_enum_value("FASYNC", FASYNC
)
1151 ctf_enum_value("O_DIRECT", O_DIRECT
)
1152 ctf_enum_value("O_LARGEFILE", O_LARGEFILE
)
1153 ctf_enum_value("O_DIRECTORY", O_DIRECTORY
)
1154 ctf_enum_value("O_NOFOLLOW", O_NOFOLLOW
)
1155 ctf_enum_value("O_NOATIME", O_NOATIME
)
1156 ctf_enum_value("O_CLOEXEC", O_CLOEXEC
)
1157 ctf_enum_value("O_SYNC", __O_SYNC
)
1158 ctf_enum_value("O_PATH", O_PATH
)
1159 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,11,0))
1160 ctf_enum_value("O_TMPFILE", __O_TMPFILE
)
1161 #endif /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,11,0)) */
1166 * Enumeration of the open flags, as described in the 'open'
1167 * system call man page.
1169 SC_LTTNG_TRACEPOINT_ENUM(lttng_file_mode
,
1171 ctf_enum_value("S_IRWXU", S_IRWXU
)
1172 ctf_enum_value("S_IRUSR", S_IRUSR
)
1173 ctf_enum_value("S_IWUSR", S_IWUSR
)
1174 ctf_enum_value("S_IXUSR", S_IXUSR
)
1175 ctf_enum_value("S_IRWXG", S_IRWXG
)
1176 ctf_enum_value("S_IRGRP", S_IRGRP
)
1177 ctf_enum_value("S_IWGRP", S_IWGRP
)
1178 ctf_enum_value("S_IXGRP", S_IXGRP
)
1179 ctf_enum_value("S_IRWXO", S_IRWXO
)
1180 ctf_enum_value("S_IROTH", S_IROTH
)
1181 ctf_enum_value("S_IWOTH", S_IWOTH
)
1182 ctf_enum_value("S_IXOTH", S_IXOTH
)
1183 ctf_enum_value("S_ISUID", S_ISUID
)
1184 ctf_enum_value("S_ISGID", S_ISGID
)
1185 ctf_enum_value("S_ISVTX", S_ISVTX
)
1189 #define OVERRIDE_32_openat
1190 #define OVERRIDE_64_openat
1191 SC_LTTNG_TRACEPOINT_EVENT(openat
,
1192 TP_PROTO(sc_exit(long ret
,) int dfd
, const char * filename
, int flags
, umode_t mode
),
1193 TP_ARGS(sc_exit(ret
,) dfd
, filename
, flags
, mode
),
1195 sc_exit(ctf_integer(long, ret
, ret
))
1196 sc_in(ctf_integer(int, dfd
, dfd
))
1197 sc_in(ctf_user_string(filename
, filename
))
1198 sc_in(ctf_enum(lttng_file_status_flags
, int, flags
, flags
))
1199 sc_in(ctf_enum(lttng_file_mode
, umode_t
, mode
, mode
))
1203 #define OVERRIDE_32_open
1204 #define OVERRIDE_64_open
1205 SC_LTTNG_TRACEPOINT_EVENT(open
,
1206 TP_PROTO(sc_exit(long ret
,) const char * filename
, int flags
, umode_t mode
),
1207 TP_ARGS(sc_exit(ret
,) filename
, flags
, mode
),
1209 sc_exit(ctf_integer(long, ret
, ret
))
1210 sc_in(ctf_user_string(filename
, filename
))
1211 sc_in(ctf_enum(lttng_file_status_flags
, int, flags
, flags
))
1212 sc_in(ctf_enum(lttng_file_mode
, umode_t
, mode
, mode
))
1215 #endif /* CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM */
1217 #endif /* CREATE_SYSCALL_TABLE */