[lttng-tools.git] / src / common / conditions / session-consumed-size.c

/*
 * Copyright (C) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

#include <lttng/condition/condition-internal.h>
#include <lttng/condition/session-consumed-size-internal.h>
#include <lttng/constant.h>
#include <common/macros.h>
#include <common/error.h>
#include <assert.h>
#include <math.h>
#include <float.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_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)
{
	struct lttng_condition_session_consumed_size *consumed_size;

	consumed_size = container_of(condition,
			struct lttng_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)
{
	bool valid = false;
	struct lttng_condition_session_consumed_size *consumed;

	if (!condition) {
		goto end;
	}

	consumed = container_of(condition, struct lttng_condition_session_consumed_size,
			parent);
	if (!consumed->session_name) {
		ERR("Invalid session consumed size condition: a target session name must be set.");
		goto end;
	}
	if (!consumed->consumed_threshold_bytes.set) {
		ERR("Invalid session consumed size condition: a threshold must be set.");
		goto end;
	}

	valid = true;
end:
	return valid;
}

static
int lttng_condition_session_consumed_size_serialize(
		const struct lttng_condition *condition,
		struct lttng_dynamic_buffer *buf,
		int *fd_to_send)
{
	int ret;
	size_t session_name_len;
	struct lttng_condition_session_consumed_size *consumed;
	struct lttng_condition_session_consumed_size_comm consumed_comm;

	if (!condition || !IS_CONSUMED_SIZE_CONDITION(condition)) {
		ret = -1;
		goto end;
	}

	DBG("Serializing session consumed size condition");
	consumed = container_of(condition,
			struct lttng_condition_session_consumed_size,
			parent);

	session_name_len = strlen(consumed->session_name) + 1;
	if (session_name_len > LTTNG_NAME_MAX) {
		ret = -1;
		goto end;
	}

	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(buf, &consumed_comm,
			sizeof(consumed_comm));
	if (ret) {
		goto end;
	}
	ret = lttng_dynamic_buffer_append(buf, consumed->session_name,
			session_name_len);
	if (ret) {
		goto end;
	}

	if (fd_to_send) {
		/* No fd to send */
		*fd_to_send = -1;
	}
end:
	return ret;
}

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;

	a = container_of(_a, struct lttng_condition_session_consumed_size, parent);
	b = container_of(_b, struct lttng_condition_session_consumed_size, parent);

	if (a->consumed_threshold_bytes.set && b->consumed_threshold_bytes.set) {
		uint64_t a_value, b_value;

		a_value = a->consumed_threshold_bytes.value;
		b_value = b->consumed_threshold_bytes.value;
		if (a_value != b_value) {
			goto end;
		}
	}

	assert(a->session_name);
	assert(b->session_name);
	if (strcmp(a->session_name, b->session_name)) {
		goto end;
	}

	is_equal = true;
end:
	return is_equal;
}

struct lttng_condition *lttng_condition_session_consumed_size_create(void)
{
	struct lttng_condition_session_consumed_size *condition;

	condition = zmalloc(sizeof(struct lttng_condition_session_consumed_size));
	if (!condition) {
		return NULL;
	}

	lttng_condition_init(&condition->parent, LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE);
	condition->parent.validate = lttng_condition_session_consumed_size_validate;
	condition->parent.serialize = lttng_condition_session_consumed_size_serialize;
	condition->parent.equal = lttng_condition_session_consumed_size_is_equal;
	condition->parent.destroy = lttng_condition_session_consumed_size_destroy;
	return &condition->parent;
}

