*
*/
-#include <assert.h>
#include <common/buffer-view.h>
#include <common/dynamic-buffer.h>
#include <common/error.h>
#include <common/macros.h>
+#include <common/mi-lttng.h>
#include <common/payload-view.h>
#include <common/payload.h>
#include <limits.h>
struct lttng_rate_policy **rate_policy);
typedef struct lttng_rate_policy *(*rate_policy_copy_cb)(
const struct lttng_rate_policy *source);
+typedef enum lttng_error_code (*rate_policy_mi_serialize_cb)(
+ const struct lttng_rate_policy *rate_policy,
+ struct mi_writer *writer);
struct lttng_rate_policy {
enum lttng_rate_policy_type type;
rate_policy_equal_cb equal;
rate_policy_destroy_cb destroy;
rate_policy_copy_cb copy;
+ rate_policy_mi_serialize_cb mi_serialize;
};
struct lttng_rate_policy_every_n {
rate_policy_serialize_cb serialize,
rate_policy_equal_cb equal,
rate_policy_destroy_cb destroy,
- rate_policy_copy_cb copy);
+ rate_policy_copy_cb copy,
+ rate_policy_mi_serialize_cb mi);
/* Forward declaration. Every n */
static bool lttng_rate_policy_every_n_should_execute(
rate_policy_serialize_cb serialize,
rate_policy_equal_cb equal,
rate_policy_destroy_cb destroy,
- rate_policy_copy_cb copy)
+ rate_policy_copy_cb copy,
+ rate_policy_mi_serialize_cb mi)
{
rate_policy->type = type;
rate_policy->serialize = serialize;
rate_policy->equal = equal;
rate_policy->destroy = destroy;
rate_policy->copy = copy;
+ rate_policy->mi_serialize = mi;
}
void lttng_rate_policy_destroy(struct lttng_rate_policy *rate_policy)
goto end;
}
- assert(*rate_policy);
+ LTTNG_ASSERT(*rate_policy);
consumed_len = sizeof(struct lttng_rate_policy_comm) +
specific_rate_policy_consumed_len;
goto end;
}
- assert(a->equal);
+ LTTNG_ASSERT(a->equal);
is_equal = a->equal(a, b);
end:
return is_equal;
static struct lttng_rate_policy_every_n *rate_policy_every_n_from_rate_policy(
struct lttng_rate_policy *policy)
{
- assert(policy);
+ LTTNG_ASSERT(policy);
return container_of(policy, struct lttng_rate_policy_every_n, parent);
}
rate_policy_every_n_from_rate_policy_const(
const struct lttng_rate_policy *policy)
{
- assert(policy);
+ LTTNG_ASSERT(policy);
return container_of(policy, struct lttng_rate_policy_every_n, parent);
}
struct lttng_rate_policy_every_n *every_n_policy;
struct lttng_rate_policy_every_n_comm comm = {};
- assert(policy);
- assert(payload);
+ LTTNG_ASSERT(policy);
+ LTTNG_ASSERT(payload);
every_n_policy = rate_policy_every_n_from_rate_policy(policy);
comm.interval = every_n_policy->interval;
return copy;
}
+static enum lttng_error_code lttng_rate_policy_every_n_mi_serialize(
+ const struct lttng_rate_policy *rate_policy,
+ struct mi_writer *writer)
+{
+ int ret;
+ enum lttng_error_code ret_code;
+ const struct lttng_rate_policy_every_n *every_n_policy = NULL;
+
+ LTTNG_ASSERT(rate_policy);
+ LTTNG_ASSERT(IS_EVERY_N_RATE_POLICY(rate_policy));
+ LTTNG_ASSERT(writer);
+
+ every_n_policy = rate_policy_every_n_from_rate_policy_const(
+ rate_policy);
+
+ /* Open rate_policy_every_n element. */
+ ret = mi_lttng_writer_open_element(
+ writer, mi_lttng_element_rate_policy_every_n);
+ if (ret) {
+ goto mi_error;
+ }
+
+ /* Interval. */
+ ret = mi_lttng_writer_write_element_unsigned_int(writer,
+ mi_lttng_element_rate_policy_every_n_interval,
+ every_n_policy->interval);
+ if (ret) {
+ goto mi_error;
+ }
+
+ /* Close rate_policy_every_n element. */
+ ret = mi_lttng_writer_close_element(writer);
+ if (ret) {
+ goto mi_error;
+ }
+
+ ret_code = LTTNG_OK;
+ goto end;
+
+mi_error:
+ ret_code = LTTNG_ERR_MI_IO_FAIL;
+end:
+ return ret_code;
+}
+
struct lttng_rate_policy *lttng_rate_policy_every_n_create(uint64_t interval)
{
struct lttng_rate_policy_every_n *policy = NULL;
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);
+ lttng_rate_policy_every_n_copy,
+ lttng_rate_policy_every_n_mi_serialize);
policy->interval = interval;
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 *policy, uint64_t counter)
{
const struct lttng_rate_policy_every_n *every_n_policy;
- assert(policy);
+ LTTNG_ASSERT(policy);
bool execute = false;
every_n_policy = rate_policy_every_n_from_rate_policy_const(policy);
static struct lttng_rate_policy_once_after_n *
rate_policy_once_after_n_from_rate_policy(struct lttng_rate_policy *policy)
{
- assert(policy);
+ LTTNG_ASSERT(policy);
return container_of(
policy, struct lttng_rate_policy_once_after_n, parent);
rate_policy_once_after_n_from_rate_policy_const(
const struct lttng_rate_policy *policy)
{
- assert(policy);
+ LTTNG_ASSERT(policy);
return container_of(
policy, struct lttng_rate_policy_once_after_n, parent);
struct lttng_rate_policy_once_after_n *once_after_n_policy;
struct lttng_rate_policy_once_after_n_comm comm = {};
- assert(policy);
- assert(payload);
+ LTTNG_ASSERT(policy);
+ LTTNG_ASSERT(payload);
once_after_n_policy = rate_policy_once_after_n_from_rate_policy(policy);
comm.threshold = once_after_n_policy->threshold;
return copy;
}
+static enum lttng_error_code lttng_rate_policy_once_after_n_mi_serialize(
+ const struct lttng_rate_policy *rate_policy,
+ struct mi_writer *writer)
+{
+ int ret;
+ enum lttng_error_code ret_code;
+ const struct lttng_rate_policy_once_after_n *once_after_n_policy = NULL;
+
+ LTTNG_ASSERT(rate_policy);
+ LTTNG_ASSERT(IS_ONCE_AFTER_N_RATE_POLICY(rate_policy));
+ LTTNG_ASSERT(writer);
+
+ once_after_n_policy = rate_policy_once_after_n_from_rate_policy_const(
+ rate_policy);
+
+ /* Open rate_policy_once_after_n. */
+ ret = mi_lttng_writer_open_element(
+ writer, mi_lttng_element_rate_policy_once_after_n);
+ if (ret) {
+ goto mi_error;
+ }
+
+ /* Threshold. */
+ ret = mi_lttng_writer_write_element_unsigned_int(writer,
+ mi_lttng_element_rate_policy_once_after_n_threshold,
+ once_after_n_policy->threshold);
+ if (ret) {
+ goto mi_error;
+ }
+
+ /* Close rate_policy_once_after_n element. */
+ ret = mi_lttng_writer_close_element(writer);
+ if (ret) {
+ goto mi_error;
+ }
+
+ ret_code = LTTNG_OK;
+ goto end;
+
+mi_error:
+ ret_code = LTTNG_ERR_MI_IO_FAIL;
+end:
+ return ret_code;
+}
+
struct lttng_rate_policy *lttng_rate_policy_once_after_n_create(
uint64_t threshold)
{
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);
+ lttng_rate_policy_once_after_n_copy,
+ lttng_rate_policy_once_after_n_mi_serialize);
policy->threshold = threshold;
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)
{
struct lttng_rate_policy *lttng_rate_policy_copy(
const struct lttng_rate_policy *source)
{
- assert(source->copy);
+ LTTNG_ASSERT(source->copy);
return source->copy(source);
}
{
const struct lttng_rate_policy_once_after_n *once_after_n_policy;
bool execute = false;
- assert(policy);
+ LTTNG_ASSERT(policy);
once_after_n_policy =
rate_policy_once_after_n_from_rate_policy_const(policy);
return counter == once_after_n_policy->threshold;
}
+
+LTTNG_HIDDEN
+enum lttng_error_code lttng_rate_policy_mi_serialize(
+ const struct lttng_rate_policy *rate_policy,
+ struct mi_writer *writer)
+{
+ int ret;
+ enum lttng_error_code ret_code;
+
+ LTTNG_ASSERT(rate_policy);
+ LTTNG_ASSERT(writer);
+ LTTNG_ASSERT(rate_policy->mi_serialize);
+
+ /* Open rate policy element. */
+ ret = mi_lttng_writer_open_element(
+ writer, mi_lttng_element_rate_policy);
+ if (ret) {
+ goto mi_error;
+ }
+
+ /* Serialize underlying rate policy. */
+ ret_code = rate_policy->mi_serialize(rate_policy, writer);
+ if (ret_code != LTTNG_OK) {
+ goto end;
+ }
+
+ /* Close rate policy element. */
+ ret = mi_lttng_writer_close_element(writer);
+ if (ret) {
+ goto mi_error;
+ }
+
+ ret_code = LTTNG_OK;
+ goto end;
+
+mi_error:
+ ret_code = LTTNG_ERR_MI_IO_FAIL;
+end:
+ return ret_code;
+}
projects / lttng-tools.git / blobdiff