X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=8e06ce6913875dd85e0a17e0eeafb929ba93d425;hp=ffff05809d2f072cd6c40ea00f83dec07fad5f56;hb=a93b3916055c57baf374c1f566d81f91101daa54;hpb=56a375637d1034231c65d90078934b8e193b151c diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index ffff05809..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 + * Copyright (C) 2016 - Jérémie Galarneau * * 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 -#include #include #include #include @@ -28,6 +27,7 @@ #include #include #include +#include #include "channel.h" #include "consumer.h" @@ -237,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++; } @@ -380,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: @@ -1046,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] == '.' || @@ -1112,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); @@ -1192,32 +1225,22 @@ int cmd_disable_event(struct ltt_session *session, switch (event->type) { case LTTNG_EVENT_ALL: - ret = event_kernel_disable_event_all(kchan); - if (ret != LTTNG_OK) { - goto error_unlock; - } - 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_unlock; } 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_unlock; - } - break; default: ret = LTTNG_ERR_UNK; goto error_unlock; @@ -1240,7 +1263,7 @@ int cmd_disable_event(struct ltt_session *session, /* * 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') { @@ -1257,7 +1280,16 @@ int cmd_disable_event(struct ltt_session *session, 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_unlock; } @@ -1293,8 +1325,11 @@ int cmd_disable_event(struct ltt_session *session, ret = -LTTNG_ERR_UST_EVENT_NOT_FOUND; 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); @@ -1325,6 +1360,12 @@ 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: @@ -1344,6 +1385,29 @@ int cmd_add_context(struct ltt_session *session, enum lttng_domain_type 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; @@ -1371,6 +1435,10 @@ int cmd_add_context(struct ltt_session *session, enum lttng_domain_type 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; } @@ -1381,7 +1449,8 @@ int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain, goto error; } - return LTTNG_OK; + ret = LTTNG_OK; + goto end; error: if (chan_kern_created) { @@ -1405,6 +1474,9 @@ error: uchan); trace_ust_destroy_channel(uchan); } +end: + free(app_ctx_provider_name); + free(app_ctx_name); return ret; } @@ -1497,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: { @@ -1597,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; @@ -1682,6 +1758,16 @@ 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 @@ -1705,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; @@ -1726,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); @@ -1736,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)); @@ -1768,27 +1855,38 @@ static int _cmd_enable_event(struct ltt_session *session, } { + 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) { @@ -1797,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; } @@ -2298,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; } @@ -2696,7 +2796,11 @@ ssize_t cmd_list_events(enum lttng_domain_type domain, 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(); }