static
ssize_t init_condition_from_buffer(struct lttng_condition *condition,
		const struct lttng_buffer_view *src_view)
{
	ssize_t ret, condition_size;
	enum lttng_condition_status status;
	const struct lttng_condition_session_consumed_size_comm *condition_comm;
	const char *session_name;
	struct lttng_buffer_view names_view;

	if (src_view->size < sizeof(*condition_comm)) {
		ERR("Failed to initialize from malformed condition buffer: buffer too short to contain header");
		ret = -1;
		goto end;
	}

	condition_comm = (const struct lttng_condition_session_consumed_size_comm *) src_view->data;
	names_view = lttng_buffer_view_from_view(src_view,
			sizeof(*condition_comm), -1);

	if (condition_comm->session_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) {
		ERR("Failed to initialize from malformed condition buffer: buffer too short to contain element names");
		ret = -1;
		goto end;
	}

	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;
	}

	session_name = names_view.data;
	if (*(session_name + condition_comm->session_name_len - 1) != '\0') {
		ERR("Malformed session name encountered in condition buffer");
		ret = -1;
		goto end;
	}

	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;
	}

	if (!lttng_condition_validate(condition)) {
		ret = -1;
		goto end;
	}

	condition_size = sizeof(*condition_comm) +
			(ssize_t) condition_comm->session_name_len;
	ret = condition_size;
end:
	return ret;
}

LTTNG_HIDDEN
ssize_t lttng_condition_session_consumed_size_create_from_buffer(
		const struct lttng_buffer_view *view,
		struct lttng_condition **_condition)
{
	ssize_t ret;
	struct lttng_condition *condition =
			lttng_condition_session_consumed_size_create();

	if (!_condition || !condition) {
		ret = -1;
		goto error;
	}

	ret = init_condition_from_buffer(condition, view);
	if (ret < 0) {
		goto error;
	}

	*_condition = condition;
	return ret;
error:
	lttng_condition_destroy(condition);
	return ret;
}

static
struct lttng_evaluation *create_evaluation_from_buffer(
		const struct lttng_buffer_view *view)
{
	const struct lttng_evaluation_session_consumed_size_comm *comm =
			(const struct lttng_evaluation_session_consumed_size_comm *) view->data;
	struct lttng_evaluation *evaluation = NULL;

	if (view->size < sizeof(*comm)) {
		goto end;
	}

	evaluation = lttng_evaluation_session_consumed_size_create(
			comm->session_consumed);
end:
	return evaluation;
}

LTTNG_HIDDEN
ssize_t lttng_evaluation_session_consumed_size_create_from_buffer(
		const struct lttng_buffer_view *view,
		struct lttng_evaluation **_evaluation)
{
	ssize_t ret;
	struct lttng_evaluation *evaluation = NULL;

	if (!_evaluation) {
		ret = -1;
		goto error;
	}

	evaluation = create_evaluation_from_buffer(view);
	if (!evaluation) {
		ret = -1;
		goto error;
	}

	*_evaluation = evaluation;
	ret = sizeof(struct lttng_evaluation_session_consumed_size_comm);
	return ret;
error:
	lttng_evaluation_destroy(evaluation);
	return ret;
}

enum lttng_condition_status
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;

	if (!condition || !IS_CONSUMED_SIZE_CONDITION(condition) || !consumed_threshold_bytes) {
		status = LTTNG_CONDITION_STATUS_INVALID;
		goto end;
	}

	consumed = container_of(condition, struct lttng_condition_session_consumed_size,
			parent);
	if (!consumed->consumed_threshold_bytes.set) {
		status = LTTNG_CONDITION_STATUS_UNSET;
		goto end;
	}
	*consumed_threshold_bytes = consumed->consumed_threshold_bytes.value;
end:
	return status;
}

enum lttng_condition_status
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;

	if (!condition || !IS_CONSUMED_SIZE_CONDITION(condition)) {
		status = LTTNG_CONDITION_STATUS_INVALID;
		goto end;
	}

	consumed = container_of(condition, struct lttng_condition_session_consumed_size,
			parent);
	consumed->consumed_threshold_bytes.set = true;
	consumed->consumed_threshold_bytes.value = consumed_threshold_bytes;
end:
	return status;
}

