Writer: set the discarded events's value before serializing

[babeltrace.git] / formats / ctf / ir / stream.c

diff --git a/formats/ctf/ir/stream.c b/formats/ctf/ir/stream.c
index 16bb0adad187be70e590fc566c5b9f61235c8acc..3de77b4182c7801fbe32d7aa3f8abced8a535a03 100644 (file)
--- a/formats/ctf/ir/stream.c
+++ b/formats/ctf/ir/stream.c
@@ -873,6 +873,7 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
        struct bt_ctf_field *integer = NULL;
        struct ctf_stream_pos packet_context_pos;
        bool empty_packet;
+       uint64_t packet_size_bits;
 
        if (!stream || stream->pos.fd < 0) {
                /*
@@ -883,12 +884,18 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
                goto end;
        }
 
-       empty_packet = (stream->events->len == 0);
-       ret = bt_ctf_field_validate(stream->packet_header);
-       if (ret) {
+       if (!stream->packet_context && stream->flushed_packet_count > 0) {
+               /*
+                * A stream without a packet context, and thus without
+                * content and packet size members, can't have more than
+                * one packet.
+                */
+               ret = -1;
                goto end;
        }
 
+       empty_packet = (stream->events->len == 0);
+
        /* mmap the next packet */
        ctf_packet_seek(&stream->pos.parent, 0, SEEK_CUR);
 
@@ -932,30 +939,23 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
                        goto end;
                }
 
-               /* Write packet context */
-               memcpy(&packet_context_pos, &stream->pos,
-                       sizeof(struct ctf_stream_pos));
-               ret = bt_ctf_field_serialize(stream->packet_context,
-                       &stream->pos);
-               if (ret) {
-                       goto end;
-               }
-
                ret = bt_ctf_stream_get_discarded_events_count(stream,
                        &events_discarded);
                if (ret) {
                        goto end;
                }
 
-               /* Unset the packet context's fields. */
-               ret = bt_ctf_field_reset(stream->packet_context);
+               ret = set_structure_field_integer(stream->packet_context,
+                       "events_discarded", events_discarded);
                if (ret) {
                        goto end;
                }
 
-               /* Set the previous number of discarded events. */
-               ret = set_structure_field_integer(stream->packet_context,
-                       "events_discarded", events_discarded);
+               /* Write packet context */
+               memcpy(&packet_context_pos, &stream->pos,
+                       sizeof(struct ctf_stream_pos));
+               ret = bt_ctf_field_serialize(stream->packet_context,
+                       &stream->pos);
                if (ret) {
                        goto end;
                }
@@ -993,6 +993,11 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
                }
        }
 
+       /* Rounded-up in case content_size is not byte-aligned. */
+       packet_size_bits = (stream->pos.offset + (CHAR_BIT - 1)) &
+               ~(CHAR_BIT - 1);
+       stream->pos.packet_size = packet_size_bits;
+
        if (stream->packet_context) {
                /*
                 * Update the packet total size and content size and overwrite
@@ -1008,7 +1013,7 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
                }
 
                ret = set_structure_field_integer(stream->packet_context,
-                       "packet_size", stream->pos.packet_size);
+                       "packet_size", packet_size_bits);
                if (ret) {
                        goto end;
                }
@@ -1022,6 +1027,7 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
 
        g_ptr_array_set_size(stream->events, 0);
        stream->flushed_packet_count++;
+       stream->size += packet_size_bits / CHAR_BIT;
 end:
        bt_put(integer);
        return ret;
@@ -1044,8 +1050,24 @@ void bt_ctf_stream_destroy(struct bt_object *obj)
 
        stream = container_of(obj, struct bt_ctf_stream, base);
        ctf_fini_pos(&stream->pos);
-       if (stream->pos.fd >= 0 && close(stream->pos.fd)) {
-               perror("close");
+       if (stream->pos.fd >= 0) {
+               int ret;
+
+               /*
+                * Truncate the file's size to the minimum required to fit the
+                * last packet as we might have grown it too much on the last
+                * mmap.
+                */
+               do {
+                       ret = ftruncate(stream->pos.fd, stream->size);
+               } while (ret == -1 && errno == EINTR);
+               if (ret) {
+                       perror("ftruncate");
+               }
+
+               if (close(stream->pos.fd)) {
+                       perror("close");
+               }
        }
 
        if (stream->events) {