X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=8e06ce6913875dd85e0a17e0eeafb929ba93d425;hp=50ff1632fb1bc3439e3517cdd66cc5129ed85146;hb=a93b3916055c57baf374c1f566d81f91101daa54;hpb=88f06f1562c6ecd3a5666baa93a57273fbe10437

diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c
index 50ff1632f..8e06ce691 100644
--- a/src/bin/lttng-sessiond/cmd.c
+++ b/src/bin/lttng-sessiond/cmd.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2012 - David Goulet <dgoulet@efficios.com>
+ * Copyright (C) 2016 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License, version 2 only, as
@@ -15,10 +16,8 @@
  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#define _GNU_SOURCE
 #define _LGPL_SOURCE
 #include <assert.h>
-#include <string.h>
 #include <inttypes.h>
 #include <urcu/list.h>
 #include <urcu/uatomic.h>
@@ -28,6 +27,7 @@
 #include <common/sessiond-comm/sessiond-comm.h>
 #include <common/relayd/relayd.h>
 #include <common/utils.h>
+#include <common/compat/string.h>
 
 #include "channel.h"
 #include "consumer.h"
@@ -51,6 +51,16 @@
 static pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER;
 static uint64_t relayd_net_seq_idx;
 
+static int validate_event_name(const char *);
+static int validate_ust_event_name(const char *);
+static int cmd_enable_event_internal(struct ltt_session *session,
+		struct lttng_domain *domain,
+		char *channel_name, struct lttng_event *event,
+		char *filter_expression,
+		struct lttng_filter_bytecode *filter,
+		struct lttng_event_exclusion *exclusion,
+		int wpipe);
+
 /*
  * Create a session path used by list_lttng_sessions for the case that the
  * session consumer is on the network.
@@ -132,8 +142,8 @@ error:
 /*
  * Fill lttng_channel array of all channels.
  */