enum lttng_condition_status
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;

	if (!condition || !IS_CONSUMED_SIZE_CONDITION(condition) || !session_name) {
		status = LTTNG_CONDITION_STATUS_INVALID;
		goto end;
	}

	consumed = container_of(condition, struct lttng_condition_session_consumed_size,
			parent);
	if (!consumed->session_name) {
		status = LTTNG_CONDITION_STATUS_UNSET;
		goto end;
	}
	*session_name = consumed->session_name;
end:
	return status;
}

enum lttng_condition_status
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) {
		status = LTTNG_CONDITION_STATUS_INVALID;
		goto end;
	}

	consumed = container_of(condition, struct lttng_condition_session_consumed_size,
			parent);
	session_name_copy = strdup(session_name);
	if (!session_name_copy) {
		status = LTTNG_CONDITION_STATUS_ERROR;
		goto end;
	}

	if (consumed->session_name) {
		free(consumed->session_name);
	}
	consumed->session_name = session_name_copy;
end:
	return status;
}

static
int lttng_evaluation_session_consumed_size_serialize(
		const struct lttng_evaluation *evaluation,
		struct lttng_dynamic_buffer *buf)
{
	struct lttng_evaluation_session_consumed_size *consumed;
	struct lttng_evaluation_session_consumed_size_comm comm;

	consumed = container_of(evaluation, struct lttng_evaluation_session_consumed_size,
			parent);
	comm.session_consumed = consumed->session_consumed;
	return lttng_dynamic_buffer_append(buf, &comm, sizeof(comm));
}

static
void lttng_evaluation_session_consumed_size_destroy(
		struct lttng_evaluation *evaluation)
{
	struct lttng_evaluation_session_consumed_size *consumed;

	consumed = container_of(evaluation, struct lttng_evaluation_session_consumed_size,
			parent);
	free(consumed);
}

LTTNG_HIDDEN
struct lttng_evaluation *lttng_evaluation_session_consumed_size_create(
		uint64_t consumed)
{
	struct lttng_evaluation_session_consumed_size *consumed_eval;

	consumed_eval = zmalloc(sizeof(struct lttng_evaluation_session_consumed_size));
	if (!consumed_eval) {
		goto end;
	}

	consumed_eval->parent.type = LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE;
	consumed_eval->session_consumed = consumed;
	consumed_eval->parent.serialize = lttng_evaluation_session_consumed_size_serialize;
	consumed_eval->parent.destroy = lttng_evaluation_session_consumed_size_destroy;
end:
	return &consumed_eval->parent;
}

enum lttng_evaluation_status
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) {
		status = LTTNG_EVALUATION_STATUS_INVALID;
		goto end;
	}

	consumed = container_of(evaluation, struct lttng_evaluation_session_consumed_size,
			parent);
	*session_consumed = consumed->session_consumed;
end:
	return status;
}
Commit	Line	Data
e8360425	1	/*
ab5be9fa	2	* Copyright (C) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
e8360425	3	*
ab5be9fa	4	* SPDX-License-Identifier: LGPL-2.1-only
e8360425	5	*
e8360425 JD	6	*/
	7
	8	#include <lttng/condition/condition-internal.h>
	9	#include <lttng/condition/session-consumed-size-internal.h>
319370bd	10	#include <lttng/constant.h>
e8360425 JD	11	#include <common/macros.h>
	12	#include <common/error.h>
	13	#include <assert.h>
	14	#include <math.h>
	15	#include <float.h>
	16	#include <time.h>
	17
	18	#define IS_CONSUMED_SIZE_CONDITION(condition) ( \
	19	lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE \
	20	)
	21
	22	#define IS_CONSUMED_SIZE_EVALUATION(evaluation) ( \
	23	lttng_evaluation_get_type(evaluation) == LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE \
	24	)
	25
	26	static
	27	void lttng_condition_session_consumed_size_destroy(struct lttng_condition *condition)
	28	{
	29	struct lttng_condition_session_consumed_size *consumed_size;
	30
	31	consumed_size = container_of(condition,
	32	struct lttng_condition_session_consumed_size, parent);
	33
	34	free(consumed_size->session_name);
	35	free(consumed_size);
	36	}
	37
	38	static
	39	bool lttng_condition_session_consumed_size_validate(
	40	const struct lttng_condition *condition)
	41	{
	42	bool valid = false;
	43	struct lttng_condition_session_consumed_size *consumed;
	44
	45	if (!condition) {
	46	goto end;
	47	}
	48
	49	consumed = container_of(condition, struct lttng_condition_session_consumed_size,
	50	parent);
	51	if (!consumed->session_name) {
9ef5b6be	52	ERR("Invalid session consumed size condition: a target session name must be set.");
e8360425 JD	53	goto end;
	54	}
	55	if (!consumed->consumed_threshold_bytes.set) {
9ef5b6be	56	ERR("Invalid session consumed size condition: a threshold must be set.");
e8360425 JD	57	goto end;
	58	}
	59
	60	valid = true;
	61	end:
	62	return valid;
	63	}
	64
	65	static
