+static
+bool validate_notification(struct bt_notification_iterator *iterator,
+ struct bt_notification *notif,
+ struct bt_ctf_stream *notif_stream,
+ struct bt_ctf_packet *notif_packet)
+{
+ bool is_valid = true;
+ struct stream_state *stream_state;
+ struct bt_port *stream_comp_cur_port;
+
+ assert(notif_stream);
+ stream_comp_cur_port =
+ bt_ctf_stream_port_for_component(notif_stream,
+ iterator->upstream_component);
+ if (!stream_comp_cur_port) {
+ /*
+ * This is the first time this notification iterator
+ * bumps into this stream. Add an action to map the
+ * iterator's upstream component to the iterator's
+ * upstream port in this stream.
+ */
+ struct action action = {
+ .type = ACTION_TYPE_MAP_PORT_TO_COMP_IN_STREAM,
+ .payload.map_port_to_comp_in_stream = {
+ .stream = bt_get(notif_stream),
+ .component = bt_get(iterator->upstream_component),
+ .port = bt_get(iterator->upstream_port),
+ },
+ };
+
+ add_action(iterator, &action);
+ } else {
+ if (stream_comp_cur_port != iterator->upstream_port) {
+ /*
+ * It looks like two different ports of the same
+ * component are emitting notifications which
+ * have references to the same stream. This is
+ * bad: the API guarantees that it can never
+ * happen.
+ */
+ is_valid = false;
+ goto end;
+ }
+
+ }
+
+ stream_state = g_hash_table_lookup(iterator->stream_states,
+ notif_stream);
+ if (stream_state) {
+ if (stream_state->is_ended) {
+ /*
+ * There's a new notification which has a
+ * reference to a stream which, from this
+ * iterator's point of view, is ended ("end of
+ * stream" notification was returned). This is
+ * bad: the API guarantees that it can never
+ * happen.
+ */
+ is_valid = false;
+ goto end;
+ }
+
+ switch (notif->type) {
+ case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
+ /*
+ * We already have a stream state, which means
+ * we already returned a "stream begin"
+ * notification: this is an invalid duplicate.
+ */
+ is_valid = false;
+ goto end;
+ case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
+ if (notif_packet == stream_state->cur_packet) {
+ /* Duplicate "packet begin" notification */
+ is_valid = false;
+ goto end;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+end:
+ return is_valid;
+}
+
+static
+void add_action_push_notif(struct bt_notification_iterator *iterator,
+ struct bt_notification *notif)
+{
+ struct action action = {
+ .type = ACTION_TYPE_PUSH_NOTIF,
+ .payload.push_notif = {
+ .notif = bt_get(notif),
+ },
+ };
+
+ assert(notif);
+ add_action(iterator, &action);
+}
+
+static
+int add_action_push_notif_stream_begin(
+ struct bt_notification_iterator *iterator,
+ struct bt_ctf_stream *stream)
+{
+ int ret = 0;
+ struct bt_notification *stream_begin_notif = NULL;
+
+ assert(stream);
+ stream_begin_notif = bt_notification_stream_begin_create(stream);
+ if (!stream_begin_notif) {
+ goto error;
+ }
+
+ add_action_push_notif(iterator, stream_begin_notif);
+ goto end;
+
+error:
+ ret = -1;
+
+end:
+ bt_put(stream_begin_notif);
+ return ret;
+}
+
+static
+int add_action_push_notif_stream_end(
+ struct bt_notification_iterator *iterator,
+ struct bt_ctf_stream *stream)
+{
+ int ret = 0;
+ struct bt_notification *stream_end_notif = NULL;
+
+ assert(stream);
+ stream_end_notif = bt_notification_stream_end_create(stream);
+ if (!stream_end_notif) {
+ goto error;
+ }
+
+ add_action_push_notif(iterator, stream_end_notif);
+ goto end;
+
+error:
+ ret = -1;
+
+end:
+ bt_put(stream_end_notif);
+ return ret;
+}
+
+static
+int add_action_push_notif_packet_begin(
+ struct bt_notification_iterator *iterator,
+ struct bt_ctf_packet *packet)
+{
+ int ret = 0;
+ struct bt_notification *packet_begin_notif = NULL;
+
+ assert(packet);
+ packet_begin_notif = bt_notification_packet_begin_create(packet);
+ if (!packet_begin_notif) {
+ goto error;
+ }
+
+ add_action_push_notif(iterator, packet_begin_notif);
+ goto end;
+
+error:
+ ret = -1;
+
+end:
+ bt_put(packet_begin_notif);
+ return ret;
+}
+
+static
+int add_action_push_notif_packet_end(
+ struct bt_notification_iterator *iterator,
+ struct bt_ctf_packet *packet)
+{
+ int ret = 0;
+ struct bt_notification *packet_end_notif = NULL;
+
+ assert(packet);
+ packet_end_notif = bt_notification_packet_end_create(packet);
+ if (!packet_end_notif) {
+ goto error;
+ }
+
+ add_action_push_notif(iterator, packet_end_notif);
+ goto end;
+
+error:
+ ret = -1;
+
+end:
+ bt_put(packet_end_notif);
+ return ret;
+}
+
+static
+void add_action_set_stream_state_is_ended(
+ struct bt_notification_iterator *iterator,
+ struct stream_state *stream_state)
+{
+ struct action action = {
+ .type = ACTION_TYPE_SET_STREAM_STATE_IS_ENDED,
+ .payload.set_stream_state_is_ended = {
+ .stream_state = stream_state,
+ },
+ };
+
+ assert(stream_state);
+ add_action(iterator, &action);
+}
+
+static
+void add_action_set_stream_state_cur_packet(
+ struct bt_notification_iterator *iterator,
+ struct stream_state *stream_state,
+ struct bt_ctf_packet *packet)
+{
+ struct action action = {
+ .type = ACTION_TYPE_SET_STREAM_STATE_CUR_PACKET,
+ .payload.set_stream_state_cur_packet = {
+ .stream_state = stream_state,
+ .packet = bt_get(packet),
+ },
+ };
+
+ assert(stream_state);
+ add_action(iterator, &action);
+}
+
+static
+int ensure_stream_state_exists(struct bt_notification_iterator *iterator,
+ struct bt_notification *stream_begin_notif,
+ struct bt_ctf_stream *notif_stream,
+ struct stream_state **stream_state)
+{
+ int ret = 0;
+
+ if (!notif_stream) {
+ /*
+ * The notification does not reference any stream: no
+ * need to get or create a stream state.
+ */
+ goto end;
+ }
+
+ *stream_state = g_hash_table_lookup(iterator->stream_states,
+ notif_stream);
+ if (!*stream_state) {
+ /*
+ * This iterator did not bump into this stream yet:
+ * create a stream state and a "stream begin"
+ * notification.
+ */
+ struct action action = {
+ .type = ACTION_TYPE_ADD_STREAM_STATE,
+ .payload.add_stream_state = {
+ .stream = bt_get(notif_stream),
+ .stream_state = NULL,
+ },
+ };
+
+ *stream_state = create_stream_state(notif_stream);
+ if (!stream_state) {
+ goto error;
+ }
+
+ action.payload.add_stream_state.stream_state =
+ *stream_state;
+ add_action(iterator, &action);
+
+ if (stream_begin_notif) {
+ add_action_push_notif(iterator, stream_begin_notif);
+ } else {
+ ret = add_action_push_notif_stream_begin(iterator,
+ notif_stream);
+ if (ret) {
+ goto error;
+ }
+ }
+ }
+
+ goto end;
+
+error:
+ destroy_stream_state(*stream_state);
+ ret = -1;
+
+end:
+ return ret;
+}
+
+static
+int handle_packet_switch(struct bt_notification_iterator *iterator,
+ struct bt_notification *packet_begin_notif,
+ struct bt_ctf_packet *new_packet,
+ struct stream_state *stream_state)
+{
+ int ret = 0;
+
+ if (stream_state->cur_packet == new_packet) {
+ goto end;
+ }
+
+ if (stream_state->cur_packet) {
+ /* End of the current packet */
+ ret = add_action_push_notif_packet_end(iterator,
+ stream_state->cur_packet);
+ if (ret) {
+ goto error;
+ }
+ }
+
+ /* Beginning of the new packet */
+ if (packet_begin_notif) {
+ add_action_push_notif(iterator, packet_begin_notif);
+ } else if (new_packet) {
+ ret = add_action_push_notif_packet_begin(iterator,
+ new_packet);
+ if (ret) {
+ goto error;
+ }
+ }
+
+ add_action_set_stream_state_cur_packet(iterator, stream_state,
+ new_packet);
+ goto end;
+
+error:
+ ret = -1;
+
+end:
+ return ret;
+}
+
+static
+int handle_notif_stream_begin(
+ struct bt_notification_iterator *iterator,
+ struct bt_notification *notif,
+ struct bt_ctf_stream *notif_stream)
+{
+ int ret = 0;
+ struct stream_state *stream_state;
+
+ assert(notif->type == BT_NOTIFICATION_TYPE_STREAM_BEGIN);
+ assert(notif_stream);
+ ret = ensure_stream_state_exists(iterator, notif, notif_stream,
+ &stream_state);
+ if (ret) {
+ goto error;
+ }
+
+ goto end;
+
+error:
+ ret = -1;
+
+end:
+ return ret;
+}
+
+static
+int handle_notif_stream_end(
+ struct bt_notification_iterator *iterator,
+ struct bt_notification *notif,
+ struct bt_ctf_stream *notif_stream)
+{
+ int ret = 0;
+ struct stream_state *stream_state;
+
+ assert(notif->type == BT_NOTIFICATION_TYPE_STREAM_END);
+ assert(notif_stream);
+ ret = ensure_stream_state_exists(iterator, NULL, notif_stream,
+ &stream_state);
+ if (ret) {
+ goto error;
+ }
+
+ ret = handle_packet_switch(iterator, NULL, NULL, stream_state);
+ if (ret) {
+ goto error;
+ }
+
+ add_action_push_notif(iterator, notif);
+ add_action_set_stream_state_is_ended(iterator, stream_state);
+ goto end;
+
+error:
+ ret = -1;
+
+end:
+ return ret;
+}
+
+static
+int handle_notif_packet_begin(
+ struct bt_notification_iterator *iterator,
+ struct bt_notification *notif,
+ struct bt_ctf_stream *notif_stream,
+ struct bt_ctf_packet *notif_packet)
+{
+ int ret = 0;
+ struct stream_state *stream_state;
+
+ assert(notif->type == BT_NOTIFICATION_TYPE_PACKET_BEGIN);
+ assert(notif_packet);
+ ret = ensure_stream_state_exists(iterator, NULL, notif_stream,
+ &stream_state);
+ if (ret) {
+ goto error;
+ }
+
+ ret = handle_packet_switch(iterator, notif, notif_packet, stream_state);
+ if (ret) {
+ goto error;
+ }
+
+ goto end;
+
+error:
+ ret = -1;
+
+end:
+ return ret;
+}
+
+static
+int handle_notif_packet_end(
+ struct bt_notification_iterator *iterator,
+ struct bt_notification *notif,
+ struct bt_ctf_stream *notif_stream,
+ struct bt_ctf_packet *notif_packet)
+{
+ int ret = 0;
+ struct stream_state *stream_state;
+
+ assert(notif->type == BT_NOTIFICATION_TYPE_PACKET_END);
+ assert(notif_packet);
+ ret = ensure_stream_state_exists(iterator, NULL, notif_stream,
+ &stream_state);
+ if (ret) {
+ goto error;
+ }
+
+ ret = handle_packet_switch(iterator, NULL, notif_packet, stream_state);
+ if (ret) {
+ goto error;
+ }
+
+ /* End of the current packet */
+ add_action_push_notif(iterator, notif);
+ add_action_set_stream_state_cur_packet(iterator, stream_state, NULL);
+ goto end;
+
+error:
+ ret = -1;
+
+end:
+ return ret;
+}
+
+static
+int handle_notif_event(
+ struct bt_notification_iterator *iterator,
+ struct bt_notification *notif,
+ struct bt_ctf_stream *notif_stream,
+ struct bt_ctf_packet *notif_packet)
+{
+ int ret = 0;
+ struct stream_state *stream_state;
+
+ assert(notif->type == BT_NOTIFICATION_TYPE_EVENT);
+ assert(notif_packet);
+ ret = ensure_stream_state_exists(iterator, NULL, notif_stream,
+ &stream_state);
+ if (ret) {
+ goto error;
+ }
+
+ ret = handle_packet_switch(iterator, NULL, notif_packet, stream_state);
+ if (ret) {
+ goto error;
+ }
+
+ add_action_push_notif(iterator, notif);
+ goto end;
+
+error:
+ ret = -1;
+
+end:
+ return ret;
+}
+
+static
+int enqueue_notification_and_automatic(
+ struct bt_notification_iterator *iterator,
+ struct bt_notification *notif)
+{
+ int ret = 0;
+ struct bt_ctf_event *notif_event = NULL;
+ struct bt_ctf_stream *notif_stream = NULL;
+ struct bt_ctf_packet *notif_packet = NULL;
+
+ assert(notif);
+
+ /* Get the stream and packet referred by the notification */
+ switch (notif->type) {
+ case BT_NOTIFICATION_TYPE_EVENT:
+ notif_event = bt_notification_event_borrow_event(notif);
+ assert(notif_event);
+ notif_packet = bt_ctf_event_borrow_packet(notif_event);
+ assert(notif_packet);
+ break;
+ case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
+ notif_stream =
+ bt_notification_stream_begin_borrow_stream(notif);
+ assert(notif_stream);
+ break;
+ case BT_NOTIFICATION_TYPE_STREAM_END:
+ notif_stream = bt_notification_stream_end_borrow_stream(notif);
+ assert(notif_stream);
+ break;
+ case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
+ notif_packet =
+ bt_notification_packet_begin_borrow_packet(notif);
+ assert(notif_packet);
+ break;
+ case BT_NOTIFICATION_TYPE_PACKET_END:
+ notif_packet = bt_notification_packet_end_borrow_packet(notif);
+ assert(notif_packet);
+ break;
+ case BT_NOTIFICATION_TYPE_INACTIVITY:
+ /* Always valid */
+ break;
+ default:
+ /*
+ * Invalid type of notification. Only the notification
+ * types above are allowed to be returned by a user
+ * component.
+ */
+ goto error;
+ }
+
+ if (notif_packet) {
+ notif_stream = bt_ctf_packet_borrow_stream(notif_packet);
+ assert(notif_stream);
+ }
+
+ if (!notif_stream) {
+ /*
+ * The notification has no reference to a stream: it
+ * cannot cause the creation of automatic notifications.
+ */
+ goto end;
+ }
+
+ if (!validate_notification(iterator, notif, notif_stream,
+ notif_packet)) {
+ goto error;
+ }
+
+ switch (notif->type) {
+ case BT_NOTIFICATION_TYPE_EVENT:
+ ret = handle_notif_event(iterator, notif, notif_stream,
+ notif_packet);
+ break;
+ case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
+ ret = handle_notif_stream_begin(iterator, notif, notif_stream);
+ break;
+ case BT_NOTIFICATION_TYPE_STREAM_END:
+ ret = handle_notif_stream_end(iterator, notif, notif_stream);
+ break;
+ case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
+ ret = handle_notif_packet_begin(iterator, notif, notif_stream,
+ notif_packet);
+ break;
+ case BT_NOTIFICATION_TYPE_PACKET_END:
+ ret = handle_notif_packet_end(iterator, notif, notif_stream,
+ notif_packet);
+ break;
+ default:
+ break;
+ }
+
+ if (ret) {
+ goto error;
+ }
+
+ apply_actions(iterator);
+ goto end;
+
+error:
+ ret = -1;
+
+end:
+ return ret;
+}
+
+static
+int handle_end(struct bt_notification_iterator *iterator)
+{
+ GHashTableIter stream_state_iter;
+ gpointer stream_gptr, stream_state_gptr;
+ int ret = 0;
+
+ /*
+ * Emit a "stream end" notification for each non-ended stream
+ * known by this iterator and mark them as ended.
+ */
+ g_hash_table_iter_init(&stream_state_iter, iterator->stream_states);
+
+ while (g_hash_table_iter_next(&stream_state_iter, &stream_gptr,
+ &stream_state_gptr)) {
+ struct stream_state *stream_state = stream_state_gptr;
+
+ assert(stream_state_gptr);
+
+ if (stream_state->is_ended) {
+ continue;
+ }
+
+ ret = handle_packet_switch(iterator, NULL, NULL, stream_state);
+ if (ret) {
+ goto error;
+ }
+
+ ret = add_action_push_notif_stream_end(iterator, stream_gptr);
+ if (ret) {
+ goto error;
+ }
+
+ add_action_set_stream_state_is_ended(iterator, stream_state);
+ }
+
+ apply_actions(iterator);
+ goto end;
+
+error:
+ ret = -1;
+
+end:
+ return ret;
+}
+
+static
+enum bt_notification_iterator_status ensure_queue_has_notifications(
+ struct bt_notification_iterator *iterator)