[lttng-tools.git] / src / common / actions / rate-policy.c

/*
 * Copyright (C) 2021 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

#include <assert.h>
#include <common/buffer-view.h>
#include <common/dynamic-buffer.h>
#include <common/error.h>
#include <common/macros.h>
#include <common/payload-view.h>
#include <common/payload.h>
#include <limits.h>
#include <lttng/action/rate-policy-internal.h>
#include <lttng/action/rate-policy.h>
#include <stdbool.h>
#include <sys/types.h>

#define IS_EVERY_N_RATE_POLICY(policy) \
	(lttng_rate_policy_get_type(policy) == LTTNG_RATE_POLICY_TYPE_EVERY_N)

#define IS_ONCE_AFTER_N_RATE_POLICY(policy)    \
	(lttng_rate_policy_get_type(policy) == \
			LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N)

typedef void (*rate_policy_destroy_cb)(struct lttng_rate_policy *rate_policy);
typedef int (*rate_policy_serialize_cb)(struct lttng_rate_policy *rate_policy,
		struct lttng_payload *payload);
typedef bool (*rate_policy_equal_cb)(const struct lttng_rate_policy *a,
		const struct lttng_rate_policy *b);
typedef ssize_t (*rate_policy_create_from_payload_cb)(
		struct lttng_payload_view *view,
		struct lttng_rate_policy **rate_policy);
typedef struct lttng_rate_policy *(*rate_policy_copy_cb)(
		const struct lttng_rate_policy *source);

struct lttng_rate_policy {
	enum lttng_rate_policy_type type;
	rate_policy_serialize_cb serialize;
	rate_policy_equal_cb equal;
	rate_policy_destroy_cb destroy;
	rate_policy_copy_cb copy;
};

struct lttng_rate_policy_every_n {
	struct lttng_rate_policy parent;
	uint64_t interval;
};

struct lttng_rate_policy_once_after_n {
	struct lttng_rate_policy parent;
	uint64_t threshold;
};

struct lttng_rate_policy_comm {
	/* enum lttng_rate_policy_type */
	int8_t rate_policy_type;
} LTTNG_PACKED;

struct lttng_rate_policy_once_after_n_comm {
	uint64_t threshold;
} LTTNG_PACKED;

struct lttng_rate_policy_every_n_comm {
	uint64_t interval;
} LTTNG_PACKED;

/* Forward declaration. */
static void lttng_rate_policy_init(struct lttng_rate_policy *rate_policy,
		enum lttng_rate_policy_type type,
		rate_policy_serialize_cb serialize,
		rate_policy_equal_cb equal,
		rate_policy_destroy_cb destroy,
		rate_policy_copy_cb copy);

/* Forward declaration. Every n */
static bool lttng_rate_policy_every_n_should_execute(
		const struct lttng_rate_policy *policy, uint64_t counter);

/* Forward declaration. Once after N */
static bool lttng_rate_policy_once_after_n_should_execute(
		const struct lttng_rate_policy *policy, uint64_t counter);

LTTNG_HIDDEN
const char *lttng_rate_policy_type_string(
		enum lttng_rate_policy_type rate_policy_type)
{
	switch (rate_policy_type) {
	case LTTNG_RATE_POLICY_TYPE_EVERY_N:
		return "EVERY-N";
	case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N:
		return "ONCE-AFTER-N";
	default:
		return "???";
	}
}

enum lttng_rate_policy_type lttng_rate_policy_get_type(
		const struct lttng_rate_policy *policy)
{
	return policy ? policy->type : LTTNG_RATE_POLICY_TYPE_UNKNOWN;
}

LTTNG_HIDDEN
void lttng_rate_policy_init(struct lttng_rate_policy *rate_policy,
		enum lttng_rate_policy_type type,
		rate_policy_serialize_cb serialize,
		rate_policy_equal_cb equal,
		rate_policy_destroy_cb destroy,
		rate_policy_copy_cb copy)
{
	rate_policy->type = type;
	rate_policy->serialize = serialize;
	rate_policy->equal = equal;
	rate_policy->destroy = destroy;
	rate_policy->copy = copy;
}

void lttng_rate_policy_destroy(struct lttng_rate_policy *rate_policy)
{
	if (!rate_policy) {
		return;
	}

	rate_policy->destroy(rate_policy);
}

LTTNG_HIDDEN
int lttng_rate_policy_serialize(struct lttng_rate_policy *rate_policy,
		struct lttng_payload *payload)
{
	int ret;
	struct lttng_rate_policy_comm rate_policy_comm = {
			.rate_policy_type = (int8_t) rate_policy->type,
	};

	ret = lttng_dynamic_buffer_append(&payload->buffer, &rate_policy_comm,
			sizeof(rate_policy_comm));
	if (ret) {
		goto end;
	}

	ret = rate_policy->serialize(rate_policy, payload);
	if (ret) {
		goto end;
	}
end:
	return ret;
}

static ssize_t lttng_rate_policy_once_after_n_create_from_payload(
		struct lttng_payload_view *view,
		struct lttng_rate_policy **rate_policy)
{
	ssize_t consumed_len = -1;
	struct lttng_rate_policy *policy = NULL;
	const struct lttng_rate_policy_once_after_n_comm *comm;
	const struct lttng_payload_view comm_view =
			lttng_payload_view_from_view(view, 0, sizeof(*comm));