3647288f JG	66	int lttng_condition_session_consumed_size_serialize(
3647288f JG	67	const struct lttng_condition *condition,
d3a684ee JR	68	struct lttng_dynamic_buffer *buf,
d3a684ee JR	69	int *fd_to_send)
e8360425	70	{
3647288f	71	int ret;
e8360425	72	size_t session_name_len;
3647288f JG	73	struct lttng_condition_session_consumed_size *consumed;
3647288f JG	74	struct lttng_condition_session_consumed_size_comm consumed_comm;
e8360425 JD	75
	76	if (!condition \|\| !IS_CONSUMED_SIZE_CONDITION(condition)) {
	77	ret = -1;
	78	goto end;
	79	}
	80
3647288f JG	81	DBG("Serializing session consumed size condition");
	82	consumed = container_of(condition,
	83	struct lttng_condition_session_consumed_size,
e8360425	84	parent);
3647288f	85
e8360425 JD	86	session_name_len = strlen(consumed->session_name) + 1;
	87	if (session_name_len > LTTNG_NAME_MAX) {
	88	ret = -1;
	89	goto end;
	90	}
3647288f JG	91
	92	consumed_comm.consumed_threshold_bytes =
	93	consumed->consumed_threshold_bytes.value;
	94	consumed_comm.session_name_len = (uint32_t) session_name_len;
	95
	96	ret = lttng_dynamic_buffer_append(buf, &consumed_comm,
	97	sizeof(consumed_comm));
	98	if (ret) {
	99	goto end;
	100	}
	101	ret = lttng_dynamic_buffer_append(buf, consumed->session_name,
	102	session_name_len);
	103	if (ret) {
	104	goto end;
e8360425	105	}
d3a684ee JR	106
	107	if (fd_to_send) {
	108	/* No fd to send */
	109	*fd_to_send = -1;
	110	}
e8360425 JD	111	end:
	112	return ret;
	113	}
	114
	115	static
	116	bool lttng_condition_session_consumed_size_is_equal(const struct lttng_condition *_a,
	117	const struct lttng_condition *_b)
	118	{
	119	bool is_equal = false;
	120	struct lttng_condition_session_consumed_size a, b;
	121
	122	a = container_of(_a, struct lttng_condition_session_consumed_size, parent);
	123	b = container_of(_b, struct lttng_condition_session_consumed_size, parent);
	124
	125	if (a->consumed_threshold_bytes.set && b->consumed_threshold_bytes.set) {
	126	uint64_t a_value, b_value;
	127
	128	a_value = a->consumed_threshold_bytes.value;
	129	b_value = b->consumed_threshold_bytes.value;
	130	if (a_value != b_value) {
	131	goto end;
	132	}
	133	}
	134
821d5e92 JG	135	assert(a->session_name);
	136	assert(b->session_name);
	137	if (strcmp(a->session_name, b->session_name)) {
e8360425 JD	138	goto end;
	139	}
	140
	141	is_equal = true;
	142	end:
	143	return is_equal;
	144	}
	145
	146	struct lttng_condition *lttng_condition_session_consumed_size_create(void)
	147	{
	148	struct lttng_condition_session_consumed_size *condition;
	149
	150	condition = zmalloc(sizeof(struct lttng_condition_session_consumed_size));
	151	if (!condition) {
	152	return NULL;
	153	}
	154
	155	lttng_condition_init(&condition->parent, LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE);
	156	condition->parent.validate = lttng_condition_session_consumed_size_validate;
	157	condition->parent.serialize = lttng_condition_session_consumed_size_serialize;
	158	condition->parent.equal = lttng_condition_session_consumed_size_is_equal;
	159	condition->parent.destroy = lttng_condition_session_consumed_size_destroy;
	160	return &condition->parent;
	161	}
	162
	163	static
	164	ssize_t init_condition_from_buffer(struct lttng_condition *condition,
	165	const struct lttng_buffer_view *src_view)
	166	{
	167	ssize_t ret, condition_size;
	168	enum lttng_condition_status status;
	169	const struct lttng_condition_session_consumed_size_comm *condition_comm;
	170	const char *session_name;
	171	struct lttng_buffer_view names_view;
	172
	173	if (src_view->size < sizeof(*condition_comm)) {
	174	ERR("Failed to initialize from malformed condition buffer: buffer too short to contain header");
	175	ret = -1;
	176	goto end;
	177	}
	178
	179	condition_comm = (const struct lttng_condition_session_consumed_size_comm *) src_view->data;
	180	names_view = lttng_buffer_view_from_view(src_view,
	181	sizeof(*condition_comm), -1);
	182
	183	if (condition_comm->session_name_len > LTTNG_NAME_MAX) {
	184	ERR("Failed to initialize from malformed condition buffer: name exceeds LTTNG_MAX_NAME");
	185	ret = -1;
	186	goto end;
	187	}
	188
	189	if (names_view.size < condition_comm->session_name_len) {
	190	ERR("Failed to initialize from malformed condition buffer: buffer too short to contain element names");
	191	ret = -1;
	192	goto end;
	193	}
	194
	195	status = lttng_condition_session_consumed_size_set_threshold(condition,
	196	condition_comm->consumed_threshold_bytes);
	197	if (status != LTTNG_CONDITION_STATUS_OK) {
9ef5b6be	198	ERR("Failed to initialize session consumed size condition threshold");
e8360425 JD	199	ret = -1;
	200	goto end;
	201	}
	202
	203	session_name = names_view.data;
	204	if (*(session_name + condition_comm->session_name_len - 1) != '\0') {
	205	ERR("Malformed session name encountered in condition buffer");
	206	ret = -1;
	207	goto end;
	208	}
	209
	210	status = lttng_condition_session_consumed_size_set_session_name(condition,
	211	session_name);
	212	if (status != LTTNG_CONDITION_STATUS_OK) {
9ef5b6be	213	ERR("Failed to set session consumed size condition's session name");
e8360425 JD	214	ret = -1;
	215	goto end;
	216	}
	217
	218	if (!lttng_condition_validate(condition)) {
	219	ret = -1;
	220	goto end;
	221	}
	222
	223	condition_size = sizeof(*condition_comm) +
	224	(ssize_t) condition_comm->session_name_len;
	225	ret = condition_size;
	226	end:
	227	return ret;
	228	}
	229
	230	LTTNG_HIDDEN
	231	ssize_t lttng_condition_session_consumed_size_create_from_buffer(
	232	const struct lttng_buffer_view *view,
	233	struct lttng_condition **_condition)
	234	{
	235	ssize_t ret;
	236	struct lttng_condition *condition =
	237	lttng_condition_session_consumed_size_create();
	238
	239	if (!_condition \|\| !condition) {
	240	ret = -1;
	241	goto error;
	242	}
	243
	244	ret = init_condition_from_buffer(condition, view);
	245	if (ret < 0) {
	246	goto error;
	247	}
	248
	249	*_condition = condition;
	250	return ret;
	251	error:
	252	lttng_condition_destroy(condition);
	253	return ret;
	254	}
	255
	256	static
	257	struct lttng_evaluation *create_evaluation_from_buffer(
e8360425 JD	258	const struct lttng_buffer_view *view)
	259	{
	260	const struct lttng_evaluation_session_consumed_size_comm *comm =
	261	(const struct lttng_evaluation_session_consumed_size_comm *) view->data;
	262	struct lttng_evaluation *evaluation = NULL;
	263
	264	if (view->size < sizeof(*comm)) {
	265	goto end;
	266	}
	267
5f2c1c0f	268	evaluation = lttng_evaluation_session_consumed_size_create(
e8360425 JD	269	comm->session_consumed);
	270	end:
	271	return evaluation;
	272	}
	273
	274	LTTNG_HIDDEN
	275	ssize_t lttng_evaluation_session_consumed_size_create_from_buffer(
	276	const struct lttng_buffer_view *view,
	277	struct lttng_evaluation **_evaluation)
	278	{
	279	ssize_t ret;
	280	struct lttng_evaluation *evaluation = NULL;
	281
	282	if (!_evaluation) {
	283	ret = -1;
	284	goto error;
	285	}
	286
5f2c1c0f	287	evaluation = create_evaluation_from_buffer(view);
e8360425 JD	288	if (!evaluation) {
	289	ret = -1;
	290	goto error;
	291	}
	292
	293	*_evaluation = evaluation;
	294	ret = sizeof(struct lttng_evaluation_session_consumed_size_comm);
	295	return ret;
	296	error:
	297	lttng_evaluation_destroy(evaluation);
	298	return ret;
	299	}
	300
	301	enum lttng_condition_status
	302	lttng_condition_session_consumed_size_get_threshold(
	303	const struct lttng_condition *condition,
	304	uint64_t *consumed_threshold_bytes)
	305	{
	306	struct lttng_condition_session_consumed_size *consumed;
	307	enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
	308
	309	if (!condition \|\| !IS_CONSUMED_SIZE_CONDITION(condition) \|\| !consumed_threshold_bytes) {
	310	status = LTTNG_CONDITION_STATUS_INVALID;
	311	goto end;
	312	}
	313
	314	consumed = container_of(condition, struct lttng_condition_session_consumed_size,
	315	parent);
	316	if (!consumed->consumed_threshold_bytes.set) {
	317	status = LTTNG_CONDITION_STATUS_UNSET;
	318	goto end;
	319	}
	320	*consumed_threshold_bytes = consumed->consumed_threshold_bytes.value;
	321	end:
	322	return status;
	323	}
	324
	325	enum lttng_condition_status
	326	lttng_condition_session_consumed_size_set_threshold(
	327	struct lttng_condition *condition, uint64_t consumed_threshold_bytes)
	328	{
	329	struct lttng_condition_session_consumed_size *consumed;
	330	enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
	331
	332	if (!condition \|\| !IS_CONSUMED_SIZE_CONDITION(condition)) {
	333	status = LTTNG_CONDITION_STATUS_INVALID;
	334	goto end;
	335	}
	336
	337	consumed = container_of(condition, struct lttng_condition_session_consumed_size,
	338	parent);
	339	consumed->consumed_threshold_bytes.set = true;
	340	consumed->consumed_threshold_bytes.value = consumed_threshold_bytes;
	341	end:
	342	return status;
	343	}
	344
	345	enum lttng_condition_status
	346	lttng_condition_session_consumed_size_get_session_name(
	347	const struct lttng_condition *condition,
	348	const char **session_name)
	349	{
	350	struct lttng_condition_session_consumed_size *consumed;
	351	enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
352
353	if (!condition \|\| !IS_CONSUMED_SIZE_CONDITION(condition) \|\| !session_name) {
354	status = LTTNG_CONDITION_STATUS_INVALID;
355	goto end;
356	}
357
358	consumed = container_of(condition, struct lttng_condition_session_consumed_size,
359	parent);
360	if (!consumed->session_name) {
361	status = LTTNG_CONDITION_STATUS_UNSET;
362	goto end;
363	}
364	*session_name = consumed->session_name;
365	end:
366	return status;
367	}
368
369	enum lttng_condition_status
370	lttng_condition_session_consumed_size_set_session_name(
371	struct lttng_condition condition, const char session_name)
372	{
373	char *session_name_copy;
374	struct lttng_condition_session_consumed_size *consumed;
375	enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
376
377	if (!condition \|\| !IS_CONSUMED_SIZE_CONDITION(condition) \|\|
378	!session_name \|\| strlen(session_name) == 0) {
379	status = LTTNG_CONDITION_STATUS_INVALID;
380	goto end;
381	}
382
383	consumed = container_of(condition, struct lttng_condition_session_consumed_size,
384	parent);
385	session_name_copy = strdup(session_name);
386	if (!session_name_copy) {
387	status = LTTNG_CONDITION_STATUS_ERROR;
388	goto end;
389	}
390
391	if (consumed->session_name) {
392	free(consumed->session_name);
393	}
394	consumed->session_name = session_name_copy;
395	end:
396	return status;
397	}
398
399	static
3647288f	400	int lttng_evaluation_session_consumed_size_serialize(
9b63a4aa	401	const struct lttng_evaluation *evaluation,
3647288f	402	struct lttng_dynamic_buffer *buf)
e8360425	403	{
e8360425	404	struct lttng_evaluation_session_consumed_size *consumed;
3647288f	405	struct lttng_evaluation_session_consumed_size_comm comm;
e8360425 JD	406
	407	consumed = container_of(evaluation, struct lttng_evaluation_session_consumed_size,
	408	parent);
3647288f JG	409	comm.session_consumed = consumed->session_consumed;
3647288f JG	410	return lttng_dynamic_buffer_append(buf, &comm, sizeof(comm));
e8360425 JD	411	}
	412
	413	static
	414	void lttng_evaluation_session_consumed_size_destroy(
	415	struct lttng_evaluation *evaluation)
	416	{
	417	struct lttng_evaluation_session_consumed_size *consumed;
	418
	419	consumed = container_of(evaluation, struct lttng_evaluation_session_consumed_size,
	420	parent);
	421	free(consumed);
	422	}
	423
	424	LTTNG_HIDDEN
	425	struct lttng_evaluation *lttng_evaluation_session_consumed_size_create(
5f2c1c0f	426	uint64_t consumed)
e8360425 JD	427	{
	428	struct lttng_evaluation_session_consumed_size *consumed_eval;
	429
	430	consumed_eval = zmalloc(sizeof(struct lttng_evaluation_session_consumed_size));
	431	if (!consumed_eval) {
	432	goto end;
	433	}
	434
5f2c1c0f	435	consumed_eval->parent.type = LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE;
e8360425 JD	436	consumed_eval->session_consumed = consumed;
	437	consumed_eval->parent.serialize = lttng_evaluation_session_consumed_size_serialize;
	438	consumed_eval->parent.destroy = lttng_evaluation_session_consumed_size_destroy;
	439	end:
	440	return &consumed_eval->parent;
	441	}
	442
	443	enum lttng_evaluation_status
	444	lttng_evaluation_session_consumed_size_get_consumed_size(
	445	const struct lttng_evaluation *evaluation,
	446	uint64_t *session_consumed)
	447	{
	448	struct lttng_evaluation_session_consumed_size *consumed;
	449	enum lttng_evaluation_status status = LTTNG_EVALUATION_STATUS_OK;
	450
	451	if (!evaluation \|\| !IS_CONSUMED_SIZE_EVALUATION(evaluation) \|\|
	452	!session_consumed) {
	453	status = LTTNG_EVALUATION_STATUS_INVALID;
	454	goto end;
	455	}
	456
	457	consumed = container_of(evaluation, struct lttng_evaluation_session_consumed_size,
	458	parent);
	459	*session_consumed = consumed->session_consumed;
	460	end:
	461	return status;
	462	}