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

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