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