Fix: ctf: notif-iter.c: update_clock() uses the wrong FT sometimes

[babeltrace.git] / plugins / ctf / common / notif-iter / notif-iter.c

diff --git a/plugins/ctf/common/notif-iter/notif-iter.c b/plugins/ctf/common/notif-iter/notif-iter.c
index 823a753ff29fcff4539ebeff616410fe1204f969..f6fe230c6b84a9b3090589d3fa74a0320532f571 100644 (file)
--- a/plugins/ctf/common/notif-iter/notif-iter.c
+++ b/plugins/ctf/common/notif-iter/notif-iter.c
@@ -38,15 +38,16 @@
 #include <babeltrace/ctf-ir/stream.h>
 #include <babeltrace/ctf-ir/clock-class.h>
 #include <babeltrace/ctf-ir/event-class.h>
-#include <babeltrace/plugin/notification/packet.h>
-#include <babeltrace/plugin/notification/event.h>
-#include <babeltrace/plugin/notification/stream.h>
+#include <babeltrace/graph/notification-packet.h>
+#include <babeltrace/graph/notification-event.h>
+#include <babeltrace/graph/notification-stream.h>
+#include <babeltrace/graph/clock-class-priority-map.h>
 #include <babeltrace/ref.h>
 #include <glib.h>
 
 #define PRINT_ERR_STREAM       notit->err_stream
 #define PRINT_PREFIX           "ctf-notif-iter"
-#include "print.h"
+#include "../print.h"
 
 #include "notif-iter.h"
 #include "../btr/btr.h"
@@ -161,6 +162,9 @@ struct bt_ctf_notif_iter {
                struct bt_ctf_event_class *event_class;
        } meta;
 
+       /* Clock class priority map (owned by this) */
+       struct bt_clock_class_priority_map *cc_prio_map;
+
        /* Current packet (NULL if not created yet) */
        struct bt_ctf_packet *packet;
 
@@ -597,14 +601,14 @@ static inline
 bool is_struct_type(struct bt_ctf_field_type *field_type)
 {
        return bt_ctf_field_type_get_type_id(field_type) ==
-                       BT_CTF_TYPE_ID_STRUCT;
+                       BT_CTF_FIELD_TYPE_ID_STRUCT;
 }
 
 static inline
 bool is_variant_type(struct bt_ctf_field_type *field_type)
 {
        return bt_ctf_field_type_get_type_id(field_type) ==
-                       BT_CTF_TYPE_ID_VARIANT;
+                       BT_CTF_FIELD_TYPE_ID_VARIANT;
 }
 
 static
