X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fust-app.c;h=d3c28883c74bea2416d9afb8a5f0db7c87c03f91;hp=8c5f3f6afc0e3dfdb7ad225f2963bce7bd526624;hb=44cdb3a261262ebabea3fb0cae9360ac05e66f2c;hpb=faadaa3a56561aca9dbd8f10f91d1e0fc40ed7e2

diff --git a/src/bin/lttng-sessiond/ust-app.c b/src/bin/lttng-sessiond/ust-app.c
index 8c5f3f6af..d3c28883c 100644
--- a/src/bin/lttng-sessiond/ust-app.c
+++ b/src/bin/lttng-sessiond/ust-app.c
@@ -27,7 +27,6 @@
 #include <sys/types.h>
 #include <unistd.h>
 #include <urcu/compiler.h>
-#include <lttng/ust-error.h>
 #include <signal.h>
 
 #include <common/common.h>
@@ -38,13 +37,18 @@
 #include "health-sessiond.h"
 #include "ust-app.h"
 #include "ust-consumer.h"
-#include "ust-ctl.h"
+#include "lttng-ust-ctl.h"
+#include "lttng-ust-error.h"
 #include "utils.h"
 #include "session.h"
 #include "lttng-sessiond.h"
 #include "notification-thread-commands.h"
 #include "rotate.h"
 
+struct lttng_ht *ust_app_ht;
+struct lttng_ht *ust_app_ht_by_sock;
+struct lttng_ht *ust_app_ht_by_notify_sock;
+
 static
 int ust_app_flush_app_session(struct ust_app *app, struct ust_app_session *ua_sess);
 
