#include "btr.h"
-#define PRINT_ERR_STREAM (btr ? btr->err_stream : stderr)
-#define PRINT_PREFIX "ctf-btr"
-#include "../print.h"
-
#define DIV8(_x) ((_x) >> 3)
#define BYTES_TO_BITS(_x) ((_x) * 8)
#define BITS_TO_BYTES_FLOOR(_x) DIV8(_x)
/* Bisit stack */
struct stack *stack;
- /* Error stream */
- FILE *err_stream;
-
/* Current basic field type */
struct bt_ctf_field_type *cur_basic_field_type;
return status;
}
-struct bt_ctf_btr *bt_ctf_btr_create(struct bt_ctf_btr_cbs cbs, void *data,
- FILE *err_stream)
+struct bt_ctf_btr *bt_ctf_btr_create(struct bt_ctf_btr_cbs cbs, void *data)
{
struct bt_ctf_btr *btr;
btr->state = BTR_STATE_NEXT_FIELD;
btr->user.cbs = cbs;
btr->user.data = data;
- btr->err_stream = err_stream;
BT_LOGD("Created BTR: addr=%p", btr);
end:
*
* @param cbs User callback functions
* @param data User data (passed to user callback functions)
- * @param err_stream Error stream (can be \c NULL to disable)
* @returns New binary type reader on success, or \c NULL on error
*/
-struct bt_ctf_btr *bt_ctf_btr_create(struct bt_ctf_btr_cbs cbs, void *data,
- FILE *err_stream);
+struct bt_ctf_btr *bt_ctf_btr_create(struct bt_ctf_btr_cbs cbs, void *data);
/**
* Destroys a CTF binary type reader, freeing all internal resources.
scanner.h \
scanner-symbols.h \
decoder.c \
- decoder.h
+ decoder.h \
+ logging.c \
+ logging.h
libctf_ast_la_LIBADD =
const char *node_type(struct ctf_node *node);
BT_HIDDEN
-struct ctf_visitor_generate_ir *ctf_visitor_generate_ir_create(FILE *efd,
- uint64_t clock_class_offset_ns, const char *name);
+struct ctf_visitor_generate_ir *ctf_visitor_generate_ir_create(
+ int64_t clock_class_offset_ns, const char *name);
void ctf_visitor_generate_ir_destroy(struct ctf_visitor_generate_ir *visitor);
struct ctf_node *node);
BT_HIDDEN
-int ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node);
+int ctf_visitor_semantic_check(int depth, struct ctf_node *node);
BT_HIDDEN
-int ctf_visitor_parent_links(FILE *fd, int depth, struct ctf_node *node);
+int ctf_visitor_parent_links(int depth, struct ctf_node *node);
#endif /* _CTF_AST_H */
#include "decoder.h"
#include "scanner.h"
-#define PRINT_ERR_STREAM (mdec ? mdec->err_stream : stderr)
-#define PRINT_PREFIX "metadata-decoder"
-#include "../print.h"
+#define BT_LOG_TAG "PLUGIN-CTF-METADATA-DECODER"
+#include "logging.h"
#define TSDL_MAGIC 0x75d11d57
struct ctf_metadata_decoder {
struct ctf_visitor_generate_ir *visitor;
- FILE *err_stream;
uint8_t uuid[16];
bool is_uuid_set;
int bo;
}
if (header.compression_scheme) {
- PERR("Metadata packet compression not supported yet\n");
+ BT_LOGE("Metadata packet compression not supported yet");
goto error;
}
if (header.encryption_scheme) {
- PERR("Metadata packet encryption not supported yet\n");
+ BT_LOGE("Metadata packet encryption not supported yet");
goto error;
}
if (header.checksum || header.checksum_scheme) {
- PERR("Metadata packet checksum verification not supported yet\n");
+ BT_LOGE("Metadata packet checksum verification not supported yet");
goto error;
}
if (!is_version_valid(header.major, header.minor)) {
- PERR("Invalid metadata version: %u.%u\n", header.major,
+ BT_LOGE("Invalid metadata version: %u.%u", header.major,
header.minor);
goto error;
}
memcpy(mdec->uuid, header.uuid, sizeof(header.uuid));
mdec->is_uuid_set = true;
} else if (bt_uuid_compare(header.uuid, mdec->uuid)) {
- PERR("Metadata UUID mismatch between packets of the same stream\n");
+ BT_LOGE("Metadata UUID mismatch between packets of the same stream");
goto error;
}
}
if ((header.content_size / CHAR_BIT) < sizeof(header)) {
- PERR("Bad metadata packet content size: %u\n",
+ BT_LOGE("Bad metadata packet content size: %u",
header.content_size);
goto error;
}
readlen = fread(buf, sizeof(uint8_t),
MIN(sizeof(buf) - 1, toread), in_fp);
if (ferror(in_fp)) {
- PERR("Cannot read metadata packet buffer (at position %ld)\n",
+ BT_LOGE("Cannot read metadata packet buffer (at position %ld)",
ftell(in_fp));
goto error;
}
writelen = fwrite(buf, sizeof(uint8_t), readlen, out_fp);
if (writelen < readlen || ferror(out_fp)) {
- PERR("Cannot write decoded metadata text to buffer\n");
+ BT_LOGE("Cannot write decoded metadata text to buffer");
goto error;
}
CHAR_BIT;
fseek_ret = fseek(in_fp, toread, SEEK_CUR);
if (fseek_ret < 0) {
- PWARN("Missing padding at the end of the metadata file\n");
+ BT_LOGW("Missing padding at the end of the metadata file");
}
break;
out_fp = bt_open_memstream(buf, &size);
if (out_fp == NULL) {
- PERR("Cannot open memory stream: %s\n", strerror(errno));
+ BT_LOGE("Cannot open memory stream: %s", strerror(errno));
goto error;
}
tret = decode_packet(mdec, fp, out_fp, byte_order);
if (tret) {
- PERR("Cannot decode packet #%zu\n", packet_index);
+ BT_LOGE("Cannot decode packet #%zu", packet_index);
goto error;
}
/* Make sure the whole string ends with a null character */
tret = fputc('\0', out_fp);
if (tret == EOF) {
- PERR("Cannot append '\\0' to the decoded metadata buffer\n");
+ BT_LOGE("Cannot append '\\0' to the decoded metadata buffer");
goto error;
}
/* Close stream, which also flushes the buffer */
ret = bt_close_memstream(buf, &size, out_fp);
if (ret < 0) {
- PERR("Cannot close memory stream: %s\n", strerror(errno));
+ BT_LOGE("Cannot close memory stream: %s", strerror(errno));
goto error;
}
}
BT_HIDDEN
-struct ctf_metadata_decoder *ctf_metadata_decoder_create(FILE *err,
- uint64_t clock_class_offset_ns, const char *name)
+struct ctf_metadata_decoder *ctf_metadata_decoder_create(
+ int64_t clock_class_offset_ns, const char *name)
{
struct ctf_metadata_decoder *mdec =
g_new0(struct ctf_metadata_decoder, 1);
goto end;
}
- mdec->err_stream = err;
- mdec->visitor = ctf_visitor_generate_ir_create(err,
- clock_class_offset_ns, name);
+ mdec->visitor = ctf_visitor_generate_ir_create(clock_class_offset_ns,
+ name);
if (!mdec->visitor) {
ctf_metadata_decoder_destroy(mdec);
mdec = NULL;
assert(mdec);
if (ctf_metadata_decoder_is_packetized(fp, &mdec->bo)) {
- PDBG("Metadata stream is packetized\n");
+ BT_LOGD("Metadata stream is packetized");
ret = ctf_metadata_decoder_packetized_file_stream_to_buf_with_mdec(
mdec, fp, &buf, mdec->bo);
if (ret) {
fp = bt_fmemopen(buf, strlen(buf), "rb");
close_fp = true;
if (!fp) {
- PERR("Cannot memory-open metadata buffer: %s\n",
+ BT_LOGE("Cannot memory-open metadata buffer: %s",
strerror(errno));
status = CTF_METADATA_DECODER_STATUS_ERROR;
goto end;
ssize_t nr_items;
const long init_pos = ftell(fp);
- PDBG("Metadata stream is plain text\n");
+ BT_LOGD("Metadata stream is plain text");
/* Check text-only metadata header and version */
nr_items = fscanf(fp, "/* CTF %10u.%10u", &major, &minor);
if (nr_items < 2) {
- PWARN("Ill-shapen or missing \"/* CTF major.minor\" header in plain text metadata file stream\n");
+ BT_LOGW("Ill-shapen or missing \"/* CTF major.minor\" header in plain text metadata file stream");
}
- PDBG("Metadata version: %u.%u\n", major, minor);
+ BT_LOGD("Metadata version: %u.%u", major, minor);
if (!is_version_valid(major, minor)) {
- PERR("Invalid metadata version: %u.%u\n", major, minor);
+ BT_LOGE("Invalid metadata version: %u.%u", major, minor);
status = CTF_METADATA_DECODER_STATUS_INVAL_VERSION;
goto end;
}
if (fseek(fp, init_pos, SEEK_SET)) {
- PERR("Cannot seek metadata file stream to initial position: %s\n",
+ BT_LOGE("Cannot seek metadata file stream to initial position: %s",
strerror(errno));
status = CTF_METADATA_DECODER_STATUS_ERROR;
goto end;
/* Allocate a scanner and append the metadata text content */
scanner = ctf_scanner_alloc();
if (!scanner) {
- PERR("Cannot allocate a metadata lexical scanner\n");
+ BT_LOGE("Cannot allocate a metadata lexical scanner");
status = CTF_METADATA_DECODER_STATUS_ERROR;
goto end;
}
assert(fp);
ret = ctf_scanner_append_ast(scanner, fp);
if (ret) {
- PERR("Cannot create the metadata AST\n");
+ BT_LOGE("Cannot create the metadata AST");
status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
goto end;
}
- ret = ctf_visitor_semantic_check(stderr, 0, &scanner->ast->root);
+ ret = ctf_visitor_semantic_check(0, &scanner->ast->root);
if (ret) {
- PERR("Metadata semantic validation failed\n");
+ BT_LOGE("Metadata semantic validation failed");
status = CTF_METADATA_DECODER_STATUS_ERROR;
goto end;
}
/* Success */
break;
case -EINCOMPLETE:
- PDBG("While visiting AST: incomplete data\n");
+ BT_LOGD("While visiting AST: incomplete data");
status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
goto end;
default:
- PERR("Cannot visit AST node to create CTF IR objects\n");
+ BT_LOGE("Cannot visit AST node to create CTF IR objects");
status = CTF_METADATA_DECODER_STATUS_IR_VISITOR_ERROR;
goto end;
}
if (fp && close_fp) {
if (fclose(fp)) {
- PERR("Cannot close metadata file stream\n");
+ BT_LOGE("Cannot close metadata file stream");
}
}
};
/*
- * Creates a CTF metadata decoder with `err` as the error stream (can
- * be `NULL` to disable error output). `clock_class_offset_ns` is an
+ * Creates a CTF metadata decoder. `clock_class_offset_ns` is an
* offset to apply to the decoded clock classes's offsets. `name` is
* this decoder's trace's name.
*
* Returns `NULL` on error.
*/
BT_HIDDEN
-struct ctf_metadata_decoder *ctf_metadata_decoder_create(FILE *err,
- uint64_t clock_class_offset_ns, const char *name);
+struct ctf_metadata_decoder *ctf_metadata_decoder_create(
+ int64_t clock_class_offset_ns, const char *name);
/*
* Destroys a CTF metadata decoder that you created with
--- /dev/null
+/*
+ * Copyright (c) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#define BT_LOG_OUTPUT_LEVEL metadata_log_level
+#include <babeltrace/logging-internal.h>
+
+BT_LOG_INIT_LOG_LEVEL(metadata_log_level, "BABELTRACE_PLUGIN_CTF_METADATA_LOG_LEVEL");
--- /dev/null
+#ifndef CTF_METADATA_LOGGING_H
+#define CTF_METADATA_LOGGING_H
+
+/*
+ * Copyright (c) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#define BT_LOG_OUTPUT_LEVEL metadata_log_level
+#include <babeltrace/logging-internal.h>
+
+BT_LOG_LEVEL_EXTERN_SYMBOL(metadata_log_level);
+
+#endif /* CTF_METADATA_LOGGING_H */
#include "parser.h"
#include "ast.h"
+#define BT_LOG_TAG "PLUGIN-CTF-METADATA-VISITOR-GENERATE-IR"
+#include "logging.h"
+
/* Bit value (left shift) */
#define _BV(_val) (1 << (_val))
#define _BT_CTF_FIELD_TYPE_INIT(_name) struct bt_ctf_field_type *_name = NULL;
-/* Error printing wrappers */
-#define _PERROR(_fmt, ...) \
- do { \
- if (!ctx->efd) break; \
- fprintf(ctx->efd, "[error] %s: " _fmt "\n", \
- __func__, __VA_ARGS__); \
- } while (0)
-
-#define _PWARNING(_fmt, ...) \
- do { \
- if (!ctx->efd) break; \
- fprintf(ctx->efd, "[warning] %s: " _fmt "\n", \
- __func__, __VA_ARGS__); \
- } while (0)
-
-#define _FPERROR(_stream, _fmt, ...) \
+#define BT_LOGE_DUP_ATTR(_attr, _entity) \
do { \
- if (!_stream) break; \
- fprintf(_stream, "[error] %s: " _fmt "\n", \
- __func__, __VA_ARGS__); \
- } while (0)
-
-#define _FPWARNING(_stream, _fmt, ...) \
- do { \
- if (!_stream) break; \
- fprintf(_stream, "[warning] %s: " _fmt "\n", \
- __func__, __VA_ARGS__); \
- } while (0)
-
-#define _PERROR_DUP_ATTR(_attr, _entity) \
- do { \
- if (!ctx->efd) break; \
- fprintf(ctx->efd, \
- "[error] %s: duplicate attribute \"" \
+ BT_LOGE("[error] %s: duplicate attribute \"" \
_attr "\" in " _entity "\n", __func__); \
} while (0)
/* Trace being filled (owned by this) */
struct bt_ctf_trace *trace;
- /* Error stream to use during visit */
- FILE *efd;
-
/* Current declaration scope (top of the stack) */
struct ctx_decl_scope *current_scope;
bool is_lttng;
/* Offset (ns) to apply to clock classes on creation */
- uint64_t clock_class_offset_ns;
+ int64_t clock_class_offset_ns;
/* Eventual name suffix of the trace to set */
char *trace_name_suffix;
* Creates a new visitor context.
*
* @param trace Associated trace
- * @param efd Error stream
* @returns New visitor context, or NULL on error
*/
static
-struct ctx *ctx_create(struct bt_ctf_trace *trace, FILE *efd,
- uint64_t clock_class_offset_ns, const char *trace_name_suffix)
+struct ctx *ctx_create(struct bt_ctf_trace *trace,
+ int64_t clock_class_offset_ns, const char *trace_name_suffix)
{
struct ctx *ctx = NULL;
struct ctx_decl_scope *scope = NULL;
}
ctx->trace = trace;
- ctx->efd = efd;
ctx->current_scope = scope;
scope = NULL;
ctx->trace_bo = BT_CTF_BYTE_ORDER_NATIVE;
}
static
-int get_boolean(FILE *efd, struct ctf_node *unary_expr)
+int get_boolean(struct ctf_node *unary_expr)
{
int ret = 0;
if (unary_expr->type != NODE_UNARY_EXPRESSION) {
- _FPERROR(efd, "%s", "expecting unary expression");
+ BT_LOGE("expecting unary expression");
ret = -EINVAL;
goto end;
}
} else if (!strcmp(str, "false") || !strcmp(str, "FALSE")) {
ret = FALSE;
} else {
- _FPERROR(efd, "unexpected string \"%s\"", str);
+ BT_LOGE("unexpected string \"%s\"", str);
ret = -EINVAL;
goto end;
}
break;
}
default:
- _FPERROR(efd, "%s", "unexpected unary expression type");
+ BT_LOGE("unexpected unary expression type");
ret = -EINVAL;
goto end;
}
}
static
-enum bt_ctf_byte_order byte_order_from_unary_expr(FILE *efd,
- struct ctf_node *unary_expr)
+enum bt_ctf_byte_order byte_order_from_unary_expr(struct ctf_node *unary_expr)
{
const char *str;
enum bt_ctf_byte_order bo = BT_CTF_BYTE_ORDER_UNKNOWN;
if (unary_expr->u.unary_expression.type != UNARY_STRING) {
- _FPERROR(efd, "%s",
- "\"byte_order\" attribute: expecting string");
+ BT_LOGE("\"byte_order\" attribute: expecting string");
goto end;
}
} else if (!strcmp(str, "native")) {
bo = BT_CTF_BYTE_ORDER_NATIVE;
} else {
- _FPERROR(efd, "unexpected \"byte_order\" attribute value \"%s\"; should be \"be\", \"le\", \"network\", or \"native\"",
+ BT_LOGE("unexpected \"byte_order\" attribute value \"%s\"; should be \"be\", \"le\", \"network\", or \"native\"",
str);
goto end;
}
enum bt_ctf_byte_order get_real_byte_order(struct ctx *ctx,
struct ctf_node *uexpr)
{
- enum bt_ctf_byte_order bo = byte_order_from_unary_expr(ctx->efd, uexpr);
+ enum bt_ctf_byte_order bo = byte_order_from_unary_expr(uexpr);
if (bo == BT_CTF_BYTE_ORDER_NATIVE) {
bo = bt_ctf_trace_get_native_byte_order(ctx->trace);
struct ctf_node *node = type_specifier->u.type_specifier.node;
if (!node->u._struct.name) {
- _PERROR("%s", "unexpected empty structure name");
+ BT_LOGE("unexpected empty structure name");
ret = -EINVAL;
goto end;
}
struct ctf_node *node = type_specifier->u.type_specifier.node;
if (!node->u.variant.name) {
- _PERROR("%s", "unexpected empty variant name");
+ BT_LOGE("unexpected empty variant name");
ret = -EINVAL;
goto end;
}
struct ctf_node *node = type_specifier->u.type_specifier.node;
if (!node->u._enum.enum_id) {
- _PERROR("%s", "unexpected empty enum name");
+ BT_LOGE("unexpected empty enum name");
ret = -EINVAL;
goto end;
}
case TYPESPEC_INTEGER:
case TYPESPEC_STRING:
default:
- _PERROR("%s", "unknown specifier");
+ BT_LOGE("unknown specifier");
ret = -EINVAL;
goto end;
}
/* TODO: GCC bitfields not supported yet */
if (node_type_declarator->u.type_declarator.bitfield_len !=
NULL) {
- _PERROR("%s", "GCC bitfields are not supported as of this version");
+ BT_LOGE("GCC bitfields are not supported as of this version");
ret = -EPERM;
goto error;
}
ctx_decl_scope_lookup_alias(ctx->current_scope,
g_quark_to_string(qalias), -1);
if (!nested_decl) {
- _PERROR("cannot find typealias \"%s\"",
+ BT_LOGE("cannot find typealias \"%s\"",
g_quark_to_string(qalias));
ret = -EINVAL;
goto error;
nested_decl_copy = bt_ctf_field_type_copy(nested_decl);
BT_PUT(nested_decl);
if (!nested_decl_copy) {
- _PERROR("%s", "cannot copy nested field type");
+ BT_LOGE("cannot copy nested field type");
ret = -EINVAL;
goto error;
}
/* Create array/sequence, pass nested_decl as child */
if (bt_list_empty(length)) {
- _PERROR("%s",
- "expecting length field reference or value");
+ BT_LOGE("expecting length field reference or value");
ret = -EINVAL;
goto error;
}
len);
BT_PUT(nested_decl);
if (!array_decl) {
- _PERROR("%s",
- "cannot create array field type");
+ BT_LOGE("cannot create array field type");
ret = -ENOMEM;
goto error;
}
g_free(length_name);
BT_PUT(nested_decl);
if (!seq_decl) {
- _PERROR("%s",
- "cannot create sequence field type");
+ BT_LOGE("cannot create sequence field type");
ret = -ENOMEM;
goto error;
}
&qfield_name, iter, &field_decl, NULL);
if (ret) {
assert(!field_decl);
- _PERROR("%s", "cannot visit type declarator");
+ BT_LOGE("cannot visit type declarator");
goto error;
}
struct_decl, field_name);
if (efield_decl) {
BT_PUT(efield_decl);
- _PERROR("duplicate field \"%s\" in structure",
+ BT_LOGE("duplicate field \"%s\" in structure",
field_name);
ret = -EINVAL;
goto error;
field_decl, field_name);
BT_PUT(field_decl);
if (ret) {
- _PERROR("cannot add field \"%s\" to structure",
+ BT_LOGE("cannot add field \"%s\" to structure",
g_quark_to_string(qfield_name));
goto error;
}
&qfield_name, iter, &field_decl, NULL);
if (ret) {
assert(!field_decl);
- _PERROR("%s",
- "cannot visit type declarator");
+ BT_LOGE("cannot visit type declarator");
goto error;
}
variant_decl, field_name);
if (efield_decl) {
BT_PUT(efield_decl);
- _PERROR("duplicate field \"%s\" in variant",
+ BT_LOGE("duplicate field \"%s\" in variant",
field_name);
ret = -EINVAL;
goto error;
field_decl, field_name);
BT_PUT(field_decl);
if (ret) {
- _PERROR("cannot add field \"%s\" to variant",
+ BT_LOGE("cannot add field \"%s\" to variant",
g_quark_to_string(qfield_name));
goto error;
}
ret = visit_type_declarator(ctx, type_specifier_list,
&qidentifier, iter, &type_decl, NULL);
if (ret) {
- _PERROR("%s", "cannot visit type declarator");
+ BT_LOGE("cannot visit type declarator");
ret = -EINVAL;
goto end;
}
/* Do not allow typedef and typealias of untagged variants */
if (bt_ctf_field_type_is_variant(type_decl)) {
if (bt_ctf_field_type_variant_get_tag_name(type_decl)) {
- _PERROR("%s", "typedef of untagged variant is not allowed");
+ BT_LOGE("typedef of untagged variant is not allowed");
ret = -EPERM;
goto end;
}
ret = ctx_decl_scope_register_alias(ctx->current_scope,
g_quark_to_string(qidentifier), type_decl);
if (ret) {
- _PERROR("cannot register typedef \"%s\"",
+ BT_LOGE("cannot register typedef \"%s\"",
g_quark_to_string(qidentifier));
goto end;
}
&qdummy_field_name, node, &type_decl, NULL);
if (ret) {
assert(!type_decl);
- _PERROR("%s", "cannot visit type declarator");
+ BT_LOGE("cannot visit type declarator");
goto end;
}
/* Do not allow typedef and typealias of untagged variants */
if (bt_ctf_field_type_is_variant(type_decl)) {
if (bt_ctf_field_type_variant_get_tag_name(type_decl)) {
- _PERROR("%s",
- "typealias of untagged variant is not allowed");
+ BT_LOGE("typealias of untagged variant is not allowed");
ret = -EPERM;
goto end;
}
* abstract or not (if it has an identifier). Check it here.
*/
if (qdummy_field_name != 0) {
- _PERROR("%s", "expecting empty identifier");
+ BT_LOGE("expecting empty identifier");
ret = -EINVAL;
goto end;
}
ret = ctx_decl_scope_register_alias(ctx->current_scope,
g_quark_to_string(qalias), type_decl);
if (ret) {
- _PERROR("cannot register typealias \"%s\"",
+ BT_LOGE("cannot register typealias \"%s\"",
g_quark_to_string(qalias));
goto end;
}
entry_node->u._typedef.type_specifier_list,
&entry_node->u._typedef.type_declarators);
if (ret) {
- _PERROR("%s",
- "cannot add typedef in \"struct\" declaration");
+ BT_LOGE("cannot add typedef in \"struct\" declaration");
goto end;
}
break;
ret = visit_typealias(ctx, entry_node->u.typealias.target,
entry_node->u.typealias.alias);
if (ret) {
- _PERROR("%s",
- "cannot add typealias in \"struct\" declaration");
+ BT_LOGE("cannot add typealias in \"struct\" declaration");
goto end;
}
break;
}
break;
default:
- _PERROR("unexpected node type: %d", (int) entry_node->type);
+ BT_LOGE("unexpected node type: %d", (int) entry_node->type);
ret = -EINVAL;
goto end;
}
entry_node->u._typedef.type_specifier_list,
&entry_node->u._typedef.type_declarators);
if (ret) {
- _PERROR("%s",
+ BT_LOGE(
"cannot add typedef in \"variant\" declaration");
goto end;
}
ret = visit_typealias(ctx, entry_node->u.typealias.target,
entry_node->u.typealias.alias);
if (ret) {
- _PERROR("%s",
+ BT_LOGE(
"cannot add typealias in \"variant\" declaration");
goto end;
}
}
break;
default:
- _PERROR("unexpected node type: %d", (int) entry_node->type);
+ BT_LOGE("unexpected node type: %d", (int) entry_node->type);
ret = -EINVAL;
goto end;
}
*struct_decl = ctx_decl_scope_lookup_struct(ctx->current_scope,
name, -1);
if (!*struct_decl) {
- _PERROR("cannot find \"struct %s\"", name);
+ BT_LOGE("cannot find \"struct %s\"", name);
ret = -EINVAL;
goto error;
}
/* Make a copy of it */
struct_decl_copy = bt_ctf_field_type_copy(*struct_decl);
if (!struct_decl_copy) {
- _PERROR("%s",
+ BT_LOGE(
"cannot create copy of structure field type");
ret = -EINVAL;
goto error;
ctx->current_scope, name, 1);
if (estruct_decl) {
BT_PUT(estruct_decl);
- _PERROR("\"struct %s\" already declared in local scope",
+ BT_LOGE("\"struct %s\" already declared in local scope",
name);
ret = -EINVAL;
goto error;
if (!bt_list_empty(min_align)) {
ret = get_unary_unsigned(min_align, &min_align_value);
if (ret) {
- _PERROR("%s", "unexpected unary expression for structure declaration's \"align\" attribute");
+ BT_LOGE("unexpected unary expression for structure declaration's \"align\" attribute");
goto error;
}
}
*struct_decl = bt_ctf_field_type_structure_create();
if (!*struct_decl) {
- _PERROR("%s", "cannot create structure field type");
+ BT_LOGE("cannot create structure field type");
ret = -ENOMEM;
goto error;
}
ret = bt_ctf_field_type_set_alignment(*struct_decl,
min_align_value);
if (ret) {
- _PERROR("%s", "failed to set structure's minimal alignment");
+ BT_LOGE("failed to set structure's minimal alignment");
goto error;
}
}
ret = ctx_push_scope(ctx);
if (ret) {
- _PERROR("%s", "cannot push scope");
+ BT_LOGE("cannot push scope");
goto error;
}
ret = ctx_decl_scope_register_struct(ctx->current_scope,
name, *struct_decl);
if (ret) {
- _PERROR("cannot register \"struct %s\" in declaration scope",
+ BT_LOGE("cannot register \"struct %s\" in declaration scope",
name);
goto error;
}
ctx_decl_scope_lookup_variant(ctx->current_scope,
name, -1);
if (!untagged_variant_decl) {
- _PERROR("cannot find \"variant %s\"", name);
+ BT_LOGE("cannot find \"variant %s\"", name);
ret = -EINVAL;
goto error;
}
variant_decl_copy = bt_ctf_field_type_copy(
untagged_variant_decl);
if (!variant_decl_copy) {
- _PERROR("%s",
+ BT_LOGE(
"cannot create copy of variant field type");
ret = -EINVAL;
goto error;
if (evariant_decl) {
BT_PUT(evariant_decl);
- _PERROR("\"variant %s\" already declared in local scope",
+ BT_LOGE("\"variant %s\" already declared in local scope",
name);
ret = -EINVAL;
goto error;
untagged_variant_decl = bt_ctf_field_type_variant_create(NULL,
NULL);
if (!untagged_variant_decl) {
- _PERROR("%s", "cannot create variant field type");
+ BT_LOGE("cannot create variant field type");
ret = -ENOMEM;
goto error;
}
ret = ctx_push_scope(ctx);
if (ret) {
- _PERROR("%s", "cannot push scope");
+ BT_LOGE("cannot push scope");
goto error;
}
ctx->current_scope, name,
untagged_variant_decl);
if (ret) {
- _PERROR("cannot register \"variant %s\" in declaration scope",
+ BT_LOGE("cannot register \"variant %s\" in declaration scope",
name);
goto error;
}
int64_t *target;
if (iter->type != NODE_UNARY_EXPRESSION) {
- _PERROR("wrong unary expression for enumeration label \"%s\"",
+ BT_LOGE("wrong unary expression for enumeration label \"%s\"",
label);
ret = -EINVAL;
goto error;
iter->u.unary_expression.u.unsigned_constant;
break;
default:
- _PERROR("invalid enumeration entry: \"%s\"",
+ BT_LOGE("invalid enumeration entry: \"%s\"",
label);
ret = -EINVAL;
goto error;
}
if (nr_vals > 1) {
- _PERROR("invalid enumeration entry: \"%s\"",
+ BT_LOGE("invalid enumeration entry: \"%s\"",
label);
ret = -EINVAL;
goto error;
label, (uint64_t) start, (uint64_t) end);
}
if (ret) {
- _PERROR("cannot add mapping to enumeration for label \"%s\"",
+ BT_LOGE("cannot add mapping to enumeration for label \"%s\"",
label);
goto error;
}
*enum_decl = ctx_decl_scope_lookup_enum(ctx->current_scope,
name, -1);
if (!*enum_decl) {
- _PERROR("cannot find \"enum %s\"", name);
+ BT_LOGE("cannot find \"enum %s\"", name);
ret = -EINVAL;
goto error;
}
/* Make a copy of it */
enum_decl_copy = bt_ctf_field_type_copy(*enum_decl);
if (!enum_decl_copy) {
- _PERROR("%s",
+ BT_LOGE(
"cannot create copy of enumeration field type");
ret = -EINVAL;
goto error;
ctx->current_scope, name, 1);
if (eenum_decl) {
BT_PUT(eenum_decl);
- _PERROR("\"enum %s\" already declared in local scope",
+ BT_LOGE("\"enum %s\" already declared in local scope",
name);
ret = -EINVAL;
goto error;
integer_decl = ctx_decl_scope_lookup_alias(
ctx->current_scope, "int", -1);
if (!integer_decl) {
- _PERROR("%s", "cannot find \"int\" type for enumeration");
+ BT_LOGE("cannot find \"int\" type for enumeration");
ret = -EINVAL;
goto error;
}
assert(integer_decl);
if (!bt_ctf_field_type_is_integer(integer_decl)) {
- _PERROR("%s", "container type for enumeration is not an integer");
+ BT_LOGE("container type for enumeration is not an integer");
ret = -EINVAL;
goto error;
}
*enum_decl = bt_ctf_field_type_enumeration_create(integer_decl);
if (!*enum_decl) {
- _PERROR("%s", "cannot create enumeration field type");
+ BT_LOGE("cannot create enumeration field type");
ret = -ENOMEM;
goto error;
}
*decl = ctx_decl_scope_lookup_alias(ctx->current_scope, str->str, -1);
if (!*decl) {
- _PERROR("cannot find type alias \"%s\"", str->str);
+ BT_LOGE("cannot find type alias \"%s\"", str->str);
ret = -EINVAL;
goto error;
}
/* Make a copy of the type declaration */
decl_copy = bt_ctf_field_type_copy(*decl);
if (!decl_copy) {
- _PERROR("%s", "cannot create field type copy");
+ BT_LOGE("cannot create field type copy");
ret = -EINVAL;
goto error;
}
if (!strcmp(left->u.unary_expression.u.string, "signed")) {
if (_IS_SET(&set, _INTEGER_SIGNED_SET)) {
- _PERROR_DUP_ATTR("signed",
+ BT_LOGE_DUP_ATTR("signed",
"integer declaration");
ret = -EPERM;
goto error;
}
- signedness = get_boolean(ctx->efd, right);
+ signedness = get_boolean(right);
if (signedness < 0) {
ret = -EINVAL;
goto error;
} else if (!strcmp(left->u.unary_expression.u.string,
"byte_order")) {
if (_IS_SET(&set, _INTEGER_BYTE_ORDER_SET)) {
- _PERROR_DUP_ATTR("byte_order",
+ BT_LOGE_DUP_ATTR("byte_order",
"integer declaration");
ret = -EPERM;
goto error;
byte_order = get_real_byte_order(ctx, right);
if (byte_order == BT_CTF_BYTE_ORDER_UNKNOWN) {
- _PERROR("%s", "invalid \"byte_order\" attribute in integer declaration");
+ BT_LOGE("invalid \"byte_order\" attribute in integer declaration");
ret = -EINVAL;
goto error;
}
_SET(&set, _INTEGER_BYTE_ORDER_SET);
} else if (!strcmp(left->u.unary_expression.u.string, "size")) {
if (_IS_SET(&set, _INTEGER_SIZE_SET)) {
- _PERROR_DUP_ATTR("size",
+ BT_LOGE_DUP_ATTR("size",
"integer declaration");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- _PERROR("%s", "invalid \"size\" attribute in integer declaration: expecting unsigned constant");
+ BT_LOGE("invalid \"size\" attribute in integer declaration: expecting unsigned constant");
ret = -EINVAL;
goto error;
}
size = right->u.unary_expression.u.unsigned_constant;
if (size == 0) {
- _PERROR("%s", "invalid \"size\" attribute in integer declaration: expecting positive constant");
+ BT_LOGE("invalid \"size\" attribute in integer declaration: expecting positive constant");
ret = -EINVAL;
goto error;
} else if (size > 64) {
- _PERROR("%s", "invalid \"size\" attribute in integer declaration: integers over 64-bit are not supported as of this version");
+ BT_LOGE("invalid \"size\" attribute in integer declaration: integers over 64-bit are not supported as of this version");
ret = -EINVAL;
goto error;
}
} else if (!strcmp(left->u.unary_expression.u.string,
"align")) {
if (_IS_SET(&set, _INTEGER_ALIGN_SET)) {
- _PERROR_DUP_ATTR("align",
+ BT_LOGE_DUP_ATTR("align",
"integer declaration");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- _PERROR("%s", "invalid \"align\" attribute in integer declaration: expecting unsigned constant");
+ BT_LOGE("invalid \"align\" attribute in integer declaration: expecting unsigned constant");
ret = -EINVAL;
goto error;
}
alignment =
right->u.unary_expression.u.unsigned_constant;
if (!is_align_valid(alignment)) {
- _PERROR("%s", "invalid \"align\" attribute in integer declaration: expecting power of two");
+ BT_LOGE("invalid \"align\" attribute in integer declaration: expecting power of two");
ret = -EINVAL;
goto error;
}
_SET(&set, _INTEGER_ALIGN_SET);
} else if (!strcmp(left->u.unary_expression.u.string, "base")) {
if (_IS_SET(&set, _INTEGER_BASE_SET)) {
- _PERROR_DUP_ATTR("base", "integer declaration");
+ BT_LOGE_DUP_ATTR("base", "integer declaration");
ret = -EPERM;
goto error;
}
base = BT_CTF_INTEGER_BASE_HEXADECIMAL;
break;
default:
- _PERROR("invalid \"base\" attribute in integer declaration: %" PRIu64,
+ BT_LOGE("invalid \"base\" attribute in integer declaration: %" PRIu64,
right->u.unary_expression.u.unsigned_constant);
ret = -EINVAL;
goto error;
char *s_right = concatenate_unary_strings(
&expression->u.ctf_expression.right);
if (!s_right) {
- _PERROR("%s", "unexpected unary expression for integer declaration's \"base\" attribute");
+ BT_LOGE("unexpected unary expression for integer declaration's \"base\" attribute");
ret = -EINVAL;
goto error;
}
!strcmp(s_right, "b")) {
base = BT_CTF_INTEGER_BASE_BINARY;
} else {
- _PERROR("unexpected unary expression for integer declaration's \"base\" attribute: \"%s\"",
+ BT_LOGE("unexpected unary expression for integer declaration's \"base\" attribute: \"%s\"",
s_right);
g_free(s_right);
ret = -EINVAL;
break;
}
default:
- _PERROR("%s", "invalid \"base\" attribute in integer declaration: expecting unsigned constant or unary string");
+ BT_LOGE("invalid \"base\" attribute in integer declaration: expecting unsigned constant or unary string");
ret = -EINVAL;
goto error;
}
char *s_right;
if (_IS_SET(&set, _INTEGER_ENCODING_SET)) {
- _PERROR_DUP_ATTR("encoding",
+ BT_LOGE_DUP_ATTR("encoding",
"integer declaration");
ret = -EPERM;
goto error;
}
if (right->u.unary_expression.type != UNARY_STRING) {
- _PERROR("%s", "invalid \"encoding\" attribute in integer declaration: expecting unary string");
+ BT_LOGE("invalid \"encoding\" attribute in integer declaration: expecting unary string");
ret = -EINVAL;
goto error;
}
s_right = concatenate_unary_strings(
&expression->u.ctf_expression.right);
if (!s_right) {
- _PERROR("%s", "unexpected unary expression for integer declaration's \"encoding\" attribute");
+ BT_LOGE("unexpected unary expression for integer declaration's \"encoding\" attribute");
ret = -EINVAL;
goto error;
}
} else if (!strcmp(s_right, "none")) {
encoding = BT_CTF_STRING_ENCODING_NONE;
} else {
- _PERROR("invalid \"encoding\" attribute in integer declaration: unknown encoding \"%s\"",
+ BT_LOGE("invalid \"encoding\" attribute in integer declaration: unknown encoding \"%s\"",
s_right);
g_free(s_right);
ret = -EINVAL;
const char *clock_name;
if (_IS_SET(&set, _INTEGER_MAP_SET)) {
- _PERROR_DUP_ATTR("map", "integer declaration");
+ BT_LOGE_DUP_ATTR("map", "integer declaration");
ret = -EPERM;
goto error;
}
if (right->u.unary_expression.type != UNARY_STRING) {
- _PERROR("%s", "invalid \"map\" attribute in integer declaration: expecting unary string");
+ BT_LOGE("invalid \"map\" attribute in integer declaration: expecting unary string");
ret = -EINVAL;
goto error;
}
&expression->u.ctf_expression.right);
if (!s_right) {
- _PERROR("%s", "unexpected unary expression for integer declaration's \"map\" attribute");
+ BT_LOGE("unexpected unary expression for integer declaration's \"map\" attribute");
ret = -EINVAL;
goto error;
}
- _PWARNING("invalid \"map\" attribute in integer declaration: unknown clock class: \"%s\"",
+ BT_LOGW("invalid \"map\" attribute in integer declaration: unknown clock class: \"%s\"",
s_right);
_SET(&set, _INTEGER_MAP_SET);
g_free(s_right);
mapped_clock = bt_ctf_trace_get_clock_class_by_name(
ctx->trace, clock_name);
if (!mapped_clock) {
- _PERROR("invalid \"map\" attribute in integer declaration: cannot find clock class \"%s\"",
+ BT_LOGE("invalid \"map\" attribute in integer declaration: cannot find clock class \"%s\"",
clock_name);
ret = -EINVAL;
goto error;
_SET(&set, _INTEGER_MAP_SET);
} else {
- _PWARNING("unknown attribute \"%s\" in integer declaration",
+ BT_LOGW("unknown attribute \"%s\" in integer declaration",
left->u.unary_expression.u.string);
}
}
if (!_IS_SET(&set, _INTEGER_SIZE_SET)) {
- _PERROR("%s",
+ BT_LOGE(
"missing \"size\" attribute in integer declaration");
ret = -EPERM;
goto error;
*integer_decl = bt_ctf_field_type_integer_create((unsigned int) size);
if (!*integer_decl) {
- _PERROR("%s", "cannot create integer field type");
+ BT_LOGE("cannot create integer field type");
ret = -ENOMEM;
goto error;
}
}
if (ret) {
- _PERROR("%s", "cannot configure integer field type");
+ BT_LOGE("cannot configure integer field type");
ret = -EINVAL;
goto error;
}
if (!strcmp(left->u.unary_expression.u.string, "byte_order")) {
if (_IS_SET(&set, _FLOAT_BYTE_ORDER_SET)) {
- _PERROR_DUP_ATTR("byte_order",
+ BT_LOGE_DUP_ATTR("byte_order",
"floating point number declaration");
ret = -EPERM;
goto error;
byte_order = get_real_byte_order(ctx, right);
if (byte_order == BT_CTF_BYTE_ORDER_UNKNOWN) {
- _PERROR("%s", "invalid \"byte_order\" attribute in floating point number declaration");
+ BT_LOGE("invalid \"byte_order\" attribute in floating point number declaration");
ret = -EINVAL;
goto error;
}
} else if (!strcmp(left->u.unary_expression.u.string,
"exp_dig")) {
if (_IS_SET(&set, _FLOAT_EXP_DIG_SET)) {
- _PERROR_DUP_ATTR("exp_dig",
+ BT_LOGE_DUP_ATTR("exp_dig",
"floating point number declaration");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- _PERROR("%s", "invalid \"exp_dig\" attribute in floating point number declaration: expecting unsigned constant");
+ BT_LOGE("invalid \"exp_dig\" attribute in floating point number declaration: expecting unsigned constant");
ret = -EINVAL;
goto error;
}
} else if (!strcmp(left->u.unary_expression.u.string,
"mant_dig")) {
if (_IS_SET(&set, _FLOAT_MANT_DIG_SET)) {
- _PERROR_DUP_ATTR("mant_dig",
+ BT_LOGE_DUP_ATTR("mant_dig",
"floating point number declaration");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- _PERROR("%s", "invalid \"mant_dig\" attribute in floating point number declaration: expecting unsigned constant");
+ BT_LOGE("invalid \"mant_dig\" attribute in floating point number declaration: expecting unsigned constant");
ret = -EINVAL;
goto error;
}
} else if (!strcmp(left->u.unary_expression.u.string,
"align")) {
if (_IS_SET(&set, _FLOAT_ALIGN_SET)) {
- _PERROR_DUP_ATTR("align",
+ BT_LOGE_DUP_ATTR("align",
"floating point number declaration");
ret = -EPERM;
goto error;
if (right->u.unary_expression.type !=
UNARY_UNSIGNED_CONSTANT) {
- _PERROR("%s", "invalid \"align\" attribute in floating point number declaration: expecting unsigned constant");
+ BT_LOGE("invalid \"align\" attribute in floating point number declaration: expecting unsigned constant");
ret = -EINVAL;
goto error;
}
unsigned_constant;
if (!is_align_valid(alignment)) {
- _PERROR("%s", "invalid \"align\" attribute in floating point number declaration: expecting power of two");
+ BT_LOGE("invalid \"align\" attribute in floating point number declaration: expecting power of two");
ret = -EINVAL;
goto error;
}
_SET(&set, _FLOAT_ALIGN_SET);
} else {
- _PWARNING("unknown attribute \"%s\" in floating point number declaration",
+ BT_LOGW("unknown attribute \"%s\" in floating point number declaration",
left->u.unary_expression.u.string);
}
}
if (!_IS_SET(&set, _FLOAT_MANT_DIG_SET)) {
- _PERROR("%s", "missing \"mant_dig\" attribute in floating point number declaration");
+ BT_LOGE("missing \"mant_dig\" attribute in floating point number declaration");
ret = -EPERM;
goto error;
}
if (!_IS_SET(&set, _FLOAT_EXP_DIG_SET)) {
- _PERROR("%s", "missing \"exp_dig\" attribute in floating point number declaration");
+ BT_LOGE("missing \"exp_dig\" attribute in floating point number declaration");
ret = -EPERM;
goto error;
}
*float_decl = bt_ctf_field_type_floating_point_create();
if (!*float_decl) {
- _PERROR("%s",
+ BT_LOGE(
"cannot create floating point number field type");
ret = -ENOMEM;
goto error;
ret |= bt_ctf_field_type_set_byte_order(*float_decl, byte_order);
ret |= bt_ctf_field_type_set_alignment(*float_decl, alignment);
if (ret) {
- _PERROR("%s",
+ BT_LOGE(
"cannot configure floating point number field type");
ret = -EINVAL;
goto error;
char *s_right;
if (_IS_SET(&set, _STRING_ENCODING_SET)) {
- _PERROR_DUP_ATTR("encoding",
+ BT_LOGE_DUP_ATTR("encoding",
"string declaration");
ret = -EPERM;
goto error;
}
if (right->u.unary_expression.type != UNARY_STRING) {
- _PERROR("%s", "invalid \"encoding\" attribute in string declaration: expecting unary string");
+ BT_LOGE("invalid \"encoding\" attribute in string declaration: expecting unary string");
ret = -EINVAL;
goto error;
}
s_right = concatenate_unary_strings(
&expression->u.ctf_expression.right);
if (!s_right) {
- _PERROR("%s", "unexpected unary expression for string declaration's \"encoding\" attribute");
+ BT_LOGE("unexpected unary expression for string declaration's \"encoding\" attribute");
ret = -EINVAL;
goto error;
}
} else if (!strcmp(s_right, "none")) {
encoding = BT_CTF_STRING_ENCODING_NONE;
} else {
- _PERROR("invalid \"encoding\" attribute in string declaration: unknown encoding \"%s\"",
+ BT_LOGE("invalid \"encoding\" attribute in string declaration: unknown encoding \"%s\"",
s_right);
g_free(s_right);
ret = -EINVAL;
g_free(s_right);
_SET(&set, _STRING_ENCODING_SET);
} else {
- _PWARNING("unknown attribute \"%s\" in string declaration",
+ BT_LOGW("unknown attribute \"%s\" in string declaration",
left->u.unary_expression.u.string);
}
}
*string_decl = bt_ctf_field_type_string_create();
if (!*string_decl) {
- _PERROR("%s", "cannot create string field type");
+ BT_LOGE("cannot create string field type");
ret = -ENOMEM;
goto error;
}
ret = bt_ctf_field_type_string_set_encoding(*string_decl, encoding);
if (ret) {
- _PERROR("%s", "cannot configure string field type");
+ BT_LOGE("cannot configure string field type");
ret = -EINVAL;
goto error;
}
}
break;
default:
- _PERROR("unexpected node type: %d",
+ BT_LOGE("unexpected node type: %d",
(int) first->u.type_specifier.type);
ret = -EINVAL;
goto error;
ret = visit_typedef(ctx, node->u._typedef.type_specifier_list,
&node->u._typedef.type_declarators);
if (ret) {
- _PERROR("%s",
+ BT_LOGE(
"cannot add typedef in \"event\" declaration");
goto error;
}
ret = visit_typealias(ctx, node->u.typealias.target,
node->u.typealias.alias);
if (ret) {
- _PERROR("%s", "cannot add typealias in \"event\" declaration");
+ BT_LOGE("cannot add typealias in \"event\" declaration");
goto error;
}
break;
if (!strcmp(left, "name")) {
/* This is already known at this stage */
if (_IS_SET(set, _EVENT_NAME_SET)) {
- _PERROR_DUP_ATTR("name", "event declaration");
+ BT_LOGE_DUP_ATTR("name", "event declaration");
ret = -EPERM;
goto error;
}
int64_t id;
if (_IS_SET(set, _EVENT_ID_SET)) {
- _PERROR_DUP_ATTR("id", "event declaration");
+ BT_LOGE_DUP_ATTR("id", "event declaration");
ret = -EPERM;
goto error;
}
(uint64_t *) &id);
/* Only read "id" if get_unary_unsigned() succeeded. */
if (ret || (!ret && id < 0)) {
- _PERROR("%s", "unexpected unary expression for event declaration's \"id\" attribute");
+ BT_LOGE("unexpected unary expression for event declaration's \"id\" attribute");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_event_class_set_id(event_class, id);
if (ret) {
- _PERROR("%s",
+ BT_LOGE(
"cannot set event declaration's ID");
goto error;
}
_SET(set, _EVENT_ID_SET);
} else if (!strcmp(left, "stream_id")) {
if (_IS_SET(set, _EVENT_STREAM_ID_SET)) {
- _PERROR_DUP_ATTR("stream_id",
+ BT_LOGE_DUP_ATTR("stream_id",
"event declaration");
ret = -EPERM;
goto error;
* succeeded.
*/
if (ret || (!ret && *stream_id < 0)) {
- _PERROR("%s", "unexpected unary expression for event declaration's \"stream_id\" attribute");
+ BT_LOGE("unexpected unary expression for event declaration'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)) {
- _PERROR("%s", "duplicate \"context\" entry in event declaration");
+ BT_LOGE("duplicate \"context\" entry in event declaration");
ret = -EPERM;
goto error;
}
struct ctf_node, siblings),
&decl);
if (ret) {
- _PERROR("%s", "cannot create event context declaration");
+ BT_LOGE("cannot create event context declaration");
goto error;
}
event_class, decl);
BT_PUT(decl);
if (ret) {
- _PERROR("%s", "cannot set event's context declaration");
+ BT_LOGE("cannot set event's context declaration");
goto error;
}
_SET(set, _EVENT_CONTEXT_SET);
} else if (!strcmp(left, "fields")) {
if (_IS_SET(set, _EVENT_FIELDS_SET)) {
- _PERROR("%s", "duplicate \"fields\" entry in event declaration");
+ BT_LOGE("duplicate \"fields\" entry in event declaration");
ret = -EPERM;
goto error;
}
struct ctf_node, siblings),
&decl);
if (ret) {
- _PERROR("%s", "cannot create event payload field type");
+ BT_LOGE("cannot create event payload field type");
goto error;
}
event_class, decl);
BT_PUT(decl);
if (ret) {
- _PERROR("%s", "cannot set event's payload field type");
+ BT_LOGE("cannot set event's payload field type");
goto error;
}
struct bt_value *value_obj, *str_obj;
if (_IS_SET(set, _EVENT_LOGLEVEL_SET)) {
- _PERROR_DUP_ATTR("loglevel",
+ BT_LOGE_DUP_ATTR("loglevel",
"event declaration");
ret = -EPERM;
goto error;
ret = get_unary_unsigned(&node->u.ctf_expression.right,
&loglevel_value);
if (ret) {
- _PERROR("%s", "unexpected unary expression for event declaration's \"loglevel\" attribute");
+ BT_LOGE("unexpected unary expression for event declaration's \"loglevel\" attribute");
ret = -EINVAL;
goto error;
}
value_obj = bt_value_integer_create_init(loglevel_value);
if (!value_obj) {
- _PERROR("%s", "cannot allocate memory for loglevel value object");
+ BT_LOGE("cannot allocate memory for loglevel value object");
ret = -ENOMEM;
goto error;
}
if (bt_ctf_event_class_set_attribute(event_class,
"loglevel", value_obj) != BT_VALUE_STATUS_OK) {
- _PERROR("%s", "cannot set loglevel value");
+ BT_LOGE("cannot set loglevel value");
ret = -EINVAL;
bt_put(value_obj);
goto error;
str_obj = bt_value_string_create_init(loglevel_str);
if (bt_ctf_event_class_set_attribute(event_class,
"loglevel_string", str_obj) != BT_VALUE_STATUS_OK) {
- _PERROR("%s", "cannot set loglevel string");
+ BT_LOGE("cannot set loglevel string");
ret = -EINVAL;
bt_put(str_obj);
goto error;
char *right;
if (_IS_SET(set, _EVENT_MODEL_EMF_URI_SET)) {
- _PERROR_DUP_ATTR("model.emf.uri",
+ BT_LOGE_DUP_ATTR("model.emf.uri",
"event declaration");
ret = -EPERM;
goto error;
right = concatenate_unary_strings(
&node->u.ctf_expression.right);
if (!right) {
- _PERROR("%s", "unexpected unary expression for event declaration's \"model.emf.uri\" attribute");
+ BT_LOGE("unexpected unary expression for event declaration's \"model.emf.uri\" attribute");
ret = -EINVAL;
goto error;
}
g_free(right);
_SET(set, _EVENT_MODEL_EMF_URI_SET);
} else {
- _PWARNING("unknown attribute \"%s\" in event declaration",
+ BT_LOGW("unknown attribute \"%s\" in event declaration",
left);
}
name = concatenate_unary_strings(
&iter->u.ctf_expression.right);
if (!name) {
- _PERROR("%s", "unexpected unary expression for event declaration's \"name\" attribute");
+ BT_LOGE("unexpected unary expression for event declaration's \"name\" attribute");
goto error;
}
}
/* Context type. */
ret = bt_ctf_event_class_set_context_type(event_class, NULL);
if (ret) {
- _PERROR("%s", "cannot set initial NULL event context");
+ BT_LOGE("cannot set initial NULL event context");
goto end;
}
/* Event payload. */
ret = bt_ctf_event_class_set_payload_type(event_class, NULL);
if (ret) {
- _PERROR("%s", "cannot set initial NULL event payload");
+ BT_LOGE("cannot set initial NULL event payload");
goto end;
}
end:
/* Packet context. */
ret = bt_ctf_stream_class_set_packet_context_type(stream_class, NULL);
if (ret) {
- _PERROR("%s", "cannot set initial empty packet context");
+ BT_LOGE("cannot set initial empty packet context");
goto end;
}
/* Event header. */
ret = bt_ctf_stream_class_set_event_header_type(stream_class, NULL);
if (ret) {
- _PERROR("%s", "cannot set initial empty event header");
+ BT_LOGE("cannot set initial empty event header");
goto end;
}
/* Event context. */
ret = bt_ctf_stream_class_set_event_context_type(stream_class, NULL);
if (ret) {
- _PERROR("%s", "cannot set initial empty stream event context");
+ BT_LOGE("cannot set initial empty stream event context");
goto end;
}
end:
stream_class = bt_ctf_stream_class_create(NULL);
if (!stream_class) {
- _PERROR("%s", "cannot create stream class");
+ BT_LOGE("cannot create stream class");
goto error;
}
node->visited = TRUE;
event_name = get_event_decl_name(ctx, node);
if (!event_name) {
- _PERROR("%s",
+ BT_LOGE(
"missing \"name\" attribute in event declaration");
ret = -EPERM;
goto error;
ret = ctx_push_scope(ctx);
if (ret) {
- _PERROR("%s", "cannot push scope");
+ BT_LOGE("cannot push scope");
goto error;
}
ret = bt_ctf_stream_class_set_id(new_stream_class, 0);
if (ret) {
- _PERROR("%s", "cannot set stream class's ID");
+ BT_LOGE("cannot set stream class's ID");
BT_PUT(new_stream_class);
goto error;
}
}
break;
default:
- _PERROR("%s", "missing \"stream_id\" attribute in event declaration");
+ BT_LOGE("missing \"stream_id\" attribute in event declaration");
ret = -EPERM;
goto error;
}
stream_class = bt_ctf_trace_get_stream_class_by_id(ctx->trace,
stream_id);
if (!stream_class) {
- _PERROR("cannot find stream class with ID %" PRId64,
+ BT_LOGE("cannot find stream class with ID %" PRId64,
stream_id);
ret = -EINVAL;
goto error;
/* Allow only one event without ID per stream */
if (bt_ctf_stream_class_get_event_class_count(stream_class) !=
0) {
- _PERROR("%s",
+ BT_LOGE(
"missing \"id\" field in event declaration");
ret = -EPERM;
goto error;
/* Automatic ID */
ret = bt_ctf_event_class_set_id(event_class, 0);
if (ret) {
- _PERROR("%s", "cannot set event's ID");
+ BT_LOGE("cannot set event's ID");
goto error;
}
}
event_id = bt_ctf_event_class_get_id(event_class);
if (event_id < 0) {
- _PERROR("%s", "cannot get event's ID");
+ BT_LOGE("cannot get event's ID");
ret = -EINVAL;
goto error;
}
event_id);
if (eevent_class) {
BT_PUT(eevent_class);
- _PERROR("duplicate event with ID %" PRId64 " in same stream", event_id);
+ BT_LOGE("duplicate event with ID %" PRId64 " in same stream", event_id);
ret = -EEXIST;
goto error;
}
ret = bt_ctf_stream_class_add_event_class(stream_class, event_class);
BT_PUT(event_class);
if (ret) {
- _PERROR("%s", "cannot add event class to stream class");
+ BT_LOGE("cannot add event class to stream class");
goto error;
}
ret = visit_typedef(ctx, node->u._typedef.type_specifier_list,
&node->u._typedef.type_declarators);
if (ret) {
- _PERROR("%s",
+ BT_LOGE(
"cannot add typedef in \"stream\" declaration");
goto error;
}
ret = visit_typealias(ctx, node->u.typealias.target,
node->u.typealias.alias);
if (ret) {
- _PERROR("%s", "cannot add typealias in \"stream\" declaration");
+ BT_LOGE("cannot add typealias in \"stream\" declaration");
goto error;
}
break;
gpointer ptr;
if (_IS_SET(set, _STREAM_ID_SET)) {
- _PERROR_DUP_ATTR("id", "stream declaration");
+ BT_LOGE_DUP_ATTR("id", "stream declaration");
ret = -EPERM;
goto error;
}
(uint64_t *) &id);
/* Only read "id" if get_unary_unsigned() succeeded. */
if (ret || (!ret && id < 0)) {
- _PERROR("%s", "unexpected unary expression for stream declaration's \"id\" attribute");
+ BT_LOGE("unexpected unary expression for stream declaration's \"id\" attribute");
ret = -EINVAL;
goto error;
}
ptr = g_hash_table_lookup(ctx->stream_classes,
(gpointer) id);
if (ptr) {
- _PERROR("duplicate stream with ID %" PRId64,
+ BT_LOGE("duplicate stream with ID %" PRId64,
id);
ret = -EEXIST;
goto error;
ret = bt_ctf_stream_class_set_id(stream_class, id);
if (ret) {
- _PERROR("%s",
+ BT_LOGE(
"cannot set stream class's ID");
goto error;
}
_SET(set, _STREAM_ID_SET);
} else if (!strcmp(left, "event.header")) {
if (_IS_SET(set, _STREAM_EVENT_HEADER_SET)) {
- _PERROR("%s", "duplicate \"event.header\" entry in stream declaration");
+ BT_LOGE("duplicate \"event.header\" entry in stream declaration");
ret = -EPERM;
goto error;
}
struct ctf_node, siblings),
&decl);
if (ret) {
- _PERROR("%s", "cannot create event header field type");
+ BT_LOGE("cannot create event header field type");
goto error;
}
stream_class, decl);
BT_PUT(decl);
if (ret) {
- _PERROR("%s", "cannot set stream's event header field type");
+ BT_LOGE("cannot set stream's event header field type");
goto error;
}
_SET(set, _STREAM_EVENT_HEADER_SET);
} else if (!strcmp(left, "event.context")) {
if (_IS_SET(set, _STREAM_EVENT_CONTEXT_SET)) {
- _PERROR("%s", "duplicate \"event.context\" entry in stream declaration");
+ BT_LOGE("duplicate \"event.context\" entry in stream declaration");
ret = -EPERM;
goto error;
}
struct ctf_node, siblings),
&decl);
if (ret) {
- _PERROR("%s", "cannot create stream event context field type");
+ BT_LOGE("cannot create stream event context field type");
goto error;
}
stream_class, decl);
BT_PUT(decl);
if (ret) {
- _PERROR("%s", "cannot set stream's event context field type");
+ BT_LOGE("cannot set stream's event context field type");
goto error;
}
_SET(set, _STREAM_EVENT_CONTEXT_SET);
} else if (!strcmp(left, "packet.context")) {
if (_IS_SET(set, _STREAM_PACKET_CONTEXT_SET)) {
- _PERROR("%s", "duplicate \"packet.context\" entry in stream declaration");
+ BT_LOGE("duplicate \"packet.context\" entry in stream declaration");
ret = -EPERM;
goto error;
}
struct ctf_node, siblings),
&decl);
if (ret) {
- _PERROR("%s", "cannot create packet context field type");
+ BT_LOGE("cannot create packet context field type");
goto error;
}
stream_class, decl);
BT_PUT(decl);
if (ret) {
- _PERROR("%s", "cannot set stream's packet context field type");
+ BT_LOGE("cannot set stream's packet context field type");
goto error;
}
_SET(set, _STREAM_PACKET_CONTEXT_SET);
} else {
- _PWARNING("unknown attribute \"%s\" in stream declaration",
+ BT_LOGW("unknown attribute \"%s\" in stream declaration",
left);
}
ret = ctx_push_scope(ctx);
if (ret) {
- _PERROR("%s", "cannot push scope");
+ BT_LOGE("cannot push scope");
goto error;
}
packet_header_decl =
bt_ctf_trace_get_packet_header_type(ctx->trace);
if (!packet_header_decl) {
- _PERROR("%s",
+ BT_LOGE(
"cannot get trace packet header field type");
goto error;
}
packet_header_decl, "stream_id");
BT_PUT(packet_header_decl);
if (!stream_id_decl) {
- _PERROR("%s", "missing \"stream_id\" field in packet header declaration, but \"id\" attribute is declared for stream");
+ BT_LOGE("missing \"stream_id\" field in packet header declaration, but \"id\" attribute is declared for stream");
goto error;
}
if (!bt_ctf_field_type_is_integer(stream_id_decl)) {
BT_PUT(stream_id_decl);
- _PERROR("%s", "\"stream_id\" field in packet header declaration is not an integer");
+ BT_LOGE("\"stream_id\" field in packet header declaration is not an integer");
goto error;
}
} else {
/* Allow only _one_ ID-less stream */
if (g_hash_table_size(ctx->stream_classes) != 0) {
- _PERROR("%s",
+ BT_LOGE(
"missing \"id\" field in stream declaration");
ret = -EPERM;
goto error;
id = bt_ctf_stream_class_get_id(stream_class);
if (id < 0) {
- _PERROR("wrong stream ID: %" PRId64, id);
+ BT_LOGE("wrong stream ID: %" PRId64, id);
ret = -EINVAL;
goto error;
}
* the trace.
*/
if (g_hash_table_lookup(ctx->stream_classes, (gpointer) id)) {
- _PERROR("a stream class with ID: %" PRId64 " already exists in the trace", id);
+ BT_LOGE("a stream class with ID: %" PRId64 " already exists in the trace", id);
ret = -EINVAL;
goto error;
}
existing_stream_class = bt_ctf_trace_get_stream_class_by_id(ctx->trace,
id);
if (existing_stream_class) {
- _PERROR("a stream class with ID: %" PRId64 " already exists in the trace", id);
+ BT_LOGE("a stream class with ID: %" PRId64 " already exists in the trace", id);
ret = -EINVAL;
goto error;
}
ret = visit_typedef(ctx, node->u._typedef.type_specifier_list,
&node->u._typedef.type_declarators);
if (ret) {
- _PERROR("%s",
+ BT_LOGE(
"cannot add typedef in \"trace\" declaration");
goto error;
}
ret = visit_typealias(ctx, node->u.typealias.target,
node->u.typealias.alias);
if (ret) {
- _PERROR("%s",
+ BT_LOGE(
"cannot add typealias in \"trace\" declaration");
goto error;
}
if (!strcmp(left, "major")) {
if (_IS_SET(set, _TRACE_MAJOR_SET)) {
- _PERROR_DUP_ATTR("major", "trace declaration");
+ BT_LOGE_DUP_ATTR("major", "trace declaration");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(&node->u.ctf_expression.right,
&ctx->trace_major);
if (ret) {
- _PERROR("%s", "unexpected unary expression for trace's \"major\" attribute");
+ BT_LOGE("unexpected unary expression for trace's \"major\" attribute");
ret = -EINVAL;
goto error;
}
_SET(set, _TRACE_MAJOR_SET);
} else if (!strcmp(left, "minor")) {
if (_IS_SET(set, _TRACE_MINOR_SET)) {
- _PERROR_DUP_ATTR("minor", "trace declaration");
+ BT_LOGE_DUP_ATTR("minor", "trace declaration");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(&node->u.ctf_expression.right,
&ctx->trace_minor);
if (ret) {
- _PERROR("%s", "unexpected unary expression for trace's \"minor\" attribute");
+ BT_LOGE("unexpected unary expression for trace's \"minor\" attribute");
ret = -EINVAL;
goto error;
}
_SET(set, _TRACE_MINOR_SET);
} else if (!strcmp(left, "uuid")) {
if (_IS_SET(set, _TRACE_UUID_SET)) {
- _PERROR_DUP_ATTR("uuid", "trace declaration");
+ BT_LOGE_DUP_ATTR("uuid", "trace declaration");
ret = -EPERM;
goto error;
}
ret = get_unary_uuid(&node->u.ctf_expression.right,
ctx->trace_uuid);
if (ret) {
- _PERROR("%s",
+ BT_LOGE(
"invalid trace declaration's UUID");
goto error;
}
ret = bt_ctf_trace_set_uuid(ctx->trace, ctx->trace_uuid);
if (ret) {
- _PERROR("%s",
+ BT_LOGE(
"cannot set trace's UUID");
goto error;
}
} else if (!strcmp(left, "byte_order")) {
/* Native byte order is already known at this stage */
if (_IS_SET(set, _TRACE_BYTE_ORDER_SET)) {
- _PERROR_DUP_ATTR("byte_order",
+ BT_LOGE_DUP_ATTR("byte_order",
"trace declaration");
ret = -EPERM;
goto error;
_SET(set, _TRACE_BYTE_ORDER_SET);
} else if (!strcmp(left, "packet.header")) {
if (_IS_SET(set, _TRACE_PACKET_HEADER_SET)) {
- _PERROR("%s", "duplicate \"packet.header\" entry in trace declaration");
+ BT_LOGE("duplicate \"packet.header\" entry in trace declaration");
ret = -EPERM;
goto error;
}
struct ctf_node, siblings),
&packet_header_decl);
if (ret) {
- _PERROR("%s", "cannot create packet header field type");
+ BT_LOGE("cannot create packet header field type");
goto error;
}
packet_header_decl);
BT_PUT(packet_header_decl);
if (ret) {
- _PERROR("%s", "cannot set trace's packet header field type");
+ BT_LOGE("cannot set trace's packet header field type");
goto error;
}
_SET(set, _TRACE_PACKET_HEADER_SET);
} else {
- _PWARNING("%s", "unknown attribute \"%s\" in trace declaration");
+ BT_LOGW("unknown attribute \"%s\" in trace declaration", left);
}
g_free(left);
break;
}
default:
- _PERROR("%s", "unknown expression in trace declaration");
+ BT_LOGE("unknown expression in trace declaration");
ret = -EINVAL;
goto error;
}
node->visited = TRUE;
if (ctx->is_trace_visited) {
- _PERROR("%s", "duplicate \"trace\" block");
+ BT_LOGE("duplicate \"trace\" block");
ret = -EEXIST;
goto error;
}
ret = ctx_push_scope(ctx);
if (ret) {
- _PERROR("%s", "cannot push scope");
+ BT_LOGE("cannot push scope");
goto error;
}
ctx_pop_scope(ctx);
if (!_IS_SET(&set, _TRACE_MAJOR_SET)) {
- _PERROR("%s",
+ BT_LOGE(
"missing \"major\" attribute in trace declaration");
ret = -EPERM;
goto error;
}
if (!_IS_SET(&set, _TRACE_MINOR_SET)) {
- _PERROR("%s",
+ BT_LOGE(
"missing \"minor\" attribute in trace declaration");
ret = -EPERM;
goto error;
}
if (!_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
- _PERROR("%s", "missing \"byte_order\" attribute in trace declaration");
+ BT_LOGE("missing \"byte_order\" attribute in trace declaration");
ret = -EPERM;
goto error;
}
&entry_node->u.ctf_expression.right;
if (entry_node->type != NODE_CTF_EXPRESSION) {
- _PERROR("%s", "wrong expression in environment entry");
+ BT_LOGE("wrong expression in environment entry");
ret = -EPERM;
goto error;
}
left = concatenate_unary_strings(
&entry_node->u.ctf_expression.left);
if (!left) {
- _PERROR("%s", "cannot get environment entry name");
+ BT_LOGE("cannot get environment entry name");
ret = -EINVAL;
goto error;
}
char *right = concatenate_unary_strings(right_head);
if (!right) {
- _PERROR("unexpected unary expression for environment entry's value (\"%s\")",
+ BT_LOGE("unexpected unary expression for environment entry's value (\"%s\")",
left);
ret = -EINVAL;
goto error;
g_free(right);
if (ret) {
- _PERROR("environment: cannot add entry \"%s\" to trace",
+ BT_LOGE("environment: cannot add entry \"%s\" to trace",
left);
goto error;
}
ret = get_unary_signed(right_head, &v);
}
if (ret) {
- _PERROR("unexpected unary expression for environment entry's value (\"%s\")",
+ BT_LOGE("unexpected unary expression for environment entry's value (\"%s\")",
left);
ret = -EINVAL;
goto error;
ret = bt_ctf_trace_set_environment_field_integer(
ctx->trace, left, v);
if (ret) {
- _PERROR("environment: cannot add entry \"%s\" to trace",
+ BT_LOGE("environment: cannot add entry \"%s\" to trace",
left);
goto error;
}
enum bt_ctf_byte_order bo;
if (_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
- _PERROR_DUP_ATTR("byte_order",
+ BT_LOGE_DUP_ATTR("byte_order",
"trace declaration");
ret = -EPERM;
goto error;
right_node = _BT_LIST_FIRST_ENTRY(
&node->u.ctf_expression.right,
struct ctf_node, siblings);
- bo = byte_order_from_unary_expr(ctx->efd,
- right_node);
+ bo = byte_order_from_unary_expr(right_node);
if (bo == BT_CTF_BYTE_ORDER_UNKNOWN) {
- _PERROR("%s", "unknown \"byte_order\" attribute in trace declaration");
+ BT_LOGE("unknown \"byte_order\" attribute in trace declaration");
ret = -EINVAL;
goto error;
} else if (bo == BT_CTF_BYTE_ORDER_NATIVE) {
- _PERROR("%s", "\"byte_order\" attribute cannot be set to \"native\" in trace declaration");
+ BT_LOGE("\"byte_order\" attribute cannot be set to \"native\" in trace declaration");
ret = -EPERM;
goto error;
}
ret = bt_ctf_trace_set_native_byte_order(
ctx->trace, bo);
if (ret) {
- _PERROR("cannot set trace's byte order (%d)",
+ BT_LOGE("cannot set trace's byte order (%d)",
ret);
goto error;
}
}
if (!_IS_SET(&set, _TRACE_BYTE_ORDER_SET)) {
- _PERROR("%s", "missing \"byte_order\" attribute in trace declaration");
+ BT_LOGE("missing \"byte_order\" attribute in trace declaration");
ret = -EINVAL;
goto error;
}
char *right;
if (_IS_SET(set, _CLOCK_NAME_SET)) {
- _PERROR_DUP_ATTR("name", "clock class declaration");
+ BT_LOGE_DUP_ATTR("name", "clock class declaration");
ret = -EPERM;
goto error;
}
right = concatenate_unary_strings(
&entry_node->u.ctf_expression.right);
if (!right) {
- _PERROR("%s", "unexpected unary expression for clock class declaration's \"name\" attribute");
+ BT_LOGE("unexpected unary expression for clock class declaration's \"name\" attribute");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_clock_class_set_name(clock, right);
if (ret) {
- _PERROR("%s", "cannot set clock class's name");
+ BT_LOGE("cannot set clock class's name");
g_free(right);
goto error;
}
unsigned char uuid[BABELTRACE_UUID_LEN];
if (_IS_SET(set, _CLOCK_UUID_SET)) {
- _PERROR_DUP_ATTR("uuid", "clock class declaration");
+ BT_LOGE_DUP_ATTR("uuid", "clock class declaration");
ret = -EPERM;
goto error;
}
ret = get_unary_uuid(&entry_node->u.ctf_expression.right, uuid);
if (ret) {
- _PERROR("%s", "invalid clock class UUID");
+ BT_LOGE("invalid clock class UUID");
goto error;
}
ret = bt_ctf_clock_class_set_uuid(clock, uuid);
if (ret) {
- _PERROR("%s", "cannot set clock class's UUID");
+ BT_LOGE("cannot set clock class's UUID");
goto error;
}
char *right;
if (_IS_SET(set, _CLOCK_DESCRIPTION_SET)) {
- _PERROR_DUP_ATTR("description", "clock class declaration");
+ BT_LOGE_DUP_ATTR("description", "clock class declaration");
ret = -EPERM;
goto error;
}
right = concatenate_unary_strings(
&entry_node->u.ctf_expression.right);
if (!right) {
- _PERROR("%s", "unexpected unary expression for clock class's \"description\" attribute");
+ BT_LOGE("unexpected unary expression for clock class's \"description\" attribute");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_clock_class_set_description(clock, right);
if (ret) {
- _PERROR("%s", "cannot set clock class's description");
+ BT_LOGE("cannot set clock class's description");
g_free(right);
goto error;
}
uint64_t freq;
if (_IS_SET(set, _CLOCK_FREQ_SET)) {
- _PERROR_DUP_ATTR("freq", "clock class declaration");
+ BT_LOGE_DUP_ATTR("freq", "clock class declaration");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(
&entry_node->u.ctf_expression.right, &freq);
if (ret) {
- _PERROR("%s", "unexpected unary expression for clock class declaration's \"freq\" attribute");
+ BT_LOGE("unexpected unary expression for clock class declaration's \"freq\" attribute");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_clock_class_set_frequency(clock, freq);
if (ret) {
- _PERROR("%s", "cannot set clock class's frequency");
+ BT_LOGE("cannot set clock class's frequency");
goto error;
}
uint64_t precision;
if (_IS_SET(set, _CLOCK_PRECISION_SET)) {
- _PERROR_DUP_ATTR("precision", "clock class declaration");
+ BT_LOGE_DUP_ATTR("precision", "clock class declaration");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(
&entry_node->u.ctf_expression.right, &precision);
if (ret) {
- _PERROR("%s", "unexpected unary expression for clock class declaration's \"precision\" attribute");
+ BT_LOGE("unexpected unary expression for clock class declaration's \"precision\" attribute");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_clock_class_set_precision(clock, precision);
if (ret) {
- _PERROR("%s", "cannot set clock class's precision");
+ BT_LOGE("cannot set clock class's precision");
goto error;
}
uint64_t offset_s;
if (_IS_SET(set, _CLOCK_OFFSET_S_SET)) {
- _PERROR_DUP_ATTR("offset_s", "clock class declaration");
+ BT_LOGE_DUP_ATTR("offset_s", "clock class declaration");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(
&entry_node->u.ctf_expression.right, &offset_s);
if (ret) {
- _PERROR("%s", "unexpected unary expression for clock class declaration's \"offset_s\" attribute");
+ BT_LOGE("unexpected unary expression for clock class declaration's \"offset_s\" attribute");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_clock_class_set_offset_s(clock, offset_s);
if (ret) {
- _PERROR("%s", "cannot set clock class's offset in seconds");
+ BT_LOGE("cannot set clock class's offset in seconds");
goto error;
}
uint64_t offset;
if (_IS_SET(set, _CLOCK_OFFSET_SET)) {
- _PERROR_DUP_ATTR("offset", "clock class declaration");
+ BT_LOGE_DUP_ATTR("offset", "clock class declaration");
ret = -EPERM;
goto error;
}
ret = get_unary_unsigned(
&entry_node->u.ctf_expression.right, &offset);
if (ret) {
- _PERROR("%s", "unexpected unary expression for clock class declaration's \"offset\" attribute");
+ BT_LOGE("unexpected unary expression for clock class declaration's \"offset\" attribute");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_clock_class_set_offset_cycles(clock, offset);
if (ret) {
- _PERROR("%s", "cannot set clock class's offset in cycles");
+ BT_LOGE("cannot set clock class's offset in cycles");
goto error;
}
struct ctf_node *right;
if (_IS_SET(set, _CLOCK_ABSOLUTE_SET)) {
- _PERROR_DUP_ATTR("absolute", "clock class declaration");
+ BT_LOGE_DUP_ATTR("absolute", "clock class declaration");
ret = -EPERM;
goto error;
}
right = _BT_LIST_FIRST_ENTRY(
&entry_node->u.ctf_expression.right,
struct ctf_node, siblings);
- ret = get_boolean(ctx->efd, right);
+ ret = get_boolean(right);
if (ret < 0) {
- _PERROR("%s", "unexpected unary expression for clock class declaration's \"absolute\" attribute");
+ BT_LOGE("unexpected unary expression for clock class declaration's \"absolute\" attribute");
ret = -EINVAL;
goto error;
}
ret = bt_ctf_clock_class_set_is_absolute(clock, ret);
if (ret) {
- _PERROR("%s", "cannot set clock class's absolute option");
+ BT_LOGE("cannot set clock class's absolute option");
goto error;
}
_SET(set, _CLOCK_ABSOLUTE_SET);
} else {
- _PWARNING("unknown attribute \"%s\" in clock class declaration",
+ BT_LOGW("unknown attribute \"%s\" in clock class declaration",
left);
}
}
static
-uint64_t cycles_from_ns(uint64_t frequency, uint64_t ns)
+int64_t cycles_from_ns(uint64_t frequency, int64_t ns)
{
- uint64_t cycles;
+ int64_t cycles;
/* 1GHz */
if (frequency == 1000000000ULL) {
freq = bt_ctf_clock_class_get_frequency(clock);
if (freq == -1ULL) {
- _PERROR("%s", "cannot get clock class frequency");
+ BT_LOGE("cannot get clock class frequency");
ret = -1;
goto end;
}
ret = bt_ctf_clock_class_get_offset_cycles(clock, &offset_cycles);
if (ret) {
- _PERROR("%s", "cannot get offset in cycles");
+ BT_LOGE("cannot get offset in cycles");
ret = -1;
goto end;
}
clock_node->visited = TRUE;
clock = bt_ctf_clock_class_create(NULL);
if (!clock) {
- _PERROR("%s", "cannot create clock");
+ BT_LOGE("cannot create clock");
ret = -ENOMEM;
goto error;
}
}
if (!_IS_SET(&set, _CLOCK_NAME_SET)) {
- _PERROR("%s",
+ BT_LOGE(
"missing \"name\" attribute in clock class declaration");
ret = -EPERM;
goto error;
*/
ret = bt_ctf_clock_class_set_is_absolute(clock, 1);
if (ret) {
- _PERROR("%s", "cannot set clock class's absolute option");
+ BT_LOGE("cannot set clock class's absolute option");
goto error;
}
}
ret = apply_clock_class_offset(ctx, clock);
if (ret) {
- _PERROR("%s", "cannot apply clock class offset ");
+ BT_LOGE("cannot apply clock class offset ");
goto error;
}
ret = bt_ctf_trace_add_clock_class(ctx->trace, clock);
if (ret) {
- _PERROR("%s", "cannot add clock class to trace");
+ BT_LOGE("cannot add clock class to trace");
goto error;
}
root_decl_node->u._typedef.type_specifier_list,
&root_decl_node->u._typedef.type_declarators);
if (ret) {
- _PERROR("%s", "cannot add typedef in root scope");
+ BT_LOGE("cannot add typedef in root scope");
goto end;
}
break;
ret = visit_typealias(ctx, root_decl_node->u.typealias.target,
root_decl_node->u.typealias.alias);
if (ret) {
- _PERROR("%s", "cannot add typealias in root scope");
+ BT_LOGE("cannot add typealias in root scope");
goto end;
}
break;
stream_class);
if (ret) {
int64_t id = bt_ctf_stream_class_get_id(stream_class);
- _PERROR("cannot add stream class %" PRId64 " to trace",
+ BT_LOGE("cannot add stream class %" PRId64 " to trace",
id);
goto end;
}
}
BT_HIDDEN
-struct ctf_visitor_generate_ir *ctf_visitor_generate_ir_create(FILE *efd,
- uint64_t clock_class_offset_ns, const char *name)
+struct ctf_visitor_generate_ir *ctf_visitor_generate_ir_create(
+ int64_t clock_class_offset_ns, const char *name)
{
int ret;
struct ctx *ctx = NULL;
trace = bt_ctf_trace_create();
if (!trace) {
- _FPERROR(efd, "%s", "cannot create trace");
+ BT_LOGE("cannot create trace");
goto error;
}
/* Set packet header to NULL to override the default one */
ret = bt_ctf_trace_set_packet_header_type(trace, NULL);
if (ret) {
- _FPERROR(efd, "%s",
- "cannot set initial, empty packet header structure");
+ BT_LOGE("cannot set initial, empty packet header structure");
goto error;
}
/* Create visitor's context */
- ctx = ctx_create(trace, efd, clock_class_offset_ns, name);
+ ctx = ctx_create(trace, clock_class_offset_ns, name);
if (!ctx) {
- _FPERROR(efd, "%s", "cannot create visitor context");
+ BT_LOGE("cannot create visitor context");
goto error;
}
if (ctx->trace_bo == BT_CTF_BYTE_ORDER_NATIVE) {
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
if (got_trace_decl) {
- _PERROR("%s", "duplicate trace declaration");
+ BT_LOGE("duplicate trace declaration");
ret = -1;
goto end;
}
ret = set_trace_byte_order(ctx, iter);
if (ret) {
- _PERROR("cannot set trace's native byte order (%d)",
+ BT_LOGE("cannot set trace's native byte order (%d)",
ret);
goto end;
}
bt_list_for_each_entry(iter, &node->u.root.env, siblings) {
ret = visit_env(ctx, iter);
if (ret) {
- _PERROR("error while visiting environment block (%d)",
+ BT_LOGE("error while visiting environment block (%d)",
ret);
goto end;
}
bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
ret = visit_clock_decl(ctx, iter);
if (ret) {
- _PERROR("error while visiting clock class declaration (%d)",
+ BT_LOGE("error while visiting clock class declaration (%d)",
ret);
goto end;
}
siblings) {
ret = visit_root_decl(ctx, iter);
if (ret) {
- _PERROR("error while visiting root declaration (%d)",
+ BT_LOGE("error while visiting root declaration (%d)",
ret);
goto end;
}
ctx->current_scope->parent_scope == NULL);
if (found_callsite) {
- _PWARNING("%s", "\"callsite\" blocks are not supported as of this version");
+ BT_LOGW("\"callsite\" blocks are not supported as of this version");
}
/* Trace */
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
ret = visit_trace_decl(ctx, iter);
if (ret) {
- _PERROR("%s", "error while visiting trace declaration");
+ BT_LOGE("error while visiting trace declaration");
goto end;
}
}
bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
ret = visit_stream_decl(ctx, iter);
if (ret) {
- _PERROR("%s", "error while visiting stream declaration");
+ BT_LOGE("error while visiting stream declaration");
goto end;
}
}
bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
ret = visit_event_decl(ctx, iter);
if (ret) {
- _PERROR("%s", "error while visiting event declaration");
+ BT_LOGE("error while visiting event declaration");
goto end;
}
}
break;
}
default:
- _PERROR("cannot decode node type: %d", (int) node->type);
+ BT_LOGE("cannot decode node type: %d", (int) node->type);
ret = -EINVAL;
goto end;
}
/* Move decoded stream classes to trace, if any */
ret = move_ctx_stream_classes_to_trace(ctx);
if (ret) {
- _PERROR("%s", "cannot move stream classes to trace");
+ BT_LOGE("cannot move stream classes to trace");
}
end:
#include "parser.h"
#include "ast.h"
-#define fprintf_dbg(fd, fmt, args...) fprintf(fd, "%s: " fmt, __func__, ## args)
+#define BT_LOG_TAG "PLUGIN-CTF-METADATA-VISITOR-PARENT-LINKS"
+#include "logging.h"
static
-int ctf_visitor_unary_expression(FILE *fd, int depth, struct ctf_node *node)
+int ctf_visitor_unary_expression(int depth, struct ctf_node *node)
{
int ret = 0;
case UNARY_DOTDOTDOT:
break;
default:
- fprintf(fd, "[error] %s: unknown expression link type %d\n", __func__,
+ BT_LOGE("unknown expression link type %d\n",
(int) node->u.unary_expression.link);
return -EINVAL;
}
break;
case UNARY_SBRAC:
node->u.unary_expression.u.sbrac_exp->parent = node;
- ret = ctf_visitor_unary_expression(fd, depth + 1,
+ ret = ctf_visitor_unary_expression(depth + 1,
node->u.unary_expression.u.sbrac_exp);
if (ret)
return ret;
case UNARY_UNKNOWN:
default:
- fprintf(fd, "[error] %s: unknown expression type %d\n", __func__,
+ BT_LOGE("unknown expression type %d\n",
(int) node->u.unary_expression.type);
return -EINVAL;
}
}
static
-int ctf_visitor_type_specifier(FILE *fd, int depth, struct ctf_node *node)
+int ctf_visitor_type_specifier(int depth, struct ctf_node *node)
{
int ret;
case TYPESPEC_VARIANT:
case TYPESPEC_ENUM:
node->u.type_specifier.node->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, node->u.type_specifier.node);
+ ret = ctf_visitor_parent_links(depth + 1, node->u.type_specifier.node);
if (ret)
return ret;
break;
case TYPESPEC_UNKNOWN:
default:
- fprintf(fd, "[error] %s: unknown type specifier %d\n", __func__,
+ BT_LOGE("unknown type specifier %d\n",
(int) node->u.type_specifier.type);
return -EINVAL;
}
}
static
-int ctf_visitor_type_declarator(FILE *fd, int depth, struct ctf_node *node)
+int ctf_visitor_type_declarator(int depth, struct ctf_node *node)
{
int ret = 0;
struct ctf_node *iter;
bt_list_for_each_entry(iter, &node->u.type_declarator.pointers,
siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case TYPEDEC_NESTED:
if (node->u.type_declarator.u.nested.type_declarator) {
node->u.type_declarator.u.nested.type_declarator->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1,
+ ret = ctf_visitor_parent_links(depth + 1,
node->u.type_declarator.u.nested.type_declarator);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u.type_declarator.u.nested.length,
siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
}
if (node->u.type_declarator.bitfield_len) {
node->u.type_declarator.bitfield_len = node;
- ret = ctf_visitor_parent_links(fd, depth + 1,
+ ret = ctf_visitor_parent_links(depth + 1,
node->u.type_declarator.bitfield_len);
if (ret)
return ret;
break;
case TYPEDEC_UNKNOWN:
default:
- fprintf(fd, "[error] %s: unknown type declarator %d\n", __func__,
+ BT_LOGE("unknown type declarator %d\n",
(int) node->u.type_declarator.type);
return -EINVAL;
}
return 0;
}
-int ctf_visitor_parent_links(FILE *fd, int depth, struct ctf_node *node)
+int ctf_visitor_parent_links(int depth, struct ctf_node *node)
{
int ret = 0;
struct ctf_node *iter;
case NODE_ROOT:
bt_list_for_each_entry(iter, &node->u.root.declaration_list, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.clock, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.callsite, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_EVENT:
bt_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_STREAM:
bt_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_ENV:
bt_list_for_each_entry(iter, &node->u.env.declaration_list, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_TRACE:
bt_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_CLOCK:
bt_list_for_each_entry(iter, &node->u.clock.declaration_list, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_CALLSITE:
bt_list_for_each_entry(iter, &node->u.callsite.declaration_list, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
depth++;
bt_list_for_each_entry(iter, &node->u.ctf_expression.left, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.ctf_expression.right, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
depth--;
break;
case NODE_UNARY_EXPRESSION:
- return ctf_visitor_unary_expression(fd, depth, node);
+ return ctf_visitor_unary_expression(depth, node);
case NODE_TYPEDEF:
depth++;
node->u._typedef.type_specifier_list->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, node->u._typedef.type_specifier_list);
+ ret = ctf_visitor_parent_links(depth + 1, node->u._typedef.type_specifier_list);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u._typedef.type_declarators, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_TYPEALIAS_TARGET:
depth++;
node->u.typealias_target.type_specifier_list->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias_target.type_specifier_list);
+ ret = ctf_visitor_parent_links(depth + 1, node->u.typealias_target.type_specifier_list);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u.typealias_target.type_declarators, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_TYPEALIAS_ALIAS:
depth++;
node->u.typealias_alias.type_specifier_list->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias_alias.type_specifier_list);
+ ret = ctf_visitor_parent_links(depth + 1, node->u.typealias_alias.type_specifier_list);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u.typealias_alias.type_declarators, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
break;
case NODE_TYPEALIAS:
node->u.typealias.target->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias.target);
+ ret = ctf_visitor_parent_links(depth + 1, node->u.typealias.target);
if (ret)
return ret;
node->u.typealias.alias->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, node->u.typealias.alias);
+ ret = ctf_visitor_parent_links(depth + 1, node->u.typealias.alias);
if (ret)
return ret;
break;
case NODE_TYPE_SPECIFIER_LIST:
bt_list_for_each_entry(iter, &node->u.type_specifier_list.head, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
break;
case NODE_TYPE_SPECIFIER:
- ret = ctf_visitor_type_specifier(fd, depth, node);
+ ret = ctf_visitor_type_specifier(depth, node);
if (ret)
return ret;
break;
case NODE_POINTER:
break;
case NODE_TYPE_DECLARATOR:
- ret = ctf_visitor_type_declarator(fd, depth, node);
+ ret = ctf_visitor_type_declarator(depth, node);
if (ret)
return ret;
break;
case NODE_FLOATING_POINT:
bt_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_INTEGER:
bt_list_for_each_entry(iter, &node->u.integer.expressions, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_STRING:
bt_list_for_each_entry(iter, &node->u.string.expressions, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_ENUMERATOR:
bt_list_for_each_entry(iter, &node->u.enumerator.values, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_ENUM:
depth++;
if (node->u._enum.container_type) {
- ret = ctf_visitor_parent_links(fd, depth + 1, node->u._enum.container_type);
+ ret = ctf_visitor_parent_links(depth + 1, node->u._enum.container_type);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
break;
case NODE_STRUCT_OR_VARIANT_DECLARATION:
node->u.struct_or_variant_declaration.type_specifier_list->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1,
+ ret = ctf_visitor_parent_links(depth + 1,
node->u.struct_or_variant_declaration.type_specifier_list);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.type_declarators, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_VARIANT:
bt_list_for_each_entry(iter, &node->u.variant.declaration_list, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_STRUCT:
bt_list_for_each_entry(iter, &node->u._struct.declaration_list, siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u._struct.min_align,
siblings) {
iter->parent = node;
- ret = ctf_visitor_parent_links(fd, depth + 1, iter);
+ ret = ctf_visitor_parent_links(depth + 1, iter);
if (ret)
return ret;
}
case NODE_UNKNOWN:
default:
- fprintf(fd, "[error] %s: unknown node type %d\n", __func__,
- (int) node->type);
+ BT_LOGE("unknown node type %d\n", (int) node->type);
return -EINVAL;
}
return ret;
#include "parser.h"
#include "ast.h"
+#define BT_LOG_TAG "PLUGIN-CTF-METADATA-VISITOR-SEMANTIC-VALIDATOR"
+#include "logging.h"
+
#define _bt_list_first_entry(ptr, type, member) \
bt_list_entry((ptr)->next, type, member)
-#define fprintf_dbg(fd, fmt, args...) fprintf(fd, "%s: " fmt, __func__, ## args)
-
static
-int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node);
+int _ctf_visitor_semantic_check(int depth, struct ctf_node *node);
static
-int ctf_visitor_unary_expression(FILE *fd, int depth, struct ctf_node *node)
+int ctf_visitor_unary_expression(int depth, struct ctf_node *node)
{
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) {
- fprintf(fd, "[error]: semantic error (left child of a ctf expression is only allowed to be a string)\n");
-
+ BT_LOGE("semantic error (left child of a ctf expression is only allowed to be a string)");
goto errperm;
}
break;
case UNARY_STRING:
break;
default:
- fprintf(fd, "[error]: semantic error (children of type declarator and enum can only be unsigned numeric constants or references to fields (a.b.c))\n");
+ BT_LOGE("semantic error (children of type declarator and enum can only be unsigned numeric constants or references to fields (a.b.c))");
goto errperm;
}
break; /* OK */
case UNARY_UNSIGNED_CONSTANT:
break;
default:
- fprintf(fd, "[error]: semantic error (structure alignment attribute can only be unsigned numeric constants)\n");
+ BT_LOGE("semantic error (structure alignment attribute can only be unsigned numeric constants)");
goto errperm;
}
break;
* We disallow nested unary expressions and "sbrac" unary
* expressions.
*/
- fprintf(fd, "[error]: semantic error (nested unary expressions not allowed ( () and [] ))\n");
+ BT_LOGE("semantic error (nested unary expressions not allowed ( () and [] ))");
goto errperm;
case NODE_ROOT:
&node->parent->u.ctf_expression.right,
struct ctf_node,
siblings) != node) {
- fprintf(fd, "[error]: semantic error (empty link not allowed except on first node of unary expression (need to separate nodes with \".\" or \"->\")\n");
+ BT_LOGE("semantic error (empty link not allowed except on first node of unary expression (need to separate nodes with \".\" or \"->\")");
goto errperm;
}
break; /* OK */
case UNARY_ARROWLINK:
/* We only allow -> and . links between children of ctf_expression. */
if (node->parent->type != NODE_CTF_EXPRESSION) {
- fprintf(fd, "[error]: semantic error (links \".\" and \"->\" are only allowed as children of ctf expression)\n");
+ BT_LOGE("semantic error (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) {
- fprintf(fd, "[error]: semantic error (links \".\" and \"->\" are only allowed to separate strings and identifiers)\n");
+ BT_LOGE("semantic error (links \".\" and \"->\" are only allowed to separate strings and identifiers)");
goto errperm;
}
/* We don't allow link on the first node of the list */
&node->parent->u.ctf_expression.right,
struct ctf_node,
siblings) == node) {
- fprintf(fd, "[error]: semantic error (links \".\" and \"->\" are not allowed before first node of the unary expression list)\n");
+ BT_LOGE("semantic error (links \".\" and \"->\" are not allowed before first node of the unary expression list)");
goto errperm;
}
break;
case UNARY_DOTDOTDOT:
/* We only allow ... link between children of enumerator. */
if (node->parent->type != NODE_ENUMERATOR) {
- fprintf(fd, "[error]: semantic error (link \"...\" is only allowed within enumerator)\n");
+ BT_LOGE("semantic error (link \"...\" is only allowed within enumerator)");
goto errperm;
}
/* We don't allow link on the first node of the list */
if (_bt_list_first_entry(&node->parent->u.enumerator.values,
struct ctf_node,
siblings) == node) {
- fprintf(fd, "[error]: semantic error (link \"...\" is not allowed on the first node of the unary expression list)\n");
+ BT_LOGE("semantic error (link \"...\" is not allowed on the first node of the unary expression list)");
goto errperm;
}
break;
default:
- fprintf(fd, "[error] %s: unknown expression link type %d\n", __func__,
+ BT_LOGE("%s: unknown expression link type %d", __func__,
(int) node->u.unary_expression.link);
return -EINVAL;
}
return 0;
errinval:
- fprintf(fd, "[error] %s: incoherent parent type %s for node type %s\n", __func__,
+ BT_LOGE("%s: incoherent parent type %s for node type %s", __func__,
node_type(node->parent), node_type(node));
return -EINVAL; /* Incoherent structure */
errperm:
- fprintf(fd, "[error] %s: semantic error (parent type %s for node type %s)\n", __func__,
+ BT_LOGE("%s: semantic error (parent type %s for node type %s)", __func__,
node_type(node->parent), node_type(node));
return -EPERM; /* Structure not allowed */
}
static
-int ctf_visitor_type_specifier_list(FILE *fd, int depth, struct ctf_node *node)
+int ctf_visitor_type_specifier_list(int depth, struct ctf_node *node)
{
switch (node->parent->type) {
case NODE_CTF_EXPRESSION:
}
return 0;
errinval:
- fprintf(fd, "[error] %s: incoherent parent type %s for node type %s\n", __func__,
+ BT_LOGE("%s: incoherent parent type %s for node type %s", __func__,
node_type(node->parent), node_type(node));
return -EINVAL; /* Incoherent structure */
}
static
-int ctf_visitor_type_specifier(FILE *fd, int depth, struct ctf_node *node)
+int ctf_visitor_type_specifier(int depth, struct ctf_node *node)
{
switch (node->parent->type) {
case NODE_TYPE_SPECIFIER_LIST:
}
return 0;
errinval:
- fprintf(fd, "[error] %s: incoherent parent type %s for node type %s\n", __func__,
+ BT_LOGE("%s: incoherent parent type %s for node type %s", __func__,
node_type(node->parent), node_type(node));
return -EINVAL; /* Incoherent structure */
}
static
-int ctf_visitor_type_declarator(FILE *fd, int depth, struct ctf_node *node)
+int ctf_visitor_type_declarator(int depth, struct ctf_node *node)
{
int ret = 0;
struct ctf_node *iter;
bt_list_for_each_entry(iter, &node->u.type_declarator.pointers,
siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
case TYPEDEC_NESTED:
{
if (node->u.type_declarator.u.nested.type_declarator) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1,
+ ret = _ctf_visitor_semantic_check(depth + 1,
node->u.type_declarator.u.nested.type_declarator);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u.type_declarator.u.nested.length,
siblings) {
if (iter->type != NODE_UNARY_EXPRESSION) {
- fprintf(fd, "[error] %s: expecting unary expression as length\n", __func__);
+ BT_LOGE("%s: expecting unary expression as length", __func__);
return -EINVAL;
}
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
} else {
if (node->parent->type == NODE_TYPEALIAS_TARGET) {
- fprintf(fd, "[error] %s: abstract array declarator not permitted as target of typealias\n", __func__);
+ BT_LOGE("%s: abstract array declarator not permitted as target of typealias", __func__);
return -EINVAL;
}
}
if (node->u.type_declarator.bitfield_len) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1,
+ ret = _ctf_visitor_semantic_check(depth + 1,
node->u.type_declarator.bitfield_len);
if (ret)
return ret;
}
case TYPEDEC_UNKNOWN:
default:
- fprintf(fd, "[error] %s: unknown type declarator %d\n", __func__,
+ BT_LOGE("%s: unknown type declarator %d", __func__,
(int) node->u.type_declarator.type);
return -EINVAL;
}
return 0;
errinval:
- fprintf(fd, "[error] %s: incoherent parent type %s for node type %s\n", __func__,
+ BT_LOGE("%s: incoherent parent type %s for node type %s", __func__,
node_type(node->parent), node_type(node));
return -EINVAL; /* Incoherent structure */
errperm:
- fprintf(fd, "[error] %s: semantic error (parent type %s for node type %s)\n", __func__,
+ BT_LOGE("%s: semantic error (parent type %s for node type %s)", __func__,
node_type(node->parent), node_type(node));
return -EPERM; /* Structure not allowed */
}
static
-int _ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node)
+int _ctf_visitor_semantic_check(int depth, struct ctf_node *node)
{
int ret = 0;
struct ctf_node *iter;
switch (node->type) {
case NODE_ROOT:
bt_list_for_each_entry(iter, &node->u.root.declaration_list, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.trace, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.stream, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.root.event, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
}
bt_list_for_each_entry(iter, &node->u.event.declaration_list, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
}
bt_list_for_each_entry(iter, &node->u.stream.declaration_list, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
}
bt_list_for_each_entry(iter, &node->u.env.declaration_list, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
}
bt_list_for_each_entry(iter, &node->u.trace.declaration_list, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
}
bt_list_for_each_entry(iter, &node->u.clock.declaration_list, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
}
bt_list_for_each_entry(iter, &node->u.callsite.declaration_list, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
depth++;
bt_list_for_each_entry(iter, &node->u.ctf_expression.left, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
bt_list_for_each_entry(iter, &node->u.ctf_expression.right, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
depth--;
break;
case NODE_UNARY_EXPRESSION:
- return ctf_visitor_unary_expression(fd, depth, node);
+ return ctf_visitor_unary_expression(depth, node);
case NODE_TYPEDEF:
switch (node->parent->type) {
}
depth++;
- ret = _ctf_visitor_semantic_check(fd, depth + 1,
+ ret = _ctf_visitor_semantic_check(depth + 1,
node->u._typedef.type_specifier_list);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u._typedef.type_declarators, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
}
depth++;
- ret = _ctf_visitor_semantic_check(fd, depth + 1,
+ ret = _ctf_visitor_semantic_check(depth + 1,
node->u.typealias_target.type_specifier_list);
if (ret)
return ret;
nr_declarators = 0;
bt_list_for_each_entry(iter, &node->u.typealias_target.type_declarators, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
nr_declarators++;
}
if (nr_declarators > 1) {
- fprintf(fd, "[error] %s: Too many declarators in typealias alias (%d, max is 1)\n", __func__, nr_declarators);
+ BT_LOGE("%s: Too many declarators in typealias alias (%d, max is 1)", __func__, nr_declarators);
return -EINVAL;
}
}
depth++;
- ret = _ctf_visitor_semantic_check(fd, depth + 1,
+ ret = _ctf_visitor_semantic_check(depth + 1,
node->u.typealias_alias.type_specifier_list);
if (ret)
return ret;
nr_declarators = 0;
bt_list_for_each_entry(iter, &node->u.typealias_alias.type_declarators, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
nr_declarators++;
}
if (nr_declarators > 1) {
- fprintf(fd, "[error] %s: Too many declarators in typealias alias (%d, max is 1)\n", __func__, nr_declarators);
+ BT_LOGE("%s: Too many declarators in typealias alias (%d, max is 1)", __func__, nr_declarators);
return -EINVAL;
}
goto errinval;
}
- ret = _ctf_visitor_semantic_check(fd, depth + 1, node->u.typealias.target);
+ ret = _ctf_visitor_semantic_check(depth + 1, node->u.typealias.target);
if (ret)
return ret;
- ret = _ctf_visitor_semantic_check(fd, depth + 1, node->u.typealias.alias);
+ ret = _ctf_visitor_semantic_check(depth + 1, node->u.typealias.alias);
if (ret)
return ret;
break;
case NODE_TYPE_SPECIFIER_LIST:
- ret = ctf_visitor_type_specifier_list(fd, depth, node);
+ ret = ctf_visitor_type_specifier_list(depth, node);
if (ret)
return ret;
break;
case NODE_TYPE_SPECIFIER:
- ret = ctf_visitor_type_specifier(fd, depth, node);
+ ret = ctf_visitor_type_specifier(depth, node);
if (ret)
return ret;
break;
}
break;
case NODE_TYPE_DECLARATOR:
- ret = ctf_visitor_type_declarator(fd, depth, node);
+ ret = ctf_visitor_type_declarator(depth, node);
if (ret)
return ret;
break;
goto errperm;
}
bt_list_for_each_entry(iter, &node->u.floating_point.expressions, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
}
bt_list_for_each_entry(iter, &node->u.integer.expressions, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
}
bt_list_for_each_entry(iter, &node->u.string.expressions, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
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) {
- fprintf(fd, "[error]: semantic error (first unary expression of enumerator is unexpected)\n");
+ BT_LOGE("semantic error (first unary expression of enumerator is unexpected)");
goto errperm;
}
break;
|| (iter->u.unary_expression.type != UNARY_SIGNED_CONSTANT
&& iter->u.unary_expression.type != UNARY_UNSIGNED_CONSTANT)
|| iter->u.unary_expression.link != UNARY_DOTDOTDOT) {
- fprintf(fd, "[error]: semantic error (second unary expression of enumerator is unexpected)\n");
+ BT_LOGE("semantic error (second unary expression of enumerator is unexpected)");
goto errperm;
}
break;
}
bt_list_for_each_entry(iter, &node->u.enumerator.values, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
}
depth++;
- ret = _ctf_visitor_semantic_check(fd, depth + 1, node->u._enum.container_type);
+ ret = _ctf_visitor_semantic_check(depth + 1, node->u._enum.container_type);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u._enum.enumerator_list, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
default:
goto errinval;
}
- ret = _ctf_visitor_semantic_check(fd, depth + 1,
+ ret = _ctf_visitor_semantic_check(depth + 1,
node->u.struct_or_variant_declaration.type_specifier_list);
if (ret)
return ret;
bt_list_for_each_entry(iter, &node->u.struct_or_variant_declaration.type_declarators, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
goto errperm;
}
bt_list_for_each_entry(iter, &node->u.variant.declaration_list, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
goto errperm;
}
bt_list_for_each_entry(iter, &node->u._struct.declaration_list, siblings) {
- ret = _ctf_visitor_semantic_check(fd, depth + 1, iter);
+ ret = _ctf_visitor_semantic_check(depth + 1, iter);
if (ret)
return ret;
}
case NODE_UNKNOWN:
default:
- fprintf(fd, "[error] %s: unknown node type %d\n", __func__,
+ BT_LOGE("%s: unknown node type %d", __func__,
(int) node->type);
return -EINVAL;
}
return ret;
errinval:
- fprintf(fd, "[error] %s: incoherent parent type %s for node type %s\n", __func__,
+ BT_LOGE("%s: incoherent parent type %s for node type %s", __func__,
node_type(node->parent), node_type(node));
return -EINVAL; /* Incoherent structure */
errperm:
- fprintf(fd, "[error] %s: semantic error (parent type %s for node type %s)\n", __func__,
+ BT_LOGE("%s: semantic error (parent type %s for node type %s)", __func__,
node_type(node->parent), node_type(node));
return -EPERM; /* Structure not allowed */
}
-int ctf_visitor_semantic_check(FILE *fd, int depth, struct ctf_node *node)
+int ctf_visitor_semantic_check(int depth, struct ctf_node *node)
{
int ret = 0;
* take the safe route and recreate them at each validation, just in
* case the structure has changed.
*/
- printf_verbose("CTF visitor: parent links creation... ");
- ret = ctf_visitor_parent_links(fd, depth, node);
- if (ret)
- return ret;
- printf_verbose("done.\n");
- printf_verbose("CTF visitor: semantic check... ");
- ret = _ctf_visitor_semantic_check(fd, depth, node);
- if (ret)
- return ret;
- printf_verbose("done.\n");
+ BT_LOGV("CTF visitor: parent links creation... ");
+ ret = ctf_visitor_parent_links(depth, node);
+ if (ret) {
+ goto end;
+ }
+ BT_LOGV("done.");
+ BT_LOGV("CTF visitor: semantic check... ");
+ ret = _ctf_visitor_semantic_check(depth, node);
+ if (ret) {
+ goto end;
+ }
+ BT_LOGV("done.");
+end:
return ret;
}
/* Visit stack */
struct stack *stack;
- /* Error stream (may be NULL) */
- FILE *err_stream;
-
/*
* Current dynamic scope field pointer.
*
BT_HIDDEN
struct bt_ctf_notif_iter *bt_ctf_notif_iter_create(struct bt_ctf_trace *trace,
size_t max_request_sz,
- struct bt_ctf_notif_iter_medium_ops medops,
- void *data, FILE *err_stream)
+ struct bt_ctf_notif_iter_medium_ops medops, void *data)
{
int ret;
struct bt_ctf_notif_iter *notit = NULL;
notit->medium.medops = medops;
notit->medium.max_request_sz = max_request_sz;
notit->medium.data = data;
- notit->err_stream = err_stream;
notit->stack = stack_new(notit);
if (!notit->stack) {
BT_LOGE_STR("Failed to create field stack.");
goto error;
}
- notit->btr = bt_ctf_btr_create(cbs, notit, err_stream);
+ notit->btr = bt_ctf_btr_create(cbs, notit);
if (!notit->btr) {
BT_LOGE_STR("Failed to create binary type reader (BTR).");
goto error;
BT_HIDDEN
struct bt_ctf_notif_iter *bt_ctf_notif_iter_create(struct bt_ctf_trace *trace,
size_t max_request_sz, struct bt_ctf_notif_iter_medium_ops medops,
- void *medops_data, FILE *err_stream);
+ void *medops_data);
/**
* Destroys a CTF notification iterator, freeing all internal resources.
metadata.h \
print.h \
query.h \
- query.c
+ query.c \
+ logging.h \
+ logging.c
#include <babeltrace/graph/notification-stream.h>
#include <babeltrace/graph/notification-event.h>
#include <babeltrace/graph/notification-packet.h>
+#include <babeltrace/common-internal.h>
#include "file.h"
#include "metadata.h"
#include "../common/notif-iter/notif-iter.h"
#include "data-stream-file.h"
#include <string.h>
-#define PRINT_ERR_STREAM ctf_fs->error_fp
-#define PRINT_PREFIX "ctf-fs-data-stream"
-#define PRINT_DBG_CHECK ctf_fs_debug
-#include "../print.h"
+#define BT_LOG_TAG "PLUGIN-CTF-FS-SRC-DS"
+#include "logging.h"
static inline
size_t remaining_mmap_bytes(struct ctf_fs_ds_file *ds_file)
int ds_file_munmap(struct ctf_fs_ds_file *ds_file)
{
int ret = 0;
- struct ctf_fs_component *ctf_fs;
if (!ds_file || !ds_file->mmap_addr) {
goto end;
}
- ctf_fs = ds_file->file->ctf_fs;
if (munmap(ds_file->mmap_addr, ds_file->mmap_len)) {
- PERR("Cannot memory-unmap address %p (size %zu) of file \"%s\" (%p): %s\n",
+ BT_LOGE("Cannot memory-unmap address %p (size %zu) of file \"%s\" (%p): %s",
ds_file->mmap_addr, ds_file->mmap_len,
ds_file->file->path->str, ds_file->file->fp,
strerror(errno));
enum bt_ctf_notif_iter_medium_status ds_file_mmap_next(
struct ctf_fs_ds_file *ds_file)
{
+ const size_t page_size = bt_common_get_page_size();
enum bt_ctf_notif_iter_medium_status ret =
BT_CTF_NOTIF_ITER_MEDIUM_STATUS_OK;
- struct ctf_fs_component *ctf_fs = ds_file->file->ctf_fs;
/* Unmap old region */
if (ds_file->mmap_addr) {
goto end;
}
/* Round up to next page, assuming page size being a power of 2. */
- ds_file->mmap_len = (ds_file->mmap_valid_len + ctf_fs->page_size - 1)
- & ~(ctf_fs->page_size - 1);
+ ds_file->mmap_len = (ds_file->mmap_valid_len + page_size - 1)
+ & ~(page_size - 1);
/* Map new region */
assert(ds_file->mmap_len);
ds_file->mmap_addr = mmap((void *) 0, ds_file->mmap_len,
PROT_READ, MAP_PRIVATE, fileno(ds_file->file->fp),
ds_file->mmap_offset);
if (ds_file->mmap_addr == MAP_FAILED) {
- PERR("Cannot memory-map address (size %zu) of file \"%s\" (%p) at offset %zu: %s\n",
+ BT_LOGE("Cannot memory-map address (size %zu) of file \"%s\" (%p) at offset %zu: %s",
ds_file->mmap_len, ds_file->file->path->str,
ds_file->file->fp, ds_file->mmap_offset,
strerror(errno));
enum bt_ctf_notif_iter_medium_status status =
BT_CTF_NOTIF_ITER_MEDIUM_STATUS_OK;
struct ctf_fs_ds_file *ds_file = data;
- struct ctf_fs_component *ctf_fs = ds_file->file->ctf_fs;
if (request_sz == 0) {
goto end;
if (remaining_mmap_bytes(ds_file) == 0) {
/* Are we at the end of the file? */
if (ds_file->mmap_offset >= ds_file->file->size) {
- PDBG("Reached end of file \"%s\" (%p)\n",
+ BT_LOGD("Reached end of file \"%s\" (%p)",
ds_file->file->path->str, ds_file->file->fp);
status = BT_CTF_NOTIF_ITER_MEDIUM_STATUS_EOF;
goto end;
case BT_CTF_NOTIF_ITER_MEDIUM_STATUS_EOF:
goto end;
default:
- PERR("Cannot memory-map next region of file \"%s\" (%p)\n",
+ BT_LOGE("Cannot memory-map next region of file \"%s\" (%p)",
ds_file->file->path->str,
ds_file->file->fp);
goto error;
/* Look for index file in relative path index/name.idx. */
basename = g_path_get_basename(ds_file->file->path->str);
if (!basename) {
+ BT_LOGE("Failed to get the basename of datastream file %s",
+ ds_file->file->path->str);
ret = -1;
goto end;
}
directory = g_path_get_dirname(ds_file->file->path->str);
if (!directory) {
+ BT_LOGE("Failed to get dirname of datastream file %s",
+ ds_file->file->path->str);
ret = -1;
goto end;
}
index_basename = g_string_new(basename);
if (!index_basename) {
+ BT_LOGE("Failed to allocate index file basename string");
ret = -1;
goto end;
}
index_basename->str, NULL);
mapped_file = g_mapped_file_new(index_file_path, FALSE, NULL);
if (!mapped_file) {
+ BT_LOGD("Failed to create new mapped file %s",
+ index_file_path);
ret = -1;
goto end;
}
filesize = g_mapped_file_get_length(mapped_file);
if (filesize < sizeof(*header)) {
- printf_error("Invalid LTTng trace index: file size < header size");
+ BT_LOGW("Invalid LTTng trace index file: file size < header size");
ret = -1;
goto end;
}
file_pos = g_mapped_file_get_contents(mapped_file) + sizeof(*header);
if (be32toh(header->magic) != CTF_INDEX_MAGIC) {
- printf_error("Invalid LTTng trace index: \"magic\" validation failed");
+ BT_LOGW("Invalid LTTng trace index: \"magic\" validation failed");
ret = -1;
goto end;
}
file_index_entry_size = be32toh(header->packet_index_len);
file_entry_count = (filesize - sizeof(*header)) / file_index_entry_size;
if ((filesize - sizeof(*header)) % (file_entry_count * file_index_entry_size)) {
- printf_error("Invalid index file size; not a multiple of index entry size");
+ BT_LOGW("Invalid index file size; not a multiple of index entry size");
ret = -1;
goto end;
}
if (packet_size % CHAR_BIT) {
ret = -1;
- printf_error("Invalid packet size encountered in index file");
+ BT_LOGW("Invalid packet size encountered in index file");
goto invalid_index;
}
index->offset = be64toh(file_index->offset);
if (i != 0 && index->offset < (index - 1)->offset) {
- printf_error("Invalid, non-monotonic, packet offset encountered in index file");
+ BT_LOGW("Invalid, non-monotonic, packet offset encountered in index file");
ret = -1;
goto invalid_index;
}
index->timestamp_begin = be64toh(file_index->timestamp_begin);
index->timestamp_end = be64toh(file_index->timestamp_end);
if (index->timestamp_end < index->timestamp_begin) {
- printf_error("Invalid packet time bounds encountered in index file");
+ BT_LOGW("Invalid packet time bounds encountered in index file");
ret = -1;
goto invalid_index;
}
/* Validate that the index addresses the complete stream. */
if (ds_file->file->size != total_packets_size) {
- printf_error("Invalid index; indexed size != stream file size");
+ BT_LOGW("Invalid index; indexed size != stream file size");
ret = -1;
goto invalid_index;
}
bool build_index)
{
int ret;
+ const size_t page_size = bt_common_get_page_size();
struct ctf_fs_ds_file *ds_file = g_new0(struct ctf_fs_ds_file, 1);
if (!ds_file) {
goto error;
}
- ds_file->file = ctf_fs_file_create(ctf_fs_trace->ctf_fs);
+ ds_file->file = ctf_fs_file_create();
if (!ds_file->file) {
goto error;
}
ds_file->stream = bt_get(stream);
ds_file->cc_prio_map = bt_get(ctf_fs_trace->cc_prio_map);
g_string_assign(ds_file->file->path, path);
- ret = ctf_fs_file_open(ctf_fs_trace->ctf_fs, ds_file->file, "rb");
+ ret = ctf_fs_file_open(ds_file->file, "rb");
if (ret) {
goto error;
}
ds_file->notif_iter = bt_ctf_notif_iter_create(
- ctf_fs_trace->metadata->trace,
- ctf_fs_trace->ctf_fs->page_size, medops, ds_file,
- ctf_fs_trace->ctf_fs->error_fp);
+ ctf_fs_trace->metadata->trace, page_size, medops, ds_file);
if (!ds_file->notif_iter) {
goto error;
}
- ds_file->mmap_max_len = ctf_fs_trace->ctf_fs->page_size * 2048;
+ ds_file->mmap_max_len = page_size * 2048;
if (build_index) {
ret = init_stream_index(ds_file);
#include <sys/stat.h>
#include <unistd.h>
#include <glib.h>
-
-#define PRINT_ERR_STREAM ctf_fs->error_fp
-#define PRINT_PREFIX "ctf-fs-file"
-#define PRINT_DBG_CHECK ctf_fs_debug
-#include "../print.h"
-
#include "file.h"
+#define BT_LOG_TAG "PLUGIN-CTF-FS-FILE-SRC"
+#include "logging.h"
+
BT_HIDDEN
void ctf_fs_file_destroy(struct ctf_fs_file *file)
{
- struct ctf_fs_component *ctf_fs;;
-
if (!file) {
return;
}
- ctf_fs = file->ctf_fs;
-
if (file->fp) {
- PDBG("Closing file \"%s\" (%p)\n",
+ BT_LOGD("Closing file \"%s\" (%p)",
file->path ? file->path->str : NULL, file->fp);
if (fclose(file->fp)) {
- PERR("Cannot close file \"%s\": %s\n",
+ BT_LOGE("Cannot close file \"%s\": %s",
file->path ? file->path->str : "NULL",
strerror(errno));
}
}
BT_HIDDEN
-struct ctf_fs_file *ctf_fs_file_create(struct ctf_fs_component *ctf_fs)
+struct ctf_fs_file *ctf_fs_file_create(void)
{
struct ctf_fs_file *file = g_new0(struct ctf_fs_file, 1);
goto error;
}
- file->ctf_fs = ctf_fs;
file->path = g_string_new(NULL);
if (!file->path) {
goto error;
}
BT_HIDDEN
-int ctf_fs_file_open(struct ctf_fs_component *ctf_fs, struct ctf_fs_file *file,
- const char *mode)
+int ctf_fs_file_open(struct ctf_fs_file *file, const char *mode)
{
int ret = 0;
struct stat stat;
- PDBG("Opening file \"%s\" with mode \"%s\"\n", file->path->str, mode);
+ BT_LOGD("Opening file \"%s\" with mode \"%s\"", file->path->str, mode);
file->fp = fopen(file->path->str, mode);
if (!file->fp) {
- PERR("Cannot open file \"%s\" with mode \"%s\": %s\n",
+ BT_LOGE("Cannot open file \"%s\" with mode \"%s\": %s",
file->path->str, mode, strerror(errno));
goto error;
}
- PDBG("Opened file: %p\n", file->fp);
+ BT_LOGD("Opened file: %p", file->fp);
if (fstat(fileno(file->fp), &stat)) {
- PERR("Cannot get file informations: %s\n", strerror(errno));
+ BT_LOGE("Cannot get file informations: %s", strerror(errno));
goto error;
}
file->size = stat.st_size;
- PDBG(" File is %zu bytes\n", file->size);
+ BT_LOGD("File is %zu bytes", file->size);
goto end;
error:
if (file->fp) {
if (fclose(file->fp)) {
- PERR("Cannot close file \"%s\": %s\n", file->path->str,
+ BT_LOGE("Cannot close file \"%s\": %s", file->path->str,
strerror(errno));
}
}
void ctf_fs_file_destroy(struct ctf_fs_file *file);
BT_HIDDEN
-struct ctf_fs_file *ctf_fs_file_create(struct ctf_fs_component *ctf_fs);
+struct ctf_fs_file *ctf_fs_file_create(void);
BT_HIDDEN
-int ctf_fs_file_open(struct ctf_fs_component *ctf_fs, struct ctf_fs_file *file,
- const char *mode);
+int ctf_fs_file_open(struct ctf_fs_file *file, const char *mode);
#endif /* CTF_FS_FILE_H */
#include "../common/metadata/decoder.h"
#include "query.h"
-#define PRINT_ERR_STREAM ctf_fs->error_fp
-#define PRINT_PREFIX "ctf-fs"
-#define PRINT_DBG_CHECK ctf_fs_debug
-#include "../print.h"
+#define BT_LOG_TAG "PLUGIN-CTF-FS-SRC"
+#include "logging.h"
BT_HIDDEN
bool ctf_fs_debug;
}
static
-int create_one_port_for_trace(struct ctf_fs_trace *ctf_fs_trace,
+int create_one_port_for_trace(struct ctf_fs_component *ctf_fs,
+ struct ctf_fs_trace *ctf_fs_trace,
struct ctf_fs_ds_file_group *ds_file_group)
{
int ret = 0;
struct ctf_fs_port_data *port_data = NULL;
GString *port_name = NULL;
- struct ctf_fs_component *ctf_fs = ctf_fs_trace->ctf_fs;
struct ctf_fs_ds_file_info *ds_file_info =
g_ptr_array_index(ds_file_group->ds_file_infos, 0);
assert(ds_file_group->ds_file_infos->len > 0);
ds_file_info = g_ptr_array_index(ds_file_group->ds_file_infos, 0);
g_string_assign(port_name, ds_file_info->path->str);
- PDBG("Creating one port named `%s`\n", port_name->str);
+ BT_LOGD("Creating one port named `%s`", port_name->str);
/* Create output port for this file */
port_data = g_new0(struct ctf_fs_port_data, 1);
}
static
-int create_ports_for_trace(struct ctf_fs_trace *ctf_fs_trace)
+int create_ports_for_trace(struct ctf_fs_component *ctf_fs,
+ struct ctf_fs_trace *ctf_fs_trace)
{
int ret = 0;
- struct ctf_fs_component *ctf_fs = ctf_fs_trace->ctf_fs;
size_t i;
/* Create one output port for each stream file group */
struct ctf_fs_ds_file_group *ds_file_group =
g_ptr_array_index(ctf_fs_trace->ds_file_groups, i);
- ret = create_one_port_for_trace(ctf_fs_trace, ds_file_group);
+ ret = create_one_port_for_trace(ctf_fs, ctf_fs_trace,
+ ds_file_group);
if (ret) {
- PERR("Cannot create output port.\n");
+ BT_LOGE("Cannot create output port.");
goto end;
}
}
struct bt_ctf_field *packet_header_field = NULL;
struct bt_ctf_field *packet_context_field = NULL;
struct bt_ctf_stream_class *stream_class = NULL;
- struct ctf_fs_component *ctf_fs = ctf_fs_trace->ctf_fs;
uint64_t stream_instance_id = -1ULL;
uint64_t begin_ns = -1ULL;
struct ctf_fs_ds_file_group *ds_file_group = NULL;
ctf_fs_trace, path, &packet_header_field,
&packet_context_field);
if (ret) {
- PERR("Cannot get stream file's first packet's header and context fields (`%s`).\n",
+ BT_LOGE("Cannot get stream file's first packet's header and context fields (`%s`).",
path);
goto error;
}
const char *basename;
GError *error = NULL;
GDir *dir = NULL;
- struct ctf_fs_component *ctf_fs = ctf_fs_trace->ctf_fs;
/* Check each file in the path directory, except specific ones */
dir = g_dir_open(ctf_fs_trace->path->str, 0, &error);
if (!dir) {
- PERR("Cannot open directory `%s`: %s (code %d)\n",
+ BT_LOGE("Cannot open directory `%s`: %s (code %d)",
ctf_fs_trace->path->str, error->message,
error->code);
goto error;
if (!strcmp(basename, CTF_FS_METADATA_FILENAME)) {
/* Ignore the metadata stream. */
- PDBG("Ignoring metadata file `%s/%s`\n",
+ BT_LOGD("Ignoring metadata file `%s/%s`",
ctf_fs_trace->path->str, basename);
continue;
}
if (basename[0] == '.') {
- PDBG("Ignoring hidden file `%s/%s`\n",
+ BT_LOGD("Ignoring hidden file `%s/%s`",
ctf_fs_trace->path->str, basename);
continue;
}
/* Create the file. */
- file = ctf_fs_file_create(ctf_fs);
+ file = ctf_fs_file_create();
if (!file) {
- PERR("Cannot create stream file object for file `%s/%s`\n",
+ BT_LOGE("Cannot create stream file object for file `%s/%s`",
ctf_fs_trace->path->str, basename);
goto error;
}
g_string_append_printf(file->path, "%s/%s",
ctf_fs_trace->path->str, basename);
if (!g_file_test(file->path->str, G_FILE_TEST_IS_REGULAR)) {
- PDBG("Ignoring non-regular file `%s`\n",
+ BT_LOGD("Ignoring non-regular file `%s`",
file->path->str);
ctf_fs_file_destroy(file);
file = NULL;
continue;
}
- ret = ctf_fs_file_open(ctf_fs, file, "rb");
+ ret = ctf_fs_file_open(file, "rb");
if (ret) {
- PERR("Cannot open stream file `%s`\n", file->path->str);
+ BT_LOGE("Cannot open stream file `%s`", file->path->str);
goto error;
}
if (file->size == 0) {
/* Skip empty stream. */
- PDBG("Ignoring empty file `%s`\n", file->path->str);
+ BT_LOGD("Ignoring empty file `%s`", file->path->str);
ctf_fs_file_destroy(file);
continue;
}
ret = add_ds_file_to_ds_file_group(ctf_fs_trace,
file->path->str);
if (ret) {
- PDBG("Cannot add stream file `%s` to stream file group\n",
+ BT_LOGD("Cannot add stream file `%s` to stream file group",
file->path->str);
ctf_fs_file_destroy(file);
goto error;
}
static
-struct ctf_fs_trace *ctf_fs_trace_create(struct ctf_fs_component *ctf_fs,
- const char *path, const char *name)
+struct ctf_fs_trace *ctf_fs_trace_create(const char *path, const char *name,
+ struct metadata_overrides *overrides)
{
struct ctf_fs_trace *ctf_fs_trace;
int ret;
goto end;
}
- ctf_fs_trace->ctf_fs = ctf_fs;
ctf_fs_trace->path = g_string_new(path);
if (!ctf_fs_trace->path) {
goto error;
goto error;
}
- ret = ctf_fs_metadata_set_trace(ctf_fs_trace);
+ ret = ctf_fs_metadata_set_trace(ctf_fs_trace, overrides);
if (ret) {
goto error;
}
goto error;
}
- ret = create_ports_for_trace(ctf_fs_trace);
- if (ret) {
- goto error;
- }
-
/*
* create_ds_file_groups() created all the streams that this
* trace needs. There won't be any more. Therefore it is safe to
}
static
-int add_trace_path(struct ctf_fs_component *ctf_fs, GList **trace_paths,
- const char *path)
+int add_trace_path(GList **trace_paths, const char *path)
{
GString *norm_path = NULL;
int ret = 0;
norm_path = bt_common_normalize_path(path, NULL);
if (!norm_path) {
- PERR("Failed to normalize path `%s`.\n", path);
+ BT_LOGE("Failed to normalize path `%s`.", path);
ret = -1;
goto end;
}
if (strcmp(norm_path->str, "/") == 0) {
- PERR("Opening a trace in `/` is not supported.\n");
+ BT_LOGE("Opening a trace in `/` is not supported.");
ret = -1;
goto end;
}
return ret;
}
-static
-int find_ctf_traces(struct ctf_fs_component *ctf_fs,
- GList **trace_paths, const char *start_path)
+BT_HIDDEN
+int ctf_fs_find_traces(GList **trace_paths, const char *start_path)
{
int ret;
GError *error = NULL;
* Stop recursion: a CTF trace cannot contain another
* CTF trace.
*/
- ret = add_trace_path(ctf_fs, trace_paths, start_path);
+ ret = add_trace_path(trace_paths, start_path);
goto end;
}
dir = g_dir_open(start_path, 0, &error);
if (!dir) {
if (error->code == G_FILE_ERROR_ACCES) {
- PDBG("Cannot open directory `%s`: %s (code %d): continuing\n",
+ BT_LOGD("Cannot open directory `%s`: %s (code %d): continuing",
start_path, error->message, error->code);
goto end;
}
- PERR("Cannot open directory `%s`: %s (code %d)\n",
+ BT_LOGE("Cannot open directory `%s`: %s (code %d)",
start_path, error->message, error->code);
ret = -1;
goto end;
}
g_string_printf(sub_path, "%s/%s", start_path, basename);
- ret = find_ctf_traces(ctf_fs, trace_paths, sub_path->str);
+ ret = ctf_fs_find_traces(trace_paths, sub_path->str);
g_string_free(sub_path, TRUE);
if (ret) {
goto end;
return ret;
}
-static
-GList *create_trace_names(GList *trace_paths, const char *base_path) {
+BT_HIDDEN
+GList *ctf_fs_create_trace_names(GList *trace_paths, const char *base_path) {
GList *trace_names = NULL;
GList *node;
const char *last_sep;
GList *trace_names = NULL;
GList *tp_node;
GList *tn_node;
+ struct metadata_overrides metadata_overrides = {
+ .clock_offset_s = ctf_fs->options.clock_offset,
+ .clock_offset_ns = ctf_fs->options.clock_offset_ns,
+ };
norm_path = bt_common_normalize_path(path_param, NULL);
if (!norm_path) {
- PERR("Failed to normalize path: `%s`.\n",
+ BT_LOGE("Failed to normalize path: `%s`.",
path_param);
goto error;
}
- ret = find_ctf_traces(ctf_fs, &trace_paths, norm_path->str);
+ ret = ctf_fs_find_traces(&trace_paths, norm_path->str);
if (ret) {
goto error;
}
if (!trace_paths) {
- PERR("No CTF traces recursively found in `%s`.\n",
+ BT_LOGE("No CTF traces recursively found in `%s`.",
path_param);
goto error;
}
- trace_names = create_trace_names(trace_paths, norm_path->str);
+ trace_names = ctf_fs_create_trace_names(trace_paths, norm_path->str);
if (!trace_names) {
- PERR("Cannot create trace names from trace paths.\n");
+ BT_LOGE("Cannot create trace names from trace paths.");
goto error;
}
GString *trace_path = tp_node->data;
GString *trace_name = tn_node->data;
- ctf_fs_trace = ctf_fs_trace_create(ctf_fs, trace_path->str,
- trace_name->str);
+ ctf_fs_trace = ctf_fs_trace_create(trace_path->str,
+ trace_name->str, &metadata_overrides);
if (!ctf_fs_trace) {
- PERR("Cannot create trace for `%s`.\n",
+ BT_LOGE("Cannot create trace for `%s`.",
trace_path->str);
goto error;
}
+ ret = create_ports_for_trace(ctf_fs, ctf_fs_trace);
+ if (ret) {
+ goto error;
+ }
+
g_ptr_array_add(ctf_fs->traces, ctf_fs_trace);
ctf_fs_trace = NULL;
}
int64_t offset;
if (!bt_value_is_integer(value)) {
- fprintf(stderr,
- "offset-s should be an integer\n");
+ BT_LOGE("offset-s should be an integer");
goto error;
}
ret = bt_value_integer_get(value, &offset);
int64_t offset;
if (!bt_value_is_integer(value)) {
- fprintf(stderr,
- "offset-ns should be an integer\n");
+ BT_LOGE("offset-ns should be an integer");
goto error;
}
ret = bt_value_integer_get(value, &offset);
BT_PUT(value);
}
- ctf_fs->error_fp = stderr;
- ctf_fs->page_size = bt_common_get_page_size();
ctf_fs->port_data = g_ptr_array_new_with_free_func(port_data_destroy);
if (!ctf_fs->port_data) {
goto error;
if (!strcmp(object, "metadata-info")) {
result = metadata_info_query(comp_class, params);
} else {
- fprintf(stderr, "Unknown query object `%s`\n", object);
+ BT_LOGE("Unknown query object `%s`", object);
goto end;
}
end:
extern bool ctf_fs_debug;
struct ctf_fs_file {
- /* Weak, belongs to component */
- struct ctf_fs_component *ctf_fs;
-
/* Owned by this */
GString *path;
};
struct ctf_fs_component_options {
- uint64_t clock_offset;
- uint64_t clock_offset_ns;
+ int64_t clock_offset;
+ int64_t clock_offset_ns;
};
struct ctf_fs_component {
GPtrArray *traces;
struct ctf_fs_component_options options;
- FILE *error_fp;
- size_t page_size;
};
struct ctf_fs_trace {
- /* Weak, belongs to component */
- struct ctf_fs_component *ctf_fs;
-
/* Owned by this */
struct ctf_fs_metadata *metadata;
struct bt_private_notification_iterator *it,
struct bt_private_port *port);
+BT_HIDDEN
+struct bt_value *ctf_fs_query(struct bt_component_class *comp_class,
+ const char *object, struct bt_value *params);
+
+BT_HIDDEN
+int ctf_fs_find_traces(GList **trace_paths, const char *start_path);
+
+BT_HIDDEN
+GList *ctf_fs_create_trace_names(GList *trace_paths, const char *base_path);
+
void ctf_fs_iterator_finalize(struct bt_private_notification_iterator *it);
struct bt_notification_iterator_next_return ctf_fs_iterator_next(
struct bt_private_notification_iterator *iterator);
-BT_HIDDEN
-struct bt_value *ctf_fs_query(struct bt_component_class *comp_class,
- const char *object, struct bt_value *params);
-
#endif /* BABELTRACE_PLUGIN_CTF_FS_H */
--- /dev/null
+/*
+ * Copyright (c) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#define BT_LOG_OUTPUT_LEVEL ctf_fs_src_log_level
+#include <babeltrace/logging-internal.h>
+
+BT_LOG_INIT_LOG_LEVEL(BT_LOG_OUTPUT_LEVEL, "BABELTRACE_PLUGIN_CTF_FS_SRC_LOG_LEVEL");
--- /dev/null
+/*
+ * Copyright (c) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef CTF_FS_SRC_LOGGING_H
+#define CTF_FS_SRC_LOGGING_H
+
+#define BT_LOG_OUTPUT_LEVEL ctf_fs_src_log_level
+#include <babeltrace/logging-internal.h>
+
+BT_LOG_LEVEL_EXTERN_SYMBOL(ctf_fs_src_log_level);
+
+#endif /* CTF_FS_SRC_LOGGING_H */
#include <babeltrace/compat/uuid-internal.h>
#include <babeltrace/compat/memstream-internal.h>
-#define PRINT_ERR_STREAM ctf_fs->error_fp
-#define PRINT_PREFIX "ctf-fs-metadata"
-#define PRINT_DBG_CHECK ctf_fs_debug
-#include "../print.h"
-
#include "fs.h"
#include "file.h"
#include "metadata.h"
#include "../common/metadata/decoder.h"
+#define BT_LOG_TAG "PLUGIN-CTF-FS-METADATA-SRC"
+#include "logging.h"
+
#define NSEC_PER_SEC 1000000000LL
BT_HIDDEN
return fp;
}
-static struct ctf_fs_file *get_file(struct ctf_fs_component *ctf_fs,
- const char *trace_path)
+static struct ctf_fs_file *get_file(const char *trace_path)
{
- struct ctf_fs_file *file = ctf_fs_file_create(ctf_fs);
+ struct ctf_fs_file *file = ctf_fs_file_create();
if (!file) {
goto error;
g_string_append(file->path, trace_path);
g_string_append(file->path, "/" CTF_FS_METADATA_FILENAME);
- if (ctf_fs_file_open(ctf_fs, file, "rb")) {
+ if (ctf_fs_file_open(file, "rb")) {
goto error;
}
return file;
}
-int ctf_fs_metadata_set_trace(struct ctf_fs_trace *ctf_fs_trace)
+int ctf_fs_metadata_set_trace(struct ctf_fs_trace *ctf_fs_trace,
+ struct metadata_overrides *overrides)
{
int ret = 0;
- struct ctf_fs_component *ctf_fs = ctf_fs_trace->ctf_fs;
struct ctf_fs_file *file = NULL;
struct ctf_metadata_decoder *metadata_decoder = NULL;
+ int64_t clock_offset_adjustment = 0;
- file = get_file(ctf_fs, ctf_fs_trace->path->str);
+ file = get_file(ctf_fs_trace->path->str);
if (!file) {
- PERR("Cannot create metadata file object\n");
+ BT_LOGE("Cannot create metadata file object");
ret = -1;
goto end;
}
- metadata_decoder = ctf_metadata_decoder_create(ctf_fs->error_fp,
- ctf_fs->options.clock_offset * NSEC_PER_SEC +
- ctf_fs->options.clock_offset_ns, ctf_fs_trace->name->str);
+ if (overrides) {
+ clock_offset_adjustment =
+ overrides->clock_offset_s * NSEC_PER_SEC +
+ overrides->clock_offset_ns;
+ }
+ metadata_decoder = ctf_metadata_decoder_create(clock_offset_adjustment,
+ ctf_fs_trace->name->str);
if (!metadata_decoder) {
- PERR("Cannot create metadata decoder object\n");
+ BT_LOGE("Cannot create metadata decoder object");
ret = -1;
goto end;
}
ret = ctf_metadata_decoder_decode(metadata_decoder, file->fp);
if (ret) {
- PERR("Cannot decode metadata file\n");
+ BT_LOGE("Cannot decode metadata file");
goto end;
}
#define CTF_FS_METADATA_FILENAME "metadata"
+struct metadata_overrides {
+ int64_t clock_offset_s;
+ int64_t clock_offset_ns;
+};
+
BT_HIDDEN
int ctf_fs_metadata_init(struct ctf_fs_metadata *metadata);
void ctf_fs_metadata_fini(struct ctf_fs_metadata *metadata);
BT_HIDDEN
-int ctf_fs_metadata_set_trace(struct ctf_fs_trace *ctf_fs_trace);
+int ctf_fs_metadata_set_trace(struct ctf_fs_trace *ctf_fs_trace,
+ struct metadata_overrides *overrides);
BT_HIDDEN
FILE *ctf_fs_metadata_open_file(const char *trace_path);
#include <assert.h>
#include "metadata.h"
#include "../common/metadata/decoder.h"
+#include <babeltrace/common-internal.h>
+
+#define BT_LOG_TAG "PLUGIN-CTF-FS-QUERY-SRC"
+#include "logging.h"
#define METADATA_TEXT_SIG "/* CTF 1.8"
}
stream->notif_iter = bt_ctf_notif_iter_create(trace->trace,
lttng_live->max_query_size, medops,
- stream, stderr);
+ stream);
if (!stream->notif_iter) {
goto error;
}
if (trace->trace) {
stream->notif_iter = bt_ctf_notif_iter_create(trace->trace,
lttng_live->max_query_size, medops,
- stream, stderr);
+ stream);
if (!stream->notif_iter) {
goto error;
}
if (!match) {
goto error;
}
- metadata->decoder = ctf_metadata_decoder_create(stderr, 0,
+ metadata->decoder = ctf_metadata_decoder_create(0,
match);
if (!metadata->decoder) {
goto error;
projects / babeltrace.git / commitdiff
