+static
+struct bt_ctf_field *get_struct_field_uint(struct bt_ctf_field *struct_field,
+ const char *field_name)
+{
+ struct bt_ctf_field *field = NULL;
+ struct bt_ctf_field_type *ft = NULL;
+
+ field = bt_ctf_field_structure_get_field_by_name(struct_field,
+ field_name);
+ if (!field) {
+ BT_LOGV_STR("`%s` field does not exist.");
+ goto end;
+ }
+
+ if (!bt_ctf_field_is_integer(field)) {
+ BT_LOGV("Skipping `%s` field because its type is not an integer field type: "
+ "field-addr=%p, ft-addr=%p, ft-id=%s", field_name,
+ field, ft, bt_ctf_field_type_id_string(
+ bt_ctf_field_type_get_type_id(ft)));
+ BT_PUT(field);
+ goto end;
+ }
+
+ ft = bt_ctf_field_get_type(field);
+ assert(ft);
+
+ if (bt_ctf_field_type_integer_is_signed(ft)) {
+ BT_LOGV("Skipping `%s` integer field because its type is signed: "
+ "field-addr=%p, ft-addr=%p", field_name, field, ft);
+ BT_PUT(field);
+ goto end;
+ }
+
+end:
+ bt_put(ft);
+ return field;
+}
+
+static
+uint64_t get_packet_context_events_discarded(struct bt_ctf_packet *packet)
+{
+ struct bt_ctf_field *packet_context = NULL;
+ struct bt_ctf_field *field = NULL;
+ uint64_t retval = -1ULL;
+ int ret;
+
+ packet_context = bt_ctf_packet_get_context(packet);
+ if (!packet_context) {
+ goto end;
+ }
+
+ field = get_struct_field_uint(packet_context, "events_discarded");
+ if (!field) {
+ BT_LOGV("`events_discarded` field does not exist in packet's context field: "
+ "packet-addr=%p, packet-context-field-addr=%p",
+ packet, packet_context);
+ goto end;
+ }
+
+ assert(bt_ctf_field_is_integer(field));
+ ret = bt_ctf_field_unsigned_integer_get_value(field, &retval);
+ if (ret) {
+ BT_LOGV("Cannot get raw value of packet's context field's `events_discarded` integer field: "
+ "packet-addr=%p, field-addr=%p",
+ packet, field);
+ retval = -1ULL;
+ goto end;
+ }
+
+end:
+ bt_put(packet_context);
+ bt_put(field);
+ return retval;
+}
+
+static
+uint64_t get_packet_header_packet_seq_num(struct bt_ctf_packet *packet)
+{
+ struct bt_ctf_field *packet_header = NULL;
+ struct bt_ctf_field *field = NULL;
+ uint64_t retval = -1ULL;
+ int ret;
+
+ packet_header = bt_ctf_packet_get_header(packet);
+ if (!packet_header) {
+ goto end;
+ }
+
+ field = get_struct_field_uint(packet_header, "packet_seq_num");
+ if (!field) {
+ BT_LOGV("`packet_seq_num` field does not exist in packet's header field: "
+ "packet-addr=%p, packet-header-field-addr=%p",
+ packet, packet_header);
+ goto end;
+ }
+
+ assert(bt_ctf_field_is_integer(field));
+ ret = bt_ctf_field_unsigned_integer_get_value(field, &retval);
+ if (ret) {
+ BT_LOGV("Cannot get raw value of packet's header field's `packet_seq_num` integer field: "
+ "packet-addr=%p, field-addr=%p",
+ packet, field);
+ retval = -1ULL;
+ goto end;
+ }
+
+end:
+ bt_put(packet_header);
+ bt_put(field);
+ return retval;
+}
+
+static
+int handle_discarded_packets(struct bt_notification_iterator *iterator,
+ struct bt_ctf_packet *packet,
+ struct bt_ctf_clock_value *ts_begin,
+ struct bt_ctf_clock_value *ts_end,
+ struct stream_state *stream_state)
+{
+ struct bt_notification *notif = NULL;
+ uint64_t diff;
+ uint64_t next_count;
+ int ret = 0;
+
+ next_count = get_packet_header_packet_seq_num(packet);
+ if (next_count == -1ULL) {
+ next_count = stream_state->discarded_packets_state.cur_count;
+ goto update_state;
+ }
+
+ if (next_count < stream_state->discarded_packets_state.cur_count) {
+ BT_LOGW("Current value of packet's header field's `packet_seq_num` field is lesser than the previous value for the same stream: "
+ "not updating the stream state's current value: "
+ "packet-addr=%p, prev-count=%" PRIu64 ", "
+ "cur-count=%" PRIu64,
+ packet, stream_state->discarded_packets_state.cur_count,
+ next_count);
+ goto end;
+ }
+
+ diff = next_count - stream_state->discarded_packets_state.cur_count;
+ if (diff > 0) {
+ /*
+ * Add a discarded packets notification. The packets
+ * are considered to be lost betweem the state's last time
+ * and the current packet's beginning time.
+ */
+ notif = bt_notification_discarded_elements_create(
+ BT_NOTIFICATION_TYPE_DISCARDED_PACKETS,
+ stream_state->stream,
+ stream_state->discarded_packets_state.cur_begin,
+ ts_begin, diff);
+ if (!notif) {
+ BT_LOGE_STR("Cannot create discarded packets notification.");
+ ret = -1;
+ goto end;
+ }
+
+ add_action_push_notif(iterator, notif);
+ }
+
+update_state:
+ add_action_update_stream_state_discarded_elements(iterator,
+ ACTION_TYPE_UPDATE_STREAM_STATE_DISCARDED_PACKETS,
+ stream_state, ts_end, next_count);
+
+end:
+ bt_put(notif);
+ return ret;
+}
+
+static
+int handle_discarded_events(struct bt_notification_iterator *iterator,
+ struct bt_ctf_packet *packet,
+ struct bt_ctf_clock_value *ts_begin,
+ struct bt_ctf_clock_value *ts_end,
+ struct stream_state *stream_state)
+{
+ struct bt_notification *notif = NULL;
+ uint64_t diff;
+ uint64_t next_count;
+ int ret = 0;
+
+ next_count = get_packet_context_events_discarded(packet);
+ if (next_count == -1ULL) {
+ next_count = stream_state->discarded_events_state.cur_count;
+ goto update_state;
+ }
+
+ if (next_count < stream_state->discarded_events_state.cur_count) {
+ BT_LOGW("Current value of packet's context field's `events_discarded` field is lesser than the previous value for the same stream: "
+ "not updating the stream state's current value: "
+ "packet-addr=%p, prev-count=%" PRIu64 ", "
+ "cur-count=%" PRIu64,
+ packet, stream_state->discarded_events_state.cur_count,
+ next_count);
+ goto end;
+ }
+
+ diff = next_count - stream_state->discarded_events_state.cur_count;
+ if (diff > 0) {
+ /*
+ * Add a discarded events notification. The events are
+ * considered to be lost betweem the state's last time
+ * and the current packet's end time.
+ */
+ notif = bt_notification_discarded_elements_create(
+ BT_NOTIFICATION_TYPE_DISCARDED_EVENTS,
+ stream_state->stream,
+ stream_state->discarded_events_state.cur_begin,
+ ts_end, diff);
+ if (!notif) {
+ BT_LOGE_STR("Cannot create discarded events notification.");
+ ret = -1;
+ goto end;
+ }
+
+ add_action_push_notif(iterator, notif);
+ }
+
+update_state:
+ add_action_update_stream_state_discarded_elements(iterator,
+ ACTION_TYPE_UPDATE_STREAM_STATE_DISCARDED_EVENTS,
+ stream_state, ts_end, next_count);
+
+end:
+ bt_put(notif);
+ return ret;
+}
+
+static
+int get_field_clock_value(struct bt_ctf_field *root_field,
+ const char *field_name,
+ struct bt_ctf_clock_value **user_clock_val)
+{
+ struct bt_ctf_field *field;
+ struct bt_ctf_field_type *ft = NULL;
+ struct bt_ctf_clock_class *clock_class = NULL;
+ struct bt_ctf_clock_value *clock_value = NULL;
+ uint64_t val;
+ int ret = 0;
+
+ field = get_struct_field_uint(root_field, field_name);
+ if (!field) {
+ /* Not an error: skip this */
+ goto end;
+ }
+
+ ft = bt_ctf_field_get_type(field);
+ assert(ft);
+ clock_class = bt_ctf_field_type_integer_get_mapped_clock_class(ft);
+ if (!clock_class) {
+ BT_LOGW("Integer field type has no mapped clock class but it's expected to have one: "
+ "ft-addr=%p", ft);
+ ret = -1;
+ goto end;
+ }
+
+ ret = bt_ctf_field_unsigned_integer_get_value(field, &val);
+ if (ret) {
+ BT_LOGW("Cannot get integer field's raw value: "
+ "field-addr=%p", field);
+ ret = -1;
+ goto end;
+ }
+
+ clock_value = bt_ctf_clock_value_create(clock_class, val);
+ if (!clock_value) {
+ BT_LOGE_STR("Cannot create clock value from clock class.");
+ ret = -1;
+ goto end;
+ }
+
+ /* Move clock value to user */
+ *user_clock_val = clock_value;
+ clock_value = NULL;
+
+end:
+ bt_put(field);
+ bt_put(ft);
+ bt_put(clock_class);
+ bt_put(clock_value);
+ return ret;
+}
+
+static
+int get_ts_begin_ts_end_from_packet(struct bt_ctf_packet *packet,
+ struct bt_ctf_clock_value **user_ts_begin,
+ struct bt_ctf_clock_value **user_ts_end)
+{
+ struct bt_ctf_field *packet_context = NULL;
+ struct bt_ctf_clock_value *ts_begin = NULL;
+ struct bt_ctf_clock_value *ts_end = NULL;
+ int ret = 0;
+
+ packet_context = bt_ctf_packet_get_context(packet);
+ if (!packet_context) {
+ goto end;
+ }
+
+ ret = get_field_clock_value(packet_context, "timestamp_begin",
+ &ts_begin);
+ if (ret) {
+ BT_LOGW("Cannot create clock value for packet context's `timestamp_begin` field: "
+ "packet-addr=%p, packet-context-field-addr=%p",
+ packet, packet_context);
+ goto end;
+ }
+
+ ret = get_field_clock_value(packet_context, "timestamp_end",
+ &ts_end);
+ if (ret) {
+ BT_LOGW("Cannot create clock value for packet context's `timestamp_begin` field: "
+ "packet-addr=%p, packet-context-field-addr=%p",
+ packet, packet_context);
+ goto end;
+ }
+
+ /* Move clock values to user */
+ *user_ts_begin = ts_begin;
+ ts_begin = NULL;
+ *user_ts_end = ts_end;
+ ts_end = NULL;
+
+end:
+ bt_put(packet_context);
+ bt_put(ts_begin);
+ bt_put(ts_end);
+ return ret;
+}
+
+static
+int handle_discarded_elements(struct bt_notification_iterator *iterator,
+ struct bt_ctf_packet *packet, struct stream_state *stream_state)
+{
+ struct bt_ctf_clock_value *ts_begin = NULL;
+ struct bt_ctf_clock_value *ts_end = NULL;
+ int ret;
+
+ ret = get_ts_begin_ts_end_from_packet(packet, &ts_begin, &ts_end);
+ if (ret) {
+ BT_LOGW("Cannot get packet's beginning or end clock values: "
+ "packet-addr=%p, ret=%d", packet, ret);
+ ret = -1;
+ goto end;
+ }
+
+ ret = handle_discarded_packets(iterator, packet, ts_begin, ts_end,
+ stream_state);
+ if (ret) {
+ BT_LOGW("Cannot handle discarded packets for packet: "
+ "packet-addr=%p, ret=%d", packet, ret);
+ ret = -1;
+ goto end;
+ }
+
+ ret = handle_discarded_events(iterator, packet, ts_begin, ts_end,
+ stream_state);
+ if (ret) {
+ BT_LOGW("Cannot handle discarded events for packet: "
+ "packet-addr=%p, ret=%d", packet, ret);
+ ret = -1;
+ goto end;
+ }
+
+end:
+ bt_put(ts_begin);
+ bt_put(ts_end);
+ return ret;
+}
+