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
17 #include <lttng/lttng.h>
18 #include <common/macros.h>
22 enum unregistration_trigger_instance
{
23 UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
,
24 UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING
,
27 typedef void (*test_function
)(enum unregistration_trigger_instance
);
30 const char *get_trigger_name(const struct lttng_trigger
*trigger
)
32 const char *trigger_name
;
33 enum lttng_trigger_status trigger_status
;
35 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
36 switch (trigger_status
) {
37 case LTTNG_TRIGGER_STATUS_OK
:
39 case LTTNG_TRIGGER_STATUS_UNSET
:
40 trigger_name
= "(anonymous)";
43 trigger_name
= "(failed to get name)";
51 const char *unregistration_trigger_instance_name(
52 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
75 int unregister_all_triggers(void)
78 enum lttng_error_code ret_code
;
79 enum lttng_trigger_status trigger_status
;
80 struct lttng_triggers
*triggers
= NULL
;
81 unsigned int trigger_count
, i
, unregistered_trigger_count
= 0;
83 ret_code
= lttng_list_triggers(&triggers
);
84 if (ret_code
!= LTTNG_OK
) {
85 fail("Failed to list triggers");
90 trigger_status
= lttng_triggers_get_count(triggers
, &trigger_count
);
91 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
92 fail("Failed to get count of triggers returned by listing");
97 for (i
= 0; i
< trigger_count
; i
++) {
98 const struct lttng_trigger
*trigger
;
100 trigger
= lttng_triggers_get_at_index(triggers
, i
);
101 LTTNG_ASSERT(trigger
);
103 ret
= lttng_unregister_trigger(trigger
);
105 fail("Failed to unregister trigger: trigger name = '%s'");
109 unregistered_trigger_count
++;
112 ret
= (int) unregistered_trigger_count
;
115 lttng_triggers_destroy(triggers
);
120 int get_registered_triggers_count(void)
123 enum lttng_error_code ret_code
;
124 enum lttng_trigger_status trigger_status
;
125 struct lttng_triggers
*triggers
= NULL
;
126 unsigned int trigger_count
;
128 ret_code
= lttng_list_triggers(&triggers
);
129 if (ret_code
!= LTTNG_OK
) {
130 fail("Failed to list triggers");
135 trigger_status
= lttng_triggers_get_count(triggers
, &trigger_count
);
136 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
137 fail("Failed to get count of triggers returned by listing");
142 ret
= (int) trigger_count
;
145 lttng_triggers_destroy(triggers
);
150 * Create a generic trigger. The specifics of the condition and action are not
151 * important for the purposes of this test.
154 struct lttng_trigger
*create_trigger(uint64_t threshold
)
156 struct lttng_condition
*condition
= NULL
;
157 struct lttng_action
*action
= NULL
;
158 struct lttng_trigger
*trigger
= NULL
;
159 enum lttng_condition_status condition_status
;
160 const char * const session_name
= "test session";
162 condition
= lttng_condition_session_consumed_size_create();
164 fail("Failed to create 'session consumed size' condition");
168 condition_status
= lttng_condition_session_consumed_size_set_session_name(condition
, session_name
);
169 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
170 fail("Failed to set session name on 'session consumed size' condition");
174 condition_status
= lttng_condition_session_consumed_size_set_threshold(
175 condition
, threshold
);
176 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
177 fail("Failed to set threshold on 'session consumed size' condition");
181 action
= lttng_action_notify_create();
183 fail("Failed to create 'notify' action");
187 trigger
= lttng_trigger_create(condition
, action
);
189 fail("Failed to create trigger");
194 lttng_condition_destroy(condition
);
195 lttng_action_destroy(action
);
200 void register_anonymous_trigger(
201 enum unregistration_trigger_instance unregistration_trigger
)
204 struct lttng_trigger
*trigger
= create_trigger(0xbadc0ffee);
205 enum lttng_trigger_status trigger_status
;
206 const char *trigger_name
;
207 struct lttng_triggers
*triggers
= NULL
;
208 unsigned int trigger_count
, i
;
209 enum lttng_error_code ret_code
;
211 diag("Register an anonymous trigger (Unregistration performed with the trigger instance %s)",
212 unregistration_trigger_instance_name(
213 unregistration_trigger
));
216 fail("Failed to create trigger");
220 ret
= lttng_register_trigger(trigger
);
221 ok(ret
== 0, "Registered anonymous trigger");
223 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
224 ok(trigger_status
== LTTNG_TRIGGER_STATUS_UNSET
,
225 "Anonymous trigger name remains unset after registration: trigger name = '%s'",
226 get_trigger_name(trigger
));
228 ret_code
= lttng_list_triggers(&triggers
);
229 if (ret_code
!= LTTNG_OK
) {
230 fail("Failed to list triggers");
235 trigger_status
= lttng_triggers_get_count(triggers
, &trigger_count
);
236 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
237 fail("Failed to get count of triggers returned by listing");
242 ok(trigger_count
== 1, "Trigger listing returns 1 trigger");
244 for (i
= 0; i
< trigger_count
; i
++) {
245 const struct lttng_trigger
*trigger_from_listing
;
247 trigger_from_listing
= lttng_triggers_get_at_index(triggers
, i
);
248 LTTNG_ASSERT(trigger_from_listing
);
250 trigger_status
= lttng_trigger_get_name(trigger_from_listing
, &trigger_name
);
251 ok(trigger_status
== LTTNG_TRIGGER_STATUS_UNSET
,
252 "Anonymous trigger returned by listing has an unset name: trigger name = '%s'",
253 get_trigger_name(trigger_from_listing
));
255 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING
) {
256 ret
= lttng_unregister_trigger(trigger_from_listing
);
257 ok(ret
== 0, "Successfully unregistered anonymous trigger using the trigger instance returned by the listing");
261 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
) {
262 ret
= lttng_unregister_trigger(trigger
);
263 ok(ret
== 0, "Successfully unregistered anonymous trigger using the trigger instance used on registration");
267 lttng_triggers_destroy(triggers
);
268 lttng_trigger_destroy(trigger
);
272 void register_named_trigger(
273 enum unregistration_trigger_instance unregistration_trigger
)
276 struct lttng_trigger
*trigger
= create_trigger(0xbadc0ffee);
277 enum lttng_trigger_status trigger_status
;
278 const char *returned_trigger_name
;
279 struct lttng_triggers
*triggers
= NULL
;
280 unsigned int trigger_count
, i
;
281 enum lttng_error_code ret_code
;
282 const char * const trigger_name
= "some name that is hopefully unique";
284 diag("Register a named trigger (Unregistration performed with the trigger instance %s)",
285 unregistration_trigger_instance_name(
286 unregistration_trigger
));
289 fail("Failed to create trigger");
293 ret_code
= lttng_register_trigger_with_name(trigger
, trigger_name
);
294 ok(ret_code
== LTTNG_OK
, "Registered trigger with name: trigger name = '%s'",
295 get_trigger_name(trigger
));
297 trigger_status
= lttng_trigger_get_name(trigger
, &returned_trigger_name
);
298 ok(trigger_status
== LTTNG_TRIGGER_STATUS_OK
,
299 "Trigger name is set after registration: trigger name = '%s'",
300 get_trigger_name(trigger
));
302 ok(!strcmp(get_trigger_name(trigger
), trigger_name
),
303 "Name set on trigger after registration is correct");
305 ret_code
= lttng_list_triggers(&triggers
);
306 if (ret_code
!= LTTNG_OK
) {
307 fail("Failed to list triggers");
312 trigger_status
= lttng_triggers_get_count(triggers
, &trigger_count
);
313 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
314 fail("Failed to get count of triggers returned by listing");
319 ok(trigger_count
== 1, "Trigger listing returns 1 trigger");
321 for (i
= 0; i
< trigger_count
; i
++) {
322 const struct lttng_trigger
*trigger_from_listing
;
324 trigger_from_listing
= lttng_triggers_get_at_index(triggers
, i
);
325 LTTNG_ASSERT(trigger_from_listing
);
327 trigger_status
= lttng_trigger_get_name(trigger_from_listing
, &returned_trigger_name
);
328 ok(trigger_status
== LTTNG_TRIGGER_STATUS_OK
,
329 "Trigger returned by listing has a name: trigger name = '%s'",
330 get_trigger_name(trigger_from_listing
));
332 ok(!strcmp(get_trigger_name(trigger_from_listing
),
334 "Name set on trigger returned from listing is correct: name returned from listing = '%s', expected name = '%s'",
335 get_trigger_name(trigger_from_listing
),
338 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING
) {
339 ret
= lttng_unregister_trigger(trigger_from_listing
);
340 ok(ret
== 0, "Successfully unregistered named trigger using the trigger instance returned by the listing");
344 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
) {
345 ret
= lttng_unregister_trigger(trigger
);
346 ok(ret
== 0, "Successfully unregistered named trigger using the trigger instance used on registration");
350 lttng_triggers_destroy(triggers
);
351 lttng_trigger_destroy(trigger
);
355 void register_automatic_name_trigger(
356 enum unregistration_trigger_instance unregistration_trigger
)
359 struct lttng_trigger
*trigger
= create_trigger(0xbadc0ffee);
360 enum lttng_trigger_status trigger_status
;
361 const char *returned_trigger_name
;
362 struct lttng_triggers
*triggers
= NULL
;
363 unsigned int trigger_count
, i
;
364 enum lttng_error_code ret_code
;
366 diag("Register an automatic name trigger (Unregistration performed with the trigger instance %s)",
367 unregistration_trigger_instance_name(
368 unregistration_trigger
));
371 fail("Failed to create trigger");
375 ret_code
= lttng_register_trigger_with_automatic_name(trigger
);
376 ok(ret_code
== LTTNG_OK
, "Registered trigger with automatic name");
378 trigger_status
= lttng_trigger_get_name(trigger
, &returned_trigger_name
);
379 ok(trigger_status
== LTTNG_TRIGGER_STATUS_OK
,
380 "Trigger name is set after registration: trigger name = '%s'",
381 get_trigger_name(trigger
));
383 ok(returned_trigger_name
&& strlen(returned_trigger_name
) > 0,
384 "Automatic name set on trigger after registration longer is not an empty string");
386 ret_code
= lttng_list_triggers(&triggers
);
387 if (ret_code
!= LTTNG_OK
) {
388 fail("Failed to list triggers");
393 trigger_status
= lttng_triggers_get_count(triggers
, &trigger_count
);
394 if (trigger_status
!= LTTNG_TRIGGER_STATUS_OK
) {
395 fail("Failed to get count of triggers returned by listing");
400 ok(trigger_count
== 1, "Trigger listing returns 1 trigger");
402 for (i
= 0; i
< trigger_count
; i
++) {
403 const struct lttng_trigger
*trigger_from_listing
;
405 trigger_from_listing
= lttng_triggers_get_at_index(triggers
, i
);
406 LTTNG_ASSERT(trigger_from_listing
);
408 trigger_status
= lttng_trigger_get_name(trigger_from_listing
, &returned_trigger_name
);
409 ok(trigger_status
== LTTNG_TRIGGER_STATUS_OK
,
410 "Trigger returned by listing has a name: trigger name = '%s'",
411 get_trigger_name(trigger_from_listing
));
413 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING
) {
414 ret
= lttng_unregister_trigger(trigger_from_listing
);
415 ok(ret
== 0, "Successfully unregistered automatic name trigger using the trigger instance returned by the listing");
419 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
) {
420 ret
= lttng_unregister_trigger(trigger
);
421 ok(ret
== 0, "Successfully unregistered automatic trigger using the trigger instance used on registration");
425 lttng_triggers_destroy(triggers
);
426 lttng_trigger_destroy(trigger
);
430 void double_register_anonymous_trigger(
431 enum unregistration_trigger_instance unregistration_trigger
)
434 struct lttng_trigger
*trigger
= create_trigger(0xbadc0ffee);
435 struct lttng_triggers
*triggers
= NULL
;
437 diag("Register duplicate anonymous trigger (Unregistration performed with the trigger instance %s)",
438 unregistration_trigger_instance_name(
439 unregistration_trigger
));
442 fail("Failed to create trigger");
446 ret
= lttng_register_trigger(trigger
);
447 ok(ret
== 0, "Registered anonymous trigger");
449 ret
= lttng_register_trigger(trigger
);
450 ok(ret
== -LTTNG_ERR_TRIGGER_EXISTS
,
451 "Registering identical anonymous trigger fails with `LTTNG_ERR_TRIGGER_EXISTS`");
454 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
) {
455 ret
= lttng_unregister_trigger(trigger
);
456 ok(ret
== 0, "Successfully unregistered anonymous trigger using the trigger instance used on registration");
458 ok(get_registered_triggers_count() == 1,
459 "Trigger listing returns 1 trigger");
460 ok(unregister_all_triggers() == 1,
461 "Successfully unregistered anonymous trigger using the trigger instance returned by the listing");
465 lttng_triggers_destroy(triggers
);
466 lttng_trigger_destroy(trigger
);
470 void double_register_named_trigger(
471 enum unregistration_trigger_instance unregistration_trigger
)
474 struct lttng_trigger
*trigger_a
= create_trigger(0xbadc0ffee);
475 struct lttng_trigger
*trigger_b
= create_trigger(0xbadc0ffee);
476 struct lttng_triggers
*triggers
= NULL
;
477 const char * const trigger_name
= "a unique trigger name";
478 enum lttng_error_code ret_code
;
480 diag("Register duplicate named trigger (Unregistration performed with the trigger instance %s)",
481 unregistration_trigger_instance_name(
482 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
, "Registering trigger with an already used name fails with `LTTNG_ERR_TRIGGER_EXISTS`");
507 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
) {
508 ret
= lttng_unregister_trigger(trigger_a
);
509 ok(ret
== 0, "Successfully unregistered named trigger using the trigger instance used on registration");
511 ok(get_registered_triggers_count() == 1,
512 "Trigger listing returns 1 trigger");
513 ok(unregister_all_triggers() == 1,
514 "Successfully unregistered named trigger using the trigger instance returned by the listing");
518 lttng_triggers_destroy(triggers
);
519 lttng_trigger_destroy(trigger_a
);
520 lttng_trigger_destroy(trigger_b
);
524 void double_register_automatic_name_trigger(
525 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
= NULL
;
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(
535 unregistration_trigger
));
537 if (!trigger_a
|| !trigger_b
) {
538 fail("Failed to create triggers");
542 ret_code
= lttng_register_trigger_with_automatic_name(trigger_a
);
543 ok(ret_code
== LTTNG_OK
, "Registered automatic name trigger: trigger name = '%s'", get_trigger_name(trigger_a
));
545 ret
= lttng_register_trigger_with_automatic_name(trigger_b
);
546 ok(ret_code
== LTTNG_OK
, "Registering an identical trigger instance with an automatic name succeeds: trigger name = '%s'", get_trigger_name(trigger_b
));
548 ok(strcmp(get_trigger_name(trigger_a
), get_trigger_name(trigger_b
)),
549 "Two identical triggers registered with an automatic name have different names");
551 if (unregistration_trigger
== UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
) {
552 ret
= lttng_unregister_trigger(trigger_a
);
553 ok(ret
== 0, "Successfully unregistered automatic trigger A using the trigger instance used on registration");
555 ret
= lttng_unregister_trigger(trigger_b
);
556 ok(ret
== 0, "Successfully unregistered automatic trigger B using the trigger instance used on registration");
558 ok(get_registered_triggers_count() == 2,
559 "Trigger listing returns 2 trigger");
560 ok(unregister_all_triggers() == 2,
561 "Successfully unregistered automatic name triggers using the trigger instance returned by the listing");
565 lttng_triggers_destroy(triggers
);
566 lttng_trigger_destroy(trigger_a
);
567 lttng_trigger_destroy(trigger_b
);
571 void register_multiple_anonymous_triggers(void)
574 struct lttng_trigger
*trigger_a
= create_trigger(0xbadc0ffee);
575 struct lttng_trigger
*trigger_b
= create_trigger(0xbadf00d);
577 diag("Register two different anonymous triggers");
579 if (!trigger_a
|| !trigger_b
) {
580 fail("Failed to create triggers");
584 ret
= lttng_register_trigger(trigger_a
);
585 ok(ret
== 0, "Registered first anonymous trigger");
587 ret
= lttng_register_trigger(trigger_b
);
588 ok(ret
== 0, "Registered second anonymous trigger");
590 ok(get_registered_triggers_count() == 2,
591 "Trigger listing returns 2 trigger");
592 ok(unregister_all_triggers() == 2,
593 "Successfully unregistered two anonymous triggers");
596 lttng_trigger_destroy(trigger_a
);
597 lttng_trigger_destroy(trigger_b
);
600 const test_function test_functions
[] = {
601 register_anonymous_trigger
,
602 register_named_trigger
,
603 register_automatic_name_trigger
,
604 double_register_anonymous_trigger
,
605 double_register_named_trigger
,
606 double_register_automatic_name_trigger
,
609 int main(int argc
, const char **argv
)
613 plan_tests(TEST_COUNT
);
615 if (get_registered_triggers_count() != 0) {
616 fail("Session daemon already has registered triggers, bailing out");
620 for (i
= 0; i
< ARRAY_SIZE(test_functions
); i
++) {
621 const test_function fn
= test_functions
[i
];
623 fn(UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING
);
624 if (get_registered_triggers_count() != 0) {
625 fail("Previous test left registered triggers, bailing out");
630 for (i
= 0; i
< ARRAY_SIZE(test_functions
); i
++) {
631 const test_function fn
= test_functions
[i
];
633 fn(UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION
);
634 if (get_registered_triggers_count() != 0) {
635 fail("Previous test left registered triggers, bailing out");
640 register_multiple_anonymous_triggers();
642 return exit_status();