#include "scanner.h"
#include "parser.h"
#include "ast.h"
+#include "decoder.h"
/* Bit value (left shift) */
#define _BV(_val) (1 << (_val))
#define _BT_CTF_FIELD_TYPE_INIT(_name) struct bt_ctf_field_type *_name = NULL;
-#define _BT_LOGE_DUP_ATTR(_attr, _entity) \
- do { \
- BT_LOGE("Duplicate attribute in %s: attr-name=\"%s\"", \
- _entity, _attr); \
- } while (0)
+#define _BT_LOGE_DUP_ATTR(_node, _attr, _entity) \
+ _BT_LOGE_LINENO((_node)->lineno, \
+ "Duplicate attribute in %s: attr-name=\"%s\"", \
+ _entity, _attr)
+
+#define _BT_LOGE_NODE(_node, _msg, args...) \
+ _BT_LOGE_LINENO((_node)->lineno, _msg, ## args)
+
+#define _BT_LOGW_NODE(_node, _msg, args...) \
+ _BT_LOGW_LINENO((_node)->lineno, _msg, ## args)
+
+#define _BT_LOGV_NODE(_node, _msg, args...) \
+ _BT_LOGV_LINENO((_node)->lineno, _msg, ## args)
/*
* Declaration scope of a visitor context. This represents a TSDL
/* 1 if this is an LTTng trace */
bool is_lttng;
- /* Offset (ns) to apply to clock classes on creation */
- int64_t clock_class_offset_ns;
-
/* Eventual name suffix of the trace to set */
char *trace_name_suffix;
* int64_t -> struct bt_ctf_stream_class *
*/
GHashTable *stream_classes;
+
+ /* Config passed by the user */
+ struct ctf_metadata_decoder_config decoder_config;
};
/*
*/
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 "<<UNKNOWN>>";
- }
- return loglevel_str[value];
-}
-
/**
* Creates a new declaration scope.
*
scope = g_new(struct ctx_decl_scope, 1);
if (!scope) {
+ BT_LOGE_STR("Failed to allocate one declaration scope.");
goto end;
}
/* Prefix character + original string + '\0' */
char *prname = g_new(char, strlen(name) + 2);
if (!prname) {
+ BT_LOGE_STR("Failed to allocate a string.");
goto end;
}
*/
static
struct ctx *ctx_create(struct bt_ctf_trace *trace,
- int64_t clock_class_offset_ns, const char *trace_name_suffix)
+ const struct ctf_metadata_decoder_config *decoder_config,
+ const char *trace_name_suffix)
{
struct ctx *ctx = NULL;
struct ctx_decl_scope *scope = NULL;
+ assert(decoder_config);
+
ctx = g_new0(struct ctx, 1);
if (!ctx) {
+ BT_LOGE_STR("Failed to allocate one visitor context.");
goto error;
}
/* Root declaration scope */
scope = ctx_decl_scope_create(NULL);
if (!scope) {
+ BT_LOGE_STR("Cannot create declaration scope.");
goto error;
}
- ctx->stream_classes = g_hash_table_new_full(g_direct_hash,
- g_direct_equal, NULL, (GDestroyNotify) bt_put);
+ ctx->stream_classes = g_hash_table_new_full(g_int64_hash,
+ g_int64_equal, g_free, (GDestroyNotify) bt_put);
if (!ctx->stream_classes) {
+ BT_LOGE_STR("Failed to allocate a GHashTable.");
goto error;
}
if (trace_name_suffix) {
ctx->trace_name_suffix = strdup(trace_name_suffix);
if (!ctx->trace_name_suffix) {
+ BT_LOGE_STR("Failed to copy string.");
goto error;
}
}
ctx->current_scope = scope;
scope = NULL;
ctx->trace_bo = BT_CTF_BYTE_ORDER_NATIVE;
- ctx->clock_class_offset_ns = clock_class_offset_ns;
+ ctx->decoder_config = *decoder_config;
return ctx;
error:
assert(ctx);
new_scope = ctx_decl_scope_create(ctx->current_scope);
if (!new_scope) {
+ BT_LOGE_STR("Cannot create declaration scope.");
ret = -ENOMEM;
goto end;
}
uexpr_type != UNARY_UNSIGNED_CONSTANT ||
uexpr_link != UNARY_LINK_UNKNOWN || i != 0;
if (cond) {
+ _BT_LOGE_NODE(node, "Invalid constant unsigned integer.");
ret = -EINVAL;
goto end;
}
int uexpr_type = node->u.unary_expression.type;
int uexpr_link = node->u.unary_expression.link;
int cond = node->type != NODE_UNARY_EXPRESSION ||
- (uexpr_type != UNARY_UNSIGNED_CONSTANT) ||
(uexpr_type != UNARY_UNSIGNED_CONSTANT &&
uexpr_type != UNARY_SIGNED_CONSTANT) ||
uexpr_link != UNARY_LINK_UNKNOWN || i != 0;
goto end;
}
- switch (node->u.unary_expression.type) {
+ switch (uexpr_type) {
case UNARY_UNSIGNED_CONSTANT:
*value = (int64_t)
node->u.unary_expression.u.unsigned_constant;
src_string = node->u.unary_expression.u.string;
ret = bt_uuid_parse(src_string, uuid);
if (ret) {
+ _BT_LOGE_NODE(node,
+ "Cannot parse UUID: uuid=\"%s\"", src_string);
goto end;
}
}
int ret = 0;
if (unary_expr->type != NODE_UNARY_EXPRESSION) {
- BT_LOGE("Expecting unary expression: node-type=%d",
+ _BT_LOGE_NODE(unary_expr,
+ "Expecting unary expression: node-type=%d",
unary_expr->type);
ret = -EINVAL;
goto end;
} else if (!strcmp(str, "false") || !strcmp(str, "FALSE")) {
ret = FALSE;
} else {
- BT_LOGE("Unexpected boolean value: value=\"%s\"", str);
+ _BT_LOGE_NODE(unary_expr,
+ "Unexpected boolean value: value=\"%s\"", str);
ret = -EINVAL;
goto end;
}
break;
}
default:
- BT_LOGE("Unexpected unary expression type: node-type=%d",
+ _BT_LOGE_NODE(unary_expr,
+ "Unexpected unary expression type: node-type=%d",
unary_expr->u.unary_expression.type);
ret = -EINVAL;
goto end;
enum bt_ctf_byte_order bo = BT_CTF_BYTE_ORDER_UNKNOWN;
if (unary_expr->u.unary_expression.type != UNARY_STRING) {
- BT_LOGE_STR("\"byte_order\" attribute: expecting `be`, `le`, `network`, or `native`.");
+ _BT_LOGE_NODE(unary_expr,
+ "\"byte_order\" attribute: expecting `be`, `le`, `network`, or `native`.");
goto end;
}
} else if (!strcmp(str, "native")) {
bo = BT_CTF_BYTE_ORDER_NATIVE;
} else {
- BT_LOGE("Unexpected \"byte_order\" attribute value: "
+ _BT_LOGE_NODE(unary_expr,
+ "Unexpected \"byte_order\" attribute value: "
"expecting `be`, `le`, `network`, or `native`: value=\"%s\"",
str);
goto end;
int ret = 0;
if (type_specifier->type != NODE_TYPE_SPECIFIER) {
+ _BT_LOGE_NODE(type_specifier,
+ "Unexpected node type: node-type=%d",
+ type_specifier->type);
ret = -EINVAL;
goto end;
}
struct ctf_node *node = type_specifier->u.type_specifier.node;
if (!node->u._struct.name) {
- BT_LOGE_STR("Unexpected empty structure name.");
+ _BT_LOGE_NODE(node, "Unexpected empty structure field type name.");
ret = -EINVAL;
goto end;
}
struct ctf_node *node = type_specifier->u.type_specifier.node;
if (!node->u.variant.name) {
- BT_LOGE_STR("Unexpected empty variant name.");
+ _BT_LOGE_NODE(node, "Unexpected empty variant field type name.");
ret = -EINVAL;
goto end;
}
struct ctf_node *node = type_specifier->u.type_specifier.node;
if (!node->u._enum.enum_id) {
- BT_LOGE_STR("Unexpected empty enumeration field type (`enum`) name.");
+ _BT_LOGE_NODE(node,
+ "Unexpected empty enumeration field type (`enum`) name.");
ret = -EINVAL;
goto end;
}
case TYPESPEC_INTEGER:
case TYPESPEC_STRING:
default:
- BT_LOGE("Unexpected type specifier type: %d",
+ _BT_LOGE_NODE(type_specifier->u.type_specifier.node,
+ "Unexpected type specifier type: %d",
type_specifier->u.type_specifier.type);
ret = -EINVAL;
goto end;
if (node_type_declarator) {
if (node_type_declarator->u.type_declarator.type ==
TYPEDEC_UNKNOWN) {
- BT_LOGE("Unexpected type declarator type: type=%d",
+ _BT_LOGE_NODE(node_type_declarator,
+ "Unexpected type declarator type: type=%d",
node_type_declarator->u.type_declarator.type);
ret = -EINVAL;
goto error;
/* TODO: GCC bitfields not supported yet */
if (node_type_declarator->u.type_declarator.bitfield_len !=
NULL) {
- BT_LOGE_STR("GCC bitfields are not supported as of this version.");
+ _BT_LOGE_NODE(node_type_declarator,
+ "GCC bitfields are not supported as of this version.");
ret = -EPERM;
goto error;
}
ctx_decl_scope_lookup_alias(ctx->current_scope,
g_quark_to_string(qalias), -1);
if (!nested_decl) {
- BT_LOGE("Cannot find type alias: name=\"%s\"",
+ _BT_LOGE_NODE(node_type_declarator,
+ "Cannot find type alias: name=\"%s\"",
g_quark_to_string(qalias));
ret = -EINVAL;
goto error;
nested_decl_copy = bt_ctf_field_type_copy(nested_decl);
BT_PUT(nested_decl);
if (!nested_decl_copy) {
- BT_LOGE_STR("Cannot copy nested field type.");
+ _BT_LOGE_NODE(node_type_declarator,
+ "Cannot copy nested field type.");
ret = -EINVAL;
goto error;
}
/* Force integer's base to 16 since it's a pointer */
if (bt_ctf_field_type_is_integer(nested_decl)) {
- bt_ctf_field_type_integer_set_base(nested_decl,
+ ret = bt_ctf_field_type_integer_set_base(
+ nested_decl,
BT_CTF_INTEGER_BASE_HEXADECIMAL);
+ assert(ret == 0);
}
} else {
ret = visit_type_specifier_list(ctx,
/* Create array/sequence, pass nested_decl as child */
if (bt_list_empty(length)) {
- BT_LOGE_STR("Expecting length field reference or value.");
+ _BT_LOGE_NODE(node_type_declarator,
+ "Expecting length field reference or value.");
ret = -EINVAL;
goto error;
}
first = _BT_LIST_FIRST_ENTRY(length, struct ctf_node, siblings);
if (first->type != NODE_UNARY_EXPRESSION) {
+ _BT_LOGE_NODE(first,
+ "Unexpected node type: node-type=%d",
+ first->type);
ret = -EINVAL;
goto error;
}
len);
BT_PUT(nested_decl);
if (!array_decl) {
- BT_LOGE_STR("Cannot create array field type.");
+ _BT_LOGE_NODE(first,
+ "Cannot create array field type.");
ret = -ENOMEM;
goto error;
}
char *length_name = concatenate_unary_strings(length);
if (!length_name) {
+ _BT_LOGE_NODE(node_type_declarator,
+ "Cannot concatenate unary strings.");
ret = -EINVAL;
goto error;
}
g_free(length_name);
BT_PUT(nested_decl);
if (!seq_decl) {
- BT_LOGE_STR("Cannot create sequence field type.");
+ _BT_LOGE_NODE(node_type_declarator,
+ "Cannot create sequence field type.");
ret = -ENOMEM;
goto error;
}
&qfield_name, iter, &field_decl, NULL);
if (ret) {
assert(!field_decl);
- BT_LOGE("Cannot visit type declarator: ret=%d", ret);
+ _BT_LOGE_NODE(type_specifier_list,
+ "Cannot visit type declarator: ret=%d", ret);
goto error;
}
struct_decl, field_name);
if (efield_decl) {
BT_PUT(efield_decl);
- BT_LOGE("Duplicate field in structure field type: "
+ _BT_LOGE_NODE(type_specifier_list,
+ "Duplicate field in structure field type: "
"field-name=\"%s\"", field_name);
ret = -EINVAL;
goto error;
field_decl, field_name);
BT_PUT(field_decl);
if (ret) {
- BT_LOGE("Cannot add field to structure field type: "
+ _BT_LOGE_NODE(type_specifier_list,
+ "Cannot add field to structure field type: "
"field-name=\"%s\", ret=%d",
g_quark_to_string(qfield_name), ret);
goto error;
&qfield_name, iter, &field_decl, NULL);
if (ret) {
assert(!field_decl);
- BT_LOGE("Cannot visit type declarator: ret=%d", ret);
+ _BT_LOGE_NODE(type_specifier_list,
+ "Cannot visit type declarator: ret=%d", ret);
goto error;
}
variant_decl, field_name);
if (efield_decl) {
BT_PUT(efield_decl);
- BT_LOGE("Duplicate field in variant field type: "
+ _BT_LOGE_NODE(type_specifier_list,
+ "Duplicate field in variant field type: "
"field-name=\"%s\"", field_name);
ret = -EINVAL;
goto error;
field_decl, field_name);
BT_PUT(field_decl);
if (ret) {
- BT_LOGE("Cannot add field to variant field type: "
+ _BT_LOGE_NODE(type_specifier_list,
+ "Cannot add field to variant field type: "
"field-name=\"%s\", ret=%d",
g_quark_to_string(qfield_name), ret);
goto error;
ret = visit_type_declarator(ctx, type_specifier_list,
&qidentifier, iter, &type_decl, NULL);
if (ret) {
- BT_LOGE("Cannot visit type declarator: ret=%d", ret);
+ _BT_LOGE_NODE(iter,
+ "Cannot visit type declarator: ret=%d", ret);
ret = -EINVAL;
goto end;
}
/* Do not allow typedef and typealias of untagged variants */
if (bt_ctf_field_type_is_variant(type_decl)) {
if (bt_ctf_field_type_variant_get_tag_name(type_decl)) {
- BT_LOGE_STR("Type definition of untagged variant field type is not allowed.");
+ _BT_LOGE_NODE(iter,
+ "Type definition of untagged variant field type is not allowed.");
ret = -EPERM;
goto end;
}
ret = ctx_decl_scope_register_alias(ctx->current_scope,
g_quark_to_string(qidentifier), type_decl);
if (ret) {
- BT_LOGE("Cannot register type definition: name=\"%s\"",
+ _BT_LOGE_NODE(iter,
+ "Cannot register type definition: name=\"%s\"",
g_quark_to_string(qidentifier));
goto end;
}
&qdummy_field_name, node, &type_decl, NULL);
if (ret) {
assert(!type_decl);
- BT_LOGE("Cannot visit type declarator: ret=%d", ret);
+ _BT_LOGE_NODE(node,
+ "Cannot visit type declarator: ret=%d", ret);
goto end;
}
/* Do not allow typedef and typealias of untagged variants */
if (bt_ctf_field_type_is_variant(type_decl)) {
if (bt_ctf_field_type_variant_get_tag_name(type_decl)) {
- BT_LOGE_STR("Type definition of untagged variant field type is not allowed.");
+ _BT_LOGE_NODE(node,
+ "Type definition of untagged variant field type is not allowed.");
ret = -EPERM;
goto end;
}
* abstract or not (if it has an identifier). Check it here.
*/
if (qdummy_field_name != 0) {
- BT_LOGE("Expecting empty identifier: id=\"%s\"",
+ _BT_LOGE_NODE(node,
+ "Expecting empty identifier: id=\"%s\"",
g_quark_to_string(qdummy_field_name));
ret = -EINVAL;
goto end;
ret = ctx_decl_scope_register_alias(ctx->current_scope,
g_quark_to_string(qalias), type_decl);
if (ret) {
- BT_LOGE("Cannot register type alias: name=\"%s\"",
+ _BT_LOGE_NODE(node,
+ "Cannot register type alias: name=\"%s\"",
g_quark_to_string(qalias));
goto end;
}
entry_node->u._typedef.type_specifier_list,
&entry_node->u._typedef.type_declarators);
if (ret) {
- BT_LOGE("Cannot add type definition found in structure field type: ret=%d",
+ _BT_LOGE_NODE(entry_node,
+ "Cannot add type definition found in structure field type: ret=%d",
ret);
goto end;
}
ret = visit_typealias(ctx, entry_node->u.typealias.target,
entry_node->u.typealias.alias);
if (ret) {
- BT_LOGE("Cannot add type alias found in structure field type: ret=%d",
+ _BT_LOGE_NODE(entry_node,
+ "Cannot add type alias found in structure field type: ret=%d",
ret);
goto end;
}
}
break;
default:
- BT_LOGE("Unexpected node type: node-type=%d", entry_node->type);
+ _BT_LOGE_NODE(entry_node,
+ "Unexpected node type: node-type=%d", entry_node->type);
ret = -EINVAL;
goto end;
}
entry_node->u._typedef.type_specifier_list,
&entry_node->u._typedef.type_declarators);
if (ret) {
- BT_LOGE("Cannot add type definition found in variant field type: ret=%d",
+ _BT_LOGE_NODE(entry_node,
+ "Cannot add type definition found in variant field type: ret=%d",
ret);
goto end;
}
ret = visit_typealias(ctx, entry_node->u.typealias.target,
entry_node->u.typealias.alias);
if (ret) {
- BT_LOGE("Cannot add type alias found in variant field type: ret=%d",
+ _BT_LOGE_NODE(entry_node,
+ "Cannot add type alias found in variant field type: ret=%d",
ret);
goto end;
}
}
break;
default:
- BT_LOGE("Unexpected node type: node-type=%d",
+ _BT_LOGE_NODE(entry_node,
+ "Unexpected node type: node-type=%d",
entry_node->type);
ret = -EINVAL;
goto end;
_BT_CTF_FIELD_TYPE_INIT(struct_decl_copy);
if (!name) {
+ BT_LOGE_STR("Bodyless structure field type: missing name.");
ret = -EPERM;
goto error;
}
ret = visit_struct_decl_entry(ctx, entry_node,
*struct_decl);
if (ret) {
+ _BT_LOGE_NODE(entry_node,
+ "Cannot visit structure field type entry: "
+ "ret=%d", ret);
ctx_pop_scope(ctx);
goto error;
}
_BT_CTF_FIELD_TYPE_INIT(variant_decl_copy);
if (!name) {
+ BT_LOGE_STR("Bodyless variant field type: missing name.");
ret = -EPERM;
goto error;
}
ret = visit_variant_decl_entry(ctx, entry_node,
untagged_variant_decl);
if (ret) {
+ _BT_LOGE_NODE(entry_node,
+ "Cannot visit variant field type entry: "
+ "ret=%d", ret);
ctx_pop_scope(ctx);
goto error;
}
ret = bt_ctf_field_type_variant_set_tag_name(
untagged_variant_decl, tag);
if (ret) {
+ BT_LOGE("Cannot set variant field type's tag name: "
+ "tag-name=\"%s\"", tag);
goto error;
}
int64_t *target;
if (iter->type != NODE_UNARY_EXPRESSION) {
- BT_LOGE("Wrong expression for enumeration field type label: "
+ _BT_LOGE_NODE(iter,
+ "Wrong expression for enumeration field type label: "
"node-type=%d, label=\"%s\"", iter->type,
label);
ret = -EINVAL;
iter->u.unary_expression.u.unsigned_constant;
break;
default:
- BT_LOGE("Invalid enumeration field type entry: "
+ _BT_LOGE_NODE(iter,
+ "Invalid enumeration field type entry: "
"expecting constant signed or unsigned integer: "
"node-type=%d, label=\"%s\"",
iter->u.unary_expression.type, label);
}
if (nr_vals > 1) {
- BT_LOGE("Invalid enumeration field type entry: label=\"%s\"",
+ _BT_LOGE_NODE(iter,
+ "Invalid enumeration field type entry: label=\"%s\"",
label);
ret = -EINVAL;
goto error;
label, (uint64_t) start, (uint64_t) end);
}
if (ret) {
- BT_LOGE("Cannot add mapping to enumeration field type: "
+ _BT_LOGE_NODE(enumerator,
+ "Cannot add mapping to enumeration field type: "
"label=\"%s\", ret=%d, "
"start-value-unsigned=%" PRIu64 ", "
"end-value-unsigned=%" PRIu64, label, ret,
_BT_CTF_FIELD_TYPE_INIT(enum_decl_copy);
if (!name) {
+ BT_LOGE_STR("Bodyless enumeration field type: missing name.");
ret = -EPERM;
goto error;
}
&last_value,
bt_ctf_field_type_integer_get_signed(integer_decl));
if (ret) {
+ _BT_LOGE_NODE(iter,
+ "Cannot visit enumeration field type entry: "
+ "ret=%d", ret);
goto error;
}
}
ret = ctx_decl_scope_register_enum(ctx->current_scope,
name, *enum_decl);
if (ret) {
+ BT_LOGE("Cannot register enumeration field type in declaration scope: "
+ "ret=%d", ret);
goto error;
}
}
str = g_string_new("");
ret = get_type_specifier_list_name(ctx, type_specifier_list, str);
if (ret) {
+ _BT_LOGE_NODE(type_specifier_list,
+ "Cannot get type specifier list's name: ret=%d", ret);
goto error;
}
*decl = ctx_decl_scope_lookup_alias(ctx->current_scope, str->str, -1);
if (!*decl) {
- BT_LOGE("Cannot find type alias: name=\"%s\"", str->str);
+ _BT_LOGE_NODE(type_specifier_list,
+ "Cannot find type alias: name=\"%s\"", str->str);
ret = -EINVAL;
goto error;
}
/* Make a copy of the type declaration */
decl_copy = bt_ctf_field_type_copy(*decl);
if (!decl_copy) {
- BT_LOGE_STR("Cannot create field type copy.");
+ _BT_LOGE_NODE(type_specifier_list,
+ "Cannot create field type copy.");
ret = -EINVAL;
goto error;
}
siblings);
if (left->u.unary_expression.type != UNARY_STRING) {
+ _BT_LOGE_NODE(left,
+ "Unexpected unary expression type: type=%d",
+ left->u.unary_expression.type);
ret = -EINVAL;
goto error;
}
if (!strcmp(left->u.unary_expression.u.string, "signed")) {
if (_IS_SET(&set, _INTEGER_SIGNED_SET)) {
- _BT_LOGE_DUP_ATTR("signed",
+ _BT_LOGE_DUP_ATTR(left, "signed",
"integer field type");
ret = -EPERM;
goto error;
signedness = get_boolean(right);
if (signedness < 0) {
+ _BT_LOGE_NODE(right,
+ "Invalid boolean value for integer field type's `signed` attribute: "
+ "ret=%d", ret);
ret = -EINVAL;
goto error;
}
} else if (!strcmp(left->u.unary_expression.u.string,
"byte_order")) {
if (_IS_SET(&set, _INTEGER_BYTE_ORDER_SET)) {
- _BT_LOGE_DUP_ATTR("byte_order",
+ _BT_LOGE_DUP_ATTR(left, "byte_order",
"integer field type");
ret = -EPERM;
goto error;
byte_order = get_real_byte_order(ctx, right);
if (byte_order == BT_CTF_BYTE_ORDER_UNKNOWN) {
- BT_LOGE("Invalid `byte_order` attribute in integer field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `byte_order` attribute in integer field type: "
"ret=%d", ret);
ret = -EINVAL;
goto error;
_SET(&set, _INTEGER_BYTE_ORDER_SET);
} else if (!strcmp(left->u.unary_expression.u.string, "size")) {
if (_IS_SET(&set, _INTEGER_SIZE_SET)) {
- _BT_LOGE_DUP_ATTR("size",
+ _BT_LOGE_DUP_ATTR(left, "size",
"integer field type");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- BT_LOGE("Invalid `size` attribute in integer field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `size` attribute in integer field type: "
"expecting unsigned constant integer: "
"node-type=%d",
right->u.unary_expression.type);
size = right->u.unary_expression.u.unsigned_constant;
if (size == 0) {
- BT_LOGE("Invalid `size` attribute in integer field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `size` attribute in integer field type: "
"expecting positive constant integer: "
"size=%" PRIu64, size);
ret = -EINVAL;
goto error;
} else if (size > 64) {
- BT_LOGE("Invalid `size` attribute in integer field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `size` attribute in integer field type: "
"integer fields over 64 bits are not supported as of this version: "
"size=%" PRIu64, size);
ret = -EINVAL;
} else if (!strcmp(left->u.unary_expression.u.string,
"align")) {
if (_IS_SET(&set, _INTEGER_ALIGN_SET)) {
- _BT_LOGE_DUP_ATTR("align",
+ _BT_LOGE_DUP_ATTR(left, "align",
"integer field type");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- BT_LOGE("Invalid `align` attribute in integer field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `align` attribute in integer field type: "
"expecting unsigned constant integer: "
"node-type=%d",
right->u.unary_expression.type);
alignment =
right->u.unary_expression.u.unsigned_constant;
if (!is_align_valid(alignment)) {
- BT_LOGE("Invalid `align` attribute in integer field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `align` attribute in integer field type: "
"expecting power of two: "
"align=%" PRIu64, alignment);
ret = -EINVAL;
_SET(&set, _INTEGER_ALIGN_SET);
} else if (!strcmp(left->u.unary_expression.u.string, "base")) {
if (_IS_SET(&set, _INTEGER_BASE_SET)) {
- _BT_LOGE_DUP_ATTR("base", "integer field type");
+ _BT_LOGE_DUP_ATTR(left, "base",
+ "integer field type");
ret = -EPERM;
goto error;
}
base = BT_CTF_INTEGER_BASE_HEXADECIMAL;
break;
default:
- BT_LOGE("Invalid `base` attribute in integer field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `base` attribute in integer field type: "
"base=%" PRIu64,
right->u.unary_expression.u.unsigned_constant);
ret = -EINVAL;
char *s_right = concatenate_unary_strings(
&expression->u.ctf_expression.right);
if (!s_right) {
- BT_LOGE_STR("Unexpected unary expression for integer field type's `base` attribute.");
+ _BT_LOGE_NODE(right,
+ "Unexpected unary expression for integer field type's `base` attribute.");
ret = -EINVAL;
goto error;
}
!strcmp(s_right, "b")) {
base = BT_CTF_INTEGER_BASE_BINARY;
} else {
- BT_LOGE("Unexpected unary expression for integer field type's `base` attribute: "
+ _BT_LOGE_NODE(right,
+ "Unexpected unary expression for integer field type's `base` attribute: "
"base=\"%s\"", s_right);
g_free(s_right);
ret = -EINVAL;
break;
}
default:
- BT_LOGE_STR("Invalid `base` attribute in integer field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `base` attribute in integer field type: "
"expecting unsigned constant integer or unary string.");
ret = -EINVAL;
goto error;
char *s_right;
if (_IS_SET(&set, _INTEGER_ENCODING_SET)) {
- _BT_LOGE_DUP_ATTR("encoding",
+ _BT_LOGE_DUP_ATTR(left, "encoding",
"integer field type");
ret = -EPERM;
goto error;
}
if (right->u.unary_expression.type != UNARY_STRING) {
- BT_LOGE_STR("Invalid `encoding` attribute in integer field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `encoding` attribute in integer field type: "
"expecting unary string.");
ret = -EINVAL;
goto error;
s_right = concatenate_unary_strings(
&expression->u.ctf_expression.right);
if (!s_right) {
- BT_LOGE_STR("Unexpected unary expression for integer field type's `encoding` attribute.");
+ _BT_LOGE_NODE(right,
+ "Unexpected unary expression for integer field type's `encoding` attribute.");
ret = -EINVAL;
goto error;
}
} else if (!strcmp(s_right, "none")) {
encoding = BT_CTF_STRING_ENCODING_NONE;
} else {
- BT_LOGE("Invalid `encoding` attribute in integer field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `encoding` attribute in integer field type: "
"unknown encoding: encoding=\"%s\"",
s_right);
g_free(s_right);
const char *clock_name;
if (_IS_SET(&set, _INTEGER_MAP_SET)) {
- _BT_LOGE_DUP_ATTR("map", "integer field type");
+ _BT_LOGE_DUP_ATTR(left, "map",
+ "integer field type");
ret = -EPERM;
goto error;
}
if (right->u.unary_expression.type != UNARY_STRING) {
- BT_LOGE_STR("Invalid `map` attribute in integer field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `map` attribute in integer field type: "
"expecting unary string.");
ret = -EINVAL;
goto error;
&expression->u.ctf_expression.right);
if (!s_right) {
- BT_LOGE_STR("Unexpected unary expression for integer field type's `map` attribute.");
+ _BT_LOGE_NODE(right,
+ "Unexpected unary expression for integer field type's `map` attribute.");
ret = -EINVAL;
goto error;
}
- BT_LOGE("Invalid `map` attribute in integer field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `map` attribute in integer field type: "
"cannot find clock class at this point: name=\"%s\"",
s_right);
_SET(&set, _INTEGER_MAP_SET);
mapped_clock = bt_ctf_trace_get_clock_class_by_name(
ctx->trace, clock_name);
if (!mapped_clock) {
- BT_LOGE("Invalid `map` attribute in integer field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `map` attribute in integer field type: "
"cannot find clock class at this point: name=\"%s\"",
clock_name);
ret = -EINVAL;
_SET(&set, _INTEGER_MAP_SET);
} else {
- BT_LOGW("Unknown attribute in integer field type: "
+ _BT_LOGW_NODE(left,
+ "Unknown attribute in integer field type: "
"attr-name=\"%s\"",
left->u.unary_expression.u.string);
}
siblings);
if (left->u.unary_expression.type != UNARY_STRING) {
+ _BT_LOGE_NODE(left,
+ "Unexpected unary expression type: type=%d",
+ left->u.unary_expression.type);
ret = -EINVAL;
goto error;
}
if (!strcmp(left->u.unary_expression.u.string, "byte_order")) {
if (_IS_SET(&set, _FLOAT_BYTE_ORDER_SET)) {
- _BT_LOGE_DUP_ATTR("byte_order",
+ _BT_LOGE_DUP_ATTR(left, "byte_order",
"floating point number field type");
ret = -EPERM;
goto error;
byte_order = get_real_byte_order(ctx, right);
if (byte_order == BT_CTF_BYTE_ORDER_UNKNOWN) {
- BT_LOGE("Invalid `byte_order` attribute in floating point number field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `byte_order` attribute in floating point number field type: "
"ret=%d", ret);
ret = -EINVAL;
goto error;
} else if (!strcmp(left->u.unary_expression.u.string,
"exp_dig")) {
if (_IS_SET(&set, _FLOAT_EXP_DIG_SET)) {
- _BT_LOGE_DUP_ATTR("exp_dig",
+ _BT_LOGE_DUP_ATTR(left, "exp_dig",
"floating point number field type");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- BT_LOGE("Invalid `exp_dig` attribute in floating point number field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `exp_dig` attribute in floating point number field type: "
"expecting unsigned constant integer: "
"node-type=%d",
right->u.unary_expression.type);
} else if (!strcmp(left->u.unary_expression.u.string,
"mant_dig")) {
if (_IS_SET(&set, _FLOAT_MANT_DIG_SET)) {
- _BT_LOGE_DUP_ATTR("mant_dig",
+ _BT_LOGE_DUP_ATTR(left, "mant_dig",
"floating point number field type");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- BT_LOGE("Invalid `mant_dig` attribute in floating point number field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `mant_dig` attribute in floating point number field type: "
"expecting unsigned constant integer: "
"node-type=%d",
right->u.unary_expression.type);
} else if (!strcmp(left->u.unary_expression.u.string,
"align")) {
if (_IS_SET(&set, _FLOAT_ALIGN_SET)) {
- _BT_LOGE_DUP_ATTR("align",
+ _BT_LOGE_DUP_ATTR(left, "align",
"floating point number field type");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- BT_LOGE("Invalid `align` attribute in floating point number field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `align` attribute in floating point number field type: "
"expecting unsigned constant integer: "
"node-type=%d",
right->u.unary_expression.type);
unsigned_constant;
if (!is_align_valid(alignment)) {
- BT_LOGE("Invalid `align` attribute in floating point number field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `align` attribute in floating point number field type: "
"expecting power of two: "
"align=%" PRIu64, alignment);
ret = -EINVAL;
_SET(&set, _FLOAT_ALIGN_SET);
} else {
- BT_LOGW("Unknown attribute in floating point number field type: "
+ _BT_LOGW_NODE(left,
+ "Unknown attribute in floating point number field type: "
"attr-name=\"%s\"",
left->u.unary_expression.u.string);
}
siblings);
if (left->u.unary_expression.type != UNARY_STRING) {
+ _BT_LOGE_NODE(left,
+ "Unexpected unary expression type: type=%d",
+ left->u.unary_expression.type);
ret = -EINVAL;
goto error;
}
char *s_right;
if (_IS_SET(&set, _STRING_ENCODING_SET)) {
- _BT_LOGE_DUP_ATTR("encoding",
+ _BT_LOGE_DUP_ATTR(left, "encoding",
"string field type");
ret = -EPERM;
goto error;
}
if (right->u.unary_expression.type != UNARY_STRING) {
- BT_LOGE_STR("Invalid `encoding` attribute in string field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `encoding` attribute in string field type: "
"expecting unary string.");
ret = -EINVAL;
goto error;
s_right = concatenate_unary_strings(
&expression->u.ctf_expression.right);
if (!s_right) {
- BT_LOGE_STR("Unexpected unary expression for string field type's `encoding` attribute.");
+ _BT_LOGE_NODE(right,
+ "Unexpected unary expression for string field type's `encoding` attribute.");
ret = -EINVAL;
goto error;
}
} else if (!strcmp(s_right, "none")) {
encoding = BT_CTF_STRING_ENCODING_NONE;
} else {
- BT_LOGE("Invalid `encoding` attribute in string field type: "
+ _BT_LOGE_NODE(right,
+ "Invalid `encoding` attribute in string field type: "
"unknown encoding: encoding=\"%s\"",
s_right);
g_free(s_right);
g_free(s_right);
_SET(&set, _STRING_ENCODING_SET);
} else {
- BT_LOGW("Unknown attribute in string field type: "
+ _BT_LOGW_NODE(left,
+ "Unknown attribute in string field type: "
"attr-name=\"%s\"",
left->u.unary_expression.u.string);
}
*decl = NULL;
if (ts_list->type != NODE_TYPE_SPECIFIER_LIST) {
+ _BT_LOGE_NODE(ts_list,
+ "Unexpected node type: node-type=%d", ts_list->type);
ret = -EINVAL;
goto error;
}
first = _BT_LIST_FIRST_ENTRY(&ts_list->u.type_specifier_list.head,
struct ctf_node, siblings);
if (first->type != NODE_TYPE_SPECIFIER) {
+ _BT_LOGE_NODE(first,
+ "Unexpected node type: node-type=%d", first->type);
ret = -EINVAL;
goto error;
}
case TYPESPEC_ID_TYPE:
ret = visit_type_specifier(ctx, ts_list, decl);
if (ret) {
+ _BT_LOGE_NODE(first,
+ "Cannot visit type specifier: ret=%d",
+ ret);
assert(!*decl);
goto error;
}
break;
default:
- BT_LOGE("Unexpected node type: node-type=%d",
+ _BT_LOGE_NODE(first,
+ "Unexpected type specifier type: node-type=%d",
first->u.type_specifier.type);
ret = -EINVAL;
goto error;
ret = visit_typedef(ctx, node->u._typedef.type_specifier_list,
&node->u._typedef.type_declarators);
if (ret) {
- BT_LOGE_STR("Cannot add type definition found in event class.");
+ _BT_LOGE_NODE(node,
+ "Cannot add type definition found in event class.");
goto error;
}
break;
ret = visit_typealias(ctx, node->u.typealias.target,
node->u.typealias.alias);
if (ret) {
- BT_LOGE_STR("Cannot add type alias found in event class.");
+ _BT_LOGE_NODE(node,
+ "Cannot add type alias found in event class.");
goto error;
}
break;
{
left = concatenate_unary_strings(&node->u.ctf_expression.left);
if (!left) {
+ _BT_LOGE_NODE(node, "Cannot concatenate unary strings.");
ret = -EINVAL;
goto error;
}
if (!strcmp(left, "name")) {
/* This is already known at this stage */
if (_IS_SET(set, _EVENT_NAME_SET)) {
- _BT_LOGE_DUP_ATTR("name", "event declaration");
+ _BT_LOGE_DUP_ATTR(node, "name",
+ "event class");
ret = -EPERM;
goto error;
}
int64_t id;
if (_IS_SET(set, _EVENT_ID_SET)) {
- _BT_LOGE_DUP_ATTR("id", "event declaration");
+ _BT_LOGE_DUP_ATTR(node, "id",
+ "event class");
ret = -EPERM;
goto error;
}
(uint64_t *) &id);
/* Only read "id" if get_unary_unsigned() succeeded. */
if (ret || (!ret && id < 0)) {
- BT_LOGE_STR("Unexpected unary expression for event class's `id` attribute.");
+ _BT_LOGE_NODE(node,
+ "Unexpected unary expression for event class's `id` attribute.");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_event_class_set_id(event_class, id);
if (ret) {
- BT_LOGE("Cannot set event class's ID: "
+ _BT_LOGE_NODE(node,
+ "Cannot set event class's ID: "
"id=%" PRId64, id);
goto error;
}
_SET(set, _EVENT_ID_SET);
} else if (!strcmp(left, "stream_id")) {
if (_IS_SET(set, _EVENT_STREAM_ID_SET)) {
- _BT_LOGE_DUP_ATTR("stream_id",
+ _BT_LOGE_DUP_ATTR(node, "stream_id",
"event class");
ret = -EPERM;
goto error;
* succeeded.
*/
if (ret || (!ret && *stream_id < 0)) {
- BT_LOGE_STR("Unexpected unary expression for event class's `stream_id` attribute.");
+ _BT_LOGE_NODE(node,
+ "Unexpected unary expression for event class's `stream_id` attribute.");
ret = -EINVAL;
goto error;
}
_SET(set, _EVENT_STREAM_ID_SET);
} else if (!strcmp(left, "context")) {
if (_IS_SET(set, _EVENT_CONTEXT_SET)) {
- BT_LOGE_STR("Duplicate `context` entry in event class.");
+ _BT_LOGE_NODE(node,
+ "Duplicate `context` entry in event class.");
ret = -EPERM;
goto error;
}
struct ctf_node, siblings),
&decl);
if (ret) {
- BT_LOGE_STR("Cannot create event class's context field type.");
+ _BT_LOGE_NODE(node,
+ "Cannot create event class's context field type.");
goto error;
}
event_class, decl);
BT_PUT(decl);
if (ret) {
- BT_LOGE_STR("Cannot set event class's context field type.");
+ _BT_LOGE_NODE(node,
+ "Cannot set event class's context field type.");
goto error;
}
_SET(set, _EVENT_CONTEXT_SET);
} else if (!strcmp(left, "fields")) {
if (_IS_SET(set, _EVENT_FIELDS_SET)) {
- BT_LOGE_STR("Duplicate `fields` entry in event class.");
+ _BT_LOGE_NODE(node,
+ "Duplicate `fields` entry in event class.");
ret = -EPERM;
goto error;
}
struct ctf_node, siblings),
&decl);
if (ret) {
- BT_LOGE_STR("Cannot create event class's payload field type.");
+ _BT_LOGE_NODE(node,
+ "Cannot create event class's payload field type.");
goto error;
}
event_class, decl);
BT_PUT(decl);
if (ret) {
- BT_LOGE_STR("Cannot set event class's payload field type.");
+ _BT_LOGE_NODE(node,
+ "Cannot set event class's payload field type.");
goto error;
}
_SET(set, _EVENT_FIELDS_SET);
} else if (!strcmp(left, "loglevel")) {
uint64_t loglevel_value;
- const char *loglevel_str;
- struct bt_value *value_obj, *str_obj;
+ enum bt_ctf_event_class_log_level log_level =
+ BT_CTF_EVENT_CLASS_LOG_LEVEL_UNSPECIFIED;
if (_IS_SET(set, _EVENT_LOGLEVEL_SET)) {
- _BT_LOGE_DUP_ATTR("loglevel",
+ _BT_LOGE_DUP_ATTR(node, "loglevel",
"event class");
ret = -EPERM;
goto error;
ret = get_unary_unsigned(&node->u.ctf_expression.right,
&loglevel_value);
if (ret) {
- BT_LOGE_STR("Unexpected unary expression for event class's `loglevel` attribute.");
+ _BT_LOGE_NODE(node,
+ "Unexpected unary expression for event class's `loglevel` attribute.");
ret = -EINVAL;
goto error;
}
- value_obj = bt_value_integer_create_init(loglevel_value);
- if (!value_obj) {
- BT_LOGE_STR("Cannot create integer value object.");
- ret = -ENOMEM;
- goto error;
- }
- if (bt_ctf_event_class_set_attribute(event_class,
- "loglevel", value_obj) != BT_VALUE_STATUS_OK) {
- BT_LOGE_STR("Cannot set event class's `loglevel` attribute.");
- ret = -EINVAL;
- bt_put(value_obj);
- goto error;
+
+ switch (loglevel_value) {
+ case 0:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_EMERGENCY;
+ break;
+ case 1:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_ALERT;
+ break;
+ case 2:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_CRITICAL;
+ break;
+ case 3:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_ERROR;
+ break;
+ case 4:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_WARNING;
+ break;
+ case 5:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_NOTICE;
+ break;
+ case 6:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_INFO;
+ break;
+ case 7:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM;
+ break;
+ case 8:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM;
+ break;
+ case 9:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS;
+ break;
+ case 10:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE;
+ break;
+ case 11:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT;
+ break;
+ case 12:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION;
+ break;
+ case 13:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE;
+ break;
+ case 14:
+ log_level = BT_CTF_EVENT_CLASS_LOG_LEVEL_DEBUG;
+ break;
+ default:
+ _BT_LOGW_NODE(node, "Not setting event class's log level because its value is unknown: "
+ "log-level=%" PRIu64, loglevel_value);
}
- 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) {
- BT_LOGE_STR("Cannot set event class's `loglevel_string` attribute.");
- ret = -EINVAL;
- bt_put(str_obj);
+
+ if (log_level != BT_CTF_EVENT_CLASS_LOG_LEVEL_UNSPECIFIED) {
+ ret = bt_ctf_event_class_set_log_level(
+ event_class, log_level);
+ if (ret) {
+ _BT_LOGE_NODE(node,
+ "Cannot set event class's log level.");
goto error;
}
- bt_put(str_obj);
}
- bt_put(value_obj);
+
_SET(set, _EVENT_LOGLEVEL_SET);
} else if (!strcmp(left, "model.emf.uri")) {
char *right;
if (_IS_SET(set, _EVENT_MODEL_EMF_URI_SET)) {
- _BT_LOGE_DUP_ATTR("model.emf.uri",
- "event declaration");
+ _BT_LOGE_DUP_ATTR(node, "model.emf.uri",
+ "event class");
ret = -EPERM;
goto error;
}
right = concatenate_unary_strings(
&node->u.ctf_expression.right);
if (!right) {
- BT_LOGE_STR("Unexpected unary expression for event class's `model.emf.uri` attribute.");
+ _BT_LOGE_NODE(node,
+ "Unexpected unary expression for event class's `model.emf.uri` attribute.");
ret = -EINVAL;
goto error;
}
- // TODO: FIXME: set model EMF URI here
+ if (strlen(right) == 0) {
+ _BT_LOGW_NODE(node,
+ "Not setting event class's EMF URI because it's empty.");
+ } else {
+ ret = bt_ctf_event_class_set_emf_uri(
+ event_class, right);
+ if (ret) {
+ _BT_LOGE_NODE(node,
+ "Cannot set event class's EMF URI.");
+ goto error;
+ }
+ }
g_free(right);
_SET(set, _EVENT_MODEL_EMF_URI_SET);
} else {
- BT_LOGW("Unknown attribute in event class: "
+ _BT_LOGW_NODE(node,
+ "Unknown attribute in event class: "
"attr-name=\"%s\"", left);
}
left = concatenate_unary_strings(&iter->u.ctf_expression.left);
if (!left) {
+ _BT_LOGE_NODE(iter,
+ "Cannot concatenate unary strings.");
goto error;
}
name = concatenate_unary_strings(
&iter->u.ctf_expression.right);
if (!name) {
- BT_LOGE_STR("Unexpected unary expression for event class's `name` attribute.");
+ _BT_LOGE_NODE(iter,
+ "Unexpected unary expression for event class's `name` attribute.");
goto error;
}
}
/* Context type. */
ret = bt_ctf_event_class_set_context_type(event_class, NULL);
if (ret) {
- BT_LOGE_STR("Cannot reset initial event class's context field type.");
+ BT_LOGE("Cannot reset initial event class's context field type: "
+ "event-name=\"%s\"",
+ bt_ctf_event_class_get_name(event_class));
goto end;
}
/* Event payload. */
ret = bt_ctf_event_class_set_payload_type(event_class, NULL);
if (ret) {
- BT_LOGE_STR("Cannot reset initial event class's payload field type.");
+ BT_LOGE("Cannot reset initial event class's payload field type: "
+ "event-name=\"%s\"",
+ bt_ctf_event_class_get_name(event_class));
goto end;
}
end:
node->visited = TRUE;
event_name = get_event_decl_name(ctx, node);
if (!event_name) {
- BT_LOGE_STR("Missing `name` attribute in event class.");
+ _BT_LOGE_NODE(node,
+ "Missing `name` attribute in event class.");
ret = -EPERM;
goto error;
}
*/
ret = reset_event_decl_types(ctx, event_class);
if (ret) {
+ _BT_LOGE_NODE(node,
+ "Cannot reset event class's field types: "
+ "ret=%d", ret);
goto error;
}
ret = visit_event_decl_entry(ctx, iter, event_class,
&stream_id, &set);
if (ret) {
+ _BT_LOGE_NODE(iter, "Cannot visit event class's entry: "
+ "ret=%d", ret);
goto error;
}
}
if (!_IS_SET(&set, _EVENT_STREAM_ID_SET)) {
GList *keys = NULL;
+ int64_t *new_stream_id;
struct bt_ctf_stream_class *new_stream_class;
size_t stream_class_count =
g_hash_table_size(ctx->stream_classes) +
switch (stream_class_count) {
case 0:
/* Create implicit stream class if there's none */
+ stream_id = 0;
new_stream_class = create_reset_stream_class(ctx);
if (!new_stream_class) {
+ _BT_LOGE_NODE(node,
+ "Cannot create empty stream class.");
ret = -EINVAL;
goto error;
}
- ret = bt_ctf_stream_class_set_id(new_stream_class, 0);
+ ret = bt_ctf_stream_class_set_id(new_stream_class,
+ stream_id);
if (ret) {
- BT_LOGE("Cannot set stream class's ID: "
+ _BT_LOGE_NODE(node,
+ "Cannot set stream class's ID: "
"id=0, ret=%d", ret);
BT_PUT(new_stream_class);
goto error;
}
- stream_id = 0;
+ new_stream_id = g_new0(int64_t, 1);
+ if (!new_stream_id) {
+ BT_LOGE_STR("Failed to allocate a int64_t.");
+ ret = -ENOMEM;
+ goto error;
+ }
+
+ *new_stream_id = stream_id;
/* Move reference to visitor's context */
g_hash_table_insert(ctx->stream_classes,
- (gpointer) stream_id, new_stream_class);
+ new_stream_id, new_stream_class);
+ new_stream_id = NULL;
new_stream_class = NULL;
break;
case 1:
/* 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;
+ stream_id = *((int64_t *) keys->data);
g_list_free(keys);
} else {
assert(bt_ctf_trace_get_stream_class_count(
}
break;
default:
- BT_LOGE_STR("Missing `stream_id` attribute in event class.");
+ _BT_LOGE_NODE(node,
+ "Missing `stream_id` attribute in event class.");
ret = -EPERM;
goto error;
}
assert(stream_id >= 0);
/* We have the stream ID now; get the stream class if found */
- stream_class = g_hash_table_lookup(ctx->stream_classes,
- (gpointer) stream_id);
+ stream_class = g_hash_table_lookup(ctx->stream_classes, &stream_id);
bt_get(stream_class);
if (!stream_class) {
stream_class = bt_ctf_trace_get_stream_class_by_id(ctx->trace,
stream_id);
if (!stream_class) {
- BT_LOGE("Cannot find stream class at this point: "
+ _BT_LOGE_NODE(node,
+ "Cannot find stream class at this point: "
"id=%" PRId64, stream_id);
ret = -EINVAL;
goto error;
/* Allow only one event without ID per stream */
if (bt_ctf_stream_class_get_event_class_count(stream_class) !=
0) {
- BT_LOGE_STR("Missing `id` attribute in event class.");
+ _BT_LOGE_NODE(node,
+ "Missing `id` attribute in event class.");
ret = -EPERM;
goto error;
}
/* Automatic ID */
ret = bt_ctf_event_class_set_id(event_class, 0);
if (ret) {
- BT_LOGE("Cannot set event class's ID: id=0, ret=%d",
+ _BT_LOGE_NODE(node,
+ "Cannot set event class's ID: id=0, ret=%d",
ret);
goto error;
}
event_id = bt_ctf_event_class_get_id(event_class);
if (event_id < 0) {
- BT_LOGE_STR("Cannot get event class's ID.");
+ _BT_LOGE_NODE(node, "Cannot get event class's ID.");
ret = -EINVAL;
goto error;
}
event_id);
if (eevent_class) {
BT_PUT(eevent_class);
- BT_LOGE("Duplicate event class (same ID) in the same stream class: "
+ _BT_LOGE_NODE(node,
+ "Duplicate event class (same ID) in the same stream class: "
"id=%" PRId64, event_id);
ret = -EEXIST;
goto error;
ret = bt_ctf_stream_class_add_event_class(stream_class, event_class);
BT_PUT(event_class);
if (ret) {
- BT_LOGE("Cannot add event class to stream class: ret=%d", ret);
+ _BT_LOGE_NODE(node,
+ "Cannot add event class to stream class: ret=%d", ret);
goto error;
}
return ret;
}
+static
+int auto_map_field_to_trace_clock_class(struct ctx *ctx,
+ struct bt_ctf_field_type *ft)
+{
+ struct bt_ctf_clock_class *clock_class_to_map_to = NULL;
+ struct bt_ctf_clock_class *mapped_clock_class = NULL;
+ int ret = 0;
+ int64_t clock_class_count;
+
+ if (!ft || !bt_ctf_field_type_is_integer(ft)) {
+ goto end;
+ }
+
+ mapped_clock_class =
+ bt_ctf_field_type_integer_get_mapped_clock_class(ft);
+ if (mapped_clock_class) {
+ goto end;
+ }
+
+ clock_class_count = bt_ctf_trace_get_clock_class_count(ctx->trace);
+ assert(clock_class_count >= 0);
+
+ switch (clock_class_count) {
+ case 0:
+ /*
+ * No clock class exists in the trace at this
+ * point. Create an implicit one at 1 GHz,
+ * named `default`, and use this clock class.
+ */
+ clock_class_to_map_to = bt_ctf_clock_class_create("default",
+ 1000000000);
+ if (!clock_class_to_map_to) {
+ BT_LOGE_STR("Cannot create a clock class.");
+ ret = -1;
+ goto end;
+ }
+
+ ret = bt_ctf_trace_add_clock_class(ctx->trace,
+ clock_class_to_map_to);
+ if (ret) {
+ BT_LOGE_STR("Cannot add clock class to trace.");
+ goto end;
+ }
+ break;
+ case 1:
+ /*
+ * Only one clock class exists in the trace at
+ * this point: use this one.
+ */
+ clock_class_to_map_to =
+ bt_ctf_trace_get_clock_class_by_index(ctx->trace, 0);
+ assert(clock_class_to_map_to);
+ break;
+ default:
+ /*
+ * Timestamp field not mapped to a clock class
+ * and there's more than one clock class in the
+ * trace: this is an error.
+ */
+ BT_LOGE_STR("Timestamp field found with no mapped clock class, "
+ "but there's more than one clock class in the trace at this point.");
+ ret = -1;
+ goto end;
+ }
+
+ assert(clock_class_to_map_to);
+ ret = bt_ctf_field_type_integer_set_mapped_clock_class(ft,
+ clock_class_to_map_to);
+ if (ret) {
+ BT_LOGE("Cannot map field type's field to trace's clock class: "
+ "clock-class-name=\"%s\", ret=%d",
+ bt_ctf_clock_class_get_name(clock_class_to_map_to),
+ ret);
+ goto end;
+ }
+
+end:
+ bt_put(clock_class_to_map_to);
+ bt_put(mapped_clock_class);
+ return ret;
+}
+
+static
+int auto_map_fields_to_trace_clock_class(struct ctx *ctx,
+ struct bt_ctf_field_type *root_ft, const char *field_name)
+{
+ int ret = 0;
+ int64_t i, count;
+
+ if (!root_ft) {
+ goto end;
+ }
+
+ if (!bt_ctf_field_type_is_structure(root_ft) &&
+ !bt_ctf_field_type_is_variant(root_ft)) {
+ goto end;
+ }
+
+ if (bt_ctf_field_type_is_structure(root_ft)) {
+ count = bt_ctf_field_type_structure_get_field_count(root_ft);
+ } else {
+ count = bt_ctf_field_type_variant_get_field_count(root_ft);
+ }
+
+ assert(count >= 0);
+
+ for (i = 0; i < count; i++) {
+ _BT_CTF_FIELD_TYPE_INIT(ft);
+ const char *name;
+
+ if (bt_ctf_field_type_is_structure(root_ft)) {
+ ret = bt_ctf_field_type_structure_get_field_by_index(
+ root_ft, &name, &ft, i);
+ } else if (bt_ctf_field_type_is_variant(root_ft)) {
+ ret = bt_ctf_field_type_variant_get_field_by_index(
+ root_ft, &name, &ft, i);
+ }
+
+ assert(ret == 0);
+
+ if (strcmp(name, field_name) == 0) {
+ ret = auto_map_field_to_trace_clock_class(ctx, ft);
+ if (ret) {
+ BT_LOGE("Cannot automatically map field to trace's clock class: "
+ "field-name=\"%s\"", field_name);
+ bt_put(ft);
+ goto end;
+ }
+ }
+
+ ret = auto_map_fields_to_trace_clock_class(ctx, ft, field_name);
+ bt_put(ft);
+ if (ret) {
+ BT_LOGE("Cannot automatically map structure or variant field type's fields to trace's clock class: "
+ "field-name=\"%s\", root-field-name=\"%s\"",
+ field_name, name);
+ goto end;
+ }
+ }
+
+end:
+ return ret;
+}
+
static
int visit_stream_decl_entry(struct ctx *ctx, struct ctf_node *node,
struct bt_ctf_stream_class *stream_class, int *set)
ret = visit_typedef(ctx, node->u._typedef.type_specifier_list,
&node->u._typedef.type_declarators);
if (ret) {
- BT_LOGE_STR("Cannot add type definition found in stream class.");
+ _BT_LOGE_NODE(node,
+ "Cannot add type definition found in stream class.");
goto error;
}
break;
ret = visit_typealias(ctx, node->u.typealias.target,
node->u.typealias.alias);
if (ret) {
- BT_LOGE_STR("Cannot add type alias found in stream class.");
+ _BT_LOGE_NODE(node,
+ "Cannot add type alias found in stream class.");
goto error;
}
break;
{
left = concatenate_unary_strings(&node->u.ctf_expression.left);
if (!left) {
+ _BT_LOGE_NODE(node, "Cannot concatenate unary strings.");
ret = -EINVAL;
goto error;
}
gpointer ptr;
if (_IS_SET(set, _STREAM_ID_SET)) {
- _BT_LOGE_DUP_ATTR("id", "stream declaration");
+ _BT_LOGE_DUP_ATTR(node, "id",
+ "stream declaration");
ret = -EPERM;
goto error;
}
(uint64_t *) &id);
/* Only read "id" if get_unary_unsigned() succeeded. */
if (ret || (!ret && id < 0)) {
- BT_LOGE_STR("Unexpected unary expression for stream class's `id` attribute.");
+ _BT_LOGE_NODE(node,
+ "Unexpected unary expression for stream class's `id` attribute.");
ret = -EINVAL;
goto error;
}
- ptr = g_hash_table_lookup(ctx->stream_classes,
- (gpointer) id);
+ ptr = g_hash_table_lookup(ctx->stream_classes, &id);
if (ptr) {
- BT_LOGE("Duplicate stream class (same ID): id=%" PRId64,
+ _BT_LOGE_NODE(node,
+ "Duplicate stream class (same ID): id=%" PRId64,
id);
ret = -EEXIST;
goto error;
ret = bt_ctf_stream_class_set_id(stream_class, id);
if (ret) {
- BT_LOGE("Cannot set stream class's ID: "
+ _BT_LOGE_NODE(node,
+ "Cannot set stream class's ID: "
"id=%" PRId64 ", ret=%d", id, ret);
goto error;
}
_SET(set, _STREAM_ID_SET);
} else if (!strcmp(left, "event.header")) {
if (_IS_SET(set, _STREAM_EVENT_HEADER_SET)) {
- BT_LOGE_STR("Duplicate `event.header` entry in stream class.");
+ _BT_LOGE_NODE(node,
+ "Duplicate `event.header` entry in stream class.");
ret = -EPERM;
goto error;
}
struct ctf_node, siblings),
&decl);
if (ret) {
- BT_LOGE_STR("Cannot create stream class's event header field type.");
+ _BT_LOGE_NODE(node,
+ "Cannot create stream class's event header field type.");
goto error;
}
assert(decl);
+ ret = auto_map_fields_to_trace_clock_class(ctx,
+ decl, "timestamp");
+ if (ret) {
+ _BT_LOGE_NODE(node,
+ "Cannot automatically map specific event header field type fields named `timestamp` to trace's clock class.");
+ goto error;
+ }
ret = bt_ctf_stream_class_set_event_header_type(
stream_class, decl);
BT_PUT(decl);
if (ret) {
- BT_LOGE_STR("Cannot set stream class's event header field type.");
+ _BT_LOGE_NODE(node,
+ "Cannot set stream class's event header field type.");
goto error;
}
_SET(set, _STREAM_EVENT_HEADER_SET);
} else if (!strcmp(left, "event.context")) {
if (_IS_SET(set, _STREAM_EVENT_CONTEXT_SET)) {
- BT_LOGE_STR("Duplicate `event.context` entry in stream class.");
+ _BT_LOGE_NODE(node,
+ "Duplicate `event.context` entry in stream class.");
ret = -EPERM;
goto error;
}
struct ctf_node, siblings),
&decl);
if (ret) {
- BT_LOGE_STR("Cannot create stream class's event context field type.");
+ _BT_LOGE_NODE(node,
+ "Cannot create stream class's event context field type.");
goto error;
}
stream_class, decl);
BT_PUT(decl);
if (ret) {
- BT_LOGE_STR("Cannot set stream class's event context field type.");
+ _BT_LOGE_NODE(node,
+ "Cannot set stream class's event context field type.");
goto error;
}
_SET(set, _STREAM_EVENT_CONTEXT_SET);
} else if (!strcmp(left, "packet.context")) {
if (_IS_SET(set, _STREAM_PACKET_CONTEXT_SET)) {
- BT_LOGE_STR("Duplicate `packet.context` entry in stream class.");
+ _BT_LOGE_NODE(node,
+ "Duplicate `packet.context` entry in stream class.");
ret = -EPERM;
goto error;
}
struct ctf_node, siblings),
&decl);
if (ret) {
- BT_LOGE_STR("Cannot create stream class's packet context field type.");
+ _BT_LOGE_NODE(node,
+ "Cannot create stream class's packet context field type.");
goto error;
}
assert(decl);
+ ret = auto_map_fields_to_trace_clock_class(ctx,
+ decl, "timestamp_begin");
+ if (ret) {
+ _BT_LOGE_NODE(node,
+ "Cannot automatically map specific packet context field type fields named `timestamp_begin` to trace's clock class.");
+ goto error;
+ }
+
+ ret = auto_map_fields_to_trace_clock_class(ctx,
+ decl, "timestamp_end");
+ if (ret) {
+ _BT_LOGE_NODE(node,
+ "Cannot automatically map specific packet context field type fields named `timestamp_end` to trace's clock class.");
+ goto error;
+ }
ret = bt_ctf_stream_class_set_packet_context_type(
stream_class, decl);
BT_PUT(decl);
if (ret) {
- BT_LOGE_STR("Cannot set stream class's packet context field type.");
+ _BT_LOGE_NODE(node,
+ "Cannot set stream class's packet context field type.");
goto error;
}
_SET(set, _STREAM_PACKET_CONTEXT_SET);
} else {
- BT_LOGW("Unknown attribute in stream class: "
+ _BT_LOGW_NODE(node,
+ "Unknown attribute in stream class: "
"attr-name=\"%s\"", left);
}
int visit_stream_decl(struct ctx *ctx, struct ctf_node *node)
{
int64_t id;
+ int64_t *new_id;
int set = 0;
int ret = 0;
struct ctf_node *iter;
node->visited = TRUE;
stream_class = create_reset_stream_class(ctx);
if (!stream_class) {
+ _BT_LOGE_NODE(node, "Cannot create empty stream class.");
ret = -EINVAL;
goto error;
}
bt_list_for_each_entry(iter, decl_list, siblings) {
ret = visit_stream_decl_entry(ctx, iter, stream_class, &set);
if (ret) {
+ _BT_LOGE_NODE(iter,
+ "Cannot visit stream class's entry: "
+ "ret=%d", ret);
ctx_pop_scope(ctx);
goto error;
}
packet_header_decl =
bt_ctf_trace_get_packet_header_type(ctx->trace);
if (!packet_header_decl) {
- BT_LOGE_STR("Stream class has a `id` attribute, "
+ _BT_LOGE_NODE(node,
+ "Stream class has a `id` attribute, "
"but trace has no packet header field type.");
goto error;
}
packet_header_decl, "stream_id");
BT_PUT(packet_header_decl);
if (!stream_id_decl) {
- BT_LOGE_STR("Stream class has a `id` attribute, "
+ _BT_LOGE_NODE(node,
+ "Stream class has a `id` attribute, "
"but trace's packet header field type has no `stream_id` field.");
goto error;
}
if (!bt_ctf_field_type_is_integer(stream_id_decl)) {
BT_PUT(stream_id_decl);
- BT_LOGE_STR("Stream class has a `id` attribute, "
+ _BT_LOGE_NODE(node,
+ "Stream class has a `id` attribute, "
"but trace's packet header field type's `stream_id` field is not an integer field type.");
goto error;
}
} else {
/* Allow only _one_ ID-less stream */
if (g_hash_table_size(ctx->stream_classes) != 0) {
- BT_LOGE_STR("Missing `id` attribute in stream class as there's more than one stream class in the trace.");
+ _BT_LOGE_NODE(node,
+ "Missing `id` attribute in stream class as there's more than one stream class in the trace.");
ret = -EPERM;
goto error;
}
id = bt_ctf_stream_class_get_id(stream_class);
if (id < 0) {
- BT_LOGE_STR("Cannot get stream class's ID.");
+ _BT_LOGE_NODE(node,
+ "Cannot get stream class's ID.");
ret = -EINVAL;
goto error;
}
*/
existing_stream_class = bt_ctf_trace_get_stream_class_by_id(ctx->trace,
id);
- if (g_hash_table_lookup(ctx->stream_classes, (gpointer) id) ||
+ if (g_hash_table_lookup(ctx->stream_classes, &id) ||
existing_stream_class) {
- BT_LOGE("Duplicate stream class (same ID): id=%" PRId64,
+ _BT_LOGE_NODE(node,
+ "Duplicate stream class (same ID): id=%" PRId64,
id);
ret = -EINVAL;
goto error;
}
+ new_id = g_new0(int64_t, 1);
+ if (!new_id) {
+ BT_LOGE_STR("Failed to allocate a int64_t.");
+ ret = -ENOMEM;
+ goto error;
+ }
+ *new_id = id;
+
/* Move reference to visitor's context */
- g_hash_table_insert(ctx->stream_classes, (gpointer) (int64_t) id,
+ g_hash_table_insert(ctx->stream_classes, new_id,
stream_class);
stream_class = NULL;
goto end;
ret = visit_typedef(ctx, node->u._typedef.type_specifier_list,
&node->u._typedef.type_declarators);
if (ret) {
- BT_LOGE_STR("Cannot add type definition found in trace (`trace` block).");
+ _BT_LOGE_NODE(node,
+ "Cannot add type definition found in trace (`trace` block).");
goto error;
}
break;
ret = visit_typealias(ctx, node->u.typealias.target,
node->u.typealias.alias);
if (ret) {
- BT_LOGE_STR("Cannot add type alias found in trace (`trace` block).");
+ _BT_LOGE_NODE(node,
+ "Cannot add type alias found in trace (`trace` block).");
goto error;
}
break;
{
left = concatenate_unary_strings(&node->u.ctf_expression.left);
if (!left) {
+ _BT_LOGE_NODE(node, "Cannot concatenate unary strings.");
ret = -EINVAL;
goto error;
}
if (!strcmp(left, "major")) {
if (_IS_SET(set, _TRACE_MAJOR_SET)) {
- _BT_LOGE_DUP_ATTR("major", "trace");
+ _BT_LOGE_DUP_ATTR(node, "major", "trace");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(&node->u.ctf_expression.right,
&ctx->trace_major);
if (ret) {
- BT_LOGE_STR("Unexpected unary expression for trace's `major` attribute.");
+ _BT_LOGE_NODE(node,
+ "Unexpected unary expression for trace's `major` attribute.");
ret = -EINVAL;
goto error;
}
_SET(set, _TRACE_MAJOR_SET);
} else if (!strcmp(left, "minor")) {
if (_IS_SET(set, _TRACE_MINOR_SET)) {
- _BT_LOGE_DUP_ATTR("minor", "trace");
+ _BT_LOGE_DUP_ATTR(node, "minor", "trace");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(&node->u.ctf_expression.right,
&ctx->trace_minor);
if (ret) {
- BT_LOGE_STR("Unexpected unary expression for trace's `minor` attribute.");
+ _BT_LOGE_NODE(node,
+ "Unexpected unary expression for trace's `minor` attribute.");
ret = -EINVAL;
goto error;
}
_SET(set, _TRACE_MINOR_SET);
} else if (!strcmp(left, "uuid")) {
if (_IS_SET(set, _TRACE_UUID_SET)) {
- _BT_LOGE_DUP_ATTR("uuid", "trace");
+ _BT_LOGE_DUP_ATTR(node, "uuid", "trace");
ret = -EPERM;
goto error;
}
ret = get_unary_uuid(&node->u.ctf_expression.right,
ctx->trace_uuid);
if (ret) {
- BT_LOGE_STR("Invalid trace's `uuid` attribute.");
+ _BT_LOGE_NODE(node,
+ "Invalid trace's `uuid` attribute.");
goto error;
}
ret = bt_ctf_trace_set_uuid(ctx->trace, ctx->trace_uuid);
if (ret) {
- BT_LOGE_STR("Cannot set trace's UUID.");
+ _BT_LOGE_NODE(node, "Cannot set trace's UUID.");
goto error;
}
} else if (!strcmp(left, "byte_order")) {
/* Native byte order is already known at this stage */
if (_IS_SET(set, _TRACE_BYTE_ORDER_SET)) {
- _BT_LOGE_DUP_ATTR("byte_order",
+ _BT_LOGE_DUP_ATTR(node, "byte_order",
"trace");
ret = -EPERM;
goto error;
_SET(set, _TRACE_BYTE_ORDER_SET);
} else if (!strcmp(left, "packet.header")) {
if (_IS_SET(set, _TRACE_PACKET_HEADER_SET)) {
- BT_LOGE_STR("Duplicate `packet.header` entry in trace.");
+ _BT_LOGE_NODE(node,
+ "Duplicate `packet.header` entry in trace.");
ret = -EPERM;
goto error;
}
struct ctf_node, siblings),
&packet_header_decl);
if (ret) {
- BT_LOGE_STR("Cannot create trace's packet header field type.");
+ _BT_LOGE_NODE(node,
+ "Cannot create trace's packet header field type.");
goto error;
}
packet_header_decl);
BT_PUT(packet_header_decl);
if (ret) {
- BT_LOGE_STR("Cannot set trace's packet header field type.");
+ _BT_LOGE_NODE(node,
+ "Cannot set trace's packet header field type.");
goto error;
}
_SET(set, _TRACE_PACKET_HEADER_SET);
} else {
- BT_LOGW("Unknown attribute in stream class: "
+ _BT_LOGW_NODE(node,
+ "Unknown attribute in stream class: "
"attr-name=\"%s\"", left);
}
break;
}
default:
- BT_LOGE_STR("Unknown expression in trace.");
+ _BT_LOGE_NODE(node, "Unknown expression in trace.");
ret = -EINVAL;
goto error;
}
node->visited = TRUE;
if (ctx->is_trace_visited) {
- BT_LOGE_STR("Duplicate trace (`trace` block).");
+ _BT_LOGE_NODE(node, "Duplicate trace (`trace` block).");
ret = -EEXIST;
goto error;
}
bt_list_for_each_entry(iter, decl_list, siblings) {
ret = visit_trace_decl_entry(ctx, iter, &set);
if (ret) {
+ _BT_LOGE_NODE(iter, "Cannot visit trace's entry (`trace` block): "
+ "ret=%d", ret);
ctx_pop_scope(ctx);
goto error;
}
ctx_pop_scope(ctx);
if (!_IS_SET(&set, _TRACE_MAJOR_SET)) {
- BT_LOGE_STR("Missing `major` attribute in trace (`trace` block).");
+ _BT_LOGE_NODE(node,
+ "Missing `major` attribute in trace (`trace` block).");
ret = -EPERM;
goto error;
}
if (!_IS_SET(&set, _TRACE_MINOR_SET)) {
- BT_LOGE_STR("Missing `minor` attribute in trace (`trace` block).");
+ _BT_LOGE_NODE(node,
+ "Missing `minor` attribute in trace (`trace` block).");
ret = -EPERM;
goto error;
}
if (!_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
- BT_LOGE_STR("Missing `byte_order` attribute in trace (`trace` block).");
+ _BT_LOGE_NODE(node,
+ "Missing `byte_order` attribute in trace (`trace` block).");
ret = -EPERM;
goto error;
}
&entry_node->u.ctf_expression.right;
if (entry_node->type != NODE_CTF_EXPRESSION) {
- BT_LOGE("Wrong expression in environment entry: "
+ _BT_LOGE_NODE(entry_node,
+ "Wrong expression in environment entry: "
"node-type=%d", entry_node->type);
ret = -EPERM;
goto error;
left = concatenate_unary_strings(
&entry_node->u.ctf_expression.left);
if (!left) {
- BT_LOGE_STR("Cannot get environment entry's name.");
+ _BT_LOGE_NODE(entry_node,
+ "Cannot get environment entry's name.");
ret = -EINVAL;
goto error;
}
char *right = concatenate_unary_strings(right_head);
if (!right) {
- BT_LOGE("Unexpected unary expression for environment entry's value: "
+ _BT_LOGE_NODE(entry_node,
+ "Unexpected unary expression for environment entry's value: "
"name=\"%s\"", left);
ret = -EINVAL;
goto error;
if (strcmp(left, "tracer_name") == 0) {
if (strncmp(right, "lttng", 5) == 0) {
+ BT_LOGI("Detected LTTng trace from `%s` environment value: "
+ "tracer-name=\"%s\"",
+ left, right);
ctx->is_lttng = 1;
}
}
g_free(right);
if (ret) {
- BT_LOGE("Cannot add string environment entry to trace: "
+ _BT_LOGE_NODE(entry_node,
+ "Cannot add string environment entry to trace: "
"name=\"%s\", ret=%d", left, ret);
goto error;
}
ret = get_unary_signed(right_head, &v);
}
if (ret) {
- BT_LOGE("Unexpected unary expression for environment entry's value: "
+ _BT_LOGE_NODE(entry_node,
+ "Unexpected unary expression for environment entry's value: "
"name=\"%s\"", left);
ret = -EINVAL;
goto error;
ret = bt_ctf_trace_set_environment_field_integer(
ctx->trace, left, v);
if (ret) {
- BT_LOGE("Cannot add integer environment entry to trace: "
+ _BT_LOGE_NODE(entry_node,
+ "Cannot add integer environment entry to trace: "
"name=\"%s\", ret=%d", left, ret);
goto error;
}
} else {
- BT_LOGW("Environment entry has unknown type: "
+ _BT_LOGW_NODE(entry_node,
+ "Environment entry has unknown type: "
"name=\"%s\"", left);
}
left = concatenate_unary_strings(
&node->u.ctf_expression.left);
if (!left) {
+ _BT_LOGE_NODE(node,
+ "Cannot concatenate unary strings.");
ret = -EINVAL;
goto error;
}
enum bt_ctf_byte_order bo;
if (_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
- _BT_LOGE_DUP_ATTR("byte_order",
+ _BT_LOGE_DUP_ATTR(node, "byte_order",
"trace");
ret = -EPERM;
goto error;
struct ctf_node, siblings);
bo = byte_order_from_unary_expr(right_node);
if (bo == BT_CTF_BYTE_ORDER_UNKNOWN) {
+ _BT_LOGE_NODE(node,
+ "Invalid `byte_order` attribute in trace (`trace` block): "
+ "expecting `le`, `be`, or `network`.");
ret = -EINVAL;
goto error;
} else if (bo == BT_CTF_BYTE_ORDER_NATIVE) {
- BT_LOGE_STR("Invalid `byte_order` attribute in trace (`trace` block): "
+ _BT_LOGE_NODE(node,
+ "Invalid `byte_order` attribute in trace (`trace` block): "
"cannot be set to `native` here.");
ret = -EPERM;
goto error;
ret = bt_ctf_trace_set_native_byte_order(
ctx->trace, bo);
if (ret) {
- BT_LOGE("Cannot set trace's byte order: "
+ _BT_LOGE_NODE(node,
+ "Cannot set trace's byte order: "
"ret=%d", ret);
goto error;
}
}
if (!_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
- BT_LOGE_STR("Missing `byte_order` attribute in trace (`trace` block).");
+ _BT_LOGE_NODE(trace_node,
+ "Missing `byte_order` attribute in trace (`trace` block).");
ret = -EINVAL;
goto error;
}
char *left = NULL;
if (entry_node->type != NODE_CTF_EXPRESSION) {
+ _BT_LOGE_NODE(entry_node,
+ "Unexpected node type: node-type=%d",
+ entry_node->type);
ret = -EPERM;
goto error;
}
left = concatenate_unary_strings(&entry_node->u.ctf_expression.left);
if (!left) {
+ _BT_LOGE_NODE(entry_node, "Cannot concatenate unary strings.");
ret = -EINVAL;
goto error;
}
char *right;
if (_IS_SET(set, _CLOCK_NAME_SET)) {
- _BT_LOGE_DUP_ATTR("name", "clock class");
+ _BT_LOGE_DUP_ATTR(entry_node, "name", "clock class");
ret = -EPERM;
goto error;
}
right = concatenate_unary_strings(
&entry_node->u.ctf_expression.right);
if (!right) {
- BT_LOGE_STR("Unexpected unary expression for clock class's `name` attribute.");
+ _BT_LOGE_NODE(entry_node,
+ "Unexpected unary expression for clock class's `name` attribute.");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_clock_class_set_name(clock, right);
if (ret) {
- BT_LOGE("cannot set clock class's name");
+ _BT_LOGE_NODE(entry_node,
+ "cannot set clock class's name");
g_free(right);
goto error;
}
unsigned char uuid[BABELTRACE_UUID_LEN];
if (_IS_SET(set, _CLOCK_UUID_SET)) {
- _BT_LOGE_DUP_ATTR("uuid", "clock class");
+ _BT_LOGE_DUP_ATTR(entry_node, "uuid", "clock class");
ret = -EPERM;
goto error;
}
ret = get_unary_uuid(&entry_node->u.ctf_expression.right, uuid);
if (ret) {
- BT_LOGE_STR("Invalid clock class's `uuid` attribute.");
+ _BT_LOGE_NODE(entry_node,
+ "Invalid clock class's `uuid` attribute.");
goto error;
}
ret = bt_ctf_clock_class_set_uuid(clock, uuid);
if (ret) {
- BT_LOGE_STR("Cannot set clock class's UUID.");
+ _BT_LOGE_NODE(entry_node,
+ "Cannot set clock class's UUID.");
goto error;
}
char *right;
if (_IS_SET(set, _CLOCK_DESCRIPTION_SET)) {
- _BT_LOGE_DUP_ATTR("description", "clock class");
+ _BT_LOGE_DUP_ATTR(entry_node, "description",
+ "clock class");
ret = -EPERM;
goto error;
}
right = concatenate_unary_strings(
&entry_node->u.ctf_expression.right);
if (!right) {
- BT_LOGE_STR("Unexpected unary expression for clock class's `description` attribute.");
+ _BT_LOGE_NODE(entry_node,
+ "Unexpected unary expression for clock class's `description` attribute.");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_clock_class_set_description(clock, right);
if (ret) {
- BT_LOGE_STR("Cannot set clock class's description.");
+ _BT_LOGE_NODE(entry_node,
+ "Cannot set clock class's description.");
g_free(right);
goto error;
}
uint64_t freq;
if (_IS_SET(set, _CLOCK_FREQ_SET)) {
- _BT_LOGE_DUP_ATTR("freq", "clock class");
+ _BT_LOGE_DUP_ATTR(entry_node, "freq", "clock class");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(
&entry_node->u.ctf_expression.right, &freq);
if (ret) {
- BT_LOGE_STR("Unexpected unary expression for clock class's `freq` attribute.");
+ _BT_LOGE_NODE(entry_node,
+ "Unexpected unary expression for clock class's `freq` attribute.");
+ ret = -EINVAL;
+ goto error;
+ }
+
+ if (freq == -1ULL || freq == 0) {
+ _BT_LOGE_NODE(entry_node,
+ "Invalid clock class frequency: freq=%" PRIu64,
+ freq);
ret = -EINVAL;
goto error;
}
ret = bt_ctf_clock_class_set_frequency(clock, freq);
if (ret) {
- BT_LOGE_STR("Cannot set clock class's frequency.");
+ _BT_LOGE_NODE(entry_node,
+ "Cannot set clock class's frequency.");
goto error;
}
uint64_t precision;
if (_IS_SET(set, _CLOCK_PRECISION_SET)) {
- _BT_LOGE_DUP_ATTR("precision", "clock class");
+ _BT_LOGE_DUP_ATTR(entry_node, "precision",
+ "clock class");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(
&entry_node->u.ctf_expression.right, &precision);
if (ret) {
- BT_LOGE_STR("Unexpected unary expression for clock class's `precision` attribute.");
+ _BT_LOGE_NODE(entry_node,
+ "Unexpected unary expression for clock class's `precision` attribute.");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_clock_class_set_precision(clock, precision);
if (ret) {
- BT_LOGE_STR("Cannot set clock class's precision.");
+ _BT_LOGE_NODE(entry_node,
+ "Cannot set clock class's precision.");
goto error;
}
_SET(set, _CLOCK_PRECISION_SET);
} else if (!strcmp(left, "offset_s")) {
- uint64_t offset_s;
+ int64_t offset_s;
if (_IS_SET(set, _CLOCK_OFFSET_S_SET)) {
- _BT_LOGE_DUP_ATTR("offset_s", "clock class");
+ _BT_LOGE_DUP_ATTR(entry_node, "offset_s",
+ "clock class");
ret = -EPERM;
goto error;
}
- ret = get_unary_unsigned(
+ ret = get_unary_signed(
&entry_node->u.ctf_expression.right, &offset_s);
if (ret) {
- BT_LOGE_STR("Unexpected unary expression for clock class's `offset_s` attribute.");
+ _BT_LOGE_NODE(entry_node,
+ "Unexpected unary expression for clock class's `offset_s` attribute.");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_clock_class_set_offset_s(clock, offset_s);
if (ret) {
- BT_LOGE_STR("Cannot set clock class's offset in seconds.");
+ _BT_LOGE_NODE(entry_node,
+ "Cannot set clock class's offset in seconds.");
goto error;
}
_SET(set, _CLOCK_OFFSET_S_SET);
} else if (!strcmp(left, "offset")) {
- uint64_t offset;
+ int64_t offset;
if (_IS_SET(set, _CLOCK_OFFSET_SET)) {
- _BT_LOGE_DUP_ATTR("offset", "clock class");
+ _BT_LOGE_DUP_ATTR(entry_node, "offset", "clock class");
ret = -EPERM;
goto error;
}
- ret = get_unary_unsigned(
+ ret = get_unary_signed(
&entry_node->u.ctf_expression.right, &offset);
if (ret) {
- BT_LOGE_STR("Unexpected unary expression for clock class's `offset` attribute.");
+ _BT_LOGE_NODE(entry_node,
+ "Unexpected unary expression for clock class's `offset` attribute.");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_clock_class_set_offset_cycles(clock, offset);
if (ret) {
- BT_LOGE_STR("Cannot set clock class's offset in cycles.");
+ _BT_LOGE_NODE(entry_node,
+ "Cannot set clock class's offset in cycles.");
goto error;
}
struct ctf_node *right;
if (_IS_SET(set, _CLOCK_ABSOLUTE_SET)) {
- _BT_LOGE_DUP_ATTR("absolute", "clock class");
+ _BT_LOGE_DUP_ATTR(entry_node, "absolute",
+ "clock class");
ret = -EPERM;
goto error;
}
struct ctf_node, siblings);
ret = get_boolean(right);
if (ret < 0) {
- BT_LOGE_STR("Unexpected unary expression for clock class's `absolute` attribute.");
+ _BT_LOGE_NODE(entry_node,
+ "Unexpected unary expression for clock class's `absolute` attribute.");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_clock_class_set_is_absolute(clock, ret);
if (ret) {
- BT_LOGE_STR("Cannot set clock class's absolute flag.");
+ _BT_LOGE_NODE(entry_node,
+ "Cannot set clock class's absolute flag.");
goto error;
}
_SET(set, _CLOCK_ABSOLUTE_SET);
} else {
- BT_LOGW("Unknown attribute in clock class: attr-name=\"%s\"",
+ _BT_LOGW_NODE(entry_node,
+ "Unknown attribute in clock class: attr-name=\"%s\"",
left);
}
int ret;
uint64_t freq;
int64_t offset_cycles;
+ int64_t offset_to_apply;
freq = bt_ctf_clock_class_get_frequency(clock);
if (freq == -1ULL) {
goto end;
}
- offset_cycles += cycles_from_ns(freq, ctx->clock_class_offset_ns);
+ offset_to_apply =
+ ctx->decoder_config.clock_class_offset_s * 1000000000LL +
+ ctx->decoder_config.clock_class_offset_ns;
+ offset_cycles += cycles_from_ns(freq, offset_to_apply);
ret = bt_ctf_clock_class_set_offset_cycles(clock, offset_cycles);
end:
}
clock_node->visited = TRUE;
- clock = bt_ctf_clock_class_create(NULL);
+
+ /* CTF 1.8's default frequency for a clock class is 1 GHz */
+ clock = bt_ctf_clock_class_create(NULL, 1000000000);
if (!clock) {
- BT_LOGE_STR("Cannot create default clock class.");
+ _BT_LOGE_NODE(clock_node,
+ "Cannot create default clock class.");
ret = -ENOMEM;
goto error;
}
bt_list_for_each_entry(entry_node, decl_list, siblings) {
ret = visit_clock_decl_entry(ctx, entry_node, clock, &set);
if (ret) {
+ _BT_LOGE_NODE(entry_node,
+ "Cannot visit clock class's entry: ret=%d",
+ ret);
goto error;
}
}
if (!_IS_SET(&set, _CLOCK_NAME_SET)) {
- BT_LOGE_STR("Missing `name` attribute in clock class.");
+ _BT_LOGE_NODE(clock_node,
+ "Missing `name` attribute in clock class.");
ret = -EPERM;
goto error;
}
*/
ret = bt_ctf_clock_class_set_is_absolute(clock, 1);
if (ret) {
- BT_LOGE_STR("Cannot set clock class's absolute flag.");
+ _BT_LOGE_NODE(clock_node,
+ "Cannot set clock class's absolute flag.");
goto error;
}
}
ret = apply_clock_class_offset(ctx, clock);
if (ret) {
- BT_LOGE_STR("Cannot apply clock class's custom offset.");
+ _BT_LOGE_NODE(clock_node,
+ "Cannot apply clock class's custom offset.");
goto error;
}
ret = bt_ctf_trace_add_clock_class(ctx->trace, clock);
if (ret) {
- BT_LOGE_STR("Cannot add clock class to trace.");
+ _BT_LOGE_NODE(clock_node,
+ "Cannot add clock class to trace.");
goto error;
}
root_decl_node->u._typedef.type_specifier_list,
&root_decl_node->u._typedef.type_declarators);
if (ret) {
- BT_LOGE_STR("Cannot add type definition found in root scope.");
+ _BT_LOGE_NODE(root_decl_node,
+ "Cannot add type definition found in root scope.");
goto end;
}
break;
ret = visit_typealias(ctx, root_decl_node->u.typealias.target,
root_decl_node->u.typealias.alias);
if (ret) {
- BT_LOGE_STR("Cannot add type alias found in root scope.");
+ _BT_LOGE_NODE(root_decl_node,
+ "Cannot add type alias found in root scope.");
goto end;
}
break;
*/
ret = visit_type_specifier_list(ctx, root_decl_node, &decl);
if (ret) {
+ _BT_LOGE_NODE(root_decl_node,
+ "Cannot visit root scope's field type: "
+ "ret=%d", ret);
assert(!decl);
goto end;
}
break;
}
default:
+ _BT_LOGE_NODE(root_decl_node,
+ "Unexpected node type: node-type=%d",
+ root_decl_node->type);
ret = -EPERM;
goto end;
}
assert(bt_ctf_trace_get_stream_class_count(ctx->trace) == 0);
name = g_string_new(NULL);
if (!name) {
+ BT_LOGE_STR("Failed to allocate a GString.");
ret = -1;
goto end;
}
ret = bt_ctf_trace_set_name(ctx->trace, name->str);
if (ret) {
+ BT_LOGE("Cannot set trace's name: name=\"%s\"", name->str);
goto error;
}
*/
ret = set_trace_name(ctx);
if (ret) {
+ BT_LOGE_STR("Cannot set trace's name.");
goto end;
}
}
BT_HIDDEN
struct ctf_visitor_generate_ir *ctf_visitor_generate_ir_create(
- int64_t clock_class_offset_ns, const char *name)
+ const struct ctf_metadata_decoder_config *decoder_config,
+ const char *name)
{
int ret;
struct ctx *ctx = NULL;
}
/* Create visitor's context */
- ctx = ctx_create(trace, clock_class_offset_ns, name);
+ ctx = ctx_create(trace, decoder_config, name);
if (!ctx) {
BT_LOGE_STR("Cannot create visitor's context.");
goto error;
{
struct ctf_node *iter;
int got_trace_decl = FALSE;
- int found_callsite = FALSE;
/*
* The first thing we need is the native byte order of
if (ctx->trace_bo == BT_CTF_BYTE_ORDER_NATIVE) {
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
if (got_trace_decl) {
- BT_LOGE_STR("Duplicate trace (`trace` block).");
+ _BT_LOGE_NODE(node,
+ "Duplicate trace (`trace` block).");
ret = -1;
goto end;
}
ret = set_trace_byte_order(ctx, iter);
if (ret) {
- BT_LOGE("Cannot set trace's native byte order: "
+ _BT_LOGE_NODE(node,
+ "Cannot set trace's native byte order: "
"ret=%d", ret);
goto end;
}
}
if (!got_trace_decl) {
+ BT_LOGD_STR("Incomplete AST: need trace (`trace` block).");
ret = -EINCOMPLETE;
goto end;
}
bt_list_for_each_entry(iter, &node->u.root.env, siblings) {
ret = visit_env(ctx, iter);
if (ret) {
- BT_LOGE("Cannot visit trace's environment (`env` block): "
+ _BT_LOGE_NODE(iter,
+ "Cannot visit trace's environment (`env` block) entry: "
"ret=%d", ret);
goto end;
}
bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
ret = visit_clock_decl(ctx, iter);
if (ret) {
- BT_LOGE("Cannot visit clock class: ret=%d",
+ _BT_LOGE_NODE(iter,
+ "Cannot visit clock class: ret=%d",
ret);
goto end;
}
siblings) {
ret = visit_root_decl(ctx, iter);
if (ret) {
- BT_LOGE("Cannot visit root entry: ret=%d",
+ _BT_LOGE_NODE(iter,
+ "Cannot visit root entry: ret=%d",
ret);
goto end;
}
/* Callsite blocks are not supported */
bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) {
- found_callsite = TRUE;
- break;
+ _BT_LOGW_NODE(iter,
+ "\"callsite\" blocks are not supported as of this version.");
}
assert(ctx->current_scope &&
ctx->current_scope->parent_scope == NULL);
- if (found_callsite) {
- BT_LOGW("\"callsite\" blocks are not supported as of this version.");
- }
-
/* Trace */
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
ret = visit_trace_decl(ctx, iter);
if (ret) {
- BT_LOGE("Cannot visit trace (`trace` block): "
+ _BT_LOGE_NODE(iter,
+ "Cannot visit trace (`trace` block): "
"ret=%d", ret);
goto end;
}
bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
ret = visit_stream_decl(ctx, iter);
if (ret) {
- BT_LOGE("Cannot visit stream class: ret=%d",
+ _BT_LOGE_NODE(iter,
+ "Cannot visit stream class: ret=%d",
ret);
goto end;
}
bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
ret = visit_event_decl(ctx, iter);
if (ret) {
- BT_LOGE("Cannot visit event class: ret=%d",
+ _BT_LOGE_NODE(iter,
+ "Cannot visit event class: ret=%d",
ret);
goto end;
}
break;
}
default:
- BT_LOGE("Unexpected node type: node-type=%d",
+ _BT_LOGE_NODE(node,
+ "Unexpected node type: node-type=%d",
node->type);
ret = -EINVAL;
goto end;
projects / babeltrace.git / blobdiff