src/plugins/ctf/fs-src/query.c

   1 /*
   2  * query.c
   3  *
   4  * Babeltrace CTF file system Reader Component queries
   5  *
   6  * Copyright 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a copy
   9  * of this software and associated documentation files (the "Software"), to deal
  10  * in the Software without restriction, including without limitation the rights
  11  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12  * copies of the Software, and to permit persons to whom the Software is
  13  * furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24  * SOFTWARE.
  25  */
  26
  27 #define BT_LOG_OUTPUT_LEVEL log_level
  28 #define BT_LOG_TAG "PLUGIN/SRC.CTF.FS/QUERY"
  29 #include "logging/log.h"
  30
  31 #include "query.h"
  32 #include <stdbool.h>
  33 #include "common/assert.h"
  34 #include "metadata.h"
  35 #include "../common/metadata/decoder.h"
  36 #include "common/common.h"
  37 #include "common/macros.h"
  38 #include <babeltrace2/babeltrace.h>
  39 #include "fs.h"
  40
  41 #define METADATA_TEXT_SIG       "/* CTF 1.8"
  42
  43 struct range {
  44         int64_t begin_ns;
  45         int64_t end_ns;
  46         bool set;
  47 };
  48
  49 BT_HIDDEN
  50 bt_component_class_query_method_status metadata_info_query(
  51                 bt_self_component_class_source *comp_class,
  52                 const bt_value *params, bt_logging_level log_level,
  53                 const bt_value **user_result)
  54 {
  55         bt_component_class_query_method_status status =
  56                 BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
  57         bt_value *result = NULL;
  58         const bt_value *path_value = NULL;
  59         char *metadata_text = NULL;
  60         FILE *metadata_fp = NULL;
  61         GString *g_metadata_text = NULL;
  62         int ret;
  63         int bo;
  64         const char *path;
  65         bool is_packetized;
  66
  67         result = bt_value_map_create();
  68         if (!result) {
  69                 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
  70                 goto error;
  71         }
  72
  73         BT_ASSERT(params);
  74
  75         if (!bt_value_is_map(params)) {
  76                 BT_LOGE_STR("Query parameters is not a map value object.");
  77                 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_INVALID_PARAMS;
  78                 goto error;
  79         }
  80
  81         path_value = bt_value_map_borrow_entry_value_const(params, "path");
  82         if (!path_value) {
  83                 BT_LOGE_STR("Mandatory `path` parameter missing");
  84                 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_INVALID_PARAMS;
  85                 goto error;
  86         }
  87
  88         if (!bt_value_is_string(path_value)) {
  89                 BT_LOGE_STR("`path` parameter is required to be a string value");
  90                 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_INVALID_PARAMS;
  91                 goto error;
  92         }
  93
  94         path = bt_value_string_get(path_value);
  95
  96         BT_ASSERT(path);
  97         metadata_fp = ctf_fs_metadata_open_file(path);
  98         if (!metadata_fp) {
  99                 BT_LOGE("Cannot open trace metadata: path=\"%s\".", path);
 100                 goto error;
 101         }
 102
 103         is_packetized = ctf_metadata_decoder_is_packetized(metadata_fp,
 104                 &bo, log_level, NULL);
 105
 106         if (is_packetized) {
 107                 ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
 108                         metadata_fp, &metadata_text, bo, NULL, NULL,
 109                         log_level, NULL);
 110                 if (ret) {
 111                         BT_LOGE("Cannot decode packetized metadata file: path=\"%s\"",
 112                                 path);
 113                         goto error;
 114                 }
 115         } else {
 116                 long filesize;
 117
 118                 ret = fseek(metadata_fp, 0, SEEK_END);
 119                 if (ret) {
 120                         BT_LOGE_ERRNO("Failed to seek to the end of the metadata file",
 121                                 ": path=\"%s\"", path);
 122                         goto error;
 123                 }
 124                 filesize = ftell(metadata_fp);
 125                 if (filesize < 0) {
 126                         BT_LOGE_ERRNO("Failed to get the current position in the metadata file",
 127                                 ": path=\"%s\"", path);
 128                         goto error;
 129                 }
 130                 rewind(metadata_fp);
 131                 metadata_text = malloc(filesize + 1);
 132                 if (!metadata_text) {
 133                         BT_LOGE_STR("Cannot allocate buffer for metadata text.");
 134                         goto error;
 135                 }
 136
 137                 if (fread(metadata_text, filesize, 1, metadata_fp) != 1) {
 138                         BT_LOGE_ERRNO("Cannot read metadata file", ": path=\"%s\"",
 139                                 path);
 140                         goto error;
 141                 }
 142
 143                 metadata_text[filesize] = '\0';
 144         }
 145
 146         g_metadata_text = g_string_new(NULL);
 147         if (!g_metadata_text) {
 148                 goto error;
 149         }
 150
 151         if (strncmp(metadata_text, METADATA_TEXT_SIG,
 152                         sizeof(METADATA_TEXT_SIG) - 1) != 0) {
 153                 g_string_assign(g_metadata_text, METADATA_TEXT_SIG);
 154                 g_string_append(g_metadata_text, " */\n\n");
 155         }
 156
 157         g_string_append(g_metadata_text, metadata_text);
 158
 159         ret = bt_value_map_insert_string_entry(result, "text",
 160                 g_metadata_text->str);
 161         if (ret) {
 162                 BT_LOGE_STR("Cannot insert metadata text into query result.");
 163                 goto error;
 164         }
 165
 166         ret = bt_value_map_insert_bool_entry(result, "is-packetized",
 167                 is_packetized);
 168         if (ret) {
 169                 BT_LOGE_STR("Cannot insert \"is-packetized\" attribute into query result.");
 170                 goto error;
 171         }
 172
 173         goto end;
 174
 175 error:
 176         BT_VALUE_PUT_REF_AND_RESET(result);
 177         result = NULL;
 178
 179         if (status >= 0) {
 180                 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
 181         }
 182
 183 end:
 184         free(metadata_text);
 185
 186         if (g_metadata_text) {
 187                 g_string_free(g_metadata_text, TRUE);
 188         }
 189
 190         if (metadata_fp) {
 191                 fclose(metadata_fp);
 192         }
 193
 194         *user_result = result;
 195         return status;
 196 }
 197
 198 static
 199 int add_range(bt_value *info, struct range *range,
 200                 const char *range_name)
 201 {
 202         int ret = 0;
 203         bt_value_map_insert_entry_status status;
 204         bt_value *range_map = NULL;
 205
 206         if (!range->set) {
 207                 /* Not an error. */
 208                 goto end;
 209         }
 210
 211         range_map = bt_value_map_create();
 212         if (!range_map) {
 213                 ret = -1;
 214                 goto end;
 215         }
 216
 217         status = bt_value_map_insert_signed_integer_entry(range_map, "begin",
 218                         range->begin_ns);
 219         if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
 220                 ret = -1;
 221                 goto end;
 222         }
 223
 224         status = bt_value_map_insert_signed_integer_entry(range_map, "end",
 225                         range->end_ns);
 226         if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
 227                 ret = -1;
 228                 goto end;
 229         }
 230
 231         status = bt_value_map_insert_entry(info, range_name,
 232                 range_map);
 233         if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
 234                 ret = -1;
 235                 goto end;
 236         }
 237
 238 end:
 239         bt_value_put_ref(range_map);
 240         return ret;
 241 }
 242
 243 static
 244 int add_stream_ids(bt_value *info, struct ctf_fs_ds_file_group *ds_file_group)
 245 {
 246         int ret = 0;
 247         bt_value_map_insert_entry_status status;
 248
 249         if (ds_file_group->stream_id != UINT64_C(-1)) {
 250                 status = bt_value_map_insert_unsigned_integer_entry(info, "id",
 251                         ds_file_group->stream_id);
 252                 if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
 253                         ret = -1;
 254                         goto end;
 255                 }
 256         }
 257
 258         status = bt_value_map_insert_unsigned_integer_entry(info, "class-id",
 259                 ds_file_group->sc->id);
 260         if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
 261                 ret = -1;
 262                 goto end;
 263         }
 264
 265 end:
 266         return ret;
 267 }
 268
 269 static
 270 int populate_stream_info(struct ctf_fs_ds_file_group *group,
 271                 bt_value *group_info, struct range *stream_range)
 272 {
 273         int ret = 0;
 274         size_t file_idx;
 275         bt_value_map_insert_entry_status insert_status;
 276         bt_value_array_append_element_status append_status;
 277         bt_value *file_paths;
 278         struct ctf_fs_ds_index_entry *first_ds_index_entry, *last_ds_index_entry;
 279         gchar *port_name = NULL;
 280
 281         file_paths = bt_value_array_create();
 282         if (!file_paths) {
 283                 ret = -1;
 284                 goto end;
 285         }
 286
 287         for (file_idx = 0; file_idx < group->ds_file_infos->len; file_idx++) {
 288                 struct ctf_fs_ds_file_info *info =
 289                         g_ptr_array_index(group->ds_file_infos,
 290                                 file_idx);
 291
 292                 append_status = bt_value_array_append_string_element(file_paths,
 293                                 info->path->str);
 294                 if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
 295                         ret = -1;
 296                         goto end;
 297                 }
 298         }
 299
 300         /*
 301          * Since each `struct ctf_fs_ds_file_group` has a sorted array of
 302          * `struct ctf_fs_ds_index_entry`, we can compute the stream range from
 303          * the timestamp_begin of the first index entry and the timestamp_end
 304          * of the last index entry.
 305          */
 306         BT_ASSERT(group->index);
 307         BT_ASSERT(group->index->entries);
 308         BT_ASSERT(group->index->entries->len > 0);
 309
 310         /* First entry. */
 311         first_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
 312                 group->index->entries, 0);
 313
 314         /* Last entry. */
 315         last_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
 316                 group->index->entries, group->index->entries->len - 1);
 317
 318         stream_range->begin_ns = first_ds_index_entry->timestamp_begin_ns;
 319         stream_range->end_ns = last_ds_index_entry->timestamp_end_ns;
 320
 321         /*
 322          * If any of the begin and end timestamps is not set it means that
 323          * packets don't include `timestamp_begin` _and_ `timestamp_end` fields
 324          * in their packet context so we can't set the range.
 325          */
 326         stream_range->set = stream_range->begin_ns != UINT64_C(-1) &&
 327                 stream_range->end_ns != UINT64_C(-1);
 328
 329         ret = add_range(group_info, stream_range, "range-ns");
 330         if (ret) {
 331                 goto end;
 332         }
 333
 334         insert_status = bt_value_map_insert_entry(group_info, "paths",
 335                 file_paths);
 336         if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
 337                 ret = -1;
 338                 goto end;
 339         }
 340
 341         ret = add_stream_ids(group_info, group);
 342         if (ret) {
 343                 goto end;
 344         }
 345
 346         port_name = ctf_fs_make_port_name(group);
 347         if (!port_name) {
 348                 ret = -1;
 349                 goto end;
 350         }
 351
 352         insert_status = bt_value_map_insert_string_entry(group_info,
 353                 "port-name", port_name);
 354         if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
 355                 ret = -1;
 356                 goto end;
 357         }
 358
 359 end:
 360         g_free(port_name);
 361         bt_value_put_ref(file_paths);
 362         return ret;
 363 }
 364
 365 static
 366 int populate_trace_info(const struct ctf_fs_trace *trace, bt_value *trace_info)
 367 {
 368         int ret = 0;
 369         size_t group_idx;
 370         bt_value_map_insert_entry_status insert_status;
 371         bt_value_array_append_element_status append_status;
 372         bt_value *file_groups = NULL;
 373         struct range trace_range = {
 374                 .begin_ns = INT64_MAX,
 375                 .end_ns = 0,
 376                 .set = false,
 377         };
 378         struct range trace_intersection = {
 379                 .begin_ns = 0,
 380                 .end_ns = INT64_MAX,
 381                 .set = false,
 382         };
 383
 384         BT_ASSERT(trace->ds_file_groups);
 385         /* Add trace range info only if it contains streams. */
 386         if (trace->ds_file_groups->len == 0) {
 387                 ret = -1;
 388                 goto end;
 389         }
 390
 391         file_groups = bt_value_array_create();
 392         if (!file_groups) {
 393                 goto end;
 394         }
 395
 396         insert_status = bt_value_map_insert_string_entry(trace_info, "name",
 397                 trace->name->str);
 398         if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
 399                 ret = -1;
 400                 goto end;
 401         }
 402         insert_status = bt_value_map_insert_string_entry(trace_info, "path",
 403                 trace->path->str);
 404         if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
 405                 ret = -1;
 406                 goto end;
 407         }
 408
 409         /* Find range of all stream groups, and of the trace. */
 410         for (group_idx = 0; group_idx < trace->ds_file_groups->len;
 411                         group_idx++) {
 412                 bt_value *group_info;
 413                 struct range group_range = { .set = false };
 414                 struct ctf_fs_ds_file_group *group = g_ptr_array_index(
 415                                 trace->ds_file_groups, group_idx);
 416
 417                 group_info = bt_value_map_create();
 418                 if (!group_info) {
 419                         ret = -1;
 420                         goto end;
 421                 }
 422
 423                 ret = populate_stream_info(group, group_info, &group_range);
 424                 if (ret) {
 425                         bt_value_put_ref(group_info);
 426                         goto end;
 427                 }
 428
 429                 append_status = bt_value_array_append_element(file_groups,
 430                         group_info);
 431                 bt_value_put_ref(group_info);
 432                 if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
 433                         goto end;
 434                 }
 435
 436                 if (group_range.set) {
 437                         trace_range.begin_ns = MIN(trace_range.begin_ns,
 438                                         group_range.begin_ns);
 439                         trace_range.end_ns = MAX(trace_range.end_ns,
 440                                         group_range.end_ns);
 441                         trace_range.set = true;
 442
 443                         trace_intersection.begin_ns = MAX(trace_intersection.begin_ns,
 444                                         group_range.begin_ns);
 445                         trace_intersection.end_ns = MIN(trace_intersection.end_ns,
 446                                         group_range.end_ns);
 447                         trace_intersection.set = true;
 448                 }
 449         }
 450
 451         ret = add_range(trace_info, &trace_range, "range-ns");
 452         if (ret) {
 453                 goto end;
 454         }
 455
 456         if (trace_intersection.begin_ns < trace_intersection.end_ns) {
 457                 ret = add_range(trace_info, &trace_intersection,
 458                                 "intersection-range-ns");
 459                 if (ret) {
 460                         goto end;
 461                 }
 462         }
 463
 464         insert_status = bt_value_map_insert_entry(trace_info, "streams",
 465                 file_groups);
 466         BT_VALUE_PUT_REF_AND_RESET(file_groups);
 467         if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
 468                 ret = -1;
 469                 goto end;
 470         }
 471
 472 end:
 473         bt_value_put_ref(file_groups);
 474         return ret;
 475 }
 476
 477 BT_HIDDEN
 478 bt_component_class_query_method_status trace_info_query(
 479                 bt_self_component_class_source *comp_class,
 480                 const bt_value *params, bt_logging_level log_level,
 481                 const bt_value **user_result)
 482 {
 483         struct ctf_fs_component *ctf_fs = NULL;
 484         bt_component_class_query_method_status status =
 485                 BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
 486         bt_value *result = NULL;
 487         const bt_value *inputs_value = NULL;
 488         int ret = 0;
 489         guint i;
 490
 491         BT_ASSERT(params);
 492
 493         if (!bt_value_is_map(params)) {
 494                 BT_LOGE("Query parameters is not a map value object.");
 495                 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_INVALID_PARAMS;
 496                 goto error;
 497         }
 498
 499         ctf_fs = ctf_fs_component_create(log_level, NULL);
 500         if (!ctf_fs) {
 501                 goto error;
 502         }
 503
 504         if (!read_src_fs_parameters(params, &inputs_value, ctf_fs)) {
 505                 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_INVALID_PARAMS;
 506                 goto error;
 507         }
 508
 509         if (ctf_fs_component_create_ctf_fs_traces(NULL, ctf_fs, inputs_value)) {
 510                 goto error;
 511         }
 512
 513         result = bt_value_array_create();
 514         if (!result) {
 515                 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
 516                 goto error;
 517         }
 518
 519         for (i = 0; i < ctf_fs->traces->len; i++) {
 520                 struct ctf_fs_trace *trace;
 521                 bt_value *trace_info;
 522                 bt_value_array_append_element_status append_status;
 523
 524                 trace = g_ptr_array_index(ctf_fs->traces, i);
 525                 BT_ASSERT(trace);
 526
 527                 trace_info = bt_value_map_create();
 528                 if (!trace_info) {
 529                         BT_LOGE("Failed to create trace info map.");
 530                         goto error;
 531                 }
 532
 533                 ret = populate_trace_info(trace, trace_info);
 534                 if (ret) {
 535                         bt_value_put_ref(trace_info);
 536                         goto error;
 537                 }
 538
 539                 append_status = bt_value_array_append_element(result,
 540                         trace_info);
 541                 bt_value_put_ref(trace_info);
 542                 if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
 543                         goto error;
 544                 }
 545         }
 546
 547         goto end;
 548
 549 error:
 550         BT_VALUE_PUT_REF_AND_RESET(result);
 551         result = NULL;
 552
 553         if (status >= 0) {
 554                 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
 555         }
 556
 557 end:
 558         if (ctf_fs) {
 559                 ctf_fs_destroy(ctf_fs);
 560                 ctf_fs = NULL;
 561         }
 562
 563         *user_result = result;
 564         return status;
 565 }
 566
 567 BT_HIDDEN
 568 bt_component_class_query_method_status support_info_query(
 569                 bt_self_component_class_source *comp_class,
 570                 const bt_value *params, bt_logging_level log_level,
 571                 const bt_value **user_result)
 572 {
 573         const bt_value *input_type_value;
 574         const char *input_type;
 575         bt_component_class_query_method_status status;
 576         double weight = 0;
 577         gchar *metadata_path = NULL;
 578         bt_value *result = NULL;
 579
 580         input_type_value = bt_value_map_borrow_entry_value_const(params, "type");
 581         BT_ASSERT(input_type_value);
 582         BT_ASSERT(bt_value_get_type(input_type_value) == BT_VALUE_TYPE_STRING);
 583         input_type = bt_value_string_get(input_type_value);
 584
 585         result = bt_value_map_create();
 586         if (!result) {
 587                 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
 588                 goto end;
 589         }
 590
 591         if (strcmp(input_type, "directory") == 0) {
 592                 const bt_value *input_value;
 593                 const char *path;
 594
 595                 input_value = bt_value_map_borrow_entry_value_const(params, "input");
 596                 BT_ASSERT(input_value);
 597                 BT_ASSERT(bt_value_get_type(input_value) == BT_VALUE_TYPE_STRING);
 598                 path = bt_value_string_get(input_value);
 599
 600                 metadata_path = g_build_filename(path, CTF_FS_METADATA_FILENAME, NULL);
 601                 if (!metadata_path) {
 602                         status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
 603                         goto end;
 604                 }
 605
 606                 /*
 607                  * If the metadata file exists in this directory, consider it to
 608                  * be a CTF trace.
 609                  */
 610                 if (g_file_test(metadata_path, G_FILE_TEST_EXISTS)) {
 611                         weight = 0.5;
 612                 }
 613         }
 614
 615         if (bt_value_map_insert_real_entry(result, "weight", weight) != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
 616                 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
 617                 goto end;
 618         }
 619
 620         /*
 621          * Use the arbitrary constant string "ctf" as the group, such that all
 622          * found ctf traces are passed to the same instance of src.ctf.fs.
 623          */
 624         if (bt_value_map_insert_string_entry(result, "group", "ctf") != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
 625                 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
 626                 goto end;
 627         }
 628
 629         *user_result = result;
 630         result = NULL;
 631         status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
 632
 633 end:
 634         g_free(metadata_path);
 635         bt_value_put_ref(result);
 636
 637         return status;
 638 }