	if (!view || !rate_policy) {
		consumed_len = -1;
		goto end;
	}

	if (!lttng_payload_view_is_valid(&comm_view)) {
		/* Payload not large enough to contain the header. */
		consumed_len = -1;
		goto end;
	}

	comm = (const struct lttng_rate_policy_once_after_n_comm *)
			       comm_view.buffer.data;

	policy = lttng_rate_policy_once_after_n_create(comm->threshold);
	if (policy == NULL) {
		consumed_len = -1;
		goto end;
	}

	*rate_policy = policy;
	consumed_len = sizeof(*comm);

end:
	return consumed_len;
}

static ssize_t lttng_rate_policy_every_n_create_from_payload(
		struct lttng_payload_view *view,
		struct lttng_rate_policy **rate_policy)
{
	ssize_t consumed_len = -1;
	struct lttng_rate_policy *policy = NULL;
	const struct lttng_rate_policy_every_n_comm *comm;
	const struct lttng_payload_view comm_view =
			lttng_payload_view_from_view(view, 0, sizeof(*comm));

	if (!view || !rate_policy) {
		consumed_len = -1;
		goto end;
	}

	if (!lttng_payload_view_is_valid(&comm_view)) {
		/* Payload not large enough to contain the header. */
		consumed_len = -1;
		goto end;
	}

	comm = (const struct lttng_rate_policy_every_n_comm *)
			       comm_view.buffer.data;

	policy = lttng_rate_policy_every_n_create(comm->interval);
	if (policy == NULL) {
		consumed_len = -1;
		goto end;
	}

	*rate_policy = policy;
	consumed_len = sizeof(*comm);

end:
	return consumed_len;
}

LTTNG_HIDDEN
ssize_t lttng_rate_policy_create_from_payload(struct lttng_payload_view *view,
		struct lttng_rate_policy **rate_policy)
{
	ssize_t consumed_len, specific_rate_policy_consumed_len;
	rate_policy_create_from_payload_cb create_from_payload_cb;
	const struct lttng_rate_policy_comm *rate_policy_comm;
	const struct lttng_payload_view rate_policy_comm_view =
			lttng_payload_view_from_view(
					view, 0, sizeof(*rate_policy_comm));

	if (!view || !rate_policy) {
		consumed_len = -1;
		goto end;
	}

	if (!lttng_payload_view_is_valid(&rate_policy_comm_view)) {
		/* Payload not large enough to contain the header. */
		consumed_len = -1;
		goto end;
	}

	rate_policy_comm = (const struct lttng_rate_policy_comm *)
					   rate_policy_comm_view.buffer.data;

	DBG("Create rate_policy from payload: rate-policy-type=%s",
			lttng_rate_policy_type_string(
					rate_policy_comm->rate_policy_type));

	switch (rate_policy_comm->rate_policy_type) {
	case LTTNG_RATE_POLICY_TYPE_EVERY_N:
		create_from_payload_cb =
				lttng_rate_policy_every_n_create_from_payload;
		break;
	case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N:
		create_from_payload_cb =
				lttng_rate_policy_once_after_n_create_from_payload;
		break;
	default:
		ERR("Failed to create rate-policy from payload, unhandled rate-policy type: rate-policy-type=%u (%s)",
				rate_policy_comm->rate_policy_type,
				lttng_rate_policy_type_string(
						rate_policy_comm->rate_policy_type));
		consumed_len = -1;
		goto end;
	}

	{
		/* Create buffer view for the rate_policy-type-specific data.
		 */
		struct lttng_payload_view specific_rate_policy_view =
				lttng_payload_view_from_view(view,
						sizeof(struct lttng_rate_policy_comm),
						-1);

		specific_rate_policy_consumed_len = create_from_payload_cb(
				&specific_rate_policy_view, rate_policy);
	}
	if (specific_rate_policy_consumed_len < 0) {
		ERR("Failed to create specific rate_policy from buffer.");
		consumed_len = -1;
		goto end;
	}

	assert(*rate_policy);

	consumed_len = sizeof(struct lttng_rate_policy_comm) +
			specific_rate_policy_consumed_len;

end:
	return consumed_len;
}

LTTNG_HIDDEN
bool lttng_rate_policy_is_equal(const struct lttng_rate_policy *a,
		const struct lttng_rate_policy *b)
{
	bool is_equal = false;

	if (!a || !b) {
		goto end;
	}

	if (a->type != b->type) {
		goto end;
	}

	if (a == b) {
		is_equal = true;
		goto end;
	}

	assert(a->equal);
	is_equal = a->equal(a, b);
end:
	return is_equal;
}

LTTNG_HIDDEN
bool lttng_rate_policy_should_execute(
		const struct lttng_rate_policy *policy, uint64_t counter)
{
	switch (policy->type) {
	case LTTNG_RATE_POLICY_TYPE_EVERY_N:
		return lttng_rate_policy_every_n_should_execute(
				policy, counter);
	case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N:
		return lttng_rate_policy_once_after_n_should_execute(
				policy, counter);
	default:
		abort();
		break;
	}
}

/* Every N */
static struct lttng_rate_policy_every_n *rate_policy_every_n_from_rate_policy(
		struct lttng_rate_policy *policy)
{
	assert(policy);

	return container_of(policy, struct lttng_rate_policy_every_n, parent);
}

static const struct lttng_rate_policy_every_n *
rate_policy_every_n_from_rate_policy_const(
		const struct lttng_rate_policy *policy)
{
	assert(policy);

	return container_of(policy, struct lttng_rate_policy_every_n, parent);
}

static int lttng_rate_policy_every_n_serialize(
		struct lttng_rate_policy *policy, struct lttng_payload *payload)
{
	int ret;

	struct lttng_rate_policy_every_n *every_n_policy;
	struct lttng_rate_policy_every_n_comm comm = {};

	assert(policy);
	assert(payload);

	every_n_policy = rate_policy_every_n_from_rate_policy(policy);
	comm.interval = every_n_policy->interval;

	ret = lttng_dynamic_buffer_append(
			&payload->buffer, &comm, sizeof(comm));
	return ret;
}

static bool lttng_rate_policy_every_n_is_equal(
		const struct lttng_rate_policy *_a,
		const struct lttng_rate_policy *_b)
{
	bool is_equal = false;
	const struct lttng_rate_policy_every_n *a, *b;

	a = rate_policy_every_n_from_rate_policy_const(_a);
	b = rate_policy_every_n_from_rate_policy_const(_b);

	if (a->interval != b->interval) {
		goto end;
	}

	is_equal = true;

end:
	return is_equal;
}

static void lttng_rate_policy_every_n_destroy(struct lttng_rate_policy *policy)
{
	struct lttng_rate_policy_every_n *every_n_policy;

	if (!policy) {
		goto end;
	}

	every_n_policy = rate_policy_every_n_from_rate_policy(policy);

	free(every_n_policy);

end:
	return;
}

static struct lttng_rate_policy *lttng_rate_policy_every_n_copy(
		const struct lttng_rate_policy *source)
{
	struct lttng_rate_policy *copy = NULL;
	const struct lttng_rate_policy_every_n *every_n_policy;

	if (!source) {
		goto end;
	}

	every_n_policy = rate_policy_every_n_from_rate_policy_const(source);
	copy = lttng_rate_policy_every_n_create(every_n_policy->interval);

end:
	return copy;
}

struct lttng_rate_policy *lttng_rate_policy_every_n_create(uint64_t interval)
{
	struct lttng_rate_policy_every_n *policy = NULL;
	struct lttng_rate_policy *_policy = NULL;

	if (interval == 0) {
		/*
		 * An interval of 0 is invalid since it would never be fired.
		 */
		goto end;
	}

	policy = zmalloc(sizeof(struct lttng_rate_policy_every_n));
	if (!policy) {
		goto end;
	}

	lttng_rate_policy_init(&policy->parent, LTTNG_RATE_POLICY_TYPE_EVERY_N,
			lttng_rate_policy_every_n_serialize,
			lttng_rate_policy_every_n_is_equal,
			lttng_rate_policy_every_n_destroy,
			lttng_rate_policy_every_n_copy);

	policy->interval = interval;

	_policy = &policy->parent;
	policy = NULL;

end:
	free(policy);
	return _policy;
}

LTTNG_HIDDEN
enum lttng_rate_policy_status lttng_rate_policy_every_n_get_interval(
		const struct lttng_rate_policy *policy, uint64_t *interval)
{
	const struct lttng_rate_policy_every_n *every_n_policy;
	enum lttng_rate_policy_status status;

	if (!policy || !IS_EVERY_N_RATE_POLICY(policy) || !interval) {
		status = LTTNG_RATE_POLICY_STATUS_INVALID;
		goto end;
	}

	every_n_policy = rate_policy_every_n_from_rate_policy_const(policy);
	*interval = every_n_policy->interval;
	status = LTTNG_RATE_POLICY_STATUS_OK;
end:

	return status;
}

static bool lttng_rate_policy_every_n_should_execute(
		const struct lttng_rate_policy *policy, uint64_t counter)
{
	const struct lttng_rate_policy_every_n *every_n_policy;
	assert(policy);
	bool execute = false;

	every_n_policy = rate_policy_every_n_from_rate_policy_const(policy);

	if (every_n_policy->interval == 0) {
		abort();
	}

	execute = (counter % every_n_policy->interval) == 0;

	DBG("Policy every N = %" PRIu64
	    ": execution %s. Execution count: %" PRIu64,
			every_n_policy->interval,
			execute ? "accepted" : "denied", counter);

	return execute;
}

/* Once after N */

static struct lttng_rate_policy_once_after_n *
rate_policy_once_after_n_from_rate_policy(struct lttng_rate_policy *policy)
{
	assert(policy);

	return container_of(
			policy, struct lttng_rate_policy_once_after_n, parent);
}

static const struct lttng_rate_policy_once_after_n *
rate_policy_once_after_n_from_rate_policy_const(
		const struct lttng_rate_policy *policy)
{
	assert(policy);

	return container_of(
			policy, struct lttng_rate_policy_once_after_n, parent);
}
static int lttng_rate_policy_once_after_n_serialize(
		struct lttng_rate_policy *policy, struct lttng_payload *payload)
{
	int ret;

	struct lttng_rate_policy_once_after_n *once_after_n_policy;
	struct lttng_rate_policy_once_after_n_comm comm = {};

	assert(policy);
	assert(payload);

	once_after_n_policy = rate_policy_once_after_n_from_rate_policy(policy);
	comm.threshold = once_after_n_policy->threshold;

