X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=plugins%2Fctf%2Fcommon%2Fmetadata%2Fvisitor-generate-ir.c;h=cb50a7e767737fdcd622f1012c587cfd413cca8c;hb=9ac68eb139149d2768848dae5e263cc5a755d439;hp=ec406bab4573dda7eb1649487eb4c7dde8f8cd68;hpb=06a626b83f4426ea5b8d3199d1edf5a07594026e;p=babeltrace.git diff --git a/plugins/ctf/common/metadata/visitor-generate-ir.c b/plugins/ctf/common/metadata/visitor-generate-ir.c index ec406bab..cb50a7e7 100644 --- a/plugins/ctf/common/metadata/visitor-generate-ir.c +++ b/plugins/ctf/common/metadata/visitor-generate-ir.c @@ -36,18 +36,16 @@ #include #include #include -#include -#include -#include +#include +#include #include -#include #include #include #include #include #include #include -#include +#include #include "scanner.h" #include "parser.h" @@ -120,6 +118,25 @@ enum { _EVENT_FIELDS_SET = _BV(6), }; +enum loglevel { + LOGLEVEL_EMERG = 0, + LOGLEVEL_ALERT = 1, + LOGLEVEL_CRIT = 2, + LOGLEVEL_ERR = 3, + LOGLEVEL_WARNING = 4, + LOGLEVEL_NOTICE = 5, + LOGLEVEL_INFO = 6, + LOGLEVEL_DEBUG_SYSTEM = 7, + LOGLEVEL_DEBUG_PROGRAM = 8, + LOGLEVEL_DEBUG_PROCESS = 9, + LOGLEVEL_DEBUG_MODULE = 10, + LOGLEVEL_DEBUG_UNIT = 11, + LOGLEVEL_DEBUG_FUNCTION = 12, + LOGLEVEL_DEBUG_LINE = 13, + LOGLEVEL_DEBUG = 14, + _NR_LOGLEVELS = 15, +}; + /* Prefixes of type aliases */ #define _PREFIX_ALIAS 'a' #define _PREFIX_ENUM 'e' @@ -135,30 +152,35 @@ enum { /* Error printing wrappers */ #define _PERROR(_fmt, ...) \ do { \ + if (!ctx->efd) break; \ fprintf(ctx->efd, "[error] %s: " _fmt "\n", \ __func__, __VA_ARGS__); \ } while (0) #define _PWARNING(_fmt, ...) \ do { \ + if (!ctx->efd) break; \ fprintf(ctx->efd, "[warning] %s: " _fmt "\n", \ __func__, __VA_ARGS__); \ } while (0) #define _FPERROR(_stream, _fmt, ...) \ do { \ + if (!_stream) break; \ fprintf(_stream, "[error] %s: " _fmt "\n", \ __func__, __VA_ARGS__); \ } while (0) #define _FPWARNING(_stream, _fmt, ...) \ do { \ + if (!_stream) break; \ fprintf(_stream, "[warning] %s: " _fmt "\n", \ __func__, __VA_ARGS__); \ } while (0) #define _PERROR_DUP_ATTR(_attr, _entity) \ do { \ + if (!ctx->efd) break; \ fprintf(ctx->efd, \ "[error] %s: duplicate attribute \"" \ _attr "\" in " _entity "\n", __func__); \ @@ -182,10 +204,10 @@ struct ctx_decl_scope { }; /* - * Visitor context. + * Visitor context (private). */ struct ctx { - /* Trace being filled (weak ref.) */ + /* Trace being filled (owned by this) */ struct bt_ctf_trace *trace; /* Error stream to use during visit */ @@ -197,7 +219,14 @@ struct ctx { /* 1 if trace declaration is visited */ int is_trace_visited; + /* 1 if this is an LTTng trace */ + bool is_lttng; + + /* Offset (ns) to apply to clock classes on creation */ + uint64_t clock_class_offset_ns; + /* Trace attributes */ + enum bt_ctf_byte_order trace_bo; uint64_t trace_major; uint64_t trace_minor; unsigned char trace_uuid[BABELTRACE_UUID_LEN]; @@ -210,6 +239,42 @@ struct ctx { GHashTable *stream_classes; }; +/* + * Visitor (public). + */ +struct ctf_visitor_generate_ir { }; + +static +const char *loglevel_str [] = { + [ LOGLEVEL_EMERG ] = "TRACE_EMERG", + [ LOGLEVEL_ALERT ] = "TRACE_ALERT", + [ LOGLEVEL_CRIT ] = "TRACE_CRIT", + [ LOGLEVEL_ERR ] = "TRACE_ERR", + [ LOGLEVEL_WARNING ] = "TRACE_WARNING", + [ LOGLEVEL_NOTICE ] = "TRACE_NOTICE", + [ LOGLEVEL_INFO ] = "TRACE_INFO", + [ LOGLEVEL_DEBUG_SYSTEM ] = "TRACE_DEBUG_SYSTEM", + [ LOGLEVEL_DEBUG_PROGRAM ] = "TRACE_DEBUG_PROGRAM", + [ LOGLEVEL_DEBUG_PROCESS ] = "TRACE_DEBUG_PROCESS", + [ LOGLEVEL_DEBUG_MODULE ] = "TRACE_DEBUG_MODULE", + [ LOGLEVEL_DEBUG_UNIT ] = "TRACE_DEBUG_UNIT", + [ LOGLEVEL_DEBUG_FUNCTION ] = "TRACE_DEBUG_FUNCTION", + [ LOGLEVEL_DEBUG_LINE ] = "TRACE_DEBUG_LINE", + [ LOGLEVEL_DEBUG ] = "TRACE_DEBUG", +}; + +static +const char *print_loglevel(int64_t value) +{ + if (value < 0) { + return NULL; + } + if (value >= _NR_LOGLEVELS) { + return "<>"; + } + return loglevel_str[value]; +} + /** * Creates a new declaration scope. * @@ -514,12 +579,13 @@ int ctx_decl_scope_register_variant(struct ctx_decl_scope *scope, * @returns New visitor context, or NULL on error */ static -struct ctx *ctx_create(struct bt_ctf_trace *trace, FILE *efd) +struct ctx *ctx_create(struct bt_ctf_trace *trace, FILE *efd, + uint64_t clock_class_offset_ns) { struct ctx *ctx = NULL; struct ctx_decl_scope *scope = NULL; - ctx = g_new(struct ctx, 1); + ctx = g_new0(struct ctx, 1); if (!ctx) { goto error; } @@ -539,14 +605,13 @@ struct ctx *ctx_create(struct bt_ctf_trace *trace, FILE *efd) ctx->trace = trace; ctx->efd = efd; ctx->current_scope = scope; - ctx->is_trace_visited = FALSE; - + ctx->trace_bo = BT_CTF_BYTE_ORDER_NATIVE; + ctx->clock_class_offset_ns = clock_class_offset_ns; return ctx; error: g_free(ctx); ctx_decl_scope_destroy(scope); - return NULL; } @@ -576,6 +641,7 @@ void ctx_destroy(struct ctx *ctx) scope = parent_scope; } + bt_put(ctx->trace); g_hash_table_destroy(ctx->stream_classes); g_free(ctx); @@ -1768,6 +1834,15 @@ int visit_struct_decl(struct ctx *ctx, const char *name, goto error; } + if (min_align_value != 0) { + ret = bt_ctf_field_type_set_alignment(*struct_decl, + min_align_value); + if (ret) { + _PERROR("%s", "failed to set structure's minimal alignment"); + goto error; + } + } + ret = ctx_push_scope(ctx); if (ret) { _PERROR("%s", "cannot push scope"); @@ -2188,7 +2263,7 @@ int visit_integer_decl(struct ctx *ctx, int signedness = 0; struct ctf_node *expression; uint64_t alignment = 0, size = 0; - struct bt_ctf_clock *mapped_clock = NULL; + struct bt_ctf_clock_class *mapped_clock = NULL; enum bt_ctf_string_encoding encoding = BT_CTF_STRING_ENCODING_NONE; enum bt_ctf_integer_base base = BT_CTF_INTEGER_BASE_DECIMAL; enum bt_ctf_byte_order byte_order = @@ -2448,17 +2523,17 @@ int visit_integer_decl(struct ctx *ctx, goto error; } - _PWARNING("invalid \"map\" attribute in integer declaration: unknown clock: \"%s\"", + _PWARNING("invalid \"map\" attribute in integer declaration: unknown clock class: \"%s\"", s_right); _SET(&set, _INTEGER_MAP_SET); g_free(s_right); continue; } - mapped_clock = bt_ctf_trace_get_clock_by_name( + mapped_clock = bt_ctf_trace_get_clock_class_by_name( ctx->trace, clock_name); if (!mapped_clock) { - _PERROR("invalid \"map\" attribute in integer declaration: cannot find clock \"%s\"", + _PERROR("invalid \"map\" attribute in integer declaration: cannot find clock class \"%s\"", clock_name); ret = -EINVAL; goto error; @@ -2504,7 +2579,7 @@ int visit_integer_decl(struct ctx *ctx, if (mapped_clock) { /* Move clock */ - ret |= bt_ctf_field_type_integer_set_mapped_clock( + ret |= bt_ctf_field_type_integer_set_mapped_clock_class( *integer_decl, mapped_clock); bt_put(mapped_clock); mapped_clock = NULL; @@ -3047,7 +3122,9 @@ int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node, _SET(set, _EVENT_FIELDS_SET); } else if (!strcmp(left, "loglevel")) { - uint64_t loglevel; + uint64_t loglevel_value; + const char *loglevel_str; + struct bt_value *value_obj, *str_obj; if (_IS_SET(set, _EVENT_LOGLEVEL_SET)) { _PERROR_DUP_ATTR("loglevel", @@ -3057,15 +3134,38 @@ int visit_event_decl_entry(struct ctx *ctx, struct ctf_node *node, } ret = get_unary_unsigned(&node->u.ctf_expression.right, - &loglevel); + &loglevel_value); if (ret) { _PERROR("%s", "unexpected unary expression for event declaration's \"loglevel\" attribute"); ret = -EINVAL; goto error; } - - // TODO: FIXME: set log level here - + value_obj = bt_value_integer_create_init(loglevel_value); + if (!value_obj) { + _PERROR("%s", "cannot allocate memory for loglevel value object"); + ret = -ENOMEM; + goto error; + } + if (bt_ctf_event_class_set_attribute(event_class, + "loglevel", value_obj) != BT_VALUE_STATUS_OK) { + _PERROR("%s", "cannot set loglevel value"); + ret = -EINVAL; + bt_put(value_obj); + goto error; + } + loglevel_str = print_loglevel(loglevel_value); + if (loglevel_str) { + str_obj = bt_value_string_create_init(loglevel_str); + if (bt_ctf_event_class_set_attribute(event_class, + "loglevel_string", str_obj) != BT_VALUE_STATUS_OK) { + _PERROR("%s", "cannot set loglevel string"); + ret = -EINVAL; + bt_put(str_obj); + goto error; + } + bt_put(str_obj); + } + bt_put(value_obj); _SET(set, _EVENT_LOGLEVEL_SET); } else if (!strcmp(left, "model.emf.uri")) { char *right; @@ -3163,43 +3263,21 @@ int reset_event_decl_types(struct ctx *ctx, struct bt_ctf_event_class *event_class) { int ret = 0; - _BT_CTF_FIELD_TYPE_INIT(decl); - - /* Event context */ - decl = bt_ctf_field_type_structure_create(); - if (!decl) { - _PERROR("%s", "cannot create initial, empty event context structure"); - ret = -ENOMEM; - goto error; - } - ret = bt_ctf_event_class_set_context_type(event_class, decl); - BT_PUT(decl); + /* Context type. */ + ret = bt_ctf_event_class_set_context_type(event_class, NULL); if (ret) { - _PERROR("%s", "cannot set initial, empty event context structure"); - goto error; - } - - /* Event payload */ - decl = bt_ctf_field_type_structure_create(); - if (!decl) { - _PERROR("%s", "cannot create initial, empty event payload structure"); - ret = -ENOMEM; - goto error; + _PERROR("%s", "cannot set initial NULL event context"); + goto end; } - ret = bt_ctf_event_class_set_payload_type(event_class, decl); - BT_PUT(decl); + /* Event payload. */ + ret = bt_ctf_event_class_set_payload_type(event_class, NULL); if (ret) { - _PERROR("%s", "cannot set initial, empty event payload structure"); - goto error; + _PERROR("%s", "cannot set initial NULL event payload"); + goto end; } - - return 0; - -error: - BT_PUT(decl); - +end: return ret; } @@ -3208,58 +3286,28 @@ int reset_stream_decl_types(struct ctx *ctx, struct bt_ctf_stream_class *stream_class) { int ret = 0; - _BT_CTF_FIELD_TYPE_INIT(decl); - - /* Packet context */ - decl = bt_ctf_field_type_structure_create(); - if (!decl) { - _PERROR("%s", "cannot create initial, empty packet context structure"); - ret = -ENOMEM; - goto error; - } - ret = bt_ctf_stream_class_set_packet_context_type(stream_class, decl); - BT_PUT(decl); + /* Packet context. */ + ret = bt_ctf_stream_class_set_packet_context_type(stream_class, NULL); if (ret) { - _PERROR("%s", "cannot set initial, empty packet context structure"); - goto error; - } - - /* Event header */ - decl = bt_ctf_field_type_structure_create(); - if (!decl) { - _PERROR("%s", "cannot create initial, empty event header structure"); - ret = -ENOMEM; - goto error; + _PERROR("%s", "cannot set initial empty packet context"); + goto end; } - ret = bt_ctf_stream_class_set_event_header_type(stream_class, decl); - BT_PUT(decl); + /* Event header. */ + ret = bt_ctf_stream_class_set_event_header_type(stream_class, NULL); if (ret) { - _PERROR("%s", "cannot set initial, empty event header structure"); - goto error; - } - - /* Event context */ - decl = bt_ctf_field_type_structure_create(); - if (!decl) { - _PERROR("%s", "cannot create initial, empty stream event context structure"); - ret = -ENOMEM; - goto error; + _PERROR("%s", "cannot set initial empty event header"); + goto end; } - ret = bt_ctf_stream_class_set_event_context_type(stream_class, decl); - BT_PUT(decl); + /* Event context. */ + ret = bt_ctf_stream_class_set_event_context_type(stream_class, NULL); if (ret) { - _PERROR("%s", "cannot set initial, empty stream event context structure"); - goto error; + _PERROR("%s", "cannot set initial empty stream event context"); + goto end; } - - return 0; - -error: - BT_PUT(decl); - +end: return ret; } @@ -3276,8 +3324,8 @@ struct bt_ctf_stream_class *create_reset_stream_class(struct ctx *ctx) } /* - * Set packet context, event header, and event context to empty - * structures to override the default ones. + * Set packet context, event header, and event context to NULL to + * override the default ones. */ ret = reset_stream_decl_types(ctx, stream_class); if (ret) { @@ -3303,8 +3351,9 @@ int visit_event_decl(struct ctx *ctx, struct ctf_node *node) char *event_name = NULL; struct bt_ctf_event_class *event_class = NULL; struct bt_ctf_event_class *eevent_class; - struct bt_ctf_stream_class *stream_class; + struct bt_ctf_stream_class *stream_class = NULL; struct bt_list_head *decl_list = &node->u.event.declaration_list; + bool pop_scope = false; if (node->visited) { goto end; @@ -3322,21 +3371,21 @@ int visit_event_decl(struct ctx *ctx, struct ctf_node *node) event_class = bt_ctf_event_class_create(event_name); /* - * Set context and fields to empty structures to override the - * default ones. + * Unset context and fields to override the default ones. */ ret = reset_event_decl_types(ctx, event_class); if (ret) { goto error; } - ret = ctx_push_scope(ctx); if (ret) { _PERROR("%s", "cannot push scope"); goto error; } + pop_scope = true; + bt_list_for_each_entry(iter, decl_list, siblings) { ret = visit_event_decl_entry(ctx, iter, event_class, &stream_id, &set); @@ -3348,11 +3397,17 @@ int visit_event_decl(struct ctx *ctx, struct ctf_node *node) if (!_IS_SET(&set, _EVENT_STREAM_ID_SET)) { GList *keys = NULL; struct bt_ctf_stream_class *new_stream_class; + size_t stream_class_count = + g_hash_table_size(ctx->stream_classes) + + bt_ctf_trace_get_stream_class_count(ctx->trace); - /* Allow missing stream_id if there is only a single stream */ - switch (g_hash_table_size(ctx->stream_classes)) { + /* + * Allow missing stream_id if there is only a single + * stream class. + */ + switch (stream_class_count) { case 0: - /* Create stream if there's none */ + /* Create implicit stream class if there's none */ new_stream_class = create_reset_stream_class(ctx); if (!new_stream_class) { ret = -EINVAL; @@ -3361,7 +3416,7 @@ int visit_event_decl(struct ctx *ctx, struct ctf_node *node) ret = bt_ctf_stream_class_set_id(new_stream_class, 0); if (ret) { - _PERROR("%s", "cannot set stream's ID"); + _PERROR("%s", "cannot set stream class's ID"); BT_PUT(new_stream_class); goto error; } @@ -3372,14 +3427,24 @@ int visit_event_decl(struct ctx *ctx, struct ctf_node *node) g_hash_table_insert(ctx->stream_classes, (gpointer) stream_id, new_stream_class); new_stream_class = NULL; - break; case 1: - /* Single stream: get its ID */ - keys = g_hash_table_get_keys(ctx->stream_classes); - stream_id = (int64_t) keys->data; - g_list_free(keys); - keys = NULL; + /* Single stream class: get its ID */ + if (g_hash_table_size(ctx->stream_classes) == 1) { + keys = g_hash_table_get_keys(ctx->stream_classes); + stream_id = (int64_t) keys->data; + g_list_free(keys); + } else { + assert(bt_ctf_trace_get_stream_class_count( + ctx->trace) == 1); + stream_class = + bt_ctf_trace_get_stream_class_by_index( + ctx->trace, 0); + assert(stream_class); + stream_id = bt_ctf_stream_class_get_id( + stream_class); + BT_PUT(stream_class); + } break; default: _PERROR("%s", "missing \"stream_id\" attribute in event declaration"); @@ -3388,20 +3453,25 @@ int visit_event_decl(struct ctx *ctx, struct ctf_node *node) } } - - assert(stream_id >= 0); - /* We have the stream ID now; borrow the stream class if found */ + /* We have the stream ID now; get the stream class if found */ stream_class = g_hash_table_lookup(ctx->stream_classes, (gpointer) stream_id); + bt_get(stream_class); if (!stream_class) { - _PERROR("cannot find stream class with ID %" PRId64, + stream_class = bt_ctf_trace_get_stream_class_by_id(ctx->trace, stream_id); - ret = -EINVAL; - goto error; + if (!stream_class) { + _PERROR("cannot find stream class with ID %" PRId64, + stream_id); + ret = -EINVAL; + goto error; + } } + assert(stream_class); + if (!_IS_SET(&set, _EVENT_ID_SET)) { /* Allow only one event without ID per stream */ if (bt_ctf_stream_class_get_event_class_count(stream_class) != @@ -3440,32 +3510,31 @@ int visit_event_decl(struct ctx *ctx, struct ctf_node *node) event_name); if (eevent_class) { BT_PUT(eevent_class); - eevent_class = NULL; _PERROR("%s", "duplicate event with name \"%s\" in same stream"); ret = -EEXIST; goto error; } - g_free(event_name); ret = bt_ctf_stream_class_add_event_class(stream_class, event_class); BT_PUT(event_class); - event_class = NULL; - if (ret) { _PERROR("%s", "cannot add event class to stream class"); goto error; } -end: - return 0; + goto end; error: - g_free(event_name); - BT_PUT(event_class); + bt_put(event_class); - /* stream_class is borrowed; it still belongs to the hash table */ +end: + if (pop_scope) { + ctx_pop_scope(ctx); + } + g_free(event_name); + bt_put(stream_class); return ret; } @@ -3654,6 +3723,7 @@ int visit_stream_decl(struct ctx *ctx, struct ctf_node *node) int ret = 0; struct ctf_node *iter; struct bt_ctf_stream_class *stream_class = NULL; + struct bt_ctf_stream_class *existing_stream_class = NULL; struct bt_list_head *decl_list = &node->u.stream.declaration_list; if (node->visited) { @@ -3732,17 +3802,35 @@ int visit_stream_decl(struct ctx *ctx, struct ctf_node *node) goto error; } + /* + * Make sure that this stream class's ID is currently unique in + * the trace. + */ + if (g_hash_table_lookup(ctx->stream_classes, (gpointer) id)) { + _PERROR("a stream class with ID: %" PRId64 " already exists in the trace", id); + ret = -EINVAL; + goto error; + } + + existing_stream_class = bt_ctf_trace_get_stream_class_by_id(ctx->trace, + id); + if (existing_stream_class) { + _PERROR("a stream class with ID: %" PRId64 " already exists in the trace", id); + ret = -EINVAL; + goto error; + } + /* Move reference to visitor's context */ g_hash_table_insert(ctx->stream_classes, (gpointer) (int64_t) id, stream_class); stream_class = NULL; - -end: - return 0; + goto end; error: - BT_PUT(stream_class); + bt_put(stream_class); +end: + bt_put(existing_stream_class); return ret; } @@ -3995,6 +4083,12 @@ int visit_env(struct ctx *ctx, struct ctf_node *node) goto error; } + if (strcmp(left, "tracer_name") == 0) { + if (strncmp(right, "lttng", 5) == 0) { + ctx->is_lttng = 1; + } + } + printf_verbose("env.%s = \"%s\"\n", left, right); ret = bt_ctf_trace_set_environment_field_string( ctx->trace, left, right); @@ -4094,7 +4188,8 @@ int set_trace_byte_order(struct ctx *ctx, struct ctf_node *trace_node) goto error; } - ret = bt_ctf_trace_set_byte_order( + ctx->trace_bo = bo; + ret = bt_ctf_trace_set_native_byte_order( ctx->trace, bo); if (ret) { _PERROR("cannot set trace's byte order (%d)", @@ -4124,7 +4219,7 @@ error: static int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, - struct bt_ctf_clock *clock, int *set) + struct bt_ctf_clock_class *clock, int *set) { int ret = 0; char *left = NULL; @@ -4144,7 +4239,7 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, char *right; if (_IS_SET(set, _CLOCK_NAME_SET)) { - _PERROR_DUP_ATTR("name", "clock declaration"); + _PERROR_DUP_ATTR("name", "clock class declaration"); ret = -EPERM; goto error; } @@ -4152,14 +4247,14 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, right = concatenate_unary_strings( &entry_node->u.ctf_expression.right); if (!right) { - _PERROR("%s", "unexpected unary expression for clock declaration's \"name\" attribute"); + _PERROR("%s", "unexpected unary expression for clock class declaration's \"name\" attribute"); ret = -EINVAL; goto error; } - ret = bt_ctf_clock_set_name(clock, right); + ret = bt_ctf_clock_class_set_name(clock, right); if (ret) { - _PERROR("%s", "cannot set clock's name"); + _PERROR("%s", "cannot set clock class's name"); g_free(right); goto error; } @@ -4170,20 +4265,20 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, unsigned char uuid[BABELTRACE_UUID_LEN]; if (_IS_SET(set, _CLOCK_UUID_SET)) { - _PERROR_DUP_ATTR("uuid", "clock declaration"); + _PERROR_DUP_ATTR("uuid", "clock class declaration"); ret = -EPERM; goto error; } ret = get_unary_uuid(&entry_node->u.ctf_expression.right, uuid); if (ret) { - _PERROR("%s", "invalid clock UUID"); + _PERROR("%s", "invalid clock class UUID"); goto error; } - ret = bt_ctf_clock_set_uuid(clock, uuid); + ret = bt_ctf_clock_class_set_uuid(clock, uuid); if (ret) { - _PERROR("%s", "cannot set clock's UUID"); + _PERROR("%s", "cannot set clock class's UUID"); goto error; } @@ -4192,7 +4287,7 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, char *right; if (_IS_SET(set, _CLOCK_DESCRIPTION_SET)) { - _PERROR_DUP_ATTR("description", "clock declaration"); + _PERROR_DUP_ATTR("description", "clock class declaration"); ret = -EPERM; goto error; } @@ -4200,14 +4295,14 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, right = concatenate_unary_strings( &entry_node->u.ctf_expression.right); if (!right) { - _PERROR("%s", "unexpected unary expression for clock's \"description\" attribute"); + _PERROR("%s", "unexpected unary expression for clock class's \"description\" attribute"); ret = -EINVAL; goto error; } - ret = bt_ctf_clock_set_description(clock, right); + ret = bt_ctf_clock_class_set_description(clock, right); if (ret) { - _PERROR("%s", "cannot set clock's description"); + _PERROR("%s", "cannot set clock class's description"); g_free(right); goto error; } @@ -4218,7 +4313,7 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, uint64_t freq; if (_IS_SET(set, _CLOCK_FREQ_SET)) { - _PERROR_DUP_ATTR("freq", "clock declaration"); + _PERROR_DUP_ATTR("freq", "clock class declaration"); ret = -EPERM; goto error; } @@ -4226,14 +4321,14 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, ret = get_unary_unsigned( &entry_node->u.ctf_expression.right, &freq); if (ret) { - _PERROR("%s", "unexpected unary expression for clock declaration's \"freq\" attribute"); + _PERROR("%s", "unexpected unary expression for clock class declaration's \"freq\" attribute"); ret = -EINVAL; goto error; } - ret = bt_ctf_clock_set_frequency(clock, freq); + ret = bt_ctf_clock_class_set_frequency(clock, freq); if (ret) { - _PERROR("%s", "cannot set clock's frequency"); + _PERROR("%s", "cannot set clock class's frequency"); goto error; } @@ -4242,7 +4337,7 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, uint64_t precision; if (_IS_SET(set, _CLOCK_PRECISION_SET)) { - _PERROR_DUP_ATTR("precision", "clock declaration"); + _PERROR_DUP_ATTR("precision", "clock class declaration"); ret = -EPERM; goto error; } @@ -4250,14 +4345,14 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, ret = get_unary_unsigned( &entry_node->u.ctf_expression.right, &precision); if (ret) { - _PERROR("%s", "unexpected unary expression for clock declaration's \"precision\" attribute"); + _PERROR("%s", "unexpected unary expression for clock class declaration's \"precision\" attribute"); ret = -EINVAL; goto error; } - ret = bt_ctf_clock_set_precision(clock, precision); + ret = bt_ctf_clock_class_set_precision(clock, precision); if (ret) { - _PERROR("%s", "cannot set clock's precision"); + _PERROR("%s", "cannot set clock class's precision"); goto error; } @@ -4266,7 +4361,7 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, uint64_t offset_s; if (_IS_SET(set, _CLOCK_OFFSET_S_SET)) { - _PERROR_DUP_ATTR("offset_s", "clock declaration"); + _PERROR_DUP_ATTR("offset_s", "clock class declaration"); ret = -EPERM; goto error; } @@ -4274,14 +4369,14 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, ret = get_unary_unsigned( &entry_node->u.ctf_expression.right, &offset_s); if (ret) { - _PERROR("%s", "unexpected unary expression for clock declaration's \"offset_s\" attribute"); + _PERROR("%s", "unexpected unary expression for clock class declaration's \"offset_s\" attribute"); ret = -EINVAL; goto error; } - ret = bt_ctf_clock_set_offset_s(clock, offset_s); + ret = bt_ctf_clock_class_set_offset_s(clock, offset_s); if (ret) { - _PERROR("%s", "cannot set clock's offset in seconds"); + _PERROR("%s", "cannot set clock class's offset in seconds"); goto error; } @@ -4290,7 +4385,7 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, uint64_t offset; if (_IS_SET(set, _CLOCK_OFFSET_SET)) { - _PERROR_DUP_ATTR("offset", "clock declaration"); + _PERROR_DUP_ATTR("offset", "clock class declaration"); ret = -EPERM; goto error; } @@ -4298,14 +4393,14 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, ret = get_unary_unsigned( &entry_node->u.ctf_expression.right, &offset); if (ret) { - _PERROR("%s", "unexpected unary expression for clock declaration's \"offset\" attribute"); + _PERROR("%s", "unexpected unary expression for clock class declaration's \"offset\" attribute"); ret = -EINVAL; goto error; } - ret = bt_ctf_clock_set_offset(clock, offset); + ret = bt_ctf_clock_class_set_offset_cycles(clock, offset); if (ret) { - _PERROR("%s", "cannot set clock's offset in cycles"); + _PERROR("%s", "cannot set clock class's offset in cycles"); goto error; } @@ -4314,7 +4409,7 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, struct ctf_node *right; if (_IS_SET(set, _CLOCK_ABSOLUTE_SET)) { - _PERROR_DUP_ATTR("absolute", "clock declaration"); + _PERROR_DUP_ATTR("absolute", "clock class declaration"); ret = -EPERM; goto error; } @@ -4324,20 +4419,20 @@ int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node, struct ctf_node, siblings); ret = get_boolean(ctx->efd, right); if (ret < 0) { - _PERROR("%s", "unexpected unary expression for clock declaration's \"absolute\" attribute"); + _PERROR("%s", "unexpected unary expression for clock class declaration's \"absolute\" attribute"); ret = -EINVAL; goto error; } - ret = bt_ctf_clock_set_is_absolute(clock, ret); + ret = bt_ctf_clock_class_set_is_absolute(clock, ret); if (ret) { - _PERROR("%s", "cannot set clock's absolute option"); + _PERROR("%s", "cannot set clock class's absolute option"); goto error; } _SET(set, _CLOCK_ABSOLUTE_SET); } else { - _PWARNING("unknown attribute \"%s\" in clock declaration", + _PWARNING("unknown attribute \"%s\" in clock class declaration", left); } @@ -4352,21 +4447,65 @@ error: return ret; } +static +uint64_t cycles_from_ns(uint64_t frequency, uint64_t ns) +{ + uint64_t cycles; + + /* 1GHz */ + if (frequency == 1000000000ULL) { + cycles = ns; + } else { + cycles = (uint64_t) (((double) ns * (double) frequency) / 1e9); + } + + return cycles; +} + +static +int apply_clock_class_offset(struct ctx *ctx, struct bt_ctf_clock_class *clock) +{ + int ret; + uint64_t freq; + int64_t offset_cycles; + + freq = bt_ctf_clock_class_get_frequency(clock); + if (freq == -1ULL) { + _PERROR("%s", "cannot get clock class frequency"); + ret = -1; + goto end; + } + + ret = bt_ctf_clock_class_get_offset_cycles(clock, &offset_cycles); + if (ret) { + _PERROR("%s", "cannot get offset in cycles"); + ret = -1; + goto end; + } + + offset_cycles += cycles_from_ns(freq, ctx->clock_class_offset_ns); + ret = bt_ctf_clock_class_set_offset_cycles(clock, offset_cycles); + +end: + return ret; +} + static int visit_clock_decl(struct ctx *ctx, struct ctf_node *clock_node) { int ret = 0; int set = 0; - struct bt_ctf_clock *clock; + struct bt_ctf_clock_class *clock; struct ctf_node *entry_node; struct bt_list_head *decl_list = &clock_node->u.clock.declaration_list; + const char *clock_class_name; if (clock_node->visited) { return 0; } clock_node->visited = TRUE; - clock = bt_ctf_clock_create(NULL); + clock = bt_ctf_clock_class_create(NULL); if (!clock) { _PERROR("%s", "cannot create clock"); ret = -ENOMEM; @@ -4382,20 +4521,36 @@ int visit_clock_decl(struct ctx *ctx, struct ctf_node *clock_node) if (!_IS_SET(&set, _CLOCK_NAME_SET)) { _PERROR("%s", - "missing \"name\" attribute in clock declaration"); + "missing \"name\" attribute in clock class declaration"); ret = -EPERM; goto error; } - if (bt_ctf_trace_get_clock_count(ctx->trace) != 0) { - _PERROR("%s", "only CTF traces with a single clock declaration are supported as of this version"); - ret = -EINVAL; + clock_class_name = bt_ctf_clock_class_get_name(clock); + assert(clock_class_name); + if (ctx->is_lttng && strcmp(clock_class_name, "monotonic") == 0) { + /* + * Old versions of LTTng forgot to set its clock class + * as absolute, even if it is. This is important because + * it's a condition to be able to sort notifications + * from different sources. + */ + ret = bt_ctf_clock_class_set_is_absolute(clock, 1); + if (ret) { + _PERROR("%s", "cannot set clock class's absolute option"); + goto error; + } + } + + ret = apply_clock_class_offset(ctx, clock); + if (ret) { + _PERROR("%s", "cannot apply clock class offset "); goto error; } - ret = bt_ctf_trace_add_clock(ctx->trace, clock); + ret = bt_ctf_trace_add_clock_class(ctx->trace, clock); if (ret) { - _PERROR("%s", "cannot add clock to trace"); + _PERROR("%s", "cannot add clock class to trace"); goto error; } @@ -4461,7 +4616,7 @@ end: } static -int add_stream_classes_to_trace(struct ctx *ctx) +int move_ctx_stream_classes_to_trace(struct ctx *ctx) { int ret; GHashTableIter iter; @@ -4480,53 +4635,79 @@ int add_stream_classes_to_trace(struct ctx *ctx) } } + g_hash_table_remove_all(ctx->stream_classes); + end: return ret; } -int ctf_visitor_generate_ir(FILE *efd, struct ctf_node *node, - struct bt_ctf_trace **trace) +BT_HIDDEN +struct ctf_visitor_generate_ir *ctf_visitor_generate_ir_create(FILE *efd, + uint64_t clock_class_offset_ns) { - int ret = 0; + int ret; struct ctx *ctx = NULL; - _BT_CTF_FIELD_TYPE_INIT(packet_header_decl); - - printf_verbose("CTF visitor: AST -> CTF IR...\n"); + struct bt_ctf_trace *trace; - *trace = bt_ctf_trace_create(); - if (!*trace) { + trace = bt_ctf_trace_create(); + if (!trace) { _FPERROR(efd, "%s", "cannot create trace"); - ret = -ENOMEM; - goto error; - } - - /* Set packet header to an empty struct tu override the default one */ - packet_header_decl = bt_ctf_field_type_structure_create(); - - if (!packet_header_decl) { - _FPERROR(efd, - "%s", - "cannot create initial, empty packet header structure"); - ret = -ENOMEM; goto error; } - ret = bt_ctf_trace_set_packet_header_type(*trace, packet_header_decl); - BT_PUT(packet_header_decl); + /* Set packet header to NULL to override the default one */ + ret = bt_ctf_trace_set_packet_header_type(trace, NULL); if (ret) { - _FPERROR(efd, - "%s", + _FPERROR(efd, "%s", "cannot set initial, empty packet header structure"); goto error; } - ctx = ctx_create(*trace, efd); + /* Create visitor's context */ + ctx = ctx_create(trace, efd, clock_class_offset_ns); if (!ctx) { _FPERROR(efd, "%s", "cannot create visitor context"); - ret = -ENOMEM; goto error; } + trace = NULL; + goto end; + +error: + ctx_destroy(ctx); + ctx = NULL; + +end: + bt_put(trace); + return (void *) ctx; +} + +BT_HIDDEN +void ctf_visitor_generate_ir_destroy(struct ctf_visitor_generate_ir *visitor) +{ + ctx_destroy((void *) visitor); +} + +BT_HIDDEN +struct bt_ctf_trace *ctf_visitor_generate_ir_get_trace( + struct ctf_visitor_generate_ir *visitor) +{ + struct ctx *ctx = (void *) visitor; + + assert(ctx); + assert(ctx->trace); + return bt_get(ctx->trace); +} + +BT_HIDDEN +int ctf_visitor_generate_ir_visit_node(struct ctf_visitor_generate_ir *visitor, + struct ctf_node *node) +{ + int ret = 0; + struct ctx *ctx = (void *) visitor; + + printf_verbose("CTF visitor: AST -> CTF IR...\n"); + switch (node->type) { case NODE_ROOT: { @@ -4535,44 +4716,69 @@ int ctf_visitor_generate_ir(FILE *efd, struct ctf_node *node, int found_callsite = FALSE; /* - * Find trace declaration's byte order first (for early - * type aliases). + * The first thing we need is the native byte order of + * the trace block, because early type aliases can have + * a `byte_order` attribute set to `native`. If we don't + * have the native byte order yet, and we don't have any + * trace block yet, then fail with EINCOMPLETE. */ - bt_list_for_each_entry(iter, &node->u.root.trace, siblings) { - if (got_trace_decl) { - _PERROR("%s", "duplicate trace declaration"); - goto error; + if (ctx->trace_bo == BT_CTF_BYTE_ORDER_NATIVE) { + bt_list_for_each_entry(iter, &node->u.root.trace, siblings) { + if (got_trace_decl) { + _PERROR("%s", "duplicate trace declaration"); + ret = -1; + goto end; + } + + ret = set_trace_byte_order(ctx, iter); + if (ret) { + _PERROR("cannot set trace's native byte order (%d)", + ret); + goto end; + } + + got_trace_decl = TRUE; } - ret = set_trace_byte_order(ctx, iter); + if (!got_trace_decl) { + ret = -EINCOMPLETE; + goto end; + } + } + + assert(ctx->trace_bo == BT_CTF_BYTE_ORDER_LITTLE_ENDIAN || + ctx->trace_bo == BT_CTF_BYTE_ORDER_BIG_ENDIAN); + assert(ctx->current_scope && + ctx->current_scope->parent_scope == NULL); + + /* Environment */ + bt_list_for_each_entry(iter, &node->u.root.env, siblings) { + ret = visit_env(ctx, iter); if (ret) { - _PERROR("cannot set trace's byte order (%d)", + _PERROR("error while visiting environment block (%d)", ret); - goto error; + goto end; } - - got_trace_decl = TRUE; } - if (!got_trace_decl) { - _PERROR("no trace declaration found (%d)", ret); - ret = -EPERM; - goto error; - } + assert(ctx->current_scope && + ctx->current_scope->parent_scope == NULL); /* - * Visit clocks first since any early integer can be mapped - * to one. + * Visit clock blocks. */ bt_list_for_each_entry(iter, &node->u.root.clock, siblings) { ret = visit_clock_decl(ctx, iter); if (ret) { - _PERROR("error while visiting clock declaration (%d)", + _PERROR("error while visiting clock class declaration (%d)", ret); - goto error; + goto end; } } + assert(ctx->current_scope && + ctx->current_scope->parent_scope == NULL); + /* * Visit root declarations next, as they can be used by any * following entity. @@ -4583,80 +4789,75 @@ int ctf_visitor_generate_ir(FILE *efd, struct ctf_node *node, if (ret) { _PERROR("error while visiting root declaration (%d)", ret); - goto error; + goto end; } } - /* Callsite are not supported */ + assert(ctx->current_scope && + ctx->current_scope->parent_scope == NULL); + + /* Callsite blocks are not supported */ bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) { found_callsite = TRUE; break; } + assert(ctx->current_scope && + ctx->current_scope->parent_scope == NULL); + if (found_callsite) { _PWARNING("%s", "\"callsite\" blocks are not supported as of this version"); } - /* Environment */ - bt_list_for_each_entry(iter, &node->u.root.env, siblings) { - ret = visit_env(ctx, iter); - if (ret) { - _PERROR("error while visiting environment block (%d)", - ret); - goto error; - } - } - /* Trace */ bt_list_for_each_entry(iter, &node->u.root.trace, siblings) { ret = visit_trace_decl(ctx, iter); if (ret) { _PERROR("%s", "error while visiting trace declaration"); - goto error; + goto end; } } + assert(ctx->current_scope && + ctx->current_scope->parent_scope == NULL); + /* Streams */ bt_list_for_each_entry(iter, &node->u.root.stream, siblings) { ret = visit_stream_decl(ctx, iter); if (ret) { _PERROR("%s", "error while visiting stream declaration"); - goto error; + goto end; } } + assert(ctx->current_scope && + ctx->current_scope->parent_scope == NULL); + /* Events */ bt_list_for_each_entry(iter, &node->u.root.event, siblings) { ret = visit_event_decl(ctx, iter); if (ret) { _PERROR("%s", "error while visiting event declaration"); - goto error; + goto end; } } + + assert(ctx->current_scope && + ctx->current_scope->parent_scope == NULL); break; } - case NODE_UNKNOWN: default: - _PERROR("unknown node type: %d", (int) node->type); + _PERROR("cannot decode node type: %d", (int) node->type); ret = -EINVAL; - goto error; + goto end; } - /* Add stream classes to trace now */ - ret = add_stream_classes_to_trace(ctx); + /* Move decoded stream classes to trace, if any */ + ret = move_ctx_stream_classes_to_trace(ctx); if (ret) { - _PERROR("%s", "cannot add stream classes to trace"); + _PERROR("%s", "cannot move stream classes to trace"); } - ctx_destroy(ctx); - printf_verbose("done!\n"); - - return ret; - -error: - BT_PUT(packet_header_decl); - ctx_destroy(ctx); - BT_PUT(*trace); - +end: return ret; }