2 * Copyright 2019 Philippe Proulx <pproulx@efficios.com>
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 #define BT_COMP_LOG_SELF_COMP (stream->trace->fs_sink->self_comp)
24 #define BT_LOG_OUTPUT_LEVEL (stream->log_level)
25 #define BT_LOG_TAG "PLUGIN/SINK.CTF.FS/STREAM"
26 #include "logging/comp-logging.h"
28 #include <babeltrace2/babeltrace.h>
32 #include "common/assert.h"
33 #include "ctfser/ctfser.h"
34 #include "compat/endian.h"
37 #include "fs-sink-trace.h"
38 #include "fs-sink-stream.h"
39 #include "translate-trace-ir-to-ctf-ir.h"
42 void fs_sink_stream_destroy(struct fs_sink_stream
*stream
)
48 bt_ctfser_fini(&stream
->ctfser
);
50 if (stream
->file_name
) {
51 g_string_free(stream
->file_name
, TRUE
);
52 stream
->file_name
= NULL
;
55 bt_packet_put_ref(stream
->packet_state
.packet
);
63 bool stream_file_name_exists(struct fs_sink_trace
*trace
, const char *name
)
69 g_hash_table_iter_init(&iter
, trace
->streams
);
71 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
72 struct fs_sink_stream
*stream
= value
;
74 if (strcmp(name
, stream
->file_name
->str
) == 0) {
85 GString
*sanitize_stream_file_name(const char *file_name
)
87 GString
*san_file_name
= g_string_new(NULL
);
91 BT_ASSERT(san_file_name
);
93 basename
= g_path_get_basename(file_name
);
95 for (ch
= basename
; *ch
!= '\0'; ch
++) {
97 g_string_append_c(san_file_name
, '_');
99 g_string_append_c(san_file_name
, *ch
);
103 /* Do not allow `.` and `..` either */
104 if (strcmp(san_file_name
->str
, ".") == 0 ||
105 strcmp(san_file_name
->str
, "..") == 0) {
106 g_string_assign(san_file_name
, "stream");
110 return san_file_name
;
114 GString
*make_unique_stream_file_name(struct fs_sink_trace
*trace
,
117 GString
*san_base
= sanitize_stream_file_name(base
);
118 GString
*name
= g_string_new(san_base
->str
);
119 unsigned int suffix
= 0;
123 while (stream_file_name_exists(trace
, name
->str
) &&
124 strcmp(name
->str
, "metadata") == 0) {
125 g_string_printf(name
, "%s-%u", san_base
->str
, suffix
);
129 g_string_free(san_base
, TRUE
);
134 void set_stream_file_name(struct fs_sink_stream
*stream
)
136 const char *base_name
= bt_stream_get_name(stream
->ir_stream
);
139 base_name
= "stream";
142 BT_ASSERT(!stream
->file_name
);
143 stream
->file_name
= make_unique_stream_file_name(stream
->trace
,
148 struct fs_sink_stream
*fs_sink_stream_create(struct fs_sink_trace
*trace
,
149 const bt_stream
*ir_stream
)
151 struct fs_sink_stream
*stream
= g_new0(struct fs_sink_stream
, 1);
153 GString
*path
= g_string_new(trace
->path
->str
);
159 stream
->log_level
= trace
->log_level
;
160 stream
->trace
= trace
;
161 stream
->ir_stream
= ir_stream
;
162 stream
->packet_state
.beginning_cs
= UINT64_C(-1);
163 stream
->packet_state
.end_cs
= UINT64_C(-1);
164 stream
->prev_packet_state
.end_cs
= UINT64_C(-1);
165 stream
->prev_packet_state
.discarded_events_counter
= UINT64_C(-1);
166 stream
->prev_packet_state
.seq_num
= UINT64_C(-1);
167 ret
= try_translate_stream_class_trace_ir_to_ctf_ir(trace
->fs_sink
,
168 trace
->trace
, bt_stream_borrow_class_const(ir_stream
),
174 set_stream_file_name(stream
);
175 g_string_append_printf(path
, "/%s", stream
->file_name
->str
);
176 ret
= bt_ctfser_init(&stream
->ctfser
, path
->str
,
182 g_hash_table_insert(trace
->streams
, (gpointer
) ir_stream
, stream
);
186 fs_sink_stream_destroy(stream
);
191 g_string_free(path
, TRUE
);
198 int write_field(struct fs_sink_stream
*stream
,
199 struct fs_sink_ctf_field_class
*fc
, const bt_field
*field
);
202 int write_bool_field(struct fs_sink_stream
*stream
,
203 struct fs_sink_ctf_field_class_int
*fc
, const bt_field
*field
)
206 * CTF 1.8 has no boolean field class type, so this component
207 * translates this boolean field to an 8-bit unsigned integer
208 * field which has the value 0 (false) or 1 (true).
210 return bt_ctfser_write_unsigned_int(&stream
->ctfser
,
211 bt_field_bool_get_value(field
) ? 1 : 0,
212 fc
->base
.base
.alignment
, fc
->base
.size
, BYTE_ORDER
);
216 int write_bit_array_field(struct fs_sink_stream
*stream
,
217 struct fs_sink_ctf_field_class_bit_array
*fc
,
218 const bt_field
*field
)
221 * CTF 1.8 has no bit array field class type, so this component
222 * translates this bit array field to an unsigned integer field.
224 return bt_ctfser_write_unsigned_int(&stream
->ctfser
,
225 bt_field_bit_array_get_value_as_integer(field
),
226 fc
->base
.alignment
, fc
->size
, BYTE_ORDER
);
230 int write_int_field(struct fs_sink_stream
*stream
,
231 struct fs_sink_ctf_field_class_int
*fc
, const bt_field
*field
)
236 ret
= bt_ctfser_write_signed_int(&stream
->ctfser
,
237 bt_field_integer_signed_get_value(field
),
238 fc
->base
.base
.alignment
, fc
->base
.size
, BYTE_ORDER
);
240 ret
= bt_ctfser_write_unsigned_int(&stream
->ctfser
,
241 bt_field_integer_unsigned_get_value(field
),
242 fc
->base
.base
.alignment
, fc
->base
.size
, BYTE_ORDER
);
249 int write_float_field(struct fs_sink_stream
*stream
,
250 struct fs_sink_ctf_field_class_float
*fc
, const bt_field
*field
)
255 if (fc
->base
.size
== 32) {
256 val
= (double) bt_field_real_single_precision_get_value(field
);
257 ret
= bt_ctfser_write_float32(&stream
->ctfser
, val
,
258 fc
->base
.base
.alignment
, BYTE_ORDER
);
260 val
= bt_field_real_double_precision_get_value(field
);
261 ret
= bt_ctfser_write_float64(&stream
->ctfser
, val
,
262 fc
->base
.base
.alignment
, BYTE_ORDER
);
269 int write_string_field(struct fs_sink_stream
*stream
,
270 struct fs_sink_ctf_field_class_string
*fc
, const bt_field
*field
)
272 return bt_ctfser_write_string(&stream
->ctfser
,
273 bt_field_string_get_value(field
));
277 int write_array_field_elements(struct fs_sink_stream
*stream
,
278 struct fs_sink_ctf_field_class_array_base
*fc
,
279 const bt_field
*field
)
282 uint64_t len
= bt_field_array_get_length(field
);
285 for (i
= 0; i
< len
; i
++) {
286 const bt_field
*elem_field
=
287 bt_field_array_borrow_element_field_by_index_const(
289 ret
= write_field(stream
, fc
->elem_fc
, elem_field
);
290 if (G_UNLIKELY(ret
)) {
300 int write_sequence_field(struct fs_sink_stream
*stream
,
301 struct fs_sink_ctf_field_class_sequence
*fc
,
302 const bt_field
*field
)
306 if (fc
->length_is_before
) {
307 ret
= bt_ctfser_write_unsigned_int(&stream
->ctfser
,
308 bt_field_array_get_length(field
), 8, 32, BYTE_ORDER
);
309 if (G_UNLIKELY(ret
)) {
314 ret
= write_array_field_elements(stream
, (void *) fc
, field
);
321 int write_struct_field(struct fs_sink_stream
*stream
,
322 struct fs_sink_ctf_field_class_struct
*fc
,
323 const bt_field
*field
, bool align_struct
)
328 if (G_LIKELY(align_struct
)) {
329 ret
= bt_ctfser_align_offset_in_current_packet(&stream
->ctfser
,
331 if (G_UNLIKELY(ret
)) {
336 for (i
= 0; i
< fc
->members
->len
; i
++) {
337 const bt_field
*memb_field
=
338 bt_field_structure_borrow_member_field_by_index_const(
340 struct fs_sink_ctf_field_class
*member_fc
=
341 fs_sink_ctf_field_class_struct_borrow_member_by_index(
344 ret
= write_field(stream
, member_fc
, memb_field
);
345 if (G_UNLIKELY(ret
)) {
355 int write_option_field(struct fs_sink_stream
*stream
,
356 struct fs_sink_ctf_field_class_option
*fc
,
357 const bt_field
*field
)
360 const bt_field
*content_field
=
361 bt_field_option_borrow_field_const(field
);
363 ret
= bt_ctfser_write_unsigned_int(&stream
->ctfser
,
364 content_field
? 1 : 0, 8, 8, BYTE_ORDER
);
365 if (G_UNLIKELY(ret
)) {
370 * CTF 1.8 has no option field class type, so this component
371 * translates the option field class to a variant field class
372 * where the options are:
374 * * An empty structure field class (field occupies 0 bits).
375 * * The optional field class itself.
377 * If `content_field` is `NULL`, do not write anything (empty
381 ret
= write_field(stream
, fc
->content_fc
, content_field
);
389 int write_variant_field(struct fs_sink_stream
*stream
,
390 struct fs_sink_ctf_field_class_variant
*fc
,
391 const bt_field
*field
)
394 bt_field_variant_get_selected_option_index(field
);
397 if (fc
->tag_is_before
) {
398 ret
= bt_ctfser_write_unsigned_int(&stream
->ctfser
,
399 opt_index
, 8, 16, BYTE_ORDER
);
400 if (G_UNLIKELY(ret
)) {
405 ret
= write_field(stream
,
406 fs_sink_ctf_field_class_variant_borrow_option_by_index(fc
,
408 bt_field_variant_borrow_selected_option_field_const(field
));
415 int write_field(struct fs_sink_stream
*stream
,
416 struct fs_sink_ctf_field_class
*fc
, const bt_field
*field
)
421 case FS_SINK_CTF_FIELD_CLASS_TYPE_BOOL
:
422 ret
= write_bool_field(stream
, (void *) fc
, field
);
424 case FS_SINK_CTF_FIELD_CLASS_TYPE_BIT_ARRAY
:
425 ret
= write_bit_array_field(stream
, (void *) fc
, field
);
427 case FS_SINK_CTF_FIELD_CLASS_TYPE_INT
:
428 ret
= write_int_field(stream
, (void *) fc
, field
);
430 case FS_SINK_CTF_FIELD_CLASS_TYPE_FLOAT
:
431 ret
= write_float_field(stream
, (void *) fc
, field
);
433 case FS_SINK_CTF_FIELD_CLASS_TYPE_STRING
:
434 ret
= write_string_field(stream
, (void *) fc
, field
);
436 case FS_SINK_CTF_FIELD_CLASS_TYPE_STRUCT
:
437 ret
= write_struct_field(stream
, (void *) fc
, field
, true);
439 case FS_SINK_CTF_FIELD_CLASS_TYPE_ARRAY
:
440 ret
= write_array_field_elements(stream
, (void *) fc
, field
);
442 case FS_SINK_CTF_FIELD_CLASS_TYPE_SEQUENCE
:
443 ret
= write_sequence_field(stream
, (void *) fc
, field
);
445 case FS_SINK_CTF_FIELD_CLASS_TYPE_OPTION
:
446 ret
= write_option_field(stream
, (void *) fc
, field
);
448 case FS_SINK_CTF_FIELD_CLASS_TYPE_VARIANT
:
449 ret
= write_variant_field(stream
, (void *) fc
, field
);
459 int write_event_header(struct fs_sink_stream
*stream
,
460 const bt_clock_snapshot
*cs
, struct fs_sink_ctf_event_class
*ec
)
465 ret
= bt_ctfser_write_byte_aligned_unsigned_int(&stream
->ctfser
,
466 bt_event_class_get_id(ec
->ir_ec
), 8, 64, BYTE_ORDER
);
467 if (G_UNLIKELY(ret
)) {
472 if (stream
->sc
->default_clock_class
) {
474 ret
= bt_ctfser_write_byte_aligned_unsigned_int(&stream
->ctfser
,
475 bt_clock_snapshot_get_value(cs
), 8, 64, BYTE_ORDER
);
476 if (G_UNLIKELY(ret
)) {
486 int fs_sink_stream_write_event(struct fs_sink_stream
*stream
,
487 const bt_clock_snapshot
*cs
, const bt_event
*event
,
488 struct fs_sink_ctf_event_class
*ec
)
491 const bt_field
*field
;
494 ret
= write_event_header(stream
, cs
, ec
);
495 if (G_UNLIKELY(ret
)) {
500 if (stream
->sc
->event_common_context_fc
) {
501 field
= bt_event_borrow_common_context_field_const(event
);
502 BT_ASSERT_DBG(field
);
503 ret
= write_struct_field(stream
,
504 (void *) stream
->sc
->event_common_context_fc
,
506 if (G_UNLIKELY(ret
)) {
511 /* Specific context */
512 if (ec
->spec_context_fc
) {
513 field
= bt_event_borrow_specific_context_field_const(event
);
514 BT_ASSERT_DBG(field
);
515 ret
= write_struct_field(stream
, (void *) ec
->spec_context_fc
,
517 if (G_UNLIKELY(ret
)) {
522 /* Specific context */
523 if (ec
->payload_fc
) {
524 field
= bt_event_borrow_payload_field_const(event
);
525 BT_ASSERT_DBG(field
);
526 ret
= write_struct_field(stream
, (void *) ec
->payload_fc
,
528 if (G_UNLIKELY(ret
)) {
538 int write_packet_context(struct fs_sink_stream
*stream
)
542 /* Packet total size */
543 ret
= bt_ctfser_write_byte_aligned_unsigned_int(&stream
->ctfser
,
544 stream
->packet_state
.total_size
, 8, 64, BYTE_ORDER
);
549 /* Packet content size */
550 ret
= bt_ctfser_write_byte_aligned_unsigned_int(&stream
->ctfser
,
551 stream
->packet_state
.content_size
, 8, 64, BYTE_ORDER
);
556 if (stream
->sc
->packets_have_ts_begin
) {
558 ret
= bt_ctfser_write_byte_aligned_unsigned_int(&stream
->ctfser
,
559 stream
->packet_state
.beginning_cs
, 8, 64, BYTE_ORDER
);
565 if (stream
->sc
->packets_have_ts_end
) {
567 ret
= bt_ctfser_write_byte_aligned_unsigned_int(&stream
->ctfser
,
568 stream
->packet_state
.end_cs
, 8, 64, BYTE_ORDER
);
574 if (stream
->sc
->has_discarded_events
) {
575 /* Discarded event counter */
576 ret
= bt_ctfser_write_byte_aligned_unsigned_int(&stream
->ctfser
,
577 stream
->packet_state
.discarded_events_counter
, 8, 64,
584 /* Sequence number */
585 ret
= bt_ctfser_write_byte_aligned_unsigned_int(&stream
->ctfser
,
586 stream
->packet_state
.seq_num
, 8, 64, BYTE_ORDER
);
592 if (stream
->sc
->packet_context_fc
) {
593 const bt_field
*packet_context_field
;
595 BT_ASSERT(stream
->packet_state
.packet
);
596 packet_context_field
= bt_packet_borrow_context_field_const(
597 stream
->packet_state
.packet
);
598 BT_ASSERT(packet_context_field
);
599 ret
= write_struct_field(stream
,
600 (void *) stream
->sc
->packet_context_fc
,
601 packet_context_field
, false);
612 int fs_sink_stream_open_packet(struct fs_sink_stream
*stream
,
613 const bt_clock_snapshot
*cs
, const bt_packet
*packet
)
618 BT_ASSERT(!stream
->packet_state
.is_open
);
619 bt_packet_put_ref(stream
->packet_state
.packet
);
620 stream
->packet_state
.packet
= packet
;
621 bt_packet_get_ref(stream
->packet_state
.packet
);
623 stream
->packet_state
.beginning_cs
=
624 bt_clock_snapshot_get_value(cs
);
628 ret
= bt_ctfser_open_packet(&stream
->ctfser
);
630 /* bt_ctfser_open_packet() logs errors */
634 /* Packet header: magic */
635 ret
= bt_ctfser_write_byte_aligned_unsigned_int(&stream
->ctfser
,
636 UINT64_C(0xc1fc1fc1), 8, 32, BYTE_ORDER
);
638 BT_COMP_LOGE("Error writing packet header magic: stream-file-name=%s",
639 stream
->file_name
->str
);
643 /* Packet header: UUID */
644 for (i
= 0; i
< BT_UUID_LEN
; i
++) {
645 ret
= bt_ctfser_write_byte_aligned_unsigned_int(&stream
->ctfser
,
646 (uint64_t) stream
->sc
->trace
->uuid
[i
], 8, 8, BYTE_ORDER
);
648 BT_COMP_LOGE("Error writing packet header UUID: stream-file-name=%s",
649 stream
->file_name
->str
);
654 /* Packet header: stream class ID */
655 ret
= bt_ctfser_write_byte_aligned_unsigned_int(&stream
->ctfser
,
656 bt_stream_class_get_id(stream
->sc
->ir_sc
), 8, 64, BYTE_ORDER
);
658 BT_COMP_LOGE("Error writing packet header stream class id: "
659 "stream-file-name=%s, stream-class-id=%"PRIu64
,
660 stream
->file_name
->str
,
661 bt_stream_class_get_id(stream
->sc
->ir_sc
));
665 /* Packet header: stream ID */
666 ret
= bt_ctfser_write_byte_aligned_unsigned_int(&stream
->ctfser
,
667 bt_stream_get_id(stream
->ir_stream
), 8, 64, BYTE_ORDER
);
669 BT_COMP_LOGE("Error writing packet header stream id: "
670 "stream-file-name=%s, stream-id=%"PRIu64
,
671 stream
->file_name
->str
,
672 bt_stream_get_id(stream
->ir_stream
));
676 /* Save packet context's offset to rewrite it later */
677 stream
->packet_state
.context_offset_bits
=
678 bt_ctfser_get_offset_in_current_packet_bits(&stream
->ctfser
);
680 /* Write packet context just to advance to content (first event) */
681 ret
= write_packet_context(stream
);
686 stream
->packet_state
.is_open
= true;
693 int fs_sink_stream_close_packet(struct fs_sink_stream
*stream
,
694 const bt_clock_snapshot
*cs
)
698 BT_ASSERT(stream
->packet_state
.is_open
);
701 stream
->packet_state
.end_cs
= bt_clock_snapshot_get_value(cs
);
704 stream
->packet_state
.content_size
=
705 bt_ctfser_get_offset_in_current_packet_bits(&stream
->ctfser
);
706 stream
->packet_state
.total_size
=
707 (stream
->packet_state
.content_size
+ 7) & ~UINT64_C(7);
709 /* Rewrite packet context */
710 bt_ctfser_set_offset_in_current_packet_bits(&stream
->ctfser
,
711 stream
->packet_state
.context_offset_bits
);
712 ret
= write_packet_context(stream
);
718 bt_ctfser_close_current_packet(&stream
->ctfser
,
719 stream
->packet_state
.total_size
/ 8);
721 /* Partially copy current packet state to previous packet state */
722 stream
->prev_packet_state
.end_cs
= stream
->packet_state
.end_cs
;
723 stream
->prev_packet_state
.discarded_events_counter
=
724 stream
->packet_state
.discarded_events_counter
;
725 stream
->prev_packet_state
.seq_num
=
726 stream
->packet_state
.seq_num
;
728 /* Reset current packet state */
729 stream
->packet_state
.beginning_cs
= UINT64_C(-1);
730 stream
->packet_state
.end_cs
= UINT64_C(-1);
731 stream
->packet_state
.content_size
= 0;
732 stream
->packet_state
.total_size
= 0;
733 stream
->packet_state
.seq_num
+= 1;
734 stream
->packet_state
.context_offset_bits
= 0;
735 stream
->packet_state
.is_open
= false;
736 BT_PACKET_PUT_REF_AND_RESET(stream
->packet_state
.packet
);