X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fplugins%2Fctf%2Flttng-live%2Flttng-live.cpp;h=6368181000f641718cb9c192cda053ba131b2341;hb=HEAD;hp=cdf324c21298c2268a9d54753c8e3c424583b2e2;hpb=277bcb7fc46fee9748f69b7817940b62b898c7fb;p=babeltrace.git diff --git a/src/plugins/ctf/lttng-live/lttng-live.cpp b/src/plugins/ctf/lttng-live/lttng-live.cpp index cdf324c2..63681810 100644 --- a/src/plugins/ctf/lttng-live/lttng-live.cpp +++ b/src/plugins/ctf/lttng-live/lttng-live.cpp @@ -57,17 +57,11 @@ void lttng_live_stream_iterator_set_state(struct lttng_live_stream_iterator *str bool lttng_live_graph_is_canceled(struct lttng_live_msg_iter *msg_iter) { - bool ret; - if (!msg_iter) { - ret = false; - goto end; + return false; } - ret = bt_self_message_iterator_is_interrupted(msg_iter->self_msg_iter); - -end: - return ret; + return bt_self_message_iterator_is_interrupted(msg_iter->self_msg_iter); } static struct lttng_live_trace * @@ -103,18 +97,12 @@ struct lttng_live_trace * lttng_live_session_borrow_or_create_trace_by_id(struct lttng_live_session *session, uint64_t trace_id) { - struct lttng_live_trace *trace; - - trace = lttng_live_session_borrow_trace_by_id(session, trace_id); - if (trace) { - goto end; + if (lttng_live_trace *trace = lttng_live_session_borrow_trace_by_id(session, trace_id)) { + return trace; } /* The session is the owner of the newly created trace. */ - trace = lttng_live_create_trace(session, trace_id); - -end: - return trace; + return lttng_live_create_trace(session, trace_id); } int lttng_live_add_session(struct lttng_live_msg_iter *lttng_live_msg_iter, uint64_t session_id, @@ -156,38 +144,20 @@ lttng_live_session::~lttng_live_session() } } -static void lttng_live_msg_iter_destroy(struct lttng_live_msg_iter *lttng_live_msg_iter) +lttng_live_msg_iter::~lttng_live_msg_iter() { - if (!lttng_live_msg_iter) { - goto end; - } - - if (lttng_live_msg_iter->viewer_connection) { - delete lttng_live_msg_iter->viewer_connection; - } - BT_ASSERT(lttng_live_msg_iter->lttng_live_comp); - BT_ASSERT(lttng_live_msg_iter->lttng_live_comp->has_msg_iter); + BT_ASSERT(this->lttng_live_comp); + BT_ASSERT(this->lttng_live_comp->has_msg_iter); /* All stream iterators must be destroyed at this point. */ - BT_ASSERT(lttng_live_msg_iter->active_stream_iter == 0); - lttng_live_msg_iter->lttng_live_comp->has_msg_iter = false; - - delete lttng_live_msg_iter; - -end: - return; + BT_ASSERT(this->active_stream_iter == 0); + this->lttng_live_comp->has_msg_iter = false; } void lttng_live_msg_iter_finalize(bt_self_message_iterator *self_msg_iter) { - struct lttng_live_msg_iter *lttng_live_msg_iter; - - BT_ASSERT(self_msg_iter); - - lttng_live_msg_iter = - (struct lttng_live_msg_iter *) bt_self_message_iterator_get_data(self_msg_iter); - BT_ASSERT(lttng_live_msg_iter); - lttng_live_msg_iter_destroy(lttng_live_msg_iter); + lttng_live_msg_iter::UP { + static_cast(bt_self_message_iterator_get_data(self_msg_iter))}; } static enum lttng_live_iterator_status @@ -322,13 +292,12 @@ lttng_live_get_session(struct lttng_live_msg_iter *lttng_live_msg_iter, * cancelled. */ bt_current_thread_clear_error(); - status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN; + return LTTNG_LIVE_ITERATOR_STATUS_AGAIN; } else { - status = LTTNG_LIVE_ITERATOR_STATUS_ERROR; BT_CPPLOGE_APPEND_CAUSE_SPEC(lttng_live_msg_iter->logger, "Error attaching to LTTng live session"); + return LTTNG_LIVE_ITERATOR_STATUS_ERROR; } - goto end; } } @@ -359,10 +328,9 @@ lttng_live_get_session(struct lttng_live_msg_iter *lttng_live_msg_iter, "Updating streams returned _END status. Override status to _OK in order fetch any remaining metadata:" "session-id={}, session-name=\"{}\"", session->id, session->session_name); - status = LTTNG_LIVE_ITERATOR_STATUS_OK; - break; + return LTTNG_LIVE_ITERATOR_STATUS_OK; default: - goto end; + return status; } BT_CPPLOGD_SPEC(lttng_live_msg_iter->logger, @@ -377,13 +345,13 @@ lttng_live_get_session(struct lttng_live_msg_iter *lttng_live_msg_iter, break; case LTTNG_LIVE_ITERATOR_STATUS_CONTINUE: case LTTNG_LIVE_ITERATOR_STATUS_AGAIN: - goto end; + return status; default: - BT_CPPLOGE_APPEND_CAUSE_SPEC(lttng_live_msg_iter->logger, - "Error updating trace metadata: " - "stream-iter-status={}, trace-id={}", - status, trace->id); - goto end; + BT_CPPLOGE_APPEND_CAUSE_SPEC( + lttng_live_msg_iter->logger, + "Error updating trace metadata: stream-iter-status={}, trace-id={}", status, + trace->id); + return status; } } @@ -391,10 +359,7 @@ lttng_live_get_session(struct lttng_live_msg_iter *lttng_live_msg_iter, * Now that we have the metadata we can initialize the downstream * iterator. */ - status = lttng_live_lazy_msg_init(session, lttng_live_msg_iter->self_msg_iter); - -end: - return status; + return lttng_live_lazy_msg_init(session, lttng_live_msg_iter->self_msg_iter); } static void @@ -422,7 +387,6 @@ lttng_live_force_new_streams_and_metadata(struct lttng_live_msg_iter *lttng_live static enum lttng_live_iterator_status lttng_live_iterator_handle_new_streams_and_metadata(struct lttng_live_msg_iter *lttng_live_msg_iter) { - enum lttng_live_iterator_status status; enum lttng_live_viewer_status viewer_status; uint64_t nr_sessions_opened = 0; enum session_not_found_action sess_not_found_act = @@ -443,8 +407,7 @@ lttng_live_iterator_handle_new_streams_and_metadata(struct lttng_live_msg_iter * BT_CPPLOGD_SPEC( lttng_live_msg_iter->logger, "No session found. Exiting in accordance with the `session-not-found-action` parameter"); - status = LTTNG_LIVE_ITERATOR_STATUS_END; - goto end; + return LTTNG_LIVE_ITERATOR_STATUS_END; } else { BT_CPPLOGD_SPEC( lttng_live_msg_iter->logger, @@ -456,21 +419,20 @@ lttng_live_iterator_handle_new_streams_and_metadata(struct lttng_live_msg_iter * viewer_status = lttng_live_create_viewer_session(lttng_live_msg_iter); if (viewer_status != LTTNG_LIVE_VIEWER_STATUS_OK) { if (viewer_status == LTTNG_LIVE_VIEWER_STATUS_ERROR) { - status = LTTNG_LIVE_ITERATOR_STATUS_ERROR; BT_CPPLOGE_APPEND_CAUSE_SPEC(lttng_live_msg_iter->logger, "Error creating LTTng live viewer session"); + return LTTNG_LIVE_ITERATOR_STATUS_ERROR; } else if (viewer_status == LTTNG_LIVE_VIEWER_STATUS_INTERRUPTED) { - status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN; + return LTTNG_LIVE_ITERATOR_STATUS_AGAIN; } else { bt_common_abort(); } - goto end; } } } for (const auto& session : lttng_live_msg_iter->sessions) { - status = lttng_live_get_session(lttng_live_msg_iter, session.get()); + const auto status = lttng_live_get_session(lttng_live_msg_iter, session.get()); switch (status) { case LTTNG_LIVE_ITERATOR_STATUS_OK: case LTTNG_LIVE_ITERATOR_STATUS_END: @@ -481,7 +443,7 @@ lttng_live_iterator_handle_new_streams_and_metadata(struct lttng_live_msg_iter * */ break; default: - goto end; + return status; } if (!session->closed) { nr_sessions_opened++; @@ -489,13 +451,10 @@ lttng_live_iterator_handle_new_streams_and_metadata(struct lttng_live_msg_iter * } if (sess_not_found_act != SESSION_NOT_FOUND_ACTION_CONTINUE && nr_sessions_opened == 0) { - status = LTTNG_LIVE_ITERATOR_STATUS_END; + return LTTNG_LIVE_ITERATOR_STATUS_END; } else { - status = LTTNG_LIVE_ITERATOR_STATUS_OK; + return LTTNG_LIVE_ITERATOR_STATUS_OK; } - -end: - return status; } static enum lttng_live_iterator_status @@ -527,8 +486,6 @@ static enum lttng_live_iterator_status lttng_live_iterator_next_handle_one_quies struct lttng_live_msg_iter *lttng_live_msg_iter, struct lttng_live_stream_iterator *lttng_live_stream, bt2::ConstMessage::Shared& message) { - enum lttng_live_iterator_status ret = LTTNG_LIVE_ITERATOR_STATUS_OK; - if (lttng_live_stream->state != LTTNG_LIVE_STREAM_QUIESCENT) { return LTTNG_LIVE_ITERATOR_STATUS_OK; } @@ -542,17 +499,20 @@ static enum lttng_live_iterator_status lttng_live_iterator_next_handle_one_quies lttng_live_stream_iterator_set_state(lttng_live_stream, LTTNG_LIVE_STREAM_QUIESCENT_NO_DATA); - ret = LTTNG_LIVE_ITERATOR_STATUS_CONTINUE; - goto end; + return LTTNG_LIVE_ITERATOR_STATUS_CONTINUE; } - ret = emit_inactivity_message(lttng_live_msg_iter, lttng_live_stream, message, - lttng_live_stream->current_inactivity_ts); + const auto status = emit_inactivity_message(lttng_live_msg_iter, lttng_live_stream, message, + lttng_live_stream->current_inactivity_ts); + + if (status != LTTNG_LIVE_ITERATOR_STATUS_OK) { + return status; + } lttng_live_stream->last_inactivity_ts.value = lttng_live_stream->current_inactivity_ts; lttng_live_stream->last_inactivity_ts.is_set = true; -end: - return ret; + + return LTTNG_LIVE_ITERATOR_STATUS_OK; } static int live_get_msg_ts_ns(struct lttng_live_msg_iter *lttng_live_msg_iter, @@ -592,10 +552,12 @@ static int live_get_msg_ts_ns(struct lttng_live_msg_iter *lttng_live_msg_iter, break; default: /* All the other messages have a higher priority */ - BT_CPPLOGD_STR_SPEC(lttng_live_msg_iter->logger, - "Message has no timestamp: using the last message timestamp."); + BT_CPPLOGD_SPEC(lttng_live_msg_iter->logger, + "Message has no timestamp, using the last message timestamp: " + "iter-data-addr={}, msg-addr={}, last-msg-ts={}, ts={}", + fmt::ptr(lttng_live_msg_iter), fmt::ptr(msg), last_msg_ts_ns, *ts_ns); *ts_ns = last_msg_ts_ns; - goto end; + return 0; } ret = bt_clock_snapshot_get_ns_from_origin(clock_snapshot, ts_ns); @@ -604,92 +566,69 @@ static int live_get_msg_ts_ns(struct lttng_live_msg_iter *lttng_live_msg_iter, "Cannot get nanoseconds from Epoch of clock snapshot: " "clock-snapshot-addr={}", fmt::ptr(clock_snapshot)); - goto error; + return -1; } - goto end; - -error: - ret = -1; + BT_CPPLOGD_SPEC( + lttng_live_msg_iter->logger, + "Found message's timestamp: iter-data-addr={}, msg-addr={}, last-msg-ts={}, ts={}", + fmt::ptr(lttng_live_msg_iter), fmt::ptr(msg), last_msg_ts_ns, *ts_ns); -end: - if (ret == 0) { - BT_CPPLOGD_SPEC(lttng_live_msg_iter->logger, - "Found message's timestamp: iter-data-addr={}, msg-addr={}, " - "last-msg-ts={}, ts={}", - fmt::ptr(lttng_live_msg_iter), fmt::ptr(msg), last_msg_ts_ns, *ts_ns); - } - - return ret; + return 0; } static enum lttng_live_iterator_status lttng_live_iterator_next_handle_one_active_data_stream( struct lttng_live_msg_iter *lttng_live_msg_iter, struct lttng_live_stream_iterator *lttng_live_stream, bt2::ConstMessage::Shared& message) { - enum lttng_live_iterator_status ret = LTTNG_LIVE_ITERATOR_STATUS_OK; enum ctf_msg_iter_status status; for (const auto& session : lttng_live_msg_iter->sessions) { if (session->new_streams_needed) { BT_CPPLOGD_SPEC(lttng_live_msg_iter->logger, - "Need an update for streams: " - "session-id={}", - session->id); - ret = LTTNG_LIVE_ITERATOR_STATUS_CONTINUE; - goto end; + "Need an update for streams: session-id={}", session->id); + return LTTNG_LIVE_ITERATOR_STATUS_CONTINUE; } for (lttng_live_trace::UP& trace : session->traces) { if (trace->metadata_stream_state == LTTNG_LIVE_METADATA_STREAM_STATE_NEEDED) { BT_CPPLOGD_SPEC(lttng_live_msg_iter->logger, - "Need an update for metadata stream: " - "session-id={}, trace-id={}", + "Need an update for metadata stream: session-id={}, trace-id={}", session->id, trace->id); - ret = LTTNG_LIVE_ITERATOR_STATUS_CONTINUE; - goto end; + return LTTNG_LIVE_ITERATOR_STATUS_CONTINUE; } } } if (lttng_live_stream->state != LTTNG_LIVE_STREAM_ACTIVE_DATA) { - ret = LTTNG_LIVE_ITERATOR_STATUS_ERROR; BT_CPPLOGE_APPEND_CAUSE_SPEC(lttng_live_msg_iter->logger, - "Invalid state of live stream iterator" - "stream-iter-status={}", + "Invalid state of live stream iterator: stream-iter-status={}", lttng_live_stream->state); - goto end; + return LTTNG_LIVE_ITERATOR_STATUS_ERROR; } const bt_message *msg; status = ctf_msg_iter_get_next_message(lttng_live_stream->msg_iter.get(), &msg); switch (status) { case CTF_MSG_ITER_STATUS_EOF: - ret = LTTNG_LIVE_ITERATOR_STATUS_END; - break; + return LTTNG_LIVE_ITERATOR_STATUS_END; case CTF_MSG_ITER_STATUS_OK: message = bt2::ConstMessage::Shared::createWithoutRef(msg); - ret = LTTNG_LIVE_ITERATOR_STATUS_OK; - break; + return LTTNG_LIVE_ITERATOR_STATUS_OK; case CTF_MSG_ITER_STATUS_AGAIN: /* * Continue immediately (end of packet). The next * get_index may return AGAIN to delay the following * attempt. */ - ret = LTTNG_LIVE_ITERATOR_STATUS_CONTINUE; - break; + return LTTNG_LIVE_ITERATOR_STATUS_CONTINUE; case CTF_MSG_ITER_STATUS_ERROR: default: - ret = LTTNG_LIVE_ITERATOR_STATUS_ERROR; - BT_CPPLOGE_APPEND_CAUSE_SPEC(lttng_live_msg_iter->logger, - "CTF message iterator failed to get next message: " - "msg-iter={}, msg-iter-status={}", - fmt::ptr(lttng_live_stream->msg_iter), status); - break; + BT_CPPLOGE_APPEND_CAUSE_SPEC( + lttng_live_msg_iter->logger, + "CTF message iterator failed to get next message: msg-iter={}, msg-iter-status={}", + fmt::ptr(lttng_live_stream->msg_iter), status); + return LTTNG_LIVE_ITERATOR_STATUS_ERROR; } - -end: - return ret; } static enum lttng_live_iterator_status @@ -697,8 +636,6 @@ lttng_live_iterator_close_stream(struct lttng_live_msg_iter *lttng_live_msg_iter struct lttng_live_stream_iterator *stream_iter, bt2::ConstMessage::Shared& curr_msg) { - enum lttng_live_iterator_status live_status = LTTNG_LIVE_ITERATOR_STATUS_OK; - BT_CPPLOGD_SPEC(lttng_live_msg_iter->logger, "Closing live stream iterator: stream-name=\"{}\", " "viewer-stream-id={}", @@ -716,21 +653,18 @@ lttng_live_iterator_close_stream(struct lttng_live_msg_iter *lttng_live_msg_iter if (status == CTF_MSG_ITER_STATUS_ERROR) { BT_CPPLOGE_APPEND_CAUSE_SPEC(lttng_live_msg_iter->logger, "Error getting the next message from CTF message iterator"); - live_status = LTTNG_LIVE_ITERATOR_STATUS_ERROR; - goto end; + return LTTNG_LIVE_ITERATOR_STATUS_ERROR; } else if (status == CTF_MSG_ITER_STATUS_EOF) { BT_CPPLOGI_SPEC(lttng_live_msg_iter->logger, "Reached the end of the live stream iterator."); - live_status = LTTNG_LIVE_ITERATOR_STATUS_END; - goto end; + return LTTNG_LIVE_ITERATOR_STATUS_END; } BT_ASSERT(status == CTF_MSG_ITER_STATUS_OK); curr_msg = bt2::ConstMessage::Shared::createWithoutRef(msg); -end: - return live_status; + return LTTNG_LIVE_ITERATOR_STATUS_OK; } /* @@ -932,7 +866,6 @@ handle_late_message(struct lttng_live_msg_iter *lttng_live_msg_iter, const bt_stream_class *stream_class; enum bt_clock_class_cycles_to_ns_from_origin_status ts_ns_status; int64_t last_inactivity_ts_ns; - enum lttng_live_iterator_status stream_iter_status = LTTNG_LIVE_ITERATOR_STATUS_OK; enum lttng_live_iterator_status adjust_status; bt2::ConstMessage::Shared adjusted_message; @@ -975,8 +908,7 @@ handle_late_message(struct lttng_live_msg_iter *lttng_live_msg_iter, "Invalid live stream state: " "have a late message when no inactivity message " "was ever sent for that stream."); - stream_iter_status = LTTNG_LIVE_ITERATOR_STATUS_ERROR; - goto end; + return LTTNG_LIVE_ITERATOR_STATUS_ERROR; } if (!is_discarded_packet_or_event_message(late_msg)) { @@ -985,8 +917,7 @@ handle_late_message(struct lttng_live_msg_iter *lttng_live_msg_iter, "have a late message that is not a packet discarded or " "event discarded message: late-msg-type={}", late_msg.type()); - stream_iter_status = LTTNG_LIVE_ITERATOR_STATUS_ERROR; - goto end; + return LTTNG_LIVE_ITERATOR_STATUS_ERROR; } stream_class = bt_stream_borrow_class_const(stream_iter->stream->libObjPtr()); @@ -998,8 +929,7 @@ handle_late_message(struct lttng_live_msg_iter *lttng_live_msg_iter, BT_CPPLOGE_APPEND_CAUSE_SPEC(lttng_live_msg_iter->logger, "Error converting last " "inactivity message timestamp to nanoseconds"); - stream_iter_status = LTTNG_LIVE_ITERATOR_STATUS_ERROR; - goto end; + return LTTNG_LIVE_ITERATOR_STATUS_ERROR; } if (last_inactivity_ts_ns <= late_msg_ts_ns) { @@ -1009,8 +939,7 @@ handle_late_message(struct lttng_live_msg_iter *lttng_live_msg_iter, "inactivity timespan: last-inactivity-ts-ns={}, " "late-msg-ts-ns={}", last_inactivity_ts_ns, late_msg_ts_ns); - stream_iter_status = LTTNG_LIVE_ITERATOR_STATUS_ERROR; - goto end; + return LTTNG_LIVE_ITERATOR_STATUS_ERROR; } /* @@ -1037,16 +966,14 @@ handle_late_message(struct lttng_live_msg_iter *lttng_live_msg_iter, } if (adjust_status != LTTNG_LIVE_ITERATOR_STATUS_OK) { - stream_iter_status = adjust_status; - goto end; + return adjust_status; } BT_ASSERT_DBG(adjusted_message); stream_iter->current_msg = adjusted_message; stream_iter->current_msg_ts_ns = last_inactivity_ts_ns; -end: - return stream_iter_status; + return LTTNG_LIVE_ITERATOR_STATUS_OK; } static enum lttng_live_iterator_status @@ -1055,7 +982,6 @@ next_stream_iterator_for_trace(struct lttng_live_msg_iter *lttng_live_msg_iter, struct lttng_live_stream_iterator **youngest_trace_stream_iter) { struct lttng_live_stream_iterator *youngest_candidate_stream_iter = NULL; - enum lttng_live_iterator_status stream_iter_status; int64_t youngest_candidate_msg_ts = INT64_MAX; uint64_t stream_iter_idx; @@ -1085,7 +1011,7 @@ next_stream_iterator_for_trace(struct lttng_live_msg_iter *lttng_live_msg_iter, bt2::ConstMessage::Shared msg; int64_t curr_msg_ts_ns = INT64_MAX; - stream_iter_status = + const auto stream_iter_status = lttng_live_iterator_next_msg_on_stream(lttng_live_msg_iter, stream_iter, msg); if (stream_iter_status == LTTNG_LIVE_ITERATOR_STATUS_END) { @@ -1094,7 +1020,7 @@ next_stream_iterator_for_trace(struct lttng_live_msg_iter *lttng_live_msg_iter, } if (stream_iter_status != LTTNG_LIVE_ITERATOR_STATUS_OK) { - goto end; + return stream_iter_status; } BT_ASSERT_DBG(msg); @@ -1125,9 +1051,8 @@ next_stream_iterator_for_trace(struct lttng_live_msg_iter *lttng_live_msg_iter, * We received a message from the past. This * may be fixable but it can also be an error. */ - stream_iter_status = - handle_late_message(lttng_live_msg_iter, stream_iter, curr_msg_ts_ns, *msg); - if (stream_iter_status != LTTNG_LIVE_ITERATOR_STATUS_OK) { + if (handle_late_message(lttng_live_msg_iter, stream_iter, curr_msg_ts_ns, *msg) != + LTTNG_LIVE_ITERATOR_STATUS_OK) { BT_CPPLOGE_APPEND_CAUSE_SPEC(lttng_live_msg_iter->logger, "Late message could not be handled correctly: " "lttng-live-msg-iter-addr={}, " @@ -1136,8 +1061,7 @@ next_stream_iterator_for_trace(struct lttng_live_msg_iter *lttng_live_msg_iter, fmt::ptr(lttng_live_msg_iter), stream_iter->name, curr_msg_ts_ns, lttng_live_msg_iter->last_msg_ts_ns); - stream_iter_status = LTTNG_LIVE_ITERATOR_STATUS_ERROR; - goto end; + return LTTNG_LIVE_ITERATOR_STATUS_ERROR; } } } @@ -1202,18 +1126,15 @@ next_stream_iterator_for_trace(struct lttng_live_msg_iter *lttng_live_msg_iter, if (youngest_candidate_stream_iter) { *youngest_trace_stream_iter = youngest_candidate_stream_iter; - stream_iter_status = LTTNG_LIVE_ITERATOR_STATUS_OK; + return LTTNG_LIVE_ITERATOR_STATUS_OK; } else { /* * The only case where we don't have a candidate for this trace * is if we reached the end of all the iterators. */ BT_ASSERT(live_trace->stream_iterators.empty()); - stream_iter_status = LTTNG_LIVE_ITERATOR_STATUS_END; + return LTTNG_LIVE_ITERATOR_STATUS_END; } - -end: - return stream_iter_status; } static enum lttng_live_iterator_status @@ -1238,7 +1159,7 @@ next_stream_iterator_for_session(struct lttng_live_msg_iter *lttng_live_msg_iter if (stream_iter_status != LTTNG_LIVE_ITERATOR_STATUS_OK && stream_iter_status != LTTNG_LIVE_ITERATOR_STATUS_CONTINUE && stream_iter_status != LTTNG_LIVE_ITERATOR_STATUS_END) { - goto end; + return stream_iter_status; } while (trace_idx < session->traces.size()) { @@ -1255,7 +1176,7 @@ next_stream_iterator_for_session(struct lttng_live_msg_iter *lttng_live_msg_iter */ trace_is_ended = true; } else if (stream_iter_status != LTTNG_LIVE_ITERATOR_STATUS_OK) { - goto end; + return stream_iter_status; } if (!trace_is_ended) { @@ -1303,7 +1224,7 @@ next_stream_iterator_for_session(struct lttng_live_msg_iter *lttng_live_msg_iter } if (youngest_candidate_stream_iter) { *youngest_session_stream_iter = youngest_candidate_stream_iter; - stream_iter_status = LTTNG_LIVE_ITERATOR_STATUS_OK; + return LTTNG_LIVE_ITERATOR_STATUS_OK; } else { /* * The only cases where we don't have a candidate for this @@ -1315,10 +1236,8 @@ next_stream_iterator_for_session(struct lttng_live_msg_iter *lttng_live_msg_iter * In either cases, we return END. */ BT_ASSERT(session->traces.empty()); - stream_iter_status = LTTNG_LIVE_ITERATOR_STATUS_END; + return LTTNG_LIVE_ITERATOR_STATUS_END; } -end: - return stream_iter_status; } static inline void put_messages(bt_message_array_const msgs, uint64_t count) @@ -1355,11 +1274,10 @@ lttng_live_msg_iter_next(bt_self_message_iterator *self_msg_it, bt_message_array * is to prevent other graph users from using this live * iterator in an messed up internal state. */ - status = BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR; BT_CPPLOGE_APPEND_CAUSE_SPEC( lttng_live_msg_iter->logger, "Message iterator was interrupted during a previous call to the `next()` and currently does not support continuing after such event."); - goto end; + return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR; } /* @@ -1375,8 +1293,7 @@ lttng_live_msg_iter_next(bt_self_message_iterator *self_msg_it, bt_message_array */ if (lttng_live_msg_iter->sessions.empty()) { if (lttng_live->params.sess_not_found_act != SESSION_NOT_FOUND_ACTION_CONTINUE) { - status = BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END; - goto end; + return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END; } else { /* * The are no more active session for this session @@ -1386,15 +1303,14 @@ lttng_live_msg_iter_next(bt_self_message_iterator *self_msg_it, bt_message_array viewer_status = lttng_live_create_viewer_session(lttng_live_msg_iter); if (viewer_status != LTTNG_LIVE_VIEWER_STATUS_OK) { if (viewer_status == LTTNG_LIVE_VIEWER_STATUS_ERROR) { - status = BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR; BT_CPPLOGE_APPEND_CAUSE_SPEC(lttng_live_msg_iter->logger, "Error creating LTTng live viewer session"); + return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR; } else if (viewer_status == LTTNG_LIVE_VIEWER_STATUS_INTERRUPTED) { - status = BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN; + return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN; } else { bt_common_abort(); } - goto end; } } } @@ -1471,7 +1387,7 @@ lttng_live_msg_iter_next(bt_self_message_iterator *self_msg_it, bt_message_array * that of the current candidate message. We * must break the tie in a predictable manner. */ - BT_CPPLOGD_STR_SPEC( + BT_CPPLOGD_SPEC( lttng_live_msg_iter->logger, "Two of the next message candidates have the same timestamps, pick one deterministically."); /* @@ -1572,7 +1488,6 @@ return_status: bt_common_abort(); } -end: return status; } catch (const std::bad_alloc&) { return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_MEMORY_ERROR; @@ -1581,15 +1496,15 @@ end: } } -static struct lttng_live_msg_iter * +static lttng_live_msg_iter::UP lttng_live_msg_iter_create(struct lttng_live_component *lttng_live_comp, bt_self_message_iterator *self_msg_it) { - lttng_live_msg_iter *msg_iter = new lttng_live_msg_iter {lttng_live_comp->logger}; + auto msg_iter = bt2s::make_unique(lttng_live_comp->logger); + msg_iter->self_comp = lttng_live_comp->self_comp; msg_iter->lttng_live_comp = lttng_live_comp; msg_iter->self_msg_iter = self_msg_it; - msg_iter->active_stream_iter = 0; msg_iter->last_msg_ts_ns = INT64_MIN; msg_iter->was_interrupted = false; @@ -1602,9 +1517,7 @@ lttng_live_msg_iter_init(bt_self_message_iterator *self_msg_it, bt_self_message_iterator_configuration *, bt_self_component_port_output *) { try { - bt_message_iterator_class_initialize_method_status status; struct lttng_live_component *lttng_live; - struct lttng_live_msg_iter *lttng_live_msg_iter; enum lttng_live_viewer_status viewer_status; bt_self_component *self_comp = bt_self_message_iterator_borrow_component(self_msg_it); @@ -1614,17 +1527,16 @@ lttng_live_msg_iter_init(bt_self_message_iterator *self_msg_it, BT_ASSERT(!lttng_live->has_msg_iter); lttng_live->has_msg_iter = true; - lttng_live_msg_iter = lttng_live_msg_iter_create(lttng_live, self_msg_it); + auto lttng_live_msg_iter = lttng_live_msg_iter_create(lttng_live, self_msg_it); if (!lttng_live_msg_iter) { BT_CPPLOGE_APPEND_CAUSE_SPEC(lttng_live->logger, "Failed to create lttng_live_msg_iter"); - status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR; - goto error; + return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR; } viewer_status = live_viewer_connection_create( - lttng_live->params.url.c_str(), false, lttng_live_msg_iter, lttng_live_msg_iter->logger, - <tng_live_msg_iter->viewer_connection); + lttng_live->params.url.c_str(), false, lttng_live_msg_iter.get(), + lttng_live_msg_iter->logger, lttng_live_msg_iter->viewer_connection); if (viewer_status != LTTNG_LIVE_VIEWER_STATUS_OK) { if (viewer_status == LTTNG_LIVE_VIEWER_STATUS_ERROR) { BT_CPPLOGE_APPEND_CAUSE_SPEC(lttng_live_msg_iter->logger, @@ -1638,11 +1550,10 @@ lttng_live_msg_iter_init(bt_self_message_iterator *self_msg_it, "Interrupted while creating viewer connection"); } - status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_ERROR; - goto error; + return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_ERROR; } - viewer_status = lttng_live_create_viewer_session(lttng_live_msg_iter); + viewer_status = lttng_live_create_viewer_session(lttng_live_msg_iter.get()); if (viewer_status != LTTNG_LIVE_VIEWER_STATUS_OK) { if (viewer_status == LTTNG_LIVE_VIEWER_STATUS_ERROR) { BT_CPPLOGE_APPEND_CAUSE_SPEC(lttng_live_msg_iter->logger, @@ -1656,8 +1567,7 @@ lttng_live_msg_iter_init(bt_self_message_iterator *self_msg_it, "Interrupted when creating viewer session"); } - status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_ERROR; - goto error; + return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_ERROR; } if (lttng_live_msg_iter->sessions.empty()) { @@ -1678,8 +1588,7 @@ lttng_live_msg_iter_init(bt_self_message_iterator *self_msg_it, "component parameter: url =\"{}\"", SESS_NOT_FOUND_ACTION_PARAM, SESS_NOT_FOUND_ACTION_FAIL_STR, lttng_live->params.url); - status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_ERROR; - goto error; + return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_ERROR; case SESSION_NOT_FOUND_ACTION_END: BT_CPPLOGI_SPEC(lttng_live_msg_iter->logger, "Unable to connect to the requested live viewer session. " @@ -1693,14 +1602,8 @@ lttng_live_msg_iter_init(bt_self_message_iterator *self_msg_it, } } - bt_self_message_iterator_set_data(self_msg_it, lttng_live_msg_iter); - status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_OK; - goto end; - -error: - lttng_live_msg_iter_destroy(lttng_live_msg_iter); -end: - return status; + bt_self_message_iterator_set_data(self_msg_it, lttng_live_msg_iter.release()); + return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_OK; } catch (const std::bad_alloc&) { return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR; } catch (const bt2::Error&) { @@ -1713,136 +1616,88 @@ static struct bt_param_validation_map_value_entry_descr list_sessions_params[] = bt_param_validation_value_descr::makeString()}, BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_END}; -static bt_component_class_query_method_status -lttng_live_query_list_sessions(const bt_value *params, const bt_value **result, - const bt2c::Logger& logger) +static bt2::Value::Shared lttng_live_query_list_sessions(const bt2::ConstMapValue params, + const bt2c::Logger& logger) { - bt_component_class_query_method_status status; - const bt_value *url_value = NULL; const char *url; - struct live_viewer_connection *viewer_connection = NULL; + live_viewer_connection::UP viewer_connection; enum lttng_live_viewer_status viewer_status; enum bt_param_validation_status validation_status; gchar *validate_error = NULL; - validation_status = bt_param_validation_validate(params, list_sessions_params, &validate_error); + validation_status = + bt_param_validation_validate(params.libObjPtr(), list_sessions_params, &validate_error); if (validation_status == BT_PARAM_VALIDATION_STATUS_MEMORY_ERROR) { - status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR; - goto error; + throw bt2c::MemoryError {}; } else if (validation_status == BT_PARAM_VALIDATION_STATUS_VALIDATION_ERROR) { - status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; - BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "{}", validate_error); - goto error; + bt2c::GCharUP errorFreer {validate_error}; + + BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error, "{}", validate_error); } - url_value = bt_value_map_borrow_entry_value_const(params, URL_PARAM); - url = bt_value_string_get(url_value); + url = params[URL_PARAM]->asString().value(); - viewer_status = live_viewer_connection_create(url, true, NULL, logger, &viewer_connection); + viewer_status = live_viewer_connection_create(url, true, NULL, logger, viewer_connection); if (viewer_status != LTTNG_LIVE_VIEWER_STATUS_OK) { if (viewer_status == LTTNG_LIVE_VIEWER_STATUS_ERROR) { - BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "Failed to create viewer connection"); - status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; + BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error, + "Failed to create viewer connection"); } else if (viewer_status == LTTNG_LIVE_VIEWER_STATUS_INTERRUPTED) { - status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_AGAIN; + throw bt2c::TryAgain {}; } else { bt_common_abort(); } - goto error; - } - - status = live_viewer_connection_list_sessions(viewer_connection, result); - if (status != BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK) { - BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "Failed to list viewer sessions"); - goto error; } - goto end; - -error: - BT_VALUE_PUT_REF_AND_RESET(*result); - - if (status >= 0) { - status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; - } - -end: - delete viewer_connection; - - g_free(validate_error); - - return status; + return live_viewer_connection_list_sessions(viewer_connection.get()); } -static bt_component_class_query_method_status -lttng_live_query_support_info(const bt_value *params, const bt_value **result, - const bt2c::Logger& logger) +static bt2::Value::Shared lttng_live_query_support_info(const bt2::ConstMapValue params, + const bt2c::Logger& logger) { - bt_component_class_query_method_status status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK; - const bt_value *input_type_value; - const bt_value *input_value; - double weight = 0; struct bt_common_lttng_live_url_parts parts = {}; + bt_common_lttng_live_url_parts_deleter partsDeleter {parts}; /* Used by the logging macros */ __attribute__((unused)) bt_self_component *self_comp = NULL; - *result = NULL; - input_type_value = bt_value_map_borrow_entry_value_const(params, "type"); - if (!input_type_value) { - BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "Missing expected `type` parameter."); - goto error; + const auto typeValue = params["type"]; + if (!typeValue) { + BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error, + "Missing expected `type` parameter."); } - if (!bt_value_is_string(input_type_value)) { - BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "`type` parameter is not a string value."); - goto error; + if (!typeValue->isString()) { + BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error, + "`type` parameter is not a string value."); } - if (strcmp(bt_value_string_get(input_type_value), "string") != 0) { + if (strcmp(typeValue->asString().value(), "string") != 0) { /* We don't handle file system paths */ - goto create_result; + return bt2::RealValue::create(); } - input_value = bt_value_map_borrow_entry_value_const(params, "input"); - if (!input_value) { - BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "Missing expected `input` parameter."); - goto error; + const auto inputValue = params["input"]; + if (!inputValue) { + BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error, + "Missing expected `input` parameter."); } - if (!bt_value_is_string(input_value)) { - BT_CPPLOGE_APPEND_CAUSE_SPEC(logger, "`input` parameter is not a string value."); - goto error; + if (!inputValue->isString()) { + BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(logger, bt2::Error, + "`input` parameter is not a string value."); } - parts = bt_common_parse_lttng_live_url(bt_value_string_get(input_value), NULL, 0); + parts = bt_common_parse_lttng_live_url(inputValue->asString().value(), NULL, 0); if (parts.session_name) { /* * Looks pretty much like an LTTng live URL: we got the * session name part, which forms a complete URL. */ - weight = .75; + return bt2::RealValue::create(.75); } -create_result: - *result = bt_value_real_create_init(weight); - if (!*result) { - status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR; - goto error; - } - - goto end; - -error: - if (status >= 0) { - status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR; - } - - BT_ASSERT(!*result); - -end: - bt_common_destroy_lttng_live_url_parts(&parts); - return status; + return bt2::RealValue::create(); } bt_component_class_query_method_status lttng_live_query(bt_self_component_class_source *comp_class, @@ -1852,23 +1707,26 @@ bt_component_class_query_method_status lttng_live_query(bt_self_component_class_ const bt_value **result) { try { - bt_component_class_query_method_status status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK; bt2c::Logger logger {bt2::SelfComponentClass {comp_class}, bt2::PrivateQueryExecutor {priv_query_exec}, "PLUGIN/SRC.CTF.LTTNG-LIVE/QUERY"}; + const bt2::ConstMapValue paramsObj(params); + bt2::Value::Shared resultObj; if (strcmp(object, "sessions") == 0) { - status = lttng_live_query_list_sessions(params, result, logger); + resultObj = lttng_live_query_list_sessions(paramsObj, logger); } else if (strcmp(object, "babeltrace.support-info") == 0) { - status = lttng_live_query_support_info(params, result, logger); + resultObj = lttng_live_query_support_info(paramsObj, logger); } else { BT_CPPLOGI_SPEC(logger, "Unknown query object `{}`", object); - status = BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_UNKNOWN_OBJECT; - goto end; + return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_UNKNOWN_OBJECT; } -end: - return status; + *result = resultObj.release().libObjPtr(); + + return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK; + } catch (const bt2c::TryAgain&) { + return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR; } catch (const std::bad_alloc&) { return BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_MEMORY_ERROR; } catch (const bt2::Error&) {