X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=e74e5a90299440a56a7c1e13b481965d8067c0d0;hb=7076b56e194da53d88d3d29cbdf48c747920caf5;hp=a80668831076a4396d14bdd45d2c155a01e7641c;hpb=b5edb9e87b46c7aaa8f2c829e677a1441ca0a260;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index a80668831..e74e5a902 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -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. @@ -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; @@ -1133,11 +1147,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,20 +1176,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 */ @@ -1183,7 +1202,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: @@ -1191,12 +1210,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); @@ -1209,6 +1228,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 @@ -1216,26 +1240,26 @@ 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 (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,13 +1280,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) { @@ -1271,20 +1295,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; } @@ -1383,6 +1408,7 @@ static int validate_event_name(const char *name) int ret = 0; const char *c = name; const char *event_name_end = c + LTTNG_SYMBOL_NAME_LEN; + bool null_terminated = false; /* * Make sure that unescaped wildcards are only used as the last @@ -1391,6 +1417,7 @@ static int validate_event_name(const char *name) while (c < event_name_end) { switch (*c) { case '\0': + null_terminated = true; goto end; case '\\': c++; @@ -1406,20 +1433,57 @@ static int validate_event_name(const char *name) } c++; } +end: + if (!ret && !null_terminated) { + ret = LTTNG_ERR_INVALID_EVENT_NAME; + } + 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); + + 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; } /* - * Command LTTNG_ENABLE_EVENT processed by the client thread. - * We own filter, exclusion, and filter_expression. + * Internal version of cmd_enable_event() with a supplemental + * "internal_event" flag which is used to enable internal events which should + * be hidden from clients. Such events are used in the agent implementation to + * enable the events through which all "agent" events are funeled. */ -int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, +static int _cmd_enable_event(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) + int wpipe, bool internal_event) { int ret, channel_created = 0; struct lttng_channel *attr; @@ -1613,9 +1677,25 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, assert(uchan); } + 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); + filter_expression, filter, exclusion, + internal_event); /* We have passed ownership */ filter_expression = NULL; filter = NULL; @@ -1678,7 +1758,7 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, 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); } @@ -1698,7 +1778,7 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, + filter->len); } - ret = cmd_enable_event(session, &tmp_dom, + ret = cmd_enable_event_internal(session, &tmp_dom, (char *) default_chan_name, &uevent, filter_expression, filter_copy, NULL, wpipe); @@ -1739,6 +1819,38 @@ error: return ret; } +/* + * Command LTTNG_ENABLE_EVENT processed by the client thread. + * We own filter, exclusion, and filter_expression. + */ +int cmd_enable_event(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 _cmd_enable_event(session, domain, channel_name, event, + filter_expression, filter, exclusion, wpipe, false); +} + +/* + * Enable an event which is internal to LTTng. An internal should + * never be made visible to clients and are immune to checks such as + * reserved names. + */ +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 _cmd_enable_event(session, domain, channel_name, event, + filter_expression, filter, exclusion, wpipe, true); +} + /* * Command LTTNG_LIST_TRACEPOINTS processed by the client thread. */ @@ -1898,9 +2010,7 @@ int cmd_start_trace(struct ltt_session *session) * possible to enable channel thus inform the client. */ if (usess && usess->domain_global.channels) { - rcu_read_lock(); nb_chan += lttng_ht_get_count(usess->domain_global.channels); - rcu_read_unlock(); } if (ksession) { nb_chan += ksession->channel_count;