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

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