	ret = lttng_dynamic_buffer_append(
			&payload->buffer, &comm, sizeof(comm));
	return ret;
}

static bool lttng_rate_policy_once_after_n_is_equal(
		const struct lttng_rate_policy *_a,
		const struct lttng_rate_policy *_b)
{
	bool is_equal = false;
	const struct lttng_rate_policy_once_after_n *a, *b;

	a = rate_policy_once_after_n_from_rate_policy_const(_a);
	b = rate_policy_once_after_n_from_rate_policy_const(_b);

	if (a->threshold != b->threshold) {
		goto end;
	}

	is_equal = true;

end:
	return is_equal;
}

static void lttng_rate_policy_once_after_n_destroy(
		struct lttng_rate_policy *policy)
{
	struct lttng_rate_policy_once_after_n *once_after_n_policy;

	if (!policy) {
		goto end;
	}

	once_after_n_policy = rate_policy_once_after_n_from_rate_policy(policy);

	free(once_after_n_policy);

end:
	return;
}

static struct lttng_rate_policy *lttng_rate_policy_once_after_n_copy(
		const struct lttng_rate_policy *source)
{
	struct lttng_rate_policy *copy = NULL;
	const struct lttng_rate_policy_once_after_n *once_after_n_policy;

	if (!source) {
		goto end;
	}

	once_after_n_policy =
			rate_policy_once_after_n_from_rate_policy_const(source);
	copy = lttng_rate_policy_once_after_n_create(
			once_after_n_policy->threshold);

end:
	return copy;
}

struct lttng_rate_policy *lttng_rate_policy_once_after_n_create(
		uint64_t threshold)
{
	struct lttng_rate_policy_once_after_n *policy = NULL;
	struct lttng_rate_policy *_policy = NULL;

	if (threshold == 0) {
		/* threshold is expected to be > 0 */
		goto end;
	}

	policy = zmalloc(sizeof(struct lttng_rate_policy_once_after_n));
	if (!policy) {
		goto end;
	}

	lttng_rate_policy_init(&policy->parent,
			LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N,
			lttng_rate_policy_once_after_n_serialize,
			lttng_rate_policy_once_after_n_is_equal,
			lttng_rate_policy_once_after_n_destroy,
			lttng_rate_policy_once_after_n_copy);

	policy->threshold = threshold;

	_policy = &policy->parent;
	policy = NULL;

end:
	free(policy);
	return _policy;
}

LTTNG_HIDDEN
enum lttng_rate_policy_status lttng_rate_policy_once_after_n_get_threshold(
		const struct lttng_rate_policy *policy, uint64_t *threshold)
{
	const struct lttng_rate_policy_once_after_n *once_after_n_policy;
	enum lttng_rate_policy_status status;

	if (!policy || !IS_ONCE_AFTER_N_RATE_POLICY(policy) || !threshold) {
		status = LTTNG_RATE_POLICY_STATUS_INVALID;
		goto end;
	}

	once_after_n_policy =
			rate_policy_once_after_n_from_rate_policy_const(policy);
	*threshold = once_after_n_policy->threshold;
	status = LTTNG_RATE_POLICY_STATUS_OK;
end:

	return status;
}

LTTNG_HIDDEN
struct lttng_rate_policy *lttng_rate_policy_copy(
		const struct lttng_rate_policy *source)
{
	assert(source->copy);
	return source->copy(source);
}

static bool lttng_rate_policy_once_after_n_should_execute(
		const struct lttng_rate_policy *policy, uint64_t counter)
{
	const struct lttng_rate_policy_once_after_n *once_after_n_policy;
	bool execute = false;
	assert(policy);

	once_after_n_policy =
			rate_policy_once_after_n_from_rate_policy_const(policy);

	execute = counter == once_after_n_policy->threshold;

	DBG("Policy once after N = %" PRIu64
	    ": execution %s. Execution count: %" PRIu64,
			once_after_n_policy->threshold,
			execute ? "accepted" : "denied", counter);

	return counter == once_after_n_policy->threshold;
}
Commit	Line	Data
7f4d5b07 JR	1	/*
	2	* Copyright (C) 2021 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
	3	*
	4	* SPDX-License-Identifier: LGPL-2.1-only
	5	*
	6	*/
	7
	8	#include <assert.h>
	9	#include <common/buffer-view.h>
	10	#include <common/dynamic-buffer.h>
	11	#include <common/error.h>
	12	#include <common/macros.h>
	13	#include <common/payload-view.h>
	14	#include <common/payload.h>
	15	#include <limits.h>
	16	#include <lttng/action/rate-policy-internal.h>
	17	#include <lttng/action/rate-policy.h>
	18	#include <stdbool.h>
	19	#include <sys/types.h>
	20
	21	#define IS_EVERY_N_RATE_POLICY(policy) \
	22	(lttng_rate_policy_get_type(policy) == LTTNG_RATE_POLICY_TYPE_EVERY_N)
	23
	24	#define IS_ONCE_AFTER_N_RATE_POLICY(policy) \
	25	(lttng_rate_policy_get_type(policy) == \
	26	LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N)
	27
	28	typedef void (rate_policy_destroy_cb)(struct lttng_rate_policy rate_policy);
	29	typedef int (rate_policy_serialize_cb)(struct lttng_rate_policy rate_policy,
	30	struct lttng_payload *payload);
	31	typedef bool (rate_policy_equal_cb)(const struct lttng_rate_policy a,
	32	const struct lttng_rate_policy *b);
	33	typedef ssize_t (*rate_policy_create_from_payload_cb)(
	34	struct lttng_payload_view *view,
	35	struct lttng_rate_policy **rate_policy);
	36	typedef struct lttng_rate_policy (rate_policy_copy_cb)(
	37	const struct lttng_rate_policy *source);
	38
	39	struct lttng_rate_policy {
	40	enum lttng_rate_policy_type type;
	41	rate_policy_serialize_cb serialize;
	42	rate_policy_equal_cb equal;
	43	rate_policy_destroy_cb destroy;
	44	rate_policy_copy_cb copy;
	45	};
	46
	47	struct lttng_rate_policy_every_n {
	48	struct lttng_rate_policy parent;
	49	uint64_t interval;
	50	};
	51
	52	struct lttng_rate_policy_once_after_n {
	53	struct lttng_rate_policy parent;
	54	uint64_t threshold;
	55	};
	56
	57	struct lttng_rate_policy_comm {
	58	/* enum lttng_rate_policy_type */
	59	int8_t rate_policy_type;
	60	} LTTNG_PACKED;
	61
	62	struct lttng_rate_policy_once_after_n_comm {
	63	uint64_t threshold;
	64	} LTTNG_PACKED;
