cli, plugins/ctf/fs-src: Make src.ctf.fs accept multiple root paths
[babeltrace.git] / 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 bt_query_status metadata_info_query(
50 bt_self_component_class_source *comp_class,
51 const bt_value *params,
52 const bt_value **user_result)
53 {
54 bt_query_status status = BT_QUERY_STATUS_OK;
55 bt_value *result = NULL;
56 const bt_value *path_value = NULL;
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
65 result = bt_value_map_create();
66 if (!result) {
67 status = BT_QUERY_STATUS_NOMEM;
68 goto error;
69 }
70
71 BT_ASSERT(params);
72
73 if (!bt_value_is_map(params)) {
74 BT_LOGE_STR("Query parameters is not a map value object.");
75 status = BT_QUERY_STATUS_INVALID_PARAMS;
76 goto error;
77 }
78
79 path_value = bt_value_map_borrow_entry_value_const(params, "path");
80 path = bt_value_string_get(path_value);
81
82 BT_ASSERT(path);
83 metadata_fp = ctf_fs_metadata_open_file(path);
84 if (!metadata_fp) {
85 BT_LOGE("Cannot open trace metadata: path=\"%s\".", path);
86 goto error;
87 }
88
89 is_packetized = ctf_metadata_decoder_is_packetized(metadata_fp,
90 &bo);
91
92 if (is_packetized) {
93 ret = ctf_metadata_decoder_packetized_file_stream_to_buf(
94 metadata_fp, &metadata_text, bo);
95 if (ret) {
96 BT_LOGE("Cannot decode packetized metadata file: path=\"%s\"",
97 path);
98 goto error;
99 }
100 } else {
101 long filesize;
102
103 ret = fseek(metadata_fp, 0, SEEK_END);
104 if (ret) {
105 BT_LOGE_ERRNO("Failed to seek to the end of the metadata file",
106 ": path=\"%s\"", path);
107 goto error;
108 }
109 filesize = ftell(metadata_fp);
110 if (filesize < 0) {
111 BT_LOGE_ERRNO("Failed to get the current position in the metadata file",
112 ": path=\"%s\"", path);
113 goto error;
114 }
115 rewind(metadata_fp);
116 metadata_text = malloc(filesize + 1);
117 if (!metadata_text) {
118 BT_LOGE_STR("Cannot allocate buffer for metadata text.");
119 goto error;
120 }
121
122 if (fread(metadata_text, filesize, 1, metadata_fp) != 1) {
123 BT_LOGE_ERRNO("Cannot read metadata file", ": path=\"%s\"",
124 path);
125 goto error;
126 }
127
128 metadata_text[filesize] = '\0';
129 }
130
131 g_metadata_text = g_string_new(NULL);
132 if (!g_metadata_text) {
133 goto error;
134 }
135
136 if (strncmp(metadata_text, METADATA_TEXT_SIG,
137 sizeof(METADATA_TEXT_SIG) - 1) != 0) {
138 g_string_assign(g_metadata_text, METADATA_TEXT_SIG);
139 g_string_append(g_metadata_text, " */\n\n");
140 }
141
142 g_string_append(g_metadata_text, metadata_text);
143
144 ret = bt_value_map_insert_string_entry(result, "text",
145 g_metadata_text->str);
146 if (ret) {
147 BT_LOGE_STR("Cannot insert metadata text into query result.");
148 goto error;
149 }
150
151 ret = bt_value_map_insert_bool_entry(result, "is-packetized",
152 is_packetized);
153 if (ret) {
154 BT_LOGE_STR("Cannot insert \"is-packetized\" attribute into query result.");
155 goto error;
156 }
157
158 goto end;
159
160 error:
161 BT_VALUE_PUT_REF_AND_RESET(result);
162 result = NULL;
163
164 if (status >= 0) {
165 status = BT_QUERY_STATUS_ERROR;
166 }
167
168 end:
169 free(metadata_text);
170
171 if (g_metadata_text) {
172 g_string_free(g_metadata_text, TRUE);
173 }
174
175 if (metadata_fp) {
176 fclose(metadata_fp);
177 }
178
179 *user_result = result;
180 return status;
181 }
182
183 static
184 int add_range(bt_value *info, struct range *range,
185 const char *range_name)
186 {
187 int ret = 0;
188 bt_value_status status;
189 bt_value *range_map = NULL;
190
191 if (!range->set) {
192 /* Not an error. */
193 goto end;
194 }
195
196 range_map = bt_value_map_create();
197 if (!range_map) {
198 ret = -1;
199 goto end;
200 }
201
202 status = bt_value_map_insert_integer_entry(range_map, "begin",
203 range->begin_ns);
204 if (status != BT_VALUE_STATUS_OK) {
205 ret = -1;
206 goto end;
207 }
208
209 status = bt_value_map_insert_integer_entry(range_map, "end",
210 range->end_ns);
211 if (status != BT_VALUE_STATUS_OK) {
212 ret = -1;
213 goto end;
214 }
215
216 status = bt_value_map_insert_entry(info, range_name,
217 range_map);
218 if (status != BT_VALUE_STATUS_OK) {
219 ret = -1;
220 goto end;
221 }
222
223 end:
224 bt_value_put_ref(range_map);
225 return ret;
226 }
227
228 static
229 int add_stream_ids(bt_value *info, struct ctf_fs_ds_file_group *ds_file_group)
230 {
231 int ret = 0;
232 bt_value_status status;
233
234 if (ds_file_group->stream_id != UINT64_C(-1)) {
235 status = bt_value_map_insert_integer_entry(info, "id",
236 (int64_t) ds_file_group->stream_id);
237 if (status != BT_VALUE_STATUS_OK) {
238 ret = -1;
239 goto end;
240 }
241 }
242
243 status = bt_value_map_insert_integer_entry(info, "class-id",
244 (int64_t) ds_file_group->sc->id);
245 if (status != BT_VALUE_STATUS_OK) {
246 ret = -1;
247 goto end;
248 }
249
250 end:
251 return ret;
252 }
253
254 static
255 int populate_stream_info(struct ctf_fs_ds_file_group *group,
256 bt_value *group_info, struct range *stream_range)
257 {
258 int ret = 0;
259 size_t file_idx;
260 bt_value_status status;
261 bt_value *file_paths;
262
263 stream_range->begin_ns = INT64_MAX;
264 stream_range->end_ns = 0;
265
266 file_paths = bt_value_array_create();
267 if (!file_paths) {
268 ret = -1;
269 goto end;
270 }
271
272 for (file_idx = 0; file_idx < group->ds_file_infos->len; file_idx++) {
273 int64_t file_begin_epoch, file_end_epoch;
274 struct ctf_fs_ds_file_info *info =
275 g_ptr_array_index(group->ds_file_infos,
276 file_idx);
277
278 if (!info->index || info->index->entries->len == 0) {
279 BT_LOGW("Cannot determine range of unindexed stream file \'%s\'",
280 info->path->str);
281 ret = -1;
282 goto end;
283 }
284
285 status = bt_value_array_append_string_element(file_paths,
286 info->path->str);
287 if (status != BT_VALUE_STATUS_OK) {
288 ret = -1;
289 goto end;
290 }
291
292 /*
293 * file range is from timestamp_begin of the first entry to the
294 * timestamp_end of the last entry.
295 */
296 file_begin_epoch = ((struct ctf_fs_ds_index_entry *) &g_array_index(info->index->entries,
297 struct ctf_fs_ds_index_entry, 0))->timestamp_begin_ns;
298 file_end_epoch = ((struct ctf_fs_ds_index_entry *) &g_array_index(info->index->entries,
299 struct ctf_fs_ds_index_entry, info->index->entries->len - 1))->timestamp_end_ns;
300
301 stream_range->begin_ns = min(stream_range->begin_ns, file_begin_epoch);
302 stream_range->end_ns = max(stream_range->end_ns, file_end_epoch);
303 stream_range->set = true;
304 }
305
306 if (stream_range->set) {
307 ret = add_range(group_info, stream_range, "range-ns");
308 if (ret) {
309 goto end;
310 }
311 }
312
313 status = bt_value_map_insert_entry(group_info, "paths",
314 file_paths);
315 if (status != BT_VALUE_STATUS_OK) {
316 ret = -1;
317 goto end;
318 }
319
320 ret = add_stream_ids(group_info, group);
321 if (ret) {
322 goto end;
323 }
324 end:
325 bt_value_put_ref(file_paths);
326 return ret;
327 }
328
329 static
330 int populate_trace_info(const struct ctf_fs_trace *trace, bt_value *trace_info)
331 {
332 int ret = 0;
333 size_t group_idx;
334 bt_value_status status;
335 bt_value *file_groups = NULL;
336 struct range trace_range = {
337 .begin_ns = INT64_MAX,
338 .end_ns = 0,
339 .set = false,
340 };
341 struct range trace_intersection = {
342 .begin_ns = 0,
343 .end_ns = INT64_MAX,
344 .set = false,
345 };
346
347 BT_ASSERT(trace->ds_file_groups);
348 /* Add trace range info only if it contains streams. */
349 if (trace->ds_file_groups->len == 0) {
350 ret = -1;
351 goto end;
352 }
353
354 file_groups = bt_value_array_create();
355 if (!file_groups) {
356 goto end;
357 }
358
359 status = bt_value_map_insert_string_entry(trace_info, "name",
360 trace->name->str);
361 if (status != BT_VALUE_STATUS_OK) {
362 ret = -1;
363 goto end;
364 }
365 status = bt_value_map_insert_string_entry(trace_info, "path",
366 trace->path->str);
367 if (status != BT_VALUE_STATUS_OK) {
368 ret = -1;
369 goto end;
370 }
371
372 /* Find range of all stream groups, and of the trace. */
373 for (group_idx = 0; group_idx < trace->ds_file_groups->len;
374 group_idx++) {
375 bt_value *group_info;
376 struct range group_range = { .set = false };
377 struct ctf_fs_ds_file_group *group = g_ptr_array_index(
378 trace->ds_file_groups, group_idx);
379
380 group_info = bt_value_map_create();
381 if (!group_info) {
382 ret = -1;
383 goto end;
384 }
385
386 ret = populate_stream_info(group, group_info, &group_range);
387 if (ret) {
388 bt_value_put_ref(group_info);
389 goto end;
390 }
391
392 if (group_range.set) {
393 trace_range.begin_ns = min(trace_range.begin_ns,
394 group_range.begin_ns);
395 trace_range.end_ns = max(trace_range.end_ns,
396 group_range.end_ns);
397 trace_range.set = true;
398
399 trace_intersection.begin_ns = max(trace_intersection.begin_ns,
400 group_range.begin_ns);
401 trace_intersection.end_ns = min(trace_intersection.end_ns,
402 group_range.end_ns);
403 trace_intersection.set = true;
404 status = bt_value_array_append_element(
405 file_groups,
406 group_info);
407 bt_value_put_ref(group_info);
408 if (status != BT_VALUE_STATUS_OK) {
409 goto end;
410 }
411 }
412 }
413
414 ret = add_range(trace_info, &trace_range, "range-ns");
415 if (ret) {
416 goto end;
417 }
418
419 if (trace_intersection.begin_ns < trace_intersection.end_ns) {
420 ret = add_range(trace_info, &trace_intersection,
421 "intersection-range-ns");
422 if (ret) {
423 goto end;
424 }
425 }
426
427 status = bt_value_map_insert_entry(trace_info, "streams",
428 file_groups);
429 BT_VALUE_PUT_REF_AND_RESET(file_groups);
430 if (status != BT_VALUE_STATUS_OK) {
431 ret = -1;
432 goto end;
433 }
434
435 end:
436 bt_value_put_ref(file_groups);
437 return ret;
438 }
439
440 BT_HIDDEN
441 bt_query_status trace_info_query(
442 bt_self_component_class_source *comp_class,
443 const bt_value *params,
444 const bt_value **user_result)
445 {
446 struct ctf_fs_component *ctf_fs = NULL;
447 bt_query_status status = BT_QUERY_STATUS_OK;
448 bt_value *result = NULL;
449 const bt_value *paths_value = NULL;
450 int ret = 0;
451 guint i;
452
453 BT_ASSERT(params);
454
455 if (!bt_value_is_map(params)) {
456 BT_LOGE("Query parameters is not a map value object.");
457 status = BT_QUERY_STATUS_INVALID_PARAMS;
458 goto error;
459 }
460
461 paths_value = bt_value_map_borrow_entry_value_const(params, "paths");
462 if (!validate_paths_parameter(paths_value)) {
463 goto error;
464 }
465
466 ctf_fs = ctf_fs_component_create();
467 if (!ctf_fs) {
468 goto error;
469 }
470
471 if (ctf_fs_component_create_ctf_fs_traces(NULL, ctf_fs, paths_value)) {
472 goto error;
473 }
474
475 result = bt_value_array_create();
476 if (!result) {
477 status = BT_QUERY_STATUS_NOMEM;
478 goto error;
479 }
480
481 for (i = 0; i < ctf_fs->traces->len; i++) {
482 struct ctf_fs_trace *trace;
483 bt_value *trace_info;
484 bt_value_status status;
485
486 trace = g_ptr_array_index(ctf_fs->traces, i);
487 BT_ASSERT(trace);
488
489 trace_info = bt_value_map_create();
490 if (!trace_info) {
491 BT_LOGE("Failed to create trace info map.");
492 goto error;
493 }
494
495 ret = populate_trace_info(trace, trace_info);
496 if (ret) {
497 bt_value_put_ref(trace_info);
498 goto error;
499 }
500
501 status = bt_value_array_append_element(result, trace_info);
502 bt_value_put_ref(trace_info);
503 if (status != BT_VALUE_STATUS_OK) {
504 goto error;
505 }
506 }
507
508 goto end;
509
510 error:
511 BT_VALUE_PUT_REF_AND_RESET(result);
512 result = NULL;
513
514 if (status >= 0) {
515 status = BT_QUERY_STATUS_ERROR;
516 }
517
518 end:
519 if (ctf_fs) {
520 ctf_fs_destroy(ctf_fs);
521 ctf_fs = NULL;
522 }
523
524 *user_result = result;
525 return status;
526 }
This page took 0.040897 seconds and 4 git commands to generate.