#include <stdbool.h>
#include <stdlib.h>
#include <ctype.h>
-#include <babeltrace/assert-internal.h>
+#include <babeltrace2/assert-internal.h>
#include <glib.h>
#include <inttypes.h>
#include <errno.h>
-#include <babeltrace/common-internal.h>
-#include <babeltrace/compat/uuid-internal.h>
-#include <babeltrace/endian-internal.h>
-#include <babeltrace/babeltrace.h>
+#include <babeltrace2/common-internal.h>
+#include <babeltrace2/compat/uuid-internal.h>
+#include <babeltrace2/endian-internal.h>
+#include <babeltrace2/babeltrace.h>
#include "scanner.h"
#include "parser.h"
* Visitor context (private).
*/
struct ctx {
- /* Trace IR trace being filled (owned by this) */
- struct bt_trace *trace;
+ bt_self_component_source *self_comp;
+ /* Trace IR trace class being filled (owned by this) */
+ bt_trace_class *trace_class;
/* CTF meta trace being filled (owned by this) */
struct ctf_trace_class *ctf_tc;
/* True if this is an LTTng trace */
bool is_lttng;
- /* Eventual name suffix of the trace to set (owned by this) */
- char *trace_class_name_suffix;
-
/* Config passed by the user */
struct ctf_metadata_decoder_config decoder_config;
};
scope = parent_scope;
}
- bt_object_put_ref(ctx->trace);
+ bt_trace_class_put_ref(ctx->trace_class);
if (ctx->ctf_tc) {
ctf_trace_class_destroy(ctx->ctf_tc);
}
- if (ctx->trace_class_name_suffix) {
- free(ctx->trace_class_name_suffix);
- }
-
g_free(ctx);
end:
* @returns New visitor context, or NULL on error
*/
static
-struct ctx *ctx_create(const struct ctf_metadata_decoder_config *decoder_config,
- const char *trace_class_name_suffix)
+struct ctx *ctx_create(bt_self_component_source *self_comp,
+ const struct ctf_metadata_decoder_config *decoder_config)
{
struct ctx *ctx = NULL;
goto error;
}
- ctx->trace = bt_trace_create();
- if (!ctx->trace) {
- BT_LOGE_STR("Cannot create empty trace.");
- goto error;
+ if (self_comp) {
+ ctx->trace_class = bt_trace_class_create(
+ bt_self_component_source_as_self_component(self_comp));
+ if (!ctx->trace_class) {
+ BT_LOGE_STR("Cannot create empty trace class.");
+ goto error;
+ }
+ ctx->self_comp = self_comp;
}
ctx->ctf_tc = ctf_trace_class_create();
goto error;
}
- if (trace_class_name_suffix) {
- ctx->trace_class_name_suffix = strdup(trace_class_name_suffix);
- if (!ctx->trace_class_name_suffix) {
- BT_LOGE_STR("Failed to copy string.");
- goto error;
- }
- }
-
ctx->decoder_config = *decoder_config;
goto end;
int signedness = 0;
struct ctf_node *expression;
uint64_t alignment = 0, size = 0;
- struct bt_clock_class *mapped_clock_class = NULL;
+ struct ctf_clock_class *mapped_clock_class = NULL;
enum ctf_encoding encoding = CTF_ENCODING_NONE;
- enum bt_field_class_integer_preferred_display_base base =
+ bt_field_class_integer_preferred_display_base base =
BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL;
enum ctf_byte_order byte_order = ctx->ctf_tc->default_byte_order;
(*integer_decl)->disp_base = base;
(*integer_decl)->encoding = encoding;
(*integer_decl)->mapped_clock_class = mapped_clock_class;
- bt_object_get_ref((*integer_decl)->mapped_clock_class);
return 0;
error:
* Only read "stream_id" if get_unary_unsigned()
* succeeded.
*/
- if (ret || (!ret && *stream_id < 0)) {
+ if (ret) {
_BT_LOGE_NODE(node,
"Unexpected unary expression for event class's `stream_id` attribute.");
ret = -EINVAL;
_SET(set, _EVENT_FIELDS_SET);
} else if (!strcmp(left, "loglevel")) {
uint64_t loglevel_value;
- enum bt_event_class_log_level log_level = -1;
+ bt_event_class_log_level log_level = -1;
if (_IS_SET(set, _EVENT_LOG_LEVEL_SET)) {
_BT_LOGE_DUP_ATTR(node, "loglevel",
stream_class->id = stream_id;
g_ptr_array_add(ctx->ctf_tc->stream_classes,
stream_class);
- stream_class = stream_class;
break;
case 1:
/* Single stream class: get its ID */
int auto_map_field_to_trace_clock_class(struct ctx *ctx,
struct ctf_field_class *fc)
{
- struct bt_clock_class *clock_class_to_map_to = NULL;
+ struct ctf_clock_class *clock_class_to_map_to = NULL;
struct ctf_field_class_int *int_fc = (void *) fc;
int ret = 0;
uint64_t clock_class_count;
* implicit one at 1 GHz, named `default`, and use this clock
* class.
*/
- clock_class_to_map_to = bt_clock_class_create();
+ clock_class_to_map_to = ctf_clock_class_create();
BT_ASSERT(clock_class_to_map_to);
- bt_clock_class_set_frequency(clock_class_to_map_to,
- UINT64_C(1000000000));
- ret = bt_clock_class_set_name(clock_class_to_map_to,
- "default");
+ clock_class_to_map_to->frequency = UINT64_C(1000000000);
+ g_string_assign(clock_class_to_map_to->name, "default");
BT_ASSERT(ret == 0);
g_ptr_array_add(ctx->ctf_tc->clock_classes,
clock_class_to_map_to);
- bt_object_get_ref(clock_class_to_map_to);
break;
case 1:
/*
* this one.
*/
clock_class_to_map_to = ctx->ctf_tc->clock_classes->pdata[0];
- bt_object_get_ref(clock_class_to_map_to);
break;
default:
/*
BT_ASSERT(clock_class_to_map_to);
int_fc->mapped_clock_class = clock_class_to_map_to;
- bt_object_get_ref(int_fc->mapped_clock_class);
end:
- bt_object_put_ref(clock_class_to_map_to);
return ret;
}
static
int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
- struct bt_clock_class *clock, int *set, int64_t *offset_seconds,
+ struct ctf_clock_class *clock, int *set, int64_t *offset_seconds,
uint64_t *offset_cycles)
{
int ret = 0;
goto error;
}
- ret = bt_clock_class_set_name(clock, right);
- if (ret) {
- _BT_LOGE_NODE(entry_node,
- "cannot set clock class's name");
- g_free(right);
- goto error;
- }
-
+ g_string_assign(clock->name, right);
g_free(right);
_SET(set, _CLOCK_NAME_SET);
} else if (!strcmp(left, "uuid")) {
goto error;
}
- bt_clock_class_set_uuid(clock, uuid);
+ clock->has_uuid = true;
+ memcpy(&clock->uuid[0], uuid, 16);
_SET(set, _CLOCK_UUID_SET);
} else if (!strcmp(left, "description")) {
char *right;
goto error;
}
- ret = bt_clock_class_set_description(clock, right);
- if (ret) {
- _BT_LOGE_NODE(entry_node,
- "Cannot set clock class's description.");
- g_free(right);
- goto error;
- }
-
+ g_string_assign(clock->description, right);
g_free(right);
_SET(set, _CLOCK_DESCRIPTION_SET);
} else if (!strcmp(left, "freq")) {
goto error;
}
- bt_clock_class_set_frequency(clock, freq);
+ clock->frequency = freq;
_SET(set, _CLOCK_FREQ_SET);
} else if (!strcmp(left, "precision")) {
uint64_t precision;
goto error;
}
- bt_clock_class_set_precision(clock, precision);
+ clock->precision = precision;
_SET(set, _CLOCK_PRECISION_SET);
} else if (!strcmp(left, "offset_s")) {
if (_IS_SET(set, _CLOCK_OFFSET_S_SET)) {
goto error;
}
- bt_clock_class_set_is_absolute(clock, ret);
+ clock->is_absolute = ret;
_SET(set, _CLOCK_ABSOLUTE_SET);
} else {
_BT_LOGW_NODE(entry_node,
static
void apply_clock_class_offset(struct ctx *ctx,
- struct bt_clock_class *clock)
+ struct ctf_clock_class *clock)
{
uint64_t freq;
int64_t offset_s_to_apply = ctx->decoder_config.clock_class_offset_s;
offset_s_to_apply += extra_s;
}
- freq = bt_clock_class_get_frequency(clock);
- bt_clock_class_get_offset(clock,
- &cur_offset_s, &cur_offset_cycles);
+ freq = clock->frequency;
+ cur_offset_s = clock->offset_seconds;
+ cur_offset_cycles = clock->offset_cycles;
/* Apply offsets */
cur_offset_s += offset_s_to_apply;
calibrate_clock_class_offsets(&cur_offset_s, &cur_offset_cycles, freq);
/* Set final offsets */
- bt_clock_class_set_offset(clock, cur_offset_s, cur_offset_cycles);
+ clock->offset_seconds = cur_offset_s;
+ clock->offset_cycles = cur_offset_cycles;
end:
return;
{
int ret = 0;
int set = 0;
- struct bt_clock_class *clock;
+ struct 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;
clock_node->visited = TRUE;
/* CTF 1.8's default frequency for a clock class is 1 GHz */
- clock = bt_clock_class_create();
+ clock = ctf_clock_class_create();
if (!clock) {
_BT_LOGE_NODE(clock_node,
"Cannot create default clock class.");
goto end;
}
- /* CTF: not absolute by default */
- bt_clock_class_set_is_absolute(clock, BT_FALSE);
-
bt_list_for_each_entry(entry_node, decl_list, siblings) {
ret = visit_clock_decl_entry(ctx, entry_node, clock, &set,
&offset_seconds, &offset_cycles);
goto end;
}
- clock_class_name = bt_clock_class_get_name(clock);
+ clock_class_name = clock->name->str;
BT_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
+ * it's a condition to be able to sort messages
* from different sources.
*/
- bt_clock_class_set_is_absolute(clock, BT_TRUE);
+ clock->is_absolute = true;
}
/*
* Adjust offsets so that the part in cycles is less than the
* frequency (move to the part in seconds).
*/
- freq = bt_clock_class_get_frequency(clock);
+ freq = clock->frequency;
calibrate_clock_class_offsets(&offset_seconds, &offset_cycles, freq);
- BT_ASSERT(offset_cycles < bt_clock_class_get_frequency(clock));
- bt_clock_class_set_offset(clock, offset_seconds, offset_cycles);
+ BT_ASSERT(offset_cycles < clock->frequency);
+ clock->offset_seconds = offset_seconds;
+ clock->offset_cycles = offset_cycles;
apply_clock_class_offset(ctx, clock);
g_ptr_array_add(ctx->ctf_tc->clock_classes, clock);
- bt_object_get_ref(clock);
+ clock = NULL;
end:
- BT_OBJECT_PUT_REF_AND_RESET(clock);
+ if (clock) {
+ ctf_clock_class_destroy(clock);
+ }
+
return ret;
}
return ret;
}
-static
-int try_set_trace_class_name(struct ctx *ctx)
-{
- GString *name = NULL;
- int ret = 0;
- struct ctf_trace_class_env_entry *env_entry;
-
- if (ctx->ctf_tc->name->len > 0) {
- /* Already set */
- goto end;
- }
-
- name = g_string_new(NULL);
- if (!name) {
- BT_LOGE_STR("Failed to allocate a GString.");
- ret = -1;
- goto end;
- }
-
- /*
- * Check if we have a trace environment string value named `hostname`.
- * If so, use it as the trace name's prefix.
- */
- env_entry = ctf_trace_class_borrow_env_entry_by_name(ctx->ctf_tc,
- "hostname");
- if (env_entry &&
- env_entry->type == CTF_TRACE_CLASS_ENV_ENTRY_TYPE_STR) {
- g_string_append(name, env_entry->value.str->str);
-
- if (ctx->trace_class_name_suffix) {
- g_string_append_c(name, G_DIR_SEPARATOR);
- }
- }
-
- if (ctx->trace_class_name_suffix) {
- g_string_append(name, ctx->trace_class_name_suffix);
- }
-
- g_string_assign(ctx->ctf_tc->name, name->str);
- goto end;
-
-end:
- if (name) {
- g_string_free(name, TRUE);
- }
-
- return ret;
-}
-
BT_HIDDEN
struct ctf_visitor_generate_ir *ctf_visitor_generate_ir_create(
- const struct ctf_metadata_decoder_config *decoder_config,
- const char *name)
+ bt_self_component_source *self_comp,
+ const struct ctf_metadata_decoder_config *decoder_config)
{
struct ctx *ctx = NULL;
/* Create visitor's context */
- ctx = ctx_create(decoder_config, name);
+ ctx = ctx_create(self_comp, decoder_config);
if (!ctx) {
BT_LOGE_STR("Cannot create visitor's context.");
goto error;
}
BT_HIDDEN
-struct bt_trace *ctf_visitor_generate_ir_get_ir_trace(
+bt_trace_class *ctf_visitor_generate_ir_get_ir_trace_class(
struct ctf_visitor_generate_ir *visitor)
{
struct ctx *ctx = (void *) visitor;
BT_ASSERT(ctx);
- BT_ASSERT(ctx->trace);
- bt_object_get_ref(ctx->trace);
- return ctx->trace;
+
+ if (ctx->trace_class) {
+ bt_trace_class_get_ref(ctx->trace_class);
+ }
+
+ return ctx->trace_class;
}
BT_HIDDEN
goto end;
}
- /* Set trace's name, if not already done */
- ret = try_set_trace_class_name(ctx);
+ /* Update trace class meanings */
+ ret = ctf_trace_class_update_meanings(ctx->ctf_tc);
if (ret) {
ret = -EINVAL;
goto end;
}
- /* Update trace class meanings */
- ret = ctf_trace_class_update_meanings(ctx->ctf_tc);
+ /* Update stream class configuration */
+ ret = ctf_trace_class_update_stream_class_config(ctx->ctf_tc);
if (ret) {
ret = -EINVAL;
goto end;
goto end;
}
- /* Update "in IR" for field classes */
- ret = ctf_trace_class_update_in_ir(ctx->ctf_tc);
- if (ret) {
- ret = -EINVAL;
- goto end;
+ if (ctx->trace_class) {
+ /*
+ * Update "in IR" for field classes.
+ *
+ * If we have no IR trace class, then we'll have no way
+ * to create IR fields anyway, so we leave all the
+ * `in_ir` members false.
+ */
+ ret = ctf_trace_class_update_in_ir(ctx->ctf_tc);
+ if (ret) {
+ ret = -EINVAL;
+ goto end;
+ }
}
/* Update saved value indexes */
goto end;
}
- /* Copy new CTF metadata -> new IR metadata */
- ret = ctf_trace_class_translate(ctx->trace, ctx->ctf_tc);
- if (ret) {
- ret = -EINVAL;
- goto end;
+ /*
+ * If there are fields which are not related to the CTF format
+ * itself in the packet header and in event header field
+ * classes, warn about it because they are never translated.
+ */
+ ctf_trace_class_warn_meaningless_header_fields(ctx->ctf_tc);
+
+ if (ctx->trace_class) {
+ /* Copy new CTF metadata -> new IR metadata */
+ ret = ctf_trace_class_translate(ctx->self_comp,
+ ctx->trace_class, ctx->ctf_tc);
+ if (ret) {
+ ret = -EINVAL;
+ goto end;
+ }
}
end: