projects / lttng-modules.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fix: net: udp: add IP/port data to the tracepoint udp/udp_fail_queue_rcv_skb (v6.10)
[lttng-modules.git] / include / instrumentation / syscalls / syscalls_pointers_override.h
1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */
2
3 #ifndef CREATE_SYSCALL_TABLE
4
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))
14 )
15 )
16
17 #ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
18
19 /*
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
23 * exit,
24 * 2. clone options: the remaining bytes of the `unsigned long` is used a
25 * bitwise flag for the clone options.
26 */
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)
29
30 SC_LTTNG_TRACEPOINT_ENUM(lttng_clone_exit_signal_flags,
31 TP_ENUM_VALUES(
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)
40 #ifdef SIGEMT
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)
51 #ifdef SIGSTKFLT
52 ctf_enum_value("SIGSTKFLT", SIGSTKFLT)
53 #endif /* #ifdef SIGSTKFLT */
54 ctf_enum_value("SIGCHLD", SIGCHLD)
55 #ifdef SIGCLD
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)
72 #ifdef SIGINFO
73 ctf_enum_value("SIGINFO", SIGINFO)
74 #endif /* #ifdef SIGINFO */
75 #ifdef SIGLOST
76 ctf_enum_value("SIGLOST", SIGLOST)
77 #endif /* #ifdef SIGLOST */
78 ctf_enum_value("SIGSYS", SIGSYS)
79 #ifdef SIGUNUSED
80 ctf_enum_value("SIGUNUSED", SIGUNUSED)
81 #endif /* #ifdef SIGUNUSED */
82 )
83 )
84
85 SC_LTTNG_TRACEPOINT_ENUM(lttng_clone_option_flags,
86 TP_ENUM_VALUES(
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))
118 )
119 )
120
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)), \
126 false, false)
127
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)), \
134 false, false)
135
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, \
141 )
142 #else
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, \
147 )
148 #endif
149
150 #endif /* CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM */
151
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),
159 TP_FIELDS(
160 sc_exit(ctf_integer(long, ret, ret))
161 sc_in(
162 #ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
163 ctf_custom_field(
164 ctf_custom_type(
165 lttng_kernel_static_type_struct(2, LTTNG_CLONE_FLAGS, lttng_alignof(unsigned long) * CHAR_BIT)
166 ),
167 flags,
168 ctf_custom_code(
169 ctf_integer_type(unsigned long, clone_flags)
170 )
171 )
172 #else
173 ctf_integer_hex(unsigned long, flags, clone_flags)
174 #endif
175 )
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))
179 )
180 )
181
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),
188 TP_FIELDS(
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))
193 )
194 )
195
196 #define OVERRIDE_32_pipe2
197 #define OVERRIDE_64_pipe2
198 SC_LTTNG_TRACEPOINT_EVENT(pipe2,
199 TP_PROTO(sc_exit(long ret,) int * fildes, int flags),
200 TP_ARGS(sc_exit(ret,) fildes, flags),
201 TP_FIELDS(sc_exit(ctf_integer(long, ret, ret))
202 sc_out(ctf_user_array(int, fildes, fildes, 2))
203 sc_in(ctf_integer(int, flags, flags))
204 )
205 )
206
207 #define LTTNG_SYSCALL_SELECT_locvar \
208 unsigned long *fds_in, *fds_out, *fds_ex; \
209 unsigned long nr_bytes, nr_ulong; \
210 uint8_t overflow;
211
212 #define LTTNG_SYSCALL_SELECT_code_pre \
213 sc_inout( \
214 { \
215 int err; \
216 unsigned int n_in_bytes; \
217 \
218 tp_locvar->fds_in = NULL; \
219 tp_locvar->fds_out = NULL; \
220 tp_locvar->fds_ex = NULL; \
221 tp_locvar->overflow = 0; \
222 \
223 sc_out( \
224 if (ret <= 0) \
225 goto error; \
226 ) \
227 \
228 if (n <= 0) \
229 goto error; \
230 \
231 /* On error or bogus input, don't copy anything. */ \
232 if (n >__FD_SETSIZE) \
233 goto error; \
234 \
235 n_in_bytes = DIV_ROUND_UP((unsigned int) n, BITS_PER_BYTE); \
236 \
237 /* \
238 * Limit atomic memory allocation to one page, since n \
239 * is limited to 1024 and the smallest page size on Linux \
240 * is 4k, this should not happen, don't try to make it work. \
241 */ \
242 if (n_in_bytes > PAGE_SIZE) { \
243 WARN_ON_ONCE(1); \
244 /* Inform the user that we did not output everything. */ \
245 tp_locvar->overflow = 1; \
246 goto error; \
247 } else { \
248 tp_locvar->nr_bytes = n_in_bytes; \
249 tp_locvar->nr_ulong = DIV_ROUND_UP(n_in_bytes, \
250 sizeof(unsigned long)); \
251 } \
252 \
253 if (inp) { \
254 tp_locvar->fds_in = lttng_tp_mempool_alloc( \
255 tp_locvar->nr_ulong * sizeof(unsigned long)); \
256 if (!tp_locvar->fds_in) \
257 goto error; \
258 \
259 err = lib_ring_buffer_copy_from_user_check_nofault( \
260 tp_locvar->fds_in, inp, \
261 tp_locvar->nr_ulong * sizeof(unsigned long)); \
262 if (err != 0) \
263 goto error; \
264 } \
265 if (outp) { \
266 tp_locvar->fds_out = lttng_tp_mempool_alloc( \
267 tp_locvar->nr_ulong * sizeof(unsigned long)); \
268 if (!tp_locvar->fds_out) \
269 goto error; \
270 \
271 err = lib_ring_buffer_copy_from_user_check_nofault( \
272 tp_locvar->fds_out, outp, \
273 tp_locvar->nr_ulong * sizeof(unsigned long)); \
274 if (err != 0) \
275 goto error; \
276 } \
277 if (exp) { \
278 tp_locvar->fds_ex = lttng_tp_mempool_alloc( \
279 tp_locvar->nr_ulong * sizeof(unsigned long)); \
280 if (!tp_locvar->fds_ex) \
281 goto error; \
282 \
283 err = lib_ring_buffer_copy_from_user_check_nofault( \
284 tp_locvar->fds_ex, exp, \
285 tp_locvar->nr_ulong * sizeof(unsigned long)); \
286 if (err != 0) \
287 goto error; \
288 } \
289 goto end; \
290 \
291 error: \
292 tp_locvar->nr_bytes = 0; \
293 tp_locvar->nr_ulong = 0; \
294 end: ; /* Label at end of compound statement. */ \
295 } \
296 )
297
298 #define LTTNG_SYSCALL_SELECT_fds_field_LE(name, input) \
299 ctf_custom_field( \
300 ctf_custom_type( \
301 lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 10) \
302 ), \
303 _ ## name ## _length, \
304 ctf_custom_code( \
305 if (input) { \
306 ctf_integer_type(uint8_t, tp_locvar->nr_bytes) \
307 ctf_align(uint8_t) \
308 } else { \
309 ctf_integer_type(uint8_t, 0) \
310 ctf_align(uint8_t) \
311 } \
312 ) \
313 ) \
314 ctf_custom_field( \
315 ctf_custom_type( \
316 lttng_kernel_static_type_sequence(NULL, \
317 lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 16), \
318 0, \
319 none) \
320 ), \
321 name, \
322 ctf_custom_code( \
323 unsigned int src; \
324 unsigned int nr_bytes_out = 0; \
325 \
326 if (!input) \
327 goto skip_##name; \
328 \
329 for (src = 0; src < tp_locvar->nr_ulong; src++) { \
330 int dst; \
331 for (dst = 0; dst < sizeof(long); dst++) { \
332 if (nr_bytes_out++ >= tp_locvar->nr_bytes) { \
333 goto skip_##name; \
334 } \
335 ctf_user_integer_type(uint8_t, \
336 ((uint8_t __user *) (input->fds_bits + src))[dst]); \
337 } \
338 } \
339 skip_##name: ; \
340 ) \
341 )
342
343 #define LTTNG_SYSCALL_SELECT_fds_field_BE(name, input) \
344 ctf_custom_field( \
345 ctf_custom_type( \
346 lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 10) \
347 ), \
348 _ ## name ## _length, \
349 ctf_custom_code( \
350 if (input) { \
351 ctf_integer_type(uint8_t, tp_locvar->nr_bytes) \
352 ctf_align(uint8_t) \
353 } else { \
354 ctf_integer_type(uint8_t, 0) \
355 ctf_align(uint8_t) \
356 } \
357 ) \
358 ) \
359 ctf_custom_field( \
360 ctf_custom_type( \
361 lttng_kernel_static_type_sequence(NULL, \
362 lttng_kernel_static_type_integer_from_type(uint8_t, __BYTE_ORDER, 16), \
363 0, \
364 none) \
365 ), \
366 name, \
367 ctf_custom_code( \
368 unsigned int src, nr_bytes_out = 0; \
369 \
370 if (!input) \
371 goto skip_##name; \
372 \
373 for (src = 0; src < tp_locvar->nr_ulong; src++) { \
374 int dst; \
375 for (dst = sizeof(long); dst >= 0; dst--) { \
376 if (nr_bytes_out++ >= tp_locvar->nr_bytes) { \
377 goto skip_##name; \
378 } \
379 ctf_user_integer_type(uint8_t, \
380 ((uint8_t __user *) (input->fds_bits + src))[dst]); \
381 } \
382 } \
383 skip_##name: ; \
384 ) \
385 )
386
387 #define LTTNG_SYSCALL_SELECT_code_post \
388 lttng_tp_mempool_free(tp_locvar->fds_in); \
389 lttng_tp_mempool_free(tp_locvar->fds_out); \
390 lttng_tp_mempool_free(tp_locvar->fds_ex);
391
392 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM)
393 /*
394 * Instead of extracting the user-space pointers of the 3 fd_set,
395 * extract the bitmask of the FDs in the sets (in, out, ex) in the form
396 * of an array of uint8_t (1024 FDs is the limit in the kernel).
397 */
398 #define OVERRIDE_32_select
399 #define OVERRIDE_64_select
400 SC_LTTNG_TRACEPOINT_EVENT_CODE(select,
401 TP_PROTO(sc_exit(long ret,) int n, fd_set __user *inp, fd_set __user *outp,
402 fd_set __user *exp, struct timeval *tvp),
403 TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp),
404 TP_locvar(
405 LTTNG_SYSCALL_SELECT_locvar
406 ),
407 TP_code_pre(
408 LTTNG_SYSCALL_SELECT_code_pre
409 ),
410 TP_FIELDS(
411 sc_exit(ctf_integer(long, ret, ret))
412 sc_in(ctf_integer(int, n, n))
413 sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow))
414 sc_inout(ctf_integer(struct timeval *, tvp, tvp))
415
416 sc_inout(
417 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
418 LTTNG_SYSCALL_SELECT_fds_field_LE(readfds, inp)
419 LTTNG_SYSCALL_SELECT_fds_field_LE(writefds, outp)
420 LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds, exp)
421 #else
422 LTTNG_SYSCALL_SELECT_fds_field_BE(readfds, inp)
423 LTTNG_SYSCALL_SELECT_fds_field_BE(writefds, outp)
424 LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds, exp)
425 #endif
426 )
427 ),
428 TP_code_post(
429 LTTNG_SYSCALL_SELECT_code_post
430 )
431 )
432 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */
433
434 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
435 /*
436 * Instead of extracting the user-space pointers of the 3 fd_set,
437 * extract the bitmask of the FDs in the sets (in, out, ex) in the form
438 * of an array of uint8_t (1024 FDs is the limit in the kernel).
439 */
440 #define OVERRIDE_32_pselect6
441 #define OVERRIDE_64_pselect6
442 SC_LTTNG_TRACEPOINT_EVENT_CODE(pselect6,
443 TP_PROTO(sc_exit(long ret,) int n, fd_set __user * inp, fd_set __user * outp,
444 fd_set __user * exp, struct timeval __user * tvp, void __user * sig),
445 TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp, sig),
446 TP_locvar(
447 LTTNG_SYSCALL_SELECT_locvar
448 ),
449 TP_code_pre(
450 LTTNG_SYSCALL_SELECT_code_pre
451 ),
452 TP_FIELDS(
453 sc_exit(ctf_integer(long, ret, ret))
454 sc_in(ctf_integer(int, n, n))
455 sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow))
456 sc_inout(ctf_integer(struct timeval *, tvp, tvp))
457 sc_in(ctf_integer_hex(void *, sig, sig))
458
459 sc_inout(
460 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
461 LTTNG_SYSCALL_SELECT_fds_field_LE(readfds, inp)
462 LTTNG_SYSCALL_SELECT_fds_field_LE(writefds, outp)
463 LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds, exp)
464 #else
465 LTTNG_SYSCALL_SELECT_fds_field_BE(readfds, inp)
466 LTTNG_SYSCALL_SELECT_fds_field_BE(writefds, outp)
467 LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds, exp)
468 #endif
469 )
470 ),
471 TP_code_post(
472 LTTNG_SYSCALL_SELECT_code_post
473 )
474 )
475 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
476
477 #if defined(CONFIG_X86_32) || defined(CONFIG_ARM)
478 /*
479 * Instead of extracting the user-space pointers of the 3 fd_set,
480 * extract the bitmask of the FDs in the sets (in, out, ex) in the form
481 * of an array of uint8_t (1024 FDs is the limit in the kernel).
482 */
483 #define OVERRIDE_32_pselect6_time32
484 SC_LTTNG_TRACEPOINT_EVENT_CODE(pselect6_time32,
485 TP_PROTO(sc_exit(long ret,) int n, fd_set __user * inp, fd_set __user * outp,
486 fd_set __user * exp, struct old_timespec32 __user * tvp, void __user * sig),
487 TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp, sig),
488 TP_locvar(
489 LTTNG_SYSCALL_SELECT_locvar
490 ),
491 TP_code_pre(
492 LTTNG_SYSCALL_SELECT_code_pre
493 ),
494 TP_FIELDS(
495 sc_exit(ctf_integer(long, ret, ret))
496 sc_in(ctf_integer(int, n, n))
497 sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow))
498 sc_inout(ctf_integer(struct old_timespec32 *, tvp, tvp))
499 sc_in(ctf_integer_hex(void *, sig, sig))
500
501 sc_inout(
502 #if (__BYTE_ORDER == __LITTLE_ENDIAN)
503 LTTNG_SYSCALL_SELECT_fds_field_LE(readfds, inp)
504 LTTNG_SYSCALL_SELECT_fds_field_LE(writefds, outp)
505 LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds, exp)
506 #else
507 LTTNG_SYSCALL_SELECT_fds_field_BE(readfds, inp)
508 LTTNG_SYSCALL_SELECT_fds_field_BE(writefds, outp)
509 LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds, exp)
510 #endif
511 )
512 ),
513 TP_code_post(
514 LTTNG_SYSCALL_SELECT_code_post
515 )
516 )
517 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_ARM) */
518
519 #ifdef LTTNG_CREATE_FIELD_METADATA
520 #ifndef ONCE_LTTNG_TRACE_POLL_H
521 #define ONCE_LTTNG_TRACE_POLL_H
522
523 #define LTTNG_POLL_NRFLAGS (POLLNVAL + 1)
524 #define POLL_FLAGS_PADDING_SIZE (sizeof(uint8_t) * BITS_PER_BYTE) - \
525 ilog2(LTTNG_POLL_NRFLAGS - 1)
526
527 #ifndef LTTNG_TRACEPOINT_TYPE_EXTERN
528 /*
529 * Only extract the values specified by iBCS2 for now.
530 */
531 static const struct lttng_kernel_event_field *lttng_pollfd_flag_fields[] = {
532 [ilog2(POLLIN)] = lttng_kernel_static_event_field("POLLIN",
533 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN, 10),
534 false, false),
535 [ilog2(POLLPRI)] = lttng_kernel_static_event_field("POLLPRI",
536 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN, 10),
537 false, false),
538 [ilog2(POLLOUT)] = lttng_kernel_static_event_field("POLLOUT",
539 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN, 10),
540 false, false),
541 [ilog2(POLLERR)] = lttng_kernel_static_event_field("POLLERR",
542 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN, 10),
543 false, false),
544 [ilog2(POLLHUP)] = lttng_kernel_static_event_field("POLLHUP",
545 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN, 10),
546 false, false),
547 [ilog2(POLLNVAL)] = lttng_kernel_static_event_field("POLLNVAL",
548 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN, 10),
549 false, false),
550 [ilog2(LTTNG_POLL_NRFLAGS)] = lttng_kernel_static_event_field("padding",
551 lttng_kernel_static_type_integer(POLL_FLAGS_PADDING_SIZE, 1, 0, __LITTLE_ENDIAN, 10),
552 false, false),
553 };
554
555 static_assert(((ARRAY_SIZE(lttng_pollfd_flag_fields) - 1) + POLL_FLAGS_PADDING_SIZE) == sizeof(uint8_t) * BITS_PER_BYTE);
556
557 #endif /* LTTNG_TRACEPOINT_TYPE_EXTERN */
558
559 LTTNG_TRACEPOINT_TYPE(PARAMS(const struct lttng_kernel_type_struct lttng_pollfd_flag_fields_struct),
560 PARAMS(lttng_kernel_static_type_struct_init(ARRAY_SIZE(lttng_pollfd_flag_fields), lttng_pollfd_flag_fields, 0)))
561
562 #ifndef LTTNG_TRACEPOINT_TYPE_EXTERN
563 static const struct lttng_kernel_event_field *lttng_pollfd_fields[] = {
564 [0] = lttng_kernel_static_event_field("fd", lttng_kernel_static_type_integer_from_type(int, __BYTE_ORDER, 10),
565 false, false),
566 [1] = lttng_kernel_static_event_field("raw_events", lttng_kernel_static_type_integer_from_type(uint16_t, __BYTE_ORDER, 16),
567 false, false),
568 [2] = lttng_kernel_static_event_field("events",
569 (const struct lttng_kernel_type_common *) &lttng_pollfd_flag_fields_struct,
570 false, false),
571 };
572 #endif /* LTTNG_TRACEPOINT_TYPE_EXTERN */
573
574 LTTNG_TRACEPOINT_TYPE(PARAMS(const struct lttng_kernel_type_struct lttng_pollfd_fields_struct),
575 PARAMS(lttng_kernel_static_type_struct_init(ARRAY_SIZE(lttng_pollfd_fields), lttng_pollfd_fields, 0)))
576
577 #endif /* ONCE_LTTNG_TRACE_POLL_H */
578 #endif /* LTTNG_CREATE_FIELD_METADATA */
579
580 #define LTTNG_SYSCALL_POLL_locvar \
581 unsigned int fds_length, fds_max_len, alloc_fds; \
582 struct pollfd *fds; \
583 uint8_t overflow;
584
585 #define LTTNG_SYSCALL_POLL_code_pre \
586 tp_locvar->fds = NULL; \
587 tp_locvar->overflow = 0; \
588 \
589 sc_in( \
590 if (nfds > PAGE_SIZE / sizeof(struct pollfd)) { \
591 tp_locvar->fds_length = PAGE_SIZE / sizeof(struct pollfd); \
592 tp_locvar->fds_max_len = PAGE_SIZE / sizeof(struct pollfd); \
593 tp_locvar->overflow = 1; \
594 } else { \
595 tp_locvar->fds_length = nfds; \
596 tp_locvar->fds_max_len = nfds; \
597 } \
598 tp_locvar->alloc_fds = tp_locvar->fds_length * sizeof(struct pollfd); \
599 ) \
600 /* \
601 * On exit, the number of active FDs is determined by ret, \
602 * nfds stays the same as the entry, but we only want to \
603 * output the FDs that are relevant. \
604 */ \
605 sc_out( \
606 if (ret <= 0 || ret > nfds) \
607 goto error; \
608 \
609 if (nfds > PAGE_SIZE / sizeof(struct pollfd)) { \
610 tp_locvar->fds_length = PAGE_SIZE / sizeof(struct pollfd); \
611 tp_locvar->fds_max_len = PAGE_SIZE / sizeof(struct pollfd); \
612 tp_locvar->overflow = 1; \
613 } else { \
614 tp_locvar->fds_length = ret; \
615 tp_locvar->fds_max_len = nfds; \
616 } \
617 tp_locvar->alloc_fds = tp_locvar->fds_max_len * sizeof(struct pollfd); \
618 ) \
619 { \
620 int err; \
621 \
622 tp_locvar->fds = lttng_tp_mempool_alloc(tp_locvar->alloc_fds); \
623 if (!tp_locvar->fds) \
624 goto error; \
625 err = lib_ring_buffer_copy_from_user_check_nofault( \
626 tp_locvar->fds, ufds, tp_locvar->alloc_fds); \
627 if (err != 0) \
628 goto error; \
629 } \
630 goto end; \
631 \
632 error: \
633 tp_locvar->fds_length = 0; \
634 tp_locvar->fds_max_len = 0; \
635 end: \
636 ;
637
638 #define LTTNG_SYSCALL_POLL_fds_field \
639 sc_in( \
640 ctf_custom_field( \
641 ctf_custom_type( \
642 lttng_kernel_static_type_sequence("fds_length", \
643 (const struct lttng_kernel_type_common *) &lttng_pollfd_fields_struct, \
644 0, \
645 none) \
646 ), \
647 fds, \
648 ctf_custom_code( \
649 uint32_t i; \
650 \
651 ctf_align(int) /* Align on largest field in struct. */ \
652 for (i = 0; i < tp_locvar->fds_length; i++) { \
653 ctf_integer_type(int, tp_locvar->fds[i].fd) \
654 ctf_integer_type(short, tp_locvar->fds[i].events) \
655 ctf_integer_bitfield_type(uint8_t, \
656 (uint8_t) tp_locvar->fds[i].events) \
657 } \
658 ) \
659 ) \
660 ) \
661 sc_out( \
662 ctf_custom_field( \
663 ctf_custom_type( \
664 lttng_kernel_static_type_sequence("fds_length", \
665 (const struct lttng_kernel_type_common *) &lttng_pollfd_fields_struct, \
666 0, \
667 none) \
668 ), \
669 fds, \
670 ctf_custom_code( \
671 unsigned int i, nr = 0; \
672 \
673 ctf_align(int) /* Align on largest field in struct. */ \
674 /* \
675 * Iterate over the complete array, but only output \
676 * "ret" active FDs. \
677 */ \
678 for (i = 0; i < tp_locvar->fds_max_len; i++) { \
679 if (!tp_locvar->fds[i].revents) \
680 continue; \
681 if (nr++ >= tp_locvar->fds_length) \
682 break; \
683 ctf_integer_type(int, tp_locvar->fds[i].fd) \
684 ctf_integer_type(short, tp_locvar->fds[i].revents) \
685 ctf_integer_bitfield_type(uint8_t, \
686 (uint8_t) tp_locvar->fds[i].revents) \
687 } \
688 /* \
689 * If there is a discrepancy between ret and the \
690 * content of revents (e.g. caused by userspace corrupting \
691 * the array from a concurrent thread), we have to output \
692 * zeros to keep the trace readable. \
693 */ \
694 for (i = nr; i < tp_locvar->fds_length; i++) { \
695 ctf_integer_type(int, 0) \
696 ctf_integer_type(short, 0) \
697 ctf_integer_bitfield_type(uint8_t, 0) \
698 } \
699 ) \
700 ) \
701 )
702
703 #define LTTNG_SYSCALL_POLL_code_post \
704 lttng_tp_mempool_free(tp_locvar->fds);
705
706 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM)
707 /*
708 * Instead of printing the pointer address of the poll set, extract all the FDs
709 * and flags from the poll set. For now, only output the standardized
710 * set of events to limit the verbosity of the output, and also extract
711 * the raw value. In the future, moving to CTF2 will allow hiding unset
712 * fields and then allow extracting all the fields.
713 */
714 #define OVERRIDE_32_poll
715 #define OVERRIDE_64_poll
716 SC_LTTNG_TRACEPOINT_EVENT_CODE(poll,
717 TP_PROTO(sc_exit(long ret,) struct pollfd __user * ufds,
718 unsigned int nfds, int timeout_msecs),
719 TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs),
720 TP_locvar(
721 LTTNG_SYSCALL_POLL_locvar
722 ),
723 TP_code_pre(
724 LTTNG_SYSCALL_POLL_code_pre
725 ),
726 TP_FIELDS(
727 sc_exit(ctf_integer(long, ret, ret))
728 sc_in(ctf_integer(int, timeout_msecs, timeout_msecs))
729 sc_inout(ctf_integer(unsigned int, nfds, nfds))
730 sc_inout(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length))
731 sc_in(ctf_integer(uint8_t, overflow, tp_locvar->overflow))
732 LTTNG_SYSCALL_POLL_fds_field
733 ),
734 TP_code_post(
735 LTTNG_SYSCALL_POLL_code_post
736 )
737 )
738 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */
739
740 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
741 /*
742 * Instead of printing the pointer address of the poll set, extract all the FDs
743 * and flags from the poll set. For now, only output the standardized
744 * set of events to limit the verbosity of the output, and also extract
745 * the raw value. In the future, moving to CTF2 will allow hiding unset
746 * fields and then allow extracting all the fields.
747 */
748 #define OVERRIDE_32_ppoll
749 #define OVERRIDE_64_ppoll
750 SC_LTTNG_TRACEPOINT_EVENT_CODE(ppoll,
751 TP_PROTO(sc_exit(long ret,) struct pollfd __user * ufds,
752 unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize),
753 TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize),
754 TP_locvar(
755 LTTNG_SYSCALL_POLL_locvar
756 ),
757 TP_code_pre(
758 LTTNG_SYSCALL_POLL_code_pre
759 ),
760 TP_FIELDS(
761 sc_exit(ctf_integer(long, ret, ret))
762 sc_in(ctf_integer(struct timespec *, tsp, tsp))
763 sc_in(ctf_integer(const sigset_t *, sigmask, sigmask))
764 sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))
765 sc_inout(ctf_integer(unsigned int, nfds, nfds))
766 sc_inout(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length))
767 sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow))
768 LTTNG_SYSCALL_POLL_fds_field
769 ),
770 TP_code_post(
771 LTTNG_SYSCALL_POLL_code_post
772 )
773 )
774 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
775
776 #if defined(CONFIG_X86_32) || defined(CONFIG_ARM)
777 /*
778 * Instead of printing the pointer address of the poll set, extract all the FDs
779 * and flags from the poll set. For now, only output the standardized
780 * set of events to limit the verbosity of the output, and also extract
781 * the raw value. In the future, moving to CTF2 will allow hiding unset
782 * fields and then allow extracting all the fields.
783 */
784 #define OVERRIDE_32_ppoll_time32
785 SC_LTTNG_TRACEPOINT_EVENT_CODE(ppoll_time32,
786 TP_PROTO(sc_exit(long ret,) struct pollfd __user * ufds,
787 unsigned int nfds, struct old_timespec32 * tsp, const sigset_t * sigmask, size_t sigsetsize),
788 TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize),
789 TP_locvar(
790 LTTNG_SYSCALL_POLL_locvar
791 ),
792 TP_code_pre(
793 LTTNG_SYSCALL_POLL_code_pre
794 ),
795 TP_FIELDS(
796 sc_exit(ctf_integer(long, ret, ret))
797 sc_in(ctf_integer(struct old_timespec32 *, tsp, tsp))
798 sc_in(ctf_integer(const sigset_t *, sigmask, sigmask))
799 sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))
800 sc_inout(ctf_integer(unsigned int, nfds, nfds))
801 sc_inout(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length))
802 sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow))
803 LTTNG_SYSCALL_POLL_fds_field
804 ),
805 TP_code_post(
806 LTTNG_SYSCALL_POLL_code_post
807 )
808 )
809 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_ARM) */
810
811 #include <linux/eventpoll.h>
812
813 SC_LTTNG_TRACEPOINT_ENUM(lttng_epoll_op,
814 TP_ENUM_VALUES(
815 ctf_enum_value("EPOLL_CTL_ADD", EPOLL_CTL_ADD)
816 ctf_enum_value("EPOLL_CTL_DEL", EPOLL_CTL_DEL)
817 ctf_enum_value("EPOLL_CTL_MOD", EPOLL_CTL_MOD)
818 )
819 )
820
821 #ifdef LTTNG_CREATE_FIELD_METADATA
822
823 #ifndef ONCE_LTTNG_TRACE_EPOLL_CTL_H
824 #define ONCE_LTTNG_TRACE_EPOLL_CTL_H
825
826 #define LTTNG_EPOLL_NRFLAGS (POLLHUP + 1)
827 #define EPOLL_FLAGS_PADDING_SIZE (sizeof(uint8_t) * BITS_PER_BYTE) - \
828 ilog2(LTTNG_EPOLL_NRFLAGS - 1)
829
830 #ifndef LTTNG_TRACEPOINT_TYPE_EXTERN
831 /*
832 * Only extract the values specified by iBCS2 for now.
833 */
834 static const struct lttng_kernel_event_field *lttng_epoll_ctl_events_fields[] = {
835 /* 0x0001 */
836 [ilog2(POLLIN)] = lttng_kernel_static_event_field("EPOLLIN",
837 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN, 10),
838 false, false),
839 /* 0x0002 */
840 [ilog2(POLLPRI)] = lttng_kernel_static_event_field("EPOLLPRI",
841 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN, 10),
842 false, false),
843 /* 0x0004 */
844 [ilog2(POLLOUT)] = lttng_kernel_static_event_field("EPOLLOUT",
845 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN, 10),
846 false, false),
847 /* 0x0008 */
848 [ilog2(POLLERR)] = lttng_kernel_static_event_field("EPOLLERR",
849 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN, 10),
850 false, false),
851 /* 0x0010 */
852 [ilog2(POLLHUP)] = lttng_kernel_static_event_field("EPOLLHUP",
853 lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN, 10),
854 false, false),
855 [ilog2(LTTNG_EPOLL_NRFLAGS)] = lttng_kernel_static_event_field("padding",
856 lttng_kernel_static_type_integer(EPOLL_FLAGS_PADDING_SIZE, 1, 0, __LITTLE_ENDIAN, 10),
857 false, false),
858 };
859 #endif /* LTTNG_TRACEPOINT_TYPE_EXTERN */
860
861 LTTNG_TRACEPOINT_TYPE(PARAMS(const struct lttng_kernel_type_struct lttng_epoll_ctl_events_fields_struct),
862 PARAMS(lttng_kernel_static_type_struct_init(ARRAY_SIZE(lttng_epoll_ctl_events_fields), lttng_epoll_ctl_events_fields, 0)))
863
864 #ifndef LTTNG_TRACEPOINT_TYPE_EXTERN
865 static const struct lttng_kernel_event_field *lttng_epoll_data_fields[] = {
866 [0] = lttng_kernel_static_event_field("u64",
867 lttng_kernel_static_type_integer_from_type(uint64_t, __BYTE_ORDER, 16),
868 false, false),
869 [1] = lttng_kernel_static_event_field("fd",
870 lttng_kernel_static_type_integer_from_type(int, __BYTE_ORDER, 10),
871 false, false),
872 };
873 #endif /* LTTNG_TRACEPOINT_TYPE_EXTERN */
874
875 LTTNG_TRACEPOINT_TYPE(PARAMS(const struct lttng_kernel_type_struct lttng_epoll_data_fields_struct),
876 PARAMS(lttng_kernel_static_type_struct_init(ARRAY_SIZE(lttng_epoll_data_fields), lttng_epoll_data_fields, 0)))
877
878 #ifndef LTTNG_TRACEPOINT_TYPE_EXTERN
879 static const struct lttng_kernel_event_field *epoll_ctl_fields[] = {
880 [0] = lttng_kernel_static_event_field("data_union",
881 (const struct lttng_kernel_type_common *) &lttng_epoll_data_fields_struct,
882 false, false),
883 [1] = lttng_kernel_static_event_field("raw_events",
884 lttng_kernel_static_type_integer_from_type(uint32_t, __BYTE_ORDER, 16),
885 false, false),
886 [2] = lttng_kernel_static_event_field("events",
887 (const struct lttng_kernel_type_common *) &lttng_epoll_ctl_events_fields_struct,
888 false, false),
889 };
890 #endif /* LTTNG_TRACEPOINT_TYPE_EXTERN */
891
892 LTTNG_TRACEPOINT_TYPE(PARAMS(const struct lttng_kernel_type_struct epoll_ctl_fields_struct),
893 PARAMS(lttng_kernel_static_type_struct_init(ARRAY_SIZE(epoll_ctl_fields), epoll_ctl_fields, 0)))
894
895 #endif /* ONCE_LTTNG_TRACE_EPOLL_CTL_H */
896 #endif /* LTTNG_CREATE_FIELD_METADATA */
897
898 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
899 #define OVERRIDE_32_epoll_ctl
900 #define OVERRIDE_64_epoll_ctl
901 SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_ctl,
902 TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd,
903 struct epoll_event __user * uevent),
904 TP_ARGS(sc_exit(ret,) epfd, op, fd, uevent),
905 TP_locvar(
906 struct epoll_event event;
907 int err;
908 ),
909 TP_code_pre(
910 tp_locvar->err = lib_ring_buffer_copy_from_user_check_nofault(
911 &tp_locvar->event, uevent, sizeof(struct epoll_event));
912 ),
913 TP_FIELDS(
914 sc_exit(ctf_integer(long, ret, ret))
915 sc_in(ctf_integer(int, epfd, epfd))
916 sc_in(ctf_enum(lttng_epoll_op, int, op_enum, op))
917 sc_in(ctf_integer(int, fd, fd))
918 sc_in(
919 ctf_custom_field(
920 ctf_custom_type(
921 (const struct lttng_kernel_type_common *) &epoll_ctl_fields_struct
922 ),
923 event,
924 ctf_custom_code(
925 ctf_align(uint64_t)
926 if (!tp_locvar->err) {
927 ctf_integer_type(uint64_t, tp_locvar->event.data)
928 ctf_integer_type(int, tp_locvar->event.data)
929 ctf_integer_bitfield_type(uint32_t,
930 tp_locvar->event.events)
931 ctf_integer_bitfield_type(uint8_t,
932 (uint8_t) tp_locvar->event.events)
933 } else {
934 ctf_integer_type(uint64_t, 0)
935 ctf_integer_type(int, 0)
936 ctf_integer_bitfield_type(uint32_t, 0)
937 ctf_integer_bitfield_type(uint8_t, 0)
938 }
939 )
940 )
941 )
942 ),
943 TP_code_post()
944 )
945 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
946
947 #ifdef LTTNG_CREATE_FIELD_METADATA
948 #ifndef ONCE_LTTNG_TRACE_EPOLL_H
949 #define ONCE_LTTNG_TRACE_EPOLL_H
950
951 #ifndef LTTNG_TRACEPOINT_TYPE_EXTERN
952 static const struct lttng_kernel_event_field *lttng_epoll_wait_fields[] = lttng_kernel_static_event_field_array(
953 [0] = lttng_kernel_static_event_field("data_union",
954 (const struct lttng_kernel_type_common *) &lttng_epoll_data_fields_struct,
955 false, false),
956 [1] = lttng_kernel_static_event_field("raw_events", lttng_kernel_static_type_integer_from_type(uint32_t, __BYTE_ORDER, 16),
957 false, false),
958 [2] = lttng_kernel_static_event_field("events",
959 (const struct lttng_kernel_type_common *) &lttng_epoll_ctl_events_fields_struct,
960 false, false),
961 );
962
963 static_assert(((ARRAY_SIZE(lttng_epoll_ctl_events_fields) - 1) + EPOLL_FLAGS_PADDING_SIZE) == sizeof(uint8_t) * BITS_PER_BYTE);
964
965 #endif /* LTTNG_TRACEPOINT_TYPE_EXTERN */
966
967 LTTNG_TRACEPOINT_TYPE(PARAMS(const struct lttng_kernel_type_struct lttng_epoll_wait_fields_struct),
968 PARAMS(lttng_kernel_static_type_struct_init(ARRAY_SIZE(lttng_epoll_wait_fields), lttng_epoll_wait_fields, 0)))
969
970 #endif /* ONCE_LTTNG_TRACE_EPOLL_H */
971 #endif /* LTTNG_CREATE_FIELD_METADATA */
972
973 #define LTTNG_SYSCALL_EPOLL_WAIT_locvar \
974 sc_out( \
975 unsigned int fds_length; \
976 uint8_t overflow; \
977 struct epoll_event *events; \
978 )
979
980 #define LTTNG_SYSCALL_EPOLL_WAIT_code_pre \
981 sc_out({ \
982 int err; \
983 unsigned long maxalloc; \
984 \
985 tp_locvar->fds_length = 0; \
986 tp_locvar->events = NULL; \
987 tp_locvar->overflow = 0; \
988 \
989 if (maxevents <= 0 || ret <= 0 || ret > maxevents) \
990 goto skip_code; \
991 \
992 if (maxevents > PAGE_SIZE / sizeof(struct epoll_event)) { \
993 maxalloc = PAGE_SIZE / sizeof(struct epoll_event); \
994 } else { \
995 maxalloc = maxevents; \
996 } \
997 \
998 if (ret > maxalloc) { \
999 tp_locvar->fds_length = maxalloc; \
1000 tp_locvar->overflow = 1; \
1001 } else { \
1002 tp_locvar->fds_length = ret; \
1003 } \
1004 \
1005 tp_locvar->events = lttng_tp_mempool_alloc( \
1006 maxalloc * sizeof(struct epoll_event)); \
1007 if (!tp_locvar->events) { \
1008 tp_locvar->fds_length = 0; \
1009 goto skip_code; \
1010 } \
1011 \
1012 err = lib_ring_buffer_copy_from_user_check_nofault( \
1013 tp_locvar->events, uevents, \
1014 maxalloc * sizeof(struct epoll_event)); \
1015 if (err != 0) \
1016 tp_locvar->fds_length = 0; \
1017 } \
1018 skip_code: \
1019 )
1020
1021 #define LTTNG_SYSCALL_EPOLL_WAIT_fds_field \
1022 ctf_custom_field( \
1023 ctf_custom_type( \
1024 lttng_kernel_static_type_sequence("fds_length", \
1025 (const struct lttng_kernel_type_common *) &lttng_epoll_wait_fields_struct, \
1026 0, \
1027 none) \
1028 ), \
1029 fds, \
1030 ctf_custom_code( \
1031 uint32_t i; \
1032 \
1033 ctf_align(uint64_t) \
1034 for (i = 0; i < tp_locvar->fds_length; i++) { \
1035 ctf_integer_type(uint64_t, tp_locvar->events[i].data) \
1036 ctf_integer_type(int, tp_locvar->events[i].data) \
1037 ctf_integer_bitfield_type(uint32_t, \
1038 tp_locvar->events[i].events) \
1039 ctf_integer_bitfield_type(uint8_t, \
1040 (uint8_t) tp_locvar->events[i].events) \
1041 } \
1042 ) \
1043 )
1044
1045 #define LTTNG_SYSCALL_EPOLL_WAIT_code_post \
1046 sc_out( \
1047 lttng_tp_mempool_free(tp_locvar->events); \
1048 )
1049
1050
1051 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM)
1052 #define OVERRIDE_32_epoll_wait
1053 #define OVERRIDE_64_epoll_wait
1054 SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_wait,
1055 TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event __user * uevents,
1056 int maxevents, int timeout),
1057 TP_ARGS(sc_exit(ret,) epfd, uevents, maxevents, timeout),
1058 TP_locvar(
1059 LTTNG_SYSCALL_EPOLL_WAIT_locvar
1060 ),
1061 TP_code_pre(
1062 LTTNG_SYSCALL_EPOLL_WAIT_code_pre
1063 ),
1064 TP_FIELDS(
1065 sc_exit(ctf_integer(long, ret, ret))
1066 sc_in(ctf_integer(int, epfd, epfd))
1067 sc_in(ctf_integer(int, maxevents, maxevents))
1068 sc_in(ctf_integer(int, timeout, timeout))
1069 sc_out(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length))
1070 sc_out(ctf_integer(uint8_t, overflow, tp_locvar->overflow))
1071 sc_out(
1072 LTTNG_SYSCALL_EPOLL_WAIT_fds_field
1073 )
1074 ),
1075 TP_code_post(
1076 LTTNG_SYSCALL_EPOLL_WAIT_code_post
1077 )
1078 )
1079 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */
1080
1081 #if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
1082 #define OVERRIDE_32_epoll_pwait
1083 #define OVERRIDE_64_epoll_pwait
1084 SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_pwait,
1085 TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event __user * uevents,
1086 int maxevents, int timeout, const sigset_t __user * sigmask, size_t sigsetsize),
1087 TP_ARGS(sc_exit(ret,) epfd, uevents, maxevents, timeout, sigmask, sigsetsize),
1088 TP_locvar(
1089 LTTNG_SYSCALL_EPOLL_WAIT_locvar
1090 ),
1091 TP_code_pre(
1092 LTTNG_SYSCALL_EPOLL_WAIT_code_pre
1093 ),
1094 TP_FIELDS(
1095 sc_exit(ctf_integer(long, ret, ret))
1096 sc_in(ctf_integer(int, epfd, epfd))
1097 sc_in(ctf_integer(int, maxevents, maxevents))
1098 sc_in(ctf_integer(int, timeout, timeout))
1099 sc_in(ctf_integer_hex(const sigset_t *, sigmask, sigmask))
1100 sc_in(ctf_integer(size_t, sigsetsize, sigsetsize))
1101 sc_out(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length))
1102 sc_out(ctf_integer(uint8_t, overflow, tp_locvar->overflow))
1103 sc_out(
1104 LTTNG_SYSCALL_EPOLL_WAIT_fds_field
1105 )
1106 ),
1107 TP_code_post(
1108 LTTNG_SYSCALL_EPOLL_WAIT_code_post
1109 )
1110 )
1111 #endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
1112
1113 #if (defined(CONFIG_X86_64) && !defined(LTTNG_SC_COMPAT)) || defined(CONFIG_ARM64) || defined(CONFIG_ARM)
1114 #define OVERRIDE_32_socketpair
1115 #define OVERRIDE_64_socketpair
1116 SC_LTTNG_TRACEPOINT_EVENT(socketpair,
1117 TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int *usockvec),
1118 TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec),
1119 TP_FIELDS(
1120 sc_exit(ctf_integer(long, ret, ret))
1121 sc_in(ctf_integer(int, family, family))
1122 sc_in(ctf_integer(int, type, type))
1123 sc_in(ctf_integer(int, protocol, protocol))
1124 sc_out(ctf_user_array(int, socket, usockvec, 2))
1125 )
1126 )
1127 #endif /* (defined(CONFIG_X86_64) && !defined(LTTNG_SC_COMPAT)) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */
1128
1129 #ifdef CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM
1130 /*
1131 * Enumeration of the open flags, as described in the 'open'
1132 * system call man page.
1133 */
1134 SC_LTTNG_TRACEPOINT_ENUM(lttng_file_status_flags,
1135 TP_ENUM_VALUES(
1136 ctf_enum_value("O_RDONLY", O_RDONLY)
1137 ctf_enum_value("O_WRONLY", O_WRONLY)
1138 ctf_enum_value("O_RDWR", O_RDWR)
1139 ctf_enum_value("O_CREAT", O_CREAT)
1140 ctf_enum_value("O_EXCL", O_EXCL)
1141 ctf_enum_value("O_NOCTTY", O_NOCTTY)
1142 ctf_enum_value("O_TRUNC", O_TRUNC)
1143 ctf_enum_value("O_APPEND", O_APPEND)
1144 ctf_enum_value("O_NONBLOCK", O_NONBLOCK)
1145 ctf_enum_value("O_DSYNC", O_DSYNC)
1146 ctf_enum_value("FASYNC", FASYNC)
1147 ctf_enum_value("O_DIRECT", O_DIRECT)
1148 ctf_enum_value("O_LARGEFILE", O_LARGEFILE)
1149 ctf_enum_value("O_DIRECTORY", O_DIRECTORY)
1150 ctf_enum_value("O_NOFOLLOW", O_NOFOLLOW)
1151 ctf_enum_value("O_NOATIME", O_NOATIME)
1152 ctf_enum_value("O_CLOEXEC", O_CLOEXEC)
1153 ctf_enum_value("O_SYNC", __O_SYNC)
1154 ctf_enum_value("O_PATH", O_PATH)
1155 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,11,0))
1156 ctf_enum_value("O_TMPFILE", __O_TMPFILE)
1157 #endif /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,11,0)) */
1158 )
1159 )
1160
1161 /*
1162 * Enumeration of the open flags, as described in the 'open'
1163 * system call man page.
1164 */
1165 SC_LTTNG_TRACEPOINT_ENUM(lttng_file_mode,
1166 TP_ENUM_VALUES(
1167 ctf_enum_value("S_IRWXU", S_IRWXU)
1168 ctf_enum_value("S_IRUSR", S_IRUSR)
1169 ctf_enum_value("S_IWUSR", S_IWUSR)
1170 ctf_enum_value("S_IXUSR", S_IXUSR)
1171 ctf_enum_value("S_IRWXG", S_IRWXG)
1172 ctf_enum_value("S_IRGRP", S_IRGRP)
1173 ctf_enum_value("S_IWGRP", S_IWGRP)
1174 ctf_enum_value("S_IXGRP", S_IXGRP)
1175 ctf_enum_value("S_IRWXO", S_IRWXO)
1176 ctf_enum_value("S_IROTH", S_IROTH)
1177 ctf_enum_value("S_IWOTH", S_IWOTH)
1178 ctf_enum_value("S_IXOTH", S_IXOTH)
1179 ctf_enum_value("S_ISUID", S_ISUID)
1180 ctf_enum_value("S_ISGID", S_ISGID)
1181 ctf_enum_value("S_ISVTX", S_ISVTX)
1182 )
1183 )
1184
1185 #define OVERRIDE_32_openat
1186 #define OVERRIDE_64_openat
1187 SC_LTTNG_TRACEPOINT_EVENT(openat,
1188 TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, umode_t mode),
1189 TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode),
1190 TP_FIELDS(
1191 sc_exit(ctf_integer(long, ret, ret))
1192 sc_in(ctf_integer(int, dfd, dfd))
1193 sc_in(ctf_user_string(filename, filename))
1194 sc_in(ctf_enum(lttng_file_status_flags, int, flags, flags))
1195 sc_in(ctf_enum(lttng_file_mode, umode_t, mode, mode))
1196 )
1197 )
1198
1199 #define OVERRIDE_32_open
1200 #define OVERRIDE_64_open
1201 SC_LTTNG_TRACEPOINT_EVENT(open,
1202 TP_PROTO(sc_exit(long ret,) const char * filename, int flags, umode_t mode),
1203 TP_ARGS(sc_exit(ret,) filename, flags, mode),
1204 TP_FIELDS(
1205 sc_exit(ctf_integer(long, ret, ret))
1206 sc_in(ctf_user_string(filename, filename))
1207 sc_in(ctf_enum(lttng_file_status_flags, int, flags, flags))
1208 sc_in(ctf_enum(lttng_file_mode, umode_t, mode, mode))
1209 )
1210 )
1211 #endif /* CONFIG_LTTNG_EXPERIMENTAL_BITWISE_ENUM */
1212
1213 #endif /* CREATE_SYSCALL_TABLE */
LTTng 2.0/0.x modules
This page took 0.05514 seconds and 5 git commands to generate.