#include <stdio.h>
#include <unistd.h>
#include <string.h>
+#include <stdbool.h>
#include <stdlib.h>
#include <ctype.h>
#include <assert.h>
/* 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;
enum bt_ctf_byte_order bo = byte_order_from_unary_expr(ctx->efd, uexpr);
if (bo == BT_CTF_BYTE_ORDER_NATIVE) {
- bo = bt_ctf_trace_get_byte_order(ctx->trace);
+ bo = bt_ctf_trace_get_native_byte_order(ctx->trace);
}
return bo;
nested_decl_copy = bt_ctf_field_type_copy(nested_decl);
BT_PUT(nested_decl);
if (!nested_decl_copy) {
- _PERROR("%s", "cannot copy nested declaration");
+ _PERROR("%s", "cannot copy nested field type");
ret = -EINVAL;
goto error;
}
BT_PUT(nested_decl);
if (!array_decl) {
_PERROR("%s",
- "cannot create array declaration");
+ "cannot create array field type");
ret = -ENOMEM;
goto error;
}
BT_PUT(nested_decl);
if (!seq_decl) {
_PERROR("%s",
- "cannot create sequence declaration");
+ "cannot create sequence field type");
ret = -ENOMEM;
goto error;
}
&qfield_name, iter, &field_decl, NULL);
if (ret) {
assert(!field_decl);
- _PERROR("%s", "unable to find structure field declaration type");
+ _PERROR("%s", "cannot visit type declarator");
goto error;
}
if (ret) {
assert(!field_decl);
_PERROR("%s",
- "unable to find variant field declaration type");
+ "cannot visit type declarator");
goto error;
}
ret = visit_type_declarator(ctx, type_specifier_list,
&qidentifier, iter, &type_decl, NULL);
if (ret) {
- _PERROR("%s", "problem creating type declaration");
+ _PERROR("%s", "cannot visit type declarator");
ret = -EINVAL;
goto end;
}
&qdummy_field_name, node, &type_decl, NULL);
if (ret) {
assert(!type_decl);
- _PERROR("%s", "problem creating type declaration");
+ _PERROR("%s", "cannot visit type declarator");
goto end;
}
struct_decl_copy = bt_ctf_field_type_copy(*struct_decl);
if (!struct_decl_copy) {
_PERROR("%s",
- "cannot create copy of structure declaration");
+ "cannot create copy of structure field type");
ret = -EINVAL;
goto error;
}
*struct_decl = bt_ctf_field_type_structure_create();
if (!*struct_decl) {
- _PERROR("%s", "cannot create structure declaration");
+ _PERROR("%s", "cannot create structure field type");
ret = -ENOMEM;
goto error;
}
untagged_variant_decl);
if (!variant_decl_copy) {
_PERROR("%s",
- "cannot create copy of structure declaration");
+ "cannot create copy of variant field type");
ret = -EINVAL;
goto error;
}
untagged_variant_decl = bt_ctf_field_type_variant_create(NULL,
NULL);
if (!untagged_variant_decl) {
- _PERROR("%s", "cannot create variant declaration");
+ _PERROR("%s", "cannot create variant field type");
ret = -ENOMEM;
goto error;
}
enum_decl_copy = bt_ctf_field_type_copy(*enum_decl);
if (!enum_decl_copy) {
_PERROR("%s",
- "cannot create copy of enumeration declaration");
+ "cannot create copy of enumeration field type");
ret = -EINVAL;
goto error;
}
*enum_decl = bt_ctf_field_type_enumeration_create(integer_decl);
if (!*enum_decl) {
- _PERROR("%s", "cannot create enumeration declaration");
+ _PERROR("%s", "cannot create enumeration field type");
ret = -ENOMEM;
goto error;
}
/* Make a copy of the type declaration */
decl_copy = bt_ctf_field_type_copy(*decl);
if (!decl_copy) {
- _PERROR("%s", "cannot create copy of type declaration");
+ _PERROR("%s", "cannot create field type copy");
ret = -EINVAL;
goto error;
}
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 =
- bt_ctf_trace_get_byte_order(ctx->trace);
+ bt_ctf_trace_get_native_byte_order(ctx->trace);
*integer_decl = NULL;
*integer_decl = bt_ctf_field_type_integer_create((unsigned int) size);
if (!*integer_decl) {
- _PERROR("%s", "cannot create integer declaration");
+ _PERROR("%s", "cannot create integer field type");
ret = -ENOMEM;
goto error;
}
}
if (ret) {
- _PERROR("%s", "cannot configure integer declaration");
+ _PERROR("%s", "cannot configure integer field type");
ret = -EINVAL;
goto error;
}
struct ctf_node *expression;
uint64_t alignment = 1, exp_dig = 0, mant_dig = 0;
enum bt_ctf_byte_order byte_order =
- bt_ctf_trace_get_byte_order(ctx->trace);
+ bt_ctf_trace_get_native_byte_order(ctx->trace);
*float_decl = NULL;
*float_decl = bt_ctf_field_type_floating_point_create();
if (!*float_decl) {
_PERROR("%s",
- "cannot create floating point number declaration");
+ "cannot create floating point number field type");
ret = -ENOMEM;
goto error;
}
ret |= bt_ctf_field_type_set_alignment(*float_decl, alignment);
if (ret) {
_PERROR("%s",
- "cannot configure floating point number declaration");
+ "cannot configure floating point number field type");
ret = -EINVAL;
goto error;
}
*string_decl = bt_ctf_field_type_string_create();
if (!*string_decl) {
- _PERROR("%s", "cannot create string declaration");
+ _PERROR("%s", "cannot create string field type");
ret = -ENOMEM;
goto error;
}
ret = bt_ctf_field_type_string_set_encoding(*string_decl, encoding);
if (ret) {
- _PERROR("%s", "cannot configure string declaration");
+ _PERROR("%s", "cannot configure string field type");
ret = -EINVAL;
goto error;
}
struct ctf_node, siblings),
&decl);
if (ret) {
- _PERROR("%s", "cannot create event payload declaration");
+ _PERROR("%s", "cannot create event payload field type");
goto error;
}
event_class, decl);
BT_PUT(decl);
if (ret) {
- _PERROR("%s", "cannot set event's payload declaration");
+ _PERROR("%s", "cannot set event's payload field type");
goto error;
}
} else {
assert(bt_ctf_trace_get_stream_class_count(
ctx->trace) == 1);
- stream_class = bt_ctf_trace_get_stream_class(
- ctx->trace, 0);
+ 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);
goto error;
}
- eevent_class = bt_ctf_stream_class_get_event_class_by_name(stream_class,
- event_name);
- if (eevent_class) {
- BT_PUT(eevent_class);
- _PERROR("%s",
- "duplicate event with name \"%s\" in same stream");
- ret = -EEXIST;
- goto error;
- }
-
ret = bt_ctf_stream_class_add_event_class(stream_class, event_class);
BT_PUT(event_class);
if (ret) {
ret = bt_ctf_stream_class_set_id(stream_class, id);
if (ret) {
_PERROR("%s",
- "cannot set stream declaration's ID");
+ "cannot set stream class's ID");
goto error;
}
struct ctf_node, siblings),
&decl);
if (ret) {
- _PERROR("%s", "cannot create event header declaration");
+ _PERROR("%s", "cannot create event header field type");
goto error;
}
stream_class, decl);
BT_PUT(decl);
if (ret) {
- _PERROR("%s", "cannot set stream's event header declaration");
+ _PERROR("%s", "cannot set stream's event header field type");
goto error;
}
struct ctf_node, siblings),
&decl);
if (ret) {
- _PERROR("%s", "cannot create stream event context declaration");
+ _PERROR("%s", "cannot create stream event context field type");
goto error;
}
stream_class, decl);
BT_PUT(decl);
if (ret) {
- _PERROR("%s", "cannot set stream's event context declaration");
+ _PERROR("%s", "cannot set stream's event context field type");
goto error;
}
struct ctf_node, siblings),
&decl);
if (ret) {
- _PERROR("%s", "cannot create packet context declaration");
+ _PERROR("%s", "cannot create packet context field type");
goto error;
}
stream_class, decl);
BT_PUT(decl);
if (ret) {
- _PERROR("%s", "cannot set stream's packet context declaration");
+ _PERROR("%s", "cannot set stream's packet context field type");
goto error;
}
bt_ctf_trace_get_packet_header_type(ctx->trace);
if (!packet_header_decl) {
_PERROR("%s",
- "cannot get trace packet header declaration");
+ "cannot get trace packet header field type");
goto error;
}
goto error;
}
+ ret = bt_ctf_trace_set_uuid(ctx->trace, ctx->trace_uuid);
+ if (ret) {
+ _PERROR("%s",
+ "cannot set trace's UUID");
+ goto error;
+ }
+
_SET(set, _TRACE_UUID_SET);
} else if (!strcmp(left, "byte_order")) {
/* Native byte order is already known at this stage */
struct ctf_node, siblings),
&packet_header_decl);
if (ret) {
- _PERROR("%s", "cannot create packet header declaration");
+ _PERROR("%s", "cannot create packet header field type");
goto error;
}
packet_header_decl);
BT_PUT(packet_header_decl);
if (ret) {
- _PERROR("%s", "cannot set trace declaration's packet header declaration");
+ _PERROR("%s", "cannot set trace's packet header field type");
goto error;
}
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);
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;
goto error;
}
- if (bt_ctf_trace_get_clock_class_count(ctx->trace) != 0) {
- _PERROR("%s", "only CTF traces with a single clock class declaration are supported as of this version");
- ret = -EINVAL;
- goto error;
+ 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);
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("error while visiting environment block (%d)",
+ ret);
+ goto end;
+ }
+ }
+
+ 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);
_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 end;
- }
- }
-
- assert(ctx->current_scope &&
- ctx->current_scope->parent_scope == NULL);
-
/* Trace */
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
ret = visit_trace_decl(ctx, iter);