* @returns New visitor context, or NULL on error
*/
static
-struct ctx *ctx_create(
+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_class = bt_trace_class_create();
- if (!ctx->trace_class) {
- BT_LOGE_STR("Cannot create empty trace class.");
- 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->ctf_tc = ctf_trace_class_create();
int signedness = 0;
struct ctf_node *expression;
uint64_t alignment = 0, size = 0;
- bt_clock_class *mapped_clock_class = NULL;
+ struct ctf_clock_class *mapped_clock_class = NULL;
enum ctf_encoding encoding = CTF_ENCODING_NONE;
bt_field_class_integer_preferred_display_base base =
BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL;
(*integer_decl)->disp_base = base;
(*integer_decl)->encoding = encoding;
(*integer_decl)->mapped_clock_class = mapped_clock_class;
- bt_clock_class_get_ref((*integer_decl)->mapped_clock_class);
return 0;
error:
int auto_map_field_to_trace_clock_class(struct ctx *ctx,
struct ctf_field_class *fc)
{
- 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_clock_class_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_clock_class_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_clock_class_get_ref(int_fc->mapped_clock_class);
end:
- bt_clock_class_put_ref(clock_class_to_map_to);
return ret;
}
static
int visit_clock_decl_entry(struct ctx *ctx, struct ctf_node *entry_node,
- 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,
- 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;
- 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) {
/*
* 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_clock_class_get_ref(clock);
+ clock = NULL;
end:
- BT_CLOCK_CLASS_PUT_REF_AND_RESET(clock);
+ if (clock) {
+ ctf_clock_class_destroy(clock);
+ }
+
return ret;
}
BT_HIDDEN
struct ctf_visitor_generate_ir *ctf_visitor_generate_ir_create(
+ 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);
+ ctx = ctx_create(self_comp, decoder_config);
if (!ctx) {
BT_LOGE_STR("Cannot create visitor's context.");
goto error;
struct ctx *ctx = (void *) visitor;
BT_ASSERT(ctx);
- BT_ASSERT(ctx->trace_class);
- bt_trace_class_get_ref(ctx->trace_class);
+
+ if (ctx->trace_class) {
+ bt_trace_class_get_ref(ctx->trace_class);
+ }
+
return ctx->trace_class;
}
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_class, ctx->ctf_tc);
- if (ret) {
- ret = -EINVAL;
- goto end;
+ if (ctx->trace_class) {
+ /* Copy new CTF metadata -> new IR metadata */
+ ret = ctf_trace_class_translate(ctx->trace_class, ctx->ctf_tc);
+ if (ret) {
+ ret = -EINVAL;
+ goto end;
+ }
}
end:
projects / babeltrace.git / blobdiff