X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fcommon%2Fevent-rule%2Fsyscall.c;h=4ac6a11af7ac777d0a128d414aa09025522fd1c9;hb=f6a5af193de5e5f219111604382ec69b784a49c7;hp=ef7ccd0f9a038505c4cec79fea5b0f6c7fb4428e;hpb=e6a39346997db7e1d40026b2cc10be5893723eb3;p=lttng-tools.git diff --git a/src/common/event-rule/syscall.c b/src/common/event-rule/syscall.c index ef7ccd0f9..4ac6a11af 100644 --- a/src/common/event-rule/syscall.c +++ b/src/common/event-rule/syscall.c @@ -6,11 +6,15 @@ */ #include +#include #include #include #include #include #include +#include +#include +#include #include #include @@ -84,6 +88,7 @@ static int lttng_event_rule_syscall_serialize( syscall_comm.pattern_len = pattern_len; syscall_comm.filter_expression_len = filter_expression_len; + syscall_comm.emission_site = syscall->emission_site; ret = lttng_dynamic_buffer_append( &payload->buffer, &syscall_comm, sizeof(syscall_comm)); @@ -137,14 +142,15 @@ end: } static enum lttng_error_code lttng_event_rule_syscall_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 = LTTNG_OK; struct lttng_event_rule_syscall *syscall; enum lttng_event_rule_status status; const char *filter; - struct lttng_filter_bytecode *bytecode = NULL; + struct lttng_bytecode *bytecode = NULL; assert(rule); @@ -177,7 +183,7 @@ static enum lttng_error_code lttng_event_rule_syscall_generate_filter_bytecode( } ret = run_as_generate_filter_bytecode( - syscall->internal_filter.filter, uid, gid, &bytecode); + syscall->internal_filter.filter, creds, &bytecode); if (ret) { ret_code = LTTNG_ERR_FILTER_INVAL; } @@ -201,7 +207,7 @@ static const char *lttng_event_rule_syscall_get_internal_filter( return syscall->internal_filter.filter; } -static const struct lttng_filter_bytecode * +static const struct lttng_bytecode * lttng_event_rule_syscall_get_internal_filter_bytecode( const struct lttng_event_rule *rule) { @@ -213,18 +219,52 @@ lttng_event_rule_syscall_get_internal_filter_bytecode( return syscall->internal_filter.bytecode; } -static struct lttng_event_exclusion * -lttng_event_rule_syscall_generate_exclusions( +static enum lttng_event_rule_generate_exclusions_status +lttng_event_rule_syscall_generate_exclusions(const struct lttng_event_rule *rule, + struct lttng_event_exclusion **exclusions) +{ + /* Unsupported. */ + *exclusions = NULL; + return LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE; +} + +static unsigned long +lttng_event_rule_syscall_hash( const struct lttng_event_rule *rule) { - /* Not supported. */ - return NULL; + unsigned long hash; + struct lttng_event_rule_syscall *syscall_rule = + container_of(rule, typeof(*syscall_rule), parent); + + hash = hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_SYSCALL, + lttng_ht_seed); + hash ^= hash_key_str(syscall_rule->pattern, lttng_ht_seed); + if (syscall_rule->filter_expression) { + hash ^= hash_key_str(syscall_rule->filter_expression, + lttng_ht_seed); + } + + return hash; } -struct lttng_event_rule *lttng_event_rule_syscall_create() +struct lttng_event_rule *lttng_event_rule_syscall_create( + enum lttng_event_rule_syscall_emission_site + emission_site) { struct lttng_event_rule *rule = NULL; struct lttng_event_rule_syscall *syscall_rule; + enum lttng_event_rule_status status; + + /* Validate the emission site type */ + switch (emission_site) { + case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY_EXIT: + case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY: + case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_EXIT: + break; + default: + /* Invalid emission type */ + goto end; + } syscall_rule = zmalloc(sizeof(struct lttng_event_rule_syscall)); if (!syscall_rule) { @@ -246,6 +286,18 @@ struct lttng_event_rule *lttng_event_rule_syscall_create() lttng_event_rule_syscall_get_internal_filter_bytecode; syscall_rule->parent.generate_exclusions = lttng_event_rule_syscall_generate_exclusions; + syscall_rule->parent.hash = lttng_event_rule_syscall_hash; + + /* Default pattern is '*'. */ + status = lttng_event_rule_syscall_set_name_pattern(rule, "*"); + if (status != LTTNG_EVENT_RULE_STATUS_OK) { + lttng_event_rule_destroy(rule); + rule = NULL; + } + + /* Emission site type */ + syscall_rule->emission_site = emission_site; + end: return rule; } @@ -276,14 +328,13 @@ ssize_t lttng_event_rule_syscall_create_from_payload( current_buffer_view = lttng_buffer_view_from_view( &view->buffer, offset, sizeof(*syscall_comm)); - syscall_comm = (typeof(syscall_comm)) current_buffer_view.data; - - if (!syscall_comm) { + if (!lttng_buffer_view_is_valid(¤t_buffer_view)) { ret = -1; goto end; } - rule = lttng_event_rule_syscall_create(); + syscall_comm = (typeof(syscall_comm)) current_buffer_view.data; + rule = lttng_event_rule_syscall_create(syscall_comm->emission_site); if (!rule) { ERR("Failed to create event rule syscall"); ret = -1; @@ -296,12 +347,12 @@ ssize_t lttng_event_rule_syscall_create_from_payload( /* Map the pattern. */ current_buffer_view = lttng_buffer_view_from_view( &view->buffer, offset, syscall_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, syscall_comm->pattern_len)) { ret = -1; @@ -318,12 +369,12 @@ ssize_t lttng_event_rule_syscall_create_from_payload( /* Map the filter_expression. */ current_buffer_view = lttng_buffer_view_from_view(&view->buffer, offset, syscall_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, syscall_comm->filter_expression_len)) { @@ -336,7 +387,7 @@ ssize_t lttng_event_rule_syscall_create_from_payload( skip_filter_expression: - status = lttng_event_rule_syscall_set_pattern(rule, pattern); + status = lttng_event_rule_syscall_set_name_pattern(rule, pattern); if (status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to set event rule syscall pattern"); ret = -1; @@ -361,7 +412,7 @@ end: return ret; } -enum lttng_event_rule_status lttng_event_rule_syscall_set_pattern( +enum lttng_event_rule_status lttng_event_rule_syscall_set_name_pattern( struct lttng_event_rule *rule, const char *pattern) { char *pattern_copy = NULL; @@ -381,9 +432,9 @@ enum lttng_event_rule_status lttng_event_rule_syscall_set_pattern( goto end; } - if (syscall->pattern) { - free(syscall->pattern); - } + strutils_normalize_star_glob_pattern(pattern_copy); + + free(syscall->pattern); syscall->pattern = pattern_copy; pattern_copy = NULL; @@ -391,7 +442,7 @@ end: return status; } -enum lttng_event_rule_status lttng_event_rule_syscall_get_pattern( +enum lttng_event_rule_status lttng_event_rule_syscall_get_name_pattern( const struct lttng_event_rule *rule, const char **pattern) { struct lttng_event_rule_syscall *syscall; @@ -466,3 +517,37 @@ enum lttng_event_rule_status lttng_event_rule_syscall_get_filter( end: return status; } +extern enum lttng_event_rule_syscall_emission_site +lttng_event_rule_syscall_get_emission_site( + const struct lttng_event_rule *rule) +{ + enum lttng_event_rule_syscall_emission_site emission_site = + LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_UNKNOWN; + struct lttng_event_rule_syscall *syscall; + + if (!rule || !IS_SYSCALL_EVENT_RULE(rule)) { + goto end; + } + + syscall = container_of(rule, struct lttng_event_rule_syscall, parent); + emission_site = syscall->emission_site; + +end: + return emission_site; +} + +LTTNG_HIDDEN +const char *lttng_event_rule_syscall_emission_site_str( + enum lttng_event_rule_syscall_emission_site emission_site) +{ + switch (emission_site) { + case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY: + return "entry"; + case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY_EXIT: + return "entry+exit"; + case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_EXIT: + return "exit"; + default: + return "???"; + } +}