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