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_query_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_query_status status = BT_QUERY_STATUS_OK;
  56         bt_value *result = NULL;
  57         const bt_value *path_value = NULL;
  58         char *metadata_text = NULL;
  59         FILE *metadata_fp = NULL;
  60         GString *g_metadata_text = NULL;
  61         int ret;
  62         int bo;
  63         const char *path;
  64         bool is_packetized;
  65
  66         result = bt_value_map_create();
  67         if (!result) {
  68                 status = BT_QUERY_STATUS_NOMEM;
  69                 goto error;
  70         }
  71
  72         BT_ASSERT(params);
  73
  74         if (!bt_value_is_map(params)) {
  75                 BT_LOGE_STR("Query parameters is not a map value object.");
  76                 status = BT_QUERY_STATUS_INVALID_PARAMS;
  77                 goto error;
  78         }
  79
  80         path_value = bt_value_map_borrow_entry_value_const(params, "path");
  81         if (!path_value) {
  82                 BT_LOGE_STR("Mandatory `path` parameter missing");
  83                 status = BT_QUERY_STATUS_INVALID_PARAMS;
  84                 goto error;
  85         }
  86
  87         if (!bt_value_is_string(path_value)) {
  88                 BT_LOGE_STR("`path` parameter is required to be a string value");
  89                 status = BT_QUERY_STATUS_INVALID_PARAMS;
  90                 goto error;
  91         }
  92
  93         path = bt_value_string_get(path_value);
  94
  95         BT_ASSERT(path);
  96         metadata_fp = ctf_fs_metadata_open_file(path);
  97         if (!metadata_fp) {
  98                 BT_LOGE("Cannot open trace metadata: path=\"%s\".", path);
  99                 goto error;
 100         }
 101
 102         is_packetized = ctf_metadata_decoder_is_packetized(metadata_fp,
 103                 &bo, log_level, NULL);
 104
 105         if (is_packetized) {
 106                 ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
 107                         metadata_fp, &metadata_text, bo, NULL, NULL,
 108                         log_level, NULL);
 109                 if (ret) {
 110                         BT_LOGE("Cannot decode packetized metadata file: path=\"%s\"",
 111                                 path);
 112                         goto error;
 113                 }
 114         } else {
 115                 long filesize;
 116
 117                 ret = fseek(metadata_fp, 0, SEEK_END);
 118                 if (ret) {
 119                         BT_LOGE_ERRNO("Failed to seek to the end of the metadata file",
 120                                 ": path=\"%s\"", path);
 121                         goto error;
 122                 }
 123                 filesize = ftell(metadata_fp);
 124                 if (filesize < 0) {
 125                         BT_LOGE_ERRNO("Failed to get the current position in the metadata file",
 126                                 ": path=\"%s\"", path);
 127                         goto error;
 128                 }
 129                 rewind(metadata_fp);
 130                 metadata_text = malloc(filesize + 1);
 131                 if (!metadata_text) {
 132                         BT_LOGE_STR("Cannot allocate buffer for metadata text.");
 133                         goto error;
 134                 }
 135
 136                 if (fread(metadata_text, filesize, 1, metadata_fp) != 1) {
 137                         BT_LOGE_ERRNO("Cannot read metadata file", ": path=\"%s\"",
 138                                 path);
 139                         goto error;
 140                 }
 141
 142                 metadata_text[filesize] = '\0';
 143         }
 144
 145         g_metadata_text = g_string_new(NULL);
 146         if (!g_metadata_text) {
 147                 goto error;
 148         }
 149
 150         if (strncmp(metadata_text, METADATA_TEXT_SIG,
 151                         sizeof(METADATA_TEXT_SIG) - 1) != 0) {
 152                 g_string_assign(g_metadata_text, METADATA_TEXT_SIG);
 153                 g_string_append(g_metadata_text, " */\n\n");
 154         }
 155
 156         g_string_append(g_metadata_text, metadata_text);
 157
 158         ret = bt_value_map_insert_string_entry(result, "text",
 159                 g_metadata_text->str);
 160         if (ret) {
 161                 BT_LOGE_STR("Cannot insert metadata text into query result.");
 162                 goto error;
 163         }
 164
 165         ret = bt_value_map_insert_bool_entry(result, "is-packetized",
 166                 is_packetized);
 167         if (ret) {
 168                 BT_LOGE_STR("Cannot insert \"is-packetized\" attribute into query result.");
 169                 goto error;
 170         }
 171
 172         goto end;
 173
 174 error:
 175         BT_VALUE_PUT_REF_AND_RESET(result);
 176         result = NULL;
 177
 178         if (status >= 0) {
 179                 status = BT_QUERY_STATUS_ERROR;
 180         }
 181
 182 end:
 183         free(metadata_text);
 184
 185         if (g_metadata_text) {
 186                 g_string_free(g_metadata_text, TRUE);
 187         }
 188
 189         if (metadata_fp) {
 190                 fclose(metadata_fp);
 191         }
 192
 193         *user_result = result;
 194         return status;
 195 }
 196
 197 static
 198 int add_range(bt_value *info, struct range *range,
 199                 const char *range_name)
 200 {
 201         int ret = 0;
 202         bt_value_status status;
 203         bt_value *range_map = NULL;
 204
 205         if (!range->set) {
 206                 /* Not an error. */
 207                 goto end;
 208         }
 209
 210         range_map = bt_value_map_create();
 211         if (!range_map) {
 212                 ret = -1;
 213                 goto end;
 214         }
 215
 216         status = bt_value_map_insert_signed_integer_entry(range_map, "begin",
 217                         range->begin_ns);
 218         if (status != BT_VALUE_STATUS_OK) {
 219                 ret = -1;
 220                 goto end;
 221         }
 222
 223         status = bt_value_map_insert_signed_integer_entry(range_map, "end",
 224                         range->end_ns);
 225         if (status != BT_VALUE_STATUS_OK) {
 226                 ret = -1;
 227                 goto end;
 228         }
 229
 230         status = bt_value_map_insert_entry(info, range_name,
 231                 range_map);
 232         if (status != BT_VALUE_STATUS_OK) {
 233                 ret = -1;
 234                 goto end;
 235         }
 236
 237 end:
 238         bt_value_put_ref(range_map);
 239         return ret;
 240 }
 241
 242 static
 243 int add_stream_ids(bt_value *info, struct ctf_fs_ds_file_group *ds_file_group)
 244 {
 245         int ret = 0;
 246         bt_value_status status;
 247
 248         if (ds_file_group->stream_id != UINT64_C(-1)) {
 249                 status = bt_value_map_insert_unsigned_integer_entry(info, "id",
 250                         ds_file_group->stream_id);
 251                 if (status != BT_VALUE_STATUS_OK) {
 252                         ret = -1;
 253                         goto end;
 254                 }
 255         }
 256
 257         status = bt_value_map_insert_unsigned_integer_entry(info, "class-id",
 258                 ds_file_group->sc->id);
 259         if (status != BT_VALUE_STATUS_OK) {
 260                 ret = -1;
 261                 goto end;
 262         }
 263
 264 end:
 265         return ret;
 266 }
 267
 268 static
 269 int populate_stream_info(struct ctf_fs_ds_file_group *group,
 270                 bt_value *group_info, struct range *stream_range)
 271 {
 272         int ret = 0;
 273         size_t file_idx;
 274         bt_value_status status;
 275         bt_value *file_paths;
 276         struct ctf_fs_ds_index_entry *first_ds_index_entry, *last_ds_index_entry;
 277         gchar *port_name = NULL;
 278
 279         file_paths = bt_value_array_create();
 280         if (!file_paths) {
 281                 ret = -1;
 282                 goto end;
 283         }
 284
 285         for (file_idx = 0; file_idx < group->ds_file_infos->len; file_idx++) {
 286                 struct ctf_fs_ds_file_info *info =
 287                         g_ptr_array_index(group->ds_file_infos,
 288                                 file_idx);
 289
 290                 status = bt_value_array_append_string_element(file_paths,
 291                                 info->path->str);
 292                 if (status != BT_VALUE_STATUS_OK) {
 293                         ret = -1;
 294                         goto end;
 295                 }
 296         }
 297
 298         /*
 299          * Since each `struct ctf_fs_ds_file_group` has a sorted array of
 300          * `struct ctf_fs_ds_index_entry`, we can compute the stream range from
 301          * the timestamp_begin of the first index entry and the timestamp_end
 302          * of the last index entry.
 303          */
 304         BT_ASSERT(group->index);
 305         BT_ASSERT(group->index->entries);
 306         BT_ASSERT(group->index->entries->len > 0);
 307
 308         /* First entry. */
 309         first_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
 310                 group->index->entries, 0);
 311
 312         /* Last entry. */
 313         last_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
 314                 group->index->entries, group->index->entries->len - 1);
 315
 316         stream_range->begin_ns = first_ds_index_entry->timestamp_begin_ns;
 317         stream_range->end_ns = last_ds_index_entry->timestamp_end_ns;
 318
 319         /*
 320          * If any of the begin and end timestamps is not set it means that
 321          * packets don't include `timestamp_begin` _and_ `timestamp_end` fields
 322          * in their packet context so we can't set the range.
 323          */
 324         stream_range->set = stream_range->begin_ns != UINT64_C(-1) &&
 325                 stream_range->end_ns != UINT64_C(-1);
 326
 327         ret = add_range(group_info, stream_range, "range-ns");
 328         if (ret) {
 329                 goto end;
 330         }
 331
 332         status = bt_value_map_insert_entry(group_info, "paths",
 333                 file_paths);
 334         if (status != BT_VALUE_STATUS_OK) {
 335                 ret = -1;
 336                 goto end;
 337         }
 338
 339         ret = add_stream_ids(group_info, group);
 340         if (ret) {
 341                 goto end;
 342         }
 343
 344         port_name = ctf_fs_make_port_name(group);
 345         if (!port_name) {
 346                 ret = -1;
 347                 goto end;
 348         }
 349
 350         status = bt_value_map_insert_string_entry(group_info, "port-name",
 351                 port_name);
 352         if (status != BT_VALUE_STATUS_OK) {
 353                 ret = -1;
 354                 goto end;
 355         }
 356
 357 end:
 358         bt_value_put_ref(file_paths);
 359         return ret;
 360 }
 361
 362 static
 363 int populate_trace_info(const struct ctf_fs_trace *trace, bt_value *trace_info)
 364 {
 365         int ret = 0;
 366         size_t group_idx;
 367         bt_value_status status;
 368         bt_value *file_groups = NULL;
 369         struct range trace_range = {
 370                 .begin_ns = INT64_MAX,
 371                 .end_ns = 0,
 372                 .set = false,
 373         };
 374         struct range trace_intersection = {
 375                 .begin_ns = 0,
 376                 .end_ns = INT64_MAX,
 377                 .set = false,
 378         };
 379
 380         BT_ASSERT(trace->ds_file_groups);
 381         /* Add trace range info only if it contains streams. */
 382         if (trace->ds_file_groups->len == 0) {
 383                 ret = -1;
 384                 goto end;
 385         }
 386
 387         file_groups = bt_value_array_create();
 388         if (!file_groups) {
 389                 goto end;
 390         }
 391
 392         status = bt_value_map_insert_string_entry(trace_info, "name",
 393                 trace->name->str);
 394         if (status != BT_VALUE_STATUS_OK) {
 395                 ret = -1;
 396                 goto end;
 397         }
 398         status = bt_value_map_insert_string_entry(trace_info, "path",
 399                 trace->path->str);
 400         if (status != BT_VALUE_STATUS_OK) {
 401                 ret = -1;
 402                 goto end;
 403         }
 404
 405         /* Find range of all stream groups, and of the trace. */
 406         for (group_idx = 0; group_idx < trace->ds_file_groups->len;
 407                         group_idx++) {
 408                 bt_value *group_info;
 409                 struct range group_range = { .set = false };
 410                 struct ctf_fs_ds_file_group *group = g_ptr_array_index(
 411                                 trace->ds_file_groups, group_idx);
 412
 413                 group_info = bt_value_map_create();
 414                 if (!group_info) {
 415                         ret = -1;
 416                         goto end;
 417                 }
 418
 419                 ret = populate_stream_info(group, group_info, &group_range);
 420                 if (ret) {
 421                         bt_value_put_ref(group_info);
 422                         goto end;
 423                 }
 424
 425                 status = bt_value_array_append_element(file_groups, group_info);
 426                 bt_value_put_ref(group_info);
 427                 if (status != BT_VALUE_STATUS_OK) {
 428                         goto end;
 429                 }
 430
 431                 if (group_range.set) {
 432                         trace_range.begin_ns = MIN(trace_range.begin_ns,
 433                                         group_range.begin_ns);
 434                         trace_range.end_ns = MAX(trace_range.end_ns,
 435                                         group_range.end_ns);
 436                         trace_range.set = true;
 437
 438                         trace_intersection.begin_ns = MAX(trace_intersection.begin_ns,
 439                                         group_range.begin_ns);
 440                         trace_intersection.end_ns = MIN(trace_intersection.end_ns,
 441                                         group_range.end_ns);
 442                         trace_intersection.set = true;
 443                 }
 444         }
 445
 446         ret = add_range(trace_info, &trace_range, "range-ns");
 447         if (ret) {
 448                 goto end;
 449         }
 450
 451         if (trace_intersection.begin_ns < trace_intersection.end_ns) {
 452                 ret = add_range(trace_info, &trace_intersection,
 453                                 "intersection-range-ns");
 454                 if (ret) {
 455                         goto end;
 456                 }
 457         }
 458
 459         status = bt_value_map_insert_entry(trace_info, "streams",
 460                 file_groups);
 461         BT_VALUE_PUT_REF_AND_RESET(file_groups);
 462         if (status != BT_VALUE_STATUS_OK) {
 463                 ret = -1;
 464                 goto end;
 465         }
 466
 467 end:
 468         bt_value_put_ref(file_groups);
 469         return ret;
 470 }
 471
 472 BT_HIDDEN
 473 bt_query_status trace_info_query(
 474                 bt_self_component_class_source *comp_class,
 475                 const bt_value *params, bt_logging_level log_level,
 476                 const bt_value **user_result)
 477 {
 478         struct ctf_fs_component *ctf_fs = NULL;
 479         bt_query_status status = BT_QUERY_STATUS_OK;
 480         bt_value *result = NULL;
 481         const bt_value *paths_value = NULL;
 482         int ret = 0;
 483         guint i;
 484
 485         BT_ASSERT(params);
 486
 487         if (!bt_value_is_map(params)) {
 488                 BT_LOGE("Query parameters is not a map value object.");
 489                 status = BT_QUERY_STATUS_INVALID_PARAMS;
 490                 goto error;
 491         }
 492
 493         ctf_fs = ctf_fs_component_create(log_level, NULL);
 494         if (!ctf_fs) {
 495                 goto error;
 496         }
 497
 498         if (!read_src_fs_parameters(params, &paths_value, ctf_fs)) {
 499                 status = BT_QUERY_STATUS_INVALID_PARAMS;
 500                 goto error;
 501         }
 502
 503         if (ctf_fs_component_create_ctf_fs_traces(NULL, ctf_fs, paths_value)) {
 504                 goto error;
 505         }
 506
 507         result = bt_value_array_create();
 508         if (!result) {
 509                 status = BT_QUERY_STATUS_NOMEM;
 510                 goto error;
 511         }
 512
 513         for (i = 0; i < ctf_fs->traces->len; i++) {
 514                 struct ctf_fs_trace *trace;
 515                 bt_value *trace_info;
 516                 bt_value_status status;
 517
 518                 trace = g_ptr_array_index(ctf_fs->traces, i);
 519                 BT_ASSERT(trace);
 520
 521                 trace_info = bt_value_map_create();
 522                 if (!trace_info) {
 523                         BT_LOGE("Failed to create trace info map.");
 524                         goto error;
 525                 }
 526
 527                 ret = populate_trace_info(trace, trace_info);
 528                 if (ret) {
 529                         bt_value_put_ref(trace_info);
 530                         goto error;
 531                 }
 532
 533                 status = bt_value_array_append_element(result, trace_info);
 534                 bt_value_put_ref(trace_info);
 535                 if (status != BT_VALUE_STATUS_OK) {
 536                         goto error;
 537                 }
 538         }
 539
 540         goto end;
 541
 542 error:
 543         BT_VALUE_PUT_REF_AND_RESET(result);
 544         result = NULL;
 545
 546         if (status >= 0) {
 547                 status = BT_QUERY_STATUS_ERROR;
 548         }
 549
 550 end:
 551         if (ctf_fs) {
 552                 ctf_fs_destroy(ctf_fs);
 553                 ctf_fs = NULL;
 554         }
 555
 556         *user_result = result;
 557         return status;
 558 }