static
int notify_thread_pipe(int wpipe)
{
- int ret;
+ ssize_t ret;
- do {
- ret = write(wpipe, "!", 1);
- } while (ret < 0 && errno == EINTR);
- if (ret < 0 || ret != 1) {
+ ret = lttng_write(wpipe, "!", 1);
+ if (ret < 1) {
PERROR("write poll pipe");
}
- return ret;
+ return (int) ret;
}
/*
static
void *thread_dispatcher(void *data)
{
- int ret, err = -1;
+ int err = -1;
+ ssize_t ret;
struct cds_wfq_node *node;
struct relay_command *relay_cmd = NULL;
* so we can be assured that the data will be read at some point in
* time or wait to the end of the world :)
*/
- do {
- ret = write(live_relay_cmd_pipe[1], relay_cmd,
- sizeof(*relay_cmd));
- } while (ret < 0 && errno == EINTR);
+ ret = lttng_write(live_relay_cmd_pipe[1], relay_cmd,
+ sizeof(*relay_cmd));
free(relay_cmd);
- if (ret < 0 || ret != sizeof(struct relay_command)) {
+ if (ret < sizeof(struct relay_command)) {
PERROR("write cmd pipe");
goto error;
}
if (reply.major != be32toh(msg.major)) {
DBG("Incompatible major versions (%u vs %u)", reply.major,
be32toh(msg.major));
- ret = 0;
+ ret = -1;
goto end;
}
return ret;
}
+/*
+ * Open index file using a given viewer stream.
+ *
+ * Return 0 on success or else a negative value.
+ */
+static int open_index(struct relay_viewer_stream *stream)
+{
+ int ret;
+ char fullpath[PATH_MAX];
+ struct ctf_packet_index_file_hdr hdr;
+
+ if (stream->tracefile_count > 0) {
+ ret = snprintf(fullpath, sizeof(fullpath), "%s/" DEFAULT_INDEX_DIR "/%s_%"
+ PRIu64 DEFAULT_INDEX_FILE_SUFFIX, stream->path_name,
+ stream->channel_name, stream->tracefile_count_current);
+ } else {
+ ret = snprintf(fullpath, sizeof(fullpath), "%s/" DEFAULT_INDEX_DIR "/%s"
+ DEFAULT_INDEX_FILE_SUFFIX, stream->path_name,
+ stream->channel_name);
+ }
+ if (ret < 0) {
+ PERROR("snprintf index path");
+ goto error;
+ }
+
+ DBG("Opening index file %s in read only", fullpath);
+ ret = open(fullpath, O_RDONLY);
+ if (ret < 0) {
+ if (errno == ENOENT) {
+ ret = -ENOENT;
+ goto error;
+ } else {
+ PERROR("opening index in read-only");
+ }
+ goto error;
+ }
+ stream->index_read_fd = ret;
+ DBG("Opening index file %s in read only, (fd: %d)", fullpath, ret);
+
+ ret = lttng_read(stream->index_read_fd, &hdr, sizeof(hdr));
+ if (ret < sizeof(hdr)) {
+ PERROR("Reading index header");
+ goto error;
+ }
+ if (be32toh(hdr.magic) != CTF_INDEX_MAGIC) {
+ ERR("Invalid header magic");
+ ret = -1;
+ goto error;
+ }
+ if (be32toh(hdr.index_major) != CTF_INDEX_MAJOR ||
+ be32toh(hdr.index_minor) != CTF_INDEX_MINOR) {
+ ERR("Invalid header version");
+ ret = -1;
+ goto error;
+ }
+ ret = 0;
+
+error:
+ return ret;
+}
+
/*
* Allocate and init a new viewer_stream.
*
* Returns 0 on success or a negative value on error.
*/
static
-int init_viewer_stream(struct relay_stream *stream)
+int init_viewer_stream(struct relay_stream *stream, int seek_last)
{
int ret;
struct relay_viewer_stream *viewer_stream;
ret = -1;
goto error;
}
-
- viewer_stream->read_fd = -1;
- viewer_stream->index_read_fd = -1;
viewer_stream->session_id = stream->session->id;
viewer_stream->stream_handle = stream->stream_handle;
viewer_stream->path_name = strndup(stream->path_name,
LTTNG_VIEWER_PATH_MAX);
viewer_stream->channel_name = strndup(stream->channel_name,
LTTNG_VIEWER_NAME_MAX);
- viewer_stream->total_index_received = stream->total_index_received;
- viewer_stream->tracefile_size = stream->tracefile_size;
viewer_stream->tracefile_count = stream->tracefile_count;
viewer_stream->metadata_flag = stream->metadata_flag;
+ viewer_stream->tracefile_count_last = -1ULL;
+ if (seek_last) {
+ viewer_stream->tracefile_count_current =
+ stream->tracefile_count_current;
+ } else {
+ viewer_stream->tracefile_count_current =
+ stream->oldest_tracefile_id;
+ }
+
+ viewer_stream->ctf_trace = stream->ctf_trace;
+ if (viewer_stream->metadata_flag) {
+ viewer_stream->ctf_trace->viewer_metadata_stream =
+ viewer_stream;
+ }
+ uatomic_inc(&viewer_stream->ctf_trace->refcount);
+
+ lttng_ht_node_init_u64(&viewer_stream->stream_n, stream->stream_handle);
+ lttng_ht_add_unique_u64(viewer_streams_ht, &viewer_stream->stream_n);
+
+ viewer_stream->index_read_fd = -1;
+ viewer_stream->read_fd = -1;
/*
* This is to avoid a race between the initialization of this object and
* the close of the given stream. If the stream is unable to find this
* viewer stream when closing, this copy will at least take the latest
* value.
+ * We also need that for the seek_last.
*/
viewer_stream->total_index_received = stream->total_index_received;
/*
- * The deletion of this ctf_trace object is only done in a call RCU of the
- * relay stream making it valid as long as we have the read side lock.
+ * If we never received an index for the current stream, delay
+ * the opening of the index, otherwise open it right now.
*/
- viewer_stream->ctf_trace = stream->ctf_trace;
- uatomic_inc(&viewer_stream->ctf_trace->refcount);
+ if (viewer_stream->tracefile_count_current ==
+ stream->tracefile_count_current &&
+ viewer_stream->total_index_received == 0) {
+ viewer_stream->index_read_fd = -1;
+ } else {
+ ret = open_index(viewer_stream);
+ if (ret < 0) {
+ goto error;
+ }
+ }
- lttng_ht_node_init_u64(&viewer_stream->stream_n, stream->stream_handle);
- lttng_ht_add_unique_u64(viewer_streams_ht, &viewer_stream->stream_n);
+ if (seek_last && viewer_stream->index_read_fd > 0) {
+ ret = lseek(viewer_stream->index_read_fd,
+ viewer_stream->total_index_received *
+ sizeof(struct ctf_packet_index),
+ SEEK_CUR);
+ if (ret < 0) {
+ goto error;
+ }
+ viewer_stream->last_sent_index =
+ viewer_stream->total_index_received;
+ }
ret = 0;
return ret;
}
+/*
+ * Rotate a stream to the next tracefile.
+ *
+ * Returns 0 on success, 1 on EOF, a negative value on error.
+ */
+static
+int rotate_viewer_stream(struct relay_viewer_stream *viewer_stream,
+ struct relay_stream *stream)
+{
+ int ret;
+ uint64_t tracefile_id;
+
+ assert(viewer_stream);
+
+ tracefile_id = (viewer_stream->tracefile_count_current + 1) %
+ viewer_stream->tracefile_count;
+ /*
+ * Detect the last tracefile to open.
+ */
+ if (viewer_stream->tracefile_count_last != -1ULL &&
+ viewer_stream->tracefile_count_last ==
+ viewer_stream->tracefile_count_current) {
+ ret = 1;
+ goto end;
+ }
+
+ if (stream) {
+ pthread_mutex_lock(&stream->viewer_stream_rotation_lock);
+ }
+ /*
+ * The writer and the reader are not working in the same
+ * tracefile, we can read up to EOF, we don't care about the
+ * total_index_received.
+ */
+ if (!stream || (stream->tracefile_count_current != tracefile_id)) {
+ viewer_stream->close_write_flag = 1;
+ } else {
+ /*
+ * We are opening a file that is still open in write, make
+ * sure we limit our reading to the number of indexes
+ * received.
+ */
+ viewer_stream->close_write_flag = 0;
+ if (stream) {
+ viewer_stream->total_index_received =
+ stream->total_index_received;
+ }
+ }
+ viewer_stream->tracefile_count_current = tracefile_id;
+
+ ret = close(viewer_stream->index_read_fd);
+ if (ret < 0) {
+ PERROR("close index file %d",
+ viewer_stream->index_read_fd);
+ }
+ viewer_stream->index_read_fd = -1;
+ ret = close(viewer_stream->read_fd);
+ if (ret < 0) {
+ PERROR("close tracefile %d",
+ viewer_stream->read_fd);
+ }
+ viewer_stream->read_fd = -1;
+
+ pthread_mutex_lock(&viewer_stream->overwrite_lock);
+ viewer_stream->abort_flag = 0;
+ pthread_mutex_unlock(&viewer_stream->overwrite_lock);
+
+ viewer_stream->index_read_fd = -1;
+ viewer_stream->read_fd = -1;
+
+ if (stream) {
+ pthread_mutex_unlock(&stream->viewer_stream_rotation_lock);
+ }
+ ret = open_index(viewer_stream);
+ if (ret < 0) {
+ goto error;
+ }
+
+ ret = 0;
+
+end:
+error:
+ return ret;
+}
+
/*
* Send the viewer the list of current sessions.
*/
int viewer_attach_session(struct relay_command *cmd,
struct lttng_ht *sessions_ht)
{
- int ret, send_streams = 0, nb_streams = 0;
+ int ret, send_streams = 0;
+ uint32_t nb_streams = 0, nb_streams_ready = 0;
struct lttng_viewer_attach_session_request request;
struct lttng_viewer_attach_session_response response;
struct lttng_viewer_stream send_stream;
struct lttng_ht_node_u64 *node64;
struct lttng_ht_iter iter;
struct relay_session *session;
+ int seek_last = 0;
assert(cmd);
assert(sessions_ht);
/* Default behaviour. */
break;
case VIEWER_SEEK_LAST:
- /* TODO */
+ seek_last = 1;
break;
default:
ERR("Wrong seek parameter");
if (stream->session != cmd->session) {
continue;
}
+ nb_streams++;
/*
- * Don't send streams with no ctf_trace, they are not ready to be
- * read.
+ * Don't send streams with no ctf_trace, they are not
+ * ready to be read.
*/
- if (!stream->ctf_trace) {
+ if (!stream->ctf_trace || !stream->viewer_ready) {
continue;
}
+ nb_streams_ready++;
vstream = live_find_viewer_stream_by_id(stream->stream_handle);
if (!vstream) {
- ret = init_viewer_stream(stream);
+ ret = init_viewer_stream(stream, seek_last);
if (ret < 0) {
goto end_unlock;
}
}
- nb_streams++;
+ }
+
+ /* We must have the same amount of existing stream and ready stream. */
+ if (nb_streams != nb_streams_ready) {
+ nb_streams = 0;
}
response.streams_count = htobe32(nb_streams);
}
health_code_update();
/*
- * Unknown or busy session, just return gracefully, the viewer knows what
+ * Unknown or empty session, just return gracefully, the viewer knows what
* is happening.
*/
- if (!send_streams) {
+ if (!send_streams || !nb_streams) {
ret = 0;
goto end_unlock;
}
return ret;
}
-/*
- * Open index file using a given viewer stream.
- *
- * Return 0 on success or else a negative value.
- */
-static int open_index(struct relay_viewer_stream *stream)
-{
- int ret;
- char fullpath[PATH_MAX];
- struct lttng_packet_index_file_hdr hdr;
-
- if (stream->tracefile_size > 0) {
- /* For now we don't support on-disk ring buffer. */
- ret = -1;
- goto end;
- } else {
- ret = snprintf(fullpath, sizeof(fullpath), "%s/" DEFAULT_INDEX_DIR
- "/%s" DEFAULT_INDEX_FILE_SUFFIX,
- stream->path_name, stream->channel_name);
- if (ret < 0) {
- PERROR("snprintf index path");
- goto error;
- }
- }
-
- DBG("Opening index file %s in read only", fullpath);
- ret = open(fullpath, O_RDONLY);
- if (ret < 0) {
- if (errno == ENOENT) {
- ret = ENOENT;
- goto error;
- } else {
- PERROR("opening index in read-only");
- }
- goto error;
- }
- stream->index_read_fd = ret;
- DBG("Opening index file %s in read only, (fd: %d)", fullpath, ret);
-
- do {
- health_code_update();
- ret = read(stream->index_read_fd, &hdr, sizeof(hdr));
- } while (ret < 0 && errno == EINTR);
- if (ret < 0) {
- PERROR("Reading index header");
- goto error;
- }
- if (strncmp(hdr.magic, INDEX_MAGIC, sizeof(hdr.magic)) != 0) {
- ERR("Invalid header magic");
- ret = -1;
- goto error;
- }
- if (be32toh(hdr.index_major) != INDEX_MAJOR ||
- be32toh(hdr.index_minor) != INDEX_MINOR) {
- ERR("Invalid header version");
- ret = -1;
- goto error;
- }
- ret = 0;
-
-error:
-end:
- return ret;
-}
-
/*
* Get viewer stream from stream id.
*
return stream;
}
+static
+void deferred_free_viewer_stream(struct rcu_head *head)
+{
+ struct relay_viewer_stream *stream =
+ caa_container_of(head, struct relay_viewer_stream, rcu_node);
+
+ free(stream->path_name);
+ free(stream->channel_name);
+ free(stream);
+}
+
+static
+void delete_viewer_stream(struct relay_viewer_stream *vstream)
+{
+ int delret;
+ struct lttng_ht_iter iter;
+
+ iter.iter.node = &vstream->stream_n.node;
+ delret = lttng_ht_del(viewer_streams_ht, &iter);
+ assert(!delret);
+}
+
+static
+void destroy_viewer_stream(struct relay_viewer_stream *vstream)
+{
+ unsigned long ret_ref;
+ int ret;
+
+ assert(vstream);
+ ret_ref = uatomic_add_return(&vstream->ctf_trace->refcount, -1);
+ assert(ret_ref >= 0);
+
+ if (vstream->read_fd >= 0) {
+ ret = close(vstream->read_fd);
+ if (ret < 0) {
+ PERROR("close read_fd");
+ }
+ }
+ if (vstream->index_read_fd >= 0) {
+ ret = close(vstream->index_read_fd);
+ if (ret < 0) {
+ PERROR("close index_read_fd");
+ }
+ }
+
+ /*
+ * If the only stream left in the HT is the metadata stream,
+ * we need to remove it because we won't detect a EOF for this
+ * stream.
+ */
+ if (ret_ref == 1 && vstream->ctf_trace->viewer_metadata_stream) {
+ destroy_viewer_stream(vstream->ctf_trace->viewer_metadata_stream);
+ vstream->ctf_trace->metadata_stream = NULL;
+ DBG("Freeing ctf_trace %" PRIu64, vstream->ctf_trace->id);
+ /*
+ * The streaming-side is already closed and we can't receive a new
+ * stream concurrently at this point (since the session is being
+ * destroyed), so when we detect the refcount equals 0, we are the
+ * only owners of the ctf_trace and we can free it ourself.
+ */
+ free(vstream->ctf_trace);
+ }
+
+ call_rcu(&vstream->rcu_node, deferred_free_viewer_stream);
+}
+
/*
* Send the next index for a stream.
*
int ret;
struct lttng_viewer_get_next_index request_index;
struct lttng_viewer_index viewer_index;
- struct lttng_packet_index packet_index;
+ struct ctf_packet_index packet_index;
struct relay_viewer_stream *vstream;
struct relay_stream *rstream;
/* First time, we open the index file */
if (vstream->index_read_fd < 0) {
ret = open_index(vstream);
- if (ret == ENOENT) {
+ if (ret == -ENOENT) {
/*
* The index is created only when the first data packet arrives, it
* might not be ready at the beginning of the session
rstream = relay_stream_find_by_id(vstream->stream_handle);
if (rstream) {
- if (rstream->beacon_ts_end != -1ULL &&
- vstream->last_sent_index == rstream->total_index_received) {
- viewer_index.status = htobe32(VIEWER_INDEX_INACTIVE);
- viewer_index.timestamp_end = htobe64(rstream->beacon_ts_end);
- goto send_reply;
+ if (vstream->abort_flag) {
+ /* Rotate on abort (overwrite). */
+ DBG("Viewer rotate because of overwrite");
+ ret = rotate_viewer_stream(vstream, rstream);
+ if (ret < 0) {
+ goto end_unlock;
+ } else if (ret == 1) {
+ viewer_index.status = htobe32(VIEWER_INDEX_HUP);
+ delete_viewer_stream(vstream);
+ destroy_viewer_stream(vstream);
+ goto send_reply;
+ }
}
-
- if (rstream->total_index_received <= vstream->last_sent_index) {
- /* No new index to send, retry later. */
- viewer_index.status = htobe32(VIEWER_INDEX_RETRY);
- goto send_reply;
+ pthread_mutex_lock(&rstream->viewer_stream_rotation_lock);
+ if (rstream->tracefile_count_current == vstream->tracefile_count_current) {
+ if (rstream->beacon_ts_end != -1ULL &&
+ vstream->last_sent_index == rstream->total_index_received) {
+ viewer_index.status = htobe32(VIEWER_INDEX_INACTIVE);
+ viewer_index.timestamp_end = htobe64(rstream->beacon_ts_end);
+ pthread_mutex_unlock(&rstream->viewer_stream_rotation_lock);
+ goto send_reply;
+ /*
+ * Reader and writer are working in the same tracefile, so we care
+ * about the number of index received and sent. Otherwise, we read
+ * up to EOF.
+ */
+ } else if (rstream->total_index_received <= vstream->last_sent_index
+ && !vstream->close_write_flag) {
+ pthread_mutex_unlock(&rstream->viewer_stream_rotation_lock);
+ /* No new index to send, retry later. */
+ viewer_index.status = htobe32(VIEWER_INDEX_RETRY);
+ goto send_reply;
+ }
}
- } else if (!rstream &&
+ pthread_mutex_unlock(&rstream->viewer_stream_rotation_lock);
+ } else if (!rstream && vstream->close_write_flag &&
vstream->total_index_received == vstream->last_sent_index) {
- /* Last index sent and stream closed */
+ /* Last index sent and current tracefile closed in write */
viewer_index.status = htobe32(VIEWER_INDEX_HUP);
+ delete_viewer_stream(vstream);
+ destroy_viewer_stream(vstream);
goto send_reply;
+ } else {
+ vstream->close_write_flag = 1;
}
if (!vstream->ctf_trace->metadata_received ||
viewer_index.flags |= LTTNG_VIEWER_FLAG_NEW_METADATA;
}
- do {
- health_code_update();
- ret = read(vstream->index_read_fd, &packet_index,
- sizeof(packet_index));
- } while (ret < 0 && errno == EINTR);
+ pthread_mutex_lock(&vstream->overwrite_lock);
+ if (vstream->abort_flag) {
+ /*
+ * The file is being overwritten by the writer, we cannot
+ * use it.
+ */
+ viewer_index.status = htobe32(VIEWER_INDEX_RETRY);
+ pthread_mutex_unlock(&vstream->overwrite_lock);
+ ret = rotate_viewer_stream(vstream, rstream);
+ if (ret < 0) {
+ goto end_unlock;
+ } else if (ret == 1) {
+ viewer_index.status = htobe32(VIEWER_INDEX_HUP);
+ delete_viewer_stream(vstream);
+ destroy_viewer_stream(vstream);
+ goto send_reply;
+ }
+ goto send_reply;
+ }
+ ret = lttng_read(vstream->index_read_fd, &packet_index,
+ sizeof(packet_index));
+ pthread_mutex_unlock(&vstream->overwrite_lock);
if (ret < sizeof(packet_index)) {
- PERROR("Relay reading index file");
- viewer_index.status = htobe32(VIEWER_INDEX_ERR);
+ /*
+ * The tracefile is closed in write, so we read up to EOF.
+ */
+ if (vstream->close_write_flag == 1) {
+ viewer_index.status = htobe32(VIEWER_INDEX_RETRY);
+ /* Rotate on normal EOF */
+ ret = rotate_viewer_stream(vstream, rstream);
+ if (ret < 0) {
+ goto end_unlock;
+ } else if (ret == 1) {
+ viewer_index.status = htobe32(VIEWER_INDEX_HUP);
+ delete_viewer_stream(vstream);
+ destroy_viewer_stream(vstream);
+ goto send_reply;
+ }
+ } else {
+ PERROR("Relay reading index file %d",
+ vstream->index_read_fd);
+ viewer_index.status = htobe32(VIEWER_INDEX_ERR);
+ }
+ goto send_reply;
} else {
viewer_index.status = htobe32(VIEWER_INDEX_OK);
vstream->last_sent_index++;
if (stream->read_fd < 0) {
char fullpath[PATH_MAX];
- ret = snprintf(fullpath, PATH_MAX, "%s/%s", stream->path_name,
- stream->channel_name);
+ if (stream->tracefile_count > 0) {
+ ret = snprintf(fullpath, PATH_MAX, "%s/%s_%" PRIu64, stream->path_name,
+ stream->channel_name,
+ stream->tracefile_count_current);
+ } else {
+ ret = snprintf(fullpath, PATH_MAX, "%s/%s", stream->path_name,
+ stream->channel_name);
+ }
if (ret < 0) {
goto error;
}
ret = lseek(stream->read_fd, be64toh(get_packet_info.offset), SEEK_SET);
if (ret < 0) {
- PERROR("lseek");
- goto error;
+ /*
+ * If the read fd was closed by the streaming side, the
+ * abort_flag will be set to 1, otherwise it is an error.
+ */
+ if (stream->abort_flag == 0) {
+ PERROR("lseek");
+ goto error;
+ }
+ reply.status = htobe32(VIEWER_GET_PACKET_EOF);
+ goto send_reply;
}
- read_len = read(stream->read_fd, data, len);
- if (read_len < (ssize_t) len) {
- PERROR("Relay reading trace file, fd: %d, offset: %" PRIu64,
- stream->read_fd, be64toh(get_packet_info.offset));
- goto error;
+ read_len = lttng_read(stream->read_fd, data, len);
+ if (read_len < len) {
+ /*
+ * If the read fd was closed by the streaming side, the
+ * abort_flag will be set to 1, otherwise it is an error.
+ */
+ if (stream->abort_flag == 0) {
+ PERROR("Relay reading trace file, fd: %d, offset: %" PRIu64,
+ stream->read_fd,
+ be64toh(get_packet_info.offset));
+ goto error;
+ } else {
+ reply.status = htobe32(VIEWER_GET_PACKET_EOF);
+ goto send_reply;
+ }
}
reply.status = htobe32(VIEWER_GET_PACKET_OK);
reply.len = htobe32(len);
goto error;
}
- read_len = read(stream->read_fd, data, len);
- if (read_len < (ssize_t) len) {
+ read_len = lttng_read(stream->read_fd, data, len);
+ if (read_len < len) {
PERROR("Relay reading metadata file");
goto error;
}
goto error;
}
- do {
- health_code_update();
- ret = read(fd, relay_connection, sizeof(*relay_connection));
- } while (ret < 0 && errno == EINTR);
- if (ret < 0 || ret < sizeof(*relay_connection)) {
+ ret = lttng_read(fd, relay_connection, sizeof(*relay_connection));
+ if (ret < sizeof(*relay_connection)) {
PERROR("read relay cmd pipe");
goto error_read;
}
free(relay_connection);
}
-static
-void deferred_free_viewer_stream(struct rcu_head *head)
-{
- struct relay_viewer_stream *stream =
- caa_container_of(head, struct relay_viewer_stream, rcu_node);
-
- if (stream->ctf_trace) {
- uatomic_dec(&stream->ctf_trace->refcount);
- assert(uatomic_read(&stream->ctf_trace->refcount) >= 0);
- if (uatomic_read(&stream->ctf_trace->refcount) == 0) {
- DBG("Freeing ctf_trace %" PRIu64, stream->ctf_trace->id);
- free(stream->ctf_trace);
- }
- }
-
- free(stream->path_name);
- free(stream->channel_name);
- free(stream);
-}
-
+/*
+ * Delete all streams for a specific session ID.
+ */
static
void viewer_del_streams(uint64_t session_id)
{
- int ret;
struct relay_viewer_stream *stream;
- struct lttng_ht_node_u64 *node;
struct lttng_ht_iter iter;
rcu_read_lock();
- cds_lfht_for_each_entry(viewer_streams_ht->ht, &iter.iter, node, node) {
+ cds_lfht_for_each_entry(viewer_streams_ht->ht, &iter.iter, stream,
+ stream_n.node) {
health_code_update();
- node = lttng_ht_iter_get_node_u64(&iter);
- if (!node) {
- continue;
- }
-
- stream = caa_container_of(node, struct relay_viewer_stream, stream_n);
if (stream->session_id != session_id) {
continue;
}
- if (stream->read_fd > 0) {
- ret = close(stream->read_fd);
- if (ret < 0) {
- PERROR("close read_fd");
- }
- }
- if (stream->index_read_fd > 0) {
- ret = close(stream->index_read_fd);
- if (ret < 0) {
- PERROR("close index_read_fd");
- }
- }
- if (stream->metadata_flag && stream->ctf_trace) {
+ delete_viewer_stream(stream);
+ assert(stream->ctf_trace);
+
+ if (stream->metadata_flag) {
+ /*
+ * The metadata viewer stream is destroyed once the refcount on the
+ * ctf trace goes to 0 in the destroy stream function thus there is
+ * no explicit call to that function here.
+ */
stream->ctf_trace->metadata_sent = 0;
+ stream->ctf_trace->viewer_metadata_stream = NULL;
+ } else {
+ destroy_viewer_stream(stream);
}
- ret = lttng_ht_del(viewer_streams_ht, &iter);
- assert(!ret);
- call_rcu(&stream->rcu_node, deferred_free_viewer_stream);
}
rcu_read_unlock();
}
assert(iter);
assert(relay_connection);
+ DBG("Cleaning connection of session ID %" PRIu64,
+ relay_connection->session_id);
+
ret = lttng_ht_del(relay_connections_ht, iter);
assert(!ret);
/* connection closed */
if (ret <= 0) {
cleanup_poll_connection(&events, pollfd);
- del_connection( relay_connections_ht, &iter,
+ del_connection(relay_connections_ht, &iter,
relay_connection);
DBG("Viewer control connection closed with %d",
pollfd);
return ret;
}
-void live_stop_threads()
+void live_stop_threads(void)
{
int ret;
void *status;
projects / lttng-tools.git / blobdiff