X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fplugins%2Fctf%2Fcommon%2Fmsg-iter%2Fmsg-iter.c;h=dd350c75ecfe4bb52f7b3b3904aeff1a5fed0334;hb=fe4df857056b4a03898f1031f136359ce733b0f5;hp=fe1d160d1cbe660ffd9b6582ed530cada8092b1b;hpb=d24d56638469189904fb6ddbb3c725817b3e9417;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 fe1d160d..dd350c75 100644
--- a/src/plugins/ctf/common/msg-iter/msg-iter.c
+++ b/src/plugins/ctf/common/msg-iter/msg-iter.c
@@ -26,7 +26,7 @@
 #define BT_COMP_LOG_SELF_COMP (notit->self_comp)
 #define BT_LOG_OUTPUT_LEVEL (notit->log_level)
 #define BT_LOG_TAG "PLUGIN/CTF/MSG-ITER"
-#include "plugins/comp-logging.h"
+#include "logging/comp-logging.h"
 
 #include <stdint.h>
 #include <inttypes.h>
@@ -80,6 +80,7 @@ struct stack {
 /* State */
 enum state {
 	STATE_INIT,
+	STATE_SWITCH_PACKET,
 	STATE_DSCOPE_TRACE_PACKET_HEADER_BEGIN,
 	STATE_DSCOPE_TRACE_PACKET_HEADER_CONTINUE,
 	STATE_AFTER_TRACE_PACKET_HEADER,
@@ -88,7 +89,6 @@ enum state {
 	STATE_AFTER_STREAM_PACKET_CONTEXT,
 	STATE_CHECK_EMIT_MSG_STREAM_BEGINNING,
 	STATE_EMIT_MSG_STREAM_BEGINNING,
-	STATE_EMIT_MSG_STREAM_ACTIVITY_BEGINNING,
 	STATE_CHECK_EMIT_MSG_DISCARDED_EVENTS,
 	STATE_CHECK_EMIT_MSG_DISCARDED_PACKETS,
 	STATE_EMIT_MSG_DISCARDED_EVENTS,
@@ -104,11 +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_ACTIVITY_END,
-	STATE_EMIT_MSG_STREAM_ACTIVITY_END,
+	STATE_CHECK_EMIT_MSG_STREAM_END,
+	STATE_EMIT_QUEUED_MSG_PACKET_END,
 	STATE_EMIT_MSG_STREAM_END,
 	STATE_DONE,
 };
@@ -128,15 +129,18 @@ struct bt_msg_iter {
 	/* Current message iterator to create messages (weak) */
 	bt_self_message_iterator *msg_iter;
 
-	/*
-	 * True to emit stream beginning and stream activity beginning
-	 * messages.
-	 */
+	/* True to emit a stream beginning message. */
 	bool emit_stream_begin_msg;
 
-	/* True to emit stream end and stream activity end messages */
+	/* 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;
 
@@ -179,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;
@@ -263,69 +273,68 @@ const char *state_string(enum state state)
 {
 	switch (state) {
 	case STATE_INIT:
-		return "STATE_INIT";
+		return "INIT";
+	case STATE_SWITCH_PACKET:
+		return "SWITCH_PACKET";
 	case STATE_DSCOPE_TRACE_PACKET_HEADER_BEGIN:
-		return "STATE_DSCOPE_TRACE_PACKET_HEADER_BEGIN";
+		return "DSCOPE_TRACE_PACKET_HEADER_BEGIN";
 	case STATE_DSCOPE_TRACE_PACKET_HEADER_CONTINUE:
-		return "STATE_DSCOPE_TRACE_PACKET_HEADER_CONTINUE";
+		return "DSCOPE_TRACE_PACKET_HEADER_CONTINUE";
 	case STATE_AFTER_TRACE_PACKET_HEADER:
-		return "STATE_AFTER_TRACE_PACKET_HEADER";
+		return "AFTER_TRACE_PACKET_HEADER";
 	case STATE_DSCOPE_STREAM_PACKET_CONTEXT_BEGIN:
-		return "STATE_DSCOPE_STREAM_PACKET_CONTEXT_BEGIN";
+		return "DSCOPE_STREAM_PACKET_CONTEXT_BEGIN";
 	case STATE_DSCOPE_STREAM_PACKET_CONTEXT_CONTINUE:
-		return "STATE_DSCOPE_STREAM_PACKET_CONTEXT_CONTINUE";
+		return "DSCOPE_STREAM_PACKET_CONTEXT_CONTINUE";
 	case STATE_AFTER_STREAM_PACKET_CONTEXT:
-		return "STATE_AFTER_STREAM_PACKET_CONTEXT";
+		return "AFTER_STREAM_PACKET_CONTEXT";
 	case STATE_EMIT_MSG_STREAM_BEGINNING:
-		return "STATE_EMIT_MSG_STREAM_BEGINNING";
-	case STATE_EMIT_MSG_STREAM_ACTIVITY_BEGINNING:
-		return "STATE_EMIT_MSG_STREAM_ACTIVITY_BEGINNING";
+		return "EMIT_MSG_STREAM_BEGINNING";
 	case STATE_EMIT_MSG_PACKET_BEGINNING:
-		return "STATE_EMIT_MSG_PACKET_BEGINNING";
+		return "EMIT_MSG_PACKET_BEGINNING";
 	case STATE_EMIT_MSG_DISCARDED_EVENTS:
-		return "STATE_EMIT_MSG_DISCARDED_EVENTS";
+		return "EMIT_MSG_DISCARDED_EVENTS";
 	case STATE_EMIT_MSG_DISCARDED_PACKETS:
-		return "STATE_EMIT_MSG_DISCARDED_PACKETS";
+		return "EMIT_MSG_DISCARDED_PACKETS";
 	case STATE_DSCOPE_EVENT_HEADER_BEGIN:
-		return "STATE_DSCOPE_EVENT_HEADER_BEGIN";
+		return "DSCOPE_EVENT_HEADER_BEGIN";
 	case STATE_DSCOPE_EVENT_HEADER_CONTINUE:
-		return "STATE_DSCOPE_EVENT_HEADER_CONTINUE";
+		return "DSCOPE_EVENT_HEADER_CONTINUE";
 	case STATE_AFTER_EVENT_HEADER:
-		return "STATE_AFTER_EVENT_HEADER";
+		return "AFTER_EVENT_HEADER";
 	case STATE_DSCOPE_EVENT_COMMON_CONTEXT_BEGIN:
-		return "STATE_DSCOPE_EVENT_COMMON_CONTEXT_BEGIN";
+		return "DSCOPE_EVENT_COMMON_CONTEXT_BEGIN";
 	case STATE_DSCOPE_EVENT_COMMON_CONTEXT_CONTINUE:
-		return "STATE_DSCOPE_EVENT_COMMON_CONTEXT_CONTINUE";
+		return "DSCOPE_EVENT_COMMON_CONTEXT_CONTINUE";
 	case STATE_DSCOPE_EVENT_SPEC_CONTEXT_BEGIN:
-		return "STATE_DSCOPE_EVENT_SPEC_CONTEXT_BEGIN";
+		return "DSCOPE_EVENT_SPEC_CONTEXT_BEGIN";
 	case STATE_DSCOPE_EVENT_SPEC_CONTEXT_CONTINUE:
-		return "STATE_DSCOPE_EVENT_SPEC_CONTEXT_CONTINUE";
+		return "DSCOPE_EVENT_SPEC_CONTEXT_CONTINUE";
 	case STATE_DSCOPE_EVENT_PAYLOAD_BEGIN:
-		return "STATE_DSCOPE_EVENT_PAYLOAD_BEGIN";
+		return "DSCOPE_EVENT_PAYLOAD_BEGIN";
 	case STATE_DSCOPE_EVENT_PAYLOAD_CONTINUE:
-		return "STATE_DSCOPE_EVENT_PAYLOAD_CONTINUE";
+		return "DSCOPE_EVENT_PAYLOAD_CONTINUE";
 	case STATE_EMIT_MSG_EVENT:
-		return "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 "STATE_SKIP_PACKET_PADDING";
+		return "SKIP_PACKET_PADDING";
 	case STATE_EMIT_MSG_PACKET_END_MULTI:
-		return "STATE_EMIT_MSG_PACKET_END_MULTI";
+		return "EMIT_MSG_PACKET_END_MULTI";
 	case STATE_EMIT_MSG_PACKET_END_SINGLE:
-		return "STATE_EMIT_MSG_PACKET_END_SINGLE";
-	case STATE_EMIT_MSG_STREAM_ACTIVITY_END:
-		return "STATE_EMIT_MSG_STREAM_ACTIVITY_END";
+		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 "STATE_EMIT_MSG_STREAM_END";
+		return "EMIT_MSG_STREAM_END";
 	case STATE_DONE:
-		return "STATE_DONE";
+		return "DONE";
 	default:
 		return "(unknown)";
 	}
 }
 
-static
-int bt_msg_iter_switch_packet(struct bt_msg_iter *notit);
-
 static
 struct stack *stack_new(struct bt_msg_iter *notit)
 {
@@ -686,6 +695,71 @@ void release_all_dscopes(struct bt_msg_iter *notit)
 	release_event_dscopes(notit);
 }
 
+static
+enum bt_msg_iter_status switch_packet_state(struct bt_msg_iter *notit)
+{
+	enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK;
+
+	/*
+	 * We don't put the stream class here because we need to make
+	 * sure that all the packets processed by the same message
+	 * iterator refer to the same stream class (the first one).
+	 */
+	BT_ASSERT(notit);
+
+	if (notit->cur_exp_packet_total_size != -1) {
+		notit->cur_packet_offset += notit->cur_exp_packet_total_size;
+	}
+
+	BT_COMP_LOGD("Switching packet: notit-addr=%p, cur=%zu, "
+		"packet-offset=%" PRId64, notit, notit->buf.at,
+		notit->cur_packet_offset);
+	stack_clear(notit->stack);
+	notit->meta.ec = NULL;
+	BT_PACKET_PUT_REF_AND_RESET(notit->packet);
+	BT_MESSAGE_PUT_REF_AND_RESET(notit->event_msg);
+	release_all_dscopes(notit);
+	notit->cur_dscope_field = NULL;
+
+	/*
+	 * Adjust current buffer so that addr points to the beginning of the new
+	 * packet.
+	 */
+	if (notit->buf.addr) {
+		size_t consumed_bytes = (size_t) (notit->buf.at / CHAR_BIT);
+
+		/* Packets are assumed to start on a byte frontier. */
+		if (notit->buf.at % CHAR_BIT) {
+			BT_COMP_LOGW("Cannot switch packet: current position is not a multiple of 8: "
+				"notit-addr=%p, cur=%zu", notit, notit->buf.at);
+			status = BT_MSG_ITER_STATUS_ERROR;
+			goto end;
+		}
+
+		notit->buf.addr += consumed_bytes;
+		notit->buf.sz -= consumed_bytes;
+		notit->buf.at = 0;
+		notit->buf.packet_offset = 0;
+		BT_COMP_LOGD("Adjusted buffer: addr=%p, size=%zu",
+			notit->buf.addr, notit->buf.sz);
+	}
+
+	notit->cur_exp_packet_content_size = -1;
+	notit->cur_exp_packet_total_size = -1;
+	notit->cur_stream_class_id = -1;
+	notit->cur_event_class_id = -1;
+	notit->cur_data_stream_id = -1;
+	notit->prev_packet_snapshots = notit->snapshots;
+	notit->snapshots.discarded_events = UINT64_C(-1);
+	notit->snapshots.packets = UINT64_C(-1);
+	notit->snapshots.beginning_clock = UINT64_C(-1);
+	notit->snapshots.end_clock = UINT64_C(-1);
+	notit->state = STATE_DSCOPE_TRACE_PACKET_HEADER_BEGIN;
+
+end:
+	return status;
+}
+
 static
 enum bt_msg_iter_status read_packet_header_begin_state(
 		struct bt_msg_iter *notit)
@@ -693,12 +767,6 @@ enum bt_msg_iter_status read_packet_header_begin_state(
 	struct ctf_field_class *packet_header_fc = NULL;
 	enum bt_msg_iter_status ret = BT_MSG_ITER_STATUS_OK;
 
-	if (bt_msg_iter_switch_packet(notit)) {
-		BT_COMP_LOGW("Cannot switch packet: notit-addr=%p", notit);
-		ret = BT_MSG_ITER_STATUS_ERROR;
-		goto end;
-	}
-
 	/*
 	 * Make sure at least one bit is available for this packet. An
 	 * empty packet is impossible. If we reach the end of the medium
@@ -710,7 +778,7 @@ enum bt_msg_iter_status read_packet_header_begin_state(
 		break;
 	case BT_MSG_ITER_STATUS_EOF:
 		ret = BT_MSG_ITER_STATUS_OK;
-		notit->state = STATE_CHECK_EMIT_MSG_STREAM_ACTIVITY_END;
+		notit->state = STATE_CHECK_EMIT_MSG_STREAM_END;
 		goto end;
 	default:
 		goto end;
@@ -927,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
@@ -1206,11 +1274,11 @@ enum bt_msg_iter_status set_current_event_message(
 	BT_ASSERT(notit->meta.sc);
 
 	if (bt_stream_class_borrow_default_clock_class(notit->meta.sc->ir_sc)) {
-		msg = bt_message_event_create_with_default_clock_snapshot(
+		msg = bt_message_event_create_with_packet_and_default_clock_snapshot(
 			notit->msg_iter, notit->meta.ec->ir_ec,
 			notit->packet, notit->default_clock_snapshot);
 	} else {
-		msg = bt_message_event_create(notit->msg_iter,
+		msg = bt_message_event_create_with_packet(notit->msg_iter,
 			notit->meta.ec->ir_ec, notit->packet);
 	}
 
@@ -1246,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;
@@ -1254,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:
@@ -1273,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(
@@ -1326,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(
@@ -1382,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(
@@ -1429,11 +1503,12 @@ enum bt_msg_iter_status skip_packet_padding_state(struct bt_msg_iter *notit)
 {
 	enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK;
 	size_t bits_to_skip;
+	const enum state next_state = STATE_SWITCH_PACKET;
 
 	BT_ASSERT(notit->cur_exp_packet_total_size > 0);
 	bits_to_skip = notit->cur_exp_packet_total_size - packet_at(notit);
 	if (bits_to_skip == 0) {
-		notit->state = STATE_DSCOPE_TRACE_PACKET_HEADER_BEGIN;
+		notit->state = next_state;
 		goto end;
 	} else {
 		size_t bits_to_consume;
@@ -1452,7 +1527,7 @@ enum bt_msg_iter_status skip_packet_padding_state(struct bt_msg_iter *notit)
 		bits_to_skip = notit->cur_exp_packet_total_size -
 			packet_at(notit);
 		if (bits_to_skip == 0) {
-			notit->state = STATE_DSCOPE_TRACE_PACKET_HEADER_BEGIN;
+			notit->state = next_state;
 			goto end;
 		}
 	}
@@ -1570,11 +1645,11 @@ end:
 }
 
 static
-enum bt_msg_iter_status check_emit_msg_stream_activity_end(
+enum bt_msg_iter_status check_emit_msg_stream_end(
 		struct bt_msg_iter *notit)
 {
 	if (notit->emit_stream_end_msg) {
-		notit->state = STATE_EMIT_MSG_STREAM_ACTIVITY_END;
+		notit->state = STATE_EMIT_MSG_STREAM_END;
 	} else {
 		notit->state = STATE_DONE;
 	}
@@ -1594,7 +1669,10 @@ enum bt_msg_iter_status handle_state(struct bt_msg_iter *notit)
 	// TODO: optimalize!
 	switch (state) {
 	case STATE_INIT:
-		notit->state = STATE_DSCOPE_TRACE_PACKET_HEADER_BEGIN;
+		notit->state = STATE_SWITCH_PACKET;
+		break;
+	case STATE_SWITCH_PACKET:
+		status = switch_packet_state(notit);
 		break;
 	case STATE_DSCOPE_TRACE_PACKET_HEADER_BEGIN:
 		status = read_packet_header_begin_state(notit);
@@ -1618,9 +1696,6 @@ enum bt_msg_iter_status handle_state(struct bt_msg_iter *notit)
 		status = check_emit_msg_stream_beginning_state(notit);
 		break;
 	case STATE_EMIT_MSG_STREAM_BEGINNING:
-		notit->state = STATE_EMIT_MSG_STREAM_ACTIVITY_BEGINNING;
-		break;
-	case STATE_EMIT_MSG_STREAM_ACTIVITY_BEGINNING:
 		notit->state = STATE_CHECK_EMIT_MSG_DISCARDED_EVENTS;
 		break;
 	case STATE_CHECK_EMIT_MSG_DISCARDED_EVENTS:
@@ -1668,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;
@@ -1675,13 +1753,13 @@ enum bt_msg_iter_status handle_state(struct bt_msg_iter *notit)
 		notit->state = STATE_SKIP_PACKET_PADDING;
 		break;
 	case STATE_EMIT_MSG_PACKET_END_SINGLE:
-		notit->state = STATE_CHECK_EMIT_MSG_STREAM_ACTIVITY_END;
+		notit->state = STATE_CHECK_EMIT_MSG_STREAM_END;
 		break;
-	case STATE_CHECK_EMIT_MSG_STREAM_ACTIVITY_END:
-		status = check_emit_msg_stream_activity_end(notit);
+	case STATE_CHECK_EMIT_MSG_STREAM_END:
+		status = check_emit_msg_stream_end(notit);
 		break;
-	case STATE_EMIT_MSG_STREAM_ACTIVITY_END:
-		notit->state = STATE_EMIT_MSG_STREAM_END;
+	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;
@@ -1743,8 +1821,6 @@ void bt_msg_iter_reset(struct bt_msg_iter *notit)
 	bt_msg_iter_reset_for_next_stream_file(notit);
 	notit->cur_stream_class_id = -1;
 	notit->cur_data_stream_id = -1;
-	notit->emit_stream_begin_msg = true;
-	notit->emit_stream_end_msg = true;
 	notit->snapshots.discarded_events = UINT64_C(-1);
 	notit->snapshots.packets = UINT64_C(-1);
 	notit->prev_packet_snapshots.discarded_events = UINT64_C(-1);
@@ -1753,70 +1829,6 @@ void bt_msg_iter_reset(struct bt_msg_iter *notit)
 	notit->prev_packet_snapshots.end_clock = UINT64_C(-1);
 }
 
-static
-int bt_msg_iter_switch_packet(struct bt_msg_iter *notit)
-{
-	int ret = 0;
-
-	/*
-	 * We don't put the stream class here because we need to make
-	 * sure that all the packets processed by the same message
-	 * iterator refer to the same stream class (the first one).
-	 */
-	BT_ASSERT(notit);
-
-	if (notit->cur_exp_packet_total_size != -1) {
-		notit->cur_packet_offset += notit->cur_exp_packet_total_size;
-	}
-
-	BT_COMP_LOGD("Switching packet: notit-addr=%p, cur=%zu, "
-		"packet-offset=%" PRId64, notit, notit->buf.at,
-		notit->cur_packet_offset);
-	stack_clear(notit->stack);
-	notit->meta.ec = NULL;
-	BT_PACKET_PUT_REF_AND_RESET(notit->packet);
-	BT_MESSAGE_PUT_REF_AND_RESET(notit->event_msg);
-	release_all_dscopes(notit);
-	notit->cur_dscope_field = NULL;
-
-	/*
-	 * Adjust current buffer so that addr points to the beginning of the new
-	 * packet.
-	 */
-	if (notit->buf.addr) {
-		size_t consumed_bytes = (size_t) (notit->buf.at / CHAR_BIT);
-
-		/* Packets are assumed to start on a byte frontier. */
-		if (notit->buf.at % CHAR_BIT) {
-			BT_COMP_LOGW("Cannot switch packet: current position is not a multiple of 8: "
-				"notit-addr=%p, cur=%zu", notit, notit->buf.at);
-			ret = -1;
-			goto end;
-		}
-
-		notit->buf.addr += consumed_bytes;
-		notit->buf.sz -= consumed_bytes;
-		notit->buf.at = 0;
-		notit->buf.packet_offset = 0;
-		BT_COMP_LOGD("Adjusted buffer: addr=%p, size=%zu",
-			notit->buf.addr, notit->buf.sz);
-	}
-
-	notit->cur_exp_packet_content_size = -1;
-	notit->cur_exp_packet_total_size = -1;
-	notit->cur_stream_class_id = -1;
-	notit->cur_event_class_id = -1;
-	notit->cur_data_stream_id = -1;
-	notit->prev_packet_snapshots = notit->snapshots;
-	notit->snapshots.discarded_events = UINT64_C(-1);
-	notit->snapshots.packets = UINT64_C(-1);
-	notit->snapshots.beginning_clock = UINT64_C(-1);
-	notit->snapshots.end_clock = UINT64_C(-1);
-
-end:
-	return ret;
-}
-
 static
 bt_field *borrow_next_field(struct bt_msg_iter *notit)
 {
@@ -1850,7 +1862,9 @@ bt_field *borrow_next_field(struct bt_msg_iter *notit)
 		next_field = bt_field_array_borrow_element_field_by_index(
 			base_field, index);
 		break;
-	case BT_FIELD_CLASS_TYPE_VARIANT:
+	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:
 		BT_ASSERT(index == 0);
 		next_field = bt_field_variant_borrow_selected_option_field(
 			base_field);
@@ -1974,7 +1988,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;
 	}
 
@@ -1985,7 +1999,7 @@ update_def_clock:
 		  BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER ||
 		  bt_field_get_class_type(field) ==
 		  BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION);
-	bt_field_unsigned_integer_set_value(field, value);
+	bt_field_integer_unsigned_set_value(field, value);
 	stack_top(notit->stack)->index++;
 
 end:
@@ -2011,7 +2025,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;
 	}
 
