X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-relayd%2Flive.cpp;h=4724a3adaab0bcbfe5d64dfc44245b57c0f202da;hb=1524f98c04431d04e50796f83a9dd29184b3a8a4;hp=e3d27b1ef8411a1a6efc837ffa10051d6108155f;hpb=7201079fc6b433affa4e6d5f0cd3cc8a08b549ac;p=lttng-tools.git diff --git a/src/bin/lttng-relayd/live.cpp b/src/bin/lttng-relayd/live.cpp index e3d27b1ef..4724a3ada 100644 --- a/src/bin/lttng-relayd/live.cpp +++ b/src/bin/lttng-relayd/live.cpp @@ -31,34 +31,34 @@ #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include -#include "cmd.h" -#include "connection.h" -#include "ctf-trace.h" -#include "health-relayd.h" -#include "live.h" -#include "lttng-relayd.h" -#include "session.h" -#include "stream.h" -#include "testpoint.h" -#include "utils.h" -#include "viewer-session.h" -#include "viewer-stream.h" +#include "cmd.hpp" +#include "connection.hpp" +#include "ctf-trace.hpp" +#include "health-relayd.hpp" +#include "live.hpp" +#include "lttng-relayd.hpp" +#include "session.hpp" +#include "stream.hpp" +#include "testpoint.hpp" +#include "utils.hpp" +#include "viewer-session.hpp" +#include "viewer-stream.hpp" #define SESSION_BUF_DEFAULT_COUNT 16 @@ -116,6 +116,68 @@ const char *lttng_viewer_command_str(lttng_viewer_command cmd) } } +static +const char *lttng_viewer_next_index_return_code_str( + enum lttng_viewer_next_index_return_code code) +{ + switch (code) { + case LTTNG_VIEWER_INDEX_OK: + return "INDEX_OK"; + case LTTNG_VIEWER_INDEX_RETRY: + return "INDEX_RETRY"; + case LTTNG_VIEWER_INDEX_HUP: + return "INDEX_HUP"; + case LTTNG_VIEWER_INDEX_ERR: + return "INDEX_ERR"; + case LTTNG_VIEWER_INDEX_INACTIVE: + return "INDEX_INACTIVE"; + case LTTNG_VIEWER_INDEX_EOF: + return "INDEX_EOF"; + default: + abort(); + } +} + +static +const char *lttng_viewer_attach_return_code_str( + enum lttng_viewer_attach_return_code code) +{ + switch (code) { + case LTTNG_VIEWER_ATTACH_OK: + return "ATTACH_OK"; + case LTTNG_VIEWER_ATTACH_ALREADY: + return "ATTACH_ALREADY"; + case LTTNG_VIEWER_ATTACH_UNK: + return "ATTACH_UNK"; + case LTTNG_VIEWER_ATTACH_NOT_LIVE: + return "ATTACH_NOT_LIVE"; + case LTTNG_VIEWER_ATTACH_SEEK_ERR: + return "ATTACH_SEEK_ERR"; + case LTTNG_VIEWER_ATTACH_NO_SESSION: + return "ATTACH_NO_SESSION"; + default: + abort(); + } +}; + +static +const char *lttng_viewer_get_packet_return_code_str( + enum lttng_viewer_get_packet_return_code code) +{ + switch (code) { + case LTTNG_VIEWER_GET_PACKET_OK: + return "GET_PACKET_OK"; + case LTTNG_VIEWER_GET_PACKET_RETRY: + return "GET_PACKET_RETRY"; + case LTTNG_VIEWER_GET_PACKET_ERR: + return "GET_PACKET_ERR"; + case LTTNG_VIEWER_GET_PACKET_EOF: + return "GET_PACKET_EOF"; + default: + abort(); + } +}; + /* * Cleanup the daemon */ @@ -402,7 +464,7 @@ static int make_viewer_streams(struct relay_session *relay_session, * chunk can be used safely. */ if ((relay_stream->ongoing_rotation.is_set || - relay_session->ongoing_rotation) && + session_has_ongoing_rotation(relay_session)) && relay_stream->trace_chunk) { viewer_stream_trace_chunk = lttng_trace_chunk_copy( relay_stream->trace_chunk); @@ -528,54 +590,6 @@ int relayd_live_stop(void) return 0; } -/* - * Create a poll set with O_CLOEXEC and add the thread quit pipe to the set. - */ -static -int create_named_thread_poll_set(struct lttng_poll_event *events, - int size, const char *name) -{ - int ret; - - if (events == NULL || size == 0) { - ret = -1; - goto error; - } - - ret = fd_tracker_util_poll_create(the_fd_tracker, - name, events, 1, LTTNG_CLOEXEC); - if (ret) { - PERROR("Failed to create \"%s\" poll file descriptor", name); - goto error; - } - - /* Add quit pipe */ - ret = lttng_poll_add(events, thread_quit_pipe[0], LPOLLIN | LPOLLERR); - if (ret < 0) { - goto error; - } - - return 0; - -error: - return ret; -} - -/* - * Check if the thread quit pipe was triggered. - * - * Return 1 if it was triggered else 0; - */ -static -int check_thread_quit_pipe(int fd, uint32_t events) -{ - if (fd == thread_quit_pipe[0] && (events & LPOLLIN)) { - return 1; - } - - return 0; -} - static int create_sock(void *data, int *out_fd) { @@ -593,7 +607,7 @@ end: } static -int close_sock(void *data, int *in_fd) +int close_sock(void *data, int *in_fd __attribute__((unused))) { struct lttcomm_sock *sock = (lttcomm_sock *) data; @@ -704,10 +718,10 @@ error: * This thread manages the listening for new connections on the network */ static -void *thread_listener(void *data) +void *thread_listener(void *data __attribute__((unused))) { - int i, ret, pollfd, err = -1; - uint32_t revents, nb_fd; + int i, ret, err = -1; + uint32_t nb_fd; struct lttng_poll_event events; struct lttcomm_sock *live_control_sock; @@ -764,15 +778,15 @@ restart: DBG("Relay new viewer connection received"); for (i = 0; i < nb_fd; i++) { - health_code_update(); - /* Fetch once the poll data */ - revents = LTTNG_POLL_GETEV(&events, i); - pollfd = LTTNG_POLL_GETFD(&events, i); + const auto revents = LTTNG_POLL_GETEV(&events, i); + const auto pollfd = LTTNG_POLL_GETFD(&events, i); + + health_code_update(); - /* Thread quit pipe has been closed. Killing thread. */ - ret = check_thread_quit_pipe(pollfd, revents); - if (ret) { + /* Activity on thread quit pipe, exiting. */ + if (relayd_is_thread_quit_pipe(pollfd)) { + DBG("Activity on thread quit pipe"); err = 0; goto exit; } @@ -869,7 +883,7 @@ error_sock_control: * This thread manages the dispatching of the requests to worker threads */ static -void *thread_dispatcher(void *data) +void *thread_dispatcher(void *data __attribute__((unused))) { int err = -1; ssize_t ret; @@ -908,7 +922,7 @@ void *thread_dispatcher(void *data) /* Continue thread execution */ break; } - conn = caa_container_of(node, struct relay_connection, qnode); + conn = lttng::utils::container_of(node, &relay_connection::qnode); DBG("Dispatching viewer request waiting on sock %d", conn->sock->fd); @@ -1050,7 +1064,7 @@ int viewer_list_sessions(struct relay_connection *conn) uint32_t buf_count = SESSION_BUF_DEFAULT_COUNT; uint32_t count = 0; - send_session_buf = (lttng_viewer_session *) zmalloc(SESSION_BUF_DEFAULT_COUNT * sizeof(*send_session_buf)); + send_session_buf = calloc(SESSION_BUF_DEFAULT_COUNT); if (!send_session_buf) { return -1; } @@ -1194,7 +1208,7 @@ int viewer_get_new_streams(struct relay_connection *conn) * stream, because the chunk can be in an intermediate state * due to directory renaming. */ - if (session->ongoing_rotation) { + if (session_has_ongoing_rotation(session)) { DBG("Relay session %" PRIu64 " rotation ongoing", session_id); response.status = htobe32(LTTNG_VIEWER_NEW_STREAMS_NO_NEW); goto send_reply_unlock; @@ -1204,7 +1218,12 @@ int viewer_get_new_streams(struct relay_connection *conn) LTTNG_VIEWER_SEEK_BEGINNING, &nb_total, &nb_unsent, &nb_created, &closed); if (ret < 0) { - goto error_unlock_session; + /* + * This is caused by an internal error; propagate the negative + * 'ret' to close the connection. + */ + response.status = htobe32(LTTNG_VIEWER_NEW_STREAMS_ERR); + goto send_reply_unlock; } send_streams = 1; response.status = htobe32(LTTNG_VIEWER_NEW_STREAMS_OK); @@ -1259,10 +1278,6 @@ end_put_session: } error: return ret; -error_unlock_session: - pthread_mutex_unlock(&session->lock); - session_put(session); - return ret; } /* @@ -1293,28 +1308,34 @@ int viewer_attach_session(struct relay_connection *conn) } session_id = be64toh(request.session_id); + health_code_update(); memset(&response, 0, sizeof(response)); if (!conn->viewer_session) { - DBG("Client trying to attach before creating a live viewer session"); - response.status = htobe32(LTTNG_VIEWER_ATTACH_NO_SESSION); + viewer_attach_status = LTTNG_VIEWER_ATTACH_NO_SESSION; + DBG("Client trying to attach before creating a live viewer session, returning status=%s", + lttng_viewer_attach_return_code_str(viewer_attach_status)); goto send_reply; } session = session_get_by_id(session_id); if (!session) { - DBG("Relay session %" PRIu64 " not found", session_id); - response.status = htobe32(LTTNG_VIEWER_ATTACH_UNK); + viewer_attach_status = LTTNG_VIEWER_ATTACH_UNK; + DBG("Relay session %" PRIu64 " not found, returning status=%s", + session_id, + lttng_viewer_attach_return_code_str(viewer_attach_status)); goto send_reply; } - DBG("Attach session ID %" PRIu64 " received", session_id); + DBG("Attach relay session ID %" PRIu64 " received", session_id); pthread_mutex_lock(&session->lock); if (session->live_timer == 0) { - DBG("Not live session"); - response.status = htobe32(LTTNG_VIEWER_ATTACH_NOT_LIVE); + viewer_attach_status = LTTNG_VIEWER_ATTACH_NOT_LIVE; + DBG("Relay session ID %" PRIu64 " is not a live session, returning status=%s", + session_id, + lttng_viewer_attach_return_code_str(viewer_attach_status)); goto send_reply; } @@ -1322,19 +1343,23 @@ int viewer_attach_session(struct relay_connection *conn) viewer_attach_status = viewer_session_attach(conn->viewer_session, session); if (viewer_attach_status != LTTNG_VIEWER_ATTACH_OK) { - response.status = htobe32(viewer_attach_status); + DBG("Error attaching to relay session %" PRIu64 ", returning status=%s", + session_id, + lttng_viewer_attach_return_code_str(viewer_attach_status)); goto send_reply; } switch (be32toh(request.seek)) { case LTTNG_VIEWER_SEEK_BEGINNING: case LTTNG_VIEWER_SEEK_LAST: - response.status = htobe32(LTTNG_VIEWER_ATTACH_OK); + viewer_attach_status = LTTNG_VIEWER_ATTACH_OK; seek_type = (lttng_viewer_seek) be32toh(request.seek); break; default: - ERR("Wrong seek parameter"); - response.status = htobe32(LTTNG_VIEWER_ATTACH_SEEK_ERR); + ERR("Wrong seek parameter for relay session %" PRIu64 + ", returning status=%s", session_id, + lttng_viewer_attach_return_code_str(viewer_attach_status)); + viewer_attach_status = LTTNG_VIEWER_ATTACH_SEEK_ERR; send_streams = 0; goto send_reply; } @@ -1344,7 +1369,7 @@ int viewer_attach_session(struct relay_connection *conn) * stream, because the chunk can be in an intermediate state * due to directory renaming. */ - if (session->ongoing_rotation) { + if (session_has_ongoing_rotation(session)) { DBG("Relay session %" PRIu64 " rotation ongoing", session_id); send_streams = 0; goto send_reply; @@ -1370,12 +1395,18 @@ int viewer_attach_session(struct relay_connection *conn) if (closed) { send_streams = 0; response.streams_count = 0; - response.status = htobe32(LTTNG_VIEWER_ATTACH_UNK); + viewer_attach_status = LTTNG_VIEWER_ATTACH_UNK; + ERR("Session %" PRIu64 " is closed, returning status=%s", + session_id, + lttng_viewer_attach_return_code_str(viewer_attach_status)); goto send_reply; } send_reply: health_code_update(); + + response.status = htobe32((uint32_t) viewer_attach_status); + ret = send_response(conn->sock, &response, sizeof(response)); if (ret < 0) { goto end_put_session; @@ -1486,7 +1517,13 @@ static int check_index_status(struct relay_viewer_stream *vstream, * Last index sent and session connection or relay * stream are closed. */ - index->status = htobe32(LTTNG_VIEWER_INDEX_HUP); + index->status = LTTNG_VIEWER_INDEX_HUP; + DBG("Check index status: Connection or stream are closed, stream %" PRIu64 + ",connection-closed=%d, relay-stream-closed=%d, returning status=%s", + vstream->stream->stream_handle, + trace->session->connection_closed, rstream->closed, + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) index->status)); goto hup; } else if (rstream->beacon_ts_end != -1ULL && (rstream->index_received_seqcount == 0 || @@ -1508,11 +1545,14 @@ static int check_index_status(struct relay_viewer_stream *vstream, * viewer_stream_sync_tracefile_array_tail) and skip over * packet sequence numbers. */ - index->status = htobe32(LTTNG_VIEWER_INDEX_INACTIVE); + index->status = LTTNG_VIEWER_INDEX_INACTIVE; index->timestamp_end = htobe64(rstream->beacon_ts_end); index->stream_id = htobe64(rstream->ctf_stream_id); - DBG("Check index status: inactive with beacon, for stream %" PRIu64, - vstream->stream->stream_handle); + DBG("Check index status: inactive with beacon, for stream %" PRIu64 + ", returning status=%s", + vstream->stream->stream_handle, + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) index->status)); goto index_ready; } else if (rstream->index_received_seqcount == 0 || (vstream->index_sent_seqcount != 0 && @@ -1529,9 +1569,13 @@ static int check_index_status(struct relay_viewer_stream *vstream, * viewer_stream_sync_tracefile_array_tail) and skip over * packet sequence numbers. */ - index->status = htobe32(LTTNG_VIEWER_INDEX_RETRY); - DBG("Check index status: retry for stream %" PRIu64, - vstream->stream->stream_handle); + index->status = LTTNG_VIEWER_INDEX_RETRY; + DBG("Check index status:" + "did not received beacon for stream %" PRIu64 + ", returning status=%s", + vstream->stream->stream_handle, + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) index->status)); goto index_ready; } else if (!tracefile_array_seq_in_file(rstream->tfa, vstream->current_tracefile_id, @@ -1546,7 +1590,13 @@ static int check_index_status(struct relay_viewer_stream *vstream, ret = viewer_stream_rotate(vstream); if (ret == 1) { /* EOF across entire stream. */ - index->status = htobe32(LTTNG_VIEWER_INDEX_HUP); + index->status = LTTNG_VIEWER_INDEX_HUP; + DBG("Check index status:" + "reached end of file for stream %" PRIu64 + ", returning status=%s", + vstream->stream->stream_handle, + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) index->status)); goto hup; } /* @@ -1568,12 +1618,15 @@ static int check_index_status(struct relay_viewer_stream *vstream, rstream->tfa, vstream->current_tracefile_id, vstream->index_sent_seqcount)) { - index->status = htobe32(LTTNG_VIEWER_INDEX_RETRY); - DBG("Check index status: retry: " + index->status = LTTNG_VIEWER_INDEX_RETRY; + DBG("Check index status:" "tracefile array sequence number %" PRIu64 - " not in file for stream %" PRIu64, + " not in file for stream %" PRIu64 + ", returning status=%s", vstream->index_sent_seqcount, - vstream->stream->stream_handle); + vstream->stream->stream_handle, + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) index->status)); goto index_ready; } LTTNG_ASSERT(tracefile_array_seq_in_file(rstream->tfa, @@ -1641,9 +1694,11 @@ int viewer_get_next_index(struct relay_connection *conn) vstream = viewer_stream_get_by_id(be64toh(request_index.stream_id)); if (!vstream) { - DBG("Client requested index of unknown stream id %" PRIu64, - (uint64_t) be64toh(request_index.stream_id)); - viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_ERR); + viewer_index.status = LTTNG_VIEWER_INDEX_ERR; + DBG("Client requested index of unknown stream id %" PRIu64", returning status=%s", + (uint64_t) be64toh(request_index.stream_id), + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) viewer_index.status)); goto send_reply; } @@ -1668,19 +1723,31 @@ int viewer_get_next_index(struct relay_connection *conn) * The viewer should not ask for index on metadata stream. */ if (rstream->is_metadata) { - viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_HUP); + viewer_index.status = LTTNG_VIEWER_INDEX_HUP; + DBG("Client requested index of a metadata stream id %" PRIu64", returning status=%s", + (uint64_t) be64toh(request_index.stream_id), + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) viewer_index.status)); goto send_reply; } if (rstream->ongoing_rotation.is_set) { /* Rotation is ongoing, try again later. */ - viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_RETRY); + viewer_index.status = LTTNG_VIEWER_INDEX_RETRY; + DBG("Client requested index for stream id %" PRIu64" while a stream rotation is ongoing, returning status=%s", + (uint64_t) be64toh(request_index.stream_id), + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) viewer_index.status)); goto send_reply; } - if (rstream->trace->session->ongoing_rotation) { + if (session_has_ongoing_rotation(rstream->trace->session)) { /* Rotation is ongoing, try again later. */ - viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_RETRY); + viewer_index.status = LTTNG_VIEWER_INDEX_RETRY; + DBG("Client requested index for stream id %" PRIu64" while a session rotation is ongoing, returning status=%s", + (uint64_t) be64toh(request_index.stream_id), + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) viewer_index.status)); goto send_reply; } @@ -1696,7 +1763,12 @@ int viewer_get_next_index(struct relay_connection *conn) conn->viewer_session, rstream->trace_chunk); if (ret) { - viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_ERR); + viewer_index.status = LTTNG_VIEWER_INDEX_ERR; + ERR("Error copying trace chunk for stream id %" PRIu64 + ", returning status=%s", + (uint64_t) be64toh(request_index.stream_id), + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) viewer_index.status)); goto send_reply; } } @@ -1779,15 +1851,30 @@ int viewer_get_next_index(struct relay_connection *conn) ret = try_open_index(vstream, rstream); if (ret == -ENOENT) { if (rstream->closed) { - viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_HUP); + viewer_index.status = LTTNG_VIEWER_INDEX_HUP; + DBG("Cannot open index for stream id %" PRIu64 + "stream is closed, returning status=%s", + (uint64_t) be64toh(request_index.stream_id), + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) viewer_index.status)); goto send_reply; } else { - viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_RETRY); + viewer_index.status = LTTNG_VIEWER_INDEX_RETRY; + DBG("Cannot open index for stream id %" PRIu64 + ", returning status=%s", + (uint64_t) be64toh(request_index.stream_id), + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) viewer_index.status)); goto send_reply; } } if (ret < 0) { - viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_ERR); + viewer_index.status = LTTNG_VIEWER_INDEX_ERR; + ERR("Error opening index for stream id %" PRIu64 + ", returning status=%s", + (uint64_t) be64toh(request_index.stream_id), + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) viewer_index.status)); goto send_reply; } @@ -1821,7 +1908,12 @@ int viewer_get_next_index(struct relay_connection *conn) if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { if (status == LTTNG_TRACE_CHUNK_STATUS_NO_FILE && rstream->closed) { - viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_HUP); + viewer_index.status = LTTNG_VIEWER_INDEX_HUP; + DBG("Cannot find trace chunk file and stream is closed for stream id %" PRIu64 + ", returning status=%s", + (uint64_t) be64toh(request_index.stream_id), + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) viewer_index.status)); goto send_reply; } PERROR("Failed to open trace file for viewer stream"); @@ -1832,7 +1924,12 @@ int viewer_get_next_index(struct relay_connection *conn) ret = check_new_streams(conn); if (ret < 0) { - viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_ERR); + viewer_index.status = LTTNG_VIEWER_INDEX_ERR; + ERR("Error checking for new streams before sending new index to stream id %" PRIu64 + ", returning status=%s", + (uint64_t) be64toh(request_index.stream_id), + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) viewer_index.status)); goto send_reply; } else if (ret == 1) { viewer_index.flags |= LTTNG_VIEWER_FLAG_NEW_STREAM; @@ -1840,11 +1937,20 @@ int viewer_get_next_index(struct relay_connection *conn) ret = lttng_index_file_read(vstream->index_file, &packet_index); if (ret) { - ERR("Relay error reading index file"); - viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_ERR); + viewer_index.status = LTTNG_VIEWER_INDEX_ERR; + ERR("Relay error reading index file for stream id %" PRIu64 + ", returning status=%s", + (uint64_t) be64toh(request_index.stream_id), + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) viewer_index.status)); goto send_reply; } else { - viewer_index.status = htobe32(LTTNG_VIEWER_INDEX_OK); + viewer_index.status = LTTNG_VIEWER_INDEX_OK; + DBG("Read index file for stream id %" PRIu64 + ", returning status=%s", + (uint64_t) be64toh(request_index.stream_id), + lttng_viewer_next_index_return_code_str( + (enum lttng_viewer_next_index_return_code) viewer_index.status)); vstream->index_sent_seqcount++; } @@ -1883,6 +1989,7 @@ send_reply: } viewer_index.flags = htobe32(viewer_index.flags); + viewer_index.status = htobe32(viewer_index.status); health_code_update(); ret = send_response(conn->sock, &viewer_index, sizeof(viewer_index)); @@ -1933,6 +2040,7 @@ int viewer_get_packet(struct relay_connection *conn) uint32_t packet_data_len = 0; ssize_t read_len; uint64_t stream_id; + enum lttng_viewer_get_packet_return_code get_packet_status; health_code_update(); @@ -1949,19 +2057,21 @@ int viewer_get_packet(struct relay_connection *conn) vstream = viewer_stream_get_by_id(stream_id); if (!vstream) { - DBG("Client requested packet of unknown stream id %" PRIu64, - stream_id); - reply_header.status = htobe32(LTTNG_VIEWER_GET_PACKET_ERR); + get_packet_status = LTTNG_VIEWER_GET_PACKET_ERR; + DBG("Client requested packet of unknown stream id %" PRIu64 + ", returning status=%s", stream_id, + lttng_viewer_get_packet_return_code_str(get_packet_status)); goto send_reply_nolock; } else { packet_data_len = be32toh(get_packet_info.len); reply_size += packet_data_len; } - reply = (char *) zmalloc(reply_size); + reply = zmalloc(reply_size); if (!reply) { - PERROR("packet reply zmalloc"); - reply_size = sizeof(reply_header); + get_packet_status = LTTNG_VIEWER_GET_PACKET_ERR; + PERROR("Falled to allocate reply, returning status=%s", + lttng_viewer_get_packet_return_code_str(get_packet_status)); goto error; } @@ -1969,29 +2079,31 @@ int viewer_get_packet(struct relay_connection *conn) lseek_ret = fs_handle_seek(vstream->stream_file.handle, be64toh(get_packet_info.offset), SEEK_SET); if (lseek_ret < 0) { + get_packet_status = LTTNG_VIEWER_GET_PACKET_ERR; PERROR("Failed to seek file system handle of viewer stream %" PRIu64 - " to offset %" PRIu64, - stream_id, - (uint64_t) be64toh(get_packet_info.offset)); + " to offset %" PRIu64", returning status=%s", stream_id, + (uint64_t) be64toh(get_packet_info.offset), + lttng_viewer_get_packet_return_code_str(get_packet_status)); goto error; } read_len = fs_handle_read(vstream->stream_file.handle, reply + sizeof(reply_header), packet_data_len); if (read_len < packet_data_len) { + get_packet_status = LTTNG_VIEWER_GET_PACKET_ERR; PERROR("Failed to read from file system handle of viewer stream id %" PRIu64 - ", offset: %" PRIu64, - stream_id, - (uint64_t) be64toh(get_packet_info.offset)); + ", offset: %" PRIu64 ", returning status=%s", stream_id, + (uint64_t) be64toh(get_packet_info.offset), + lttng_viewer_get_packet_return_code_str(get_packet_status)); goto error; } - reply_header.status = htobe32(LTTNG_VIEWER_GET_PACKET_OK); + + get_packet_status = LTTNG_VIEWER_GET_PACKET_OK; reply_header.len = htobe32(packet_data_len); goto send_reply; error: /* No payload to send on error. */ reply_size = sizeof(reply_header); - reply_header.status = htobe32(LTTNG_VIEWER_GET_PACKET_ERR); send_reply: if (vstream) { @@ -2001,6 +2113,7 @@ send_reply_nolock: health_code_update(); + reply_header.status = htobe32(get_packet_status); if (reply) { memcpy(reply, &reply_header, sizeof(reply_header)); ret = send_response(conn->sock, reply, reply_size); @@ -2093,9 +2206,16 @@ int viewer_get_metadata(struct relay_connection *conn) */ if (vstream->metadata_sent > 0) { if (vstream->stream->closed && vstream->stream->no_new_metadata_notified) { - /* Release ownership for the viewer metadata stream. */ + /* + * Release ownership for the viewer metadata + * stream. Note that this reference is the + * viewer's reference. The vstream still exists + * until the end of the function as + * viewer_stream_get_by_id() took a reference. + */ viewer_stream_put(vstream); } + vstream->stream->no_new_metadata_notified = true; } goto send_reply; @@ -2210,7 +2330,7 @@ int viewer_get_metadata(struct relay_connection *conn) } reply.len = htobe64(len); - data = (char *) zmalloc(len); + data = zmalloc(len); if (!data) { PERROR("viewer metadata zmalloc"); goto error; @@ -2494,7 +2614,7 @@ void cleanup_connection_pollfd(struct lttng_poll_event *events, int pollfd) * This thread does the actual work */ static -void *thread_worker(void *data) +void *thread_worker(void *data __attribute__((unused))) { int ret, err = -1; uint32_t nb_fd; @@ -2561,14 +2681,14 @@ restart: */ for (i = 0; i < nb_fd; i++) { /* Fetch once the poll data */ - uint32_t revents = LTTNG_POLL_GETEV(&events, i); - int pollfd = LTTNG_POLL_GETFD(&events, i); + const auto revents = LTTNG_POLL_GETEV(&events, i); + const auto pollfd = LTTNG_POLL_GETFD(&events, i); health_code_update(); - /* Thread quit pipe has been closed. Killing thread. */ - ret = check_thread_quit_pipe(pollfd, revents); - if (ret) { + /* Activity on thread quit pipe, exiting. */ + if (relayd_is_thread_quit_pipe(pollfd)) { + DBG("Activity on thread quit pipe"); err = 0; goto exit; }