X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Frelayd%2Frelayd.c;h=7f0ea74e94085b99873049a736941015e85fda5c;hp=aa3f7685300bdd175abd5492c3cb66f6a75283e5;hb=a7c918ad2aefd0c540b0aa4aacace40941d94643;hpb=8fd623e0d1c389a76e4dc3ee74a77490b678c5b8 diff --git a/src/common/relayd/relayd.c b/src/common/relayd/relayd.c index aa3f76853..7f0ea74e9 100644 --- a/src/common/relayd/relayd.c +++ b/src/common/relayd/relayd.c @@ -15,7 +15,7 @@ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE +#define _LGPL_SOURCE #include #include #include @@ -25,7 +25,9 @@ #include #include +#include #include +#include #include "relayd.h" @@ -41,6 +43,10 @@ static int send_command(struct lttcomm_relayd_sock *rsock, char *buf; uint64_t buf_size = sizeof(header); + if (rsock->sock.fd < 0) { + return -ECONNRESET; + } + if (data) { buf_size += size; } @@ -52,6 +58,7 @@ static int send_command(struct lttcomm_relayd_sock *rsock, goto alloc_error; } + memset(&header, 0, sizeof(header)); header.cmd = htobe32(cmd); header.data_size = htobe64(size); @@ -87,6 +94,10 @@ static int recv_reply(struct lttcomm_relayd_sock *rsock, void *data, size_t size { int ret; + if (rsock->sock.fd < 0) { + return -ECONNRESET; + } + DBG3("Relayd waiting for reply of size %zu", size); ret = rsock->sock.ops->recvmsg(&rsock->sock, data, size, 0); @@ -107,6 +118,57 @@ error: return ret; } +/* + * Starting at 2.4, RELAYD_CREATE_SESSION takes additional parameters to + * support the live reading capability. + */ +static int relayd_create_session_2_4(struct lttcomm_relayd_sock *rsock, + uint64_t *session_id, char *session_name, char *hostname, + int session_live_timer, unsigned int snapshot) +{ + int ret; + struct lttcomm_relayd_create_session_2_4 msg; + + if (lttng_strncpy(msg.session_name, session_name, + sizeof(msg.session_name))) { + ret = -1; + goto error; + } + if (lttng_strncpy(msg.hostname, hostname, sizeof(msg.hostname))) { + ret = -1; + goto error; + } + msg.live_timer = htobe32(session_live_timer); + msg.snapshot = htobe32(snapshot); + + /* Send command */ + ret = send_command(rsock, RELAYD_CREATE_SESSION, &msg, sizeof(msg), 0); + if (ret < 0) { + goto error; + } + +error: + return ret; +} + +/* + * RELAYD_CREATE_SESSION from 2.1 to 2.3. + */ +static int relayd_create_session_2_1(struct lttcomm_relayd_sock *rsock, + uint64_t *session_id) +{ + int ret; + + /* Send command */ + ret = send_command(rsock, RELAYD_CREATE_SESSION, NULL, 0, 0); + if (ret < 0) { + goto error; + } + +error: + return ret; +} + /* * Send a RELAYD_CREATE_SESSION command to the relayd with the given socket and * set session_id of the relayd if we have a successful reply from the relayd. @@ -114,7 +176,9 @@ error: * On success, return 0 else a negative value which is either an errno error or * a lttng error code from the relayd. */ -int relayd_create_session(struct lttcomm_relayd_sock *rsock, uint64_t *session_id) +int relayd_create_session(struct lttcomm_relayd_sock *rsock, uint64_t *session_id, + char *session_name, char *hostname, int session_live_timer, + unsigned int snapshot) { int ret; struct lttcomm_relayd_status_session reply; @@ -124,8 +188,19 @@ int relayd_create_session(struct lttcomm_relayd_sock *rsock, uint64_t *session_i DBG("Relayd create session"); - /* Send command */ - ret = send_command(rsock, RELAYD_CREATE_SESSION, NULL, 0, 0); + switch(rsock->minor) { + case 1: + case 2: + case 3: + ret = relayd_create_session_2_1(rsock, session_id); + break; + case 4: + default: + ret = relayd_create_session_2_4(rsock, session_id, session_name, + hostname, session_live_timer, snapshot); + break; + } + if (ret < 0) { goto error; } @@ -178,8 +253,17 @@ int relayd_add_stream(struct lttcomm_relayd_sock *rsock, const char *channel_nam /* Compat with relayd 2.1 */ if (rsock->minor == 1) { - strncpy(msg.channel_name, channel_name, sizeof(msg.channel_name)); - strncpy(msg.pathname, pathname, sizeof(msg.pathname)); + memset(&msg, 0, sizeof(msg)); + if (lttng_strncpy(msg.channel_name, channel_name, + sizeof(msg.channel_name))) { + ret = -1; + goto error; + } + if (lttng_strncpy(msg.pathname, pathname, + sizeof(msg.pathname))) { + ret = -1; + goto error; + } /* Send command */ ret = send_command(rsock, RELAYD_ADD_STREAM, (void *) &msg, sizeof(msg), 0); @@ -187,9 +271,18 @@ int relayd_add_stream(struct lttcomm_relayd_sock *rsock, const char *channel_nam goto error; } } else { + memset(&msg_2_2, 0, sizeof(msg_2_2)); /* Compat with relayd 2.2+ */ - strncpy(msg_2_2.channel_name, channel_name, sizeof(msg_2_2.channel_name)); - strncpy(msg_2_2.pathname, pathname, sizeof(msg_2_2.pathname)); + if (lttng_strncpy(msg_2_2.channel_name, channel_name, + sizeof(msg_2_2.channel_name))) { + ret = -1; + goto error; + } + if (lttng_strncpy(msg_2_2.pathname, pathname, + sizeof(msg_2_2.pathname))) { + ret = -1; + goto error; + } msg_2_2.tracefile_size = htobe64(tracefile_size); msg_2_2.tracefile_count = htobe64(tracefile_count); @@ -227,6 +320,59 @@ error: return ret; } +/* + * Inform the relay that all the streams for the current channel has been sent. + * + * On success return 0 else return ret_code negative value. + */ +int relayd_streams_sent(struct lttcomm_relayd_sock *rsock) +{ + int ret; + struct lttcomm_relayd_generic_reply reply; + + /* Code flow error. Safety net. */ + assert(rsock); + + DBG("Relayd sending streams sent."); + + /* This feature was introduced in 2.4, ignore it for earlier versions. */ + if (rsock->minor < 4) { + ret = 0; + goto end; + } + + /* Send command */ + ret = send_command(rsock, RELAYD_STREAMS_SENT, NULL, 0, 0); + if (ret < 0) { + goto error; + } + + /* Waiting for reply */ + ret = recv_reply(rsock, (void *) &reply, sizeof(reply)); + if (ret < 0) { + goto error; + } + + /* Back to host bytes order. */ + reply.ret_code = be32toh(reply.ret_code); + + /* Return session id or negative ret code. */ + if (reply.ret_code != LTTNG_OK) { + ret = -1; + ERR("Relayd streams sent replied error %d", reply.ret_code); + goto error; + } else { + /* Success */ + ret = 0; + } + + DBG("Relayd streams sent success"); + +error: +end: + return ret; +} + /* * Check version numbers on the relayd. * If major versions are compatible, we assign minor_to_use to the @@ -245,6 +391,7 @@ int relayd_version_check(struct lttcomm_relayd_sock *rsock) DBG("Relayd version check for major.minor %u.%u", rsock->major, rsock->minor); + memset(&msg, 0, sizeof(msg)); /* Prepare network byte order before transmission. */ msg.major = htobe32(rsock->major); msg.minor = htobe32(rsock->minor); @@ -337,6 +484,13 @@ int relayd_connect(struct lttcomm_relayd_sock *rsock) /* Code flow error. Safety net. */ assert(rsock); + if (!rsock->sock.ops) { + /* + * Attempting a connect on a non-initialized socket. + */ + return -ECONNRESET; + } + DBG3("Relayd connect ..."); return rsock->sock.ops->connect(&rsock->sock); @@ -379,6 +533,7 @@ int relayd_close(struct lttcomm_relayd_sock *rsock) PERROR("relayd_close default close"); } } + rsock->sock.fd = -1; end: return ret; @@ -396,6 +551,10 @@ int relayd_send_data_hdr(struct lttcomm_relayd_sock *rsock, assert(rsock); assert(hdr); + if (rsock->sock.fd < 0) { + return -ECONNRESET; + } + DBG3("Relayd sending data header of size %zu", size); /* Again, safety net */ @@ -434,6 +593,7 @@ int relayd_send_close_stream(struct lttcomm_relayd_sock *rsock, uint64_t stream_ DBG("Relayd closing stream id %" PRIu64, stream_id); + memset(&msg, 0, sizeof(msg)); msg.stream_id = htobe64(stream_id); msg.last_net_seq_num = htobe64(last_net_seq_num); @@ -483,6 +643,7 @@ int relayd_data_pending(struct lttcomm_relayd_sock *rsock, uint64_t stream_id, DBG("Relayd data pending for stream id %" PRIu64, stream_id); + memset(&msg, 0, sizeof(msg)); msg.stream_id = htobe64(stream_id); msg.last_net_seq_num = htobe64(last_net_seq_num); @@ -531,6 +692,7 @@ int relayd_quiescent_control(struct lttcomm_relayd_sock *rsock, DBG("Relayd checking quiescent control state"); + memset(&msg, 0, sizeof(msg)); msg.stream_id = htobe64(metadata_stream_id); /* Send command */ @@ -575,6 +737,7 @@ int relayd_begin_data_pending(struct lttcomm_relayd_sock *rsock, uint64_t id) DBG("Relayd begin data pending"); + memset(&msg, 0, sizeof(msg)); msg.session_id = htobe64(id); /* Send command */ @@ -613,7 +776,7 @@ error: int relayd_end_data_pending(struct lttcomm_relayd_sock *rsock, uint64_t id, unsigned int *is_data_inflight) { - int ret; + int ret, recv_ret; struct lttcomm_relayd_end_data_pending msg; struct lttcomm_relayd_generic_reply reply; @@ -622,6 +785,7 @@ int relayd_end_data_pending(struct lttcomm_relayd_sock *rsock, uint64_t id, DBG("Relayd end data pending"); + memset(&msg, 0, sizeof(msg)); msg.session_id = htobe64(id); /* Send command */ @@ -636,18 +800,139 @@ int relayd_end_data_pending(struct lttcomm_relayd_sock *rsock, uint64_t id, goto error; } - reply.ret_code = be32toh(reply.ret_code); - if (reply.ret_code < 0) { - ret = reply.ret_code; + recv_ret = be32toh(reply.ret_code); + if (recv_ret < 0) { + ret = recv_ret; goto error; } - *is_data_inflight = reply.ret_code; + *is_data_inflight = recv_ret; - DBG("Relayd end data pending is data inflight: %d", reply.ret_code); + DBG("Relayd end data pending is data inflight: %d", recv_ret); return 0; error: return ret; } + +/* + * Send index to the relayd. + */ +int relayd_send_index(struct lttcomm_relayd_sock *rsock, + struct ctf_packet_index *index, uint64_t relay_stream_id, + uint64_t net_seq_num) +{ + int ret; + struct lttcomm_relayd_index msg; + struct lttcomm_relayd_generic_reply reply; + + /* Code flow error. Safety net. */ + assert(rsock); + + if (rsock->minor < 4) { + DBG("Not sending indexes before protocol 2.4"); + ret = 0; + goto error; + } + + DBG("Relayd sending index for stream ID %" PRIu64, relay_stream_id); + + memset(&msg, 0, sizeof(msg)); + msg.relay_stream_id = htobe64(relay_stream_id); + msg.net_seq_num = htobe64(net_seq_num); + + /* The index is already in big endian. */ + msg.packet_size = index->packet_size; + msg.content_size = index->content_size; + msg.timestamp_begin = index->timestamp_begin; + msg.timestamp_end = index->timestamp_end; + msg.events_discarded = index->events_discarded; + msg.stream_id = index->stream_id; + + if (rsock->minor >= 8) { + msg.stream_instance_id = index->stream_instance_id; + msg.packet_seq_num = index->packet_seq_num; + } + + /* Send command */ + ret = send_command(rsock, RELAYD_SEND_INDEX, &msg, sizeof(msg), 0); + if (ret < 0) { + goto error; + } + + /* Receive response */ + ret = recv_reply(rsock, (void *) &reply, sizeof(reply)); + if (ret < 0) { + goto error; + } + + reply.ret_code = be32toh(reply.ret_code); + + /* Return session id or negative ret code. */ + if (reply.ret_code != LTTNG_OK) { + ret = -1; + ERR("Relayd send index replied error %d", reply.ret_code); + } else { + /* Success */ + ret = 0; + } + +error: + return ret; +} + +/* + * Ask the relay to reset the metadata trace file (regeneration). + */ +int relayd_reset_metadata(struct lttcomm_relayd_sock *rsock, + uint64_t stream_id, uint64_t version) +{ + int ret; + struct lttcomm_relayd_reset_metadata msg; + struct lttcomm_relayd_generic_reply reply; + + /* Code flow error. Safety net. */ + assert(rsock); + + /* Should have been prevented by the sessiond. */ + if (rsock->minor < 8) { + ERR("Metadata regeneration unsupported before 2.8"); + ret = -1; + goto error; + } + + DBG("Relayd reset metadata stream id %" PRIu64, stream_id); + + memset(&msg, 0, sizeof(msg)); + msg.stream_id = htobe64(stream_id); + msg.version = htobe64(version); + + /* Send command */ + ret = send_command(rsock, RELAYD_RESET_METADATA, (void *) &msg, sizeof(msg), 0); + if (ret < 0) { + goto error; + } + + /* Receive response */ + ret = recv_reply(rsock, (void *) &reply, sizeof(reply)); + if (ret < 0) { + goto error; + } + + reply.ret_code = be32toh(reply.ret_code); + + /* Return session id or negative ret code. */ + if (reply.ret_code != LTTNG_OK) { + ret = -1; + ERR("Relayd reset metadata replied error %d", reply.ret_code); + } else { + /* Success */ + ret = 0; + } + + DBG("Relayd reset metadata stream id %" PRIu64 " successfully", stream_id); + +error: + return ret; +}