X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng%2Fcommands%2Fenable_events.c;h=af6abbe6e6b4e93bc5950dfd000a9d0236e9cfb7;hp=3f304a0902ad398bfddacc76ba97ca6595836685;hb=d5dd17fd22066461e22eae8f77062cb3b9b111bc;hpb=53a80697a772bc2e260e3dff006f910be6709f04

diff --git a/src/bin/lttng/commands/enable_events.c b/src/bin/lttng/commands/enable_events.c
index 3f304a090..af6abbe6e 100644
--- a/src/bin/lttng/commands/enable_events.c
+++ b/src/bin/lttng/commands/enable_events.c
@@ -36,12 +36,14 @@ static int opt_loglevel_type;
 static int opt_kernel;
 static char *opt_session_name;
 static int opt_userspace;
+static int opt_jul;
 static int opt_enable_all;
 static char *opt_probe;
 static char *opt_function;
 static char *opt_function_entry_symbol;
 static char *opt_channel_name;
 static char *opt_filter;
+static char *opt_exclude;
 #if 0
 /* Not implemented yet */
 static char *opt_cmd_name;
@@ -60,6 +62,7 @@ enum {
 	OPT_LOGLEVEL_ONLY,
 	OPT_LIST_OPTIONS,
 	OPT_FILTER,
+	OPT_EXCLUDE,
 };
 
 static struct lttng_handle *handle;
