ctf.fs: bt_ctf_notif_iter_create(): assert() that all medops exist

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

diff --git a/formats/ctf/ir/stream.c b/formats/ctf/ir/stream.c
index 4fe0589d00366a9e23be1a5a7c6e2ebb1e32fe4d..b4d234703e1bb27d7725bb7ab9530232e2847dc4 100644 (file)
--- a/formats/ctf/ir/stream.c
+++ b/formats/ctf/ir/stream.c
@@ -868,15 +868,32 @@ end:
        return ret;
 }
 
+static
+void reset_structure_field(struct bt_ctf_field *structure, const char *name)
+{
+       struct bt_ctf_field *member;
+
+       member = bt_ctf_field_structure_get_field(structure, name);
+       assert(member);
+       (void) bt_ctf_field_reset(member);
+       bt_put(member);
+}
+
 int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
 {
        int ret = 0;
        size_t i;
-       uint64_t timestamp_begin, timestamp_end, events_discarded;
+       uint64_t timestamp_begin, timestamp_end;
        struct bt_ctf_field *integer = NULL;
        struct ctf_stream_pos packet_context_pos;
        bool empty_packet;
        uint64_t packet_size_bits;
+       struct {
+               bool timestamp_begin;
+               bool timestamp_end;
+               bool content_size;
+               bool packet_size;
+       } auto_set_fields = { 0 };
 
        if (!stream || stream->pos.fd < 0) {
                /*
@@ -901,7 +918,6 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
 
        /* mmap the next packet */
        ctf_packet_seek(&stream->pos.parent, 0, SEEK_CUR);
-
        ret = bt_ctf_field_serialize(stream->packet_header, &stream->pos);
        if (ret) {
                goto end;
@@ -918,6 +934,7 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
                        if (ret < 0) {
                                goto end;
                        }
+                       auto_set_fields.timestamp_begin = ret == 1;
                }
 
                if (!empty_packet && !get_event_header_timestamp(
@@ -931,18 +948,21 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
                        if (ret < 0) {
                                goto end;
                        }
+                       auto_set_fields.timestamp_end = ret == 1;
                }
                ret = try_set_structure_field_integer(stream->packet_context,
                        "content_size", UINT64_MAX);
                if (ret < 0) {
                        goto end;
                }
+               auto_set_fields.content_size = ret == 1;
 
                ret = try_set_structure_field_integer(stream->packet_context,
                        "packet_size", UINT64_MAX);
                if (ret < 0) {
                        goto end;
                }
+               auto_set_fields.packet_size = ret == 1;
 
                /* Write packet context */
                memcpy(&packet_context_pos, &stream->pos,
@@ -958,11 +978,6 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
                struct bt_ctf_event *event = g_ptr_array_index(
                        stream->events, i);
 
-               ret = bt_ctf_field_reset(event->event_header);
-               if (ret) {
-                       goto end;
-               }
-
                /* Write event header */
                ret = bt_ctf_field_serialize(event->event_header,
                        &stream->pos);
@@ -999,16 +1014,21 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
                 * a packet is resized).
                 */
                packet_context_pos.base_mma = stream->pos.base_mma;
-               ret = set_structure_field_integer(stream->packet_context,
-                       "content_size", stream->pos.offset);
-               if (ret) {
-                       goto end;
+               if (auto_set_fields.content_size) {
+                       ret = set_structure_field_integer(
+                                       stream->packet_context,
+                                       "content_size", stream->pos.offset);
+                       if (ret < 0) {
+                               goto end;
+                       }
                }
 
-               ret = set_structure_field_integer(stream->packet_context,
-                       "packet_size", packet_size_bits);
-               if (ret) {
-                       goto end;
+               if (auto_set_fields.packet_size) {
+                       ret = set_structure_field_integer(stream->packet_context,
+                                       "packet_size", packet_size_bits);
+                       if (ret < 0) {
+                               goto end;
+                       }
                }
 
                ret = bt_ctf_field_serialize(stream->packet_context,
@@ -1022,7 +1042,34 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
        stream->flushed_packet_count++;
        stream->size += packet_size_bits / CHAR_BIT;
 end:
+       /* Reset automatically-set fields. */
+       if (auto_set_fields.timestamp_begin) {
+               reset_structure_field(stream->packet_context,
+                               "timestamp_begin");
+       }
+       if (auto_set_fields.timestamp_end) {
+               reset_structure_field(stream->packet_context,
+                               "timestamp_end");
+       }
+       if (auto_set_fields.packet_size) {
+               reset_structure_field(stream->packet_context,
+                               "packet_size");
+       }
+       if (auto_set_fields.content_size) {
+               reset_structure_field(stream->packet_context,
+                               "content_size");
+       }
        bt_put(integer);
+
+       if (ret < 0) {
+               /*
+                * We failed to write the packet. Its size is therefore set to 0
+                * to ensure the next mapping is done in the same place rather
+                * than advancing by "stream->pos.packet_size", which would
+                * leave a corrupted packet in the trace.
+                */
+               stream->pos.packet_size = 0;
+       }
        return ret;
 }