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 #include <glib.h>
   8 #include <inttypes.h>
   9 #include <stdint.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13
  14 #include <babeltrace2/babeltrace.h>
  15
  16 #define BT_COMP_LOG_SELF_COMP       (mdec->config.self_comp)
  17 #define BT_COMP_LOG_SELF_COMP_CLASS (mdec->config.self_comp_class)
  18 #define BT_LOG_OUTPUT_LEVEL         ((enum bt_log_level) mdec->config.log_level)
  19 #define BT_LOG_TAG                  "PLUGIN/CTF/META/DECODER"
  20 #include "logging.hpp"
  21 #include "logging/comp-logging.h"
  22
  23 #include "common/assert.h"
  24 #include "common/uuid.h"
  25 #include "compat/memstream.h"
  26
  27 #include "ast.hpp"
  28 #include "decoder-packetized-file-stream-to-buf.hpp"
  29 #include "decoder.hpp"
  30 #include "parser-wrap.hpp"
  31 #include "scanner.hpp"
  32
  33 #define TSDL_MAGIC 0x75d11d57
  34
  35 struct ctf_metadata_decoder
  36 {
  37     struct ctf_scanner *scanner;
  38     GString *text;
  39     struct ctf_visitor_generate_ir *visitor;
  40     bt_uuid_t uuid;
  41     bool is_uuid_set;
  42     int bo;
  43     struct ctf_metadata_decoder_config config;
  44     struct meta_log_config log_cfg;
  45     bool has_checked_plaintext_signature;
  46 };
  47
  48 struct packet_header
  49 {
  50     uint32_t magic;
  51     bt_uuid_t uuid;
  52     uint32_t checksum;
  53     uint32_t content_size;
  54     uint32_t packet_size;
  55     uint8_t compression_scheme;
  56     uint8_t encryption_scheme;
  57     uint8_t checksum_scheme;
  58     uint8_t major;
  59     uint8_t minor;
  60 } __attribute__((__packed__));
  61
  62 int ctf_metadata_decoder_is_packetized(FILE *fp, bool *is_packetized, int *byte_order,
  63                                        bt_logging_level log_level, bt_self_component *self_comp)
  64 {
  65     uint32_t magic;
  66     size_t len;
  67     int ret = 0;
  68
  69     *is_packetized = false;
  70     len = fread(&magic, sizeof(magic), 1, fp);
  71     if (len != 1) {
  72         BT_COMP_LOG_CUR_LVL(
  73             BT_LOG_INFO, log_level, self_comp,
  74             "Cannot read first metadata packet header: assuming the stream is not packetized.");
  75         ret = -1;
  76         goto end;
  77     }
  78
  79     if (byte_order) {
  80         if (magic == TSDL_MAGIC) {
  81             *is_packetized = true;
  82             *byte_order = BYTE_ORDER;
  83         } else if (magic == GUINT32_SWAP_LE_BE(TSDL_MAGIC)) {
  84             *is_packetized = true;
  85             *byte_order = BYTE_ORDER == BIG_ENDIAN ? LITTLE_ENDIAN : BIG_ENDIAN;
  86         }
  87     }
  88
  89 end:
  90     rewind(fp);
  91
  92     return ret;
  93 }
  94
  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 void ctf_metadata_decoder_destroy(struct ctf_metadata_decoder *mdec)
 157 {
 158     if (!mdec) {
 159         return;
 160     }
 161
 162     if (mdec->scanner) {
 163         ctf_scanner_free(mdec->scanner);
 164     }
 165
 166     if (mdec->text) {
 167         g_string_free(mdec->text, TRUE);
 168     }
 169
 170     BT_COMP_LOGD("Destroying CTF metadata decoder: addr=%p", mdec);
 171     ctf_visitor_generate_ir_destroy(mdec->visitor);
 172     g_free(mdec);
 173 }
 174
 175 enum ctf_metadata_decoder_status
 176 ctf_metadata_decoder_append_content(struct ctf_metadata_decoder *mdec, FILE *fp)
 177 {
 178     enum ctf_metadata_decoder_status status = CTF_METADATA_DECODER_STATUS_OK;
 179     int ret;
 180     char *buf = NULL;
 181     bool close_fp = false;
 182     long start_pos = -1;
 183     bool is_packetized;
 184
 185     BT_ASSERT(mdec);
 186     ret = ctf_metadata_decoder_is_packetized(fp, &is_packetized, &mdec->bo, mdec->config.log_level,
 187                                              mdec->config.self_comp);
 188     if (ret) {
 189         status = CTF_METADATA_DECODER_STATUS_ERROR;
 190         goto end;
 191     }
 192
 193     if (is_packetized) {
 194         BT_COMP_LOGI("Metadata stream is packetized: mdec-addr=%p", mdec);
 195         ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
 196             fp, &buf, mdec->bo, &mdec->is_uuid_set, mdec->uuid, mdec->config.log_level,
 197             mdec->config.self_comp, mdec->config.self_comp_class);
 198         if (ret) {
 199             _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
 200                 "Cannot decode packetized metadata packets to metadata text: "
 201                 "mdec-addr=%p, ret=%d",
 202                 mdec, ret);
 203             status = CTF_METADATA_DECODER_STATUS_ERROR;
 204             goto end;
 205         }
 206
 207         if (strlen(buf) == 0) {
 208             /* An empty metadata packet is OK. */
 209             goto end;
 210         }
 211
 212         /* Convert the real file pointer to a memory file pointer */
 213         fp = bt_fmemopen(buf, strlen(buf), "rb");
 214         close_fp = true;
 215         if (!fp) {
 216             _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot memory-open metadata buffer: %s: "
 217                                                      "mdec-addr=%p",
 218                                                      strerror(errno), mdec);
 219             status = CTF_METADATA_DECODER_STATUS_ERROR;
 220             goto end;
 221         }
 222     } else if (!mdec->has_checked_plaintext_signature) {
 223         unsigned int major, minor;
 224         ssize_t nr_items;
 225         const long init_pos = ftell(fp);
 226
 227         BT_COMP_LOGI("Metadata stream is plain text: mdec-addr=%p", mdec);
 228
 229         if (init_pos < 0) {
 230             BT_COMP_LOGE_APPEND_CAUSE_ERRNO(BT_COMP_LOG_SELF_COMP,
 231                                             "Failed to get current file position", ".");
 232             status = CTF_METADATA_DECODER_STATUS_ERROR;
 233             goto end;
 234         }
 235
 236         /* Check text-only metadata header and version */
 237         nr_items = fscanf(fp, "/* CTF %10u.%10u", &major, &minor);
 238         if (nr_items < 2) {
 239             BT_COMP_LOGW(
 240                 "Missing \"/* CTF major.minor\" signature in plain text metadata file stream: "
 241                 "mdec-addr=%p",
 242                 mdec);
 243         }
 244
 245         BT_COMP_LOGI("Found metadata stream version in signature: version=%u.%u", major, minor);
 246
 247         if (!ctf_metadata_decoder_is_packet_version_valid(major, minor)) {
 248             _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
 249                 "Invalid metadata version found in plain text signature: "
 250                 "version=%u.%u, mdec-addr=%p",
 251                 major, minor, mdec);
 252             status = CTF_METADATA_DECODER_STATUS_INVAL_VERSION;
 253             goto end;
 254         }
 255
 256         if (fseek(fp, init_pos, SEEK_SET)) {
 257             _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(
 258                 "Cannot seek metadata file stream to initial position: %s: "
 259                 "mdec-addr=%p",
 260                 strerror(errno), mdec);
 261             status = CTF_METADATA_DECODER_STATUS_ERROR;
 262             goto end;
 263         }
 264
 265         mdec->has_checked_plaintext_signature = true;
 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_trace_class *ctf_metadata_decoder_get_ir_trace_class(struct ctf_metadata_decoder *mdec)
 363 {
 364     BT_ASSERT_DBG(mdec);
 365     BT_ASSERT_DBG(mdec->config.create_trace_class);
 366     return ctf_visitor_generate_ir_get_ir_trace_class(mdec->visitor);
 367 }
 368
 369 struct ctf_trace_class *
 370 ctf_metadata_decoder_borrow_ctf_trace_class(struct ctf_metadata_decoder *mdec)
 371 {
 372     BT_ASSERT_DBG(mdec);
 373     BT_ASSERT_DBG(mdec->config.create_trace_class);
 374     return ctf_visitor_generate_ir_borrow_ctf_trace_class(mdec->visitor);
 375 }
 376
 377 const char *ctf_metadata_decoder_get_text(struct ctf_metadata_decoder *mdec)
 378 {
 379     BT_ASSERT_DBG(mdec);
 380     BT_ASSERT_DBG(mdec->config.keep_plain_text);
 381     return mdec->text->str;
 382 }
 383
 384 int ctf_metadata_decoder_get_byte_order(struct ctf_metadata_decoder *mdec)
 385 {
 386     BT_ASSERT_DBG(mdec);
 387     return mdec->bo;
 388 }
 389
 390 int ctf_metadata_decoder_get_uuid(struct ctf_metadata_decoder *mdec, bt_uuid_t uuid)
 391 {
 392     int ret = 0;
 393
 394     BT_ASSERT_DBG(mdec);
 395
 396     if (!mdec->is_uuid_set) {
 397         ret = -1;
 398         goto end;
 399     }
 400
 401     bt_uuid_copy(uuid, mdec->uuid);
 402
 403 end:
 404     return ret;
 405 }
 406
 407 static enum ctf_metadata_decoder_status find_uuid_in_trace_decl(struct ctf_metadata_decoder *mdec,
 408                                                                 struct ctf_node *trace_node,
 409                                                                 bt_uuid_t uuid)
 410 {
 411     enum ctf_metadata_decoder_status status = CTF_METADATA_DECODER_STATUS_OK;
 412     struct ctf_node *entry_node;
 413     struct bt_list_head *decl_list = &trace_node->u.trace.declaration_list;
 414     char *left = NULL;
 415
 416     bt_list_for_each_entry (entry_node, decl_list, siblings) {
 417         if (entry_node->type == NODE_CTF_EXPRESSION) {
 418             int ret;
 419
 420             left = ctf_ast_concatenate_unary_strings(&entry_node->u.ctf_expression.left);
 421             if (!left) {
 422                 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot concatenate unary strings.");
 423                 status = CTF_METADATA_DECODER_STATUS_ERROR;
 424                 goto end;
 425             }
 426
 427             if (strcmp(left, "uuid") == 0) {
 428                 ret = ctf_ast_get_unary_uuid(&entry_node->u.ctf_expression.right, uuid,
 429                                              mdec->config.log_level, mdec->config.self_comp);
 430                 if (ret) {
 431                     _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Invalid trace's `uuid` attribute.");
 432                     status = CTF_METADATA_DECODER_STATUS_ERROR;
 433                     goto end;
 434                 }
 435
 436                 goto end;
 437             }
 438
 439             g_free(left);
 440             left = NULL;
 441         }
 442     }
 443
 444     status = CTF_METADATA_DECODER_STATUS_NONE;
 445
 446 end:
 447     g_free(left);
 448     return status;
 449 }
 450
 451 enum ctf_metadata_decoder_status
 452 ctf_metadata_decoder_get_trace_class_uuid(struct ctf_metadata_decoder *mdec, bt_uuid_t uuid)
 453 {
 454     enum ctf_metadata_decoder_status status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
 455     struct ctf_node *root_node = &mdec->scanner->ast->root;
 456     struct ctf_node *trace_node;
 457
 458     if (!root_node) {
 459         status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
 460         goto end;
 461     }
 462
 463     trace_node = bt_list_entry(root_node->u.root.trace.next, struct ctf_node, siblings);
 464     if (!trace_node) {
 465         status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
 466         goto end;
 467     }
 468
 469     status = find_uuid_in_trace_decl(mdec, trace_node, uuid);
 470
 471 end:
 472     return status;
 473 }