X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=src%2Fbin%2Flttng-relayd%2Fmain.c;h=1017fd47f7201924ca1f7abde2b15f728dbe39f7;hb=c3c841f480fd72c3e9ae7212fb9b48bb2e15e821;hp=5782175e6e7f15b57753cc29dedebd54db7a51da;hpb=6b6b9a5a667d6713eb7bcf22daf4f9bbeef00fb1;p=lttng-tools.git diff --git a/src/bin/lttng-relayd/main.c b/src/bin/lttng-relayd/main.c index 5782175e6..1017fd47f 100644 --- a/src/bin/lttng-relayd/main.c +++ b/src/bin/lttng-relayd/main.c @@ -132,6 +132,7 @@ void usage(void) fprintf(stderr, " -d, --daemonize Start as a daemon.\n"); fprintf(stderr, " -C, --control-port URL Control port listening.\n"); fprintf(stderr, " -D, --data-port URL Data port listening.\n"); + fprintf(stderr, " -L, --live-port URL Live view port listening.\n"); fprintf(stderr, " -o, --output PATH Output path for traces. Must use an absolute path.\n"); fprintf(stderr, " -v, --verbose Verbose mode. Activate DBG() macro.\n"); fprintf(stderr, " -g, --group NAME Specify the tracing group name. (default: tracing)\n"); @@ -157,7 +158,7 @@ int parse_args(int argc, char **argv) while (1) { int option_index = 0; - c = getopt_long(argc, argv, "dhv" "C:D:o:g:", + c = getopt_long(argc, argv, "dhv" "C:D:L:o:g:", long_options, &option_index); if (c == -1) { break; @@ -190,6 +191,16 @@ int parse_args(int argc, char **argv) data_uri->port = DEFAULT_NETWORK_DATA_PORT; } break; + case 'L': + ret = uri_parse(optarg, &live_uri); + if (ret < 0) { + ERR("Invalid live URI specified"); + goto exit; + } + if (live_uri->port == 0) { + live_uri->port = DEFAULT_NETWORK_VIEWER_PORT; + } + break; case 'd': opt_daemon = 1; break; @@ -285,6 +296,7 @@ void cleanup(void) uri_free(control_uri); uri_free(data_uri); + /* Live URI is freed in the live thread. */ } /* @@ -800,8 +812,6 @@ void deferred_free_stream(struct rcu_head *head) struct relay_stream *stream = caa_container_of(head, struct relay_stream, rcu_node); - ctf_trace_try_destroy(stream->ctf_trace); - free(stream->path_name); free(stream->channel_name); free(stream); @@ -849,7 +859,11 @@ static void destroy_stream(struct relay_stream *stream) * lookup failure on the live thread side of a stream indicates * that the viewer stream index received value should be used. */ + pthread_mutex_lock(&stream->viewer_stream_rotation_lock); vstream->total_index_received = stream->total_index_received; + vstream->tracefile_count_last = stream->tracefile_count_current; + vstream->close_write_flag = 1; + pthread_mutex_unlock(&stream->viewer_stream_rotation_lock); } /* Cleanup index of that stream. */ @@ -861,6 +875,11 @@ static void destroy_stream(struct relay_stream *stream) iter.iter.node = &stream->ctf_trace_node.node; delret = lttng_ht_del(stream->ctf_traces_ht, &iter); assert(!delret); + + if (stream->ctf_trace) { + ctf_trace_try_destroy(stream->ctf_trace); + } + call_rcu(&stream->rcu_node, deferred_free_stream); DBG("Closed tracefile %d from close stream", stream->fd); } @@ -992,6 +1011,61 @@ error: return ret; } +/* + * When we have received all the streams and the metadata for a channel, + * we make them visible to the viewer threads. + */ +static +void set_viewer_ready_flag(struct relay_command *cmd) +{ + struct relay_stream_recv_handle *node, *tmp_node; + + cds_list_for_each_entry_safe(node, tmp_node, &cmd->recv_head, node) { + struct relay_stream *stream; + + rcu_read_lock(); + stream = relay_stream_find_by_id(node->id); + if (!stream) { + /* + * Stream is most probably being cleaned up by the data thread thus + * simply continue to the next one. + */ + rcu_read_unlock(); + continue; + } + + stream->viewer_ready = 1; + rcu_read_unlock(); + + /* Clean stream handle node. */ + cds_list_del(&node->node); + free(node); + } + + return; +} + +/* + * Add a recv handle node to the connection recv list with the given stream + * handle. A new node is allocated thus must be freed when the node is deleted + * from the list. + */ +static void queue_stream_handle(uint64_t handle, struct relay_command *cmd) +{ + struct relay_stream_recv_handle *node; + + assert(cmd); + + node = zmalloc(sizeof(*node)); + if (!node) { + PERROR("zmalloc queue stream handle"); + return; + } + + node->id = handle; + cds_list_add(&node->node, &cmd->recv_head); +} + /* * relay_add_stream: allocate a new stream for a session */ @@ -1084,6 +1158,17 @@ int relay_add_stream(struct lttcomm_relayd_hdr *recv_hdr, ctf_trace_assign(cmd->ctf_traces_ht, stream); stream->ctf_traces_ht = cmd->ctf_traces_ht; + /* + * Add the stream handle in the recv list of the connection. Once the end + * stream message is received, this list is emptied and streams are set + * with the viewer ready flag. + */ + if (stream->metadata_flag) { + stream->viewer_ready = 1; + } else { + queue_stream_handle(stream->stream_handle, cmd); + } + lttng_ht_node_init_ulong(&stream->stream_n, (unsigned long) stream->stream_handle); lttng_ht_add_unique_ulong(relay_streams_ht, @@ -1832,6 +1917,48 @@ end_no_session: return ret; } +/* + * Receive the streams_sent message. + * + * Return 0 on success else a negative value. + */ +static +int relay_streams_sent(struct lttcomm_relayd_hdr *recv_hdr, + struct relay_command *cmd) +{ + int ret, send_ret; + struct lttcomm_relayd_generic_reply reply; + + assert(cmd); + + DBG("Relay receiving streams_sent"); + + if (!cmd->session || cmd->version_check_done == 0) { + ERR("Trying to close a stream before version check"); + ret = -1; + goto end_no_session; + } + + /* + * Flag every pending stream in the connection recv list that they are + * ready to be used by the viewer. + */ + set_viewer_ready_flag(cmd); + + reply.ret_code = htobe32(LTTNG_OK); + send_ret = cmd->sock->ops->sendmsg(cmd->sock, &reply, sizeof(reply), 0); + if (send_ret < 0) { + ERR("Relay sending sent_stream reply"); + ret = send_ret; + } else { + /* Success. */ + ret = 0; + } + +end_no_session: + return ret; +} + /* * Process the commands received on the control socket */ @@ -1875,6 +2002,9 @@ int relay_process_control(struct lttcomm_relayd_hdr *recv_hdr, case RELAYD_SEND_INDEX: ret = relay_recv_index(recv_hdr, cmd); break; + case RELAYD_STREAMS_SENT: + ret = relay_streams_sent(recv_hdr, cmd); + break; case RELAYD_UPDATE_SYNC_INFO: default: ERR("Received unknown command (%u)", be32toh(recv_hdr->cmd)); @@ -2065,18 +2195,9 @@ int relay_process_data(struct relay_command *cmd) * currently using and let it handle the fault. */ if (vstream->tracefile_count_current == new_id) { + pthread_mutex_lock(&vstream->overwrite_lock); vstream->abort_flag = 1; - vstream->close_write_flag = 1; - - ret = close(vstream->read_fd); - if (ret < 0) { - PERROR("close index"); - } - - ret = close(vstream->index_read_fd); - if (ret < 0) { - PERROR("close tracefile"); - } + pthread_mutex_unlock(&vstream->overwrite_lock); DBG("Streaming side setting abort_flag on stream %s_%lu\n", stream->channel_name, new_id); } else if (vstream->tracefile_count_current == @@ -2094,6 +2215,7 @@ int relay_process_data(struct relay_command *cmd) stream->tracefile_size, stream->tracefile_count, relayd_uid, relayd_gid, stream->fd, &(stream->tracefile_count_current), &stream->fd); + stream->total_index_received = 0; pthread_mutex_unlock(&stream->viewer_stream_rotation_lock); if (ret < 0) { ERR("Rotating stream output file"); @@ -2175,6 +2297,7 @@ int relay_add_connection(int fd, struct lttng_poll_event *events, PERROR("read relay cmd pipe"); goto error_read; } + CDS_INIT_LIST_HEAD(&relay_connection->recv_head); /* * Only used by the control side and the reference is copied inside each @@ -2226,8 +2349,17 @@ void relay_del_connection(struct lttng_ht *relay_connections_ht, assert(!ret); if (relay_connection->type == RELAY_CONTROL) { + struct relay_stream_recv_handle *node, *tmp_node; + relay_delete_session(relay_connection, sessions_ht); lttng_ht_destroy(relay_connection->ctf_traces_ht); + + /* Clean up recv list. */ + cds_list_for_each_entry_safe(node, tmp_node, + &relay_connection->recv_head, node) { + cds_list_del(&node->node); + free(node); + } } call_rcu(&relay_connection->rcu_node, deferred_free_connection); @@ -2593,7 +2725,8 @@ int main(int argc, char **argv) /* Check if daemon is UID = 0 */ if (relayd_uid == 0) { - if (control_uri->port < 1024 || data_uri->port < 1024) { + if (control_uri->port < 1024 || data_uri->port < 1024 || + live_uri->port < 1024) { ERR("Need to be root to use ports < 1024"); ret = -1; goto exit;