@@ -2063,7 +2077,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;
 	}
 
@@ -2074,7 +2088,7 @@ enum bt_bfcr_status bfcr_signed_int_cb(int64_t value,
 		  BT_FIELD_CLASS_TYPE_SIGNED_INTEGER ||
 		  bt_field_get_class_type(field) ==
 		  BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION);
-	bt_field_signed_integer_set_value(field, value);
+	bt_field_integer_signed_set_value(field, value);
 	stack_top(notit->stack)->index++;
 
 end:
@@ -2094,16 +2108,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:
@@ -2122,7 +2142,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;
 	}
 
@@ -2159,7 +2179,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;
 	}
 
@@ -2191,7 +2211,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;
 	}
 
@@ -2216,7 +2236,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;
 	}
 
@@ -2266,7 +2286,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;
 	}
 
@@ -2314,6 +2334,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);
 
@@ -2326,7 +2351,7 @@ 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);
-		ret = bt_field_dynamic_array_set_length(seq_field,
+		ret = bt_field_array_dynamic_set_length(seq_field,
 			(uint64_t) length);
 		if (ret) {
 			BT_COMP_LOGE("Cannot set dynamic array field's length field: "
@@ -2335,6 +2360,7 @@ int64_t bfcr_get_sequence_length_cb(struct ctf_field_class *fc, void *data)
 		}
 	}
 
+end:
 	return length;
 }
 
