X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fust-metadata.c;h=fb1f1152180aad9d714831a9dfc70e1ec2f2a4ee;hp=f430ae1f1e8ed390df410b71370f1771286afc66;hb=8ada111f6d3ab40d1c33cf1a7b2546de9a47d1d5;hpb=8c645bb0c85b560355bf01337ca82dd4904a0ff3 diff --git a/src/bin/lttng-sessiond/ust-metadata.c b/src/bin/lttng-sessiond/ust-metadata.c index f430ae1f1..fb1f11521 100644 --- a/src/bin/lttng-sessiond/ust-metadata.c +++ b/src/bin/lttng-sessiond/ust-metadata.c @@ -19,7 +19,7 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE +#define _LGPL_SOURCE #include #include #include @@ -28,6 +28,7 @@ #include #include #include +#include #include "ust-registry.h" #include "ust-clock.h" @@ -40,10 +41,15 @@ #define NR_CLOCK_OFFSET_SAMPLES 10 struct offset_sample { - uint64_t offset; /* correlation offset */ + int64_t offset; /* correlation offset */ uint64_t measure_delta; /* lower is better */ }; +static +int _lttng_field_statedump(struct ust_registry_session *session, + const struct ustctl_field *fields, size_t nr_fields, + size_t *iter_field, size_t nesting); + static inline int fls(unsigned int x) { @@ -68,7 +74,6 @@ int fls(unsigned int x) r -= 2; } if (!(x & 0x80000000U)) { - x <<= 1; r -= 1; } return r; @@ -119,6 +124,23 @@ ssize_t metadata_reserve(struct ust_registry_session *session, size_t len) return ret; } +static +int metadata_file_append(struct ust_registry_session *session, + const char *str, size_t len) +{ + ssize_t written; + + if (session->metadata_fd < 0) { + return 0; + } + /* Write to metadata file */ + written = lttng_write(session->metadata_fd, str, len); + if (written != len) { + return -1; + } + return 0; +} + /* * We have exclusive access to our metadata buffer (protected by the * ust_lock), so we can do racy operations such as looking for @@ -148,6 +170,11 @@ int lttng_metadata_printf(struct ust_registry_session *session, goto end; } memcpy(&session->metadata[offset], str, len); + ret = metadata_file_append(session, str, len); + if (ret) { + PERROR("Error appending to metadata file"); + goto end; + } DBG3("Append to metadata: \"%s\"", str); ret = 0; @@ -156,25 +183,268 @@ end: return ret; } +static +int print_tabs(struct ust_registry_session *session, size_t nesting) +{ + size_t i; + + for (i = 0; i < nesting; i++) { + int ret; + + ret = lttng_metadata_printf(session, " "); + if (ret) { + return ret; + } + } + return 0; +} + +static +void sanitize_ctf_identifier(char *out, const char *in) +{ + size_t i; + + for (i = 0; i < LTTNG_UST_SYM_NAME_LEN; i++) { + switch (in[i]) { + case '.': + case '$': + case ':': + out[i] = '_'; + break; + default: + out[i] = in[i]; + } + } +} + +/* Called with session registry mutex held. */ +static +int ust_metadata_enum_statedump(struct ust_registry_session *session, + const char *enum_name, + uint64_t enum_id, + const struct ustctl_integer_type *container_type, + const char *field_name, size_t *iter_field, size_t nesting) +{ + struct ust_registry_enum *reg_enum; + const struct ustctl_enum_entry *entries; + size_t nr_entries; + int ret = 0; + size_t i; + char identifier[LTTNG_UST_SYM_NAME_LEN]; + + rcu_read_lock(); + reg_enum = ust_registry_lookup_enum_by_id(session, enum_name, enum_id); + rcu_read_unlock(); + /* reg_enum can still be used because session registry mutex is held. */ + if (!reg_enum) { + ret = -ENOENT; + goto end; + } + entries = reg_enum->entries; + nr_entries = reg_enum->nr_entries; + + ret = print_tabs(session, nesting); + if (ret) { + goto end; + } + ret = lttng_metadata_printf(session, + "enum : integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u; } {\n", + container_type->size, + container_type->alignment, + container_type->signedness, + (container_type->encoding == ustctl_encode_none) + ? "none" + : (container_type->encoding == ustctl_encode_UTF8) + ? "UTF8" + : "ASCII", + container_type->base); + if (ret) { + goto end; + } + nesting++; + /* Dump all entries */ + for (i = 0; i < nr_entries; i++) { + const struct ustctl_enum_entry *entry = &entries[i]; + int j, len; + + ret = print_tabs(session, nesting); + if (ret) { + goto end; + } + ret = lttng_metadata_printf(session, + "\""); + if (ret) { + goto end; + } + len = strlen(entry->string); + /* Escape the character '"' */ + for (j = 0; j < len; j++) { + char c = entry->string[j]; + + switch (c) { + case '"': + ret = lttng_metadata_printf(session, + "\\\""); + break; + case '\\': + ret = lttng_metadata_printf(session, + "\\\\"); + break; + default: + ret = lttng_metadata_printf(session, + "%c", c); + break; + } + if (ret) { + goto end; + } + } + ret = lttng_metadata_printf(session, "\""); + if (ret) { + goto end; + } + + if (entry->u.extra.options & + USTCTL_UST_ENUM_ENTRY_OPTION_IS_AUTO) { + ret = lttng_metadata_printf(session, ",\n"); + if (ret) { + goto end; + } + } else { + ret = lttng_metadata_printf(session, + " = "); + if (ret) { + goto end; + } + + if (entry->start.signedness) { + ret = lttng_metadata_printf(session, + "%lld", (long long) entry->start.value); + } else { + ret = lttng_metadata_printf(session, + "%llu", entry->start.value); + } + if (ret) { + goto end; + } + + if (entry->start.signedness == entry->end.signedness && + entry->start.value == + entry->end.value) { + ret = lttng_metadata_printf(session, ",\n"); + } else { + if (entry->end.signedness) { + ret = lttng_metadata_printf(session, + " ... %lld,\n", + (long long) entry->end.value); + } else { + ret = lttng_metadata_printf(session, + " ... %llu,\n", + entry->end.value); + } + } + if (ret) { + goto end; + } + } + } + nesting--; + sanitize_ctf_identifier(identifier, field_name); + ret = print_tabs(session, nesting); + if (ret) { + goto end; + } + ret = lttng_metadata_printf(session, "} _%s;\n", + identifier); +end: + (*iter_field)++; + return ret; +} + +static +int _lttng_variant_statedump(struct ust_registry_session *session, + const struct ustctl_field *fields, size_t nr_fields, + size_t *iter_field, size_t nesting) +{ + const struct ustctl_field *variant = &fields[*iter_field]; + uint32_t nr_choices, i; + int ret; + char identifier[LTTNG_UST_SYM_NAME_LEN]; + + if (variant->type.atype != ustctl_atype_variant) { + ret = -EINVAL; + goto end; + } + nr_choices = variant->type.u.variant.nr_choices; + (*iter_field)++; + sanitize_ctf_identifier(identifier, variant->type.u.variant.tag_name); + ret = print_tabs(session, nesting); + if (ret) { + goto end; + } + ret = lttng_metadata_printf(session, + "variant <_%s> {\n", + identifier); + if (ret) { + goto end; + } + + for (i = 0; i < nr_choices; i++) { + if (*iter_field >= nr_fields) { + ret = -EOVERFLOW; + goto end; + } + ret = _lttng_field_statedump(session, + fields, nr_fields, + iter_field, nesting + 1); + if (ret) { + goto end; + } + } + sanitize_ctf_identifier(identifier, variant->name); + ret = print_tabs(session, nesting); + ret = lttng_metadata_printf(session, + "} _%s;\n", + identifier); + if (ret) { + goto end; + } +end: + return ret; +} + static int _lttng_field_statedump(struct ust_registry_session *session, - const struct ustctl_field *field) + const struct ustctl_field *fields, size_t nr_fields, + size_t *iter_field, size_t nesting) { int ret = 0; const char *bo_be = " byte_order = be;"; const char *bo_le = " byte_order = le;"; const char *bo_native = ""; const char *bo_reverse; + const struct ustctl_field *field; + + if (*iter_field >= nr_fields) { + ret = -EOVERFLOW; + goto end; + } + field = &fields[*iter_field]; - if (session->byte_order == BIG_ENDIAN) + if (session->byte_order == BIG_ENDIAN) { bo_reverse = bo_le; - else + } else { bo_reverse = bo_be; + } switch (field->type.atype) { case ustctl_atype_integer: + ret = print_tabs(session, nesting); + if (ret) { + goto end; + } ret = lttng_metadata_printf(session, - " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s;\n", + "integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s;\n", field->type.u.basic.integer.size, field->type.u.basic.integer.alignment, field->type.u.basic.integer.signedness, @@ -186,25 +456,40 @@ int _lttng_field_statedump(struct ust_registry_session *session, field->type.u.basic.integer.base, field->type.u.basic.integer.reverse_byte_order ? bo_reverse : bo_native, field->name); + (*iter_field)++; + break; + case ustctl_atype_enum: + ret = ust_metadata_enum_statedump(session, + field->type.u.basic.enumeration.name, + field->type.u.basic.enumeration.id, + &field->type.u.basic.enumeration.container_type, + field->name, iter_field, nesting); break; case ustctl_atype_float: + ret = print_tabs(session, nesting); + if (ret) { + goto end; + } ret = lttng_metadata_printf(session, - " floating_point { exp_dig = %u; mant_dig = %u; align = %u;%s } _%s;\n", + "floating_point { exp_dig = %u; mant_dig = %u; align = %u;%s } _%s;\n", field->type.u.basic._float.exp_dig, field->type.u.basic._float.mant_dig, field->type.u.basic._float.alignment, field->type.u.basic.integer.reverse_byte_order ? bo_reverse : bo_native, field->name); + (*iter_field)++; break; - case ustctl_atype_enum: - return -EINVAL; case ustctl_atype_array: { const struct ustctl_basic_type *elem_type; + ret = print_tabs(session, nesting); + if (ret) { + goto end; + } elem_type = &field->type.u.array.elem_type; ret = lttng_metadata_printf(session, - " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[%u];\n", + "integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[%u];\n", elem_type->u.basic.integer.size, elem_type->u.basic.integer.alignment, elem_type->u.basic.integer.signedness, @@ -216,6 +501,7 @@ int _lttng_field_statedump(struct ust_registry_session *session, elem_type->u.basic.integer.base, elem_type->u.basic.integer.reverse_byte_order ? bo_reverse : bo_native, field->name, field->type.u.array.length); + (*iter_field)++; break; } case ustctl_atype_sequence: @@ -225,8 +511,12 @@ int _lttng_field_statedump(struct ust_registry_session *session, elem_type = &field->type.u.sequence.elem_type; length_type = &field->type.u.sequence.length_type; + ret = print_tabs(session, nesting); + if (ret) { + goto end; + } ret = lttng_metadata_printf(session, - " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } __%s_length;\n", + "integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } __%s_length;\n", length_type->u.basic.integer.size, (unsigned int) length_type->u.basic.integer.alignment, length_type->u.basic.integer.signedness, @@ -238,11 +528,16 @@ int _lttng_field_statedump(struct ust_registry_session *session, length_type->u.basic.integer.base, length_type->u.basic.integer.reverse_byte_order ? bo_reverse : bo_native, field->name); - if (ret) - return ret; + if (ret) { + goto end; + } + ret = print_tabs(session, nesting); + if (ret) { + goto end; + } ret = lttng_metadata_printf(session, - " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[ __%s_length ];\n", + "integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[ __%s_length ];\n", elem_type->u.basic.integer.size, (unsigned int) elem_type->u.basic.integer.alignment, elem_type->u.basic.integer.signedness, @@ -255,20 +550,43 @@ int _lttng_field_statedump(struct ust_registry_session *session, elem_type->u.basic.integer.reverse_byte_order ? bo_reverse : bo_native, field->name, field->name); + (*iter_field)++; break; } case ustctl_atype_string: /* Default encoding is UTF8 */ + ret = print_tabs(session, nesting); + if (ret) { + goto end; + } ret = lttng_metadata_printf(session, - " string%s _%s;\n", + "string%s _%s;\n", field->type.u.basic.string.encoding == ustctl_encode_ASCII ? " { encoding = ASCII; }" : "", field->name); + (*iter_field)++; + break; + case ustctl_atype_variant: + ret = _lttng_variant_statedump(session, fields, nr_fields, iter_field, nesting); + if (ret) { + goto end; + } + break; + case ustctl_atype_struct: + ret = print_tabs(session, nesting); + if (ret) { + goto end; + } + ret = lttng_metadata_printf(session, + "struct {} _%s;\n", + field->name); + (*iter_field)++; break; default: - return -EINVAL; + ret = -EINVAL; } +end: return ret; } @@ -278,16 +596,19 @@ int _lttng_context_metadata_statedump(struct ust_registry_session *session, struct ustctl_field *ctx) { int ret = 0; - int i; + size_t i = 0; if (!ctx) return 0; - for (i = 0; i < nr_ctx_fields; i++) { - const struct ustctl_field *field = &ctx[i]; - - ret = _lttng_field_statedump(session, field); - if (ret) - return ret; + for (;;) { + if (i >= nr_ctx_fields) { + break; + } + ret = _lttng_field_statedump(session, ctx, + nr_ctx_fields, &i, 2); + if (ret) { + break; + } } return ret; } @@ -297,14 +618,17 @@ int _lttng_fields_metadata_statedump(struct ust_registry_session *session, struct ust_registry_event *event) { int ret = 0; - int i; - - for (i = 0; i < event->nr_fields; i++) { - const struct ustctl_field *field = &event->fields[i]; + size_t i = 0; - ret = _lttng_field_statedump(session, field); - if (ret) - return ret; + for (;;) { + if (i >= event->nr_fields) { + break; + } + ret = _lttng_field_statedump(session, event->fields, + event->nr_fields, &i, 2); + if (ret) { + break; + } } return ret; } @@ -335,7 +659,7 @@ int ust_metadata_event_statedump(struct ust_registry_session *session, ret = lttng_metadata_printf(session, " loglevel = %d;\n", - event->loglevel); + event->loglevel_value); if (ret) goto end; @@ -347,23 +671,6 @@ int ust_metadata_event_statedump(struct ust_registry_session *session, goto end; } -#if 0 /* context for events not supported */ - if (event->ctx) { - ret = lttng_metadata_printf(session, - " context := struct {\n"); - if (ret) - goto end; - } - ret = _lttng_context_metadata_statedump(session, event->ctx); - if (ret) - goto end; - if (event->ctx) { - ret = lttng_metadata_printf(session, - " };\n"); - if (ret) - goto end; - } -#endif ret = lttng_metadata_printf(session, " fields := struct {\n" ); @@ -448,6 +755,7 @@ int _lttng_stream_packet_context_declare(struct ust_registry_session *session) " uint64_clock_monotonic_t timestamp_end;\n" " uint64_t content_size;\n" " uint64_t packet_size;\n" + " uint64_t packet_seq_num;\n" " unsigned long events_discarded;\n" " uint32_t cpu_id;\n" "};\n\n" @@ -497,15 +805,20 @@ int _lttng_event_header_declare(struct ust_registry_session *session) ); } +/* + * The offset between monotonic and realtime clock can be negative if + * the system sets the REALTIME clock to 0 after boot. + */ static int measure_single_clock_offset(struct offset_sample *sample) { - uint64_t offset, monotonic[2], measure_delta, realtime; + uint64_t monotonic_avg, monotonic[2], measure_delta, realtime; + uint64_t tcf = trace_clock_freq(); struct timespec rts = { 0, 0 }; int ret; monotonic[0] = trace_clock_read64(); - ret = clock_gettime(CLOCK_REALTIME, &rts); + ret = lttng_clock_gettime(CLOCK_REALTIME, &rts); if (ret < 0) { return ret; } @@ -518,11 +831,14 @@ int measure_single_clock_offset(struct offset_sample *sample) */ return 0; } - offset = (monotonic[0] + monotonic[1]) >> 1; - realtime = (uint64_t) rts.tv_sec * 1000000000ULL; - realtime += rts.tv_nsec; - offset = realtime - offset; - sample->offset = offset; + monotonic_avg = (monotonic[0] + monotonic[1]) >> 1; + realtime = (uint64_t) rts.tv_sec * tcf; + if (tcf == NSEC_PER_SEC) { + realtime += rts.tv_nsec; + } else { + realtime += (uint64_t) rts.tv_nsec * tcf / NSEC_PER_SEC; + } + sample->offset = (int64_t) realtime - monotonic_avg; sample->measure_delta = measure_delta; return 0; } @@ -531,9 +847,10 @@ int measure_single_clock_offset(struct offset_sample *sample) * Approximation of NTP time of day to clock monotonic correlation, * taken at start of trace. Keep the measurement that took the less time * to complete, thus removing imprecision caused by preemption. + * May return a negative offset. */ static -uint64_t measure_clock_offset(void) +int64_t measure_clock_offset(void) { int i; struct offset_sample offset_best_sample = { @@ -574,6 +891,15 @@ int ust_metadata_session_statedump(struct ust_registry_session *session, uuid_c[8], uuid_c[9], uuid_c[10], uuid_c[11], uuid_c[12], uuid_c[13], uuid_c[14], uuid_c[15]); + /* For crash ABI */ + ret = lttng_metadata_printf(session, + "/* CTF %u.%u */\n\n", + CTF_SPEC_MAJOR, + CTF_SPEC_MINOR); + if (ret) { + goto end; + } + ret = lttng_metadata_printf(session, "typealias integer { size = 8; align = %u; signed = false; } := uint8_t;\n" "typealias integer { size = 16; align = %u; signed = false; } := uint16_t;\n" @@ -592,6 +918,7 @@ int ust_metadata_session_statedump(struct ust_registry_session *session, " uint32_t magic;\n" " uint8_t uuid[16];\n" " uint32_t stream_id;\n" + " uint64_t stream_instance_id;\n" " };\n" "};\n\n", session->uint8_t_alignment, @@ -653,8 +980,8 @@ int ust_metadata_session_statedump(struct ust_registry_session *session, ret = lttng_metadata_printf(session, "clock {\n" - " name = %s;\n", - "monotonic" + " name = \"%s\";\n", + trace_clock_name() ); if (ret) goto end; @@ -669,11 +996,12 @@ int ust_metadata_session_statedump(struct ust_registry_session *session, } ret = lttng_metadata_printf(session, - " description = \"Monotonic Clock\";\n" + " description = \"%s\";\n" " freq = %" PRIu64 "; /* Frequency, in Hz */\n" " /* clock value offset from Epoch is: offset * (1/freq) */\n" - " offset = %" PRIu64 ";\n" + " offset = %" PRId64 ";\n" "};\n\n", + trace_clock_description(), trace_clock_freq(), measure_clock_offset() ); @@ -683,20 +1011,23 @@ int ust_metadata_session_statedump(struct ust_registry_session *session, ret = lttng_metadata_printf(session, "typealias integer {\n" " size = 27; align = 1; signed = false;\n" - " map = clock.monotonic.value;\n" + " map = clock.%s.value;\n" "} := uint27_clock_monotonic_t;\n" "\n" "typealias integer {\n" " size = 32; align = %u; signed = false;\n" - " map = clock.monotonic.value;\n" + " map = clock.%s.value;\n" "} := uint32_clock_monotonic_t;\n" "\n" "typealias integer {\n" " size = 64; align = %u; signed = false;\n" - " map = clock.monotonic.value;\n" + " map = clock.%s.value;\n" "} := uint64_clock_monotonic_t;\n\n", + trace_clock_name(), session->uint32_t_alignment, - session->uint64_t_alignment + trace_clock_name(), + session->uint64_t_alignment, + trace_clock_name() ); if (ret) goto end;