X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fcommon%2Fevent-rule%2Fjul-logging.cpp;h=bff0aa6b6896533e3314948b84e3de45167a86f9;hb=cd9adb8b829564212158943a0d279bb35322ab30;hp=14fa179eba2276820f3099cb7c70594c05ec7f62;hpb=64803277bbdbe0a943360d918298a48157d9da55;p=lttng-tools.git diff --git a/src/common/event-rule/jul-logging.cpp b/src/common/event-rule/jul-logging.cpp index 14fa179eb..bff0aa6b6 100644 --- a/src/common/event-rule/jul-logging.cpp +++ b/src/common/event-rule/jul-logging.cpp @@ -16,6 +16,7 @@ #include #include #include + #include #include #include @@ -28,12 +29,11 @@ static void lttng_event_rule_jul_logging_destroy(struct lttng_event_rule *rule) { struct lttng_event_rule_jul_logging *jul_logging; - if (rule == NULL) { + if (rule == nullptr) { return; } - jul_logging = container_of( - rule, struct lttng_event_rule_jul_logging, parent); + jul_logging = lttng::utils::container_of(rule, <tng_event_rule_jul_logging::parent); lttng_log_level_rule_destroy(jul_logging->log_level_rule); free(jul_logging->pattern); @@ -43,8 +43,7 @@ static void lttng_event_rule_jul_logging_destroy(struct lttng_event_rule *rule) free(jul_logging); } -static bool lttng_event_rule_jul_logging_validate( - const struct lttng_event_rule *rule) +static bool lttng_event_rule_jul_logging_validate(const struct lttng_event_rule *rule) { bool valid = false; struct lttng_event_rule_jul_logging *jul_logging; @@ -53,8 +52,7 @@ static bool lttng_event_rule_jul_logging_validate( goto end; } - jul_logging = container_of( - rule, struct lttng_event_rule_jul_logging, parent); + jul_logging = lttng::utils::container_of(rule, <tng_event_rule_jul_logging::parent); /* Required field. */ if (!jul_logging->pattern) { @@ -67,9 +65,8 @@ end: return valid; } -static int lttng_event_rule_jul_logging_serialize( - const struct lttng_event_rule *rule, - struct lttng_payload *payload) +static int lttng_event_rule_jul_logging_serialize(const struct lttng_event_rule *rule, + struct lttng_payload *payload) { int ret; size_t pattern_len, filter_expression_len, header_offset; @@ -86,14 +83,12 @@ static int lttng_event_rule_jul_logging_serialize( header_offset = payload->buffer.size; DBG("Serializing jul_logging event rule."); - jul_logging = container_of( - rule, struct lttng_event_rule_jul_logging, parent); + jul_logging = lttng::utils::container_of(rule, <tng_event_rule_jul_logging::parent); pattern_len = strlen(jul_logging->pattern) + 1; - if (jul_logging->filter_expression != NULL) { - filter_expression_len = - strlen(jul_logging->filter_expression) + 1; + if (jul_logging->filter_expression != nullptr) { + filter_expression_len = strlen(jul_logging->filter_expression) + 1; } else { filter_expression_len = 0; } @@ -101,20 +96,19 @@ static int lttng_event_rule_jul_logging_serialize( jul_logging_comm.pattern_len = pattern_len; jul_logging_comm.filter_expression_len = filter_expression_len; - ret = lttng_dynamic_buffer_append(&payload->buffer, &jul_logging_comm, - sizeof(jul_logging_comm)); + ret = lttng_dynamic_buffer_append( + &payload->buffer, &jul_logging_comm, sizeof(jul_logging_comm)); if (ret) { goto end; } - ret = lttng_dynamic_buffer_append( - &payload->buffer, jul_logging->pattern, pattern_len); + ret = lttng_dynamic_buffer_append(&payload->buffer, jul_logging->pattern, pattern_len); if (ret) { goto end; } - ret = lttng_dynamic_buffer_append(&payload->buffer, jul_logging->filter_expression, - filter_expression_len); + ret = lttng_dynamic_buffer_append( + &payload->buffer, jul_logging->filter_expression, filter_expression_len); if (ret) { goto end; } @@ -127,22 +121,20 @@ static int lttng_event_rule_jul_logging_serialize( } header = (typeof(header)) ((char *) payload->buffer.data + header_offset); - header->log_level_rule_len = - payload->buffer.size - size_before_log_level_rule; + header->log_level_rule_len = payload->buffer.size - size_before_log_level_rule; end: return ret; } -static bool lttng_event_rule_jul_logging_is_equal( - const struct lttng_event_rule *_a, - const struct lttng_event_rule *_b) +static bool lttng_event_rule_jul_logging_is_equal(const struct lttng_event_rule *_a, + const struct lttng_event_rule *_b) { bool is_equal = false; struct lttng_event_rule_jul_logging *a, *b; - a = container_of(_a, struct lttng_event_rule_jul_logging, parent); - b = container_of(_b, struct lttng_event_rule_jul_logging, parent); + a = lttng::utils::container_of(_a, <tng_event_rule_jul_logging::parent); + b = lttng::utils::container_of(_b, <tng_event_rule_jul_logging::parent); /* Quick checks. */ @@ -166,8 +158,7 @@ static bool lttng_event_rule_jul_logging_is_equal( goto end; } - if (!lttng_log_level_rule_is_equal( - a->log_level_rule, b->log_level_rule)) { + if (!lttng_log_level_rule_is_equal(a->log_level_rule, b->log_level_rule)) { goto end; } @@ -183,15 +174,14 @@ end: * * An event with NO loglevel and the name is * will return NULL. */ -static int generate_agent_filter( - const struct lttng_event_rule *rule, char **_agent_filter) +static int generate_agent_filter(const struct lttng_event_rule *rule, char **_agent_filter) { int err; int ret = 0; - char *agent_filter = NULL; + char *agent_filter = nullptr; const char *pattern; const char *filter; - const struct lttng_log_level_rule *log_level_rule = NULL; + const struct lttng_log_level_rule *log_level_rule = nullptr; enum lttng_event_rule_status status; LTTNG_ASSERT(rule); @@ -205,22 +195,19 @@ static int generate_agent_filter( status = lttng_event_rule_jul_logging_get_filter(rule, &filter); if (status == LTTNG_EVENT_RULE_STATUS_UNSET) { - filter = NULL; + filter = nullptr; } else if (status != LTTNG_EVENT_RULE_STATUS_OK) { ret = -1; goto end; } - /* Don't add filter for the '*' event. */ if (strcmp(pattern, "*") != 0) { if (filter) { - err = asprintf(&agent_filter, - "(%s) && (logger_name == \"%s\")", - filter, pattern); + err = asprintf( + &agent_filter, "(%s) && (logger_name == \"%s\")", filter, pattern); } else { - err = asprintf(&agent_filter, "logger_name == \"%s\"", - pattern); + err = asprintf(&agent_filter, "logger_name == \"%s\"", pattern); } if (err < 0) { @@ -230,23 +217,20 @@ static int generate_agent_filter( } } - status = lttng_event_rule_jul_logging_get_log_level_rule( - rule, &log_level_rule); + status = lttng_event_rule_jul_logging_get_log_level_rule(rule, &log_level_rule); if (status == LTTNG_EVENT_RULE_STATUS_OK) { enum lttng_log_level_rule_status llr_status; const char *op; int level; - switch (lttng_log_level_rule_get_type(log_level_rule)) - { + switch (lttng_log_level_rule_get_type(log_level_rule)) { case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY: - llr_status = lttng_log_level_rule_exactly_get_level( - log_level_rule, &level); + llr_status = lttng_log_level_rule_exactly_get_level(log_level_rule, &level); op = "=="; break; case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS: llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level( - log_level_rule, &level); + log_level_rule, &level); op = ">="; break; default: @@ -262,16 +246,16 @@ static int generate_agent_filter( char *new_filter; err = asprintf(&new_filter, - "(%s) && (int_loglevel %s %d)", - agent_filter ? agent_filter : filter, - op, level); + "(%s) && (int_loglevel %s %d)", + agent_filter ? agent_filter : filter, + op, + level); if (agent_filter) { free(agent_filter); } agent_filter = new_filter; } else { - err = asprintf(&agent_filter, "int_loglevel %s %d", op, - level); + err = asprintf(&agent_filter, "int_loglevel %s %d", op, level); } if (err < 0) { @@ -282,7 +266,7 @@ static int generate_agent_filter( } *_agent_filter = agent_filter; - agent_filter = NULL; + agent_filter = nullptr; end: free(agent_filter); @@ -290,26 +274,24 @@ end: } static enum lttng_error_code -lttng_event_rule_jul_logging_generate_filter_bytecode( - struct lttng_event_rule *rule, - const struct lttng_credentials *creds) +lttng_event_rule_jul_logging_generate_filter_bytecode(struct lttng_event_rule *rule, + const struct lttng_credentials *creds) { int ret; enum lttng_error_code ret_code; struct lttng_event_rule_jul_logging *jul_logging; enum lttng_event_rule_status status; const char *filter; - struct lttng_bytecode *bytecode = NULL; + struct lttng_bytecode *bytecode = nullptr; char *agent_filter; LTTNG_ASSERT(rule); - jul_logging = container_of( - rule, struct lttng_event_rule_jul_logging, parent); + jul_logging = lttng::utils::container_of(rule, <tng_event_rule_jul_logging::parent); status = lttng_event_rule_jul_logging_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; @@ -328,21 +310,20 @@ lttng_event_rule_jul_logging_generate_filter_bytecode( jul_logging->internal_filter.filter = agent_filter; - if (jul_logging->internal_filter.filter == NULL) { + if (jul_logging->internal_filter.filter == nullptr) { ret_code = LTTNG_OK; goto end; } ret = run_as_generate_filter_bytecode( - jul_logging->internal_filter.filter, creds, - &bytecode); + jul_logging->internal_filter.filter, creds, &bytecode); if (ret) { ret_code = LTTNG_ERR_FILTER_INVAL; goto end; } jul_logging->internal_filter.bytecode = bytecode; - bytecode = NULL; + bytecode = nullptr; ret_code = LTTNG_OK; error: @@ -351,48 +332,43 @@ end: return ret_code; } -static const char *lttng_event_rule_jul_logging_get_internal_filter( - const struct lttng_event_rule *rule) +static const char * +lttng_event_rule_jul_logging_get_internal_filter(const struct lttng_event_rule *rule) { struct lttng_event_rule_jul_logging *jul_logging; LTTNG_ASSERT(rule); - jul_logging = container_of( - rule, struct lttng_event_rule_jul_logging, parent); + jul_logging = lttng::utils::container_of(rule, <tng_event_rule_jul_logging::parent); return jul_logging->internal_filter.filter; } static const struct lttng_bytecode * -lttng_event_rule_jul_logging_get_internal_filter_bytecode( - const struct lttng_event_rule *rule) +lttng_event_rule_jul_logging_get_internal_filter_bytecode(const struct lttng_event_rule *rule) { struct lttng_event_rule_jul_logging *jul_logging; LTTNG_ASSERT(rule); - jul_logging = container_of( - rule, struct lttng_event_rule_jul_logging, parent); + jul_logging = lttng::utils::container_of(rule, <tng_event_rule_jul_logging::parent); return jul_logging->internal_filter.bytecode; } static enum lttng_event_rule_generate_exclusions_status -lttng_event_rule_jul_logging_generate_exclusions( - const struct lttng_event_rule *rule __attribute__((unused)), - struct lttng_event_exclusion **_exclusions) +lttng_event_rule_jul_logging_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_jul_logging_hash( - const struct lttng_event_rule *rule) +static unsigned long lttng_event_rule_jul_logging_hash(const struct lttng_event_rule *rule) { unsigned long hash; struct lttng_event_rule_jul_logging *tp_rule = - container_of(rule, typeof(*tp_rule), parent); + lttng::utils::container_of(rule, <tng_event_rule_jul_logging::parent); - hash = hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_JUL_LOGGING, - lttng_ht_seed); + hash = hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_JUL_LOGGING, lttng_ht_seed); hash ^= hash_key_str(tp_rule->pattern, lttng_ht_seed); if (tp_rule->filter_expression) { @@ -406,20 +382,19 @@ static unsigned long lttng_event_rule_jul_logging_hash( return hash; } -static struct lttng_event *lttng_event_rule_jul_logging_generate_lttng_event( - const struct lttng_event_rule *rule) +static struct lttng_event * +lttng_event_rule_jul_logging_generate_lttng_event(const struct lttng_event_rule *rule) { int ret; const struct lttng_event_rule_jul_logging *jul_logging; - struct lttng_event *local_event = NULL; - struct lttng_event *event = NULL; + struct lttng_event *local_event = nullptr; + struct lttng_event *event = nullptr; enum lttng_loglevel_type loglevel_type; int loglevel_value = 0; enum lttng_event_rule_status status; const struct lttng_log_level_rule *log_level_rule; - jul_logging = container_of( - rule, const struct lttng_event_rule_jul_logging, parent); + jul_logging = lttng::utils::container_of(rule, <tng_event_rule_jul_logging::parent); local_event = zmalloc(); if (!local_event) { @@ -427,18 +402,15 @@ static struct lttng_event *lttng_event_rule_jul_logging_generate_lttng_event( } local_event->type = LTTNG_EVENT_TRACEPOINT; - ret = lttng_strncpy(local_event->name, jul_logging->pattern, - sizeof(local_event->name)); + ret = lttng_strncpy(local_event->name, jul_logging->pattern, sizeof(local_event->name)); if (ret) { ERR("Truncation occurred when copying event rule pattern to `lttng_event` structure: pattern = '%s'", - jul_logging->pattern); + jul_logging->pattern); goto error; } - /* Map the log level rule to an equivalent lttng_loglevel. */ - status = lttng_event_rule_jul_logging_get_log_level_rule( - rule, &log_level_rule); + status = lttng_event_rule_jul_logging_get_log_level_rule(rule, &log_level_rule); if (status == LTTNG_EVENT_RULE_STATUS_UNSET) { loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; loglevel_value = 0; @@ -447,13 +419,13 @@ static struct lttng_event *lttng_event_rule_jul_logging_generate_lttng_event( switch (lttng_log_level_rule_get_type(log_level_rule)) { case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY: - llr_status = lttng_log_level_rule_exactly_get_level( - log_level_rule, &loglevel_value); + llr_status = lttng_log_level_rule_exactly_get_level(log_level_rule, + &loglevel_value); loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE; break; case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS: llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level( - log_level_rule, &loglevel_value); + log_level_rule, &loglevel_value); loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE; break; default: @@ -472,60 +444,57 @@ static struct lttng_event *lttng_event_rule_jul_logging_generate_lttng_event( local_event->loglevel = loglevel_value; event = local_event; - local_event = NULL; + local_event = nullptr; error: free(local_event); return event; } -static enum lttng_error_code lttng_event_rule_jul_logging_mi_serialize( - const struct lttng_event_rule *rule, struct mi_writer *writer) +static enum lttng_error_code +lttng_event_rule_jul_logging_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; - 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; LTTNG_ASSERT(rule); LTTNG_ASSERT(writer); LTTNG_ASSERT(IS_JUL_LOGGING_EVENT_RULE(rule)); - status = lttng_event_rule_jul_logging_get_name_pattern( - rule, &name_pattern); + status = lttng_event_rule_jul_logging_get_name_pattern(rule, &name_pattern); LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK); LTTNG_ASSERT(name_pattern); status = lttng_event_rule_jul_logging_get_filter(rule, &filter); LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK || - status == LTTNG_EVENT_RULE_STATUS_UNSET); + status == LTTNG_EVENT_RULE_STATUS_UNSET); - status = lttng_event_rule_jul_logging_get_log_level_rule( - rule, &log_level_rule); + status = lttng_event_rule_jul_logging_get_log_level_rule(rule, &log_level_rule); LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK || - status == LTTNG_EVENT_RULE_STATUS_UNSET); + status == LTTNG_EVENT_RULE_STATUS_UNSET); /* Open event rule jul logging element. */ - ret = mi_lttng_writer_open_element( - writer, mi_lttng_element_event_rule_jul_logging); + ret = mi_lttng_writer_open_element(writer, mi_lttng_element_event_rule_jul_logging); 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 expression. */ - 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; } @@ -533,8 +502,7 @@ static enum lttng_error_code lttng_event_rule_jul_logging_mi_serialize( /* Log level rule. */ if (log_level_rule) { - ret_code = lttng_log_level_rule_mi_serialize( - log_level_rule, writer); + ret_code = lttng_log_level_rule_mi_serialize(log_level_rule, writer); if (ret_code != LTTNG_OK) { goto end; } @@ -557,7 +525,7 @@ end: struct lttng_event_rule *lttng_event_rule_jul_logging_create(void) { - struct lttng_event_rule *rule = NULL; + struct lttng_event_rule *rule = nullptr; struct lttng_event_rule_jul_logging *tp_rule; enum lttng_event_rule_status status; @@ -573,51 +541,47 @@ struct lttng_event_rule *lttng_event_rule_jul_logging_create(void) tp_rule->parent.equal = lttng_event_rule_jul_logging_is_equal; tp_rule->parent.destroy = lttng_event_rule_jul_logging_destroy; tp_rule->parent.generate_filter_bytecode = - lttng_event_rule_jul_logging_generate_filter_bytecode; - tp_rule->parent.get_filter = - lttng_event_rule_jul_logging_get_internal_filter; + lttng_event_rule_jul_logging_generate_filter_bytecode; + tp_rule->parent.get_filter = lttng_event_rule_jul_logging_get_internal_filter; tp_rule->parent.get_filter_bytecode = - lttng_event_rule_jul_logging_get_internal_filter_bytecode; - tp_rule->parent.generate_exclusions = - lttng_event_rule_jul_logging_generate_exclusions; + lttng_event_rule_jul_logging_get_internal_filter_bytecode; + tp_rule->parent.generate_exclusions = lttng_event_rule_jul_logging_generate_exclusions; tp_rule->parent.hash = lttng_event_rule_jul_logging_hash; - tp_rule->parent.generate_lttng_event = - lttng_event_rule_jul_logging_generate_lttng_event; + tp_rule->parent.generate_lttng_event = lttng_event_rule_jul_logging_generate_lttng_event; tp_rule->parent.mi_serialize = lttng_event_rule_jul_logging_mi_serialize; - tp_rule->log_level_rule = NULL; + tp_rule->log_level_rule = nullptr; /* Default pattern is '*'. */ status = lttng_event_rule_jul_logging_set_name_pattern(rule, "*"); if (status != LTTNG_EVENT_RULE_STATUS_OK) { lttng_event_rule_destroy(rule); - rule = NULL; + rule = nullptr; } end: return rule; } -ssize_t lttng_event_rule_jul_logging_create_from_payload( - struct lttng_payload_view *view, - struct lttng_event_rule **_event_rule) +ssize_t lttng_event_rule_jul_logging_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_jul_logging_comm *jul_logging_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_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; goto end; } - current_buffer_view = lttng_buffer_view_from_view( - &view->buffer, offset, sizeof(*jul_logging_comm)); + current_buffer_view = + lttng_buffer_view_from_view(&view->buffer, offset, sizeof(*jul_logging_comm)); if (!lttng_buffer_view_is_valid(¤t_buffer_view)) { ERR("Failed to initialize from malformed event rule jul_logging: buffer too short to contain header."); ret = -1; @@ -637,8 +601,8 @@ ssize_t lttng_event_rule_jul_logging_create_from_payload( offset += current_buffer_view.size; /* Map the pattern. */ - current_buffer_view = lttng_buffer_view_from_view( - &view->buffer, offset, jul_logging_comm->pattern_len); + current_buffer_view = + lttng_buffer_view_from_view(&view->buffer, offset, jul_logging_comm->pattern_len); if (!lttng_buffer_view_is_valid(¤t_buffer_view)) { ret = -1; @@ -646,8 +610,8 @@ ssize_t lttng_event_rule_jul_logging_create_from_payload( } pattern = current_buffer_view.data; - if (!lttng_buffer_view_contains_string(¤t_buffer_view, pattern, - jul_logging_comm->pattern_len)) { + if (!lttng_buffer_view_contains_string( + ¤t_buffer_view, pattern, jul_logging_comm->pattern_len)) { ret = -1; goto end; } @@ -660,8 +624,8 @@ ssize_t lttng_event_rule_jul_logging_create_from_payload( } /* Map the filter_expression. */ - current_buffer_view = lttng_buffer_view_from_view(&view->buffer, offset, - jul_logging_comm->filter_expression_len); + current_buffer_view = lttng_buffer_view_from_view( + &view->buffer, offset, jul_logging_comm->filter_expression_len); if (!lttng_buffer_view_is_valid(¤t_buffer_view)) { ret = -1; goto end; @@ -669,8 +633,8 @@ ssize_t lttng_event_rule_jul_logging_create_from_payload( filter_expression = current_buffer_view.data; if (!lttng_buffer_view_contains_string(¤t_buffer_view, - filter_expression, - jul_logging_comm->filter_expression_len)) { + filter_expression, + jul_logging_comm->filter_expression_len)) { ret = -1; goto end; } @@ -685,12 +649,11 @@ skip_filter_expression: { /* Map the log level rule. */ - struct lttng_payload_view current_payload_view = - lttng_payload_view_from_view(view, offset, - jul_logging_comm->log_level_rule_len); + struct lttng_payload_view current_payload_view = lttng_payload_view_from_view( + view, offset, jul_logging_comm->log_level_rule_len); - ret = lttng_log_level_rule_create_from_payload( - ¤t_payload_view, &log_level_rule); + ret = lttng_log_level_rule_create_from_payload(¤t_payload_view, + &log_level_rule); if (ret < 0) { ret = -1; goto end; @@ -712,8 +675,7 @@ skip_log_level_rule: } if (filter_expression) { - status = lttng_event_rule_jul_logging_set_filter( - rule, filter_expression); + status = lttng_event_rule_jul_logging_set_filter(rule, filter_expression); if (status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to set event rule jul_logging pattern."); ret = -1; @@ -722,8 +684,7 @@ skip_log_level_rule: } if (log_level_rule) { - status = lttng_event_rule_jul_logging_set_log_level_rule( - rule, log_level_rule); + status = lttng_event_rule_jul_logging_set_log_level_rule(rule, log_level_rule); if (status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to set event rule jul_logging log level rule."); ret = -1; @@ -732,7 +693,7 @@ skip_log_level_rule: } *_event_rule = rule; - rule = NULL; + rule = nullptr; ret = offset; end: lttng_log_level_rule_destroy(log_level_rule); @@ -740,21 +701,19 @@ end: return ret; } -enum lttng_event_rule_status lttng_event_rule_jul_logging_set_name_pattern( - struct lttng_event_rule *rule, const char *pattern) +enum lttng_event_rule_status +lttng_event_rule_jul_logging_set_name_pattern(struct lttng_event_rule *rule, const char *pattern) { - char *pattern_copy = NULL; + char *pattern_copy = nullptr; struct lttng_event_rule_jul_logging *jul_logging; enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK; - if (!rule || !IS_JUL_LOGGING_EVENT_RULE(rule) || !pattern || - strlen(pattern) == 0) { + if (!rule || !IS_JUL_LOGGING_EVENT_RULE(rule) || !pattern || strlen(pattern) == 0) { status = LTTNG_EVENT_RULE_STATUS_INVALID; goto end; } - jul_logging = container_of( - rule, struct lttng_event_rule_jul_logging, parent); + jul_logging = lttng::utils::container_of(rule, <tng_event_rule_jul_logging::parent); pattern_copy = strdup(pattern); if (!pattern_copy) { status = LTTNG_EVENT_RULE_STATUS_ERROR; @@ -767,13 +726,14 @@ enum lttng_event_rule_status lttng_event_rule_jul_logging_set_name_pattern( free(jul_logging->pattern); jul_logging->pattern = pattern_copy; - pattern_copy = NULL; + pattern_copy = nullptr; end: return status; } -enum lttng_event_rule_status lttng_event_rule_jul_logging_get_name_pattern( - const struct lttng_event_rule *rule, const char **pattern) +enum lttng_event_rule_status +lttng_event_rule_jul_logging_get_name_pattern(const struct lttng_event_rule *rule, + const char **pattern) { struct lttng_event_rule_jul_logging *jul_logging; enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK; @@ -783,8 +743,7 @@ enum lttng_event_rule_status lttng_event_rule_jul_logging_get_name_pattern( goto end; } - jul_logging = container_of( - rule, struct lttng_event_rule_jul_logging, parent); + jul_logging = lttng::utils::container_of(rule, <tng_event_rule_jul_logging::parent); if (!jul_logging->pattern) { status = LTTNG_EVENT_RULE_STATUS_UNSET; goto end; @@ -795,21 +754,19 @@ end: return status; } -enum lttng_event_rule_status lttng_event_rule_jul_logging_set_filter( - struct lttng_event_rule *rule, const char *expression) +enum lttng_event_rule_status lttng_event_rule_jul_logging_set_filter(struct lttng_event_rule *rule, + const char *expression) { - char *expression_copy = NULL; + char *expression_copy = nullptr; struct lttng_event_rule_jul_logging *jul_logging; enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK; - if (!rule || !IS_JUL_LOGGING_EVENT_RULE(rule) || !expression || - strlen(expression) == 0) { + if (!rule || !IS_JUL_LOGGING_EVENT_RULE(rule) || !expression || strlen(expression) == 0) { status = LTTNG_EVENT_RULE_STATUS_INVALID; goto end; } - jul_logging = container_of( - rule, struct lttng_event_rule_jul_logging, parent); + jul_logging = lttng::utils::container_of(rule, <tng_event_rule_jul_logging::parent); expression_copy = strdup(expression); if (!expression_copy) { PERROR("Failed to copy filter expression"); @@ -822,13 +779,14 @@ enum lttng_event_rule_status lttng_event_rule_jul_logging_set_filter( } jul_logging->filter_expression = expression_copy; - expression_copy = NULL; + expression_copy = nullptr; end: return status; } -enum lttng_event_rule_status lttng_event_rule_jul_logging_get_filter( - const struct lttng_event_rule *rule, const char **expression) +enum lttng_event_rule_status +lttng_event_rule_jul_logging_get_filter(const struct lttng_event_rule *rule, + const char **expression) { struct lttng_event_rule_jul_logging *jul_logging; enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK; @@ -838,8 +796,7 @@ enum lttng_event_rule_status lttng_event_rule_jul_logging_get_filter( goto end; } - jul_logging = container_of( - rule, struct lttng_event_rule_jul_logging, parent); + jul_logging = lttng::utils::container_of(rule, <tng_event_rule_jul_logging::parent); if (!jul_logging->filter_expression) { status = LTTNG_EVENT_RULE_STATUS_UNSET; goto end; @@ -850,8 +807,7 @@ end: return status; } -static bool log_level_rule_valid( - const struct lttng_log_level_rule *rule __attribute__((unused))) +static bool log_level_rule_valid(const struct lttng_log_level_rule *rule __attribute__((unused))) { /* * For both JUL and LOG4J custom log level are possible and can @@ -860,21 +816,20 @@ static bool log_level_rule_valid( return true; } -enum lttng_event_rule_status lttng_event_rule_jul_logging_set_log_level_rule( - struct lttng_event_rule *rule, - const struct lttng_log_level_rule *log_level_rule) +enum lttng_event_rule_status +lttng_event_rule_jul_logging_set_log_level_rule(struct lttng_event_rule *rule, + const struct lttng_log_level_rule *log_level_rule) { struct lttng_event_rule_jul_logging *jul_logging; 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_JUL_LOGGING_EVENT_RULE(rule)) { status = LTTNG_EVENT_RULE_STATUS_INVALID; goto end; } - jul_logging = container_of( - rule, struct lttng_event_rule_jul_logging, parent); + jul_logging = lttng::utils::container_of(rule, <tng_event_rule_jul_logging::parent); if (!log_level_rule_valid(log_level_rule)) { status = LTTNG_EVENT_RULE_STATUS_INVALID; @@ -882,7 +837,7 @@ enum lttng_event_rule_status lttng_event_rule_jul_logging_set_log_level_rule( } copy = lttng_log_level_rule_copy(log_level_rule); - if (copy == NULL) { + if (copy == nullptr) { status = LTTNG_EVENT_RULE_STATUS_ERROR; goto end; } @@ -897,10 +852,9 @@ end: return status; } -enum lttng_event_rule_status lttng_event_rule_jul_logging_get_log_level_rule( - const struct lttng_event_rule *rule, - const struct lttng_log_level_rule **log_level_rule - ) +enum lttng_event_rule_status +lttng_event_rule_jul_logging_get_log_level_rule(const struct lttng_event_rule *rule, + const struct lttng_log_level_rule **log_level_rule) { struct lttng_event_rule_jul_logging *jul_logging; enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK; @@ -910,9 +864,8 @@ enum lttng_event_rule_status lttng_event_rule_jul_logging_get_log_level_rule( goto end; } - jul_logging = container_of( - rule, struct lttng_event_rule_jul_logging, parent); - if (jul_logging->log_level_rule == NULL) { + jul_logging = lttng::utils::container_of(rule, <tng_event_rule_jul_logging::parent); + if (jul_logging->log_level_rule == nullptr) { status = LTTNG_EVENT_RULE_STATUS_UNSET; goto end; }