@@ -2397,10 +2423,10 @@ 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(
+		ret = bt_field_variant_select_option_field_by_index(
 			var_field, option_index);
 		if (ret) {
 			BT_COMP_LOGW("Cannot select variant field's option field: "
@@ -2437,52 +2463,6 @@ void create_msg_stream_beginning(struct bt_msg_iter *notit,
 	*message = ret;
 }
 
-static
-void create_msg_stream_activity_beginning(struct bt_msg_iter *notit,
-		bt_message **message)
-{
-	bt_message *ret = NULL;
-
-	BT_ASSERT(notit->stream);
-	BT_ASSERT(notit->msg_iter);
-	ret = bt_message_stream_activity_beginning_create(notit->msg_iter,
-		notit->stream);
-	if (!ret) {
-		BT_COMP_LOGE("Cannot create stream activity beginning message: "
-			"notit-addr=%p, stream-addr=%p",
-			notit, notit->stream);
-		return;
-	}
-
-	*message = ret;
-}
-
-static
-void create_msg_stream_activity_end(struct bt_msg_iter *notit,
-		bt_message **message)
-{
-	bt_message *ret = NULL;
-
-	if (!notit->stream) {
-		BT_COMP_LOGE("Cannot create stream for stream message: "
-			"notit-addr=%p", notit);
-		return;
-	}
-
-	BT_ASSERT(notit->stream);
-	BT_ASSERT(notit->msg_iter);
-	ret = bt_message_stream_activity_end_create(notit->msg_iter,
-		notit->stream);
-	if (!ret) {
-		BT_COMP_LOGE("Cannot create stream activity end message: "
-			"notit-addr=%p, stream-addr=%p",
-			notit, notit->stream);
-		return;
-	}
-
-	*message = ret;
-}
-
 static
 void create_msg_stream_end(struct bt_msg_iter *notit, bt_message **message)
 {
@@ -2509,20 +2489,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) {
@@ -2548,9 +2521,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);
@@ -2569,17 +2554,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;
 	}
 
@@ -2589,7 +2643,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);
@@ -2823,8 +2877,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 */
@@ -2845,11 +2918,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;
@@ -2862,24 +2950,6 @@ enum bt_msg_iter_status bt_msg_iter_get_next_message(
 				status = BT_MSG_ITER_STATUS_ERROR;
 			}
 
-			goto end;
-		case STATE_EMIT_MSG_STREAM_ACTIVITY_BEGINNING:
-			/* create_msg_stream_activity_beginning() logs errors */
-			create_msg_stream_activity_beginning(notit, message);
-
-			if (!*message) {
-				status = BT_MSG_ITER_STATUS_ERROR;
-			}
-
-			goto end;
-		case STATE_EMIT_MSG_STREAM_ACTIVITY_END:
-			/* create_msg_stream_activity_end() logs errors */
-			create_msg_stream_activity_end(notit, message);
-
-			if (!*message) {
-				status = BT_MSG_ITER_STATUS_ERROR;
-			}
-
 			goto end;
 		case STATE_EMIT_MSG_STREAM_BEGINNING:
 			/* create_msg_stream_beginning() logs errors */
@@ -2913,21 +2983,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.");
@@ -2939,13 +3012,8 @@ 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:
 		case STATE_DSCOPE_TRACE_PACKET_HEADER_CONTINUE:
 		case STATE_AFTER_TRACE_PACKET_HEADER:
@@ -2954,30 +3022,62 @@ enum bt_msg_iter_status read_packet_header_context_fields(
 		case STATE_AFTER_STREAM_PACKET_CONTEXT:
 		case STATE_CHECK_EMIT_MSG_STREAM_BEGINNING:
 		case STATE_EMIT_MSG_STREAM_BEGINNING:
-		case STATE_EMIT_MSG_STREAM_ACTIVITY_BEGINNING:
 		case STATE_CHECK_EMIT_MSG_DISCARDED_EVENTS:
 		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;
 }
 
@@ -2998,7 +3098,7 @@ enum bt_msg_iter_status bt_msg_iter_seek(struct bt_msg_iter *notit,
 
 	BT_ASSERT(notit);
 	if (offset < 0) {
-		BT_COMP_LOGE("Cannot seek to negative offset: offset=%jd", offset);
+		BT_COMP_LOGE("Cannot seek to negative offset: offset=%jd", (intmax_t) offset);
 		ret = BT_MSG_ITER_STATUS_INVAL;
 		goto end;
 	}
@@ -3027,6 +3127,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,
@@ -3067,3 +3203,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;
+}