X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=lib%2Fgraph%2Fiterator.c;h=db774dfd298a6b13d7a6f79ad1807906b2be3e0e;hb=c8db321922f3730c70628a5e452baf8a046e70fd;hp=2c83d47bc64b6d546ab4ab64cac288e57da6d89d;hpb=3fea54f69edd1780566230255da196cb6e82df62;p=babeltrace.git diff --git a/lib/graph/iterator.c b/lib/graph/iterator.c index 2c83d47b..db774dfd 100644 --- a/lib/graph/iterator.c +++ b/lib/graph/iterator.c @@ -1,10 +1,6 @@ /* - * iterator.c - * - * Babeltrace Notification Iterator - * + * Copyright 2017-2018 Philippe Proulx * Copyright 2015 Jérémie Galarneau - * Copyright 2017 Philippe Proulx * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal @@ -29,32 +25,35 @@ #include #include -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include #include -#include +#include +#include #include #include #include -#include -#include +#include +#include #include #include +#include +#include #include -#include +#include #include -#include +#include #include -#include +#include #include -#include -#include +#include +#include +#include #include #include #include @@ -63,29 +62,20 @@ #include #include -struct discarded_elements_state { - struct bt_clock_value *cur_begin; - uint64_t cur_count; -}; +/* + * TODO: Use graph's state (number of active iterators, etc.) and + * possibly system specifications to make a better guess than this. + */ +#define NOTIF_BATCH_SIZE 15 struct stream_state { - struct bt_stream *stream; /* owned by this */ - struct bt_packet *cur_packet; /* owned by this */ - struct discarded_elements_state discarded_packets_state; - struct discarded_elements_state discarded_events_state; + const struct bt_stream *stream; /* owned by this */ + const struct bt_packet *cur_packet; /* owned by this */ uint64_t expected_notif_seq_num; bt_bool is_ended; }; -static -void stream_destroy_listener(struct bt_stream_common *stream, void *data) -{ - struct bt_notification_iterator_private_connection *iterator = data; - - /* Remove associated stream state */ - g_hash_table_remove(iterator->stream_states, stream); -} - +BT_ASSERT_PRE_FUNC static void destroy_stream_state(struct stream_state *stream_state) { @@ -95,16 +85,15 @@ void destroy_stream_state(struct stream_state *stream_state) BT_LOGV("Destroying stream state: stream-state-addr=%p", stream_state); BT_LOGV_STR("Putting stream state's current packet."); - bt_put(stream_state->cur_packet); + BT_OBJECT_PUT_REF_AND_RESET(stream_state->cur_packet); BT_LOGV_STR("Putting stream state's stream."); - bt_put(stream_state->stream); - bt_put(stream_state->discarded_packets_state.cur_begin); - bt_put(stream_state->discarded_events_state.cur_begin); + BT_OBJECT_PUT_REF_AND_RESET(stream_state->stream); g_free(stream_state); } +BT_ASSERT_PRE_FUNC static -struct stream_state *create_stream_state(struct bt_stream *stream) +struct stream_state *create_stream_state(const struct bt_stream *stream) { struct stream_state *stream_state = g_new0(struct stream_state, 1); @@ -113,22 +102,14 @@ struct stream_state *create_stream_state(struct bt_stream *stream) goto end; } - /* - * The packet index is a monotonic counter which may not start - * at 0 at the beginning of the stream. We therefore need to - * have an internal object initial state of -1ULL to distinguish - * between initial state and having seen a packet with - * the sequence number 0. - */ - stream_state->discarded_packets_state.cur_count = -1ULL; - /* * We keep a reference to the stream until we know it's ended. */ - stream_state->stream = bt_get(stream); - BT_LOGV("Created stream state: stream-addr=%p, stream-name=\"%s\", " + stream_state->stream = stream; + bt_object_get_no_null_check(stream_state->stream); + BT_LIB_LOGV("Created stream state: %![stream-]+s, " "stream-state-addr=%p", - stream, bt_stream_get_name(stream), stream_state); + stream, stream_state); end: return stream_state; @@ -137,14 +118,22 @@ end: static void destroy_base_notification_iterator(struct bt_object *obj) { - BT_ASSERT(obj); - g_free(obj); + struct bt_notification_iterator *iterator = (void *) obj; + + BT_ASSERT(iterator); + + if (iterator->notifs) { + g_ptr_array_free(iterator->notifs, TRUE); + iterator->notifs = NULL; + } + + g_free(iterator); } static -void bt_private_connection_notification_iterator_destroy(struct bt_object *obj) +void bt_self_component_port_input_notification_iterator_destroy(struct bt_object *obj) { - struct bt_notification_iterator_private_connection *iterator; + struct bt_self_component_port_input_notification_iterator *iterator; BT_ASSERT(obj); @@ -152,17 +141,18 @@ void bt_private_connection_notification_iterator_destroy(struct bt_object *obj) * The notification iterator's reference count is 0 if we're * here. Increment it to avoid a double-destroy (possibly * infinitely recursive). This could happen for example if the - * notification iterator's finalization function does bt_get() - * (or anything that causes bt_get() to be called) on itself - * (ref. count goes from 0 to 1), and then bt_put(): the - * reference count would go from 1 to 0 again and this function - * would be called again. + * notification iterator's finalization function does + * bt_object_get_ref() (or anything that causes + * bt_object_get_ref() to be called) on itself (ref. count goes + * from 0 to 1), and then bt_object_put_ref(): the reference + * count would go from 1 to 0 again and this function would be + * called again. */ obj->ref_count++; iterator = (void *) obj; - BT_LOGD("Destroying private connection notification iterator object: addr=%p", - iterator); - bt_private_connection_notification_iterator_finalize(iterator); + BT_LIB_LOGD("Destroying self component input port notification iterator object: " + "%!+i", iterator); + bt_self_component_port_input_notification_iterator_finalize(iterator); if (iterator->stream_states) { /* @@ -171,21 +161,8 @@ void bt_private_connection_notification_iterator_destroy(struct bt_object *obj) * listener would be called with an invalid/other * notification iterator object. */ - GHashTableIter ht_iter; - gpointer stream_gptr, stream_state_gptr; - - g_hash_table_iter_init(&ht_iter, iterator->stream_states); - - while (g_hash_table_iter_next(&ht_iter, &stream_gptr, &stream_state_gptr)) { - BT_ASSERT(stream_gptr); - - BT_LOGD_STR("Removing stream's destroy listener for notification iterator."); - bt_stream_common_remove_destroy_listener( - (void *) stream_gptr, stream_destroy_listener, - iterator); - } - g_hash_table_destroy(iterator->stream_states); + iterator->stream_states = NULL; } if (iterator->connection) { @@ -195,47 +172,49 @@ void bt_private_connection_notification_iterator_destroy(struct bt_object *obj) * later. */ bt_connection_remove_iterator(iterator->connection, iterator); + iterator->connection = NULL; } destroy_base_notification_iterator(obj); } BT_HIDDEN -void bt_private_connection_notification_iterator_finalize( - struct bt_notification_iterator_private_connection *iterator) +void bt_self_component_port_input_notification_iterator_finalize( + struct bt_self_component_port_input_notification_iterator *iterator) { + typedef void (*method_t)(void *); + struct bt_component_class *comp_class = NULL; - bt_component_class_notification_iterator_finalize_method - finalize_method = NULL; + method_t method = NULL; BT_ASSERT(iterator); switch (iterator->state) { - case BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_NON_INITIALIZED: + case BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_NON_INITIALIZED: /* Skip user finalization if user initialization failed */ - BT_LOGD("Not finalizing non-initialized notification iterator: " - "addr=%p", iterator); + BT_LIB_LOGD("Not finalizing non-initialized notification iterator: " + "%!+i", iterator); return; - case BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_FINALIZED: - case BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_FINALIZED_AND_ENDED: + case BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_FINALIZED: + case BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_FINALIZED_AND_ENDED: /* Already finalized */ - BT_LOGD("Not finalizing notification iterator: already finalized: " - "addr=%p", iterator); + BT_LIB_LOGD("Not finalizing notification iterator: already finalized: " + "%!+i", iterator); return; default: break; } - BT_LOGD("Finalizing notification iterator: addr=%p", iterator); + BT_LIB_LOGD("Finalizing notification iterator: %!+i", iterator); - if (iterator->state == BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_ENDED) { - BT_LOGD("Updating notification iterator's state: " - "new-state=BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_FINALIZED_AND_ENDED"); - iterator->state = BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_FINALIZED_AND_ENDED; + if (iterator->state == BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_ENDED) { + BT_LIB_LOGD("Updating notification iterator's state: " + "new-state=BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_FINALIZED_AND_ENDED"); + iterator->state = BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_FINALIZED_AND_ENDED; } else { - BT_LOGD("Updating notification iterator's state: " - "new-state=BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_FINALIZED"); - iterator->state = BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_FINALIZED; + BT_LIB_LOGD("Updating notification iterator's state: " + "new-state=BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_FINALIZED"); + iterator->state = BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_FINALIZED; } BT_ASSERT(iterator->upstream_component); @@ -245,18 +224,18 @@ void bt_private_connection_notification_iterator_finalize( switch (comp_class->type) { case BT_COMPONENT_CLASS_TYPE_SOURCE: { - struct bt_component_class_source *source_class; + struct bt_component_class_source *src_comp_cls = + (void *) comp_class; - source_class = container_of(comp_class, struct bt_component_class_source, parent); - finalize_method = source_class->methods.iterator.finalize; + method = (method_t) src_comp_cls->methods.notif_iter_finalize; break; } case BT_COMPONENT_CLASS_TYPE_FILTER: { - struct bt_component_class_filter *filter_class; + struct bt_component_class_filter *flt_comp_cls = + (void *) comp_class; - filter_class = container_of(comp_class, struct bt_component_class_filter, parent); - finalize_method = filter_class->methods.iterator.finalize; + method = (method_t) flt_comp_cls->methods.notif_iter_finalize; break; } default: @@ -264,166 +243,246 @@ void bt_private_connection_notification_iterator_finalize( abort(); } - if (finalize_method) { - BT_LOGD("Calling user's finalization method: addr=%p", + if (method) { + BT_LIB_LOGD("Calling user's finalization method: %!+i", iterator); - finalize_method( - bt_private_connection_private_notification_iterator_from_notification_iterator(iterator)); + method(iterator); } iterator->upstream_component = NULL; iterator->upstream_port = NULL; - BT_LOGD("Finalized notification iterator: addr=%p", iterator); + BT_LIB_LOGD("Finalized notification iterator: %!+i", iterator); } BT_HIDDEN -void bt_private_connection_notification_iterator_set_connection( - struct bt_notification_iterator_private_connection *iterator, +void bt_self_component_port_input_notification_iterator_set_connection( + struct bt_self_component_port_input_notification_iterator *iterator, struct bt_connection *connection) { BT_ASSERT(iterator); iterator->connection = connection; - BT_LOGV("Set notification iterator's connection: " - "iter-addr=%p, conn-addr=%p", iterator, connection); + BT_LIB_LOGV("Set notification iterator's connection: " + "%![iter-]+i, %![conn-]+x", iterator, connection); } static -void init_notification_iterator(struct bt_notification_iterator *iterator, +int init_notification_iterator(struct bt_notification_iterator *iterator, enum bt_notification_iterator_type type, bt_object_release_func destroy) { + int ret = 0; + bt_object_init_shared(&iterator->base, destroy); iterator->type = type; + iterator->notifs = g_ptr_array_new(); + if (!iterator->notifs) { + BT_LOGE_STR("Failed to allocate a GPtrArray."); + ret = -1; + goto end; + } + + g_ptr_array_set_size(iterator->notifs, NOTIF_BATCH_SIZE); + +end: + return ret; } -BT_HIDDEN -enum bt_connection_status bt_private_connection_notification_iterator_create( +static +struct bt_self_component_port_input_notification_iterator * +bt_self_component_port_input_notification_iterator_create_initial( struct bt_component *upstream_comp, - struct bt_port *upstream_port, - struct bt_connection *connection, - struct bt_notification_iterator_private_connection **user_iterator) + struct bt_port *upstream_port) { - enum bt_connection_status status = BT_CONNECTION_STATUS_OK; - enum bt_component_class_type type; - struct bt_notification_iterator_private_connection *iterator = NULL; + int ret; + struct bt_self_component_port_input_notification_iterator *iterator = NULL; BT_ASSERT(upstream_comp); BT_ASSERT(upstream_port); BT_ASSERT(bt_port_is_connected(upstream_port)); - BT_ASSERT(user_iterator); - BT_LOGD("Creating notification iterator on private connection: " - "upstream-comp-addr=%p, upstream-comp-name=\"%s\", " - "upstream-port-addr=%p, upstream-port-name=\"%s\", " - "conn-addr=%p", - upstream_comp, bt_component_get_name(upstream_comp), - upstream_port, bt_port_get_name(upstream_port), - connection); - type = bt_component_get_class_type(upstream_comp); - BT_ASSERT(type == BT_COMPONENT_CLASS_TYPE_SOURCE || - type == BT_COMPONENT_CLASS_TYPE_FILTER); - iterator = g_new0(struct bt_notification_iterator_private_connection, 1); + BT_LIB_LOGD("Creating initial notification iterator on self component input port: " + "%![up-comp-]+c, %![up-port-]+p", upstream_comp, upstream_port); + BT_ASSERT(bt_component_get_class_type(upstream_comp) == + BT_COMPONENT_CLASS_TYPE_SOURCE || + bt_component_get_class_type(upstream_comp) == + BT_COMPONENT_CLASS_TYPE_FILTER); + iterator = g_new0( + struct bt_self_component_port_input_notification_iterator, 1); if (!iterator) { - BT_LOGE_STR("Failed to allocate one private connection notification iterator."); - status = BT_CONNECTION_STATUS_NOMEM; + BT_LOGE_STR("Failed to allocate one self component input port " + "notification iterator."); goto end; } - init_notification_iterator((void *) iterator, - BT_NOTIFICATION_ITERATOR_TYPE_PRIVATE_CONNECTION, - bt_private_connection_notification_iterator_destroy); + ret = init_notification_iterator((void *) iterator, + BT_NOTIFICATION_ITERATOR_TYPE_SELF_COMPONENT_PORT_INPUT, + bt_self_component_port_input_notification_iterator_destroy); + if (ret) { + /* init_notification_iterator() logs errors */ + BT_OBJECT_PUT_REF_AND_RESET(iterator); + goto end; + } iterator->stream_states = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) destroy_stream_state); if (!iterator->stream_states) { BT_LOGE_STR("Failed to allocate a GHashTable."); - status = BT_CONNECTION_STATUS_NOMEM; + BT_OBJECT_PUT_REF_AND_RESET(iterator); goto end; } iterator->upstream_component = upstream_comp; iterator->upstream_port = upstream_port; - iterator->connection = connection; + iterator->connection = iterator->upstream_port->connection; iterator->graph = bt_component_borrow_graph(upstream_comp); - iterator->state = BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_NON_INITIALIZED; - BT_LOGD("Created notification iterator: " - "upstream-comp-addr=%p, upstream-comp-name=\"%s\", " - "upstream-port-addr=%p, upstream-port-name=\"%s\", " - "conn-addr=%p, iter-addr=%p", - upstream_comp, bt_component_get_name(upstream_comp), - upstream_port, bt_port_get_name(upstream_port), - connection, iterator); - - /* Move reference to user */ - *user_iterator = iterator; - iterator = NULL; + iterator->state = BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_NON_INITIALIZED; + BT_LIB_LOGD("Created initial notification iterator on self component input port: " + "%![up-port-]+p, %![up-comp-]+c, %![iter-]+i", + upstream_port, upstream_comp, iterator); end: - bt_put(iterator); - return status; + return iterator; } -void *bt_private_connection_private_notification_iterator_get_user_data( - struct bt_private_connection_private_notification_iterator *private_iterator) +struct bt_self_component_port_input_notification_iterator * +bt_self_component_port_input_notification_iterator_create( + struct bt_self_component_port_input *self_port) { - struct bt_notification_iterator_private_connection *iterator = (void *) - bt_private_connection_notification_iterator_borrow_from_private(private_iterator); + typedef enum bt_self_notification_iterator_status (*init_method_t)( + void *, void *, void *); + + init_method_t init_method = NULL; + struct bt_self_component_port_input_notification_iterator *iterator = + NULL; + struct bt_port *port = (void *) self_port; + struct bt_port *upstream_port; + struct bt_component *comp; + struct bt_component *upstream_comp; + struct bt_component_class *upstream_comp_cls; + + BT_ASSERT_PRE_NON_NULL(port, "Port"); + comp = bt_port_borrow_component_inline(port); + BT_ASSERT_PRE(bt_port_is_connected(port), + "Port is not connected: %![port-]+p", port); + BT_ASSERT_PRE(comp, "Port is not part of a component: %![port-]+p", + port); + BT_ASSERT_PRE(!bt_component_graph_is_canceled(comp), + "Port's component's graph is canceled: " + "%![port-]+p, %![comp-]+c", port, comp); + BT_ASSERT(port->connection); + upstream_port = port->connection->upstream_port; + BT_ASSERT(upstream_port); + upstream_comp = bt_port_borrow_component_inline(upstream_port); + BT_ASSERT(upstream_comp); + upstream_comp_cls = upstream_comp->class; + BT_ASSERT(upstream_comp->class->type == + BT_COMPONENT_CLASS_TYPE_SOURCE || + upstream_comp->class->type == + BT_COMPONENT_CLASS_TYPE_FILTER); + iterator = bt_self_component_port_input_notification_iterator_create_initial( + upstream_comp, upstream_port); + if (!iterator) { + BT_LOGW_STR("Cannot create self component input port " + "notification iterator."); + goto end; + } - BT_ASSERT_PRE_NON_NULL(private_iterator, "Notification iterator"); - return iterator->user_data; + switch (upstream_comp_cls->type) { + case BT_COMPONENT_CLASS_TYPE_SOURCE: + { + struct bt_component_class_source *src_comp_cls = + (void *) upstream_comp_cls; + + init_method = + (init_method_t) src_comp_cls->methods.notif_iter_init; + break; + } + case BT_COMPONENT_CLASS_TYPE_FILTER: + { + struct bt_component_class_filter *flt_comp_cls = + (void *) upstream_comp_cls; + + init_method = + (init_method_t) flt_comp_cls->methods.notif_iter_init; + break; + } + default: + /* Unreachable */ + abort(); + } + + if (init_method) { + int iter_status; + + BT_LIB_LOGD("Calling user's initialization method: %!+i", iterator); + iter_status = init_method(iterator, upstream_comp, + upstream_port); + BT_LOGD("User method returned: status=%s", + bt_notification_iterator_status_string(iter_status)); + if (iter_status != BT_NOTIFICATION_ITERATOR_STATUS_OK) { + BT_LOGW_STR("Initialization method failed."); + goto end; + } + } + + iterator->state = BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_ACTIVE; + g_ptr_array_add(port->connection->iterators, iterator); + BT_LIB_LOGD("Created notification iterator on self component input port: " + "%![up-port-]+p, %![up-comp-]+c, %![iter-]+i", + upstream_port, upstream_comp, iterator); + +end: + return iterator; } -enum bt_notification_iterator_status -bt_private_connection_private_notification_iterator_set_user_data( - struct bt_private_connection_private_notification_iterator *private_iterator, - void *data) +void *bt_self_notification_iterator_get_data( + const struct bt_self_notification_iterator *self_iterator) { - struct bt_notification_iterator_private_connection *iterator = (void *) - bt_private_connection_notification_iterator_borrow_from_private(private_iterator); + struct bt_self_component_port_input_notification_iterator *iterator = + (void *) self_iterator; BT_ASSERT_PRE_NON_NULL(iterator, "Notification iterator"); - iterator->user_data = data; - BT_LOGV("Set notification iterator's user data: " - "iter-addr=%p, user-data-addr=%p", iterator, data); - return BT_NOTIFICATION_ITERATOR_STATUS_OK; + return iterator->user_data; } -struct bt_graph *bt_private_connection_private_notification_iterator_borrow_graph( - struct bt_private_connection_private_notification_iterator *private_iterator) +void bt_self_notification_iterator_set_data( + struct bt_self_notification_iterator *self_iterator, void *data) { - struct bt_notification_iterator_private_connection *iterator = (void *) - bt_private_connection_notification_iterator_borrow_from_private( - private_iterator); + struct bt_self_component_port_input_notification_iterator *iterator = + (void *) self_iterator; BT_ASSERT_PRE_NON_NULL(iterator, "Notification iterator"); - return iterator->graph; + iterator->user_data = data; + BT_LIB_LOGV("Set notification iterator's user data: " + "%!+i, user-data-addr=%p", iterator, data); } BT_ASSERT_PRE_FUNC static inline -void bt_notification_borrow_packet_stream(struct bt_notification *notif, - struct bt_stream **stream, struct bt_packet **packet) +void bt_notification_borrow_packet_stream(const struct bt_notification *notif, + const struct bt_stream **stream, + const struct bt_packet **packet) { BT_ASSERT(notif); switch (notif->type) { case BT_NOTIFICATION_TYPE_EVENT: - *packet = bt_event_borrow_packet( - bt_notification_event_borrow_event(notif)); - *stream = bt_packet_borrow_stream(*packet); + *packet = bt_event_borrow_packet_const( + bt_notification_event_borrow_event_const(notif)); + *stream = bt_packet_borrow_stream_const(*packet); break; - case BT_NOTIFICATION_TYPE_STREAM_BEGIN: - *stream = bt_notification_stream_begin_borrow_stream(notif); + case BT_NOTIFICATION_TYPE_STREAM_BEGINNING: + *stream = bt_notification_stream_beginning_borrow_stream_const(notif); break; case BT_NOTIFICATION_TYPE_STREAM_END: - *stream = bt_notification_stream_end_borrow_stream(notif); + *stream = bt_notification_stream_end_borrow_stream_const(notif); break; - case BT_NOTIFICATION_TYPE_PACKET_BEGIN: - *packet = bt_notification_packet_begin_borrow_packet(notif); - *stream = bt_packet_borrow_stream(*packet); + case BT_NOTIFICATION_TYPE_PACKET_BEGINNING: + *packet = bt_notification_packet_beginning_borrow_packet_const(notif); + *stream = bt_packet_borrow_stream_const(*packet); break; case BT_NOTIFICATION_TYPE_PACKET_END: - *packet = bt_notification_packet_end_borrow_packet(notif); - *stream = bt_packet_borrow_stream(*packet); + *packet = bt_notification_packet_end_borrow_packet_const(notif); + *stream = bt_packet_borrow_stream_const(*packet); break; default: break; @@ -433,16 +492,17 @@ void bt_notification_borrow_packet_stream(struct bt_notification *notif, BT_ASSERT_PRE_FUNC static inline bool validate_notification( - struct bt_notification_iterator_private_connection *iterator, - struct bt_notification *notif) + struct bt_self_component_port_input_notification_iterator *iterator, + const struct bt_notification *c_notif) { bool is_valid = true; struct stream_state *stream_state; - struct bt_stream *stream = NULL; - struct bt_packet *packet = NULL; + const struct bt_stream *stream = NULL; + const struct bt_packet *packet = NULL; + struct bt_notification *notif = (void *) c_notif; BT_ASSERT(notif); - bt_notification_borrow_packet_stream(notif, &stream, &packet); + bt_notification_borrow_packet_stream(c_notif, &stream, &packet); if (!stream) { /* we don't care about notifications not attached to streams */ @@ -453,29 +513,29 @@ bool validate_notification( if (!stream_state) { /* * No stream state for this stream: this notification - * MUST be a BT_NOTIFICATION_TYPE_STREAM_BEGIN notification + * MUST be a BT_NOTIFICATION_TYPE_STREAM_BEGINNING notification * and its sequence number must be 0. */ - if (notif->type != BT_NOTIFICATION_TYPE_STREAM_BEGIN) { + if (c_notif->type != BT_NOTIFICATION_TYPE_STREAM_BEGINNING) { BT_ASSERT_PRE_MSG("Unexpected notification: missing a " - "BT_NOTIFICATION_TYPE_STREAM_BEGIN " + "BT_NOTIFICATION_TYPE_STREAM_BEGINNING " "notification prior to this notification: " "%![stream-]+s", stream); is_valid = false; goto end; } - if (notif->seq_num == -1ULL) { + if (c_notif->seq_num == -1ULL) { notif->seq_num = 0; } - if (notif->seq_num != 0) { + if (c_notif->seq_num != 0) { BT_ASSERT_PRE_MSG("Unexpected notification sequence " "number for this notification iterator: " "this is the first notification for this " "stream, expecting sequence number 0: " "seq-num=%" PRIu64 ", %![stream-]+s", - notif->seq_num, stream); + c_notif->seq_num, stream); is_valid = false; goto end; } @@ -485,8 +545,8 @@ bool validate_notification( abort(); } - g_hash_table_insert(iterator->stream_states, stream, - stream_state); + g_hash_table_insert(iterator->stream_states, + (void *) stream, stream_state); stream_state->expected_notif_seq_num++; goto end; } @@ -505,26 +565,26 @@ bool validate_notification( goto end; } - if (notif->seq_num == -1ULL) { + if (c_notif->seq_num == -1ULL) { notif->seq_num = stream_state->expected_notif_seq_num; } - if (notif->seq_num != -1ULL && - notif->seq_num != stream_state->expected_notif_seq_num) { + if (c_notif->seq_num != -1ULL && + c_notif->seq_num != stream_state->expected_notif_seq_num) { BT_ASSERT_PRE_MSG("Unexpected notification sequence number: " "seq-num=%" PRIu64 ", " "expected-seq-num=%" PRIu64 ", %![stream-]+s", - notif->seq_num, stream_state->expected_notif_seq_num, + c_notif->seq_num, stream_state->expected_notif_seq_num, stream); is_valid = false; goto end; } - switch (notif->type) { - case BT_NOTIFICATION_TYPE_STREAM_BEGIN: - BT_ASSERT_PRE_MSG("Unexpected BT_NOTIFICATION_TYPE_STREAM_BEGIN " + switch (c_notif->type) { + case BT_NOTIFICATION_TYPE_STREAM_BEGINNING: + BT_ASSERT_PRE_MSG("Unexpected BT_NOTIFICATION_TYPE_STREAM_BEGINNING " "notification at this point: notif-seq-num=%" PRIu64 ", " - "%![stream-]+s", notif->seq_num, stream); + "%![stream-]+s", c_notif->seq_num, stream); is_valid = false; goto end; case BT_NOTIFICATION_TYPE_STREAM_END: @@ -534,42 +594,43 @@ bool validate_notification( "BT_NOTIFICATION_TYPE_PACKET_END notification " "prior to this notification: " "notif-seq-num=%" PRIu64 ", " - "%![stream-]+s", notif->seq_num, stream); + "%![stream-]+s", c_notif->seq_num, stream); is_valid = false; goto end; } stream_state->expected_notif_seq_num++; stream_state->is_ended = true; goto end; - case BT_NOTIFICATION_TYPE_PACKET_BEGIN: + case BT_NOTIFICATION_TYPE_PACKET_BEGINNING: if (stream_state->cur_packet) { - BT_ASSERT_PRE_MSG("Unexpected BT_NOTIFICATION_TYPE_PACKET_BEGIN " + BT_ASSERT_PRE_MSG("Unexpected BT_NOTIFICATION_TYPE_PACKET_BEGINNING " "notification at this point: missing a " "BT_NOTIFICATION_TYPE_PACKET_END notification " "prior to this notification: " "notif-seq-num=%" PRIu64 ", %![stream-]+s, " - "%![packet-]+a", notif->seq_num, stream, + "%![packet-]+a", c_notif->seq_num, stream, packet); is_valid = false; goto end; } stream_state->expected_notif_seq_num++; - stream_state->cur_packet = bt_get(packet); + stream_state->cur_packet = packet; + bt_object_get_no_null_check(stream_state->cur_packet); goto end; case BT_NOTIFICATION_TYPE_PACKET_END: if (!stream_state->cur_packet) { BT_ASSERT_PRE_MSG("Unexpected BT_NOTIFICATION_TYPE_PACKET_END " "notification at this point: missing a " - "BT_NOTIFICATION_TYPE_PACKET_BEGIN notification " + "BT_NOTIFICATION_TYPE_PACKET_BEGINNING notification " "prior to this notification: " "notif-seq-num=%" PRIu64 ", %![stream-]+s, " - "%![packet-]+a", notif->seq_num, stream, + "%![packet-]+a", c_notif->seq_num, stream, packet); is_valid = false; goto end; } stream_state->expected_notif_seq_num++; - BT_PUT(stream_state->cur_packet); + BT_OBJECT_PUT_REF_AND_RESET(stream_state->cur_packet); goto end; case BT_NOTIFICATION_TYPE_EVENT: if (packet != stream_state->cur_packet) { @@ -577,7 +638,7 @@ bool validate_notification( "BT_NOTIFICATION_TYPE_EVENT notification: " "notif-seq-num=%" PRIu64 ", %![stream-]+s, " "%![notif-packet-]+a, %![expected-packet-]+a", - notif->seq_num, stream, + c_notif->seq_num, stream, stream_state->cur_packet, packet); is_valid = false; goto end; @@ -593,8 +654,29 @@ end: } BT_ASSERT_PRE_FUNC -static inline bool priv_conn_notif_iter_can_end( - struct bt_notification_iterator_private_connection *iterator) +static inline +bool validate_notifications( + struct bt_self_component_port_input_notification_iterator *iterator, + uint64_t count) +{ + bool ret = true; + bt_notification_array_const notifs = + (void *) iterator->base.notifs->pdata; + uint64_t i; + + for (i = 0; i < count; i++) { + ret = validate_notification(iterator, notifs[i]); + if (!ret) { + break; + } + } + + return ret; +} + +BT_ASSERT_PRE_FUNC +static inline bool self_comp_port_input_notif_iter_can_end( + struct bt_self_component_port_input_notification_iterator *iterator) { GHashTableIter iter; gpointer stream_key, state_value; @@ -628,57 +710,46 @@ end: } enum bt_notification_iterator_status -bt_private_connection_notification_iterator_next( - struct bt_notification_iterator *user_iterator, - struct bt_notification **user_notif) +bt_self_component_port_input_notification_iterator_next( + struct bt_self_component_port_input_notification_iterator *iterator, + bt_notification_array_const *notifs, uint64_t *user_count) { - struct bt_notification_iterator_private_connection *iterator = - (void *) user_iterator; - struct bt_private_connection_private_notification_iterator *priv_iterator = - bt_private_connection_private_notification_iterator_from_notification_iterator(iterator); - bt_component_class_notification_iterator_next_method next_method = NULL; - struct bt_notification_iterator_next_method_return next_return = { - .status = BT_NOTIFICATION_ITERATOR_STATUS_OK, - .notification = NULL, - }; - enum bt_notification_iterator_status status = - BT_NOTIFICATION_ITERATOR_STATUS_OK; - - BT_ASSERT_PRE_NON_NULL(user_iterator, "Notification iterator"); - BT_ASSERT_PRE_NON_NULL(user_notif, "Notification"); - BT_ASSERT_PRE(user_iterator->type == - BT_NOTIFICATION_ITERATOR_TYPE_PRIVATE_CONNECTION, - "Notification iterator was not created from a private connection: " - "%!+i", iterator); - BT_LIB_LOGD("Getting next private connection notification iterator's notification: %!+i", - iterator); + typedef enum bt_self_notification_iterator_status (*method_t)( + void *, bt_notification_array_const, uint64_t, uint64_t *); + + method_t method = NULL; + struct bt_component_class *comp_cls; + int status = BT_NOTIFICATION_ITERATOR_STATUS_OK; + + BT_ASSERT_PRE_NON_NULL(iterator, "Notification iterator"); + BT_ASSERT_PRE_NON_NULL(notifs, "Notification array (output)"); + BT_ASSERT_PRE_NON_NULL(user_count, "Notification count (output)"); BT_ASSERT_PRE(iterator->state == - BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_ACTIVE, + BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_ACTIVE, "Notification iterator's \"next\" called, but " "iterator is in the wrong state: %!+i", iterator); BT_ASSERT(iterator->upstream_component); BT_ASSERT(iterator->upstream_component->class); + BT_LIB_LOGD("Getting next self component input port " + "notification iterator's notifications: %!+i", iterator); + comp_cls = iterator->upstream_component->class; /* Pick the appropriate "next" method */ - switch (iterator->upstream_component->class->type) { + switch (comp_cls->type) { case BT_COMPONENT_CLASS_TYPE_SOURCE: { - struct bt_component_class_source *source_class = - container_of(iterator->upstream_component->class, - struct bt_component_class_source, parent); + struct bt_component_class_source *src_comp_cls = + (void *) comp_cls; - BT_ASSERT(source_class->methods.iterator.next); - next_method = source_class->methods.iterator.next; + method = (method_t) src_comp_cls->methods.notif_iter_next; break; } case BT_COMPONENT_CLASS_TYPE_FILTER: { - struct bt_component_class_filter *filter_class = - container_of(iterator->upstream_component->class, - struct bt_component_class_filter, parent); + struct bt_component_class_filter *flt_comp_cls = + (void *) comp_cls; - BT_ASSERT(filter_class->methods.iterator.next); - next_method = filter_class->methods.iterator.next; + method = (method_t) flt_comp_cls->methods.notif_iter_next; break; } default: @@ -686,22 +757,23 @@ bt_private_connection_notification_iterator_next( } /* - * Call the user's "next" method to get the next notification + * Call the user's "next" method to get the next notifications * and status. */ - BT_ASSERT(next_method); + BT_ASSERT(method); BT_LOGD_STR("Calling user's \"next\" method."); - next_return = next_method(priv_iterator); + status = method(iterator, + (void *) iterator->base.notifs->pdata, + NOTIF_BATCH_SIZE, user_count); BT_LOGD("User method returned: status=%s", - bt_notification_iterator_status_string(next_return.status)); - if (next_return.status < 0) { + bt_notification_iterator_status_string(status)); + if (status < 0) { BT_LOGW_STR("User method failed."); - status = next_return.status; goto end; } - if (iterator->state == BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_FINALIZED || - iterator->state == BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_FINALIZED_AND_ENDED) { + if (iterator->state == BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_FINALIZED || + iterator->state == BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_FINALIZED_AND_ENDED) { /* * The user's "next" method, somehow, cancelled its own * notification iterator. This can happen, for example, @@ -710,46 +782,44 @@ bt_private_connection_notification_iterator_next( * created. In this case, said connection is ended, and * all its notification iterators are finalized. * - * Only bt_put() the returned notification if - * the status is - * BT_NOTIFICATION_ITERATOR_STATUS_OK because - * otherwise this field could be garbage. + * Only bt_object_put_ref() the returned notification if + * the status is BT_NOTIFICATION_ITERATOR_STATUS_OK + * because otherwise this field could be garbage. */ - if (next_return.status == - BT_NOTIFICATION_ITERATOR_STATUS_OK) { - bt_put(next_return.notification); + if (status == BT_NOTIFICATION_ITERATOR_STATUS_OK) { + uint64_t i; + bt_notification_array_const notifs = + (void *) iterator->base.notifs->pdata; + + for (i = 0; i < *user_count; i++) { + bt_object_put_ref(notifs[i]); + } } status = BT_NOTIFICATION_ITERATOR_STATUS_CANCELED; goto end; } - switch (next_return.status) { + switch (status) { + case BT_NOTIFICATION_ITERATOR_STATUS_OK: + BT_ASSERT_PRE(validate_notifications(iterator, *user_count), + "Notifications are invalid at this point: " + "%![notif-iter-]+i, count=%" PRIu64, + iterator, *user_count); + *notifs = (void *) iterator->base.notifs->pdata; + break; + case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN: + goto end; case BT_NOTIFICATION_ITERATOR_STATUS_END: - BT_ASSERT_PRE(priv_conn_notif_iter_can_end(iterator), + BT_ASSERT_PRE(self_comp_port_input_notif_iter_can_end(iterator), "Notification iterator cannot end at this point: " "%!+i", iterator); BT_ASSERT(iterator->state == - BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_ACTIVE); - iterator->state = BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_ENDED; - status = BT_NOTIFICATION_ITERATOR_STATUS_END; + BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_ACTIVE); + iterator->state = BT_SELF_COMPONENT_PORT_INPUT_NOTIFICATION_ITERATOR_STATE_ENDED; BT_LOGD("Set new status: status=%s", bt_notification_iterator_status_string(status)); goto end; - case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN: - status = BT_NOTIFICATION_ITERATOR_STATUS_AGAIN; - goto end; - case BT_NOTIFICATION_ITERATOR_STATUS_OK: - BT_ASSERT_PRE(next_return.notification, - "User method returned BT_NOTIFICATION_ITERATOR_STATUS_OK, but notification is NULL: " - "%!+i", iterator); - BT_ASSERT_PRE(validate_notification(iterator, - next_return.notification), - "Notification is invalid at this point: " - "%![notif-iter-]+i, %![notif-]+n", - iterator, next_return.notification); - *user_notif = next_return.notification; - break; default: /* Unknown non-error status */ abort(); @@ -760,47 +830,39 @@ end: } enum bt_notification_iterator_status -bt_output_port_notification_iterator_next( - struct bt_notification_iterator *iterator, - struct bt_notification **user_notif) +bt_port_output_notification_iterator_next( + struct bt_port_output_notification_iterator *iterator, + bt_notification_array_const *notifs_to_user, + uint64_t *count_to_user) { enum bt_notification_iterator_status status; - struct bt_notification_iterator_output_port *out_port_iter = - (void *) iterator; enum bt_graph_status graph_status; BT_ASSERT_PRE_NON_NULL(iterator, "Notification iterator"); - BT_ASSERT_PRE_NON_NULL(user_notif, "Notification"); - BT_ASSERT_PRE(iterator->type == - BT_NOTIFICATION_ITERATOR_TYPE_OUTPUT_PORT, - "Notification iterator was not created from an output port: " + BT_ASSERT_PRE_NON_NULL(notifs_to_user, "Notification array (output)"); + BT_ASSERT_PRE_NON_NULL(count_to_user, "Notification count (output)"); + BT_LIB_LOGD("Getting next output port notification iterator's notifications: " "%!+i", iterator); - BT_LIB_LOGD("Getting next output port notification iterator's notification: %!+i", - iterator); - graph_status = bt_graph_consume_sink_no_check( - out_port_iter->graph, out_port_iter->colander); + + graph_status = bt_graph_consume_sink_no_check(iterator->graph, + iterator->colander); switch (graph_status) { case BT_GRAPH_STATUS_CANCELED: - BT_ASSERT(!out_port_iter->notif); - status = BT_NOTIFICATION_ITERATOR_STATUS_CANCELED; - break; case BT_GRAPH_STATUS_AGAIN: - BT_ASSERT(!out_port_iter->notif); - status = BT_NOTIFICATION_ITERATOR_STATUS_AGAIN; - break; case BT_GRAPH_STATUS_END: - BT_ASSERT(!out_port_iter->notif); - status = BT_NOTIFICATION_ITERATOR_STATUS_END; - break; case BT_GRAPH_STATUS_NOMEM: - BT_ASSERT(!out_port_iter->notif); - status = BT_NOTIFICATION_ITERATOR_STATUS_NOMEM; + status = (int) graph_status; break; case BT_GRAPH_STATUS_OK: - BT_ASSERT(out_port_iter->notif); status = BT_NOTIFICATION_ITERATOR_STATUS_OK; - *user_notif = out_port_iter->notif; - out_port_iter->notif = NULL; + + /* + * On success, the colander sink moves the notifications + * to this iterator's array and sets this iterator's + * notification count: move them to the user. + */ + *notifs_to_user = (void *) iterator->base.notifs->pdata; + *count_to_user = iterator->count; break; default: /* Other errors */ @@ -810,82 +872,89 @@ bt_output_port_notification_iterator_next( return status; } -struct bt_component *bt_private_connection_notification_iterator_get_component( - struct bt_notification_iterator *iterator) +struct bt_component *bt_self_component_port_input_notification_iterator_borrow_component( + struct bt_self_component_port_input_notification_iterator *iterator) +{ + BT_ASSERT_PRE_NON_NULL(iterator, "Notification iterator"); + return iterator->upstream_component; +} + +struct bt_self_component *bt_self_notification_iterator_borrow_component( + struct bt_self_notification_iterator *self_iterator) { - struct bt_notification_iterator_private_connection *iter_priv_conn; + struct bt_self_component_port_input_notification_iterator *iterator = + (void *) self_iterator; BT_ASSERT_PRE_NON_NULL(iterator, "Notification iterator"); - BT_ASSERT_PRE(iterator->type == - BT_NOTIFICATION_ITERATOR_TYPE_PRIVATE_CONNECTION, - "Notification iterator was not created from a private connection: " - "%!+i", iterator); - iter_priv_conn = (void *) iterator; - return bt_get(iter_priv_conn->upstream_component); + return (void *) iterator->upstream_component; } -struct bt_private_component * -bt_private_connection_private_notification_iterator_get_private_component( - struct bt_private_connection_private_notification_iterator *private_iterator) +struct bt_self_port_output *bt_self_notification_iterator_borrow_port( + struct bt_self_notification_iterator *self_iterator) { - return bt_private_component_from_component( - bt_private_connection_notification_iterator_get_component( - (void *) bt_private_connection_notification_iterator_borrow_from_private(private_iterator))); + struct bt_self_component_port_input_notification_iterator *iterator = + (void *) self_iterator; + + BT_ASSERT_PRE_NON_NULL(iterator, "Notification iterator"); + return (void *) iterator->upstream_port; } static -void bt_output_port_notification_iterator_destroy(struct bt_object *obj) +void bt_port_output_notification_iterator_destroy(struct bt_object *obj) { - struct bt_notification_iterator_output_port *iterator = - (void *) container_of(obj, struct bt_notification_iterator, base); + struct bt_port_output_notification_iterator *iterator = (void *) obj; - BT_LOGD("Destroying output port notification iterator object: addr=%p", + BT_LIB_LOGD("Destroying output port notification iterator object: %!+i", iterator); - BT_ASSERT(!iterator->notif); BT_LOGD_STR("Putting graph."); - bt_put(iterator->graph); + BT_OBJECT_PUT_REF_AND_RESET(iterator->graph); BT_LOGD_STR("Putting colander sink component."); - bt_put(iterator->colander); + BT_OBJECT_PUT_REF_AND_RESET(iterator->colander); destroy_base_notification_iterator(obj); } -struct bt_notification_iterator *bt_output_port_notification_iterator_create( - struct bt_port *output_port, - const char *colander_component_name) +struct bt_port_output_notification_iterator * +bt_port_output_notification_iterator_create( + struct bt_graph *graph, + const struct bt_port_output *output_port) { - struct bt_notification_iterator_output_port *iterator = NULL; - struct bt_component_class *colander_comp_cls = NULL; + struct bt_port_output_notification_iterator *iterator = NULL; + struct bt_component_class_sink *colander_comp_cls = NULL; struct bt_component *output_port_comp = NULL; - struct bt_component *colander_comp; - struct bt_graph *graph = NULL; + struct bt_component_sink *colander_comp; enum bt_graph_status graph_status; - const char *colander_comp_name; - struct bt_port *colander_in_port = NULL; + struct bt_port_input *colander_in_port = NULL; struct bt_component_class_sink_colander_data colander_data; + int ret; + BT_ASSERT_PRE_NON_NULL(graph, "Graph"); BT_ASSERT_PRE_NON_NULL(output_port, "Output port"); - BT_ASSERT_PRE(bt_port_get_type(output_port) == BT_PORT_TYPE_OUTPUT, - "Port is not an output port: %!+p", output_port); - output_port_comp = bt_port_get_component(output_port); + output_port_comp = bt_port_borrow_component_inline( + (const void *) output_port); BT_ASSERT_PRE(output_port_comp, "Output port has no component: %!+p", output_port); - graph = bt_component_get_graph(output_port_comp); - BT_ASSERT(graph); + BT_ASSERT_PRE(bt_component_borrow_graph(output_port_comp) == + (void *) graph, + "Output port is not part of graph: %![graph-]+g, %![port-]+p", + graph, output_port); /* Create notification iterator */ - BT_LOGD("Creating notification iterator on output port: " - "comp-addr=%p, comp-name\"%s\", port-addr=%p, port-name=\"%s\"", - output_port_comp, bt_component_get_name(output_port_comp), - output_port, bt_port_get_name(output_port)); - iterator = g_new0(struct bt_notification_iterator_output_port, 1); + BT_LIB_LOGD("Creating notification iterator on output port: " + "%![port-]+p, %![comp-]+c", output_port, output_port_comp); + iterator = g_new0(struct bt_port_output_notification_iterator, 1); if (!iterator) { BT_LOGE_STR("Failed to allocate one output port notification iterator."); goto error; } - init_notification_iterator((void *) iterator, - BT_NOTIFICATION_ITERATOR_TYPE_OUTPUT_PORT, - bt_output_port_notification_iterator_destroy); + ret = init_notification_iterator((void *) iterator, + BT_NOTIFICATION_ITERATOR_TYPE_PORT_OUTPUT, + bt_port_output_notification_iterator_destroy); + if (ret) { + /* init_notification_iterator() logs errors */ + BT_OBJECT_PUT_REF_AND_RESET(iterator); + goto end; + } /* Create colander component */ colander_comp_cls = bt_component_class_sink_colander_get(); @@ -894,17 +963,20 @@ struct bt_notification_iterator *bt_output_port_notification_iterator_create( goto error; } - BT_MOVE(iterator->graph, graph); - colander_comp_name = - colander_component_name ? colander_component_name : "colander"; - colander_data.notification = &iterator->notif; - graph_status = bt_graph_add_component_with_init_method_data( - iterator->graph, colander_comp_cls, colander_comp_name, - NULL, &colander_data, &iterator->colander); + iterator->graph = graph; + bt_object_get_no_null_check(iterator->graph); + colander_data.notifs = (void *) iterator->base.notifs->pdata; + colander_data.count_addr = &iterator->count; + + /* Hope that nobody uses this very unique name */ + graph_status = + bt_graph_add_sink_component_with_init_method_data( + (void *) graph, colander_comp_cls, + "colander-36ac3409-b1a8-4d60-ab1f-4fdf341a8fb1", + NULL, &colander_data, (void *) &iterator->colander); if (graph_status != BT_GRAPH_STATUS_OK) { - BT_LOGW("Cannot add colander sink component to graph: " - "graph-addr=%p, name=\"%s\", graph-status=%s", - iterator->graph, colander_comp_name, + BT_LIB_LOGW("Cannot add colander sink component to graph: " + "%1[graph-]+g, status=%s", graph, bt_graph_status_string(graph_status)); goto error; } @@ -913,15 +985,16 @@ struct bt_notification_iterator *bt_output_port_notification_iterator_create( * Connect provided output port to the colander component's * input port. */ - colander_in_port = bt_component_sink_get_input_port_by_index( - iterator->colander, 0); + colander_in_port = + (void *) bt_component_sink_borrow_input_port_by_index_const( + (void *) iterator->colander, 0); BT_ASSERT(colander_in_port); - graph_status = bt_graph_connect_ports(iterator->graph, + graph_status = bt_graph_connect_ports(graph, output_port, colander_in_port, NULL); if (graph_status != BT_GRAPH_STATUS_OK) { - BT_LOGW("Cannot add colander sink component to graph: " - "graph-addr=%p, name=\"%s\", graph-status=%s", - iterator->graph, colander_comp_name, + BT_LIB_LOGW("Cannot add colander sink component to graph: " + "%![graph-]+g, %![comp-]+c, status=%s", graph, + iterator->colander, bt_graph_status_string(graph_status)); goto error; } @@ -934,7 +1007,7 @@ struct bt_notification_iterator *bt_output_port_notification_iterator_create( * sink and moved to the notification iterator's notification * member. */ - bt_graph_set_can_consume(iterator->graph, BT_FALSE); + bt_graph_set_can_consume(iterator->graph, false); goto end; error: @@ -943,7 +1016,7 @@ error: /* Remove created colander component from graph if any */ colander_comp = iterator->colander; - BT_PUT(iterator->colander); + BT_OBJECT_PUT_REF_AND_RESET(iterator->colander); /* * At this point the colander component's reference @@ -957,23 +1030,37 @@ error: * succeeds. */ ret = bt_graph_remove_unconnected_component(iterator->graph, - colander_comp); + (void *) colander_comp); BT_ASSERT(ret == 0); } - BT_PUT(iterator); + BT_OBJECT_PUT_REF_AND_RESET(iterator); end: - bt_put(colander_in_port); - bt_put(colander_comp_cls); - bt_put(output_port_comp); - bt_put(graph); + bt_object_put_ref(colander_comp_cls); return (void *) iterator; } -struct bt_notification_iterator * -bt_private_connection_notification_iterator_borrow_from_private( - struct bt_private_connection_private_notification_iterator *private_notification_iterator) +void bt_port_output_notification_iterator_get_ref( + const struct bt_port_output_notification_iterator *iterator) +{ + bt_object_get_ref(iterator); +} + +void bt_port_output_notification_iterator_put_ref( + const struct bt_port_output_notification_iterator *iterator) +{ + bt_object_put_ref(iterator); +} + +void bt_self_component_port_input_notification_iterator_get_ref( + const struct bt_self_component_port_input_notification_iterator *iterator) +{ + bt_object_get_ref(iterator); +} + +void bt_self_component_port_input_notification_iterator_put_ref( + const struct bt_self_component_port_input_notification_iterator *iterator) { - return (void *) private_notification_iterator; + bt_object_put_ref(iterator); }