X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=include%2Flttng%2Fust-tracepoint-event.h;h=ec0e314432e58cde1be7deae76601dec5f2ca1e4;hb=2df82195d140b;hp=0b4e5a262b537ea7de75b4502a83c7480a5c9d27;hpb=3e7622607bd37d4f19b8ef831c27b7b556acf6d5;p=lttng-ust.git diff --git a/include/lttng/ust-tracepoint-event.h b/include/lttng/ust-tracepoint-event.h index 0b4e5a26..ec0e3144 100644 --- a/include/lttng/ust-tracepoint-event.h +++ b/include/lttng/ust-tracepoint-event.h @@ -20,6 +20,7 @@ * SOFTWARE. */ +#include #include #include #include @@ -120,6 +121,30 @@ static const char \ #include TRACEPOINT_INCLUDE +/* + * Stage 0.2 of tracepoint event generation. + * + * 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. + */ + +/* Reset all macros within TRACEPOINT_EVENT */ +#include + +#undef TP_ARGS +#define TP_ARGS(...) __VA_ARGS__ + +#undef TRACEPOINT_EVENT_INSTANCE +#define TRACEPOINT_EVENT_INSTANCE(_provider, _template, _name, _args) \ +void __event_template_proto___##_provider##___##_template(_TP_ARGS_DATA_PROTO(_args)); + +#undef TRACEPOINT_EVENT_CLASS +#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \ +void __event_template_proto___##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args)); + +#include TRACEPOINT_INCLUDE + /* * Stage 0.9 of tracepoint event generation * @@ -191,6 +216,36 @@ static const char \ _values \ ctf_enum_value("", 0) /* Dummy, 0-len array forbidden by C99. */ \ }; +#include TRACEPOINT_INCLUDE + +/* + * Stage 0.9.1 + * Verifying array and sequence elements are of an integer type. + */ + +/* Reset all macros within TRACEPOINT_EVENT */ +#include +#include +#include + +#undef _ctf_array_encoded +#define _ctf_array_encoded(_type, _item, _src, _byte_order, \ + _length, _encoding, _nowrite, \ + _elem_type_base) \ + _lttng_array_element_type_is_supported(_type, _item) + +#undef _ctf_sequence_encoded +#define _ctf_sequence_encoded(_type, _item, _src, _byte_order, \ + _length_type, _src_length, _encoding, _nowrite, \ + _elem_type_base) \ + _lttng_array_element_type_is_supported(_type, _item) + +#undef TP_FIELDS +#define TP_FIELDS(...) __VA_ARGS__ /* Only one used in this phase */ + +#undef TRACEPOINT_EVENT_CLASS +#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \ + _fields #include TRACEPOINT_INCLUDE @@ -212,6 +267,11 @@ static const char \ .name = #_item, \ .type = __type_integer(_type, _byte_order, _base, none),\ .nowrite = _nowrite, \ + .u = { \ + .ext = { \ + .nofilter = 0, \ + }, \ + }, \ }, #undef _ctf_float @@ -220,6 +280,11 @@ static const char \ .name = #_item, \ .type = __type_float(_type), \ .nowrite = _nowrite, \ + .u = { \ + .ext = { \ + .nofilter = 0, \ + }, \ + }, \ }, #undef _ctf_array_encoded @@ -230,38 +295,62 @@ static const char \ .name = #_item, \ .type = \ { \ - .atype = atype_array, \ + .atype = atype_array_nestable, \ .u = \ { \ - .array = \ + .array_nestable = \ { \ - .elem_type = __type_integer(_type, _byte_order, _elem_type_base, _encoding), \ + .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ + __type_integer(_type, _byte_order, _elem_type_base, _encoding)), \ .length = _length, \ + .alignment = 0, \ } \ } \ }, \ .nowrite = _nowrite, \ + .u = { \ + .ext = { \ + .nofilter = 0, \ + }, \ + }, \ }, #undef _ctf_sequence_encoded #define _ctf_sequence_encoded(_type, _item, _src, _byte_order, \ _length_type, _src_length, _encoding, _nowrite, \ _elem_type_base) \ + { \ + .name = "_" #_item "_length", \ + .type = __type_integer(_length_type, BYTE_ORDER, 10, none), \ + .nowrite = _nowrite, \ + .u = { \ + .ext = { \ + .nofilter = 1, \ + }, \ + }, \ + }, \ { \ .name = #_item, \ .type = \ { \ - .atype = atype_sequence, \ + .atype = atype_sequence_nestable, \ .u = \ { \ - .sequence = \ + .sequence_nestable = \ { \ - .length_type = __type_integer(_length_type, BYTE_ORDER, 10, none), \ - .elem_type = __type_integer(_type, _byte_order, _elem_type_base, _encoding), \ + .length_name = "_" #_item "_length", \ + .elem_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ + __type_integer(_type, _byte_order, _elem_type_base, _encoding)), \ + .alignment = 0, \ }, \ }, \ }, \ .nowrite = _nowrite, \ + .u = { \ + .ext = { \ + .nofilter = 0, \ + }, \ + }, \ }, #undef _ctf_string @@ -273,10 +362,15 @@ static const char \ .atype = atype_string, \ .u = \ { \ - .basic = { .string = { .encoding = lttng_encode_UTF8 } } \ + .string = { .encoding = lttng_encode_UTF8 } \ }, \ }, \ .nowrite = _nowrite, \ + .u = { \ + .ext = { \ + .nofilter = 0, \ + }, \ + }, \ }, #undef _ctf_enum @@ -284,24 +378,21 @@ static const char \ { \ .name = #_item, \ .type = { \ - .atype = atype_enum, \ + .atype = atype_enum_nestable, \ .u = { \ - .basic = { \ - .enumeration = { \ - .desc = &__enum_##_provider##_##_name, \ - .container_type = { \ - .size = sizeof(_type) * CHAR_BIT, \ - .alignment = lttng_alignof(_type) * CHAR_BIT, \ - .signedness = lttng_is_signed_type(_type), \ - .reverse_byte_order = 0, \ - .base = 10, \ - .encoding = lttng_encode_none, \ - }, \ - }, \ - }, \ + .enum_nestable = { \ + .desc = &__enum_##_provider##_##_name, \ + .container_type = __LTTNG_COMPOUND_LITERAL(struct lttng_type, \ + __type_integer(_type, BYTE_ORDER, 10, none)), \ + }, \ }, \ }, \ .nowrite = _nowrite, \ + .u = { \ + .ext = { \ + .nofilter = 0, \ + }, \ + }, \ }, #undef TP_FIELDS @@ -666,15 +757,6 @@ size_t __event_get_align__##_provider##___##_name(_TP_ARGS_PROTO(_args)) \ __chan->ops->event_write(&__ctx, _src, \ sizeof(_type) * __get_dynamic_len(dest)); -/* - * __chan->ops->u.has_strcpy is a flag letting us know if the LTTng-UST - * tracepoint provider ABI implements event_strcpy. This dynamic check - * can be removed when the tracepoint provider ABI moves to 2. - */ -#if (LTTNG_UST_PROVIDER_MAJOR > 1) -#error "Tracepoint probe provider major version has changed. Please remove dynamic check for has_strcpy." -#endif - #undef _ctf_string #define _ctf_string(_item, _src, _nowrite) \ { \ @@ -682,12 +764,8 @@ size_t __event_get_align__##_provider##___##_name(_TP_ARGS_PROTO(_args)) \ ((_src) ? (_src) : __LTTNG_UST_NULL_STRING); \ lib_ring_buffer_align_ctx(&__ctx, \ lttng_alignof(*__ctf_tmp_string)); \ - if (__chan->ops->u.has_strcpy) \ - __chan->ops->event_strcpy(&__ctx, __ctf_tmp_string, \ - __get_dynamic_len(dest)); \ - else \ - __chan->ops->event_write(&__ctx, __ctf_tmp_string, \ - __get_dynamic_len(dest)); \ + __chan->ops->event_strcpy(&__ctx, __ctf_tmp_string, \ + __get_dynamic_len(dest)); \ } @@ -756,9 +834,10 @@ void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args)) \ struct lttng_stack_ctx __lttng_ctx; \ size_t __event_len, __event_align; \ size_t __dynamic_len_idx = 0; \ + const size_t __num_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_name) - 1; \ union { \ - size_t __dynamic_len[_TP_ARRAY_SIZE(__event_fields___##_provider##___##_name) - 1]; \ - char __filter_stack_data[2 * sizeof(unsigned long) * (_TP_ARRAY_SIZE(__event_fields___##_provider##___##_name) - 1)]; \ + size_t __dynamic_len[__num_fields]; \ + char __filter_stack_data[2 * sizeof(unsigned long) * __num_fields]; \ } __stackvar; \ int __ret; \ \ @@ -782,8 +861,10 @@ void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args)) \ _TP_ARGS_DATA_VAR(_args)); \ tp_list_for_each_entry_rcu(bc_runtime, &__event->bytecode_runtime_head, node) { \ if (caa_unlikely(bc_runtime->filter(bc_runtime, \ - __stackvar.__filter_stack_data) & LTTNG_FILTER_RECORD_FLAG)) \ + __stackvar.__filter_stack_data) & LTTNG_FILTER_RECORD_FLAG)) { \ __filter_record = 1; \ + break; \ + } \ } \ if (caa_likely(!__filter_record)) \ return; \ @@ -844,14 +925,29 @@ static const char __tp_event_signature___##_provider##___##_name[] = \ /* Reset all macros within TRACEPOINT_EVENT */ #include +/* + * Declare _loglevel___##__provider##___##__name as non-static, with + * hidden visibility for c++ handling of weakref. We do a weakref to the + * symbol in a later stage, which requires that the symbol is not + * mangled. + */ +#ifdef __cplusplus +#define LTTNG_TP_EXTERN_C extern "C" +#else +#define LTTNG_TP_EXTERN_C +#endif + #undef TRACEPOINT_LOGLEVEL #define TRACEPOINT_LOGLEVEL(__provider, __name, __loglevel) \ static const int _loglevel_value___##__provider##___##__name = __loglevel; \ -static const int *_loglevel___##__provider##___##__name = \ +LTTNG_TP_EXTERN_C const int *_loglevel___##__provider##___##__name \ + __attribute__((visibility("hidden"))) = \ &_loglevel_value___##__provider##___##__name; #include TRACEPOINT_INCLUDE +#undef LTTNG_TP_EXTERN_C + /* * Stage 6.1 of tracepoint event generation. * @@ -861,12 +957,27 @@ static const int *_loglevel___##__provider##___##__name = \ /* Reset all macros within TRACEPOINT_EVENT */ #include +/* + * Declare _model_emf_uri___##__provider##___##__name as non-static, + * with hidden visibility for c++ handling of weakref. We do a weakref + * to the symbol in a later stage, which requires that the symbol is not + * mangled. + */ +#ifdef __cplusplus +#define LTTNG_TP_EXTERN_C extern "C" +#else +#define LTTNG_TP_EXTERN_C +#endif + #undef TRACEPOINT_MODEL_EMF_URI #define TRACEPOINT_MODEL_EMF_URI(__provider, __name, __uri) \ -static const char *_model_emf_uri___##__provider##___##__name = __uri; +LTTNG_TP_EXTERN_C const char *_model_emf_uri___##__provider##___##__name \ + __attribute__((visibility("hidden"))) = __uri; \ #include TRACEPOINT_INCLUDE +#undef LTTNG_TP_EXTERN_C + /* * Stage 7.1 of tracepoint event generation. * @@ -977,7 +1088,7 @@ _TP_COMBINE_TOKENS(__lttng_events_init__, TRACEPOINT_PROVIDER)(void) _TP_COMBINE_TOKENS(__tracepoint_provider_check_, TRACEPOINT_PROVIDER)(); ret = lttng_probe_register(&_TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER)); if (ret) { - fprintf(stderr, "LTTng-UST: Error (%d) while registering tracepoint probe. Duplicate registration of tracepoint probes having the same name is not allowed.\n", ret); + fprintf(stderr, "LTTng-UST: Error (%d) while registering tracepoint probe.\n", ret); abort(); } }