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 struct bt_component_class_query_method_return metadata_info_query(
  50                 struct bt_component_class *comp_class,
  51                 struct bt_value *params)
  52 {
  53         struct bt_component_class_query_method_return query_ret = {
  54                 .result = NULL,
  55                 .status = BT_QUERY_STATUS_OK,
  56         };
  57
  58         struct bt_private_value *result = NULL;
  59         struct bt_value *path_value = NULL;
  60         char *metadata_text = NULL;
  61         FILE *metadata_fp = NULL;
  62         GString *g_metadata_text = NULL;
  63         int ret;
  64         int bo;
  65         const char *path;
  66         bool is_packetized;
  67
  68         result = bt_private_value_map_create();
  69         if (!result) {
  70                 query_ret.status = BT_QUERY_STATUS_NOMEM;
  71                 goto error;
  72         }
  73
  74         query_ret.result = bt_value_borrow_from_private(result);
  75         BT_ASSERT(params);
  76
  77         if (!bt_value_is_map(params)) {
  78                 BT_LOGE_STR("Query parameters is not a map value object.");
  79                 query_ret.status = BT_QUERY_STATUS_INVALID_PARAMS;
  80                 goto error;
  81         }
  82
  83         path_value = bt_value_map_borrow_entry_value(params, "path");
  84         path = bt_value_string_get(path_value);
  85
  86         BT_ASSERT(path);
  87         metadata_fp = ctf_fs_metadata_open_file(path);
  88         if (!metadata_fp) {
  89                 BT_LOGE("Cannot open trace metadata: path=\"%s\".", path);
  90                 goto error;
  91         }
  92
  93         is_packetized = ctf_metadata_decoder_is_packetized(metadata_fp,
  94                 &bo);
  95
  96         if (is_packetized) {
  97                 ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
  98                         metadata_fp, &metadata_text, bo);
  99                 if (ret) {
 100                         BT_LOGE("Cannot decode packetized metadata file: path=\"%s\"",
 101                                 path);
 102                         goto error;
 103                 }
 104         } else {
 105                 long filesize;
 106
 107                 ret = fseek(metadata_fp, 0, SEEK_END);
 108                 if (ret) {
 109                         BT_LOGE_ERRNO("Failed to seek to the end of the metadata file",
 110                                 ": path=\"%s\"", path);
 111                         goto error;
 112                 }
 113                 filesize = ftell(metadata_fp);
 114                 if (filesize < 0) {
 115                         BT_LOGE_ERRNO("Failed to get the current position in the metadata file",
 116                                 ": path=\"%s\"", path);
 117                         goto error;
 118                 }
 119                 rewind(metadata_fp);
 120                 metadata_text = malloc(filesize + 1);
 121                 if (!metadata_text) {
 122                         BT_LOGE_STR("Cannot allocate buffer for metadata text.");
 123                         goto error;
 124                 }
 125
 126                 if (fread(metadata_text, filesize, 1, metadata_fp) != 1) {
 127                         BT_LOGE_ERRNO("Cannot read metadata file", ": path=\"%s\"",
 128                                 path);
 129                         goto error;
 130                 }
 131
 132                 metadata_text[filesize] = '\0';
 133         }
 134
 135         g_metadata_text = g_string_new(NULL);
 136         if (!g_metadata_text) {
 137                 goto error;
 138         }
 139
 140         if (strncmp(metadata_text, METADATA_TEXT_SIG,
 141                         sizeof(METADATA_TEXT_SIG) - 1) != 0) {
 142                 g_string_assign(g_metadata_text, METADATA_TEXT_SIG);
 143                 g_string_append(g_metadata_text, " */\n\n");
 144         }
 145
 146         g_string_append(g_metadata_text, metadata_text);
 147
 148         ret = bt_private_value_map_insert_string_entry(result, "text",
 149                 g_metadata_text->str);
 150         if (ret) {
 151                 BT_LOGE_STR("Cannot insert metadata text into query result.");
 152                 goto error;
 153         }
 154
 155         ret = bt_private_value_map_insert_bool_entry(result, "is-packetized",
 156                 is_packetized);
 157         if (ret) {
 158                 BT_LOGE_STR("Cannot insert \"is-packetized\" attribute into query result.");
 159                 goto error;
 160         }
 161
 162         goto end;
 163
 164 error:
 165         BT_OBJECT_PUT_REF_AND_RESET(result);
 166         query_ret.result = NULL;
 167
 168         if (query_ret.status >= 0) {
 169                 query_ret.status = BT_QUERY_STATUS_ERROR;
 170         }
 171
 172 end:
 173         free(metadata_text);
 174
 175         if (g_metadata_text) {
 176                 g_string_free(g_metadata_text, TRUE);
 177         }
 178
 179         if (metadata_fp) {
 180                 fclose(metadata_fp);
 181         }
 182
 183         return query_ret;
 184 }
 185
 186 static
 187 int add_range(struct bt_private_value *info, struct range *range,
 188                 const char *range_name)
 189 {
 190         int ret = 0;
 191         enum bt_value_status status;
 192         struct bt_private_value *range_map = NULL;
 193
 194         if (!range->set) {
 195                 /* Not an error. */
 196                 goto end;
 197         }
 198
 199         range_map = bt_private_value_map_create();
 200         if (!range_map) {
 201                 ret = -1;
 202                 goto end;
 203         }
 204
 205         status = bt_private_value_map_insert_integer_entry(range_map, "begin",
 206                         range->begin_ns);
 207         if (status != BT_VALUE_STATUS_OK) {
 208                 ret = -1;
 209                 goto end;
 210         }
 211
 212         status = bt_private_value_map_insert_integer_entry(range_map, "end",
 213                         range->end_ns);
 214         if (status != BT_VALUE_STATUS_OK) {
 215                 ret = -1;
 216                 goto end;
 217         }
 218
 219         status = bt_private_value_map_insert_entry(info, range_name,
 220                 bt_value_borrow_from_private(range_map));
 221         if (status != BT_VALUE_STATUS_OK) {
 222                 ret = -1;
 223                 goto end;
 224         }
 225
 226 end:
 227         bt_object_put_ref(range_map);
 228         return ret;
 229 }
 230
 231 static
 232 int add_stream_ids(struct bt_private_value *info,
 233                 struct bt_stream *stream)
 234 {
 235         int ret = 0;
 236         int64_t stream_class_id, stream_instance_id;
 237         enum bt_value_status status;
 238         struct bt_stream_class *stream_class = NULL;
 239
 240         stream_instance_id = bt_stream_get_id(stream);
 241         if (stream_instance_id != -1) {
 242                 status = bt_private_value_map_insert_integer_entry(info, "id",
 243                                 stream_instance_id);
 244                 if (status != BT_VALUE_STATUS_OK) {
 245                         ret = -1;
 246                         goto end;
 247                 }
 248         }
 249
 250         stream_class = bt_stream_borrow_class(stream);
 251         if (!stream_class) {
 252                 ret = -1;
 253                 goto end;
 254         }
 255
 256         stream_class_id = bt_stream_class_get_id(stream_class);
 257         if (stream_class_id == -1) {
 258                 ret = -1;
 259                 goto end;
 260         }
 261
 262         status = bt_private_value_map_insert_integer_entry(info, "class-id", stream_class_id);
 263         if (status != BT_VALUE_STATUS_OK) {
 264                 ret = -1;
 265                 goto end;
 266         }
 267
 268 end:
 269         return ret;
 270 }
 271
 272 static
 273 int populate_stream_info(struct ctf_fs_ds_file_group *group,
 274                 struct bt_private_value *group_info,
 275                 struct range *stream_range)
 276 {
 277         int ret = 0;
 278         size_t file_idx;
 279         enum bt_value_status status;
 280         struct bt_private_value *file_paths;
 281
 282         stream_range->begin_ns = INT64_MAX;
 283         stream_range->end_ns = 0;
 284
 285         file_paths = bt_private_value_array_create();
 286         if (!file_paths) {
 287                 ret = -1;
 288                 goto end;
 289         }
 290
 291         for (file_idx = 0; file_idx < group->ds_file_infos->len; file_idx++) {
 292                 int64_t file_begin_epoch, file_end_epoch;
 293                 struct ctf_fs_ds_file_info *info =
 294                                 g_ptr_array_index(group->ds_file_infos,
 295                                         file_idx);
 296
 297                 if (!info->index || info->index->entries->len == 0) {
 298                         BT_LOGW("Cannot determine range of unindexed stream file \'%s\'",
 299                                 info->path->str);
 300                         ret = -1;
 301                         goto end;
 302                 }
 303
 304                 status = bt_private_value_array_append_string_element(file_paths,
 305                                 info->path->str);
 306                 if (status != BT_VALUE_STATUS_OK) {
 307                         ret = -1;
 308                         goto end;
 309                 }
 310
 311                 /*
 312                  * file range is from timestamp_begin of the first entry to the
 313                  * timestamp_end of the last entry.
 314                  */
 315                 file_begin_epoch = ((struct ctf_fs_ds_index_entry *) &g_array_index(info->index->entries,
 316                                 struct ctf_fs_ds_index_entry, 0))->timestamp_begin_ns;
 317                 file_end_epoch = ((struct ctf_fs_ds_index_entry *) &g_array_index(info->index->entries,
 318                                 struct ctf_fs_ds_index_entry, info->index->entries->len - 1))->timestamp_end_ns;
 319
 320                 stream_range->begin_ns = min(stream_range->begin_ns, file_begin_epoch);
 321                 stream_range->end_ns = max(stream_range->end_ns, file_end_epoch);
 322                 stream_range->set = true;
 323         }
 324
 325         if (stream_range->set) {
 326                 ret = add_range(group_info, stream_range, "range-ns");
 327                 if (ret) {
 328                         goto end;
 329                 }
 330         }
 331
 332         status = bt_private_value_map_insert_entry(group_info, "paths",
 333                 bt_value_borrow_from_private(file_paths));
 334         if (status != BT_VALUE_STATUS_OK) {
 335                 ret = -1;
 336                 goto end;
 337         }
 338
 339         ret = add_stream_ids(group_info,
 340                 bt_stream_borrow_from_private(group->stream));
 341         if (ret) {
 342                 goto end;
 343         }
 344 end:
 345         bt_object_put_ref(file_paths);
 346         return ret;
 347 }
 348
 349 static
 350 int populate_trace_info(const char *trace_path, const char *trace_name,
 351                 struct bt_private_value *trace_info)
 352 {
 353         int ret = 0;
 354         size_t group_idx;
 355         struct ctf_fs_trace *trace = NULL;
 356         enum bt_value_status status;
 357         struct bt_private_value *file_groups;
 358         struct range trace_range = {
 359                 .begin_ns = INT64_MAX,
 360                 .end_ns = 0,
 361                 .set = false,
 362         };
 363         struct range trace_intersection = {
 364                 .begin_ns = 0,
 365                 .end_ns = INT64_MAX,
 366                 .set = false,
 367         };
 368
 369         file_groups = bt_private_value_array_create();
 370         if (!file_groups) {
 371                 goto end;
 372         }
 373
 374         status = bt_private_value_map_insert_string_entry(trace_info, "name",
 375                 trace_name);
 376         if (status != BT_VALUE_STATUS_OK) {
 377                 ret = -1;
 378                 goto end;
 379         }
 380         status = bt_private_value_map_insert_string_entry(trace_info, "path",
 381                         trace_path);
 382         if (status != BT_VALUE_STATUS_OK) {
 383                 ret = -1;
 384                 goto end;
 385         }
 386
 387         trace = ctf_fs_trace_create(trace_path, trace_name, NULL);
 388         if (!trace) {
 389                 BT_LOGE("Failed to create fs trace at \'%s\'", trace_path);
 390                 ret = -1;
 391                 goto end;
 392         }
 393
 394         BT_ASSERT(trace->ds_file_groups);
 395         /* Add trace range info only if it contains streams. */
 396         if (trace->ds_file_groups->len == 0) {
 397                 ret = -1;
 398                 goto end;
 399         }
 400
 401         /* Find range of all stream groups, and of the trace. */
 402         for (group_idx = 0; group_idx < trace->ds_file_groups->len;
 403                         group_idx++) {
 404                 struct bt_private_value *group_info;
 405                 struct range group_range = { .set = false };
 406                 struct ctf_fs_ds_file_group *group = g_ptr_array_index(
 407                                 trace->ds_file_groups, group_idx);
 408
 409                 group_info = bt_private_value_map_create();
 410                 if (!group_info) {
 411                         ret = -1;
 412                         goto end;
 413                 }
 414
 415                 ret = populate_stream_info(group, group_info, &group_range);
 416                 if (ret) {
 417                         bt_object_put_ref(group_info);
 418                         goto end;
 419                 }
 420
 421                 if (group_range.set) {
 422                         trace_range.begin_ns = min(trace_range.begin_ns,
 423                                         group_range.begin_ns);
 424                         trace_range.end_ns = max(trace_range.end_ns,
 425                                         group_range.end_ns);
 426                         trace_range.set = true;
 427
 428                         trace_intersection.begin_ns = max(trace_intersection.begin_ns,
 429                                         group_range.begin_ns);
 430                         trace_intersection.end_ns = min(trace_intersection.end_ns,
 431                                         group_range.end_ns);
 432                         trace_intersection.set = true;
 433                         status = bt_private_value_array_append_element(
 434                                 file_groups,
 435                                 bt_value_borrow_from_private(group_info));
 436                         bt_object_put_ref(group_info);
 437                         if (status != BT_VALUE_STATUS_OK) {
 438                                 goto end;
 439                         }
 440                 }
 441         }
 442
 443         ret = add_range(trace_info, &trace_range, "range-ns");
 444         if (ret) {
 445                 goto end;
 446         }
 447
 448         if (trace_intersection.begin_ns < trace_intersection.end_ns) {
 449                 ret = add_range(trace_info, &trace_intersection,
 450                                 "intersection-range-ns");
 451                 if (ret) {
 452                         goto end;
 453                 }
 454         }
 455
 456         status = bt_private_value_map_insert_entry(trace_info, "streams",
 457                 bt_value_borrow_from_private(file_groups));
 458         BT_OBJECT_PUT_REF_AND_RESET(file_groups);
 459         if (status != BT_VALUE_STATUS_OK) {
 460                 ret = -1;
 461                 goto end;
 462         }
 463
 464 end:
 465         bt_object_put_ref(file_groups);
 466         ctf_fs_trace_destroy(trace);
 467         return ret;
 468 }
 469
 470 BT_HIDDEN
 471 struct bt_component_class_query_method_return trace_info_query(
 472                 struct bt_component_class *comp_class,
 473                 struct bt_value *params)
 474 {
 475         struct bt_component_class_query_method_return query_ret = {
 476                 .result = NULL,
 477                 .status = BT_QUERY_STATUS_OK,
 478         };
 479
 480         struct bt_private_value *result = NULL;
 481         struct bt_value *path_value = NULL;
 482         int ret = 0;
 483         const char *path = NULL;
 484         GList *trace_paths = NULL;
 485         GList *trace_names = NULL;
 486         GList *tp_node = NULL;
 487         GList *tn_node = NULL;
 488         GString *normalized_path = NULL;
 489
 490         BT_ASSERT(params);
 491
 492         if (!bt_value_is_map(params)) {
 493                 BT_LOGE("Query parameters is not a map value object.");
 494                 query_ret.status = BT_QUERY_STATUS_INVALID_PARAMS;
 495                 goto error;
 496         }
 497
 498         path_value = bt_value_map_borrow_entry_value(params, "path");
 499         path = bt_value_string_get(path_value);
 500
 501         normalized_path = bt_common_normalize_path(path, NULL);
 502         if (!normalized_path) {
 503                 BT_LOGE("Failed to normalize path: `%s`.", path);
 504                 goto error;
 505         }
 506         BT_ASSERT(path);
 507
 508         ret = ctf_fs_find_traces(&trace_paths, normalized_path->str);
 509         if (ret) {
 510                 goto error;
 511         }
 512
 513         trace_names = ctf_fs_create_trace_names(trace_paths,
 514                 normalized_path->str);
 515         if (!trace_names) {
 516                 BT_LOGE("Cannot create trace names from trace paths.");
 517                 goto error;
 518         }
 519
 520         result = bt_private_value_array_create();
 521         if (!result) {
 522                 query_ret.status = BT_QUERY_STATUS_NOMEM;
 523                 goto error;
 524         }
 525
 526         query_ret.result = bt_value_borrow_from_private(result);
 527
 528         /* Iterates over both trace paths and names simultaneously. */
 529         for (tp_node = trace_paths, tn_node = trace_names; tp_node;
 530                         tp_node = g_list_next(tp_node),
 531                         tn_node = g_list_next(tn_node)) {
 532                 GString *trace_path = tp_node->data;
 533                 GString *trace_name = tn_node->data;
 534                 enum bt_value_status status;
 535                 struct bt_private_value *trace_info;
 536
 537                 trace_info = bt_private_value_map_create();
 538                 if (!trace_info) {
 539                         BT_LOGE("Failed to create trace info map.");
 540                         goto error;
 541                 }
 542
 543                 ret = populate_trace_info(trace_path->str, trace_name->str,
 544                         trace_info);
 545                 if (ret) {
 546                         bt_object_put_ref(trace_info);
 547                         goto error;
 548                 }
 549
 550                 status = bt_private_value_array_append_element(result,
 551                         bt_value_borrow_from_private(trace_info));
 552                 bt_object_put_ref(trace_info);
 553                 if (status != BT_VALUE_STATUS_OK) {
 554                         goto error;
 555                 }
 556         }
 557
 558         goto end;
 559
 560 error:
 561         BT_OBJECT_PUT_REF_AND_RESET(result);
 562         query_ret.result = NULL;
 563
 564         if (query_ret.status >= 0) {
 565                 query_ret.status = BT_QUERY_STATUS_ERROR;
 566         }
 567
 568 end:
 569         if (normalized_path) {
 570                 g_string_free(normalized_path, TRUE);
 571         }
 572         if (trace_paths) {
 573                 for (tp_node = trace_paths; tp_node; tp_node = g_list_next(tp_node)) {
 574                         if (tp_node->data) {
 575                                 g_string_free(tp_node->data, TRUE);
 576                         }
 577                 }
 578                 g_list_free(trace_paths);
 579         }
 580         if (trace_names) {
 581                 for (tn_node = trace_names; tn_node; tn_node = g_list_next(tn_node)) {
 582                         if (tn_node->data) {
 583                                 g_string_free(tn_node->data, TRUE);
 584                         }
 585                 }
 586                 g_list_free(trace_names);
 587         }
 588         /* "path" becomes invalid with the release of path_value. */
 589         return query_ret;
 590 }