X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=include%2Flttng%2Fust-tracepoint-event.h;h=1f8be1a99efd4c5eeb80fd4d6db775dfbd835b11;hb=c42416df21bb28b9b19ca509f7242f660c5469b2;hp=2b599a889662a562dc553e3019456eedb2e8d1e0;hpb=48d660d146a6c8c7c8a54a183faac7d493deb32b;p=lttng-ust.git diff --git a/include/lttng/ust-tracepoint-event.h b/include/lttng/ust-tracepoint-event.h index 2b599a88..1f8be1a9 100644 --- a/include/lttng/ust-tracepoint-event.h +++ b/include/lttng/ust-tracepoint-event.h @@ -20,6 +20,7 @@ * SOFTWARE. */ +#include #include #include #include @@ -28,7 +29,7 @@ #include #include #include -#include +#include #include #define __LTTNG_UST_NULL_STRING "(null)" @@ -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 * @@ -132,14 +157,14 @@ static const char \ #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), \ + .signedness = lttng_is_signed_type(__typeof__(_value)), \ }, \ .end = { \ - .signedness = lttng_is_signed_type(__typeof__(_value)), \ .value = lttng_is_signed_type(__typeof__(_value)) ? \ (long long) (_value) : (_value), \ + .signedness = lttng_is_signed_type(__typeof__(_value)), \ }, \ .string = (_string), \ }, @@ -149,16 +174,36 @@ static const char \ #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), \ + .signedness = lttng_is_signed_type(__typeof__(_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), \ + .signedness = lttng_is_signed_type(__typeof__(_range_end)), \ + }, \ + .string = (_string), \ + }, + +/* Enumeration entry (automatic value; follows the rules of CTF) */ +#undef ctf_enum_auto +#define ctf_enum_auto(_string) \ + { \ + .start = { \ + .value = -1ULL, \ + .signedness = 0, \ + }, \ + .end = { \ + .value = -1ULL, \ + .signedness = 0, \ }, \ .string = (_string), \ + .u = { \ + .extra = { \ + .options = LTTNG_ENUM_ENTRY_OPTION_IS_AUTO, \ + }, \ + }, \ }, #undef TP_ENUM_VALUES @@ -169,7 +214,38 @@ static const char \ #define TRACEPOINT_ENUM(_provider, _name, _values) \ const struct lttng_enum_entry __enum_values__##_provider##_##_name[] = { \ _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 @@ -191,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 @@ -199,46 +280,77 @@ static const char \ .name = #_item, \ .type = __type_float(_type), \ .nowrite = _nowrite, \ + .u = { \ + .ext = { \ + .nofilter = 0, \ + }, \ + }, \ }, #undef _ctf_array_encoded -#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _nowrite) \ +#define _ctf_array_encoded(_type, _item, _src, _byte_order, \ + _length, _encoding, _nowrite, \ + _elem_type_base) \ { \ .name = #_item, \ .type = \ { \ - .atype = atype_array, \ + .atype = atype_array_nestable, \ .u = \ { \ - .array = \ + .array_nestable = \ { \ - .elem_type = __type_integer(_type, BYTE_ORDER, 10, _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 @@ -250,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 @@ -261,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 @@ -288,6 +402,7 @@ static const char \ #define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \ static const struct lttng_event_field __event_fields___##_provider##___##_name[] = { \ _fields \ + ctf_integer(int, dummy, 0) /* Dummy, C99 forbids 0-len array. */ \ }; #undef TRACEPOINT_ENUM @@ -295,7 +410,7 @@ static const char \ static const struct lttng_enum_desc __enum_##_provider##_##_name = { \ .name = #_provider "_" #_name, \ .entries = __enum_values__##_provider##_##_name, \ - .nr_entries = _TP_ARRAY_SIZE(__enum_values__##_provider##_##_name), \ + .nr_entries = _TP_ARRAY_SIZE(__enum_values__##_provider##_##_name) - 1, \ }; #include TRACEPOINT_INCLUDE @@ -318,6 +433,24 @@ static void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args)); #include TRACEPOINT_INCLUDE +/* + * Stage 2.1 of tracepoint event generation. + * + * Create probe event notifier callback prototypes. + */ + +/* Reset all macros within TRACEPOINT_EVENT */ +#include + +#undef TP_ARGS +#define TP_ARGS(...) __VA_ARGS__ + +#undef TRACEPOINT_EVENT_CLASS +#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \ +static void __event_notifier_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args)); + +#include TRACEPOINT_INCLUDE + /* * Stage 3.0 of tracepoint event generation. * @@ -339,7 +472,8 @@ static void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args)); __event_len += sizeof(_type); #undef _ctf_array_encoded -#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _nowrite) \ +#define _ctf_array_encoded(_type, _item, _src, _byte_order, _length, _encoding, \ + _nowrite, _elem_type_base) \ __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \ __event_len += sizeof(_type) * (_length); @@ -486,7 +620,8 @@ size_t __event_get_size__##_provider##___##_name(size_t *__dynamic_len, _TP_ARGS } #undef _ctf_array_encoded -#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _nowrite) \ +#define _ctf_array_encoded(_type, _item, _src, _byte_order, _length, \ + _encoding, _nowrite, _elem_type_base) \ { \ unsigned long __ctf_tmp_ulong = (unsigned long) (_length); \ const void *__ctf_tmp_ptr = (_src); \ @@ -557,7 +692,8 @@ void __event_prepare_filter_stack__##_provider##___##_name(char *__stack_data,\ __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type)); #undef _ctf_array_encoded -#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _nowrite) \ +#define _ctf_array_encoded(_type, _item, _src, _byte_order, _length, \ + _encoding, _nowrite, _elem_type_base) \ __event_align = _tp_max_t(size_t, __event_align, lttng_alignof(_type)); #undef _ctf_sequence_encoded @@ -622,7 +758,8 @@ size_t __event_get_align__##_provider##___##_name(_TP_ARGS_PROTO(_args)) \ } #undef _ctf_array_encoded -#define _ctf_array_encoded(_type, _item, _src, _length, _encoding, _nowrite) \ +#define _ctf_array_encoded(_type, _item, _src, _byte_order, _length, \ + _encoding, _nowrite, _elem_type_base) \ lib_ring_buffer_align_ctx(&__ctx, lttng_alignof(_type)); \ __chan->ops->event_write(&__ctx, _src, sizeof(_type) * (_length)); @@ -638,15 +775,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) \ { \ @@ -654,12 +782,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)); \ } @@ -728,9 +852,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)]; \ - char __filter_stack_data[2 * sizeof(unsigned long) * _TP_ARRAY_SIZE(__event_fields___##_provider##___##_name)]; \ + size_t __dynamic_len[__num_fields]; \ + char __filter_stack_data[2 * sizeof(unsigned long) * __num_fields]; \ } __stackvar; \ int __ret; \ \ @@ -746,16 +871,18 @@ void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args)) \ return; \ if (caa_unlikely(!TP_RCU_LINK_TEST())) \ return; \ - if (caa_unlikely(!cds_list_empty(&__event->bytecode_runtime_head))) { \ - struct lttng_bytecode_runtime *bc_runtime; \ + if (caa_unlikely(!cds_list_empty(&__event->filter_bytecode_runtime_head))) { \ + struct lttng_bytecode_runtime *__filter_bc_runtime; \ int __filter_record = __event->has_enablers_without_bytecode; \ \ __event_prepare_filter_stack__##_provider##___##_name(__stackvar.__filter_stack_data, \ _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)) \ + tp_list_for_each_entry_rcu(__filter_bc_runtime, &__event->filter_bytecode_runtime_head, node) { \ + if (caa_unlikely(__filter_bc_runtime->interpreter_funcs.filter(__filter_bc_runtime, \ + __stackvar.__filter_stack_data) & LTTNG_INTERPRETER_RECORD_FLAG)) { \ __filter_record = 1; \ + break; \ + } \ } \ if (caa_likely(!__filter_record)) \ return; \ @@ -797,13 +924,55 @@ void __event_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args)) \ #undef TRACEPOINT_EVENT_CLASS #define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \ -const char __tp_event_signature___##_provider##___##_name[] = \ +static const char __tp_event_signature___##_provider##___##_name[] = \ _TP_EXTRACT_STRING2(_args); #include TRACEPOINT_INCLUDE #undef _TP_EXTRACT_STRING2 +/* + * Stage 5.2 of tracepoint event generation. + * + * Create the event notifier probe function. + */ +#undef TRACEPOINT_EVENT_CLASS +#define TRACEPOINT_EVENT_CLASS(_provider, _name, _args, _fields) \ +static lttng_ust_notrace \ +void __event_notifier_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args)); \ +static \ +void __event_notifier_probe__##_provider##___##_name(_TP_ARGS_DATA_PROTO(_args)) \ +{ \ + struct lttng_event_notifier *__event_notifier = (struct lttng_event_notifier *) __tp_data; \ + const size_t __num_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_name) - 1;\ + union { \ + size_t __dynamic_len[__num_fields]; \ + char __filter_stack_data[2 * sizeof(unsigned long) * __num_fields]; \ + } __stackvar; \ + if (caa_unlikely(!CMM_ACCESS_ONCE(__event_notifier->enabled))) \ + return; \ + if (caa_unlikely(!TP_RCU_LINK_TEST())) \ + return; \ + if (caa_unlikely(!cds_list_empty(&__event_notifier->filter_bytecode_runtime_head))) { \ + struct lttng_bytecode_runtime *__filter_bc_runtime; \ + int __filter_record = __event_notifier->has_enablers_without_bytecode; \ + \ + __event_prepare_filter_stack__##_provider##___##_name(__stackvar.__filter_stack_data, \ + _TP_ARGS_DATA_VAR(_args)); \ + tp_list_for_each_entry_rcu(__filter_bc_runtime, &__event_notifier->filter_bytecode_runtime_head, node) { \ + if (caa_unlikely(__filter_bc_runtime->interpreter_funcs.filter(__filter_bc_runtime, \ + __stackvar.__filter_stack_data) & LTTNG_INTERPRETER_RECORD_FLAG)) \ + __filter_record = 1; \ + } \ + if (caa_likely(!__filter_record)) \ + return; \ + } \ + \ + lttng_event_notifier_notification_send(__event_notifier); \ +} + +#include TRACEPOINT_INCLUDE + /* * Stage 6 of tracepoint event generation. * @@ -816,14 +985,29 @@ 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. * @@ -833,12 +1017,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. * @@ -858,17 +1057,18 @@ static const int * \ static const char * \ __ref_model_emf_uri___##_provider##___##_name \ __attribute__((weakref ("_model_emf_uri___" #_provider "___" #_name)));\ -const struct lttng_event_desc __event_desc___##_provider##_##_name = { \ +static const struct lttng_event_desc __event_desc___##_provider##_##_name = { \ .name = #_provider ":" #_name, \ .probe_callback = (void (*)(void)) &__event_probe__##_provider##___##_template,\ .ctx = NULL, \ .fields = __event_fields___##_provider##___##_template, \ - .nr_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_template), \ + .nr_fields = _TP_ARRAY_SIZE(__event_fields___##_provider##___##_template) - 1, \ .loglevel = &__ref_loglevel___##_provider##___##_name, \ .signature = __tp_event_signature___##_provider##___##_template, \ .u = { \ .ext = { \ .model_emf_uri = &__ref_model_emf_uri___##_provider##___##_name, \ + .event_notifier_callback = (void (*)(void)) &__event_notifier_probe__##_provider##___##_template,\ }, \ }, \ }; @@ -890,6 +1090,7 @@ const struct lttng_event_desc __event_desc___##_provider##_##_name = { \ static const struct lttng_event_desc *_TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER)[] = { #include TRACEPOINT_INCLUDE + NULL, /* Dummy, C99 forbids 0-len array. */ }; @@ -903,7 +1104,7 @@ static const struct lttng_event_desc *_TP_COMBINE_TOKENS(__event_desc___, TRACEP static struct lttng_probe_desc _TP_COMBINE_TOKENS(__probe_desc___, TRACEPOINT_PROVIDER) = { .provider = __tp_stringify(TRACEPOINT_PROVIDER), .event_desc = _TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER), - .nr_events = _TP_ARRAY_SIZE(_TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER)), + .nr_events = _TP_ARRAY_SIZE(_TP_COMBINE_TOKENS(__event_desc___, TRACEPOINT_PROVIDER)) - 1, .head = { NULL, NULL }, .lazy_init_head = { NULL, NULL }, .lazy = 0, @@ -948,7 +1149,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(); } }