const char *node_type(struct ctf_node *node);
+struct meta_log_config;
+
BT_HIDDEN
struct ctf_visitor_generate_ir *ctf_visitor_generate_ir_create(
- bt_self_component_source *self_comp,
const struct ctf_metadata_decoder_config *config);
void ctf_visitor_generate_ir_destroy(struct ctf_visitor_generate_ir *visitor);
BT_HIDDEN
int ctf_visitor_semantic_check(int depth, struct ctf_node *node,
- bt_logging_level log_level);
+ struct meta_log_config *log_cfg);
BT_HIDDEN
int ctf_visitor_parent_links(int depth, struct ctf_node *node,
- bt_logging_level log_level);
+ struct meta_log_config *log_cfg);
#endif /* _CTF_AST_H */
* all copies or substantial portions of the Software.
*/
+#define BT_COMP_LOG_SELF_COMP (ctx->self_comp)
#define BT_LOG_OUTPUT_LEVEL (ctx->log_level)
#define BT_LOG_TAG "PLUGIN/CTF/META/RESOLVE"
-#include "logging/log.h"
+#include "plugins/comp-logging.h"
#include <babeltrace2/babeltrace.h>
#include "common/macros.h"
#include <glib.h>
#include "ctf-meta-visitors.h"
+#include "logging.h"
typedef GPtrArray field_class_stack;
*/
struct resolve_context {
bt_logging_level log_level;
+ bt_self_component *self_comp;
struct ctf_trace_class *tc;
struct ctf_stream_class *sc;
struct ctf_event_class *ec;
struct field_class_stack_frame *frame = NULL;
if (!stack || !fc) {
- BT_LOGE("Invalid parameter: stack or field class is NULL.");
+ BT_COMP_LOGE("Invalid parameter: stack or field class is NULL.");
ret = -1;
goto end;
}
frame = g_new0(struct field_class_stack_frame, 1);
if (!frame) {
- BT_LOGE_STR("Failed to allocate one field class stack frame.");
+ BT_COMP_LOGE_STR("Failed to allocate one field class stack frame.");
ret = -1;
goto end;
}
- BT_LOGD("Pushing field class on context's stack: "
+ BT_COMP_LOGD("Pushing field class on context's stack: "
"fc-addr=%p, stack-size-before=%u", fc, stack->len);
frame->fc = fc;
g_ptr_array_add(stack, frame);
* This will call the frame's destructor and free it, as
* well as put its contained field class.
*/
- BT_LOGD("Popping context's stack: stack-size-before=%u",
+ BT_COMP_LOGD("Popping context's stack: stack-size-before=%u",
stack->len);
g_ptr_array_set_size(stack, stack->len - 1);
}
if (strncmp(pathstr, absolute_path_prefixes[scope],
strlen(absolute_path_prefixes[scope]))) {
/* Prefix does not match: try the next one */
- BT_LOGD("Prefix does not match: trying the next one: "
+ BT_COMP_LOGD("Prefix does not match: trying the next one: "
"path=\"%s\", path-prefix=\"%s\", scope=%s",
pathstr, absolute_path_prefixes[scope],
ctf_scope_string(scope));
/* Found it! */
ret = scope;
- BT_LOGD("Found root scope from absolute path: "
+ BT_COMP_LOGD("Found root scope from absolute path: "
"path=\"%s\", scope=%s", pathstr,
ctf_scope_string(scope));
goto end;
if (at == last) {
/* Error: empty token */
- BT_LOGE("Empty path token: path=\"%s\", pos=%u",
+ BT_COMP_LOGE("Empty path token: path=\"%s\", pos=%u",
pathstr, (unsigned int) (at - pathstr));
goto error;
}
struct ctf_field_class *child_fc;
const char *ft_name = ptoken_get_string(cur_ptoken);
- BT_LOGD("Current path token: token=\"%s\"", ft_name);
+ BT_COMP_LOGD("Current path token: token=\"%s\"", ft_name);
/* Find to which index corresponds the current path token */
if (fc->type == CTF_FIELD_CLASS_TYPE_ARRAY ||
* Error: field name does not exist or
* wrong current class.
*/
- BT_LOGD("Cannot get index of field class: "
+ BT_COMP_LOGD("Cannot get index of field class: "
"field-name=\"%s\", "
"src-index=%" PRId64 ", "
"child-index=%" PRId64 ", "
goto end;
} else if (child_index > src_index &&
!first_level_done) {
- BT_LOGD("Child field class is located after source field class: "
+ BT_COMP_LOGD("Child field class is located after source field class: "
"field-name=\"%s\", "
"src-index=%" PRId64 ", "
"child-index=%" PRId64 ", "
switch (field_path->root) {
case CTF_SCOPE_PACKET_HEADER:
if (ctx->tc->is_translated) {
- BT_LOGE("Trace class is already translated: "
+ BT_COMP_LOGE("Trace class is already translated: "
"root-scope=%s",
ctf_scope_string(field_path->root));
ret = -1;
case CTF_SCOPE_EVENT_HEADER:
case CTF_SCOPE_EVENT_COMMON_CONTEXT:
if (!ctx->sc) {
- BT_LOGE("No current stream class: "
+ BT_COMP_LOGE("No current stream class: "
"root-scope=%s",
ctf_scope_string(field_path->root));
ret = -1;
}
if (ctx->sc->is_translated) {
- BT_LOGE("Stream class is already translated: "
+ BT_COMP_LOGE("Stream class is already translated: "
"root-scope=%s",
ctf_scope_string(field_path->root));
ret = -1;
case CTF_SCOPE_EVENT_SPECIFIC_CONTEXT:
case CTF_SCOPE_EVENT_PAYLOAD:
if (!ctx->ec) {
- BT_LOGE("No current event class: "
+ BT_COMP_LOGE("No current event class: "
"root-scope=%s",
ctf_scope_string(field_path->root));
ret = -1;
}
if (ctx->ec->is_translated) {
- BT_LOGE("Event class is already translated: "
+ BT_COMP_LOGE("Event class is already translated: "
"root-scope=%s",
ctf_scope_string(field_path->root));
ret = -1;
fc = borrow_class_from_ctx(ctx, field_path->root);
if (!fc) {
/* Error: root class is not available */
- BT_LOGE("Root field class is not available: "
+ BT_COMP_LOGE("Root field class is not available: "
"root-scope=%s",
ctf_scope_string(field_path->root));
ret = -1;
int64_t cur_index = field_class_stack_at(ctx->field_class_stack,
parent_pos_in_stack)->index;
- BT_LOGD("Locating target field class from current parent field class: "
+ BT_COMP_LOGD("Locating target field class from current parent field class: "
"parent-pos=%" PRId64 ", parent-fc-addr=%p, "
"cur-index=%" PRId64,
parent_pos_in_stack, parent_class, cur_index);
parent_class, cur_index, ctx);
if (ret) {
/* Not found... yet */
- BT_LOGD_STR("Not found at this point.");
+ BT_COMP_LOGD_STR("Not found at this point.");
ctf_field_path_clear(&tail_field_path);
} else {
/* Found: stitch tail field path to head field path */
/* Convert path string to path tokens */
ptokens = pathstr_to_ptokens(pathstr, ctx);
if (!ptokens) {
- BT_LOGE("Cannot convert path string to path tokens: "
+ BT_COMP_LOGE("Cannot convert path string to path tokens: "
"path=\"%s\"", pathstr);
ret = -1;
goto end;
if (root_scope == -1) {
/* Relative path: start with current root scope */
field_path->root = ctx->root_scope;
- BT_LOGD("Detected relative path: starting with current root scope: "
+ BT_COMP_LOGD("Detected relative path: starting with current root scope: "
"scope=%s", ctf_scope_string(field_path->root));
ret = relative_ptokens_to_field_path(ptokens, field_path, ctx);
if (ret) {
- BT_LOGE("Cannot get relative field path of path string: "
+ BT_COMP_LOGE("Cannot get relative field path of path string: "
"path=\"%s\", start-scope=%s, end-scope=%s",
pathstr, ctf_scope_string(ctx->root_scope),
ctf_scope_string(field_path->root));
} else {
/* Absolute path: use found root scope */
field_path->root = root_scope;
- BT_LOGD("Detected absolute path: using root scope: "
+ BT_COMP_LOGD("Detected absolute path: using root scope: "
"scope=%s", ctf_scope_string(field_path->root));
ret = absolute_ptokens_to_field_path(ptokens, field_path, ctx);
if (ret) {
- BT_LOGE("Cannot get absolute field path of path string: "
+ BT_COMP_LOGE("Cannot get absolute field path of path string: "
"path=\"%s\", root-scope=%s",
pathstr, ctf_scope_string(root_scope));
goto end;
const char *field_path_pretty_str =
field_path_pretty ? field_path_pretty->str : NULL;
- BT_LOGD("Found field path: path=\"%s\", field-path=\"%s\"",
+ BT_COMP_LOGD("Found field path: path=\"%s\", field-path=\"%s\"",
pathstr, field_path_pretty_str);
if (field_path_pretty) {
fc = borrow_class_from_ctx(ctx, field_path->root);
if (!fc) {
/* Error: root class is not available */
- BT_LOGE("Root field class is not available: root-scope=%s",
+ BT_COMP_LOGE("Root field class is not available: root-scope=%s",
ctf_scope_string(field_path->root));
goto end;
}
const char *field_path2_pretty_str =
field_path2_pretty ? field_path2_pretty->str : NULL;
- BT_LOGD("Finding lowest common ancestor (LCA) between two field paths: "
+ BT_COMP_LOGD("Finding lowest common ancestor (LCA) between two field paths: "
"field-path-1=\"%s\", field-path-2=\"%s\"",
field_path1_pretty_str, field_path2_pretty_str);
* This is invalid because the target cannot be
* an ancestor of the source.
*/
- BT_LOGE("Source field class is an ancestor of target field class or vice versa: "
+ BT_COMP_LOGE("Source field class is an ancestor of target field class or vice versa: "
"lca-index=%" PRId64 ", "
"field-path-1-len=%" PRIu64 ", "
"field-path-2-len=%" PRIu64,
lca_index++;
}
- BT_LOGD("Found LCA: lca-index=%" PRId64, lca_index);
+ BT_COMP_LOGD("Found LCA: lca-index=%" PRId64, lca_index);
return lca_index;
}
* Make sure the target is not a root.
*/
if (target_field_path_len == 0) {
- BT_LOGE_STR("Target field path's length is 0 (targeting the root).");
+ BT_COMP_LOGE_STR("Target field path's length is 0 (targeting the root).");
ret = -1;
goto end;
}
* after the context field path's root.
*/
if (target_field_path->root > ctx_field_path.root) {
- BT_LOGE("Target field class is located after source field class: "
+ BT_COMP_LOGE("Target field class is located after source field class: "
"target-root=%s, source-root=%s",
ctf_scope_string(target_field_path->root),
ctf_scope_string(ctx_field_path.root));
lca_index = get_field_paths_lca_index(target_field_path,
&ctx_field_path, ctx);
if (lca_index < 0) {
- BT_LOGE_STR("Cannot get least common ancestor.");
+ BT_COMP_LOGE_STR("Cannot get least common ancestor.");
ret = -1;
goto end;
}
&ctx_field_path, (uint64_t) lca_index);
if (target_index >= ctx_index) {
- BT_LOGE("Target field class's index is greater than or equal to source field class's index in LCA: "
+ BT_COMP_LOGE("Target field class's index is greater than or equal to source field class's index in LCA: "
"lca-index=%" PRId64 ", "
"target-index=%" PRId64 ", "
"source-index=%" PRId64,
switch (ctx->cur_fc->type) {
case CTF_FIELD_CLASS_TYPE_VARIANT:
if (target_fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
- BT_LOGE("Variant field class's tag field class is not an enumeration field class: "
+ BT_COMP_LOGE("Variant field class's tag field class is not an enumeration field class: "
"tag-fc-addr=%p, tag-fc-id=%d",
target_fc, target_fc->type);
ret = -1;
if (target_fc->type != CTF_FIELD_CLASS_TYPE_INT &&
target_fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
- BT_LOGE("Sequence field class's length field class is not an unsigned integer field class: "
+ BT_COMP_LOGE("Sequence field class's length field class is not an unsigned integer field class: "
"length-fc-addr=%p, length-fc-id=%d",
target_fc, target_fc->type);
ret = -1;
}
if (int_fc->is_signed) {
- BT_LOGE("Sequence field class's length field class is not an unsigned integer field class: "
+ BT_COMP_LOGE("Sequence field class's length field class is not an unsigned integer field class: "
"length-fc-addr=%p, length-fc-id=%d",
target_fc, target_fc->type);
ret = -1;
}
if (!pathstr) {
- BT_LOGE_STR("Cannot get path string.");
+ BT_COMP_LOGE_STR("Cannot get path string.");
ret = -1;
goto end;
}
/* Get target field path out of path string */
ret = pathstr_to_field_path(pathstr, &target_field_path, ctx);
if (ret) {
- BT_LOGE("Cannot get target field path for path string: "
+ BT_COMP_LOGE("Cannot get target field path for path string: "
"path=\"%s\"", pathstr);
goto end;
}
/* Get target field class */
target_fc = field_path_to_field_class(&target_field_path, ctx);
if (!target_fc) {
- BT_LOGE("Cannot get target field class for path string: "
+ BT_COMP_LOGE("Cannot get target field class for path string: "
"path=\"%s\", target-field-path=\"%s\"",
pathstr, target_field_path_pretty_str);
ret = -1;
ret = validate_target_field_path(&target_field_path,
target_fc, ctx);
if (ret) {
- BT_LOGE("Invalid target field path for path string: "
+ BT_COMP_LOGE("Invalid target field path for path string: "
"path=\"%s\", target-field-path=\"%s\"",
pathstr, target_field_path_pretty_str);
goto end;
case CTF_FIELD_CLASS_TYPE_VARIANT:
ret = resolve_sequence_or_variant_field_class(fc, ctx);
if (ret) {
- BT_LOGE("Cannot resolve sequence field class's length or variant field class's tag: "
+ BT_COMP_LOGE("Cannot resolve sequence field class's length or variant field class's tag: "
"ret=%d, fc-addr=%p", ret, fc);
goto end;
}
ret = field_class_stack_push(ctx->field_class_stack, fc, ctx);
if (ret) {
- BT_LOGE("Cannot push field class on context's stack: "
+ BT_COMP_LOGE("Cannot push field class on context's stack: "
"fc-addr=%p", fc);
goto end;
}
(int64_t) i;
}
- BT_LOGD("Resolving field class's child field class: "
+ BT_COMP_LOGD("Resolving field class's child field class: "
"parent-fc-addr=%p, child-fc-addr=%p, "
"index=%" PRIu64 ", count=%" PRIu64,
fc, child_fc, i, field_count);
ctx->scopes.event_spec_context = ec->spec_context_fc;
ret = resolve_root_class(CTF_SCOPE_EVENT_COMMON_CONTEXT, ctx);
if (ret) {
- BT_LOGE("Cannot resolve event specific context field class: "
+ BT_COMP_LOGE("Cannot resolve event specific context field class: "
"ret=%d", ret);
goto end;
}
ctx->scopes.event_payload = ec->payload_fc;
ret = resolve_root_class(CTF_SCOPE_EVENT_PAYLOAD, ctx);
if (ret) {
- BT_LOGE("Cannot resolve event payload field class: "
+ BT_COMP_LOGE("Cannot resolve event payload field class: "
"ret=%d", ret);
goto end;
}
ctx->scopes.packet_context = sc->packet_context_fc;
ret = resolve_root_class(CTF_SCOPE_PACKET_CONTEXT, ctx);
if (ret) {
- BT_LOGE("Cannot resolve packet context field class: "
+ BT_COMP_LOGE("Cannot resolve packet context field class: "
"ret=%d", ret);
goto end;
}
ctx->scopes.event_header = sc->event_header_fc;
ret = resolve_root_class(CTF_SCOPE_EVENT_HEADER, ctx);
if (ret) {
- BT_LOGE("Cannot resolve event header field class: "
+ BT_COMP_LOGE("Cannot resolve event header field class: "
"ret=%d", ret);
goto end;
}
ctx->scopes.event_common_context = sc->event_common_context_fc;
ret = resolve_root_class(CTF_SCOPE_EVENT_SPECIFIC_CONTEXT, ctx);
if (ret) {
- BT_LOGE("Cannot resolve event common context field class: "
+ BT_COMP_LOGE("Cannot resolve event common context field class: "
"ret=%d", ret);
goto end;
}
ret = resolve_event_class_field_classes(ctx, ec);
if (ret) {
- BT_LOGE("Cannot resolve event class's field classes: "
+ BT_COMP_LOGE("Cannot resolve event class's field classes: "
"ec-id=%" PRIu64 ", ec-name=\"%s\"",
ec->id, ec->name->str);
goto end;
BT_HIDDEN
int ctf_trace_class_resolve_field_classes(struct ctf_trace_class *tc,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
int ret = 0;
uint64_t i;
struct resolve_context local_ctx = {
- .log_level = log_level,
+ .log_level = log_cfg->log_level,
+ .self_comp = log_cfg->self_comp,
.tc = tc,
.sc = NULL,
.ec = NULL,
/* Initialize class stack */
ctx->field_class_stack = field_class_stack_create();
if (!ctx->field_class_stack) {
- BT_LOGE_STR("Cannot create field class stack.");
+ BT_COMP_LOGE_STR("Cannot create field class stack.");
ret = -1;
goto end;
}
ctx->scopes.packet_header = tc->packet_header_fc;
ret = resolve_root_class(CTF_SCOPE_PACKET_HEADER, ctx);
if (ret) {
- BT_LOGE("Cannot resolve packet header field class: "
+ BT_COMP_LOGE("Cannot resolve packet header field class: "
"ret=%d", ret);
goto end;
}
ret = resolve_stream_class_field_classes(ctx, sc);
if (ret) {
- BT_LOGE("Cannot resolve stream class's field classes: "
+ BT_COMP_LOGE("Cannot resolve stream class's field classes: "
"sc-id=%" PRIu64, sc->id);
goto end;
}
#include "ctf-meta-visitors.h"
struct ctx {
- bt_self_component_source *self_comp;
+ bt_self_component *self_comp;
bt_trace_class *ir_tc;
bt_stream_class *ir_sc;
struct ctf_trace_class *tc;
for (i = 0; i < ctx->tc->clock_classes->len; i++) {
struct ctf_clock_class *cc = ctx->tc->clock_classes->pdata[i];
- cc->ir_cc = bt_clock_class_create(
- bt_self_component_source_as_self_component(
- ctx->self_comp));
+ cc->ir_cc = bt_clock_class_create(ctx->self_comp);
ctf_clock_class_to_ir(cc->ir_cc, cc);
}
}
BT_HIDDEN
-int ctf_trace_class_translate(bt_self_component_source *self_comp,
+int ctf_trace_class_translate(bt_self_component *self_comp,
bt_trace_class *ir_tc, struct ctf_trace_class *tc)
{
int ret = 0;
* all copies or substantial portions of the Software.
*/
-#define BT_LOG_OUTPUT_LEVEL log_level
+#define BT_COMP_LOG_SELF_COMP (log_cfg->self_comp)
+#define BT_LOG_OUTPUT_LEVEL (log_cfg->log_level)
#define BT_LOG_TAG "PLUGIN/CTF/META/UPDATE-DEF-CC"
-#include "logging/log.h"
+#include "plugins/comp-logging.h"
#include <babeltrace2/babeltrace.h>
#include "common/macros.h"
#include <inttypes.h>
#include "ctf-meta-visitors.h"
+#include "logging.h"
static inline
int find_mapped_clock_class(struct ctf_field_class *fc,
struct ctf_clock_class **clock_class,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
int ret = 0;
uint64_t i;
if (int_fc->mapped_clock_class) {
if (*clock_class && *clock_class !=
int_fc->mapped_clock_class) {
- BT_LOGE("Stream class contains more than one "
+ BT_COMP_LOGE("Stream class contains more than one "
"clock class: expected-cc-name=\"%s\", "
"other-cc-name=\"%s\"",
(*clock_class)->name->str,
struct_fc, i);
ret = find_mapped_clock_class(named_fc->fc,
- clock_class, log_level);
+ clock_class, log_cfg);
if (ret) {
goto end;
}
var_fc, i);
ret = find_mapped_clock_class(named_fc->fc,
- clock_class, log_level);
+ clock_class, log_cfg);
if (ret) {
goto end;
}
struct ctf_field_class_array_base *array_fc = (void *) fc;
ret = find_mapped_clock_class(array_fc->elem_fc, clock_class,
- log_level);
+ log_cfg);
if (ret) {
goto end;
}
static inline
int update_stream_class_default_clock_class(
struct ctf_stream_class *stream_class,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
int ret = 0;
struct ctf_clock_class *clock_class =
uint64_t i;
ret = find_mapped_clock_class(stream_class->packet_context_fc,
- &clock_class, log_level);
+ &clock_class, log_cfg);
if (ret) {
goto end;
}
ret = find_mapped_clock_class(stream_class->event_header_fc,
- &clock_class, log_level);
+ &clock_class, log_cfg);
if (ret) {
goto end;
}
ret = find_mapped_clock_class(stream_class->event_common_context_fc,
- &clock_class, log_level);
+ &clock_class, log_cfg);
if (ret) {
goto end;
}
stream_class->event_classes->pdata[i];
ret = find_mapped_clock_class(event_class->spec_context_fc,
- &clock_class, log_level);
+ &clock_class, log_cfg);
if (ret) {
goto end;
}
ret = find_mapped_clock_class(event_class->payload_fc,
- &clock_class, log_level);
+ &clock_class, log_cfg);
if (ret) {
goto end;
}
BT_HIDDEN
int ctf_trace_class_update_default_clock_classes(struct ctf_trace_class *ctf_tc,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
uint64_t i;
int ret = 0;
struct ctf_clock_class *clock_class = NULL;
ret = find_mapped_clock_class(ctf_tc->packet_header_fc, &clock_class,
- log_level);
+ log_cfg);
if (ret) {
goto end;
}
ctf_tc->stream_classes->pdata[i];
ret = update_stream_class_default_clock_class(
- ctf_tc->stream_classes->pdata[i], log_level);
+ ctf_tc->stream_classes->pdata[i], log_cfg);
if (ret) {
- BT_LOGE("Stream class contains more than one "
+ BT_COMP_LOGE("Stream class contains more than one "
"clock class: stream-class-id=%" PRIu64,
sc->id);
goto end;
* all copies or substantial portions of the Software.
*/
-#define BT_LOG_OUTPUT_LEVEL log_level
+#define BT_COMP_LOG_SELF_COMP (log_cfg->self_comp)
+#define BT_LOG_OUTPUT_LEVEL (log_cfg->log_level)
#define BT_LOG_TAG "PLUGIN/CTF/META/VALIDATE"
-#include "logging/log.h"
+#include "plugins/comp-logging.h"
#include <babeltrace2/babeltrace.h>
#include "common/macros.h"
#include <inttypes.h>
#include "ctf-meta-visitors.h"
+#include "logging.h"
static
int validate_stream_class(struct ctf_stream_class *sc,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
int ret = 0;
struct ctf_field_class_int *int_fc;
if (fc) {
if (fc->type != CTF_FIELD_CLASS_TYPE_INT &&
fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
- BT_LOGE_STR("Invalid packet context field class: "
+ BT_COMP_LOGE_STR("Invalid packet context field class: "
"`timestamp_begin` member is not an integer field class.");
goto invalid;
}
int_fc = (void *) fc;
if (int_fc->is_signed) {
- BT_LOGE_STR("Invalid packet context field class: "
+ BT_COMP_LOGE_STR("Invalid packet context field class: "
"`timestamp_begin` member is signed.");
goto invalid;
}
if (fc) {
if (fc->type != CTF_FIELD_CLASS_TYPE_INT &&
fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
- BT_LOGE_STR("Invalid packet context field class: "
+ BT_COMP_LOGE_STR("Invalid packet context field class: "
"`timestamp_end` member is not an integer field class.");
goto invalid;
}
int_fc = (void *) fc;
if (int_fc->is_signed) {
- BT_LOGE_STR("Invalid packet context field class: "
+ BT_COMP_LOGE_STR("Invalid packet context field class: "
"`timestamp_end` member is signed.");
goto invalid;
}
if (fc) {
if (fc->type != CTF_FIELD_CLASS_TYPE_INT &&
fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
- BT_LOGE_STR("Invalid packet context field class: "
+ BT_COMP_LOGE_STR("Invalid packet context field class: "
"`events_discarded` member is not an integer field class.");
goto invalid;
}
int_fc = (void *) fc;
if (int_fc->is_signed) {
- BT_LOGE_STR("Invalid packet context field class: "
+ BT_COMP_LOGE_STR("Invalid packet context field class: "
"`events_discarded` member is signed.");
goto invalid;
}
if (fc) {
if (fc->type != CTF_FIELD_CLASS_TYPE_INT &&
fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
- BT_LOGE_STR("Invalid packet context field class: "
+ BT_COMP_LOGE_STR("Invalid packet context field class: "
"`packet_seq_num` member is not an integer field class.");
goto invalid;
}
int_fc = (void *) fc;
if (int_fc->is_signed) {
- BT_LOGE_STR("Invalid packet context field class: "
+ BT_COMP_LOGE_STR("Invalid packet context field class: "
"`packet_seq_num` member is signed.");
goto invalid;
}
if (fc) {
if (fc->type != CTF_FIELD_CLASS_TYPE_INT &&
fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
- BT_LOGE_STR("Invalid packet context field class: "
+ BT_COMP_LOGE_STR("Invalid packet context field class: "
"`packet_size` member is not an integer field class.");
goto invalid;
}
int_fc = (void *) fc;
if (int_fc->is_signed) {
- BT_LOGE_STR("Invalid packet context field class: "
+ BT_COMP_LOGE_STR("Invalid packet context field class: "
"`packet_size` member is signed.");
goto invalid;
}
if (fc) {
if (fc->type != CTF_FIELD_CLASS_TYPE_INT &&
fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
- BT_LOGE_STR("Invalid packet context field class: "
+ BT_COMP_LOGE_STR("Invalid packet context field class: "
"`content_size` member is not an integer field class.");
goto invalid;
}
int_fc = (void *) fc;
if (int_fc->is_signed) {
- BT_LOGE_STR("Invalid packet context field class: "
+ BT_COMP_LOGE_STR("Invalid packet context field class: "
"`content_size` member is signed.");
goto invalid;
}
if (fc) {
if (fc->type != CTF_FIELD_CLASS_TYPE_INT &&
fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
- BT_LOGE_STR("Invalid event header field class: "
+ BT_COMP_LOGE_STR("Invalid event header field class: "
"`id` member is not an integer field class.");
goto invalid;
}
int_fc = (void *) fc;
if (int_fc->is_signed) {
- BT_LOGE_STR("Invalid event header field class: "
+ BT_COMP_LOGE_STR("Invalid event header field class: "
"`id` member is signed.");
goto invalid;
}
} else {
if (sc->event_classes->len > 1) {
- BT_LOGE_STR("Invalid event header field class: "
+ BT_COMP_LOGE_STR("Invalid event header field class: "
"missing `id` member as there's "
"more than one event class.");
goto invalid;
BT_HIDDEN
int ctf_trace_class_validate(struct ctf_trace_class *ctf_tc,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
int ret = 0;
struct ctf_field_class_int *int_fc;
0);
if (named_fc->fc != fc) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"`magic` member is not the first member.");
goto invalid;
}
if (fc->type != CTF_FIELD_CLASS_TYPE_INT &&
fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"`magic` member is not an integer field class.");
goto invalid;
}
int_fc = (void *) fc;
if (int_fc->is_signed) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"`magic` member is signed.");
goto invalid;
}
if (int_fc->base.size != 32) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"`magic` member is not 32-bit.");
goto invalid;
}
if (fc) {
if (fc->type != CTF_FIELD_CLASS_TYPE_INT &&
fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"`stream_id` member is not an integer field class.");
goto invalid;
}
int_fc = (void *) fc;
if (int_fc->is_signed) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"`stream_id` member is signed.");
goto invalid;
}
} else {
if (ctf_tc->stream_classes->len > 1) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"missing `stream_id` member as there's "
"more than one stream class.");
goto invalid;
if (fc) {
if (fc->type != CTF_FIELD_CLASS_TYPE_INT &&
fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"`stream_instance_id` member is not an integer field class.");
goto invalid;
}
int_fc = (void *) fc;
if (int_fc->is_signed) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"`stream_instance_id` member is signed.");
goto invalid;
}
struct ctf_field_class_array *array_fc = (void *) fc;
if (fc->type != CTF_FIELD_CLASS_TYPE_ARRAY) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"`uuid` member is not an array field class.");
goto invalid;
}
array_fc = (void *) fc;
if (array_fc->length != 16) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"`uuid` member is not a 16-element array field class.");
goto invalid;
}
if (array_fc->base.elem_fc->type != CTF_FIELD_CLASS_TYPE_INT) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"`uuid` member's element field class is not "
"an integer field class.");
goto invalid;
int_fc = (void *) array_fc->base.elem_fc;
if (int_fc->is_signed) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"`uuid` member's element field class "
"is a signed integer field class.");
goto invalid;
}
if (int_fc->base.size != 8) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"`uuid` member's element field class "
"is not an 8-bit integer field class.");
goto invalid;
}
if (int_fc->base.base.alignment != 8) {
- BT_LOGE_STR("Invalid packet header field class: "
+ BT_COMP_LOGE_STR("Invalid packet header field class: "
"`uuid` member's element field class's "
"alignment is not 8.");
goto invalid;
struct ctf_stream_class *sc =
ctf_tc->stream_classes->pdata[i];
- ret = validate_stream_class(sc, log_level);
+ ret = validate_stream_class(sc, log_cfg);
if (ret) {
- BT_LOGE("Invalid stream class: sc-id=%" PRIu64, sc->id);
+ BT_COMP_LOGE("Invalid stream class: sc-id=%" PRIu64, sc->id);
goto invalid;
}
}
#include "ctf-meta.h"
+struct meta_log_config;
+
BT_HIDDEN
int ctf_trace_class_resolve_field_classes(struct ctf_trace_class *tc,
- bt_logging_level log_level);
+ struct meta_log_config *log_cfg);
BT_HIDDEN
-int ctf_trace_class_translate(bt_self_component_source *self_comp,
+int ctf_trace_class_translate(bt_self_component *self_comp,
bt_trace_class *ir_tc, struct ctf_trace_class *tc);
BT_HIDDEN
int ctf_trace_class_update_default_clock_classes(
struct ctf_trace_class *ctf_tc,
- bt_logging_level log_level);
+ struct meta_log_config *log_cfg);
BT_HIDDEN
int ctf_trace_class_update_in_ir(struct ctf_trace_class *ctf_tc);
BT_HIDDEN
int ctf_trace_class_validate(struct ctf_trace_class *ctf_tc,
- bt_logging_level log_level);
+ struct meta_log_config *log_cfg);
BT_HIDDEN
void ctf_trace_class_warn_meaningless_header_fields(
- struct ctf_trace_class *ctf_tc, bt_logging_level log_level);
+ struct ctf_trace_class *ctf_tc,
+ struct meta_log_config *log_cfg);
#endif /* _CTF_META_VISITORS_H */
* all copies or substantial portions of the Software.
*/
-#define BT_LOG_OUTPUT_LEVEL log_level
+#define BT_COMP_LOG_SELF_COMP (log_cfg->self_comp)
+#define BT_LOG_OUTPUT_LEVEL (log_cfg->log_level)
#define BT_LOG_TAG "PLUGIN/CTF/META/WARN-MEANINGLESS-HEADER-FIELDS"
-#include "logging/log.h"
+#include "plugins/comp-logging.h"
#include <babeltrace2/babeltrace.h>
#include "common/macros.h"
#include <inttypes.h>
#include "ctf-meta-visitors.h"
+#include "logging.h"
static inline
void warn_meaningless_field(const char *name, const char *scope_name,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
- BT_LOGW("User field found in %s: ignoring: name=\"%s\"",
+ BT_COMP_LOGW("User field found in %s: ignoring: name=\"%s\"",
scope_name, name);
}
static inline
void warn_meaningless_fields(struct ctf_field_class *fc, const char *name,
- const char *scope_name, bt_logging_level log_level)
+ const char *scope_name, struct meta_log_config *log_cfg)
{
uint64_t i;
switch (fc->type) {
case CTF_FIELD_CLASS_TYPE_FLOAT:
case CTF_FIELD_CLASS_TYPE_STRING:
- warn_meaningless_field(name, scope_name, log_level);
+ warn_meaningless_field(name, scope_name, log_cfg);
break;
case CTF_FIELD_CLASS_TYPE_INT:
case CTF_FIELD_CLASS_TYPE_ENUM:
if (int_fc->meaning == CTF_FIELD_CLASS_MEANING_NONE &&
!int_fc->mapped_clock_class) {
- warn_meaningless_field(name, scope_name, log_level);
+ warn_meaningless_field(name, scope_name, log_cfg);
}
break;
struct_fc, i);
warn_meaningless_fields(named_fc->fc,
- named_fc->name->str, scope_name, log_level);
+ named_fc->name->str, scope_name, log_cfg);
}
break;
var_fc, i);
warn_meaningless_fields(named_fc->fc,
- named_fc->name->str, scope_name, log_level);
+ named_fc->name->str, scope_name, log_cfg);
}
break;
struct ctf_field_class_array_base *array_fc = (void *) fc;
warn_meaningless_fields(array_fc->elem_fc, name, scope_name,
- log_level);
+ log_cfg);
break;
}
default:
BT_HIDDEN
void ctf_trace_class_warn_meaningless_header_fields(
struct ctf_trace_class *ctf_tc,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
uint64_t i;
if (!ctf_tc->is_translated) {
warn_meaningless_fields(
ctf_tc->packet_header_fc, NULL, "packet header",
- log_level);
+ log_cfg);
}
for (i = 0; i < ctf_tc->stream_classes->len; i++) {
if (!sc->is_translated) {
warn_meaningless_fields(sc->event_header_fc, NULL,
- "event header", log_level);
+ "event header", log_cfg);
}
}
}
* all copies or substantial portions of the Software.
*/
+#define BT_COMP_LOG_SELF_COMP (mdec->config.self_comp)
#define BT_LOG_OUTPUT_LEVEL (mdec->config.log_level)
#define BT_LOG_TAG "PLUGIN/CTF/META/DECODER"
-#include "logging/log.h"
+#include "plugins/comp-logging.h"
#include <stdio.h>
#include <stdbool.h>
#include "ast.h"
#include "decoder.h"
#include "scanner.h"
+#include "logging.h"
#define TSDL_MAGIC 0x75d11d57
BT_HIDDEN
bool ctf_metadata_decoder_is_packetized(FILE *fp, int *byte_order,
- bt_logging_level log_level)
+ bt_logging_level log_level, bt_self_component *self_comp)
{
uint32_t magic;
size_t len;
len = fread(&magic, sizeof(magic), 1, fp);
if (len != 1) {
- BT_LOG_WRITE_CUR_LVL(BT_LOG_INFO, log_level, BT_LOG_TAG,
+ BT_COMP_LOG_CUR_LVL(BT_LOG_INFO, log_level, self_comp,
"Cannot read first metadata packet header: assuming the stream is not packetized.");
goto end;
}
const long offset = ftell(in_fp);
if (offset < 0) {
- BT_LOGE_ERRNO("Failed to get current metadata file position",
+ BT_COMP_LOGE_ERRNO("Failed to get current metadata file position",
".");
goto error;
}
- BT_LOGD("Decoding metadata packet: mdec-addr=%p, offset=%ld",
+ BT_COMP_LOGD("Decoding metadata packet: mdec-addr=%p, offset=%ld",
mdec, offset);
readlen = fread(&header, sizeof(header), 1, in_fp);
if (feof(in_fp) != 0) {
- BT_LOGI("Reached end of file: offset=%ld", ftell(in_fp));
+ BT_COMP_LOGI("Reached end of file: offset=%ld", ftell(in_fp));
goto end;
}
if (readlen < 1) {
- BT_LOGE("Cannot decode metadata packet: offset=%ld", offset);
+ BT_COMP_LOGE("Cannot decode metadata packet: offset=%ld", offset);
goto error;
}
}
if (header.compression_scheme) {
- BT_LOGE("Metadata packet compression is not supported as of this version: "
+ BT_COMP_LOGE("Metadata packet compression is not supported as of this version: "
"compression-scheme=%u, offset=%ld",
(unsigned int) header.compression_scheme, offset);
goto error;
}
if (header.encryption_scheme) {
- BT_LOGE("Metadata packet encryption is not supported as of this version: "
+ BT_COMP_LOGE("Metadata packet encryption is not supported as of this version: "
"encryption-scheme=%u, offset=%ld",
(unsigned int) header.encryption_scheme, offset);
goto error;
}
if (header.checksum || header.checksum_scheme) {
- BT_LOGE("Metadata packet checksum verification is not supported as of this version: "
+ BT_COMP_LOGE("Metadata packet checksum verification is not supported as of this version: "
"checksum-scheme=%u, checksum=%x, offset=%ld",
(unsigned int) header.checksum_scheme, header.checksum,
offset);
}
if (!is_version_valid(header.major, header.minor)) {
- BT_LOGE("Invalid metadata packet version: "
+ BT_COMP_LOGE("Invalid metadata packet version: "
"version=%u.%u, offset=%ld",
header.major, header.minor, offset);
goto error;
memcpy(mdec->uuid, header.uuid, sizeof(header.uuid));
mdec->is_uuid_set = true;
} else if (bt_uuid_compare(header.uuid, mdec->uuid)) {
- BT_LOGE("Metadata UUID mismatch between packets of the same stream: "
+ BT_COMP_LOGE("Metadata UUID mismatch between packets of the same stream: "
"packet-uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\", "
"expected-uuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\", "
"offset=%ld",
}
if ((header.content_size / CHAR_BIT) < sizeof(header)) {
- BT_LOGE("Bad metadata packet content size: content-size=%u, "
+ BT_COMP_LOGE("Bad metadata packet content size: content-size=%u, "
"offset=%ld", header.content_size, offset);
goto error;
}
loop_read = MIN(sizeof(buf) - 1, toread);
readlen = fread(buf, sizeof(uint8_t), loop_read, in_fp);
if (ferror(in_fp)) {
- BT_LOGE("Cannot read metadata packet buffer: "
+ BT_COMP_LOGE("Cannot read metadata packet buffer: "
"offset=%ld, read-size=%zu",
ftell(in_fp), loop_read);
goto error;
}
if (readlen > loop_read) {
- BT_LOGE("fread returned more byte than expected: "
+ BT_COMP_LOGE("fread returned more byte than expected: "
"read-size-asked=%zu, read-size-returned=%zu",
loop_read, readlen);
goto error;
writelen = fwrite(buf, sizeof(uint8_t), readlen, out_fp);
if (writelen < readlen || ferror(out_fp)) {
- BT_LOGE("Cannot write decoded metadata text to buffer: "
+ BT_COMP_LOGE("Cannot write decoded metadata text to buffer: "
"read-offset=%ld, write-size=%zu",
ftell(in_fp), readlen);
goto error;
CHAR_BIT;
fseek_ret = fseek(in_fp, toread, SEEK_CUR);
if (fseek_ret < 0) {
- BT_LOGW_STR("Missing padding at the end of the metadata stream.");
+ BT_COMP_LOGW_STR("Missing padding at the end of the metadata stream.");
}
break;
}
static
int ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
struct ctf_metadata_decoder *mdec, FILE *fp,
- char **buf, int byte_order, bt_logging_level log_level)
+ char **buf, int byte_order, bt_logging_level log_level,
+ bt_self_component *self_comp)
{
FILE *out_fp;
size_t size;
out_fp = bt_open_memstream(buf, &size);
if (out_fp == NULL) {
- BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG,
+ BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
"Cannot open memory stream: %s: mdec-addr=%p",
strerror(errno), mdec);
goto error;
tret = decode_packet(mdec, fp, out_fp, byte_order);
if (tret) {
- BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG,
+ BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
"Cannot decode packet: index=%zu, mdec-addr=%p",
packet_index, mdec);
goto error;
/* Make sure the whole string ends with a null character */
tret = fputc('\0', out_fp);
if (tret == EOF) {
- BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG,
+ BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
"Cannot append '\\0' to the decoded metadata buffer: "
"mdec-addr=%p", mdec);
goto error;
*/
out_fp = NULL;
if (ret < 0) {
- BT_LOG_WRITE_ERRNO_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG,
+ BT_COMP_LOG_ERRNO_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
"Cannot close memory stream", ": mdec-addr=%p", mdec);
goto error;
}
if (out_fp) {
if (bt_close_memstream(buf, &size, out_fp)) {
- BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, log_level, BT_LOG_TAG,
- "Cannot close memory stream: %s: mdec-addr=%p",
- strerror(errno), mdec);
+ BT_COMP_LOG_ERRNO_CUR_LVL(BT_LOG_ERROR, log_level,
+ self_comp, "Cannot close memory stream",
+ ": mdec-addr=%p", mdec);
}
}
BT_HIDDEN
int ctf_metadata_decoder_packetized_file_stream_to_buf(
FILE *fp, char **buf, int byte_order,
- bt_logging_level log_level)
+ bt_logging_level log_level,
+ bt_self_component *self_comp)
{
return ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
- NULL, fp, buf, byte_order, log_level);
+ NULL, fp, buf, byte_order, log_level, self_comp);
}
BT_HIDDEN
struct ctf_metadata_decoder *ctf_metadata_decoder_create(
- bt_self_component_source *self_comp,
const struct ctf_metadata_decoder_config *config)
{
struct ctf_metadata_decoder *mdec =
g_new0(struct ctf_metadata_decoder, 1);
- struct ctf_metadata_decoder_config default_config = {
- .clock_class_offset_s = 0,
- .clock_class_offset_ns = 0,
- };
- if (!config) {
- config = &default_config;
- }
-
- BT_LOGD("Creating CTF metadata decoder: "
+ BT_ASSERT(config);
+ BT_COMP_LOG_CUR_LVL(BT_LOG_DEBUG, config->log_level, config->self_comp,
+ "Creating CTF metadata decoder: "
"clock-class-offset-s=%" PRId64 ", "
"clock-class-offset-ns=%" PRId64,
config->clock_class_offset_s, config->clock_class_offset_ns);
if (!mdec) {
- BT_LOGE_STR("Failed to allocate one CTF metadata decoder.");
+ BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, config->log_level,
+ config->self_comp,
+ "Failed to allocate one CTF metadata decoder.");
goto end;
}
mdec->config = *config;
- mdec->visitor = ctf_visitor_generate_ir_create(self_comp, config);
+ mdec->visitor = ctf_visitor_generate_ir_create(config);
if (!mdec->visitor) {
- BT_LOGE("Failed to create a CTF IR metadata AST visitor: "
+ BT_COMP_LOGE("Failed to create a CTF IR metadata AST visitor: "
"mdec-addr=%p", mdec);
ctf_metadata_decoder_destroy(mdec);
mdec = NULL;
goto end;
}
- BT_LOGD("Creating CTF metadata decoder: "
+ BT_COMP_LOGD("Creating CTF metadata decoder: "
"clock-class-offset-s=%" PRId64 ", "
"clock-class-offset-ns=%" PRId64 ", addr=%p",
config->clock_class_offset_s, config->clock_class_offset_ns,
return;
}
- BT_LOGD("Destroying CTF metadata decoder: addr=%p", mdec);
+ BT_COMP_LOGD("Destroying CTF metadata decoder: addr=%p", mdec);
ctf_visitor_generate_ir_destroy(mdec->visitor);
g_free(mdec);
}
struct ctf_scanner *scanner = NULL;
char *buf = NULL;
bool close_fp = false;
+ struct meta_log_config log_cfg;
BT_ASSERT(mdec);
+ log_cfg.log_level = mdec->config.log_level;
+ log_cfg.self_comp = mdec->config.self_comp;
if (ctf_metadata_decoder_is_packetized(fp, &mdec->bo,
- BT_LOG_OUTPUT_LEVEL)) {
- BT_LOGI("Metadata stream is packetized: mdec-addr=%p", mdec);
+ mdec->config.log_level, mdec->config.self_comp)) {
+ BT_COMP_LOGI("Metadata stream is packetized: mdec-addr=%p", mdec);
ret = ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
- mdec, fp, &buf, mdec->bo, BT_LOG_OUTPUT_LEVEL);
+ mdec, fp, &buf, mdec->bo, mdec->config.log_level,
+ mdec->config.self_comp);
if (ret) {
- BT_LOGE("Cannot decode packetized metadata packets to metadata text: "
+ BT_COMP_LOGE("Cannot decode packetized metadata packets to metadata text: "
"mdec-addr=%p, ret=%d", mdec, ret);
status = CTF_METADATA_DECODER_STATUS_ERROR;
goto end;
fp = bt_fmemopen(buf, strlen(buf), "rb");
close_fp = true;
if (!fp) {
- BT_LOGE("Cannot memory-open metadata buffer: %s: "
+ BT_COMP_LOGE("Cannot memory-open metadata buffer: %s: "
"mdec-addr=%p", strerror(errno), mdec);
status = CTF_METADATA_DECODER_STATUS_ERROR;
goto end;
ssize_t nr_items;
const long init_pos = ftell(fp);
- BT_LOGI("Metadata stream is plain text: mdec-addr=%p", mdec);
+ BT_COMP_LOGI("Metadata stream is plain text: mdec-addr=%p", mdec);
if (init_pos < 0) {
- BT_LOGE_ERRNO("Failed to get current file position", ".");
+ BT_COMP_LOGE_ERRNO("Failed to get current file position", ".");
status = CTF_METADATA_DECODER_STATUS_ERROR;
goto end;
}
/* Check text-only metadata header and version */
nr_items = fscanf(fp, "/* CTF %10u.%10u", &major, &minor);
if (nr_items < 2) {
- BT_LOGW("Missing \"/* CTF major.minor\" signature in plain text metadata file stream: "
+ BT_COMP_LOGW("Missing \"/* CTF major.minor\" signature in plain text metadata file stream: "
"mdec-addr=%p", mdec);
}
- BT_LOGI("Found metadata stream version in signature: version=%u.%u", major, minor);
+ BT_COMP_LOGI("Found metadata stream version in signature: version=%u.%u", major, minor);
if (!is_version_valid(major, minor)) {
- BT_LOGE("Invalid metadata version found in plain text signature: "
+ BT_COMP_LOGE("Invalid metadata version found in plain text signature: "
"version=%u.%u, mdec-addr=%p", major, minor,
mdec);
status = CTF_METADATA_DECODER_STATUS_INVAL_VERSION;
}
if (fseek(fp, init_pos, SEEK_SET)) {
- BT_LOGE("Cannot seek metadata file stream to initial position: %s: "
+ BT_COMP_LOGE("Cannot seek metadata file stream to initial position: %s: "
"mdec-addr=%p", strerror(errno), mdec);
status = CTF_METADATA_DECODER_STATUS_ERROR;
goto end;
/* Allocate a scanner and append the metadata text content */
scanner = ctf_scanner_alloc();
if (!scanner) {
- BT_LOGE("Cannot allocate a metadata lexical scanner: "
+ BT_COMP_LOGE("Cannot allocate a metadata lexical scanner: "
"mdec-addr=%p", mdec);
status = CTF_METADATA_DECODER_STATUS_ERROR;
goto end;
BT_ASSERT(fp);
ret = ctf_scanner_append_ast(scanner, fp);
if (ret) {
- BT_LOGE("Cannot create the metadata AST out of the metadata text: "
+ BT_COMP_LOGE("Cannot create the metadata AST out of the metadata text: "
"mdec-addr=%p", mdec);
status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
goto end;
}
- ret = ctf_visitor_semantic_check(0, &scanner->ast->root,
- mdec->config.log_level);
+ ret = ctf_visitor_semantic_check(0, &scanner->ast->root, &log_cfg);
if (ret) {
- BT_LOGE("Validation of the metadata semantics failed: "
+ BT_COMP_LOGE("Validation of the metadata semantics failed: "
"mdec-addr=%p", mdec);
status = CTF_METADATA_DECODER_STATUS_ERROR;
goto end;
/* Success */
break;
case -EINCOMPLETE:
- BT_LOGD("While visiting metadata AST: incomplete data: "
+ BT_COMP_LOGD("While visiting metadata AST: incomplete data: "
"mdec-addr=%p", mdec);
status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
goto end;
default:
- BT_LOGE("Failed to visit AST node to create CTF IR objects: "
+ BT_COMP_LOGE("Failed to visit AST node to create CTF IR objects: "
"mdec-addr=%p, ret=%d", mdec, ret);
status = CTF_METADATA_DECODER_STATUS_IR_VISITOR_ERROR;
goto end;
if (fp && close_fp) {
if (fclose(fp)) {
- BT_LOGE("Cannot close metadata file stream: "
+ BT_COMP_LOGE("Cannot close metadata file stream: "
"mdec-addr=%p", mdec);
}
}
/* Decoding configuration */
struct ctf_metadata_decoder_config {
bt_logging_level log_level;
+
+ /* Weak */
+ bt_self_component *self_comp;
+
int64_t clock_class_offset_s;
int64_t clock_class_offset_ns;
};
*/
BT_HIDDEN
struct ctf_metadata_decoder *ctf_metadata_decoder_create(
- bt_self_component_source *self_comp,
const struct ctf_metadata_decoder_config *config);
/*
*/
BT_HIDDEN
bool ctf_metadata_decoder_is_packetized(FILE *fp, int *byte_order,
- bt_logging_level log_level);
+ bt_logging_level log_level,
+ bt_self_component *self_comp);
/*
* Decodes a packetized metadata file stream to a NULL-terminated
BT_HIDDEN
int ctf_metadata_decoder_packetized_file_stream_to_buf(
FILE *fp, char **buf, int byte_order,
- bt_logging_level log_level);
+ bt_logging_level log_level,
+ bt_self_component *self_comp);
#endif /* _METADATA_DECODER_H */
* SOFTWARE.
*/
+#include <babeltrace2/babeltrace.h>
#include "logging/log.h"
/*
*/
BT_LOG_LEVEL_EXTERN_SYMBOL(ctf_plugin_metadata_log_level);
+/*
+ * To be used by functions without a context structure to pass all the
+ * logging configuration at once.
+ */
+struct meta_log_config {
+ bt_logging_level log_level;
+
+ /* Weak */
+ bt_self_component *self_comp;
+};
+
#define _BT_LOGV_LINENO(_lineno, _msg, args...) \
BT_LOGV("At line %u in metadata stream: " _msg, _lineno, ## args)
#define _BT_LOGE_LINENO(_lineno, _msg, args...) \
BT_LOGE("At line %u in metadata stream: " _msg, _lineno, ## args)
+#define _BT_COMP_LOGV_LINENO(_lineno, _msg, args...) \
+ BT_COMP_LOGV("At line %u in metadata stream: " _msg, _lineno, ## args)
+
+#define _BT_COMP_LOGW_LINENO(_lineno, _msg, args...) \
+ BT_COMP_LOGW("At line %u in metadata stream: " _msg, _lineno, ## args)
+
+#define _BT_COMP_LOGE_LINENO(_lineno, _msg, args...) \
+ BT_COMP_LOGE("At line %u in metadata stream: " _msg, _lineno, ## args)
+
#endif /* CTF_METADATA_LOGGING_H */
* SOFTWARE.
*/
-#define BT_LOG_OUTPUT_LEVEL (ctx->log_level)
+#define BT_COMP_LOG_SELF_COMP (ctx->log_cfg.self_comp)
+#define BT_LOG_OUTPUT_LEVEL (ctx->log_cfg.log_level)
#define BT_LOG_TAG "PLUGIN/CTF/META/IR-VISITOR"
-#include "logging/log.h"
+#include "plugins/comp-logging.h"
#include <stdio.h>
#include <unistd.h>
do { \
ret = ctx_push_scope(ctx); \
if (ret) { \
- BT_LOGE_STR("Cannot push scope."); \
+ BT_COMP_LOGE_STR("Cannot push scope."); \
goto error; \
} \
} while (0)
#define _BT_LIST_FIRST_ENTRY(_ptr, _class, _member) \
bt_list_entry((_ptr)->next, _class, _member)
-#define _BT_LOGE_DUP_ATTR(_node, _attr, _entity) \
- _BT_LOGE_LINENO((_node)->lineno, \
+#define _BT_COMP_LOGE_DUP_ATTR(_node, _attr, _entity) \
+ _BT_COMP_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_COMP_LOGE_NODE(_node, _msg, args...) \
+ _BT_COMP_LOGE_LINENO((_node)->lineno, _msg, ## args)
-#define _BT_LOGW_NODE(_node, _msg, args...) \
- _BT_LOGW_LINENO((_node)->lineno, _msg, ## args)
+#define _BT_COMP_LOGW_NODE(_node, _msg, args...) \
+ _BT_COMP_LOGW_LINENO((_node)->lineno, _msg, ## args)
-#define _BT_LOGV_NODE(_node, _msg, args...) \
- _BT_LOGV_LINENO((_node)->lineno, _msg, ## args)
+#define _BT_COMP_LOGV_NODE(_node, _msg, args...) \
+ _BT_COMP_LOGV_LINENO((_node)->lineno, _msg, ## args)
/*
* Declaration scope of a visitor context. This represents a TSDL
* Visitor context (private).
*/
struct ctx {
- bt_logging_level log_level;
- bt_self_component_source *self_comp;
+ struct meta_log_config log_cfg;
+
/* Trace IR trace class being filled (owned by this) */
bt_trace_class *trace_class;
scope = g_new(struct ctx_decl_scope, 1);
if (!scope) {
- BT_LOGE_STR("Failed to allocate one declaration scope.");
+ BT_COMP_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.");
+ BT_COMP_LOGE_STR("Failed to allocate a string.");
goto end;
}
* @returns New visitor context, or NULL on error
*/
static
-struct ctx *ctx_create(bt_self_component_source *self_comp,
- const struct ctf_metadata_decoder_config *decoder_config)
+struct ctx *ctx_create(const struct ctf_metadata_decoder_config *decoder_config)
{
struct ctx *ctx = NULL;
ctx = g_new0(struct ctx, 1);
if (!ctx) {
- BT_LOG_WRITE_CUR_LVL(BT_LOG_ERROR, decoder_config->log_level,
- BT_LOG_TAG,
+ BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, decoder_config->log_level,
+ decoder_config->self_comp,
"Failed to allocate one visitor context.");
goto error;
}
- ctx->log_level = decoder_config->log_level;
+ ctx->log_cfg.log_level = decoder_config->log_level;
+ ctx->log_cfg.self_comp = decoder_config->self_comp;
- if (self_comp) {
+ if (decoder_config->self_comp) {
ctx->trace_class = bt_trace_class_create(
- bt_self_component_source_as_self_component(self_comp));
+ decoder_config->self_comp);
if (!ctx->trace_class) {
- BT_LOGE_STR("Cannot create empty trace class.");
+ BT_COMP_LOGE_STR("Cannot create empty trace class.");
goto error;
}
- ctx->self_comp = self_comp;
}
ctx->ctf_tc = ctf_trace_class_create();
if (!ctx->ctf_tc) {
- BT_LOGE_STR("Cannot create CTF trace class.");
+ BT_COMP_LOGE_STR("Cannot create CTF trace class.");
goto error;
}
/* Root declaration scope */
ctx->current_scope = ctx_decl_scope_create(ctx, NULL);
if (!ctx->current_scope) {
- BT_LOGE_STR("Cannot create declaration scope.");
+ BT_COMP_LOGE_STR("Cannot create declaration scope.");
goto error;
}
BT_ASSERT(ctx);
new_scope = ctx_decl_scope_create(ctx, ctx->current_scope);
if (!new_scope) {
- BT_LOGE_STR("Cannot create declaration scope.");
+ BT_COMP_LOGE_STR("Cannot create declaration scope.");
ret = -ENOMEM;
goto end;
}
BT_ASSERT(field_ref);
ret = calloc(strlen(field_ref) + 1, 1);
if (!ret) {
- BT_LOGE("Failed to allocate a string: size=%zu",
+ BT_COMP_LOGE("Failed to allocate a string: size=%zu",
strlen(field_ref) + 1);
goto end;
}
uexpr_type != UNARY_UNSIGNED_CONSTANT ||
uexpr_link != UNARY_LINK_UNKNOWN || i != 0;
if (cond) {
- _BT_LOGE_NODE(node, "Invalid constant unsigned integer.");
+ _BT_COMP_LOGE_NODE(node, "Invalid constant unsigned integer.");
ret = -EINVAL;
goto end;
}
src_string = node->u.unary_expression.u.string;
ret = bt_uuid_parse(src_string, uuid);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot parse UUID: uuid=\"%s\"", src_string);
goto end;
}
int ret = 0;
if (unary_expr->type != NODE_UNARY_EXPRESSION) {
- _BT_LOGE_NODE(unary_expr,
+ _BT_COMP_LOGE_NODE(unary_expr,
"Expecting unary expression: node-type=%d",
unary_expr->type);
ret = -EINVAL;
} else if (!strcmp(str, "false") || !strcmp(str, "FALSE")) {
ret = FALSE;
} else {
- _BT_LOGE_NODE(unary_expr,
+ _BT_COMP_LOGE_NODE(unary_expr,
"Unexpected boolean value: value=\"%s\"", str);
ret = -EINVAL;
goto end;
break;
}
default:
- _BT_LOGE_NODE(unary_expr,
+ _BT_COMP_LOGE_NODE(unary_expr,
"Unexpected unary expression type: node-type=%d",
unary_expr->u.unary_expression.type);
ret = -EINVAL;
enum ctf_byte_order bo = -1;
if (unary_expr->u.unary_expression.type != UNARY_STRING) {
- _BT_LOGE_NODE(unary_expr,
+ _BT_COMP_LOGE_NODE(unary_expr,
"\"byte_order\" attribute: expecting `be`, `le`, `network`, or `native`.");
goto end;
}
} else if (!strcmp(str, "native")) {
bo = CTF_BYTE_ORDER_DEFAULT;
} else {
- _BT_LOGE_NODE(unary_expr,
+ _BT_COMP_LOGE_NODE(unary_expr,
"Unexpected \"byte_order\" attribute value: "
"expecting `be`, `le`, `network`, or `native`: value=\"%s\"",
str);
int ret = 0;
if (cls_specifier->type != NODE_TYPE_SPECIFIER) {
- _BT_LOGE_NODE(cls_specifier,
+ _BT_COMP_LOGE_NODE(cls_specifier,
"Unexpected node type: node-type=%d",
cls_specifier->type);
ret = -EINVAL;
struct ctf_node *node = cls_specifier->u.field_class_specifier.node;
if (!node->u._struct.name) {
- _BT_LOGE_NODE(node, "Unexpected empty structure field class name.");
+ _BT_COMP_LOGE_NODE(node, "Unexpected empty structure field class name.");
ret = -EINVAL;
goto end;
}
struct ctf_node *node = cls_specifier->u.field_class_specifier.node;
if (!node->u.variant.name) {
- _BT_LOGE_NODE(node, "Unexpected empty variant field class name.");
+ _BT_COMP_LOGE_NODE(node, "Unexpected empty variant field class name.");
ret = -EINVAL;
goto end;
}
struct ctf_node *node = cls_specifier->u.field_class_specifier.node;
if (!node->u._enum.enum_id) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Unexpected empty enumeration field class (`enum`) name.");
ret = -EINVAL;
goto end;
case TYPESPEC_INTEGER:
case TYPESPEC_STRING:
default:
- _BT_LOGE_NODE(cls_specifier->u.field_class_specifier.node,
+ _BT_COMP_LOGE_NODE(cls_specifier->u.field_class_specifier.node,
"Unexpected field class specifier type: %d",
cls_specifier->u.field_class_specifier.type);
ret = -EINVAL;
if (node_field_class_declarator) {
if (node_field_class_declarator->u.field_class_declarator.type ==
TYPEDEC_UNKNOWN) {
- _BT_LOGE_NODE(node_field_class_declarator,
+ _BT_COMP_LOGE_NODE(node_field_class_declarator,
"Unexpected field class declarator type: type=%d",
node_field_class_declarator->u.field_class_declarator.type);
ret = -EINVAL;
/* TODO: GCC bitfields not supported yet */
if (node_field_class_declarator->u.field_class_declarator.bitfield_len !=
NULL) {
- _BT_LOGE_NODE(node_field_class_declarator,
+ _BT_COMP_LOGE_NODE(node_field_class_declarator,
"GCC bitfields are not supported as of this version.");
ret = -EPERM;
goto error;
ctx->current_scope,
g_quark_to_string(qalias), -1, true);
if (!nested_decl) {
- _BT_LOGE_NODE(node_field_class_declarator,
+ _BT_COMP_LOGE_NODE(node_field_class_declarator,
"Cannot find class alias: name=\"%s\"",
g_quark_to_string(qalias));
ret = -EINVAL;
/* Create array/sequence, pass nested_decl as child */
if (bt_list_empty(length)) {
- _BT_LOGE_NODE(node_field_class_declarator,
+ _BT_COMP_LOGE_NODE(node_field_class_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,
+ _BT_COMP_LOGE_NODE(first,
"Unexpected node type: node-type=%d",
first->type);
ret = -EINVAL;
char *length_name = concatenate_unary_strings(length);
if (!length_name) {
- _BT_LOGE_NODE(node_field_class_declarator,
+ _BT_COMP_LOGE_NODE(node_field_class_declarator,
"Cannot concatenate unary strings.");
ret = -EINVAL;
goto error;
struct ctf_field_class_array *array_decl;
if (!env_entry) {
- _BT_LOGE_NODE(node_field_class_declarator,
+ _BT_COMP_LOGE_NODE(node_field_class_declarator,
"Cannot find environment entry: "
"name=\"%s\"", env_entry_name);
ret = -EINVAL;
}
if (env_entry->type != CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT) {
- _BT_LOGE_NODE(node_field_class_declarator,
+ _BT_COMP_LOGE_NODE(node_field_class_declarator,
"Wrong environment entry type "
"(expecting integer): "
"name=\"%s\"", env_entry_name);
}
if (env_entry->value.i < 0) {
- _BT_LOGE_NODE(node_field_class_declarator,
+ _BT_COMP_LOGE_NODE(node_field_class_declarator,
"Invalid, negative array length: "
"env-entry-name=\"%s\", "
"value=%" PRId64,
&qfield_name, iter, &field_decl, NULL);
if (ret) {
BT_ASSERT(!field_decl);
- _BT_LOGE_NODE(cls_specifier_list,
+ _BT_COMP_LOGE_NODE(cls_specifier_list,
"Cannot visit field class declarator: ret=%d", ret);
goto error;
}
/* Check if field with same name already exists */
if (ctf_field_class_struct_borrow_member_by_name(
struct_decl, field_name)) {
- _BT_LOGE_NODE(cls_specifier_list,
+ _BT_COMP_LOGE_NODE(cls_specifier_list,
"Duplicate field in structure field class: "
"field-name=\"%s\"", field_name);
ret = -EINVAL;
&qfield_name, iter, &field_decl, NULL);
if (ret) {
BT_ASSERT(!field_decl);
- _BT_LOGE_NODE(cls_specifier_list,
+ _BT_COMP_LOGE_NODE(cls_specifier_list,
"Cannot visit field class declarator: ret=%d", ret);
goto error;
}
/* Check if field with same name already exists */
if (ctf_field_class_variant_borrow_option_by_name(
variant_decl, field_name)) {
- _BT_LOGE_NODE(cls_specifier_list,
+ _BT_COMP_LOGE_NODE(cls_specifier_list,
"Duplicate field in variant field class: "
"field-name=\"%s\"", field_name);
ret = -EINVAL;
ret = visit_field_class_declarator(ctx, cls_specifier_list,
&qidentifier, iter, &class_decl, NULL);
if (ret) {
- _BT_LOGE_NODE(iter,
+ _BT_COMP_LOGE_NODE(iter,
"Cannot visit field class declarator: ret=%d", ret);
ret = -EINVAL;
goto end;
(void *) class_decl;
if (var_fc->tag_path.path->len == 0) {
- _BT_LOGE_NODE(iter,
+ _BT_COMP_LOGE_NODE(iter,
"Type definition of untagged variant field class is not allowed.");
ret = -EPERM;
goto end;
ret = ctx_decl_scope_register_alias(ctx, ctx->current_scope,
g_quark_to_string(qidentifier), class_decl);
if (ret) {
- _BT_LOGE_NODE(iter,
+ _BT_COMP_LOGE_NODE(iter,
"Cannot register field class alias: name=\"%s\"",
g_quark_to_string(qidentifier));
goto end;
&qdummy_field_name, node, &class_decl, NULL);
if (ret) {
BT_ASSERT(!class_decl);
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot visit field class declarator: ret=%d", ret);
goto end;
}
struct ctf_field_class_variant *var_fc = (void *) class_decl;
if (var_fc->tag_path.path->len == 0) {
- _BT_LOGE_NODE(target,
+ _BT_COMP_LOGE_NODE(target,
"Type definition of untagged variant field class 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_NODE(target,
+ _BT_COMP_LOGE_NODE(target,
"Expecting empty identifier: id=\"%s\"",
g_quark_to_string(qdummy_field_name));
ret = -EINVAL;
ret = ctx_decl_scope_register_alias(ctx, ctx->current_scope,
g_quark_to_string(qalias), class_decl);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot register class alias: name=\"%s\"",
g_quark_to_string(qalias));
goto end;
entry_node->u.field_class_def.field_class_specifier_list,
&entry_node->u.field_class_def.field_class_declarators);
if (ret) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Cannot add field class found in structure field class: ret=%d",
ret);
goto end;
ret = visit_field_class_alias(ctx, entry_node->u.field_class_alias.target,
entry_node->u.field_class_alias.alias);
if (ret) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Cannot add field class alias found in structure field class: ret=%d",
ret);
goto end;
}
break;
default:
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Unexpected node type: node-type=%d", entry_node->type);
ret = -EINVAL;
goto end;
entry_node->u.field_class_def.field_class_specifier_list,
&entry_node->u.field_class_def.field_class_declarators);
if (ret) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Cannot add field class found in variant field class: ret=%d",
ret);
goto end;
ret = visit_field_class_alias(ctx, entry_node->u.field_class_alias.target,
entry_node->u.field_class_alias.alias);
if (ret) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Cannot add field class alias found in variant field class: ret=%d",
ret);
goto end;
}
break;
default:
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Unexpected node type: node-type=%d",
entry_node->type);
ret = -EINVAL;
/* For named struct (without body), lookup in declaration scope */
if (!has_body) {
if (!name) {
- BT_LOGE_STR("Bodyless structure field class: missing name.");
+ BT_COMP_LOGE_STR("Bodyless structure field class: missing name.");
ret = -EPERM;
goto error;
}
*struct_decl = ctx_decl_scope_lookup_struct(ctx, ctx->current_scope,
name, -1, true);
if (!*struct_decl) {
- BT_LOGE("Cannot find structure field class: name=\"struct %s\"",
+ BT_COMP_LOGE("Cannot find structure field class: name=\"struct %s\"",
name);
ret = -EINVAL;
goto error;
if (name) {
if (ctx_decl_scope_lookup_struct(ctx,
ctx->current_scope, name, 1, false)) {
- BT_LOGE("Structure field class already declared in local scope: "
+ BT_COMP_LOGE("Structure field class already declared in local scope: "
"name=\"struct %s\"", name);
ret = -EINVAL;
goto error;
ret = get_unary_unsigned(ctx, min_align,
&min_align_value);
if (ret) {
- BT_LOGE("Unexpected unary expression for structure field class's `align` attribute: "
+ BT_COMP_LOGE("Unexpected unary expression for structure field class's `align` attribute: "
"ret=%d", ret);
goto error;
}
ret = visit_struct_decl_entry(ctx, entry_node,
*struct_decl);
if (ret) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Cannot visit structure field class entry: "
"ret=%d", ret);
ctx_pop_scope(ctx);
ret = ctx_decl_scope_register_struct(ctx,
ctx->current_scope, name, *struct_decl);
if (ret) {
- BT_LOGE("Cannot register structure field class in declaration scope: "
+ BT_COMP_LOGE("Cannot register structure field class in declaration scope: "
"name=\"struct %s\", ret=%d", name, ret);
goto error;
}
/* For named variant (without body), lookup in declaration scope */
if (!has_body) {
if (!name) {
- BT_LOGE_STR("Bodyless variant field class: missing name.");
+ BT_COMP_LOGE_STR("Bodyless variant field class: missing name.");
ret = -EPERM;
goto error;
}
ctx_decl_scope_lookup_variant(ctx, ctx->current_scope,
name, -1, true);
if (!untagged_variant_decl) {
- BT_LOGE("Cannot find variant field class: name=\"variant %s\"",
+ BT_COMP_LOGE("Cannot find variant field class: name=\"variant %s\"",
name);
ret = -EINVAL;
goto error;
if (name) {
if (ctx_decl_scope_lookup_variant(ctx,
ctx->current_scope, name, 1, false)) {
- BT_LOGE("Variant field class already declared in local scope: "
+ BT_COMP_LOGE("Variant field class already declared in local scope: "
"name=\"variant %s\"", name);
ret = -EINVAL;
goto error;
ret = visit_variant_decl_entry(ctx, entry_node,
untagged_variant_decl);
if (ret) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Cannot visit variant field class entry: "
"ret=%d", ret);
ctx_pop_scope(ctx);
ctx->current_scope, name,
untagged_variant_decl);
if (ret) {
- BT_LOGE("Cannot register variant field class in declaration scope: "
+ BT_COMP_LOGE("Cannot register variant field class in declaration scope: "
"name=\"variant %s\", ret=%d", name, ret);
goto error;
}
struct uori *target;
if (iter->type != NODE_UNARY_EXPRESSION) {
- _BT_LOGE_NODE(iter,
+ _BT_COMP_LOGE_NODE(iter,
"Wrong expression for enumeration field class label: "
"node-type=%d, label=\"%s\"", iter->type,
label);
iter->u.unary_expression.u.unsigned_constant;
break;
default:
- _BT_LOGE_NODE(iter,
+ _BT_COMP_LOGE_NODE(iter,
"Invalid enumeration field class entry: "
"expecting constant signed or unsigned integer: "
"node-type=%d, label=\"%s\"",
}
if (nr_vals > 1) {
- _BT_LOGE_NODE(iter,
+ _BT_COMP_LOGE_NODE(iter,
"Invalid enumeration field class entry: label=\"%s\"",
label);
ret = -EINVAL;
/* For named enum (without body), lookup in declaration scope */
if (!has_body) {
if (!name) {
- BT_LOGE_STR("Bodyless enumeration field class: missing name.");
+ BT_COMP_LOGE_STR("Bodyless enumeration field class: missing name.");
ret = -EPERM;
goto error;
}
*enum_decl = ctx_decl_scope_lookup_enum(ctx, ctx->current_scope,
name, -1, true);
if (!*enum_decl) {
- BT_LOGE("Cannot find enumeration field class: "
+ BT_COMP_LOGE("Cannot find enumeration field class: "
"name=\"enum %s\"", name);
ret = -EINVAL;
goto error;
if (name) {
if (ctx_decl_scope_lookup_enum(ctx, ctx->current_scope,
name, 1, false)) {
- BT_LOGE("Enumeration field class already declared in local scope: "
+ BT_COMP_LOGE("Enumeration field class already declared in local scope: "
"name=\"enum %s\"", name);
ret = -EINVAL;
goto error;
integer_decl = (void *) ctx_decl_scope_lookup_alias(ctx,
ctx->current_scope, "int", -1, true);
if (!integer_decl) {
- BT_LOGE_STR("Cannot find implicit `int` field class alias for enumeration field class.");
+ BT_COMP_LOGE_STR("Cannot find implicit `int` field class alias for enumeration field class.");
ret = -EINVAL;
goto error;
}
BT_ASSERT(integer_decl);
if (integer_decl->base.base.type != CTF_FIELD_CLASS_TYPE_INT) {
- BT_LOGE("Container field class for enumeration field class is not an integer field class: "
+ BT_COMP_LOGE("Container field class for enumeration field class is not an integer field class: "
"fc-type=%d", integer_decl->base.base.type);
ret = -EINVAL;
goto error;
ret = visit_enum_decl_entry(ctx, iter, *enum_decl,
&last_value);
if (ret) {
- _BT_LOGE_NODE(iter,
+ _BT_COMP_LOGE_NODE(iter,
"Cannot visit enumeration field class entry: "
"ret=%d", ret);
goto error;
ret = ctx_decl_scope_register_enum(ctx,
ctx->current_scope, name, *enum_decl);
if (ret) {
- BT_LOGE("Cannot register enumeration field class in declaration scope: "
+ BT_COMP_LOGE("Cannot register enumeration field class in declaration scope: "
"ret=%d", ret);
goto error;
}
str = g_string_new("");
ret = get_class_specifier_list_name(ctx, cls_specifier_list, str);
if (ret) {
- _BT_LOGE_NODE(cls_specifier_list,
+ _BT_COMP_LOGE_NODE(cls_specifier_list,
"Cannot get field class specifier list's name: ret=%d", ret);
goto error;
}
*decl = ctx_decl_scope_lookup_alias(ctx, ctx->current_scope, str->str,
-1, true);
if (!*decl) {
- _BT_LOGE_NODE(cls_specifier_list,
+ _BT_COMP_LOGE_NODE(cls_specifier_list,
"Cannot find field class alias: name=\"%s\"", str->str);
ret = -EINVAL;
goto error;
siblings);
if (left->u.unary_expression.type != UNARY_STRING) {
- _BT_LOGE_NODE(left,
+ _BT_COMP_LOGE_NODE(left,
"Unexpected unary expression type: type=%d",
left->u.unary_expression.type);
ret = -EINVAL;
if (!strcmp(left->u.unary_expression.u.string, "signed")) {
if (_IS_SET(&set, _INTEGER_SIGNED_SET)) {
- _BT_LOGE_DUP_ATTR(left, "signed",
+ _BT_COMP_LOGE_DUP_ATTR(left, "signed",
"integer field class");
ret = -EPERM;
goto error;
signedness = get_boolean(ctx, right);
if (signedness < 0) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid boolean value for integer field class's `signed` attribute: "
"ret=%d", ret);
ret = -EINVAL;
} else if (!strcmp(left->u.unary_expression.u.string,
"byte_order")) {
if (_IS_SET(&set, _INTEGER_BYTE_ORDER_SET)) {
- _BT_LOGE_DUP_ATTR(left, "byte_order",
+ _BT_COMP_LOGE_DUP_ATTR(left, "byte_order",
"integer field class");
ret = -EPERM;
goto error;
byte_order = get_real_byte_order(ctx, right);
if (byte_order == -1) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `byte_order` attribute in integer field class: "
"ret=%d", ret);
ret = -EINVAL;
_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(left, "size",
+ _BT_COMP_LOGE_DUP_ATTR(left, "size",
"integer field class");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `size` attribute in integer field class: "
"expecting unsigned constant integer: "
"node-type=%d",
size = right->u.unary_expression.u.unsigned_constant;
if (size == 0) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `size` attribute in integer field class: "
"expecting positive constant integer: "
"size=%" PRIu64, size);
ret = -EINVAL;
goto error;
} else if (size > 64) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `size` attribute in integer field class: "
"integer fields over 64 bits are not supported as of this version: "
"size=%" PRIu64, size);
} else if (!strcmp(left->u.unary_expression.u.string,
"align")) {
if (_IS_SET(&set, _INTEGER_ALIGN_SET)) {
- _BT_LOGE_DUP_ATTR(left, "align",
+ _BT_COMP_LOGE_DUP_ATTR(left, "align",
"integer field class");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `align` attribute in integer field class: "
"expecting unsigned constant integer: "
"node-type=%d",
alignment =
right->u.unary_expression.u.unsigned_constant;
if (!is_align_valid(alignment)) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `align` attribute in integer field class: "
"expecting power of two: "
"align=%" PRIu64, alignment);
_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(left, "base",
+ _BT_COMP_LOGE_DUP_ATTR(left, "base",
"integer field class");
ret = -EPERM;
goto error;
base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL;
break;
default:
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `base` attribute in integer field class: "
"base=%" PRIu64,
right->u.unary_expression.u.unsigned_constant);
char *s_right = concatenate_unary_strings(
&expression->u.ctf_expression.right);
if (!s_right) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Unexpected unary expression for integer field class's `base` attribute.");
ret = -EINVAL;
goto error;
!strcmp(s_right, "b")) {
base = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY;
} else {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Unexpected unary expression for integer field class's `base` attribute: "
"base=\"%s\"", s_right);
g_free(s_right);
break;
}
default:
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `base` attribute in integer field class: "
"expecting unsigned constant integer or unary string.");
ret = -EINVAL;
char *s_right;
if (_IS_SET(&set, _INTEGER_ENCODING_SET)) {
- _BT_LOGE_DUP_ATTR(left, "encoding",
+ _BT_COMP_LOGE_DUP_ATTR(left, "encoding",
"integer field class");
ret = -EPERM;
goto error;
}
if (right->u.unary_expression.type != UNARY_STRING) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `encoding` attribute in integer field class: "
"expecting unary string.");
ret = -EINVAL;
s_right = concatenate_unary_strings(
&expression->u.ctf_expression.right);
if (!s_right) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Unexpected unary expression for integer field class's `encoding` attribute.");
ret = -EINVAL;
goto error;
} else if (!strcmp(s_right, "none")) {
encoding = CTF_ENCODING_NONE;
} else {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `encoding` attribute in integer field class: "
"unknown encoding: encoding=\"%s\"",
s_right);
const char *clock_name;
if (_IS_SET(&set, _INTEGER_MAP_SET)) {
- _BT_LOGE_DUP_ATTR(left, "map",
+ _BT_COMP_LOGE_DUP_ATTR(left, "map",
"integer field class");
ret = -EPERM;
goto error;
}
if (right->u.unary_expression.type != UNARY_STRING) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `map` attribute in integer field class: "
"expecting unary string.");
ret = -EINVAL;
&expression->u.ctf_expression.right);
if (!s_right) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Unexpected unary expression for integer field class's `map` attribute.");
ret = -EINVAL;
goto error;
}
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `map` attribute in integer field class: "
"cannot find clock class at this point: name=\"%s\"",
s_right);
ctf_trace_class_borrow_clock_class_by_name(
ctx->ctf_tc, clock_name);
if (!mapped_clock_class) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `map` attribute in integer field class: "
"cannot find clock class at this point: name=\"%s\"",
clock_name);
_SET(&set, _INTEGER_MAP_SET);
} else {
- _BT_LOGW_NODE(left,
+ _BT_COMP_LOGW_NODE(left,
"Unknown attribute in integer field class: "
"attr-name=\"%s\"",
left->u.unary_expression.u.string);
}
if (!_IS_SET(&set, _INTEGER_SIZE_SET)) {
- BT_LOGE_STR("Missing `size` attribute in integer field class.");
+ BT_COMP_LOGE_STR("Missing `size` attribute in integer field class.");
ret = -EPERM;
goto error;
}
siblings);
if (left->u.unary_expression.type != UNARY_STRING) {
- _BT_LOGE_NODE(left,
+ _BT_COMP_LOGE_NODE(left,
"Unexpected unary expression type: type=%d",
left->u.unary_expression.type);
ret = -EINVAL;
if (!strcmp(left->u.unary_expression.u.string, "byte_order")) {
if (_IS_SET(&set, _FLOAT_BYTE_ORDER_SET)) {
- _BT_LOGE_DUP_ATTR(left, "byte_order",
+ _BT_COMP_LOGE_DUP_ATTR(left, "byte_order",
"floating point number field class");
ret = -EPERM;
goto error;
byte_order = get_real_byte_order(ctx, right);
if (byte_order == -1) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `byte_order` attribute in floating point number field class: "
"ret=%d", ret);
ret = -EINVAL;
} else if (!strcmp(left->u.unary_expression.u.string,
"exp_dig")) {
if (_IS_SET(&set, _FLOAT_EXP_DIG_SET)) {
- _BT_LOGE_DUP_ATTR(left, "exp_dig",
+ _BT_COMP_LOGE_DUP_ATTR(left, "exp_dig",
"floating point number field class");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `exp_dig` attribute in floating point number field class: "
"expecting unsigned constant integer: "
"node-type=%d",
} else if (!strcmp(left->u.unary_expression.u.string,
"mant_dig")) {
if (_IS_SET(&set, _FLOAT_MANT_DIG_SET)) {
- _BT_LOGE_DUP_ATTR(left, "mant_dig",
+ _BT_COMP_LOGE_DUP_ATTR(left, "mant_dig",
"floating point number field class");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `mant_dig` attribute in floating point number field class: "
"expecting unsigned constant integer: "
"node-type=%d",
} else if (!strcmp(left->u.unary_expression.u.string,
"align")) {
if (_IS_SET(&set, _FLOAT_ALIGN_SET)) {
- _BT_LOGE_DUP_ATTR(left, "align",
+ _BT_COMP_LOGE_DUP_ATTR(left, "align",
"floating point number field class");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `align` attribute in floating point number field class: "
"expecting unsigned constant integer: "
"node-type=%d",
unsigned_constant;
if (!is_align_valid(alignment)) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `align` attribute in floating point number field class: "
"expecting power of two: "
"align=%" PRIu64, alignment);
_SET(&set, _FLOAT_ALIGN_SET);
} else {
- _BT_LOGW_NODE(left,
+ _BT_COMP_LOGW_NODE(left,
"Unknown attribute in floating point number field class: "
"attr-name=\"%s\"",
left->u.unary_expression.u.string);
}
if (!_IS_SET(&set, _FLOAT_MANT_DIG_SET)) {
- BT_LOGE_STR("Missing `mant_dig` attribute in floating point number field class.");
+ BT_COMP_LOGE_STR("Missing `mant_dig` attribute in floating point number field class.");
ret = -EPERM;
goto error;
}
if (!_IS_SET(&set, _FLOAT_EXP_DIG_SET)) {
- BT_LOGE_STR("Missing `exp_dig` attribute in floating point number field class.");
+ BT_COMP_LOGE_STR("Missing `exp_dig` attribute in floating point number field class.");
ret = -EPERM;
goto error;
}
if (mant_dig != 24 && mant_dig != 53) {
- BT_LOGE_STR("`mant_dig` attribute: expecting 24 or 53.");
+ BT_COMP_LOGE_STR("`mant_dig` attribute: expecting 24 or 53.");
ret = -EPERM;
goto error;
}
if (mant_dig == 24 && exp_dig != 8) {
- BT_LOGE_STR("`exp_dig` attribute: expecting 8 because `mant_dig` is 24.");
+ BT_COMP_LOGE_STR("`exp_dig` attribute: expecting 8 because `mant_dig` is 24.");
ret = -EPERM;
goto error;
}
if (mant_dig == 53 && exp_dig != 11) {
- BT_LOGE_STR("`exp_dig` attribute: expecting 11 because `mant_dig` is 53.");
+ BT_COMP_LOGE_STR("`exp_dig` attribute: expecting 11 because `mant_dig` is 53.");
ret = -EPERM;
goto error;
}
siblings);
if (left->u.unary_expression.type != UNARY_STRING) {
- _BT_LOGE_NODE(left,
+ _BT_COMP_LOGE_NODE(left,
"Unexpected unary expression type: type=%d",
left->u.unary_expression.type);
ret = -EINVAL;
char *s_right;
if (_IS_SET(&set, _STRING_ENCODING_SET)) {
- _BT_LOGE_DUP_ATTR(left, "encoding",
+ _BT_COMP_LOGE_DUP_ATTR(left, "encoding",
"string field class");
ret = -EPERM;
goto error;
}
if (right->u.unary_expression.type != UNARY_STRING) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `encoding` attribute in string field class: "
"expecting unary string.");
ret = -EINVAL;
s_right = concatenate_unary_strings(
&expression->u.ctf_expression.right);
if (!s_right) {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Unexpected unary expression for string field class's `encoding` attribute.");
ret = -EINVAL;
goto error;
} else if (!strcmp(s_right, "none")) {
encoding = CTF_ENCODING_NONE;
} else {
- _BT_LOGE_NODE(right,
+ _BT_COMP_LOGE_NODE(right,
"Invalid `encoding` attribute in string field class: "
"unknown encoding: encoding=\"%s\"",
s_right);
g_free(s_right);
_SET(&set, _STRING_ENCODING_SET);
} else {
- _BT_LOGW_NODE(left,
+ _BT_COMP_LOGW_NODE(left,
"Unknown attribute in string field class: "
"attr-name=\"%s\"",
left->u.unary_expression.u.string);
*decl = NULL;
if (ts_list->type != NODE_TYPE_SPECIFIER_LIST) {
- _BT_LOGE_NODE(ts_list,
+ _BT_COMP_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.field_class_specifier_list.head,
struct ctf_node, siblings);
if (first->type != NODE_TYPE_SPECIFIER) {
- _BT_LOGE_NODE(first,
+ _BT_COMP_LOGE_NODE(first,
"Unexpected node type: node-type=%d", first->type);
ret = -EINVAL;
goto error;
case TYPESPEC_ID_TYPE:
ret = visit_field_class_specifier(ctx, ts_list, decl);
if (ret) {
- _BT_LOGE_NODE(first,
+ _BT_COMP_LOGE_NODE(first,
"Cannot visit field class specifier: ret=%d",
ret);
BT_ASSERT(!*decl);
}
break;
default:
- _BT_LOGE_NODE(first,
+ _BT_COMP_LOGE_NODE(first,
"Unexpected field class specifier type: node-type=%d",
first->u.field_class_specifier.type);
ret = -EINVAL;
ret = visit_field_class_def(ctx, node->u.field_class_def.field_class_specifier_list,
&node->u.field_class_def.field_class_declarators);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot add field class found in event class.");
goto error;
}
ret = visit_field_class_alias(ctx, node->u.field_class_alias.target,
node->u.field_class_alias.alias);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot add field class alias found in event class.");
goto error;
}
{
left = concatenate_unary_strings(&node->u.ctf_expression.left);
if (!left) {
- _BT_LOGE_NODE(node, "Cannot concatenate unary strings.");
+ _BT_COMP_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(node, "name", "event class");
+ _BT_COMP_LOGE_DUP_ATTR(node, "name", "event class");
ret = -EPERM;
goto error;
}
int64_t id = -1;
if (_IS_SET(set, _EVENT_ID_SET)) {
- _BT_LOGE_DUP_ATTR(node, "id", "event class");
+ _BT_COMP_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_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Unexpected unary expression for event class's `id` attribute.");
ret = -EINVAL;
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(node, "stream_id",
+ _BT_COMP_LOGE_DUP_ATTR(node, "stream_id",
"event class");
ret = -EPERM;
goto error;
* succeeded.
*/
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_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_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Duplicate `context` entry in event class.");
ret = -EPERM;
goto error;
struct ctf_node, siblings),
&event_class->spec_context_fc);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot create event class's context field class.");
goto error;
}
_SET(set, _EVENT_CONTEXT_SET);
} else if (!strcmp(left, "fields")) {
if (_IS_SET(set, _EVENT_FIELDS_SET)) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Duplicate `fields` entry in event class.");
ret = -EPERM;
goto error;
struct ctf_node, siblings),
&event_class->payload_fc);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot create event class's payload field class.");
goto error;
}
bt_event_class_log_level log_level = -1;
if (_IS_SET(set, _EVENT_LOG_LEVEL_SET)) {
- _BT_LOGE_DUP_ATTR(node, "loglevel",
+ _BT_COMP_LOGE_DUP_ATTR(node, "loglevel",
"event class");
ret = -EPERM;
goto error;
ret = get_unary_unsigned(ctx,
&node->u.ctf_expression.right, &loglevel_value);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Unexpected unary expression for event class's `loglevel` attribute.");
ret = -EINVAL;
goto error;
log_level = BT_EVENT_CLASS_LOG_LEVEL_DEBUG;
break;
default:
- _BT_LOGW_NODE(node, "Not setting event class's log level because its value is unknown: "
+ _BT_COMP_LOGW_NODE(node, "Not setting event class's log level because its value is unknown: "
"log-level=%" PRIu64, loglevel_value);
}
char *right;
if (_IS_SET(set, _EVENT_MODEL_EMF_URI_SET)) {
- _BT_LOGE_DUP_ATTR(node, "model.emf.uri",
+ _BT_COMP_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_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Unexpected unary expression for event class's `model.emf.uri` attribute.");
ret = -EINVAL;
goto error;
}
if (strlen(right) == 0) {
- _BT_LOGW_NODE(node,
+ _BT_COMP_LOGW_NODE(node,
"Not setting event class's EMF URI because it's empty.");
} else {
g_string_assign(event_class->emf_uri,
g_free(right);
_SET(set, _EVENT_MODEL_EMF_URI_SET);
} else {
- _BT_LOGW_NODE(node,
+ _BT_COMP_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,
+ _BT_COMP_LOGE_NODE(iter,
"Cannot concatenate unary strings.");
goto error;
}
name = concatenate_unary_strings(
&iter->u.ctf_expression.right);
if (!name) {
- _BT_LOGE_NODE(iter,
+ _BT_COMP_LOGE_NODE(iter,
"Unexpected unary expression for event class's `name` attribute.");
goto error;
}
node->visited = TRUE;
event_name = get_event_decl_name(ctx, node);
if (!event_name) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Missing `name` attribute in event class.");
ret = -EPERM;
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: "
+ _BT_COMP_LOGE_NODE(iter, "Cannot visit event class's entry: "
"ret=%d", ret);
goto error;
}
stream_id = stream_class->id;
break;
default:
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Missing `stream_id` attribute in event class.");
ret = -EPERM;
goto error;
stream_class = ctf_trace_class_borrow_stream_class_by_id(
ctx->ctf_tc, stream_id);
if (!stream_class) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot find stream class at this point: "
"id=%" PRId64, stream_id);
ret = -EINVAL;
if (!_IS_SET(&set, _EVENT_ID_SET)) {
/* Allow only one event without ID per stream */
if (stream_class->event_classes->len != 0) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Missing `id` attribute in event class.");
ret = -EPERM;
goto error;
if (ctf_stream_class_borrow_event_class_by_id(stream_class,
event_class->id)) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Duplicate event class (same ID) in the same stream class: "
"id=%" PRId64, event_class->id);
ret = -EEXIST;
* 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, "
+ BT_COMP_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;
ret = auto_map_field_to_trace_clock_class(ctx,
named_fc->fc);
if (ret) {
- BT_LOGE("Cannot automatically map field to trace's clock class: "
+ BT_COMP_LOGE("Cannot automatically map field to trace's clock class: "
"field-name=\"%s\"", field_name);
goto end;
}
ret = auto_map_fields_to_trace_clock_class(ctx, named_fc->fc,
field_name);
if (ret) {
- BT_LOGE("Cannot automatically map structure or variant field class's fields to trace's clock class: "
+ BT_COMP_LOGE("Cannot automatically map structure or variant field class's fields to trace's clock class: "
"field-name=\"%s\", root-field-name=\"%s\"",
field_name, named_fc->name->str);
goto end;
ret = visit_field_class_def(ctx, node->u.field_class_def.field_class_specifier_list,
&node->u.field_class_def.field_class_declarators);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot add field class found in stream class.");
goto error;
}
ret = visit_field_class_alias(ctx, node->u.field_class_alias.target,
node->u.field_class_alias.alias);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot add field class alias found in stream class.");
goto error;
}
{
left = concatenate_unary_strings(&node->u.ctf_expression.left);
if (!left) {
- _BT_LOGE_NODE(node, "Cannot concatenate unary strings.");
+ _BT_COMP_LOGE_NODE(node, "Cannot concatenate unary strings.");
ret = -EINVAL;
goto error;
}
int64_t id;
if (_IS_SET(set, _STREAM_ID_SET)) {
- _BT_LOGE_DUP_ATTR(node, "id",
+ _BT_COMP_LOGE_DUP_ATTR(node, "id",
"stream declaration");
ret = -EPERM;
goto error;
/* Only read "id" if get_unary_unsigned() succeeded. */
if (ret || (!ret && id < 0)) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Unexpected unary expression for stream class's `id` attribute.");
ret = -EINVAL;
goto error;
if (ctf_trace_class_borrow_stream_class_by_id(
ctx->ctf_tc, id)) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Duplicate stream class (same ID): id=%" PRId64,
id);
ret = -EEXIST;
_SET(set, _STREAM_ID_SET);
} else if (!strcmp(left, "event.header")) {
if (_IS_SET(set, _STREAM_EVENT_HEADER_SET)) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Duplicate `event.header` entry in stream class.");
ret = -EPERM;
goto error;
struct ctf_node, siblings),
&stream_class->event_header_fc);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot create stream class's event header field class.");
goto error;
}
ret = auto_map_fields_to_trace_clock_class(ctx,
stream_class->event_header_fc, "timestamp");
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot automatically map specific event header field class fields named `timestamp` to trace's clock class.");
goto error;
}
_SET(set, _STREAM_EVENT_HEADER_SET);
} else if (!strcmp(left, "event.context")) {
if (_IS_SET(set, _STREAM_EVENT_CONTEXT_SET)) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Duplicate `event.context` entry in stream class.");
ret = -EPERM;
goto error;
struct ctf_node, siblings),
&stream_class->event_common_context_fc);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot create stream class's event context field class.");
goto error;
}
_SET(set, _STREAM_EVENT_CONTEXT_SET);
} else if (!strcmp(left, "packet.context")) {
if (_IS_SET(set, _STREAM_PACKET_CONTEXT_SET)) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Duplicate `packet.context` entry in stream class.");
ret = -EPERM;
goto error;
struct ctf_node, siblings),
&stream_class->packet_context_fc);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot create stream class's packet context field class.");
goto error;
}
stream_class->packet_context_fc,
"timestamp_begin");
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot automatically map specific packet context field class fields named `timestamp_begin` to trace's clock class.");
goto error;
}
stream_class->packet_context_fc,
"timestamp_end");
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot automatically map specific packet context field class fields named `timestamp_end` to trace's clock class.");
goto error;
}
_SET(set, _STREAM_PACKET_CONTEXT_SET);
} else {
- _BT_LOGW_NODE(node,
+ _BT_COMP_LOGW_NODE(node,
"Unknown attribute in stream class: "
"attr-name=\"%s\"", left);
}
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,
+ _BT_COMP_LOGE_NODE(iter,
"Cannot visit stream class's entry: "
"ret=%d", ret);
ctx_pop_scope(ctx);
struct ctf_named_field_class *named_fc = NULL;
if (!ctx->ctf_tc->packet_header_fc) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Stream class has a `id` attribute, "
"but trace has no packet header field class.");
goto error;
named_fc = ctf_field_class_struct_borrow_member_by_name(
(void *) ctx->ctf_tc->packet_header_fc, "stream_id");
if (!named_fc) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Stream class has a `id` attribute, "
"but trace's packet header field class has no `stream_id` field.");
goto error;
if (named_fc->fc->type != CTF_FIELD_CLASS_TYPE_INT &&
named_fc->fc->type != CTF_FIELD_CLASS_TYPE_ENUM) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Stream class has a `id` attribute, "
"but trace's packet header field class's `stream_id` field is not an integer field class.");
goto error;
} else {
/* Allow only _one_ ID-less stream */
if (ctx->ctf_tc->stream_classes->len != 0) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Missing `id` attribute in stream class as there's more than one stream class in the trace.");
ret = -EPERM;
goto error;
*/
if (ctf_trace_class_borrow_stream_class_by_id(ctx->ctf_tc,
stream_class->id)) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Duplicate stream class (same ID): id=%" PRId64,
stream_class->id);
ret = -EINVAL;
ret = visit_field_class_def(ctx, node->u.field_class_def.field_class_specifier_list,
&node->u.field_class_def.field_class_declarators);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot add field class found in trace (`trace` block).");
goto error;
}
ret = visit_field_class_alias(ctx, node->u.field_class_alias.target,
node->u.field_class_alias.alias);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot add field class alias found in trace (`trace` block).");
goto error;
}
{
left = concatenate_unary_strings(&node->u.ctf_expression.left);
if (!left) {
- _BT_LOGE_NODE(node, "Cannot concatenate unary strings.");
+ _BT_COMP_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(node, "major", "trace");
+ _BT_COMP_LOGE_DUP_ATTR(node, "major", "trace");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(ctx,
&node->u.ctf_expression.right, &val);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Unexpected unary expression for trace's `major` attribute.");
ret = -EINVAL;
goto error;
}
if (val != 1) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Invalid trace's `minor` attribute: expecting 1.");
goto error;
}
_SET(set, _TRACE_MAJOR_SET);
} else if (!strcmp(left, "minor")) {
if (_IS_SET(set, _TRACE_MINOR_SET)) {
- _BT_LOGE_DUP_ATTR(node, "minor", "trace");
+ _BT_COMP_LOGE_DUP_ATTR(node, "minor", "trace");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(ctx,
&node->u.ctf_expression.right, &val);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Unexpected unary expression for trace's `minor` attribute.");
ret = -EINVAL;
goto error;
}
if (val != 8) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Invalid trace's `minor` attribute: expecting 8.");
goto error;
}
_SET(set, _TRACE_MINOR_SET);
} else if (!strcmp(left, "uuid")) {
if (_IS_SET(set, _TRACE_UUID_SET)) {
- _BT_LOGE_DUP_ATTR(node, "uuid", "trace");
+ _BT_COMP_LOGE_DUP_ATTR(node, "uuid", "trace");
ret = -EPERM;
goto error;
}
&node->u.ctf_expression.right,
ctx->ctf_tc->uuid);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Invalid trace's `uuid` attribute.");
goto error;
}
} else if (!strcmp(left, "byte_order")) {
/* Default byte order is already known at this stage */
if (_IS_SET(set, _TRACE_BYTE_ORDER_SET)) {
- _BT_LOGE_DUP_ATTR(node, "byte_order",
+ _BT_COMP_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_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Duplicate `packet.header` entry in trace.");
ret = -EPERM;
goto error;
struct ctf_node, siblings),
&ctx->ctf_tc->packet_header_fc);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Cannot create trace's packet header field class.");
goto error;
}
BT_ASSERT(ctx->ctf_tc->packet_header_fc);
_SET(set, _TRACE_PACKET_HEADER_SET);
} else {
- _BT_LOGW_NODE(node,
+ _BT_COMP_LOGW_NODE(node,
"Unknown attribute in stream class: "
"attr-name=\"%s\"", left);
}
break;
}
default:
- _BT_LOGE_NODE(node, "Unknown expression in trace.");
+ _BT_COMP_LOGE_NODE(node, "Unknown expression in trace.");
ret = -EINVAL;
goto error;
}
node->visited = TRUE;
if (ctx->is_trace_visited) {
- _BT_LOGE_NODE(node, "Duplicate trace (`trace` block).");
+ _BT_COMP_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): "
+ _BT_COMP_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_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Missing `major` attribute in trace (`trace` block).");
ret = -EPERM;
goto error;
}
if (!_IS_SET(&set, _TRACE_MINOR_SET)) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Missing `minor` attribute in trace (`trace` block).");
ret = -EPERM;
goto error;
}
if (!_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_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_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Wrong expression in environment entry: "
"node-type=%d", entry_node->type);
ret = -EPERM;
left = concatenate_unary_strings(
&entry_node->u.ctf_expression.left);
if (!left) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_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_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Unexpected unary expression for environment entry's value: "
"name=\"%s\"", left);
ret = -EINVAL;
if (strcmp(left, "tracer_name") == 0) {
if (strncmp(right, "lttng", 5) == 0) {
- BT_LOGI("Detected LTTng trace from `%s` environment value: "
+ BT_COMP_LOGI("Detected LTTng trace from `%s` environment value: "
"tracer-name=\"%s\"",
left, right);
ctx->is_lttng = true;
ret = get_unary_signed(right_head, &v);
}
if (ret) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Unexpected unary expression for environment entry's value: "
"name=\"%s\"", left);
ret = -EINVAL;
left, CTF_TRACE_CLASS_ENV_ENTRY_TYPE_INT,
NULL, v);
} else {
- _BT_LOGW_NODE(entry_node,
+ _BT_COMP_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,
+ _BT_COMP_LOGE_NODE(node,
"Cannot concatenate unary strings.");
ret = -EINVAL;
goto error;
enum ctf_byte_order bo;
if (_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
- _BT_LOGE_DUP_ATTR(node, "byte_order",
+ _BT_COMP_LOGE_DUP_ATTR(node, "byte_order",
"trace");
ret = -EPERM;
goto error;
bo = byte_order_from_unary_expr(ctx,
right_node);
if (bo == -1) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Invalid `byte_order` attribute in trace (`trace` block): "
"expecting `le`, `be`, or `network`.");
ret = -EINVAL;
goto error;
} else if (bo == CTF_BYTE_ORDER_DEFAULT) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Invalid `byte_order` attribute in trace (`trace` block): "
"cannot be set to `native` here.");
ret = -EPERM;
}
if (!_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
- _BT_LOGE_NODE(trace_node,
+ _BT_COMP_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,
+ _BT_COMP_LOGE_NODE(entry_node,
"Unexpected node type: node-type=%d",
entry_node->type);
ret = -EPERM;
left = concatenate_unary_strings(&entry_node->u.ctf_expression.left);
if (!left) {
- _BT_LOGE_NODE(entry_node, "Cannot concatenate unary strings.");
+ _BT_COMP_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(entry_node, "name", "clock class");
+ _BT_COMP_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_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Unexpected unary expression for clock class's `name` attribute.");
ret = -EINVAL;
goto error;
uint8_t uuid[BABELTRACE_UUID_LEN];
if (_IS_SET(set, _CLOCK_UUID_SET)) {
- _BT_LOGE_DUP_ATTR(entry_node, "uuid", "clock class");
+ _BT_COMP_LOGE_DUP_ATTR(entry_node, "uuid", "clock class");
ret = -EPERM;
goto error;
}
ret = get_unary_uuid(ctx, &entry_node->u.ctf_expression.right,
uuid);
if (ret) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Invalid clock class's `uuid` attribute.");
goto error;
}
char *right;
if (_IS_SET(set, _CLOCK_DESCRIPTION_SET)) {
- _BT_LOGE_DUP_ATTR(entry_node, "description",
+ _BT_COMP_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_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Unexpected unary expression for clock class's `description` attribute.");
ret = -EINVAL;
goto error;
uint64_t freq = UINT64_C(-1);
if (_IS_SET(set, _CLOCK_FREQ_SET)) {
- _BT_LOGE_DUP_ATTR(entry_node, "freq", "clock class");
+ _BT_COMP_LOGE_DUP_ATTR(entry_node, "freq", "clock class");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(ctx,
&entry_node->u.ctf_expression.right, &freq);
if (ret) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Unexpected unary expression for clock class's `freq` attribute.");
ret = -EINVAL;
goto error;
}
if (freq == UINT64_C(-1) || freq == 0) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Invalid clock class frequency: freq=%" PRIu64,
freq);
ret = -EINVAL;
uint64_t precision;
if (_IS_SET(set, _CLOCK_PRECISION_SET)) {
- _BT_LOGE_DUP_ATTR(entry_node, "precision",
+ _BT_COMP_LOGE_DUP_ATTR(entry_node, "precision",
"clock class");
ret = -EPERM;
goto error;
ret = get_unary_unsigned(ctx,
&entry_node->u.ctf_expression.right, &precision);
if (ret) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Unexpected unary expression for clock class's `precision` attribute.");
ret = -EINVAL;
goto error;
_SET(set, _CLOCK_PRECISION_SET);
} else if (!strcmp(left, "offset_s")) {
if (_IS_SET(set, _CLOCK_OFFSET_S_SET)) {
- _BT_LOGE_DUP_ATTR(entry_node, "offset_s",
+ _BT_COMP_LOGE_DUP_ATTR(entry_node, "offset_s",
"clock class");
ret = -EPERM;
goto error;
ret = get_unary_signed(
&entry_node->u.ctf_expression.right, offset_seconds);
if (ret) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Unexpected unary expression for clock class's `offset_s` attribute.");
ret = -EINVAL;
goto error;
_SET(set, _CLOCK_OFFSET_S_SET);
} else if (!strcmp(left, "offset")) {
if (_IS_SET(set, _CLOCK_OFFSET_SET)) {
- _BT_LOGE_DUP_ATTR(entry_node, "offset", "clock class");
+ _BT_COMP_LOGE_DUP_ATTR(entry_node, "offset", "clock class");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(ctx,
&entry_node->u.ctf_expression.right, offset_cycles);
if (ret) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Unexpected unary expression for clock class's `offset` attribute.");
ret = -EINVAL;
goto error;
struct ctf_node *right;
if (_IS_SET(set, _CLOCK_ABSOLUTE_SET)) {
- _BT_LOGE_DUP_ATTR(entry_node, "absolute",
+ _BT_COMP_LOGE_DUP_ATTR(entry_node, "absolute",
"clock class");
ret = -EPERM;
goto error;
struct ctf_node, siblings);
ret = get_boolean(ctx, right);
if (ret < 0) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Unexpected unary expression for clock class's `absolute` attribute.");
ret = -EINVAL;
goto error;
clock->is_absolute = ret;
_SET(set, _CLOCK_ABSOLUTE_SET);
} else {
- _BT_LOGW_NODE(entry_node,
+ _BT_COMP_LOGW_NODE(entry_node,
"Unknown attribute in clock class: attr-name=\"%s\"",
left);
}
/* CTF 1.8's default frequency for a clock class is 1 GHz */
clock = ctf_clock_class_create();
if (!clock) {
- _BT_LOGE_NODE(clock_node,
+ _BT_COMP_LOGE_NODE(clock_node,
"Cannot create default clock class.");
ret = -ENOMEM;
goto end;
ret = visit_clock_decl_entry(ctx, entry_node, clock, &set,
&offset_seconds, &offset_cycles);
if (ret) {
- _BT_LOGE_NODE(entry_node,
+ _BT_COMP_LOGE_NODE(entry_node,
"Cannot visit clock class's entry: ret=%d",
ret);
goto end;
}
if (!_IS_SET(&set, _CLOCK_NAME_SET)) {
- _BT_LOGE_NODE(clock_node,
+ _BT_COMP_LOGE_NODE(clock_node,
"Missing `name` attribute in clock class.");
ret = -EPERM;
goto end;
root_decl_node->u.field_class_def.field_class_specifier_list,
&root_decl_node->u.field_class_def.field_class_declarators);
if (ret) {
- _BT_LOGE_NODE(root_decl_node,
+ _BT_COMP_LOGE_NODE(root_decl_node,
"Cannot add field class found in root scope.");
goto end;
}
ret = visit_field_class_alias(ctx, root_decl_node->u.field_class_alias.target,
root_decl_node->u.field_class_alias.alias);
if (ret) {
- _BT_LOGE_NODE(root_decl_node,
+ _BT_COMP_LOGE_NODE(root_decl_node,
"Cannot add field class alias found in root scope.");
goto end;
}
*/
ret = visit_field_class_specifier_list(ctx, root_decl_node, &decl);
if (ret) {
- _BT_LOGE_NODE(root_decl_node,
+ _BT_COMP_LOGE_NODE(root_decl_node,
"Cannot visit root scope's field class: "
"ret=%d", ret);
BT_ASSERT(!decl);
break;
}
default:
- _BT_LOGE_NODE(root_decl_node,
+ _BT_COMP_LOGE_NODE(root_decl_node,
"Unexpected node type: node-type=%d",
root_decl_node->type);
ret = -EPERM;
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(self_comp, decoder_config);
+ ctx = ctx_create(decoder_config);
if (!ctx) {
- BT_LOGE_STR("Cannot create visitor's context.");
+ BT_COMP_LOGE_STR("Cannot create visitor's context.");
goto error;
}
int ret = 0;
struct ctx *ctx = (void *) visitor;
- BT_LOGI_STR("Visiting metadata's AST to generate CTF IR objects.");
+ BT_COMP_LOGI_STR("Visiting metadata's AST to generate CTF IR objects.");
switch (node->type) {
case NODE_ROOT:
if (ctx->ctf_tc->default_byte_order == -1) {
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
if (got_trace_decl) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Duplicate trace (`trace` block).");
ret = -1;
goto end;
ret = set_trace_byte_order(ctx, iter);
if (ret) {
- _BT_LOGE_NODE(node,
+ _BT_COMP_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).");
+ BT_COMP_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_NODE(iter,
+ _BT_COMP_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_NODE(iter,
+ _BT_COMP_LOGE_NODE(iter,
"Cannot visit clock class: ret=%d",
ret);
goto end;
siblings) {
ret = visit_root_decl(ctx, iter);
if (ret) {
- _BT_LOGE_NODE(iter,
+ _BT_COMP_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) {
- _BT_LOGW_NODE(iter,
+ _BT_COMP_LOGW_NODE(iter,
"\"callsite\" blocks are not supported as of this version.");
}
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
ret = visit_trace_decl(ctx, iter);
if (ret) {
- _BT_LOGE_NODE(iter,
+ _BT_COMP_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_NODE(iter,
+ _BT_COMP_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_NODE(iter,
+ _BT_COMP_LOGE_NODE(iter,
"Cannot visit event class: ret=%d",
ret);
goto end;
break;
}
default:
- _BT_LOGE_NODE(node,
+ _BT_COMP_LOGE_NODE(node,
"Unexpected node type: node-type=%d",
node->type);
ret = -EINVAL;
/* Update default clock classes */
ret = ctf_trace_class_update_default_clock_classes(ctx->ctf_tc,
- ctx->log_level);
+ &ctx->log_cfg);
if (ret) {
ret = -EINVAL;
goto end;
}
/* Resolve sequence lengths and variant tags */
- ret = ctf_trace_class_resolve_field_classes(ctx->ctf_tc,
- ctx->log_level);
+ ret = ctf_trace_class_resolve_field_classes(ctx->ctf_tc, &ctx->log_cfg);
if (ret) {
ret = -EINVAL;
goto end;
}
/* Validate what we have so far */
- ret = ctf_trace_class_validate(ctx->ctf_tc,
- ctx->log_level);
+ ret = ctf_trace_class_validate(ctx->ctf_tc, &ctx->log_cfg);
if (ret) {
ret = -EINVAL;
goto end;
* classes, warn about it because they are never translated.
*/
ctf_trace_class_warn_meaningless_header_fields(ctx->ctf_tc,
- ctx->log_level);
+ &ctx->log_cfg);
if (ctx->trace_class) {
/* Copy new CTF metadata -> new IR metadata */
- ret = ctf_trace_class_translate(ctx->self_comp,
+ ret = ctf_trace_class_translate(ctx->log_cfg.self_comp,
ctx->trace_class, ctx->ctf_tc);
if (ret) {
ret = -EINVAL;
* SOFTWARE.
*/
-#define BT_LOG_OUTPUT_LEVEL log_level
+#define BT_COMP_LOG_SELF_COMP (log_cfg->self_comp)
+#define BT_LOG_OUTPUT_LEVEL (log_cfg->log_level)
#define BT_LOG_TAG "PLUGIN/CTF/META/PARENT-LINKS-VISITOR"
-#include "logging/log.h"
+#include "plugins/comp-logging.h"
#include <stdio.h>
#include <unistd.h>
static
int ctf_visitor_unary_expression(int depth, struct ctf_node *node,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
int ret = 0;
case UNARY_DOTDOTDOT:
break;
default:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Unknown expression link type: type=%d\n",
node->u.unary_expression.link);
return -EINVAL;
node->u.unary_expression.u.sbrac_exp->parent = node;
ret = ctf_visitor_unary_expression(depth + 1,
node->u.unary_expression.u.sbrac_exp,
- log_level);
+ log_cfg);
if (ret)
return ret;
break;
case UNARY_UNKNOWN:
default:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Unknown expression link type: type=%d\n",
node->u.unary_expression.link);
return -EINVAL;
static
int ctf_visitor_type_specifier(int depth, struct ctf_node *node,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
int ret;
node->u.field_class_specifier.node->parent = node;
ret = ctf_visitor_parent_links(depth + 1,
node->u.field_class_specifier.node,
- log_level);
+ log_cfg);
if (ret)
return ret;
break;
case TYPESPEC_UNKNOWN:
default:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Unknown type specifier: type=%d\n",
node->u.field_class_specifier.type);
return -EINVAL;
static
int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
int ret = 0;
struct ctf_node *iter;
bt_list_for_each_entry(iter, &node->u.field_class_declarator.pointers,
siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(depth + 1, iter, log_level);
+ ret = ctf_visitor_parent_links(depth + 1, iter, log_cfg);
if (ret)
return ret;
}
node->u.field_class_declarator.u.nested.field_class_declarator->parent = node;
ret = ctf_visitor_parent_links(depth + 1,
node->u.field_class_declarator.u.nested.field_class_declarator,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
node->u.field_class_declarator.bitfield_len = node;
ret = ctf_visitor_parent_links(depth + 1,
node->u.field_class_declarator.bitfield_len,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
break;
case TYPEDEC_UNKNOWN:
default:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Unknown type declarator: type=%d\n",
node->u.field_class_declarator.type);
return -EINVAL;
}
int ctf_visitor_parent_links(int depth, struct ctf_node *node,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
int ret = 0;
struct ctf_node *iter;
bt_list_for_each_entry(iter, &node->u.root.declaration_list, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.env.declaration_list, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.clock.declaration_list, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.callsite.declaration_list, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.ctf_expression.left, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.ctf_expression.right, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
depth--;
break;
case NODE_UNARY_EXPRESSION:
- return ctf_visitor_unary_expression(depth, node, log_level);
+ return ctf_visitor_unary_expression(depth, node, log_cfg);
case NODE_TYPEDEF:
depth++;
node->u.field_class_def.field_class_specifier_list->parent = node;
ret = ctf_visitor_parent_links(depth + 1,
node->u.field_class_def.field_class_specifier_list,
- log_level);
+ log_cfg);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u.field_class_def.field_class_declarators, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
node->u.field_class_alias_target.field_class_specifier_list->parent = node;
ret = ctf_visitor_parent_links(depth + 1,
node->u.field_class_alias_target.field_class_specifier_list,
- log_level);
+ log_cfg);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u.field_class_alias_target.field_class_declarators, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
node->u.field_class_alias_name.field_class_specifier_list->parent = node;
ret = ctf_visitor_parent_links(depth + 1,
node->u.field_class_alias_name.field_class_specifier_list,
- log_level);
+ log_cfg);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u.field_class_alias_name.field_class_declarators, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
case NODE_TYPEALIAS:
node->u.field_class_alias.target->parent = node;
ret = ctf_visitor_parent_links(depth + 1,
- node->u.field_class_alias.target, log_level);
+ node->u.field_class_alias.target, log_cfg);
if (ret)
return ret;
node->u.field_class_alias.alias->parent = node;
ret = ctf_visitor_parent_links(depth + 1,
- node->u.field_class_alias.alias, log_level);
+ node->u.field_class_alias.alias, log_cfg);
if (ret)
return ret;
break;
bt_list_for_each_entry(iter, &node->u.field_class_specifier_list.head, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
break;
case NODE_TYPE_SPECIFIER:
- ret = ctf_visitor_type_specifier(depth, node, log_level);
+ ret = ctf_visitor_type_specifier(depth, node, log_cfg);
if (ret)
return ret;
break;
break;
case NODE_TYPE_DECLARATOR:
ret = ctf_visitor_field_class_declarator(depth, node,
- log_level);
+ log_cfg);
if (ret)
return ret;
break;
bt_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.integer.expressions, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.string.expressions, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.enumerator.values, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
depth++;
if (node->u._enum.container_field_class) {
ret = ctf_visitor_parent_links(depth + 1,
- node->u._enum.container_field_class, log_level);
+ node->u._enum.container_field_class, log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
node->u.struct_or_variant_declaration.field_class_specifier_list->parent = node;
ret = ctf_visitor_parent_links(depth + 1,
node->u.struct_or_variant_declaration.field_class_specifier_list,
- log_level);
+ log_cfg);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.field_class_declarators, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.variant.declaration_list, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u._struct.declaration_list, siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
siblings) {
iter->parent = node;
ret = ctf_visitor_parent_links(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
case NODE_UNKNOWN:
default:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Unknown node type: type=%d\n", node->type);
return -EINVAL;
}
* SOFTWARE.
*/
-#define BT_LOG_OUTPUT_LEVEL log_level
+#define BT_COMP_LOG_SELF_COMP (log_cfg->self_comp)
+#define BT_LOG_OUTPUT_LEVEL (log_cfg->log_level)
#define BT_LOG_TAG "PLUGIN/CTF/META/SEMANTIC-VALIDATOR-VISITOR"
-#include "logging/log.h"
+#include "plugins/comp-logging.h"
#include <stdio.h>
#include <unistd.h>
static
int _ctf_visitor_semantic_check(int depth, struct ctf_node *node,
- bt_logging_level log_level);
+ struct meta_log_config *log_cfg);
static
int ctf_visitor_unary_expression(int depth, struct ctf_node *node,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
struct ctf_node *iter;
int is_ctf_exp = 0, is_ctf_exp_left = 0;
* We are only allowed to be a string.
*/
if (node->u.unary_expression.type != UNARY_STRING) {
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Left child of a CTF expression is only allowed to be a string.");
goto errperm;
}
case UNARY_STRING:
break;
default:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Children of field class declarator and `enum` can only be unsigned numeric constants or references to fields (e.g., `a.b.c`).");
goto errperm;
}
case UNARY_UNSIGNED_CONSTANT:
break;
default:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Structure alignment attribute can only be an unsigned numeric constant.");
goto errperm;
}
* We disallow nested unary expressions and "sbrac" unary
* expressions.
*/
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Nested unary expressions not allowed (`()` and `[]`).");
goto errperm;
&node->parent->u.ctf_expression.right,
struct ctf_node,
siblings) != node) {
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Empty link is not allowed except on first node of unary expression (need to separate nodes with `.` or `->`).");
goto errperm;
}
case UNARY_ARROWLINK:
/* We only allow -> and . links between children of ctf_expression. */
if (node->parent->type != NODE_CTF_EXPRESSION) {
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Links `.` and `->` are only allowed as children of CTF expression.");
goto errperm;
}
* This includes "", '' and non-quoted identifiers.
*/
if (node->u.unary_expression.type != UNARY_STRING) {
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Links `.` and `->` are only allowed to separate strings and identifiers.");
goto errperm;
}
&node->parent->u.ctf_expression.right,
struct ctf_node,
siblings) == node) {
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Links `.` and `->` are not allowed before first node of the unary expression list.");
goto errperm;
}
case UNARY_DOTDOTDOT:
/* We only allow ... link between children of enumerator. */
if (node->parent->type != NODE_ENUMERATOR) {
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Link `...` is only allowed within enumerator.");
goto errperm;
}
if (_bt_list_first_entry(&node->parent->u.enumerator.values,
struct ctf_node,
siblings) == node) {
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Link `...` is not allowed on the first node of the unary expression list.");
goto errperm;
}
break;
default:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Unknown expression link type: type=%d",
node->u.unary_expression.link);
return -EINVAL;
return 0;
errinval:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Incoherent parent node's type: node-type=%s, parent-node-type=%s",
node_type(node), node_type(node->parent));
return -EINVAL; /* Incoherent structure */
errperm:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Semantic error: node-type=%s, parent-node-type=%s",
node_type(node), node_type(node->parent));
return -EPERM; /* Structure not allowed */
static
int ctf_visitor_field_class_specifier_list(int depth, struct ctf_node *node,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
switch (node->parent->type) {
case NODE_CTF_EXPRESSION:
}
return 0;
errinval:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Incoherent parent node's type: node-type=%s, parent-node-type=%s",
node_type(node), node_type(node->parent));
return -EINVAL; /* Incoherent structure */
static
int ctf_visitor_field_class_specifier(int depth, struct ctf_node *node,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
switch (node->parent->type) {
case NODE_TYPE_SPECIFIER_LIST:
}
return 0;
errinval:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Incoherent parent node's type: node-type=%s, parent-node-type=%s",
node_type(node), node_type(node->parent));
return -EINVAL; /* Incoherent structure */
static
int ctf_visitor_field_class_declarator(int depth, struct ctf_node *node,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
int ret = 0;
struct ctf_node *iter;
bt_list_for_each_entry(iter, &node->u.field_class_declarator.pointers,
siblings) {
- ret = _ctf_visitor_semantic_check(depth + 1, iter, log_level);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter, log_cfg);
if (ret)
return ret;
}
if (node->u.field_class_declarator.u.nested.field_class_declarator) {
ret = _ctf_visitor_semantic_check(depth + 1,
node->u.field_class_declarator.u.nested.field_class_declarator,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.field_class_declarator.u.nested.length,
siblings) {
if (iter->type != NODE_UNARY_EXPRESSION) {
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Expecting unary expression as length: node-type=%s",
node_type(iter));
return -EINVAL;
}
ret = _ctf_visitor_semantic_check(depth + 1,
- iter, log_level);
+ iter, log_cfg);
if (ret)
return ret;
}
} else {
if (node->parent->type == NODE_TYPEALIAS_TARGET) {
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Abstract array declarator not permitted as target of field class alias.");
return -EINVAL;
}
if (node->u.field_class_declarator.bitfield_len) {
ret = _ctf_visitor_semantic_check(depth + 1,
node->u.field_class_declarator.bitfield_len,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
}
case TYPEDEC_UNKNOWN:
default:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Unknown field class declarator: type=%d",
node->u.field_class_declarator.type);
return -EINVAL;
return 0;
errinval:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Incoherent parent node's type: node-type=%s, parent-node-type=%s",
node_type(node), node_type(node->parent));
return -EINVAL; /* Incoherent structure */
errperm:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Semantic error: node-type=%s, parent-node-type=%s",
node_type(node), node_type(node->parent));
return -EPERM; /* Structure not allowed */
static
int _ctf_visitor_semantic_check(int depth, struct ctf_node *node,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
int ret = 0;
struct ctf_node *iter;
case NODE_ROOT:
bt_list_for_each_entry(iter, &node->u.root.declaration_list, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.env.declaration_list, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.clock.declaration_list, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.callsite.declaration_list, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
depth++;
bt_list_for_each_entry(iter, &node->u.ctf_expression.left, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.ctf_expression.right, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
depth--;
break;
case NODE_UNARY_EXPRESSION:
- return ctf_visitor_unary_expression(depth, node, log_level);
+ return ctf_visitor_unary_expression(depth, node, log_cfg);
case NODE_TYPEDEF:
switch (node->parent->type) {
depth++;
ret = _ctf_visitor_semantic_check(depth + 1,
node->u.field_class_def.field_class_specifier_list,
- log_level);
+ log_cfg);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u.field_class_def.field_class_declarators, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
depth++;
ret = _ctf_visitor_semantic_check(depth + 1,
node->u.field_class_alias_target.field_class_specifier_list,
- log_level);
+ log_cfg);
if (ret)
return ret;
nr_declarators = 0;
bt_list_for_each_entry(iter, &node->u.field_class_alias_target.field_class_declarators, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
nr_declarators++;
}
if (nr_declarators > 1) {
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Too many declarators in field class alias's name (maximum is 1): count=%d",
nr_declarators);
return -EINVAL;
depth++;
ret = _ctf_visitor_semantic_check(depth + 1,
node->u.field_class_alias_name.field_class_specifier_list,
- log_level);
+ log_cfg);
if (ret)
return ret;
nr_declarators = 0;
bt_list_for_each_entry(iter, &node->u.field_class_alias_name.field_class_declarators, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
nr_declarators++;
}
if (nr_declarators > 1) {
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Too many declarators in field class alias's name (maximum is 1): count=%d",
nr_declarators);
return -EINVAL;
}
ret = _ctf_visitor_semantic_check(depth + 1,
- node->u.field_class_alias.target, log_level);
+ node->u.field_class_alias.target, log_cfg);
if (ret)
return ret;
ret = _ctf_visitor_semantic_check(depth + 1,
- node->u.field_class_alias.alias, log_level);
+ node->u.field_class_alias.alias, log_cfg);
if (ret)
return ret;
break;
case NODE_TYPE_SPECIFIER_LIST:
ret = ctf_visitor_field_class_specifier_list(depth, node,
- log_level);
+ log_cfg);
if (ret)
return ret;
break;
case NODE_TYPE_SPECIFIER:
ret = ctf_visitor_field_class_specifier(depth, node,
- log_level);
+ log_cfg);
if (ret)
return ret;
break;
break;
case NODE_TYPE_DECLARATOR:
ret = ctf_visitor_field_class_declarator(depth, node,
- log_level);
+ log_cfg);
if (ret)
return ret;
break;
}
bt_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.integer.expressions, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.string.expressions, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
|| (iter->u.unary_expression.type != UNARY_SIGNED_CONSTANT
&& iter->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT)
|| iter->u.unary_expression.link != UNARY_LINK_UNKNOWN) {
- _BT_LOGE_LINENO(iter->lineno,
+ _BT_COMP_LOGE_LINENO(iter->lineno,
"First unary expression of enumerator is unexpected.");
goto errperm;
}
|| (iter->u.unary_expression.type != UNARY_SIGNED_CONSTANT
&& iter->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT)
|| iter->u.unary_expression.link != UNARY_DOTDOTDOT) {
- _BT_LOGE_LINENO(iter->lineno,
+ _BT_COMP_LOGE_LINENO(iter->lineno,
"Second unary expression of enumerator is unexpected.");
goto errperm;
}
bt_list_for_each_entry(iter, &node->u.enumerator.values, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
depth++;
ret = _ctf_visitor_semantic_check(depth + 1,
- node->u._enum.container_field_class, log_level);
+ node->u._enum.container_field_class, log_cfg);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
}
ret = _ctf_visitor_semantic_check(depth + 1,
node->u.struct_or_variant_declaration.field_class_specifier_list,
- log_level);
+ log_cfg);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.field_class_declarators, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
}
bt_list_for_each_entry(iter, &node->u.variant.declaration_list, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
}
bt_list_for_each_entry(iter, &node->u._struct.declaration_list, siblings) {
ret = _ctf_visitor_semantic_check(depth + 1, iter,
- log_level);
+ log_cfg);
if (ret)
return ret;
}
case NODE_UNKNOWN:
default:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Unknown node type: type=%d", node->type);
return -EINVAL;
}
return ret;
errinval:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Incoherent parent node's type: node-type=%s, parent-node-type=%s",
node_type(node), node_type(node->parent));
return -EINVAL; /* Incoherent structure */
errperm:
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Semantic error: node-type=%s, parent-node-type=%s",
node_type(node), node_type(node->parent));
return -EPERM; /* Structure not allowed */
}
int ctf_visitor_semantic_check(int depth, struct ctf_node *node,
- bt_logging_level log_level)
+ struct meta_log_config *log_cfg)
{
int ret = 0;
* take the safe route and recreate them at each validation, just in
* case the structure has changed.
*/
- ret = ctf_visitor_parent_links(depth, node, log_level);
+ ret = ctf_visitor_parent_links(depth, node, log_cfg);
if (ret) {
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Cannot create parent links in metadata's AST: "
"ret=%d", ret);
goto end;
}
- ret = _ctf_visitor_semantic_check(depth, node, log_level);
+ ret = _ctf_visitor_semantic_check(depth, node, log_cfg);
if (ret) {
- _BT_LOGE_LINENO(node->lineno,
+ _BT_COMP_LOGE_LINENO(node->lineno,
"Cannot check metadata's AST semantics: "
"ret=%d", ret);
goto end;
struct ctf_fs_file *file = NULL;
struct ctf_metadata_decoder_config decoder_config = {
.log_level = BT_LOG_OUTPUT_LEVEL,
+ .self_comp = bt_self_component_source_as_self_component(self_comp),
.clock_class_offset_s = config ? config->clock_class_offset_s : 0,
.clock_class_offset_ns = config ? config->clock_class_offset_ns : 0,
};
goto end;
}
- ctf_fs_trace->metadata->decoder = ctf_metadata_decoder_create(self_comp,
- config ? &decoder_config : NULL);
+ ctf_fs_trace->metadata->decoder = ctf_metadata_decoder_create(
+ &decoder_config);
if (!ctf_fs_trace->metadata->decoder) {
BT_LOGE("Cannot create metadata decoder object");
ret = -1;
}
is_packetized = ctf_metadata_decoder_is_packetized(metadata_fp,
- &bo, BT_LOG_OUTPUT_LEVEL);
+ &bo, BT_LOG_OUTPUT_LEVEL, NULL);
if (is_packetized) {
ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
metadata_fp, &metadata_text, bo,
- BT_LOG_OUTPUT_LEVEL);
+ BT_LOG_OUTPUT_LEVEL, NULL);
if (ret) {
BT_LOGE("Cannot decode packetized metadata file: path=\"%s\"",
path);
const char *match;
struct ctf_metadata_decoder_config cfg = {
.log_level = session->log_level,
+ .self_comp =
+ bt_self_component_source_as_self_component(
+ lttng_live->self_comp),
.clock_class_offset_s = 0,
.clock_class_offset_ns = 0,
};
goto error;
}
- metadata->decoder = ctf_metadata_decoder_create(
- lttng_live->self_comp, &cfg);
+ metadata->decoder = ctf_metadata_decoder_create(&cfg);
if (!metadata->decoder) {
goto error;
}
projects / babeltrace.git / commitdiff
