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

   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.h"
  26 #include "decoder.h"
  27 #include "scanner.h"
  28 #include "logging.h"
  29 #include "parser-wrap.h"
  30 #include "decoder-packetized-file-stream-to-buf.h"
  31
  32 #define TSDL_MAGIC      0x75d11d57
  33
  34 struct ctf_metadata_decoder {
  35         struct ctf_scanner *scanner;
  36         GString *text;
  37         struct ctf_visitor_generate_ir *visitor;
  38         bt_uuid_t uuid;
  39         bool is_uuid_set;
  40         int bo;
  41         struct ctf_metadata_decoder_config config;
  42         struct meta_log_config log_cfg;
  43 };
  44
  45 struct packet_header {
  46         uint32_t magic;
  47         bt_uuid_t  uuid;
  48         uint32_t checksum;
  49         uint32_t content_size;
  50         uint32_t packet_size;
  51         uint8_t  compression_scheme;
  52         uint8_t  encryption_scheme;
  53         uint8_t  checksum_scheme;
  54         uint8_t  major;
  55         uint8_t  minor;
  56 } __attribute__((__packed__));
  57
  58 BT_HIDDEN
  59 int ctf_metadata_decoder_is_packetized(FILE *fp, bool *is_packetized,
  60                 int *byte_order, bt_logging_level log_level,
  61                 bt_self_component *self_comp)
  62 {
  63         uint32_t magic;
  64         size_t len;
  65         int ret = 0;
  66
  67         *is_packetized = false;
  68         len = fread(&magic, sizeof(magic), 1, fp);
  69         if (len != 1) {
  70                 BT_COMP_LOG_CUR_LVL(BT_LOG_INFO, log_level, self_comp,
  71                         "Cannot read first metadata packet header: assuming the stream is not packetized.");
  72                 ret = -1;
  73                 goto end;
  74         }
  75
  76         if (byte_order) {
  77                 if (magic == TSDL_MAGIC) {
  78                         *is_packetized = true;
  79                         *byte_order = BYTE_ORDER;
  80                 } else if (magic == GUINT32_SWAP_LE_BE(TSDL_MAGIC)) {
  81                         *is_packetized = true;
  82                         *byte_order = BYTE_ORDER == BIG_ENDIAN ?
  83                                 LITTLE_ENDIAN : BIG_ENDIAN;
  84                 }
  85         }
  86
  87 end:
  88         rewind(fp);
  89
  90         return ret;
  91 }
  92
  93 BT_HIDDEN
  94 struct ctf_metadata_decoder *ctf_metadata_decoder_create(
  95                 const struct ctf_metadata_decoder_config *config)
  96 {
  97         struct ctf_metadata_decoder *mdec =
  98                 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,
 109                         config->self_comp,
 110                         "Failed to allocate one CTF metadata decoder.");
 111                 goto end;
 112         }
 113
 114         mdec->log_cfg.log_level = config->log_level;
 115         mdec->log_cfg.self_comp = config->self_comp;
 116         mdec->log_cfg.self_comp_class = config->self_comp_class;
 117         mdec->scanner = ctf_scanner_alloc();
 118         if (!mdec->scanner) {
 119                 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot allocate a metadata lexical scanner: "
 120                         "mdec-addr=%p", 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", mdec);
 128                 goto error;
 129         }
 130
 131         mdec->bo = -1;
 132         mdec->config = *config;
 133         mdec->visitor = ctf_visitor_generate_ir_create(config);
 134         if (!mdec->visitor) {
 135                 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to create a CTF IR metadata AST visitor: "
 136                         "mdec-addr=%p", mdec);
 137                 goto error;
 138         }
 139
 140         BT_COMP_LOGD("Creating CTF metadata decoder: "
 141                 "clock-class-offset-s=%" PRId64 ", "
 142                 "clock-class-offset-ns=%" PRId64 ", addr=%p",
 143                 config->clock_class_offset_s, config->clock_class_offset_ns,
 144                 mdec);
 145         goto end;
 146
 147 error:
 148         ctf_metadata_decoder_destroy(mdec);
 149         mdec = NULL;
 150
 151 end:
 152         return mdec;
 153 }
 154
 155 BT_HIDDEN
 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 BT_HIDDEN
 176 enum ctf_metadata_decoder_status ctf_metadata_decoder_append_content(
 177                 struct ctf_metadata_decoder *mdec, FILE *fp)
 178 {
 179         enum ctf_metadata_decoder_status status =
 180                 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,
 189                         mdec->config.log_level, 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(fp,
 198                         &buf, mdec->bo, &mdec->is_uuid_set,
 199                         mdec->uuid, mdec->config.log_level,
 200                         mdec->config.self_comp,
 201                         mdec->config.self_comp_class);
 202                 if (ret) {
 203                         _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot decode packetized metadata packets to metadata text: "
 204                                 "mdec-addr=%p, ret=%d", 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", strerror(errno), mdec);
 220                         status = CTF_METADATA_DECODER_STATUS_ERROR;
 221                         goto end;
 222                 }
 223         } else {
 224                 unsigned int major, minor;
 225                 ssize_t nr_items;
 226                 const long init_pos = ftell(fp);
 227
 228                 BT_COMP_LOGI("Metadata stream is plain text: mdec-addr=%p", mdec);
 229
 230                 if (init_pos < 0) {
 231                         BT_COMP_LOGE_APPEND_CAUSE_ERRNO(BT_COMP_LOG_SELF_COMP,
 232                                 "Failed to get current file position", ".");
 233                         status = CTF_METADATA_DECODER_STATUS_ERROR;
 234                         goto end;
 235                 }
 236
 237                 /* Check text-only metadata header and version */
 238                 nr_items = fscanf(fp, "/* CTF %10u.%10u", &major, &minor);
 239                 if (nr_items < 2) {
 240                         BT_COMP_LOGW("Missing \"/* CTF major.minor\" signature in plain text metadata file stream: "
 241                                 "mdec-addr=%p", mdec);
 242                 }
 243
 244                 BT_COMP_LOGI("Found metadata stream version in signature: version=%u.%u", major, minor);
 245
 246                 if (!ctf_metadata_decoder_is_packet_version_valid(major,
 247                                 minor)) {
 248                         _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Invalid metadata version found in plain text signature: "
 249                                 "version=%u.%u, mdec-addr=%p", major, minor,
 250                                 mdec);
 251                         status = CTF_METADATA_DECODER_STATUS_INVAL_VERSION;
 252                         goto end;
 253                 }
 254
 255                 if (fseek(fp, init_pos, SEEK_SET)) {
 256                         _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot seek metadata file stream to initial position: %s: "
 257                                 "mdec-addr=%p", strerror(errno), mdec);
 258                         status = CTF_METADATA_DECODER_STATUS_ERROR;
 259                         goto end;
 260                 }
 261         }
 262
 263 #if YYDEBUG
 264         if (BT_LOG_ON_TRACE) {
 265                 yydebug = 1;
 266         }
 267 #endif
 268
 269         /* Save the file's position: we'll seek back to append the plain text */
 270         BT_ASSERT(fp);
 271
 272         if (mdec->config.keep_plain_text) {
 273                 start_pos = ftell(fp);
 274         }
 275
 276         /* Append the metadata text content */
 277         ret = ctf_scanner_append_ast(mdec->scanner, fp);
 278         if (ret) {
 279                 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot create the metadata AST out of the metadata text: "
 280                         "mdec-addr=%p", mdec);
 281                 status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
 282                 goto end;
 283         }
 284
 285         /* We know it's complete: append plain text */
 286         if (mdec->config.keep_plain_text) {
 287                 BT_ASSERT(start_pos != -1);
 288                 ret = fseek(fp, start_pos, SEEK_SET);
 289                 if (ret) {
 290                         _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to seek file: ret=%d, mdec-addr=%p",
 291                                 ret, mdec);
 292                         status = CTF_METADATA_DECODER_STATUS_ERROR;
 293                         goto end;
 294                 }
 295
 296                 ret = bt_common_append_file_content_to_g_string(mdec->text, fp);
 297                 if (ret) {
 298                         _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to append to current plain text: "
 299                                 "ret=%d, mdec-addr=%p", ret, mdec);
 300                         status = CTF_METADATA_DECODER_STATUS_ERROR;
 301                         goto end;
 302                 }
 303         }
 304
 305         ret = ctf_visitor_semantic_check(0, &mdec->scanner->ast->root,
 306                 &mdec->log_cfg);
 307         if (ret) {
 308                 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Validation of the metadata semantics failed: "
 309                         "mdec-addr=%p", mdec);
 310                 status = CTF_METADATA_DECODER_STATUS_ERROR;
 311                 goto end;
 312         }
 313
 314         if (mdec->config.create_trace_class) {
 315                 ret = ctf_visitor_generate_ir_visit_node(mdec->visitor,
 316                         &mdec->scanner->ast->root);
 317                 switch (ret) {
 318                 case 0:
 319                         /* Success */
 320                         break;
 321                 case -EINCOMPLETE:
 322                         BT_COMP_LOGD("While visiting metadata AST: incomplete data: "
 323                                 "mdec-addr=%p", mdec);
 324                         status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
 325                         goto end;
 326                 default:
 327                         _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Failed to visit AST node to create CTF IR objects: "
 328                                 "mdec-addr=%p, ret=%d", mdec, ret);
 329                         status = CTF_METADATA_DECODER_STATUS_IR_VISITOR_ERROR;
 330                         goto end;
 331                 }
 332         }
 333
 334 end:
 335 #if YYDEBUG
 336         yydebug = 0;
 337 #endif
 338
 339         if (fp && close_fp) {
 340                 if (fclose(fp)) {
 341                         BT_COMP_LOGE("Cannot close metadata file stream: "
 342                                 "mdec-addr=%p", mdec);
 343                 }
 344         }
 345
 346         free(buf);
 347
 348         return status;
 349 }
 350
 351 BT_HIDDEN
 352 bt_trace_class *ctf_metadata_decoder_get_ir_trace_class(
 353                 struct ctf_metadata_decoder *mdec)
 354 {
 355         BT_ASSERT_DBG(mdec);
 356         BT_ASSERT_DBG(mdec->config.create_trace_class);
 357         return ctf_visitor_generate_ir_get_ir_trace_class(mdec->visitor);
 358 }
 359
 360 BT_HIDDEN
 361 struct ctf_trace_class *ctf_metadata_decoder_borrow_ctf_trace_class(
 362                 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_borrow_ctf_trace_class(mdec->visitor);
 367 }
 368
 369 BT_HIDDEN
 370 const char *ctf_metadata_decoder_get_text(struct ctf_metadata_decoder *mdec)
 371 {
 372         BT_ASSERT_DBG(mdec);
 373         BT_ASSERT_DBG(mdec->config.keep_plain_text);
 374         return mdec->text->str;
 375 }
 376
 377 BT_HIDDEN
 378 int ctf_metadata_decoder_get_byte_order(struct ctf_metadata_decoder *mdec)
 379 {
 380         BT_ASSERT_DBG(mdec);
 381         return mdec->bo;
 382 }
 383
 384 BT_HIDDEN
 385 int ctf_metadata_decoder_get_uuid(struct ctf_metadata_decoder *mdec,
 386                 bt_uuid_t uuid)
 387 {
 388         int ret = 0;
 389
 390         BT_ASSERT_DBG(mdec);
 391
 392         if (!mdec->is_uuid_set) {
 393                 ret = -1;
 394                 goto end;
 395         }
 396
 397         bt_uuid_copy(uuid, mdec->uuid);
 398
 399 end:
 400         return ret;
 401 }
 402
 403 static
 404 enum ctf_metadata_decoder_status find_uuid_in_trace_decl(
 405                 struct ctf_metadata_decoder *mdec, struct ctf_node *trace_node,
 406                 bt_uuid_t uuid)
 407 {
 408         enum ctf_metadata_decoder_status status =
 409                 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(
 419                                 &entry_node->u.ctf_expression.left);
 420                         if (!left) {
 421                                 _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Cannot concatenate unary strings.");
 422                                 status = CTF_METADATA_DECODER_STATUS_ERROR;
 423                                 goto end;
 424                         }
 425
 426                         if (strcmp(left, "uuid") == 0) {
 427                                 ret = ctf_ast_get_unary_uuid(
 428                                         &entry_node->u.ctf_expression.right,
 429                                         uuid, mdec->config.log_level,
 430                                         mdec->config.self_comp);
 431                                 if (ret) {
 432                                         _BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE("Invalid trace's `uuid` attribute.");
 433                                         status = CTF_METADATA_DECODER_STATUS_ERROR;
 434                                         goto end;
 435                                 }
 436
 437                                 goto end;
 438                         }
 439
 440                         g_free(left);
 441                         left = NULL;
 442                 }
 443         }
 444
 445         status = CTF_METADATA_DECODER_STATUS_NONE;
 446
 447 end:
 448         g_free(left);
 449         return status;
 450 }
 451
 452 BT_HIDDEN
 453 enum ctf_metadata_decoder_status ctf_metadata_decoder_get_trace_class_uuid(
 454                 struct ctf_metadata_decoder *mdec, bt_uuid_t uuid)
 455 {
 456         enum ctf_metadata_decoder_status status =
 457                 CTF_METADATA_DECODER_STATUS_INCOMPLETE;
 458         struct ctf_node *root_node = &mdec->scanner->ast->root;
 459         struct ctf_node *trace_node;
 460
 461         if (!root_node) {
 462                 status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
 463                 goto end;
 464         }
 465
 466         trace_node =
 467                 bt_list_entry(root_node->u.root.trace.next,
 468                         struct ctf_node, siblings);
 469         if (!trace_node) {
 470                 status = CTF_METADATA_DECODER_STATUS_INCOMPLETE;
 471                 goto end;
 472         }
 473
 474         status = find_uuid_in_trace_decl(mdec, trace_node, uuid);
 475
 476 end:
 477         return status;
 478 }