projects / babeltrace.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
ctf: check version of LTTng trace index
[babeltrace.git] / src / plugins / ctf / fs-src / data-stream-file.c
... / ...
CommitLineData
1/*
2 * Copyright 2016-2017 - Philippe Proulx <pproulx@efficios.com>
3 * Copyright 2016 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * Copyright 2010-2011 - EfficiOS Inc. and Linux Foundation
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25#define BT_COMP_LOG_SELF_COMP (ds_file->self_comp)
26#define BT_LOG_OUTPUT_LEVEL (ds_file->log_level)
27#define BT_LOG_TAG "PLUGIN/SRC.CTF.FS/DS"
28#include "logging/comp-logging.h"
29
30#include <stdlib.h>
31#include <stdio.h>
32#include <stdint.h>
33#include <stdlib.h>
34#include <glib.h>
35#include <inttypes.h>
36#include "compat/mman.h"
37#include "compat/endian.h"
38#include <babeltrace2/babeltrace.h>
39#include "common/common.h"
40#include "file.h"
41#include "metadata.h"
42#include "../common/msg-iter/msg-iter.h"
43#include "common/assert.h"
44#include "data-stream-file.h"
45#include <string.h>
46
47static inline
48size_t remaining_mmap_bytes(struct ctf_fs_ds_file *ds_file)
49{
50 BT_ASSERT_DBG(ds_file->mmap_len >= ds_file->request_offset);
51 return ds_file->mmap_len - ds_file->request_offset;
52}
53
54static
55int ds_file_munmap(struct ctf_fs_ds_file *ds_file)
56{
57 int ret = 0;
58
59 if (!ds_file || !ds_file->mmap_addr) {
60 goto end;
61 }
62
63 if (bt_munmap(ds_file->mmap_addr, ds_file->mmap_len)) {
64 BT_COMP_LOGE_ERRNO("Cannot memory-unmap file",
65 ": address=%p, size=%zu, file_path=\"%s\", file=%p",
66 ds_file->mmap_addr, ds_file->mmap_len,
67 ds_file->file ? ds_file->file->path->str : "NULL",
68 ds_file->file ? ds_file->file->fp : NULL);
69 ret = -1;
70 goto end;
71 }
72
73 ds_file->mmap_addr = NULL;
74
75end:
76 return ret;
77}
78
79static
80enum ctf_msg_iter_medium_status ds_file_mmap_next(
81 struct ctf_fs_ds_file *ds_file)
82{
83 enum ctf_msg_iter_medium_status ret =
84 CTF_MSG_ITER_MEDIUM_STATUS_OK;
85
86 /* Unmap old region */
87 if (ds_file->mmap_addr) {
88 if (ds_file_munmap(ds_file)) {
89 goto error;
90 }
91
92 /*
93 * mmap_len is guaranteed to be page-aligned except on the
94 * last mapping where it may not be possible (since the file's
95 * size itself may not be a page multiple).
96 */
97 ds_file->mmap_offset += ds_file->mmap_len;
98 ds_file->request_offset = 0;
99 }
100
101 ds_file->mmap_len = MIN(ds_file->file->size - ds_file->mmap_offset,
102 ds_file->mmap_max_len);
103 if (ds_file->mmap_len == 0) {
104 ret = CTF_MSG_ITER_MEDIUM_STATUS_EOF;
105 goto end;
106 }
107 /* Map new region */
108 BT_ASSERT(ds_file->mmap_len);
109 ds_file->mmap_addr = bt_mmap((void *) 0, ds_file->mmap_len,
110 PROT_READ, MAP_PRIVATE, fileno(ds_file->file->fp),
111 ds_file->mmap_offset, ds_file->log_level);
112 if (ds_file->mmap_addr == MAP_FAILED) {
113 BT_COMP_LOGE("Cannot memory-map address (size %zu) of file \"%s\" (%p) at offset %jd: %s",
114 ds_file->mmap_len, ds_file->file->path->str,
115 ds_file->file->fp, (intmax_t) ds_file->mmap_offset,
116 strerror(errno));
117 goto error;
118 }
119
120 goto end;
121error:
122 ds_file_munmap(ds_file);
123 ret = CTF_MSG_ITER_MEDIUM_STATUS_ERROR;
124end:
125 return ret;
126}
127
128static
129enum ctf_msg_iter_medium_status medop_request_bytes(
130 size_t request_sz, uint8_t **buffer_addr,
131 size_t *buffer_sz, void *data)
132{
133 enum ctf_msg_iter_medium_status status =
134 CTF_MSG_ITER_MEDIUM_STATUS_OK;
135 struct ctf_fs_ds_file *ds_file = data;
136
137 if (request_sz == 0) {
138 goto end;
139 }
140
141 /*
142 * Check if we have at least one memory-mapped byte left. If we don't,
143 * mmap the next file.
144 */
145 if (remaining_mmap_bytes(ds_file) == 0) {
146 /* Are we at the end of the file? */
147 if (ds_file->mmap_offset >= ds_file->file->size) {
148 BT_COMP_LOGD("Reached end of file \"%s\" (%p)",
149 ds_file->file->path->str, ds_file->file->fp);
150 status = CTF_MSG_ITER_MEDIUM_STATUS_EOF;
151 goto end;
152 }
153
154 status = ds_file_mmap_next(ds_file);
155 switch (status) {
156 case CTF_MSG_ITER_MEDIUM_STATUS_OK:
157 break;
158 case CTF_MSG_ITER_MEDIUM_STATUS_EOF:
159 goto end;
160 default:
161 BT_COMP_LOGE("Cannot memory-map next region of file \"%s\" (%p)",
162 ds_file->file->path->str,
163 ds_file->file->fp);
164 goto error;
165 }
166 }
167
168 *buffer_sz = MIN(remaining_mmap_bytes(ds_file), request_sz);
169 BT_ASSERT(ds_file->mmap_addr);
170 *buffer_addr = ((uint8_t *) ds_file->mmap_addr) + ds_file->request_offset;
171 ds_file->request_offset += *buffer_sz;
172 goto end;
173
174error:
175 status = CTF_MSG_ITER_MEDIUM_STATUS_ERROR;
176
177end:
178 return status;
179}
180
181static
182bt_stream *medop_borrow_stream(bt_stream_class *stream_class, int64_t stream_id,
183 void *data)
184{
185 struct ctf_fs_ds_file *ds_file = data;
186 bt_stream_class *ds_file_stream_class;
187 bt_stream *stream = NULL;
188
189 ds_file_stream_class = bt_stream_borrow_class(
190 ds_file->stream);
191
192 if (stream_class != ds_file_stream_class) {
193 /*
194 * Not supported: two packets described by two different
195 * stream classes within the same data stream file.
196 */
197 goto end;
198 }
199
200 stream = ds_file->stream;
201
202end:
203 return stream;
204}
205
206static
207enum ctf_msg_iter_medium_status medop_seek(enum ctf_msg_iter_seek_whence whence,
208 off_t offset, void *data)
209{
210 enum ctf_msg_iter_medium_status ret =
211 CTF_MSG_ITER_MEDIUM_STATUS_OK;
212 struct ctf_fs_ds_file *ds_file = data;
213 off_t offset_in_mapping, file_size = ds_file->file->size;
214
215 if (whence != CTF_MSG_ITER_SEEK_WHENCE_SET ||
216 offset < 0 || offset > file_size) {
217 BT_COMP_LOGE("Invalid medium seek request: whence=%d, offset=%jd, "
218 "file-size=%jd", (int) whence, (intmax_t) offset,
219 (intmax_t) file_size);
220 ret = CTF_MSG_ITER_MEDIUM_STATUS_INVAL;
221 goto end;
222 }
223
224 /* If there is no current mapping, map the right file directly. */
225 if (!ds_file->mmap_addr) {
226 goto map_requested_offset;
227 }
228
229 /*
230 * Determine whether or not the destination is contained within the
231 * current mapping.
232 */
233 if (offset < ds_file->mmap_offset ||
234 offset >= ds_file->mmap_offset + ds_file->mmap_len) {
235 int unmap_ret;
236 BT_COMP_LOGD("Medium seek request cannot be accomodated by the current "
237 "file mapping: offset=%jd, mmap-offset=%jd, "
238 "mmap-len=%zu", (intmax_t) offset, (intmax_t) ds_file->mmap_offset,
239 ds_file->mmap_len);
240 unmap_ret = ds_file_munmap(ds_file);
241 if (unmap_ret) {
242 ret = CTF_MSG_ITER_MEDIUM_STATUS_ERROR;
243 goto end;
244 }
245 goto map_requested_offset;
246 } else {
247 ds_file->request_offset = offset - ds_file->mmap_offset;
248 goto test_end;
249 }
250
251map_requested_offset:
252 offset_in_mapping = offset %
253 bt_mmap_get_offset_align_size(ds_file->log_level);
254
255 ds_file->mmap_offset = offset - offset_in_mapping;
256 ds_file->request_offset = offset_in_mapping;
257 ret = ds_file_mmap_next(ds_file);
258 if (ret != CTF_MSG_ITER_MEDIUM_STATUS_OK) {
259 goto end;
260 }
261
262test_end:
263 ds_file->end_reached = (offset == file_size);
264end:
265 return ret;
266}
267
268BT_HIDDEN
269struct ctf_msg_iter_medium_ops ctf_fs_ds_file_medops = {
270 .request_bytes = medop_request_bytes,
271 .borrow_stream = medop_borrow_stream,
272 .seek = medop_seek,
273};
274
275static
276int convert_cycles_to_ns(struct ctf_clock_class *clock_class,
277 uint64_t cycles, int64_t *ns)
278{
279 return bt_util_clock_cycles_to_ns_from_origin(cycles,
280 clock_class->frequency, clock_class->offset_seconds,
281 clock_class->offset_cycles, ns);
282}
283
284static
285struct ctf_fs_ds_index *build_index_from_idx_file(
286 struct ctf_fs_ds_file *ds_file,
287 struct ctf_fs_ds_file_info *file_info)
288{
289 int ret;
290 gchar *directory = NULL;
291 gchar *basename = NULL;
292 GString *index_basename = NULL;
293 gchar *index_file_path = NULL;
294 GMappedFile *mapped_file = NULL;
295 gsize filesize;
296 const char *mmap_begin = NULL, *file_pos = NULL;
297 const struct ctf_packet_index_file_hdr *header = NULL;
298 struct ctf_fs_ds_index *index = NULL;
299 struct ctf_fs_ds_index_entry *index_entry = NULL, *prev_index_entry = NULL;
300 uint64_t total_packets_size = 0;
301 size_t file_index_entry_size;
302 size_t file_entry_count;
303 size_t i;
304 struct ctf_stream_class *sc;
305 struct ctf_msg_iter_packet_properties props;
306 uint32_t version_major, version_minor;
307
308 BT_COMP_LOGI("Building index from .idx file of stream file %s",
309 ds_file->file->path->str);
310 ret = ctf_msg_iter_get_packet_properties(ds_file->msg_iter, &props);
311 if (ret) {
312 BT_COMP_LOGI_STR("Cannot read first packet's header and context fields.");
313 goto error;
314 }
315
316 sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc,
317 props.stream_class_id);
318 BT_ASSERT(sc);
319 if (!sc->default_clock_class) {
320 BT_COMP_LOGI_STR("Cannot find stream class's default clock class.");
321 goto error;
322 }
323
324 /* Look for index file in relative path index/name.idx. */
325 basename = g_path_get_basename(ds_file->file->path->str);
326 if (!basename) {
327 BT_COMP_LOGE("Cannot get the basename of datastream file %s",
328 ds_file->file->path->str);
329 goto error;
330 }
331
332 directory = g_path_get_dirname(ds_file->file->path->str);
333 if (!directory) {
334 BT_COMP_LOGE("Cannot get dirname of datastream file %s",
335 ds_file->file->path->str);
336 goto error;
337 }
338
339 index_basename = g_string_new(basename);
340 if (!index_basename) {
341 BT_COMP_LOGE_STR("Cannot allocate index file basename string");
342 goto error;
343 }
344
345 g_string_append(index_basename, ".idx");
346 index_file_path = g_build_filename(directory, "index",
347 index_basename->str, NULL);
348 mapped_file = g_mapped_file_new(index_file_path, FALSE, NULL);
349 if (!mapped_file) {
350 BT_COMP_LOGD("Cannot create new mapped file %s",
351 index_file_path);
352 goto error;
353 }
354
355 /*
356 * The g_mapped_file API limits us to 4GB files on 32-bit.
357 * Traces with such large indexes have never been seen in the wild,
358 * but this would need to be adjusted to support them.
359 */
360 filesize = g_mapped_file_get_length(mapped_file);
361 if (filesize < sizeof(*header)) {
362 BT_COMP_LOGW("Invalid LTTng trace index file: "
363 "file size (%zu bytes) < header size (%zu bytes)",
364 filesize, sizeof(*header));
365 goto error;
366 }
367
368 mmap_begin = g_mapped_file_get_contents(mapped_file);
369 header = (struct ctf_packet_index_file_hdr *) mmap_begin;
370
371 file_pos = g_mapped_file_get_contents(mapped_file) + sizeof(*header);
372 if (be32toh(header->magic) != CTF_INDEX_MAGIC) {
373 BT_COMP_LOGW_STR("Invalid LTTng trace index: \"magic\" field validation failed");
374 goto error;
375 }
376
377 version_major = be32toh(header->index_major);
378 version_minor = be32toh(header->index_minor);
379 if (version_major != 1) {
380 BT_COMP_LOGW(
381 "Unknown LTTng trace index version: "
382 "major=%" PRIu32 ", minor=%" PRIu32,
383 version_major, version_minor);
384 goto error;
385 }
386
387 file_index_entry_size = be32toh(header->packet_index_len);
388 file_entry_count = (filesize - sizeof(*header)) / file_index_entry_size;
389 if ((filesize - sizeof(*header)) % file_index_entry_size) {
390 BT_COMP_LOGW("Invalid LTTng trace index: the index's size after the header "
391 "(%zu bytes) is not a multiple of the index entry size "
392 "(%zu bytes)", (filesize - sizeof(*header)),
393 sizeof(*header));
394 goto error;
395 }
396
397 index = ctf_fs_ds_index_create(ds_file->log_level, ds_file->self_comp);
398 if (!index) {
399 goto error;
400 }
401
402 for (i = 0; i < file_entry_count; i++) {
403 struct ctf_packet_index *file_index =
404 (struct ctf_packet_index *) file_pos;
405 uint64_t packet_size = be64toh(file_index->packet_size);
406
407 if (packet_size % CHAR_BIT) {
408 BT_COMP_LOGW("Invalid packet size encountered in LTTng trace index file");
409 goto error;
410 }
411
412 index_entry = g_new0(struct ctf_fs_ds_index_entry, 1);
413 if (!index_entry) {
414 goto error;
415 }
416
417 /* Set path to stream file. */
418 index_entry->path = file_info->path->str;
419
420 /* Convert size in bits to bytes. */
421 packet_size /= CHAR_BIT;
422 index_entry->packet_size = packet_size;
423
424 index_entry->offset = be64toh(file_index->offset);
425 if (i != 0 && index_entry->offset < prev_index_entry->offset) {
426 BT_COMP_LOGW("Invalid, non-monotonic, packet offset encountered in LTTng trace index file: "
427 "previous offset=%" PRIu64 ", current offset=%" PRIu64,
428 prev_index_entry->offset, index_entry->offset);
429 goto error;
430 }
431
432 index_entry->timestamp_begin = be64toh(file_index->timestamp_begin);
433 index_entry->timestamp_end = be64toh(file_index->timestamp_end);
434 if (index_entry->timestamp_end < index_entry->timestamp_begin) {
435 BT_COMP_LOGW("Invalid packet time bounds encountered in LTTng trace index file (begin > end): "
436 "timestamp_begin=%" PRIu64 "timestamp_end=%" PRIu64,
437 index_entry->timestamp_begin,
438 index_entry->timestamp_end);
439 goto error;
440 }
441
442 /* Convert the packet's bound to nanoseconds since Epoch. */
443 ret = convert_cycles_to_ns(sc->default_clock_class,
444 index_entry->timestamp_begin,
445 &index_entry->timestamp_begin_ns);
446 if (ret) {
447 BT_COMP_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch during index parsing");
448 goto error;
449 }
450 ret = convert_cycles_to_ns(sc->default_clock_class,
451 index_entry->timestamp_end,
452 &index_entry->timestamp_end_ns);
453 if (ret) {
454 BT_COMP_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch during LTTng trace index parsing");
455 goto error;
456 }
457
458 total_packets_size += packet_size;
459 file_pos += file_index_entry_size;
460
461 prev_index_entry = index_entry;
462
463 /* Give ownership of `index_entry` to `index->entries`. */
464 g_ptr_array_add(index->entries, index_entry);
465 index_entry = NULL;
466 }
467
468 /* Validate that the index addresses the complete stream. */
469 if (ds_file->file->size != total_packets_size) {
470 BT_COMP_LOGW("Invalid LTTng trace index file; indexed size != stream file size: "
471 "file-size=%" PRIu64 ", total-packets-size=%" PRIu64,
472 ds_file->file->size, total_packets_size);
473 goto error;
474 }
475end:
476 g_free(directory);
477 g_free(basename);
478 g_free(index_file_path);
479 if (index_basename) {
480 g_string_free(index_basename, TRUE);
481 }
482 if (mapped_file) {
483 g_mapped_file_unref(mapped_file);
484 }
485 return index;
486error:
487 ctf_fs_ds_index_destroy(index);
488 g_free(index_entry);
489 index = NULL;
490 goto end;
491}
492
493static
494int init_index_entry(struct ctf_fs_ds_index_entry *entry,
495 struct ctf_fs_ds_file *ds_file,
496 struct ctf_msg_iter_packet_properties *props,
497 off_t packet_size, off_t packet_offset)
498{
499 int ret = 0;
500 struct ctf_stream_class *sc;
501
502 sc = ctf_trace_class_borrow_stream_class_by_id(ds_file->metadata->tc,
503 props->stream_class_id);
504 BT_ASSERT(sc);
505 BT_ASSERT(packet_offset >= 0);
506 entry->offset = packet_offset;
507 BT_ASSERT(packet_size >= 0);
508 entry->packet_size = packet_size;
509
510 if (props->snapshots.beginning_clock != UINT64_C(-1)) {
511 entry->timestamp_begin = props->snapshots.beginning_clock;
512
513 /* Convert the packet's bound to nanoseconds since Epoch. */
514 ret = convert_cycles_to_ns(sc->default_clock_class,
515 props->snapshots.beginning_clock,
516 &entry->timestamp_begin_ns);
517 if (ret) {
518 BT_COMP_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch.");
519 goto end;
520 }
521 } else {
522 entry->timestamp_begin = UINT64_C(-1);
523 entry->timestamp_begin_ns = UINT64_C(-1);
524 }
525
526 if (props->snapshots.end_clock != UINT64_C(-1)) {
527 entry->timestamp_end = props->snapshots.end_clock;
528
529 /* Convert the packet's bound to nanoseconds since Epoch. */
530 ret = convert_cycles_to_ns(sc->default_clock_class,
531 props->snapshots.end_clock,
532 &entry->timestamp_end_ns);
533 if (ret) {
534 BT_COMP_LOGI_STR("Failed to convert raw timestamp to nanoseconds since Epoch.");
535 goto end;
536 }
537 } else {
538 entry->timestamp_end = UINT64_C(-1);
539 entry->timestamp_end_ns = UINT64_C(-1);
540 }
541
542end:
543 return ret;
544}
545
546static
547struct ctf_fs_ds_index *build_index_from_stream_file(
548 struct ctf_fs_ds_file *ds_file,
549 struct ctf_fs_ds_file_info *file_info)
550{
551 int ret;
552 struct ctf_fs_ds_index *index = NULL;
553 enum ctf_msg_iter_status iter_status = CTF_MSG_ITER_STATUS_OK;
554 off_t current_packet_offset_bytes = 0;
555
556 BT_COMP_LOGI("Indexing stream file %s", ds_file->file->path->str);
557
558 index = ctf_fs_ds_index_create(ds_file->log_level, ds_file->self_comp);
559 if (!index) {
560 goto error;
561 }
562
563 while (true) {
564 off_t current_packet_size_bytes;
565 struct ctf_fs_ds_index_entry *index_entry;
566 struct ctf_msg_iter_packet_properties props;
567
568 if (current_packet_offset_bytes < 0) {
569 BT_COMP_LOGE_STR("Cannot get the current packet's offset.");
570 goto error;
571 } else if (current_packet_offset_bytes > ds_file->file->size) {
572 BT_COMP_LOGE_STR("Unexpected current packet's offset (larger than file).");
573 goto error;
574 } else if (current_packet_offset_bytes == ds_file->file->size) {
575 /* No more data */
576 break;
577 }
578
579 iter_status = ctf_msg_iter_seek(ds_file->msg_iter,
580 current_packet_offset_bytes);
581 if (iter_status != CTF_MSG_ITER_STATUS_OK) {
582 goto error;
583 }
584
585 iter_status = ctf_msg_iter_get_packet_properties(
586 ds_file->msg_iter, &props);
587 if (iter_status != CTF_MSG_ITER_STATUS_OK) {
588 goto error;
589 }
590
591 if (props.exp_packet_total_size >= 0) {
592 current_packet_size_bytes =
593 (uint64_t) props.exp_packet_total_size / 8;
594 } else {
595 current_packet_size_bytes = ds_file->file->size;
596 }
597
598 if (current_packet_offset_bytes + current_packet_size_bytes >
599 ds_file->file->size) {
600 BT_COMP_LOGW("Invalid packet size reported in file: stream=\"%s\", "
601 "packet-offset=%jd, packet-size-bytes=%jd, "
602 "file-size=%jd",
603 ds_file->file->path->str,
604 (intmax_t) current_packet_offset_bytes,
605 (intmax_t) current_packet_size_bytes,
606 (intmax_t) ds_file->file->size);
607 goto error;
608 }
609
610 index_entry = g_new0(struct ctf_fs_ds_index_entry, 1);
611 if (!index_entry) {
612 BT_COMP_LOGE_STR("Failed to allocate a new index entry.");
613 goto error;
614 }
615
616 /* Set path to stream file. */
617 index_entry->path = file_info->path->str;
618
619 ret = init_index_entry(index_entry, ds_file, &props,
620 current_packet_size_bytes, current_packet_offset_bytes);
621 if (ret) {
622 g_free(index_entry);
623 goto error;
624 }
625
626 g_ptr_array_add(index->entries, index_entry);
627
628 current_packet_offset_bytes += current_packet_size_bytes;
629 BT_COMP_LOGD("Seeking to next packet: current-packet-offset=%jd, "
630 "next-packet-offset=%jd",
631 (intmax_t) (current_packet_offset_bytes - current_packet_size_bytes),
632 (intmax_t) current_packet_offset_bytes);
633 }
634
635end:
636 return index;
637
638error:
639 ctf_fs_ds_index_destroy(index);
640 index = NULL;
641 goto end;
642}
643
644BT_HIDDEN
645struct ctf_fs_ds_file *ctf_fs_ds_file_create(
646 struct ctf_fs_trace *ctf_fs_trace,
647 bt_self_message_iterator *pc_msg_iter,
648 struct ctf_msg_iter *msg_iter,
649 bt_stream *stream, const char *path,
650 bt_logging_level log_level)
651{
652 int ret;
653 const size_t offset_align = bt_mmap_get_offset_align_size(log_level);
654 struct ctf_fs_ds_file *ds_file = g_new0(struct ctf_fs_ds_file, 1);
655
656 if (!ds_file) {
657 goto error;
658 }
659
660 ds_file->log_level = log_level;
661 ds_file->self_comp = ctf_fs_trace->self_comp;
662 ds_file->self_msg_iter = pc_msg_iter;
663 ds_file->file = ctf_fs_file_create(log_level, ds_file->self_comp);
664 if (!ds_file->file) {
665 goto error;
666 }
667
668 ds_file->stream = stream;
669 bt_stream_get_ref(ds_file->stream);
670 ds_file->metadata = ctf_fs_trace->metadata;
671 g_string_assign(ds_file->file->path, path);
672 ret = ctf_fs_file_open(ds_file->file, "rb");
673 if (ret) {
674 goto error;
675 }
676
677 ds_file->msg_iter = msg_iter;
678 ctf_msg_iter_set_medops_data(ds_file->msg_iter, ds_file);
679 if (!ds_file->msg_iter) {
680 goto error;
681 }
682
683 ds_file->mmap_max_len = offset_align * 2048;
684
685 goto end;
686
687error:
688 /* Do not touch "borrowed" file. */
689 ctf_fs_ds_file_destroy(ds_file);
690 ds_file = NULL;
691
692end:
693 return ds_file;
694}
695
696BT_HIDDEN
697struct ctf_fs_ds_index *ctf_fs_ds_file_build_index(
698 struct ctf_fs_ds_file *ds_file,
699 struct ctf_fs_ds_file_info *file_info)
700{
701 struct ctf_fs_ds_index *index;
702
703 index = build_index_from_idx_file(ds_file, file_info);
704 if (index) {
705 goto end;
706 }
707
708 BT_COMP_LOGI("Failed to build index from .index file; "
709 "falling back to stream indexing.");
710 index = build_index_from_stream_file(ds_file, file_info);
711end:
712 return index;
713}
714
715BT_HIDDEN
716struct ctf_fs_ds_index *ctf_fs_ds_index_create(bt_logging_level log_level,
717 bt_self_component *self_comp)
718{
719 struct ctf_fs_ds_index *index = g_new0(struct ctf_fs_ds_index, 1);
720
721 if (!index) {
722 BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
723 "Failed to allocate index");
724 goto error;
725 }
726
727 index->entries = g_ptr_array_new_with_free_func((GDestroyNotify) g_free);
728 if (!index->entries) {
729 BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
730 "Failed to allocate index entries.");
731 goto error;
732 }
733
734 goto end;
735
736error:
737 ctf_fs_ds_index_destroy(index);
738 index = NULL;
739end:
740 return index;
741}
742
743BT_HIDDEN
744void ctf_fs_ds_file_destroy(struct ctf_fs_ds_file *ds_file)
745{
746 if (!ds_file) {
747 return;
748 }
749
750 bt_stream_put_ref(ds_file->stream);
751 (void) ds_file_munmap(ds_file);
752
753 if (ds_file->file) {
754 ctf_fs_file_destroy(ds_file->file);
755 }
756
757 g_free(ds_file);
758}
759
760BT_HIDDEN
761bt_component_class_message_iterator_next_method_status ctf_fs_ds_file_next(
762 struct ctf_fs_ds_file *ds_file,
763 bt_message **msg)
764{
765 enum ctf_msg_iter_status msg_iter_status;
766 bt_component_class_message_iterator_next_method_status status;
767
768 msg_iter_status = ctf_msg_iter_get_next_message(
769 ds_file->msg_iter, msg);
770
771 switch (msg_iter_status) {
772 case CTF_MSG_ITER_STATUS_EOF:
773 status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_END;
774 break;
775 case CTF_MSG_ITER_STATUS_OK:
776 status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK;
777 break;
778 case CTF_MSG_ITER_STATUS_AGAIN:
779 /*
780 * Should not make it this far as this is
781 * medium-specific; there is nothing for the user to do
782 * and it should have been handled upstream.
783 */
784 bt_common_abort();
785 case CTF_MSG_ITER_STATUS_INVAL:
786 case CTF_MSG_ITER_STATUS_ERROR:
787 default:
788 status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_ERROR;
789 break;
790 }
791 return status;
792}
793
794BT_HIDDEN
795void ctf_fs_ds_index_destroy(struct ctf_fs_ds_index *index)
796{
797 if (!index) {
798 return;
799 }
800
801 if (index->entries) {
802 g_ptr_array_free(index->entries, TRUE);
803 }
804 g_free(index);
805}
BabelTrace - Trace Format Babel Tower
This page took 0.025316 seconds and 4 git commands to generate.