X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=instrumentation%2Fsyscalls%2Fheaders%2Fsyscalls_pointers_override.h;fp=instrumentation%2Fsyscalls%2Fheaders%2Fsyscalls_pointers_override.h;h=0000000000000000000000000000000000000000;hb=7c6d929d62a6e24fb1dbeaee5cd2c8afe77720b7;hp=89f2cd8e61f7a3bdc7f866b1d0637af39d594cbf;hpb=cf77d12083b5092eca8c6f9899ec0892756845aa;p=lttng-modules.git diff --git a/instrumentation/syscalls/headers/syscalls_pointers_override.h b/instrumentation/syscalls/headers/syscalls_pointers_override.h deleted file mode 100644 index 89f2cd8e..00000000 --- a/instrumentation/syscalls/headers/syscalls_pointers_override.h +++ /dev/null @@ -1,1006 +0,0 @@ -/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only) */ - -#ifndef CREATE_SYSCALL_TABLE - -#define OVERRIDE_32_execve -#define OVERRIDE_64_execve -SC_LTTNG_TRACEPOINT_EVENT(execve, - TP_PROTO(sc_exit(long ret,) const char *filename, char *const *argv, char *const *envp), - TP_ARGS(sc_exit(ret,) filename, argv, envp), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_user_string(filename, filename)) - sc_in(ctf_integer_hex(char *const *, argv, argv)) - sc_in(ctf_integer_hex(char *const *, envp, envp)) - ) -) - -#define OVERRIDE_32_clone -#define OVERRIDE_64_clone -SC_LTTNG_TRACEPOINT_EVENT(clone, - TP_PROTO(sc_exit(long ret,) unsigned long clone_flags, unsigned long newsp, - void __user *parent_tid, - void __user *child_tid), - TP_ARGS(sc_exit(ret,) clone_flags, newsp, parent_tid, child_tid), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer_hex(unsigned long, clone_flags, clone_flags)) - sc_in(ctf_integer_hex(unsigned long, newsp, newsp)) - sc_in(ctf_integer_hex(void *, parent_tid, parent_tid)) - sc_in(ctf_integer_hex(void *, child_tid, child_tid)) - ) -) - -/* present in 32, missing in 64 due to old kernel headers */ -#define OVERRIDE_32_getcpu -#define OVERRIDE_64_getcpu -SC_LTTNG_TRACEPOINT_EVENT(getcpu, - TP_PROTO(sc_exit(long ret,) unsigned __user *cpup, unsigned __user *nodep, void *tcache), - TP_ARGS(sc_exit(ret,) cpup, nodep, tcache), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_out(ctf_integer_hex(unsigned *, cpup, cpup)) - sc_out(ctf_integer_hex(unsigned *, nodep, nodep)) - sc_inout(ctf_integer_hex(void *, tcache, tcache)) - ) -) - -#define OVERRIDE_32_pipe2 -#define OVERRIDE_64_pipe2 -SC_LTTNG_TRACEPOINT_EVENT(pipe2, - TP_PROTO(sc_exit(long ret,) int * fildes, int flags), - TP_ARGS(sc_exit(ret,) fildes, flags), - TP_FIELDS(sc_exit(ctf_integer(long, ret, ret)) - sc_out(ctf_user_array(int, fildes, fildes, 2)) - sc_in(ctf_integer(int, flags, flags)) - ) -) - -#define LTTNG_SYSCALL_SELECT_locvar \ - unsigned long *fds_in, *fds_out, *fds_ex; \ - unsigned long nr_bytes, nr_ulong; \ - uint8_t overflow; - -#define LTTNG_SYSCALL_SELECT_code_pre \ - sc_inout( \ - { \ - int err; \ - unsigned int n_in_bytes; \ - \ - tp_locvar->fds_in = NULL; \ - tp_locvar->fds_out = NULL; \ - tp_locvar->fds_ex = NULL; \ - tp_locvar->overflow = 0; \ - \ - sc_out( \ - if (ret <= 0) \ - goto error; \ - ) \ - \ - if (n <= 0) \ - goto error; \ - \ - /* On error or bogus input, don't copy anything. */ \ - if (n >__FD_SETSIZE) \ - goto error; \ - \ - n_in_bytes = DIV_ROUND_UP((unsigned int) n, BITS_PER_BYTE); \ - \ - /* \ - * Limit atomic memory allocation to one page, since n \ - * is limited to 1024 and the smallest page size on Linux \ - * is 4k, this should not happen, don't try to make it work. \ - */ \ - if (n_in_bytes > PAGE_SIZE) { \ - WARN_ON_ONCE(1); \ - /* Inform the user that we did not output everything. */ \ - tp_locvar->overflow = 1; \ - goto error; \ - } else { \ - tp_locvar->nr_bytes = n_in_bytes; \ - tp_locvar->nr_ulong = DIV_ROUND_UP(n_in_bytes, \ - sizeof(unsigned long)); \ - } \ - \ - if (inp) { \ - tp_locvar->fds_in = lttng_tp_mempool_alloc( \ - tp_locvar->nr_ulong * sizeof(unsigned long)); \ - if (!tp_locvar->fds_in) \ - goto error; \ - \ - err = lib_ring_buffer_copy_from_user_check_nofault( \ - tp_locvar->fds_in, inp, \ - tp_locvar->nr_ulong * sizeof(unsigned long)); \ - if (err != 0) \ - goto error; \ - } \ - if (outp) { \ - tp_locvar->fds_out = lttng_tp_mempool_alloc( \ - tp_locvar->nr_ulong * sizeof(unsigned long)); \ - if (!tp_locvar->fds_out) \ - goto error; \ - \ - err = lib_ring_buffer_copy_from_user_check_nofault( \ - tp_locvar->fds_out, outp, \ - tp_locvar->nr_ulong * sizeof(unsigned long)); \ - if (err != 0) \ - goto error; \ - } \ - if (exp) { \ - tp_locvar->fds_ex = lttng_tp_mempool_alloc( \ - tp_locvar->nr_ulong * sizeof(unsigned long)); \ - if (!tp_locvar->fds_ex) \ - goto error; \ - \ - err = lib_ring_buffer_copy_from_user_check_nofault( \ - tp_locvar->fds_ex, exp, \ - tp_locvar->nr_ulong * sizeof(unsigned long)); \ - if (err != 0) \ - goto error; \ - } \ - goto end; \ - \ -error: \ - tp_locvar->nr_bytes = 0; \ - tp_locvar->nr_ulong = 0; \ -end: ; /* Label at end of compound statement. */ \ - } \ - ) - -#define LTTNG_SYSCALL_SELECT_fds_field_LE(name, input) \ - ctf_custom_field( \ - ctf_custom_type( \ - __type_integer(uint8_t, 0, 0, 0, __BYTE_ORDER, 10, none) \ - ), \ - _ ## name ## _length, \ - ctf_custom_code( \ - if (input) { \ - ctf_integer_type(uint8_t, tp_locvar->nr_bytes) \ - ctf_align(uint8_t) \ - } else { \ - ctf_integer_type(uint8_t, 0) \ - ctf_align(uint8_t) \ - } \ - ) \ - ) \ - ctf_custom_field( \ - ctf_custom_type( \ - { \ - .atype = atype_sequence_nestable, \ - .u.sequence_nestable.length_name = "_" #name "_length", \ - .u.sequence_nestable.elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ - __type_integer(uint8_t, 0, 0, 0, __BYTE_ORDER, 16, none)), \ - .u.sequence_nestable.alignment = 0, \ - } \ - ), \ - name, \ - ctf_custom_code( \ - unsigned int src; \ - unsigned int nr_bytes_out = 0; \ - \ - if (!input) \ - goto skip_##name; \ - \ - for (src = 0; src < tp_locvar->nr_ulong; src++) { \ - int dst; \ - for (dst = 0; dst < sizeof(long); dst++) { \ - if (nr_bytes_out++ >= tp_locvar->nr_bytes) { \ - goto skip_##name; \ - } \ - ctf_user_integer_type(uint8_t, \ - ((uint8_t __user *) (input->fds_bits + src))[dst]); \ - } \ - } \ - skip_##name: ; \ - ) \ - ) - -#define LTTNG_SYSCALL_SELECT_fds_field_BE(name, input) \ - ctf_custom_field( \ - ctf_custom_type( \ - __type_integer(uint8_t, 0, 0, 0, __BYTE_ORDER, 10, none) \ - ), \ - _ ## name ## _length, \ - ctf_custom_code( \ - if (input) { \ - ctf_integer_type(uint8_t, tp_locvar->nr_bytes) \ - ctf_align(uint8_t) \ - } else { \ - ctf_integer_type(uint8_t, 0) \ - ctf_align(uint8_t) \ - } \ - ) \ - ) \ - ctf_custom_field( \ - ctf_custom_type( \ - { \ - .atype = atype_sequence_nestable, \ - .u.sequence_nestable.elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ - __type_integer(uint8_t, 0, 0, 0, __BYTE_ORDER, 16, none)), \ - .u.sequence_nestable.alignment = 0, \ - } \ - ), \ - name, \ - ctf_custom_code( \ - unsigned int src, nr_bytes_out = 0; \ - \ - if (!input) \ - goto skip_##name; \ - \ - for (src = 0; src < tp_locvar->nr_ulong; src++) { \ - int dst; \ - for (dst = sizeof(long); dst >= 0; dst--) { \ - if (nr_bytes_out++ >= tp_locvar->nr_bytes) { \ - goto skip_##name; \ - } \ - ctf_user_integer_type(uint8_t, \ - ((uint8_t __user *) (input->fds_bits + src))[dst]); \ - } \ - } \ - skip_##name: ; \ - ) \ - ) - -#define LTTNG_SYSCALL_SELECT_code_post \ - lttng_tp_mempool_free(tp_locvar->fds_in); \ - lttng_tp_mempool_free(tp_locvar->fds_out); \ - lttng_tp_mempool_free(tp_locvar->fds_ex); - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) -#define OVERRIDE_32_select -#define OVERRIDE_64_select -SC_LTTNG_TRACEPOINT_EVENT_CODE(select, - TP_PROTO(sc_exit(long ret,) int n, fd_set __user *inp, fd_set __user *outp, - fd_set __user *exp, struct timeval *tvp), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp), - TP_locvar( - LTTNG_SYSCALL_SELECT_locvar - ), - TP_code_pre( - LTTNG_SYSCALL_SELECT_code_pre - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, n, n)) - sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) - sc_inout(ctf_integer(struct timeval *, tvp, tvp)) - - sc_inout( -#if (__BYTE_ORDER == __LITTLE_ENDIAN) - LTTNG_SYSCALL_SELECT_fds_field_LE(readfds, inp) - LTTNG_SYSCALL_SELECT_fds_field_LE(writefds, outp) - LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds, exp) -#else - LTTNG_SYSCALL_SELECT_fds_field_BE(readfds, inp) - LTTNG_SYSCALL_SELECT_fds_field_BE(writefds, outp) - LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds, exp) -#endif - ) - ), - TP_code_post( - LTTNG_SYSCALL_SELECT_code_post - ) -) -#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */ - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) -#define OVERRIDE_32_pselect6 -#define OVERRIDE_64_pselect6 -SC_LTTNG_TRACEPOINT_EVENT_CODE(pselect6, - TP_PROTO(sc_exit(long ret,) int n, fd_set __user * inp, fd_set __user * outp, - fd_set __user * exp, struct timeval __user * tvp, void __user * sig), - TP_ARGS(sc_exit(ret,) n, inp, outp, exp, tvp, sig), - TP_locvar( - LTTNG_SYSCALL_SELECT_locvar - ), - TP_code_pre( - LTTNG_SYSCALL_SELECT_code_pre - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, n, n)) - sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) - sc_inout(ctf_integer(struct timeval *, tvp, tvp)) - sc_in(ctf_integer_hex(void *, sig, sig)) - - sc_inout( -#if (__BYTE_ORDER == __LITTLE_ENDIAN) - LTTNG_SYSCALL_SELECT_fds_field_LE(readfds, inp) - LTTNG_SYSCALL_SELECT_fds_field_LE(writefds, outp) - LTTNG_SYSCALL_SELECT_fds_field_LE(exceptfds, exp) -#else - LTTNG_SYSCALL_SELECT_fds_field_BE(readfds, inp) - LTTNG_SYSCALL_SELECT_fds_field_BE(writefds, outp) - LTTNG_SYSCALL_SELECT_fds_field_BE(exceptfds, exp) -#endif - ) - ), - TP_code_post( - LTTNG_SYSCALL_SELECT_code_post - ) -) -#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ - -#ifndef ONCE_LTTNG_TRACE_POLL_H -#define ONCE_LTTNG_TRACE_POLL_H - -#define LTTNG_POLL_NRFLAGS (POLLNVAL + 1) -#define POLL_FLAGS_PADDING_SIZE (sizeof(uint8_t) * BITS_PER_BYTE) - \ - ilog2(LTTNG_POLL_NRFLAGS - 1) - -/* - * Only extract the values specified by iBCS2 for now. - */ -static struct lttng_event_field lttng_pollfd_flag_fields[] = { - [ilog2(POLLIN)] = { - .name = "POLLIN", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - [ilog2(POLLPRI)] = { - .name = "POLLPRI", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - [ilog2(POLLOUT)] = { - .name = "POLLOUT", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - [ilog2(POLLERR)] = { - .name = "POLLERR", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - [ilog2(POLLHUP)] = { - .name = "POLLHUP", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - [ilog2(POLLNVAL)] = { - .name = "POLLNVAL", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - [ilog2(LTTNG_POLL_NRFLAGS)] = { - .name = "padding", - .type = __type_integer(int, POLL_FLAGS_PADDING_SIZE, 1, 0, - __LITTLE_ENDIAN, 10, none), - }, -}; - -static struct lttng_event_field lttng_pollfd_fields[] = { - [0] = { - .name = "fd", - .type = __type_integer(int, 0, 0, 0, __BYTE_ORDER, 10, none), - }, - [1] = { - .name = "raw_events", - .type = __type_integer(short, 0, 0, 0, __BYTE_ORDER, 16, none), - }, - [2] = { - .name = "events", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_pollfd_flag_fields), - .u.struct_nestable.fields = lttng_pollfd_flag_fields, - .u.struct_nestable.alignment = 0, - } - }, -}; - -static struct lttng_type lttng_pollfd_elem = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_pollfd_fields), - .u.struct_nestable.fields = lttng_pollfd_fields, - .u.struct_nestable.alignment = 0, -}; -#endif /* ONCE_LTTNG_TRACE_POLL_H */ - -#define LTTNG_SYSCALL_POLL_locvar \ - unsigned int fds_length, fds_max_len, alloc_fds; \ - struct pollfd *fds; \ - uint8_t overflow; - -#define LTTNG_SYSCALL_POLL_code_pre \ - BUILD_BUG_ON(((ARRAY_SIZE(lttng_pollfd_flag_fields) - 1) + \ - POLL_FLAGS_PADDING_SIZE) != \ - sizeof(uint8_t) * BITS_PER_BYTE); \ - tp_locvar->fds = NULL; \ - tp_locvar->overflow = 0; \ - \ - sc_in( \ - if (nfds > PAGE_SIZE / sizeof(struct pollfd)) { \ - tp_locvar->fds_length = PAGE_SIZE / sizeof(struct pollfd); \ - tp_locvar->fds_max_len = PAGE_SIZE / sizeof(struct pollfd); \ - tp_locvar->overflow = 1; \ - } else { \ - tp_locvar->fds_length = nfds; \ - tp_locvar->fds_max_len = nfds; \ - } \ - tp_locvar->alloc_fds = tp_locvar->fds_length * sizeof(struct pollfd); \ - ) \ - /* \ - * On exit, the number of active FDs is determined by ret, \ - * nfds stays the same as the entry, but we only want to \ - * output the FDs that are relevant. \ - */ \ - sc_out( \ - if (ret <= 0 || ret > nfds) \ - goto error; \ - \ - if (nfds > PAGE_SIZE / sizeof(struct pollfd)) { \ - tp_locvar->fds_length = PAGE_SIZE / sizeof(struct pollfd); \ - tp_locvar->fds_max_len = PAGE_SIZE / sizeof(struct pollfd); \ - tp_locvar->overflow = 1; \ - } else { \ - tp_locvar->fds_length = ret; \ - tp_locvar->fds_max_len = nfds; \ - } \ - tp_locvar->alloc_fds = tp_locvar->fds_max_len * sizeof(struct pollfd); \ - ) \ - { \ - int err; \ - \ - tp_locvar->fds = lttng_tp_mempool_alloc(tp_locvar->alloc_fds); \ - if (!tp_locvar->fds) \ - goto error; \ - err = lib_ring_buffer_copy_from_user_check_nofault( \ - tp_locvar->fds, ufds, tp_locvar->alloc_fds); \ - if (err != 0) \ - goto error; \ - } \ - goto end; \ - \ -error: \ - tp_locvar->fds_length = 0; \ - tp_locvar->fds_max_len = 0; \ -end: \ - ; - -#define LTTNG_SYSCALL_POLL_fds_field \ - sc_in( \ - ctf_custom_field( \ - ctf_custom_type( \ - { \ - .atype = atype_sequence_nestable, \ - .u.sequence_nestable.length_name = "fds_length", \ - .u.sequence_nestable.elem_type = <tng_pollfd_elem, \ - } \ - ), \ - fds, \ - ctf_custom_code( \ - uint32_t i; \ - \ - ctf_align(int) /* Align on largest field in struct. */ \ - for (i = 0; i < tp_locvar->fds_length; i++) { \ - ctf_integer_type(int, tp_locvar->fds[i].fd) \ - ctf_integer_type(short, tp_locvar->fds[i].events) \ - ctf_integer_bitfield_type(uint8_t, \ - (uint8_t) tp_locvar->fds[i].events) \ - } \ - ) \ - ) \ - ) \ - sc_out( \ - ctf_custom_field( \ - ctf_custom_type( \ - { \ - .atype = atype_sequence_nestable, \ - .u.sequence_nestable.length_name = "fds_length", \ - .u.sequence_nestable.elem_type = <tng_pollfd_elem, \ - } \ - ), \ - fds, \ - ctf_custom_code( \ - unsigned int i, nr = 0; \ - \ - ctf_align(int) /* Align on largest field in struct. */ \ - /* \ - * Iterate over the complete array, but only output \ - * "ret" active FDs. \ - */ \ - for (i = 0; i < tp_locvar->fds_max_len; i++) { \ - if (!tp_locvar->fds[i].revents) \ - continue; \ - if (nr++ >= tp_locvar->fds_length) \ - break; \ - ctf_integer_type(int, tp_locvar->fds[i].fd) \ - ctf_integer_type(short, tp_locvar->fds[i].revents) \ - ctf_integer_bitfield_type(uint8_t, \ - (uint8_t) tp_locvar->fds[i].revents) \ - } \ - /* \ - * If there is a discrepancy between ret and the \ - * content of revents (e.g. caused by userspace corrupting \ - * the array from a concurrent thread), we have to output \ - * zeros to keep the trace readable. \ - */ \ - for (i = nr; i < tp_locvar->fds_length; i++) { \ - ctf_integer_type(int, 0) \ - ctf_integer_type(short, 0) \ - ctf_integer_bitfield_type(uint8_t, 0) \ - } \ - ) \ - ) \ - ) - -#define LTTNG_SYSCALL_POLL_code_post \ - lttng_tp_mempool_free(tp_locvar->fds); - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) -#define OVERRIDE_32_poll -#define OVERRIDE_64_poll -SC_LTTNG_TRACEPOINT_EVENT_CODE(poll, - TP_PROTO(sc_exit(long ret,) struct pollfd __user * ufds, - unsigned int nfds, int timeout_msecs), - TP_ARGS(sc_exit(ret,) ufds, nfds, timeout_msecs), - TP_locvar( - LTTNG_SYSCALL_POLL_locvar - ), - TP_code_pre( - LTTNG_SYSCALL_POLL_code_pre - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, timeout_msecs, timeout_msecs)) - sc_inout(ctf_integer(unsigned int, nfds, nfds)) - sc_inout(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length)) - sc_in(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) - LTTNG_SYSCALL_POLL_fds_field - ), - TP_code_post( - LTTNG_SYSCALL_POLL_code_post - ) -) -#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */ - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) -#define OVERRIDE_32_ppoll -#define OVERRIDE_64_ppoll -SC_LTTNG_TRACEPOINT_EVENT_CODE(ppoll, - TP_PROTO(sc_exit(long ret,) struct pollfd __user * ufds, - unsigned int nfds, struct timespec * tsp, const sigset_t * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) ufds, nfds, tsp, sigmask, sigsetsize), - TP_locvar( - LTTNG_SYSCALL_POLL_locvar - ), - TP_code_pre( - LTTNG_SYSCALL_POLL_code_pre - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(struct timespec *, tsp, tsp)) - sc_in(ctf_integer(const sigset_t *, sigmask, sigmask)) - sc_in(ctf_integer(size_t, sigsetsize, sigsetsize)) - sc_inout(ctf_integer(unsigned int, nfds, nfds)) - sc_inout(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length)) - sc_inout(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) - LTTNG_SYSCALL_POLL_fds_field - ), - TP_code_post( - LTTNG_SYSCALL_POLL_code_post - ) -) -#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ - -#include - -SC_LTTNG_TRACEPOINT_ENUM(lttng_epoll_op, - TP_ENUM_VALUES( - ctf_enum_value("EPOLL_CTL_ADD", EPOLL_CTL_ADD) - ctf_enum_value("EPOLL_CTL_DEL", EPOLL_CTL_DEL) - ctf_enum_value("EPOLL_CTL_MOD", EPOLL_CTL_MOD) - ) -) - -#ifndef ONCE_LTTNG_TRACE_EPOLL_CTL_H -#define ONCE_LTTNG_TRACE_EPOLL_CTL_H - -#define LTTNG_EPOLL_NRFLAGS (POLLHUP + 1) -#define EPOLL_FLAGS_PADDING_SIZE (sizeof(uint8_t) * BITS_PER_BYTE) - \ - ilog2(LTTNG_EPOLL_NRFLAGS - 1) - -/* - * Only extract the values specified by iBCS2 for now. - */ -static struct lttng_event_field lttng_epoll_ctl_events_fields[] = { - /* 0x0001 */ - [ilog2(POLLIN)] = { - .name = "EPOLLIN", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - /* 0x0002 */ - [ilog2(POLLPRI)] = { - .name = "EPOLLPRI", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - /* 0x0004 */ - [ilog2(POLLOUT)] = { - .name = "EPOLLOUT", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - /* 0x0008 */ - [ilog2(POLLERR)] = { - .name = "EPOLLERR", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - /* 0x0010 */ - [ilog2(POLLHUP)] = { - .name = "EPOLLHUP", - .type = __type_integer(int, 1, 1, 0, __LITTLE_ENDIAN, 10, none), - }, - [ilog2(LTTNG_EPOLL_NRFLAGS)] = { - .name = "padding", - .type = __type_integer(int, EPOLL_FLAGS_PADDING_SIZE, 1, 0, - __LITTLE_ENDIAN, 10, none), - }, - -}; - -static struct lttng_event_field lttng_epoll_data_fields[] = { - [0] = { - .name = "u64", - .type = __type_integer(uint64_t, 0, 0, 0, __BYTE_ORDER, 16, none), - }, - [1] = { - .name = "fd", - .type = __type_integer(int, 0, 0, 0, __BYTE_ORDER, 10, none), - }, -}; - -static struct lttng_event_field epoll_ctl_fields[] = { - [0] = { - .name = "data_union", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_data_fields), - .u.struct_nestable.fields = lttng_epoll_data_fields, - .u.struct_nestable.alignment = 0, - } - }, - [1] = { - .name = "raw_events", - .type = __type_integer(uint32_t, 0, 0, 0, __BYTE_ORDER, 16, none), - }, - [2] = { - .name = "events", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_ctl_events_fields), - .u.struct_nestable.fields = lttng_epoll_ctl_events_fields, - .u.struct_nestable.alignment = 0, - } - }, -}; -#endif /* ONCE_LTTNG_TRACE_EPOLL_CTL_H */ - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) -#define OVERRIDE_32_epoll_ctl -#define OVERRIDE_64_epoll_ctl -SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_ctl, - TP_PROTO(sc_exit(long ret,) int epfd, int op, int fd, - struct epoll_event __user * uevent), - TP_ARGS(sc_exit(ret,) epfd, op, fd, uevent), - TP_locvar( - struct epoll_event event; - int err; - ), - TP_code_pre( - tp_locvar->err = lib_ring_buffer_copy_from_user_check_nofault( - &tp_locvar->event, uevent, sizeof(struct epoll_event)); - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, epfd, epfd)) - sc_in(ctf_enum(lttng_epoll_op, int, op_enum, op)) - sc_in(ctf_integer(int, fd, fd)) - sc_in( - ctf_custom_field( - ctf_custom_type( - { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(epoll_ctl_fields), - .u.struct_nestable.fields = epoll_ctl_fields, - .u.struct_nestable.alignment = 0, - } - ), - event, - ctf_custom_code( - ctf_align(uint64_t) - if (!tp_locvar->err) { - ctf_integer_type(uint64_t, tp_locvar->event.data) - ctf_integer_type(int, tp_locvar->event.data) - ctf_integer_bitfield_type(uint32_t, - tp_locvar->event.events) - ctf_integer_bitfield_type(uint8_t, - (uint8_t) tp_locvar->event.events) - } else { - ctf_integer_type(uint64_t, 0) - ctf_integer_type(int, 0) - ctf_integer_bitfield_type(uint32_t, 0) - ctf_integer_bitfield_type(uint8_t, 0) - } - ) - ) - ) - ), - TP_code_post() -) -#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ - -#ifndef ONCE_LTTNG_TRACE_EPOLL_H -#define ONCE_LTTNG_TRACE_EPOLL_H - -static struct lttng_event_field lttng_epoll_wait_fields[] = { - [0] = { - .name = "data_union", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_data_fields), - .u.struct_nestable.fields = lttng_epoll_data_fields, - .u.struct_nestable.alignment = 0, - } - }, - [1] = { - .name = "raw_events", - .type = __type_integer(uint32_t, 0, 0, 0, __BYTE_ORDER, 16, none), - }, - [2] = { - .name = "events", - .type = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_ctl_events_fields), - .u.struct_nestable.fields = lttng_epoll_ctl_events_fields, - .u.struct_nestable.alignment = 0, - } - }, -}; - -static struct lttng_type lttng_epoll_wait_elem = { - .atype = atype_struct_nestable, - .u.struct_nestable.nr_fields = ARRAY_SIZE(lttng_epoll_wait_fields), - .u.struct_nestable.fields = lttng_epoll_wait_fields, - .u.struct_nestable.alignment = 0, -}; - -#endif /* ONCE_LTTNG_TRACE_EPOLL_H */ - -#define LTTNG_SYSCALL_EPOLL_WAIT_locvar \ - sc_out( \ - unsigned int fds_length; \ - uint8_t overflow; \ - struct epoll_event *events; \ - ) - -#define LTTNG_SYSCALL_EPOLL_WAIT_code_pre \ - BUILD_BUG_ON(((ARRAY_SIZE(lttng_epoll_ctl_events_fields) - 1) + \ - EPOLL_FLAGS_PADDING_SIZE) != \ - sizeof(uint8_t) * BITS_PER_BYTE); \ - sc_out({ \ - int err; \ - unsigned long maxalloc; \ - \ - tp_locvar->fds_length = 0; \ - tp_locvar->events = NULL; \ - tp_locvar->overflow = 0; \ - \ - if (maxevents <= 0 || ret <= 0 || ret > maxevents) \ - goto skip_code; \ - \ - if (maxevents > PAGE_SIZE / sizeof(struct epoll_event)) { \ - maxalloc = PAGE_SIZE / sizeof(struct epoll_event); \ - } else { \ - maxalloc = maxevents; \ - } \ - \ - if (ret > maxalloc) { \ - tp_locvar->fds_length = maxalloc; \ - tp_locvar->overflow = 1; \ - } else { \ - tp_locvar->fds_length = ret; \ - } \ - \ - tp_locvar->events = lttng_tp_mempool_alloc( \ - maxalloc * sizeof(struct epoll_event)); \ - if (!tp_locvar->events) { \ - tp_locvar->fds_length = 0; \ - goto skip_code; \ - } \ - \ - err = lib_ring_buffer_copy_from_user_check_nofault( \ - tp_locvar->events, uevents, \ - maxalloc * sizeof(struct epoll_event)); \ - if (err != 0) \ - tp_locvar->fds_length = 0; \ - } \ - skip_code: \ - ) - -#define LTTNG_SYSCALL_EPOLL_WAIT_fds_field \ - ctf_custom_field( \ - ctf_custom_type( \ - { \ - .atype = atype_sequence_nestable, \ - .u.sequence_nestable.length_name = \ - "fds_length", \ - .u.sequence_nestable.elem_type = \ - <tng_epoll_wait_elem, \ - } \ - ), \ - fds, \ - ctf_custom_code( \ - uint32_t i; \ - \ - ctf_align(uint64_t) \ - for (i = 0; i < tp_locvar->fds_length; i++) { \ - ctf_integer_type(uint64_t, tp_locvar->events[i].data) \ - ctf_integer_type(int, tp_locvar->events[i].data) \ - ctf_integer_bitfield_type(uint32_t, \ - tp_locvar->events[i].events) \ - ctf_integer_bitfield_type(uint8_t, \ - (uint8_t) tp_locvar->events[i].events) \ - } \ - ) \ - ) - -#define LTTNG_SYSCALL_EPOLL_WAIT_code_post \ - sc_out( \ - lttng_tp_mempool_free(tp_locvar->events); \ - ) - - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) -#define OVERRIDE_32_epoll_wait -#define OVERRIDE_64_epoll_wait -SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_wait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event __user * uevents, - int maxevents, int timeout), - TP_ARGS(sc_exit(ret,) epfd, uevents, maxevents, timeout), - TP_locvar( - LTTNG_SYSCALL_EPOLL_WAIT_locvar - ), - TP_code_pre( - LTTNG_SYSCALL_EPOLL_WAIT_code_pre - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, epfd, epfd)) - sc_in(ctf_integer(int, maxevents, maxevents)) - sc_in(ctf_integer(int, timeout, timeout)) - sc_out(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length)) - sc_out(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) - sc_out( - LTTNG_SYSCALL_EPOLL_WAIT_fds_field - ) - ), - TP_code_post( - LTTNG_SYSCALL_EPOLL_WAIT_code_post - ) -) -#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM) */ - -#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) -#define OVERRIDE_32_epoll_pwait -#define OVERRIDE_64_epoll_pwait -SC_LTTNG_TRACEPOINT_EVENT_CODE(epoll_pwait, - TP_PROTO(sc_exit(long ret,) int epfd, struct epoll_event __user * uevents, - int maxevents, int timeout, const sigset_t __user * sigmask, size_t sigsetsize), - TP_ARGS(sc_exit(ret,) epfd, uevents, maxevents, timeout, sigmask, sigsetsize), - TP_locvar( - LTTNG_SYSCALL_EPOLL_WAIT_locvar - ), - TP_code_pre( - LTTNG_SYSCALL_EPOLL_WAIT_code_pre - ), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, epfd, epfd)) - sc_in(ctf_integer(int, maxevents, maxevents)) - sc_in(ctf_integer(int, timeout, timeout)) - sc_in(ctf_integer_hex(const sigset_t *, sigmask, sigmask)) - sc_in(ctf_integer(size_t, sigsetsize, sigsetsize)) - sc_out(ctf_integer(unsigned int, fds_length, tp_locvar->fds_length)) - sc_out(ctf_integer(uint8_t, overflow, tp_locvar->overflow)) - sc_out( - LTTNG_SYSCALL_EPOLL_WAIT_fds_field - ) - ), - TP_code_post( - LTTNG_SYSCALL_EPOLL_WAIT_code_post - ) -) -#endif /* defined(CONFIG_X86_32) || defined(CONFIG_X86_64) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ - -#if (defined(CONFIG_X86_64) && !defined(LTTNG_SC_COMPAT)) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) -#define OVERRIDE_32_socketpair -#define OVERRIDE_64_socketpair -SC_LTTNG_TRACEPOINT_EVENT(socketpair, - TP_PROTO(sc_exit(long ret,) int family, int type, int protocol, int *usockvec), - TP_ARGS(sc_exit(ret,) family, type, protocol, usockvec), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, family, family)) - sc_in(ctf_integer(int, type, type)) - sc_in(ctf_integer(int, protocol, protocol)) - sc_out(ctf_user_array(int, socket, usockvec, 2)) - ) -) -#endif /* (defined(CONFIG_X86_64) && !defined(LTTNG_SC_COMPAT)) || defined(CONFIG_ARM64) || defined(CONFIG_ARM) */ - -/* - * Enumeration of the open flags, as described in the 'open' - * system call man page. - */ -SC_LTTNG_TRACEPOINT_ENUM(lttng_file_status_flags, - TP_ENUM_VALUES( - ctf_enum_value("O_RDONLY", O_RDONLY) - ctf_enum_value("O_WRONLY", O_WRONLY) - ctf_enum_value("O_RDWR", O_RDWR) - ctf_enum_value("O_CREAT", O_CREAT) - ctf_enum_value("O_EXCL", O_EXCL) - ctf_enum_value("O_NOCTTY", O_NOCTTY) - ctf_enum_value("O_TRUNC", O_TRUNC) - ctf_enum_value("O_APPEND", O_APPEND) - ctf_enum_value("O_NONBLOCK", O_NONBLOCK) - ctf_enum_value("O_DSYNC", O_DSYNC) - ctf_enum_value("FASYNC", FASYNC) - ctf_enum_value("O_DIRECT", O_DIRECT) - ctf_enum_value("O_LARGEFILE", O_LARGEFILE) - ctf_enum_value("O_DIRECTORY", O_DIRECTORY) - ctf_enum_value("O_NOFOLLOW", O_NOFOLLOW) - ctf_enum_value("O_NOATIME", O_NOATIME) - ctf_enum_value("O_CLOEXEC", O_CLOEXEC) - ctf_enum_value("O_SYNC", __O_SYNC) - ctf_enum_value("O_PATH", O_PATH) -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0)) - ctf_enum_value("O_TMPFILE", __O_TMPFILE) -#endif /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0)) */ - ) -) - -/* - * Enumeration of the open flags, as described in the 'open' - * system call man page. - */ -SC_LTTNG_TRACEPOINT_ENUM(lttng_file_mode, - TP_ENUM_VALUES( - ctf_enum_value("S_IRWXU", S_IRWXU) - ctf_enum_value("S_IRUSR", S_IRUSR) - ctf_enum_value("S_IWUSR", S_IWUSR) - ctf_enum_value("S_IXUSR", S_IXUSR) - ctf_enum_value("S_IRWXG", S_IRWXG) - ctf_enum_value("S_IRGRP", S_IRGRP) - ctf_enum_value("S_IWGRP", S_IWGRP) - ctf_enum_value("S_IXGRP", S_IXGRP) - ctf_enum_value("S_IRWXO", S_IRWXO) - ctf_enum_value("S_IROTH", S_IROTH) - ctf_enum_value("S_IWOTH", S_IWOTH) - ctf_enum_value("S_IXOTH", S_IXOTH) - ctf_enum_value("S_ISUID", S_ISUID) - ctf_enum_value("S_ISGID", S_ISGID) - ctf_enum_value("S_ISVTX", S_ISVTX) - ) -) - -#define OVERRIDE_32_openat -#define OVERRIDE_64_openat -SC_LTTNG_TRACEPOINT_EVENT(openat, - TP_PROTO(sc_exit(long ret,) int dfd, const char * filename, int flags, umode_t mode), - TP_ARGS(sc_exit(ret,) dfd, filename, flags, mode), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_integer(int, dfd, dfd)) - sc_in(ctf_user_string(filename, filename)) - sc_in(ctf_enum(lttng_file_status_flags, int, flags, flags)) - sc_in(ctf_enum(lttng_file_mode, umode_t, mode, mode)) - ) -) - -#define OVERRIDE_32_open -#define OVERRIDE_64_open -SC_LTTNG_TRACEPOINT_EVENT(open, - TP_PROTO(sc_exit(long ret,) const char * filename, int flags, umode_t mode), - TP_ARGS(sc_exit(ret,) filename, flags, mode), - TP_FIELDS( - sc_exit(ctf_integer(long, ret, ret)) - sc_in(ctf_user_string(filename, filename)) - sc_in(ctf_enum(lttng_file_status_flags, int, flags, flags)) - sc_in(ctf_enum(lttng_file_mode, umode_t, mode, mode)) - ) -) - -#endif /* CREATE_SYSCALL_TABLE */