X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=include%2Flttng%2Ftracepoint-event-impl.h;h=c9674a35404c5b550564237014c603bc94f166e4;hb=a67ba386d82d85c6b6ca56c249a13ab5a1f34b08;hp=b5094619176e6764ae1ff01afda5ce726a4afe97;hpb=2df37e95fa4303ecc0db41334452665491533641;p=lttng-modules.git diff --git a/include/lttng/tracepoint-event-impl.h b/include/lttng/tracepoint-event-impl.h index b5094619..c9674a35 100644 --- a/include/lttng/tracepoint-event-impl.h +++ b/include/lttng/tracepoint-event-impl.h @@ -20,6 +20,7 @@ #include #include #include +#include /* TODO: remove this include after refactoring is done. */ #include #include @@ -172,6 +173,41 @@ void __event_template_proto___##_name(void); #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) +/* + * Stage 1.2 of the trace event_notifier. + * + * Create dummy trace prototypes for each event class, and for each used + * template. This will allow checking whether the prototypes from the + * class and the instance using the class actually match. + */ + +#include /* Reset all macros within TRACE_EVENT */ + +#undef TP_PROTO +#define TP_PROTO(...) __VA_ARGS__ + +#undef TP_ARGS +#define TP_ARGS(...) __VA_ARGS__ + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP(_template, _name, _map, _proto, _args) \ +void __event_notifier_template_proto___##_template(_proto); + +#undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS +#define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \ +void __event_notifier_template_proto___##_template(void); + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ +void __event_notifier_template_proto___##_name(_proto); + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ +void __event_notifier_template_proto___##_name(void); + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + + /* * Stage 1.2 of tracepoint event generation * @@ -182,54 +218,17 @@ void __event_template_proto___##_name(void); /* Enumeration entry (single value) */ #undef ctf_enum_value #define ctf_enum_value(_string, _value) \ - { \ - .start = { \ - .signedness = lttng_is_signed_type(__typeof__(_value)), \ - .value = lttng_is_signed_type(__typeof__(_value)) ? \ - (long long) (_value) : (_value), \ - }, \ - .end = { \ - .signedness = lttng_is_signed_type(__typeof__(_value)), \ - .value = lttng_is_signed_type(__typeof__(_value)) ? \ - (long long) (_value) : (_value), \ - }, \ - .string = (_string), \ - }, + lttng_kernel_static_enum_entry_value(_string, _value) /* Enumeration entry (range) */ #undef ctf_enum_range #define ctf_enum_range(_string, _range_start, _range_end) \ - { \ - .start = { \ - .signedness = lttng_is_signed_type(__typeof__(_range_start)), \ - .value = lttng_is_signed_type(__typeof__(_range_start)) ? \ - (long long) (_range_start) : (_range_start), \ - }, \ - .end = { \ - .signedness = lttng_is_signed_type(__typeof__(_range_end)), \ - .value = lttng_is_signed_type(__typeof__(_range_end)) ? \ - (long long) (_range_end) : (_range_end), \ - }, \ - .string = (_string), \ - }, + lttng_kernel_static_enum_entry_range(_string, _range_start, _range_end) /* Enumeration entry (automatic value; follows the rules of CTF) */ #undef ctf_enum_auto -#define ctf_enum_auto(_string) \ - { \ - .start = { \ - .signedness = -1, \ - .value = -1, \ - }, \ - .end = { \ - .signedness = -1, \ - .value = -1, \ - }, \ - .string = (_string), \ - .options = { \ - .is_auto = 1, \ - } \ - }, +#define ctf_enum_auto(_string) \ + lttng_kernel_static_enum_entry_auto(_string) #undef TP_ENUM_VALUES #define TP_ENUM_VALUES(...) \ @@ -237,7 +236,7 @@ void __event_template_proto___##_name(void); #undef LTTNG_TRACEPOINT_ENUM #define LTTNG_TRACEPOINT_ENUM(_name, _values) \ - const struct lttng_enum_entry __enum_values__##_name[] = { \ + static const struct lttng_kernel_enum_entry *__enum_values__##_name[] = { \ _values \ }; @@ -256,170 +255,77 @@ void __event_template_proto___##_name(void); #include #undef _ctf_integer_ext -#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _user, _nowrite) \ - { \ - .name = #_item, \ - .type = __type_integer(_type, 0, 0, -1, _byte_order, _base, none), \ - .nowrite = _nowrite, \ - .user = _user, \ - .nofilter = 0, \ - }, +#define _ctf_integer_ext(_type, _item, _src, _byte_order, _base, _user, _nowrite) \ + lttng_kernel_static_event_field(#_item, \ + lttng_kernel_static_type_integer_from_type(_type, _byte_order, _base), \ + _nowrite, _user, 0), #undef _ctf_array_encoded #define _ctf_array_encoded(_type, _item, _src, _length, \ _encoding, _byte_order, _elem_type_base, _user, _nowrite) \ - { \ - .name = #_item, \ - .type = \ - { \ - .atype = atype_array_nestable, \ - .u = \ - { \ - .array_nestable = \ - { \ - .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ - __type_integer(_type, 0, 0, -1, _byte_order, _elem_type_base, _encoding)), \ - .length = _length, \ - .alignment = 0, \ - } \ - } \ - }, \ - .nowrite = _nowrite, \ - .user = _user, \ - .nofilter = 0, \ - }, + lttng_kernel_static_event_field(#_item, \ + lttng_kernel_static_type_array(_length, \ + lttng_kernel_static_type_integer_from_type(_type, _byte_order, _elem_type_base), \ + 0, \ + _encoding), \ + _nowrite, _user, 0), #undef _ctf_array_bitfield #define _ctf_array_bitfield(_type, _item, _src, _length, _user, _nowrite) \ - { \ - .name = #_item, \ - .type = \ - { \ - .atype = atype_array_nestable, \ - .u = \ - { \ - .array_nestable = \ - { \ - .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ - __type_integer(_type, 1, 1, 0, __LITTLE_ENDIAN, 10, none)), \ - .length = (_length) * sizeof(_type) * CHAR_BIT, \ - .alignment = lttng_alignof(_type), \ - } \ - } \ - }, \ - .nowrite = _nowrite, \ - .user = _user, \ - .nofilter = 0, \ - }, - + lttng_kernel_static_event_field(#_item, \ + lttng_kernel_static_type_array((_length) * sizeof(_type) * CHAR_BIT, \ + lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN, 10), \ + lttng_alignof(_type), \ + none), \ + _nowrite, _user, 0), #undef _ctf_sequence_encoded #define _ctf_sequence_encoded(_type, _item, _src, \ _length_type, _src_length, _encoding, \ _byte_order, _elem_type_base, _user, _nowrite) \ - { \ - .name = "_" #_item "_length", \ - .type = __type_integer(_length_type, 0, 0, -1, __BYTE_ORDER, 10, none), \ - .nowrite = _nowrite, \ - .nofilter = 1, \ - }, \ - { \ - .name = #_item, \ - .type = \ - { \ - .atype = atype_sequence_nestable, \ - .u = \ - { \ - .sequence_nestable = \ - { \ - .length_name = "_" #_item "_length", \ - .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ - __type_integer(_type, 0, 0, -1, _byte_order, _elem_type_base, _encoding)), \ - .alignment = 0, \ - }, \ - }, \ - }, \ - .nowrite = _nowrite, \ - .user = _user, \ - .nofilter = 0, \ - }, + lttng_kernel_static_event_field("_" #_item "_length", \ + lttng_kernel_static_type_integer_from_type(_length_type, __BYTE_ORDER, 10), \ + _nowrite, 0, 1), \ + lttng_kernel_static_event_field(#_item, \ + lttng_kernel_static_type_sequence("_" #_item "_length", \ + lttng_kernel_static_type_integer_from_type(_type, _byte_order, _elem_type_base), \ + 0, \ + _encoding), \ + _nowrite, _user, 0), #undef _ctf_sequence_bitfield #define _ctf_sequence_bitfield(_type, _item, _src, \ _length_type, _src_length, \ _user, _nowrite) \ - { \ - .name = "_" #_item "_length", \ - .type = __type_integer(_length_type, 0, 0, -1, __BYTE_ORDER, 10, none), \ - .nowrite = _nowrite, \ - .nofilter = 1, \ - }, \ - { \ - .name = #_item, \ - .type = \ - { \ - .atype = atype_sequence_nestable, \ - .u = \ - { \ - .sequence_nestable = \ - { \ - .length_name = "_" #_item "_length", \ - .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ - __type_integer(_type, 1, 1, 0, __LITTLE_ENDIAN, 10, none)), \ - .alignment = lttng_alignof(_type), \ - }, \ - }, \ - }, \ - .nowrite = _nowrite, \ - .user = _user, \ - .nofilter = 0, \ - }, + lttng_kernel_static_event_field("_" #_item "_length", \ + lttng_kernel_static_type_integer_from_type(_length_type, __BYTE_ORDER, 10), \ + _nowrite, 0, 1), \ + lttng_kernel_static_event_field(#_item, \ + lttng_kernel_static_type_sequence("_" #_item "_length", \ + lttng_kernel_static_type_integer(1, 1, 0, __LITTLE_ENDIAN, 10), \ + lttng_alignof(_type), \ + none), \ + _nowrite, _user, 0), #undef _ctf_string #define _ctf_string(_item, _src, _user, _nowrite) \ - { \ - .name = #_item, \ - .type = \ - { \ - .atype = atype_string, \ - .u = \ - { \ - .string = { .encoding = lttng_encode_UTF8 }, \ - }, \ - }, \ - .nowrite = _nowrite, \ - .user = _user, \ - .nofilter = 0, \ - }, + lttng_kernel_static_event_field(#_item, \ + lttng_kernel_static_type_string(UTF8), \ + _nowrite, _user, 0), + +#undef _ctf_unused +#define _ctf_unused(_src) #undef _ctf_enum #define _ctf_enum(_name, _type, _item, _src, _user, _nowrite) \ - { \ - .name = #_item, \ - .type = { \ - .atype = atype_enum_nestable, \ - .u = { \ - .enum_nestable = { \ - .desc = &__enum_##_name, \ - .container_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ - __type_integer(_type, 0, 0, -1, __BYTE_ORDER, 10, none)), \ - }, \ - }, \ - }, \ - .nowrite = _nowrite, \ - .user = _user, \ - .nofilter = 0, \ - }, + lttng_kernel_static_event_field(#_item, \ + lttng_kernel_static_type_enum(&__enum_##_name, \ + lttng_kernel_static_type_integer_from_type(_type, __BYTE_ORDER, 10)), \ + _nowrite, _user, 0), #undef ctf_custom_field #define ctf_custom_field(_type, _item, _code) \ - { \ - .name = #_item, \ - .type = _type, \ - .nowrite = 0, \ - .user = 0, \ - .nofilter = 1, \ - }, + lttng_kernel_static_event_field(#_item, PARAMS(_type), 0, 0, 1), #undef ctf_custom_type #define ctf_custom_type(...) __VA_ARGS__ @@ -429,7 +335,7 @@ void __event_template_proto___##_name(void); #undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS #define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ - static const struct lttng_event_field __event_fields___##_name[] = { \ + static const struct lttng_kernel_event_field *__event_fields___##_name[] = { \ _fields \ }; @@ -439,13 +345,15 @@ void __event_template_proto___##_name(void); #undef LTTNG_TRACEPOINT_ENUM #define LTTNG_TRACEPOINT_ENUM(_name, _values) \ - static const struct lttng_enum_desc __enum_##_name = { \ + static const struct lttng_kernel_enum_desc __enum_##_name = { \ .name = #_name, \ .entries = __enum_values__##_name, \ .nr_entries = ARRAY_SIZE(__enum_values__##_name), \ }; +#define LTTNG_CREATE_FIELD_METADATA #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) +#undef LTTNG_CREATE_FIELD_METADATA /* * Stage 3 of the trace events. @@ -469,6 +377,28 @@ static void __event_probe__##_name(void *__data); #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) +/* + * Stage 3.1 of the trace event_notifiers. + * + * Create event_notifier probe callback prototypes. + */ + +/* Reset all macros within TRACEPOINT_EVENT */ +#include + +#undef TP_PROTO +#define TP_PROTO(...) __VA_ARGS__ + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ +static void __event_notifier_probe__##_name(void *__data, _proto); + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ +static void __event_notifier_probe__##_name(void *__data); + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + /* * Stage 4 of the trace events. * @@ -765,7 +695,7 @@ error: \ #undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS #define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ static inline \ -void __event_prepare_filter_stack__##_name(char *__stack_data, \ +void __event_prepare_interpreter_stack__##_name(char *__stack_data, \ void *__tp_locvar) \ { \ struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar; \ @@ -776,7 +706,7 @@ void __event_prepare_filter_stack__##_name(char *__stack_data, \ #undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE #define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ static inline \ -void __event_prepare_filter_stack__##_name(char *__stack_data, \ +void __event_prepare_interpreter_stack__##_name(char *__stack_data, \ void *__tp_locvar, _proto) \ { \ struct { _locvar } *tp_locvar __attribute__((unused)) = __tp_locvar; \ @@ -1130,12 +1060,13 @@ static inline size_t __event_get_align__##_name(void *__tp_locvar) \ static void __event_probe__##_name(void *__data, _proto) \ { \ struct probe_local_vars { _locvar }; \ - struct lttng_event *__event = __data; \ - struct lttng_probe_ctx __lttng_probe_ctx = { \ - .event = __event, \ + struct lttng_kernel_event_recorder *__event_recorder = __data; \ + struct lttng_probe_ctx __lttng_probe_ctx = { \ + .event = __event_recorder, \ + .event_notifier = NULL, \ .interruptible = !irqs_disabled(), \ }; \ - struct lttng_channel *__chan = __event->chan; \ + struct lttng_channel *__chan = __event_recorder->chan; \ struct lttng_session *__session = __chan->session; \ struct lib_ring_buffer_ctx __ctx; \ ssize_t __event_len; \ @@ -1153,11 +1084,11 @@ static void __event_probe__##_name(void *__data, _proto) \ \ if (!_TP_SESSION_CHECK(session, __session)) \ return; \ - if (unlikely(!READ_ONCE(__session->active))) \ + if (unlikely(!LTTNG_READ_ONCE(__session->active))) \ return; \ - if (unlikely(!READ_ONCE(__chan->enabled))) \ + if (unlikely(!LTTNG_READ_ONCE(__chan->enabled))) \ return; \ - if (unlikely(!READ_ONCE(__event->enabled))) \ + if (unlikely(!LTTNG_READ_ONCE(__event_recorder->parent.enabled))) \ return; \ __lf = lttng_rcu_dereference(__session->pid_tracker.p); \ if (__lf && likely(!lttng_id_tracker_lookup(__lf, current->tgid))) \ @@ -1184,15 +1115,15 @@ static void __event_probe__##_name(void *__data, _proto) \ __orig_dynamic_len_offset = this_cpu_ptr(<tng_dynamic_len_stack)->offset; \ __dynamic_len_idx = __orig_dynamic_len_offset; \ _code_pre \ - if (unlikely(!list_empty(&__event->bytecode_runtime_head))) { \ + if (unlikely(!list_empty(&__event_recorder->priv->parent.filter_bytecode_runtime_head))) { \ struct lttng_bytecode_runtime *bc_runtime; \ - int __filter_record = __event->has_enablers_without_bytecode; \ + int __filter_record = __event_recorder->priv->parent.has_enablers_without_filter_bytecode; \ \ - __event_prepare_filter_stack__##_name(__stackvar.__filter_stack_data, \ + __event_prepare_interpreter_stack__##_name(__stackvar.__filter_stack_data, \ tp_locvar, _args); \ - lttng_list_for_each_entry_rcu(bc_runtime, &__event->bytecode_runtime_head, node) { \ - if (unlikely(bc_runtime->filter(bc_runtime, &__lttng_probe_ctx, \ - __stackvar.__filter_stack_data) & LTTNG_FILTER_RECORD_FLAG)) { \ + lttng_list_for_each_entry_rcu(bc_runtime, &__event_recorder->priv->parent.filter_bytecode_runtime_head, node) { \ + if (unlikely(bc_runtime->interpreter_funcs.filter(bc_runtime, &__lttng_probe_ctx, \ + __stackvar.__filter_stack_data) & LTTNG_INTERPRETER_RECORD_FLAG)) { \ __filter_record = 1; \ break; \ } \ @@ -1208,7 +1139,7 @@ static void __event_probe__##_name(void *__data, _proto) \ __event_align = __event_get_align__##_name(tp_locvar, _args); \ lib_ring_buffer_ctx_init(&__ctx, __chan->chan, &__lttng_probe_ctx, __event_len, \ __event_align, -1); \ - __ret = __chan->ops->event_reserve(&__ctx, __event->id); \ + __ret = __chan->ops->event_reserve(&__ctx, __event_recorder->priv->id); \ if (__ret < 0) \ goto __post; \ _fields \ @@ -1225,12 +1156,13 @@ __post: \ static void __event_probe__##_name(void *__data) \ { \ struct probe_local_vars { _locvar }; \ - struct lttng_event *__event = __data; \ - struct lttng_probe_ctx __lttng_probe_ctx = { \ - .event = __event, \ + struct lttng_kernel_event_recorder *__event_recorder = __data; \ + struct lttng_probe_ctx __lttng_probe_ctx = { \ + .event = __event_recorder, \ + .event_notifier = NULL, \ .interruptible = !irqs_disabled(), \ }; \ - struct lttng_channel *__chan = __event->chan; \ + struct lttng_channel *__chan = __event_recorder->chan; \ struct lttng_session *__session = __chan->session; \ struct lib_ring_buffer_ctx __ctx; \ ssize_t __event_len; \ @@ -1248,11 +1180,11 @@ static void __event_probe__##_name(void *__data) \ \ if (!_TP_SESSION_CHECK(session, __session)) \ return; \ - if (unlikely(!READ_ONCE(__session->active))) \ + if (unlikely(!LTTNG_READ_ONCE(__session->active))) \ return; \ - if (unlikely(!READ_ONCE(__chan->enabled))) \ + if (unlikely(!LTTNG_READ_ONCE(__chan->enabled))) \ return; \ - if (unlikely(!READ_ONCE(__event->enabled))) \ + if (unlikely(!LTTNG_READ_ONCE(__event_recorder->parent.enabled))) \ return; \ __lf = lttng_rcu_dereference(__session->pid_tracker.p); \ if (__lf && likely(!lttng_id_tracker_lookup(__lf, current->tgid))) \ @@ -1279,15 +1211,15 @@ static void __event_probe__##_name(void *__data) \ __orig_dynamic_len_offset = this_cpu_ptr(<tng_dynamic_len_stack)->offset; \ __dynamic_len_idx = __orig_dynamic_len_offset; \ _code_pre \ - if (unlikely(!list_empty(&__event->bytecode_runtime_head))) { \ + if (unlikely(!list_empty(&__event_recorder->priv->parent.filter_bytecode_runtime_head))) { \ struct lttng_bytecode_runtime *bc_runtime; \ - int __filter_record = __event->has_enablers_without_bytecode; \ + int __filter_record = __event_recorder->priv->parent.has_enablers_without_filter_bytecode; \ \ - __event_prepare_filter_stack__##_name(__stackvar.__filter_stack_data, \ + __event_prepare_interpreter_stack__##_name(__stackvar.__filter_stack_data, \ tp_locvar); \ - lttng_list_for_each_entry_rcu(bc_runtime, &__event->bytecode_runtime_head, node) { \ - if (unlikely(bc_runtime->filter(bc_runtime, &__lttng_probe_ctx, \ - __stackvar.__filter_stack_data) & LTTNG_FILTER_RECORD_FLAG)) { \ + lttng_list_for_each_entry_rcu(bc_runtime, &__event_recorder->priv->parent.filter_bytecode_runtime_head, node) { \ + if (unlikely(bc_runtime->interpreter_funcs.filter(bc_runtime, &__lttng_probe_ctx, \ + __stackvar.__filter_stack_data) & LTTNG_INTERPRETER_RECORD_FLAG)) { \ __filter_record = 1; \ break; \ } \ @@ -1303,7 +1235,7 @@ static void __event_probe__##_name(void *__data) \ __event_align = __event_get_align__##_name(tp_locvar); \ lib_ring_buffer_ctx_init(&__ctx, __chan->chan, &__lttng_probe_ctx, __event_len, \ __event_align, -1); \ - __ret = __chan->ops->event_reserve(&__ctx, __event->id); \ + __ret = __chan->ops->event_reserve(&__ctx, __event_recorder->priv->id); \ if (__ret < 0) \ goto __post; \ _fields \ @@ -1319,6 +1251,152 @@ __post: \ #undef __get_dynamic_len +/* + * Stage 6.1 of tracepoint generation: generate event notifier probes + * + * Create the probe function. This function evaluates the filter bytecode and + * queue a notification to be sent to userspace. + */ + +#include /* Reset all macros within LTTNG_TRACEPOINT_EVENT */ + +#undef TP_PROTO +#define TP_PROTO(...) __VA_ARGS__ + +#undef TP_ARGS +#define TP_ARGS(...) __VA_ARGS__ + +#undef TP_FIELDS +#define TP_FIELDS(...) __VA_ARGS__ + +#undef TP_locvar +#define TP_locvar(...) __VA_ARGS__ + +#undef TP_code_pre +#define TP_code_pre(...) __VA_ARGS__ + +#undef TP_code_post +#define TP_code_post(...) __VA_ARGS__ + +/* + * Using twice size for filter stack data to hold size and pointer for + * each field (worse case). For integers, max size required is 64-bit. + * Same for double-precision floats. Those fit within + * 2*sizeof(unsigned long) for all supported architectures. + * Perform UNION (||) of filter runtime list. + */ +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE(_name, _proto, _args, _locvar, _code_pre, _fields, _code_post) \ +static void __event_notifier_probe__##_name(void *__data, _proto) \ +{ \ + struct probe_local_vars { _locvar }; \ + struct lttng_kernel_event_notifier *__event_notifier = __data; \ + struct lttng_probe_ctx __lttng_probe_ctx = { \ + .event = NULL, \ + .event_notifier = __event_notifier, \ + .interruptible = !irqs_disabled(), \ + }; \ + union { \ + size_t __dynamic_len_removed[ARRAY_SIZE(__event_fields___##_name)]; \ + char __interpreter_stack_data[2 * sizeof(unsigned long) * ARRAY_SIZE(__event_fields___##_name)]; \ + } __stackvar; \ + struct probe_local_vars __tp_locvar; \ + struct probe_local_vars *tp_locvar __attribute__((unused)) = \ + &__tp_locvar; \ + struct lttng_kernel_notification_ctx __notif_ctx; \ + bool __interpreter_stack_prepared = false; \ + \ + if (unlikely(!READ_ONCE(__event_notifier->parent.enabled))) \ + return; \ + _code_pre \ + if (unlikely(!list_empty(&__event_notifier->priv->parent.filter_bytecode_runtime_head))) { \ + struct lttng_bytecode_runtime *bc_runtime; \ + int __filter_record = __event_notifier->priv->parent.has_enablers_without_filter_bytecode; \ + \ + __event_prepare_interpreter_stack__##_name(__stackvar.__interpreter_stack_data, \ + tp_locvar, _args); \ + __interpreter_stack_prepared = true; \ + lttng_list_for_each_entry_rcu(bc_runtime, &__event_notifier->priv->parent.filter_bytecode_runtime_head, node) { \ + if (unlikely(bc_runtime->interpreter_funcs.filter(bc_runtime, &__lttng_probe_ctx, \ + __stackvar.__interpreter_stack_data) & LTTNG_INTERPRETER_RECORD_FLAG)) \ + __filter_record = 1; \ + } \ + if (likely(!__filter_record)) \ + goto __post; \ + } \ + \ + __notif_ctx.eval_capture = LTTNG_READ_ONCE(__event_notifier->eval_capture); \ + if (unlikely(!__interpreter_stack_prepared && __notif_ctx.eval_capture)) \ + __event_prepare_interpreter_stack__##_name( \ + __stackvar.__interpreter_stack_data, \ + tp_locvar, _args); \ + \ + __event_notifier->notification_send(__event_notifier, \ + &__lttng_probe_ctx, \ + __stackvar.__interpreter_stack_data, \ + &__notif_ctx); \ + \ +__post: \ + _code_post \ + return; \ +} + +#undef LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS +#define LTTNG_TRACEPOINT_EVENT_CLASS_CODE_NOARGS(_name, _locvar, _code_pre, _fields, _code_post) \ +static void __event_notifier_probe__##_name(void *__data) \ +{ \ + struct probe_local_vars { _locvar }; \ + struct lttng_kernel_event_notifier *__event_notifier = __data; \ + struct lttng_probe_ctx __lttng_probe_ctx = { \ + .event = NULL, \ + .event_notifier = __event_notifier, \ + .interruptible = !irqs_disabled(), \ + }; \ + union { \ + size_t __dynamic_len_removed[ARRAY_SIZE(__event_fields___##_name)]; \ + char __interpreter_stack_data[2 * sizeof(unsigned long) * ARRAY_SIZE(__event_fields___##_name)]; \ + } __stackvar; \ + struct probe_local_vars __tp_locvar; \ + struct probe_local_vars *tp_locvar __attribute__((unused)) = \ + &__tp_locvar; \ + struct lttng_kernel_notification_ctx __notif_ctx; \ + bool __interpreter_stack_prepared = false; \ + \ + if (unlikely(!READ_ONCE(__event_notifier->parent.enabled))) \ + return; \ + _code_pre \ + if (unlikely(!list_empty(&__event_notifier->priv->parent.filter_bytecode_runtime_head))) { \ + struct lttng_bytecode_runtime *bc_runtime; \ + int __filter_record = __event_notifier->priv->parent.has_enablers_without_filter_bytecode; \ + \ + __event_prepare_interpreter_stack__##_name(__stackvar.__interpreter_stack_data, \ + tp_locvar); \ + __interpreter_stack_prepared = true; \ + lttng_list_for_each_entry_rcu(bc_runtime, &__event_notifier->priv->parent.filter_bytecode_runtime_head, node) { \ + if (unlikely(bc_runtime->interpreter_funcs.filter(bc_runtime, &__lttng_probe_ctx, \ + __stackvar.__interpreter_stack_data) & LTTNG_INTERPRETER_RECORD_FLAG)) \ + __filter_record = 1; \ + } \ + if (likely(!__filter_record)) \ + goto __post; \ + } \ + \ + __notif_ctx.eval_capture = LTTNG_READ_ONCE(__event_notifier->eval_capture); \ + if (unlikely(!__interpreter_stack_prepared && __notif_ctx.eval_capture)) \ + __event_prepare_interpreter_stack__##_name( \ + __stackvar.__interpreter_stack_data, \ + tp_locvar); \ + \ + __event_notifier->notification_send(__event_notifier, \ + &__lttng_probe_ctx, \ + __stackvar.__interpreter_stack_data, \ + &__notif_ctx); \ +__post: \ + _code_post \ + return; \ +} + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) /* * Stage 7 of the trace events. * @@ -1333,15 +1411,20 @@ __post: \ #define TP_PROBE_CB(_template) &__event_probe__##_template #endif +#ifndef TP_EVENT_NOTIFIER_PROBE_CB +#define TP_EVENT_NOTIFIER_PROBE_CB(_template) &__event_notifier_probe__##_template +#endif + #undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS #define LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP_NOARGS(_template, _name, _map) \ -static const struct lttng_event_desc __event_desc___##_map = { \ +static const struct lttng_kernel_event_desc __event_desc___##_map = { \ + .event_name = #_map, \ + .event_kname = #_name, \ + .probe_callback = (void *) TP_PROBE_CB(_template), \ .fields = __event_fields___##_template, \ - .name = #_map, \ - .kname = #_name, \ - .probe_callback = (void *) TP_PROBE_CB(_template), \ .nr_fields = ARRAY_SIZE(__event_fields___##_template), \ .owner = THIS_MODULE, \ + .event_notifier_callback = (void *) TP_EVENT_NOTIFIER_PROBE_CB(_template), \ }; #undef LTTNG_TRACEPOINT_EVENT_INSTANCE_MAP @@ -1369,7 +1452,7 @@ static const struct lttng_event_desc __event_desc___##_map = { \ #define TP_ID1(_token, _system) _token##_system #define TP_ID(_token, _system) TP_ID1(_token, _system) -static const struct lttng_event_desc *TP_ID(__event_desc___, TRACE_SYSTEM)[] = { +static const struct lttng_kernel_event_desc *TP_ID(__event_desc___, TRACE_SYSTEM)[] = { #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) }; @@ -1386,8 +1469,8 @@ static const struct lttng_event_desc *TP_ID(__event_desc___, TRACE_SYSTEM)[] = { #define TP_ID(_token, _system) TP_ID1(_token, _system) /* non-const because list head will be modified when registered. */ -static __used struct lttng_probe_desc TP_ID(__probe_desc___, TRACE_SYSTEM) = { - .provider = __stringify(TRACE_SYSTEM), +static __used struct lttng_kernel_probe_desc TP_ID(__probe_desc___, TRACE_SYSTEM) = { + .provider_name = __stringify(TRACE_SYSTEM), .event_desc = TP_ID(__event_desc___, TRACE_SYSTEM), .nr_events = ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)), .head = { NULL, NULL },