X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fevent-rule%2Ftracepoint.c;h=93de1e98ce936c28ffe1dfb6a634595e51b8353b;hp=14e4c7b01901e9b7706ab5e3b83162ba82764337;hb=cb6096aac522cc9b005eb704d40c6aac00e384ab;hpb=6d420eff669a3de55be3ee348f88a4e244b78ecf diff --git a/src/common/event-rule/tracepoint.c b/src/common/event-rule/tracepoint.c index 14e4c7b01..93de1e98c 100644 --- a/src/common/event-rule/tracepoint.c +++ b/src/common/event-rule/tracepoint.c @@ -6,13 +6,17 @@ */ #include +#include #include #include #include #include #include +#include +#include #include #include +#include #define IS_TRACEPOINT_EVENT_RULE(rule) \ (lttng_event_rule_get_type(rule) == LTTNG_EVENT_RULE_TYPE_TRACEPOINT) @@ -357,7 +361,8 @@ end: static enum lttng_error_code lttng_event_rule_tracepoint_generate_filter_bytecode( - struct lttng_event_rule *rule, uid_t uid, gid_t gid) + struct lttng_event_rule *rule, + const struct lttng_credentials *creds) { int ret; enum lttng_error_code ret_code; @@ -365,7 +370,7 @@ lttng_event_rule_tracepoint_generate_filter_bytecode( enum lttng_domain_type domain_type; enum lttng_event_rule_status status; const char *filter; - struct lttng_filter_bytecode *bytecode = NULL; + struct lttng_bytecode *bytecode = NULL; assert(rule); @@ -429,7 +434,7 @@ lttng_event_rule_tracepoint_generate_filter_bytecode( } ret = run_as_generate_filter_bytecode( - tracepoint->internal_filter.filter, uid, gid, + tracepoint->internal_filter.filter, creds, &bytecode); if (ret) { ret_code = LTTNG_ERR_FILTER_INVAL; @@ -457,7 +462,7 @@ static const char *lttng_event_rule_tracepoint_get_internal_filter( return tracepoint->internal_filter.filter; } -static const struct lttng_filter_bytecode * +static const struct lttng_bytecode * lttng_event_rule_tracepoint_get_internal_filter_bytecode( const struct lttng_event_rule *rule) { @@ -469,19 +474,22 @@ lttng_event_rule_tracepoint_get_internal_filter_bytecode( return tracepoint->internal_filter.bytecode; } -static struct lttng_event_exclusion * +static enum lttng_event_rule_generate_exclusions_status lttng_event_rule_tracepoint_generate_exclusions( - const struct lttng_event_rule *rule) + const struct lttng_event_rule *rule, + struct lttng_event_exclusion **_exclusions) { - enum lttng_domain_type domain_type = LTTNG_DOMAIN_NONE; - enum lttng_event_rule_status status; - struct lttng_event_exclusion *local_exclusions = NULL; - struct lttng_event_exclusion *ret_exclusions = NULL; - unsigned int nb_exclusions = 0; - unsigned int i; + unsigned int nb_exclusions = 0, i; + enum lttng_domain_type domain_type; + struct lttng_event_exclusion *exclusions; + enum lttng_event_rule_status event_rule_status; + enum lttng_event_rule_generate_exclusions_status ret_status; - status = lttng_event_rule_tracepoint_get_domain_type(rule, &domain_type); - assert(status == LTTNG_EVENT_RULE_STATUS_OK); + assert(_exclusions); + + event_rule_status = lttng_event_rule_tracepoint_get_domain_type( + rule, &domain_type); + assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK); switch (domain_type) { case LTTNG_DOMAIN_KERNEL: @@ -489,50 +497,60 @@ lttng_event_rule_tracepoint_generate_exclusions( case LTTNG_DOMAIN_LOG4J: case LTTNG_DOMAIN_PYTHON: /* Not supported. */ - ret_exclusions = NULL; + exclusions = NULL; + ret_status = LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE; goto end; case LTTNG_DOMAIN_UST: /* Exclusions supported. */ break; default: + /* Unknown domain. */ abort(); } - status = lttng_event_rule_tracepoint_get_exclusions_count( + event_rule_status = lttng_event_rule_tracepoint_get_exclusions_count( rule, &nb_exclusions); - assert(status == LTTNG_EVENT_RULE_STATUS_OK); + assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK); if (nb_exclusions == 0) { /* Nothing to do. */ - ret_exclusions = NULL; + exclusions = NULL; + ret_status = LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE; goto end; } - local_exclusions = zmalloc(sizeof(struct lttng_event_exclusion) + - (LTTNG_SYMBOL_NAME_LEN * nb_exclusions)); - if (!local_exclusions) { + exclusions = zmalloc(sizeof(struct lttng_event_exclusion) + + (LTTNG_SYMBOL_NAME_LEN * nb_exclusions)); + if (!exclusions) { PERROR("Failed to allocate exclusions buffer"); - ret_exclusions = NULL; + ret_status = LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_OUT_OF_MEMORY; goto end; } - local_exclusions->count = nb_exclusions; + exclusions->count = nb_exclusions; for (i = 0; i < nb_exclusions; i++) { - /* Truncation is already checked at the setter level. */ - const char *tmp; - - status = lttng_event_rule_tracepoint_get_exclusion_at_index( - rule, i, &tmp); - assert(status == LTTNG_EVENT_RULE_STATUS_OK); - strncpy(local_exclusions->names[i], tmp, LTTNG_SYMBOL_NAME_LEN); - local_exclusions->names[i][LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; + int copy_ret; + const char *exclusion_str; + + event_rule_status = + lttng_event_rule_tracepoint_get_exclusion_at_index( + rule, i, &exclusion_str); + assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK); + + copy_ret = lttng_strncpy(exclusions->names[i], exclusion_str, + LTTNG_SYMBOL_NAME_LEN); + if (copy_ret) { + free(exclusions); + exclusions = NULL; + ret_status = LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_ERROR; + goto end; + } } - /* Pass ownership. */ - ret_exclusions = local_exclusions; - local_exclusions = NULL; + ret_status = LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_OK; + end: - free(local_exclusions); - return ret_exclusions; + *_exclusions = exclusions; + return ret_status; } static void destroy_lttng_exclusions_element(void *ptr) @@ -540,11 +558,89 @@ static void destroy_lttng_exclusions_element(void *ptr) free(ptr); } +static unsigned long lttng_event_rule_tracepoint_hash( + const struct lttng_event_rule *rule) +{ + unsigned long hash; + unsigned int i, exclusion_count; + enum lttng_event_rule_status status; + struct lttng_event_rule_tracepoint *tp_rule = + container_of(rule, typeof(*tp_rule), parent); + + hash = hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_TRACEPOINT, + lttng_ht_seed); + hash ^= hash_key_ulong((void *) tp_rule->domain, lttng_ht_seed); + hash ^= hash_key_str(tp_rule->pattern, lttng_ht_seed); + + if (tp_rule->filter_expression) { + hash ^= hash_key_str(tp_rule->filter_expression, lttng_ht_seed); + } + + hash ^= hash_key_ulong((void *) tp_rule->loglevel.type, + lttng_ht_seed); + if (tp_rule->loglevel.type != LTTNG_EVENT_LOGLEVEL_ALL) { + hash ^= hash_key_ulong( + (void *) (unsigned long) tp_rule->loglevel.value, + lttng_ht_seed); + } + + status = lttng_event_rule_tracepoint_get_exclusions_count(rule, + &exclusion_count); + assert(status == LTTNG_EVENT_RULE_STATUS_OK); + + for (i = 0; i < exclusion_count; i++) { + const char *exclusion; + + status = lttng_event_rule_tracepoint_get_exclusion_at_index( + rule, i, &exclusion); + assert(status == LTTNG_EVENT_RULE_STATUS_OK); + hash ^= hash_key_str(exclusion, lttng_ht_seed); + } + + return hash; +} + +static struct lttng_event *lttng_event_rule_tracepoint_generate_lttng_event( + const struct lttng_event_rule *rule) +{ + int ret; + const struct lttng_event_rule_tracepoint *tracepoint; + struct lttng_event *local_event = NULL; + struct lttng_event *event = NULL; + + tracepoint = container_of( + rule, const struct lttng_event_rule_tracepoint, parent); + + local_event = zmalloc(sizeof(*local_event)); + if (!local_event) { + goto error; + } + + local_event->type = LTTNG_EVENT_TRACEPOINT; + ret = lttng_strncpy(local_event->name, tracepoint->pattern, + sizeof(local_event->name)); + if (ret) { + ERR("Truncation occurred when copying event rule pattern to `lttng_event` structure: pattern = '%s'", + tracepoint->pattern); + goto error; + } + + local_event->loglevel_type = tracepoint->loglevel.type; + local_event->loglevel = tracepoint->loglevel.value; + + event = local_event; + local_event = NULL; +error: + free(local_event); + return event; +} + struct lttng_event_rule *lttng_event_rule_tracepoint_create( enum lttng_domain_type domain_type) { struct lttng_event_rule *rule = NULL; struct lttng_event_rule_tracepoint *tp_rule; + enum lttng_event_rule_status status; if (domain_type == LTTNG_DOMAIN_NONE) { goto end; @@ -569,12 +665,23 @@ struct lttng_event_rule *lttng_event_rule_tracepoint_create( lttng_event_rule_tracepoint_get_internal_filter_bytecode; tp_rule->parent.generate_exclusions = lttng_event_rule_tracepoint_generate_exclusions; + tp_rule->parent.hash = lttng_event_rule_tracepoint_hash; + tp_rule->parent.generate_lttng_event = + lttng_event_rule_tracepoint_generate_lttng_event; tp_rule->domain = domain_type; tp_rule->loglevel.type = LTTNG_EVENT_LOGLEVEL_ALL; lttng_dynamic_pointer_array_init(&tp_rule->exclusions, destroy_lttng_exclusions_element); + + /* Default pattern is '*'. */ + status = lttng_event_rule_tracepoint_set_pattern(rule, "*"); + if (status != LTTNG_EVENT_RULE_STATUS_OK) { + lttng_event_rule_destroy(rule); + rule = NULL; + } + end: return rule; } @@ -603,21 +710,16 @@ ssize_t lttng_event_rule_tracepoint_create_from_payload( goto end; } - if (view->buffer.size < sizeof(*tracepoint_comm)) { + current_buffer_view = lttng_buffer_view_from_view( + &view->buffer, offset, sizeof(*tracepoint_comm)); + if (!lttng_buffer_view_is_valid(¤t_buffer_view)) { ERR("Failed to initialize from malformed event rule tracepoint: buffer too short to contain header."); ret = -1; goto end; } - current_buffer_view = lttng_buffer_view_from_view( - &view->buffer, offset, sizeof(*tracepoint_comm)); tracepoint_comm = (typeof(tracepoint_comm)) current_buffer_view.data; - if (!tracepoint_comm) { - ret = -1; - goto end; - } - if (tracepoint_comm->domain_type <= LTTNG_DOMAIN_NONE || tracepoint_comm->domain_type > LTTNG_DOMAIN_PYTHON) { /* Invalid domain value. */ @@ -667,12 +769,13 @@ ssize_t lttng_event_rule_tracepoint_create_from_payload( /* Map the pattern. */ current_buffer_view = lttng_buffer_view_from_view( &view->buffer, offset, tracepoint_comm->pattern_len); - pattern = current_buffer_view.data; - if (!pattern) { + + if (!lttng_buffer_view_is_valid(¤t_buffer_view)) { ret = -1; goto end; } + pattern = current_buffer_view.data; if (!lttng_buffer_view_contains_string(¤t_buffer_view, pattern, tracepoint_comm->pattern_len)) { ret = -1; @@ -689,12 +792,12 @@ ssize_t lttng_event_rule_tracepoint_create_from_payload( /* Map the filter_expression. */ current_buffer_view = lttng_buffer_view_from_view(&view->buffer, offset, tracepoint_comm->filter_expression_len); - filter_expression = current_buffer_view.data; - if (!filter_expression) { + if (!lttng_buffer_view_is_valid(¤t_buffer_view)) { ret = -1; goto end; } + filter_expression = current_buffer_view.data; if (!lttng_buffer_view_contains_string(¤t_buffer_view, filter_expression, tracepoint_comm->filter_expression_len)) { @@ -709,15 +812,21 @@ skip_filter_expression: for (i = 0; i < tracepoint_comm->exclusions_count; i++) { current_buffer_view = lttng_buffer_view_from_view( &view->buffer, offset, sizeof(*exclusion_len)); - exclusion_len = (typeof(exclusion_len)) current_buffer_view.data; - if (!exclusion_len) { + if (!lttng_buffer_view_is_valid(¤t_buffer_view)) { ret = -1; goto end; } + exclusion_len = (typeof(exclusion_len)) current_buffer_view.data; offset += sizeof(*exclusion_len); + current_buffer_view = lttng_buffer_view_from_view( &view->buffer, offset, *exclusion_len); + if (!lttng_buffer_view_is_valid(¤t_buffer_view)) { + ret = -1; + goto end; + } + exclusion = current_buffer_view.data; if (!lttng_buffer_view_contains_string(¤t_buffer_view, exclusion, *exclusion_len)) {