#include <lttng/trigger/trigger-internal.h>
#include <lttng/condition/condition.h>
#include <lttng/action/action.h>
+#include <lttng/channel.h>
#include <lttng/channel-internal.h>
#include <common/string-utils/string-utils.h>
goto end;
}
- ret = consumer_get_discarded_events(session->id, kchan->fd,
+ ret = consumer_get_discarded_events(session->id, kchan->key,
session->kernel_session->consumer,
discarded_events);
if (ret < 0) {
goto end;
}
- ret = consumer_get_lost_packets(session->id, kchan->fd,
+ ret = consumer_get_lost_packets(session->id, kchan->key,
session->kernel_session->consumer,
lost_packets);
if (ret < 0) {
/*
* Fill lttng_channel array of all channels.
*/
-static void list_lttng_channels(enum lttng_domain_type domain,
+static ssize_t list_lttng_channels(enum lttng_domain_type domain,
struct ltt_session *session, struct lttng_channel *channels,
struct lttng_channel_extended *chan_exts)
{
- int i = 0, ret;
+ int i = 0, ret = 0;
struct ltt_kernel_channel *kchan;
DBG("Listing channels for session %s", session->name);
chan_exts[i].lost_packets = lost_packets;
chan_exts[i].monitor_timer_interval =
extended->monitor_timer_interval;
+ chan_exts[i].blocking_timeout = 0;
i++;
}
}
break;
}
+ chan_exts[i].monitor_timer_interval =
+ uchan->monitor_timer_interval;
+ chan_exts[i].blocking_timeout =
+ uchan->attr.u.s.blocking_timeout;
+
ret = get_ust_runtime_stats(session, uchan,
&discarded_events, &lost_packets);
if (ret < 0) {
}
chan_exts[i].discarded_events = discarded_events;
chan_exts[i].lost_packets = lost_packets;
- chan_exts[i].monitor_timer_interval =
- uchan->monitor_timer_interval;
i++;
}
rcu_read_unlock();
}
end:
- return;
+ if (ret < 0) {
+ return -LTTNG_ERR_FATAL;
+ } else {
+ return LTTNG_OK;
+ }
}
static void increment_extended_len(const char *filter_expression,
break;
case LTTNG_DST_PATH:
DBG2("Setting trace directory path from URI to %s", uri->dst.path);
- memset(consumer->dst.trace_path, 0,
- sizeof(consumer->dst.trace_path));
+ memset(consumer->dst.session_root_path, 0,
+ sizeof(consumer->dst.session_root_path));
/* Explicit length checks for strcpy and strcat. */
if (strlen(uri->dst.path) + strlen(default_trace_dir)
- >= sizeof(consumer->dst.trace_path)) {
+ >= sizeof(consumer->dst.session_root_path)) {
ret = LTTNG_ERR_FATAL;
goto error;
}
- strcpy(consumer->dst.trace_path, uri->dst.path);
+ strcpy(consumer->dst.session_root_path, uri->dst.path);
/* Append default trace dir */
- strcat(consumer->dst.trace_path, default_trace_dir);
+ strcat(consumer->dst.session_root_path, default_trace_dir);
/* Flag consumer as local. */
consumer->type = CONSUMER_DST_LOCAL;
break;
/* Check relayd version */
ret = relayd_version_check(rsock);
- if (ret < 0) {
- ret = LTTNG_ERR_RELAYD_VERSION_FAIL;
+ if (ret == LTTNG_ERR_RELAYD_VERSION_FAIL) {
+ goto close_sock;
+ } else if (ret < 0) {
+ ERR("Unable to reach lttng-relayd");
+ ret = LTTNG_ERR_RELAYD_CONNECT_FAIL;
goto close_sock;
}
consumer->relay_major_version = rsock->major;
/*
* Connect to the relayd using URI and send the socket to the right consumer.
+ *
+ * The consumer socket lock must be held by the caller.
*/
static int send_consumer_relayd_socket(enum lttng_domain_type domain,
unsigned int session_id, struct lttng_uri *relayd_uri,
/* Connect to relayd and make version check if uri is the control. */
ret = create_connect_relayd(relayd_uri, &rsock, consumer);
if (ret != LTTNG_OK) {
- goto error;
+ goto relayd_comm_error;
}
assert(rsock);
*/
close_sock:
- (void) relayd_close(rsock);
- free(rsock);
-
-error:
if (ret != LTTNG_OK) {
/*
* The consumer output for this session should not be used anymore
*/
consumer->enabled = 0;
}
+ (void) relayd_close(rsock);
+ free(rsock);
+
+relayd_comm_error:
return ret;
}
* Send both relayd sockets to a specific consumer and domain. This is a
* helper function to facilitate sending the information to the consumer for a
* session.
+ *
+ * The consumer socket lock must be held by the caller.
*/
static int send_consumer_relayd_sockets(enum lttng_domain_type domain,
unsigned int session_id, struct consumer_output *consumer,
attr->attr.switch_timer_interval = 0;
}
+ /* Check for feature support */
+ switch (domain->type) {
+ case LTTNG_DOMAIN_KERNEL:
+ {
+ if (kernel_supports_ring_buffer_snapshot_sample_positions(kernel_tracer_fd) != 1) {
+ /* Sampling position of buffer is not supported */
+ WARN("Kernel tracer does not support buffer monitoring. "
+ "Setting the monitor interval timer to 0 "
+ "(disabled) for channel '%s' of session '%s'",
+ attr-> name, session->name);
+ lttng_channel_set_monitor_timer_interval(attr, 0);
+ }
+ break;
+ }
+ case LTTNG_DOMAIN_UST:
+ case LTTNG_DOMAIN_JUL:
+ case LTTNG_DOMAIN_LOG4J:
+ case LTTNG_DOMAIN_PYTHON:
+ break;
+ default:
+ ret = LTTNG_ERR_UNKNOWN_DOMAIN;
+ goto error;
+ }
+
switch (domain->type) {
case LTTNG_DOMAIN_KERNEL:
{
int ret, chan_kern_created = 0, chan_ust_created = 0;
char *app_ctx_provider_name = NULL, *app_ctx_name = NULL;
+ /*
+ * Don't try to add a context if the session has been started at
+ * some point in time before. The tracer does not allow it and would
+ * result in a corrupted trace.
+ */
+ if (session->has_been_started) {
+ ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
+ goto end;
+ }
+
if (ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
app_ctx_provider_name = ctx->u.app_ctx.provider_name;
app_ctx_name = ctx->u.app_ctx.ctx_name;
return -ret;
}
+static
+int domain_mkdir(const struct consumer_output *output,
+ const struct ltt_session *session,
+ uid_t uid, gid_t gid)
+{
+ struct consumer_socket *socket;
+ struct lttng_ht_iter iter;
+ int ret;
+ char *path = NULL;
+
+ if (!output || !output->socks) {
+ ERR("No consumer output found");
+ ret = -1;
+ goto end;
+ }
+
+ path = zmalloc(LTTNG_PATH_MAX * sizeof(char));
+ if (!path) {
+ ERR("Cannot allocate mkdir path");
+ ret = -1;
+ goto end;
+ }
+
+ ret = snprintf(path, LTTNG_PATH_MAX, "%s%s%s",
+ session_get_base_path(session),
+ output->chunk_path, output->subdir);
+ if (ret < 0 || ret >= LTTNG_PATH_MAX) {
+ ERR("Format path");
+ ret = -1;
+ goto end;
+ }
+
+ DBG("Domain mkdir %s for session %" PRIu64, path, session->id);
+ rcu_read_lock();
+ /*
+ * We have to iterate to find a socket, but we only need to send the
+ * rename command to one consumer, so we break after the first one.
+ */
+ cds_lfht_for_each_entry(output->socks->ht, &iter.iter, socket, node.node) {
+ pthread_mutex_lock(socket->lock);
+ ret = consumer_mkdir(socket, session->id, output, path, uid, gid);
+ pthread_mutex_unlock(socket->lock);
+ if (ret) {
+ ERR("Consumer mkdir");
+ ret = -1;
+ goto end_unlock;
+ }
+ break;
+ }
+
+ ret = 0;
+
+end_unlock:
+ rcu_read_unlock();
+end:
+ free(path);
+ return ret;
+}
+
+static
+int session_mkdir(const struct ltt_session *session)
+{
+ int ret;
+ struct consumer_output *output;
+ uid_t uid;
+ gid_t gid;
+
+ /*
+ * Unsupported feature in lttng-relayd before 2.11, not an error since it
+ * is only needed for session rotation and the user will get an error
+ * on rotate.
+ */
+ if (session->consumer->type == CONSUMER_DST_NET &&
+ session->consumer->relay_major_version == 2 &&
+ session->consumer->relay_minor_version < 11) {
+ ret = 0;
+ goto end;
+ }
+
+ if (session->kernel_session) {
+ output = session->kernel_session->consumer;
+ uid = session->kernel_session->uid;
+ gid = session->kernel_session->gid;
+ ret = domain_mkdir(output, session, uid, gid);
+ if (ret) {
+ ERR("Mkdir kernel");
+ goto end;
+ }
+ }
+
+ if (session->ust_session) {
+ output = session->ust_session->consumer;
+ uid = session->ust_session->uid;
+ gid = session->ust_session->gid;
+ ret = domain_mkdir(output, session, uid, gid);
+ if (ret) {
+ ERR("Mkdir UST");
+ goto end;
+ }
+ }
+
+ ret = 0;
+
+end:
+ return ret;
+}
+
/*
* Command LTTNG_START_TRACE processed by the client thread.
*
goto error;
}
+ if (!session->has_been_started) {
+ if (!session->snapshot_mode && session->output_traces) {
+ ret = session_mkdir(session);
+ if (ret) {
+ ERR("Failed to create the session directories");
+ ret = LTTNG_ERR_CREATE_DIR_FAIL;
+ goto error;
+ }
+ }
+ }
+
/* Kernel tracing */
if (ksession != NULL) {
+ DBG("Start kernel tracing session %s", session->name);
ret = start_kernel_session(ksession, kernel_tracer_fd);
if (ret != LTTNG_OK) {
goto error;
channel_exts = ((void *) *channels) +
(nb_chan * sizeof(struct lttng_channel));
- list_lttng_channels(domain, session, *channels, channel_exts);
+ ret = list_lttng_channels(domain, session, *channels, channel_exts);
+ if (ret != LTTNG_OK) {
+ free(*channels);
+ *channels = NULL;
+ goto end;
+ }
} else {
*channels = NULL;
}
sizeof(sessions[i].path), session);
} else {
ret = snprintf(sessions[i].path, sizeof(sessions[i].path), "%s",
- session->consumer->dst.trace_path);
+ session->consumer->dst.session_root_path);
}
if (ret < 0) {
PERROR("snprintf session path");
}
if (output->consumer->type == CONSUMER_DST_LOCAL) {
if (lttng_strncpy(list[idx].ctrl_url,
- output->consumer->dst.trace_path,
+ output->consumer->dst.session_root_path,
sizeof(list[idx].ctrl_url))) {
ret = -LTTNG_ERR_INVALID;
goto error;
ret = LTTNG_ERR_SESSION_NOT_STARTED;
goto end;
}
- ret = 0;
if (session->kernel_session) {
ret = kernctl_session_regenerate_statedump(
rcu_read_lock();
cds_lfht_for_each_entry(snap_output->consumer->socks->ht, &iter.iter,
socket, node.node) {
+ pthread_mutex_lock(socket->lock);
ret = send_consumer_relayd_sockets(0, session->id,
snap_output->consumer, socket,
session->name, session->hostname,
session->live_timer);
+ pthread_mutex_unlock(socket->lock);
if (ret != LTTNG_OK) {
rcu_read_unlock();
goto error;