X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;ds=sidebyside;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=4391b6a58c354c6445a8195c345bc7eb91b3a561;hb=d8366880cdb6583ca6c9a04fd022abbca26ff09a;hp=5aff25d2ab937371e547b2bc50ecfa95738d6d0f;hpb=c810029902dacbb0aca6106c4c161acbf6382816;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index 5aff25d2a..4391b6a58 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -50,6 +50,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. @@ -226,7 +236,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++; } @@ -267,8 +277,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; @@ -283,6 +292,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; @@ -365,6 +379,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: @@ -1092,9 +1108,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); @@ -1132,11 +1179,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(); @@ -1156,20 +1208,20 @@ 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; + goto error_unlock; } break; case LTTNG_EVENT_TRACEPOINT: /* fall-through */ @@ -1182,7 +1234,7 @@ int cmd_disable_event(struct ltt_session *session, int domain, event_name); } if (ret != LTTNG_OK) { - goto error; + goto error_unlock; } break; case LTTNG_EVENT_PROBE: @@ -1190,12 +1242,12 @@ int cmd_disable_event(struct ltt_session *session, int domain, 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); @@ -1208,6 +1260,11 @@ 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 @@ -1215,26 +1272,33 @@ int cmd_disable_event(struct ltt_session *session, int domain, */ 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); + if (strlen(event->name) == 1 && + !strncmp(event->name, "*", 1)) { + 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, @@ -1255,13 +1319,13 @@ 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) { @@ -1270,20 +1334,21 @@ int cmd_disable_event(struct ltt_session *session, int domain, 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; } @@ -1440,14 +1505,6 @@ end: return ret; } -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); - /* * Internal version of cmd_enable_event() with a supplemental * "internal_event" flag which is used to enable internal events which should @@ -1471,13 +1528,13 @@ static int _cmd_enable_event(struct ltt_session *session, 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: { @@ -1569,9 +1626,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; @@ -1654,6 +1712,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 @@ -1698,7 +1766,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); @@ -1708,9 +1776,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)); @@ -1740,27 +1809,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); + + filter_expression_copy = + strdup(filter_expression); + if (!filter_expression) { + ret = LTTNG_ERR_NOMEM; + } - memcpy(filter_copy, filter, - sizeof(struct lttng_filter_bytecode) - + filter->len); + 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) { @@ -1769,12 +1849,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; } @@ -2271,7 +2353,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; } @@ -2666,7 +2748,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(); }