if (ret < 0) {
PERROR("snprintf kernel channel path");
goto error;
+ } else if (ret >= sizeof(tmp_path)) {
+ ERR("Kernel channel path exceeds the maximal allowed length of of %zu bytes (%i bytes required) with path \"%s%s%s\"",
+ sizeof(tmp_path), ret,
+ consumer->dst.session_root_path,
+ consumer->chunk_path,
+ consumer->subdir);
+ goto error;
}
pathname = lttng_strndup(tmp_path, sizeof(tmp_path));
if (!pathname) {
}
DBG3("Kernel local consumer tracefile path: %s", pathname);
} else {
- ret = snprintf(tmp_path, sizeof(tmp_path), "%s", consumer->subdir);
+ ret = snprintf(tmp_path, sizeof(tmp_path), "%s%s",
+ consumer->dst.net.base_dir,
+ consumer->subdir);
if (ret < 0) {
PERROR("snprintf kernel metadata path");
goto error;
+ } else if (ret >= sizeof(tmp_path)) {
+ ERR("Kernel channel path exceeds the maximal allowed length of of %zu bytes (%i bytes required) with path \"%s%s\"",
+ sizeof(tmp_path), ret,
+ consumer->dst.net.base_dir,
+ consumer->subdir);
+ goto error;
}
pathname = lttng_strndup(tmp_path, sizeof(tmp_path));
if (!pathname) {
struct lttcomm_consumer_msg lkm;
struct consumer_output *consumer;
enum lttng_error_code status;
- struct ltt_session *session;
+ struct ltt_session *session = NULL;
struct lttng_channel_extended *channel_attr_extended;
/* Safety net */
}
/* Prep channel message structure */
- consumer_init_channel_comm_msg(&lkm,
- LTTNG_CONSUMER_ADD_CHANNEL,
+ consumer_init_add_channel_comm_msg(&lkm,
channel->key,
ksession->id,
pathname,
rcu_read_lock();
session = session_find_by_id(ksession->id);
assert(session);
+ assert(pthread_mutex_trylock(&session->lock));
+ assert(session_trylock_list());
status = notification_thread_command_add_channel(
notification_thread_handle, session->name,
channel->published_to_notification_thread = true;
error:
+ if (session) {
+ session_put(session);
+ }
free(pathname);
return ret;
}
* The consumer socket lock must be held by the caller.
*/
int kernel_consumer_add_metadata(struct consumer_socket *sock,
- struct ltt_kernel_session *session, unsigned int monitor)
+ struct ltt_kernel_session *ksession, unsigned int monitor)
{
int ret;
char *pathname;
struct lttcomm_consumer_msg lkm;
struct consumer_output *consumer;
+ struct ltt_session *session = NULL;
+
+ rcu_read_lock();
/* Safety net */
- assert(session);
- assert(session->consumer);
+ assert(ksession);
+ assert(ksession->consumer);
assert(sock);
- DBG("Sending metadata %d to kernel consumer", session->metadata_stream_fd);
+ DBG("Sending metadata %d to kernel consumer",
+ ksession->metadata_stream_fd);
/* Get consumer output pointer */
- consumer = session->consumer;
+ consumer = ksession->consumer;
if (monitor) {
- pathname = create_channel_path(consumer, session->uid, session->gid);
+ pathname = create_channel_path(consumer,
+ ksession->uid, ksession->gid);
} else {
/* Empty path. */
pathname = strdup("");
goto error;
}
+ session = session_find_by_id(ksession->id);
+ assert(session);
+ assert(pthread_mutex_trylock(&session->lock));
+ assert(session_trylock_list());
+
/* Prep channel message structure */
- consumer_init_channel_comm_msg(&lkm,
- LTTNG_CONSUMER_ADD_CHANNEL,
- session->metadata->fd,
- session->id,
+ consumer_init_add_channel_comm_msg(&lkm,
+ ksession->metadata->key,
+ ksession->id,
pathname,
- session->uid,
- session->gid,
+ ksession->uid,
+ ksession->gid,
consumer->net_seq_index,
DEFAULT_METADATA_NAME,
1,
health_code_update();
/* Prep stream message structure */
- consumer_init_stream_comm_msg(&lkm,
- LTTNG_CONSUMER_ADD_STREAM,
- session->metadata->fd,
- session->metadata_stream_fd,
- 0); /* CPU: 0 for metadata. */
+ consumer_init_add_stream_comm_msg(&lkm,
+ ksession->metadata->key,
+ ksession->metadata_stream_fd,
+ 0 /* CPU: 0 for metadata. */,
+ session->current_archive_id);
health_code_update();
/* Send stream and file descriptor */
ret = consumer_send_stream(sock, consumer, &lkm,
- &session->metadata_stream_fd, 1);
+ &ksession->metadata_stream_fd, 1);
if (ret < 0) {
goto error;
}
health_code_update();
error:
+ rcu_read_unlock();
free(pathname);
+ if (session) {
+ session_put(session);
+ }
return ret;
}
/*
* Sending a single stream to the consumer with command ADD_STREAM.
*/
+static
int kernel_consumer_add_stream(struct consumer_socket *sock,
- struct ltt_kernel_channel *channel, struct ltt_kernel_stream *stream,
- struct ltt_kernel_session *session, unsigned int monitor)
+ struct ltt_kernel_channel *channel,
+ struct ltt_kernel_stream *stream,
+ struct ltt_kernel_session *session, unsigned int monitor,
+ uint64_t trace_archive_id)
{
int ret;
struct lttcomm_consumer_msg lkm;
consumer = session->consumer;
/* Prep stream consumer message */
- consumer_init_stream_comm_msg(&lkm,
- LTTNG_CONSUMER_ADD_STREAM,
+ consumer_init_add_stream_comm_msg(&lkm,
channel->key,
stream->fd,
- stream->cpu);
+ stream->cpu,
+ trace_archive_id);
health_code_update();
*
* The consumer socket lock must be held by the caller.
*/
-int kernel_consumer_send_channel_stream(struct consumer_socket *sock,
- struct ltt_kernel_channel *channel, struct ltt_kernel_session *session,
+int kernel_consumer_send_channel_streams(struct consumer_socket *sock,
+ struct ltt_kernel_channel *channel, struct ltt_kernel_session *ksession,
unsigned int monitor)
{
int ret = LTTNG_OK;
struct ltt_kernel_stream *stream;
+ struct ltt_session *session = NULL;
/* Safety net */
assert(channel);
- assert(session);
- assert(session->consumer);
+ assert(ksession);
+ assert(ksession->consumer);
assert(sock);
+ rcu_read_lock();
+
+ session = session_find_by_id(ksession->id);
+ assert(session);
+ assert(pthread_mutex_trylock(&session->lock));
+ assert(session_trylock_list());
+
/* Bail out if consumer is disabled */
- if (!session->consumer->enabled) {
+ if (!ksession->consumer->enabled) {
ret = LTTNG_OK;
goto error;
}
channel->channel->name);
if (!channel->sent_to_consumer) {
- ret = kernel_consumer_add_channel(sock, channel, session, monitor);
+ ret = kernel_consumer_add_channel(sock, channel, ksession, monitor);
if (ret < 0) {
goto error;
}
}
/* Add stream on the kernel consumer side. */
- ret = kernel_consumer_add_stream(sock, channel, stream, session,
- monitor);
+ ret = kernel_consumer_add_stream(sock, channel, stream,
+ ksession, monitor, session->current_archive_id);
if (ret < 0) {
goto error;
}
}
error:
+ rcu_read_unlock();
+ if (session) {
+ session_put(session);
+ }
return ret;
}
/* Send channel and streams of it */
cds_list_for_each_entry(chan, &session->channel_list.head, list) {
- ret = kernel_consumer_send_channel_stream(sock, chan, session,
+ ret = kernel_consumer_send_channel_streams(sock, chan, session,
monitor);
if (ret < 0) {
goto error;
assert(metadata);
assert(socket);
- DBG("Sending kernel consumer destroy channel key %d", metadata->fd);
+ DBG("Sending kernel consumer destroy channel key %" PRIu64, metadata->key);
memset(&msg, 0, sizeof(msg));
msg.cmd_type = LTTNG_CONSUMER_DESTROY_CHANNEL;
- msg.u.destroy_channel.key = metadata->fd;
+ msg.u.destroy_channel.key = metadata->key;
pthread_mutex_lock(socket->lock);
health_code_update();
projects / lttng-tools.git / blobdiff