ctf: remove `intersection-range-ns` from `babeltrace.trace-info` query
[babeltrace.git] / src / plugins / ctf / fs-src / query.c
CommitLineData
04c0ba87
JG
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
98903a3e
PP
27#define BT_LOG_OUTPUT_LEVEL log_level
28#define BT_LOG_TAG "PLUGIN/SRC.CTF.FS/QUERY"
29#include "logging/log.h"
30
04c0ba87
JG
31#include "query.h"
32#include <stdbool.h>
493917ba
SM
33#include <glib.h>
34#include <glib/gstdio.h>
35#include <fcntl.h>
36#include <sys/types.h>
37#include <sys/stat.h>
578e048b 38#include "common/assert.h"
04c0ba87
JG
39#include "metadata.h"
40#include "../common/metadata/decoder.h"
578e048b 41#include "common/common.h"
91d81473 42#include "common/macros.h"
3fadfbc0 43#include <babeltrace2/babeltrace.h>
97ade20b 44#include "fs.h"
d23b766e 45#include "logging/comp-logging.h"
55314f2a 46
04c0ba87
JG
47#define METADATA_TEXT_SIG "/* CTF 1.8"
48
97ade20b
JG
49struct range {
50 int64_t begin_ns;
51 int64_t end_ns;
52 bool set;
53};
54
04c0ba87 55BT_HIDDEN
d24d5663 56bt_component_class_query_method_status metadata_info_query(
d23b766e 57 bt_self_component_class_source *self_comp_class_src,
98903a3e 58 const bt_value *params, bt_logging_level log_level,
b19ff26f 59 const bt_value **user_result)
04c0ba87 60{
d24d5663
PP
61 bt_component_class_query_method_status status =
62 BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
d23b766e
SM
63 bt_self_component_class *self_comp_class =
64 bt_self_component_class_source_as_self_component_class(self_comp_class_src);
b19ff26f
PP
65 bt_value *result = NULL;
66 const bt_value *path_value = NULL;
04c0ba87 67 FILE *metadata_fp = NULL;
04c0ba87
JG
68 int ret;
69 int bo;
70 const char *path;
71 bool is_packetized;
06be9946
PP
72 struct ctf_metadata_decoder *decoder = NULL;
73 struct ctf_metadata_decoder_config decoder_cfg = { 0 };
74 enum ctf_metadata_decoder_status decoder_status;
04c0ba87 75
05e21286 76 result = bt_value_map_create();
da91b29a 77 if (!result) {
d24d5663 78 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
04c0ba87
JG
79 goto error;
80 }
81
f6ccaed9
PP
82 BT_ASSERT(params);
83
04c0ba87 84 if (!bt_value_is_map(params)) {
d23b766e
SM
85 BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
86 "Query parameters is not a map value object.");
a635e507 87 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
04c0ba87
JG
88 goto error;
89 }
90
05e21286 91 path_value = bt_value_map_borrow_entry_value_const(params, "path");
07330b50 92 if (!path_value) {
d23b766e
SM
93 BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
94 "Mandatory `path` parameter missing");
a635e507 95 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
07330b50
FD
96 goto error;
97 }
98
99 if (!bt_value_is_string(path_value)) {
d23b766e
SM
100 BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
101 "`path` parameter is required to be a string value");
a635e507 102 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
07330b50
FD
103 goto error;
104 }
105
601b0d3c 106 path = bt_value_string_get(path_value);
04c0ba87 107
f6ccaed9 108 BT_ASSERT(path);
04c0ba87
JG
109 metadata_fp = ctf_fs_metadata_open_file(path);
110 if (!metadata_fp) {
d23b766e
SM
111 BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
112 "Cannot open trace metadata: path=\"%s\".", path);
04c0ba87
JG
113 goto error;
114 }
115
06be9946 116 ret = ctf_metadata_decoder_is_packetized(metadata_fp, &is_packetized,
98903a3e 117 &bo, log_level, NULL);
06be9946
PP
118 if (ret) {
119 BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
120 "Cannot check whether or not the metadata stream is packetized: path=\"%s\".",
121 path);
122 goto error;
04c0ba87
JG
123 }
124
06be9946
PP
125 decoder_cfg.log_level = log_level;
126 decoder_cfg.keep_plain_text = true;
127 decoder = ctf_metadata_decoder_create(&decoder_cfg);
128 if (!decoder) {
129 BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
130 "Cannot create metadata decoder: path=\"%s\".", path);
04c0ba87
JG
131 goto error;
132 }
133
06be9946
PP
134 rewind(metadata_fp);
135 decoder_status = ctf_metadata_decoder_append_content(decoder,
136 metadata_fp);
137 if (decoder_status) {
138 BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
139 "Cannot update metadata decoder's content: path=\"%s\".",
140 path);
141 goto error;
04c0ba87
JG
142 }
143
05e21286 144 ret = bt_value_map_insert_string_entry(result, "text",
06be9946 145 ctf_metadata_decoder_get_text(decoder));
04c0ba87 146 if (ret) {
d23b766e
SM
147 BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
148 "Cannot insert metadata text into query result.");
04c0ba87
JG
149 goto error;
150 }
151
05e21286 152 ret = bt_value_map_insert_bool_entry(result, "is-packetized",
04c0ba87
JG
153 is_packetized);
154 if (ret) {
d23b766e
SM
155 BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
156 "Cannot insert \"is-packetized\" attribute into query result.");
04c0ba87
JG
157 goto error;
158 }
159
160 goto end;
161
162error:
c5b9b441 163 BT_VALUE_PUT_REF_AND_RESET(result);
d94d92ac 164 result = NULL;
c7eee084 165
d94d92ac 166 if (status >= 0) {
d24d5663 167 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
c7eee084 168 }
04c0ba87
JG
169
170end:
06be9946 171 ctf_metadata_decoder_destroy(decoder);
04c0ba87
JG
172
173 if (metadata_fp) {
174 fclose(metadata_fp);
175 }
c7eee084 176
05e21286 177 *user_result = result;
d94d92ac 178 return status;
97ade20b 179}
9ec238a8 180
97ade20b 181static
b19ff26f 182int add_range(bt_value *info, struct range *range,
97ade20b
JG
183 const char *range_name)
184{
185 int ret = 0;
d24d5663 186 bt_value_map_insert_entry_status status;
760b266c 187 bt_value *range_map;
97ade20b
JG
188
189 if (!range->set) {
190 /* Not an error. */
191 goto end;
192 }
193
760b266c
SM
194 status = bt_value_map_insert_empty_map_entry(info, range_name,
195 &range_map);
196 if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
97ade20b
JG
197 ret = -1;
198 goto end;
199 }
200
fdd3a2da 201 status = bt_value_map_insert_signed_integer_entry(range_map, "begin",
97ade20b 202 range->begin_ns);
d24d5663 203 if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
97ade20b
JG
204 ret = -1;
205 goto end;
206 }
207
fdd3a2da 208 status = bt_value_map_insert_signed_integer_entry(range_map, "end",
97ade20b 209 range->end_ns);
d24d5663 210 if (status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
97ade20b
JG
211 ret = -1;
212 goto end;
213 }
214
97ade20b 215end:
97ade20b
JG
216 return ret;
217}
218
97ade20b
JG
219static
220int populate_stream_info(struct ctf_fs_ds_file_group *group,
b19ff26f 221 bt_value *group_info, struct range *stream_range)
97ade20b
JG
222{
223 int ret = 0;
d24d5663 224 bt_value_map_insert_entry_status insert_status;
b1c001b6 225 struct ctf_fs_ds_index_entry *first_ds_index_entry, *last_ds_index_entry;
a38d7650 226 gchar *port_name = NULL;
97ade20b 227
b1c001b6 228 /*
7ed5243a
FD
229 * Since each `struct ctf_fs_ds_file_group` has a sorted array of
230 * `struct ctf_fs_ds_index_entry`, we can compute the stream range from
231 * the timestamp_begin of the first index entry and the timestamp_end
232 * of the last index entry.
b1c001b6 233 */
7ed5243a
FD
234 BT_ASSERT(group->index);
235 BT_ASSERT(group->index->entries);
236 BT_ASSERT(group->index->entries->len > 0);
b1c001b6 237
7ed5243a
FD
238 /* First entry. */
239 first_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
240 group->index->entries, 0);
b1c001b6 241
7ed5243a
FD
242 /* Last entry. */
243 last_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
244 group->index->entries, group->index->entries->len - 1);
b1c001b6
FD
245
246 stream_range->begin_ns = first_ds_index_entry->timestamp_begin_ns;
247 stream_range->end_ns = last_ds_index_entry->timestamp_end_ns;
b1c001b6 248
1d4ac4b6
FD
249 /*
250 * If any of the begin and end timestamps is not set it means that
251 * packets don't include `timestamp_begin` _and_ `timestamp_end` fields
252 * in their packet context so we can't set the range.
253 */
254 stream_range->set = stream_range->begin_ns != UINT64_C(-1) &&
255 stream_range->end_ns != UINT64_C(-1);
256
257 ret = add_range(group_info, stream_range, "range-ns");
258 if (ret) {
259 goto end;
97ade20b
JG
260 }
261
a38d7650
SM
262 port_name = ctf_fs_make_port_name(group);
263 if (!port_name) {
264 ret = -1;
265 goto end;
266 }
267
d24d5663
PP
268 insert_status = bt_value_map_insert_string_entry(group_info,
269 "port-name", port_name);
270 if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
a38d7650
SM
271 ret = -1;
272 goto end;
273 }
274
97ade20b 275end:
19bbdc9b 276 g_free(port_name);
97ade20b
JG
277 return ret;
278}
279
280static
f280892e 281int populate_trace_info(const struct ctf_fs_trace *trace, bt_value *trace_info)
97ade20b
JG
282{
283 int ret = 0;
284 size_t group_idx;
d24d5663
PP
285 bt_value_map_insert_entry_status insert_status;
286 bt_value_array_append_element_status append_status;
f280892e 287 bt_value *file_groups = NULL;
97ade20b 288
f280892e
SM
289 BT_ASSERT(trace->ds_file_groups);
290 /* Add trace range info only if it contains streams. */
291 if (trace->ds_file_groups->len == 0) {
292 ret = -1;
293 goto end;
294 }
295
760b266c
SM
296 insert_status = bt_value_map_insert_empty_array_entry(trace_info,
297 "streams", &file_groups);
298 if (insert_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
299 ret = -1;
97ade20b
JG
300 goto end;
301 }
302
97ade20b
JG
303 /* Find range of all stream groups, and of the trace. */
304 for (group_idx = 0; group_idx < trace->ds_file_groups->len;
305 group_idx++) {
b19ff26f 306 bt_value *group_info;
97ade20b
JG
307 struct range group_range = { .set = false };
308 struct ctf_fs_ds_file_group *group = g_ptr_array_index(
309 trace->ds_file_groups, group_idx);
310
760b266c
SM
311 append_status = bt_value_array_append_empty_map_element(
312 file_groups, &group_info);
313 if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
97ade20b
JG
314 ret = -1;
315 goto end;
316 }
317
318 ret = populate_stream_info(group, group_info, &group_range);
319 if (ret) {
7233204d
FD
320 goto end;
321 }
97ade20b
JG
322 }
323
97ade20b 324end:
97ade20b
JG
325 return ret;
326}
327
328BT_HIDDEN
d24d5663 329bt_component_class_query_method_status trace_info_query(
d23b766e 330 bt_self_component_class_source *self_comp_class_src,
98903a3e 331 const bt_value *params, bt_logging_level log_level,
b19ff26f 332 const bt_value **user_result)
97ade20b 333{
f280892e 334 struct ctf_fs_component *ctf_fs = NULL;
d24d5663
PP
335 bt_component_class_query_method_status status =
336 BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
d23b766e
SM
337 bt_self_component_class *self_comp_class =
338 bt_self_component_class_source_as_self_component_class(
339 self_comp_class_src);
b19ff26f 340 bt_value *result = NULL;
73760435 341 const bt_value *inputs_value = NULL;
97ade20b 342 int ret = 0;
a0cd55ad
SM
343 bt_value *trace_info = NULL;
344 bt_value_array_append_element_status append_status;
97ade20b 345
f6ccaed9
PP
346 BT_ASSERT(params);
347
97ade20b 348 if (!bt_value_is_map(params)) {
d23b766e
SM
349 BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
350 "Query parameters is not a map value object.");
a635e507 351 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
97ade20b
JG
352 goto error;
353 }
354
4c65a157 355 ctf_fs = ctf_fs_component_create(log_level, NULL);
d907165c 356 if (!ctf_fs) {
97ade20b
JG
357 goto error;
358 }
97ade20b 359
d23b766e
SM
360 if (!read_src_fs_parameters(params, &inputs_value, ctf_fs, NULL,
361 self_comp_class)) {
a635e507 362 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
97ade20b
JG
363 goto error;
364 }
365
a0cd55ad 366 if (ctf_fs_component_create_ctf_fs_trace(ctf_fs, inputs_value, NULL,
d23b766e 367 self_comp_class)) {
97ade20b
JG
368 goto error;
369 }
370
05e21286 371 result = bt_value_array_create();
da91b29a 372 if (!result) {
d24d5663 373 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
97ade20b
JG
374 goto error;
375 }
376
a0cd55ad
SM
377 append_status = bt_value_array_append_empty_map_element(result,
378 &trace_info);
379 if (append_status != BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_OK) {
380 BT_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp_class,
381 "Failed to create trace info map.");
382 goto error;
383 }
97ade20b 384
a0cd55ad
SM
385 ret = populate_trace_info(ctf_fs->trace, trace_info);
386 if (ret) {
387 goto error;
97ade20b
JG
388 }
389
390 goto end;
391
392error:
c5b9b441 393 BT_VALUE_PUT_REF_AND_RESET(result);
c7eee084 394
d94d92ac 395 if (status >= 0) {
d24d5663 396 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
c7eee084
PP
397 }
398
97ade20b 399end:
f280892e
SM
400 if (ctf_fs) {
401 ctf_fs_destroy(ctf_fs);
402 ctf_fs = NULL;
97ade20b 403 }
d94d92ac 404
05e21286 405 *user_result = result;
d94d92ac 406 return status;
04c0ba87 407}
73760435
SM
408
409BT_HIDDEN
410bt_component_class_query_method_status support_info_query(
411 bt_self_component_class_source *comp_class,
412 const bt_value *params, bt_logging_level log_level,
413 const bt_value **user_result)
414{
415 const bt_value *input_type_value;
416 const char *input_type;
417 bt_component_class_query_method_status status;
493917ba 418 bt_value_map_insert_entry_status insert_entry_status;
73760435
SM
419 double weight = 0;
420 gchar *metadata_path = NULL;
421 bt_value *result = NULL;
493917ba
SM
422 struct ctf_metadata_decoder *metadata_decoder = NULL;
423 FILE *metadata_file = NULL;
424 char uuid_str[BT_UUID_STR_LEN + 1];
425 bool has_uuid = false;
426 const bt_value *input_value;
427 const char *input;
73760435
SM
428
429 input_type_value = bt_value_map_borrow_entry_value_const(params, "type");
430 BT_ASSERT(input_type_value);
431 BT_ASSERT(bt_value_get_type(input_type_value) == BT_VALUE_TYPE_STRING);
432 input_type = bt_value_string_get(input_type_value);
433
493917ba
SM
434 if (strcmp(input_type, "directory") != 0) {
435 goto create_result;
436 }
437
438 input_value = bt_value_map_borrow_entry_value_const(params, "input");
439 BT_ASSERT(input_value);
440 BT_ASSERT(bt_value_get_type(input_value) == BT_VALUE_TYPE_STRING);
441 input = bt_value_string_get(input_value);
442
443 metadata_path = g_build_filename(input, CTF_FS_METADATA_FILENAME, NULL);
444 if (!metadata_path) {
73760435
SM
445 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
446 goto end;
447 }
448
493917ba
SM
449 metadata_file = g_fopen(metadata_path, "r");
450 if (metadata_file) {
451 struct ctf_metadata_decoder_config metadata_decoder_config = { 0 };
452 enum ctf_metadata_decoder_status decoder_status;
453 bt_uuid_t uuid;
73760435 454
493917ba 455 metadata_decoder_config.log_level = log_level;
73760435 456
493917ba
SM
457 metadata_decoder = ctf_metadata_decoder_create(
458 &metadata_decoder_config);
459 if (!metadata_decoder) {
460 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
461 goto end;
462 }
463
464 decoder_status = ctf_metadata_decoder_append_content(
465 metadata_decoder, metadata_file);
466 if (decoder_status != CTF_METADATA_DECODER_STATUS_OK) {
467 BT_LOGW("cannot append metadata content: metadata-decoder-status=%d",
468 decoder_status);
469 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR;
73760435
SM
470 goto end;
471 }
472
473 /*
493917ba
SM
474 * We were able to parse the metadata file, so we are
475 * confident it's a CTF trace.
73760435 476 */
493917ba
SM
477 weight = 0.75;
478
479 /* If the trace has a UUID, return the stringified UUID as the group. */
480 if (ctf_metadata_decoder_get_trace_class_uuid(metadata_decoder, uuid) == 0) {
481 bt_uuid_to_str(uuid, uuid_str);
482 has_uuid = true;
73760435
SM
483 }
484 }
485
493917ba
SM
486create_result:
487 result = bt_value_map_create();
488 if (!result) {
73760435
SM
489 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR;
490 goto end;
491 }
492
493917ba
SM
493 insert_entry_status = bt_value_map_insert_real_entry(result, "weight", weight);
494 if (insert_entry_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
495 status = (int) insert_entry_status;
73760435
SM
496 goto end;
497 }
498
493917ba
SM
499 /* We are not supposed to have weight == 0 and a UUID. */
500 BT_ASSERT(weight > 0 || !has_uuid);
501
502 if (weight > 0 && has_uuid) {
503 insert_entry_status = bt_value_map_insert_string_entry(result, "group", uuid_str);
504 if (insert_entry_status != BT_VALUE_MAP_INSERT_ENTRY_STATUS_OK) {
505 status = (int) insert_entry_status;
506 goto end;
507 }
508 }
509
73760435
SM
510 *user_result = result;
511 result = NULL;
512 status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK;
513
514end:
515 g_free(metadata_path);
516 bt_value_put_ref(result);
493917ba 517 ctf_metadata_decoder_destroy(metadata_decoder);
73760435
SM
518
519 return status;
520}
This page took 0.072549 seconds and 4 git commands to generate.