X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fconditions%2Fbuffer-usage.cpp;fp=src%2Fcommon%2Fconditions%2Fbuffer-usage.cpp;h=e1af44b1c2eb0d4de73c28fa5f83b783538fbda1;hp=6830877a189e63f6fc98405eb6a54fd6e2933db8;hb=28ab034a2c3582d07d3423d2d746731f87d3969f;hpb=52e345b9ac912d033c2a2c25a170a01cf209839d diff --git a/src/common/conditions/buffer-usage.cpp b/src/common/conditions/buffer-usage.cpp index 6830877a1..e1af44b1c 100644 --- a/src/common/conditions/buffer-usage.cpp +++ b/src/common/conditions/buffer-usage.cpp @@ -8,42 +8,38 @@ #include #include #include -#include + #include #include + +#include #include #include -#define IS_USAGE_CONDITION(condition) ( \ - lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW || \ - lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH \ - ) +#define IS_USAGE_CONDITION(condition) \ + (lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW || \ + lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH) -static -bool is_usage_evaluation(const struct lttng_evaluation *evaluation) +static bool is_usage_evaluation(const struct lttng_evaluation *evaluation) { enum lttng_condition_type type = lttng_evaluation_get_type(evaluation); return type == LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW || - type == LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH; + type == LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH; } -static -void lttng_condition_buffer_usage_destroy(struct lttng_condition *condition) +static void lttng_condition_buffer_usage_destroy(struct lttng_condition *condition) { struct lttng_condition_buffer_usage *usage; - usage = lttng::utils::container_of(condition, - <tng_condition_buffer_usage::parent); + usage = lttng::utils::container_of(condition, <tng_condition_buffer_usage::parent); free(usage->session_name); free(usage->channel_name); free(usage); } -static -bool lttng_condition_buffer_usage_validate( - const struct lttng_condition *condition) +static bool lttng_condition_buffer_usage_validate(const struct lttng_condition *condition) { bool valid = false; struct lttng_condition_buffer_usage *usage; @@ -52,8 +48,7 @@ bool lttng_condition_buffer_usage_validate( goto end; } - usage = lttng::utils::container_of(condition, - <tng_condition_buffer_usage::parent); + usage = lttng::utils::container_of(condition, <tng_condition_buffer_usage::parent); if (!usage->session_name) { ERR("Invalid buffer condition: a target session name must be set."); goto end; @@ -76,10 +71,8 @@ end: return valid; } -static -int lttng_condition_buffer_usage_serialize( - const struct lttng_condition *condition, - struct lttng_payload *payload) +static int lttng_condition_buffer_usage_serialize(const struct lttng_condition *condition, + struct lttng_payload *payload) { int ret; struct lttng_condition_buffer_usage *usage; @@ -92,13 +85,11 @@ int lttng_condition_buffer_usage_serialize( } DBG("Serializing buffer usage condition"); - usage = lttng::utils::container_of(condition, - <tng_condition_buffer_usage::parent); + usage = lttng::utils::container_of(condition, <tng_condition_buffer_usage::parent); session_name_len = strlen(usage->session_name) + 1; channel_name_len = strlen(usage->channel_name) + 1; - if (session_name_len > LTTNG_NAME_MAX || - channel_name_len > LTTNG_NAME_MAX) { + if (session_name_len > LTTNG_NAME_MAX || channel_name_len > LTTNG_NAME_MAX) { ret = -1; goto end; } @@ -114,20 +105,17 @@ int lttng_condition_buffer_usage_serialize( usage_comm.threshold_ratio = usage->threshold_ratio.value; } - ret = lttng_dynamic_buffer_append(&payload->buffer, &usage_comm, - sizeof(usage_comm)); + ret = lttng_dynamic_buffer_append(&payload->buffer, &usage_comm, sizeof(usage_comm)); if (ret) { goto end; } - ret = lttng_dynamic_buffer_append(&payload->buffer, usage->session_name, - session_name_len); + ret = lttng_dynamic_buffer_append(&payload->buffer, usage->session_name, session_name_len); if (ret) { goto end; } - ret = lttng_dynamic_buffer_append(&payload->buffer, usage->channel_name, - channel_name_len); + ret = lttng_dynamic_buffer_append(&payload->buffer, usage->channel_name, channel_name_len); if (ret) { goto end; } @@ -135,9 +123,8 @@ end: return ret; } -static -bool lttng_condition_buffer_usage_is_equal(const struct lttng_condition *_a, - const struct lttng_condition *_b) +static bool lttng_condition_buffer_usage_is_equal(const struct lttng_condition *_a, + const struct lttng_condition *_b) { bool is_equal = false; struct lttng_condition_buffer_usage *a, *b; @@ -146,7 +133,7 @@ bool lttng_condition_buffer_usage_is_equal(const struct lttng_condition *_a, b = lttng::utils::container_of(_b, <tng_condition_buffer_usage::parent); if ((a->threshold_ratio.set && !b->threshold_ratio.set) || - (a->threshold_bytes.set && !b->threshold_bytes.set)) { + (a->threshold_bytes.set && !b->threshold_bytes.set)) { goto end; } @@ -193,9 +180,9 @@ end: return is_equal; } -static enum lttng_error_code lttng_condition_buffer_usage_mi_serialize( - const struct lttng_condition *condition, - struct mi_writer *writer) +static enum lttng_error_code +lttng_condition_buffer_usage_mi_serialize(const struct lttng_condition *condition, + struct mi_writer *writer) { int ret; enum lttng_error_code ret_code; @@ -210,22 +197,18 @@ static enum lttng_error_code lttng_condition_buffer_usage_mi_serialize( LTTNG_ASSERT(condition); LTTNG_ASSERT(IS_USAGE_CONDITION(condition)); - status = lttng_condition_buffer_usage_get_session_name( - condition, &session_name); + status = lttng_condition_buffer_usage_get_session_name(condition, &session_name); LTTNG_ASSERT(status == LTTNG_CONDITION_STATUS_OK); LTTNG_ASSERT(session_name); - status = lttng_condition_buffer_usage_get_channel_name( - condition, &channel_name); + status = lttng_condition_buffer_usage_get_channel_name(condition, &channel_name); LTTNG_ASSERT(status == LTTNG_CONDITION_STATUS_OK); LTTNG_ASSERT(session_name); - status = lttng_condition_buffer_usage_get_domain_type( - condition, &domain_type); + status = lttng_condition_buffer_usage_get_domain_type(condition, &domain_type); LTTNG_ASSERT(status == LTTNG_CONDITION_STATUS_OK); - status = lttng_condition_buffer_usage_get_threshold( - condition, &threshold_bytes); + status = lttng_condition_buffer_usage_get_threshold(condition, &threshold_bytes); if (status == LTTNG_CONDITION_STATUS_OK) { is_threshold_bytes = true; } else if (status != LTTNG_CONDITION_STATUS_UNSET) { @@ -235,19 +218,17 @@ static enum lttng_error_code lttng_condition_buffer_usage_mi_serialize( } if (!is_threshold_bytes) { - status = lttng_condition_buffer_usage_get_threshold_ratio( - condition, &threshold_ratio); + status = lttng_condition_buffer_usage_get_threshold_ratio(condition, + &threshold_ratio); LTTNG_ASSERT(status == LTTNG_CONDITION_STATUS_OK); } switch (lttng_condition_get_type(condition)) { case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH: - condition_type_str = - mi_lttng_element_condition_buffer_usage_high; + condition_type_str = mi_lttng_element_condition_buffer_usage_high; break; case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW: - condition_type_str = - mi_lttng_element_condition_buffer_usage_low; + condition_type_str = mi_lttng_element_condition_buffer_usage_low; break; default: abort(); @@ -262,39 +243,36 @@ static enum lttng_error_code lttng_condition_buffer_usage_mi_serialize( /* Session name. */ ret = mi_lttng_writer_write_element_string( - writer, mi_lttng_element_session_name, session_name); + writer, mi_lttng_element_session_name, session_name); if (ret) { goto mi_error; } /* Channel name. */ - ret = mi_lttng_writer_write_element_string(writer, - mi_lttng_element_condition_channel_name, channel_name); + ret = mi_lttng_writer_write_element_string( + writer, mi_lttng_element_condition_channel_name, channel_name); if (ret) { goto mi_error; } /* Domain. */ - ret = mi_lttng_writer_write_element_string(writer, - config_element_domain, - mi_lttng_domaintype_string(domain_type)); + ret = mi_lttng_writer_write_element_string( + writer, config_element_domain, mi_lttng_domaintype_string(domain_type)); if (ret) { goto mi_error; } if (is_threshold_bytes) { /* Usage in bytes. */ - ret = mi_lttng_writer_write_element_unsigned_int(writer, - mi_lttng_element_condition_threshold_bytes, - threshold_bytes); + ret = mi_lttng_writer_write_element_unsigned_int( + writer, mi_lttng_element_condition_threshold_bytes, threshold_bytes); if (ret) { goto mi_error; } } else { /* Ratio. */ - ret = mi_lttng_writer_write_element_double(writer, - mi_lttng_element_condition_threshold_ratio, - threshold_ratio); + ret = mi_lttng_writer_write_element_double( + writer, mi_lttng_element_condition_threshold_ratio, threshold_ratio); if (ret) { goto mi_error; } @@ -315,9 +293,7 @@ end: return ret_code; } -static -struct lttng_condition *lttng_condition_buffer_usage_create( - enum lttng_condition_type type) +static struct lttng_condition *lttng_condition_buffer_usage_create(enum lttng_condition_type type) { struct lttng_condition_buffer_usage *condition; @@ -337,19 +313,16 @@ struct lttng_condition *lttng_condition_buffer_usage_create( struct lttng_condition *lttng_condition_buffer_usage_low_create(void) { - return lttng_condition_buffer_usage_create( - LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW); + return lttng_condition_buffer_usage_create(LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW); } struct lttng_condition *lttng_condition_buffer_usage_high_create(void) { - return lttng_condition_buffer_usage_create( - LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH); + return lttng_condition_buffer_usage_create(LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH); } -static -ssize_t init_condition_from_payload(struct lttng_condition *condition, - struct lttng_payload_view *src_view) +static ssize_t init_condition_from_payload(struct lttng_condition *condition, + struct lttng_payload_view *src_view) { ssize_t ret, condition_size; enum lttng_condition_status status; @@ -358,8 +331,7 @@ ssize_t init_condition_from_payload(struct lttng_condition *condition, struct lttng_buffer_view names_view; const struct lttng_condition_buffer_usage_comm *condition_comm; const struct lttng_payload_view condition_comm_view = - lttng_payload_view_from_view( - src_view, 0, sizeof(*condition_comm)); + lttng_payload_view_from_view(src_view, 0, sizeof(*condition_comm)); if (!lttng_payload_view_is_valid(&condition_comm_view)) { ERR("Failed to initialize from malformed condition buffer: buffer too short to contain header"); @@ -368,30 +340,28 @@ ssize_t init_condition_from_payload(struct lttng_condition *condition, } condition_comm = (typeof(condition_comm)) condition_comm_view.buffer.data; - names_view = lttng_buffer_view_from_view(&src_view->buffer, - sizeof(*condition_comm), -1); + names_view = lttng_buffer_view_from_view(&src_view->buffer, sizeof(*condition_comm), -1); if (condition_comm->session_name_len > LTTNG_NAME_MAX || - condition_comm->channel_name_len > LTTNG_NAME_MAX) { + condition_comm->channel_name_len > LTTNG_NAME_MAX) { ERR("Failed to initialize from malformed condition buffer: name exceeds LTTNG_MAX_NAME"); ret = -1; goto end; } if (names_view.size < - (condition_comm->session_name_len + - condition_comm->channel_name_len)) { + (condition_comm->session_name_len + condition_comm->channel_name_len)) { ERR("Failed to initialize from malformed condition buffer: buffer too short to contain element names"); ret = -1; goto end; } if (condition_comm->threshold_set_in_bytes) { - status = lttng_condition_buffer_usage_set_threshold(condition, - condition_comm->threshold_bytes); + status = lttng_condition_buffer_usage_set_threshold( + condition, condition_comm->threshold_bytes); } else { status = lttng_condition_buffer_usage_set_threshold_ratio( - condition, condition_comm->threshold_ratio); + condition, condition_comm->threshold_ratio); } if (status != LTTNG_CONDITION_STATUS_OK) { @@ -401,17 +371,16 @@ ssize_t init_condition_from_payload(struct lttng_condition *condition, } if (condition_comm->domain_type <= LTTNG_DOMAIN_NONE || - condition_comm->domain_type > LTTNG_DOMAIN_PYTHON) { + condition_comm->domain_type > LTTNG_DOMAIN_PYTHON) { /* Invalid domain value. */ ERR("Invalid domain type value (%i) found in condition buffer", - (int) condition_comm->domain_type); + (int) condition_comm->domain_type); ret = -1; goto end; } domain_type = (enum lttng_domain_type) condition_comm->domain_type; - status = lttng_condition_buffer_usage_set_domain_type(condition, - domain_type); + status = lttng_condition_buffer_usage_set_domain_type(condition, domain_type); if (status != LTTNG_CONDITION_STATUS_OK) { ERR("Failed to set buffer usage condition domain"); ret = -1; @@ -432,16 +401,14 @@ ssize_t init_condition_from_payload(struct lttng_condition *condition, goto end; } - status = lttng_condition_buffer_usage_set_session_name(condition, - session_name); + status = lttng_condition_buffer_usage_set_session_name(condition, session_name); if (status != LTTNG_CONDITION_STATUS_OK) { ERR("Failed to set buffer usage session name"); ret = -1; goto end; } - status = lttng_condition_buffer_usage_set_channel_name(condition, - channel_name); + status = lttng_condition_buffer_usage_set_channel_name(condition, channel_name); if (status != LTTNG_CONDITION_STATUS_OK) { ERR("Failed to set buffer usage channel name"); ret = -1; @@ -453,21 +420,18 @@ ssize_t init_condition_from_payload(struct lttng_condition *condition, goto end; } - condition_size = sizeof(*condition_comm) + - (ssize_t) condition_comm->session_name_len + - (ssize_t) condition_comm->channel_name_len; + condition_size = sizeof(*condition_comm) + (ssize_t) condition_comm->session_name_len + + (ssize_t) condition_comm->channel_name_len; ret = condition_size; end: return ret; } -ssize_t lttng_condition_buffer_usage_low_create_from_payload( - struct lttng_payload_view *view, - struct lttng_condition **_condition) +ssize_t lttng_condition_buffer_usage_low_create_from_payload(struct lttng_payload_view *view, + struct lttng_condition **_condition) { ssize_t ret; - struct lttng_condition *condition = - lttng_condition_buffer_usage_low_create(); + struct lttng_condition *condition = lttng_condition_buffer_usage_low_create(); if (!_condition || !condition) { ret = -1; @@ -486,13 +450,11 @@ error: return ret; } -ssize_t lttng_condition_buffer_usage_high_create_from_payload( - struct lttng_payload_view *view, - struct lttng_condition **_condition) +ssize_t lttng_condition_buffer_usage_high_create_from_payload(struct lttng_payload_view *view, + struct lttng_condition **_condition) { ssize_t ret; - struct lttng_condition *condition = - lttng_condition_buffer_usage_high_create(); + struct lttng_condition *condition = lttng_condition_buffer_usage_high_create(); if (!_condition || !condition) { ret = -1; @@ -511,28 +473,24 @@ error: return ret; } -static -struct lttng_evaluation *create_evaluation_from_payload( - enum lttng_condition_type type, - struct lttng_payload_view *view) +static struct lttng_evaluation *create_evaluation_from_payload(enum lttng_condition_type type, + struct lttng_payload_view *view) { - const struct lttng_evaluation_buffer_usage_comm *comm = - (typeof(comm)) view->buffer.data; + const struct lttng_evaluation_buffer_usage_comm *comm = (typeof(comm)) view->buffer.data; struct lttng_evaluation *evaluation = NULL; if (view->buffer.size < sizeof(*comm)) { goto end; } - evaluation = lttng_evaluation_buffer_usage_create(type, - comm->buffer_use, comm->buffer_capacity); + evaluation = + lttng_evaluation_buffer_usage_create(type, comm->buffer_use, comm->buffer_capacity); end: return evaluation; } -ssize_t lttng_evaluation_buffer_usage_low_create_from_payload( - struct lttng_payload_view *view, - struct lttng_evaluation **_evaluation) +ssize_t lttng_evaluation_buffer_usage_low_create_from_payload(struct lttng_payload_view *view, + struct lttng_evaluation **_evaluation) { ssize_t ret; struct lttng_evaluation *evaluation = NULL; @@ -542,8 +500,7 @@ ssize_t lttng_evaluation_buffer_usage_low_create_from_payload( goto error; } - evaluation = create_evaluation_from_payload( - LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW, view); + evaluation = create_evaluation_from_payload(LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW, view); if (!evaluation) { ret = -1; goto error; @@ -557,9 +514,9 @@ error: return ret; } -ssize_t lttng_evaluation_buffer_usage_high_create_from_payload( - struct lttng_payload_view *view, - struct lttng_evaluation **_evaluation) +ssize_t +lttng_evaluation_buffer_usage_high_create_from_payload(struct lttng_payload_view *view, + struct lttng_evaluation **_evaluation) { ssize_t ret; struct lttng_evaluation *evaluation = NULL; @@ -569,8 +526,7 @@ ssize_t lttng_evaluation_buffer_usage_high_create_from_payload( goto error; } - evaluation = create_evaluation_from_payload( - LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH, view); + evaluation = create_evaluation_from_payload(LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH, view); if (!evaluation) { ret = -1; goto error; @@ -585,21 +541,18 @@ error: } enum lttng_condition_status -lttng_condition_buffer_usage_get_threshold_ratio( - const struct lttng_condition *condition, - double *threshold_ratio) +lttng_condition_buffer_usage_get_threshold_ratio(const struct lttng_condition *condition, + double *threshold_ratio) { struct lttng_condition_buffer_usage *usage; enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK; - if (!condition || !IS_USAGE_CONDITION(condition) || - !threshold_ratio) { + if (!condition || !IS_USAGE_CONDITION(condition) || !threshold_ratio) { status = LTTNG_CONDITION_STATUS_INVALID; goto end; } - usage = lttng::utils::container_of(condition, - <tng_condition_buffer_usage::parent); + usage = lttng::utils::container_of(condition, <tng_condition_buffer_usage::parent); if (!usage->threshold_ratio.set) { status = LTTNG_CONDITION_STATUS_UNSET; goto end; @@ -611,21 +564,19 @@ end: /* threshold_ratio expressed as [0.0, 1.0]. */ enum lttng_condition_status -lttng_condition_buffer_usage_set_threshold_ratio( - struct lttng_condition *condition, double threshold_ratio) +lttng_condition_buffer_usage_set_threshold_ratio(struct lttng_condition *condition, + double threshold_ratio) { struct lttng_condition_buffer_usage *usage; enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK; - if (!condition || !IS_USAGE_CONDITION(condition) || - threshold_ratio < 0.0 || - threshold_ratio > 1.0) { + if (!condition || !IS_USAGE_CONDITION(condition) || threshold_ratio < 0.0 || + threshold_ratio > 1.0) { status = LTTNG_CONDITION_STATUS_INVALID; goto end; } - usage = lttng::utils::container_of(condition, - <tng_condition_buffer_usage::parent); + usage = lttng::utils::container_of(condition, <tng_condition_buffer_usage::parent); usage->threshold_ratio.set = true; usage->threshold_bytes.set = false; usage->threshold_ratio.value = threshold_ratio; @@ -634,9 +585,8 @@ end: } enum lttng_condition_status -lttng_condition_buffer_usage_get_threshold( - const struct lttng_condition *condition, - uint64_t *threshold_bytes) +lttng_condition_buffer_usage_get_threshold(const struct lttng_condition *condition, + uint64_t *threshold_bytes) { struct lttng_condition_buffer_usage *usage; enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK; @@ -646,8 +596,7 @@ lttng_condition_buffer_usage_get_threshold( goto end; } - usage = lttng::utils::container_of(condition, - <tng_condition_buffer_usage::parent); + usage = lttng::utils::container_of(condition, <tng_condition_buffer_usage::parent); if (!usage->threshold_bytes.set) { status = LTTNG_CONDITION_STATUS_UNSET; goto end; @@ -658,8 +607,8 @@ end: } enum lttng_condition_status -lttng_condition_buffer_usage_set_threshold( - struct lttng_condition *condition, uint64_t threshold_bytes) +lttng_condition_buffer_usage_set_threshold(struct lttng_condition *condition, + uint64_t threshold_bytes) { struct lttng_condition_buffer_usage *usage; enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK; @@ -669,8 +618,7 @@ lttng_condition_buffer_usage_set_threshold( goto end; } - usage = lttng::utils::container_of(condition, - <tng_condition_buffer_usage::parent); + usage = lttng::utils::container_of(condition, <tng_condition_buffer_usage::parent); usage->threshold_ratio.set = false; usage->threshold_bytes.set = true; usage->threshold_bytes.value = threshold_bytes; @@ -679,9 +627,8 @@ end: } enum lttng_condition_status -lttng_condition_buffer_usage_get_session_name( - const struct lttng_condition *condition, - const char **session_name) +lttng_condition_buffer_usage_get_session_name(const struct lttng_condition *condition, + const char **session_name) { struct lttng_condition_buffer_usage *usage; enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK; @@ -691,8 +638,7 @@ lttng_condition_buffer_usage_get_session_name( goto end; } - usage = lttng::utils::container_of(condition, - <tng_condition_buffer_usage::parent); + usage = lttng::utils::container_of(condition, <tng_condition_buffer_usage::parent); if (!usage->session_name) { status = LTTNG_CONDITION_STATUS_UNSET; goto end; @@ -703,21 +649,20 @@ end: } enum lttng_condition_status -lttng_condition_buffer_usage_set_session_name( - struct lttng_condition *condition, const char *session_name) +lttng_condition_buffer_usage_set_session_name(struct lttng_condition *condition, + const char *session_name) { char *session_name_copy; struct lttng_condition_buffer_usage *usage; enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK; if (!condition || !IS_USAGE_CONDITION(condition) || !session_name || - strlen(session_name) == 0) { + strlen(session_name) == 0) { status = LTTNG_CONDITION_STATUS_INVALID; goto end; } - usage = lttng::utils::container_of(condition, - <tng_condition_buffer_usage::parent); + usage = lttng::utils::container_of(condition, <tng_condition_buffer_usage::parent); session_name_copy = strdup(session_name); if (!session_name_copy) { status = LTTNG_CONDITION_STATUS_ERROR; @@ -733,9 +678,8 @@ end: } enum lttng_condition_status -lttng_condition_buffer_usage_get_channel_name( - const struct lttng_condition *condition, - const char **channel_name) +lttng_condition_buffer_usage_get_channel_name(const struct lttng_condition *condition, + const char **channel_name) { struct lttng_condition_buffer_usage *usage; enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK; @@ -745,8 +689,7 @@ lttng_condition_buffer_usage_get_channel_name( goto end; } - usage = lttng::utils::container_of(condition, - <tng_condition_buffer_usage::parent); + usage = lttng::utils::container_of(condition, <tng_condition_buffer_usage::parent); if (!usage->channel_name) { status = LTTNG_CONDITION_STATUS_UNSET; goto end; @@ -757,21 +700,20 @@ end: } enum lttng_condition_status -lttng_condition_buffer_usage_set_channel_name( - struct lttng_condition *condition, const char *channel_name) +lttng_condition_buffer_usage_set_channel_name(struct lttng_condition *condition, + const char *channel_name) { char *channel_name_copy; struct lttng_condition_buffer_usage *usage; enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK; if (!condition || !IS_USAGE_CONDITION(condition) || !channel_name || - strlen(channel_name) == 0) { + strlen(channel_name) == 0) { status = LTTNG_CONDITION_STATUS_INVALID; goto end; } - usage = lttng::utils::container_of(condition, - <tng_condition_buffer_usage::parent); + usage = lttng::utils::container_of(condition, <tng_condition_buffer_usage::parent); channel_name_copy = strdup(channel_name); if (!channel_name_copy) { status = LTTNG_CONDITION_STATUS_ERROR; @@ -787,9 +729,8 @@ end: } enum lttng_condition_status -lttng_condition_buffer_usage_get_domain_type( - const struct lttng_condition *condition, - enum lttng_domain_type *type) +lttng_condition_buffer_usage_get_domain_type(const struct lttng_condition *condition, + enum lttng_domain_type *type) { struct lttng_condition_buffer_usage *usage; enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK; @@ -799,8 +740,7 @@ lttng_condition_buffer_usage_get_domain_type( goto end; } - usage = lttng::utils::container_of(condition, - <tng_condition_buffer_usage::parent); + usage = lttng::utils::container_of(condition, <tng_condition_buffer_usage::parent); if (!usage->domain.set) { status = LTTNG_CONDITION_STATUS_UNSET; goto end; @@ -811,56 +751,48 @@ end: } enum lttng_condition_status -lttng_condition_buffer_usage_set_domain_type( - struct lttng_condition *condition, enum lttng_domain_type type) +lttng_condition_buffer_usage_set_domain_type(struct lttng_condition *condition, + enum lttng_domain_type type) { struct lttng_condition_buffer_usage *usage; enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK; - if (!condition || !IS_USAGE_CONDITION(condition) || - type == LTTNG_DOMAIN_NONE) { + if (!condition || !IS_USAGE_CONDITION(condition) || type == LTTNG_DOMAIN_NONE) { status = LTTNG_CONDITION_STATUS_INVALID; goto end; } - usage = lttng::utils::container_of(condition, - <tng_condition_buffer_usage::parent); + usage = lttng::utils::container_of(condition, <tng_condition_buffer_usage::parent); usage->domain.set = true; usage->domain.type = type; end: return status; } -static -int lttng_evaluation_buffer_usage_serialize( - const struct lttng_evaluation *evaluation, - struct lttng_payload *payload) +static int lttng_evaluation_buffer_usage_serialize(const struct lttng_evaluation *evaluation, + struct lttng_payload *payload) { struct lttng_evaluation_buffer_usage *usage; struct lttng_evaluation_buffer_usage_comm comm; - usage = lttng::utils::container_of(evaluation, - <tng_evaluation_buffer_usage::parent); + usage = lttng::utils::container_of(evaluation, <tng_evaluation_buffer_usage::parent); comm.buffer_use = usage->buffer_use; comm.buffer_capacity = usage->buffer_capacity; - return lttng_dynamic_buffer_append( - &payload->buffer, &comm, sizeof(comm)); + return lttng_dynamic_buffer_append(&payload->buffer, &comm, sizeof(comm)); } -static -void lttng_evaluation_buffer_usage_destroy( - struct lttng_evaluation *evaluation) +static void lttng_evaluation_buffer_usage_destroy(struct lttng_evaluation *evaluation) { struct lttng_evaluation_buffer_usage *usage; - usage = lttng::utils::container_of(evaluation, - <tng_evaluation_buffer_usage::parent); + usage = lttng::utils::container_of(evaluation, <tng_evaluation_buffer_usage::parent); free(usage); } -struct lttng_evaluation *lttng_evaluation_buffer_usage_create( - enum lttng_condition_type type, uint64_t use, uint64_t capacity) +struct lttng_evaluation *lttng_evaluation_buffer_usage_create(enum lttng_condition_type type, + uint64_t use, + uint64_t capacity) { struct lttng_evaluation_buffer_usage *usage; @@ -883,8 +815,8 @@ end: * evaluate to "true". */ enum lttng_evaluation_status -lttng_evaluation_buffer_usage_get_usage_ratio( - const struct lttng_evaluation *evaluation, double *usage_ratio) +lttng_evaluation_buffer_usage_get_usage_ratio(const struct lttng_evaluation *evaluation, + double *usage_ratio) { struct lttng_evaluation_buffer_usage *usage; enum lttng_evaluation_status status = LTTNG_EVALUATION_STATUS_OK; @@ -894,18 +826,15 @@ lttng_evaluation_buffer_usage_get_usage_ratio( goto end; } - usage = lttng::utils::container_of(evaluation, - <tng_evaluation_buffer_usage::parent); - *usage_ratio = (double) usage->buffer_use / - (double) usage->buffer_capacity; + usage = lttng::utils::container_of(evaluation, <tng_evaluation_buffer_usage::parent); + *usage_ratio = (double) usage->buffer_use / (double) usage->buffer_capacity; end: return status; } enum lttng_evaluation_status -lttng_evaluation_buffer_usage_get_usage( - const struct lttng_evaluation *evaluation, - uint64_t *usage_bytes) +lttng_evaluation_buffer_usage_get_usage(const struct lttng_evaluation *evaluation, + uint64_t *usage_bytes) { struct lttng_evaluation_buffer_usage *usage; enum lttng_evaluation_status status = LTTNG_EVALUATION_STATUS_OK; @@ -915,8 +844,7 @@ lttng_evaluation_buffer_usage_get_usage( goto end; } - usage = lttng::utils::container_of(evaluation, - <tng_evaluation_buffer_usage::parent); + usage = lttng::utils::container_of(evaluation, <tng_evaluation_buffer_usage::parent); *usage_bytes = usage->buffer_use; end: return status;