2 * Copyright 2017 Philippe Proulx <pproulx@efficios.com>
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 #include <babeltrace/babeltrace-internal.h>
24 #include <babeltrace/ctf-ir/clock-class.h>
25 #include <babeltrace/ctf-ir/event.h>
26 #include <babeltrace/graph/clock-class-priority-map.h>
27 #include <babeltrace/graph/component-filter.h>
28 #include <babeltrace/graph/component.h>
29 #include <babeltrace/graph/notification-event.h>
30 #include <babeltrace/graph/notification-inactivity.h>
31 #include <babeltrace/graph/notification-iterator.h>
32 #include <babeltrace/graph/notification.h>
33 #include <babeltrace/graph/port.h>
34 #include <babeltrace/graph/private-component-filter.h>
35 #include <babeltrace/graph/private-component.h>
36 #include <babeltrace/graph/private-component.h>
37 #include <babeltrace/graph/private-connection.h>
38 #include <babeltrace/graph/private-notification-iterator.h>
39 #include <babeltrace/graph/private-port.h>
40 #include <plugins-common.h>
45 #define IGNORE_ABSOLUTE_PARAM_NAME "ignore-absolute"
48 /* Array of struct bt_private_notification_iterator * (weak refs) */
49 GPtrArray
*muxer_notif_iters
;
52 struct bt_private_component
*priv_comp
;
53 unsigned int next_port_num
;
54 size_t available_input_ports
;
56 bool initializing_muxer_notif_iter
;
60 struct muxer_upstream_notif_iter
{
61 /* Owned by this, NULL if ended */
62 struct bt_notification_iterator
*notif_iter
;
65 struct bt_private_port
*priv_port
;
68 * This flag is true if the upstream notification iterator's
69 * current notification must be considered for the multiplexing
70 * operations. If the upstream iterator returns
71 * BT_NOTIFICATION_ITERATOR_STATUS_AGAIN, then this object
72 * is considered invalid, because its current notification is
73 * still the previous one, but we already took it into account.
75 * The value of this flag is not important if notif_iter above
76 * is NULL (which means the upstream iterator is finished).
81 struct muxer_notif_iter
{
83 * Array of struct muxer_upstream_notif_iter * (owned by this).
85 * NOTE: This array is searched in linearly to find the youngest
86 * current notification. Keep this until benchmarks confirm that
87 * another data structure is faster than this for our typical
90 GPtrArray
*muxer_upstream_notif_iters
;
93 * List of "recently" connected input ports (owned by this) to
94 * handle by this muxer notification iterator.
95 * muxer_port_connected() adds entries to this list, and the
96 * entries are removed when a notification iterator is created
97 * on the port's connection and put into
98 * muxer_upstream_notif_iters above by
99 * muxer_notif_iter_handle_newly_connected_ports().
101 GList
*newly_connected_priv_ports
;
103 /* Next thing to return by the "next" method */
104 struct bt_notification_iterator_next_return next_next_return
;
106 /* Last time returned in a notification */
107 int64_t last_returned_ts_ns
;
111 void destroy_muxer_upstream_notif_iter(
112 struct muxer_upstream_notif_iter
*muxer_upstream_notif_iter
)
114 if (!muxer_upstream_notif_iter
) {
118 bt_put(muxer_upstream_notif_iter
->notif_iter
);
119 bt_put(muxer_upstream_notif_iter
->priv_port
);
120 g_free(muxer_upstream_notif_iter
);
124 struct muxer_upstream_notif_iter
*muxer_notif_iter_add_upstream_notif_iter(
125 struct muxer_notif_iter
*muxer_notif_iter
,
126 struct bt_notification_iterator
*notif_iter
,
127 struct bt_private_port
*priv_port
)
129 struct muxer_upstream_notif_iter
*muxer_upstream_notif_iter
=
130 g_new0(struct muxer_upstream_notif_iter
, 1);
132 if (!muxer_upstream_notif_iter
) {
136 muxer_upstream_notif_iter
->notif_iter
= bt_get(notif_iter
);
137 muxer_upstream_notif_iter
->priv_port
= bt_get(priv_port
);
138 muxer_upstream_notif_iter
->is_valid
= false;
139 g_ptr_array_add(muxer_notif_iter
->muxer_upstream_notif_iters
,
140 muxer_upstream_notif_iter
);
143 return muxer_upstream_notif_iter
;
147 int ensure_available_input_port(struct bt_private_component
*priv_comp
)
149 struct muxer_comp
*muxer_comp
=
150 bt_private_component_get_user_data(priv_comp
);
152 GString
*port_name
= NULL
;
153 void *priv_port
= NULL
;
157 if (muxer_comp
->available_input_ports
>= 1) {
161 port_name
= g_string_new("in");
167 g_string_append_printf(port_name
, "%u", muxer_comp
->next_port_num
);
168 priv_port
= bt_private_component_filter_add_input_private_port(
169 priv_comp
, port_name
->str
, NULL
);
175 muxer_comp
->available_input_ports
++;
176 muxer_comp
->next_port_num
++;
180 g_string_free(port_name
, TRUE
);
188 int create_output_port(struct bt_private_component
*priv_comp
)
193 priv_port
= bt_private_component_filter_add_output_private_port(
194 priv_comp
, "out", NULL
);
204 void destroy_muxer_comp(struct muxer_comp
*muxer_comp
)
210 if (muxer_comp
->muxer_notif_iters
) {
211 g_ptr_array_free(muxer_comp
->muxer_notif_iters
, TRUE
);
218 struct bt_value
*get_default_params(void)
220 struct bt_value
*params
;
223 params
= bt_value_map_create();
228 ret
= bt_value_map_insert_bool(params
, IGNORE_ABSOLUTE_PARAM_NAME
,
244 int configure_muxer_comp(struct muxer_comp
*muxer_comp
, struct bt_value
*params
)
246 struct bt_value
*default_params
= NULL
;
247 struct bt_value
*real_params
= NULL
;
248 struct bt_value
*ignore_absolute
= NULL
;
252 default_params
= get_default_params();
253 if (!default_params
) {
257 real_params
= bt_value_map_extend(default_params
, params
);
262 ignore_absolute
= bt_value_map_get(real_params
,
263 IGNORE_ABSOLUTE_PARAM_NAME
);
264 if (!bt_value_is_bool(ignore_absolute
)) {
268 if (bt_value_bool_get(ignore_absolute
, &bool_val
)) {
272 muxer_comp
->ignore_absolute
= (bool) bool_val
;
280 bt_put(default_params
);
282 bt_put(ignore_absolute
);
287 enum bt_component_status
muxer_init(
288 struct bt_private_component
*priv_comp
,
289 struct bt_value
*params
, void *init_data
)
292 enum bt_component_status status
= BT_COMPONENT_STATUS_OK
;
293 struct muxer_comp
*muxer_comp
= g_new0(struct muxer_comp
, 1);
299 ret
= configure_muxer_comp(muxer_comp
, params
);
304 muxer_comp
->muxer_notif_iters
= g_ptr_array_new();
305 if (!muxer_comp
->muxer_notif_iters
) {
309 muxer_comp
->priv_comp
= priv_comp
;
310 ret
= bt_private_component_set_user_data(priv_comp
, muxer_comp
);
312 ret
= ensure_available_input_port(priv_comp
);
317 ret
= create_output_port(priv_comp
);
325 destroy_muxer_comp(muxer_comp
);
326 ret
= bt_private_component_set_user_data(priv_comp
, NULL
);
328 status
= BT_COMPONENT_STATUS_ERROR
;
335 void muxer_finalize(struct bt_private_component
*priv_comp
)
337 struct muxer_comp
*muxer_comp
=
338 bt_private_component_get_user_data(priv_comp
);
340 destroy_muxer_comp(muxer_comp
);
344 struct bt_notification_iterator
*create_notif_iter_on_input_port(
345 struct bt_private_port
*priv_port
, int *ret
)
347 struct bt_port
*port
= bt_port_from_private_port(priv_port
);
348 struct bt_notification_iterator
*notif_iter
= NULL
;
349 struct bt_private_connection
*priv_conn
= NULL
;
355 assert(bt_port_is_connected(port
));
356 priv_conn
= bt_private_port_get_private_connection(priv_port
);
362 // TODO: Advance the iterator to >= the time of the latest
363 // returned notification by the muxer notification
364 // iterator which creates it.
365 notif_iter
= bt_private_connection_create_notification_iterator(
379 enum bt_notification_iterator_status
muxer_upstream_notif_iter_next(
380 struct muxer_upstream_notif_iter
*muxer_upstream_notif_iter
)
382 enum bt_notification_iterator_status status
;
384 status
= bt_notification_iterator_next(
385 muxer_upstream_notif_iter
->notif_iter
);
388 case BT_NOTIFICATION_ITERATOR_STATUS_OK
:
390 * Notification iterator's current notification is valid:
391 * it must be considered for muxing operations.
393 muxer_upstream_notif_iter
->is_valid
= true;
395 case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
:
397 * Notification iterator's current notification is not
398 * valid anymore. Return
399 * BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
402 muxer_upstream_notif_iter
->is_valid
= false;
404 case BT_NOTIFICATION_ITERATOR_STATUS_END
:
406 * Notification iterator reached the end: release it. It
407 * won't be considered again to find the youngest
410 BT_PUT(muxer_upstream_notif_iter
->notif_iter
);
411 muxer_upstream_notif_iter
->is_valid
= false;
412 status
= BT_NOTIFICATION_ITERATOR_STATUS_OK
;
415 /* Error or unsupported status code */
416 status
= BT_NOTIFICATION_ITERATOR_STATUS_ERROR
;
424 int muxer_notif_iter_handle_newly_connected_ports(
425 struct muxer_notif_iter
*muxer_notif_iter
)
430 * Here we create one upstream notification iterator for each
431 * newly connected port. We do not perform an initial "next" on
432 * those new upstream notification iterators: they are
433 * invalidated, to be validated later. The list of newly
434 * connected ports to handle here is updated by
435 * muxer_port_connected().
438 GList
*node
= muxer_notif_iter
->newly_connected_priv_ports
;
439 struct bt_private_port
*priv_port
;
440 struct bt_port
*port
;
441 struct bt_notification_iterator
*upstream_notif_iter
= NULL
;
442 struct muxer_upstream_notif_iter
*muxer_upstream_notif_iter
;
448 priv_port
= node
->data
;
449 port
= bt_port_from_private_port(priv_port
);
452 if (!bt_port_is_connected(port
)) {
454 * Looks like this port is not connected
455 * anymore: we can't create an upstream
456 * notification iterator on its (non-existing)
457 * connection in this case.
463 upstream_notif_iter
= create_notif_iter_on_input_port(priv_port
,
466 assert(!upstream_notif_iter
);
471 muxer_upstream_notif_iter
=
472 muxer_notif_iter_add_upstream_notif_iter(
473 muxer_notif_iter
, upstream_notif_iter
,
476 BT_PUT(upstream_notif_iter
);
477 if (!muxer_upstream_notif_iter
) {
482 bt_put(upstream_notif_iter
);
485 muxer_notif_iter
->newly_connected_priv_ports
=
487 muxer_notif_iter
->newly_connected_priv_ports
,
503 int get_notif_ts_ns(struct muxer_comp
*muxer_comp
,
504 struct bt_notification
*notif
, int64_t last_returned_ts_ns
,
507 struct bt_clock_class_priority_map
*cc_prio_map
= NULL
;
508 struct bt_ctf_clock_class
*clock_class
= NULL
;
509 struct bt_ctf_clock_value
*clock_value
= NULL
;
510 struct bt_ctf_event
*event
= NULL
;
516 switch (bt_notification_get_type(notif
)) {
517 case BT_NOTIFICATION_TYPE_EVENT
:
519 bt_notification_event_get_clock_class_priority_map(
523 case BT_NOTIFICATION_TYPE_INACTIVITY
:
525 bt_notification_inactivity_get_clock_class_priority_map(
529 /* All the other notifications have a higher priority */
530 *ts_ns
= last_returned_ts_ns
;
539 * If the clock class priority map is empty, then we consider
540 * that this notification has no time. In this case it's always
543 if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map
) == 0) {
544 *ts_ns
= last_returned_ts_ns
;
549 bt_clock_class_priority_map_get_highest_priority_clock_class(
555 if (!muxer_comp
->ignore_absolute
&&
556 !bt_ctf_clock_class_is_absolute(clock_class
)) {
560 switch (bt_notification_get_type(notif
)) {
561 case BT_NOTIFICATION_TYPE_EVENT
:
562 event
= bt_notification_event_get_event(notif
);
564 clock_value
= bt_ctf_event_get_clock_value(event
,
567 case BT_NOTIFICATION_TYPE_INACTIVITY
:
568 clock_value
= bt_notification_inactivity_get_clock_value(
579 ret
= bt_ctf_clock_value_get_value_ns_from_epoch(clock_value
, ts_ns
);
598 * This function finds the youngest available notification amongst the
599 * non-ended upstream notification iterators and returns the upstream
600 * notification iterator which has it, or
601 * BT_NOTIFICATION_ITERATOR_STATUS_END if there's no available
604 * This function does NOT:
606 * * Update any upstream notification iterator.
607 * * Check for newly connected ports.
608 * * Check the upstream notification iterators to retry.
610 * On sucess, this function sets *muxer_upstream_notif_iter to the
611 * upstream notification iterator of which the current notification is
612 * the youngest, and sets *ts_ns to its time.
615 enum bt_notification_iterator_status
616 muxer_notif_iter_youngest_upstream_notif_iter(
617 struct muxer_comp
*muxer_comp
,
618 struct muxer_notif_iter
*muxer_notif_iter
,
619 struct muxer_upstream_notif_iter
**muxer_upstream_notif_iter
,
624 int64_t youngest_ts_ns
= INT64_MAX
;
625 enum bt_notification_iterator_status status
=
626 BT_NOTIFICATION_ITERATOR_STATUS_OK
;
629 assert(muxer_notif_iter
);
630 assert(muxer_upstream_notif_iter
);
631 *muxer_upstream_notif_iter
= NULL
;
633 for (i
= 0; i
< muxer_notif_iter
->muxer_upstream_notif_iters
->len
; i
++) {
634 struct bt_notification
*notif
;
635 struct muxer_upstream_notif_iter
*cur_muxer_upstream_notif_iter
=
636 g_ptr_array_index(muxer_notif_iter
->muxer_upstream_notif_iters
, i
);
639 if (!cur_muxer_upstream_notif_iter
->notif_iter
) {
640 /* This upstream notification iterator is ended */
644 assert(cur_muxer_upstream_notif_iter
->is_valid
);
645 notif
= bt_notification_iterator_get_notification(
646 cur_muxer_upstream_notif_iter
->notif_iter
);
648 ret
= get_notif_ts_ns(muxer_comp
, notif
,
649 muxer_notif_iter
->last_returned_ts_ns
, ¬if_ts_ns
);
652 *muxer_upstream_notif_iter
= NULL
;
653 status
= BT_NOTIFICATION_ITERATOR_STATUS_ERROR
;
657 if (notif_ts_ns
<= youngest_ts_ns
) {
658 *muxer_upstream_notif_iter
=
659 cur_muxer_upstream_notif_iter
;
660 youngest_ts_ns
= notif_ts_ns
;
661 *ts_ns
= youngest_ts_ns
;
665 if (!*muxer_upstream_notif_iter
) {
666 status
= BT_NOTIFICATION_ITERATOR_STATUS_END
;
675 enum bt_notification_iterator_status
validate_muxer_upstream_notif_iter(
676 struct muxer_upstream_notif_iter
*muxer_upstream_notif_iter
)
678 enum bt_notification_iterator_status status
=
679 BT_NOTIFICATION_ITERATOR_STATUS_OK
;
681 if (muxer_upstream_notif_iter
->is_valid
||
682 !muxer_upstream_notif_iter
->notif_iter
) {
686 status
= muxer_upstream_notif_iter_next(muxer_upstream_notif_iter
);
693 enum bt_notification_iterator_status
validate_muxer_upstream_notif_iters(
694 struct muxer_notif_iter
*muxer_notif_iter
)
696 enum bt_notification_iterator_status status
=
697 BT_NOTIFICATION_ITERATOR_STATUS_OK
;
700 for (i
= 0; i
< muxer_notif_iter
->muxer_upstream_notif_iters
->len
; i
++) {
701 struct muxer_upstream_notif_iter
*muxer_upstream_notif_iter
=
703 muxer_notif_iter
->muxer_upstream_notif_iters
,
706 status
= validate_muxer_upstream_notif_iter(
707 muxer_upstream_notif_iter
);
708 if (status
!= BT_NOTIFICATION_ITERATOR_STATUS_OK
) {
718 struct bt_notification_iterator_next_return
muxer_notif_iter_do_next(
719 struct muxer_comp
*muxer_comp
,
720 struct muxer_notif_iter
*muxer_notif_iter
)
722 struct muxer_upstream_notif_iter
*muxer_upstream_notif_iter
= NULL
;
723 struct bt_notification_iterator_next_return next_return
= {
724 .notification
= NULL
,
725 .status
= BT_NOTIFICATION_ITERATOR_STATUS_OK
,
727 int64_t next_return_ts
;
730 int ret
= muxer_notif_iter_handle_newly_connected_ports(
735 BT_NOTIFICATION_ITERATOR_STATUS_ERROR
;
740 validate_muxer_upstream_notif_iters(muxer_notif_iter
);
741 if (next_return
.status
!= BT_NOTIFICATION_ITERATOR_STATUS_OK
) {
746 * At this point, we know that all the existing upstream
747 * notification iterators are valid. However the
748 * operations to validate them (during
749 * validate_muxer_upstream_notif_iters()) may have
750 * connected new ports. If no ports were connected
751 * during this operation, exit the loop.
753 if (!muxer_notif_iter
->newly_connected_priv_ports
) {
758 assert(!muxer_notif_iter
->newly_connected_priv_ports
);
761 * At this point we know that all the existing upstream
762 * notification iterators are valid. We can find the one,
763 * amongst those, of which the current notification is the
767 muxer_notif_iter_youngest_upstream_notif_iter(muxer_comp
,
768 muxer_notif_iter
, &muxer_upstream_notif_iter
,
770 if (next_return
.status
< 0 ||
771 next_return
.status
== BT_NOTIFICATION_ITERATOR_STATUS_END
) {
775 if (next_return_ts
< muxer_notif_iter
->last_returned_ts_ns
) {
776 next_return
.status
= BT_NOTIFICATION_ITERATOR_STATUS_ERROR
;
780 assert(next_return
.status
== BT_NOTIFICATION_ITERATOR_STATUS_OK
);
781 assert(muxer_upstream_notif_iter
);
782 next_return
.notification
= bt_notification_iterator_get_notification(
783 muxer_upstream_notif_iter
->notif_iter
);
784 assert(next_return
.notification
);
787 * We invalidate the upstream notification iterator so that, the
788 * next time this function is called,
789 * validate_muxer_upstream_notif_iters() will make it valid.
791 muxer_upstream_notif_iter
->is_valid
= false;
792 muxer_notif_iter
->last_returned_ts_ns
= next_return_ts
;
799 void destroy_muxer_notif_iter(struct muxer_notif_iter
*muxer_notif_iter
)
803 if (!muxer_notif_iter
) {
807 if (muxer_notif_iter
->muxer_upstream_notif_iters
) {
809 muxer_notif_iter
->muxer_upstream_notif_iters
, TRUE
);
812 for (node
= muxer_notif_iter
->newly_connected_priv_ports
;
813 node
; node
= g_list_next(node
)) {
817 g_list_free(muxer_notif_iter
->newly_connected_priv_ports
);
818 g_free(muxer_notif_iter
);
822 int muxer_notif_iter_init_newly_connected_ports(struct muxer_comp
*muxer_comp
,
823 struct muxer_notif_iter
*muxer_notif_iter
)
825 struct bt_component
*comp
;
831 * Add the connected input ports to this muxer notification
832 * iterator's list of newly connected ports. They will be
833 * handled by muxer_notif_iter_handle_newly_connected_ports().
835 comp
= bt_component_from_private_component(muxer_comp
->priv_comp
);
837 count
= bt_component_filter_get_input_port_count(comp
);
842 for (i
= 0; i
< count
; i
++) {
843 struct bt_private_port
*priv_port
=
844 bt_private_component_filter_get_input_private_port_by_index(
845 muxer_comp
->priv_comp
, i
);
846 struct bt_port
*port
;
849 port
= bt_port_from_private_port(priv_port
);
852 if (!bt_port_is_connected(port
)) {
859 muxer_notif_iter
->newly_connected_priv_ports
=
861 muxer_notif_iter
->newly_connected_priv_ports
,
863 if (!muxer_notif_iter
->newly_connected_priv_ports
) {
876 enum bt_notification_iterator_status
muxer_notif_iter_init(
877 struct bt_private_notification_iterator
*priv_notif_iter
,
878 struct bt_private_port
*output_priv_port
)
880 struct muxer_comp
*muxer_comp
= NULL
;
881 struct muxer_notif_iter
*muxer_notif_iter
= NULL
;
882 struct bt_private_component
*priv_comp
= NULL
;
883 enum bt_notification_iterator_status status
=
884 BT_NOTIFICATION_ITERATOR_STATUS_OK
;
887 priv_comp
= bt_private_notification_iterator_get_private_component(
890 muxer_comp
= bt_private_component_get_user_data(priv_comp
);
893 if (muxer_comp
->initializing_muxer_notif_iter
) {
895 * Weird, unhandled situation detected: downstream
896 * creates a muxer notification iterator while creating
897 * another muxer notification iterator (same component).
902 muxer_comp
->initializing_muxer_notif_iter
= true;
903 muxer_notif_iter
= g_new0(struct muxer_notif_iter
, 1);
904 if (!muxer_notif_iter
) {
908 muxer_notif_iter
->last_returned_ts_ns
= INT64_MIN
;
909 muxer_notif_iter
->muxer_upstream_notif_iters
=
910 g_ptr_array_new_with_free_func(
911 (GDestroyNotify
) destroy_muxer_upstream_notif_iter
);
912 if (!muxer_notif_iter
->muxer_upstream_notif_iters
) {
917 * Add the muxer notification iterator to the component's array
918 * of muxer notification iterators here because
919 * muxer_notif_iter_init_newly_connected_ports() can cause
920 * muxer_port_connected() to be called, which adds the newly
921 * connected port to each muxer notification iterator's list of
922 * newly connected ports.
924 g_ptr_array_add(muxer_comp
->muxer_notif_iters
, muxer_notif_iter
);
925 ret
= muxer_notif_iter_init_newly_connected_ports(muxer_comp
,
931 ret
= bt_private_notification_iterator_set_user_data(priv_notif_iter
,
937 if (g_ptr_array_index(muxer_comp
->muxer_notif_iters
,
938 muxer_comp
->muxer_notif_iters
->len
- 1) == muxer_notif_iter
) {
939 g_ptr_array_remove_index(muxer_comp
->muxer_notif_iters
,
940 muxer_comp
->muxer_notif_iters
->len
- 1);
943 destroy_muxer_notif_iter(muxer_notif_iter
);
944 ret
= bt_private_notification_iterator_set_user_data(priv_notif_iter
,
947 status
= BT_NOTIFICATION_ITERATOR_STATUS_ERROR
;
950 muxer_comp
->initializing_muxer_notif_iter
= false;
956 void muxer_notif_iter_finalize(
957 struct bt_private_notification_iterator
*priv_notif_iter
)
959 struct muxer_notif_iter
*muxer_notif_iter
=
960 bt_private_notification_iterator_get_user_data(priv_notif_iter
);
961 struct bt_private_component
*priv_comp
= NULL
;
962 struct muxer_comp
*muxer_comp
= NULL
;
964 priv_comp
= bt_private_notification_iterator_get_private_component(
967 muxer_comp
= bt_private_component_get_user_data(priv_comp
);
970 (void) g_ptr_array_remove_fast(muxer_comp
->muxer_notif_iters
,
972 destroy_muxer_notif_iter(muxer_notif_iter
);
979 struct bt_notification_iterator_next_return
muxer_notif_iter_next(
980 struct bt_private_notification_iterator
*priv_notif_iter
)
982 struct bt_notification_iterator_next_return next_ret
;
983 struct muxer_notif_iter
*muxer_notif_iter
=
984 bt_private_notification_iterator_get_user_data(priv_notif_iter
);
985 struct bt_private_component
*priv_comp
= NULL
;
986 struct muxer_comp
*muxer_comp
= NULL
;
988 assert(muxer_notif_iter
);
989 priv_comp
= bt_private_notification_iterator_get_private_component(
992 muxer_comp
= bt_private_component_get_user_data(priv_comp
);
995 /* Are we in an error state set elsewhere? */
996 if (unlikely(muxer_comp
->error
)) {
997 next_ret
.notification
= NULL
;
998 next_ret
.status
= BT_NOTIFICATION_ITERATOR_STATUS_ERROR
;
1002 next_ret
= muxer_notif_iter_do_next(muxer_comp
, muxer_notif_iter
);
1010 void muxer_port_connected(
1011 struct bt_private_component
*priv_comp
,
1012 struct bt_private_port
*self_private_port
,
1013 struct bt_port
*other_port
)
1015 struct bt_port
*self_port
=
1016 bt_port_from_private_port(self_private_port
);
1017 struct muxer_comp
*muxer_comp
=
1018 bt_private_component_get_user_data(priv_comp
);
1024 if (bt_port_get_type(self_port
) == BT_PORT_TYPE_INPUT
) {
1027 /* One less available input port */
1028 muxer_comp
->available_input_ports
--;
1029 ret
= ensure_available_input_port(priv_comp
);
1032 * Only way to report an error later since this
1033 * method does not return anything.
1035 muxer_comp
->error
= true;
1040 for (i
= 0; i
< muxer_comp
->muxer_notif_iters
->len
; i
++) {
1041 struct muxer_notif_iter
*muxer_notif_iter
=
1042 g_ptr_array_index(muxer_comp
->muxer_notif_iters
, i
);
1045 * Add this port to the list of newly connected ports
1046 * for this muxer notification iterator. We append at
1047 * the end of this list while
1048 * muxer_notif_iter_handle_newly_connected_ports()
1049 * removes the nodes from the beginning.
1051 * The list node owns the private port.
1053 muxer_notif_iter
->newly_connected_priv_ports
=
1055 muxer_notif_iter
->newly_connected_priv_ports
,
1056 bt_get(self_private_port
));
1057 if (!muxer_notif_iter
->newly_connected_priv_ports
) {
1058 /* Put reference taken by bt_get() above */
1059 bt_put(self_private_port
);
1060 muxer_comp
->error
= true;
1070 void muxer_port_disconnected(struct bt_private_component
*priv_comp
,
1071 struct bt_private_port
*priv_port
)
1073 struct bt_port
*port
= bt_port_from_private_port(priv_port
);
1074 struct muxer_comp
*muxer_comp
=
1075 bt_private_component_get_user_data(priv_comp
);
1081 * There's nothing special to do when a port is disconnected
1082 * because this component deals with upstream notification
1083 * iterators which were already created thanks to connected
1084 * ports. The fact that the port is disconnected does not cancel
1085 * the upstream notification iterators created using its
1086 * connection: they still exist, even if the connection is dead.
1087 * The only way to remove an upstream notification iterator is
1088 * for its "next" operation to return
1089 * BT_NOTIFICATION_ITERATOR_STATUS_END.
1091 if (bt_port_get_type(port
) == BT_PORT_TYPE_INPUT
) {
1092 /* One more available input port */
1093 muxer_comp
->available_input_ports
++;