Logging: standardize logging tags
[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
27#include "query.h"
28#include <stdbool.h>
578e048b 29#include "common/assert.h"
04c0ba87
JG
30#include "metadata.h"
31#include "../common/metadata/decoder.h"
578e048b 32#include "common/common.h"
91d81473 33#include "common/macros.h"
3fadfbc0 34#include <babeltrace2/babeltrace.h>
97ade20b 35#include "fs.h"
55314f2a 36
350ad6c1 37#define BT_LOG_TAG "PLUGIN/SRC.CTF.FS/QUERY"
55314f2a 38#include "logging.h"
04c0ba87
JG
39
40#define METADATA_TEXT_SIG "/* CTF 1.8"
41
97ade20b
JG
42struct range {
43 int64_t begin_ns;
44 int64_t end_ns;
45 bool set;
46};
47
04c0ba87 48BT_HIDDEN
4cdfc5e8 49bt_query_status metadata_info_query(
b19ff26f
PP
50 bt_self_component_class_source *comp_class,
51 const bt_value *params,
52 const bt_value **user_result)
04c0ba87 53{
4cdfc5e8 54 bt_query_status status = BT_QUERY_STATUS_OK;
b19ff26f
PP
55 bt_value *result = NULL;
56 const bt_value *path_value = NULL;
04c0ba87
JG
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
05e21286 65 result = bt_value_map_create();
da91b29a 66 if (!result) {
d94d92ac 67 status = BT_QUERY_STATUS_NOMEM;
04c0ba87
JG
68 goto error;
69 }
70
f6ccaed9
PP
71 BT_ASSERT(params);
72
04c0ba87 73 if (!bt_value_is_map(params)) {
f7d0e29c 74 BT_LOGE_STR("Query parameters is not a map value object.");
d94d92ac 75 status = BT_QUERY_STATUS_INVALID_PARAMS;
04c0ba87
JG
76 goto error;
77 }
78
05e21286 79 path_value = bt_value_map_borrow_entry_value_const(params, "path");
07330b50
FD
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
601b0d3c 92 path = bt_value_string_get(path_value);
04c0ba87 93
f6ccaed9 94 BT_ASSERT(path);
04c0ba87
JG
95 metadata_fp = ctf_fs_metadata_open_file(path);
96 if (!metadata_fp) {
f7d0e29c 97 BT_LOGE("Cannot open trace metadata: path=\"%s\".", path);
04c0ba87
JG
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) {
f7d0e29c
JG
108 BT_LOGE("Cannot decode packetized metadata file: path=\"%s\"",
109 path);
04c0ba87
JG
110 goto error;
111 }
112 } else {
113 long filesize;
114
677e1a21
MD
115 ret = fseek(metadata_fp, 0, SEEK_END);
116 if (ret) {
f7d0e29c
JG
117 BT_LOGE_ERRNO("Failed to seek to the end of the metadata file",
118 ": path=\"%s\"", path);
677e1a21
MD
119 goto error;
120 }
04c0ba87 121 filesize = ftell(metadata_fp);
677e1a21 122 if (filesize < 0) {
f7d0e29c
JG
123 BT_LOGE_ERRNO("Failed to get the current position in the metadata file",
124 ": path=\"%s\"", path);
677e1a21
MD
125 goto error;
126 }
04c0ba87
JG
127 rewind(metadata_fp);
128 metadata_text = malloc(filesize + 1);
129 if (!metadata_text) {
f7d0e29c 130 BT_LOGE_STR("Cannot allocate buffer for metadata text.");
04c0ba87
JG
131 goto error;
132 }
133
134 if (fread(metadata_text, filesize, 1, metadata_fp) != 1) {
f7d0e29c
JG
135 BT_LOGE_ERRNO("Cannot read metadata file", ": path=\"%s\"",
136 path);
04c0ba87
JG
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
05e21286 156 ret = bt_value_map_insert_string_entry(result, "text",
04c0ba87
JG
157 g_metadata_text->str);
158 if (ret) {
f7d0e29c 159 BT_LOGE_STR("Cannot insert metadata text into query result.");
04c0ba87
JG
160 goto error;
161 }
162
05e21286 163 ret = bt_value_map_insert_bool_entry(result, "is-packetized",
04c0ba87
JG
164 is_packetized);
165 if (ret) {
f7d0e29c 166 BT_LOGE_STR("Cannot insert \"is-packetized\" attribute into query result.");
04c0ba87
JG
167 goto error;
168 }
169
170 goto end;
171
172error:
c5b9b441 173 BT_VALUE_PUT_REF_AND_RESET(result);
d94d92ac 174 result = NULL;
c7eee084 175
d94d92ac
PP
176 if (status >= 0) {
177 status = BT_QUERY_STATUS_ERROR;
c7eee084 178 }
04c0ba87
JG
179
180end:
04c0ba87
JG
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 }
c7eee084 190
05e21286 191 *user_result = result;
d94d92ac 192 return status;
97ade20b 193}
9ec238a8 194
97ade20b 195static
b19ff26f 196int add_range(bt_value *info, struct range *range,
97ade20b
JG
197 const char *range_name)
198{
199 int ret = 0;
4cdfc5e8 200 bt_value_status status;
b19ff26f 201 bt_value *range_map = NULL;
97ade20b
JG
202
203 if (!range->set) {
204 /* Not an error. */
205 goto end;
206 }
207
05e21286 208 range_map = bt_value_map_create();
97ade20b
JG
209 if (!range_map) {
210 ret = -1;
211 goto end;
212 }
213
fdd3a2da 214 status = bt_value_map_insert_signed_integer_entry(range_map, "begin",
97ade20b
JG
215 range->begin_ns);
216 if (status != BT_VALUE_STATUS_OK) {
217 ret = -1;
218 goto end;
219 }
220
fdd3a2da 221 status = bt_value_map_insert_signed_integer_entry(range_map, "end",
97ade20b
JG
222 range->end_ns);
223 if (status != BT_VALUE_STATUS_OK) {
224 ret = -1;
225 goto end;
226 }
227
05e21286
PP
228 status = bt_value_map_insert_entry(info, range_name,
229 range_map);
97ade20b
JG
230 if (status != BT_VALUE_STATUS_OK) {
231 ret = -1;
232 goto end;
233 }
da91b29a 234
97ade20b 235end:
c5b9b441 236 bt_value_put_ref(range_map);
97ade20b
JG
237 return ret;
238}
239
240static
60363f2f 241int add_stream_ids(bt_value *info, struct ctf_fs_ds_file_group *ds_file_group)
97ade20b
JG
242{
243 int ret = 0;
4cdfc5e8 244 bt_value_status status;
97ade20b 245
60363f2f 246 if (ds_file_group->stream_id != UINT64_C(-1)) {
fdd3a2da
PP
247 status = bt_value_map_insert_unsigned_integer_entry(info, "id",
248 ds_file_group->stream_id);
97ade20b
JG
249 if (status != BT_VALUE_STATUS_OK) {
250 ret = -1;
251 goto end;
252 }
253 }
254
fdd3a2da
PP
255 status = bt_value_map_insert_unsigned_integer_entry(info, "class-id",
256 ds_file_group->sc->id);
97ade20b
JG
257 if (status != BT_VALUE_STATUS_OK) {
258 ret = -1;
259 goto end;
260 }
0b29603d 261
97ade20b 262end:
97ade20b
JG
263 return ret;
264}
265
266static
267int populate_stream_info(struct ctf_fs_ds_file_group *group,
b19ff26f 268 bt_value *group_info, struct range *stream_range)
97ade20b
JG
269{
270 int ret = 0;
271 size_t file_idx;
4cdfc5e8 272 bt_value_status status;
b19ff26f 273 bt_value *file_paths;
b1c001b6 274 struct ctf_fs_ds_index_entry *first_ds_index_entry, *last_ds_index_entry;
a38d7650 275 gchar *port_name = NULL;
97ade20b 276
05e21286 277 file_paths = bt_value_array_create();
97ade20b
JG
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++) {
97ade20b 284 struct ctf_fs_ds_file_info *info =
60363f2f
PP
285 g_ptr_array_index(group->ds_file_infos,
286 file_idx);
97ade20b 287
05e21286 288 status = bt_value_array_append_string_element(file_paths,
97ade20b
JG
289 info->path->str);
290 if (status != BT_VALUE_STATUS_OK) {
291 ret = -1;
292 goto end;
293 }
97ade20b
JG
294 }
295
b1c001b6 296 /*
7ed5243a
FD
297 * Since each `struct ctf_fs_ds_file_group` has a sorted array of
298 * `struct ctf_fs_ds_index_entry`, we can compute the stream range from
299 * the timestamp_begin of the first index entry and the timestamp_end
300 * of the last index entry.
b1c001b6 301 */
7ed5243a
FD
302 BT_ASSERT(group->index);
303 BT_ASSERT(group->index->entries);
304 BT_ASSERT(group->index->entries->len > 0);
b1c001b6 305
7ed5243a
FD
306 /* First entry. */
307 first_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
308 group->index->entries, 0);
b1c001b6 309
7ed5243a
FD
310 /* Last entry. */
311 last_ds_index_entry = (struct ctf_fs_ds_index_entry *) g_ptr_array_index(
312 group->index->entries, group->index->entries->len - 1);
b1c001b6
FD
313
314 stream_range->begin_ns = first_ds_index_entry->timestamp_begin_ns;
315 stream_range->end_ns = last_ds_index_entry->timestamp_end_ns;
b1c001b6 316
1d4ac4b6
FD
317 /*
318 * If any of the begin and end timestamps is not set it means that
319 * packets don't include `timestamp_begin` _and_ `timestamp_end` fields
320 * in their packet context so we can't set the range.
321 */
322 stream_range->set = stream_range->begin_ns != UINT64_C(-1) &&
323 stream_range->end_ns != UINT64_C(-1);
324
325 ret = add_range(group_info, stream_range, "range-ns");
326 if (ret) {
327 goto end;
97ade20b
JG
328 }
329
05e21286
PP
330 status = bt_value_map_insert_entry(group_info, "paths",
331 file_paths);
97ade20b
JG
332 if (status != BT_VALUE_STATUS_OK) {
333 ret = -1;
334 goto end;
335 }
336
60363f2f 337 ret = add_stream_ids(group_info, group);
97ade20b
JG
338 if (ret) {
339 goto end;
340 }
a38d7650
SM
341
342 port_name = ctf_fs_make_port_name(group);
343 if (!port_name) {
344 ret = -1;
345 goto end;
346 }
347
348 status = bt_value_map_insert_string_entry(group_info, "port-name",
349 port_name);
350 if (status != BT_VALUE_STATUS_OK) {
351 ret = -1;
352 goto end;
353 }
354
97ade20b 355end:
c5b9b441 356 bt_value_put_ref(file_paths);
97ade20b
JG
357 return ret;
358}
359
360static
f280892e 361int populate_trace_info(const struct ctf_fs_trace *trace, bt_value *trace_info)
97ade20b
JG
362{
363 int ret = 0;
364 size_t group_idx;
4cdfc5e8 365 bt_value_status status;
f280892e 366 bt_value *file_groups = NULL;
97ade20b
JG
367 struct range trace_range = {
368 .begin_ns = INT64_MAX,
369 .end_ns = 0,
370 .set = false,
371 };
372 struct range trace_intersection = {
373 .begin_ns = 0,
374 .end_ns = INT64_MAX,
375 .set = false,
376 };
377
f280892e
SM
378 BT_ASSERT(trace->ds_file_groups);
379 /* Add trace range info only if it contains streams. */
380 if (trace->ds_file_groups->len == 0) {
381 ret = -1;
382 goto end;
383 }
384
05e21286 385 file_groups = bt_value_array_create();
97ade20b
JG
386 if (!file_groups) {
387 goto end;
388 }
389
05e21286 390 status = bt_value_map_insert_string_entry(trace_info, "name",
f280892e 391 trace->name->str);
97ade20b
JG
392 if (status != BT_VALUE_STATUS_OK) {
393 ret = -1;
394 goto end;
395 }
05e21286 396 status = bt_value_map_insert_string_entry(trace_info, "path",
f280892e 397 trace->path->str);
97ade20b
JG
398 if (status != BT_VALUE_STATUS_OK) {
399 ret = -1;
400 goto end;
401 }
402
97ade20b
JG
403 /* Find range of all stream groups, and of the trace. */
404 for (group_idx = 0; group_idx < trace->ds_file_groups->len;
405 group_idx++) {
b19ff26f 406 bt_value *group_info;
97ade20b
JG
407 struct range group_range = { .set = false };
408 struct ctf_fs_ds_file_group *group = g_ptr_array_index(
409 trace->ds_file_groups, group_idx);
410
05e21286 411 group_info = bt_value_map_create();
97ade20b
JG
412 if (!group_info) {
413 ret = -1;
414 goto end;
415 }
416
417 ret = populate_stream_info(group, group_info, &group_range);
418 if (ret) {
c5b9b441 419 bt_value_put_ref(group_info);
97ade20b
JG
420 goto end;
421 }
422
7233204d
FD
423 status = bt_value_array_append_element(file_groups, group_info);
424 bt_value_put_ref(group_info);
425 if (status != BT_VALUE_STATUS_OK) {
426 goto end;
427 }
428
97ade20b 429 if (group_range.set) {
91d81473 430 trace_range.begin_ns = MIN(trace_range.begin_ns,
97ade20b 431 group_range.begin_ns);
91d81473 432 trace_range.end_ns = MAX(trace_range.end_ns,
97ade20b
JG
433 group_range.end_ns);
434 trace_range.set = true;
435
91d81473 436 trace_intersection.begin_ns = MAX(trace_intersection.begin_ns,
97ade20b 437 group_range.begin_ns);
91d81473 438 trace_intersection.end_ns = MIN(trace_intersection.end_ns,
97ade20b
JG
439 group_range.end_ns);
440 trace_intersection.set = true;
97ade20b
JG
441 }
442 }
443
444 ret = add_range(trace_info, &trace_range, "range-ns");
445 if (ret) {
446 goto end;
447 }
c6daf8b2
PP
448
449 if (trace_intersection.begin_ns < trace_intersection.end_ns) {
450 ret = add_range(trace_info, &trace_intersection,
451 "intersection-range-ns");
452 if (ret) {
453 goto end;
454 }
97ade20b
JG
455 }
456
05e21286
PP
457 status = bt_value_map_insert_entry(trace_info, "streams",
458 file_groups);
c5b9b441 459 BT_VALUE_PUT_REF_AND_RESET(file_groups);
97ade20b
JG
460 if (status != BT_VALUE_STATUS_OK) {
461 ret = -1;
462 goto end;
463 }
464
465end:
c5b9b441 466 bt_value_put_ref(file_groups);
97ade20b
JG
467 return ret;
468}
469
470BT_HIDDEN
4cdfc5e8 471bt_query_status trace_info_query(
b19ff26f
PP
472 bt_self_component_class_source *comp_class,
473 const bt_value *params,
474 const bt_value **user_result)
97ade20b 475{
f280892e 476 struct ctf_fs_component *ctf_fs = NULL;
4cdfc5e8 477 bt_query_status status = BT_QUERY_STATUS_OK;
b19ff26f 478 bt_value *result = NULL;
f280892e 479 const bt_value *paths_value = NULL;
97ade20b 480 int ret = 0;
f280892e 481 guint i;
97ade20b 482
f6ccaed9
PP
483 BT_ASSERT(params);
484
97ade20b
JG
485 if (!bt_value_is_map(params)) {
486 BT_LOGE("Query parameters is not a map value object.");
d94d92ac 487 status = BT_QUERY_STATUS_INVALID_PARAMS;
97ade20b
JG
488 goto error;
489 }
490
d907165c
SM
491 ctf_fs = ctf_fs_component_create();
492 if (!ctf_fs) {
97ade20b
JG
493 goto error;
494 }
97ade20b 495
d907165c
SM
496 if (!read_src_fs_parameters(params, &paths_value, ctf_fs)) {
497 status = BT_QUERY_STATUS_INVALID_PARAMS;
97ade20b
JG
498 goto error;
499 }
500
f280892e 501 if (ctf_fs_component_create_ctf_fs_traces(NULL, ctf_fs, paths_value)) {
97ade20b
JG
502 goto error;
503 }
504
05e21286 505 result = bt_value_array_create();
da91b29a 506 if (!result) {
d94d92ac 507 status = BT_QUERY_STATUS_NOMEM;
97ade20b
JG
508 goto error;
509 }
510
f280892e
SM
511 for (i = 0; i < ctf_fs->traces->len; i++) {
512 struct ctf_fs_trace *trace;
b19ff26f 513 bt_value *trace_info;
f280892e
SM
514 bt_value_status status;
515
516 trace = g_ptr_array_index(ctf_fs->traces, i);
517 BT_ASSERT(trace);
97ade20b 518
05e21286 519 trace_info = bt_value_map_create();
97ade20b
JG
520 if (!trace_info) {
521 BT_LOGE("Failed to create trace info map.");
522 goto error;
523 }
524
f280892e 525 ret = populate_trace_info(trace, trace_info);
97ade20b 526 if (ret) {
c5b9b441 527 bt_value_put_ref(trace_info);
97ade20b
JG
528 goto error;
529 }
530
05e21286 531 status = bt_value_array_append_element(result, trace_info);
c5b9b441 532 bt_value_put_ref(trace_info);
97ade20b
JG
533 if (status != BT_VALUE_STATUS_OK) {
534 goto error;
535 }
536 }
537
538 goto end;
539
540error:
c5b9b441 541 BT_VALUE_PUT_REF_AND_RESET(result);
d94d92ac 542 result = NULL;
c7eee084 543
d94d92ac
PP
544 if (status >= 0) {
545 status = BT_QUERY_STATUS_ERROR;
c7eee084
PP
546 }
547
97ade20b 548end:
f280892e
SM
549 if (ctf_fs) {
550 ctf_fs_destroy(ctf_fs);
551 ctf_fs = NULL;
97ade20b 552 }
d94d92ac 553
05e21286 554 *user_result = result;
d94d92ac 555 return status;
04c0ba87 556}
This page took 0.064581 seconds and 4 git commands to generate.