From 18a1979b5eae4e700e0e6716d83ca909f508d3e0 Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Mon, 4 Nov 2019 11:33:33 -0500 Subject: [PATCH] ctf: rename bt_msg_iter to ctf_msg_iter The bt_msg_iter structure is specific to iterating on CTF messages, so it would be more appropriate for it to be called ctf_msg_iter. Rename it, as well as related types and functions. Change-Id: I0ce498e492295a3f7390d73d921ef2eca1cc6d00 Signed-off-by: Simon Marchi Reviewed-on: https://review.lttng.org/c/babeltrace/+/2322 Tested-by: jenkins Reviewed-by: Francis Deslauriers --- src/plugins/ctf/common/msg-iter/msg-iter.c | 440 +++++++++--------- src/plugins/ctf/common/msg-iter/msg-iter.h | 154 +++--- src/plugins/ctf/fs-src/data-stream-file.c | 76 +-- src/plugins/ctf/fs-src/data-stream-file.h | 6 +- src/plugins/ctf/fs-src/fs.c | 42 +- src/plugins/ctf/fs-src/fs.h | 2 +- src/plugins/ctf/lttng-live/data-stream.c | 26 +- src/plugins/ctf/lttng-live/lttng-live.c | 22 +- src/plugins/ctf/lttng-live/lttng-live.h | 4 +- .../ctf/lttng-live/viewer-connection.c | 14 +- 10 files changed, 393 insertions(+), 393 deletions(-) diff --git a/src/plugins/ctf/common/msg-iter/msg-iter.c b/src/plugins/ctf/common/msg-iter/msg-iter.c index abf58fbe..8f0d663c 100644 --- a/src/plugins/ctf/common/msg-iter/msg-iter.c +++ b/src/plugins/ctf/common/msg-iter/msg-iter.c @@ -43,7 +43,7 @@ #include "msg-iter.h" #include "../bfcr/bfcr.h" -struct bt_msg_iter; +struct ctf_msg_iter; /* A visit stack entry */ struct stack_entry { @@ -64,11 +64,11 @@ struct stack_entry { size_t index; }; -struct bt_msg_iter; +struct ctf_msg_iter; /* Visit stack */ struct stack { - struct bt_msg_iter *msg_it; + struct ctf_msg_iter *msg_it; /* Entries (struct stack_entry) */ GArray *entries; @@ -122,7 +122,7 @@ struct end_of_packet_snapshots { }; /* CTF message iterator */ -struct bt_msg_iter { +struct ctf_msg_iter { /* Visit stack */ struct stack *stack; @@ -223,7 +223,7 @@ struct bt_msg_iter { /* Current medium data */ struct { - struct bt_msg_iter_medium_ops medops; + struct ctf_msg_iter_medium_ops medops; size_t max_request_sz; void *data; } medium; @@ -336,7 +336,7 @@ const char *state_string(enum state state) } static -struct stack *stack_new(struct bt_msg_iter *msg_it) +struct stack *stack_new(struct ctf_msg_iter *msg_it) { bt_self_component *self_comp = msg_it->self_comp; struct stack *stack = NULL; @@ -370,7 +370,7 @@ end: static void stack_destroy(struct stack *stack) { - struct bt_msg_iter *msg_it; + struct ctf_msg_iter *msg_it; BT_ASSERT_DBG(stack); msg_it = stack->msg_it; @@ -387,7 +387,7 @@ static void stack_push(struct stack *stack, bt_field *base) { struct stack_entry *entry; - struct bt_msg_iter *msg_it; + struct ctf_msg_iter *msg_it; BT_ASSERT_DBG(stack); msg_it = stack->msg_it; @@ -416,7 +416,7 @@ unsigned int stack_size(struct stack *stack) static void stack_pop(struct stack *stack) { - struct bt_msg_iter *msg_it; + struct ctf_msg_iter *msg_it; BT_ASSERT_DBG(stack); BT_ASSERT_DBG(stack_size(stack)); @@ -450,33 +450,33 @@ void stack_clear(struct stack *stack) } static inline -enum bt_msg_iter_status msg_iter_status_from_m_status( - enum bt_msg_iter_medium_status m_status) +enum ctf_msg_iter_status msg_iter_status_from_m_status( + enum ctf_msg_iter_medium_status m_status) { /* They are the same */ return (int) m_status; } static inline -size_t buf_size_bits(struct bt_msg_iter *msg_it) +size_t buf_size_bits(struct ctf_msg_iter *msg_it) { return msg_it->buf.sz * 8; } static inline -size_t buf_available_bits(struct bt_msg_iter *msg_it) +size_t buf_available_bits(struct ctf_msg_iter *msg_it) { return buf_size_bits(msg_it) - msg_it->buf.at; } static inline -size_t packet_at(struct bt_msg_iter *msg_it) +size_t packet_at(struct ctf_msg_iter *msg_it) { return msg_it->buf.packet_offset + msg_it->buf.at; } static inline -void buf_consume_bits(struct bt_msg_iter *msg_it, size_t incr) +void buf_consume_bits(struct ctf_msg_iter *msg_it, size_t incr) { BT_COMP_LOGT("Advancing cursor: msg-it-addr=%p, cur-before=%zu, cur-after=%zu", msg_it, msg_it->buf.at, msg_it->buf.at + incr); @@ -484,13 +484,13 @@ void buf_consume_bits(struct bt_msg_iter *msg_it, size_t incr) } static -enum bt_msg_iter_status request_medium_bytes( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status request_medium_bytes( + struct ctf_msg_iter *msg_it) { bt_self_component *self_comp = msg_it->self_comp; uint8_t *buffer_addr = NULL; size_t buffer_sz = 0; - enum bt_msg_iter_medium_status m_status; + enum ctf_msg_iter_medium_status m_status; BT_COMP_LOGD("Calling user function (request bytes): msg-it-addr=%p, " "request-size=%zu", msg_it, msg_it->medium.max_request_sz); @@ -498,9 +498,9 @@ enum bt_msg_iter_status request_medium_bytes( msg_it->medium.max_request_sz, &buffer_addr, &buffer_sz, msg_it->medium.data); BT_COMP_LOGD("User function returned: status=%s, buf-addr=%p, buf-size=%zu", - bt_msg_iter_medium_status_string(m_status), + ctf_msg_iter_medium_status_string(m_status), buffer_addr, buffer_sz); - if (m_status == BT_MSG_ITER_MEDIUM_STATUS_OK) { + if (m_status == CTF_MSG_ITER_MEDIUM_STATUS_OK) { BT_ASSERT(buffer_sz != 0); /* New packet offset is old one + old size (in bits) */ @@ -522,7 +522,7 @@ enum bt_msg_iter_status request_medium_bytes( msg_it->buf.sz, msg_it->buf.addr); BT_COMP_LOGD_MEM(buffer_addr, buffer_sz, "Returned bytes at %p:", buffer_addr); - } else if (m_status == BT_MSG_ITER_MEDIUM_STATUS_EOF) { + } else if (m_status == CTF_MSG_ITER_MEDIUM_STATUS_EOF) { /* * User returned end of stream: validate that we're not * in the middle of a packet header, packet context, or @@ -549,15 +549,15 @@ enum bt_msg_iter_status request_medium_bytes( "User function returned %s, but message iterator is in an unexpected state: " "state=%s, cur-packet-size=%" PRId64 ", cur=%zu, " "packet-cur=%zu, last-eh-at=%zu", - bt_msg_iter_medium_status_string(m_status), + ctf_msg_iter_medium_status_string(m_status), state_string(msg_it->state), msg_it->cur_exp_packet_total_size, msg_it->buf.at, packet_at(msg_it), msg_it->buf.last_eh_at); - m_status = BT_MSG_ITER_MEDIUM_STATUS_ERROR; + m_status = CTF_MSG_ITER_MEDIUM_STATUS_ERROR; } else if (m_status < 0) { BT_COMP_LOGE_APPEND_CAUSE(self_comp, "User function failed: " - "status=%s", bt_msg_iter_medium_status_string(m_status)); + "status=%s", ctf_msg_iter_medium_status_string(m_status)); } end: @@ -565,14 +565,14 @@ end: } static inline -enum bt_msg_iter_status buf_ensure_available_bits( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status buf_ensure_available_bits( + struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; if (G_UNLIKELY(buf_available_bits(msg_it) == 0)) { /* - * This _cannot_ return BT_MSG_ITER_STATUS_OK + * This _cannot_ return CTF_MSG_ITER_STATUS_OK * _and_ no bits. */ status = request_medium_bytes(msg_it); @@ -582,13 +582,13 @@ enum bt_msg_iter_status buf_ensure_available_bits( } static -enum bt_msg_iter_status read_dscope_begin_state( - struct bt_msg_iter *msg_it, +enum ctf_msg_iter_status read_dscope_begin_state( + struct ctf_msg_iter *msg_it, struct ctf_field_class *dscope_fc, enum state done_state, enum state continue_state, bt_field *dscope_field) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; enum bt_bfcr_status bfcr_status; size_t consumed_bits; @@ -616,7 +616,7 @@ enum bt_msg_iter_status read_dscope_begin_state( "BFCR failed to start: msg-it-addr=%p, bfcr-addr=%p, " "status=%s", msg_it, msg_it->bfcr, bt_bfcr_status_string(bfcr_status)); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } @@ -628,10 +628,10 @@ end: } static -enum bt_msg_iter_status read_dscope_continue_state( - struct bt_msg_iter *msg_it, enum state done_state) +enum ctf_msg_iter_status read_dscope_continue_state( + struct ctf_msg_iter *msg_it, enum state done_state) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; enum bt_bfcr_status bfcr_status; size_t consumed_bits; @@ -640,16 +640,16 @@ enum bt_msg_iter_status read_dscope_continue_state( msg_it, msg_it->bfcr); status = buf_ensure_available_bits(msg_it); - if (status != BT_MSG_ITER_STATUS_OK) { + if (status != CTF_MSG_ITER_STATUS_OK) { if (status < 0) { BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot ensure that buffer has at least one byte: " "msg-addr=%p, status=%s", - msg_it, bt_msg_iter_status_string(status)); + msg_it, ctf_msg_iter_status_string(status)); } else { BT_COMP_LOGT("Cannot ensure that buffer has at least one byte: " "msg-addr=%p, status=%s", - msg_it, bt_msg_iter_status_string(status)); + msg_it, ctf_msg_iter_status_string(status)); } goto end; @@ -674,7 +674,7 @@ enum bt_msg_iter_status read_dscope_continue_state( "BFCR failed to continue: msg-it-addr=%p, bfcr-addr=%p, " "status=%s", msg_it, msg_it->bfcr, bt_bfcr_status_string(bfcr_status)); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } @@ -685,7 +685,7 @@ end: } static -void release_event_dscopes(struct bt_msg_iter *msg_it) +void release_event_dscopes(struct ctf_msg_iter *msg_it) { msg_it->dscopes.event_common_context = NULL; msg_it->dscopes.event_spec_context = NULL; @@ -693,7 +693,7 @@ void release_event_dscopes(struct bt_msg_iter *msg_it) } static -void release_all_dscopes(struct bt_msg_iter *msg_it) +void release_all_dscopes(struct ctf_msg_iter *msg_it) { msg_it->dscopes.stream_packet_context = NULL; @@ -706,9 +706,9 @@ void release_all_dscopes(struct bt_msg_iter *msg_it) } static -enum bt_msg_iter_status switch_packet_state(struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status switch_packet_state(struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; /* @@ -744,7 +744,7 @@ enum bt_msg_iter_status switch_packet_state(struct bt_msg_iter *msg_it) BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot switch packet: current position is not a multiple of 8: " "msg-it-addr=%p, cur=%zu", msg_it, msg_it->buf.at); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } @@ -773,12 +773,12 @@ end: } static -enum bt_msg_iter_status read_packet_header_begin_state( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status read_packet_header_begin_state( + struct ctf_msg_iter *msg_it) { struct ctf_field_class *packet_header_fc = NULL; bt_self_component *self_comp = msg_it->self_comp; - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; /* * Make sure at least one bit is available for this packet. An @@ -787,10 +787,10 @@ enum bt_msg_iter_status read_packet_header_begin_state( */ status = buf_ensure_available_bits(msg_it); switch (status) { - case BT_MSG_ITER_STATUS_OK: + case CTF_MSG_ITER_STATUS_OK: break; - case BT_MSG_ITER_STATUS_EOF: - status = BT_MSG_ITER_STATUS_OK; + case CTF_MSG_ITER_STATUS_EOF: + status = CTF_MSG_ITER_STATUS_OK; msg_it->state = STATE_CHECK_EMIT_MSG_STREAM_END; goto end; default: @@ -826,17 +826,17 @@ end: } static -enum bt_msg_iter_status read_packet_header_continue_state( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status read_packet_header_continue_state( + struct ctf_msg_iter *msg_it) { return read_dscope_continue_state(msg_it, STATE_AFTER_TRACE_PACKET_HEADER); } static inline -enum bt_msg_iter_status set_current_stream_class(struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status set_current_stream_class(struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; struct ctf_stream_class *new_stream_class = NULL; @@ -850,7 +850,7 @@ enum bt_msg_iter_status set_current_stream_class(struct bt_msg_iter *msg_it) "Need exactly one stream class since there's " "no stream class ID field: " "msg-it-addr=%p", msg_it); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } @@ -866,7 +866,7 @@ enum bt_msg_iter_status set_current_stream_class(struct bt_msg_iter *msg_it) "msg-it-addr=%p, stream-class-id=%" PRIu64 ", " "trace-class-addr=%p", msg_it, msg_it->cur_stream_class_id, msg_it->meta.tc); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } @@ -884,7 +884,7 @@ enum bt_msg_iter_status set_current_stream_class(struct bt_msg_iter *msg_it) new_stream_class, new_stream_class->id, msg_it->meta.tc); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } } else { @@ -901,9 +901,9 @@ end: } static inline -enum bt_msg_iter_status set_current_stream(struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status set_current_stream(struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; bt_stream *stream = NULL; @@ -919,14 +919,14 @@ enum bt_msg_iter_status set_current_stream(struct bt_msg_iter *msg_it) if (!stream) { BT_COMP_LOGE_APPEND_CAUSE(self_comp, "User function failed to return a stream object for the given stream class."); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } if (msg_it->stream && stream != msg_it->stream) { BT_COMP_LOGE_APPEND_CAUSE(self_comp, "User function returned a different stream than the previous one for the same sequence of packets."); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } @@ -938,9 +938,9 @@ end: } static inline -enum bt_msg_iter_status set_current_packet(struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status set_current_packet(struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; bt_packet *packet = NULL; @@ -969,7 +969,7 @@ enum bt_msg_iter_status set_current_packet(struct bt_msg_iter *msg_it) error: BT_PACKET_PUT_REF_AND_RESET(packet); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; end: BT_PACKET_MOVE_REF(msg_it->packet, packet); @@ -977,13 +977,13 @@ end: } static -enum bt_msg_iter_status after_packet_header_state( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status after_packet_header_state( + struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status; + enum ctf_msg_iter_status status; status = set_current_stream_class(msg_it); - if (status != BT_MSG_ITER_STATUS_OK) { + if (status != CTF_MSG_ITER_STATUS_OK) { goto end; } @@ -994,10 +994,10 @@ end: } static -enum bt_msg_iter_status read_packet_context_begin_state( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status read_packet_context_begin_state( + struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; struct ctf_field_class *packet_context_fc; @@ -1023,7 +1023,7 @@ enum bt_msg_iter_status read_packet_context_begin_state( * packet is created from a stream, and this API must be * able to return the packet context properties without * creating a stream - * (bt_msg_iter_get_packet_properties()). + * (ctf_msg_iter_get_packet_properties()). */ msg_it->packet_context_field = bt_packet_context_field_create( @@ -1031,7 +1031,7 @@ enum bt_msg_iter_status read_packet_context_begin_state( if (!msg_it->packet_context_field) { BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot create packet context field wrapper from stream class."); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } @@ -1065,18 +1065,18 @@ end: } static -enum bt_msg_iter_status read_packet_context_continue_state( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status read_packet_context_continue_state( + struct ctf_msg_iter *msg_it) { return read_dscope_continue_state(msg_it, STATE_AFTER_STREAM_PACKET_CONTEXT); } static -enum bt_msg_iter_status set_current_packet_content_sizes( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status set_current_packet_content_sizes( + struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; if (msg_it->cur_exp_packet_total_size == -1) { @@ -1106,7 +1106,7 @@ enum bt_msg_iter_status set_current_packet_content_sizes( msg_it, msg_it->dscopes.stream_packet_context, msg_it->cur_exp_packet_total_size, msg_it->cur_exp_packet_content_size); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } @@ -1120,12 +1120,12 @@ end: } static -enum bt_msg_iter_status after_packet_context_state(struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status after_packet_context_state(struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status; + enum ctf_msg_iter_status status; status = set_current_packet_content_sizes(msg_it); - if (status != BT_MSG_ITER_STATUS_OK) { + if (status != CTF_MSG_ITER_STATUS_OK) { goto end; } @@ -1145,9 +1145,9 @@ end: } static -enum bt_msg_iter_status read_event_header_begin_state(struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status read_event_header_begin_state(struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; struct ctf_field_class *event_header_fc = NULL; @@ -1172,7 +1172,7 @@ enum bt_msg_iter_status read_event_header_begin_state(struct bt_msg_iter *msg_it "cur=%zu", msg_it, msg_it->cur_exp_packet_content_size, packet_at(msg_it)); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } } else { @@ -1182,10 +1182,10 @@ enum bt_msg_iter_status read_event_header_begin_state(struct bt_msg_iter *msg_it */ status = buf_ensure_available_bits(msg_it); switch (status) { - case BT_MSG_ITER_STATUS_OK: + case CTF_MSG_ITER_STATUS_OK: break; - case BT_MSG_ITER_STATUS_EOF: - status = BT_MSG_ITER_STATUS_OK; + case CTF_MSG_ITER_STATUS_EOF: + status = CTF_MSG_ITER_STATUS_OK; msg_it->state = STATE_EMIT_MSG_PACKET_END_SINGLE; goto end; default: @@ -1226,17 +1226,17 @@ end: } static -enum bt_msg_iter_status read_event_header_continue_state( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status read_event_header_continue_state( + struct ctf_msg_iter *msg_it) { return read_dscope_continue_state(msg_it, STATE_AFTER_EVENT_HEADER); } static inline -enum bt_msg_iter_status set_current_event_class(struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status set_current_event_class(struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; struct ctf_event_class *new_event_class = NULL; @@ -1250,7 +1250,7 @@ enum bt_msg_iter_status set_current_event_class(struct bt_msg_iter *msg_it) BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Need exactly one event class since there's no event class ID field: " "msg-it-addr=%p", msg_it); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } @@ -1268,7 +1268,7 @@ enum bt_msg_iter_status set_current_event_class(struct bt_msg_iter *msg_it) "trace-class-addr=%p", msg_it, msg_it->meta.sc->id, msg_it->cur_event_class_id, msg_it->meta.tc); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } @@ -1285,10 +1285,10 @@ end: } static inline -enum bt_msg_iter_status set_current_event_message( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status set_current_event_message( + struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; bt_message *msg = NULL; @@ -1326,7 +1326,7 @@ enum bt_msg_iter_status set_current_event_message( error: BT_MESSAGE_PUT_REF_AND_RESET(msg); - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; end: BT_MESSAGE_MOVE_REF(msg_it->event_msg, msg); @@ -1334,13 +1334,13 @@ end: } static -enum bt_msg_iter_status after_event_header_state( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status after_event_header_state( + struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status; + enum ctf_msg_iter_status status; status = set_current_event_class(msg_it); - if (status != BT_MSG_ITER_STATUS_OK) { + if (status != CTF_MSG_ITER_STATUS_OK) { goto end; } @@ -1349,7 +1349,7 @@ enum bt_msg_iter_status after_event_header_state( } status = set_current_event_message(msg_it); - if (status != BT_MSG_ITER_STATUS_OK) { + if (status != CTF_MSG_ITER_STATUS_OK) { goto end; } @@ -1365,10 +1365,10 @@ end: } static -enum bt_msg_iter_status read_event_common_context_begin_state( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status read_event_common_context_begin_state( + struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; struct ctf_field_class *event_common_context_fc; @@ -1412,18 +1412,18 @@ end: } static -enum bt_msg_iter_status read_event_common_context_continue_state( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status read_event_common_context_continue_state( + struct ctf_msg_iter *msg_it) { return read_dscope_continue_state(msg_it, STATE_DSCOPE_EVENT_SPEC_CONTEXT_BEGIN); } static -enum bt_msg_iter_status read_event_spec_context_begin_state( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status read_event_spec_context_begin_state( + struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; struct ctf_field_class *event_spec_context_fc; @@ -1470,18 +1470,18 @@ end: } static -enum bt_msg_iter_status read_event_spec_context_continue_state( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status read_event_spec_context_continue_state( + struct ctf_msg_iter *msg_it) { return read_dscope_continue_state(msg_it, STATE_DSCOPE_EVENT_PAYLOAD_BEGIN); } static -enum bt_msg_iter_status read_event_payload_begin_state( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status read_event_payload_begin_state( + struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; struct ctf_field_class *event_payload_fc; @@ -1528,16 +1528,16 @@ end: } static -enum bt_msg_iter_status read_event_payload_continue_state( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status read_event_payload_continue_state( + struct ctf_msg_iter *msg_it) { return read_dscope_continue_state(msg_it, STATE_EMIT_MSG_EVENT); } static -enum bt_msg_iter_status skip_packet_padding_state(struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status skip_packet_padding_state(struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; size_t bits_to_skip; const enum state next_state = STATE_SWITCH_PACKET; @@ -1552,7 +1552,7 @@ enum bt_msg_iter_status skip_packet_padding_state(struct bt_msg_iter *msg_it) BT_COMP_LOGD("Trying to skip %zu bits of padding: msg-it-addr=%p, size=%zu", bits_to_skip, msg_it, bits_to_skip); status = buf_ensure_available_bits(msg_it); - if (status != BT_MSG_ITER_STATUS_OK) { + if (status != CTF_MSG_ITER_STATUS_OK) { goto end; } @@ -1573,14 +1573,14 @@ end: } static -enum bt_msg_iter_status check_emit_msg_stream_beginning_state( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status check_emit_msg_stream_beginning_state( + struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; if (msg_it->set_stream) { status = set_current_stream(msg_it); - if (status != BT_MSG_ITER_STATUS_OK) { + if (status != CTF_MSG_ITER_STATUS_OK) { goto end; } } @@ -1597,8 +1597,8 @@ end: } static -enum bt_msg_iter_status check_emit_msg_discarded_events( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status check_emit_msg_discarded_events( + struct ctf_msg_iter *msg_it) { msg_it->state = STATE_EMIT_MSG_DISCARDED_EVENTS; @@ -1635,12 +1635,12 @@ enum bt_msg_iter_status check_emit_msg_discarded_events( } end: - return BT_MSG_ITER_STATUS_OK; + return CTF_MSG_ITER_STATUS_OK; } static -enum bt_msg_iter_status check_emit_msg_discarded_packets( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status check_emit_msg_discarded_packets( + struct ctf_msg_iter *msg_it) { msg_it->state = STATE_EMIT_MSG_DISCARDED_PACKETS; @@ -1677,12 +1677,12 @@ enum bt_msg_iter_status check_emit_msg_discarded_packets( } end: - return BT_MSG_ITER_STATUS_OK; + return CTF_MSG_ITER_STATUS_OK; } static -enum bt_msg_iter_status check_emit_msg_stream_end( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status check_emit_msg_stream_end( + struct ctf_msg_iter *msg_it) { if (msg_it->emit_stream_end_msg) { msg_it->state = STATE_EMIT_MSG_STREAM_END; @@ -1690,13 +1690,13 @@ enum bt_msg_iter_status check_emit_msg_stream_end( msg_it->state = STATE_DONE; } - return BT_MSG_ITER_STATUS_OK; + return CTF_MSG_ITER_STATUS_OK; } static inline -enum bt_msg_iter_status handle_state(struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status handle_state(struct ctf_msg_iter *msg_it) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; const enum state state = msg_it->state; BT_COMP_LOGT("Handling state: msg-it-addr=%p, state=%s", @@ -1810,13 +1810,13 @@ enum bt_msg_iter_status handle_state(struct bt_msg_iter *msg_it) BT_COMP_LOGT("Handled state: msg-it-addr=%p, status=%s, " "prev-state=%s, cur-state=%s", - msg_it, bt_msg_iter_status_string(status), + msg_it, ctf_msg_iter_status_string(status), state_string(state), state_string(msg_it->state)); return status; } BT_HIDDEN -void bt_msg_iter_reset_for_next_stream_file(struct bt_msg_iter *msg_it) +void ctf_msg_iter_reset_for_next_stream_file(struct ctf_msg_iter *msg_it) { BT_ASSERT(msg_it); BT_COMP_LOGD("Resetting message iterator: addr=%p", msg_it); @@ -1852,9 +1852,9 @@ void bt_msg_iter_reset_for_next_stream_file(struct bt_msg_iter *msg_it) * Resets the internal state of a CTF message iterator. */ BT_HIDDEN -void bt_msg_iter_reset(struct bt_msg_iter *msg_it) +void ctf_msg_iter_reset(struct ctf_msg_iter *msg_it) { - bt_msg_iter_reset_for_next_stream_file(msg_it); + ctf_msg_iter_reset_for_next_stream_file(msg_it); msg_it->cur_stream_class_id = -1; msg_it->cur_data_stream_id = -1; msg_it->snapshots.discarded_events = UINT64_C(-1); @@ -1866,7 +1866,7 @@ void bt_msg_iter_reset(struct bt_msg_iter *msg_it) } static -bt_field *borrow_next_field(struct bt_msg_iter *msg_it) +bt_field *borrow_next_field(struct ctf_msg_iter *msg_it) { bt_field *next_field = NULL; bt_field *base_field; @@ -1909,7 +1909,7 @@ bt_field *borrow_next_field(struct bt_msg_iter *msg_it) } static -void update_default_clock(struct bt_msg_iter *msg_it, uint64_t new_val, +void update_default_clock(struct ctf_msg_iter *msg_it, uint64_t new_val, uint64_t new_val_size) { uint64_t new_val_mask; @@ -1954,7 +1954,7 @@ static enum bt_bfcr_status bfcr_unsigned_int_cb(uint64_t value, struct ctf_field_class *fc, void *data) { - struct bt_msg_iter *msg_it = data; + struct ctf_msg_iter *msg_it = data; bt_self_component *self_comp = msg_it->self_comp; enum bt_bfcr_status status = BT_BFCR_STATUS_OK; @@ -2043,7 +2043,7 @@ enum bt_bfcr_status bfcr_unsigned_int_char_cb(uint64_t value, struct ctf_field_class *fc, void *data) { int ret; - struct bt_msg_iter *msg_it = data; + struct ctf_msg_iter *msg_it = data; bt_self_component *self_comp = msg_it->self_comp; enum bt_bfcr_status status = BT_BFCR_STATUS_OK; bt_field *string_field = NULL; @@ -2097,7 +2097,7 @@ enum bt_bfcr_status bfcr_signed_int_cb(int64_t value, { enum bt_bfcr_status status = BT_BFCR_STATUS_OK; bt_field *field = NULL; - struct bt_msg_iter *msg_it = data; + struct ctf_msg_iter *msg_it = data; struct ctf_field_class_int *int_fc = (void *) fc; BT_COMP_LOGT("Signed integer function called from BFCR: " @@ -2133,7 +2133,7 @@ enum bt_bfcr_status bfcr_floating_point_cb(double value, { enum bt_bfcr_status status = BT_BFCR_STATUS_OK; bt_field *field = NULL; - struct bt_msg_iter *msg_it = data; + struct ctf_msg_iter *msg_it = data; bt_field_class_type type; BT_COMP_LOGT("Floating point number function called from BFCR: " @@ -2167,7 +2167,7 @@ enum bt_bfcr_status bfcr_string_begin_cb( struct ctf_field_class *fc, void *data) { bt_field *field = NULL; - struct bt_msg_iter *msg_it = data; + struct ctf_msg_iter *msg_it = data; BT_COMP_LOGT("String (beginning) function called from BFCR: " "msg-it-addr=%p, bfcr-addr=%p, fc-addr=%p, " @@ -2202,7 +2202,7 @@ enum bt_bfcr_status bfcr_string_cb(const char *value, { enum bt_bfcr_status status = BT_BFCR_STATUS_OK; bt_field *field = NULL; - struct bt_msg_iter *msg_it = data; + struct ctf_msg_iter *msg_it = data; bt_self_component *self_comp = msg_it->self_comp; int ret; @@ -2238,7 +2238,7 @@ static enum bt_bfcr_status bfcr_string_end_cb( struct ctf_field_class *fc, void *data) { - struct bt_msg_iter *msg_it = data; + struct ctf_msg_iter *msg_it = data; BT_COMP_LOGT("String (end) function called from BFCR: " "msg-it-addr=%p, bfcr-addr=%p, fc-addr=%p, " @@ -2263,7 +2263,7 @@ static enum bt_bfcr_status bfcr_compound_begin_cb( struct ctf_field_class *fc, void *data) { - struct bt_msg_iter *msg_it = data; + struct ctf_msg_iter *msg_it = data; bt_field *field; BT_COMP_LOGT("Compound (beginning) function called from BFCR: " @@ -2315,7 +2315,7 @@ static enum bt_bfcr_status bfcr_compound_end_cb( struct ctf_field_class *fc, void *data) { - struct bt_msg_iter *msg_it = data; + struct ctf_msg_iter *msg_it = data; BT_COMP_LOGT("Compound (end) function called from BFCR: " "msg-it-addr=%p, bfcr-addr=%p, fc-addr=%p, " @@ -2363,7 +2363,7 @@ static int64_t bfcr_get_sequence_length_cb(struct ctf_field_class *fc, void *data) { bt_field *seq_field; - struct bt_msg_iter *msg_it = data; + struct ctf_msg_iter *msg_it = data; bt_self_component *self_comp = msg_it->self_comp; struct ctf_field_class_sequence *seq_fc = (void *) fc; int64_t length; @@ -2411,7 +2411,7 @@ struct ctf_field_class *bfcr_borrow_variant_selected_field_class_cb( int ret; uint64_t i; int64_t option_index = -1; - struct bt_msg_iter *msg_it = data; + struct ctf_msg_iter *msg_it = data; struct ctf_field_class_variant *var_fc = (void *) fc; struct ctf_named_field_class *selected_option = NULL; bt_self_component *self_comp = msg_it->self_comp; @@ -2489,7 +2489,7 @@ end: } static -bt_message *create_msg_stream_beginning(struct bt_msg_iter *msg_it) +bt_message *create_msg_stream_beginning(struct ctf_msg_iter *msg_it) { bt_self_component *self_comp = msg_it->self_comp; bt_message *msg; @@ -2509,7 +2509,7 @@ bt_message *create_msg_stream_beginning(struct bt_msg_iter *msg_it) } static -bt_message *create_msg_stream_end(struct bt_msg_iter *msg_it) +bt_message *create_msg_stream_end(struct ctf_msg_iter *msg_it) { bt_self_component *self_comp = msg_it->self_comp; bt_message *msg; @@ -2537,7 +2537,7 @@ end: } static -bt_message *create_msg_packet_beginning(struct bt_msg_iter *msg_it, +bt_message *create_msg_packet_beginning(struct ctf_msg_iter *msg_it, bool use_default_cs) { bt_self_component *self_comp = msg_it->self_comp; @@ -2605,7 +2605,7 @@ end: } static -bt_message *emit_delayed_packet_beg_msg(struct bt_msg_iter *msg_it) +bt_message *emit_delayed_packet_beg_msg(struct ctf_msg_iter *msg_it) { bool packet_beg_ts_need_fix_up; @@ -2626,7 +2626,7 @@ bt_message *emit_delayed_packet_beg_msg(struct bt_msg_iter *msg_it) static -bt_message *create_msg_packet_end(struct bt_msg_iter *msg_it) +bt_message *create_msg_packet_end(struct ctf_msg_iter *msg_it) { bt_message *msg; bool update_default_cs = true; @@ -2714,7 +2714,7 @@ end: } static -bt_message *create_msg_discarded_events(struct bt_msg_iter *msg_it) +bt_message *create_msg_discarded_events(struct ctf_msg_iter *msg_it) { bt_message *msg; bt_self_component *self_comp = msg_it->self_comp; @@ -2768,7 +2768,7 @@ end: } static -bt_message *create_msg_discarded_packets(struct bt_msg_iter *msg_it) +bt_message *create_msg_discarded_packets(struct ctf_msg_iter *msg_it) { bt_message *msg; bt_self_component *self_comp = msg_it->self_comp; @@ -2808,12 +2808,12 @@ end: } BT_HIDDEN -struct bt_msg_iter *bt_msg_iter_create(struct ctf_trace_class *tc, +struct ctf_msg_iter *ctf_msg_iter_create(struct ctf_trace_class *tc, size_t max_request_sz, - struct bt_msg_iter_medium_ops medops, void *data, + struct ctf_msg_iter_medium_ops medops, void *data, bt_logging_level log_level, bt_self_component *self_comp) { - struct bt_msg_iter *msg_it = NULL; + struct ctf_msg_iter *msg_it = NULL; struct bt_bfcr_cbs cbs = { .classes = { .signed_int = bfcr_signed_int_cb, @@ -2839,7 +2839,7 @@ struct bt_msg_iter *bt_msg_iter_create(struct ctf_trace_class *tc, "trace-addr=%p, max-request-size=%zu, " "data=%p, log-level=%s", tc, max_request_sz, data, bt_common_logging_level_string(log_level)); - msg_it = g_new0(struct bt_msg_iter, 1); + msg_it = g_new0(struct ctf_msg_iter, 1); if (!msg_it) { BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp, "Failed to allocate one CTF plugin message iterator."); @@ -2868,7 +2868,7 @@ struct bt_msg_iter *bt_msg_iter_create(struct ctf_trace_class *tc, goto error; } - bt_msg_iter_reset(msg_it); + ctf_msg_iter_reset(msg_it); BT_COMP_LOGD("Created CTF plugin message iterator: " "trace-addr=%p, max-request-size=%zu, " "data=%p, msg-it-addr=%p, log-level=%s", @@ -2880,12 +2880,12 @@ end: return msg_it; error: - bt_msg_iter_destroy(msg_it); + ctf_msg_iter_destroy(msg_it); msg_it = NULL; goto end; } -void bt_msg_iter_destroy(struct bt_msg_iter *msg_it) +void ctf_msg_iter_destroy(struct ctf_msg_iter *msg_it) { BT_PACKET_PUT_REF_AND_RESET(msg_it->packet); BT_STREAM_PUT_REF_AND_RESET(msg_it->stream); @@ -2910,11 +2910,11 @@ void bt_msg_iter_destroy(struct bt_msg_iter *msg_it) g_free(msg_it); } -enum bt_msg_iter_status bt_msg_iter_get_next_message( - struct bt_msg_iter *msg_it, +enum ctf_msg_iter_status ctf_msg_iter_get_next_message( + struct ctf_msg_iter *msg_it, bt_self_message_iterator *self_msg_iter, bt_message **message) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; BT_ASSERT_DBG(msg_it); @@ -2925,10 +2925,10 @@ enum bt_msg_iter_status bt_msg_iter_get_next_message( while (true) { status = handle_state(msg_it); - if (G_UNLIKELY(status == BT_MSG_ITER_STATUS_AGAIN)) { - BT_COMP_LOGD_STR("Medium returned BT_MSG_ITER_STATUS_AGAIN."); + if (G_UNLIKELY(status == CTF_MSG_ITER_STATUS_AGAIN)) { + BT_COMP_LOGD_STR("Medium returned CTF_MSG_ITER_STATUS_AGAIN."); goto end; - } else if (G_UNLIKELY(status != BT_MSG_ITER_STATUS_OK)) { + } else if (G_UNLIKELY(status != CTF_MSG_ITER_STATUS_OK)) { BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot handle state: msg-it-addr=%p, state=%s", msg_it, state_string(msg_it->state)); @@ -2946,7 +2946,7 @@ enum bt_msg_iter_status bt_msg_iter_get_next_message( if (G_UNLIKELY(msg_it->emit_delayed_packet_beginning_msg)) { *message = emit_delayed_packet_beg_msg(msg_it); if (!*message) { - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; } /* @@ -2965,7 +2965,7 @@ enum bt_msg_iter_status bt_msg_iter_get_next_message( *message = create_msg_discarded_events(msg_it); if (!*message) { - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; } goto end; @@ -2974,13 +2974,13 @@ enum bt_msg_iter_status bt_msg_iter_get_next_message( *message = create_msg_discarded_packets(msg_it); if (!*message) { - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; } goto end; case STATE_EMIT_MSG_PACKET_BEGINNING: status = set_current_packet(msg_it); - if (status != BT_MSG_ITER_STATUS_OK) { + if (status != CTF_MSG_ITER_STATUS_OK) { goto end; } @@ -2997,7 +2997,7 @@ enum bt_msg_iter_status bt_msg_iter_get_next_message( /* create_msg_packet_beginning() logs errors */ *message = create_msg_packet_beginning(msg_it, false); if (!*message) { - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; } } @@ -3008,7 +3008,7 @@ enum bt_msg_iter_status bt_msg_iter_get_next_message( *message = create_msg_packet_end(msg_it); if (!*message) { - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; } goto end; @@ -3017,7 +3017,7 @@ enum bt_msg_iter_status bt_msg_iter_get_next_message( *message = create_msg_stream_beginning(msg_it); if (!*message) { - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; } goto end; @@ -3026,12 +3026,12 @@ enum bt_msg_iter_status bt_msg_iter_get_next_message( *message = create_msg_stream_end(msg_it); if (!*message) { - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; } goto end; case STATE_DONE: - status = BT_MSG_ITER_STATUS_EOF; + status = CTF_MSG_ITER_STATUS_EOF; goto end; default: /* Non-emitting state: continue */ @@ -3044,10 +3044,10 @@ end: } static -enum bt_msg_iter_status decode_until_state( struct bt_msg_iter *msg_it, +enum ctf_msg_iter_status decode_until_state( struct ctf_msg_iter *msg_it, enum state target_state_1, enum state target_state_2) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; BT_ASSERT_DBG(msg_it); @@ -3064,10 +3064,10 @@ enum bt_msg_iter_status decode_until_state( struct bt_msg_iter *msg_it, } status = handle_state(msg_it); - if (G_UNLIKELY(status == BT_MSG_ITER_STATUS_AGAIN)) { - BT_COMP_LOGD_STR("Medium returned BT_MSG_ITER_STATUS_AGAIN."); + if (G_UNLIKELY(status == CTF_MSG_ITER_STATUS_AGAIN)) { + BT_COMP_LOGD_STR("Medium returned CTF_MSG_ITER_STATUS_AGAIN."); goto end; - } else if (G_UNLIKELY(status != BT_MSG_ITER_STATUS_OK)) { + } else if (G_UNLIKELY(status != CTF_MSG_ITER_STATUS_OK)) { BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot handle state: msg-it-addr=%p, state=%s", msg_it, state_string(msg_it->state)); @@ -3123,20 +3123,20 @@ end: } static -enum bt_msg_iter_status read_packet_header_context_fields( - struct bt_msg_iter *msg_it) +enum ctf_msg_iter_status read_packet_header_context_fields( + struct ctf_msg_iter *msg_it) { int ret; - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; status = decode_until_state(msg_it, STATE_EMIT_MSG_PACKET_BEGINNING, -1); - if (status != BT_MSG_ITER_STATUS_OK) { + if (status != CTF_MSG_ITER_STATUS_OK) { goto end; } ret = set_current_packet_content_sizes(msg_it); if (ret) { - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } @@ -3145,7 +3145,7 @@ end: } BT_HIDDEN -void bt_msg_iter_set_medops_data(struct bt_msg_iter *msg_it, +void ctf_msg_iter_set_medops_data(struct ctf_msg_iter *msg_it, void *medops_data) { BT_ASSERT(msg_it); @@ -3153,40 +3153,40 @@ void bt_msg_iter_set_medops_data(struct bt_msg_iter *msg_it, } BT_HIDDEN -enum bt_msg_iter_status bt_msg_iter_seek(struct bt_msg_iter *msg_it, +enum ctf_msg_iter_status ctf_msg_iter_seek(struct ctf_msg_iter *msg_it, off_t offset) { - enum bt_msg_iter_status status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; bt_self_component *self_comp = msg_it->self_comp; - enum bt_msg_iter_medium_status medium_status; + enum ctf_msg_iter_medium_status medium_status; BT_ASSERT(msg_it); if (offset < 0) { BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot seek to negative offset: offset=%jd", (intmax_t) offset); - status = BT_MSG_ITER_STATUS_INVAL; + status = CTF_MSG_ITER_STATUS_INVAL; goto end; } if (!msg_it->medium.medops.seek) { - status = BT_MSG_ITER_STATUS_UNSUPPORTED; + status = CTF_MSG_ITER_STATUS_UNSUPPORTED; BT_COMP_LOGD("Aborting seek as the iterator's underlying media does not implement seek support."); goto end; } medium_status = msg_it->medium.medops.seek( - BT_MSG_ITER_SEEK_WHENCE_SET, offset, msg_it->medium.data); - if (medium_status != BT_MSG_ITER_MEDIUM_STATUS_OK) { - if (medium_status == BT_MSG_ITER_MEDIUM_STATUS_EOF) { - status = BT_MSG_ITER_STATUS_EOF; + CTF_MSG_ITER_SEEK_WHENCE_SET, offset, msg_it->medium.data); + if (medium_status != CTF_MSG_ITER_MEDIUM_STATUS_OK) { + if (medium_status == CTF_MSG_ITER_MEDIUM_STATUS_EOF) { + status = CTF_MSG_ITER_STATUS_EOF; } else { - status = BT_MSG_ITER_STATUS_ERROR; + status = CTF_MSG_ITER_STATUS_ERROR; goto end; } } - bt_msg_iter_reset(msg_it); + ctf_msg_iter_reset(msg_it); msg_it->cur_packet_offset = offset; end: @@ -3194,16 +3194,16 @@ end: } static -enum bt_msg_iter_status clock_snapshot_at_msg_iter_state( - struct bt_msg_iter *msg_it, enum state target_state_1, +enum ctf_msg_iter_status clock_snapshot_at_msg_iter_state( + struct ctf_msg_iter *msg_it, 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; + enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK; BT_ASSERT_DBG(msg_it); BT_ASSERT_DBG(clock_snapshot); status = decode_until_state(msg_it, target_state_1, target_state_2); - if (status != BT_MSG_ITER_STATUS_OK) { + if (status != CTF_MSG_ITER_STATUS_OK) { goto end; } @@ -3213,16 +3213,16 @@ end: } BT_HIDDEN -enum bt_msg_iter_status bt_msg_iter_curr_packet_first_event_clock_snapshot( - struct bt_msg_iter *msg_it, uint64_t *first_clock_snapshot) +enum ctf_msg_iter_status ctf_msg_iter_curr_packet_first_event_clock_snapshot( + struct ctf_msg_iter *msg_it, uint64_t *first_clock_snapshot) { return clock_snapshot_at_msg_iter_state(msg_it, 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 *msg_it, uint64_t *last_clock_snapshot) +enum ctf_msg_iter_status ctf_msg_iter_curr_packet_last_event_clock_snapshot( + struct ctf_msg_iter *msg_it, uint64_t *last_clock_snapshot) { return clock_snapshot_at_msg_iter_state(msg_it, STATE_EMIT_MSG_PACKET_END_SINGLE, @@ -3230,16 +3230,16 @@ enum bt_msg_iter_status bt_msg_iter_curr_packet_last_event_clock_snapshot( } BT_HIDDEN -enum bt_msg_iter_status bt_msg_iter_get_packet_properties( - struct bt_msg_iter *msg_it, - struct bt_msg_iter_packet_properties *props) +enum ctf_msg_iter_status ctf_msg_iter_get_packet_properties( + struct ctf_msg_iter *msg_it, + struct ctf_msg_iter_packet_properties *props) { - enum bt_msg_iter_status status; + enum ctf_msg_iter_status status; BT_ASSERT_DBG(msg_it); BT_ASSERT_DBG(props); status = read_packet_header_context_fields(msg_it); - if (status != BT_MSG_ITER_STATUS_OK) { + if (status != CTF_MSG_ITER_STATUS_OK) { goto end; } @@ -3257,21 +3257,21 @@ end: } BT_HIDDEN -void bt_msg_iter_set_emit_stream_beginning_message(struct bt_msg_iter *msg_it, +void ctf_msg_iter_set_emit_stream_beginning_message(struct ctf_msg_iter *msg_it, bool val) { msg_it->emit_stream_begin_msg = val; } BT_HIDDEN -void bt_msg_iter_set_emit_stream_end_message(struct bt_msg_iter *msg_it, +void ctf_msg_iter_set_emit_stream_end_message(struct ctf_msg_iter *msg_it, bool val) { msg_it->emit_stream_end_msg = val; } BT_HIDDEN -void bt_msg_iter_set_dry_run(struct bt_msg_iter *msg_it, +void ctf_msg_iter_set_dry_run(struct ctf_msg_iter *msg_it, bool val) { msg_it->dry_run = val; diff --git a/src/plugins/ctf/common/msg-iter/msg-iter.h b/src/plugins/ctf/common/msg-iter/msg-iter.h index 10ac2d0b..3bd55a61 100644 --- a/src/plugins/ctf/common/msg-iter/msg-iter.h +++ b/src/plugins/ctf/common/msg-iter/msg-iter.h @@ -47,78 +47,78 @@ /** * Medium operations status codes. */ -enum bt_msg_iter_medium_status { +enum ctf_msg_iter_medium_status { /** * End of file. * * The medium function called by the message iterator * function reached the end of the file. */ - BT_MSG_ITER_MEDIUM_STATUS_EOF = 1, + CTF_MSG_ITER_MEDIUM_STATUS_EOF = 1, /** * There is no data available right now, try again later. */ - BT_MSG_ITER_MEDIUM_STATUS_AGAIN = 11, + CTF_MSG_ITER_MEDIUM_STATUS_AGAIN = 11, /** Unsupported operation. */ - BT_MSG_ITER_MEDIUM_STATUS_UNSUPPORTED = -3, + CTF_MSG_ITER_MEDIUM_STATUS_UNSUPPORTED = -3, /** Invalid argument. */ - BT_MSG_ITER_MEDIUM_STATUS_INVAL = -2, + CTF_MSG_ITER_MEDIUM_STATUS_INVAL = -2, /** General error. */ - BT_MSG_ITER_MEDIUM_STATUS_ERROR = -1, + CTF_MSG_ITER_MEDIUM_STATUS_ERROR = -1, /** Everything okay. */ - BT_MSG_ITER_MEDIUM_STATUS_OK = 0, + CTF_MSG_ITER_MEDIUM_STATUS_OK = 0, }; /** * CTF message iterator API status code. */ -enum bt_msg_iter_status { +enum ctf_msg_iter_status { /** * End of file. * * The medium function called by the message iterator * function reached the end of the file. */ - BT_MSG_ITER_STATUS_EOF = BT_MSG_ITER_MEDIUM_STATUS_EOF, + CTF_MSG_ITER_STATUS_EOF = CTF_MSG_ITER_MEDIUM_STATUS_EOF, /** * There is no data available right now, try again later. * * Some condition resulted in the - * bt_msg_iter_medium_ops::request_bytes() user function not + * ctf_msg_iter_medium_ops::request_bytes() user function not * having access to any data now. You should retry calling the * last called message iterator function once the situation * is resolved. */ - BT_MSG_ITER_STATUS_AGAIN = BT_MSG_ITER_MEDIUM_STATUS_AGAIN, + CTF_MSG_ITER_STATUS_AGAIN = CTF_MSG_ITER_MEDIUM_STATUS_AGAIN, /** Invalid argument. */ - BT_MSG_ITER_STATUS_INVAL = BT_MSG_ITER_MEDIUM_STATUS_INVAL, + CTF_MSG_ITER_STATUS_INVAL = CTF_MSG_ITER_MEDIUM_STATUS_INVAL, /** Unsupported operation. */ - BT_MSG_ITER_STATUS_UNSUPPORTED = BT_MSG_ITER_MEDIUM_STATUS_UNSUPPORTED, + CTF_MSG_ITER_STATUS_UNSUPPORTED = CTF_MSG_ITER_MEDIUM_STATUS_UNSUPPORTED, /** General error. */ - BT_MSG_ITER_STATUS_ERROR = BT_MSG_ITER_MEDIUM_STATUS_ERROR, + CTF_MSG_ITER_STATUS_ERROR = CTF_MSG_ITER_MEDIUM_STATUS_ERROR, /** Everything okay. */ - BT_MSG_ITER_STATUS_OK = 0, + CTF_MSG_ITER_STATUS_OK = CTF_MSG_ITER_MEDIUM_STATUS_OK, }; /** * CTF message iterator seek operation directives. */ -enum bt_msg_iter_seek_whence { +enum ctf_msg_iter_seek_whence { /** * Set the iterator's position to an absolute offset in the underlying * medium. */ - BT_MSG_ITER_SEEK_WHENCE_SET, + CTF_MSG_ITER_SEEK_WHENCE_SET, }; /** @@ -127,7 +127,7 @@ enum bt_msg_iter_seek_whence { * Those user functions are called by the message iterator * functions to request medium actions. */ -struct bt_msg_iter_medium_ops { +struct ctf_msg_iter_medium_ops { /** * Returns the next byte buffer to be used by the binary file * reader to deserialize binary data. @@ -155,36 +155,36 @@ struct bt_msg_iter_medium_ops { * * This function must return one of the following statuses: * - * - #BT_MSG_ITER_MEDIUM_STATUS_OK: Everything + * - #CTF_MSG_ITER_MEDIUM_STATUS_OK: Everything * is okay, i.e. \p buffer_sz is set to a positive value * reflecting the number of available bytes in the buffer * starting at the address written in \p buffer_addr. - * - #BT_MSG_ITER_MEDIUM_STATUS_AGAIN: No data is + * - #CTF_MSG_ITER_MEDIUM_STATUS_AGAIN: No data is * available right now. In this case, the message * iterator function called by the user returns - * #BT_MSG_ITER_STATUS_AGAIN, and it is the user's + * #CTF_MSG_ITER_STATUS_AGAIN, and it is the user's * responsibility to make sure enough data becomes available * before calling the \em same message iterator * function again to continue the decoding process. - * - #BT_MSG_ITER_MEDIUM_STATUS_EOF: The end of + * - #CTF_MSG_ITER_MEDIUM_STATUS_EOF: The end of * the file was reached, and no more data will ever be * available for this file. In this case, the message * iterator function called by the user returns - * #BT_MSG_ITER_STATUS_EOF. This must \em not be + * #CTF_MSG_ITER_STATUS_EOF. This must \em not be * returned when returning at least one byte of data to the * caller, i.e. this must be returned when there's * absolutely nothing left; should the request size be * larger than what's left in the file, this function must * return what's left, setting \p buffer_sz to the number of * remaining bytes, and return - * #BT_MSG_ITER_MEDIUM_STATUS_EOF on the \em following + * #CTF_MSG_ITER_MEDIUM_STATUS_EOF on the \em following * call. - * - #BT_MSG_ITER_MEDIUM_STATUS_ERROR: A fatal + * - #CTF_MSG_ITER_MEDIUM_STATUS_ERROR: A fatal * error occured during this operation. In this case, the * message iterator function called by the user returns - * #BT_MSG_ITER_STATUS_ERROR. + * #CTF_MSG_ITER_STATUS_ERROR. * - * If #BT_MSG_ITER_MEDIUM_STATUS_OK is not returned, the + * If #CTF_MSG_ITER_MEDIUM_STATUS_OK is not returned, the * values of \p buffer_sz and \p buffer_addr are \em ignored by * the caller. * @@ -194,7 +194,7 @@ struct bt_msg_iter_medium_ops { * @param data User data * @returns Status code (see description above) */ - enum bt_msg_iter_medium_status (* request_bytes)(size_t request_sz, + enum ctf_msg_iter_medium_status (* request_bytes)(size_t request_sz, uint8_t **buffer_addr, size_t *buffer_sz, void *data); /** @@ -204,13 +204,13 @@ struct bt_msg_iter_medium_ops { * to a given absolute or relative position, as indicated by * the whence directive. * - * @param whence One of #bt_msg_iter_seek_whence values + * @param whence One of #ctf_msg_iter_seek_whence values * @param offset Offset to use for the given directive * @param data User data - * @returns One of #bt_msg_iter_medium_status values + * @returns One of #ctf_msg_iter_medium_status values */ - enum bt_msg_iter_medium_status (* seek)( - enum bt_msg_iter_seek_whence whence, + enum ctf_msg_iter_medium_status (* seek)( + enum ctf_msg_iter_seek_whence whence, off_t offset, void *data); /** @@ -233,7 +233,7 @@ struct bt_msg_iter_medium_ops { }; /** CTF message iterator. */ -struct bt_msg_iter; +struct ctf_msg_iter; /** * Creates a CTF message iterator. @@ -244,7 +244,7 @@ struct bt_msg_iter; * @param trace Trace to read * @param max_request_sz Maximum buffer size, in bytes, to * request to - * bt_msg_iter_medium_ops::request_bytes() + * ctf_msg_iter_medium_ops::request_bytes() * at a time * @param medops Medium operations * @param medops_data User data (passed to medium operations) @@ -252,8 +252,8 @@ struct bt_msg_iter; * success, or \c NULL on error */ BT_HIDDEN -struct bt_msg_iter *bt_msg_iter_create(struct ctf_trace_class *tc, - size_t max_request_sz, struct bt_msg_iter_medium_ops medops, +struct ctf_msg_iter *ctf_msg_iter_create(struct ctf_trace_class *tc, + size_t max_request_sz, struct ctf_msg_iter_medium_ops medops, void *medops_data, bt_logging_level log_level, bt_self_component *self_comp); @@ -265,32 +265,32 @@ struct bt_msg_iter *bt_msg_iter_create(struct ctf_trace_class *tc, * @param msg_iter CTF message iterator */ BT_HIDDEN -void bt_msg_iter_destroy(struct bt_msg_iter *msg_iter); +void ctf_msg_iter_destroy(struct ctf_msg_iter *msg_iter); /** * Returns the next message from a CTF message iterator. * - * Upon successful completion, #BT_MSG_ITER_STATUS_OK is + * Upon successful completion, #CTF_MSG_ITER_STATUS_OK is * returned, and the next message is written to \p msg. * In this case, the caller is responsible for calling * bt_message_put() on the returned message. * - * If this function returns #BT_MSG_ITER_STATUS_AGAIN, the caller + * If this function returns #CTF_MSG_ITER_STATUS_AGAIN, the caller * should make sure that data becomes available to its medium, and * call this function again, until another status is returned. * * @param msg_iter CTF message iterator * @param message Returned message if the function's - * return value is #BT_MSG_ITER_STATUS_OK - * @returns One of #bt_msg_iter_status values + * return value is #CTF_MSG_ITER_STATUS_OK + * @returns One of #ctf_msg_iter_status values */ BT_HIDDEN -enum bt_msg_iter_status bt_msg_iter_get_next_message( - struct bt_msg_iter *msg_it, +enum ctf_msg_iter_status ctf_msg_iter_get_next_message( + struct ctf_msg_iter *msg_it, bt_self_message_iterator *msg_iter, bt_message **message); -struct bt_msg_iter_packet_properties { +struct ctf_msg_iter_packet_properties { int64_t exp_packet_total_size; int64_t exp_packet_content_size; uint64_t stream_class_id; @@ -305,68 +305,68 @@ struct bt_msg_iter_packet_properties { }; BT_HIDDEN -enum bt_msg_iter_status bt_msg_iter_get_packet_properties( - struct bt_msg_iter *msg_it, - struct bt_msg_iter_packet_properties *props); +enum ctf_msg_iter_status ctf_msg_iter_get_packet_properties( + struct ctf_msg_iter *msg_it, + struct ctf_msg_iter_packet_properties *props); BT_HIDDEN -enum bt_msg_iter_status bt_msg_iter_curr_packet_first_event_clock_snapshot( - struct bt_msg_iter *msg_it, uint64_t *first_event_cs); +enum ctf_msg_iter_status ctf_msg_iter_curr_packet_first_event_clock_snapshot( + struct ctf_msg_iter *msg_it, uint64_t *first_event_cs); BT_HIDDEN -enum bt_msg_iter_status bt_msg_iter_curr_packet_last_event_clock_snapshot( - struct bt_msg_iter *msg_it, uint64_t *last_event_cs); +enum ctf_msg_iter_status ctf_msg_iter_curr_packet_last_event_clock_snapshot( + struct ctf_msg_iter *msg_it, uint64_t *last_event_cs); BT_HIDDEN -void bt_msg_iter_set_medops_data(struct bt_msg_iter *msg_it, +void ctf_msg_iter_set_medops_data(struct ctf_msg_iter *msg_it, void *medops_data); BT_HIDDEN -enum bt_msg_iter_status bt_msg_iter_seek( - struct bt_msg_iter *msg_it, off_t offset); +enum ctf_msg_iter_status ctf_msg_iter_seek( + struct ctf_msg_iter *msg_it, off_t offset); /* * Resets the iterator so that the next requested medium bytes are * assumed to be the first bytes of a new stream. Depending on - * bt_msg_iter_set_emit_stream_beginning_message(), the first message - * which this iterator emits after calling bt_msg_iter_reset() is of - * type `BT_MESSAGE_TYPE_STREAM_BEGINNING`. + * ctf_msg_iter_set_emit_stream_beginning_message(), the first message + * which this iterator emits after calling ctf_msg_iter_reset() is of + * type `CTF_MESSAGE_TYPE_STREAM_BEGINNING`. */ BT_HIDDEN -void bt_msg_iter_reset(struct bt_msg_iter *msg_it); +void ctf_msg_iter_reset(struct ctf_msg_iter *msg_it); /* - * Like bt_msg_iter_reset(), but preserves stream-dependent state. + * Like ctf_msg_iter_reset(), but preserves stream-dependent state. */ BT_HIDDEN -void bt_msg_iter_reset_for_next_stream_file(struct bt_msg_iter *msg_it); +void ctf_msg_iter_reset_for_next_stream_file(struct ctf_msg_iter *msg_it); BT_HIDDEN -void bt_msg_iter_set_emit_stream_beginning_message(struct bt_msg_iter *msg_it, +void ctf_msg_iter_set_emit_stream_beginning_message(struct ctf_msg_iter *msg_it, bool val); BT_HIDDEN -void bt_msg_iter_set_emit_stream_end_message(struct bt_msg_iter *msg_it, +void ctf_msg_iter_set_emit_stream_end_message(struct ctf_msg_iter *msg_it, bool val); BT_HIDDEN -void bt_msg_iter_set_dry_run(struct bt_msg_iter *msg_it, +void ctf_msg_iter_set_dry_run(struct ctf_msg_iter *msg_it, bool val); static inline -const char *bt_msg_iter_medium_status_string( - enum bt_msg_iter_medium_status status) +const char *ctf_msg_iter_medium_status_string( + enum ctf_msg_iter_medium_status status) { switch (status) { - case BT_MSG_ITER_MEDIUM_STATUS_EOF: + case CTF_MSG_ITER_MEDIUM_STATUS_EOF: return "EOF"; - case BT_MSG_ITER_MEDIUM_STATUS_AGAIN: + case CTF_MSG_ITER_MEDIUM_STATUS_AGAIN: return "AGAIN"; - case BT_MSG_ITER_MEDIUM_STATUS_INVAL: + case CTF_MSG_ITER_MEDIUM_STATUS_INVAL: return "INVAL"; - case BT_MSG_ITER_MEDIUM_STATUS_ERROR: + case CTF_MSG_ITER_MEDIUM_STATUS_ERROR: return "ERROR"; - case BT_MSG_ITER_MEDIUM_STATUS_OK: + case CTF_MSG_ITER_MEDIUM_STATUS_OK: return "OK"; default: return "(unknown)"; @@ -374,19 +374,19 @@ const char *bt_msg_iter_medium_status_string( } static inline -const char *bt_msg_iter_status_string( - enum bt_msg_iter_status status) +const char *ctf_msg_iter_status_string( + enum ctf_msg_iter_status status) { switch (status) { - case BT_MSG_ITER_STATUS_EOF: + case CTF_MSG_ITER_STATUS_EOF: return "EOF"; - case BT_MSG_ITER_STATUS_AGAIN: + case CTF_MSG_ITER_STATUS_AGAIN: return "AGAIN"; - case BT_MSG_ITER_STATUS_INVAL: + case CTF_MSG_ITER_STATUS_INVAL: return "INVAL"; - case BT_MSG_ITER_STATUS_ERROR: + case CTF_MSG_ITER_STATUS_ERROR: return "ERROR"; - case BT_MSG_ITER_STATUS_OK: + case CTF_MSG_ITER_STATUS_OK: return "OK"; default: return "(unknown)"; diff --git a/src/plugins/ctf/fs-src/data-stream-file.c b/src/plugins/ctf/fs-src/data-stream-file.c index 20b60cce..64f7f2be 100644 --- a/src/plugins/ctf/fs-src/data-stream-file.c +++ b/src/plugins/ctf/fs-src/data-stream-file.c @@ -77,11 +77,11 @@ end: } static -enum bt_msg_iter_medium_status ds_file_mmap_next( +enum ctf_msg_iter_medium_status ds_file_mmap_next( struct ctf_fs_ds_file *ds_file) { - enum bt_msg_iter_medium_status ret = - BT_MSG_ITER_MEDIUM_STATUS_OK; + enum ctf_msg_iter_medium_status ret = + CTF_MSG_ITER_MEDIUM_STATUS_OK; /* Unmap old region */ if (ds_file->mmap_addr) { @@ -101,7 +101,7 @@ enum bt_msg_iter_medium_status ds_file_mmap_next( ds_file->mmap_len = MIN(ds_file->file->size - ds_file->mmap_offset, ds_file->mmap_max_len); if (ds_file->mmap_len == 0) { - ret = BT_MSG_ITER_MEDIUM_STATUS_EOF; + ret = CTF_MSG_ITER_MEDIUM_STATUS_EOF; goto end; } /* Map new region */ @@ -120,18 +120,18 @@ enum bt_msg_iter_medium_status ds_file_mmap_next( goto end; error: ds_file_munmap(ds_file); - ret = BT_MSG_ITER_MEDIUM_STATUS_ERROR; + ret = CTF_MSG_ITER_MEDIUM_STATUS_ERROR; end: return ret; } static -enum bt_msg_iter_medium_status medop_request_bytes( +enum ctf_msg_iter_medium_status medop_request_bytes( size_t request_sz, uint8_t **buffer_addr, size_t *buffer_sz, void *data) { - enum bt_msg_iter_medium_status status = - BT_MSG_ITER_MEDIUM_STATUS_OK; + enum ctf_msg_iter_medium_status status = + CTF_MSG_ITER_MEDIUM_STATUS_OK; struct ctf_fs_ds_file *ds_file = data; if (request_sz == 0) { @@ -147,15 +147,15 @@ enum bt_msg_iter_medium_status medop_request_bytes( if (ds_file->mmap_offset >= ds_file->file->size) { BT_COMP_LOGD("Reached end of file \"%s\" (%p)", ds_file->file->path->str, ds_file->file->fp); - status = BT_MSG_ITER_MEDIUM_STATUS_EOF; + status = CTF_MSG_ITER_MEDIUM_STATUS_EOF; goto end; } status = ds_file_mmap_next(ds_file); switch (status) { - case BT_MSG_ITER_MEDIUM_STATUS_OK: + case CTF_MSG_ITER_MEDIUM_STATUS_OK: break; - case BT_MSG_ITER_MEDIUM_STATUS_EOF: + case CTF_MSG_ITER_MEDIUM_STATUS_EOF: goto end; default: BT_COMP_LOGE("Cannot memory-map next region of file \"%s\" (%p)", @@ -172,7 +172,7 @@ enum bt_msg_iter_medium_status medop_request_bytes( goto end; error: - status = BT_MSG_ITER_MEDIUM_STATUS_ERROR; + status = CTF_MSG_ITER_MEDIUM_STATUS_ERROR; end: return status; @@ -204,20 +204,20 @@ end: } static -enum bt_msg_iter_medium_status medop_seek(enum bt_msg_iter_seek_whence whence, +enum ctf_msg_iter_medium_status medop_seek(enum ctf_msg_iter_seek_whence whence, off_t offset, void *data) { - enum bt_msg_iter_medium_status ret = - BT_MSG_ITER_MEDIUM_STATUS_OK; + enum ctf_msg_iter_medium_status ret = + CTF_MSG_ITER_MEDIUM_STATUS_OK; struct ctf_fs_ds_file *ds_file = data; off_t offset_in_mapping, file_size = ds_file->file->size; - if (whence != BT_MSG_ITER_SEEK_WHENCE_SET || + if (whence != CTF_MSG_ITER_SEEK_WHENCE_SET || offset < 0 || offset > file_size) { BT_COMP_LOGE("Invalid medium seek request: whence=%d, offset=%jd, " "file-size=%jd", (int) whence, (intmax_t) offset, (intmax_t) file_size); - ret = BT_MSG_ITER_MEDIUM_STATUS_INVAL; + ret = CTF_MSG_ITER_MEDIUM_STATUS_INVAL; goto end; } @@ -239,7 +239,7 @@ enum bt_msg_iter_medium_status medop_seek(enum bt_msg_iter_seek_whence whence, ds_file->mmap_len); unmap_ret = ds_file_munmap(ds_file); if (unmap_ret) { - ret = BT_MSG_ITER_MEDIUM_STATUS_ERROR; + ret = CTF_MSG_ITER_MEDIUM_STATUS_ERROR; goto end; } goto map_requested_offset; @@ -255,7 +255,7 @@ map_requested_offset: ds_file->mmap_offset = offset - offset_in_mapping; ds_file->request_offset = offset_in_mapping; ret = ds_file_mmap_next(ds_file); - if (ret != BT_MSG_ITER_MEDIUM_STATUS_OK) { + if (ret != CTF_MSG_ITER_MEDIUM_STATUS_OK) { goto end; } @@ -266,7 +266,7 @@ end: } BT_HIDDEN -struct bt_msg_iter_medium_ops ctf_fs_ds_file_medops = { +struct ctf_msg_iter_medium_ops ctf_fs_ds_file_medops = { .request_bytes = medop_request_bytes, .borrow_stream = medop_borrow_stream, .seek = medop_seek, @@ -302,11 +302,11 @@ struct ctf_fs_ds_index *build_index_from_idx_file( size_t file_entry_count; size_t i; struct ctf_stream_class *sc; - struct bt_msg_iter_packet_properties props; + struct ctf_msg_iter_packet_properties props; BT_COMP_LOGI("Building index from .idx file of stream file %s", ds_file->file->path->str); - ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props); + ret = ctf_msg_iter_get_packet_properties(ds_file->msg_iter, &props); if (ret) { BT_COMP_LOGI_STR("Cannot read first packet's header and context fields."); goto error; @@ -482,7 +482,7 @@ error: static int init_index_entry(struct ctf_fs_ds_index_entry *entry, struct ctf_fs_ds_file *ds_file, - struct bt_msg_iter_packet_properties *props, + struct ctf_msg_iter_packet_properties *props, off_t packet_size, off_t packet_offset) { int ret = 0; @@ -539,7 +539,7 @@ struct ctf_fs_ds_index *build_index_from_stream_file( { int ret; struct ctf_fs_ds_index *index = NULL; - enum bt_msg_iter_status iter_status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status iter_status = CTF_MSG_ITER_STATUS_OK; off_t current_packet_offset_bytes = 0; BT_COMP_LOGI("Indexing stream file %s", ds_file->file->path->str); @@ -552,7 +552,7 @@ struct ctf_fs_ds_index *build_index_from_stream_file( while (true) { off_t current_packet_size_bytes; struct ctf_fs_ds_index_entry *index_entry; - struct bt_msg_iter_packet_properties props; + struct ctf_msg_iter_packet_properties props; if (current_packet_offset_bytes < 0) { BT_COMP_LOGE_STR("Cannot get the current packet's offset."); @@ -565,15 +565,15 @@ struct ctf_fs_ds_index *build_index_from_stream_file( break; } - iter_status = bt_msg_iter_seek(ds_file->msg_iter, + iter_status = ctf_msg_iter_seek(ds_file->msg_iter, current_packet_offset_bytes); - if (iter_status != BT_MSG_ITER_STATUS_OK) { + if (iter_status != CTF_MSG_ITER_STATUS_OK) { goto error; } - iter_status = bt_msg_iter_get_packet_properties( + iter_status = ctf_msg_iter_get_packet_properties( ds_file->msg_iter, &props); - if (iter_status != BT_MSG_ITER_STATUS_OK) { + if (iter_status != CTF_MSG_ITER_STATUS_OK) { goto error; } @@ -634,7 +634,7 @@ BT_HIDDEN struct ctf_fs_ds_file *ctf_fs_ds_file_create( struct ctf_fs_trace *ctf_fs_trace, bt_self_message_iterator *pc_msg_iter, - struct bt_msg_iter *msg_iter, + struct ctf_msg_iter *msg_iter, bt_stream *stream, const char *path, bt_logging_level log_level) { @@ -664,7 +664,7 @@ struct ctf_fs_ds_file *ctf_fs_ds_file_create( } ds_file->msg_iter = msg_iter; - bt_msg_iter_set_medops_data(ds_file->msg_iter, ds_file); + ctf_msg_iter_set_medops_data(ds_file->msg_iter, ds_file); if (!ds_file->msg_iter) { goto error; } @@ -751,28 +751,28 @@ bt_component_class_message_iterator_next_method_status ctf_fs_ds_file_next( struct ctf_fs_ds_file *ds_file, bt_message **msg) { - enum bt_msg_iter_status msg_iter_status; + enum ctf_msg_iter_status msg_iter_status; bt_component_class_message_iterator_next_method_status status; - msg_iter_status = bt_msg_iter_get_next_message( + msg_iter_status = ctf_msg_iter_get_next_message( ds_file->msg_iter, ds_file->self_msg_iter, msg); switch (msg_iter_status) { - case BT_MSG_ITER_STATUS_EOF: + case CTF_MSG_ITER_STATUS_EOF: status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_END; break; - case BT_MSG_ITER_STATUS_OK: + case CTF_MSG_ITER_STATUS_OK: status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK; break; - case BT_MSG_ITER_STATUS_AGAIN: + case CTF_MSG_ITER_STATUS_AGAIN: /* * Should not make it this far as this is * medium-specific; there is nothing for the user to do * and it should have been handled upstream. */ bt_common_abort(); - case BT_MSG_ITER_STATUS_INVAL: - case BT_MSG_ITER_STATUS_ERROR: + case CTF_MSG_ITER_STATUS_INVAL: + case CTF_MSG_ITER_STATUS_ERROR: default: status = BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_ERROR; break; diff --git a/src/plugins/ctf/fs-src/data-stream-file.h b/src/plugins/ctf/fs-src/data-stream-file.h index 0517020e..57c7eea3 100644 --- a/src/plugins/ctf/fs-src/data-stream-file.h +++ b/src/plugins/ctf/fs-src/data-stream-file.h @@ -66,7 +66,7 @@ struct ctf_fs_ds_file { bt_stream *stream; /* Weak */ - struct bt_msg_iter *msg_iter; + struct ctf_msg_iter *msg_iter; void *mmap_addr; @@ -95,7 +95,7 @@ BT_HIDDEN struct ctf_fs_ds_file *ctf_fs_ds_file_create( struct ctf_fs_trace *ctf_fs_trace, bt_self_message_iterator *pc_msg_iter, - struct bt_msg_iter *msg_iter, + struct ctf_msg_iter *msg_iter, bt_stream *stream, const char *path, bt_logging_level log_level); @@ -119,6 +119,6 @@ struct ctf_fs_ds_index *ctf_fs_ds_index_create(bt_logging_level log_level, BT_HIDDEN void ctf_fs_ds_index_destroy(struct ctf_fs_ds_index *index); -extern struct bt_msg_iter_medium_ops ctf_fs_ds_file_medops; +extern struct ctf_msg_iter_medium_ops ctf_fs_ds_file_medops; #endif /* CTF_FS_DS_FILE_H */ diff --git a/src/plugins/ctf/fs-src/fs.c b/src/plugins/ctf/fs-src/fs.c index f03a3635..28b728ae 100644 --- a/src/plugins/ctf/fs-src/fs.c +++ b/src/plugins/ctf/fs-src/fs.c @@ -92,7 +92,7 @@ void ctf_fs_msg_iter_data_destroy( ctf_fs_ds_file_destroy(msg_iter_data->ds_file); if (msg_iter_data->msg_iter) { - bt_msg_iter_destroy(msg_iter_data->msg_iter); + ctf_msg_iter_destroy(msg_iter_data->msg_iter); } g_free(msg_iter_data); @@ -102,10 +102,10 @@ static void set_msg_iter_emits_stream_beginning_end_messages( struct ctf_fs_msg_iter_data *msg_iter_data) { - bt_msg_iter_set_emit_stream_beginning_message( + ctf_msg_iter_set_emit_stream_beginning_message( msg_iter_data->ds_file->msg_iter, msg_iter_data->ds_file_info_index == 0); - bt_msg_iter_set_emit_stream_end_message( + ctf_msg_iter_set_emit_stream_end_message( msg_iter_data->ds_file->msg_iter, msg_iter_data->ds_file_info_index == msg_iter_data->ds_file_group->ds_file_infos->len - 1); @@ -140,7 +140,7 @@ bt_component_class_message_iterator_next_method_status ctf_fs_iterator_next_one( } msg_iter_data->ds_file_info_index++; - bt_msg_iter_reset_for_next_stream_file( + ctf_msg_iter_reset_for_next_stream_file( msg_iter_data->msg_iter); set_msg_iter_emits_stream_beginning_end_messages( msg_iter_data); @@ -217,7 +217,7 @@ int ctf_fs_iterator_reset(struct ctf_fs_msg_iter_data *msg_iter_data) goto end; } - bt_msg_iter_reset(msg_iter_data->msg_iter); + ctf_msg_iter_reset(msg_iter_data->msg_iter); set_msg_iter_emits_stream_beginning_end_messages(msg_iter_data); end: @@ -277,7 +277,7 @@ bt_component_class_message_iterator_initialize_method_status ctf_fs_iterator_ini msg_iter_data->log_level = log_level; msg_iter_data->self_comp = self_comp; msg_iter_data->self_msg_iter = self_msg_iter; - msg_iter_data->msg_iter = bt_msg_iter_create( + msg_iter_data->msg_iter = ctf_msg_iter_create( port_data->ds_file_group->ctf_fs_trace->metadata->tc, bt_common_get_page_size(msg_iter_data->log_level) * 8, ctf_fs_ds_file_medops, NULL, msg_iter_data->log_level, @@ -729,14 +729,14 @@ int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, struct ctf_fs_ds_file *ds_file = NULL; struct ctf_fs_ds_file_info *ds_file_info = NULL; struct ctf_fs_ds_index *index = NULL; - struct bt_msg_iter *msg_iter = NULL; + struct ctf_msg_iter *msg_iter = NULL; struct ctf_stream_class *sc = NULL; - struct bt_msg_iter_packet_properties props; + struct ctf_msg_iter_packet_properties props; bt_logging_level log_level = ctf_fs_trace->log_level; bt_self_component *self_comp = ctf_fs_trace->self_comp; bt_self_component_class *self_comp_class = ctf_fs_trace->self_comp_class; - msg_iter = bt_msg_iter_create(ctf_fs_trace->metadata->tc, + msg_iter = ctf_msg_iter_create(ctf_fs_trace->metadata->tc, bt_common_get_page_size(log_level) * 8, ctf_fs_ds_file_medops, NULL, log_level, self_comp); if (!msg_iter) { @@ -750,7 +750,7 @@ int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, goto error; } - ret = bt_msg_iter_get_packet_properties(ds_file->msg_iter, &props); + ret = ctf_msg_iter_get_packet_properties(ds_file->msg_iter, &props); if (ret) { BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, "Cannot get stream file's first packet's header and context fields (`%s`).", @@ -875,7 +875,7 @@ end: ctf_fs_ds_file_info_destroy(ds_file_info); if (msg_iter) { - bt_msg_iter_destroy(msg_iter); + ctf_msg_iter_destroy(msg_iter); } ctf_fs_ds_index_destroy(index); @@ -1429,9 +1429,9 @@ int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace, struct ctf_fs_ds_index_entry *index_entry, enum target_event target_event, uint64_t *cs, int64_t *ts_ns) { - enum bt_msg_iter_status iter_status = BT_MSG_ITER_STATUS_OK; + enum ctf_msg_iter_status iter_status = CTF_MSG_ITER_STATUS_OK; struct ctf_fs_ds_file *ds_file = NULL; - struct bt_msg_iter *msg_iter = NULL; + struct ctf_msg_iter *msg_iter = NULL; bt_logging_level log_level = ctf_fs_trace->log_level; bt_self_component *self_comp = ctf_fs_trace->self_comp; int ret = 0; @@ -1440,11 +1440,11 @@ int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace, BT_ASSERT(ctf_fs_trace->metadata); BT_ASSERT(ctf_fs_trace->metadata->tc); - msg_iter = bt_msg_iter_create(ctf_fs_trace->metadata->tc, + msg_iter = ctf_msg_iter_create(ctf_fs_trace->metadata->tc, bt_common_get_page_size(log_level) * 8, ctf_fs_ds_file_medops, NULL, log_level, self_comp); if (!msg_iter) { - /* bt_msg_iter_create() logs errors. */ + /* ctf_msg_iter_create() logs errors. */ ret = -1; goto end; } @@ -1464,12 +1464,12 @@ int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace, * Turn on dry run mode to prevent the creation and usage of Babeltrace * library objects (bt_field, bt_message_*, etc.). */ - bt_msg_iter_set_dry_run(msg_iter, true); + ctf_msg_iter_set_dry_run(msg_iter, true); /* Seek to the beginning of the target packet. */ - iter_status = bt_msg_iter_seek(ds_file->msg_iter, index_entry->offset); + iter_status = ctf_msg_iter_seek(ds_file->msg_iter, index_entry->offset); if (iter_status) { - /* bt_msg_iter_seek() logs errors. */ + /* ctf_msg_iter_seek() logs errors. */ ret = -1; goto end; } @@ -1481,12 +1481,12 @@ int decode_clock_snapshot_after_event(struct ctf_fs_trace *ctf_fs_trace, * the first event. To extract the first event's clock * snapshot. */ - iter_status = bt_msg_iter_curr_packet_first_event_clock_snapshot( + iter_status = ctf_msg_iter_curr_packet_first_event_clock_snapshot( ds_file->msg_iter, cs); break; case LAST_EVENT: /* Decode the packet to extract the last event's clock snapshot. */ - iter_status = bt_msg_iter_curr_packet_last_event_clock_snapshot( + iter_status = ctf_msg_iter_curr_packet_last_event_clock_snapshot( ds_file->msg_iter, cs); break; default: @@ -1512,7 +1512,7 @@ end: ctf_fs_ds_file_destroy(ds_file); } if (msg_iter) { - bt_msg_iter_destroy(msg_iter); + ctf_msg_iter_destroy(msg_iter); } return ret; diff --git a/src/plugins/ctf/fs-src/fs.h b/src/plugins/ctf/fs-src/fs.h index bf2e254e..95fffa24 100644 --- a/src/plugins/ctf/fs-src/fs.h +++ b/src/plugins/ctf/fs-src/fs.h @@ -193,7 +193,7 @@ struct ctf_fs_msg_iter_data { size_t ds_file_info_index; /* Owned by this */ - struct bt_msg_iter *msg_iter; + struct ctf_msg_iter *msg_iter; }; BT_HIDDEN diff --git a/src/plugins/ctf/lttng-live/data-stream.c b/src/plugins/ctf/lttng-live/data-stream.c index 61777519..b7083ab6 100644 --- a/src/plugins/ctf/lttng-live/data-stream.c +++ b/src/plugins/ctf/lttng-live/data-stream.c @@ -44,12 +44,12 @@ #define STREAM_NAME_PREFIX "stream-" static -enum bt_msg_iter_medium_status medop_request_bytes( +enum ctf_msg_iter_medium_status medop_request_bytes( size_t request_sz, uint8_t **buffer_addr, size_t *buffer_sz, void *data) { - enum bt_msg_iter_medium_status status = - BT_MSG_ITER_MEDIUM_STATUS_OK; + enum ctf_msg_iter_medium_status status = + CTF_MSG_ITER_MEDIUM_STATUS_OK; struct lttng_live_stream_iterator *stream = data; struct lttng_live_trace *trace = stream->trace; struct lttng_live_session *session = trace->session; @@ -59,14 +59,14 @@ enum bt_msg_iter_medium_status medop_request_bytes( uint64_t read_len; if (stream->has_stream_hung_up) { - status = BT_MSG_ITER_MEDIUM_STATUS_EOF; + status = CTF_MSG_ITER_MEDIUM_STATUS_EOF; goto end; } len_left = stream->base_offset + stream->len - stream->offset; if (!len_left) { stream->state = LTTNG_LIVE_STREAM_ACTIVE_NO_DATA; - status = BT_MSG_ITER_MEDIUM_STATUS_AGAIN; + status = CTF_MSG_ITER_MEDIUM_STATUS_AGAIN; goto end; } @@ -130,7 +130,7 @@ end: return lttng_live_stream->stream; } -static struct bt_msg_iter_medium_ops medops = { +static struct ctf_msg_iter_medium_ops medops = { .request_bytes = medop_request_bytes, .seek = NULL, .borrow_stream = medop_borrow_stream, @@ -167,7 +167,7 @@ enum lttng_live_iterator_status lttng_live_lazy_msg_init( } ctf_tc = ctf_metadata_decoder_borrow_ctf_trace_class( trace->metadata->decoder); - stream_iter->msg_iter = bt_msg_iter_create(ctf_tc, + stream_iter->msg_iter = ctf_msg_iter_create(ctf_tc, lttng_live->max_query_size, medops, stream_iter, log_level, self_comp); if (!stream_iter->msg_iter) { @@ -176,9 +176,9 @@ enum lttng_live_iterator_status lttng_live_lazy_msg_init( goto error; } - bt_msg_iter_set_emit_stream_end_message( + ctf_msg_iter_set_emit_stream_end_message( stream_iter->msg_iter, true); - bt_msg_iter_set_emit_stream_beginning_message( + ctf_msg_iter_set_emit_stream_beginning_message( stream_iter->msg_iter, true); } } @@ -238,7 +238,7 @@ struct lttng_live_stream_iterator *lttng_live_stream_iterator_create( ctf_metadata_decoder_borrow_ctf_trace_class( trace->metadata->decoder); BT_ASSERT(!stream_iter->msg_iter); - stream_iter->msg_iter = bt_msg_iter_create(ctf_tc, + stream_iter->msg_iter = ctf_msg_iter_create(ctf_tc, lttng_live->max_query_size, medops, stream_iter, log_level, self_comp); if (!stream_iter->msg_iter) { @@ -247,9 +247,9 @@ struct lttng_live_stream_iterator *lttng_live_stream_iterator_create( goto error; } - bt_msg_iter_set_emit_stream_end_message( + ctf_msg_iter_set_emit_stream_end_message( stream_iter->msg_iter, true); - bt_msg_iter_set_emit_stream_beginning_message( + ctf_msg_iter_set_emit_stream_beginning_message( stream_iter->msg_iter, true); } stream_iter->buf = g_new0(uint8_t, lttng_live->max_query_size); @@ -295,7 +295,7 @@ void lttng_live_stream_iterator_destroy( } if (stream_iter->msg_iter) { - bt_msg_iter_destroy(stream_iter->msg_iter); + ctf_msg_iter_destroy(stream_iter->msg_iter); } g_free(stream_iter->buf); if (stream_iter->name) { diff --git a/src/plugins/ctf/lttng-live/lttng-live.c b/src/plugins/ctf/lttng-live/lttng-live.c index c28af3d5..aeb9e80f 100644 --- a/src/plugins/ctf/lttng-live/lttng-live.c +++ b/src/plugins/ctf/lttng-live/lttng-live.c @@ -770,7 +770,7 @@ enum lttng_live_iterator_status lttng_live_iterator_next_handle_one_active_data_ enum lttng_live_iterator_status ret = LTTNG_LIVE_ITERATOR_STATUS_OK; bt_logging_level log_level = lttng_live_msg_iter->log_level; bt_self_component *self_comp = lttng_live_msg_iter->self_comp; - enum bt_msg_iter_status status; + enum ctf_msg_iter_status status; uint64_t session_idx, trace_idx; for (session_idx = 0; session_idx < lttng_live_msg_iter->sessions->len; @@ -798,16 +798,16 @@ enum lttng_live_iterator_status lttng_live_iterator_next_handle_one_active_data_ goto end; } - status = bt_msg_iter_get_next_message(lttng_live_stream->msg_iter, + status = ctf_msg_iter_get_next_message(lttng_live_stream->msg_iter, lttng_live_msg_iter->self_msg_iter, message); switch (status) { - case BT_MSG_ITER_STATUS_EOF: + case CTF_MSG_ITER_STATUS_EOF: ret = LTTNG_LIVE_ITERATOR_STATUS_END; break; - case BT_MSG_ITER_STATUS_OK: + case CTF_MSG_ITER_STATUS_OK: ret = LTTNG_LIVE_ITERATOR_STATUS_OK; break; - case BT_MSG_ITER_STATUS_AGAIN: + case CTF_MSG_ITER_STATUS_AGAIN: /* * Continue immediately (end of packet). The next * get_index may return AGAIN to delay the following @@ -815,9 +815,9 @@ enum lttng_live_iterator_status lttng_live_iterator_next_handle_one_active_data_ */ ret = LTTNG_LIVE_ITERATOR_STATUS_CONTINUE; break; - case BT_MSG_ITER_STATUS_INVAL: + case CTF_MSG_ITER_STATUS_INVAL: /* No argument provided by the user, so don't return INVAL. */ - case BT_MSG_ITER_STATUS_ERROR: + case CTF_MSG_ITER_STATUS_ERROR: default: ret = LTTNG_LIVE_ITERATOR_STATUS_ERROR; BT_COMP_LOGE_APPEND_CAUSE(self_comp, @@ -842,21 +842,21 @@ enum lttng_live_iterator_status lttng_live_iterator_close_stream( bt_self_component *self_comp = lttng_live_msg_iter->self_comp; /* * The viewer has hung up on us so we are closing the stream. The - * `bt_msg_iter` should simply realize that it needs to close the + * `ctf_msg_iter` should simply realize that it needs to close the * stream properly by emitting the necessary stream end message. */ - enum bt_msg_iter_status status = bt_msg_iter_get_next_message( + enum ctf_msg_iter_status status = ctf_msg_iter_get_next_message( stream_iter->msg_iter, lttng_live_msg_iter->self_msg_iter, curr_msg); - if (status == BT_MSG_ITER_STATUS_ERROR) { + if (status == CTF_MSG_ITER_STATUS_ERROR) { BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Error getting the next message from CTF message iterator"); live_status = LTTNG_LIVE_ITERATOR_STATUS_ERROR; goto end; } - BT_ASSERT(status == BT_MSG_ITER_STATUS_OK); + BT_ASSERT(status == CTF_MSG_ITER_STATUS_OK); end: return live_status; diff --git a/src/plugins/ctf/lttng-live/lttng-live.h b/src/plugins/ctf/lttng-live/lttng-live.h index bd5b317d..533c3213 100644 --- a/src/plugins/ctf/lttng-live/lttng-live.h +++ b/src/plugins/ctf/lttng-live/lttng-live.h @@ -79,7 +79,7 @@ struct lttng_live_stream_iterator { * Since only a single iterator per viewer connection, we have * only a single message iterator per stream. */ - struct bt_msg_iter *msg_iter; + struct ctf_msg_iter *msg_iter; uint64_t viewer_stream_id; @@ -333,7 +333,7 @@ enum lttng_live_iterator_status lttng_live_get_next_index( struct lttng_live_stream_iterator *stream, struct packet_index *index); -enum bt_msg_iter_medium_status lttng_live_get_stream_bytes( +enum ctf_msg_iter_medium_status lttng_live_get_stream_bytes( struct lttng_live_msg_iter *lttng_live_msg_iter, struct lttng_live_stream_iterator *stream, uint8_t *buf, uint64_t offset, uint64_t req_len, uint64_t *recv_len); diff --git a/src/plugins/ctf/lttng-live/viewer-connection.c b/src/plugins/ctf/lttng-live/viewer-connection.c index 132591e7..62918034 100644 --- a/src/plugins/ctf/lttng-live/viewer-connection.c +++ b/src/plugins/ctf/lttng-live/viewer-connection.c @@ -1343,12 +1343,12 @@ error: } BT_HIDDEN -enum bt_msg_iter_medium_status lttng_live_get_stream_bytes( +enum ctf_msg_iter_medium_status lttng_live_get_stream_bytes( struct lttng_live_msg_iter *lttng_live_msg_iter, struct lttng_live_stream_iterator *stream, uint8_t *buf, uint64_t offset, uint64_t req_len, uint64_t *recv_len) { - enum bt_msg_iter_medium_status retstatus = BT_MSG_ITER_MEDIUM_STATUS_OK; + enum ctf_msg_iter_medium_status retstatus = CTF_MSG_ITER_MEDIUM_STATUS_OK; struct lttng_viewer_trace_packet rp; struct lttng_viewer_cmd cmd; struct lttng_viewer_get_packet rq; @@ -1418,7 +1418,7 @@ enum bt_msg_iter_medium_status lttng_live_get_stream_bytes( case LTTNG_VIEWER_GET_PACKET_RETRY: /* Unimplemented by relay daemon */ BT_COMP_LOGD("Received get_data_packet response: retry"); - retstatus = BT_MSG_ITER_MEDIUM_STATUS_AGAIN; + retstatus = CTF_MSG_ITER_MEDIUM_STATUS_AGAIN; goto end; case LTTNG_VIEWER_GET_PACKET_ERR: if (flags & LTTNG_VIEWER_FLAG_NEW_METADATA) { @@ -1431,14 +1431,14 @@ enum bt_msg_iter_medium_status lttng_live_get_stream_bytes( } if (flags & (LTTNG_VIEWER_FLAG_NEW_METADATA | LTTNG_VIEWER_FLAG_NEW_STREAM)) { - retstatus = BT_MSG_ITER_MEDIUM_STATUS_AGAIN; + retstatus = CTF_MSG_ITER_MEDIUM_STATUS_AGAIN; goto end; } BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Received get_data_packet response: error"); goto error; case LTTNG_VIEWER_GET_PACKET_EOF: - retstatus = BT_MSG_ITER_MEDIUM_STATUS_EOF; + retstatus = CTF_MSG_ITER_MEDIUM_STATUS_EOF; goto end; default: BT_COMP_LOGE_APPEND_CAUSE(self_comp, @@ -1469,9 +1469,9 @@ end: error: if (lttng_live_graph_is_canceled(lttng_live_msg_iter)) { - retstatus = BT_MSG_ITER_MEDIUM_STATUS_AGAIN; + retstatus = CTF_MSG_ITER_MEDIUM_STATUS_AGAIN; } else { - retstatus = BT_MSG_ITER_MEDIUM_STATUS_ERROR; + retstatus = CTF_MSG_ITER_MEDIUM_STATUS_ERROR; } return retstatus; } -- 2.34.1