{
struct lttng_event_rule_user_tracepoint *tracepoint;
- if (rule == NULL) {
+ if (rule == nullptr) {
return;
}
pattern_len = strlen(tracepoint->pattern) + 1;
- if (tracepoint->filter_expression != NULL) {
+ if (tracepoint->filter_expression != nullptr) {
filter_expression_len = strlen(tracepoint->filter_expression) + 1;
} else {
filter_expression_len = 0;
for (i = 0; i < exclusion_count; i++) {
size_t len;
+ uint32_t serialized_len;
const char *exclusion;
status = lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK);
len = strlen(exclusion) + 1;
+
+ serialized_len = len;
/* Append exclusion length, includes the null terminator. */
- ret = lttng_dynamic_buffer_append(&payload->buffer, &len, sizeof(uint32_t));
+ ret = lttng_dynamic_buffer_append(
+ &payload->buffer, &serialized_len, sizeof(serialized_len));
if (ret) {
goto end;
}
/* Long check. */
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) {
status = lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
_b, i, &exclusion_b);
LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK);
- if (strcmp(exclusion_a, exclusion_b)) {
+ if (strcmp(exclusion_a, exclusion_b) != 0) {
goto end;
}
}
struct lttng_event_rule_user_tracepoint *tracepoint;
enum lttng_event_rule_status status;
const char *filter;
- struct lttng_bytecode *bytecode = NULL;
+ struct lttng_bytecode *bytecode = nullptr;
LTTNG_ASSERT(rule);
status = lttng_event_rule_user_tracepoint_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;
if (filter) {
tracepoint->internal_filter.filter = strdup(filter);
- if (tracepoint->internal_filter.filter == NULL) {
+ if (tracepoint->internal_filter.filter == nullptr) {
ret_code = LTTNG_ERR_NOMEM;
goto error;
}
} else {
- tracepoint->internal_filter.filter = NULL;
+ tracepoint->internal_filter.filter = nullptr;
}
- if (tracepoint->internal_filter.filter == NULL) {
+ if (tracepoint->internal_filter.filter == nullptr) {
ret_code = LTTNG_OK;
goto end;
}
}
tracepoint->internal_filter.bytecode = bytecode;
- bytecode = NULL;
+ bytecode = nullptr;
ret_code = LTTNG_OK;
error:
LTTNG_ASSERT(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK);
if (nb_exclusions == 0) {
/* Nothing to do. */
- exclusions = NULL;
+ exclusions = nullptr;
ret_status = LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_NONE;
goto end;
}
sizeof(LTTNG_EVENT_EXCLUSION_NAME_AT(exclusions, i)));
if (copy_ret) {
free(exclusions);
- exclusions = NULL;
+ exclusions = nullptr;
ret_status = LTTNG_EVENT_RULE_GENERATE_EXCLUSIONS_STATUS_ERROR;
goto end;
}
int ret;
enum lttng_error_code ret_code;
enum lttng_event_rule_status status;
- const char *filter = NULL;
- const char *name_pattern = NULL;
- const struct lttng_log_level_rule *log_level_rule = NULL;
+ const char *filter = nullptr;
+ const char *name_pattern = nullptr;
+ const struct lttng_log_level_rule *log_level_rule = nullptr;
unsigned int exclusion_count = 0;
LTTNG_ASSERT(rule);
}
/* Filter expression. */
- if (filter != NULL) {
+ if (filter != nullptr) {
ret = mi_lttng_writer_write_element_string(
writer, mi_lttng_element_event_rule_filter_expression, filter);
if (ret) {
struct lttng_event_rule *lttng_event_rule_user_tracepoint_create(void)
{
- struct lttng_event_rule *rule = NULL;
+ struct lttng_event_rule *rule = nullptr;
struct lttng_event_rule_user_tracepoint *tp_rule;
enum lttng_event_rule_status status;
tp_rule->parent.mi_serialize = lttng_event_rule_user_tracepoint_mi_serialize;
/* Not necessary for now. */
- tp_rule->parent.generate_lttng_event = NULL;
+ tp_rule->parent.generate_lttng_event = nullptr;
- tp_rule->log_level_rule = NULL;
+ tp_rule->log_level_rule = nullptr;
lttng_dynamic_pointer_array_init(&tp_rule->exclusions, destroy_lttng_exclusions_element);
status = lttng_event_rule_user_tracepoint_set_name_pattern(rule, "*");
if (status != LTTNG_EVENT_RULE_STATUS_OK) {
lttng_event_rule_destroy(rule);
- rule = NULL;
+ rule = nullptr;
}
end:
enum lttng_event_rule_status status;
const struct lttng_event_rule_user_tracepoint_comm *tracepoint_comm;
const char *pattern;
- const char *filter_expression = NULL;
- const char **exclusions = NULL;
+ const char *filter_expression = nullptr;
+ const char **exclusions = nullptr;
const uint32_t *exclusion_len;
const char *exclusion;
struct lttng_buffer_view current_buffer_view;
- struct lttng_event_rule *rule = NULL;
- struct lttng_log_level_rule *log_level_rule = NULL;
+ struct lttng_event_rule *rule = nullptr;
+ struct lttng_log_level_rule *log_level_rule = nullptr;
if (!_event_rule) {
ret = -1;
}
*_event_rule = rule;
- rule = NULL;
+ rule = nullptr;
ret = offset;
end:
free(exclusions);
lttng_event_rule_user_tracepoint_set_name_pattern(struct lttng_event_rule *rule,
const char *pattern)
{
- char *pattern_copy = NULL;
+ char *pattern_copy = nullptr;
struct lttng_event_rule_user_tracepoint *tracepoint;
enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
free(tracepoint->pattern);
tracepoint->pattern = pattern_copy;
- pattern_copy = NULL;
+ pattern_copy = nullptr;
end:
return status;
}
enum lttng_event_rule_status
lttng_event_rule_user_tracepoint_set_filter(struct lttng_event_rule *rule, const char *expression)
{
- char *expression_copy = NULL;
+ char *expression_copy = nullptr;
struct lttng_event_rule_user_tracepoint *tracepoint;
enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
}
tracepoint->filter_expression = expression_copy;
- expression_copy = NULL;
+ expression_copy = nullptr;
end:
return status;
}
{
struct lttng_event_rule_user_tracepoint *tracepoint;
enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
- struct lttng_log_level_rule *copy = NULL;
+ struct lttng_log_level_rule *copy = nullptr;
if (!rule || !IS_USER_TRACEPOINT_EVENT_RULE(rule)) {
status = LTTNG_EVENT_RULE_STATUS_INVALID;
}
copy = lttng_log_level_rule_copy(log_level_rule);
- if (copy == NULL) {
+ if (copy == nullptr) {
status = LTTNG_EVENT_RULE_STATUS_ERROR;
goto end;
}
}
tracepoint = lttng::utils::container_of(rule, <tng_event_rule_user_tracepoint::parent);
- if (tracepoint->log_level_rule == NULL) {
+ if (tracepoint->log_level_rule == nullptr) {
status = LTTNG_EVENT_RULE_STATUS_UNSET;
goto end;
}
const char *exclusion)
{
int ret;
- char *exclusion_copy = NULL;
+ char *exclusion_copy = nullptr;
struct lttng_event_rule_user_tracepoint *tracepoint;
enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
goto end;
}
- exclusion_copy = NULL;
+ exclusion_copy = nullptr;
end:
free(exclusion_copy);
return status;