X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-relayd%2Fmain.c;h=dffcaff9855a61b265bba6b3eb376a990188a76e;hb=7d2f74525fbda4dcc744f33ea26c911545b5df13;hp=43e6f318aef9eec57daecb9a6106f4b314c9296b;hpb=d3e2ba59faddb31870e2ce29b6a881f7ad5ad883;p=lttng-tools.git diff --git a/src/bin/lttng-relayd/main.c b/src/bin/lttng-relayd/main.c index 43e6f318a..dffcaff98 100644 --- a/src/bin/lttng-relayd/main.c +++ b/src/bin/lttng-relayd/main.c @@ -101,9 +101,6 @@ static struct relay_cmd_queue relay_cmd_queue; static char *data_buffer; static unsigned int data_buffer_size; -/* Global hash table that stores relay index object. */ -static struct lttng_ht *indexes_ht; - /* We need those values for the file/dir creation. */ static uid_t relayd_uid; static gid_t relayd_gid; @@ -111,6 +108,12 @@ static gid_t relayd_gid; /* Global relay stream hash table. */ struct lttng_ht *relay_streams_ht; +/* Global relay viewer stream hash table. */ +struct lttng_ht *viewer_streams_ht; + +/* Global hash table that stores relay index object. */ +struct lttng_ht *indexes_ht; + /* * usage function on stderr */ @@ -761,6 +764,57 @@ void deferred_free_session(struct rcu_head *head) free(session); } +/* + * Close a given stream. The stream is freed using a call RCU. + * + * RCU read side lock MUST be acquired. If NO close_stream_check() was called + * BEFORE the stream lock MUST be acquired. + */ +static void destroy_stream(struct relay_stream *stream, + struct lttng_ht *ctf_traces_ht) +{ + int delret; + struct relay_viewer_stream *vstream; + struct lttng_ht_iter iter; + + assert(stream); + + delret = close(stream->fd); + if (delret < 0) { + PERROR("close stream"); + } + + if (stream->index_fd >= 0) { + delret = close(stream->index_fd); + if (delret < 0) { + PERROR("close stream index_fd"); + } + } + + vstream = live_find_viewer_stream_by_id(stream->stream_handle); + if (vstream) { + /* + * Set the last good value into the viewer stream. This is done + * right before the stream gets deleted from the hash table. The + * lookup failure on the live thread side of a stream indicates + * that the viewer stream index received value should be used. + */ + vstream->total_index_received = stream->total_index_received; + } + + /* Cleanup index of that stream. */ + relay_index_destroy_by_stream_id(stream->stream_handle); + + iter.iter.node = &stream->stream_n.node; + delret = lttng_ht_del(relay_streams_ht, &iter); + assert(!delret); + iter.iter.node = &stream->ctf_trace_node.node; + delret = lttng_ht_del(ctf_traces_ht, &iter); + assert(!delret); + call_rcu(&stream->rcu_node, deferred_free_stream); + DBG("Closed tracefile %d from close stream", stream->fd); +} + /* * relay_delete_session: Free all memory associated with a session and * close all the FDs @@ -783,29 +837,20 @@ void relay_delete_session(struct relay_command *cmd, rcu_read_lock(); cds_lfht_for_each_entry(relay_streams_ht->ht, &iter.iter, node, node) { node = lttng_ht_iter_get_node_ulong(&iter); - if (node) { - stream = caa_container_of(node, - struct relay_stream, stream_n); - if (stream->session == cmd->session) { - ret = close(stream->fd); - if (ret < 0) { - PERROR("close stream fd on delete session"); - } - ret = lttng_ht_del(relay_streams_ht, &iter); - assert(!ret); - call_rcu(&stream->rcu_node, - deferred_free_stream); - } - /* Cleanup index of that stream. */ - relay_index_destroy_by_stream_id(stream->stream_handle, - indexes_ht); + if (!node) { + continue; + } + stream = caa_container_of(node, struct relay_stream, stream_n); + if (stream->session == cmd->session) { + destroy_stream(stream, cmd->ctf_traces_ht); } } + + /* Make this session not visible anymore. */ iter.iter.node = &cmd->session->session_n.node; ret = lttng_ht_del(sessions_ht, &iter); assert(!ret); - call_rcu(&cmd->session->rcu_node, - deferred_free_session); + call_rcu(&cmd->session->rcu_node, deferred_free_session); rcu_read_unlock(); } @@ -859,6 +904,8 @@ int relay_create_session(struct lttcomm_relayd_hdr *recv_hdr, session->id = ++last_relay_session_id; session->sock = cmd->sock; + session->minor = cmd->minor; + session->major = cmd->major; cmd->session = session; reply.session_id = htobe64(session->id); @@ -1029,14 +1076,13 @@ err_free_stream: */ static int relay_close_stream(struct lttcomm_relayd_hdr *recv_hdr, - struct relay_command *cmd, struct lttng_ht *viewer_streams_ht) + struct relay_command *cmd) { + int ret, send_ret; struct relay_session *session = cmd->session; struct lttcomm_relayd_close_stream stream_info; struct lttcomm_relayd_generic_reply reply; struct relay_stream *stream; - int ret, send_ret; - struct lttng_ht_iter iter; DBG("Close stream received"); @@ -1070,42 +1116,7 @@ int relay_close_stream(struct lttcomm_relayd_hdr *recv_hdr, stream->close_flag = 1; if (close_stream_check(stream)) { - int delret; - struct relay_viewer_stream *vstream; - - delret = close(stream->fd); - if (delret < 0) { - PERROR("close stream"); - } - - if (stream->index_fd >= 0) { - delret = close(stream->index_fd); - if (delret < 0) { - PERROR("close stream index_fd"); - } - } - - vstream = live_find_viewer_stream_by_id(stream->stream_handle, - viewer_streams_ht); - if (vstream) { - /* - * Set the last good value into the viewer stream. This is done - * right before the stream gets deleted from the hash table. The - * lookup failure on the live thread side of a stream indicates - * that the viewer stream index received value should be used. - */ - vstream->total_index_received = stream->total_index_received; - } - - iter.iter.node = &stream->stream_n.node; - delret = lttng_ht_del(relay_streams_ht, &iter); - assert(!delret); - iter.iter.node = &stream->ctf_trace_node.node; - delret = lttng_ht_del(cmd->ctf_traces_ht, &iter); - assert(!delret); - call_rcu(&stream->rcu_node, - deferred_free_stream); - DBG("Closed tracefile %d from close stream", stream->fd); + destroy_stream(stream, cmd->ctf_traces_ht); } end_unlock: @@ -1644,7 +1655,7 @@ end_no_session: */ static int relay_recv_index(struct lttcomm_relayd_hdr *recv_hdr, - struct relay_command *cmd, struct lttng_ht *indexes_ht) + struct relay_command *cmd) { int ret, send_ret, index_created = 0; struct relay_session *session = cmd->session; @@ -1655,7 +1666,6 @@ int relay_recv_index(struct lttcomm_relayd_hdr *recv_hdr, uint64_t net_seq_num; assert(cmd); - assert(indexes_ht); DBG("Relay receiving index"); @@ -1703,7 +1713,7 @@ int relay_recv_index(struct lttcomm_relayd_hdr *recv_hdr, stream->beacon_ts_end = -1ULL; } - index = relay_index_find(stream->stream_handle, net_seq_num, indexes_ht); + index = relay_index_find(stream->stream_handle, net_seq_num); if (!index) { /* A successful creation will add the object to the HT. */ index = relay_index_create(stream->stream_handle, net_seq_num); @@ -1721,7 +1731,7 @@ int relay_recv_index(struct lttcomm_relayd_hdr *recv_hdr, * already exist, destroy back the index created, set the data in this * object and write it on disk. */ - relay_index_add(index, indexes_ht, &wr_index); + relay_index_add(index, &wr_index); if (wr_index) { copy_index_control_data(wr_index, &index_info); free(index); @@ -1744,7 +1754,7 @@ int relay_recv_index(struct lttcomm_relayd_hdr *recv_hdr, stream->index_fd = ret; } - ret = relay_index_write(wr_index->fd, wr_index, indexes_ht); + ret = relay_index_write(wr_index->fd, wr_index); if (ret < 0) { goto end_rcu_unlock; } @@ -1795,7 +1805,7 @@ int relay_process_control(struct lttcomm_relayd_hdr *recv_hdr, ret = relay_send_version(recv_hdr, cmd, ctx->sessions_ht); break; case RELAYD_CLOSE_STREAM: - ret = relay_close_stream(recv_hdr, cmd, ctx->viewer_streams_ht); + ret = relay_close_stream(recv_hdr, cmd); break; case RELAYD_DATA_PENDING: ret = relay_data_pending(recv_hdr, cmd); @@ -1810,7 +1820,7 @@ int relay_process_control(struct lttcomm_relayd_hdr *recv_hdr, ret = relay_end_data_pending(recv_hdr, cmd); break; case RELAYD_SEND_INDEX: - ret = relay_recv_index(recv_hdr, cmd, indexes_ht); + ret = relay_recv_index(recv_hdr, cmd); break; case RELAYD_UPDATE_SYNC_INFO: default: @@ -1824,18 +1834,98 @@ end: return ret; } +/* + * Handle index for a data stream. + * + * RCU read side lock MUST be acquired. + * + * Return 0 on success else a negative value. + */ +static int handle_index_data(struct relay_stream *stream, uint64_t net_seq_num, + int rotate_index) +{ + int ret = 0, index_created = 0; + uint64_t stream_id, data_offset; + struct relay_index *index, *wr_index = NULL; + + assert(stream); + + stream_id = stream->stream_handle; + /* Get data offset because we are about to update the index. */ + data_offset = htobe64(stream->tracefile_size_current); + + /* + * Lookup for an existing index for that stream id/sequence number. If on + * exists, the control thread already received the data for it thus we need + * to write it on disk. + */ + index = relay_index_find(stream_id, net_seq_num); + if (!index) { + /* A successful creation will add the object to the HT. */ + index = relay_index_create(stream_id, net_seq_num); + if (!index) { + ret = -1; + goto error; + } + index_created = 1; + } + + if (rotate_index || stream->index_fd < 0) { + index->to_close_fd = stream->index_fd; + ret = index_create_file(stream->path_name, stream->channel_name, + relayd_uid, relayd_gid, stream->tracefile_size, + stream->tracefile_count_current); + if (ret < 0) { + /* This will close the stream's index fd if one. */ + relay_index_free_safe(index); + goto error; + } + stream->index_fd = ret; + } + index->fd = stream->index_fd; + index->index_data.offset = data_offset; + + if (index_created) { + /* + * Try to add the relay index object to the hash table. If an object + * already exist, destroy back the index created and set the data. + */ + relay_index_add(index, &wr_index); + if (wr_index) { + /* Copy back data from the created index. */ + wr_index->fd = index->fd; + wr_index->to_close_fd = index->to_close_fd; + wr_index->index_data.offset = data_offset; + free(index); + } + } else { + /* The index already exists so write it on disk. */ + wr_index = index; + } + + /* Do we have a writable ready index to write on disk. */ + if (wr_index) { + ret = relay_index_write(wr_index->fd, wr_index); + if (ret < 0) { + goto error; + } + stream->total_index_received++; + } + +error: + return ret; +} + /* * relay_process_data: Process the data received on the data socket */ static -int relay_process_data(struct relay_command *cmd, - struct lttng_ht *indexes_ht) +int relay_process_data(struct relay_command *cmd) { - int ret = 0, rotate_index = 0, index_created = 0; + int ret = 0, rotate_index = 0; struct relay_stream *stream; - struct relay_index *index, *wr_index = NULL; struct lttcomm_relayd_data_hdr data_hdr; - uint64_t stream_id, data_offset; + uint64_t stream_id; uint64_t net_seq_num; uint32_t data_size; @@ -1908,77 +1998,18 @@ int relay_process_data(struct relay_command *cmd, rotate_index = 1; } - /* Get data offset because we are about to update the index. */ - data_offset = htobe64(stream->tracefile_size_current); - /* - * Lookup for an existing index for that stream id/sequence number. If on - * exists, the control thread already received the data for it thus we need - * to write it on disk. + * Index are handled in protocol version 2.4 and above. Also, snapshot and + * index are NOT supported. */ - index = relay_index_find(stream_id, net_seq_num, indexes_ht); - if (!index) { - /* A successful creation will add the object to the HT. */ - index = relay_index_create(stream->stream_handle, net_seq_num); - if (!index) { - goto end_rcu_unlock; - } - index_created = 1; - } - - if (rotate_index || stream->index_fd < 0) { - index->to_close_fd = stream->index_fd; - ret = index_create_file(stream->path_name, stream->channel_name, - relayd_uid, relayd_gid, stream->tracefile_size, - stream->tracefile_count_current); + if (stream->session->minor >= 4 && !stream->session->snapshot) { + ret = handle_index_data(stream, net_seq_num, rotate_index); if (ret < 0) { - /* This will close the stream's index fd if one. */ - relay_index_free_safe(index); goto end_rcu_unlock; } - stream->index_fd = ret; - } - index->fd = stream->index_fd; - index->index_data.offset = data_offset; - - if (index_created) { - /* - * Try to add the relay index object to the hash table. If an object - * already exist, destroy back the index created and set the data. - */ - relay_index_add(index, indexes_ht, &wr_index); - if (wr_index) { - /* Copy back data from the created index. */ - wr_index->fd = index->fd; - wr_index->to_close_fd = index->to_close_fd; - wr_index->index_data.offset = data_offset; - free(index); - } - } else { - /* The index already exists so write it on disk. */ - wr_index = index; - } - - /* Do we have a writable ready index to write on disk. */ - if (wr_index) { - /* Starting at 2.4, create the index file if none available. */ - if (cmd->minor >= 4 && stream->index_fd < 0) { - ret = index_create_file(stream->path_name, stream->channel_name, - relayd_uid, relayd_gid, stream->tracefile_size, - stream->tracefile_count_current); - if (ret < 0) { - goto end_rcu_unlock; - } - stream->index_fd = ret; - } - - ret = relay_index_write(wr_index->fd, wr_index, indexes_ht); - if (ret < 0) { - goto end_rcu_unlock; - } - stream->total_index_received++; } + /* Write data to stream output fd. */ do { ret = write(stream->fd, data_buffer, data_size); } while (ret < 0 && errno == EINTR); @@ -2001,24 +2032,7 @@ int relay_process_data(struct relay_command *cmd, /* Check if we need to close the FD */ if (close_stream_check(stream)) { - int cret; - struct lttng_ht_iter iter; - - cret = close(stream->fd); - if (cret < 0) { - PERROR("close stream process data"); - } - - cret = close(stream->index_fd); - if (cret < 0) { - PERROR("close stream index_fd"); - } - iter.iter.node = &stream->stream_n.node; - ret = lttng_ht_del(relay_streams_ht, &iter); - assert(!ret); - call_rcu(&stream->rcu_node, - deferred_free_stream); - DBG("Closed tracefile %d after recv data", stream->fd); + destroy_stream(stream, cmd->ctf_traces_ht); } end_rcu_unlock: @@ -2320,7 +2334,7 @@ restart: continue; } - ret = relay_process_data(relay_connection, indexes_ht); + ret = relay_process_data(relay_connection); /* connection closed */ if (ret < 0) { relay_cleanup_poll_connection(&events, pollfd); @@ -2484,8 +2498,8 @@ int main(int argc, char **argv) } /* tables of streams indexed by stream ID */ - relay_ctx->viewer_streams_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); - if (!relay_ctx->viewer_streams_ht) { + viewer_streams_ht = lttng_ht_new(0, LTTNG_HT_TYPE_U64); + if (!viewer_streams_ht) { goto exit_relay_ctx_viewer_streams; } @@ -2538,7 +2552,7 @@ exit_dispatcher: PERROR("pthread_join"); goto error; /* join error, exit without cleanup */ } - lttng_ht_destroy(relay_ctx->viewer_streams_ht); + lttng_ht_destroy(viewer_streams_ht); exit_relay_ctx_viewer_streams: lttng_ht_destroy(relay_streams_ht);