4 * Tests suite for anonymous, named, and automatic name triggers.
6 * Copyright (C) 2021 Jérémie Galarneau <jeremie.galarneau@efficios.com>
8 * SPDX-License-Identifier: MIT
12 #include <common/macros.hpp>
14 #include <lttng/lttng.h>
24 enum unregistration_trigger_instance
{
25 UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
,
26 UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING
,
29 using test_function
= void (*)(enum unregistration_trigger_instance
);
31 static const char *get_trigger_name(const struct lttng_trigger
*trigger
)
33 const char *trigger_name
;
34 enum lttng_trigger_status trigger_status
;
36 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
37 switch (trigger_status
) {
38 case LTTNG_TRIGGER_STATUS_OK
:
40 case LTTNG_TRIGGER_STATUS_UNSET
:
41 trigger_name
= "(anonymous)";
44 trigger_name
= "(failed to get name)";
52 unregistration_trigger_instance_name(enum unregistration_trigger_instance unregistration_trigger
)
56 switch (unregistration_trigger
) {
57 case UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING
:
58 name
= "from listing";
60 case UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
:
61 name
= "used for registration";
71 * Returns a negative error code on error, else the number of unregistered
74 static int unregister_all_triggers()
77 enum lttng_error_code ret_code
;
78 enum lttng_trigger_status trigger_status
;
79 struct lttng_triggers
*triggers
= nullptr;
80 unsigned int trigger_count
, i
, unregistered_trigger_count
= 0;
82 ret_code
= lttng_list_triggers(&triggers
);
83 if (ret_code
!= LTTNG_OK
) {
84 fail("Failed to list triggers");
89 trigger_status
= lttng_triggers_get_count(triggers
, &trigger_count
);
90 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
91 fail("Failed to get count of triggers returned by listing");
96 for (i
= 0; i
< trigger_count
; i
++) {
97 const struct lttng_trigger
*trigger
;
99 trigger
= lttng_triggers_get_at_index(triggers
, i
);
100 LTTNG_ASSERT(trigger
);
102 ret
= lttng_unregister_trigger(trigger
);
105 enum lttng_trigger_status get_name_status
=
106 lttng_trigger_get_name(trigger
, &name
);
107 if (get_name_status
== LTTNG_TRIGGER_STATUS_OK
) {
108 fail("Failed to unregister trigger: trigger name = '%s'", name
);
110 fail("Failed to unregister trigger");
115 unregistered_trigger_count
++;
118 ret
= (int) unregistered_trigger_count
;
121 lttng_triggers_destroy(triggers
);
125 static int get_registered_triggers_count()
128 enum lttng_error_code ret_code
;
129 enum lttng_trigger_status trigger_status
;
130 struct lttng_triggers
*triggers
= nullptr;
131 unsigned int trigger_count
;
133 ret_code
= lttng_list_triggers(&triggers
);
134 if (ret_code
!= LTTNG_OK
) {
135 fail("Failed to list triggers");
140 trigger_status
= lttng_triggers_get_count(triggers
, &trigger_count
);
141 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
142 fail("Failed to get count of triggers returned by listing");
147 ret
= (int) trigger_count
;
150 lttng_triggers_destroy(triggers
);
155 * Create a generic trigger. The specifics of the condition and action are not
156 * important for the purposes of this test.
158 static struct lttng_trigger
*create_trigger(uint64_t threshold
)
160 struct lttng_condition
*condition
= nullptr;
161 struct lttng_action
*action
= nullptr;
162 struct lttng_trigger
*trigger
= nullptr;
163 enum lttng_condition_status condition_status
;
164 const char *const session_name
= "test session";
166 condition
= lttng_condition_session_consumed_size_create();
168 fail("Failed to create 'session consumed size' condition");
173 lttng_condition_session_consumed_size_set_session_name(condition
, session_name
);
174 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
175 fail("Failed to set session name on 'session consumed size' condition");
180 lttng_condition_session_consumed_size_set_threshold(condition
, threshold
);
181 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
182 fail("Failed to set threshold on 'session consumed size' condition");
186 action
= lttng_action_notify_create();
188 fail("Failed to create 'notify' action");
192 trigger
= lttng_trigger_create(condition
, action
);
194 fail("Failed to create trigger");
199 lttng_condition_destroy(condition
);
200 lttng_action_destroy(action
);
204 static void register_anonymous_trigger(enum unregistration_trigger_instance unregistration_trigger
)
207 struct lttng_trigger
*trigger
= create_trigger(0xbadc0ffee);
208 enum lttng_trigger_status trigger_status
;
209 const char *trigger_name
;
210 struct lttng_triggers
*triggers
= nullptr;
211 unsigned int trigger_count
, i
;
212 enum lttng_error_code ret_code
;
214 diag("Register an anonymous trigger (Unregistration performed with the trigger instance %s)",
215 unregistration_trigger_instance_name(unregistration_trigger
));
218 fail("Failed to create trigger");
222 ret
= lttng_register_trigger(trigger
);
223 ok(ret
== 0, "Registered anonymous trigger");
225 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
226 ok(trigger_status
== LTTNG_TRIGGER_STATUS_UNSET
,
227 "Anonymous trigger name remains unset after registration: trigger name = '%s'",
228 get_trigger_name(trigger
));
230 ret_code
= lttng_list_triggers(&triggers
);
231 if (ret_code
!= LTTNG_OK
) {
232 fail("Failed to list triggers");
237 trigger_status
= lttng_triggers_get_count(triggers
, &trigger_count
);
238 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
239 fail("Failed to get count of triggers returned by listing");
244 ok(trigger_count
== 1, "Trigger listing returns 1 trigger");
246 for (i
= 0; i
< trigger_count
; i
++) {
247 const struct lttng_trigger
*trigger_from_listing
;
249 trigger_from_listing
= lttng_triggers_get_at_index(triggers
, i
);
250 LTTNG_ASSERT(trigger_from_listing
);
252 trigger_status
= lttng_trigger_get_name(trigger_from_listing
, &trigger_name
);
253 ok(trigger_status
== LTTNG_TRIGGER_STATUS_UNSET
,
254 "Anonymous trigger returned by listing has an unset name: trigger name = '%s'",
255 get_trigger_name(trigger_from_listing
));
257 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING
) {
258 ret
= lttng_unregister_trigger(trigger_from_listing
);
260 "Successfully unregistered anonymous trigger using the trigger instance returned by the listing");
264 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
) {
265 ret
= lttng_unregister_trigger(trigger
);
267 "Successfully unregistered anonymous trigger using the trigger instance used on registration");
271 lttng_triggers_destroy(triggers
);
272 lttng_trigger_destroy(trigger
);
275 static void register_named_trigger(enum unregistration_trigger_instance unregistration_trigger
)
278 struct lttng_trigger
*trigger
= create_trigger(0xbadc0ffee);
279 enum lttng_trigger_status trigger_status
;
280 const char *returned_trigger_name
;
281 struct lttng_triggers
*triggers
= nullptr;
282 unsigned int trigger_count
, i
;
283 enum lttng_error_code ret_code
;
284 const char *const trigger_name
= "some name that is hopefully unique";
286 diag("Register a named trigger (Unregistration performed with the trigger instance %s)",
287 unregistration_trigger_instance_name(unregistration_trigger
));
290 fail("Failed to create trigger");
294 ret_code
= lttng_register_trigger_with_name(trigger
, trigger_name
);
295 ok(ret_code
== LTTNG_OK
,
296 "Registered trigger with name: trigger name = '%s'",
297 get_trigger_name(trigger
));
299 trigger_status
= lttng_trigger_get_name(trigger
, &returned_trigger_name
);
300 ok(trigger_status
== LTTNG_TRIGGER_STATUS_OK
,
301 "Trigger name is set after registration: trigger name = '%s'",
302 get_trigger_name(trigger
));
304 ok(!strcmp(get_trigger_name(trigger
), trigger_name
),
305 "Name set on trigger after registration is correct");
307 ret_code
= lttng_list_triggers(&triggers
);
308 if (ret_code
!= LTTNG_OK
) {
309 fail("Failed to list triggers");
314 trigger_status
= lttng_triggers_get_count(triggers
, &trigger_count
);
315 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
316 fail("Failed to get count of triggers returned by listing");
321 ok(trigger_count
== 1, "Trigger listing returns 1 trigger");
323 for (i
= 0; i
< trigger_count
; i
++) {
324 const struct lttng_trigger
*trigger_from_listing
;
326 trigger_from_listing
= lttng_triggers_get_at_index(triggers
, i
);
327 LTTNG_ASSERT(trigger_from_listing
);
330 lttng_trigger_get_name(trigger_from_listing
, &returned_trigger_name
);
331 ok(trigger_status
== LTTNG_TRIGGER_STATUS_OK
,
332 "Trigger returned by listing has a name: trigger name = '%s'",
333 get_trigger_name(trigger_from_listing
));
335 ok(!strcmp(get_trigger_name(trigger_from_listing
), trigger_name
),
336 "Name set on trigger returned from listing is correct: name returned from listing = '%s', expected name = '%s'",
337 get_trigger_name(trigger_from_listing
),
340 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING
) {
341 ret
= lttng_unregister_trigger(trigger_from_listing
);
343 "Successfully unregistered named trigger using the trigger instance returned by the listing");
347 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
) {
348 ret
= lttng_unregister_trigger(trigger
);
350 "Successfully unregistered named trigger using the trigger instance used on registration");
354 lttng_triggers_destroy(triggers
);
355 lttng_trigger_destroy(trigger
);
359 register_automatic_name_trigger(enum unregistration_trigger_instance unregistration_trigger
)
362 struct lttng_trigger
*trigger
= create_trigger(0xbadc0ffee);
363 enum lttng_trigger_status trigger_status
;
364 const char *returned_trigger_name
;
365 struct lttng_triggers
*triggers
= nullptr;
366 unsigned int trigger_count
, i
;
367 enum lttng_error_code ret_code
;
369 diag("Register an automatic name trigger (Unregistration performed with the trigger instance %s)",
370 unregistration_trigger_instance_name(unregistration_trigger
));
373 fail("Failed to create trigger");
377 ret_code
= lttng_register_trigger_with_automatic_name(trigger
);
378 ok(ret_code
== LTTNG_OK
, "Registered trigger with automatic name");
380 trigger_status
= lttng_trigger_get_name(trigger
, &returned_trigger_name
);
381 ok(trigger_status
== LTTNG_TRIGGER_STATUS_OK
,
382 "Trigger name is set after registration: trigger name = '%s'",
383 get_trigger_name(trigger
));
385 ok(returned_trigger_name
&& strlen(returned_trigger_name
) > 0,
386 "Automatic name set on trigger after registration longer is not an empty string");
388 ret_code
= lttng_list_triggers(&triggers
);
389 if (ret_code
!= LTTNG_OK
) {
390 fail("Failed to list triggers");
395 trigger_status
= lttng_triggers_get_count(triggers
, &trigger_count
);
396 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
397 fail("Failed to get count of triggers returned by listing");
402 ok(trigger_count
== 1, "Trigger listing returns 1 trigger");
404 for (i
= 0; i
< trigger_count
; i
++) {
405 const struct lttng_trigger
*trigger_from_listing
;
407 trigger_from_listing
= lttng_triggers_get_at_index(triggers
, i
);
408 LTTNG_ASSERT(trigger_from_listing
);
411 lttng_trigger_get_name(trigger_from_listing
, &returned_trigger_name
);
412 ok(trigger_status
== LTTNG_TRIGGER_STATUS_OK
,
413 "Trigger returned by listing has a name: trigger name = '%s'",
414 get_trigger_name(trigger_from_listing
));
416 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING
) {
417 ret
= lttng_unregister_trigger(trigger_from_listing
);
419 "Successfully unregistered automatic name trigger using the trigger instance returned by the listing");
423 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
) {
424 ret
= lttng_unregister_trigger(trigger
);
426 "Successfully unregistered automatic trigger using the trigger instance used on registration");
430 lttng_triggers_destroy(triggers
);
431 lttng_trigger_destroy(trigger
);
435 double_register_anonymous_trigger(enum unregistration_trigger_instance unregistration_trigger
)
438 struct lttng_trigger
*trigger
= create_trigger(0xbadc0ffee);
439 struct lttng_triggers
*triggers
= nullptr;
441 diag("Register duplicate anonymous trigger (Unregistration performed with the trigger instance %s)",
442 unregistration_trigger_instance_name(unregistration_trigger
));
445 fail("Failed to create trigger");
449 ret
= lttng_register_trigger(trigger
);
450 ok(ret
== 0, "Registered anonymous trigger");
452 ret
= lttng_register_trigger(trigger
);
453 ok(ret
== -LTTNG_ERR_TRIGGER_EXISTS
,
454 "Registering identical anonymous trigger fails with `LTTNG_ERR_TRIGGER_EXISTS`");
456 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
) {
457 ret
= lttng_unregister_trigger(trigger
);
459 "Successfully unregistered anonymous trigger using the trigger instance used on registration");
461 ok(get_registered_triggers_count() == 1, "Trigger listing returns 1 trigger");
462 ok(unregister_all_triggers() == 1,
463 "Successfully unregistered anonymous trigger using the trigger instance returned by the listing");
467 lttng_triggers_destroy(triggers
);
468 lttng_trigger_destroy(trigger
);
472 double_register_named_trigger(enum unregistration_trigger_instance unregistration_trigger
)
475 struct lttng_trigger
*trigger_a
= create_trigger(0xbadc0ffee);
476 struct lttng_trigger
*trigger_b
= create_trigger(0xbadc0ffee);
477 struct lttng_triggers
*triggers
= nullptr;
478 const char *const trigger_name
= "a unique trigger name";
479 enum lttng_error_code ret_code
;
481 diag("Register duplicate named trigger (Unregistration performed with the trigger instance %s)",
482 unregistration_trigger_instance_name(unregistration_trigger
));
484 if (!trigger_a
|| !trigger_b
) {
485 fail("Failed to create triggers");
489 ret_code
= lttng_register_trigger_with_name(trigger_a
, trigger_name
);
490 ok(ret_code
== LTTNG_OK
, "Registered named trigger");
492 ret
= lttng_register_trigger(trigger_a
);
493 ok(ret
== -LTTNG_ERR_INVALID
,
494 "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (anonymous registration)");
496 ret_code
= lttng_register_trigger_with_name(trigger_a
, trigger_name
);
497 ok(ret_code
== LTTNG_ERR_INVALID
,
498 "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (register with name)");
500 ret_code
= lttng_register_trigger_with_automatic_name(trigger_a
);
501 ok(ret_code
== LTTNG_ERR_INVALID
,
502 "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (register with automatic name)");
504 ret_code
= lttng_register_trigger_with_name(trigger_b
, trigger_name
);
505 ok(ret_code
== LTTNG_ERR_TRIGGER_EXISTS
,
506 "Registering trigger with an already used name fails with `LTTNG_ERR_TRIGGER_EXISTS`");
508 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
) {
509 ret
= lttng_unregister_trigger(trigger_a
);
511 "Successfully unregistered named trigger using the trigger instance used on registration");
513 ok(get_registered_triggers_count() == 1, "Trigger listing returns 1 trigger");
514 ok(unregister_all_triggers() == 1,
515 "Successfully unregistered named trigger using the trigger instance returned by the listing");
519 lttng_triggers_destroy(triggers
);
520 lttng_trigger_destroy(trigger_a
);
521 lttng_trigger_destroy(trigger_b
);
525 double_register_automatic_name_trigger(enum unregistration_trigger_instance unregistration_trigger
)
528 struct lttng_trigger
*trigger_a
= create_trigger(0xbadc0ffee);
529 struct lttng_trigger
*trigger_b
= create_trigger(0xbadc0ffee);
530 struct lttng_triggers
*triggers
= nullptr;
531 enum lttng_error_code ret_code
;
533 diag("Register duplicate automatic name trigger (Unregistration performed with the trigger instance %s)",
534 unregistration_trigger_instance_name(unregistration_trigger
));
536 if (!trigger_a
|| !trigger_b
) {
537 fail("Failed to create triggers");
541 ret_code
= lttng_register_trigger_with_automatic_name(trigger_a
);
542 ok(ret_code
== LTTNG_OK
,
543 "Registered automatic name trigger: trigger name = '%s'",
544 get_trigger_name(trigger_a
));
546 ret
= lttng_register_trigger_with_automatic_name(trigger_b
);
547 ok(ret_code
== LTTNG_OK
,
548 "Registering an identical trigger instance with an automatic name succeeds: trigger name = '%s'",
549 get_trigger_name(trigger_b
));
551 ok(strcmp(get_trigger_name(trigger_a
), get_trigger_name(trigger_b
)),
552 "Two identical triggers registered with an automatic name have different names");
554 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
) {
555 ret
= lttng_unregister_trigger(trigger_a
);
557 "Successfully unregistered automatic trigger A using the trigger instance used on registration");
559 ret
= lttng_unregister_trigger(trigger_b
);
561 "Successfully unregistered automatic trigger B using the trigger instance used on registration");
563 ok(get_registered_triggers_count() == 2, "Trigger listing returns 2 trigger");
564 ok(unregister_all_triggers() == 2,
565 "Successfully unregistered automatic name triggers using the trigger instance returned by the listing");
569 lttng_triggers_destroy(triggers
);
570 lttng_trigger_destroy(trigger_a
);
571 lttng_trigger_destroy(trigger_b
);
574 static void register_multiple_anonymous_triggers()
577 struct lttng_trigger
*trigger_a
= create_trigger(0xbadc0ffee);
578 struct lttng_trigger
*trigger_b
= create_trigger(0xbadf00d);
580 diag("Register two different anonymous triggers");
582 if (!trigger_a
|| !trigger_b
) {
583 fail("Failed to create triggers");
587 ret
= lttng_register_trigger(trigger_a
);
588 ok(ret
== 0, "Registered first anonymous trigger");
590 ret
= lttng_register_trigger(trigger_b
);
591 ok(ret
== 0, "Registered second anonymous trigger");
593 ok(get_registered_triggers_count() == 2, "Trigger listing returns 2 trigger");
594 ok(unregister_all_triggers() == 2, "Successfully unregistered two anonymous triggers");
597 lttng_trigger_destroy(trigger_a
);
598 lttng_trigger_destroy(trigger_b
);
601 const test_function test_functions
[] = {
602 register_anonymous_trigger
, register_named_trigger
,
603 register_automatic_name_trigger
, double_register_anonymous_trigger
,
604 double_register_named_trigger
, double_register_automatic_name_trigger
,
611 plan_tests(TEST_COUNT
);
613 if (get_registered_triggers_count() != 0) {
614 fail("Session daemon already has registered triggers, bailing out");
618 for (i
= 0; i
< ARRAY_SIZE(test_functions
); i
++) {
619 const test_function fn
= test_functions
[i
];
621 fn(UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING
);
622 if (get_registered_triggers_count() != 0) {
623 fail("Previous test left registered triggers, bailing out");
628 for (i
= 0; i
< ARRAY_SIZE(test_functions
); i
++) {
629 const test_function fn
= test_functions
[i
];
631 fn(UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
);
632 if (get_registered_triggers_count() != 0) {
633 fail("Previous test left registered triggers, bailing out");
638 register_multiple_anonymous_triggers();
640 return exit_status();