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