Fix: futex wait: handle spurious futex wakeups
[lttng-tools.git] / src / common / actions / rate-policy.cpp
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 <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>
15 #include <limits.h>
16 #include <lttng/action/rate-policy-internal.hpp>
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 typedef enum lttng_error_code (*rate_policy_mi_serialize_cb)(
39 const struct lttng_rate_policy *rate_policy,
40 struct mi_writer *writer);
41
42 struct 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;
48 rate_policy_mi_serialize_cb mi_serialize;
49 };
50
51 namespace {
52 struct lttng_rate_policy_every_n {
53 struct lttng_rate_policy parent;
54 uint64_t interval;
55 };
56
57 struct lttng_rate_policy_once_after_n {
58 struct lttng_rate_policy parent;
59 uint64_t threshold;
60 };
61
62 struct lttng_rate_policy_comm {
63 /* enum lttng_rate_policy_type */
64 int8_t rate_policy_type;
65 } LTTNG_PACKED;
66
67 struct lttng_rate_policy_once_after_n_comm {
68 uint64_t threshold;
69 } LTTNG_PACKED;
70
71 struct lttng_rate_policy_every_n_comm {
72 uint64_t interval;
73 } LTTNG_PACKED;
74 } /* namespace */
75
76 /* Forward declaration. */
77 static 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,
82 rate_policy_copy_cb copy,
83 rate_policy_mi_serialize_cb mi);
84
85 /* Forward declaration. Every n */
86 static 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 */
90 static bool lttng_rate_policy_once_after_n_should_execute(
91 const struct lttng_rate_policy *policy, uint64_t counter);
92
93 const 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
106 enum 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
112 void 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,
117 rate_policy_copy_cb copy,
118 rate_policy_mi_serialize_cb mi)
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;
125 rate_policy->mi_serialize = mi;
126 }
127
128 void 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
137 int 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 }
155 end:
156 return ret;
157 }
158
159 static 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
192 end:
193 return consumed_len;
194 }
195
196 static 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
229 end:
230 return consumed_len;
231 }
232
233 ssize_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 =
240 lttng_payload_view_from_view(
241 view, 0, sizeof(*rate_policy_comm));
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",
258 lttng_rate_policy_type_string(
259 (lttng_rate_policy_type) rate_policy_comm->rate_policy_type));
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(
274 (lttng_rate_policy_type) rate_policy_comm->rate_policy_type));
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
296 LTTNG_ASSERT(*rate_policy);
297
298 consumed_len = sizeof(struct lttng_rate_policy_comm) +
299 specific_rate_policy_consumed_len;
300
301 end:
302 return consumed_len;
303 }
304
305 bool 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
323 LTTNG_ASSERT(a->equal);
324 is_equal = a->equal(a, b);
325 end:
326 return is_equal;
327 }
328
329 bool 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 */
346 static struct lttng_rate_policy_every_n *rate_policy_every_n_from_rate_policy(
347 struct lttng_rate_policy *policy)
348 {
349 LTTNG_ASSERT(policy);
350
351 return lttng::utils::container_of(policy, &lttng_rate_policy_every_n::parent);
352 }
353
354 static const struct lttng_rate_policy_every_n *
355 rate_policy_every_n_from_rate_policy_const(
356 const struct lttng_rate_policy *policy)
357 {
358 LTTNG_ASSERT(policy);
359
360 return lttng::utils::container_of(policy, &lttng_rate_policy_every_n::parent);
361 }
362
363 static 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
371 LTTNG_ASSERT(policy);
372 LTTNG_ASSERT(payload);
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
382 static 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
398 end:
399 return is_equal;
400 }
401
402 static 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
414 end:
415 return;
416 }
417
418 static 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
431 end:
432 return copy;
433 }
434
435 static 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
443 LTTNG_ASSERT(rate_policy);
444 LTTNG_ASSERT(IS_EVERY_N_RATE_POLICY(rate_policy));
445 LTTNG_ASSERT(writer);
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
474 mi_error:
475 ret_code = LTTNG_ERR_MI_IO_FAIL;
476 end:
477 return ret_code;
478 }
479
480 struct 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
492 policy = zmalloc<lttng_rate_policy_every_n>();
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,
501 lttng_rate_policy_every_n_copy,
502 lttng_rate_policy_every_n_mi_serialize);
503
504 policy->interval = interval;
505
506 _policy = &policy->parent;
507 policy = NULL;
508
509 end:
510 free(policy);
511 return _policy;
512 }
513
514 enum 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;
528 end:
529
530 return status;
531 }
532
533 static 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;
537 LTTNG_ASSERT(policy);
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
558 static struct lttng_rate_policy_once_after_n *
559 rate_policy_once_after_n_from_rate_policy(struct lttng_rate_policy *policy)
560 {
561 LTTNG_ASSERT(policy);
562
563 return lttng::utils::container_of(
564 policy, &lttng_rate_policy_once_after_n::parent);
565 }
566
567 static const struct lttng_rate_policy_once_after_n *
568 rate_policy_once_after_n_from_rate_policy_const(
569 const struct lttng_rate_policy *policy)
570 {
571 LTTNG_ASSERT(policy);
572
573 return lttng::utils::container_of(
574 policy, &lttng_rate_policy_once_after_n::parent);
575 }
576 static 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
584 LTTNG_ASSERT(policy);
585 LTTNG_ASSERT(payload);
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
595 static 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
611 end:
612 return is_equal;
613 }
614
615 static 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
628 end:
629 return;
630 }
631
632 static 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
647 end:
648 return copy;
649 }
650
651 static 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
659 LTTNG_ASSERT(rate_policy);
660 LTTNG_ASSERT(IS_ONCE_AFTER_N_RATE_POLICY(rate_policy));
661 LTTNG_ASSERT(writer);
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
690 mi_error:
691 ret_code = LTTNG_ERR_MI_IO_FAIL;
692 end:
693 return ret_code;
694 }
695
696 struct 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
707 policy = zmalloc<lttng_rate_policy_once_after_n>();
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,
717 lttng_rate_policy_once_after_n_copy,
718 lttng_rate_policy_once_after_n_mi_serialize);
719
720 policy->threshold = threshold;
721
722 _policy = &policy->parent;
723 policy = NULL;
724
725 end:
726 free(policy);
727 return _policy;
728 }
729
730 enum 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;
745 end:
746
747 return status;
748 }
749
750 struct lttng_rate_policy *lttng_rate_policy_copy(
751 const struct lttng_rate_policy *source)
752 {
753 LTTNG_ASSERT(source->copy);
754 return source->copy(source);
755 }
756
757 static 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;
762 LTTNG_ASSERT(policy);
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 }
776
777 enum 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
784 LTTNG_ASSERT(rate_policy);
785 LTTNG_ASSERT(writer);
786 LTTNG_ASSERT(rate_policy->mi_serialize);
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
810 mi_error:
811 ret_code = LTTNG_ERR_MI_IO_FAIL;
812 end:
813 return ret_code;
814 }
This page took 0.046741 seconds and 4 git commands to generate.