#include <common/error.hpp>
#include <common/macros.hpp>
#include <common/mi-lttng.hpp>
-#include <float.h>
+
#include <lttng/condition/condition-internal.hpp>
#include <lttng/condition/session-consumed-size-internal.hpp>
#include <lttng/constant.h>
+
+#include <float.h>
#include <math.h>
#include <time.h>
-#define IS_CONSUMED_SIZE_CONDITION(condition) ( \
- lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE \
- )
+#define IS_CONSUMED_SIZE_CONDITION(condition) \
+ (lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE)
-#define IS_CONSUMED_SIZE_EVALUATION(evaluation) ( \
- lttng_evaluation_get_type(evaluation) == LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE \
- )
+#define IS_CONSUMED_SIZE_EVALUATION(evaluation) \
+ (lttng_evaluation_get_type(evaluation) == LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE)
-static
-void lttng_condition_session_consumed_size_destroy(struct lttng_condition *condition)
+static void lttng_condition_session_consumed_size_destroy(struct lttng_condition *condition)
{
struct lttng_condition_session_consumed_size *consumed_size;
consumed_size = lttng::utils::container_of(condition,
- <tng_condition_session_consumed_size::parent);
+ <tng_condition_session_consumed_size::parent);
free(consumed_size->session_name);
free(consumed_size);
}
-static
-bool lttng_condition_session_consumed_size_validate(
- const struct lttng_condition *condition)
+static bool lttng_condition_session_consumed_size_validate(const struct lttng_condition *condition)
{
bool valid = false;
struct lttng_condition_session_consumed_size *consumed;
}
consumed = lttng::utils::container_of(condition,
- <tng_condition_session_consumed_size::parent);
+ <tng_condition_session_consumed_size::parent);
if (!consumed->session_name) {
ERR("Invalid session consumed size condition: a target session name must be set.");
goto end;
return valid;
}
-static
-int lttng_condition_session_consumed_size_serialize(
- const struct lttng_condition *condition,
- struct lttng_payload *payload)
+static int lttng_condition_session_consumed_size_serialize(const struct lttng_condition *condition,
+ struct lttng_payload *payload)
{
int ret;
size_t session_name_len;
DBG("Serializing session consumed size condition");
consumed = lttng::utils::container_of(condition,
- <tng_condition_session_consumed_size::parent);
+ <tng_condition_session_consumed_size::parent);
session_name_len = strlen(consumed->session_name) + 1;
if (session_name_len > LTTNG_NAME_MAX) {
goto end;
}
- consumed_comm.consumed_threshold_bytes =
- consumed->consumed_threshold_bytes.value;
+ consumed_comm.consumed_threshold_bytes = consumed->consumed_threshold_bytes.value;
consumed_comm.session_name_len = (uint32_t) session_name_len;
- ret = lttng_dynamic_buffer_append(&payload->buffer, &consumed_comm,
- sizeof(consumed_comm));
+ ret = lttng_dynamic_buffer_append(&payload->buffer, &consumed_comm, sizeof(consumed_comm));
if (ret) {
goto end;
}
- ret = lttng_dynamic_buffer_append(&payload->buffer, consumed->session_name,
- session_name_len);
+ ret = lttng_dynamic_buffer_append(
+ &payload->buffer, consumed->session_name, session_name_len);
if (ret) {
goto end;
}
return ret;
}
-static
-bool lttng_condition_session_consumed_size_is_equal(const struct lttng_condition *_a,
- const struct lttng_condition *_b)
+static bool lttng_condition_session_consumed_size_is_equal(const struct lttng_condition *_a,
+ const struct lttng_condition *_b)
{
bool is_equal = false;
struct lttng_condition_session_consumed_size *a, *b;
return is_equal;
}
-static
-enum lttng_error_code lttng_condition_session_consumed_size_mi_serialize(
- const struct lttng_condition *condition,
- struct mi_writer *writer)
+static enum lttng_error_code
+lttng_condition_session_consumed_size_mi_serialize(const struct lttng_condition *condition,
+ struct mi_writer *writer)
{
int ret;
enum lttng_error_code ret_code;
LTTNG_ASSERT(writer);
LTTNG_ASSERT(IS_CONSUMED_SIZE_CONDITION(condition));
- status = lttng_condition_session_consumed_size_get_session_name(
- condition, &session_name);
+ status = lttng_condition_session_consumed_size_get_session_name(condition, &session_name);
LTTNG_ASSERT(status == LTTNG_CONDITION_STATUS_OK);
LTTNG_ASSERT(session_name);
- status = lttng_condition_session_consumed_size_get_threshold(
- condition, &threshold_bytes);
+ status = lttng_condition_session_consumed_size_get_threshold(condition, &threshold_bytes);
LTTNG_ASSERT(status == LTTNG_CONDITION_STATUS_OK);
/* Open condition session consumed size element. */
ret = mi_lttng_writer_open_element(writer,
- mi_lttng_element_condition_session_consumed_size);
+ mi_lttng_element_condition_session_consumed_size);
if (ret) {
goto mi_error;
}
/* 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;
}
/* Threshold 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;
}
return &condition->parent;
}
-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;
const char *session_name;
struct lttng_buffer_view session_name_view;
const struct lttng_condition_session_consumed_size_comm *condition_comm;
- struct lttng_payload_view condition_comm_view = lttng_payload_view_from_view(
- src_view, 0, sizeof(*condition_comm));
+ struct lttng_payload_view condition_comm_view =
+ 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");
}
condition_comm = (typeof(condition_comm)) condition_comm_view.buffer.data;
- session_name_view = lttng_buffer_view_from_view(&src_view->buffer,
- sizeof(*condition_comm), condition_comm->session_name_len);
+ session_name_view = lttng_buffer_view_from_view(
+ &src_view->buffer, sizeof(*condition_comm), condition_comm->session_name_len);
if (condition_comm->session_name_len > LTTNG_NAME_MAX) {
ERR("Failed to initialize from malformed condition buffer: name exceeds LTTNG_MAX_NAME");
goto end;
}
- status = lttng_condition_session_consumed_size_set_threshold(condition,
- condition_comm->consumed_threshold_bytes);
+ status = lttng_condition_session_consumed_size_set_threshold(
+ condition, condition_comm->consumed_threshold_bytes);
if (status != LTTNG_CONDITION_STATUS_OK) {
ERR("Failed to initialize session consumed size condition threshold");
ret = -1;
goto end;
}
- status = lttng_condition_session_consumed_size_set_session_name(condition,
- session_name);
+ status = lttng_condition_session_consumed_size_set_session_name(condition, session_name);
if (status != LTTNG_CONDITION_STATUS_OK) {
ERR("Failed to set session consumed size condition's session name");
ret = -1;
goto end;
}
- condition_size = sizeof(*condition_comm) +
- (ssize_t) condition_comm->session_name_len;
+ condition_size = sizeof(*condition_comm) + (ssize_t) condition_comm->session_name_len;
ret = condition_size;
end:
return ret;
}
-ssize_t lttng_condition_session_consumed_size_create_from_payload(
- struct lttng_payload_view *view,
- struct lttng_condition **_condition)
+ssize_t
+lttng_condition_session_consumed_size_create_from_payload(struct lttng_payload_view *view,
+ struct lttng_condition **_condition)
{
ssize_t ret;
- struct lttng_condition *condition =
- lttng_condition_session_consumed_size_create();
+ struct lttng_condition *condition = lttng_condition_session_consumed_size_create();
if (!_condition || !condition) {
ret = -1;
return ret;
}
-static
-struct lttng_evaluation *create_evaluation_from_payload(
- const struct lttng_payload_view *view)
+static struct lttng_evaluation *
+create_evaluation_from_payload(const struct lttng_payload_view *view)
{
const struct lttng_evaluation_session_consumed_size_comm *comm =
- (typeof(comm)) view->buffer.data;
+ (typeof(comm)) view->buffer.data;
struct lttng_evaluation *evaluation = NULL;
if (view->buffer.size < sizeof(*comm)) {
goto end;
}
- evaluation = lttng_evaluation_session_consumed_size_create(
- comm->session_consumed);
+ evaluation = lttng_evaluation_session_consumed_size_create(comm->session_consumed);
end:
return evaluation;
}
-ssize_t lttng_evaluation_session_consumed_size_create_from_payload(
- struct lttng_payload_view *view,
- struct lttng_evaluation **_evaluation)
+ssize_t
+lttng_evaluation_session_consumed_size_create_from_payload(struct lttng_payload_view *view,
+ struct lttng_evaluation **_evaluation)
{
ssize_t ret;
struct lttng_evaluation *evaluation = NULL;
}
enum lttng_condition_status
-lttng_condition_session_consumed_size_get_threshold(
- const struct lttng_condition *condition,
- uint64_t *consumed_threshold_bytes)
+lttng_condition_session_consumed_size_get_threshold(const struct lttng_condition *condition,
+ uint64_t *consumed_threshold_bytes)
{
struct lttng_condition_session_consumed_size *consumed;
enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
}
consumed = lttng::utils::container_of(condition,
- <tng_condition_session_consumed_size::parent);
+ <tng_condition_session_consumed_size::parent);
if (!consumed->consumed_threshold_bytes.set) {
status = LTTNG_CONDITION_STATUS_UNSET;
goto end;
}
enum lttng_condition_status
-lttng_condition_session_consumed_size_set_threshold(
- struct lttng_condition *condition, uint64_t consumed_threshold_bytes)
+lttng_condition_session_consumed_size_set_threshold(struct lttng_condition *condition,
+ uint64_t consumed_threshold_bytes)
{
struct lttng_condition_session_consumed_size *consumed;
enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
}
consumed = lttng::utils::container_of(condition,
- <tng_condition_session_consumed_size::parent);
+ <tng_condition_session_consumed_size::parent);
consumed->consumed_threshold_bytes.set = true;
consumed->consumed_threshold_bytes.value = consumed_threshold_bytes;
end:
}
enum lttng_condition_status
-lttng_condition_session_consumed_size_get_session_name(
- const struct lttng_condition *condition,
- const char **session_name)
+lttng_condition_session_consumed_size_get_session_name(const struct lttng_condition *condition,
+ const char **session_name)
{
struct lttng_condition_session_consumed_size *consumed;
enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
}
consumed = lttng::utils::container_of(condition,
- <tng_condition_session_consumed_size::parent);
+ <tng_condition_session_consumed_size::parent);
if (!consumed->session_name) {
status = LTTNG_CONDITION_STATUS_UNSET;
goto end;
}
enum lttng_condition_status
-lttng_condition_session_consumed_size_set_session_name(
- struct lttng_condition *condition, const char *session_name)
+lttng_condition_session_consumed_size_set_session_name(struct lttng_condition *condition,
+ const char *session_name)
{
char *session_name_copy;
struct lttng_condition_session_consumed_size *consumed;
enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
- if (!condition || !IS_CONSUMED_SIZE_CONDITION(condition) ||
- !session_name || strlen(session_name) == 0) {
+ if (!condition || !IS_CONSUMED_SIZE_CONDITION(condition) || !session_name ||
+ strlen(session_name) == 0) {
status = LTTNG_CONDITION_STATUS_INVALID;
goto end;
}
consumed = lttng::utils::container_of(condition,
- <tng_condition_session_consumed_size::parent);
+ <tng_condition_session_consumed_size::parent);
session_name_copy = strdup(session_name);
if (!session_name_copy) {
status = LTTNG_CONDITION_STATUS_ERROR;
return status;
}
-static
-int lttng_evaluation_session_consumed_size_serialize(
- const struct lttng_evaluation *evaluation,
- struct lttng_payload *payload)
+static int
+lttng_evaluation_session_consumed_size_serialize(const struct lttng_evaluation *evaluation,
+ struct lttng_payload *payload)
{
struct lttng_evaluation_session_consumed_size *consumed;
struct lttng_evaluation_session_consumed_size_comm comm;
consumed = lttng::utils::container_of(evaluation,
- <tng_evaluation_session_consumed_size::parent);
+ <tng_evaluation_session_consumed_size::parent);
comm.session_consumed = consumed->session_consumed;
- return lttng_dynamic_buffer_append(
- &payload->buffer, &comm, sizeof(comm));
+ return lttng_dynamic_buffer_append(&payload->buffer, &comm, sizeof(comm));
}
-static
-void lttng_evaluation_session_consumed_size_destroy(
- struct lttng_evaluation *evaluation)
+static void lttng_evaluation_session_consumed_size_destroy(struct lttng_evaluation *evaluation)
{
struct lttng_evaluation_session_consumed_size *consumed;
consumed = lttng::utils::container_of(evaluation,
- <tng_evaluation_session_consumed_size::parent);
+ <tng_evaluation_session_consumed_size::parent);
free(consumed);
}
-struct lttng_evaluation *lttng_evaluation_session_consumed_size_create(
- uint64_t consumed)
+struct lttng_evaluation *lttng_evaluation_session_consumed_size_create(uint64_t consumed)
{
struct lttng_evaluation_session_consumed_size *consumed_eval;
}
enum lttng_evaluation_status
-lttng_evaluation_session_consumed_size_get_consumed_size(
- const struct lttng_evaluation *evaluation,
- uint64_t *session_consumed)
+lttng_evaluation_session_consumed_size_get_consumed_size(const struct lttng_evaluation *evaluation,
+ uint64_t *session_consumed)
{
struct lttng_evaluation_session_consumed_size *consumed;
enum lttng_evaluation_status status = LTTNG_EVALUATION_STATUS_OK;
- if (!evaluation || !IS_CONSUMED_SIZE_EVALUATION(evaluation) ||
- !session_consumed) {
+ if (!evaluation || !IS_CONSUMED_SIZE_EVALUATION(evaluation) || !session_consumed) {
status = LTTNG_EVALUATION_STATUS_INVALID;
goto end;
}
consumed = lttng::utils::container_of(evaluation,
- <tng_evaluation_session_consumed_size::parent);
+ <tng_evaluation_session_consumed_size::parent);
*session_consumed = consumed->session_consumed;
end:
return status;
projects / lttng-tools.git / blobdiff