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) {
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,
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;
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;