X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fcommon%2Fevent-rule%2Fkernel-syscall.cpp;h=23a432aacaaff285e6f0e3cb735d8cb1b4b3f26a;hb=5c7248cd5bce45bf64d563fb4e130a63bf345f11;hp=d006eaa054960b29eeb59edf0e342cc60ba19459;hpb=64803277bbdbe0a943360d918298a48157d9da55;p=lttng-tools.git diff --git a/src/common/event-rule/kernel-syscall.cpp b/src/common/event-rule/kernel-syscall.cpp index d006eaa05..23a432aac 100644 --- a/src/common/event-rule/kernel-syscall.cpp +++ b/src/common/event-rule/kernel-syscall.cpp @@ -15,6 +15,7 @@ #include #include #include + #include #include @@ -25,11 +26,11 @@ static void lttng_event_rule_kernel_syscall_destroy(struct lttng_event_rule *rul { struct lttng_event_rule_kernel_syscall *syscall; - if (rule == NULL) { + if (rule == nullptr) { return; } - syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); + syscall = lttng::utils::container_of(rule, <tng_event_rule_kernel_syscall::parent); free(syscall->pattern); free(syscall->filter_expression); @@ -38,8 +39,7 @@ static void lttng_event_rule_kernel_syscall_destroy(struct lttng_event_rule *rul free(syscall); } -static bool lttng_event_rule_kernel_syscall_validate( - const struct lttng_event_rule *rule) +static bool lttng_event_rule_kernel_syscall_validate(const struct lttng_event_rule *rule) { bool valid = false; struct lttng_event_rule_kernel_syscall *syscall; @@ -48,7 +48,7 @@ static bool lttng_event_rule_kernel_syscall_validate( goto end; } - syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); + syscall = lttng::utils::container_of(rule, <tng_event_rule_kernel_syscall::parent); /* Required field. */ if (!syscall->pattern) { @@ -61,9 +61,8 @@ end: return valid; } -static int lttng_event_rule_kernel_syscall_serialize( - const struct lttng_event_rule *rule, - struct lttng_payload *payload) +static int lttng_event_rule_kernel_syscall_serialize(const struct lttng_event_rule *rule, + struct lttng_payload *payload) { int ret; size_t pattern_len, filter_expression_len; @@ -76,11 +75,11 @@ static int lttng_event_rule_kernel_syscall_serialize( } DBG("Serializing syscall event rule"); - syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); + syscall = lttng::utils::container_of(rule, <tng_event_rule_kernel_syscall::parent); pattern_len = strlen(syscall->pattern) + 1; - if (syscall->filter_expression != NULL) { + if (syscall->filter_expression != nullptr) { filter_expression_len = strlen(syscall->filter_expression) + 1; } else { filter_expression_len = 0; @@ -90,32 +89,30 @@ static int lttng_event_rule_kernel_syscall_serialize( 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)); + ret = lttng_dynamic_buffer_append(&payload->buffer, &syscall_comm, sizeof(syscall_comm)); if (ret) { goto end; } - ret = lttng_dynamic_buffer_append( - &payload->buffer, syscall->pattern, pattern_len); + ret = lttng_dynamic_buffer_append(&payload->buffer, syscall->pattern, pattern_len); if (ret) { goto end; } - ret = lttng_dynamic_buffer_append(&payload->buffer, - syscall->filter_expression, filter_expression_len); + ret = lttng_dynamic_buffer_append( + &payload->buffer, syscall->filter_expression, filter_expression_len); end: return ret; } static bool lttng_event_rule_kernel_syscall_is_equal(const struct lttng_event_rule *_a, - const struct lttng_event_rule *_b) + const struct lttng_event_rule *_b) { bool is_equal = false; struct lttng_event_rule_kernel_syscall *a, *b; - a = container_of(_a, struct lttng_event_rule_kernel_syscall, parent); - b = container_of(_b, struct lttng_event_rule_kernel_syscall, parent); + a = lttng::utils::container_of(_a, <tng_event_rule_kernel_syscall::parent); + b = lttng::utils::container_of(_b, <tng_event_rule_kernel_syscall::parent); if (!!a->filter_expression != !!b->filter_expression) { goto end; @@ -123,12 +120,12 @@ static bool lttng_event_rule_kernel_syscall_is_equal(const struct lttng_event_ru LTTNG_ASSERT(a->pattern); LTTNG_ASSERT(b->pattern); - if (strcmp(a->pattern, b->pattern)) { + if (strcmp(a->pattern, b->pattern) != 0) { goto end; } if (a->filter_expression && b->filter_expression) { - if (strcmp(a->filter_expression, b->filter_expression)) { + if (strcmp(a->filter_expression, b->filter_expression) != 0) { goto end; } } else if (!!a->filter_expression != !!b->filter_expression) { @@ -141,25 +138,25 @@ end: return is_equal; } -static enum lttng_error_code lttng_event_rule_kernel_syscall_generate_filter_bytecode( - struct lttng_event_rule *rule, - const struct lttng_credentials *creds) +static enum lttng_error_code +lttng_event_rule_kernel_syscall_generate_filter_bytecode(struct lttng_event_rule *rule, + const struct lttng_credentials *creds) { int ret; enum lttng_error_code ret_code = LTTNG_OK; struct lttng_event_rule_kernel_syscall *syscall; enum lttng_event_rule_status status; const char *filter; - struct lttng_bytecode *bytecode = NULL; + struct lttng_bytecode *bytecode = nullptr; LTTNG_ASSERT(rule); - syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); + syscall = lttng::utils::container_of(rule, <tng_event_rule_kernel_syscall::parent); /* Generate the filter bytecode. */ status = lttng_event_rule_kernel_syscall_get_filter(rule, &filter); if (status == LTTNG_EVENT_RULE_STATUS_UNSET) { - filter = NULL; + filter = nullptr; } else if (status != LTTNG_EVENT_RULE_STATUS_OK) { ret_code = LTTNG_ERR_FILTER_INVAL; goto end; @@ -170,108 +167,102 @@ static enum lttng_error_code lttng_event_rule_kernel_syscall_generate_filter_byt goto end; } - if (filter == NULL) { + if (filter == nullptr) { /* Nothing to do. */ ret = LTTNG_OK; goto end; } syscall->internal_filter.filter = strdup(filter); - if (syscall->internal_filter.filter == NULL) { + if (syscall->internal_filter.filter == nullptr) { ret_code = LTTNG_ERR_NOMEM; goto end; } - ret = run_as_generate_filter_bytecode( - syscall->internal_filter.filter, creds, &bytecode); + ret = run_as_generate_filter_bytecode(syscall->internal_filter.filter, creds, &bytecode); if (ret) { ret_code = LTTNG_ERR_FILTER_INVAL; } syscall->internal_filter.bytecode = bytecode; - bytecode = NULL; + bytecode = nullptr; end: free(bytecode); return ret_code; } -static const char *lttng_event_rule_kernel_syscall_get_internal_filter( - const struct lttng_event_rule *rule) +static const char * +lttng_event_rule_kernel_syscall_get_internal_filter(const struct lttng_event_rule *rule) { struct lttng_event_rule_kernel_syscall *syscall; LTTNG_ASSERT(rule); - syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); + syscall = lttng::utils::container_of(rule, <tng_event_rule_kernel_syscall::parent); return syscall->internal_filter.filter; } static const struct lttng_bytecode * -lttng_event_rule_kernel_syscall_get_internal_filter_bytecode( - const struct lttng_event_rule *rule) +lttng_event_rule_kernel_syscall_get_internal_filter_bytecode(const struct lttng_event_rule *rule) { struct lttng_event_rule_kernel_syscall *syscall; LTTNG_ASSERT(rule); - syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); + syscall = lttng::utils::container_of(rule, <tng_event_rule_kernel_syscall::parent); return syscall->internal_filter.bytecode; } static enum lttng_event_rule_generate_exclusions_status -lttng_event_rule_kernel_syscall_generate_exclusions( - const struct lttng_event_rule *rule __attribute__((unused)), - struct lttng_event_exclusion **exclusions) +lttng_event_rule_kernel_syscall_generate_exclusions(const struct lttng_event_rule *rule + __attribute__((unused)), + struct lttng_event_exclusion **exclusions) { /* Unsupported. */ - *exclusions = NULL; + *exclusions = nullptr; return LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE; } -static unsigned long -lttng_event_rule_kernel_syscall_hash( - const struct lttng_event_rule *rule) +static unsigned long lttng_event_rule_kernel_syscall_hash(const struct lttng_event_rule *rule) { unsigned long hash; struct lttng_event_rule_kernel_syscall *syscall_rule = - container_of(rule, typeof(*syscall_rule), parent); + lttng::utils::container_of(rule, <tng_event_rule_kernel_syscall::parent); - hash = hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL, - lttng_ht_seed); + hash = hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_KERNEL_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); + hash ^= hash_key_str(syscall_rule->filter_expression, lttng_ht_seed); } return hash; } -static enum lttng_error_code lttng_event_rule_kernel_syscall_mi_serialize( - const struct lttng_event_rule *rule, struct mi_writer *writer) +static enum lttng_error_code +lttng_event_rule_kernel_syscall_mi_serialize(const struct lttng_event_rule *rule, + struct mi_writer *writer) { int ret; enum lttng_error_code ret_code; enum lttng_event_rule_status status; enum lttng_event_rule_kernel_syscall_emission_site site_type; - const char *filter = NULL; - const char *name_pattern = NULL; - const char *site_type_str = NULL; + const char *filter = nullptr; + const char *name_pattern = nullptr; + const char *site_type_str = nullptr; LTTNG_ASSERT(rule); LTTNG_ASSERT(writer); LTTNG_ASSERT(IS_SYSCALL_EVENT_RULE(rule)); - status = lttng_event_rule_kernel_syscall_get_name_pattern( - rule, &name_pattern); + status = lttng_event_rule_kernel_syscall_get_name_pattern(rule, &name_pattern); LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK); LTTNG_ASSERT(name_pattern); status = lttng_event_rule_kernel_syscall_get_filter(rule, &filter); LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK || - status == LTTNG_EVENT_RULE_STATUS_UNSET); + status == LTTNG_EVENT_RULE_STATUS_UNSET); site_type = lttng_event_rule_kernel_syscall_get_emission_site(rule); @@ -291,32 +282,29 @@ static enum lttng_error_code lttng_event_rule_kernel_syscall_mi_serialize( } /* Open event rule kernel syscall element. */ - ret = mi_lttng_writer_open_element( - writer, mi_lttng_element_event_rule_kernel_syscall); + ret = mi_lttng_writer_open_element(writer, mi_lttng_element_event_rule_kernel_syscall); if (ret) { goto mi_error; } /* Emission site. */ - ret = mi_lttng_writer_write_element_string(writer, - mi_lttng_element_event_rule_kernel_syscall_emission_site, - site_type_str); + ret = mi_lttng_writer_write_element_string( + writer, mi_lttng_element_event_rule_kernel_syscall_emission_site, site_type_str); if (ret) { goto mi_error; } /* Name pattern. */ - ret = mi_lttng_writer_write_element_string(writer, - mi_lttng_element_event_rule_name_pattern, name_pattern); + ret = mi_lttng_writer_write_element_string( + writer, mi_lttng_element_event_rule_name_pattern, name_pattern); if (ret) { goto mi_error; } /* Filter. */ - if (filter != NULL) { - ret = mi_lttng_writer_write_element_string(writer, - mi_lttng_element_event_rule_filter_expression, - filter); + if (filter != nullptr) { + ret = mi_lttng_writer_write_element_string( + writer, mi_lttng_element_event_rule_filter_expression, filter); if (ret) { goto mi_error; } @@ -338,10 +326,9 @@ end: } struct lttng_event_rule *lttng_event_rule_kernel_syscall_create( - enum lttng_event_rule_kernel_syscall_emission_site - emission_site) + enum lttng_event_rule_kernel_syscall_emission_site emission_site) { - struct lttng_event_rule *rule = NULL; + struct lttng_event_rule *rule = nullptr; struct lttng_event_rule_kernel_syscall *syscall_rule; enum lttng_event_rule_status status; @@ -362,20 +349,18 @@ struct lttng_event_rule *lttng_event_rule_kernel_syscall_create( } rule = &syscall_rule->parent; - lttng_event_rule_init( - &syscall_rule->parent, LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL); + lttng_event_rule_init(&syscall_rule->parent, LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL); syscall_rule->parent.validate = lttng_event_rule_kernel_syscall_validate; syscall_rule->parent.serialize = lttng_event_rule_kernel_syscall_serialize; syscall_rule->parent.equal = lttng_event_rule_kernel_syscall_is_equal; syscall_rule->parent.destroy = lttng_event_rule_kernel_syscall_destroy; syscall_rule->parent.generate_filter_bytecode = - lttng_event_rule_kernel_syscall_generate_filter_bytecode; - syscall_rule->parent.get_filter = - lttng_event_rule_kernel_syscall_get_internal_filter; + lttng_event_rule_kernel_syscall_generate_filter_bytecode; + syscall_rule->parent.get_filter = lttng_event_rule_kernel_syscall_get_internal_filter; syscall_rule->parent.get_filter_bytecode = - lttng_event_rule_kernel_syscall_get_internal_filter_bytecode; + lttng_event_rule_kernel_syscall_get_internal_filter_bytecode; syscall_rule->parent.generate_exclusions = - lttng_event_rule_kernel_syscall_generate_exclusions; + lttng_event_rule_kernel_syscall_generate_exclusions; syscall_rule->parent.hash = lttng_event_rule_kernel_syscall_hash; syscall_rule->parent.mi_serialize = lttng_event_rule_kernel_syscall_mi_serialize; @@ -383,7 +368,7 @@ struct lttng_event_rule *lttng_event_rule_kernel_syscall_create( status = lttng_event_rule_kernel_syscall_set_name_pattern(rule, "*"); if (status != LTTNG_EVENT_RULE_STATUS_OK) { lttng_event_rule_destroy(rule); - rule = NULL; + rule = nullptr; } /* Emission site type */ @@ -393,17 +378,16 @@ end: return rule; } -ssize_t lttng_event_rule_kernel_syscall_create_from_payload( - struct lttng_payload_view *view, - struct lttng_event_rule **_event_rule) +ssize_t lttng_event_rule_kernel_syscall_create_from_payload(struct lttng_payload_view *view, + struct lttng_event_rule **_event_rule) { ssize_t ret, offset = 0; enum lttng_event_rule_status status; const struct lttng_event_rule_kernel_syscall_comm *syscall_comm; const char *pattern; - const char *filter_expression = NULL; + const char *filter_expression = nullptr; struct lttng_buffer_view current_buffer_view; - struct lttng_event_rule *rule = NULL; + struct lttng_event_rule *rule = nullptr; if (!_event_rule) { ret = -1; @@ -416,15 +400,16 @@ ssize_t lttng_event_rule_kernel_syscall_create_from_payload( goto end; } - current_buffer_view = lttng_buffer_view_from_view( - &view->buffer, offset, sizeof(*syscall_comm)); + current_buffer_view = + lttng_buffer_view_from_view(&view->buffer, offset, sizeof(*syscall_comm)); if (!lttng_buffer_view_is_valid(¤t_buffer_view)) { ret = -1; goto end; } syscall_comm = (typeof(syscall_comm)) current_buffer_view.data; - rule = lttng_event_rule_kernel_syscall_create((lttng_event_rule_kernel_syscall_emission_site) syscall_comm->emission_site); + rule = lttng_event_rule_kernel_syscall_create( + (lttng_event_rule_kernel_syscall_emission_site) syscall_comm->emission_site); if (!rule) { ERR("Failed to create event rule syscall"); ret = -1; @@ -435,16 +420,16 @@ ssize_t lttng_event_rule_kernel_syscall_create_from_payload( offset += current_buffer_view.size; /* Map the pattern. */ - current_buffer_view = lttng_buffer_view_from_view( - &view->buffer, offset, syscall_comm->pattern_len); + current_buffer_view = + lttng_buffer_view_from_view(&view->buffer, offset, syscall_comm->pattern_len); 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)) { + if (!lttng_buffer_view_contains_string( + ¤t_buffer_view, pattern, syscall_comm->pattern_len)) { ret = -1; goto end; } @@ -457,17 +442,16 @@ ssize_t lttng_event_rule_kernel_syscall_create_from_payload( } /* Map the filter_expression. */ - current_buffer_view = lttng_buffer_view_from_view(&view->buffer, offset, - syscall_comm->filter_expression_len); + current_buffer_view = lttng_buffer_view_from_view( + &view->buffer, offset, syscall_comm->filter_expression_len); 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)) { + if (!lttng_buffer_view_contains_string( + ¤t_buffer_view, filter_expression, syscall_comm->filter_expression_len)) { ret = -1; goto end; } @@ -485,8 +469,7 @@ skip_filter_expression: } if (filter_expression) { - status = lttng_event_rule_kernel_syscall_set_filter( - rule, filter_expression); + status = lttng_event_rule_kernel_syscall_set_filter(rule, filter_expression); if (status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to set event rule syscall pattern"); ret = -1; @@ -495,27 +478,26 @@ skip_filter_expression: } *_event_rule = rule; - rule = NULL; + rule = nullptr; ret = offset; end: lttng_event_rule_destroy(rule); return ret; } -enum lttng_event_rule_status lttng_event_rule_kernel_syscall_set_name_pattern( - struct lttng_event_rule *rule, const char *pattern) +enum lttng_event_rule_status +lttng_event_rule_kernel_syscall_set_name_pattern(struct lttng_event_rule *rule, const char *pattern) { - char *pattern_copy = NULL; + char *pattern_copy = nullptr; struct lttng_event_rule_kernel_syscall *syscall; enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK; - if (!rule || !IS_SYSCALL_EVENT_RULE(rule) || !pattern || - strlen(pattern) == 0) { + if (!rule || !IS_SYSCALL_EVENT_RULE(rule) || !pattern || strlen(pattern) == 0) { status = LTTNG_EVENT_RULE_STATUS_INVALID; goto end; } - syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); + syscall = lttng::utils::container_of(rule, <tng_event_rule_kernel_syscall::parent); pattern_copy = strdup(pattern); if (!pattern_copy) { status = LTTNG_EVENT_RULE_STATUS_ERROR; @@ -527,13 +509,14 @@ enum lttng_event_rule_status lttng_event_rule_kernel_syscall_set_name_pattern( free(syscall->pattern); syscall->pattern = pattern_copy; - pattern_copy = NULL; + pattern_copy = nullptr; end: return status; } -enum lttng_event_rule_status lttng_event_rule_kernel_syscall_get_name_pattern( - const struct lttng_event_rule *rule, const char **pattern) +enum lttng_event_rule_status +lttng_event_rule_kernel_syscall_get_name_pattern(const struct lttng_event_rule *rule, + const char **pattern) { struct lttng_event_rule_kernel_syscall *syscall; enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK; @@ -543,7 +526,7 @@ enum lttng_event_rule_status lttng_event_rule_kernel_syscall_get_name_pattern( goto end; } - syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); + syscall = lttng::utils::container_of(rule, <tng_event_rule_kernel_syscall::parent); if (!syscall->pattern) { status = LTTNG_EVENT_RULE_STATUS_UNSET; goto end; @@ -554,22 +537,21 @@ end: return status; } -enum lttng_event_rule_status lttng_event_rule_kernel_syscall_set_filter( - struct lttng_event_rule *rule, const char *expression) +enum lttng_event_rule_status +lttng_event_rule_kernel_syscall_set_filter(struct lttng_event_rule *rule, const char *expression) { - char *expression_copy = NULL; + char *expression_copy = nullptr; struct lttng_event_rule_kernel_syscall *syscall; enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK; /* TODO: validate that the passed expression is valid. */ - if (!rule || !IS_SYSCALL_EVENT_RULE(rule) || !expression || - strlen(expression) == 0) { + if (!rule || !IS_SYSCALL_EVENT_RULE(rule) || !expression || strlen(expression) == 0) { status = LTTNG_EVENT_RULE_STATUS_INVALID; goto end; } - syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); + syscall = lttng::utils::container_of(rule, <tng_event_rule_kernel_syscall::parent); expression_copy = strdup(expression); if (!expression_copy) { status = LTTNG_EVENT_RULE_STATUS_ERROR; @@ -581,13 +563,14 @@ enum lttng_event_rule_status lttng_event_rule_kernel_syscall_set_filter( } syscall->filter_expression = expression_copy; - expression_copy = NULL; + expression_copy = nullptr; end: return status; } -enum lttng_event_rule_status lttng_event_rule_kernel_syscall_get_filter( - const struct lttng_event_rule *rule, const char **expression) +enum lttng_event_rule_status +lttng_event_rule_kernel_syscall_get_filter(const struct lttng_event_rule *rule, + const char **expression) { struct lttng_event_rule_kernel_syscall *syscall; enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK; @@ -597,7 +580,7 @@ enum lttng_event_rule_status lttng_event_rule_kernel_syscall_get_filter( goto end; } - syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); + syscall = lttng::utils::container_of(rule, <tng_event_rule_kernel_syscall::parent); if (!syscall->filter_expression) { status = LTTNG_EVENT_RULE_STATUS_UNSET; goto end; @@ -608,8 +591,7 @@ end: return status; } extern enum lttng_event_rule_kernel_syscall_emission_site -lttng_event_rule_kernel_syscall_get_emission_site( - const struct lttng_event_rule *rule) +lttng_event_rule_kernel_syscall_get_emission_site(const struct lttng_event_rule *rule) { enum lttng_event_rule_kernel_syscall_emission_site emission_site = LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_UNKNOWN; @@ -619,7 +601,7 @@ lttng_event_rule_kernel_syscall_get_emission_site( goto end; } - syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); + syscall = lttng::utils::container_of(rule, <tng_event_rule_kernel_syscall::parent); emission_site = syscall->emission_site; end: @@ -627,7 +609,7 @@ end: } const char *lttng_event_rule_kernel_syscall_emission_site_str( - enum lttng_event_rule_kernel_syscall_emission_site emission_site) + enum lttng_event_rule_kernel_syscall_emission_site emission_site) { switch (emission_site) { case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY: