Fix: futex wait: handle spurious futex wakeups
[lttng-tools.git] / src / common / actions / rate-policy.cpp
CommitLineData
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
c9e313bc
SM
8#include <common/buffer-view.hpp>
9#include <common/dynamic-buffer.hpp>
10#include <common/error.hpp>
11#include <common/macros.hpp>
12#include <common/mi-lttng.hpp>
13#include <common/payload-view.hpp>
14#include <common/payload.hpp>
7f4d5b07 15#include <limits.h>
c9e313bc 16#include <lttng/action/rate-policy-internal.hpp>
7f4d5b07
JR
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
28typedef void (*rate_policy_destroy_cb)(struct lttng_rate_policy *rate_policy);
29typedef int (*rate_policy_serialize_cb)(struct lttng_rate_policy *rate_policy,
30 struct lttng_payload *payload);
31typedef bool (*rate_policy_equal_cb)(const struct lttng_rate_policy *a,
32 const struct lttng_rate_policy *b);
33typedef ssize_t (*rate_policy_create_from_payload_cb)(
34 struct lttng_payload_view *view,
35 struct lttng_rate_policy **rate_policy);
36typedef struct lttng_rate_policy *(*rate_policy_copy_cb)(
37 const struct lttng_rate_policy *source);
6a751b95
JR
38typedef enum lttng_error_code (*rate_policy_mi_serialize_cb)(
39 const struct lttng_rate_policy *rate_policy,
40 struct mi_writer *writer);
7f4d5b07
JR
41
42struct lttng_rate_policy {
43 enum lttng_rate_policy_type type;
44 rate_policy_serialize_cb serialize;
45 rate_policy_equal_cb equal;
46 rate_policy_destroy_cb destroy;
47 rate_policy_copy_cb copy;
6a751b95 48 rate_policy_mi_serialize_cb mi_serialize;
7f4d5b07
JR
49};
50
f1494934 51namespace {
7f4d5b07
JR
52struct lttng_rate_policy_every_n {
53 struct lttng_rate_policy parent;
54 uint64_t interval;
55};
56
57struct lttng_rate_policy_once_after_n {
58 struct lttng_rate_policy parent;
59 uint64_t threshold;
60};
61
62struct lttng_rate_policy_comm {
63 /* enum lttng_rate_policy_type */
64 int8_t rate_policy_type;
65} LTTNG_PACKED;
66
67struct lttng_rate_policy_once_after_n_comm {
68 uint64_t threshold;
69} LTTNG_PACKED;
70
71struct lttng_rate_policy_every_n_comm {
72 uint64_t interval;
73} LTTNG_PACKED;
f1494934 74} /* namespace */
7f4d5b07
JR
75
76/* Forward declaration. */
77static void lttng_rate_policy_init(struct lttng_rate_policy *rate_policy,
78 enum lttng_rate_policy_type type,
79 rate_policy_serialize_cb serialize,
80 rate_policy_equal_cb equal,
81 rate_policy_destroy_cb destroy,
6a751b95
JR
82 rate_policy_copy_cb copy,
83 rate_policy_mi_serialize_cb mi);
7f4d5b07
JR
84
85/* Forward declaration. Every n */
86static bool lttng_rate_policy_every_n_should_execute(
87 const struct lttng_rate_policy *policy, uint64_t counter);
88
89/* Forward declaration. Once after N */
90static bool lttng_rate_policy_once_after_n_should_execute(
91 const struct lttng_rate_policy *policy, uint64_t counter);
92
7f4d5b07
JR
93const char *lttng_rate_policy_type_string(
94 enum lttng_rate_policy_type rate_policy_type)
95{
96 switch (rate_policy_type) {
97 case LTTNG_RATE_POLICY_TYPE_EVERY_N:
98 return "EVERY-N";
99 case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N:
100 return "ONCE-AFTER-N";
101 default:
102 return "???";
103 }
104}
105
106enum lttng_rate_policy_type lttng_rate_policy_get_type(
107 const struct lttng_rate_policy *policy)
108{
109 return policy ? policy->type : LTTNG_RATE_POLICY_TYPE_UNKNOWN;
110}
111
7f4d5b07
JR
112void lttng_rate_policy_init(struct lttng_rate_policy *rate_policy,
113 enum lttng_rate_policy_type type,
114 rate_policy_serialize_cb serialize,
115 rate_policy_equal_cb equal,
116 rate_policy_destroy_cb destroy,
6a751b95
JR
117 rate_policy_copy_cb copy,
118 rate_policy_mi_serialize_cb mi)
7f4d5b07
JR
119{
120 rate_policy->type = type;
121 rate_policy->serialize = serialize;
122 rate_policy->equal = equal;
123 rate_policy->destroy = destroy;
124 rate_policy->copy = copy;
6a751b95 125 rate_policy->mi_serialize = mi;
7f4d5b07
JR
126}
127
128void lttng_rate_policy_destroy(struct lttng_rate_policy *rate_policy)
129{
130 if (!rate_policy) {
131 return;
132 }
133
134 rate_policy->destroy(rate_policy);
135}
136
7f4d5b07
JR
137int lttng_rate_policy_serialize(struct lttng_rate_policy *rate_policy,
138 struct lttng_payload *payload)
139{
140 int ret;
141 struct lttng_rate_policy_comm rate_policy_comm = {
142 .rate_policy_type = (int8_t) rate_policy->type,
143 };
144
145 ret = lttng_dynamic_buffer_append(&payload->buffer, &rate_policy_comm,
146 sizeof(rate_policy_comm));
147 if (ret) {
148 goto end;
149 }
150
151 ret = rate_policy->serialize(rate_policy, payload);
152 if (ret) {
153 goto end;
154 }
155end:
156 return ret;
157}
158
159static ssize_t lttng_rate_policy_once_after_n_create_from_payload(
160 struct lttng_payload_view *view,
161 struct lttng_rate_policy **rate_policy)
162{
163 ssize_t consumed_len = -1;
164 struct lttng_rate_policy *policy = NULL;
165 const struct lttng_rate_policy_once_after_n_comm *comm;
166 const struct lttng_payload_view comm_view =
167 lttng_payload_view_from_view(view, 0, sizeof(*comm));
168
169 if (!view || !rate_policy) {
170 consumed_len = -1;
171 goto end;
172 }
173
174 if (!lttng_payload_view_is_valid(&comm_view)) {
175 /* Payload not large enough to contain the header. */
176 consumed_len = -1;
177 goto end;
178 }
179
180 comm = (const struct lttng_rate_policy_once_after_n_comm *)
181 comm_view.buffer.data;
182
183 policy = lttng_rate_policy_once_after_n_create(comm->threshold);
184 if (policy == NULL) {
185 consumed_len = -1;
186 goto end;
187 }
188
189 *rate_policy = policy;
190 consumed_len = sizeof(*comm);
191
192end:
193 return consumed_len;
194}
195
196static ssize_t lttng_rate_policy_every_n_create_from_payload(
197 struct lttng_payload_view *view,
198 struct lttng_rate_policy **rate_policy)
199{
200 ssize_t consumed_len = -1;
201 struct lttng_rate_policy *policy = NULL;
202 const struct lttng_rate_policy_every_n_comm *comm;
203 const struct lttng_payload_view comm_view =
204 lttng_payload_view_from_view(view, 0, sizeof(*comm));
205
206 if (!view || !rate_policy) {
207 consumed_len = -1;
208 goto end;
209 }
210
211 if (!lttng_payload_view_is_valid(&comm_view)) {
212 /* Payload not large enough to contain the header. */
213 consumed_len = -1;
214 goto end;
215 }
216
217 comm = (const struct lttng_rate_policy_every_n_comm *)
218 comm_view.buffer.data;
219
220 policy = lttng_rate_policy_every_n_create(comm->interval);
221 if (policy == NULL) {
222 consumed_len = -1;
223 goto end;
224 }
225
226 *rate_policy = policy;
227 consumed_len = sizeof(*comm);
228
229end:
230 return consumed_len;
231}
232
7f4d5b07
JR
233ssize_t lttng_rate_policy_create_from_payload(struct lttng_payload_view *view,
234 struct lttng_rate_policy **rate_policy)
235{
236 ssize_t consumed_len, specific_rate_policy_consumed_len;
237 rate_policy_create_from_payload_cb create_from_payload_cb;
238 const struct lttng_rate_policy_comm *rate_policy_comm;
239 const struct lttng_payload_view rate_policy_comm_view =
a6bc4ca9
SM
240 lttng_payload_view_from_view(
241 view, 0, sizeof(*rate_policy_comm));
7f4d5b07
JR
242
243 if (!view || !rate_policy) {
244 consumed_len = -1;
245 goto end;
246 }
247
248 if (!lttng_payload_view_is_valid(&rate_policy_comm_view)) {
249 /* Payload not large enough to contain the header. */
250 consumed_len = -1;
251 goto end;
252 }
253
254 rate_policy_comm = (const struct lttng_rate_policy_comm *)
255 rate_policy_comm_view.buffer.data;
256
257 DBG("Create rate_policy from payload: rate-policy-type=%s",
a6bc4ca9
SM
258 lttng_rate_policy_type_string(
259 (lttng_rate_policy_type) rate_policy_comm->rate_policy_type));
7f4d5b07
JR
260
261 switch (rate_policy_comm->rate_policy_type) {
262 case LTTNG_RATE_POLICY_TYPE_EVERY_N:
263 create_from_payload_cb =
264 lttng_rate_policy_every_n_create_from_payload;
265 break;
266 case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N:
267 create_from_payload_cb =
268 lttng_rate_policy_once_after_n_create_from_payload;
269 break;
270 default:
271 ERR("Failed to create rate-policy from payload, unhandled rate-policy type: rate-policy-type=%u (%s)",
272 rate_policy_comm->rate_policy_type,
273 lttng_rate_policy_type_string(
a6bc4ca9 274 (lttng_rate_policy_type) rate_policy_comm->rate_policy_type));
7f4d5b07
JR
275 consumed_len = -1;
276 goto end;
277 }
278
279 {
280 /* Create buffer view for the rate_policy-type-specific data.
281 */
282 struct lttng_payload_view specific_rate_policy_view =
283 lttng_payload_view_from_view(view,
284 sizeof(struct lttng_rate_policy_comm),
285 -1);
286
287 specific_rate_policy_consumed_len = create_from_payload_cb(
288 &specific_rate_policy_view, rate_policy);
289 }
290 if (specific_rate_policy_consumed_len < 0) {
291 ERR("Failed to create specific rate_policy from buffer.");
292 consumed_len = -1;
293 goto end;
294 }
295
a0377dfe 296 LTTNG_ASSERT(*rate_policy);
7f4d5b07
JR
297
298 consumed_len = sizeof(struct lttng_rate_policy_comm) +
299 specific_rate_policy_consumed_len;
300
301end:
302 return consumed_len;
303}
304
7f4d5b07
JR
305bool lttng_rate_policy_is_equal(const struct lttng_rate_policy *a,
306 const struct lttng_rate_policy *b)
307{
308 bool is_equal = false;
309
310 if (!a || !b) {
311 goto end;
312 }
313
314 if (a->type != b->type) {
315 goto end;
316 }
317
318 if (a == b) {
319 is_equal = true;
320 goto end;
321 }
322
a0377dfe 323 LTTNG_ASSERT(a->equal);
7f4d5b07
JR
324 is_equal = a->equal(a, b);
325end:
326 return is_equal;
327}
328
7f4d5b07
JR
329bool lttng_rate_policy_should_execute(
330 const struct lttng_rate_policy *policy, uint64_t counter)
331{
332 switch (policy->type) {
333 case LTTNG_RATE_POLICY_TYPE_EVERY_N:
334 return lttng_rate_policy_every_n_should_execute(
335 policy, counter);
336 case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N:
337 return lttng_rate_policy_once_after_n_should_execute(
338 policy, counter);
339 default:
340 abort();
341 break;
342 }
343}
344
345/* Every N */
346static struct lttng_rate_policy_every_n *rate_policy_every_n_from_rate_policy(
347 struct lttng_rate_policy *policy)
348{
a0377dfe 349 LTTNG_ASSERT(policy);
7f4d5b07 350
0114db0e 351 return lttng::utils::container_of(policy, &lttng_rate_policy_every_n::parent);
7f4d5b07
JR
352}
353
354static const struct lttng_rate_policy_every_n *
355rate_policy_every_n_from_rate_policy_const(
356 const struct lttng_rate_policy *policy)
357{
a0377dfe 358 LTTNG_ASSERT(policy);
7f4d5b07 359
0114db0e 360 return lttng::utils::container_of(policy, &lttng_rate_policy_every_n::parent);
7f4d5b07
JR
361}
362
363static int lttng_rate_policy_every_n_serialize(
364 struct lttng_rate_policy *policy, struct lttng_payload *payload)
365{
366 int ret;
367
368 struct lttng_rate_policy_every_n *every_n_policy;
369 struct lttng_rate_policy_every_n_comm comm = {};
370
a0377dfe
FD
371 LTTNG_ASSERT(policy);
372 LTTNG_ASSERT(payload);
7f4d5b07
JR
373
374 every_n_policy = rate_policy_every_n_from_rate_policy(policy);
375 comm.interval = every_n_policy->interval;
376
377 ret = lttng_dynamic_buffer_append(
378 &payload->buffer, &comm, sizeof(comm));
379 return ret;
380}
381
382static bool lttng_rate_policy_every_n_is_equal(
383 const struct lttng_rate_policy *_a,
384 const struct lttng_rate_policy *_b)
385{
386 bool is_equal = false;
387 const struct lttng_rate_policy_every_n *a, *b;
388
389 a = rate_policy_every_n_from_rate_policy_const(_a);
390 b = rate_policy_every_n_from_rate_policy_const(_b);
391
392 if (a->interval != b->interval) {
393 goto end;
394 }
395
396 is_equal = true;
397
398end:
399 return is_equal;
400}
401
402static void lttng_rate_policy_every_n_destroy(struct lttng_rate_policy *policy)
403{
404 struct lttng_rate_policy_every_n *every_n_policy;
405
406 if (!policy) {
407 goto end;
408 }
409
410 every_n_policy = rate_policy_every_n_from_rate_policy(policy);
411
412 free(every_n_policy);
413
414end:
415 return;
416}
417
418static struct lttng_rate_policy *lttng_rate_policy_every_n_copy(
419 const struct lttng_rate_policy *source)
420{
421 struct lttng_rate_policy *copy = NULL;
422 const struct lttng_rate_policy_every_n *every_n_policy;
423
424 if (!source) {
425 goto end;
426 }
427
428 every_n_policy = rate_policy_every_n_from_rate_policy_const(source);
429 copy = lttng_rate_policy_every_n_create(every_n_policy->interval);
430
431end:
432 return copy;
433}
434
6a751b95
JR
435static enum lttng_error_code lttng_rate_policy_every_n_mi_serialize(
436 const struct lttng_rate_policy *rate_policy,
437 struct mi_writer *writer)
438{
439 int ret;
440 enum lttng_error_code ret_code;
441 const struct lttng_rate_policy_every_n *every_n_policy = NULL;
442
a0377dfe
FD
443 LTTNG_ASSERT(rate_policy);
444 LTTNG_ASSERT(IS_EVERY_N_RATE_POLICY(rate_policy));
445 LTTNG_ASSERT(writer);
6a751b95
JR
446
447 every_n_policy = rate_policy_every_n_from_rate_policy_const(
448 rate_policy);
449
450 /* Open rate_policy_every_n element. */
451 ret = mi_lttng_writer_open_element(
452 writer, mi_lttng_element_rate_policy_every_n);
453 if (ret) {
454 goto mi_error;
455 }
456
457 /* Interval. */
458 ret = mi_lttng_writer_write_element_unsigned_int(writer,
459 mi_lttng_element_rate_policy_every_n_interval,
460 every_n_policy->interval);
461 if (ret) {
462 goto mi_error;
463 }
464
465 /* Close rate_policy_every_n element. */
466 ret = mi_lttng_writer_close_element(writer);
467 if (ret) {
468 goto mi_error;
469 }
470
471 ret_code = LTTNG_OK;
472 goto end;
473
474mi_error:
475 ret_code = LTTNG_ERR_MI_IO_FAIL;
476end:
477 return ret_code;
478}
479
7f4d5b07
JR
480struct lttng_rate_policy *lttng_rate_policy_every_n_create(uint64_t interval)
481{
482 struct lttng_rate_policy_every_n *policy = NULL;
483 struct lttng_rate_policy *_policy = NULL;
484
485 if (interval == 0) {
486 /*
487 * An interval of 0 is invalid since it would never be fired.
488 */
489 goto end;
490 }
491
64803277 492 policy = zmalloc<lttng_rate_policy_every_n>();
7f4d5b07
JR
493 if (!policy) {
494 goto end;
495 }
496
497 lttng_rate_policy_init(&policy->parent, LTTNG_RATE_POLICY_TYPE_EVERY_N,
498 lttng_rate_policy_every_n_serialize,
499 lttng_rate_policy_every_n_is_equal,
500 lttng_rate_policy_every_n_destroy,
6a751b95
JR
501 lttng_rate_policy_every_n_copy,
502 lttng_rate_policy_every_n_mi_serialize);
7f4d5b07
JR
503
504 policy->interval = interval;
505
506 _policy = &policy->parent;
507 policy = NULL;
508
509end:
510 free(policy);
511 return _policy;
512}
513
7f4d5b07
JR
514enum lttng_rate_policy_status lttng_rate_policy_every_n_get_interval(
515 const struct lttng_rate_policy *policy, uint64_t *interval)
516{
517 const struct lttng_rate_policy_every_n *every_n_policy;
518 enum lttng_rate_policy_status status;
519
520 if (!policy || !IS_EVERY_N_RATE_POLICY(policy) || !interval) {
521 status = LTTNG_RATE_POLICY_STATUS_INVALID;
522 goto end;
523 }
524
525 every_n_policy = rate_policy_every_n_from_rate_policy_const(policy);
526 *interval = every_n_policy->interval;
527 status = LTTNG_RATE_POLICY_STATUS_OK;
528end:
529
530 return status;
531}
532
533static bool lttng_rate_policy_every_n_should_execute(
534 const struct lttng_rate_policy *policy, uint64_t counter)
535{
536 const struct lttng_rate_policy_every_n *every_n_policy;
a0377dfe 537 LTTNG_ASSERT(policy);
7f4d5b07
JR
538 bool execute = false;
539
540 every_n_policy = rate_policy_every_n_from_rate_policy_const(policy);
541
542 if (every_n_policy->interval == 0) {
543 abort();
544 }
545
546 execute = (counter % every_n_policy->interval) == 0;
547
548 DBG("Policy every N = %" PRIu64
549 ": execution %s. Execution count: %" PRIu64,
550 every_n_policy->interval,
551 execute ? "accepted" : "denied", counter);
552
553 return execute;
554}
555
556/* Once after N */
557
558static struct lttng_rate_policy_once_after_n *
559rate_policy_once_after_n_from_rate_policy(struct lttng_rate_policy *policy)
560{
a0377dfe 561 LTTNG_ASSERT(policy);
7f4d5b07 562
0114db0e
JG
563 return lttng::utils::container_of(
564 policy, &lttng_rate_policy_once_after_n::parent);
7f4d5b07
JR
565}
566
567static const struct lttng_rate_policy_once_after_n *
568rate_policy_once_after_n_from_rate_policy_const(
569 const struct lttng_rate_policy *policy)
570{
a0377dfe 571 LTTNG_ASSERT(policy);
7f4d5b07 572
0114db0e
JG
573 return lttng::utils::container_of(
574 policy, &lttng_rate_policy_once_after_n::parent);
7f4d5b07
JR
575}
576static int lttng_rate_policy_once_after_n_serialize(
577 struct lttng_rate_policy *policy, struct lttng_payload *payload)
578{
579 int ret;
580
581 struct lttng_rate_policy_once_after_n *once_after_n_policy;
582 struct lttng_rate_policy_once_after_n_comm comm = {};
583
a0377dfe
FD
584 LTTNG_ASSERT(policy);
585 LTTNG_ASSERT(payload);
7f4d5b07
JR
586
587 once_after_n_policy = rate_policy_once_after_n_from_rate_policy(policy);
588 comm.threshold = once_after_n_policy->threshold;
589
590 ret = lttng_dynamic_buffer_append(
591 &payload->buffer, &comm, sizeof(comm));
592 return ret;
593}
594
595static bool lttng_rate_policy_once_after_n_is_equal(
596 const struct lttng_rate_policy *_a,
597 const struct lttng_rate_policy *_b)
598{
599 bool is_equal = false;
600 const struct lttng_rate_policy_once_after_n *a, *b;
601
602 a = rate_policy_once_after_n_from_rate_policy_const(_a);
603 b = rate_policy_once_after_n_from_rate_policy_const(_b);
604
605 if (a->threshold != b->threshold) {
606 goto end;
607 }
608
609 is_equal = true;
610
611end:
612 return is_equal;
613}
614
615static void lttng_rate_policy_once_after_n_destroy(
616 struct lttng_rate_policy *policy)
617{
618 struct lttng_rate_policy_once_after_n *once_after_n_policy;
619
620 if (!policy) {
621 goto end;
622 }
623
624 once_after_n_policy = rate_policy_once_after_n_from_rate_policy(policy);
625
626 free(once_after_n_policy);
627
628end:
629 return;
630}
631
632static struct lttng_rate_policy *lttng_rate_policy_once_after_n_copy(
633 const struct lttng_rate_policy *source)
634{
635 struct lttng_rate_policy *copy = NULL;
636 const struct lttng_rate_policy_once_after_n *once_after_n_policy;
637
638 if (!source) {
639 goto end;
640 }
641
642 once_after_n_policy =
643 rate_policy_once_after_n_from_rate_policy_const(source);
644 copy = lttng_rate_policy_once_after_n_create(
645 once_after_n_policy->threshold);
646
647end:
648 return copy;
649}
650
6a751b95
JR
651static enum lttng_error_code lttng_rate_policy_once_after_n_mi_serialize(
652 const struct lttng_rate_policy *rate_policy,
653 struct mi_writer *writer)
654{
655 int ret;
656 enum lttng_error_code ret_code;
657 const struct lttng_rate_policy_once_after_n *once_after_n_policy = NULL;
658
a0377dfe
FD
659 LTTNG_ASSERT(rate_policy);
660 LTTNG_ASSERT(IS_ONCE_AFTER_N_RATE_POLICY(rate_policy));
661 LTTNG_ASSERT(writer);
6a751b95
JR
662
663 once_after_n_policy = rate_policy_once_after_n_from_rate_policy_const(
664 rate_policy);
665
666 /* Open rate_policy_once_after_n. */
667 ret = mi_lttng_writer_open_element(
668 writer, mi_lttng_element_rate_policy_once_after_n);
669 if (ret) {
670 goto mi_error;
671 }
672
673 /* Threshold. */
674 ret = mi_lttng_writer_write_element_unsigned_int(writer,
675 mi_lttng_element_rate_policy_once_after_n_threshold,
676 once_after_n_policy->threshold);
677 if (ret) {
678 goto mi_error;
679 }
680
681 /* Close rate_policy_once_after_n element. */
682 ret = mi_lttng_writer_close_element(writer);
683 if (ret) {
684 goto mi_error;
685 }
686
687 ret_code = LTTNG_OK;
688 goto end;
689
690mi_error:
691 ret_code = LTTNG_ERR_MI_IO_FAIL;
692end:
693 return ret_code;
694}
695
7f4d5b07
JR
696struct lttng_rate_policy *lttng_rate_policy_once_after_n_create(
697 uint64_t threshold)
698{
699 struct lttng_rate_policy_once_after_n *policy = NULL;
700 struct lttng_rate_policy *_policy = NULL;
701
702 if (threshold == 0) {
703 /* threshold is expected to be > 0 */
704 goto end;
705 }
706
64803277 707 policy = zmalloc<lttng_rate_policy_once_after_n>();
7f4d5b07
JR
708 if (!policy) {
709 goto end;
710 }
711
712 lttng_rate_policy_init(&policy->parent,
713 LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N,
714 lttng_rate_policy_once_after_n_serialize,
715 lttng_rate_policy_once_after_n_is_equal,
716 lttng_rate_policy_once_after_n_destroy,
6a751b95
JR
717 lttng_rate_policy_once_after_n_copy,
718 lttng_rate_policy_once_after_n_mi_serialize);
7f4d5b07
JR
719
720 policy->threshold = threshold;
721
722 _policy = &policy->parent;
723 policy = NULL;
724
725end:
726 free(policy);
727 return _policy;
728}
729
7f4d5b07
JR
730enum lttng_rate_policy_status lttng_rate_policy_once_after_n_get_threshold(
731 const struct lttng_rate_policy *policy, uint64_t *threshold)
732{
733 const struct lttng_rate_policy_once_after_n *once_after_n_policy;
734 enum lttng_rate_policy_status status;
735
736 if (!policy || !IS_ONCE_AFTER_N_RATE_POLICY(policy) || !threshold) {
737 status = LTTNG_RATE_POLICY_STATUS_INVALID;
738 goto end;
739 }
740
741 once_after_n_policy =
742 rate_policy_once_after_n_from_rate_policy_const(policy);
743 *threshold = once_after_n_policy->threshold;
744 status = LTTNG_RATE_POLICY_STATUS_OK;
745end:
746
747 return status;
748}
749
7f4d5b07
JR
750struct lttng_rate_policy *lttng_rate_policy_copy(
751 const struct lttng_rate_policy *source)
752{
a0377dfe 753 LTTNG_ASSERT(source->copy);
7f4d5b07
JR
754 return source->copy(source);
755}
756
757static bool lttng_rate_policy_once_after_n_should_execute(
758 const struct lttng_rate_policy *policy, uint64_t counter)
759{
760 const struct lttng_rate_policy_once_after_n *once_after_n_policy;
761 bool execute = false;
a0377dfe 762 LTTNG_ASSERT(policy);
7f4d5b07
JR
763
764 once_after_n_policy =
765 rate_policy_once_after_n_from_rate_policy_const(policy);
766
767 execute = counter == once_after_n_policy->threshold;
768
769 DBG("Policy once after N = %" PRIu64
770 ": execution %s. Execution count: %" PRIu64,
771 once_after_n_policy->threshold,
772 execute ? "accepted" : "denied", counter);
773
774 return counter == once_after_n_policy->threshold;
775}
6a751b95 776
6a751b95
JR
777enum lttng_error_code lttng_rate_policy_mi_serialize(
778 const struct lttng_rate_policy *rate_policy,
779 struct mi_writer *writer)
780{
781 int ret;
782 enum lttng_error_code ret_code;
783
a0377dfe
FD
784 LTTNG_ASSERT(rate_policy);
785 LTTNG_ASSERT(writer);
786 LTTNG_ASSERT(rate_policy->mi_serialize);
6a751b95
JR
787
788 /* Open rate policy element. */
789 ret = mi_lttng_writer_open_element(
790 writer, mi_lttng_element_rate_policy);
791 if (ret) {
792 goto mi_error;
793 }
794
795 /* Serialize underlying rate policy. */
796 ret_code = rate_policy->mi_serialize(rate_policy, writer);
797 if (ret_code != LTTNG_OK) {
798 goto end;
799 }
800
801 /* Close rate policy element. */
802 ret = mi_lttng_writer_close_element(writer);
803 if (ret) {
804 goto mi_error;
805 }
806
807 ret_code = LTTNG_OK;
808 goto end;
809
810mi_error:
811 ret_code = LTTNG_ERR_MI_IO_FAIL;
812end:
813 return ret_code;
814}
This page took 0.069562 seconds and 4 git commands to generate.