65
66	struct lttng_rate_policy_every_n_comm {
67	uint64_t interval;
68	} LTTNG_PACKED;
69
70	/* Forward declaration. */
71	static void lttng_rate_policy_init(struct lttng_rate_policy *rate_policy,
72	enum lttng_rate_policy_type type,
73	rate_policy_serialize_cb serialize,
74	rate_policy_equal_cb equal,
75	rate_policy_destroy_cb destroy,
76	rate_policy_copy_cb copy);
77
78	/* Forward declaration. Every n */
79	static bool lttng_rate_policy_every_n_should_execute(
80	const struct lttng_rate_policy *policy, uint64_t counter);
81
82	/* Forward declaration. Once after N */
83	static bool lttng_rate_policy_once_after_n_should_execute(
84	const struct lttng_rate_policy *policy, uint64_t counter);
85
86	LTTNG_HIDDEN
87	const char *lttng_rate_policy_type_string(
88	enum lttng_rate_policy_type rate_policy_type)
89	{
90	switch (rate_policy_type) {
91	case LTTNG_RATE_POLICY_TYPE_EVERY_N:
92	return "EVERY-N";
93	case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N:
94	return "ONCE-AFTER-N";
95	default:
96	return "???";
97	}
98	}
99
100	enum lttng_rate_policy_type lttng_rate_policy_get_type(
101	const struct lttng_rate_policy *policy)
102	{
103	return policy ? policy->type : LTTNG_RATE_POLICY_TYPE_UNKNOWN;
104	}
105
106	LTTNG_HIDDEN
107	void lttng_rate_policy_init(struct lttng_rate_policy *rate_policy,
108	enum lttng_rate_policy_type type,
109	rate_policy_serialize_cb serialize,
110	rate_policy_equal_cb equal,
111	rate_policy_destroy_cb destroy,
112	rate_policy_copy_cb copy)
113	{
114	rate_policy->type = type;
115	rate_policy->serialize = serialize;
116	rate_policy->equal = equal;
117	rate_policy->destroy = destroy;
118	rate_policy->copy = copy;
119	}
120
121	void lttng_rate_policy_destroy(struct lttng_rate_policy *rate_policy)
122	{
123	if (!rate_policy) {
124	return;
125	}
126
127	rate_policy->destroy(rate_policy);
128	}
129
130	LTTNG_HIDDEN
131	int lttng_rate_policy_serialize(struct lttng_rate_policy *rate_policy,
132	struct lttng_payload *payload)
133	{
134	int ret;
135	struct lttng_rate_policy_comm rate_policy_comm = {
136	.rate_policy_type = (int8_t) rate_policy->type,
137	};
138
139	ret = lttng_dynamic_buffer_append(&payload->buffer, &rate_policy_comm,
140	sizeof(rate_policy_comm));
141	if (ret) {
142	goto end;
143	}
144
145	ret = rate_policy->serialize(rate_policy, payload);
146	if (ret) {
147	goto end;
148	}
149	end:
150	return ret;
151	}
152
153	static ssize_t lttng_rate_policy_once_after_n_create_from_payload(
154	struct lttng_payload_view *view,
155	struct lttng_rate_policy **rate_policy)
156	{
157	ssize_t consumed_len = -1;
158	struct lttng_rate_policy *policy = NULL;
159	const struct lttng_rate_policy_once_after_n_comm *comm;
160	const struct lttng_payload_view comm_view =
161	lttng_payload_view_from_view(view, 0, sizeof(*comm));
162
163	if (!view \|\| !rate_policy) {
164	consumed_len = -1;
165	goto end;
166	}
167
168	if (!lttng_payload_view_is_valid(&comm_view)) {
169	/* Payload not large enough to contain the header. */
170	consumed_len = -1;
171	goto end;
172	}
173
174	comm = (const struct lttng_rate_policy_once_after_n_comm *)
175	comm_view.buffer.data;
176
177	policy = lttng_rate_policy_once_after_n_create(comm->threshold);
178	if (policy == NULL) {
179	consumed_len = -1;
180	goto end;
181	}
182
183	*rate_policy = policy;
184	consumed_len = sizeof(*comm);
185
186	end:
187	return consumed_len;
188	}
189
190	static ssize_t lttng_rate_policy_every_n_create_from_payload(
191	struct lttng_payload_view *view,
192	struct lttng_rate_policy **rate_policy)
193	{
194	ssize_t consumed_len = -1;
195	struct lttng_rate_policy *policy = NULL;
196	const struct lttng_rate_policy_every_n_comm *comm;
197	const struct lttng_payload_view comm_view =
198	lttng_payload_view_from_view(view, 0, sizeof(*comm));
199
200	if (!view \|\| !rate_policy) {
201	consumed_len = -1;
202	goto end;
203	}
204
205	if (!lttng_payload_view_is_valid(&comm_view)) {
206	/* Payload not large enough to contain the header. */
207	consumed_len = -1;
208	goto end;
209	}
210
211	comm = (const struct lttng_rate_policy_every_n_comm *)
212	comm_view.buffer.data;
213
214	policy = lttng_rate_policy_every_n_create(comm->interval);
215	if (policy == NULL) {
216	consumed_len = -1;
217	goto end;
218	}
219
220	*rate_policy = policy;
221	consumed_len = sizeof(*comm);
222
223	end:
224	return consumed_len;
225	}
226
227	LTTNG_HIDDEN
228	ssize_t lttng_rate_policy_create_from_payload(struct lttng_payload_view *view,
229	struct lttng_rate_policy **rate_policy)
230	{
231	ssize_t consumed_len, specific_rate_policy_consumed_len;
232	rate_policy_create_from_payload_cb create_from_payload_cb;
233	const struct lttng_rate_policy_comm *rate_policy_comm;
234	const struct lttng_payload_view rate_policy_comm_view =
235	lttng_payload_view_from_view(
236	view, 0, sizeof(*rate_policy_comm));
237
238	if (!view \|\| !rate_policy) {
239	consumed_len = -1;
240	goto end;
241	}
242
243	if (!lttng_payload_view_is_valid(&rate_policy_comm_view)) {
244	/* Payload not large enough to contain the header. */
245	consumed_len = -1;
246	goto end;
247	}
248
249	rate_policy_comm = (const struct lttng_rate_policy_comm *)
250	rate_policy_comm_view.buffer.data;
251
252	DBG("Create rate_policy from payload: rate-policy-type=%s",
253	lttng_rate_policy_type_string(
254	rate_policy_comm->rate_policy_type));
255
256	switch (rate_policy_comm->rate_policy_type) {
257	case LTTNG_RATE_POLICY_TYPE_EVERY_N:
258	create_from_payload_cb =
259	lttng_rate_policy_every_n_create_from_payload;
260	break;
261	case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N:
262	create_from_payload_cb =
263	lttng_rate_policy_once_after_n_create_from_payload;
264	break;
265	default:
266	ERR("Failed to create rate-policy from payload, unhandled rate-policy type: rate-policy-type=%u (%s)",
267	rate_policy_comm->rate_policy_type,
268	lttng_rate_policy_type_string(
269	rate_policy_comm->rate_policy_type));
270	consumed_len = -1;
271	goto end;
272	}
273
274	{
275	/* Create buffer view for the rate_policy-type-specific data.
276	*/
277	struct lttng_payload_view specific_rate_policy_view =
278	lttng_payload_view_from_view(view,
279	sizeof(struct lttng_rate_policy_comm),
280	-1);
281
282	specific_rate_policy_consumed_len = create_from_payload_cb(
283	&specific_rate_policy_view, rate_policy);
284	}
285	if (specific_rate_policy_consumed_len < 0) {
286	ERR("Failed to create specific rate_policy from buffer.");
287	consumed_len = -1;
288	goto end;
289	}
290
291	assert(*rate_policy);
292
293	consumed_len = sizeof(struct lttng_rate_policy_comm) +
294	specific_rate_policy_consumed_len;
295
296	end:
297	return consumed_len;
298	}
299
300	LTTNG_HIDDEN
301	bool lttng_rate_policy_is_equal(const struct lttng_rate_policy *a,
302	const struct lttng_rate_policy *b)
303	{
304	bool is_equal = false;
305
306	if (!a \|\| !b) {
307	goto end;
308	}
309
310	if (a->type != b->type) {
311	goto end;
312	}
313
314	if (a == b) {
315	is_equal = true;
316	goto end;
317	}
318
319	assert(a->equal);
320	is_equal = a->equal(a, b);
321	end:
322	return is_equal;
323	}
324
325	LTTNG_HIDDEN
326	bool lttng_rate_policy_should_execute(
327	const struct lttng_rate_policy *policy, uint64_t counter)
328	{
329	switch (policy->type) {
330	case LTTNG_RATE_POLICY_TYPE_EVERY_N:
331	return lttng_rate_policy_every_n_should_execute(
332	policy, counter);
333	case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N:
334	return lttng_rate_policy_once_after_n_should_execute(
335	policy, counter);
336	default:
337	abort();
338	break;
339	}
340	}
341
342	/* Every N */
343	static struct lttng_rate_policy_every_n *rate_policy_every_n_from_rate_policy(
344	struct lttng_rate_policy *policy)
345	{
346	assert(policy);
347
348	return container_of(policy, struct lttng_rate_policy_every_n, parent);
349	}
350
351	static const struct lttng_rate_policy_every_n *
352	rate_policy_every_n_from_rate_policy_const(
353	const struct lttng_rate_policy *policy)
354	{
355	assert(policy);
356
357	return container_of(policy, struct lttng_rate_policy_every_n, parent);
358	}
359
360	static int lttng_rate_policy_every_n_serialize(
361	struct lttng_rate_policy policy, struct lttng_payload payload)
362	{
363	int ret;
364
365	struct lttng_rate_policy_every_n *every_n_policy;
366	struct lttng_rate_policy_every_n_comm comm = {};
367
368	assert(policy);
369	assert(payload);
370
371	every_n_policy = rate_policy_every_n_from_rate_policy(policy);
372	comm.interval = every_n_policy->interval;
373
374	ret = lttng_dynamic_buffer_append(
375	&payload->buffer, &comm, sizeof(comm));
376	return ret;
377	}
378
379	static bool lttng_rate_policy_every_n_is_equal(
380	const struct lttng_rate_policy *_a,
381	const struct lttng_rate_policy *_b)
382	{
383	bool is_equal = false;
384	const struct lttng_rate_policy_every_n a, b;
385
386	a = rate_policy_every_n_from_rate_policy_const(_a);
387	b = rate_policy_every_n_from_rate_policy_const(_b);
388
389	if (a->interval != b->interval) {
390	goto end;
391	}
392
393	is_equal = true;
394
395	end:
396	return is_equal;
397	}
398
399	static void lttng_rate_policy_every_n_destroy(struct lttng_rate_policy *policy)
400	{
401	struct lttng_rate_policy_every_n *every_n_policy;
402
403	if (!policy) {
404	goto end;
405	}
406
407	every_n_policy = rate_policy_every_n_from_rate_policy(policy);
408
409	free(every_n_policy);
410
411	end:
412	return;
413	}
414
415	static struct lttng_rate_policy *lttng_rate_policy_every_n_copy(
416	const struct lttng_rate_policy *source)
417	{
418	struct lttng_rate_policy *copy = NULL;
419	const struct lttng_rate_policy_every_n *every_n_policy;
420
421	if (!source) {
422	goto end;
423	}
424
425	every_n_policy = rate_policy_every_n_from_rate_policy_const(source);
426	copy = lttng_rate_policy_every_n_create(every_n_policy->interval);
427
428	end:
429	return copy;
430	}
431
432	struct lttng_rate_policy *lttng_rate_policy_every_n_create(uint64_t interval)
433	{
434	struct lttng_rate_policy_every_n *policy = NULL;
435	struct lttng_rate_policy *_policy = NULL;
436
437	if (interval == 0) {
438	/*
439	* An interval of 0 is invalid since it would never be fired.
440	*/
441	goto end;
442	}
443
444	policy = zmalloc(sizeof(struct lttng_rate_policy_every_n));
445	if (!policy) {
446	goto end;
447	}
448
449	lttng_rate_policy_init(&policy->parent, LTTNG_RATE_POLICY_TYPE_EVERY_N,
450	lttng_rate_policy_every_n_serialize,
451	lttng_rate_policy_every_n_is_equal,
452	lttng_rate_policy_every_n_destroy,
453	lttng_rate_policy_every_n_copy);
454
455	policy->interval = interval;
456
457	_policy = &policy->parent;
458	policy = NULL;
459
460	end:
461	free(policy);
462	return _policy;
463	}
464
465	LTTNG_HIDDEN
466	enum lttng_rate_policy_status lttng_rate_policy_every_n_get_interval(
467	const struct lttng_rate_policy policy, uint64_t interval)
468	{
469	const struct lttng_rate_policy_every_n *every_n_policy;
470	enum lttng_rate_policy_status status;
471
472	if (!policy \|\| !IS_EVERY_N_RATE_POLICY(policy) \|\| !interval) {
473	status = LTTNG_RATE_POLICY_STATUS_INVALID;
474	goto end;
475	}
476
477	every_n_policy = rate_policy_every_n_from_rate_policy_const(policy);
478	*interval = every_n_policy->interval;
479	status = LTTNG_RATE_POLICY_STATUS_OK;
480	end:
481
482	return status;
483	}
484
485	static bool lttng_rate_policy_every_n_should_execute(
486	const struct lttng_rate_policy *policy, uint64_t counter)
487	{
488	const struct lttng_rate_policy_every_n *every_n_policy;
489	assert(policy);
490	bool execute = false;
491
492	every_n_policy = rate_policy_every_n_from_rate_policy_const(policy);
493
494	if (every_n_policy->interval == 0) {
495	abort();
496	}
497
498	execute = (counter % every_n_policy->interval) == 0;
499
500	DBG("Policy every N = %" PRIu64
501	": execution %s. Execution count: %" PRIu64,
502	every_n_policy->interval,
503	execute ? "accepted" : "denied", counter);
504
505	return execute;
506	}
507
508	/* Once after N */
509
510	static struct lttng_rate_policy_once_after_n *
511	rate_policy_once_after_n_from_rate_policy(struct lttng_rate_policy *policy)
512	{
513	assert(policy);
514
515	return container_of(
516	policy, struct lttng_rate_policy_once_after_n, parent);
517	}
518
519	static const struct lttng_rate_policy_once_after_n *
520	rate_policy_once_after_n_from_rate_policy_const(
521	const struct lttng_rate_policy *policy)
522	{
523	assert(policy);
524
525	return container_of(
526	policy, struct lttng_rate_policy_once_after_n, parent);
527	}
528	static int lttng_rate_policy_once_after_n_serialize(
529	struct lttng_rate_policy policy, struct lttng_payload payload)
530	{
531	int ret;
532
533	struct lttng_rate_policy_once_after_n *once_after_n_policy;
534	struct lttng_rate_policy_once_after_n_comm comm = {};
535
536	assert(policy);
537	assert(payload);
538
539	once_after_n_policy = rate_policy_once_after_n_from_rate_policy(policy);
540	comm.threshold = once_after_n_policy->threshold;
541
542	ret = lttng_dynamic_buffer_append(
543	&payload->buffer, &comm, sizeof(comm));
544	return ret;
545	}
546
547	static bool lttng_rate_policy_once_after_n_is_equal(
548	const struct lttng_rate_policy *_a,
549	const struct lttng_rate_policy *_b)
550	{
551	bool is_equal = false;
552	const struct lttng_rate_policy_once_after_n a, b;
553
554	a = rate_policy_once_after_n_from_rate_policy_const(_a);
555	b = rate_policy_once_after_n_from_rate_policy_const(_b);
556
557	if (a->threshold != b->threshold) {
558	goto end;
559	}
560
561	is_equal = true;
562
563	end:
564	return is_equal;
565	}
566
567	static void lttng_rate_policy_once_after_n_destroy(
568	struct lttng_rate_policy *policy)
569	{
570	struct lttng_rate_policy_once_after_n *once_after_n_policy;
571
572	if (!policy) {
573	goto end;
574	}
575
576	once_after_n_policy = rate_policy_once_after_n_from_rate_policy(policy);
577
578	free(once_after_n_policy);
579
580	end:
581	return;
582	}
583
584	static struct lttng_rate_policy *lttng_rate_policy_once_after_n_copy(
585	const struct lttng_rate_policy *source)
586	{
587	struct lttng_rate_policy *copy = NULL;
588	const struct lttng_rate_policy_once_after_n *once_after_n_policy;
589
590	if (!source) {
591	goto end;
592	}
593
594	once_after_n_policy =
595	rate_policy_once_after_n_from_rate_policy_const(source);
596	copy = lttng_rate_policy_once_after_n_create(
597	once_after_n_policy->threshold);
598
599	end:
600	return copy;
601	}
602
603	struct lttng_rate_policy *lttng_rate_policy_once_after_n_create(
604	uint64_t threshold)
605	{
606	struct lttng_rate_policy_once_after_n *policy = NULL;
607	struct lttng_rate_policy *_policy = NULL;
608
609	if (threshold == 0) {
610	/* threshold is expected to be > 0 */
611	goto end;
612	}
613
614	policy = zmalloc(sizeof(struct lttng_rate_policy_once_after_n));
615	if (!policy) {
616	goto end;
617	}
618
619	lttng_rate_policy_init(&policy->parent,
620	LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N,
621	lttng_rate_policy_once_after_n_serialize,
622	lttng_rate_policy_once_after_n_is_equal,
623	lttng_rate_policy_once_after_n_destroy,
624	lttng_rate_policy_once_after_n_copy);
625
626	policy->threshold = threshold;
627
628	_policy = &policy->parent;
629	policy = NULL;
630
631	end:
632	free(policy);
633	return _policy;
634	}
635
636	LTTNG_HIDDEN
637	enum lttng_rate_policy_status lttng_rate_policy_once_after_n_get_threshold(
638	const struct lttng_rate_policy policy, uint64_t threshold)
639	{
640	const struct lttng_rate_policy_once_after_n *once_after_n_policy;
641	enum lttng_rate_policy_status status;
642
643	if (!policy \|\| !IS_ONCE_AFTER_N_RATE_POLICY(policy) \|\| !threshold) {
644	status = LTTNG_RATE_POLICY_STATUS_INVALID;
645	goto end;
646	}
647
648	once_after_n_policy =
649	rate_policy_once_after_n_from_rate_policy_const(policy);
650	*threshold = once_after_n_policy->threshold;
651	status = LTTNG_RATE_POLICY_STATUS_OK;
652	end:
653
654	return status;
655	}
656
657	LTTNG_HIDDEN
658	struct lttng_rate_policy *lttng_rate_policy_copy(
659	const struct lttng_rate_policy *source)
660	{
661	assert(source->copy);
662	return source->copy(source);
663	}
664
665	static bool lttng_rate_policy_once_after_n_should_execute(
666	const struct lttng_rate_policy *policy, uint64_t counter)
667	{
668	const struct lttng_rate_policy_once_after_n *once_after_n_policy;
669	bool execute = false;
670	assert(policy);
671
672	once_after_n_policy =
673	rate_policy_once_after_n_from_rate_policy_const(policy);
674
675	execute = counter == once_after_n_policy->threshold;
676
677	DBG("Policy once after N = %" PRIu64
678	": execution %s. Execution count: %" PRIu64,
679	once_after_n_policy->threshold,
680	execute ? "accepted" : "denied", counter);
681
682	return counter == once_after_n_policy->threshold;
683	}