projects / lttng-tools.git / blob
? search:


9638bb4527ff8efad3533a90cbfd782e4ddb6d2a
[lttng-tools.git] / tests / regression / tools / notification / notification.c
1 /*
2 * notification.c
3 *
4 * Tests suite for LTTng notification API
5 *
6 * Copyright (C) 2017 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
7 *
8 * SPDX-License-Identifier: MIT
9 *
10 */
11
12 #include <assert.h>
13 #include <math.h>
14 #include <stdbool.h>
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18 #include <unistd.h>
19 #include <inttypes.h>
20 #include <sys/types.h>
21 #include <sys/stat.h>
22 #include <fcntl.h>
23 #include <signal.h>
24 #include <poll.h>
25
26 #include <common/compat/errno.h>
27 #include <lttng/lttng.h>
28
29 #include <tap/tap.h>
30
31 #define FIELD_NAME_MAX_LEN 256
32
33 /* A callback to populate the condition capture descriptor. */
34 typedef int (*condition_capture_desc_cb)(struct lttng_condition *condition);
35
36 /* A callback for captured field validation. */
37 typedef int (*validate_cb)(const struct lttng_event_field_value *event_field, unsigned iteration);
38
39 int nb_args = 0;
40 int named_pipe_args_start = 0;
41 pid_t app_pid = 0;
42 const char *app_state_file = NULL;
43
44 enum field_type {
45 FIELD_TYPE_PAYLOAD,
46 FIELD_TYPE_CONTEXT,
47 FIELD_TYPE_APP_CONTEXT,
48 FIELD_TYPE_ARRAY_FIELD,
49 };
50
51 struct capture_base_field_tuple {
52 char* field_name;
53 enum field_type field_type;
54 /* Do we expect a userspace capture? */
55 bool expected_ust;
56 /* Do we expect a kernel capture? */
57 bool expected_kernel;
58 validate_cb validate_ust;
59 validate_cb validate_kernel;
60 };
61
62 static
63 const char *field_value_type_to_str(enum lttng_event_field_value_type type)
64 {
65 switch (type) {
66 case LTTNG_EVENT_FIELD_VALUE_TYPE_UNKNOWN:
67 return "UNKNOWN";
68 case LTTNG_EVENT_FIELD_VALUE_TYPE_INVALID:
69 return "INVALID";
70 case LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_INT:
71 return "UNSIGNED INT";
72 case LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_INT:
73 return "SIGNED INT";
74 case LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM:
75 return "UNSIGNED ENUM";
76 case LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM:
77 return "SIGNED ENUM";
78 case LTTNG_EVENT_FIELD_VALUE_TYPE_REAL:
79 return "REAL";
80 case LTTNG_EVENT_FIELD_VALUE_TYPE_STRING:
81 return "STRING";
82 case LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY:
83 return "ARRAY";
84 default:
85 abort();
86 }
87 }
88
89 static int validate_type(const struct lttng_event_field_value *event_field,
90 enum lttng_event_field_value_type expect)
91 {
92 int ret;
93 enum lttng_event_field_value_type value;
94
95 value = lttng_event_field_value_get_type(event_field);
96 if (value == LTTNG_EVENT_FIELD_VALUE_TYPE_INVALID) {
97 ret = 1;
98 goto end;
99 }
100
101 ok(expect == value, "Expected field type %s, got %s",
102 field_value_type_to_str(expect),
103 field_value_type_to_str(value));
104
105 ret = expect != value;
106
107 end:
108 return ret;
109 }
110
111 /*
112 * Validate unsigned captured field against the iteration number.
113 */
114 static int validate_unsigned_int_field(
115 const struct lttng_event_field_value *event_field,
116 unsigned int expected_value)
117 {
118 int ret;
119 uint64_t value;
120 enum lttng_event_field_value_status status;
121
122 ret = validate_type(
123 event_field, LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_INT);
124 if (ret) {
125 goto end;
126 }
127
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",
132 (int) status);
133 ret = 1;
134 goto end;
135 }
136
137 ok(value == (uint64_t) expected_value,
138 "Expected unsigned integer value %u, got %" PRIu64,
139 expected_value, value);
140
141 ret = value != (uint64_t) expected_value;
142
143 end:
144 return ret;
145 }
146
147 /*
148 * Validate signed captured field.
149 */
150 static int validate_signed_int_field(
151 const struct lttng_event_field_value *event_field,
152 unsigned int iteration)
153 {
154 int ret;
155 const int64_t expected = -1;
156 int64_t value;
157 enum lttng_event_field_value_status status;
158
159 /* Unused. */
160 (void) iteration;
161
162 ret = validate_type(
163 event_field, LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_INT);
164 if (ret) {
165 goto end;
166 }
167
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",
172 (int) status);
173 ret = 1;
174 goto end;
175 }
176
177 ok(value == expected,
178 "Expected signed integer value %" PRId64
179 ", got %" PRId64,
180 expected, value);
181
182 ret = value != expected;
183
184 end:
185
186 return ret;
187 }
188
189 /*
190 * Validate array of unsigned int.
191 */
192 static int validate_array_unsigned_int_field(
193 const struct lttng_event_field_value *event_field,
194 unsigned int iteration)
195 {
196 int ret;
197 enum lttng_event_field_value_status status;
198 const unsigned int expected = 3;
199 unsigned int i, count;
200
201 /* Unused. */
202 (void) iteration;
203
204 ret = validate_type(event_field, LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY);
205 if (ret) {
206 goto end;
207 }
208
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");
212 ret = 1;
213 goto end;
214 }
215
216 ok(count == expected, "Expected %d subelements, got %d", expected,
217 count);
218 if (count != expected) {
219 ret = 1;
220 goto end;
221 }
222
223 for (i = 1; i < count + 1; i++) {
224 const struct lttng_event_field_value *value;
225
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",
230 (int) status);
231 ret = 1;
232 goto end;
233 }
234
235 ret = validate_unsigned_int_field(value, i);
236 if (ret) {
237 goto end;
238 }
239 }
240
241 ret = 0;
242 end:
243
244 return ret;
245 }
246
247 static int validate_array_unsigned_int_field_at_index(
248 const struct lttng_event_field_value *event_field,
249 unsigned int iteration)
250 {
251 int ret;
252 const uint64_t expected_value = 2;
253 enum lttng_event_field_value_status status;
254 uint64_t value;
255
256 /* Unused. */
257 (void) iteration;
258
259 ret = validate_type(
260 event_field, LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_INT);
261 if (ret) {
262 goto end;
263 }
264
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",
269 (int) status);
270 ret = 1;
271 goto end;
272 }
273
274 ok(value == expected_value,
275 "Expected unsigned integer value %u, got %" PRIu64,
276 expected_value, value);
277
278 ret = 0;
279 end:
280 return ret;
281 }
282
283 /*
284 * Validate sequence for a string (seqfield1):
285 *
286 * Value: "test" encoded in UTF-8: [116, 101, 115, 116]
287 */
288 static int validate_seqfield1(const struct lttng_event_field_value *event_field,
289 unsigned int iteration)
290 {
291 int ret;
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);
296
297 /* Unused. */
298 (void) iteration;
299
300 ret = validate_type(event_field, LTTNG_EVENT_FIELD_VALUE_TYPE_ARRAY);
301 if (ret) {
302 goto end;
303 }
304
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",
308 (int) status);
309 ret = 1;
310 goto end;
311 }
312
313 ok(count == array_count, "Expected %zu array sub-elements, got %d",
314 array_count, count);
315 if (count != array_count) {
316 ret = 1;
317 goto end;
318 }
319
320 for (i = 0; i < count; i++) {
321 const struct lttng_event_field_value *value;
322
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",
327 (int) status);
328 ret = 1;
329 goto end;
330 }
331
332 ret = validate_unsigned_int_field(value, expect[i]);
333 if (ret) {
334 goto end;
335 }
336 }
337
338 ret = 0;
339 end:
340 return ret;
341 }
342
343 static int validate_string(
344 const struct lttng_event_field_value *event_field,
345 const char *expect)
346 {
347 int ret;
348 const char *value = NULL;
349 enum lttng_event_field_value_status status;
350
351 ret = validate_type(event_field, LTTNG_EVENT_FIELD_VALUE_TYPE_STRING);
352 if (ret) {
353 goto end;
354 }
355
356 status = lttng_event_field_value_string_get_value(event_field, &value);
357 if (!value) {
358 fail("lttng_event_field_value_array_get_length returned an error: status = %d",
359 (int) status);
360 ret = 1;
361 goto end;
362 }
363
364 ok(!strcmp(value, expect), "Expected string value \"%s\", got \"%s\"",
365 expect, value);
366
367 ret = 0;
368 end:
369
370 return ret;
371 }
372
373 /*
374 * Validate string. Expected value is "test".
375 */
376 static int validate_string_test(
377 const struct lttng_event_field_value *event_field,
378 unsigned int iteration)
379 {
380 const char * const expect = "test";
381
382 /* Unused. */
383 (void) iteration;
384
385 return validate_string(event_field, expect);
386 }
387
388 /*
389 * Validate escaped string. Expected value is "\*".
390 */
391 static int validate_string_escaped(
392 const struct lttng_event_field_value *event_field,
393 unsigned int iteration)
394 {
395 const char * const expect = "\\*";
396
397 /* Unused. */
398 (void) iteration;
399
400 return validate_string(event_field, expect);
401 }
402
403 /*
404 * Validate real field.
405 */
406 static int validate_real(
407 const struct lttng_event_field_value *event_field,
408 double expect)
409 {
410 int ret;
411 double value;
412 enum lttng_event_field_value_status status;
413
414 ret = validate_type(event_field, LTTNG_EVENT_FIELD_VALUE_TYPE_REAL);
415 if (ret) {
416 goto end;
417 }
418
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",
422 (int) status);
423 ret = 1;
424 goto end;
425 }
426
427 ok(value == expect, "Expected real value %f, got %f", expect, value);
428 ret = value != expect;
429 end:
430 return ret;
431 }
432
433 /*
434 * Validate floatfield.
435 */
436 static int validate_floatfield(
437 const struct lttng_event_field_value *event_field,
438 unsigned int iteration)
439 {
440 const double expect = 2222.0;
441
442 /* Unused. */
443 (void) iteration;
444
445 return validate_real(event_field, expect);
446 }
447
448 /*
449 * Validate doublefield.
450 */
451 static int validate_doublefield(
452 const struct lttng_event_field_value *event_field,
453 unsigned int iteration)
454 {
455 const double expect = 2.0;
456
457 /* Unused. */
458 (void) iteration;
459
460 return validate_real(event_field, expect);
461 }
462
463 /*
464 * Validate enum0: enum0 = ( "AUTO: EXPECT 0" : container = 0 )
465 */
466 static int validate_enum0(const struct lttng_event_field_value *event_field,
467 unsigned int iteration)
468 {
469 int ret;
470 enum lttng_event_field_value_status status;
471 uint64_t value;
472 const uint64_t expected_value = 0;
473
474 /* Unused. */
475 (void) iteration;
476
477 ret = validate_type(event_field,
478 LTTNG_EVENT_FIELD_VALUE_TYPE_UNSIGNED_ENUM);
479 if (ret) {
480 goto end;
481 }
482
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",
487 (int) status);
488 ret = 1;
489 goto end;
490 }
491
492 ok(value == expected_value,
493 "Expected enum value %" PRIu64 ", got %" PRIu64,
494 expected_value, value);
495
496 end:
497 return ret;
498 }
499
500 /*
501 * Validate enumnegative: enumnegative = ( "AUTO: EXPECT 0" : container = 0 )
502 *
503 * We expect 2 labels here.
504 */
505 static int validate_enumnegative(
506 const struct lttng_event_field_value *event_field,
507 unsigned int iteration)
508 {
509 int ret;
510 enum lttng_event_field_value_status status;
511 int64_t value;
512 const int64_t expected_value = -1;
513
514 /* Unused. */
515 (void) iteration;
516
517 ret = validate_type(event_field,
518 LTTNG_EVENT_FIELD_VALUE_TYPE_SIGNED_ENUM);
519 if (ret) {
520 goto end;
521 }
522
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");
527 ret = 1;
528 goto end;
529 }
530
531 ok(value == expected_value,
532 "Expected enum value %" PRId64 ", got %" PRId64,
533 expected_value, value);
534
535 end:
536 return ret;
537 }
538
539 static int validate_context_procname_ust(
540 const struct lttng_event_field_value *event_field,
541 unsigned int iteration)
542 {
543 /* Unused. */
544 (void) iteration;
545 return validate_string(event_field, "gen-ust-events");
546 }
547
548 static int validate_context_procname_kernel(
549 const struct lttng_event_field_value *event_field,
550 unsigned int iteration)
551 {
552 /* Unused. */
553 (void) iteration;
554 return validate_string(event_field, "echo");
555 }
556
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 },
577 };
578
579 static const char *get_notification_trigger_name(
580 struct lttng_notification *notification)
581 {
582 const char *trigger_name = NULL;
583 enum lttng_trigger_status trigger_status;
584 const struct lttng_trigger *trigger;
585
586 trigger = lttng_notification_get_trigger(notification);
587 if (!trigger) {
588 fail("Failed to get trigger from notification");
589 goto end;
590 }
591
592 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
593 switch (trigger_status) {
594 case LTTNG_TRIGGER_STATUS_OK:
595 break;
596 case LTTNG_TRIGGER_STATUS_UNSET:
597 trigger_name = "(anonymous)";
598 break;
599 default:
600 fail("Failed to get name from notification's trigger");
601 goto end;
602 }
603
604 end:
605 return trigger_name;
606 }
607
608 static int validator_notification_trigger_name(
609 struct lttng_notification *notification,
610 const char *trigger_name)
611 {
612 int ret;
613 bool name_is_equal;
614 const char *name;
615
616 assert(notification);
617 assert(trigger_name);
618
619 name = get_notification_trigger_name(notification);
620 if (name == NULL) {
621 ret = 1;
622 goto end;
623 }
624
625 name_is_equal = (strcmp(trigger_name, name) == 0);
626 ok(name_is_equal, "Expected trigger name: %s got %s", trigger_name,
627 name);
628
629 ret = !name_is_equal;
630
631 end:
632 return ret;
633 }
634
635 static
636 void wait_on_file(const char *path, bool file_exist)
637 {
638 if (!path) {
639 return;
640 }
641 for (;;) {
642 int ret;
643 struct stat buf;
644
645 ret = stat(path, &buf);
646 if (ret == -1 && errno == ENOENT) {
647 if (file_exist) {
648 /*
649 * The file does not exist. wait a bit and
650 * continue looping until it does.
651 */
652 (void) poll(NULL, 0, 10);
653 continue;
654 }
655
656 /*
657 * File does not exist and the exit condition we want.
658 * Break from the loop and return.
659 */
660 break;
661 }
662 if (ret) {
663 perror("stat");
664 exit(EXIT_FAILURE);
665 }
666 /*
667 * stat() returned 0, so the file exists. break now only if
668 * that's the exit condition we want.
669 */
670 if (file_exist) {
671 break;
672 }
673 }
674 }
675
676 static
677 int write_pipe(const char *path, uint8_t data)
678 {
679 int ret = 0;
680 int fd = 0;
681
682 fd = open(path, O_WRONLY | O_NONBLOCK);
683 if (fd < 0) {
684 perror("Could not open consumer control named pipe");
685 goto end;
686 }
687
688 ret = write(fd, &data , sizeof(data));
689 if (ret < 1) {
690 perror("Named pipe write failed");
691 if (close(fd)) {
692 perror("Named pipe close failed");
693 }
694 ret = -1;
695 goto end;
696 }
697
698 ret = close(fd);
699 if (ret < 0) {
700 perror("Name pipe closing failed");
701 ret = -1;
702 goto end;
703 }
704 end:
705 return ret;
706 }
707
708 static
709 int stop_consumer(const char **argv)
710 {
711 int ret = 0, i;
712
713 for (i = named_pipe_args_start; i < nb_args; i++) {
714 ret = write_pipe(argv[i], 49);
715 }
716 return ret;
717 }
718
719 static
720 int resume_consumer(const char **argv)
721 {
722 int ret = 0, i;
723
724 for (i = named_pipe_args_start; i < nb_args; i++) {
725 ret = write_pipe(argv[i], 0);
726 }
727 return ret;
728 }
729
730 static
731 int suspend_application(void)
732 {
733 int ret;
734 struct stat buf;
735
736 if (!stat(app_state_file, &buf)) {
737 fail("App is already in a suspended state.");
738 ret = -1;
739 goto error;
740 }
741
742 /*
743 * Send SIGUSR1 to application instructing it to bypass tracepoint.
744 */
745 assert(app_pid > 1);
746
747 ret = kill(app_pid, SIGUSR1);
748 if (ret) {
749 fail("SIGUSR1 failed. errno %d", errno);
750 ret = -1;
751 goto error;
752 }
753
754 wait_on_file(app_state_file, true);
755
756 error:
757 return ret;
758
759 }
760
761 static
762 int resume_application(void)
763 {
764 int ret;
765 struct stat buf;
766
767 ret = stat(app_state_file, &buf);
768 if (ret == -1 && errno == ENOENT) {
769 fail("State file does not exist");
770 goto error;
771 }
772 if (ret) {
773 perror("stat");
774 goto error;
775 }
776
777 assert(app_pid > 1);
778
779 ret = kill(app_pid, SIGUSR1);
780 if (ret) {
781 fail("SIGUSR1 failed. errno %d", errno);
782 ret = -1;
783 goto error;
784 }
785
786 wait_on_file(app_state_file, false);
787
788 error:
789 return ret;
790
791 }
792
793
794 static
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)
799 {
800 unsigned int test_vector_size = 5, i;
801 enum lttng_condition_status condition_status;
802 struct lttng_action *action;
803
804 /* Set-up */
805 action = lttng_action_notify_create();
806 if (!action) {
807 fail("Setup error on action creation");
808 goto end;
809 }
810
811 /* Test lttng_register_trigger with null value */
812 ok(lttng_register_trigger(NULL) == -LTTNG_ERR_INVALID, "Registering a NULL trigger fails as expected");
813
814 /* Test: register a trigger */
815
816 for (i = 0; i < pow(2,test_vector_size); i++) {
817 int loop_ret = 0;
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;
825
826 struct lttng_trigger *trigger = NULL;
827 struct lttng_condition *condition = NULL;
828
829 /* Create base condition */
830 switch (condition_type) {
831 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
832 condition = lttng_condition_buffer_usage_low_create();
833 break;
834 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
835 condition = lttng_condition_buffer_usage_high_create();
836 break;
837 default:
838 loop_ret = 1;
839 goto loop_end;
840 }
841
842 if (!condition) {
843 loop_ret = 1;
844 goto loop_end;
845
846 }
847
848 /* Prepare the condition for trigger registration test */
849
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) {
855 loop_ret = 1;
856 goto loop_end;
857 }
858 session_name_set = true;
859 }
860 mask_position++;
861
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) {
867 loop_ret = 1;
868 goto loop_end;
869 }
870 channel_name_set = true;
871 }
872 mask_position++;
873
874 /* Set threshold ratio */
875 if ((1 << mask_position) & i) {
876 condition_status = lttng_condition_buffer_usage_set_threshold_ratio(
877 condition, 0.0);
878 if (condition_status != LTTNG_CONDITION_STATUS_OK) {
879 loop_ret = 1;
880 goto loop_end;
881 }
882 threshold_ratio_set = true;
883 }
884 mask_position++;
885
886 /* Set threshold byte */
887 if ((1 << mask_position) & i) {
888 condition_status = lttng_condition_buffer_usage_set_threshold(
889 condition, 0);
890 if (condition_status != LTTNG_CONDITION_STATUS_OK) {
891 loop_ret = 1;
892 goto loop_end;
893 }
894 threshold_byte_set = true;
895 }
896 mask_position++;
897
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) {
903 loop_ret = 1;
904 goto loop_end;
905 }
906 domain_type_set = true;
907 }
908
909 /* Safety check */
910 if (mask_position != test_vector_size -1) {
911 assert("Logic error for test vector generation");
912 }
913
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) {
921 loop_ret = 1;
922 goto loop_end;
923 }
924
925 /* Create trigger */
926 trigger = lttng_trigger_create(condition, action);
927 if (!trigger) {
928 loop_ret = 1;
929 goto loop_end;
930 }
931
932 loop_ret = lttng_register_trigger(trigger);
933
934 loop_end:
935 if (loop_ret == 1) {
936 fail("Setup error occurred for tuple: %s", test_tuple_string);
937 goto loop_cleanup;
938 }
939
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);
945
946 /*
947 * Test that a trigger cannot be registered
948 * multiple time.
949 */
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);
952
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);
956
957 /*
958 * Test that unregistration of a non-previously
959 * registered trigger fail.
960 */
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);
963 } else {
964 ok(loop_ret == -LTTNG_ERR_INVALID_TRIGGER, "Trigger is invalid as expected and cannot be registered: %s", test_tuple_string);
965 }
966
967 loop_cleanup:
968 free(test_tuple_string);
969 lttng_trigger_destroy(trigger);
970 lttng_condition_destroy(condition);
971 }
972
973 end:
974 lttng_action_destroy(action);
975 }
976
977 static
978 void wait_data_pending(const char *session_name)
979 {
980 int ret;
981
982 do {
983 ret = lttng_data_pending(session_name);
984 assert(ret >= 0);
985 } while (ret != 0);
986 }
987
988 static
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)
994 {
995 enum lttng_condition_status condition_status;
996 int ret = 0;
997
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`",
1002 condition_name);
1003 ret = -1;
1004 goto end;
1005 }
1006
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`",
1011 condition_name);
1012 ret = -1;
1013 goto end;
1014 }
1015
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`",
1020 condition_name);
1021 ret = -1;
1022 goto end;
1023 }
1024
1025 end:
1026 return ret;
1027 }
1028
1029 static
1030 void test_invalid_channel_subscription(
1031 const enum lttng_domain_type domain_type)
1032 {
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;
1038 int ret = 0;
1039
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) {
1044 goto end;
1045 }
1046
1047 /*
1048 * Create a dummy, empty (thus invalid) condition to test error paths.
1049 */
1050 dummy_invalid_condition = lttng_condition_buffer_usage_low_create();
1051 if (!dummy_invalid_condition) {
1052 fail("Setup error on condition creation");
1053 goto end;
1054 }
1055
1056 /*
1057 * Test subscription and unsubscription of an invalid condition to/from
1058 * a channel.
1059 */
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");
1064
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");
1069
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");
1074 goto end;
1075 }
1076
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");
1081 goto end;
1082 }
1083
1084 ret = setup_buffer_usage_condition(dummy_condition, "dummy_condition",
1085 "dummy_session", "dummy_channel", domain_type);
1086 if (ret) {
1087 fail("Setup error on dummy condition creation");
1088 goto end;
1089 }
1090
1091 /*
1092 * Test subscription and unsubscription to/from a channel with invalid
1093 * parameters.
1094 */
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");
1098
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");
1103
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");
1107
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");
1112
1113 end:
1114 lttng_notification_channel_destroy(notification_channel);
1115 lttng_condition_destroy(dummy_invalid_condition);
1116 lttng_condition_destroy(dummy_condition);
1117 return;
1118 }
1119
1120 enum buffer_usage_type {
1121 BUFFER_USAGE_TYPE_LOW,
1122 BUFFER_USAGE_TYPE_HIGH,
1123 };
1124
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,
1129 double ratio,
1130 struct lttng_condition **condition,
1131 struct lttng_action **action,
1132 struct lttng_trigger **trigger)
1133 {
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;
1138 int ret = 0;
1139
1140 /* Set-up */
1141 tmp_action = lttng_action_notify_create();
1142 if (!action) {
1143 fail("Setup error on action creation");
1144 ret = -1;
1145 goto error;
1146 }
1147
1148 if (buffer_usage_type == BUFFER_USAGE_TYPE_LOW) {
1149 tmp_condition = lttng_condition_buffer_usage_low_create();
1150 } else {
1151 tmp_condition = lttng_condition_buffer_usage_high_create();
1152 }
1153
1154 if (!tmp_condition) {
1155 fail("Setup error on condition creation");
1156 ret = -1;
1157 goto error;
1158 }
1159
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");
1165 ret = -1;
1166 goto error;
1167 }
1168
1169 ret = setup_buffer_usage_condition(tmp_condition, "condition_name",
1170 session_name, channel_name, domain_type);
1171 if (ret) {
1172 fail("Setup error on condition creation");
1173 ret = -1;
1174 goto error;
1175 }
1176
1177 /* Register the trigger for condition. */
1178 tmp_trigger = lttng_trigger_create(tmp_condition, tmp_action);
1179 if (!tmp_trigger) {
1180 fail("Setup error on trigger creation");
1181 ret = -1;
1182 goto error;
1183 }
1184
1185 ret = lttng_register_trigger(tmp_trigger);
1186 if (ret) {
1187 fail("Setup error on trigger registration");
1188 ret = -1;
1189 goto error;
1190 }
1191
1192 *condition = tmp_condition;
1193 *trigger = tmp_trigger;
1194 *action = tmp_action;
1195 goto end;
1196
1197 error:
1198 lttng_action_destroy(tmp_action);
1199 lttng_condition_destroy(tmp_condition);
1200 lttng_trigger_destroy(tmp_trigger);
1201
1202 end:
1203 return ret;
1204 }
1205
1206 static void test_subscription_twice(const char *session_name,
1207 const char *channel_name,
1208 const enum lttng_domain_type domain_type)
1209 {
1210 int ret = 0;
1211 enum lttng_notification_channel_status nc_status;
1212
1213 struct lttng_action *action = NULL;
1214 struct lttng_notification_channel *notification_channel = NULL;
1215 struct lttng_trigger *trigger = NULL;
1216
1217 struct lttng_condition *condition = NULL;
1218
1219 ret = register_buffer_usage_notify_trigger(session_name, channel_name,
1220 domain_type, BUFFER_USAGE_TYPE_LOW, 0.99, &condition,
1221 &action, &trigger);
1222 if (ret) {
1223 fail("Setup error on trigger registration in %s()",
1224 __FUNCTION__);
1225 goto end;
1226 }
1227
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) {
1233 goto end;
1234 }
1235
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");
1241
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");
1247
1248 end:
1249 ret = lttng_unregister_trigger(trigger);
1250 if (ret) {
1251 fail("Failed to unregister trigger in %s()", __FUNCTION__);
1252 }
1253
1254 lttng_trigger_destroy(trigger);
1255 lttng_notification_channel_destroy(notification_channel);
1256 lttng_action_destroy(action);
1257 lttng_condition_destroy(condition);
1258 }
1259
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,
1263 const char **argv)
1264 {
1265 int ret = 0;
1266 enum lttng_notification_channel_status nc_status;
1267
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;
1274
1275 struct lttng_condition *low_condition = NULL;
1276 struct lttng_condition *high_condition = NULL;
1277
1278 const double low_ratio = 0.0;
1279 const double high_ratio = 0.90;
1280
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);
1284 if (ret) {
1285 fail("Setup error on low trigger registration");
1286 goto end;
1287 }
1288
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);
1292 if (ret) {
1293 fail("Setup error on high trigger registration");
1294 goto end;
1295 }
1296
1297 /* Begin testing */
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) {
1302 goto end;
1303 }
1304
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");
1310
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");
1316
1317 resume_application();
1318
1319 /* Wait for notification to happen */
1320 stop_consumer(argv);
1321 lttng_start_tracing(session_name);
1322
1323 /* Wait for high notification */
1324 do {
1325 nc_status = lttng_notification_channel_get_next_notification(
1326 notification_channel, &notification);
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(
1330 notification)) ==
1331 LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH,
1332 "High notification received after intermediary communication");
1333 lttng_notification_destroy(notification);
1334 notification = NULL;
1335
1336 suspend_application();
1337 lttng_stop_tracing_no_wait(session_name);
1338 resume_consumer(argv);
1339 wait_data_pending(session_name);
1340
1341 /*
1342 * Test that communication still work even if there is notification
1343 * waiting for consumption.
1344 */
1345
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");
1350
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");
1355
1356 do {
1357 nc_status = lttng_notification_channel_get_next_notification(
1358 notification_channel, &notification);
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(
1362 notification)) ==
1363 LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW,
1364 "Low notification received after intermediary communication");
1365 lttng_notification_destroy(notification);
1366 notification = NULL;
1367
1368 /* Stop consumer to force a high notification */
1369 stop_consumer(argv);
1370 resume_application();
1371 lttng_start_tracing(session_name);
1372
1373 do {
1374 nc_status = lttng_notification_channel_get_next_notification(
1375 notification_channel, &notification);
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(
1379 notification)) ==
1380 LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH,
1381 "High notification received after intermediary communication");
1382 lttng_notification_destroy(notification);
1383 notification = NULL;
1384
1385 suspend_application();
1386 lttng_stop_tracing_no_wait(session_name);
1387 resume_consumer(argv);
1388 wait_data_pending(session_name);
1389
1390 do {
1391 nc_status = lttng_notification_channel_get_next_notification(
1392 notification_channel, &notification);
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(
1396 notification)) ==
1397 LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW,
1398 "Low notification received after re-subscription");
1399 lttng_notification_destroy(notification);
1400 notification = NULL;
1401
1402 stop_consumer(argv);
1403 resume_application();
1404 /* Stop consumer to force a high notification */
1405 lttng_start_tracing(session_name);
1406
1407 do {
1408 nc_status = lttng_notification_channel_get_next_notification(
1409 notification_channel, &notification);
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(
1413 notification)) ==
1414 LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH,
1415 "High notification");
1416 lttng_notification_destroy(notification);
1417 notification = NULL;
1418
1419 suspend_application();
1420
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);
1425
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");
1430
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");
1435
1436 end:
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);
1444 }
1445
1446 static void create_tracepoint_event_rule_trigger(const char *event_pattern,
1447 const char *trigger_name,
1448 const char *filter,
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)
1455 {
1456 enum lttng_event_rule_status event_rule_status;
1457 struct lttng_action *tmp_action = NULL;
1458 struct lttng_event_rule *event_rule = NULL;
1459 struct lttng_condition *tmp_condition = NULL;
1460 struct lttng_trigger *tmp_trigger = NULL;
1461 int ret;
1462 enum lttng_error_code ret_code;
1463
1464 assert(event_pattern);
1465 assert(trigger_name);
1466 assert(condition);
1467 assert(trigger);
1468
1469 event_rule = lttng_event_rule_tracepoint_create(domain_type);
1470 ok(event_rule, "Tracepoint event rule object creation");
1471
1472 event_rule_status = lttng_event_rule_tracepoint_set_name_pattern(
1473 event_rule, event_pattern);
1474 ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
1475 "Setting tracepoint event rule pattern: '%s'",
1476 event_pattern);
1477
1478 if (filter) {
1479 event_rule_status = lttng_event_rule_tracepoint_set_filter(
1480 event_rule, filter);
1481 ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
1482 "Setting tracepoint event rule filter: '%s'",
1483 filter);
1484 }
1485
1486 if (exclusions) {
1487 int i;
1488 bool success = true;
1489
1490 assert(domain_type == LTTNG_DOMAIN_UST);
1491 assert(exclusion_count > 0);
1492
1493 for (i = 0; i < exclusion_count; i++) {
1494 event_rule_status =
1495 lttng_event_rule_tracepoint_add_name_pattern_exclusion(
1496 event_rule,
1497 exclusions[i]);
1498 if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
1499 fail("Setting tracepoint event rule exclusion '%s'.",
1500 exclusions[i]);
1501 success = false;
1502 }
1503 }
1504
1505 ok(success, "Setting tracepoint event rule exclusions");
1506 }
1507
1508 tmp_condition = lttng_condition_event_rule_matches_create(event_rule);
1509 ok(tmp_condition, "Condition event rule object creation");
1510
1511 if (capture_desc_cb) {
1512 ret = capture_desc_cb(tmp_condition);
1513 if (ret) {
1514 fail("Failed to generate the condition capture descriptor");
1515 abort();
1516 }
1517 }
1518
1519 tmp_action = lttng_action_notify_create();
1520 ok(tmp_action, "Action event rule object creation");
1521
1522 tmp_trigger = lttng_trigger_create(tmp_condition, tmp_action);
1523 ok(tmp_trigger, "Trigger object creation %s", trigger_name);
1524
1525 ret_code = lttng_register_trigger_with_name(tmp_trigger, trigger_name);
1526 ok(ret_code == LTTNG_OK, "Trigger registration %s", trigger_name);
1527
1528 lttng_event_rule_destroy(event_rule);
1529
1530 *condition = tmp_condition;
1531 *trigger = tmp_trigger;
1532
1533 return;
1534 }
1535
1536 static struct lttng_notification *get_next_notification(
1537 struct lttng_notification_channel *notification_channel)
1538 {
1539 struct lttng_notification *local_notification = NULL;
1540 enum lttng_notification_channel_status status;
1541
1542 /* Receive the next notification. */
1543 status = lttng_notification_channel_get_next_notification(
1544 notification_channel, &local_notification);
1545
1546 switch (status) {
1547 case LTTNG_NOTIFICATION_CHANNEL_STATUS_OK:
1548 break;
1549 case LTTNG_NOTIFICATION_CHANNEL_STATUS_NOTIFICATIONS_DROPPED:
1550 fail("Notifications have been dropped");
1551 local_notification = NULL;
1552 break;
1553 default:
1554 /* Unhandled conditions / errors. */
1555 fail("Failed to get next notification (unknown notification channel status): status = %d",
1556 (int) status);
1557 local_notification = NULL;
1558 break;
1559 }
1560
1561 return local_notification;
1562 }
1563
1564 static void test_tracepoint_event_rule_notification(
1565 enum lttng_domain_type domain_type)
1566 {
1567 int i;
1568 int ret;
1569 const int notification_count = 3;
1570 enum lttng_notification_channel_status nc_status;
1571 struct lttng_action *action = NULL;
1572 struct lttng_condition *condition = NULL;
1573 struct lttng_notification_channel *notification_channel = NULL;
1574 struct lttng_trigger *trigger = NULL;
1575 const char * const trigger_name = "my_precious";
1576 const char *pattern;
1577
1578 if (domain_type == LTTNG_DOMAIN_UST) {
1579 pattern = "tp:tptest";
1580 } else {
1581 pattern = "lttng_test_filter_event";
1582 }
1583
1584 create_tracepoint_event_rule_trigger(pattern, trigger_name, NULL, 0,
1585 NULL, domain_type, NULL, &condition, &trigger);
1586
1587 notification_channel = lttng_notification_channel_create(
1588 lttng_session_daemon_notification_endpoint);
1589 ok(notification_channel, "Notification channel object creation");
1590
1591 nc_status = lttng_notification_channel_subscribe(
1592 notification_channel, condition);
1593 ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1594 "Subscribe to tracepoint event rule condition");
1595
1596 resume_application();
1597
1598 /* Get notifications. */
1599 for (i = 0; i < notification_count; i++) {
1600 struct lttng_notification *notification = get_next_notification(
1601 notification_channel);
1602
1603 ok(notification, "Received notification (%d/%d)", i + 1,
1604 notification_count);
1605
1606 /* Error. */
1607 if (notification == NULL) {
1608 goto end;
1609 }
1610
1611 ret = validator_notification_trigger_name(notification, trigger_name);
1612 lttng_notification_destroy(notification);
1613 if (ret) {
1614 goto end;
1615 }
1616 }
1617
1618 end:
1619 suspend_application();
1620 lttng_notification_channel_destroy(notification_channel);
1621 lttng_unregister_trigger(trigger);
1622 lttng_trigger_destroy(trigger);
1623 lttng_action_destroy(action);
1624 lttng_condition_destroy(condition);
1625 return;
1626 }
1627
1628 static void test_tracepoint_event_rule_notification_filter(
1629 enum lttng_domain_type domain_type)
1630 {
1631 int i;
1632 const int notification_count = 3;
1633 enum lttng_notification_channel_status nc_status;
1634 struct lttng_condition *ctrl_condition = NULL, *condition = NULL;
1635 struct lttng_notification_channel *notification_channel = NULL;
1636 struct lttng_trigger *ctrl_trigger = NULL, *trigger = NULL;
1637 const char * const ctrl_trigger_name = "control_trigger";
1638 const char * const trigger_name = "trigger";
1639 const char *pattern;
1640 int ctrl_count = 0, count = 0;
1641
1642 if (domain_type == LTTNG_DOMAIN_UST) {
1643 pattern = "tp:tptest";
1644 } else {
1645 pattern = "lttng_test_filter_event";
1646 }
1647
1648 notification_channel = lttng_notification_channel_create(
1649 lttng_session_daemon_notification_endpoint);
1650 ok(notification_channel, "Notification channel object creation");
1651
1652 create_tracepoint_event_rule_trigger(pattern, ctrl_trigger_name, NULL,
1653 0, NULL, domain_type, NULL, &ctrl_condition, &ctrl_trigger);
1654
1655 nc_status = lttng_notification_channel_subscribe(
1656 notification_channel, ctrl_condition);
1657 ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1658 "Subscribe to tracepoint event rule condition");
1659
1660 /*
1661 * Attach a filter expression to get notification only if the
1662 * `intfield` is even.
1663 */
1664 create_tracepoint_event_rule_trigger(pattern, trigger_name,
1665 "(intfield & 1) == 0", 0, NULL, domain_type, NULL, &condition,
1666 &trigger);
1667
1668 nc_status = lttng_notification_channel_subscribe(
1669 notification_channel, condition);
1670 ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1671 "Subscribe to tracepoint event rule condition");
1672
1673 /*
1674 * We registered 2 notifications triggers, one with a filter and one
1675 * without (control). The one with a filter will only fired when the
1676 * `intfield` is a multiple of 2. We should get two times as many
1677 * control notifications as filter notifications.
1678 */
1679 resume_application();
1680
1681 /*
1682 * Get 3 notifications. We should get 1 for the regular trigger (with
1683 * the filter) and 2 from the control trigger. This works whatever
1684 * the order we receive the notifications.
1685 */
1686 for (i = 0; i < notification_count; i++) {
1687 const char *name;
1688 struct lttng_notification *notification = get_next_notification(
1689 notification_channel);
1690
1691 ok(notification, "Received notification (%d/%d)", i + 1,
1692 notification_count);
1693
1694 /* Error. */
1695 if (notification == NULL) {
1696 goto end;
1697 }
1698
1699 name = get_notification_trigger_name(notification);
1700 if (name == NULL) {
1701 lttng_notification_destroy(notification);
1702 goto end;
1703 }
1704
1705 if (strcmp(ctrl_trigger_name, name) == 0) {
1706 ctrl_count++;
1707 } else if (strcmp(trigger_name, name) == 0) {
1708 count++;
1709 }
1710
1711 lttng_notification_destroy(notification);
1712 }
1713
1714 ok(ctrl_count / 2 == count,
1715 "Get twice as many control notif as of regular notif");
1716
1717 end:
1718 suspend_application();
1719
1720 lttng_unregister_trigger(trigger);
1721 lttng_unregister_trigger(ctrl_trigger);
1722 lttng_notification_channel_destroy(notification_channel);
1723 lttng_trigger_destroy(trigger);
1724 lttng_trigger_destroy(ctrl_trigger);
1725 lttng_condition_destroy(condition);
1726 lttng_condition_destroy(ctrl_condition);
1727 }
1728
1729 static void test_tracepoint_event_rule_notification_exclusion(
1730 enum lttng_domain_type domain_type)
1731 {
1732 enum lttng_notification_channel_status nc_status;
1733 struct lttng_condition *ctrl_condition = NULL, *condition = NULL;
1734 struct lttng_notification_channel *notification_channel = NULL;
1735 struct lttng_trigger *ctrl_trigger = NULL, *trigger = NULL;
1736 int ctrl_count = 0, count = 0, i;
1737 const int notification_count = 6;
1738 const char * const ctrl_trigger_name = "control_exclusion_trigger";
1739 const char * const trigger_name = "exclusion_trigger";
1740 const char * const pattern = "tp:tptest*";
1741 const char * const exclusions[] = {
1742 "tp:tptest2",
1743 "tp:tptest3",
1744 "tp:tptest4",
1745 "tp:tptest5"
1746 };
1747
1748 notification_channel = lttng_notification_channel_create(
1749 lttng_session_daemon_notification_endpoint);
1750 ok(notification_channel, "Notification channel object creation");
1751
1752 create_tracepoint_event_rule_trigger(pattern, ctrl_trigger_name, NULL,
1753 0, NULL, domain_type, NULL, &ctrl_condition,
1754 &ctrl_trigger);
1755
1756 nc_status = lttng_notification_channel_subscribe(
1757 notification_channel, ctrl_condition);
1758 ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1759 "Subscribe to tracepoint event rule condition");
1760
1761 create_tracepoint_event_rule_trigger(pattern, trigger_name, NULL, 4,
1762 exclusions, domain_type, NULL, &condition,
1763 &trigger);
1764
1765 nc_status = lttng_notification_channel_subscribe(
1766 notification_channel, condition);
1767 ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1768 "Subscribe to tracepoint event rule condition");
1769
1770 /*
1771 * We registered 2 notifications triggers, one with an exclusion and
1772 * one without (control).
1773 * - The trigger with an exclusion will fire once every iteration.
1774 * - The trigger without an exclusion will fire 5 times every
1775 * iteration.
1776 *
1777 * We should get 5 times as many notifications from the control
1778 * trigger.
1779 */
1780 resume_application();
1781
1782 /*
1783 * Get 6 notifications. We should get 1 for the regular trigger (with
1784 * the exclusion) and 5 from the control trigger. This works whatever
1785 * the order we receive the notifications.
1786 */
1787 for (i = 0; i < notification_count; i++) {
1788 const char *name;
1789 struct lttng_notification *notification = get_next_notification(
1790 notification_channel);
1791
1792 ok(notification, "Received notification (%d/%d)", i + 1,
1793 notification_count);
1794
1795 /* Error. */
1796 if (notification == NULL) {
1797 goto end;
1798 }
1799
1800 name = get_notification_trigger_name(notification);
1801 if (name == NULL) {
1802 lttng_notification_destroy(notification);
1803 goto end;
1804 }
1805
1806 if (strcmp(ctrl_trigger_name, name) == 0) {
1807 ctrl_count++;
1808 } else if (strcmp(trigger_name, name) == 0) {
1809 count++;
1810 }
1811
1812 lttng_notification_destroy(notification);
1813 }
1814
1815 ok(ctrl_count / 5 == count,
1816 "Got 5 times as many control notif as of regular notif");
1817
1818 end:
1819 suspend_application();
1820
1821 lttng_unregister_trigger(trigger);
1822 lttng_unregister_trigger(ctrl_trigger);
1823 lttng_notification_channel_destroy(notification_channel);
1824 lttng_trigger_destroy(trigger);
1825 lttng_trigger_destroy(ctrl_trigger);
1826 lttng_condition_destroy(condition);
1827 lttng_condition_destroy(ctrl_condition);
1828 return;
1829 }
1830
1831 static void test_kprobe_event_rule_notification(
1832 enum lttng_domain_type domain_type)
1833 {
1834 int i, ret;
1835 enum lttng_error_code ret_code;
1836 const int notification_count = 3;
1837 enum lttng_notification_channel_status nc_status;
1838 enum lttng_event_rule_status event_rule_status;
1839 struct lttng_notification_channel *notification_channel = NULL;
1840 struct lttng_condition *condition = NULL;
1841 struct lttng_kernel_probe_location *location = NULL;
1842 struct lttng_event_rule *event_rule = NULL;
1843 struct lttng_action *action = NULL;
1844 struct lttng_trigger *trigger = NULL;
1845 const char * const trigger_name = "kprobe_trigger";
1846 const char * const symbol_name = "lttng_test_filter_event_write";
1847
1848 action = lttng_action_notify_create();
1849 if (!action) {
1850 fail("Failed to create notify action");
1851 goto end;
1852 }
1853
1854 location = lttng_kernel_probe_location_symbol_create(symbol_name, 0);
1855 if (!location) {
1856 fail("Failed to create kernel probe location");
1857 goto end;
1858 }
1859
1860 notification_channel = lttng_notification_channel_create(
1861 lttng_session_daemon_notification_endpoint);
1862 ok(notification_channel, "Notification channel object creation");
1863
1864 event_rule = lttng_event_rule_kernel_probe_create(location);
1865 ok(event_rule, "kprobe event rule object creation");
1866
1867 event_rule_status = lttng_event_rule_kernel_probe_set_event_name(
1868 event_rule, trigger_name);
1869 ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
1870 "Setting kprobe event rule name: '%s'", trigger_name);
1871
1872 condition = lttng_condition_event_rule_matches_create(event_rule);
1873 ok(condition, "Condition event rule object creation");
1874
1875 /* Register the trigger for condition. */
1876 trigger = lttng_trigger_create(condition, action);
1877 if (!trigger) {
1878 fail("Failed to create trigger with kernel probe event rule condition and notify action");
1879 goto end;
1880 }
1881
1882 ret_code = lttng_register_trigger_with_name(trigger, trigger_name);
1883 if (ret_code != LTTNG_OK) {
1884 fail("Failed to register trigger with kernel probe event rule condition and notify action");
1885 goto end;
1886 }
1887
1888 nc_status = lttng_notification_channel_subscribe(
1889 notification_channel, condition);
1890 ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1891 "Subscribe to tracepoint event rule condition");
1892
1893 resume_application();
1894
1895 for (i = 0; i < notification_count; i++) {
1896 struct lttng_notification *notification = get_next_notification(
1897 notification_channel);
1898
1899 ok(notification, "Received notification (%d/%d)", i + 1,
1900 notification_count);
1901
1902 /* Error. */
1903 if (notification == NULL) {
1904 goto end;
1905 }
1906
1907 ret = validator_notification_trigger_name(notification, trigger_name);
1908 lttng_notification_destroy(notification);
1909 if (ret) {
1910 goto end;
1911 }
1912 }
1913
1914 end:
1915 suspend_application();
1916 lttng_notification_channel_destroy(notification_channel);
1917 lttng_unregister_trigger(trigger);
1918 lttng_trigger_destroy(trigger);
1919 lttng_action_destroy(action);
1920 lttng_event_rule_destroy(event_rule);
1921 lttng_condition_destroy(condition);
1922 lttng_kernel_probe_location_destroy(location);
1923 return;
1924 }
1925
1926 static void test_uprobe_event_rule_notification(
1927 enum lttng_domain_type domain_type,
1928 const char *testapp_path,
1929 const char *test_symbol_name)
1930 {
1931 int i, ret;
1932 enum lttng_error_code ret_code;
1933 const int notification_count = 3;
1934 enum lttng_notification_channel_status nc_status;
1935 enum lttng_event_rule_status event_rule_status;
1936 struct lttng_notification_channel *notification_channel = NULL;
1937 struct lttng_userspace_probe_location *probe_location = NULL;
1938 struct lttng_userspace_probe_location_lookup_method *lookup_method =
1939 NULL;
1940 struct lttng_condition *condition = NULL;
1941 struct lttng_event_rule *event_rule = NULL;
1942 struct lttng_action *action = NULL;
1943 struct lttng_trigger *trigger = NULL;
1944 const char * const trigger_name = "uprobe_trigger";
1945
1946 action = lttng_action_notify_create();
1947 if (!action) {
1948 fail("Failed to create notify action");
1949 goto end;
1950 }
1951
1952 lookup_method = lttng_userspace_probe_location_lookup_method_function_elf_create();
1953 if (!lookup_method) {
1954 fail("Setup error on userspace probe lookup method creation");
1955 goto end;
1956 }
1957
1958 probe_location = lttng_userspace_probe_location_function_create(
1959 testapp_path, test_symbol_name, lookup_method);
1960 if (!probe_location) {
1961 fail("Failed to create userspace probe location");
1962 goto end;
1963 }
1964
1965 notification_channel = lttng_notification_channel_create(
1966 lttng_session_daemon_notification_endpoint);
1967 ok(notification_channel, "Notification channel object creation");
1968
1969 event_rule = lttng_event_rule_userspace_probe_create(probe_location);
1970 ok(event_rule, "kprobe event rule object creation");
1971
1972 event_rule_status = lttng_event_rule_userspace_probe_set_event_name(
1973 event_rule, trigger_name);
1974 ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
1975 "Setting uprobe event rule name: '%s'", trigger_name);
1976
1977 condition = lttng_condition_event_rule_matches_create(event_rule);
1978 ok(condition, "Condition event rule object creation");
1979
1980 /* Register the trigger for condition. */
1981 trigger = lttng_trigger_create(condition, action);
1982 if (!trigger) {
1983 fail("Failed to create trigger with userspace probe event rule condition and notify action");
1984 goto end;
1985 }
1986
1987 ret_code = lttng_register_trigger_with_name(trigger, trigger_name);
1988 if (ret_code != LTTNG_OK) {
1989 fail("Failed to register trigger with userspace probe event rule condition and notify action");
1990 goto end;
1991 }
1992
1993 nc_status = lttng_notification_channel_subscribe(
1994 notification_channel, condition);
1995 ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1996 "Subscribe to tracepoint event rule condition");
1997
1998 resume_application();
1999
2000 for (i = 0; i < 3; i++) {
2001 struct lttng_notification *notification = get_next_notification(
2002 notification_channel);
2003
2004 ok(notification, "Received notification (%d/%d)", i + 1,
2005 notification_count);
2006
2007 /* Error. */
2008 if (notification == NULL) {
2009 goto end;
2010 }
2011
2012 ret = validator_notification_trigger_name(notification, trigger_name);
2013 lttng_notification_destroy(notification);
2014 if (ret) {
2015 goto end;
2016 }
2017 }
2018 end:
2019 suspend_application();
2020
2021 lttng_notification_channel_destroy(notification_channel);
2022 lttng_unregister_trigger(trigger);
2023 lttng_trigger_destroy(trigger);
2024 lttng_action_destroy(action);
2025 lttng_userspace_probe_location_destroy(probe_location);
2026 lttng_event_rule_destroy(event_rule);
2027 lttng_condition_destroy(condition);
2028 return;
2029 }
2030
2031 static void test_syscall_event_rule_notification(
2032 enum lttng_domain_type domain_type)
2033 {
2034 int i, ret;
2035 enum lttng_error_code ret_code;
2036 const int notification_count = 3;
2037 enum lttng_notification_channel_status nc_status;
2038 enum lttng_event_rule_status event_rule_status;
2039 struct lttng_notification_channel *notification_channel = NULL;
2040 struct lttng_condition *condition = NULL;
2041 struct lttng_event_rule *event_rule = NULL;
2042 struct lttng_action *action = NULL;
2043 struct lttng_trigger *trigger = NULL;
2044 const char * const trigger_name = "syscall_trigger";
2045 const char * const syscall_name = "openat";
2046
2047 action = lttng_action_notify_create();
2048 if (!action) {
2049 fail("Failed to create notify action");
2050 goto end;
2051 }
2052
2053 notification_channel = lttng_notification_channel_create(
2054 lttng_session_daemon_notification_endpoint);
2055 ok(notification_channel, "Notification channel object creation");
2056
2057 event_rule = lttng_event_rule_syscall_create(LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY);
2058 ok(event_rule, "syscall event rule object creation");
2059
2060 event_rule_status = lttng_event_rule_syscall_set_name_pattern(
2061 event_rule, syscall_name);
2062 ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
2063 "Setting syscall event rule pattern: '%s'", syscall_name);
2064
2065 condition = lttng_condition_event_rule_matches_create(event_rule);
2066 ok(condition, "Condition syscall event rule object creation");
2067
2068 /* Register the trigger for condition. */
2069 trigger = lttng_trigger_create(condition, action);
2070 if (!trigger) {
2071 fail("Failed to create trigger with syscall event rule condition and notify action");
2072 goto end;
2073 }
2074
2075 ret_code = lttng_register_trigger_with_name(trigger, trigger_name);
2076 if (ret_code != LTTNG_OK) {
2077 fail("Failed to register trigger with syscall event rule condition and notify action");
2078 goto end;
2079 }
2080
2081 nc_status = lttng_notification_channel_subscribe(
2082 notification_channel, condition);
2083 ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
2084 "Subscribe to tracepoint event rule condition");
2085
2086 resume_application();
2087
2088 for (i = 0; i < notification_count; i++) {
2089 struct lttng_notification *notification = get_next_notification(
2090 notification_channel);
2091
2092 ok(notification, "Received notification (%d/%d)", i + 1,
2093 notification_count);
2094
2095 /* Error. */
2096 if (notification == NULL) {
2097 goto end;
2098 }
2099
2100 ret = validator_notification_trigger_name(notification, trigger_name);
2101 lttng_notification_destroy(notification);
2102 if (ret) {
2103 goto end;
2104 }
2105 }
2106 end:
2107 suspend_application();
2108 lttng_notification_channel_destroy(notification_channel);
2109 lttng_unregister_trigger(trigger);
2110 lttng_trigger_destroy(trigger);
2111 lttng_action_destroy(action);
2112 lttng_condition_destroy(condition);
2113 return;
2114 }
2115
2116 static void test_syscall_event_rule_notification_filter(
2117 enum lttng_domain_type domain_type)
2118 {
2119 int i, ret;
2120 enum lttng_error_code ret_code;
2121 const int notification_count = 3;
2122 enum lttng_notification_channel_status nc_status;
2123 enum lttng_event_rule_status event_rule_status;
2124 struct lttng_notification_channel *notification_channel = NULL;
2125 struct lttng_condition *condition = NULL;
2126 struct lttng_event_rule *event_rule = NULL;
2127 struct lttng_action *action = NULL;
2128 struct lttng_trigger *trigger = NULL;
2129 const char * const trigger_name = "syscall_trigger";
2130 const char * const syscall_name = "openat";
2131 const char * const filter_pattern = "filename == \"/proc/cpuinfo\"";
2132
2133 action = lttng_action_notify_create();
2134 if (!action) {
2135 fail("Failed to create notify action");
2136 goto end;
2137 }
2138
2139 notification_channel = lttng_notification_channel_create(
2140 lttng_session_daemon_notification_endpoint);
2141 ok(notification_channel, "Notification channel object creation");
2142
2143 event_rule = lttng_event_rule_syscall_create(LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY);
2144 ok(event_rule, "syscall event rule object creation");
2145
2146 event_rule_status = lttng_event_rule_syscall_set_name_pattern(
2147 event_rule, syscall_name);
2148 ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
2149 "Setting syscall event rule pattern: '%s'", syscall_name);
2150
2151 event_rule_status = lttng_event_rule_syscall_set_filter(
2152 event_rule, filter_pattern);
2153 ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
2154 "Setting filter: '%s'", filter_pattern);
2155
2156 condition = lttng_condition_event_rule_matches_create(event_rule);
2157 ok(condition, "Condition event rule object creation");
2158
2159 /* Register the triggers for condition */
2160 trigger = lttng_trigger_create(condition, action);
2161 if (!trigger) {
2162 fail("Failed to create trigger with syscall filtering event rule condition and notify action");
2163 goto end;
2164 }
2165
2166 ret_code = lttng_register_trigger_with_name(trigger, trigger_name);
2167 if (ret_code != LTTNG_OK) {
2168 fail("Failed to register trigger with syscall filtering event rule condition and notify action");
2169 goto end;
2170 }
2171
2172 nc_status = lttng_notification_channel_subscribe(
2173 notification_channel, condition);
2174 ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
2175 "Subscribe to tracepoint event rule condition");
2176
2177 resume_application();
2178
2179 for (i = 0; i < notification_count; i++) {
2180 struct lttng_notification *notification = get_next_notification(
2181 notification_channel);
2182
2183 ok(notification, "Received notification (%d/%d)", i + 1,
2184 notification_count);
2185
2186 /* Error. */
2187 if (notification == NULL) {
2188 goto end;
2189 }
2190
2191 ret = validator_notification_trigger_name(notification, trigger_name);
2192 lttng_notification_destroy(notification);
2193 if (ret) {
2194 goto end;
2195 }
2196 }
2197
2198 end:
2199 suspend_application();
2200
2201 lttng_unregister_trigger(trigger);
2202 lttng_notification_channel_destroy(notification_channel);
2203 lttng_trigger_destroy(trigger);
2204 lttng_event_rule_destroy(event_rule);
2205 lttng_condition_destroy(condition);
2206 return;
2207 }
2208
2209 static int generate_capture_descr(struct lttng_condition *condition)
2210 {
2211 int ret, i;
2212 struct lttng_event_expr *expr = NULL;
2213 const unsigned int basic_field_count = sizeof(test_capture_base_fields) /
2214 sizeof(*test_capture_base_fields);
2215 enum lttng_condition_status cond_status;
2216
2217 for (i = 0; i < basic_field_count; i++) {
2218 diag("Adding capture descriptor '%s'",
2219 test_capture_base_fields[i].field_name);
2220
2221 switch (test_capture_base_fields[i].field_type) {
2222 case FIELD_TYPE_PAYLOAD:
2223 expr = lttng_event_expr_event_payload_field_create(
2224 test_capture_base_fields[i].field_name);
2225 break;
2226 case FIELD_TYPE_CONTEXT:
2227 expr = lttng_event_expr_channel_context_field_create(
2228 test_capture_base_fields[i].field_name);
2229 break;
2230 case FIELD_TYPE_ARRAY_FIELD:
2231 {
2232 int nb_matches;
2233 unsigned int index;
2234 char field_name[FIELD_NAME_MAX_LEN];
2235 struct lttng_event_expr *array_expr = NULL;
2236
2237 nb_matches = sscanf(test_capture_base_fields[i].field_name,
2238 "%[^[][%u]", field_name, &index);
2239 if (nb_matches != 2) {
2240 fail("Unexpected array field name format: field name = '%s'",
2241 test_capture_base_fields[i].field_name);
2242 ret = 1;
2243 goto end;
2244 }
2245
2246 array_expr = lttng_event_expr_event_payload_field_create(
2247 field_name);
2248
2249 expr = lttng_event_expr_array_field_element_create(
2250 array_expr, index);
2251 break;
2252 }
2253 case FIELD_TYPE_APP_CONTEXT:
2254 fail("Application context tests are not implemented yet.");
2255 /* fallthrough. */
2256 default:
2257 ret = 1;
2258 goto end;
2259 }
2260
2261 if (expr == NULL) {
2262 fail("Failed to create capture expression");
2263 ret = -1;
2264 goto end;
2265 }
2266
2267 cond_status = lttng_condition_event_rule_matches_append_capture_descriptor(
2268 condition, expr);
2269 if (cond_status != LTTNG_CONDITION_STATUS_OK) {
2270 fail("Failed to append capture descriptor");
2271 ret = -1;
2272 lttng_event_expr_destroy(expr);
2273 goto end;
2274 }
2275 }
2276
2277 ret = 0;
2278
2279 end:
2280 return ret;
2281 }
2282
2283 static int validator_notification_trigger_capture(
2284 enum lttng_domain_type domain,
2285 struct lttng_notification *notification,
2286 const int iteration)
2287 {
2288 int ret;
2289 unsigned int capture_count, i;
2290 enum lttng_evaluation_event_rule_matches_status
2291 event_rule_matches_evaluation_status;
2292 enum lttng_event_field_value_status event_field_value_status;
2293 const struct lttng_evaluation *evaluation;
2294 const struct lttng_event_field_value *captured_fields;
2295 bool at_least_one_error = false;
2296
2297 evaluation = lttng_notification_get_evaluation(notification);
2298 if (evaluation == NULL) {
2299 fail("Failed to get evaluation from notification during trigger capture test");
2300 ret = 1;
2301 goto end;
2302 }
2303
2304 event_rule_matches_evaluation_status =
2305 lttng_evaluation_event_rule_matches_get_captured_values(
2306 evaluation, &captured_fields);
2307 if (event_rule_matches_evaluation_status !=
2308 LTTNG_EVALUATION_EVENT_RULE_MATCHES_STATUS_OK) {
2309 diag("Failed to get event rule evaluation captured values: status = %d",
2310 (int) event_rule_matches_evaluation_status);
2311 ret = 1;
2312 goto end;
2313 }
2314
2315 event_field_value_status =
2316 lttng_event_field_value_array_get_length(captured_fields,
2317 &capture_count);
2318 if (event_field_value_status != LTTNG_EVENT_FIELD_VALUE_STATUS_OK) {
2319 fail("Failed to get count of captured value field array");
2320 ret = 1;
2321 goto end;
2322 }
2323
2324 for (i = 0; i < capture_count; i++) {
2325 const struct lttng_event_field_value *captured_field = NULL;
2326 validate_cb validate;
2327 bool expected;
2328
2329 diag("Validating capture of field '%s'",
2330 test_capture_base_fields[i].field_name);
2331 event_field_value_status =
2332 lttng_event_field_value_array_get_element_at_index(
2333 captured_fields, i,
2334 &captured_field);
2335
2336 switch(domain) {
2337 case LTTNG_DOMAIN_UST:
2338 expected = test_capture_base_fields[i].expected_ust;
2339 break;
2340 case LTTNG_DOMAIN_KERNEL:
2341 expected = test_capture_base_fields[i].expected_kernel;
2342 break;
2343 default:
2344 fail("Unexpected domain encountered: domain = %d",
2345 (int) domain);
2346 ret = 1;
2347 goto end;
2348 }
2349
2350 if (domain == LTTNG_DOMAIN_UST) {
2351 validate = test_capture_base_fields[i].validate_ust;
2352 } else {
2353 validate = test_capture_base_fields[i].validate_kernel;
2354 }
2355
2356 if (!expected) {
2357 ok(event_field_value_status == LTTNG_EVENT_FIELD_VALUE_STATUS_UNAVAILABLE,
2358 "No payload captured");
2359 continue;
2360 }
2361
2362 if (event_field_value_status != LTTNG_EVENT_FIELD_VALUE_STATUS_OK) {
2363 if (event_field_value_status ==
2364 LTTNG_EVENT_FIELD_VALUE_STATUS_UNAVAILABLE) {
2365 fail("Expected a capture but it is unavailable");
2366 } else {
2367 fail("lttng_event_field_value_array_get_element_at_index returned an error: status = %d",
2368 (int) event_field_value_status);
2369 }
2370
2371 ret = 1;
2372 goto end;
2373 }
2374
2375 diag("Captured field of type %s",
2376 field_value_type_to_str(
2377 lttng_event_field_value_get_type(captured_field)));
2378
2379 assert(validate);
2380 ret = validate(captured_field, iteration);
2381 if (ret) {
2382 at_least_one_error = true;
2383 }
2384 }
2385
2386 ret = at_least_one_error;
2387
2388 end:
2389 return ret;
2390 }
2391
2392 static void test_tracepoint_event_rule_notification_capture(
2393 enum lttng_domain_type domain_type)
2394 {
2395 enum lttng_notification_channel_status nc_status;
2396
2397 int i, ret;
2398 struct lttng_condition *condition = NULL;
2399 struct lttng_notification_channel *notification_channel = NULL;
2400 struct lttng_trigger *trigger = NULL;
2401 const char *trigger_name = "my_precious";
2402 const char *pattern;
2403
2404 if (domain_type == LTTNG_DOMAIN_UST) {
2405 pattern = "tp:tptest";
2406 } else {
2407 pattern = "lttng_test_filter_event";
2408 }
2409
2410 create_tracepoint_event_rule_trigger(pattern, trigger_name, NULL, 0,
2411 NULL, domain_type, generate_capture_descr, &condition,
2412 &trigger);
2413
2414 notification_channel = lttng_notification_channel_create(
2415 lttng_session_daemon_notification_endpoint);
2416 ok(notification_channel, "Notification channel object creation");
2417
2418 nc_status = lttng_notification_channel_subscribe(
2419 notification_channel, condition);
2420 ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
2421 "Subscribe to tracepoint event rule condition");
2422
2423 resume_application();
2424
2425 /* Get 3 notifications */
2426 for (i = 0; i < 3; i++) {
2427 struct lttng_notification *notification = get_next_notification(
2428 notification_channel);
2429 ok(notification, "Received notification");
2430
2431 /* Error */
2432 if (notification == NULL) {
2433 goto end;
2434 }
2435
2436 ret = validator_notification_trigger_name(notification, trigger_name);
2437 if (ret) {
2438 lttng_notification_destroy(notification);
2439 goto end;
2440 }
2441
2442 ret = validator_notification_trigger_capture(domain_type, notification, i);
2443 if (ret) {
2444 lttng_notification_destroy(notification);
2445 goto end;
2446 }
2447
2448 lttng_notification_destroy(notification);
2449 }
2450
2451 end:
2452 suspend_application();
2453 lttng_notification_channel_destroy(notification_channel);
2454 lttng_unregister_trigger(trigger);
2455 lttng_trigger_destroy(trigger);
2456 lttng_condition_destroy(condition);
2457 return;
2458 }
2459
2460 int main(int argc, const char *argv[])
2461 {
2462 int test_scenario;
2463 const char *domain_type_string = NULL;
2464 enum lttng_domain_type domain_type = LTTNG_DOMAIN_NONE;
2465
2466 if (argc < 5) {
2467 fail("Missing test scenario, domain type, pid, or application state file argument(s)");
2468 goto error;
2469 }
2470
2471 test_scenario = atoi(argv[1]);
2472 domain_type_string = argv[2];
2473 app_pid = (pid_t) atoi(argv[3]);
2474 app_state_file = argv[4];
2475
2476 if (!strcmp("LTTNG_DOMAIN_UST", domain_type_string)) {
2477 domain_type = LTTNG_DOMAIN_UST;
2478 }
2479 if (!strcmp("LTTNG_DOMAIN_KERNEL", domain_type_string)) {
2480 domain_type = LTTNG_DOMAIN_KERNEL;
2481 }
2482 if (domain_type == LTTNG_DOMAIN_NONE) {
2483 fail("Unknown domain type");
2484 goto error;
2485 }
2486
2487 /*
2488 * Test cases are responsible for resuming the app when needed
2489 * and making sure it's suspended when returning.
2490 */
2491 suspend_application();
2492
2493 switch (test_scenario) {
2494 case 1:
2495 {
2496 plan_tests(41);
2497
2498 /* Test cases that need gen-ust-event testapp. */
2499 diag("Test basic notification error paths for %s domain",
2500 domain_type_string);
2501 test_invalid_channel_subscription(domain_type);
2502
2503 diag("Test tracepoint event rule notifications for domain %s",
2504 domain_type_string);
2505 test_tracepoint_event_rule_notification(domain_type);
2506
2507 diag("Test tracepoint event rule notifications with filter for domain %s",
2508 domain_type_string);
2509 test_tracepoint_event_rule_notification_filter(domain_type);
2510 break;
2511 }
2512 case 2:
2513 {
2514 const char *session_name, *channel_name;
2515
2516 /* Test cases that need a tracing session enabled. */
2517 plan_tests(99);
2518
2519 /*
2520 * Argument 7 and upward are named pipe location for consumerd
2521 * control.
2522 */
2523 named_pipe_args_start = 7;
2524
2525 if (argc < 8) {
2526 fail("Missing parameter for tests to run %d", argc);
2527 goto error;
2528 }
2529
2530 nb_args = argc;
2531
2532 session_name = argv[5];
2533 channel_name = argv[6];
2534
2535 test_subscription_twice(session_name, channel_name,
2536 domain_type);
2537
2538 diag("Test trigger for domain %s with buffer_usage_low condition",
2539 domain_type_string);
2540 test_triggers_buffer_usage_condition(session_name, channel_name,
2541 domain_type,
2542 LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW);
2543
2544 diag("Test trigger for domain %s with buffer_usage_high condition",
2545 domain_type_string);
2546 test_triggers_buffer_usage_condition(session_name, channel_name,
2547 domain_type,
2548 LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH);
2549
2550 diag("Test buffer usage notification channel api for domain %s",
2551 domain_type_string);
2552 test_buffer_usage_notification_channel(session_name, channel_name,
2553 domain_type, argv);
2554 break;
2555 }
2556 case 3:
2557 {
2558 /*
2559 * Test cases that need a test app with more than one event
2560 * type.
2561 */
2562 plan_tests(23);
2563
2564 /*
2565 * At the moment, the only test case of this scenario is
2566 * exclusion which is only supported by UST.
2567 */
2568 assert(domain_type == LTTNG_DOMAIN_UST);
2569 diag("Test tracepoint event rule notifications with exclusion for domain %s",
2570 domain_type_string);
2571 test_tracepoint_event_rule_notification_exclusion(domain_type);
2572
2573 break;
2574 }
2575 case 4:
2576 {
2577 plan_tests(11);
2578 /* Test cases that need the kernel tracer. */
2579 assert(domain_type == LTTNG_DOMAIN_KERNEL);
2580
2581 diag("Test kprobe event rule notifications for domain %s",
2582 domain_type_string);
2583
2584 test_kprobe_event_rule_notification(domain_type);
2585
2586 break;
2587 }
2588 case 5:
2589 {
2590 plan_tests(23);
2591 /* Test cases that need the kernel tracer. */
2592 assert(domain_type == LTTNG_DOMAIN_KERNEL);
2593
2594 diag("Test syscall event rule notifications for domain %s",
2595 domain_type_string);
2596
2597 test_syscall_event_rule_notification(domain_type);
2598
2599 diag("Test syscall filtering event rule notifications for domain %s",
2600 domain_type_string);
2601
2602 test_syscall_event_rule_notification_filter(domain_type);
2603
2604 break;
2605 }
2606 case 6:
2607 {
2608 const char *testapp_path, *test_symbol_name;
2609
2610 plan_tests(11);
2611
2612 if (argc < 7) {
2613 fail("Missing parameter for tests to run %d", argc);
2614 goto error;
2615 }
2616
2617 testapp_path = argv[5];
2618 test_symbol_name = argv[6];
2619 /* Test cases that need the kernel tracer. */
2620 assert(domain_type == LTTNG_DOMAIN_KERNEL);
2621
2622 diag("Test userspace-probe event rule notifications for domain %s",
2623 domain_type_string);
2624
2625 test_uprobe_event_rule_notification(
2626 domain_type, testapp_path, test_symbol_name);
2627
2628 break;
2629 }
2630 case 7:
2631 {
2632 switch(domain_type) {
2633 case LTTNG_DOMAIN_UST:
2634 plan_tests(221);
2635 break;
2636 case LTTNG_DOMAIN_KERNEL:
2637 plan_tests(215);
2638 break;
2639 default:
2640 assert(0);
2641 }
2642
2643 diag("Test tracepoint event rule notification captures for domain %s",
2644 domain_type_string);
2645 test_tracepoint_event_rule_notification_capture(domain_type);
2646
2647 break;
2648 }
2649
2650 default:
2651 abort();
2652 }
2653
2654 error:
2655 return exit_status();
2656 }
2657
LTTng 2.0 tools and control repository
This page took 0.080244 seconds and 3 git commands to generate.