@@ -71,13 +74,8 @@ static struct poptOption long_options[] = {
 	{"all",            'a', POPT_ARG_VAL, &opt_enable_all, 1, 0, 0},
 	{"channel",        'c', POPT_ARG_STRING, &opt_channel_name, 0, 0, 0},
 	{"kernel",         'k', POPT_ARG_VAL, &opt_kernel, 1, 0, 0},
-#if 0
-	/* Not implemented yet */
-	{"userspace",      'u', POPT_ARG_STRING | POPT_ARGFLAG_OPTIONAL, &opt_cmd_name, OPT_USERSPACE, 0, 0},
-	{"pid",            'p', POPT_ARG_INT, &opt_pid, 0, 0, 0},
-#else
 	{"userspace",      'u', POPT_ARG_NONE, 0, OPT_USERSPACE, 0, 0},
-#endif
+	{"jul",            'j', POPT_ARG_VAL, &opt_jul, 1, 0, 0},
 	{"tracepoint",     0,   POPT_ARG_NONE, 0, OPT_TRACEPOINT, 0, 0},
 	{"probe",          0,   POPT_ARG_STRING, &opt_probe, OPT_PROBE, 0, 0},
 	{"function",       0,   POPT_ARG_STRING, &opt_function, OPT_FUNCTION, 0, 0},
@@ -93,6 +91,7 @@ static struct poptOption long_options[] = {
 	{"loglevel-only",  0,     POPT_ARG_STRING, 0, OPT_LOGLEVEL_ONLY, 0, 0},
 	{"list-options", 0, POPT_ARG_NONE, NULL, OPT_LIST_OPTIONS, NULL, NULL},
 	{"filter",         'f', POPT_ARG_STRING, &opt_filter, OPT_FILTER, 0, 0},
+	{"exclude",        'x', POPT_ARG_STRING, &opt_exclude, OPT_EXCLUDE, 0, 0},
 	{0, 0, 0, 0, 0, 0, 0}
 };
 
@@ -101,22 +100,17 @@ static struct poptOption long_options[] = {
  */
 static void usage(FILE *ofp)
 {
-	fprintf(ofp, "usage: lttng enable-event NAME[,NAME2,...] [options] [event_options]\n");
+	fprintf(ofp, "usage: lttng enable-event NAME[,NAME2,...] [-k|-u] [OPTIONS] \n");
 	fprintf(ofp, "\n");
+	fprintf(ofp, "Options:\n");
 	fprintf(ofp, "  -h, --help               Show this help\n");
 	fprintf(ofp, "      --list-options       Simple listing of options\n");
-	fprintf(ofp, "  -s, --session            Apply to session name\n");
-	fprintf(ofp, "  -c, --channel            Apply to this channel\n");
+	fprintf(ofp, "  -s, --session NAME       Apply to session name\n");
+	fprintf(ofp, "  -c, --channel NAME       Apply to this channel\n");
 	fprintf(ofp, "  -a, --all                Enable all tracepoints and syscalls\n");
 	fprintf(ofp, "  -k, --kernel             Apply for the kernel tracer\n");
-#if 0
-	fprintf(ofp, "  -u, --userspace [CMD]    Apply to the user-space tracer\n");
-	fprintf(ofp, "                           If no CMD, the domain used is UST global\n");
-	fprintf(ofp, "                           or else the domain is UST EXEC_NAME\n");
-	fprintf(ofp, "  -p, --pid PID            If -u, apply to specific PID (domain: UST PID)\n");
-#else
 	fprintf(ofp, "  -u, --userspace          Apply to the user-space tracer\n");
-#endif
+	fprintf(ofp, "  -j, --jul                Apply for Java application using JUL\n");
 	fprintf(ofp, "\n");
 	fprintf(ofp, "Event options:\n");
 	fprintf(ofp, "    --tracepoint           Tracepoint event (default)\n");
@@ -125,11 +119,11 @@ static void usage(FILE *ofp)
 	fprintf(ofp, "                             e.g.:\n");
 	fprintf(ofp, "                               \"*\"\n");
 	fprintf(ofp, "                               \"app_component:na*\"\n");
-	fprintf(ofp, "    --probe [addr | symbol | symbol+offset]\n");
+	fprintf(ofp, "    --probe (addr | symbol | symbol+offset)\n");
 	fprintf(ofp, "                           Dynamic probe.\n");
 	fprintf(ofp, "                           Addr and offset can be octal (0NNN...),\n");
 	fprintf(ofp, "                           decimal (NNN...) or hexadecimal (0xNNN...)\n");
-	fprintf(ofp, "    --function [addr | symbol | symbol+offset]\n");
+	fprintf(ofp, "    --function (addr | symbol | symbol+offset)\n");
 	fprintf(ofp, "                           Dynamic function entry/return probe.\n");
 	fprintf(ofp, "                           Addr and offset can be octal (0NNN...),\n");
 	fprintf(ofp, "                           decimal (NNN...) or hexadecimal (0xNNN...)\n");
@@ -165,9 +159,48 @@ static void usage(FILE *ofp)
 	fprintf(ofp, "                               TRACE_DEBUG_LINE     = 13\n");
 	fprintf(ofp, "                               TRACE_DEBUG          = 14\n");
 	fprintf(ofp, "                               (shortcuts such as \"system\" are allowed)\n");
-	fprintf(ofp, "    --filter \'expression\'\n");
-	fprintf(ofp, "                           Filter expression on event fields,\n");
-	fprintf(ofp, "                           event recording depends on evaluation.\n");
+	fprintf(ofp, "  -f, --filter \'expression\'\n");
+	fprintf(ofp, "                           Filter expression on event fields and context.\n");
+	fprintf(ofp, "                           Event recording depends on evaluation.\n");
+	fprintf(ofp, "                           Only specify on first activation of\n");
+	fprintf(ofp, "                           a given event within a session.\n");
+	fprintf(ofp, "                           Filter only allowed when enabling\n");
+	fprintf(ofp, "                           events within a session before tracing\n");
+	fprintf(ofp, "                           is started. If the filter fails to link\n");
+	fprintf(ofp, "                           with the event within the traced domain,\n");
+	fprintf(ofp, "                           the event will be discarded. Currently,\n");
+	fprintf(ofp, "                           filter is only implemented for the user-space\n");
+	fprintf(ofp, "                           tracer.\n");
+	fprintf(ofp, "                           Expression examples:.\n");
+	fprintf(ofp, "                           \n");
+	fprintf(ofp, "                           'intfield > 500 && intfield < 503'\n");
+	fprintf(ofp, "                           '(strfield == \"test\" || intfield != 10) && intfield > 33'\n");
+	fprintf(ofp, "                           'doublefield > 1.1 && intfield < 5.3'\n");
+	fprintf(ofp, "                           \n");
+	fprintf(ofp, "                           Wildcards are allowed at the end of strings:\n");
+	fprintf(ofp, "                           'seqfield1 == \"te*\"'\n");
+	fprintf(ofp, "                           In string literals, the escape character is '\\'.\n");
+	fprintf(ofp, "                           Use '\\*' for the '*' character, and '\\\\' for\n");
+	fprintf(ofp, "                           the '\\' character. Wildcard match any sequence of,\n");
+	fprintf(ofp, "                           characters including an empty sub-string (match 0 or\n");
+	fprintf(ofp, "                           more characters).\n");
+	fprintf(ofp, "\n");
+	fprintf(ofp, "                           Context information can be used for filtering. The\n");
+	fprintf(ofp, "                           examples below show usage of context filtering on\n");
+	fprintf(ofp, "                           process name (with a wildcard), process ID range, and\n");
+	fprintf(ofp, "                           unique thread ID for filtering. The process and\n");
+	fprintf(ofp, "                           thread ID of running applications can be found under\n");
+	fprintf(ofp, "                           columns \"PID\" and \"LWP\" of the \"ps -eLf\" command.\n");
+	fprintf(ofp, "\n");
+	fprintf(ofp, "                           '$ctx.procname == \"demo*\"'\n");
+	fprintf(ofp, "                           '$ctx.vpid >= 4433 && $ctx.vpid < 4455'\n");
+	fprintf(ofp, "                           '$ctx.vtid == 1234'\n");
+	fprintf(ofp, "  -x, --exclude LIST\n");
+	fprintf(ofp, "                           Add exclusions to UST tracepoints:\n");
+	fprintf(ofp, "                           Events that match any of the items\n");
+	fprintf(ofp, "                           in the comma-separated LIST are not\n");
+	fprintf(ofp, "                           enabled, even if they match a wildcard\n");
+	fprintf(ofp, "                           definition of the event.\n");
 	fprintf(ofp, "\n");
 }
 
@@ -191,7 +224,7 @@ static int parse_probe_opts(struct lttng_event *ev, char *opt)
 		strncpy(ev->attr.probe.symbol_name, name, LTTNG_SYMBOL_NAME_LEN);
 		ev->attr.probe.symbol_name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 		DBG("probe symbol %s", ev->attr.probe.symbol_name);
-		if (strlen(s_hex) == 0) {
+		if (*s_hex == '\0') {
 			ERR("Invalid probe offset %s", s_hex);
 			ret = -1;
 			goto end;
@@ -219,7 +252,7 @@ static int parse_probe_opts(struct lttng_event *ev, char *opt)
 	/* Check for address */
 	ret = sscanf(opt, "%s", s_hex);
 	if (ret > 0) {
-		if (strlen(s_hex) == 0) {
+		if (*s_hex == '\0') {
 			ERR("Invalid probe address %s", s_hex);
 			ret = -1;
 			goto end;
@@ -247,7 +280,11 @@ int loglevel_str_to_value(const char *inputstr)
 	int i = 0;
 	char str[LTTNG_SYMBOL_NAME_LEN];
 
-	while (inputstr[i] != '\0' && i < LTTNG_SYMBOL_NAME_LEN) {
+	/*
+	 * Loop up to LTTNG_SYMBOL_NAME_LEN minus one because the NULL bytes is
+	 * added at the end of the loop so a the upper bound we avoid the overflow.
+	 */
+	while (i < (LTTNG_SYMBOL_NAME_LEN - 1) && inputstr[i] != '\0') {
 		str[i] = toupper(inputstr[i]);
 		i++;
 	}
@@ -287,15 +324,117 @@ int loglevel_str_to_value(const char *inputstr)
 	}
 }
 
+static
+const char *print_channel_name(const char *name)
+{
+	return name ? : DEFAULT_CHANNEL_NAME;
+}
+
+static
+const char *print_raw_channel_name(const char *name)
+{
+	return name ? : "<default>";
+}
+
+/*
+ * Compare list of exclusions against an event name.
+ * Return a list of legal exclusion names.
+ * Produce an error or a warning about others (depending on the situation)
+ */
+static
+int check_exclusion_subsets(const char *event_name,
+		const char *exclusions,
+		int *exclusion_count_ptr,
+		char ***exclusion_list_ptr)
+{
+	const char *excluder_ptr;
+	const char *event_ptr;
+	const char *next_excluder;
+	int excluder_length;
+	int exclusion_count = 0;
+	char **exclusion_list = NULL;
+	int ret = CMD_SUCCESS;
+
+	if (event_name[strlen(event_name) - 1] != '*') {
+		ERR("Event %s: Excluders can only be used with wildcarded events", event_name);
+		goto error;
+	}
+
+	next_excluder = exclusions;
+	while (*next_excluder != 0) {
+		event_ptr = event_name;
+		excluder_ptr = next_excluder;
+		excluder_length = strcspn(next_excluder, ",");
+
+		/* Scan both the excluder and the event letter by letter */
+		while (1) {
+			char e, x;
+
+			e = *event_ptr;
+			x = *excluder_ptr;
+
+			if (x == '*') {
+				/* Event is a subset of the excluder */
+				ERR("Event %s: %.*s excludes all events from %s",
+						event_name,
+						excluder_length,
+						next_excluder,
+						event_name);
+				goto error;
+			}
+			if (e == '*') {
+				/* Excluder is a proper subset of event */
+				exclusion_count++;
+				exclusion_list = realloc(exclusion_list, sizeof(char **) * exclusion_count);
+				exclusion_list[exclusion_count - 1] = strndup(next_excluder, excluder_length);
+
+				break;
+			}
+			if (x != e) {
+				/* Excluder and event sets have no common elements */
+				WARN("Event %s: %.*s does not exclude any events from %s",
+						event_name,
+						excluder_length,
+						next_excluder,
+						event_name);
+				break;
+			}
+			excluder_ptr++;
+			event_ptr++;
+		}
+		/* next excluder */
+		next_excluder += excluder_length;
+		if (*next_excluder == ',') {
+			next_excluder++;
+		}
+	}
+	goto end;
+error:
+	while (exclusion_count--) {
+		free(exclusion_list[exclusion_count]);
+	}
+	if (exclusion_list != NULL) {
+		free(exclusion_list);
+	}
+	exclusion_list = NULL;
+	exclusion_count = 0;
+	ret = CMD_ERROR;
+end:
+	*exclusion_count_ptr = exclusion_count;
+	*exclusion_list_ptr = exclusion_list;
+	return ret;
+}
 /*
  * Enabling event using the lttng API.
  */
 static int enable_events(char *session_name)
 {
-	int err, ret = CMD_SUCCESS, warn = 0;
+	int ret = CMD_SUCCESS, warn = 0;
 	char *event_name, *channel_name = NULL;
 	struct lttng_event ev;
 	struct lttng_domain dom;
+	int exclusion_count = 0;
+	char **exclusion_list = NULL;
 
 	memset(&ev, 0, sizeof(ev));
 	memset(&dom, 0, sizeof(dom));
@@ -306,29 +445,37 @@ static int enable_events(char *session_name)
 			ret = CMD_ERROR;
 			goto error;
 		}
+		if (opt_loglevel) {
+			WARN("Kernel loglevels are not supported.");
+		}
 	}
 
 	/* Create lttng domain */
 	if (opt_kernel) {
 		dom.type = LTTNG_DOMAIN_KERNEL;
+		dom.buf_type = LTTNG_BUFFER_GLOBAL;
 	} else if (opt_userspace) {
 		dom.type = LTTNG_DOMAIN_UST;
+		/* Default. */
+		dom.buf_type = LTTNG_BUFFER_PER_UID;
+	} else if (opt_jul) {
+		dom.type = LTTNG_DOMAIN_JUL;
+		/* Default. */
+		dom.buf_type = LTTNG_BUFFER_PER_UID;
 	} else {
-		ERR("Please specify a tracer (-k/--kernel or -u/--userspace)");
+		print_missing_domain();
 		ret = CMD_ERROR;
 		goto error;
 	}
 
-	if (opt_channel_name == NULL) {
-		err = asprintf(&channel_name, DEFAULT_CHANNEL_NAME);
-		if (err < 0) {
-			ret = CMD_FATAL;
-			goto error;
-		}
-	} else {
-		channel_name = opt_channel_name;
+	if (opt_kernel && opt_exclude) {
+		ERR("Event name exclusions are not yet implemented for kernel events");
+		ret = CMD_ERROR;
+		goto error;
 	}
 
+	channel_name = opt_channel_name;
+
 	handle = lttng_create_handle(session_name, &dom);
 	if (handle == NULL) {
 		ret = -1;
@@ -350,7 +497,7 @@ static int enable_events(char *session_name)
 				ev.loglevel = loglevel_str_to_value(opt_loglevel);
 				if (ev.loglevel == -1) {
 					ERR("Unknown loglevel %s", opt_loglevel);
-					ret = -1;
+					ret = -LTTNG_ERR_INVALID;
 					goto error;
 				}
 			} else {
@@ -358,64 +505,98 @@ static int enable_events(char *session_name)
 			}
 		}
 
-		ret = lttng_enable_event(handle, &ev, channel_name);
-		if (ret < 0) {
-			switch (-ret) {
-			case LTTCOMM_KERN_EVENT_EXIST:
-				WARN("Kernel events already enabled (channel %s, session %s)",
-						channel_name, session_name);
+		if (opt_exclude) {
+			ret = check_exclusion_subsets("*", opt_exclude,
+					&exclusion_count, &exclusion_list);
+			if (ret == CMD_ERROR) {
+				goto error;
+			}
+		}
+		if (!opt_filter) {
+			ret = lttng_enable_event_with_exclusions(handle,
+					&ev, channel_name,
+					NULL,
+					exclusion_count, exclusion_list);
+			if (ret < 0) {
+				switch (-ret) {
+				case LTTNG_ERR_KERN_EVENT_EXIST:
+					WARN("Kernel events already enabled (channel %s, session %s)",
+							print_channel_name(channel_name), session_name);
+					break;
+				default:
+					ERR("Events: %s (channel %s, session %s)",
+							lttng_strerror(ret),
+							ret == -LTTNG_ERR_NEED_CHANNEL_NAME
+								? print_raw_channel_name(channel_name)
+								: print_channel_name(channel_name),
+							session_name);
+					break;
+				}
+				goto end;
+			}
+
+			switch (opt_event_type) {
+			case LTTNG_EVENT_TRACEPOINT:
+				if (opt_loglevel && dom.type != LTTNG_DOMAIN_KERNEL) {
+					MSG("All %s tracepoints are enabled in channel %s for loglevel %s",
+							get_domain_str(dom.type),
+							print_channel_name(channel_name),
+							opt_loglevel);
+				} else {
+					MSG("All %s tracepoints are enabled in channel %s",
+							get_domain_str(dom.type),
+							print_channel_name(channel_name));
+				}
 				break;
-			default:
-				ERR("Events: %s (channel %s, session %s)",
-						lttng_strerror(ret), channel_name, session_name);
+			case LTTNG_EVENT_SYSCALL:
+				if (opt_kernel) {
+					MSG("All kernel system calls are enabled in channel %s",
+							print_channel_name(channel_name));
+				}
+				break;
+			case LTTNG_EVENT_ALL:
+				if (opt_loglevel && dom.type != LTTNG_DOMAIN_KERNEL) {
+					MSG("All %s events are enabled in channel %s for loglevel %s",
+							get_domain_str(dom.type),
+							print_channel_name(channel_name),
+							opt_loglevel);
+				} else {
+					MSG("All %s events are enabled in channel %s",
+							get_domain_str(dom.type),
+							print_channel_name(channel_name));
+				}
 				break;
+			default:
+				/*
+				 * We should not be here since lttng_enable_event should have
+				 * failed on the event type.
+				 */
+				goto error;
 			}
-			goto end;
 		}
 		if (opt_filter) {
-			ret = lttng_set_event_filter(handle, ev.name, channel_name,
-						opt_filter);
+			ret = lttng_enable_event_with_exclusions(handle, &ev, channel_name,
+						opt_filter, exclusion_count, exclusion_list);
 			if (ret < 0) {
-				ERR("Error setting filter");
-				ret = -1;
+				switch (-ret) {
+				case LTTNG_ERR_FILTER_EXIST:
+					WARN("Filter on all events is already enabled"
+							" (channel %s, session %s)",
+						print_channel_name(channel_name), session_name);
+					break;
+				default:
+					ERR("All events: %s (channel %s, session %s, filter \'%s\')",
+							lttng_strerror(ret),
+							ret == -LTTNG_ERR_NEED_CHANNEL_NAME
+								? print_raw_channel_name(channel_name)
+								: print_channel_name(channel_name),
+							session_name, opt_filter);
+					break;
+				}
 				goto error;
-			}
-		}
-
-		switch (opt_event_type) {
-		case LTTNG_EVENT_TRACEPOINT:
-			if (opt_loglevel) {
-				MSG("All %s tracepoints are enabled in channel %s for loglevel %s",
-					opt_kernel ? "kernel" : "UST", channel_name,
-					opt_loglevel);
 			} else {
-				MSG("All %s tracepoints are enabled in channel %s",
-					opt_kernel ? "kernel" : "UST", channel_name);
-
-			}
-			break;
-		case LTTNG_EVENT_SYSCALL:
-			if (opt_kernel) {
-				MSG("All kernel system calls are enabled in channel %s",
-						channel_name);
+				MSG("Filter '%s' successfully set", opt_filter);
 			}
-			break;
-		case LTTNG_EVENT_ALL:
-			if (opt_loglevel) {
-				MSG("All %s events are enabled in channel %s for loglevel %s",
-					opt_kernel ? "kernel" : "UST", channel_name,
-					opt_loglevel);
-			} else {
-				MSG("All %s events are enabled in channel %s",
-					opt_kernel ? "kernel" : "UST", channel_name);
-			}
-			break;
-		default:
-			/*
-			 * We should not be here since lttng_enable_event should have
-			 * failed on the event type.
-			 */
-			goto error;
 		}
 		goto end;
 	}
@@ -431,7 +612,8 @@ static int enable_events(char *session_name)
 		/* Kernel tracer action */
 		if (opt_kernel) {
 			DBG("Enabling kernel event %s for channel %s",
-					event_name, channel_name);
+					event_name,
+					print_channel_name(channel_name));
 
 			switch (opt_event_type) {
 			case LTTNG_EVENT_ALL:	/* Default behavior is tracepoint */
@@ -468,12 +650,6 @@ static int enable_events(char *session_name)
 				goto error;
 			}
 
-			if (opt_loglevel) {
-				MSG("Kernel loglevels are not supported.");
-				ret = CMD_UNDEFINED;
-				goto error;
-			}
-
 			/* kernel loglevels not implemented */
 			ev.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
 		} else if (opt_userspace) {		/* User-space tracer action */
@@ -486,7 +662,7 @@ static int enable_events(char *session_name)
 #endif
 
 			DBG("Enabling UST event %s for channel %s, loglevel %s", event_name,
-					channel_name, opt_loglevel ? : "<all>");
+					print_channel_name(channel_name), opt_loglevel ? : "<all>");
 
 			switch (opt_event_type) {
 			case LTTNG_EVENT_ALL:	/* Default behavior is tracepoint */
@@ -503,52 +679,111 @@ static int enable_events(char *session_name)
 			case LTTNG_EVENT_SYSCALL:
 			default:
 				ERR("Event type not available for user-space tracing");
-				ret = CMD_UNDEFINED;
+				ret = CMD_UNSUPPORTED;
 				goto error;
 			}
 
+			if (opt_exclude) {
+				if (opt_event_type != LTTNG_EVENT_ALL && opt_event_type != LTTNG_EVENT_TRACEPOINT) {
+					ERR("Exclusion option can only be used with tracepoint events");
+					ret = CMD_ERROR;
+					goto error;
+				}
+				/* Free previously allocated items */
+				if (exclusion_list != NULL) {
+					while (exclusion_count--) {
+						free(exclusion_list[exclusion_count]);
+					}
+					free(exclusion_list);
+					exclusion_list = NULL;
+				}
+				/* Check for proper subsets */
+				ret = check_exclusion_subsets(event_name, opt_exclude,
+						&exclusion_count, &exclusion_list);
+				if (ret == CMD_ERROR) {
+					goto error;
+				}
+			}
+
 			ev.loglevel_type = opt_loglevel_type;
 			if (opt_loglevel) {
 				ev.loglevel = loglevel_str_to_value(opt_loglevel);
 				if (ev.loglevel == -1) {
 					ERR("Unknown loglevel %s", opt_loglevel);
-					ret = -1;
+					ret = -LTTNG_ERR_INVALID;
 					goto error;
 				}
 			} else {
 				ev.loglevel = -1;
 			}
+		} else if (opt_jul) {
+			if (opt_event_type != LTTNG_EVENT_ALL &&
+					opt_event_type != LTTNG_EVENT_TRACEPOINT) {
+				ERR("Event type not supported for JUL domain.");
+				ret = CMD_UNSUPPORTED;
+				goto error;
+			}
+			ev.type = LTTNG_EVENT_TRACEPOINT;
+			strncpy(ev.name, event_name, LTTNG_SYMBOL_NAME_LEN);
+			ev.name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 		} else {
-			ERR("Please specify a tracer (-k/--kernel or -u/--userspace)");
+			print_missing_domain();
 			ret = CMD_ERROR;
 			goto error;
 		}
 
-		ret = lttng_enable_event(handle, &ev, channel_name);
-		if (ret < 0) {
-			/* Turn ret to positive value to handle the positive error code */
-			switch (-ret) {
-			case LTTCOMM_KERN_EVENT_EXIST:
-				WARN("Kernel event %s already enabled (channel %s, session %s)",
-						event_name, channel_name, session_name);
-				break;
-			default:
-				ERR("Event %s: %s (channel %s, session %s)", event_name,
-						lttng_strerror(ret), channel_name, session_name);
-				break;
+		if (!opt_filter) {
+			ret = lttng_enable_event_with_exclusions(handle,
+					&ev, channel_name,
+					NULL, exclusion_count, exclusion_list);
+			if (ret < 0) {
+				/* Turn ret to positive value to handle the positive error code */
+				switch (-ret) {
+				case LTTNG_ERR_KERN_EVENT_EXIST:
+					WARN("Kernel event %s already enabled (channel %s, session %s)",
+							event_name,
+							print_channel_name(channel_name), session_name);
+					break;
+				default:
+					ERR("Event %s: %s (channel %s, session %s)", event_name,
+							lttng_strerror(ret),
+							ret == -LTTNG_ERR_NEED_CHANNEL_NAME
+								? print_raw_channel_name(channel_name)
+								: print_channel_name(channel_name),
+							session_name);
+					break;
+				}
+				warn = 1;
+			} else {
+				MSG("%s event %s created in channel %s",
+						get_domain_str(dom.type), event_name,
+						print_channel_name(channel_name));
 			}
-			warn = 1;
-		} else {
-			MSG("%s event %s created in channel %s",
-					opt_kernel ? "kernel": "UST", event_name, channel_name);
 		}
+
 		if (opt_filter) {
-			ret = lttng_set_event_filter(handle, ev.name,
-				channel_name, opt_filter);
+			ret = lttng_enable_event_with_exclusions(handle, &ev, channel_name,
+					opt_filter, exclusion_count, exclusion_list);
 			if (ret < 0) {
-				ERR("Error setting filter");
-				ret = -1;
+				switch (-ret) {
+				case LTTNG_ERR_FILTER_EXIST:
+					WARN("Filter on event %s is already enabled"
+							" (channel %s, session %s)",
+						event_name,
+						print_channel_name(channel_name), session_name);
+					break;
+				default:
+					ERR("Event %s: %s (channel %s, session %s, filter \'%s\')", ev.name,
+							lttng_strerror(ret),
+							ret == -LTTNG_ERR_NEED_CHANNEL_NAME
+								? print_raw_channel_name(channel_name)
+								: print_channel_name(channel_name),
+							session_name, opt_filter);
+					break;
+				}
 				goto error;
+			} else {
+				MSG("Filter '%s' successfully set", opt_filter);
 			}
 		}
 
@@ -561,11 +796,15 @@ error:
 	if (warn) {
 		ret = CMD_WARNING;
 	}
-	if (opt_channel_name == NULL) {
-		free(channel_name);
-	}
 	lttng_destroy_handle(handle);
 
+	if (exclusion_list != NULL) {
+		while (exclusion_count--) {
+			free(exclusion_list[exclusion_count]);
+		}
+		free(exclusion_list);
+	}
+
 	return ret;
 }
 
@@ -577,6 +816,7 @@ int cmd_enable_events(int argc, const char **argv)
 	int opt, ret = CMD_SUCCESS;
 	static poptContext pc;
 	char *session_name = NULL;
+	int event_type = -1;
 
 	pc = poptGetContext(NULL, argc, argv, long_options, 0);
 	poptReadDefaultConfig(pc, 0);
@@ -620,11 +860,24 @@ int cmd_enable_events(int argc, const char **argv)
 			goto end;
 		case OPT_FILTER:
 			break;
+		case OPT_EXCLUDE:
+			break;
 		default:
 			usage(stderr);
 			ret = CMD_UNDEFINED;
 			goto end;
 		}
+
+		/* Validate event type. Multiple event type are not supported. */
+		if (event_type == -1) {
+			event_type = opt_event_type;
+		} else {
+			if (event_type != opt_event_type) {
+				ERR("Multiple event type not supported.");
+				ret = CMD_ERROR;
+				goto end;
+			}
+		}
 	}
 
 	opt_event_list = (char*) poptGetArg(pc);