@@ -250,7 +254,8 @@ static struct ust_registry_session *get_session_registry(
 	case LTTNG_BUFFER_PER_UID:
 	{
 		struct buffer_reg_uid *reg_uid = buffer_reg_uid_find(
-				ua_sess->tracing_id, ua_sess->bits_per_long, ua_sess->uid);
+				ua_sess->tracing_id, ua_sess->bits_per_long,
+				ua_sess->real_credentials.uid);
 		if (!reg_uid) {
 			goto error;
 		}
@@ -740,6 +745,10 @@ error:
  * nullified. The session lock MUST be held unless the application is
  * in the destroy path.
  *
+ * Do not hold the registry lock while communicating with the consumerd, because
+ * doing so causes inter-process deadlocks between consumerd and sessiond with
+ * the metadata request notification.
+ *
  * Return 0 on success else a negative value.
  */
 static int close_metadata(struct ust_registry_session *registry,
@@ -747,6 +756,8 @@ static int close_metadata(struct ust_registry_session *registry,
 {
 	int ret;
 	struct consumer_socket *socket;
+	uint64_t metadata_key;
+	bool registry_was_already_closed;
 
 	assert(registry);
 	assert(consumer);
@@ -754,8 +765,19 @@ static int close_metadata(struct ust_registry_session *registry,
 	rcu_read_lock();
 
 	pthread_mutex_lock(&registry->lock);
+	metadata_key = registry->metadata_key;
+	registry_was_already_closed = registry->metadata_closed;
+	if (metadata_key != 0) {
+		/*
+		 * Metadata closed. Even on error this means that the consumer
+		 * is not responding or not found so either way a second close
+		 * should NOT be emit for this registry.
+		 */
+		registry->metadata_closed = 1;
+	}
+	pthread_mutex_unlock(&registry->lock);
 
-	if (!registry->metadata_key || registry->metadata_closed) {
+	if (metadata_key == 0 || registry_was_already_closed) {
 		ret = 0;
 		goto end;
 	}
@@ -765,23 +787,15 @@ static int close_metadata(struct ust_registry_session *registry,
 			consumer);
 	if (!socket) {
 		ret = -1;
-		goto error;
+		goto end;
 	}
 
-	ret = consumer_close_metadata(socket, registry->metadata_key);
+	ret = consumer_close_metadata(socket, metadata_key);
 	if (ret < 0) {
-		goto error;
+		goto end;
 	}
 
-error:
-	/*
-	 * Metadata closed. Even on error this means that the consumer is not
-	 * responding or not found so either way a second close should NOT be emit
-	 * for this registry.
-	 */
-	registry->metadata_closed = 1;
 end:
-	pthread_mutex_unlock(&registry->lock);
 	rcu_read_unlock();
 	return ret;
 }
@@ -1099,7 +1113,7 @@ struct ust_app_event *alloc_ust_app_event(char *name,
 	/* Init most of the default value by allocating and zeroing */
 	ua_event = zmalloc(sizeof(struct ust_app_event));
 	if (ua_event == NULL) {
-		PERROR("malloc");
+		PERROR("Failed to allocate ust_app_event structure");
 		goto error;
 	}
 
@@ -1260,7 +1274,7 @@ error:
  * Return an ust_app_event object or NULL on error.
  */
 static struct ust_app_event *find_ust_app_event(struct lttng_ht *ht,
-		char *name, struct lttng_filter_bytecode *filter,
+		const char *name, const struct lttng_filter_bytecode *filter,
 		int loglevel_value,
 		const struct lttng_event_exclusion *exclusion)
 {
@@ -1321,7 +1335,7 @@ int create_ust_channel_context(struct ust_app_channel *ua_chan,
 			 * continue normally.
 			 */
 			ret = 0;
-			DBG3("UST app disable event failed. Application is dead.");
+			DBG3("UST app add context failed. Application is dead.");
 		}
 		goto error;
 	}
@@ -1683,6 +1697,7 @@ int create_ust_event(struct ust_app *app, struct ust_app_session *ua_sess,
 	pthread_mutex_unlock(&app->sock_lock);
 	if (ret < 0) {
 		if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
+			abort();
 			ERR("Error ustctl create event %s for app pid: %d with ret %d",
 					ua_event->attr.name, app->pid, ret);
 		} else {
@@ -1795,11 +1810,6 @@ static void shadow_copy_event(struct ust_app_event *ua_event,
 static void shadow_copy_channel(struct ust_app_channel *ua_chan,
 		struct ltt_ust_channel *uchan)
 {
-	struct lttng_ht_iter iter;
-	struct ltt_ust_event *uevent;
-	struct ltt_ust_context *uctx;
-	struct ust_app_event *ua_event;
-
 	DBG2("UST app shadow copy of channel %s started", ua_chan->name);
 
 	strncpy(ua_chan->name, uchan->name, sizeof(ua_chan->name));
@@ -1826,34 +1836,6 @@ static void shadow_copy_channel(struct ust_app_channel *ua_chan,
 	ua_chan->enabled = uchan->enabled;
 	ua_chan->tracing_channel_id = uchan->id;
 
-	cds_list_for_each_entry(uctx, &uchan->ctx_list, list) {
-		struct ust_app_ctx *ua_ctx = alloc_ust_app_ctx(&uctx->ctx);
-
-		if (ua_ctx == NULL) {
-			continue;
-		}
-		lttng_ht_node_init_ulong(&ua_ctx->node,
-				(unsigned long) ua_ctx->ctx.ctx);
-		lttng_ht_add_ulong(ua_chan->ctx, &ua_ctx->node);
-		cds_list_add_tail(&ua_ctx->list, &ua_chan->ctx_list);
-	}
-
-	/* Copy all events from ltt ust channel to ust app channel */
-	cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
-		ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
-				uevent->filter, uevent->attr.loglevel, uevent->exclusion);
-		if (ua_event == NULL) {
-			DBG2("UST event %s not found on shadow copy channel",
-					uevent->attr.name);
-			ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
-			if (ua_event == NULL) {
-				continue;
-			}
-			shadow_copy_event(ua_event, uevent);
-			add_unique_ust_app_event(ua_chan, ua_event);
-		}
-	}
-
 	DBG3("UST app shadow copy of channel %s done", ua_chan->name);
 }
 
@@ -1863,29 +1845,22 @@ static void shadow_copy_channel(struct ust_app_channel *ua_chan,
 static void shadow_copy_session(struct ust_app_session *ua_sess,
 		struct ltt_ust_session *usess, struct ust_app *app)
 {
-	struct lttng_ht_node_str *ua_chan_node;
-	struct lttng_ht_iter iter;
-	struct ltt_ust_channel *uchan;
-	struct ust_app_channel *ua_chan;
-	time_t rawtime;
 	struct tm *timeinfo;
 	char datetime[16];
 	int ret;
 	char tmp_shm_path[PATH_MAX];
 
-	/* Get date and time for unique app path */
-	time(&rawtime);
-	timeinfo = localtime(&rawtime);
+	timeinfo = localtime(&app->registration_time);
 	strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S", timeinfo);
 
 	DBG2("Shadow copy of session handle %d", ua_sess->handle);
 
 	ua_sess->tracing_id = usess->id;
 	ua_sess->id = get_next_session_id();
-	ua_sess->uid = app->uid;
-	ua_sess->gid = app->gid;
-	ua_sess->euid = usess->uid;
-	ua_sess->egid = usess->gid;
+	ua_sess->real_credentials.uid = app->uid;
+	ua_sess->real_credentials.gid = app->gid;
+	ua_sess->effective_credentials.uid = usess->uid;
+	ua_sess->effective_credentials.gid = usess->gid;
 	ua_sess->buffer_type = usess->buffer_type;
 	ua_sess->bits_per_long = app->bits_per_long;
 
@@ -1906,7 +1881,9 @@ static void shadow_copy_session(struct ust_app_session *ua_sess,
 		break;
 	case LTTNG_BUFFER_PER_UID:
 		ret = snprintf(ua_sess->path, sizeof(ua_sess->path),
-				DEFAULT_UST_TRACE_UID_PATH, ua_sess->uid, app->bits_per_long);
+				DEFAULT_UST_TRACE_UID_PATH,
+				ua_sess->real_credentials.uid,
+				app->bits_per_long);
 		break;
 	default:
 		assert(0);
@@ -1928,12 +1905,12 @@ static void shadow_copy_session(struct ust_app_session *ua_sess,
 		switch (ua_sess->buffer_type) {
 		case LTTNG_BUFFER_PER_PID:
 			ret = snprintf(tmp_shm_path, sizeof(tmp_shm_path),
-					DEFAULT_UST_TRACE_PID_PATH "/%s-%d-%s",
+					"/" DEFAULT_UST_TRACE_PID_PATH "/%s-%d-%s",
 					app->name, app->pid, datetime);
 			break;
 		case LTTNG_BUFFER_PER_UID:
 			ret = snprintf(tmp_shm_path, sizeof(tmp_shm_path),
-					DEFAULT_UST_TRACE_UID_PATH,
+					"/" DEFAULT_UST_TRACE_UID_PATH,
 					app->uid, app->bits_per_long);
 			break;
 		default:
@@ -1949,37 +1926,6 @@ static void shadow_copy_session(struct ust_app_session *ua_sess,
 			sizeof(ua_sess->shm_path) - strlen(ua_sess->shm_path) - 1);
 		ua_sess->shm_path[sizeof(ua_sess->shm_path) - 1] = '\0';
 	}
-
-	/* Iterate over all channels in global domain. */
-	cds_lfht_for_each_entry(usess->domain_global.channels->ht, &iter.iter,
-			uchan, node.node) {
-		struct lttng_ht_iter uiter;
-
-		lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
-		ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
-		if (ua_chan_node != NULL) {
-			/* Session exist. Contiuing. */
-			continue;
-		}
-
-		DBG2("Channel %s not found on shadow session copy, creating it",
-				uchan->name);
-		ua_chan = alloc_ust_app_channel(uchan->name, ua_sess,
-				&uchan->attr);
-		if (ua_chan == NULL) {
-			/* malloc failed FIXME: Might want to do handle ENOMEM .. */
-			continue;
-		}
-		shadow_copy_channel(ua_chan, uchan);
-		/*
-		 * The concept of metadata channel does not exist on the tracing
-		 * registry side of the session daemon so this can only be a per CPU
-		 * channel and not metadata.
-		 */
-		ua_chan->attr.type = LTTNG_UST_CHAN_PER_CPU;
-
-		lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
-	}
 	return;
 
 error:
@@ -1990,7 +1936,7 @@ error:
  * Lookup sesison wrapper.
  */
 static
-void __lookup_session_by_app(struct ltt_ust_session *usess,
+void __lookup_session_by_app(const struct ltt_ust_session *usess,
 			struct ust_app *app, struct lttng_ht_iter *iter)
 {
 	/* Get right UST app session from app */
@@ -2002,7 +1948,7 @@ void __lookup_session_by_app(struct ltt_ust_session *usess,
  * id.
  */
 static struct ust_app_session *lookup_session_by_app(
-		struct ltt_ust_session *usess, struct ust_app *app)
+		const struct ltt_ust_session *usess, struct ust_app *app)
 {
 	struct lttng_ht_iter iter;
 	struct lttng_ht_node_u64 *node;
@@ -2057,10 +2003,11 @@ static int setup_buffer_reg_pid(struct ust_app_session *ua_sess,
 			app->bits_per_long, app->uint8_t_alignment,
 			app->uint16_t_alignment, app->uint32_t_alignment,
 			app->uint64_t_alignment, app->long_alignment,
-			app->byte_order, app->version.major,
-			app->version.minor, reg_pid->root_shm_path,
-			reg_pid->shm_path,
-			ua_sess->euid, ua_sess->egid);
+			app->byte_order, app->version.major, app->version.minor,
+			reg_pid->root_shm_path, reg_pid->shm_path,
+			ua_sess->effective_credentials.uid,
+			ua_sess->effective_credentials.gid, ua_sess->tracing_id,
+			app->uid);
 	if (ret < 0) {
 		/*
 		 * reg_pid->registry->reg.ust is NULL upon error, so we need to
@@ -2127,7 +2074,8 @@ static int setup_buffer_reg_uid(struct ltt_ust_session *usess,
 			app->uint64_t_alignment, app->long_alignment,
 			app->byte_order, app->version.major,
 			app->version.minor, reg_uid->root_shm_path,
-			reg_uid->shm_path, usess->uid, usess->gid);
+			reg_uid->shm_path, usess->uid, usess->gid,
+			ua_sess->tracing_id, app->uid);
 	if (ret < 0) {
 		/*
 		 * reg_uid->registry->reg.ust is NULL upon error, so we need to
@@ -2529,7 +2477,7 @@ static int do_consumer_create_channel(struct ltt_ust_session *usess,
 	 * stream we have to expect.
 	 */
 	ret = ust_consumer_ask_channel(ua_sess, ua_chan, usess->consumer, socket,
-			registry, trace_archive_id);
+			registry, usess->current_trace_chunk);
 	if (ret < 0) {
 		goto error_ask;
 	}
@@ -2912,7 +2860,7 @@ static int create_channel_per_uid(struct ust_app *app,
 	 */
 	ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
 			app->bits_per_long, reg_uid->registry->reg.ust,
-			session->current_archive_id);
+			session->most_recent_chunk_id.value);
 	if (ret < 0) {
 		ERR("Error creating UST channel \"%s\" on the consumer daemon",
 				ua_chan->name);
@@ -2949,10 +2897,9 @@ static int create_channel_per_uid(struct ust_app *app,
 
 	notification_ret = notification_thread_command_add_channel(
 			notification_thread_handle, session->name,
-			ua_sess->euid, ua_sess->egid,
-			ua_chan->name,
-			ua_chan->key,
-			LTTNG_DOMAIN_UST,
+			ua_sess->effective_credentials.uid,
+			ua_sess->effective_credentials.gid, ua_chan->name,
+			ua_chan->key, LTTNG_DOMAIN_UST,
 			ua_chan->attr.subbuf_size * ua_chan->attr.num_subbuf);
 	if (notification_ret != LTTNG_OK) {
 		ret = - (int) notification_ret;
@@ -3026,7 +2973,7 @@ static int create_channel_per_pid(struct ust_app *app,
 	/* Create and get channel on the consumer side. */
 	ret = do_consumer_create_channel(usess, ua_sess, ua_chan,
 			app->bits_per_long, registry,
-			session->current_archive_id);
+			session->most_recent_chunk_id.value);
 	if (ret < 0) {
 		ERR("Error creating UST channel \"%s\" on the consumer daemon",
 			ua_chan->name);
@@ -3050,10 +2997,9 @@ static int create_channel_per_pid(struct ust_app *app,
 
 	cmd_ret = notification_thread_command_add_channel(
 			notification_thread_handle, session->name,
-			ua_sess->euid, ua_sess->egid,
-			ua_chan->name,
-			ua_chan->key,
-			LTTNG_DOMAIN_UST,
+			ua_sess->effective_credentials.uid,
+			ua_sess->effective_credentials.gid, ua_chan->name,
+			ua_chan->key, LTTNG_DOMAIN_UST,
 			ua_chan->attr.subbuf_size * ua_chan->attr.num_subbuf);
 	if (cmd_ret != LTTNG_OK) {
 		ret = - (int) cmd_ret;
@@ -3075,7 +3021,7 @@ error:
 
 /*
  * From an already allocated ust app channel, create the channel buffers if
- * need and send it to the application. This MUST be called with a RCU read
+ * needed and send them to the application. This MUST be called with a RCU read
  * side lock acquired.
  *
  * Called with UST app session lock held.
@@ -3083,7 +3029,7 @@ error:
  * Return 0 on success or else a negative value. Returns -ENOTCONN if
  * the application exited concurrently.
  */
-static int do_create_channel(struct ust_app *app,
+static int ust_app_channel_send(struct ust_app *app,
 		struct ltt_ust_session *usess, struct ust_app_session *ua_sess,
 		struct ust_app_channel *ua_chan)
 {
@@ -3091,6 +3037,7 @@ static int do_create_channel(struct ust_app *app,
 
 	assert(app);
 	assert(usess);
+	assert(usess->active);
 	assert(ua_sess);
 	assert(ua_chan);
 
@@ -3135,16 +3082,14 @@ error:
 }
 
 /*
- * Create UST app channel and create it on the tracer. Set ua_chanp of the
- * newly created channel if not NULL.
+ * Create UST app channel and return it through ua_chanp if not NULL.
  *
  * Called with UST app session lock and RCU read-side lock held.
  *
- * Return 0 on success or else a negative value. Returns -ENOTCONN if
- * the application exited concurrently.
+ * Return 0 on success or else a negative value.
  */
-static int create_ust_app_channel(struct ust_app_session *ua_sess,
-		struct ltt_ust_channel *uchan, struct ust_app *app,
+static int ust_app_channel_allocate(struct ust_app_session *ua_sess,
+		struct ltt_ust_channel *uchan,
 		enum lttng_ust_chan_type type, struct ltt_ust_session *usess,
 		struct ust_app_channel **ua_chanp)
 {
@@ -3165,21 +3110,13 @@ static int create_ust_app_channel(struct ust_app_session *ua_sess,
 	if (ua_chan == NULL) {
 		/* Only malloc can fail here */
 		ret = -ENOMEM;
-		goto error_alloc;
+		goto error;
 	}
 	shadow_copy_channel(ua_chan, uchan);
 
 	/* Set channel type. */
 	ua_chan->attr.type = type;
 
-	ret = do_create_channel(app, usess, ua_sess, ua_chan);
-	if (ret < 0) {
-		goto error;
-	}
-
-	DBG2("UST app create channel %s for PID %d completed", ua_chan->name,
-			app->pid);
-
 	/* Only add the channel if successful on the tracer side. */
 	lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
 end:
@@ -3191,8 +3128,6 @@ end:
 	return 0;
 
 error:
-	delete_ust_app_channel(ua_chan->is_sent ? app->sock : -1, ua_chan, app);
-error_alloc:
 	return ret;
 }
 
@@ -3209,18 +3144,9 @@ int create_ust_app_event(struct ust_app_session *ua_sess,
 	int ret = 0;
 	struct ust_app_event *ua_event;
 
-	/* Get event node */
-	ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
-			uevent->filter, uevent->attr.loglevel, uevent->exclusion);
-	if (ua_event != NULL) {
-		ret = -EEXIST;
-		goto end;
-	}
-
-	/* Does not exist so create one */
 	ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
 	if (ua_event == NULL) {
-		/* Only malloc can failed so something is really wrong */
+		/* Only failure mode of alloc_ust_app_event(). */
 		ret = -ENOMEM;
 		goto end;
 	}
@@ -3229,8 +3155,19 @@ int create_ust_app_event(struct ust_app_session *ua_sess,
 	/* Create it on the tracer side */
 	ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
 	if (ret < 0) {
-		/* Not found previously means that it does not exist on the tracer */
-		assert(ret != -LTTNG_UST_ERR_EXIST);
+		/*
+		 * Not found previously means that it does not exist on the
+		 * tracer. If the application reports that the event existed,
+		 * it means there is a bug in the sessiond or lttng-ust
+		 * (or corruption, etc.)
+		 */
+		if (ret == -LTTNG_UST_ERR_EXIST) {
+			ERR("Tracer for application reported that an event being created already existed: "
+					"event_name = \"%s\", pid = %d, ppid = %d, uid = %d, gid = %d",
+					uevent->attr.name,
+					app->pid, app->ppid, app->uid,
+					app->gid);
+		}
 		goto error;
 	}
 
@@ -3323,7 +3260,7 @@ static int create_ust_app_metadata(struct ust_app_session *ua_sess,
 	 * consumer.
 	 */
 	ret = ust_consumer_ask_channel(ua_sess, metadata, consumer, socket,
-			registry, session->current_archive_id);
+			registry, session->current_trace_chunk);
 	if (ret < 0) {
 		/* Nullify the metadata key so we don't try to close it later on. */
 		registry->metadata_key = 0;
@@ -3463,6 +3400,8 @@ void ust_app_add(struct ust_app *app)
 	assert(app);
 	assert(app->notify_sock >= 0);
 
+	app->registration_time = time(NULL);
+
 	rcu_read_lock();
 
 	/*
@@ -4003,12 +3942,7 @@ int ust_app_disable_channel_glb(struct ltt_ust_session *usess,
 	struct ust_app_session *ua_sess;
 	struct ust_app_channel *ua_chan;
 
-	if (usess == NULL || uchan == NULL) {
-		ERR("Disabling UST global channel with NULL values");
-		ret = -1;
-		goto error;
-	}
-
+	assert(usess->active);
 	DBG2("UST app disabling channel %s from global domain for session id %" PRIu64,
 			uchan->name, usess->id);
 
@@ -4048,8 +3982,6 @@ int ust_app_disable_channel_glb(struct ltt_ust_session *usess,
 	}
 
 	rcu_read_unlock();
-
-error:
 	return ret;
 }
 
@@ -4064,12 +3996,7 @@ int ust_app_enable_channel_glb(struct ltt_ust_session *usess,
 	struct ust_app *app;
 	struct ust_app_session *ua_sess;
 
-	if (usess == NULL || uchan == NULL) {
-		ERR("Adding UST global channel to NULL values");
-		ret = -1;
-		goto error;
-	}
-
+	assert(usess->active);
 	DBG2("UST app enabling channel %s to global domain for session id %" PRIu64,
 			uchan->name, usess->id);
 
@@ -4098,8 +4025,6 @@ int ust_app_enable_channel_glb(struct ltt_ust_session *usess,
 	}
 
 	rcu_read_unlock();
-
-error:
 	return ret;
 }
 
@@ -4117,6 +4042,7 @@ int ust_app_disable_event_glb(struct ltt_ust_session *usess,
 	struct ust_app_channel *ua_chan;
 	struct ust_app_event *ua_event;
 
+	assert(usess->active);
 	DBG("UST app disabling event %s for all apps in channel "
 			"%s for session id %" PRIu64,
 			uevent->attr.name, uchan->name, usess->id);
@@ -4165,107 +4091,77 @@ int ust_app_disable_event_glb(struct ltt_ust_session *usess,
 	}
 
 	rcu_read_unlock();
-
 	return ret;
 }
 
-/*
- * For a specific UST session, create the channel for all registered apps.
- */
-int ust_app_create_channel_glb(struct ltt_ust_session *usess,
-		struct ltt_ust_channel *uchan)
+/* The ua_sess lock must be held by the caller.  */
+static
+int ust_app_channel_create(struct ltt_ust_session *usess,
+		struct ust_app_session *ua_sess,
+		struct ltt_ust_channel *uchan, struct ust_app *app,
+		struct ust_app_channel **_ua_chan)
 {
-	int ret = 0, created;
-	struct lttng_ht_iter iter;
-	struct ust_app *app;
-	struct ust_app_session *ua_sess = NULL;
-
-	/* Very wrong code flow */
-	assert(usess);
-	assert(uchan);
-
-	DBG2("UST app adding channel %s to UST domain for session id %" PRIu64,
-			uchan->name, usess->id);
+	int ret = 0;
+	struct ust_app_channel *ua_chan = NULL;
 
-	rcu_read_lock();
+	assert(ua_sess);
+	ASSERT_LOCKED(ua_sess->lock);
 
-	/* For every registered applications */
-	cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
-		if (!app->compatible) {
-			/*
-			 * TODO: In time, we should notice the caller of this error by
-			 * telling him that this is a version error.
-			 */
-			continue;
-		}
-		if (!trace_ust_pid_tracker_lookup(usess, app->pid)) {
-			/* Skip. */
-			continue;
-		}
+	if (!strncmp(uchan->name, DEFAULT_METADATA_NAME,
+		     sizeof(uchan->name))) {
+		copy_channel_attr_to_ustctl(&ua_sess->metadata_attr,
+			&uchan->attr);
+		ret = 0;
+	} else {
+		struct ltt_ust_context *uctx = NULL;
 
 		/*
-		 * Create session on the tracer side and add it to app session HT. Note
-		 * that if session exist, it will simply return a pointer to the ust
-		 * app session.
+		 * Create channel onto application and synchronize its
+		 * configuration.
 		 */
-		ret = find_or_create_ust_app_session(usess, app, &ua_sess, &created);
-		if (ret < 0) {
-			switch (ret) {
-			case -ENOTCONN:
-				/*
-				 * The application's socket is not valid. Either a bad socket
-				 * or a timeout on it. We can't inform the caller that for a
-				 * specific app, the session failed so lets continue here.
-				 */
-				ret = 0;	/* Not an error. */
-				continue;
-			case -ENOMEM:
-			default:
-				goto error_rcu_unlock;
-			}
-		}
-		assert(ua_sess);
-
-		pthread_mutex_lock(&ua_sess->lock);
-
-		if (ua_sess->deleted) {
-			pthread_mutex_unlock(&ua_sess->lock);
-			continue;
-		}
-
-		if (!strncmp(uchan->name, DEFAULT_METADATA_NAME,
-					sizeof(uchan->name))) {
-			copy_channel_attr_to_ustctl(&ua_sess->metadata_attr, &uchan->attr);
-			ret = 0;
+		ret = ust_app_channel_allocate(ua_sess, uchan,
+			LTTNG_UST_CHAN_PER_CPU, usess,
+			&ua_chan);
+		if (ret == 0) {
+			ret = ust_app_channel_send(app, usess,
+				ua_sess, ua_chan);
 		} else {
-			/* Create channel onto application. We don't need the chan ref. */
-			ret = create_ust_app_channel(ua_sess, uchan, app,
-					LTTNG_UST_CHAN_PER_CPU, usess, NULL);
+			goto end;
 		}
-		pthread_mutex_unlock(&ua_sess->lock);
-		if (ret < 0) {
-			/* Cleanup the created session if it's the case. */
-			if (created) {
-				destroy_app_session(app, ua_sess);
-			}
-			switch (ret) {
-			case -ENOTCONN:
-				/*
-				 * The application's socket is not valid. Either a bad socket
-				 * or a timeout on it. We can't inform the caller that for a
-				 * specific app, the session failed so lets continue here.
-				 */
-				ret = 0;	/* Not an error. */
-				continue;
-			case -ENOMEM:
-			default:
-				goto error_rcu_unlock;
+
+		/* Add contexts. */
+		cds_list_for_each_entry(uctx, &uchan->ctx_list, list) {
+			ret = create_ust_app_channel_context(ua_chan,
+				&uctx->ctx, app);
+			if (ret) {
+				goto end;
 			}
 		}
 	}
-
-error_rcu_unlock:
-	rcu_read_unlock();
+	if (ret < 0) {
+		switch (ret) {
+		case -ENOTCONN:
+			/*
+			 * The application's socket is not valid. Either a bad socket
+			 * or a timeout on it. We can't inform the caller that for a
+			 * specific app, the session failed so lets continue here.
+			 */
+			ret = 0;	/* Not an error. */
+			break;
+		case -ENOMEM:
+		default:
+			break;
+		}
+	}
+end:
+	if (ret == 0 && _ua_chan) {
+		/*
+		 * Only return the application's channel on success. Note
+		 * that the channel can still be part of the application's
+		 * channel hashtable on error.
+		 */
+		*_ua_chan = ua_chan;
+	}
 	return ret;
 }
 
@@ -4283,6 +4179,7 @@ int ust_app_enable_event_glb(struct ltt_ust_session *usess,
 	struct ust_app_channel *ua_chan;
 	struct ust_app_event *ua_event;
 
+	assert(usess->active);
 	DBG("UST app enabling event %s for all apps for session id %" PRIu64,
 			uevent->attr.name, usess->id);
 
@@ -4368,6 +4265,7 @@ int ust_app_create_event_glb(struct ltt_ust_session *usess,
 	struct ust_app_session *ua_sess;
 	struct ust_app_channel *ua_chan;
 
+	assert(usess->active);
 	DBG("UST app creating event %s for all apps for session id %" PRIu64,
 			uevent->attr.name, usess->id);
 
@@ -4417,7 +4315,6 @@ int ust_app_create_event_glb(struct ltt_ust_session *usess,
 	}
 
 	rcu_read_unlock();
-
 	return ret;
 }
 
@@ -4454,48 +4351,16 @@ int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
 		goto end;
 	}
 
+	if (ua_sess->enabled) {
+		pthread_mutex_unlock(&ua_sess->lock);
+		goto end;
+	}
+
 	/* Upon restart, we skip the setup, already done */
 	if (ua_sess->started) {
 		goto skip_setup;
 	}
 
-	/* Create directories if consumer is LOCAL and has a path defined. */
-	if (usess->consumer->type == CONSUMER_DST_LOCAL &&
-			usess->consumer->dst.session_root_path[0] != '\0') {
-		char *tmp_path;
-
-		tmp_path = zmalloc(LTTNG_PATH_MAX);
-		if (!tmp_path) {
-			ERR("Alloc tmp_path");
-			goto error_unlock;
-		}
-		ret = snprintf(tmp_path, LTTNG_PATH_MAX, "%s%s%s",
-				usess->consumer->dst.session_root_path,
-				usess->consumer->chunk_path,
-				usess->consumer->subdir);
-		if (ret >= LTTNG_PATH_MAX) {
-			ERR("Local destination path exceeds the maximal allowed length of %i bytes (needs %i bytes) with path = \"%s%s%s\"",
-					LTTNG_PATH_MAX, ret,
-					usess->consumer->dst.session_root_path,
-					usess->consumer->chunk_path,
-					usess->consumer->subdir);
-			free(tmp_path);
-			goto error_unlock;
-		}
-
-		DBG("Creating directory path for local tracing: \"%s\"",
-				tmp_path);
-		ret = run_as_mkdir_recursive(tmp_path, S_IRWXU | S_IRWXG,
-				ua_sess->euid, ua_sess->egid);
-		free(tmp_path);
-		if (ret < 0) {
-			if (errno != EEXIST) {
-				ERR("Trace directory creation error");
-				goto error_unlock;
-			}
-		}
-	}
-
 	/*
 	 * Create the metadata for the application. This returns gracefully if a
 	 * metadata was already set for the session.
@@ -4508,7 +4373,7 @@ int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
 	health_code_update();
 
 skip_setup:
-	/* This start the UST tracing */
+	/* This starts the UST tracing */
 	pthread_mutex_lock(&app->sock_lock);
 	ret = ustctl_start_session(app->sock, ua_sess->handle);
 	pthread_mutex_unlock(&app->sock_lock);
@@ -4531,6 +4396,7 @@ skip_setup:
 
 	/* Indicate that the session has been started once */
 	ua_sess->started = 1;
+	ua_sess->enabled = 1;
 
 	pthread_mutex_unlock(&ua_sess->lock);
 
@@ -4620,6 +4486,7 @@ int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app)
 	}
 
 	health_code_update();
+	ua_sess->enabled = 0;
 
 	/* Quiescent wait after stopping trace */
 	pthread_mutex_lock(&app->sock_lock);
@@ -4990,12 +4857,17 @@ end:
  */
 int ust_app_start_trace_all(struct ltt_ust_session *usess)
 {
-	int ret = 0;
 	struct lttng_ht_iter iter;
 	struct ust_app *app;
 
 	DBG("Starting all UST traces");
 
+	/*
+	 * Even though the start trace might fail, flag this session active so
+	 * other application coming in are started by default.
+	 */
+	usess->active = 1;
+
 	rcu_read_lock();
 
 	/*
@@ -5007,11 +4879,7 @@ int ust_app_start_trace_all(struct ltt_ust_session *usess)
 	(void) ust_app_clear_quiescent_session(usess);
 
 	cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
-		ret = ust_app_start_trace(usess, app);
-		if (ret < 0) {
-			/* Continue to next apps even on error */
-			continue;
-		}
+		ust_app_global_update(usess, app);
 	}
 
 	rcu_read_unlock();
@@ -5031,6 +4899,12 @@ int ust_app_stop_trace_all(struct ltt_ust_session *usess)
 
 	DBG("Stopping all UST traces");
 
+	/*
+	 * Even though the stop trace might fail, flag this session inactive so
+	 * other application coming in are not started by default.
+	 */
+	usess->active = 0;
+
 	rcu_read_lock();
 
 	cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
@@ -5074,92 +4948,147 @@ int ust_app_destroy_trace_all(struct ltt_ust_session *usess)
 	return 0;
 }
 
+/* The ua_sess lock must be held by the caller. */
 static
-void ust_app_global_create(struct ltt_ust_session *usess, struct ust_app *app)
+int find_or_create_ust_app_channel(
+		struct ltt_ust_session *usess,
+		struct ust_app_session *ua_sess,
+		struct ust_app *app,
+		struct ltt_ust_channel *uchan,
+		struct ust_app_channel **ua_chan)
 {
 	int ret = 0;
-	struct lttng_ht_iter iter, uiter;
+	struct lttng_ht_iter iter;
+	struct lttng_ht_node_str *ua_chan_node;
+
+	lttng_ht_lookup(ua_sess->channels, (void *) uchan->name, &iter);
+	ua_chan_node = lttng_ht_iter_get_node_str(&iter);
+	if (ua_chan_node) {
+		*ua_chan = caa_container_of(ua_chan_node,
+			struct ust_app_channel, node);
+		goto end;
+	}
+
+	ret = ust_app_channel_create(usess, ua_sess, uchan, app, ua_chan);
+	if (ret) {
+		goto end;
+	}
+end:
+	return ret;
+}
+
+static
+int ust_app_channel_synchronize_event(struct ust_app_channel *ua_chan,
+		struct ltt_ust_event *uevent, struct ust_app_session *ua_sess,
+		struct ust_app *app)
+{
+	int ret = 0;
+	struct ust_app_event *ua_event = NULL;
+
+	ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
+		uevent->filter, uevent->attr.loglevel, uevent->exclusion);
+	if (!ua_event) {
+		ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
+		if (ret < 0) {
+			goto end;
+		}
+	} else {
+		if (ua_event->enabled != uevent->enabled) {
+			ret = uevent->enabled ?
+				enable_ust_app_event(ua_sess, ua_event, app) :
+				disable_ust_app_event(ua_sess, ua_event, app);
+		}
+	}
+
+end:
+	return ret;
+}
+
+/*
+ * The caller must ensure that the application is compatible and is tracked
+ * by the PID tracker.
+ */
+static
+void ust_app_synchronize(struct ltt_ust_session *usess,
+		struct ust_app *app)
+{
+	int ret = 0;
+	struct cds_lfht_iter uchan_iter;
+	struct ltt_ust_channel *uchan;
 	struct ust_app_session *ua_sess = NULL;
-	struct ust_app_channel *ua_chan;
-	struct ust_app_event *ua_event;
-	struct ust_app_ctx *ua_ctx;
-	int is_created = 0;
 
-	ret = find_or_create_ust_app_session(usess, app, &ua_sess, &is_created);
+	/*
+	 * The application's configuration should only be synchronized for
+	 * active sessions.
+	 */
+	assert(usess->active);
+
+	ret = find_or_create_ust_app_session(usess, app, &ua_sess, NULL);
 	if (ret < 0) {
 		/* Tracer is probably gone or ENOMEM. */
 		goto error;
 	}
-	if (!is_created) {
-		/* App session already created. */
-		goto end;
-	}
 	assert(ua_sess);
 
 	pthread_mutex_lock(&ua_sess->lock);
-
 	if (ua_sess->deleted) {
 		pthread_mutex_unlock(&ua_sess->lock);
 		goto end;
 	}
 
-	/*
-	 * We can iterate safely here over all UST app session since the create ust
-	 * app session above made a shadow copy of the UST global domain from the
-	 * ltt ust session.
-	 */
-	cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
-			node.node) {
-		ret = do_create_channel(app, usess, ua_sess, ua_chan);
-		if (ret < 0 && ret != -ENOTCONN) {
-			/*
-			 * Stop everything. On error, the application
-			 * failed, no more file descriptor are available
-			 * or ENOMEM so stopping here is the only thing
-			 * we can do for now. The only exception is
-			 * -ENOTCONN, which indicates that the application
-			 * has exit.
-			 */
-			goto error_unlock;
-		}
+	rcu_read_lock();
+	cds_lfht_for_each_entry(usess->domain_global.channels->ht, &uchan_iter,
+			uchan, node.node) {
+		struct ust_app_channel *ua_chan;
+		struct cds_lfht_iter uevent_iter;
+		struct ltt_ust_event *uevent;
 
 		/*
-		 * Add context using the list so they are enabled in the same order the
-		 * user added them.
+		 * Search for a matching ust_app_channel. If none is found,
+		 * create it. Creating the channel will cause the ua_chan
+		 * structure to be allocated, the channel buffers to be
+		 * allocated (if necessary) and sent to the application, and
+		 * all enabled contexts will be added to the channel.
 		 */
-		cds_list_for_each_entry(ua_ctx, &ua_chan->ctx_list, list) {
-			ret = create_ust_channel_context(ua_chan, ua_ctx, app);
-			if (ret < 0) {
-				goto error_unlock;
-			}
+	        ret = find_or_create_ust_app_channel(usess, ua_sess,
+			app, uchan, &ua_chan);
+		if (ret) {
+			/* Tracer is probably gone or ENOMEM. */
+			goto error_unlock;
 		}
 
+		if (!ua_chan) {
+			/* ua_chan will be NULL for the metadata channel */
+			continue;
+		}
 
-		/* For each events */
-		cds_lfht_for_each_entry(ua_chan->events->ht, &uiter.iter, ua_event,
+		cds_lfht_for_each_entry(uchan->events->ht, &uevent_iter, uevent,
 				node.node) {
-			ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
-			if (ret < 0) {
+			ret = ust_app_channel_synchronize_event(ua_chan,
+				uevent, ua_sess, app);
+			if (ret) {
 				goto error_unlock;
 			}
 		}
-	}
 
-	pthread_mutex_unlock(&ua_sess->lock);
-
-	if (usess->active) {
-		ret = ust_app_start_trace(usess, app);
-		if (ret < 0) {
-			goto error;
+		if (ua_chan->enabled != uchan->enabled) {
+			ret = uchan->enabled ?
+				enable_ust_app_channel(ua_sess, uchan, app) :
+				disable_ust_app_channel(ua_sess, ua_chan, app);
+			if (ret) {
+				goto error_unlock;
+			}
 		}
-
-		DBG2("UST trace started for app pid %d", app->pid);
 	}
+	rcu_read_unlock();
+
 end:
+	pthread_mutex_unlock(&ua_sess->lock);
 	/* Everything went well at this point. */
 	return;
 
 error_unlock:
+	rcu_read_unlock();
 	pthread_mutex_unlock(&ua_sess->lock);
 error:
 	if (ua_sess) {
@@ -5189,6 +5118,7 @@ void ust_app_global_destroy(struct ltt_ust_session *usess, struct ust_app *app)
 void ust_app_global_update(struct ltt_ust_session *usess, struct ust_app *app)
 {
 	assert(usess);
+	assert(usess->active);
 
 	DBG2("UST app global update for app sock %d for session id %" PRIu64,
 			app->sock, usess->id);
@@ -5196,9 +5126,17 @@ void ust_app_global_update(struct ltt_ust_session *usess, struct ust_app *app)
 	if (!app->compatible) {
 		return;
 	}
-
-	if (trace_ust_pid_tracker_lookup(usess, app->pid)) {
-		ust_app_global_create(usess, app);
+	if (trace_ust_id_tracker_lookup(LTTNG_TRACKER_VPID, usess, app->pid) &&
+			trace_ust_id_tracker_lookup(
+					LTTNG_TRACKER_VUID, usess, app->uid) &&
+			trace_ust_id_tracker_lookup(
+					LTTNG_TRACKER_VGID, usess, app->gid)) {
+		/*
+		 * Synchronize the application's internal tracing configuration
+		 * and start tracing.
+		 */
+		ust_app_synchronize(usess, app);
+		ust_app_start_trace(usess, app);
 	} else {
 		ust_app_global_destroy(usess, app);
 	}
@@ -5232,8 +5170,9 @@ int ust_app_add_ctx_channel_glb(struct ltt_ust_session *usess,
 	struct ust_app_session *ua_sess;
 	struct ust_app *app;
 
-	rcu_read_lock();
+	assert(usess->active);
 
+	rcu_read_lock();
 	cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
 		if (!app->compatible) {
 			/*
@@ -5274,79 +5213,6 @@ int ust_app_add_ctx_channel_glb(struct ltt_ust_session *usess,
 	return ret;
 }
 
-/*
- * Enable event for a channel from a UST session for a specific PID.
- */
-int ust_app_enable_event_pid(struct ltt_ust_session *usess,
-		struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
-{
-	int ret = 0;
-	struct lttng_ht_iter iter;
-	struct lttng_ht_node_str *ua_chan_node;
-	struct ust_app *app;
-	struct ust_app_session *ua_sess;
-	struct ust_app_channel *ua_chan;
-	struct ust_app_event *ua_event;
-
-	DBG("UST app enabling event %s for PID %d", uevent->attr.name, pid);
-
-	rcu_read_lock();
-
-	app = ust_app_find_by_pid(pid);
-	if (app == NULL) {
-		ERR("UST app enable event per PID %d not found", pid);
-		ret = -1;
-		goto end;
-	}
-
-	if (!app->compatible) {
-		ret = 0;
-		goto end;
-	}
-
-	ua_sess = lookup_session_by_app(usess, app);
-	if (!ua_sess) {
-		/* The application has problem or is probably dead. */
-		ret = 0;
-		goto end;
-	}
-
-	pthread_mutex_lock(&ua_sess->lock);
-
-	if (ua_sess->deleted) {
-		ret = 0;
-		goto end_unlock;
-	}
-
-	/* Lookup channel in the ust app session */
-	lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
-	ua_chan_node = lttng_ht_iter_get_node_str(&iter);
-	/* If the channel is not found, there is a code flow error */
-	assert(ua_chan_node);
-
-	ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
-
-	ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
-			uevent->filter, uevent->attr.loglevel, uevent->exclusion);
-	if (ua_event == NULL) {
-		ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
-		if (ret < 0) {
-			goto end_unlock;
-		}
-	} else {
-		ret = enable_ust_app_event(ua_sess, ua_event, app);
-		if (ret < 0) {
-			goto end_unlock;
-		}
-	}
-
-end_unlock:
-	pthread_mutex_unlock(&ua_sess->lock);
-end:
-	rcu_read_unlock();
-	return ret;
-}
-
 /*
  * Receive registration and populate the given msg structure.
  *
@@ -5976,29 +5842,22 @@ void ust_app_destroy(struct ust_app *app)
  *
  * Returns LTTNG_OK on success or a LTTNG_ERR error code.
  */
-enum lttng_error_code ust_app_snapshot_record(struct ltt_ust_session *usess,
-		struct snapshot_output *output, int wait,
+enum lttng_error_code ust_app_snapshot_record(
+		const struct ltt_ust_session *usess,
+		const struct consumer_output *output, int wait,
 		uint64_t nb_packets_per_stream)
 {
 	int ret = 0;
 	enum lttng_error_code status = LTTNG_OK;
 	struct lttng_ht_iter iter;
 	struct ust_app *app;
-	char pathname[PATH_MAX];
-	struct ltt_session *session = NULL;
-	uint64_t trace_archive_id;
+	char *trace_path = NULL;
 
 	assert(usess);
 	assert(output);
 
 	rcu_read_lock();
 
-	session = session_find_by_id(usess->id);
-	assert(session);
-	assert(pthread_mutex_trylock(&session->lock));
-	assert(session_trylock_list());
-	trace_archive_id = session->current_archive_id;
-
 	switch (usess->buffer_type) {
 	case LTTNG_BUFFER_PER_UID:
 	{
@@ -6007,6 +5866,8 @@ enum lttng_error_code ust_app_snapshot_record(struct ltt_ust_session *usess,
 		cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
 			struct buffer_reg_channel *reg_chan;
 			struct consumer_socket *socket;
+			char pathname[PATH_MAX];
+			size_t consumer_path_offset = 0;
 
 			if (!reg->registry->reg.ust->metadata_key) {
 				/* Skip since no metadata is present */
@@ -6030,24 +5891,30 @@ enum lttng_error_code ust_app_snapshot_record(struct ltt_ust_session *usess,
 				status = LTTNG_ERR_INVALID;
 				goto error;
 			}
-
-			/* Add the UST default trace dir to path. */
+			/* Free path allowed on previous iteration. */
+			free(trace_path);
+			trace_path = setup_channel_trace_path(usess->consumer, pathname,
+						&consumer_path_offset);
+			if (!trace_path) {
+				status = LTTNG_ERR_INVALID;
+				goto error;
+			}
+                        /* Add the UST default trace dir to path. */
 			cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
 					reg_chan, node.node) {
 				status = consumer_snapshot_channel(socket,
 						reg_chan->consumer_key,
 						output, 0, usess->uid,
-						usess->gid, pathname, wait,
-						nb_packets_per_stream,
-						trace_archive_id);
+						usess->gid, &trace_path[consumer_path_offset], wait,
+						nb_packets_per_stream);
 				if (status != LTTNG_OK) {
 					goto error;
 				}
 			}
 			status = consumer_snapshot_channel(socket,
 					reg->registry->reg.ust->metadata_key, output, 1,
-					usess->uid, usess->gid, pathname, wait, 0,
-					trace_archive_id);
+					usess->uid, usess->gid, &trace_path[consumer_path_offset],
+					wait, 0);
 			if (status != LTTNG_OK) {
 				goto error;
 			}
@@ -6062,6 +5929,8 @@ enum lttng_error_code ust_app_snapshot_record(struct ltt_ust_session *usess,
 			struct ust_app_channel *ua_chan;
 			struct ust_app_session *ua_sess;
 			struct ust_registry_session *registry;
+			char pathname[PATH_MAX];
+			size_t consumer_path_offset = 0;
 
 			ua_sess = lookup_session_by_app(usess, app);
 			if (!ua_sess) {
@@ -6071,7 +5940,7 @@ enum lttng_error_code ust_app_snapshot_record(struct ltt_ust_session *usess,
 
 			/* Get the right consumer socket for the application. */
 			socket = consumer_find_socket_by_bitness(app->bits_per_long,
-					output->consumer);
+					output);
 			if (!socket) {
 				status = LTTNG_ERR_INVALID;
 				goto error;
@@ -6086,15 +5955,24 @@ enum lttng_error_code ust_app_snapshot_record(struct ltt_ust_session *usess,
 				PERROR("snprintf snapshot path");
 				goto error;
 			}
-
-			cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
+			/* Free path allowed on previous iteration. */
+			free(trace_path);
+			trace_path = setup_channel_trace_path(usess->consumer, pathname,
+					&consumer_path_offset);
+			if (!trace_path) {
+				status = LTTNG_ERR_INVALID;
+				goto error;
+			}
+                        cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
 					ua_chan, node.node) {
 				status = consumer_snapshot_channel(socket,
-						ua_chan->key, output,
-						0, ua_sess->euid, ua_sess->egid,
-						pathname, wait,
-						nb_packets_per_stream,
-						trace_archive_id);
+						ua_chan->key, output, 0,
+						ua_sess->effective_credentials
+								.uid,
+						ua_sess->effective_credentials
+								.gid,
+						&trace_path[consumer_path_offset], wait,
+						nb_packets_per_stream);
 				switch (status) {
 				case LTTNG_OK:
 					break;
@@ -6111,10 +5989,10 @@ enum lttng_error_code ust_app_snapshot_record(struct ltt_ust_session *usess,
 				continue;
 			}
 			status = consumer_snapshot_channel(socket,
-					registry->metadata_key, output,
-					1, ua_sess->euid, ua_sess->egid,
-					pathname, wait, 0,
-					trace_archive_id);
+					registry->metadata_key, output, 1,
+					ua_sess->effective_credentials.uid,
+					ua_sess->effective_credentials.gid,
+					&trace_path[consumer_path_offset], wait, 0);
 			switch (status) {
 			case LTTNG_OK:
 				break;
@@ -6132,18 +6010,16 @@ enum lttng_error_code ust_app_snapshot_record(struct ltt_ust_session *usess,
 	}
 
 error:
+	free(trace_path);
 	rcu_read_unlock();
-	if (session) {
-		session_put(session);
-	}
 	return status;
 }
 
 /*
  * Return the size taken by one more packet per stream.
  */
-uint64_t ust_app_get_size_one_more_packet_per_stream(struct ltt_ust_session *usess,
-		uint64_t cur_nr_packets)
+uint64_t ust_app_get_size_one_more_packet_per_stream(
+		const struct ltt_ust_session *usess, uint64_t cur_nr_packets)
 {
 	uint64_t tot_size = 0;
 	struct ust_app *app;
@@ -6382,7 +6258,6 @@ enum lttng_error_code ust_app_rotate_session(struct ltt_session *session)
 	struct lttng_ht_iter iter;
 	struct ust_app *app;
 	struct ltt_ust_session *usess = session->ust_session;
-	char pathname[LTTNG_PATH_MAX];
 
 	assert(usess);
 
@@ -6397,6 +6272,11 @@ enum lttng_error_code ust_app_rotate_session(struct ltt_session *session)
 			struct buffer_reg_channel *reg_chan;
 			struct consumer_socket *socket;
 
+			if (!reg->registry->reg.ust->metadata_key) {
+				/* Skip since no metadata is present */
+				continue;
+			}
+
 			/* Get consumer socket to use to push the metadata.*/
 			socket = consumer_find_socket_by_bitness(reg->bits_per_long,
 					usess->consumer);
@@ -6405,24 +6285,14 @@ enum lttng_error_code ust_app_rotate_session(struct ltt_session *session)
 				goto error;
 			}
 
-			ret = snprintf(pathname, sizeof(pathname),
-					DEFAULT_UST_TRACE_DIR "/" DEFAULT_UST_TRACE_UID_PATH,
-					reg->uid, reg->bits_per_long);
-			if (ret < 0 || ret == sizeof(pathname)) {
-				PERROR("Failed to format rotation path");
-				cmd_ret = LTTNG_ERR_INVALID;
-				goto error;
-			}
-
 			/* Rotate the data channels. */
 			cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
 					reg_chan, node.node) {
 				ret = consumer_rotate_channel(socket,
 						reg_chan->consumer_key,
 						usess->uid, usess->gid,
-						usess->consumer, pathname,
-						/* is_metadata_channel */ false,
-						session->current_archive_id);
+						usess->consumer,
+						/* is_metadata_channel */ false);
 				if (ret < 0) {
 					cmd_ret = LTTNG_ERR_ROTATION_FAIL_CONSUMER;
 					goto error;
@@ -6434,9 +6304,8 @@ enum lttng_error_code ust_app_rotate_session(struct ltt_session *session)
 			ret = consumer_rotate_channel(socket,
 					reg->registry->reg.ust->metadata_key,
 					usess->uid, usess->gid,
-					usess->consumer, pathname,
-					/* is_metadata_channel */ true,
-					session->current_archive_id);
+					usess->consumer,
+					/* is_metadata_channel */ true);
 			if (ret < 0) {
 				cmd_ret = LTTNG_ERR_ROTATION_FAIL_CONSUMER;
 				goto error;
@@ -6458,14 +6327,6 @@ enum lttng_error_code ust_app_rotate_session(struct ltt_session *session)
 				/* Session not associated with this app. */
 				continue;
 			}
-			ret = snprintf(pathname, sizeof(pathname),
-					DEFAULT_UST_TRACE_DIR "/%s",
-					ua_sess->path);
-			if (ret < 0 || ret == sizeof(pathname)) {
-				PERROR("Failed to format rotation path");
-				cmd_ret = LTTNG_ERR_INVALID;
-				goto error;
-			}
 
 			/* Get the right consumer socket for the application. */
 			socket = consumer_find_socket_by_bitness(app->bits_per_long,
@@ -6481,15 +6342,17 @@ enum lttng_error_code ust_app_rotate_session(struct ltt_session *session)
 				continue;
 			}
 
-
 			/* Rotate the data channels. */
 			cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
 					ua_chan, node.node) {
-				ret = consumer_rotate_channel(socket, ua_chan->key,
-						ua_sess->euid, ua_sess->egid,
-						ua_sess->consumer, pathname,
-						/* is_metadata_channel */ false,
-						session->current_archive_id);
+				ret = consumer_rotate_channel(socket,
+						ua_chan->key,
+						ua_sess->effective_credentials
+								.uid,
+						ua_sess->effective_credentials
+								.gid,
+						ua_sess->consumer,
+						/* is_metadata_channel */ false);
 				if (ret < 0) {
 					/* Per-PID buffer and application going away. */
 					if (ret == -LTTNG_ERR_CHAN_NOT_FOUND)
@@ -6501,11 +6364,12 @@ enum lttng_error_code ust_app_rotate_session(struct ltt_session *session)
 
 			/* Rotate the metadata channel. */
 			(void) push_metadata(registry, usess->consumer);
-			ret = consumer_rotate_channel(socket, registry->metadata_key,
-					ua_sess->euid, ua_sess->egid,
-					ua_sess->consumer, pathname,
-					/* is_metadata_channel */ true,
-					session->current_archive_id);
+			ret = consumer_rotate_channel(socket,
+					registry->metadata_key,
+					ua_sess->effective_credentials.uid,
+					ua_sess->effective_credentials.gid,
+					ua_sess->consumer,
+					/* is_metadata_channel */ true);
 			if (ret < 0) {
 				/* Per-PID buffer and application going away. */
 				if (ret == -LTTNG_ERR_CHAN_NOT_FOUND)
@@ -6527,3 +6391,258 @@ error:
 	rcu_read_unlock();
 	return cmd_ret;
 }
+
+enum lttng_error_code ust_app_create_channel_subdirectories(
+		const struct ltt_ust_session *usess)
+{
+	enum lttng_error_code ret = LTTNG_OK;
+	struct lttng_ht_iter iter;
+	enum lttng_trace_chunk_status chunk_status;
+	char *pathname_index;
+	int fmt_ret;
+
+	assert(usess->current_trace_chunk);
+	rcu_read_lock();
+
+	switch (usess->buffer_type) {
+	case LTTNG_BUFFER_PER_UID:
+	{
+		struct buffer_reg_uid *reg;
+
+		cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
+			fmt_ret = asprintf(&pathname_index,
+				       DEFAULT_UST_TRACE_DIR "/" DEFAULT_UST_TRACE_UID_PATH "/" DEFAULT_INDEX_DIR,
+				       reg->uid, reg->bits_per_long);
+			if (fmt_ret < 0) {
+				ERR("Failed to format channel index directory");
+				ret = LTTNG_ERR_CREATE_DIR_FAIL;
+				goto error;
+			}
+
+			/*
+			 * Create the index subdirectory which will take care
+			 * of implicitly creating the channel's path.
+			 */
+			chunk_status = lttng_trace_chunk_create_subdirectory(
+					usess->current_trace_chunk,
+					pathname_index);
+			free(pathname_index);
+			if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
+				ret = LTTNG_ERR_CREATE_DIR_FAIL;
+				goto error;
+			}
+		}
+		break;
+	}
+	case LTTNG_BUFFER_PER_PID:
+	{
+		struct ust_app *app;
+
+		/*
+		 * Create the toplevel ust/ directory in case no apps are running.
+		 */
+		chunk_status = lttng_trace_chunk_create_subdirectory(
+				usess->current_trace_chunk,
+				DEFAULT_UST_TRACE_DIR);
+		if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
+			ret = LTTNG_ERR_CREATE_DIR_FAIL;
+			goto error;
+		}
+
+		cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app,
+				pid_n.node) {
+			struct ust_app_session *ua_sess;
+			struct ust_registry_session *registry;
+
+			ua_sess = lookup_session_by_app(usess, app);
+			if (!ua_sess) {
+				/* Session not associated with this app. */
+				continue;
+			}
+
+			registry = get_session_registry(ua_sess);
+			if (!registry) {
+				DBG("Application session is being torn down. Skip application.");
+				continue;
+			}
+
+			fmt_ret = asprintf(&pathname_index,
+					DEFAULT_UST_TRACE_DIR "/%s/" DEFAULT_INDEX_DIR,
+					ua_sess->path);
+			if (fmt_ret < 0) {
+				ERR("Failed to format channel index directory");
+				ret = LTTNG_ERR_CREATE_DIR_FAIL;
+				goto error;
+			}
+			/*
+			 * Create the index subdirectory which will take care
+			 * of implicitly creating the channel's path.
+			 */
+			chunk_status = lttng_trace_chunk_create_subdirectory(
+					usess->current_trace_chunk,
+					pathname_index);
+			free(pathname_index);
+			if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
+				ret = LTTNG_ERR_CREATE_DIR_FAIL;
+				goto error;
+			}
+		}
+		break;
+	}
+	default:
+		abort();
+	}
+
+	ret = LTTNG_OK;
+error:
+	rcu_read_unlock();
+	return ret;
+}
+
+/*
+ * Clear all the channels of a session.
+ *
+ * Return LTTNG_OK on success or else an LTTng error code.
+ */
+enum lttng_error_code ust_app_clear_session(struct ltt_session *session)
+{
+	int ret;
+	enum lttng_error_code cmd_ret = LTTNG_OK;
+	struct lttng_ht_iter iter;
+	struct ust_app *app;
+	struct ltt_ust_session *usess = session->ust_session;
+
+	assert(usess);
+
+	rcu_read_lock();
+
+	if (usess->active) {
+		ERR("Expecting inactive session %s (%" PRIu64 ")", session->name, session->id);
+		cmd_ret = LTTNG_ERR_FATAL;
+		goto end;
+	}
+
+	switch (usess->buffer_type) {
+	case LTTNG_BUFFER_PER_UID:
+	{
+		struct buffer_reg_uid *reg;
+
+		cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) {
+			struct buffer_reg_channel *reg_chan;
+			struct consumer_socket *socket;
+
+			/* Get consumer socket to use to push the metadata.*/
+			socket = consumer_find_socket_by_bitness(reg->bits_per_long,
+					usess->consumer);
+			if (!socket) {
+				cmd_ret = LTTNG_ERR_INVALID;
+				goto error_socket;
+			}
+
+			/* Clear the data channels. */
+			cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter,
+					reg_chan, node.node) {
+				ret = consumer_clear_channel(socket,
+						reg_chan->consumer_key);
+				if (ret < 0) {
+					goto error;
+				}
+			}
+
+			(void) push_metadata(reg->registry->reg.ust, usess->consumer);
+
+			/*
+			 * Clear the metadata channel.
+			 * Metadata channel is not cleared per se but we still need to
+			 * perform a rotation operation on it behind the scene.
+			 */
+			ret = consumer_clear_channel(socket,
+					reg->registry->reg.ust->metadata_key);
+			if (ret < 0) {
+				goto error;
+			}
+		}
+		break;
+	}
+	case LTTNG_BUFFER_PER_PID:
+	{
+		cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
+			struct consumer_socket *socket;
+			struct lttng_ht_iter chan_iter;
+			struct ust_app_channel *ua_chan;
+			struct ust_app_session *ua_sess;
+			struct ust_registry_session *registry;
+
+			ua_sess = lookup_session_by_app(usess, app);
+			if (!ua_sess) {
+				/* Session not associated with this app. */
+				continue;
+			}
+
+			/* Get the right consumer socket for the application. */
+			socket = consumer_find_socket_by_bitness(app->bits_per_long,
+					usess->consumer);
+			if (!socket) {
+				cmd_ret = LTTNG_ERR_INVALID;
+				goto error_socket;
+			}
+
+			registry = get_session_registry(ua_sess);
+			if (!registry) {
+				DBG("Application session is being torn down. Skip application.");
+				continue;
+			}
+
+			/* Clear the data channels. */
+			cds_lfht_for_each_entry(ua_sess->channels->ht, &chan_iter.iter,
+					ua_chan, node.node) {
+				ret = consumer_clear_channel(socket, ua_chan->key);
+				if (ret < 0) {
+					/* Per-PID buffer and application going away. */
+					if (ret == -LTTNG_ERR_CHAN_NOT_FOUND) {
+						continue;
+					}
+					goto error;
+				}
+			}
+
+			(void) push_metadata(registry, usess->consumer);
+
+			/*
+			 * Clear the metadata channel.
+			 * Metadata channel is not cleared per se but we still need to
+			 * perform rotation operation on it behind the scene.
+			 */
+			ret = consumer_clear_channel(socket, registry->metadata_key);
+			if (ret < 0) {
+				/* Per-PID buffer and application going away. */
+				if (ret == -LTTNG_ERR_CHAN_NOT_FOUND) {
+					continue;
+				}
+				goto error;
+			}
+		}
+		break;
+	}
+	default:
+		assert(0);
+		break;
+	}
+
+	cmd_ret = LTTNG_OK;
+	goto end;
+
+error:
+	switch (-ret) {
+	case LTTCOMM_CONSUMERD_RELAYD_CLEAR_DISALLOWED:
+		cmd_ret = LTTNG_ERR_CLEAR_RELAY_DISALLOWED;
+		break;
+	default:
+		cmd_ret = LTTNG_ERR_CLEAR_FAIL_CONSUMER;
+	}
+
+error_socket:
+end:
+	rcu_read_unlock();
+	return cmd_ret;
+}