@@ -1408,17 +1412,17 @@ struct bt_ctf_field *get_next_field(struct bt_ctf_notif_iter *notit)
        }
 
        switch (bt_ctf_field_type_get_type_id(base_type)) {
-       case BT_CTF_TYPE_ID_STRUCT:
+       case BT_CTF_FIELD_TYPE_ID_STRUCT:
                next_field = bt_ctf_field_structure_get_field_by_index(
                        base_field, index);
                break;
-       case BT_CTF_TYPE_ID_ARRAY:
+       case BT_CTF_FIELD_TYPE_ID_ARRAY:
                next_field = bt_ctf_field_array_get_field(base_field, index);
                break;
-       case BT_CTF_TYPE_ID_SEQUENCE:
+       case BT_CTF_FIELD_TYPE_ID_SEQUENCE:
                next_field = bt_ctf_field_sequence_get_field(base_field, index);
                break;
-       case BT_CTF_TYPE_ID_VARIANT:
+       case BT_CTF_FIELD_TYPE_ID_VARIANT:
                next_field = bt_ctf_field_variant_get_current_field(base_field);
                break;
        default:
@@ -1487,18 +1491,23 @@ end:
 
 static
 enum bt_ctf_btr_status update_clock(struct bt_ctf_notif_iter *notit,
-               struct bt_ctf_field_type *int_field_type,
                struct bt_ctf_field *int_field)
 {
        gboolean clock_class_found;
        uint64_t *clock_state;
+       struct bt_ctf_field_type *int_field_type = NULL;
        enum bt_ctf_btr_status ret = BT_CTF_BTR_STATUS_OK;
-       struct bt_ctf_clock_class *clock_class =
-               bt_ctf_field_type_integer_get_mapped_clock_class(
-                       int_field_type);
+       struct bt_ctf_clock_class *clock_class = NULL;
 
+       int_field_type = bt_ctf_field_get_type(int_field);
+       if (unlikely(!int_field_type)) {
+               goto end;
+       }
+
+       clock_class = bt_ctf_field_type_integer_get_mapped_clock_class(
+               int_field_type);
        if (likely(!clock_class)) {
-               goto end_no_clock;
+               goto end;
        }
 
        clock_class_found = g_hash_table_lookup_extended(notit->clock_states,
@@ -1526,15 +1535,15 @@ enum bt_ctf_btr_status update_clock(struct bt_ctf_notif_iter *notit,
        /* Update the clock's state. */
        update_clock_state(clock_state, int_field);
 end:
+       bt_put(int_field_type);
        bt_put(clock_class);
-end_no_clock:
        return ret;
 }
 
 static
 enum bt_ctf_btr_status btr_unsigned_int_common(uint64_t value,
                struct bt_ctf_field_type *type, void *data,
-               struct bt_ctf_field **_field)
+               struct bt_ctf_field **out_int_field)
 {
        enum bt_ctf_btr_status status = BT_CTF_BTR_STATUS_OK;
        struct bt_ctf_field *field = NULL;
@@ -1551,12 +1560,12 @@ enum bt_ctf_btr_status btr_unsigned_int_common(uint64_t value,
        }
 
        switch(bt_ctf_field_type_get_type_id(type)) {
-       case BT_CTF_TYPE_ID_INTEGER:
+       case BT_CTF_FIELD_TYPE_ID_INTEGER:
                /* Integer field is created field */
                BT_MOVE(int_field, field);
                bt_get(type);
                break;
-       case BT_CTF_TYPE_ID_ENUM:
+       case BT_CTF_FIELD_TYPE_ID_ENUM:
                int_field = bt_ctf_field_enumeration_get_container(field);
                type = bt_ctf_field_get_type(int_field);
                break;
@@ -1575,7 +1584,7 @@ enum bt_ctf_btr_status btr_unsigned_int_common(uint64_t value,
        ret = bt_ctf_field_unsigned_integer_set_value(int_field, value);
        assert(!ret);
        stack_top(notit->stack)->index++;
-       *_field = int_field;
+       *out_int_field = int_field;
 
 end:
        BT_PUT(field);
@@ -1621,7 +1630,7 @@ enum bt_ctf_btr_status btr_unsigned_int_cb(uint64_t value,
                goto end;
        }
 
-       status = update_clock(notit, type, field);
+       status = update_clock(notit, field);
        BT_PUT(field);
 end:
        return status;
@@ -1646,12 +1655,12 @@ enum bt_ctf_btr_status btr_signed_int_cb(int64_t value,
        }
 
        switch(bt_ctf_field_type_get_type_id(type)) {
-       case BT_CTF_TYPE_ID_INTEGER:
+       case BT_CTF_FIELD_TYPE_ID_INTEGER:
                /* Integer field is created field */
                BT_MOVE(int_field, field);
                bt_get(type);
                break;
-       case BT_CTF_TYPE_ID_ENUM:
+       case BT_CTF_FIELD_TYPE_ID_ENUM:
                int_field = bt_ctf_field_enumeration_get_container(field);
                type = bt_ctf_field_get_type(int_field);
                break;
@@ -1670,7 +1679,7 @@ enum bt_ctf_btr_status btr_signed_int_cb(int64_t value,
        ret = bt_ctf_field_signed_integer_set_value(int_field, value);
        assert(!ret);
        stack_top(notit->stack)->index++;
-       status = update_clock(notit, type, int_field);
+       status = update_clock(notit, int_field);
 end:
        BT_PUT(field);
        BT_PUT(int_field);
@@ -2034,8 +2043,7 @@ int set_event_clocks(struct bt_ctf_event *event,
                        ret = -1;
                        goto end;
                }
-               ret = bt_ctf_event_set_clock_value(event, clock_class,
-                       clock_value);
+               ret = bt_ctf_event_set_clock_value(event, clock_value);
                bt_put(clock_value);
                if (ret) {
                        goto end;
@@ -2196,7 +2204,7 @@ void notify_event(struct bt_ctf_notif_iter *notit,
                goto end;
        }
 
-       ret = bt_notification_event_create(event);
+       ret = bt_notification_event_create(event, notit->cc_prio_map);
        if (!ret) {
                goto end;
        }
@@ -2304,6 +2312,7 @@ end:
 
 BT_HIDDEN
 struct bt_ctf_notif_iter *bt_ctf_notif_iter_create(struct bt_ctf_trace *trace,
+               struct bt_clock_class_priority_map *cc_prio_map,
                size_t max_request_sz,
                struct bt_ctf_notif_iter_medium_ops medops,
                void *data, FILE *err_stream)
@@ -2328,7 +2337,9 @@ struct bt_ctf_notif_iter *bt_ctf_notif_iter_create(struct bt_ctf_trace *trace,
        };
 
        assert(trace);
+       assert(cc_prio_map);
        assert(medops.request_bytes);
+       assert(medops.get_stream);
        notit = g_new0(struct bt_ctf_notif_iter, 1);
        if (!notit) {
                PERR("Failed to allocate memory for CTF notification iterator\n");
@@ -2345,6 +2356,7 @@ struct bt_ctf_notif_iter *bt_ctf_notif_iter_create(struct bt_ctf_trace *trace,
                PERR("Failed to initialize stream clock states\n");
                goto error;
        }
+       notit->cc_prio_map = bt_get(cc_prio_map);
        notit->meta.trace = bt_get(trace);
        notit->medium.medops = medops;
        notit->medium.max_request_sz = max_request_sz;
@@ -2388,6 +2400,7 @@ error:
 
 void bt_ctf_notif_iter_destroy(struct bt_ctf_notif_iter *notit)
 {
+       BT_PUT(notit->cc_prio_map);
        BT_PUT(notit->meta.trace);
        BT_PUT(notit->meta.stream_class);
        BT_PUT(notit->meta.event_class);
@@ -2461,8 +2474,8 @@ enum bt_ctf_notif_iter_status bt_ctf_notif_iter_get_next_notification(
                                                bt_ctf_field_get_type(
                                                        notit->cur_timestamp_end);
 
-                               btr_status = update_clock(notit, field_type,
-                                               notit->cur_timestamp_end);
+                               btr_status = update_clock(notit,
+                                       notit->cur_timestamp_end);
                                BT_PUT(field_type);
                                if (btr_status != BT_CTF_BTR_STATUS_OK) {
                                        status = BT_CTF_NOTIF_ITER_STATUS_ERROR;