goto error;
}
+ consumer_stream_update_channel_attributes(stream, channel);
stream->chan = channel;
error:
/* Get the right pipe where the stream will be sent. */
if (stream->metadata_flag) {
- ret = consumer_add_metadata_stream(stream);
- if (ret) {
- ERR("Consumer add metadata stream %" PRIu64 " failed.",
- stream->key);
- goto error;
- }
+ consumer_add_metadata_stream(stream);
stream_pipe = ctx->consumer_metadata_pipe;
} else {
- ret = consumer_add_data_stream(stream);
- if (ret) {
- ERR("Consumer add stream %" PRIu64 " failed.",
- stream->key);
- goto error;
- }
+ consumer_add_data_stream(stream);
stream_pipe = ctx->consumer_data_pipe;
}
/*
* From this point on, the stream's ownership has been moved away from
- * the channel and becomes globally visible.
+ * the channel and it becomes globally visible. Hence, remove it from
+ * the local stream list to prevent the stream from being both local and
+ * global.
*/
stream->globally_visible = 1;
+ cds_list_del(&stream->send_node);
ret = lttng_pipe_write(stream_pipe, &stream, sizeof(stream));
if (ret < 0) {
} else {
consumer_del_stream_for_data(stream);
}
+ goto error;
}
+
error:
return ret;
}
* If we are unable to send the stream to the thread, there is
* a big problem so just stop everything.
*/
- /* Remove node from the channel stream list. */
- cds_list_del(&stream->send_node);
goto error;
}
-
- /* Remove node from the channel stream list. */
- cds_list_del(&stream->send_node);
-
}
error:
{
int ret = 0;
struct lttng_consumer_channel *channel;
+ unsigned int channel_monitor;
DBG("UST consumer close metadata key %" PRIu64, chan_key);
pthread_mutex_lock(&consumer_data.lock);
pthread_mutex_lock(&channel->lock);
-
+ channel_monitor = channel->monitor;
if (cds_lfht_is_node_deleted(&channel->node.node)) {
goto error_unlock;
}
lttng_ustconsumer_close_metadata(channel);
+ pthread_mutex_unlock(&channel->lock);
+ pthread_mutex_unlock(&consumer_data.lock);
+
+ /*
+ * The ownership of a metadata channel depends on the type of
+ * session to which it belongs. In effect, the monitor flag is checked
+ * to determine if this metadata channel is in "snapshot" mode or not.
+ *
+ * In the non-snapshot case, the metadata channel is created along with
+ * a single stream which will remain present until the metadata channel
+ * is destroyed (on the destruction of its session). In this case, the
+ * metadata stream in "monitored" by the metadata poll thread and holds
+ * the ownership of its channel.
+ *
+ * Closing the metadata will cause the metadata stream's "metadata poll
+ * pipe" to be closed. Closing this pipe will wake-up the metadata poll
+ * thread which will teardown the metadata stream which, in return,
+ * deletes the metadata channel.
+ *
+ * In the snapshot case, the metadata stream is created and destroyed
+ * on every snapshot record. Since the channel doesn't have an owner
+ * other than the session daemon, it is safe to destroy it immediately
+ * on reception of the CLOSE_METADATA command.
+ */
+ if (!channel_monitor) {
+ /*
+ * The channel and consumer_data locks must be
+ * released before this call since consumer_del_channel
+ * re-acquires the channel and consumer_data locks to teardown
+ * the channel and queue its reclamation by the "call_rcu"
+ * worker thread.
+ */
+ consumer_del_channel(channel);
+ }
+ return ret;
error_unlock:
pthread_mutex_unlock(&channel->lock);
pthread_mutex_unlock(&consumer_data.lock);
}
}
+ /*
+ * Ownership of metadata stream is passed along. Freeing is handled by
+ * the callee.
+ */
ret = send_streams_to_thread(metadata, ctx);
if (ret < 0) {
/*
* a big problem so just stop everything.
*/
ret = LTTCOMM_CONSUMERD_FATAL;
- goto error;
+ goto send_streams_error;
}
/* List MUST be empty after or else it could be reused. */
assert(cds_list_empty(&metadata->streams.head));
consumer_stream_destroy(metadata->metadata_stream, NULL);
cds_list_del(&metadata->metadata_stream->send_node);
metadata->metadata_stream = NULL;
+send_streams_error:
error_no_stream:
end:
return ret;
DBG("UST consumer snapshot stream %s/%s (%" PRIu64 ")", path,
stream->name, stream->key);
}
- if (relayd_id != -1ULL) {
- ret = consumer_send_relayd_streams_sent(relayd_id);
- if (ret < 0) {
- goto error_unlock;
- }
- }
/*
* If tracing is active, we want to perform a "full" buffer flush.
case LTTNG_CONSUMER_ADD_RELAYD_SOCKET:
{
/* Session daemon status message are handled in the following call. */
- ret = consumer_add_relayd_socket(msg.u.relayd_sock.net_index,
+ consumer_add_relayd_socket(msg.u.relayd_sock.net_index,
msg.u.relayd_sock.type, ctx, sock, consumer_sockpoll,
&msg.u.relayd_sock.sock, msg.u.relayd_sock.session_id,
msg.u.relayd_sock.relayd_session_id);
}
goto end_msg_sessiond;
}
+ case LTTNG_CONSUMER_ROTATE_RENAME:
+ {
+ DBG("Consumer rename session %" PRIu64 " after rotation",
+ msg.u.rotate_rename.session_id);
+ ret = lttng_consumer_rotate_rename(msg.u.rotate_rename.old_path,
+ msg.u.rotate_rename.new_path,
+ msg.u.rotate_rename.uid,
+ msg.u.rotate_rename.gid,
+ msg.u.rotate_rename.relayd_id);
+ if (ret < 0) {
+ ERR("Rotate rename failed");
+ ret_code = LTTCOMM_CONSUMERD_CHAN_NOT_FOUND;
+ }
+
+ health_code_update();
+
+ ret = consumer_send_status_msg(sock, ret_code);
+ if (ret < 0) {
+ /* Somehow, the session daemon is not responding anymore. */
+ goto end_nosignal;
+ }
+ break;
+ }
+ case LTTNG_CONSUMER_MKDIR:
+ {
+ DBG("Consumer mkdir %s in session %" PRIu64,
+ msg.u.mkdir.path,
+ msg.u.mkdir.session_id);
+ ret = lttng_consumer_mkdir(msg.u.mkdir.path,
+ msg.u.mkdir.uid,
+ msg.u.mkdir.gid,
+ msg.u.mkdir.relayd_id);
+ if (ret < 0) {
+ ERR("consumer mkdir failed");
+ ret_code = LTTCOMM_CONSUMERD_CHAN_NOT_FOUND;
+ }
+
+ health_code_update();
+
+ ret = consumer_send_status_msg(sock, ret_code);
+ if (ret < 0) {
+ /* Somehow, the session daemon is not responding anymore. */
+ goto end_nosignal;
+ }
+ break;
+ }
default:
break;
}
projects / lttng-tools.git / blobdiff