4 * Tests suite for LTTng notification API
6 * Copyright (C) 2017 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
8 * SPDX-License-Identifier: MIT
19 #include <sys/types.h>
25 #include <common/compat/errno.h>
26 #include <common/macros.h>
27 #include <lttng/lttng.h>
31 #define FIELD_NAME_MAX_LEN 256
33 /* A callback to populate the condition capture descriptor. */
34 typedef int (*condition_capture_desc_cb
)(struct lttng_condition
*condition
);
36 /* A callback for captured field validation. */
37 typedef int (*validate_cb
)(const struct lttng_event_field_value
*event_field
, unsigned iteration
);
40 int named_pipe_args_start
= 0;
42 const char *app_state_file
= NULL
;
47 FIELD_TYPE_APP_CONTEXT
,
48 FIELD_TYPE_ARRAY_FIELD
,
51 struct capture_base_field_tuple
{
52 const char *field_name
;
53 enum field_type field_type
;
54 /* Do we expect a userspace capture? */
56 /* Do we expect a kernel capture? */
58 validate_cb validate_ust
;
59 validate_cb validate_kernel
;
63 const char *field_value_type_to_str(enum lttng_event_field_value_type type
)
66 case LTTNG_EVENT_FIELD_VALUE_TYPE_UNKNOWN
:
68 case LTTNG_EVENT_FIELD_VALUE_TYPE_INVALID
:
70 case LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_INT
:
71 return "UNSIGNED INT";
72 case LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_INT
:
74 case LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM
:
75 return "UNSIGNED ENUM";
76 case LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM
:
78 case LTTNG_EVENT_FIELD_VALUE_TYPE_REAL
:
80 case LTTNG_EVENT_FIELD_VALUE_TYPE_STRING
:
82 case LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY
:
89 static int validate_type(const struct lttng_event_field_value
*event_field
,
90 enum lttng_event_field_value_type expect
)
93 enum lttng_event_field_value_type value
;
95 value
= lttng_event_field_value_get_type(event_field
);
96 if (value
== LTTNG_EVENT_FIELD_VALUE_TYPE_INVALID
) {
101 ok(expect
== value
, "Expected field type %s, got %s",
102 field_value_type_to_str(expect
),
103 field_value_type_to_str(value
));
105 ret
= expect
!= value
;
112 * Validate unsigned captured field against the iteration number.
114 static int validate_unsigned_int_field(
115 const struct lttng_event_field_value
*event_field
,
116 unsigned int expected_value
)
120 enum lttng_event_field_value_status status
;
123 event_field
, LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_INT
);
128 status
= lttng_event_field_value_unsigned_int_get_value(
129 event_field
, &value
);
130 if (status
!= LTTNG_EVENT_FIELD_VALUE_STATUS_OK
) {
131 fail("lttng_event_field_value_unsigned_int_get_value returned an error: status = %d",
137 ok(value
== (uint64_t) expected_value
,
138 "Expected unsigned integer value %u, got %" PRIu64
,
139 expected_value
, value
);
141 ret
= value
!= (uint64_t) expected_value
;
148 * Validate signed captured field.
150 static int validate_signed_int_field(
151 const struct lttng_event_field_value
*event_field
,
152 unsigned int iteration
)
155 const int64_t expected
= -1;
157 enum lttng_event_field_value_status status
;
163 event_field
, LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_INT
);
168 status
= lttng_event_field_value_signed_int_get_value(
169 event_field
, &value
);
170 if (status
!= LTTNG_EVENT_FIELD_VALUE_STATUS_OK
) {
171 fail("lttng_event_field_value_signed_int_get_value returned an error: status = %d",
177 ok(value
== expected
,
178 "Expected signed integer value %" PRId64
182 ret
= value
!= expected
;
190 * Validate array of unsigned int.
192 static int validate_array_unsigned_int_field(
193 const struct lttng_event_field_value
*event_field
,
194 unsigned int iteration
)
197 enum lttng_event_field_value_status status
;
198 const unsigned int expected
= 3;
199 unsigned int i
, count
;
204 ret
= validate_type(event_field
, LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY
);
209 status
= lttng_event_field_value_array_get_length(event_field
, &count
);
210 if (status
!= LTTNG_EVENT_FIELD_VALUE_STATUS_OK
) {
211 fail("lttng_event_field_value_array_get_length");
216 ok(count
== expected
, "Expected %d subelements, got %d", expected
,
218 if (count
!= expected
) {
223 for (i
= 1; i
< count
+ 1; i
++) {
224 const struct lttng_event_field_value
*value
;
226 status
= lttng_event_field_value_array_get_element_at_index(
227 event_field
, i
- 1, &value
);
228 if (status
!= LTTNG_EVENT_FIELD_VALUE_STATUS_OK
) {
229 fail("lttng_event_field_value_array_get_element_at_index returned an error: status = %d",
235 ret
= validate_unsigned_int_field(value
, i
);
247 static int validate_array_unsigned_int_field_at_index(
248 const struct lttng_event_field_value
*event_field
,
249 unsigned int iteration
)
252 const uint64_t expected_value
= 2;
253 enum lttng_event_field_value_status status
;
260 event_field
, LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_INT
);
265 status
= lttng_event_field_value_unsigned_int_get_value(
266 event_field
, &value
);
267 if (status
!= LTTNG_EVENT_FIELD_VALUE_STATUS_OK
) {
268 fail("lttng_event_field_value_unsigned_int_get_value returned an error: status = %d",
274 ok(value
== expected_value
,
275 "Expected unsigned integer value %" PRIu64
", got %" PRIu64
,
276 expected_value
, value
);
284 * Validate sequence for a string (seqfield1):
286 * Value: "test" encoded in UTF-8: [116, 101, 115, 116]
288 static int validate_seqfield1(const struct lttng_event_field_value
*event_field
,
289 unsigned int iteration
)
292 enum lttng_event_field_value_status status
;
293 unsigned int i
, count
;
294 const unsigned int expect
[] = {116, 101, 115, 116};
295 const size_t array_count
= sizeof(expect
) / sizeof(*expect
);
300 ret
= validate_type(event_field
, LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY
);
305 status
= lttng_event_field_value_array_get_length(event_field
, &count
);
306 if (status
!= LTTNG_EVENT_FIELD_VALUE_STATUS_OK
) {
307 fail("lttng_event_field_value_array_get_length returned an error: status = %d",
313 ok(count
== array_count
, "Expected %zu array sub-elements, got %d",
315 if (count
!= array_count
) {
320 for (i
= 0; i
< count
; i
++) {
321 const struct lttng_event_field_value
*value
;
323 status
= lttng_event_field_value_array_get_element_at_index(
324 event_field
, i
, &value
);
325 if (status
!= LTTNG_EVENT_FIELD_VALUE_STATUS_OK
) {
326 fail("lttng_event_field_value_array_get_element_at_index returned an error: status = %d",
332 ret
= validate_unsigned_int_field(value
, expect
[i
]);
343 static int validate_string(
344 const struct lttng_event_field_value
*event_field
,
348 const char *value
= NULL
;
349 enum lttng_event_field_value_status status
;
351 ret
= validate_type(event_field
, LTTNG_EVENT_FIELD_VALUE_TYPE_STRING
);
356 status
= lttng_event_field_value_string_get_value(event_field
, &value
);
358 fail("lttng_event_field_value_array_get_length returned an error: status = %d",
364 ok(!strcmp(value
, expect
), "Expected string value \"%s\", got \"%s\"",
374 * Validate string. Expected value is "test".
376 static int validate_string_test(
377 const struct lttng_event_field_value
*event_field
,
378 unsigned int iteration
)
380 const char * const expect
= "test";
385 return validate_string(event_field
, expect
);
389 * Validate escaped string. Expected value is "\*".
391 static int validate_string_escaped(
392 const struct lttng_event_field_value
*event_field
,
393 unsigned int iteration
)
395 const char * const expect
= "\\*";
400 return validate_string(event_field
, expect
);
404 * Validate real field.
406 static int validate_real(
407 const struct lttng_event_field_value
*event_field
,
412 enum lttng_event_field_value_status status
;
414 ret
= validate_type(event_field
, LTTNG_EVENT_FIELD_VALUE_TYPE_REAL
);
419 status
= lttng_event_field_value_real_get_value(event_field
, &value
);
420 if (status
!= LTTNG_EVENT_FIELD_VALUE_STATUS_OK
) {
421 fail("lttng_event_field_value_real_get_value returned an error: status = %d",
427 ok(value
== expect
, "Expected real value %f, got %f", expect
, value
);
428 ret
= value
!= expect
;
434 * Validate floatfield.
436 static int validate_floatfield(
437 const struct lttng_event_field_value
*event_field
,
438 unsigned int iteration
)
440 const double expect
= 2222.0;
445 return validate_real(event_field
, expect
);
449 * Validate doublefield.
451 static int validate_doublefield(
452 const struct lttng_event_field_value
*event_field
,
453 unsigned int iteration
)
455 const double expect
= 2.0;
460 return validate_real(event_field
, expect
);
464 * Validate enum0: enum0 = ( "AUTO: EXPECT 0" : container = 0 )
466 static int validate_enum0(const struct lttng_event_field_value
*event_field
,
467 unsigned int iteration
)
470 enum lttng_event_field_value_status status
;
472 const uint64_t expected_value
= 0;
477 ret
= validate_type(event_field
,
478 LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM
);
483 status
= lttng_event_field_value_unsigned_int_get_value(
484 event_field
, &value
);
485 if (status
!= LTTNG_EVENT_FIELD_VALUE_STATUS_OK
) {
486 fail("lttng_event_field_value_unsigned_int_get_value returned an error: status = %d",
492 ok(value
== expected_value
,
493 "Expected enum value %" PRIu64
", got %" PRIu64
,
494 expected_value
, value
);
501 * Validate enumnegative: enumnegative = ( "AUTO: EXPECT 0" : container = 0 )
503 * We expect 2 labels here.
505 static int validate_enumnegative(
506 const struct lttng_event_field_value
*event_field
,
507 unsigned int iteration
)
510 enum lttng_event_field_value_status status
;
512 const int64_t expected_value
= -1;
517 ret
= validate_type(event_field
,
518 LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM
);
523 status
= lttng_event_field_value_signed_int_get_value(
524 event_field
, &value
);
525 if (status
!= LTTNG_EVENT_FIELD_VALUE_STATUS_OK
) {
526 fail("lttng_event_field_value_unsigned_int_get_value");
531 ok(value
== expected_value
,
532 "Expected enum value %" PRId64
", got %" PRId64
,
533 expected_value
, value
);
539 static int validate_context_procname_ust(
540 const struct lttng_event_field_value
*event_field
,
541 unsigned int iteration
)
545 return validate_string(event_field
, "gen-ust-events");
548 static int validate_context_procname_kernel(
549 const struct lttng_event_field_value
*event_field
,
550 unsigned int iteration
)
554 return validate_string(event_field
, "echo");
557 struct capture_base_field_tuple test_capture_base_fields
[] = {
558 { "DOESNOTEXIST", FIELD_TYPE_PAYLOAD
, false, false, NULL
, NULL
},
559 { "intfield", FIELD_TYPE_PAYLOAD
, true, true, validate_unsigned_int_field
, validate_unsigned_int_field
},
560 { "longfield", FIELD_TYPE_PAYLOAD
, true, true, validate_unsigned_int_field
, validate_unsigned_int_field
},
561 { "signedfield", FIELD_TYPE_PAYLOAD
, true, true, validate_signed_int_field
, validate_signed_int_field
},
562 { "arrfield1", FIELD_TYPE_PAYLOAD
, true, true, validate_array_unsigned_int_field
, validate_array_unsigned_int_field
},
563 { "arrfield2", FIELD_TYPE_PAYLOAD
, true, true, validate_string_test
, validate_string_test
},
564 { "arrfield3", FIELD_TYPE_PAYLOAD
, true, true, validate_array_unsigned_int_field
, validate_array_unsigned_int_field
},
565 { "seqfield1", FIELD_TYPE_PAYLOAD
, true, true, validate_seqfield1
, validate_seqfield1
},
566 { "seqfield2", FIELD_TYPE_PAYLOAD
, true, true, validate_string_test
, validate_string_test
},
567 { "seqfield3", FIELD_TYPE_PAYLOAD
, true, true, validate_array_unsigned_int_field
, validate_array_unsigned_int_field
},
568 { "seqfield4", FIELD_TYPE_PAYLOAD
, true, true, validate_array_unsigned_int_field
, validate_array_unsigned_int_field
},
569 { "arrfield1[1]", FIELD_TYPE_ARRAY_FIELD
, true, true, validate_array_unsigned_int_field_at_index
, validate_array_unsigned_int_field_at_index
},
570 { "stringfield", FIELD_TYPE_PAYLOAD
, true, true, validate_string_test
, validate_string_test
},
571 { "stringfield2", FIELD_TYPE_PAYLOAD
, true, true, validate_string_escaped
, validate_string_escaped
},
572 { "floatfield", FIELD_TYPE_PAYLOAD
, true, false, validate_floatfield
, validate_floatfield
},
573 { "doublefield", FIELD_TYPE_PAYLOAD
, true, false, validate_doublefield
, validate_doublefield
},
574 { "enum0", FIELD_TYPE_PAYLOAD
, true, true, validate_enum0
, validate_enum0
},
575 { "enumnegative", FIELD_TYPE_PAYLOAD
, true, true, validate_enumnegative
, validate_enumnegative
},
576 { "$ctx.procname", FIELD_TYPE_CONTEXT
, true, true, validate_context_procname_ust
, validate_context_procname_kernel
},
579 static const char *get_notification_trigger_name(
580 struct lttng_notification
*notification
)
582 const char *trigger_name
= NULL
;
583 enum lttng_trigger_status trigger_status
;
584 const struct lttng_trigger
*trigger
;
586 trigger
= lttng_notification_get_trigger(notification
);
588 fail("Failed to get trigger from notification");
592 trigger_status
= lttng_trigger_get_name(trigger
, &trigger_name
);
593 switch (trigger_status
) {
594 case LTTNG_TRIGGER_STATUS_OK
:
596 case LTTNG_TRIGGER_STATUS_UNSET
:
597 trigger_name
= "(anonymous)";
600 fail("Failed to get name from notification's trigger");
608 static int validator_notification_trigger_name(
609 struct lttng_notification
*notification
,
610 const char *trigger_name
)
616 LTTNG_ASSERT(notification
);
617 LTTNG_ASSERT(trigger_name
);
619 name
= get_notification_trigger_name(notification
);
625 name_is_equal
= (strcmp(trigger_name
, name
) == 0);
626 ok(name_is_equal
, "Expected trigger name: %s got %s", trigger_name
,
629 ret
= !name_is_equal
;
636 void wait_on_file(const char *path
, bool file_exist
)
645 ret
= stat(path
, &buf
);
646 if (ret
== -1 && errno
== ENOENT
) {
649 * The file does not exist. wait a bit and
650 * continue looping until it does.
652 (void) poll(NULL
, 0, 10);
657 * File does not exist and the exit condition we want.
658 * Break from the loop and return.
667 * stat() returned 0, so the file exists. break now only if
668 * that's the exit condition we want.
677 int write_pipe(const char *path
, uint8_t data
)
682 fd
= open(path
, O_WRONLY
| O_NONBLOCK
);
684 perror("Could not open consumer control named pipe");
688 ret
= write(fd
, &data
, sizeof(data
));
690 perror("Named pipe write failed");
692 perror("Named pipe close failed");
700 perror("Name pipe closing failed");
709 int stop_consumer(const char **argv
)
713 for (i
= named_pipe_args_start
; i
< nb_args
; i
++) {
714 ret
= write_pipe(argv
[i
], 49);
720 int resume_consumer(const char **argv
)
724 for (i
= named_pipe_args_start
; i
< nb_args
; i
++) {
725 ret
= write_pipe(argv
[i
], 0);
731 int suspend_application(void)
736 if (!stat(app_state_file
, &buf
)) {
737 fail("App is already in a suspended state.");
743 * Send SIGUSR1 to application instructing it to bypass tracepoint.
745 LTTNG_ASSERT(app_pid
> 1);
747 ret
= kill(app_pid
, SIGUSR1
);
749 fail("SIGUSR1 failed. errno %d", errno
);
754 wait_on_file(app_state_file
, true);
762 int resume_application(void)
767 ret
= stat(app_state_file
, &buf
);
768 if (ret
== -1 && errno
== ENOENT
) {
769 fail("State file does not exist");
777 LTTNG_ASSERT(app_pid
> 1);
779 ret
= kill(app_pid
, SIGUSR1
);
781 fail("SIGUSR1 failed. errno %d", errno
);
786 wait_on_file(app_state_file
, false);
795 void test_triggers_buffer_usage_condition(const char *session_name
,
796 const char *channel_name
,
797 enum lttng_domain_type domain_type
,
798 enum lttng_condition_type condition_type
)
800 unsigned int test_vector_size
= 5, i
;
801 enum lttng_condition_status condition_status
;
802 struct lttng_action
*action
;
805 action
= lttng_action_notify_create();
807 fail("Setup error on action creation");
811 /* Test lttng_register_trigger with null value */
812 ok(lttng_register_trigger(NULL
) == -LTTNG_ERR_INVALID
, "Registering a NULL trigger fails as expected");
814 /* Test: register a trigger */
816 for (i
= 0; i
< pow(2,test_vector_size
); i
++) {
818 char *test_tuple_string
= NULL
;
819 unsigned int mask_position
= 0;
820 bool session_name_set
= false;
821 bool channel_name_set
= false;
822 bool threshold_ratio_set
= false;
823 bool threshold_byte_set
= false;
824 bool domain_type_set
= false;
826 struct lttng_trigger
*trigger
= NULL
;
827 struct lttng_condition
*condition
= NULL
;
829 /* Create base condition */
830 switch (condition_type
) {
831 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW
:
832 condition
= lttng_condition_buffer_usage_low_create();
834 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH
:
835 condition
= lttng_condition_buffer_usage_high_create();
848 /* Prepare the condition for trigger registration test */
850 /* Set session name */
851 if ((1 << mask_position
) & i
) {
852 condition_status
= lttng_condition_buffer_usage_set_session_name(
853 condition
, session_name
);
854 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
858 session_name_set
= true;
862 /* Set channel name */
863 if ((1 << mask_position
) & i
) {
864 condition_status
= lttng_condition_buffer_usage_set_channel_name(
865 condition
, channel_name
);
866 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
870 channel_name_set
= true;
874 /* Set threshold ratio */
875 if ((1 << mask_position
) & i
) {
876 condition_status
= lttng_condition_buffer_usage_set_threshold_ratio(
878 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
882 threshold_ratio_set
= true;
886 /* Set threshold byte */
887 if ((1 << mask_position
) & i
) {
888 condition_status
= lttng_condition_buffer_usage_set_threshold(
890 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
894 threshold_byte_set
= true;
898 /* Set domain type */
899 if ((1 << mask_position
) & i
) {
900 condition_status
= lttng_condition_buffer_usage_set_domain_type(
901 condition
, LTTNG_DOMAIN_UST
);
902 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
906 domain_type_set
= true;
910 if (mask_position
!= test_vector_size
-1) {
911 LTTNG_ASSERT("Logic error for test vector generation");
914 loop_ret
= asprintf(&test_tuple_string
, "session name %s, channel name %s, threshold ratio %s, threshold byte %s, domain type %s",
915 session_name_set
? "set" : "unset",
916 channel_name_set
? "set" : "unset",
917 threshold_ratio_set
? "set" : "unset",
918 threshold_byte_set
? "set" : "unset",
919 domain_type_set
? "set" : "unset");
920 if (!test_tuple_string
|| loop_ret
< 0) {
926 trigger
= lttng_trigger_create(condition
, action
);
932 loop_ret
= lttng_register_trigger(trigger
);
936 fail("Setup error occurred for tuple: %s", test_tuple_string
);
940 /* This combination happens three times */
941 if (session_name_set
&& channel_name_set
942 && (threshold_ratio_set
|| threshold_byte_set
)
943 && domain_type_set
) {
944 ok(loop_ret
== 0, "Trigger is registered: %s", test_tuple_string
);
947 * Test that a trigger cannot be registered
950 loop_ret
= lttng_register_trigger(trigger
);
951 ok(loop_ret
== -LTTNG_ERR_TRIGGER_EXISTS
, "Re-register trigger fails as expected: %s", test_tuple_string
);
953 /* Test that a trigger can be unregistered */
954 loop_ret
= lttng_unregister_trigger(trigger
);
955 ok(loop_ret
== 0, "Unregister trigger: %s", test_tuple_string
);
958 * Test that unregistration of a non-previously
959 * registered trigger fail.
961 loop_ret
= lttng_unregister_trigger(trigger
);
962 ok(loop_ret
== -LTTNG_ERR_TRIGGER_NOT_FOUND
, "Unregister of a non-registered trigger fails as expected: %s", test_tuple_string
);
964 ok(loop_ret
== -LTTNG_ERR_INVALID_TRIGGER
, "Trigger is invalid as expected and cannot be registered: %s", test_tuple_string
);
968 free(test_tuple_string
);
969 lttng_trigger_destroy(trigger
);
970 lttng_condition_destroy(condition
);
974 lttng_action_destroy(action
);
978 void wait_data_pending(const char *session_name
)
983 ret
= lttng_data_pending(session_name
);
984 LTTNG_ASSERT(ret
>= 0);
989 int setup_buffer_usage_condition(struct lttng_condition
*condition
,
990 const char *condition_name
,
991 const char *session_name
,
992 const char *channel_name
,
993 const enum lttng_domain_type domain_type
)
995 enum lttng_condition_status condition_status
;
998 condition_status
= lttng_condition_buffer_usage_set_session_name(
999 condition
, session_name
);
1000 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
1001 fail("Failed to set session name on creation of condition `%s`",
1007 condition_status
= lttng_condition_buffer_usage_set_channel_name(
1008 condition
, channel_name
);
1009 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
1010 fail("Failed to set channel name on creation of condition `%s`",
1016 condition_status
= lttng_condition_buffer_usage_set_domain_type(
1017 condition
, domain_type
);
1018 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
1019 fail("Failed to set domain type on creation of condition `%s`",
1030 void test_invalid_channel_subscription(
1031 const enum lttng_domain_type domain_type
)
1033 enum lttng_condition_status condition_status
;
1034 enum lttng_notification_channel_status nc_status
;
1035 struct lttng_condition
*dummy_condition
= NULL
;
1036 struct lttng_condition
*dummy_invalid_condition
= NULL
;
1037 struct lttng_notification_channel
*notification_channel
= NULL
;
1040 notification_channel
= lttng_notification_channel_create(
1041 lttng_session_daemon_notification_endpoint
);
1042 ok(notification_channel
, "Notification channel object creation");
1043 if (!notification_channel
) {
1048 * Create a dummy, empty (thus invalid) condition to test error paths.
1050 dummy_invalid_condition
= lttng_condition_buffer_usage_low_create();
1051 if (!dummy_invalid_condition
) {
1052 fail("Setup error on condition creation");
1057 * Test subscription and unsubscription of an invalid condition to/from
1060 nc_status
= lttng_notification_channel_subscribe(
1061 notification_channel
, dummy_invalid_condition
);
1062 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID
,
1063 "Subscribing to an invalid condition");
1065 nc_status
= lttng_notification_channel_unsubscribe(
1066 notification_channel
, dummy_invalid_condition
);
1067 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID
,
1068 "Unsubscribing from an invalid condition");
1070 /* Create a valid dummy condition with a ratio of 0.5 */
1071 dummy_condition
= lttng_condition_buffer_usage_low_create();
1072 if (!dummy_condition
) {
1073 fail("Setup error on dummy_condition creation");
1077 condition_status
= lttng_condition_buffer_usage_set_threshold_ratio(
1078 dummy_condition
, 0.5);
1079 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
1080 fail("Setup error on condition creation");
1084 ret
= setup_buffer_usage_condition(dummy_condition
, "dummy_condition",
1085 "dummy_session", "dummy_channel", domain_type
);
1087 fail("Setup error on dummy condition creation");
1092 * Test subscription and unsubscription to/from a channel with invalid
1095 nc_status
= lttng_notification_channel_subscribe(NULL
, NULL
);
1096 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID
,
1097 "Notification channel subscription is invalid: NULL, NULL");
1099 nc_status
= lttng_notification_channel_subscribe(
1100 notification_channel
, NULL
);
1101 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID
,
1102 "Notification channel subscription is invalid: NON-NULL, NULL");
1104 nc_status
= lttng_notification_channel_subscribe(NULL
, dummy_condition
);
1105 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID
,
1106 "Notification channel subscription is invalid: NULL, NON-NULL");
1108 nc_status
= lttng_notification_channel_unsubscribe(
1109 notification_channel
, dummy_condition
);
1110 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_UNKNOWN_CONDITION
,
1111 "Unsubscribing from a valid unknown condition");
1114 lttng_notification_channel_destroy(notification_channel
);
1115 lttng_condition_destroy(dummy_invalid_condition
);
1116 lttng_condition_destroy(dummy_condition
);
1120 enum buffer_usage_type
{
1121 BUFFER_USAGE_TYPE_LOW
,
1122 BUFFER_USAGE_TYPE_HIGH
,
1125 static int register_buffer_usage_notify_trigger(const char *session_name
,
1126 const char *channel_name
,
1127 const enum lttng_domain_type domain_type
,
1128 enum buffer_usage_type buffer_usage_type
,
1130 struct lttng_condition
**condition
,
1131 struct lttng_action
**action
,
1132 struct lttng_trigger
**trigger
)
1134 enum lttng_condition_status condition_status
;
1135 struct lttng_action
*tmp_action
= NULL
;
1136 struct lttng_condition
*tmp_condition
= NULL
;
1137 struct lttng_trigger
*tmp_trigger
= NULL
;
1141 tmp_action
= lttng_action_notify_create();
1143 fail("Setup error on action creation");
1148 if (buffer_usage_type
== BUFFER_USAGE_TYPE_LOW
) {
1149 tmp_condition
= lttng_condition_buffer_usage_low_create();
1151 tmp_condition
= lttng_condition_buffer_usage_high_create();
1154 if (!tmp_condition
) {
1155 fail("Setup error on condition creation");
1160 /* Set the buffer usage threashold */
1161 condition_status
= lttng_condition_buffer_usage_set_threshold_ratio(
1162 tmp_condition
, ratio
);
1163 if (condition_status
!= LTTNG_CONDITION_STATUS_OK
) {
1164 fail("Setup error on condition creation");
1169 ret
= setup_buffer_usage_condition(tmp_condition
, "condition_name",
1170 session_name
, channel_name
, domain_type
);
1172 fail("Setup error on condition creation");
1177 /* Register the trigger for condition. */
1178 tmp_trigger
= lttng_trigger_create(tmp_condition
, tmp_action
);
1180 fail("Setup error on trigger creation");
1185 ret
= lttng_register_trigger(tmp_trigger
);
1187 fail("Setup error on trigger registration");
1192 *condition
= tmp_condition
;
1193 *trigger
= tmp_trigger
;
1194 *action
= tmp_action
;
1198 lttng_action_destroy(tmp_action
);
1199 lttng_condition_destroy(tmp_condition
);
1200 lttng_trigger_destroy(tmp_trigger
);
1206 static void test_subscription_twice(const char *session_name
,
1207 const char *channel_name
,
1208 const enum lttng_domain_type domain_type
)
1211 enum lttng_notification_channel_status nc_status
;
1213 struct lttng_action
*action
= NULL
;
1214 struct lttng_notification_channel
*notification_channel
= NULL
;
1215 struct lttng_trigger
*trigger
= NULL
;
1217 struct lttng_condition
*condition
= NULL
;
1219 ret
= register_buffer_usage_notify_trigger(session_name
, channel_name
,
1220 domain_type
, BUFFER_USAGE_TYPE_LOW
, 0.99, &condition
,
1223 fail("Setup error on trigger registration in %s()",
1228 /* Begin testing. */
1229 notification_channel
= lttng_notification_channel_create(
1230 lttng_session_daemon_notification_endpoint
);
1231 ok(notification_channel
, "Notification channel object creation");
1232 if (!notification_channel
) {
1236 /* Subscribe a valid condition. */
1237 nc_status
= lttng_notification_channel_subscribe(
1238 notification_channel
, condition
);
1239 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
1240 "Subscribe to condition");
1242 /* Subscribing again should fail. */
1243 nc_status
= lttng_notification_channel_subscribe(
1244 notification_channel
, condition
);
1245 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_ALREADY_SUBSCRIBED
,
1246 "Subscribe to a condition for which subscription was already done");
1249 ret
= lttng_unregister_trigger(trigger
);
1251 fail("Failed to unregister trigger in %s()", __FUNCTION__
);
1254 lttng_trigger_destroy(trigger
);
1255 lttng_notification_channel_destroy(notification_channel
);
1256 lttng_action_destroy(action
);
1257 lttng_condition_destroy(condition
);
1260 static void test_buffer_usage_notification_channel(const char *session_name
,
1261 const char *channel_name
,
1262 const enum lttng_domain_type domain_type
,
1266 enum lttng_notification_channel_status nc_status
;
1268 struct lttng_action
*low_action
= NULL
;
1269 struct lttng_action
*high_action
= NULL
;
1270 struct lttng_notification
*notification
= NULL
;
1271 struct lttng_notification_channel
*notification_channel
= NULL
;
1272 struct lttng_trigger
*low_trigger
= NULL
;
1273 struct lttng_trigger
*high_trigger
= NULL
;
1275 struct lttng_condition
*low_condition
= NULL
;
1276 struct lttng_condition
*high_condition
= NULL
;
1278 const double low_ratio
= 0.0;
1279 const double high_ratio
= 0.90;
1281 ret
= register_buffer_usage_notify_trigger(session_name
, channel_name
,
1282 domain_type
, BUFFER_USAGE_TYPE_LOW
, low_ratio
,
1283 &low_condition
, &low_action
, &low_trigger
);
1285 fail("Setup error on low trigger registration");
1289 ret
= register_buffer_usage_notify_trigger(session_name
, channel_name
,
1290 domain_type
, BUFFER_USAGE_TYPE_HIGH
, high_ratio
,
1291 &high_condition
, &high_action
, &high_trigger
);
1293 fail("Setup error on high trigger registration");
1298 notification_channel
= lttng_notification_channel_create(
1299 lttng_session_daemon_notification_endpoint
);
1300 ok(notification_channel
, "Notification channel object creation");
1301 if (!notification_channel
) {
1305 /* Subscribe a valid low condition */
1306 nc_status
= lttng_notification_channel_subscribe(
1307 notification_channel
, low_condition
);
1308 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
1309 "Subscribe to low condition");
1311 /* Subscribe a valid high condition */
1312 nc_status
= lttng_notification_channel_subscribe(
1313 notification_channel
, high_condition
);
1314 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
1315 "Subscribe to high condition");
1317 resume_application();
1319 /* Wait for notification to happen */
1320 stop_consumer(argv
);
1321 lttng_start_tracing(session_name
);
1323 /* Wait for high notification */
1325 nc_status
= lttng_notification_channel_get_next_notification(
1326 notification_channel
, ¬ification
);
1327 } while (nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_INTERRUPTED
);
1328 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
&& notification
&&
1329 lttng_condition_get_type(lttng_notification_get_condition(
1331 LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH
,
1332 "High notification received after intermediary communication");
1333 lttng_notification_destroy(notification
);
1334 notification
= NULL
;
1336 suspend_application();
1337 lttng_stop_tracing_no_wait(session_name
);
1338 resume_consumer(argv
);
1339 wait_data_pending(session_name
);
1342 * Test that communication still work even if there is notification
1343 * waiting for consumption.
1346 nc_status
= lttng_notification_channel_unsubscribe(
1347 notification_channel
, low_condition
);
1348 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
1349 "Unsubscribe with pending notification");
1351 nc_status
= lttng_notification_channel_subscribe(
1352 notification_channel
, low_condition
);
1353 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
1354 "Subscribe with pending notification");
1357 nc_status
= lttng_notification_channel_get_next_notification(
1358 notification_channel
, ¬ification
);
1359 } while (nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_INTERRUPTED
);
1360 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
&& notification
&&
1361 lttng_condition_get_type(lttng_notification_get_condition(
1363 LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW
,
1364 "Low notification received after intermediary communication");
1365 lttng_notification_destroy(notification
);
1366 notification
= NULL
;
1368 /* Stop consumer to force a high notification */
1369 stop_consumer(argv
);
1370 resume_application();
1371 lttng_start_tracing(session_name
);
1374 nc_status
= lttng_notification_channel_get_next_notification(
1375 notification_channel
, ¬ification
);
1376 } while (nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_INTERRUPTED
);
1377 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
&& notification
&&
1378 lttng_condition_get_type(lttng_notification_get_condition(
1380 LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH
,
1381 "High notification received after intermediary communication");
1382 lttng_notification_destroy(notification
);
1383 notification
= NULL
;
1385 suspend_application();
1386 lttng_stop_tracing_no_wait(session_name
);
1387 resume_consumer(argv
);
1388 wait_data_pending(session_name
);
1391 nc_status
= lttng_notification_channel_get_next_notification(
1392 notification_channel
, ¬ification
);
1393 } while (nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_INTERRUPTED
);
1394 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
&& notification
&&
1395 lttng_condition_get_type(lttng_notification_get_condition(
1397 LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW
,
1398 "Low notification received after re-subscription");
1399 lttng_notification_destroy(notification
);
1400 notification
= NULL
;
1402 stop_consumer(argv
);
1403 resume_application();
1404 /* Stop consumer to force a high notification */
1405 lttng_start_tracing(session_name
);
1408 nc_status
= lttng_notification_channel_get_next_notification(
1409 notification_channel
, ¬ification
);
1410 } while (nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_INTERRUPTED
);
1411 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
&& notification
&&
1412 lttng_condition_get_type(lttng_notification_get_condition(
1414 LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH
,
1415 "High notification");
1416 lttng_notification_destroy(notification
);
1417 notification
= NULL
;
1419 suspend_application();
1421 /* Resume consumer to allow event consumption */
1422 lttng_stop_tracing_no_wait(session_name
);
1423 resume_consumer(argv
);
1424 wait_data_pending(session_name
);
1426 nc_status
= lttng_notification_channel_unsubscribe(
1427 notification_channel
, low_condition
);
1428 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
1429 "Unsubscribe low condition with pending notification");
1431 nc_status
= lttng_notification_channel_unsubscribe(
1432 notification_channel
, high_condition
);
1433 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
1434 "Unsubscribe high condition with pending notification");
1437 lttng_notification_channel_destroy(notification_channel
);
1438 lttng_trigger_destroy(low_trigger
);
1439 lttng_trigger_destroy(high_trigger
);
1440 lttng_action_destroy(low_action
);
1441 lttng_action_destroy(high_action
);
1442 lttng_condition_destroy(low_condition
);
1443 lttng_condition_destroy(high_condition
);
1446 static void create_tracepoint_event_rule_trigger(const char *event_pattern
,
1447 const char *trigger_name
,
1449 unsigned int exclusion_count
,
1450 const char * const *exclusions
,
1451 enum lttng_domain_type domain_type
,
1452 condition_capture_desc_cb capture_desc_cb
,
1453 struct lttng_condition
**condition
,
1454 struct lttng_trigger
**trigger
)
1456 typedef struct lttng_event_rule
*(*event_rule_create
)(void);
1457 typedef enum lttng_event_rule_status (
1458 *event_rule_set_name_pattern
)(
1459 struct lttng_event_rule
*rule
,
1460 const char *pattern
);
1461 typedef enum lttng_event_rule_status (*event_rule_set_filter
)(
1462 struct lttng_event_rule
*rule
,
1463 const char *expression
);
1464 typedef enum lttng_event_rule_status (
1465 *event_rule_add_name_pattern_exclusion
)(
1466 struct lttng_event_rule
* rule
, const char *exclusion
);
1468 enum lttng_event_rule_status event_rule_status
;
1469 struct lttng_action
*tmp_action
= NULL
;
1470 struct lttng_event_rule
*event_rule
= NULL
;
1471 struct lttng_condition
*tmp_condition
= NULL
;
1472 struct lttng_trigger
*tmp_trigger
= NULL
;
1474 enum lttng_error_code ret_code
;
1475 event_rule_create create
;
1476 event_rule_set_name_pattern set_name_pattern
;
1477 event_rule_set_filter set_filter
;
1478 event_rule_add_name_pattern_exclusion add_name_pattern_exclusion
;
1480 LTTNG_ASSERT(event_pattern
);
1481 LTTNG_ASSERT(trigger_name
);
1482 LTTNG_ASSERT(condition
);
1483 LTTNG_ASSERT(trigger
);
1485 /* Set the function pointers based on the domain type. */
1486 switch (domain_type
) {
1487 case LTTNG_DOMAIN_UST
:
1488 create
= lttng_event_rule_user_tracepoint_create
;
1489 set_name_pattern
= lttng_event_rule_user_tracepoint_set_name_pattern
;
1490 set_filter
= lttng_event_rule_user_tracepoint_set_filter
;
1491 add_name_pattern_exclusion
= lttng_event_rule_user_tracepoint_add_name_pattern_exclusion
;
1493 case LTTNG_DOMAIN_KERNEL
:
1494 create
= lttng_event_rule_kernel_tracepoint_create
;
1495 set_name_pattern
= lttng_event_rule_kernel_tracepoint_set_name_pattern
;
1496 set_filter
= lttng_event_rule_kernel_tracepoint_set_filter
;
1497 add_name_pattern_exclusion
= NULL
;
1504 event_rule
= create();
1505 ok(event_rule
, "Tracepoint event rule object creation");
1507 event_rule_status
= set_name_pattern(event_rule
, event_pattern
);
1508 ok(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
,
1509 "Setting tracepoint event rule pattern: '%s'",
1513 event_rule_status
= set_filter(event_rule
, filter
);
1514 ok(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
,
1515 "Setting tracepoint event rule filter: '%s'",
1521 bool success
= true;
1523 LTTNG_ASSERT(domain_type
== LTTNG_DOMAIN_UST
);
1524 LTTNG_ASSERT(add_name_pattern_exclusion
!= NULL
);
1525 LTTNG_ASSERT(exclusion_count
> 0);
1527 for (i
= 0; i
< exclusion_count
; i
++) {
1528 event_rule_status
= add_name_pattern_exclusion(
1529 event_rule
, exclusions
[i
]);
1530 if (event_rule_status
!= LTTNG_EVENT_RULE_STATUS_OK
) {
1531 fail("Setting tracepoint event rule exclusion '%s'.",
1537 ok(success
, "Setting tracepoint event rule exclusions");
1540 tmp_condition
= lttng_condition_event_rule_matches_create(event_rule
);
1541 ok(tmp_condition
, "Condition event rule object creation");
1543 if (capture_desc_cb
) {
1544 ret
= capture_desc_cb(tmp_condition
);
1546 fail("Failed to generate the condition capture descriptor");
1551 tmp_action
= lttng_action_notify_create();
1552 ok(tmp_action
, "Action event rule object creation");
1554 tmp_trigger
= lttng_trigger_create(tmp_condition
, tmp_action
);
1555 ok(tmp_trigger
, "Trigger object creation %s", trigger_name
);
1557 ret_code
= lttng_register_trigger_with_name(tmp_trigger
, trigger_name
);
1558 ok(ret_code
== LTTNG_OK
, "Trigger registration %s", trigger_name
);
1560 lttng_event_rule_destroy(event_rule
);
1562 *condition
= tmp_condition
;
1563 *trigger
= tmp_trigger
;
1568 static struct lttng_notification
*get_next_notification(
1569 struct lttng_notification_channel
*notification_channel
)
1571 struct lttng_notification
*local_notification
= NULL
;
1572 enum lttng_notification_channel_status status
;
1574 /* Receive the next notification. */
1575 status
= lttng_notification_channel_get_next_notification(
1576 notification_channel
, &local_notification
);
1579 case LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
:
1581 case LTTNG_NOTIFICATION_CHANNEL_STATUS_NOTIFICATIONS_DROPPED
:
1582 fail("Notifications have been dropped");
1583 local_notification
= NULL
;
1586 /* Unhandled conditions / errors. */
1587 fail("Failed to get next notification (unknown notification channel status): status = %d",
1589 local_notification
= NULL
;
1593 return local_notification
;
1596 static void test_tracepoint_event_rule_notification(
1597 enum lttng_domain_type domain_type
)
1601 const int notification_count
= 3;
1602 enum lttng_notification_channel_status nc_status
;
1603 struct lttng_action
*action
= NULL
;
1604 struct lttng_condition
*condition
= NULL
;
1605 struct lttng_notification_channel
*notification_channel
= NULL
;
1606 struct lttng_trigger
*trigger
= NULL
;
1607 const char * const trigger_name
= "my_precious";
1608 const char *pattern
;
1610 if (domain_type
== LTTNG_DOMAIN_UST
) {
1611 pattern
= "tp:tptest";
1613 pattern
= "lttng_test_filter_event";
1616 create_tracepoint_event_rule_trigger(pattern
, trigger_name
, NULL
, 0,
1617 NULL
, domain_type
, NULL
, &condition
, &trigger
);
1619 notification_channel
= lttng_notification_channel_create(
1620 lttng_session_daemon_notification_endpoint
);
1621 ok(notification_channel
, "Notification channel object creation");
1623 nc_status
= lttng_notification_channel_subscribe(
1624 notification_channel
, condition
);
1625 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
1626 "Subscribe to tracepoint event rule condition");
1628 resume_application();
1630 /* Get notifications. */
1631 for (i
= 0; i
< notification_count
; i
++) {
1632 struct lttng_notification
*notification
= get_next_notification(
1633 notification_channel
);
1635 ok(notification
, "Received notification (%d/%d)", i
+ 1,
1636 notification_count
);
1639 if (notification
== NULL
) {
1643 ret
= validator_notification_trigger_name(notification
, trigger_name
);
1644 lttng_notification_destroy(notification
);
1651 suspend_application();
1652 lttng_notification_channel_destroy(notification_channel
);
1653 lttng_unregister_trigger(trigger
);
1654 lttng_trigger_destroy(trigger
);
1655 lttng_action_destroy(action
);
1656 lttng_condition_destroy(condition
);
1660 static void test_tracepoint_event_rule_notification_filter(
1661 enum lttng_domain_type domain_type
)
1664 const int notification_count
= 3;
1665 enum lttng_notification_channel_status nc_status
;
1666 struct lttng_condition
*ctrl_condition
= NULL
, *condition
= NULL
;
1667 struct lttng_notification_channel
*notification_channel
= NULL
;
1668 struct lttng_trigger
*ctrl_trigger
= NULL
, *trigger
= NULL
;
1669 const char * const ctrl_trigger_name
= "control_trigger";
1670 const char * const trigger_name
= "trigger";
1671 const char *pattern
;
1672 int ctrl_count
= 0, count
= 0;
1674 if (domain_type
== LTTNG_DOMAIN_UST
) {
1675 pattern
= "tp:tptest";
1677 pattern
= "lttng_test_filter_event";
1680 notification_channel
= lttng_notification_channel_create(
1681 lttng_session_daemon_notification_endpoint
);
1682 ok(notification_channel
, "Notification channel object creation");
1684 create_tracepoint_event_rule_trigger(pattern
, ctrl_trigger_name
, NULL
,
1685 0, NULL
, domain_type
, NULL
, &ctrl_condition
, &ctrl_trigger
);
1687 nc_status
= lttng_notification_channel_subscribe(
1688 notification_channel
, ctrl_condition
);
1689 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
1690 "Subscribe to tracepoint event rule condition");
1693 * Attach a filter expression to get notification only if the
1694 * `intfield` is even.
1696 create_tracepoint_event_rule_trigger(pattern
, trigger_name
,
1697 "(intfield & 1) == 0", 0, NULL
, domain_type
, NULL
, &condition
,
1700 nc_status
= lttng_notification_channel_subscribe(
1701 notification_channel
, condition
);
1702 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
1703 "Subscribe to tracepoint event rule condition");
1706 * We registered 2 notifications triggers, one with a filter and one
1707 * without (control). The one with a filter will only fired when the
1708 * `intfield` is a multiple of 2. We should get two times as many
1709 * control notifications as filter notifications.
1711 resume_application();
1714 * Get 3 notifications. We should get 1 for the regular trigger (with
1715 * the filter) and 2 from the control trigger. This works whatever
1716 * the order we receive the notifications.
1718 for (i
= 0; i
< notification_count
; i
++) {
1720 struct lttng_notification
*notification
= get_next_notification(
1721 notification_channel
);
1723 ok(notification
, "Received notification (%d/%d)", i
+ 1,
1724 notification_count
);
1727 if (notification
== NULL
) {
1731 name
= get_notification_trigger_name(notification
);
1733 lttng_notification_destroy(notification
);
1737 if (strcmp(ctrl_trigger_name
, name
) == 0) {
1739 } else if (strcmp(trigger_name
, name
) == 0) {
1743 lttng_notification_destroy(notification
);
1746 ok(ctrl_count
/ 2 == count
,
1747 "Get twice as many control notif as of regular notif");
1750 suspend_application();
1752 lttng_unregister_trigger(trigger
);
1753 lttng_unregister_trigger(ctrl_trigger
);
1754 lttng_notification_channel_destroy(notification_channel
);
1755 lttng_trigger_destroy(trigger
);
1756 lttng_trigger_destroy(ctrl_trigger
);
1757 lttng_condition_destroy(condition
);
1758 lttng_condition_destroy(ctrl_condition
);
1761 static void test_tracepoint_event_rule_notification_exclusion(
1762 enum lttng_domain_type domain_type
)
1764 enum lttng_notification_channel_status nc_status
;
1765 struct lttng_condition
*ctrl_condition
= NULL
, *condition
= NULL
;
1766 struct lttng_notification_channel
*notification_channel
= NULL
;
1767 struct lttng_trigger
*ctrl_trigger
= NULL
, *trigger
= NULL
;
1768 int ctrl_count
= 0, count
= 0, i
;
1769 const int notification_count
= 6;
1770 const char * const ctrl_trigger_name
= "control_exclusion_trigger";
1771 const char * const trigger_name
= "exclusion_trigger";
1772 const char * const pattern
= "tp:tptest*";
1773 const char * const exclusions
[] = {
1780 notification_channel
= lttng_notification_channel_create(
1781 lttng_session_daemon_notification_endpoint
);
1782 ok(notification_channel
, "Notification channel object creation");
1784 create_tracepoint_event_rule_trigger(pattern
, ctrl_trigger_name
, NULL
,
1785 0, NULL
, domain_type
, NULL
, &ctrl_condition
,
1788 nc_status
= lttng_notification_channel_subscribe(
1789 notification_channel
, ctrl_condition
);
1790 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
1791 "Subscribe to tracepoint event rule condition");
1793 create_tracepoint_event_rule_trigger(pattern
, trigger_name
, NULL
, 4,
1794 exclusions
, domain_type
, NULL
, &condition
,
1797 nc_status
= lttng_notification_channel_subscribe(
1798 notification_channel
, condition
);
1799 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
1800 "Subscribe to tracepoint event rule condition");
1803 * We registered 2 notifications triggers, one with an exclusion and
1804 * one without (control).
1805 * - The trigger with an exclusion will fire once every iteration.
1806 * - The trigger without an exclusion will fire 5 times every
1809 * We should get 5 times as many notifications from the control
1812 resume_application();
1815 * Get 6 notifications. We should get 1 for the regular trigger (with
1816 * the exclusion) and 5 from the control trigger. This works whatever
1817 * the order we receive the notifications.
1819 for (i
= 0; i
< notification_count
; i
++) {
1821 struct lttng_notification
*notification
= get_next_notification(
1822 notification_channel
);
1824 ok(notification
, "Received notification (%d/%d)", i
+ 1,
1825 notification_count
);
1828 if (notification
== NULL
) {
1832 name
= get_notification_trigger_name(notification
);
1834 lttng_notification_destroy(notification
);
1838 if (strcmp(ctrl_trigger_name
, name
) == 0) {
1840 } else if (strcmp(trigger_name
, name
) == 0) {
1844 lttng_notification_destroy(notification
);
1847 ok(ctrl_count
/ 5 == count
,
1848 "Got 5 times as many control notif as of regular notif");
1851 suspend_application();
1853 lttng_unregister_trigger(trigger
);
1854 lttng_unregister_trigger(ctrl_trigger
);
1855 lttng_notification_channel_destroy(notification_channel
);
1856 lttng_trigger_destroy(trigger
);
1857 lttng_trigger_destroy(ctrl_trigger
);
1858 lttng_condition_destroy(condition
);
1859 lttng_condition_destroy(ctrl_condition
);
1863 static void test_kprobe_event_rule_notification(
1864 enum lttng_domain_type domain_type
)
1867 enum lttng_error_code ret_code
;
1868 const int notification_count
= 3;
1869 enum lttng_notification_channel_status nc_status
;
1870 enum lttng_event_rule_status event_rule_status
;
1871 struct lttng_notification_channel
*notification_channel
= NULL
;
1872 struct lttng_condition
*condition
= NULL
;
1873 struct lttng_kernel_probe_location
*location
= NULL
;
1874 struct lttng_event_rule
*event_rule
= NULL
;
1875 struct lttng_action
*action
= NULL
;
1876 struct lttng_trigger
*trigger
= NULL
;
1877 const char * const trigger_name
= "kprobe_trigger";
1878 const char * const symbol_name
= "lttng_test_filter_event_write";
1880 action
= lttng_action_notify_create();
1882 fail("Failed to create notify action");
1886 location
= lttng_kernel_probe_location_symbol_create(symbol_name
, 0);
1888 fail("Failed to create kernel probe location");
1892 notification_channel
= lttng_notification_channel_create(
1893 lttng_session_daemon_notification_endpoint
);
1894 ok(notification_channel
, "Notification channel object creation");
1896 event_rule
= lttng_event_rule_kernel_kprobe_create(location
);
1897 ok(event_rule
, "kprobe event rule object creation");
1899 event_rule_status
= lttng_event_rule_kernel_kprobe_set_event_name(
1900 event_rule
, trigger_name
);
1901 ok(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
,
1902 "Setting kprobe event rule name: '%s'", trigger_name
);
1904 condition
= lttng_condition_event_rule_matches_create(event_rule
);
1905 ok(condition
, "Condition event rule object creation");
1907 /* Register the trigger for condition. */
1908 trigger
= lttng_trigger_create(condition
, action
);
1910 fail("Failed to create trigger with kernel probe event rule condition and notify action");
1914 ret_code
= lttng_register_trigger_with_name(trigger
, trigger_name
);
1915 if (ret_code
!= LTTNG_OK
) {
1916 fail("Failed to register trigger with kernel probe event rule condition and notify action");
1920 nc_status
= lttng_notification_channel_subscribe(
1921 notification_channel
, condition
);
1922 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
1923 "Subscribe to tracepoint event rule condition");
1925 resume_application();
1927 for (i
= 0; i
< notification_count
; i
++) {
1928 struct lttng_notification
*notification
= get_next_notification(
1929 notification_channel
);
1931 ok(notification
, "Received notification (%d/%d)", i
+ 1,
1932 notification_count
);
1935 if (notification
== NULL
) {
1939 ret
= validator_notification_trigger_name(notification
, trigger_name
);
1940 lttng_notification_destroy(notification
);
1947 suspend_application();
1948 lttng_notification_channel_destroy(notification_channel
);
1949 lttng_unregister_trigger(trigger
);
1950 lttng_trigger_destroy(trigger
);
1951 lttng_action_destroy(action
);
1952 lttng_event_rule_destroy(event_rule
);
1953 lttng_condition_destroy(condition
);
1954 lttng_kernel_probe_location_destroy(location
);
1958 static void test_uprobe_event_rule_notification(
1959 enum lttng_domain_type domain_type
,
1960 const char *testapp_path
,
1961 const char *test_symbol_name
)
1964 enum lttng_error_code ret_code
;
1965 const int notification_count
= 3;
1966 enum lttng_notification_channel_status nc_status
;
1967 enum lttng_event_rule_status event_rule_status
;
1968 struct lttng_notification_channel
*notification_channel
= NULL
;
1969 struct lttng_userspace_probe_location
*probe_location
= NULL
;
1970 struct lttng_userspace_probe_location_lookup_method
*lookup_method
=
1972 struct lttng_condition
*condition
= NULL
;
1973 struct lttng_event_rule
*event_rule
= NULL
;
1974 struct lttng_action
*action
= NULL
;
1975 struct lttng_trigger
*trigger
= NULL
;
1976 const char * const trigger_name
= "uprobe_trigger";
1978 action
= lttng_action_notify_create();
1980 fail("Failed to create notify action");
1984 lookup_method
= lttng_userspace_probe_location_lookup_method_function_elf_create();
1985 if (!lookup_method
) {
1986 fail("Setup error on userspace probe lookup method creation");
1990 probe_location
= lttng_userspace_probe_location_function_create(
1991 testapp_path
, test_symbol_name
, lookup_method
);
1992 if (!probe_location
) {
1993 fail("Failed to create userspace probe location");
1997 notification_channel
= lttng_notification_channel_create(
1998 lttng_session_daemon_notification_endpoint
);
1999 ok(notification_channel
, "Notification channel object creation");
2001 event_rule
= lttng_event_rule_kernel_uprobe_create(probe_location
);
2002 ok(event_rule
, "kprobe event rule object creation");
2004 event_rule_status
= lttng_event_rule_kernel_uprobe_set_event_name(
2005 event_rule
, trigger_name
);
2006 ok(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
,
2007 "Setting uprobe event rule name: '%s'", trigger_name
);
2009 condition
= lttng_condition_event_rule_matches_create(event_rule
);
2010 ok(condition
, "Condition event rule object creation");
2012 /* Register the trigger for condition. */
2013 trigger
= lttng_trigger_create(condition
, action
);
2015 fail("Failed to create trigger with userspace probe event rule condition and notify action");
2019 ret_code
= lttng_register_trigger_with_name(trigger
, trigger_name
);
2020 if (ret_code
!= LTTNG_OK
) {
2021 fail("Failed to register trigger with userspace probe event rule condition and notify action");
2025 nc_status
= lttng_notification_channel_subscribe(
2026 notification_channel
, condition
);
2027 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
2028 "Subscribe to tracepoint event rule condition");
2030 resume_application();
2032 for (i
= 0; i
< 3; i
++) {
2033 struct lttng_notification
*notification
= get_next_notification(
2034 notification_channel
);
2036 ok(notification
, "Received notification (%d/%d)", i
+ 1,
2037 notification_count
);
2040 if (notification
== NULL
) {
2044 ret
= validator_notification_trigger_name(notification
, trigger_name
);
2045 lttng_notification_destroy(notification
);
2051 suspend_application();
2053 lttng_notification_channel_destroy(notification_channel
);
2054 lttng_unregister_trigger(trigger
);
2055 lttng_trigger_destroy(trigger
);
2056 lttng_action_destroy(action
);
2057 lttng_userspace_probe_location_destroy(probe_location
);
2058 lttng_event_rule_destroy(event_rule
);
2059 lttng_condition_destroy(condition
);
2063 static void test_syscall_event_rule_notification(
2064 enum lttng_domain_type domain_type
)
2067 enum lttng_error_code ret_code
;
2068 const int notification_count
= 3;
2069 enum lttng_notification_channel_status nc_status
;
2070 enum lttng_event_rule_status event_rule_status
;
2071 struct lttng_notification_channel
*notification_channel
= NULL
;
2072 struct lttng_condition
*condition
= NULL
;
2073 struct lttng_event_rule
*event_rule
= NULL
;
2074 struct lttng_action
*action
= NULL
;
2075 struct lttng_trigger
*trigger
= NULL
;
2076 const char * const trigger_name
= "syscall_trigger";
2077 const char * const syscall_name
= "openat";
2079 action
= lttng_action_notify_create();
2081 fail("Failed to create notify action");
2085 notification_channel
= lttng_notification_channel_create(
2086 lttng_session_daemon_notification_endpoint
);
2087 ok(notification_channel
, "Notification channel object creation");
2089 event_rule
= lttng_event_rule_kernel_syscall_create(LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY
);
2090 ok(event_rule
, "syscall event rule object creation");
2092 event_rule_status
= lttng_event_rule_kernel_syscall_set_name_pattern(
2093 event_rule
, syscall_name
);
2094 ok(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
,
2095 "Setting syscall event rule pattern: '%s'", syscall_name
);
2097 condition
= lttng_condition_event_rule_matches_create(event_rule
);
2098 ok(condition
, "Condition syscall event rule object creation");
2100 /* Register the trigger for condition. */
2101 trigger
= lttng_trigger_create(condition
, action
);
2103 fail("Failed to create trigger with syscall event rule condition and notify action");
2107 ret_code
= lttng_register_trigger_with_name(trigger
, trigger_name
);
2108 if (ret_code
!= LTTNG_OK
) {
2109 fail("Failed to register trigger with syscall event rule condition and notify action");
2113 nc_status
= lttng_notification_channel_subscribe(
2114 notification_channel
, condition
);
2115 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
2116 "Subscribe to tracepoint event rule condition");
2118 resume_application();
2120 for (i
= 0; i
< notification_count
; i
++) {
2121 struct lttng_notification
*notification
= get_next_notification(
2122 notification_channel
);
2124 ok(notification
, "Received notification (%d/%d)", i
+ 1,
2125 notification_count
);
2128 if (notification
== NULL
) {
2132 ret
= validator_notification_trigger_name(notification
, trigger_name
);
2133 lttng_notification_destroy(notification
);
2139 suspend_application();
2140 lttng_notification_channel_destroy(notification_channel
);
2141 lttng_unregister_trigger(trigger
);
2142 lttng_trigger_destroy(trigger
);
2143 lttng_action_destroy(action
);
2144 lttng_condition_destroy(condition
);
2148 static void test_syscall_event_rule_notification_filter(
2149 enum lttng_domain_type domain_type
)
2152 enum lttng_error_code ret_code
;
2153 const int notification_count
= 3;
2154 enum lttng_notification_channel_status nc_status
;
2155 enum lttng_event_rule_status event_rule_status
;
2156 struct lttng_notification_channel
*notification_channel
= NULL
;
2157 struct lttng_condition
*condition
= NULL
;
2158 struct lttng_event_rule
*event_rule
= NULL
;
2159 struct lttng_action
*action
= NULL
;
2160 struct lttng_trigger
*trigger
= NULL
;
2161 const char * const trigger_name
= "syscall_trigger";
2162 const char * const syscall_name
= "openat";
2163 const char * const filter_pattern
= "filename == \"/proc/cpuinfo\"";
2165 action
= lttng_action_notify_create();
2167 fail("Failed to create notify action");
2171 notification_channel
= lttng_notification_channel_create(
2172 lttng_session_daemon_notification_endpoint
);
2173 ok(notification_channel
, "Notification channel object creation");
2175 event_rule
= lttng_event_rule_kernel_syscall_create(LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY
);
2176 ok(event_rule
, "syscall event rule object creation");
2178 event_rule_status
= lttng_event_rule_kernel_syscall_set_name_pattern(
2179 event_rule
, syscall_name
);
2180 ok(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
,
2181 "Setting syscall event rule pattern: '%s'", syscall_name
);
2183 event_rule_status
= lttng_event_rule_kernel_syscall_set_filter(
2184 event_rule
, filter_pattern
);
2185 ok(event_rule_status
== LTTNG_EVENT_RULE_STATUS_OK
,
2186 "Setting filter: '%s'", filter_pattern
);
2188 condition
= lttng_condition_event_rule_matches_create(event_rule
);
2189 ok(condition
, "Condition event rule object creation");
2191 /* Register the triggers for condition */
2192 trigger
= lttng_trigger_create(condition
, action
);
2194 fail("Failed to create trigger with syscall filtering event rule condition and notify action");
2198 ret_code
= lttng_register_trigger_with_name(trigger
, trigger_name
);
2199 if (ret_code
!= LTTNG_OK
) {
2200 fail("Failed to register trigger with syscall filtering event rule condition and notify action");
2204 nc_status
= lttng_notification_channel_subscribe(
2205 notification_channel
, condition
);
2206 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
2207 "Subscribe to tracepoint event rule condition");
2209 resume_application();
2211 for (i
= 0; i
< notification_count
; i
++) {
2212 struct lttng_notification
*notification
= get_next_notification(
2213 notification_channel
);
2215 ok(notification
, "Received notification (%d/%d)", i
+ 1,
2216 notification_count
);
2219 if (notification
== NULL
) {
2223 ret
= validator_notification_trigger_name(notification
, trigger_name
);
2224 lttng_notification_destroy(notification
);
2231 suspend_application();
2233 lttng_unregister_trigger(trigger
);
2234 lttng_notification_channel_destroy(notification_channel
);
2235 lttng_trigger_destroy(trigger
);
2236 lttng_event_rule_destroy(event_rule
);
2237 lttng_condition_destroy(condition
);
2241 static int generate_capture_descr(struct lttng_condition
*condition
)
2244 struct lttng_event_expr
*expr
= NULL
;
2245 const unsigned int basic_field_count
= sizeof(test_capture_base_fields
) /
2246 sizeof(*test_capture_base_fields
);
2247 enum lttng_condition_status cond_status
;
2249 for (i
= 0; i
< basic_field_count
; i
++) {
2250 diag("Adding capture descriptor '%s'",
2251 test_capture_base_fields
[i
].field_name
);
2253 switch (test_capture_base_fields
[i
].field_type
) {
2254 case FIELD_TYPE_PAYLOAD
:
2255 expr
= lttng_event_expr_event_payload_field_create(
2256 test_capture_base_fields
[i
].field_name
);
2258 case FIELD_TYPE_CONTEXT
:
2259 expr
= lttng_event_expr_channel_context_field_create(
2260 test_capture_base_fields
[i
].field_name
);
2262 case FIELD_TYPE_ARRAY_FIELD
:
2266 char field_name
[FIELD_NAME_MAX_LEN
];
2267 struct lttng_event_expr
*array_expr
= NULL
;
2269 nb_matches
= sscanf(test_capture_base_fields
[i
].field_name
,
2270 "%[^[][%u]", field_name
, &index
);
2271 if (nb_matches
!= 2) {
2272 fail("Unexpected array field name format: field name = '%s'",
2273 test_capture_base_fields
[i
].field_name
);
2278 array_expr
= lttng_event_expr_event_payload_field_create(
2281 expr
= lttng_event_expr_array_field_element_create(
2285 case FIELD_TYPE_APP_CONTEXT
:
2286 fail("Application context tests are not implemented yet.");
2294 fail("Failed to create capture expression");
2299 cond_status
= lttng_condition_event_rule_matches_append_capture_descriptor(
2301 if (cond_status
!= LTTNG_CONDITION_STATUS_OK
) {
2302 fail("Failed to append capture descriptor");
2304 lttng_event_expr_destroy(expr
);
2315 static int validator_notification_trigger_capture(
2316 enum lttng_domain_type domain
,
2317 struct lttng_notification
*notification
,
2318 const int iteration
)
2321 unsigned int capture_count
, i
;
2322 enum lttng_evaluation_event_rule_matches_status
2323 event_rule_matches_evaluation_status
;
2324 enum lttng_event_field_value_status event_field_value_status
;
2325 const struct lttng_evaluation
*evaluation
;
2326 const struct lttng_event_field_value
*captured_fields
;
2327 bool at_least_one_error
= false;
2329 evaluation
= lttng_notification_get_evaluation(notification
);
2330 if (evaluation
== NULL
) {
2331 fail("Failed to get evaluation from notification during trigger capture test");
2336 event_rule_matches_evaluation_status
=
2337 lttng_evaluation_event_rule_matches_get_captured_values(
2338 evaluation
, &captured_fields
);
2339 if (event_rule_matches_evaluation_status
!=
2340 LTTNG_EVALUATION_EVENT_RULE_MATCHES_STATUS_OK
) {
2341 diag("Failed to get event rule evaluation captured values: status = %d",
2342 (int) event_rule_matches_evaluation_status
);
2347 event_field_value_status
=
2348 lttng_event_field_value_array_get_length(captured_fields
,
2350 if (event_field_value_status
!= LTTNG_EVENT_FIELD_VALUE_STATUS_OK
) {
2351 fail("Failed to get count of captured value field array");
2356 for (i
= 0; i
< capture_count
; i
++) {
2357 const struct lttng_event_field_value
*captured_field
= NULL
;
2358 validate_cb validate
;
2361 diag("Validating capture of field '%s'",
2362 test_capture_base_fields
[i
].field_name
);
2363 event_field_value_status
=
2364 lttng_event_field_value_array_get_element_at_index(
2369 case LTTNG_DOMAIN_UST
:
2370 expected
= test_capture_base_fields
[i
].expected_ust
;
2372 case LTTNG_DOMAIN_KERNEL
:
2373 expected
= test_capture_base_fields
[i
].expected_kernel
;
2376 fail("Unexpected domain encountered: domain = %d",
2382 if (domain
== LTTNG_DOMAIN_UST
) {
2383 validate
= test_capture_base_fields
[i
].validate_ust
;
2385 validate
= test_capture_base_fields
[i
].validate_kernel
;
2389 ok(event_field_value_status
== LTTNG_EVENT_FIELD_VALUE_STATUS_UNAVAILABLE
,
2390 "No payload captured");
2394 if (event_field_value_status
!= LTTNG_EVENT_FIELD_VALUE_STATUS_OK
) {
2395 if (event_field_value_status
==
2396 LTTNG_EVENT_FIELD_VALUE_STATUS_UNAVAILABLE
) {
2397 fail("Expected a capture but it is unavailable");
2399 fail("lttng_event_field_value_array_get_element_at_index returned an error: status = %d",
2400 (int) event_field_value_status
);
2407 diag("Captured field of type %s",
2408 field_value_type_to_str(
2409 lttng_event_field_value_get_type(captured_field
)));
2411 LTTNG_ASSERT(validate
);
2412 ret
= validate(captured_field
, iteration
);
2414 at_least_one_error
= true;
2418 ret
= at_least_one_error
;
2424 static void test_tracepoint_event_rule_notification_capture(
2425 enum lttng_domain_type domain_type
)
2427 enum lttng_notification_channel_status nc_status
;
2430 struct lttng_condition
*condition
= NULL
;
2431 struct lttng_notification_channel
*notification_channel
= NULL
;
2432 struct lttng_trigger
*trigger
= NULL
;
2433 const char *trigger_name
= "my_precious";
2434 const char *pattern
;
2436 if (domain_type
== LTTNG_DOMAIN_UST
) {
2437 pattern
= "tp:tptest";
2439 pattern
= "lttng_test_filter_event";
2442 create_tracepoint_event_rule_trigger(pattern
, trigger_name
, NULL
, 0,
2443 NULL
, domain_type
, generate_capture_descr
, &condition
,
2446 notification_channel
= lttng_notification_channel_create(
2447 lttng_session_daemon_notification_endpoint
);
2448 ok(notification_channel
, "Notification channel object creation");
2450 nc_status
= lttng_notification_channel_subscribe(
2451 notification_channel
, condition
);
2452 ok(nc_status
== LTTNG_NOTIFICATION_CHANNEL_STATUS_OK
,
2453 "Subscribe to tracepoint event rule condition");
2455 resume_application();
2457 /* Get 3 notifications */
2458 for (i
= 0; i
< 3; i
++) {
2459 struct lttng_notification
*notification
= get_next_notification(
2460 notification_channel
);
2461 ok(notification
, "Received notification");
2464 if (notification
== NULL
) {
2468 ret
= validator_notification_trigger_name(notification
, trigger_name
);
2470 lttng_notification_destroy(notification
);
2474 ret
= validator_notification_trigger_capture(domain_type
, notification
, i
);
2476 lttng_notification_destroy(notification
);
2480 lttng_notification_destroy(notification
);
2484 suspend_application();
2485 lttng_notification_channel_destroy(notification_channel
);
2486 lttng_unregister_trigger(trigger
);
2487 lttng_trigger_destroy(trigger
);
2488 lttng_condition_destroy(condition
);
2492 int main(int argc
, const char *argv
[])
2495 const char *domain_type_string
= NULL
;
2496 enum lttng_domain_type domain_type
= LTTNG_DOMAIN_NONE
;
2499 fail("Missing test scenario, domain type, pid, or application state file argument(s)");
2503 test_scenario
= atoi(argv
[1]);
2504 domain_type_string
= argv
[2];
2505 app_pid
= (pid_t
) atoi(argv
[3]);
2506 app_state_file
= argv
[4];
2508 if (!strcmp("LTTNG_DOMAIN_UST", domain_type_string
)) {
2509 domain_type
= LTTNG_DOMAIN_UST
;
2511 if (!strcmp("LTTNG_DOMAIN_KERNEL", domain_type_string
)) {
2512 domain_type
= LTTNG_DOMAIN_KERNEL
;
2514 if (domain_type
== LTTNG_DOMAIN_NONE
) {
2515 fail("Unknown domain type");
2520 * Test cases are responsible for resuming the app when needed
2521 * and making sure it's suspended when returning.
2523 suspend_application();
2525 switch (test_scenario
) {
2530 /* Test cases that need gen-ust-event testapp. */
2531 diag("Test basic notification error paths for %s domain",
2532 domain_type_string
);
2533 test_invalid_channel_subscription(domain_type
);
2535 diag("Test tracepoint event rule notifications for domain %s",
2536 domain_type_string
);
2537 test_tracepoint_event_rule_notification(domain_type
);
2539 diag("Test tracepoint event rule notifications with filter for domain %s",
2540 domain_type_string
);
2541 test_tracepoint_event_rule_notification_filter(domain_type
);
2546 const char *session_name
, *channel_name
;
2548 /* Test cases that need a tracing session enabled. */
2552 * Argument 7 and upward are named pipe location for consumerd
2555 named_pipe_args_start
= 7;
2558 fail("Missing parameter for tests to run %d", argc
);
2564 session_name
= argv
[5];
2565 channel_name
= argv
[6];
2567 test_subscription_twice(session_name
, channel_name
,
2570 diag("Test trigger for domain %s with buffer_usage_low condition",
2571 domain_type_string
);
2572 test_triggers_buffer_usage_condition(session_name
, channel_name
,
2574 LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW
);
2576 diag("Test trigger for domain %s with buffer_usage_high condition",
2577 domain_type_string
);
2578 test_triggers_buffer_usage_condition(session_name
, channel_name
,
2580 LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH
);
2582 diag("Test buffer usage notification channel api for domain %s",
2583 domain_type_string
);
2584 test_buffer_usage_notification_channel(session_name
, channel_name
,
2591 * Test cases that need a test app with more than one event
2597 * At the moment, the only test case of this scenario is
2598 * exclusion which is only supported by UST.
2600 LTTNG_ASSERT(domain_type
== LTTNG_DOMAIN_UST
);
2601 diag("Test tracepoint event rule notifications with exclusion for domain %s",
2602 domain_type_string
);
2603 test_tracepoint_event_rule_notification_exclusion(domain_type
);
2610 /* Test cases that need the kernel tracer. */
2611 LTTNG_ASSERT(domain_type
== LTTNG_DOMAIN_KERNEL
);
2613 diag("Test kprobe event rule notifications for domain %s",
2614 domain_type_string
);
2616 test_kprobe_event_rule_notification(domain_type
);
2623 /* Test cases that need the kernel tracer. */
2624 LTTNG_ASSERT(domain_type
== LTTNG_DOMAIN_KERNEL
);
2626 diag("Test syscall event rule notifications for domain %s",
2627 domain_type_string
);
2629 test_syscall_event_rule_notification(domain_type
);
2631 diag("Test syscall filtering event rule notifications for domain %s",
2632 domain_type_string
);
2634 test_syscall_event_rule_notification_filter(domain_type
);
2640 const char *testapp_path
, *test_symbol_name
;
2645 fail("Missing parameter for tests to run %d", argc
);
2649 testapp_path
= argv
[5];
2650 test_symbol_name
= argv
[6];
2651 /* Test cases that need the kernel tracer. */
2652 LTTNG_ASSERT(domain_type
== LTTNG_DOMAIN_KERNEL
);
2654 diag("Test userspace-probe event rule notifications for domain %s",
2655 domain_type_string
);
2657 test_uprobe_event_rule_notification(
2658 domain_type
, testapp_path
, test_symbol_name
);
2664 switch(domain_type
) {
2665 case LTTNG_DOMAIN_UST
:
2668 case LTTNG_DOMAIN_KERNEL
:
2675 diag("Test tracepoint event rule notification captures for domain %s",
2676 domain_type_string
);
2677 test_tracepoint_event_rule_notification_capture(domain_type
);
2687 return exit_status();