src/plugins/ctf/common/metadata/decoder.cpp

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2016-2017 Philippe Proulx <pproulx@efficios.com>
   5  */
   6
   7 #define BT_COMP_LOG_SELF_COMP       (mdec->config.self_comp)
   8 #define BT_COMP_LOG_SELF_COMP_CLASS (mdec->config.self_comp_class)
   9 #define BT_LOG_OUTPUT_LEVEL         (mdec->config.log_level)
  10 #define BT_LOG_TAG                  "PLUGIN/CTF/META/DECODER"
  11 #include "logging/comp-logging.h"
  12
  13 #include <stdio.h>
  14 #include <stdbool.h>
  15 #include <stdint.h>
  16 #include <stdlib.h>
  17 #include <inttypes.h>
  18 #include "common/assert.h"
  19 #include "common/uuid.h"
  20 #include "compat/memstream.h"
  21 #include <babeltrace2/babeltrace.h>
  22 #include <glib.h>
  23 #include <string.h>
  24
  25 #include "ast.hpp"
  26 #include "decoder.hpp"
  27 #include "scanner.hpp"
  28 #include "logging.hpp"
  29 #include "parser-wrap.hpp"
  30 #include "decoder-packetized-file-stream-to-buf.hpp"
  31
  32 #define TSDL_MAGIC 0x75d11d57
  33
  34 struct ctf_metadata_decoder
  35 {
  36     struct ctf_scanner *scanner;
  37     GString *text;
  38     struct ctf_visitor_generate_ir *visitor;
  39     bt_uuid_t uuid;
  40     bool is_uuid_set;
  41     int bo;
  42     struct ctf_metadata_decoder_config config;
  43     struct meta_log_config log_cfg;
  44 };
  45
  46 struct packet_header
  47 {
  48     uint32_t magic;
  49     bt_uuid_t uuid;
  50     uint32_t checksum;
  51     uint32_t content_size;
  52     uint32_t packet_size;
  53     uint8_t compression_scheme;
  54     uint8_t encryption_scheme;
  55     uint8_t checksum_scheme;
  56     uint8_t major;
  57     uint8_t minor;
  58 } __attribute__((__packed__));
  59
  60 BT_HIDDEN
  61 int ctf_metadata_decoder_is_packetized(FILE *fp, bool *is_packetized, int *byte_order,
  62                                        bt_logging_level log_level, bt_self_component *self_comp)
  63 {
  64     uint32_t magic;
  65     size_t len;
  66     int ret = 0;
  67
  68     *is_packetized = false;
  69     len = fread(&magic, sizeof(magic), 1, fp);
  70     if (len != 1) {
  71         BT_COMP_LOG_CUR_LVL(
  72             BT_LOG_INFO, log_level, self_comp,
  73             "Cannot read first metadata packet header: assuming the stream is not packetized.");
  74         ret = -1;
  75         goto end;
  76     }
  77
  78     if (byte_order) {
  79         if (magic == TSDL_MAGIC) {
  80             *is_packetized = true;
  81             *byte_order = BYTE_ORDER;
  82         } else if (magic == GUINT32_SWAP_LE_BE(TSDL_MAGIC)) {
  83             *is_packetized = true;
  84             *byte_order = BYTE_ORDER == BIG_ENDIAN ? LITTLE_ENDIAN : BIG_ENDIAN;
  85         }
  86     }
  87
  88 end:
  89     rewind(fp);
  90
  91     return ret;
  92 }
  93
  94 BT_HIDDEN
  95 struct ctf_metadata_decoder *
  96 ctf_metadata_decoder_create(const struct ctf_metadata_decoder_config *config)
  97 {
  98     struct ctf_metadata_decoder *mdec = g_new0(struct ctf_metadata_decoder, 1);
  99
 100     BT_ASSERT(config);
 101     BT_COMP_LOG_CUR_LVL(BT_LOG_DEBUG, config->log_level, config->self_comp,
 102                         "Creating CTF metadata decoder: "
 103                         "clock-class-offset-s=%" PRId64 ", "
 104                         "clock-class-offset-ns=%" PRId64,
 105                         config->clock_class_offset_s, config->clock_class_offset_ns);
 106
 107     if (!mdec) {
 108         BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, config->log_level, config->self_comp,
 109                             "Failed to allocate one CTF metadata decoder.");
 110         goto end;
 111     }
 112
 113     mdec->log_cfg.log_level = config->log_level;
 114     mdec->log_cfg.self_comp = config->self_comp;
 115     mdec->log_cfg.self_comp_class = config->self_comp_class;
 116     mdec->scanner = ctf_scanner_alloc();
 117     if (!mdec->scanner) {
 118         _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot allocate a metadata lexical scanner: "
 119                                                  "mdec-addr=%p",
 120                                                  mdec);
 121         goto error;
 122     }
 123
 124     mdec->text = g_string_new(NULL);
 125     if (!mdec->text) {
 126         _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to allocate one GString: "
 127                                                  "mdec-addr=%p",
 128                                                  mdec);
 129         goto error;
 130     }
 131
 132     mdec->bo = -1;
 133     mdec->config = *config;
 134     mdec->visitor = ctf_visitor_generate_ir_create(config);
 135     if (!mdec->visitor) {
 136         _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to create a CTF IR metadata AST visitor: "
 137                                                  "mdec-addr=%p",
 138                                                  mdec);
 139         goto error;
 140     }
 141
 142     BT_COMP_LOGD("Creating CTF metadata decoder: "
 143                  "clock-class-offset-s=%" PRId64 ", "
 144                  "clock-class-offset-ns=%" PRId64 ", addr=%p",
 145                  config->clock_class_offset_s, config->clock_class_offset_ns, mdec);
 146     goto end;
 147
 148 error:
 149     ctf_metadata_decoder_destroy(mdec);
 150     mdec = NULL;
 151
 152 end:
 153     return mdec;
 154 }
 155
 156 BT_HIDDEN
 157 void ctf_metadata_decoder_destroy(struct ctf_metadata_decoder *mdec)
 158 {
 159     if (!mdec) {
 160         return;
 161     }
 162
 163     if (mdec->scanner) {
 164         ctf_scanner_free(mdec->scanner);
 165     }
 166
 167     if (mdec->text) {
 168         g_string_free(mdec->text, TRUE);
 169     }
 170
 171     BT_COMP_LOGD("Destroying CTF metadata decoder: addr=%p", mdec);
 172     ctf_visitor_generate_ir_destroy(mdec->visitor);
 173     g_free(mdec);
 174 }
 175
 176 BT_HIDDEN
 177 enum ctf_metadata_decoder_status
 178 ctf_metadata_decoder_append_content(struct ctf_metadata_decoder *mdec, FILE *fp)
 179 {
 180     enum ctf_metadata_decoder_status status = CTF_METADATA_DECODER_STATUS_OK;
 181     int ret;
 182     char *buf = NULL;
 183     bool close_fp = false;
 184     long start_pos = -1;
 185     bool is_packetized;
 186
 187     BT_ASSERT(mdec);
 188     ret = ctf_metadata_decoder_is_packetized(fp, &is_packetized, &mdec->bo, mdec->config.log_level,
 189                                              mdec->config.self_comp);
 190     if (ret) {
 191         status = CTF_METADATA_DECODER_STATUS_ERROR;
 192         goto end;
 193     }
 194
 195     if (is_packetized) {
 196         BT_COMP_LOGI("Metadata stream is packetized: mdec-addr=%p", mdec);
 197         ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
 198             fp, &buf, mdec->bo, &mdec->is_uuid_set, mdec->uuid, mdec->config.log_level,
 199             mdec->config.self_comp, mdec->config.self_comp_class);
 200         if (ret) {
 201             _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
 202                 "Cannot decode packetized metadata packets to metadata text: "
 203                 "mdec-addr=%p, ret=%d",
 204                 mdec, ret);
 205             status = CTF_METADATA_DECODER_STATUS_ERROR;
 206             goto end;
 207         }
 208
 209         if (strlen(buf) == 0) {
 210             /* An empty metadata packet is OK. */
 211             goto end;
 212         }
 213
 214         /* Convert the real file pointer to a memory file pointer */
 215         fp = bt_fmemopen(buf, strlen(buf), "rb");
 216         close_fp = true;
 217         if (!fp) {
 218             _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot memory-open metadata buffer: %s: "
 219                                                      "mdec-addr=%p",
 220                                                      strerror(errno), mdec);
 221             status = CTF_METADATA_DECODER_STATUS_ERROR;
 222             goto end;
 223         }
 224     } else {
 225         unsigned int major, minor;
 226         ssize_t nr_items;
 227         const long init_pos = ftell(fp);
 228
 229         BT_COMP_LOGI("Metadata stream is plain text: mdec-addr=%p", mdec);
 230
 231         if (init_pos < 0) {
 232             BT_COMP_LOGE_APPEND_CAUSE_ERRNO(BT_COMP_LOG_SELF_COMP,
 233                                             "Failed to get current file position", ".");
 234             status = CTF_METADATA_DECODER_STATUS_ERROR;
 235             goto end;
 236         }
 237
 238         /* Check text-only metadata header and version */
 239         nr_items = fscanf(fp, "/* CTF %10u.%10u", &major, &minor);
 240         if (nr_items < 2) {
 241             BT_COMP_LOGW(
 242                 "Missing \"/* CTF major.minor\" signature in plain text metadata file stream: "
 243                 "mdec-addr=%p",
 244                 mdec);
 245         }
 246
 247         BT_COMP_LOGI("Found metadata stream version in signature: version=%u.%u", major, minor);
 248
 249         if (!ctf_metadata_decoder_is_packet_version_valid(major, minor)) {
 250             _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
 251                 "Invalid metadata version found in plain text signature: "
 252                 "version=%u.%u, mdec-addr=%p",
 253                 major, minor, mdec);
 254             status = CTF_METADATA_DECODER_STATUS_INVAL_VERSION;
 255             goto end;
 256         }
 257
 258         if (fseek(fp, init_pos, SEEK_SET)) {
 259             _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
 260                 "Cannot seek metadata file stream to initial position: %s: "
 261                 "mdec-addr=%p",
 262                 strerror(errno), mdec);
 263             status = CTF_METADATA_DECODER_STATUS_ERROR;
 264             goto end;
 265         }
 266     }
 267
 268 #if YYDEBUG
 269     if (BT_LOG_ON_TRACE) {
 270         yydebug = 1;
 271     }
 272 #endif
 273
 274     /* Save the file's position: we'll seek back to append the plain text */
 275     BT_ASSERT(fp);
 276
 277     if (mdec->config.keep_plain_text) {
 278         start_pos = ftell(fp);
 279     }
 280
 281     /* Append the metadata text content */
 282     ret = ctf_scanner_append_ast(mdec->scanner, fp);
 283     if (ret) {
 284         _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
 285             "Cannot create the metadata AST out of the metadata text: "
 286             "mdec-addr=%p",
 287             mdec);
 288         status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
 289         goto end;
 290     }
 291
 292     /* We know it's complete: append plain text */
 293     if (mdec->config.keep_plain_text) {
 294         BT_ASSERT(start_pos != -1);
 295         ret = fseek(fp, start_pos, SEEK_SET);
 296         if (ret) {
 297             _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to seek file: ret=%d, mdec-addr=%p",
 298                                                      ret, mdec);
 299             status = CTF_METADATA_DECODER_STATUS_ERROR;
 300             goto end;
 301         }
 302
 303         ret = bt_common_append_file_content_to_g_string(mdec->text, fp);
 304         if (ret) {
 305             _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to append to current plain text: "
 306                                                      "ret=%d, mdec-addr=%p",
 307                                                      ret, mdec);
 308             status = CTF_METADATA_DECODER_STATUS_ERROR;
 309             goto end;
 310         }
 311     }
 312
 313     ret = ctf_visitor_semantic_check(0, &mdec->scanner->ast->root, &mdec->log_cfg);
 314     if (ret) {
 315         _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Validation of the metadata semantics failed: "
 316                                                  "mdec-addr=%p",
 317                                                  mdec);
 318         status = CTF_METADATA_DECODER_STATUS_ERROR;
 319         goto end;
 320     }
 321
 322     if (mdec->config.create_trace_class) {
 323         ret = ctf_visitor_generate_ir_visit_node(mdec->visitor, &mdec->scanner->ast->root);
 324         switch (ret) {
 325         case 0:
 326             /* Success */
 327             break;
 328         case -EINCOMPLETE:
 329             BT_COMP_LOGD("While visiting metadata AST: incomplete data: "
 330                          "mdec-addr=%p",
 331                          mdec);
 332             status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
 333             goto end;
 334         default:
 335             _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
 336                 "Failed to visit AST node to create CTF IR objects: "
 337                 "mdec-addr=%p, ret=%d",
 338                 mdec, ret);
 339             status = CTF_METADATA_DECODER_STATUS_IR_VISITOR_ERROR;
 340             goto end;
 341         }
 342     }
 343
 344 end:
 345 #if YYDEBUG
 346     yydebug = 0;
 347 #endif
 348
 349     if (fp && close_fp) {
 350         if (fclose(fp)) {
 351             BT_COMP_LOGE("Cannot close metadata file stream: "
 352                          "mdec-addr=%p",
 353                          mdec);
 354         }
 355     }
 356
 357     free(buf);
 358
 359     return status;
 360 }
 361
 362 BT_HIDDEN
 363 bt_trace_class *ctf_metadata_decoder_get_ir_trace_class(struct ctf_metadata_decoder *mdec)
 364 {
 365     BT_ASSERT_DBG(mdec);
 366     BT_ASSERT_DBG(mdec->config.create_trace_class);
 367     return ctf_visitor_generate_ir_get_ir_trace_class(mdec->visitor);
 368 }
 369
 370 BT_HIDDEN
 371 struct ctf_trace_class *
 372 ctf_metadata_decoder_borrow_ctf_trace_class(struct ctf_metadata_decoder *mdec)
 373 {
 374     BT_ASSERT_DBG(mdec);
 375     BT_ASSERT_DBG(mdec->config.create_trace_class);
 376     return ctf_visitor_generate_ir_borrow_ctf_trace_class(mdec->visitor);
 377 }
 378
 379 BT_HIDDEN
 380 const char *ctf_metadata_decoder_get_text(struct ctf_metadata_decoder *mdec)
 381 {
 382     BT_ASSERT_DBG(mdec);
 383     BT_ASSERT_DBG(mdec->config.keep_plain_text);
 384     return mdec->text->str;
 385 }
 386
 387 BT_HIDDEN
 388 int ctf_metadata_decoder_get_byte_order(struct ctf_metadata_decoder *mdec)
 389 {
 390     BT_ASSERT_DBG(mdec);
 391     return mdec->bo;
 392 }
 393
 394 BT_HIDDEN
 395 int ctf_metadata_decoder_get_uuid(struct ctf_metadata_decoder *mdec, bt_uuid_t uuid)
 396 {
 397     int ret = 0;
 398
 399     BT_ASSERT_DBG(mdec);
 400
 401     if (!mdec->is_uuid_set) {
 402         ret = -1;
 403         goto end;
 404     }
 405
 406     bt_uuid_copy(uuid, mdec->uuid);
 407
 408 end:
 409     return ret;
 410 }
 411
 412 static enum ctf_metadata_decoder_status find_uuid_in_trace_decl(struct ctf_metadata_decoder *mdec,
 413                                                                 struct ctf_node *trace_node,
 414                                                                 bt_uuid_t uuid)
 415 {
 416     enum ctf_metadata_decoder_status status = CTF_METADATA_DECODER_STATUS_OK;
 417     struct ctf_node *entry_node;
 418     struct bt_list_head *decl_list = &trace_node->u.trace.declaration_list;
 419     char *left = NULL;
 420
 421     bt_list_for_each_entry (entry_node, decl_list, siblings) {
 422         if (entry_node->type == NODE_CTF_EXPRESSION) {
 423             int ret;
 424
 425             left = ctf_ast_concatenate_unary_strings(&entry_node->u.ctf_expression.left);
 426             if (!left) {
 427                 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot concatenate unary strings.");
 428                 status = CTF_METADATA_DECODER_STATUS_ERROR;
 429                 goto end;
 430             }
 431
 432             if (strcmp(left, "uuid") == 0) {
 433                 ret = ctf_ast_get_unary_uuid(&entry_node->u.ctf_expression.right, uuid,
 434                                              mdec->config.log_level, mdec->config.self_comp);
 435                 if (ret) {
 436                     _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Invalid trace's `uuid` attribute.");
 437                     status = CTF_METADATA_DECODER_STATUS_ERROR;
 438                     goto end;
 439                 }
 440
 441                 goto end;
 442             }
 443
 444             g_free(left);
 445             left = NULL;
 446         }
 447     }
 448
 449     status = CTF_METADATA_DECODER_STATUS_NONE;
 450
 451 end:
 452     g_free(left);
 453     return status;
 454 }
 455
 456 BT_HIDDEN
 457 enum ctf_metadata_decoder_status
 458 ctf_metadata_decoder_get_trace_class_uuid(struct ctf_metadata_decoder *mdec, bt_uuid_t uuid)
 459 {
 460     enum ctf_metadata_decoder_status status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
 461     struct ctf_node *root_node = &mdec->scanner->ast->root;
 462     struct ctf_node *trace_node;
 463
 464     if (!root_node) {
 465         status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
 466         goto end;
 467     }
 468
 469     trace_node = bt_list_entry(root_node->u.root.trace.next, struct ctf_node, siblings);
 470     if (!trace_node) {
 471         status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
 472         goto end;
 473     }
 474
 475     status = find_uuid_in_trace_decl(mdec, trace_node, uuid);
 476
 477 end:
 478     return status;
 479 }