-static void list_lttng_channels(int domain, struct ltt_session *session,
-		struct lttng_channel *channels)
+static void list_lttng_channels(enum lttng_domain_type domain,
+		struct ltt_session *session, struct lttng_channel *channels)
 {
 	int i = 0;
 	struct ltt_kernel_channel *kchan;
@@ -227,7 +237,7 @@ static int list_lttng_agent_events(struct agent *agt,
 		strncpy(tmp_events[i].name, event->name, sizeof(tmp_events[i].name));
 		tmp_events[i].name[sizeof(tmp_events[i].name) - 1] = '\0';
 		tmp_events[i].enabled = event->enabled;
-		tmp_events[i].loglevel = event->loglevel;
+		tmp_events[i].loglevel = event->loglevel_value;
 		tmp_events[i].loglevel_type = event->loglevel_type;
 		i++;
 	}
@@ -268,8 +278,7 @@ static int list_lttng_ust_global_events(char *channel_name,
 
 	uchan = caa_container_of(&node->node, struct ltt_ust_channel, node.node);
 
-	nb_event += lttng_ht_get_count(uchan->events);
-
+	nb_event = lttng_ht_get_count(uchan->events);
 	if (nb_event == 0) {
 		ret = nb_event;
 		goto error;
@@ -284,6 +293,11 @@ static int list_lttng_ust_global_events(char *channel_name,
 	}
 
 	cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
+		if (uevent->internal) {
+			/* This event should remain hidden from clients */
+			nb_event--;
+			continue;
+		}
 		strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN);
 		tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 		tmp[i].enabled = uevent->enabled;
@@ -366,6 +380,8 @@ static int list_lttng_kernel_events(char *channel_name,
 		strncpy((*events)[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN);
 		(*events)[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 		(*events)[i].enabled = event->enabled;
+		(*events)[i].filter =
+				(unsigned char) !!event->filter_expression;
 
 		switch (event->event->instrumentation) {
 		case LTTNG_KERNEL_TRACEPOINT:
@@ -424,7 +440,8 @@ error:
  * domain adding the default trace directory.
  */
 static int add_uri_to_consumer(struct consumer_output *consumer,
-		struct lttng_uri *uri, int domain, const char *session_name)
+		struct lttng_uri *uri, enum lttng_domain_type domain,
+		const char *session_name)
 {
 	int ret = LTTNG_OK;
 	const char *default_trace_dir;
@@ -621,8 +638,9 @@ error:
 /*
  * Connect to the relayd using URI and send the socket to the right consumer.
  */
-static int send_consumer_relayd_socket(int domain, unsigned int session_id,
-		struct lttng_uri *relayd_uri, struct consumer_output *consumer,
+static int send_consumer_relayd_socket(enum lttng_domain_type domain,
+		unsigned int session_id, struct lttng_uri *relayd_uri,
+		struct consumer_output *consumer,
 		struct consumer_socket *consumer_sock,
 		char *session_name, char *hostname, int session_live_timer)
 {
@@ -692,9 +710,10 @@ error:
  * helper function to facilitate sending the information to the consumer for a
  * session.
  */
-static int send_consumer_relayd_sockets(int domain, unsigned int session_id,
-		struct consumer_output *consumer, struct consumer_socket *sock,
-		char *session_name, char *hostname, int session_live_timer)
+static int send_consumer_relayd_sockets(enum lttng_domain_type domain,
+		unsigned int session_id, struct consumer_output *consumer,
+		struct consumer_socket *sock, char *session_name,
+		char *hostname, int session_live_timer)
 {
 	int ret = LTTNG_OK;
 
@@ -857,8 +876,8 @@ error:
 /*
  * Command LTTNG_DISABLE_CHANNEL processed by the client thread.
  */
-int cmd_disable_channel(struct ltt_session *session, int domain,
-		char *channel_name)
+int cmd_disable_channel(struct ltt_session *session,
+		enum lttng_domain_type domain, char *channel_name)
 {
 	int ret;
 	struct ltt_ust_session *usess;
@@ -915,7 +934,8 @@ error:
  *
  * Called with session lock held.
  */
-int cmd_track_pid(struct ltt_session *session, int domain, int pid)
+int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain,
+		int pid)
 {
 	int ret;
 
@@ -965,7 +985,8 @@ error:
  *
  * Called with session lock held.
  */
-int cmd_untrack_pid(struct ltt_session *session, int domain, int pid)
+int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain,
+		int pid)
 {
 	int ret;
 
@@ -1027,7 +1048,7 @@ int cmd_enable_channel(struct ltt_session *session,
 	assert(attr);
 	assert(domain);
 
-	len = strnlen(attr->name, sizeof(attr->name));
+	len = lttng_strnlen(attr->name, sizeof(attr->name));
 
 	/* Validate channel name */
 	if (attr->name[0] == '.' ||
@@ -1093,9 +1114,40 @@ int cmd_enable_channel(struct ltt_session *session,
 		break;
 	}
 	case LTTNG_DOMAIN_UST:
+	case LTTNG_DOMAIN_JUL:
+	case LTTNG_DOMAIN_LOG4J:
+	case LTTNG_DOMAIN_PYTHON:
 	{
 		struct ltt_ust_channel *uchan;
 
+		/*
+		 * FIXME
+		 *
+		 * Current agent implementation limitations force us to allow
+		 * only one channel at once in "agent" subdomains. Each
+		 * subdomain has a default channel name which must be strictly
+		 * adhered to.
+		 */
+		if (domain->type == LTTNG_DOMAIN_JUL) {
+			if (strncmp(attr->name, DEFAULT_JUL_CHANNEL_NAME,
+					LTTNG_SYMBOL_NAME_LEN)) {
+				ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
+				goto error;
+			}
+		} else if (domain->type == LTTNG_DOMAIN_LOG4J) {
+			if (strncmp(attr->name, DEFAULT_LOG4J_CHANNEL_NAME,
+					LTTNG_SYMBOL_NAME_LEN)) {
+				ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
+				goto error;
+			}
+		} else if (domain->type == LTTNG_DOMAIN_PYTHON) {
+			if (strncmp(attr->name, DEFAULT_PYTHON_CHANNEL_NAME,
+					LTTNG_SYMBOL_NAME_LEN)) {
+				ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
+				goto error;
+			}
+		}
+
 		chan_ht = usess->domain_global.channels;
 
 		uchan = trace_ust_find_channel_by_name(chan_ht, attr->name);
@@ -1123,8 +1175,8 @@ end:
 /*
  * Command LTTNG_DISABLE_EVENT processed by the client thread.
  */
-int cmd_disable_event(struct ltt_session *session, int domain,
-		char *channel_name,
+int cmd_disable_event(struct ltt_session *session,
+		enum lttng_domain_type domain, char *channel_name,
 		struct lttng_event *event)
 {
 	int ret;
@@ -1133,11 +1185,16 @@ int cmd_disable_event(struct ltt_session *session, int domain,
 	DBG("Disable event command for event \'%s\'", event->name);
 
 	event_name = event->name;
+	if (validate_event_name(event_name)) {
+		ret = LTTNG_ERR_INVALID_EVENT_NAME;
+		goto error;
+	}
 
 	/* Error out on unhandled search criteria */
 	if (event->loglevel_type || event->loglevel != -1 || event->enabled
 			|| event->pid || event->filter || event->exclusion) {
-		return LTTNG_ERR_UNK;
+		ret = LTTNG_ERR_UNK;
+		goto error;
 	}
 
 	rcu_read_lock();
@@ -1157,46 +1214,36 @@ int cmd_disable_event(struct ltt_session *session, int domain,
 		 */
 		if (ksess->has_non_default_channel && channel_name[0] == '\0') {
 			ret = LTTNG_ERR_NEED_CHANNEL_NAME;
-			goto error;
+			goto error_unlock;
 		}
 
 		kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
 		if (kchan == NULL) {
 			ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
-			goto error;
+			goto error_unlock;
 		}
 
 		switch (event->type) {
 		case LTTNG_EVENT_ALL:
-			ret = event_kernel_disable_event_all(kchan);
-			if (ret != LTTNG_OK) {
-				goto error;
-			}
-			break;
-		case LTTNG_EVENT_TRACEPOINT:	/* fall-through */
+		case LTTNG_EVENT_TRACEPOINT:
 		case LTTNG_EVENT_SYSCALL:
-			if (!strcmp(event_name, "*")) {
-				ret = event_kernel_disable_event_type(kchan,
-					event->type);
+		case LTTNG_EVENT_PROBE:
+		case LTTNG_EVENT_FUNCTION:
+		case LTTNG_EVENT_FUNCTION_ENTRY:/* fall-through */
+			if (event_name[0] == '\0') {
+				ret = event_kernel_disable_event(kchan,
+					NULL, event->type);
 			} else {
 				ret = event_kernel_disable_event(kchan,
-					event_name);
+					event_name, event->type);
 			}
 			if (ret != LTTNG_OK) {
-				goto error;
-			}
-			break;
-		case LTTNG_EVENT_PROBE:
-		case LTTNG_EVENT_FUNCTION:
-		case LTTNG_EVENT_FUNCTION_ENTRY:
-			ret = event_kernel_disable_event(kchan, event_name);
-			if (ret != LTTNG_OK) {
-				goto error;
+				goto error_unlock;
 			}
 			break;
 		default:
 			ret = LTTNG_ERR_UNK;
-			goto error;
+			goto error_unlock;
 		}
 
 		kernel_wait_quiescent(kernel_tracer_fd);
@@ -1209,33 +1256,47 @@ int cmd_disable_event(struct ltt_session *session, int domain,
 
 		usess = session->ust_session;
 
+		if (validate_ust_event_name(event_name)) {
+			ret = LTTNG_ERR_INVALID_EVENT_NAME;
+			goto error_unlock;
+		}
+
 		/*
 		 * If a non-default channel has been created in the
-		 * session, explicitely require that -c chan_name needs
+		 * session, explicitly require that -c chan_name needs
 		 * to be provided.
 		 */
 		if (usess->has_non_default_channel && channel_name[0] == '\0') {
 			ret = LTTNG_ERR_NEED_CHANNEL_NAME;
-			goto error;
+			goto error_unlock;
 		}
 
 		uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
 				channel_name);
 		if (uchan == NULL) {
 			ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
-			goto error;
+			goto error_unlock;
 		}
 
 		switch (event->type) {
 		case LTTNG_EVENT_ALL:
-			ret = event_ust_disable_tracepoint(usess, uchan, event_name);
+			/*
+			 * An empty event name means that everything
+			 * should be disabled.
+			 */
+			if (event->name[0] == '\0') {
+				ret = event_ust_disable_all_tracepoints(usess, uchan);
+			} else {
+				ret = event_ust_disable_tracepoint(usess, uchan,
+						event_name);
+			}
 			if (ret != LTTNG_OK) {
-				goto error;
+				goto error_unlock;
 			}
 			break;
 		default:
 			ret = LTTNG_ERR_UNK;
-			goto error;
+			goto error_unlock;
 		}
 
 		DBG3("Disable UST event %s in channel %s completed", event_name,
@@ -1256,45 +1317,55 @@ int cmd_disable_event(struct ltt_session *session, int domain,
 			break;
 		default:
 			ret = LTTNG_ERR_UNK;
-			goto error;
+			goto error_unlock;
 		}
 
 		agt = trace_ust_find_agent(usess, domain);
 		if (!agt) {
 			ret = -LTTNG_ERR_UST_EVENT_NOT_FOUND;
-			goto error;
+			goto error_unlock;
 		}
-		/* The wild card * means that everything should be disabled. */
-		if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) {
+		/*
+		 * An empty event name means that everything
+		 * should be disabled.
+		 */
+		if (event->name[0] == '\0') {
 			ret = event_agent_disable_all(usess, agt);
 		} else {
 			ret = event_agent_disable(usess, agt, event_name);
 		}
 		if (ret != LTTNG_OK) {
-			goto error;
+			goto error_unlock;
 		}
 
 		break;
 	}
 	default:
 		ret = LTTNG_ERR_UND;
-		goto error;
+		goto error_unlock;
 	}
 
 	ret = LTTNG_OK;
 
-error:
+error_unlock:
 	rcu_read_unlock();
+error:
 	return ret;
 }
 
 /*
  * Command LTTNG_ADD_CONTEXT processed by the client thread.
  */
-int cmd_add_context(struct ltt_session *session, int domain,
+int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain,
 		char *channel_name, struct lttng_event_context *ctx, int kwpipe)
 {
 	int ret, chan_kern_created = 0, chan_ust_created = 0;
+	char *app_ctx_provider_name = NULL, *app_ctx_name = NULL;
+
+	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;
+	}
 
 	switch (domain) {
 	case LTTNG_DOMAIN_KERNEL:
@@ -1314,6 +1385,29 @@ int cmd_add_context(struct ltt_session *session, int domain,
 			goto error;
 		}
 		break;
+	case LTTNG_DOMAIN_JUL:
+	case LTTNG_DOMAIN_LOG4J:
+	{
+		/*
+		 * Validate channel name.
+		 * If no channel name is given and the domain is JUL or LOG4J,
+		 * set it to the appropriate domain-specific channel name. If
+		 * a name is provided but does not match the expexted channel
+		 * name, return an error.
+		 */
+		if (domain == LTTNG_DOMAIN_JUL && *channel_name &&
+				strcmp(channel_name,
+				DEFAULT_JUL_CHANNEL_NAME)) {
+			ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
+			goto error;
+		} else if (domain == LTTNG_DOMAIN_LOG4J && *channel_name &&
+				strcmp(channel_name,
+				DEFAULT_LOG4J_CHANNEL_NAME)) {
+			ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
+			goto error;
+		}
+		/* break is _not_ missing here. */
+	}
 	case LTTNG_DOMAIN_UST:
 	{
 		struct ltt_ust_session *usess = session->ust_session;
@@ -1341,6 +1435,10 @@ int cmd_add_context(struct ltt_session *session, int domain,
 		}
 
 		ret = context_ust_add(usess, domain, ctx, channel_name);
+		free(app_ctx_provider_name);
+		free(app_ctx_name);
+		app_ctx_name = NULL;
+		app_ctx_provider_name = NULL;
 		if (ret != LTTNG_OK) {
 			goto error;
 		}
@@ -1351,7 +1449,8 @@ int cmd_add_context(struct ltt_session *session, int domain,
 		goto error;
 	}
 
-	return LTTNG_OK;
+	ret = LTTNG_OK;
+	goto end;
 
 error:
 	if (chan_kern_created) {
@@ -1375,6 +1474,9 @@ error:
 				uchan);
 		trace_ust_destroy_channel(uchan);
 	}
+end:
+	free(app_ctx_provider_name);
+	free(app_ctx_name);
 	return ret;
 }
 
@@ -1415,14 +1517,36 @@ end:
 	return ret;
 }
 
+static inline bool name_starts_with(const char *name, const char *prefix)
+{
+	const size_t max_cmp_len = min(strlen(prefix), LTTNG_SYMBOL_NAME_LEN);
 
-static int cmd_enable_event_internal(struct ltt_session *session,
-		struct lttng_domain *domain,
-		char *channel_name, struct lttng_event *event,
-		char *filter_expression,
-		struct lttng_filter_bytecode *filter,
-		struct lttng_event_exclusion *exclusion,
-		int wpipe);
+	return !strncmp(name, prefix, max_cmp_len);
+}
+
+/* Perform userspace-specific event name validation */
+static int validate_ust_event_name(const char *name)
+{
+	int ret = 0;
+
+	if (!name) {
+		ret = -1;
+		goto end;
+	}
+
+	/*
+	 * Check name against all internal UST event component namespaces used
+	 * by the agents.
+	 */
+	if (name_starts_with(name, DEFAULT_JUL_EVENT_COMPONENT) ||
+		name_starts_with(name, DEFAULT_LOG4J_EVENT_COMPONENT) ||
+		name_starts_with(name, DEFAULT_PYTHON_EVENT_COMPONENT)) {
+		ret = -1;
+	}
+
+end:
+	return ret;
+}
 
 /*
  * Internal version of cmd_enable_event() with a supplemental
@@ -1445,15 +1569,18 @@ static int _cmd_enable_event(struct ltt_session *session,
 	assert(event);
 	assert(channel_name);
 
+	/* If we have a filter, we must have its filter expression */
+	assert(!(!!filter_expression ^ !!filter));
+
 	DBG("Enable event command for event \'%s\'", event->name);
 
+	rcu_read_lock();
+
 	ret = validate_event_name(event->name);
 	if (ret) {
 		goto error;
 	}
 
-	rcu_read_lock();
-
 	switch (domain->type) {
 	case LTTNG_DOMAIN_KERNEL:
 	{
@@ -1545,9 +1672,10 @@ static int _cmd_enable_event(struct ltt_session *session,
 			event->type = LTTNG_EVENT_SYSCALL;	/* Hack */
 			ret = event_kernel_enable_event(kchan, event,
 				filter_expression_a, filter_a);
+			/* We have passed ownership */
+			filter_expression_a = NULL;
+			filter_a = NULL;
 			if (ret != LTTNG_OK) {
-				free(filter_expression_a);
-				free(filter_a);
 				goto error;
 			}
 			break;
@@ -1630,6 +1758,31 @@ static int _cmd_enable_event(struct ltt_session *session,
 			assert(uchan);
 		}
 
+		if (uchan->domain != LTTNG_DOMAIN_UST && !internal_event) {
+			/*
+			 * Don't allow users to add UST events to channels which
+			 * are assigned to a userspace subdomain (JUL, Log4J,
+			 * Python, etc.).
+			 */
+			ret = LTTNG_ERR_INVALID_CHANNEL_DOMAIN;
+			goto error;
+		}
+
+		if (!internal_event) {
+			/*
+			 * Ensure the event name is not reserved for internal
+			 * use.
+			 */
+			ret = validate_ust_event_name(event->name);
+			if (ret) {
+			        WARN("Userspace event name %s failed validation.",
+						event->name ?
+						event->name : "NULL");
+				ret = LTTNG_ERR_INVALID_EVENT_NAME;
+				goto error;
+			}
+		}
+
 		/* At this point, the session and channel exist on the tracer */
 		ret = event_ust_enable_tracepoint(usess, uchan, event,
 				filter_expression, filter, exclusion,
@@ -1638,7 +1791,7 @@ static int _cmd_enable_event(struct ltt_session *session,
 		filter_expression = NULL;
 		filter = NULL;
 		exclusion = NULL;
-		if (ret != LTTNG_OK) {
+		if (ret != LTTNG_OK && ret != LTTNG_ERR_UST_EVENT_ENABLED) {
 			goto error;
 		}
 		break;
@@ -1659,7 +1812,7 @@ static int _cmd_enable_event(struct ltt_session *session,
 		if (!agt) {
 			agt = agent_create(domain->type);
 			if (!agt) {
-				ret = -LTTNG_ERR_NOMEM;
+				ret = LTTNG_ERR_NOMEM;
 				goto error;
 			}
 			agent_add(agt, usess->agents);
@@ -1669,9 +1822,10 @@ static int _cmd_enable_event(struct ltt_session *session,
 		memset(&uevent, 0, sizeof(uevent));
 		uevent.type = LTTNG_EVENT_TRACEPOINT;
 		uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
-		default_event_name = event_get_default_agent_ust_name(domain->type);
+		default_event_name = event_get_default_agent_ust_name(
+				domain->type);
 		if (!default_event_name) {
-			ret = -LTTNG_ERR_FATAL;
+			ret = LTTNG_ERR_FATAL;
 			goto error;
 		}
 		strncpy(uevent.name, default_event_name, sizeof(uevent.name));
@@ -1696,32 +1850,43 @@ static int _cmd_enable_event(struct ltt_session *session,
 			default_chan_name = DEFAULT_PYTHON_CHANNEL_NAME;
 			break;
 		default:
-			/* The switch/case we are in should avoid this else big problem */
+			/* The switch/case we are in makes this impossible */
 			assert(0);
 		}
 
 		{
+			char *filter_expression_copy = NULL;
 			struct lttng_filter_bytecode *filter_copy = NULL;
 
 			if (filter) {
-				filter_copy = zmalloc(
-					sizeof(struct lttng_filter_bytecode)
-					+ filter->len);
+				const size_t filter_size = sizeof(
+						struct lttng_filter_bytecode)
+						+ filter->len;
+
+				filter_copy = zmalloc(filter_size);
 				if (!filter_copy) {
+					ret = LTTNG_ERR_NOMEM;
 					goto error;
 				}
+				memcpy(filter_copy, filter, filter_size);
 
-				memcpy(filter_copy, filter,
-					sizeof(struct lttng_filter_bytecode)
-					+ filter->len);
+				filter_expression_copy =
+						strdup(filter_expression);
+				if (!filter_expression) {
+					ret = LTTNG_ERR_NOMEM;
+				}
+
+				if (!filter_expression_copy || !filter_copy) {
+					free(filter_expression_copy);
+					free(filter_copy);
+					goto error;
+				}
 			}
 
 			ret = cmd_enable_event_internal(session, &tmp_dom,
 					(char *) default_chan_name,
-					&uevent, filter_expression, filter_copy,
-					NULL, wpipe);
-			/* We have passed ownership */
-			filter_expression = NULL;
+					&uevent, filter_expression_copy,
+					filter_copy, NULL, wpipe);
 		}
 
 		if (ret != LTTNG_OK && ret != LTTNG_ERR_UST_EVENT_ENABLED) {
@@ -1730,12 +1895,14 @@ static int _cmd_enable_event(struct ltt_session *session,
 
 		/* The wild card * means that everything should be enabled. */
 		if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) {
-			ret = event_agent_enable_all(usess, agt, event, filter);
-			filter = NULL;
+			ret = event_agent_enable_all(usess, agt, event, filter,
+					filter_expression);
 		} else {
-			ret = event_agent_enable(usess, agt, event, filter);
-			filter = NULL;
+			ret = event_agent_enable(usess, agt, event, filter,
+					filter_expression);
 		}
+		filter = NULL;
+		filter_expression = NULL;
 		if (ret != LTTNG_OK) {
 			goto error;
 		}
@@ -1792,7 +1959,8 @@ static int cmd_enable_event_internal(struct ltt_session *session,
 /*
  * Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
  */
-ssize_t cmd_list_tracepoints(int domain, struct lttng_event **events)
+ssize_t cmd_list_tracepoints(enum lttng_domain_type domain,
+		struct lttng_event **events)
 {
 	int ret;
 	ssize_t nb_events = 0;
@@ -1836,7 +2004,7 @@ error:
 /*
  * Command LTTNG_LIST_TRACEPOINT_FIELDS processed by the client thread.
  */
-ssize_t cmd_list_tracepoint_fields(int domain,
+ssize_t cmd_list_tracepoint_fields(enum lttng_domain_type domain,
 		struct lttng_event_field **fields)
 {
 	int ret;
@@ -1874,7 +2042,7 @@ ssize_t cmd_list_syscalls(struct lttng_event **events)
  * Called with session lock held.
  */
 ssize_t cmd_list_tracker_pids(struct ltt_session *session,
-		int domain, int32_t **pids)
+		enum lttng_domain_type domain, int32_t **pids)
 {
 	int ret;
 	ssize_t nr_pids = 0;
@@ -2230,7 +2398,7 @@ int cmd_create_session_snapshot(char *name, struct lttng_uri *uris,
 	 * Create session in no output mode with URIs set to NULL. The uris we've
 	 * received are for a default snapshot output if one.
 	 */
-	ret = cmd_create_session_uri(name, NULL, 0, creds, -1);
+	ret = cmd_create_session_uri(name, NULL, 0, creds, 0);
 	if (ret != LTTNG_OK) {
 		goto error;
 	}
@@ -2331,7 +2499,8 @@ int cmd_destroy_session(struct ltt_session *session, int wpipe)
 /*
  * Command LTTNG_CALIBRATE processed by the client thread.
  */
-int cmd_calibrate(int domain, struct lttng_calibrate *calibrate)
+int cmd_calibrate(enum lttng_domain_type domain,
+		struct lttng_calibrate *calibrate)
 {
 	int ret;
 
@@ -2388,8 +2557,9 @@ error:
 /*
  * Command LTTNG_REGISTER_CONSUMER processed by the client thread.
  */
-int cmd_register_consumer(struct ltt_session *session, int domain,
-		const char *sock_path, struct consumer_data *cdata)
+int cmd_register_consumer(struct ltt_session *session,
+		enum lttng_domain_type domain, const char *sock_path,
+		struct consumer_data *cdata)
 {
 	int ret, sock;
 	struct consumer_socket *socket = NULL;
@@ -2540,8 +2710,8 @@ error:
 /*
  * Command LTTNG_LIST_CHANNELS processed by the client thread.
  */
-ssize_t cmd_list_channels(int domain, struct ltt_session *session,
-		struct lttng_channel **channels)
+ssize_t cmd_list_channels(enum lttng_domain_type domain,
+		struct ltt_session *session, struct lttng_channel **channels)
 {
 	int ret;
 	ssize_t nb_chan = 0;
@@ -2594,8 +2764,9 @@ error:
 /*
  * Command LTTNG_LIST_EVENTS processed by the client thread.
  */
-ssize_t cmd_list_events(int domain, struct ltt_session *session,
-		char *channel_name, struct lttng_event **events)
+ssize_t cmd_list_events(enum lttng_domain_type domain,
+		struct ltt_session *session, char *channel_name,
+		struct lttng_event **events)
 {
 	int ret = 0;
 	ssize_t nb_event = 0;
@@ -2625,7 +2796,11 @@ ssize_t cmd_list_events(int domain, struct ltt_session *session,
 			rcu_read_lock();
 			cds_lfht_for_each_entry(session->ust_session->agents->ht,
 					&iter.iter, agt, node.node) {
-				nb_event = list_lttng_agent_events(agt, events);
+				if (agt->domain == domain) {
+					nb_event = list_lttng_agent_events(
+							agt, events);
+					break;
+				}
 			}
 			rcu_read_unlock();
 		}