X-Git-Url: https://git.efficios.com/?a=blobdiff_plain;f=src%2Fplugins%2Fctf%2Fcommon%2Fmsg-iter%2Fmsg-iter.c;h=e0d1f4fa85e1c9e2845658a4dee801b35ffd60ac;hb=b8ddb4f036272e30030202637201d11baf5f20a5;hp=ba686961d4034d170ff1d587b5ab41fdaf91981e;hpb=b25ff394d8f3c4f9febb55bcbd6c630e4a5a04f4;p=babeltrace.git diff --git a/src/plugins/ctf/common/msg-iter/msg-iter.c b/src/plugins/ctf/common/msg-iter/msg-iter.c index ba686961..e0d1f4fa 100644 --- a/src/plugins/ctf/common/msg-iter/msg-iter.c +++ b/src/plugins/ctf/common/msg-iter/msg-iter.c @@ -104,10 +104,12 @@ enum state { STATE_DSCOPE_EVENT_PAYLOAD_BEGIN, STATE_DSCOPE_EVENT_PAYLOAD_CONTINUE, STATE_EMIT_MSG_EVENT, + STATE_EMIT_QUEUED_MSG_EVENT, STATE_SKIP_PACKET_PADDING, STATE_EMIT_MSG_PACKET_END_MULTI, STATE_EMIT_MSG_PACKET_END_SINGLE, STATE_CHECK_EMIT_MSG_STREAM_END, + STATE_EMIT_QUEUED_MSG_PACKET_END, STATE_EMIT_MSG_STREAM_END, STATE_DONE, }; @@ -133,6 +135,12 @@ struct bt_msg_iter { /* True to emit a stream end message. */ bool emit_stream_end_msg; + /* + * True if library objects are unavailable during the decoding and + * should not be created/used. + */ + bool dry_run; + /* True to set the stream */ bool set_stream; @@ -175,6 +183,12 @@ struct bt_msg_iter { /* Current event message (NULL if not created yet) */ bt_message *event_msg; + /* + * True if we need to emit a packet beginning message before we emit + * the next event message or the packet end message. + */ + bool emit_delayed_packet_beginning_msg; + /* Database of current dynamic scopes */ struct { bt_field *stream_packet_context; @@ -302,12 +316,16 @@ const char *state_string(enum state state) return "DSCOPE_EVENT_PAYLOAD_CONTINUE"; case STATE_EMIT_MSG_EVENT: return "EMIT_MSG_EVENT"; + case STATE_EMIT_QUEUED_MSG_EVENT: + return "EMIT_QUEUED_MSG_EVENT"; case STATE_SKIP_PACKET_PADDING: return "SKIP_PACKET_PADDING"; case STATE_EMIT_MSG_PACKET_END_MULTI: return "EMIT_MSG_PACKET_END_MULTI"; case STATE_EMIT_MSG_PACKET_END_SINGLE: return "EMIT_MSG_PACKET_END_SINGLE"; + case STATE_EMIT_QUEUED_MSG_PACKET_END: + return "EMIT_QUEUED_MSG_PACKET_END"; case STATE_EMIT_MSG_STREAM_END: return "EMIT_MSG_STREAM_END"; case STATE_DONE: @@ -977,7 +995,7 @@ enum bt_msg_iter_status read_packet_context_begin_state( BT_ASSERT(!notit->packet_context_field); - if (packet_context_fc->in_ir) { + if (packet_context_fc->in_ir && !notit->dry_run) { /* * Create free packet context field from stream class. * This field is going to be moved to the packet once we @@ -1296,6 +1314,10 @@ enum bt_msg_iter_status after_event_header_state( goto end; } + if (G_UNLIKELY(notit->dry_run)) { + goto next_state; + } + status = set_current_event_message(notit); if (status != BT_MSG_ITER_STATUS_OK) { goto end; @@ -1304,6 +1326,8 @@ enum bt_msg_iter_status after_event_header_state( notit->event = bt_message_event_borrow_event( notit->event_msg); BT_ASSERT(notit->event); + +next_state: notit->state = STATE_DSCOPE_EVENT_COMMON_CONTEXT_BEGIN; end: @@ -1323,7 +1347,7 @@ enum bt_msg_iter_status read_event_common_context_begin_state( goto end; } - if (event_common_context_fc->in_ir) { + if (event_common_context_fc->in_ir && !notit->dry_run) { BT_ASSERT(!notit->dscopes.event_common_context); notit->dscopes.event_common_context = bt_event_borrow_common_context_field( @@ -1376,7 +1400,7 @@ enum bt_msg_iter_status read_event_spec_context_begin_state( goto end; } - if (event_spec_context_fc->in_ir) { + if (event_spec_context_fc->in_ir && !notit->dry_run) { BT_ASSERT(!notit->dscopes.event_spec_context); notit->dscopes.event_spec_context = bt_event_borrow_specific_context_field( @@ -1432,7 +1456,7 @@ enum bt_msg_iter_status read_event_payload_begin_state( goto end; } - if (event_payload_fc->in_ir) { + if (event_payload_fc->in_ir && !notit->dry_run) { BT_ASSERT(!notit->dscopes.event_payload); notit->dscopes.event_payload = bt_event_borrow_payload_field( @@ -1719,6 +1743,9 @@ enum bt_msg_iter_status handle_state(struct bt_msg_iter *notit) case STATE_EMIT_MSG_EVENT: notit->state = STATE_DSCOPE_EVENT_HEADER_BEGIN; break; + case STATE_EMIT_QUEUED_MSG_EVENT: + notit->state = STATE_EMIT_MSG_EVENT; + break; case STATE_SKIP_PACKET_PADDING: status = skip_packet_padding_state(notit); break; @@ -1731,6 +1758,9 @@ enum bt_msg_iter_status handle_state(struct bt_msg_iter *notit) case STATE_CHECK_EMIT_MSG_STREAM_END: status = check_emit_msg_stream_end(notit); break; + case STATE_EMIT_QUEUED_MSG_PACKET_END: + notit->state = STATE_EMIT_MSG_PACKET_END_SINGLE; + break; case STATE_EMIT_MSG_STREAM_END: notit->state = STATE_DONE; break; @@ -1827,14 +1857,15 @@ bt_field *borrow_next_field(struct bt_msg_iter *notit) break; } case BT_FIELD_CLASS_TYPE_STATIC_ARRAY: - case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY: + case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD: + case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD: BT_ASSERT(index < bt_field_array_get_length(base_field)); next_field = bt_field_array_borrow_element_field_by_index( base_field, index); break; case BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR: - case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_SELECTOR: - case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_SELECTOR: + case BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR: + case BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR: BT_ASSERT(index == 0); next_field = bt_field_variant_borrow_selected_option_field( base_field); @@ -1958,7 +1989,7 @@ update_def_clock: (uint64_t) int_fc->storing_index) = value; } - if (G_UNLIKELY(!fc->in_ir)) { + if (G_UNLIKELY(!fc->in_ir || notit->dry_run)) { goto end; } @@ -1995,7 +2026,7 @@ enum bt_bfcr_status bfcr_unsigned_int_char_cb(uint64_t value, BT_ASSERT(!int_fc->mapped_clock_class); BT_ASSERT(int_fc->storing_index < 0); - if (G_UNLIKELY(!fc->in_ir)) { + if (G_UNLIKELY(!fc->in_ir || notit->dry_run)) { goto end; } @@ -2047,7 +2078,7 @@ enum bt_bfcr_status bfcr_signed_int_cb(int64_t value, (uint64_t) int_fc->storing_index) = (uint64_t) value; } - if (G_UNLIKELY(!fc->in_ir)) { + if (G_UNLIKELY(!fc->in_ir || notit->dry_run)) { goto end; } @@ -2078,16 +2109,22 @@ enum bt_bfcr_status bfcr_floating_point_cb(double value, "fc-type=%d, fc-in-ir=%d, value=%f", notit, notit->bfcr, fc, fc->type, fc->in_ir, value); - if (G_UNLIKELY(!fc->in_ir)) { + if (G_UNLIKELY(!fc->in_ir || notit->dry_run)) { goto end; } field = borrow_next_field(notit); + bt_field_class_type type = bt_field_get_class_type(field); BT_ASSERT(field); BT_ASSERT(bt_field_borrow_class_const(field) == fc->ir_fc); - BT_ASSERT(bt_field_get_class_type(field) == - BT_FIELD_CLASS_TYPE_REAL); - bt_field_real_set_value(field, value); + BT_ASSERT(type == BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL || + type == BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL); + + if (type == BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL) { + bt_field_real_single_precision_set_value(field, (float) value); + } else { + bt_field_real_double_precision_set_value(field, value); + } stack_top(notit->stack)->index++; end: @@ -2106,7 +2143,7 @@ enum bt_bfcr_status bfcr_string_begin_cb( "fc-type=%d, fc-in-ir=%d", notit, notit->bfcr, fc, fc->type, fc->in_ir); - if (G_UNLIKELY(!fc->in_ir)) { + if (G_UNLIKELY(!fc->in_ir || notit->dry_run)) { goto end; } @@ -2143,7 +2180,7 @@ enum bt_bfcr_status bfcr_string_cb(const char *value, notit, notit->bfcr, fc, fc->type, fc->in_ir, len); - if (G_UNLIKELY(!fc->in_ir)) { + if (G_UNLIKELY(!fc->in_ir || notit->dry_run)) { goto end; } @@ -2175,7 +2212,7 @@ enum bt_bfcr_status bfcr_string_end_cb( "fc-type=%d, fc-in-ir=%d", notit, notit->bfcr, fc, fc->type, fc->in_ir); - if (G_UNLIKELY(!fc->in_ir)) { + if (G_UNLIKELY(!fc->in_ir || notit->dry_run)) { goto end; } @@ -2200,7 +2237,7 @@ enum bt_bfcr_status bfcr_compound_begin_cb( "fc-type=%d, fc-in-ir=%d", notit, notit->bfcr, fc, fc->type, fc->in_ir); - if (!fc->in_ir) { + if (G_UNLIKELY(!fc->in_ir || notit->dry_run)) { goto end; } @@ -2250,7 +2287,7 @@ enum bt_bfcr_status bfcr_compound_end_cb( "fc-type=%d, fc-in-ir=%d", notit, notit->bfcr, fc, fc->type, fc->in_ir); - if (!fc->in_ir) { + if (G_UNLIKELY(!fc->in_ir || notit->dry_run)) { goto end; } @@ -2298,6 +2335,11 @@ int64_t bfcr_get_sequence_length_cb(struct ctf_field_class *fc, void *data) length = (uint64_t) g_array_index(notit->stored_values, uint64_t, seq_fc->stored_length_index); + + if (G_UNLIKELY(notit->dry_run)){ + goto end; + } + seq_field = stack_top(notit->stack)->base; BT_ASSERT(seq_field); @@ -2309,7 +2351,9 @@ int64_t bfcr_get_sequence_length_cb(struct ctf_field_class *fc, void *data) */ if (!seq_fc->base.is_text) { BT_ASSERT(bt_field_get_class_type(seq_field) == - BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY); + BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD || + bt_field_get_class_type(seq_field) == + BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD); ret = bt_field_array_dynamic_set_length(seq_field, (uint64_t) length); if (ret) { @@ -2319,6 +2363,7 @@ int64_t bfcr_get_sequence_length_cb(struct ctf_field_class *fc, void *data) } } +end: return length; } @@ -2381,7 +2426,7 @@ struct ctf_field_class *bfcr_borrow_variant_selected_field_class_cb( selected_option = ctf_field_class_variant_borrow_option_by_index( var_fc, (uint64_t) option_index); - if (selected_option->fc->in_ir) { + if (selected_option->fc->in_ir && !notit->dry_run) { bt_field *var_field = stack_top(notit->stack)->base; ret = bt_field_variant_select_option_field_by_index( @@ -2447,20 +2492,13 @@ void create_msg_stream_end(struct bt_msg_iter *notit, bt_message **message) static void create_msg_packet_beginning(struct bt_msg_iter *notit, - bt_message **message) + bt_message **message, bool use_default_cs) { int ret; - enum bt_msg_iter_status status; bt_message *msg = NULL; - const bt_stream_class *sc; - - status = set_current_packet(notit); - if (status != BT_MSG_ITER_STATUS_OK) { - goto end; - } + const bt_stream_class *sc = notit->meta.sc->ir_sc; BT_ASSERT(notit->packet); - sc = notit->meta.sc->ir_sc; BT_ASSERT(sc); if (notit->packet_context_field) { @@ -2486,9 +2524,21 @@ void create_msg_packet_beginning(struct bt_msg_iter *notit, if (notit->meta.sc->packets_have_ts_begin) { BT_ASSERT(notit->snapshots.beginning_clock != UINT64_C(-1)); + uint64_t raw_cs_value; + + /* + * Either use the decoded packet `timestamp_begin` field or the + * current stream's default clock_snapshot. + */ + if (use_default_cs) { + raw_cs_value = notit->default_clock_snapshot; + } else { + raw_cs_value = notit->snapshots.beginning_clock; + } + msg = bt_message_packet_beginning_create_with_default_clock_snapshot( notit->msg_iter, notit->packet, - notit->snapshots.beginning_clock); + raw_cs_value); } else { msg = bt_message_packet_beginning_create(notit->msg_iter, notit->packet); @@ -2507,17 +2557,86 @@ end: return; } +static +void emit_delayed_packet_beg_msg(struct bt_msg_iter *notit, + bt_message **message) +{ + bool packet_beg_ts_need_fix_up; + + notit->emit_delayed_packet_beginning_msg = false; + + /* + * Only fix the packet's timestamp_begin if it's larger than the first + * event of the packet. If there was no event in the packet, the + * `default_clock_snapshot` field will be either equal or greater than + * `snapshots.beginning_clock` so there is not fix needed. + */ + packet_beg_ts_need_fix_up = + notit->default_clock_snapshot < notit->snapshots.beginning_clock; + + /* create_msg_packet_beginning() logs errors */ + create_msg_packet_beginning(notit, message, packet_beg_ts_need_fix_up); + + return; +} + + static void create_msg_packet_end(struct bt_msg_iter *notit, bt_message **message) { bt_message *msg; + bool update_default_cs = true; if (!notit->packet) { return; } - /* Update default clock from packet's end time */ - if (notit->snapshots.end_clock != UINT64_C(-1)) { + /* + * Check if we need to emit the delayed packet + * beginning message instead of the packet end message. + */ + if (G_UNLIKELY(notit->emit_delayed_packet_beginning_msg)) { + emit_delayed_packet_beg_msg(notit, message); + /* Don't forget to emit the packet end message. */ + notit->state = STATE_EMIT_QUEUED_MSG_PACKET_END; + return; + } + + /* Check if may be affected by lttng-crash timestamp_end quirk. */ + if (G_UNLIKELY(notit->meta.tc->quirks.lttng_crash)) { + /* + * Check if the `timestamp_begin` field is non-zero but + * `timestamp_end` is zero. It means the trace is affected by + * the lttng-crash packet `timestamp_end` quirk and must be + * fixed up by omitting to update the default clock snapshot to + * the `timestamp_end` as is typically done. + */ + if (notit->snapshots.beginning_clock != 0 && + notit->snapshots.end_clock == 0) { + update_default_cs = false; + } + } + + /* + * Check if may be affected by lttng event-after-packet `timestamp_end` + * quirk. + */ + if (notit->meta.tc->quirks.lttng_event_after_packet) { + /* + * Check if `timestamp_end` is smaller then the current + * default_clock_snapshot (which is set to the last event + * decoded). It means the trace is affected by the lttng + * `event-after-packet` packet `timestamp_end` quirk and must + * be fixed up by omitting to update the default clock snapshot + * to the `timestamp_end` as is typically done. + */ + if (notit->snapshots.end_clock < notit->default_clock_snapshot) { + update_default_cs = false; + } + } + + /* Update default clock from packet's end time. */ + if (notit->snapshots.end_clock != UINT64_C(-1) && update_default_cs) { notit->default_clock_snapshot = notit->snapshots.end_clock; } @@ -2527,7 +2646,7 @@ void create_msg_packet_end(struct bt_msg_iter *notit, bt_message **message) BT_ASSERT(notit->snapshots.end_clock != UINT64_C(-1)); msg = bt_message_packet_end_create_with_default_clock_snapshot( notit->msg_iter, notit->packet, - notit->snapshots.end_clock); + notit->default_clock_snapshot); } else { msg = bt_message_packet_end_create(notit->msg_iter, notit->packet); @@ -2761,8 +2880,27 @@ enum bt_msg_iter_status bt_msg_iter_get_next_message( switch (notit->state) { case STATE_EMIT_MSG_EVENT: BT_ASSERT(notit->event_msg); - *message = notit->event_msg; - notit->event_msg = NULL; + + /* + * Check if we need to emit the delayed packet + * beginning message instead of the event message. + */ + if (G_UNLIKELY(notit->emit_delayed_packet_beginning_msg)) { + emit_delayed_packet_beg_msg(notit, message); + if (!*message) { + status = BT_MSG_ITER_STATUS_ERROR; + } + + /* + * Don't forget to emit the event message of + * the event record that was just decoded. + */ + notit->state = STATE_EMIT_QUEUED_MSG_EVENT; + + } else { + *message = notit->event_msg; + notit->event_msg = NULL; + } goto end; case STATE_EMIT_MSG_DISCARDED_EVENTS: /* create_msg_discared_events() logs errors */ @@ -2783,11 +2921,26 @@ enum bt_msg_iter_status bt_msg_iter_get_next_message( goto end; case STATE_EMIT_MSG_PACKET_BEGINNING: - /* create_msg_packet_beginning() logs errors */ - create_msg_packet_beginning(notit, message); + status = set_current_packet(notit); + if (status != BT_MSG_ITER_STATUS_OK) { + goto end; + } - if (!*message) { - status = BT_MSG_ITER_STATUS_ERROR; + if (G_UNLIKELY(notit->meta.tc->quirks.barectf_event_before_packet)) { + notit->emit_delayed_packet_beginning_msg = true; + /* + * There is no message to return yet as this + * packet beginning message is delayed until we + * decode the first event message of the + * packet. + */ + break; + } else { + /* create_msg_packet_beginning() logs errors */ + create_msg_packet_beginning(notit, message, false); + if (!*message) { + status = BT_MSG_ITER_STATUS_ERROR; + } } goto end; @@ -2833,21 +2986,24 @@ end: } static -enum bt_msg_iter_status read_packet_header_context_fields( - struct bt_msg_iter *notit) +enum bt_msg_iter_status decode_until_state( struct bt_msg_iter *notit, + enum state target_state_1, enum state target_state_2) { - int ret; enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; BT_ASSERT(notit); notit->set_stream = false; - if (notit->state == STATE_EMIT_MSG_PACKET_BEGINNING) { - /* We're already there */ - goto end; - } + do { + /* + * Check if we reached the state at which we want to stop + * decoding. + */ + if (notit->state == target_state_1 || + notit->state == target_state_2) { + goto end; + } - while (true) { status = handle_state(notit); if (G_UNLIKELY(status == BT_MSG_ITER_STATUS_AGAIN)) { BT_COMP_LOGD_STR("Medium returned BT_MSG_ITER_STATUS_AGAIN."); @@ -2859,12 +3015,6 @@ enum bt_msg_iter_status read_packet_header_context_fields( } switch (notit->state) { - case STATE_EMIT_MSG_PACKET_BEGINNING: - /* - * Packet header and context fields are - * potentially decoded (or they don't exist). - */ - goto end; case STATE_INIT: case STATE_SWITCH_PACKET: case STATE_DSCOPE_TRACE_PACKET_HEADER_BEGIN: @@ -2879,25 +3029,58 @@ enum bt_msg_iter_status read_packet_header_context_fields( case STATE_EMIT_MSG_DISCARDED_EVENTS: case STATE_CHECK_EMIT_MSG_DISCARDED_PACKETS: case STATE_EMIT_MSG_DISCARDED_PACKETS: - /* Non-emitting state: continue */ + case STATE_EMIT_MSG_PACKET_BEGINNING: + case STATE_DSCOPE_EVENT_HEADER_BEGIN: + case STATE_DSCOPE_EVENT_HEADER_CONTINUE: + case STATE_AFTER_EVENT_HEADER: + case STATE_DSCOPE_EVENT_COMMON_CONTEXT_BEGIN: + case STATE_DSCOPE_EVENT_COMMON_CONTEXT_CONTINUE: + case STATE_DSCOPE_EVENT_SPEC_CONTEXT_BEGIN: + case STATE_DSCOPE_EVENT_SPEC_CONTEXT_CONTINUE: + case STATE_DSCOPE_EVENT_PAYLOAD_BEGIN: + case STATE_DSCOPE_EVENT_PAYLOAD_CONTINUE: + case STATE_EMIT_MSG_EVENT: + case STATE_EMIT_QUEUED_MSG_EVENT: + case STATE_SKIP_PACKET_PADDING: + case STATE_EMIT_MSG_PACKET_END_MULTI: + case STATE_EMIT_MSG_PACKET_END_SINGLE: + case STATE_EMIT_QUEUED_MSG_PACKET_END: + case STATE_CHECK_EMIT_MSG_STREAM_END: + case STATE_EMIT_MSG_STREAM_END: break; + case STATE_DONE: + /* fall-through */ default: - /* - * We should never get past the - * STATE_EMIT_MSG_PACKET_BEGINNING state. - */ + /* We should never get to the STATE_DONE state. */ BT_COMP_LOGF("Unexpected state: notit-addr=%p, state=%s", notit, state_string(notit->state)); abort(); } - } + } while (true); end: + return status; +} + +static +enum bt_msg_iter_status read_packet_header_context_fields( + struct bt_msg_iter *notit) +{ + int ret; + enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + + status = decode_until_state(notit, STATE_EMIT_MSG_PACKET_BEGINNING, -1); + if (status != BT_MSG_ITER_STATUS_OK) { + goto end; + } + ret = set_current_packet_content_sizes(notit); if (ret) { status = BT_MSG_ITER_STATUS_ERROR; + goto end; } +end: return status; } @@ -2947,6 +3130,42 @@ end: return ret; } +static +enum bt_msg_iter_status clock_snapshot_at_msg_iter_state( + struct bt_msg_iter *notit, enum state target_state_1, + enum state target_state_2, uint64_t *clock_snapshot) +{ + enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + + BT_ASSERT(notit); + BT_ASSERT(clock_snapshot); + status = decode_until_state(notit, target_state_1, target_state_2); + if (status != BT_MSG_ITER_STATUS_OK) { + goto end; + } + + *clock_snapshot = notit->default_clock_snapshot; +end: + return status; +} + +BT_HIDDEN +enum bt_msg_iter_status bt_msg_iter_curr_packet_first_event_clock_snapshot( + struct bt_msg_iter *notit, uint64_t *first_clock_snapshot) +{ + return clock_snapshot_at_msg_iter_state(notit, + STATE_AFTER_EVENT_HEADER, -1, first_clock_snapshot); +} + +BT_HIDDEN +enum bt_msg_iter_status bt_msg_iter_curr_packet_last_event_clock_snapshot( + struct bt_msg_iter *notit, uint64_t *last_clock_snapshot) +{ + return clock_snapshot_at_msg_iter_state(notit, + STATE_EMIT_MSG_PACKET_END_SINGLE, + STATE_EMIT_MSG_PACKET_END_MULTI, last_clock_snapshot); +} + BT_HIDDEN enum bt_msg_iter_status bt_msg_iter_get_packet_properties( struct bt_msg_iter *notit, @@ -2987,3 +3206,10 @@ void bt_msg_iter_set_emit_stream_end_message(struct bt_msg_iter *notit, { notit->emit_stream_end_msg = val; } + +BT_HIDDEN +void bt_msg_iter_set_dry_run(struct bt_msg_iter *notit, + bool val) +{ + notit->dry_run = val; +}