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 *name = NULL;
 583         enum lttng_evaluation_status status;
 584         const struct lttng_evaluation *evaluation;
 585         evaluation = lttng_notification_get_evaluation(notification);
 586         if (evaluation == NULL) {
 587                 fail("lttng_notification_get_evaluation");
 588                 goto end;
 589         }
 590
 591         switch (lttng_evaluation_get_type(evaluation)) {
 592         case LTTNG_CONDITION_TYPE_ON_EVENT:
 593         {
 594                 status = lttng_evaluation_on_event_get_trigger_name(
 595                                 evaluation, &name);
 596                 if (status != LTTNG_EVALUATION_STATUS_OK) {
 597                         fail("lttng_evaluation_on_event_get_trigger_name");
 598                         name = NULL;
 599                         goto end;
 600                 }
 601                 break;
 602         }
 603         default:
 604                 fail("Wrong notification evaluation type \n");
 605                 goto end;
 606         }
 607 end:
 608         return name;
 609 }
 610
 611 static int validator_notification_trigger_name(
 612                 struct lttng_notification *notification,
 613                 const char *trigger_name)
 614 {
 615         int ret;
 616         bool name_is_equal;
 617         const char *name;
 618
 619         assert(notification);
 620         assert(trigger_name);
 621
 622         name = get_notification_trigger_name(notification);
 623         if (name == NULL) {
 624                 ret = 1;
 625                 goto end;
 626         }
 627
 628         name_is_equal = (strcmp(trigger_name, name) == 0);
 629         ok(name_is_equal, "Expected trigger name: %s got %s", trigger_name,
 630                         name);
 631
 632         ret = !name_is_equal;
 633
 634 end:
 635         return ret;
 636 }
 637
 638 static
 639 void wait_on_file(const char *path, bool file_exist)
 640 {
 641         if (!path) {
 642                 return;
 643         }
 644         for (;;) {
 645                 int ret;
 646                 struct stat buf;
 647
 648                 ret = stat(path, &buf);
 649                 if (ret == -1 && errno == ENOENT) {
 650                         if (file_exist) {
 651                                 /*
 652                                  * The file does not exist. wait a bit and
 653                                  * continue looping until it does.
 654                                  */
 655                                 (void) poll(NULL, 0, 10);
 656                                 continue;
 657                         }
 658
 659                         /*
 660                          * File does not exist and the exit condition we want.
 661                          * Break from the loop and return.
 662                          */
 663                         break;
 664                 }
 665                 if (ret) {
 666                         perror("stat");
 667                         exit(EXIT_FAILURE);
 668                 }
 669                 /*
 670                  * stat() returned 0, so the file exists. break now only if
 671                  * that's the exit condition we want.
 672                  */
 673                 if (file_exist) {
 674                         break;
 675                 }
 676         }
 677 }
 678
 679 static
 680 int write_pipe(const char *path, uint8_t data)
 681 {
 682         int ret = 0;
 683         int fd = 0;
 684
 685         fd = open(path, O_WRONLY | O_NONBLOCK);
 686         if (fd < 0) {
 687                 perror("Could not open consumer control named pipe");
 688                 goto end;
 689         }
 690
 691         ret = write(fd, &data , sizeof(data));
 692         if (ret < 1) {
 693                 perror("Named pipe write failed");
 694                 if (close(fd)) {
 695                         perror("Named pipe close failed");
 696                 }
 697                 ret = -1;
 698                 goto end;
 699         }
 700
 701         ret = close(fd);
 702         if (ret < 0) {
 703                 perror("Name pipe closing failed");
 704                 ret = -1;
 705                 goto end;
 706         }
 707 end:
 708         return ret;
 709 }
 710
 711 static
 712 int stop_consumer(const char **argv)
 713 {
 714         int ret = 0, i;
 715
 716         for (i = named_pipe_args_start; i < nb_args; i++) {
 717                 ret = write_pipe(argv[i], 49);
 718         }
 719         return ret;
 720 }
 721
 722 static
 723 int resume_consumer(const char **argv)
 724 {
 725         int ret = 0, i;
 726
 727         for (i = named_pipe_args_start; i < nb_args; i++) {
 728                 ret = write_pipe(argv[i], 0);
 729         }
 730         return ret;
 731 }
 732
 733 static
 734 int suspend_application(void)
 735 {
 736         int ret;
 737         struct stat buf;
 738
 739         if (!stat(app_state_file, &buf)) {
 740                 fail("App is already in a suspended state.");
 741                 ret = -1;
 742                 goto error;
 743         }
 744
 745         /*
 746          * Send SIGUSR1 to application instructing it to bypass tracepoint.
 747          */
 748         assert(app_pid > 1);
 749
 750         ret = kill(app_pid, SIGUSR1);
 751         if (ret) {
 752                 fail("SIGUSR1 failed. errno %d", errno);
 753                 ret = -1;
 754                 goto error;
 755         }
 756
 757         wait_on_file(app_state_file, true);
 758
 759 error:
 760         return ret;
 761
 762 }
 763
 764 static
 765 int resume_application(void)
 766 {
 767         int ret;
 768         struct stat buf;
 769
 770         ret = stat(app_state_file, &buf);
 771         if (ret == -1 && errno == ENOENT) {
 772                 fail("State file does not exist");
 773                 goto error;
 774         }
 775         if (ret) {
 776                 perror("stat");
 777                 goto error;
 778         }
 779
 780         assert(app_pid > 1);
 781
 782         ret = kill(app_pid, SIGUSR1);
 783         if (ret) {
 784                 fail("SIGUSR1 failed. errno %d", errno);
 785                 ret = -1;
 786                 goto error;
 787         }
 788
 789         wait_on_file(app_state_file, false);
 790
 791 error:
 792         return ret;
 793
 794 }
 795
 796
 797 static
 798 void test_triggers_buffer_usage_condition(const char *session_name,
 799                 const char *channel_name,
 800                 enum lttng_domain_type domain_type,
 801                 enum lttng_condition_type condition_type)
 802 {
 803         unsigned int test_vector_size = 5, i;
 804         enum lttng_condition_status condition_status;
 805         struct lttng_action *action;
 806
 807         /* Set-up */
 808         action = lttng_action_notify_create();
 809         if (!action) {
 810                 fail("Setup error on action creation");
 811                 goto end;
 812         }
 813
 814         /* Test lttng_register_trigger with null value */
 815         ok(lttng_register_trigger(NULL) == -LTTNG_ERR_INVALID, "Registering a NULL trigger fails as expected");
 816
 817         /* Test: register a trigger */
 818
 819         for (i = 0; i < pow(2,test_vector_size); i++) {
 820                 int loop_ret = 0;
 821                 char *test_tuple_string = NULL;
 822                 unsigned int mask_position = 0;
 823                 bool session_name_set = false;
 824                 bool channel_name_set = false;
 825                 bool threshold_ratio_set = false;
 826                 bool threshold_byte_set = false;
 827                 bool domain_type_set = false;
 828
 829                 struct lttng_trigger *trigger = NULL;
 830                 struct lttng_condition *condition = NULL;
 831
 832                 /* Create base condition */
 833                 switch (condition_type) {
 834                 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
 835                         condition = lttng_condition_buffer_usage_low_create();
 836                         break;
 837                 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
 838                         condition = lttng_condition_buffer_usage_high_create();
 839                         break;
 840                 default:
 841                         loop_ret = 1;
 842                         goto loop_end;
 843                 }
 844
 845                 if (!condition) {
 846                         loop_ret = 1;
 847                         goto loop_end;
 848
 849                 }
 850
 851                 /* Prepare the condition for trigger registration test */
 852
 853                 /* Set session name */
 854                 if ((1 << mask_position) & i) {
 855                         condition_status = lttng_condition_buffer_usage_set_session_name(
 856                                         condition, session_name);
 857                         if (condition_status != LTTNG_CONDITION_STATUS_OK) {
 858                                 loop_ret = 1;
 859                                 goto loop_end;
 860                         }
 861                         session_name_set = true;
 862                 }
 863                 mask_position++;
 864
 865                 /* Set channel name */
 866                 if ((1 << mask_position) & i) {
 867                         condition_status = lttng_condition_buffer_usage_set_channel_name(
 868                                         condition, channel_name);
 869                         if (condition_status != LTTNG_CONDITION_STATUS_OK) {
 870                                 loop_ret = 1;
 871                                 goto loop_end;
 872                         }
 873                         channel_name_set = true;
 874                 }
 875                 mask_position++;
 876
 877                 /* Set threshold ratio */
 878                 if ((1 << mask_position) & i) {
 879                         condition_status = lttng_condition_buffer_usage_set_threshold_ratio(
 880                                         condition, 0.0);
 881                         if (condition_status != LTTNG_CONDITION_STATUS_OK) {
 882                                 loop_ret = 1;
 883                                 goto loop_end;
 884                         }
 885                         threshold_ratio_set = true;
 886                 }
 887                 mask_position++;
 888
 889                 /* Set threshold byte */
 890                 if ((1 << mask_position) & i) {
 891                         condition_status = lttng_condition_buffer_usage_set_threshold(
 892                                         condition, 0);
 893                         if (condition_status != LTTNG_CONDITION_STATUS_OK) {
 894                                 loop_ret = 1;
 895                                 goto loop_end;
 896                         }
 897                         threshold_byte_set = true;
 898                 }
 899                 mask_position++;
 900
 901                 /* Set domain type */
 902                 if ((1 << mask_position) & i) {
 903                         condition_status = lttng_condition_buffer_usage_set_domain_type(
 904                                         condition, LTTNG_DOMAIN_UST);
 905                         if (condition_status != LTTNG_CONDITION_STATUS_OK) {
 906                                 loop_ret = 1;
 907                                 goto loop_end;
 908                         }
 909                         domain_type_set = true;
 910                 }
 911
 912                 /* Safety check */
 913                 if (mask_position != test_vector_size -1) {
 914                         assert("Logic error for test vector generation");
 915                 }
 916
 917                 loop_ret = asprintf(&test_tuple_string, "session name %s, channel name %s, threshold ratio %s, threshold byte %s, domain type %s",
 918                                 session_name_set ? "set" : "unset",
 919                                 channel_name_set ? "set" : "unset",
 920                                 threshold_ratio_set ? "set" : "unset",
 921                                 threshold_byte_set ? "set" : "unset",
 922                                 domain_type_set? "set" : "unset");
 923                 if (!test_tuple_string || loop_ret < 0) {
 924                         loop_ret = 1;
 925                         goto loop_end;
 926                 }
 927
 928                 /* Create trigger */
 929                 trigger = lttng_trigger_create(condition, action);
 930                 if (!trigger) {
 931                         loop_ret = 1;
 932                         goto loop_end;
 933                 }
 934
 935                 loop_ret = lttng_register_trigger(trigger);
 936
 937 loop_end:
 938                 if (loop_ret == 1) {
 939                         fail("Setup error occurred for tuple: %s", test_tuple_string);
 940                         goto loop_cleanup;
 941                 }
 942
 943                 /* This combination happens three times */
 944                 if (session_name_set && channel_name_set
 945                                 && (threshold_ratio_set || threshold_byte_set)
 946                                 && domain_type_set) {
 947                         ok(loop_ret == 0, "Trigger is registered: %s", test_tuple_string);
 948
 949                         /*
 950                          * Test that a trigger cannot be registered
 951                          * multiple time.
 952                          */
 953                         loop_ret = lttng_register_trigger(trigger);
 954                         ok(loop_ret == -LTTNG_ERR_TRIGGER_EXISTS, "Re-register trigger fails as expected: %s", test_tuple_string);
 955
 956                         /* Test that a trigger can be unregistered */
 957                         loop_ret = lttng_unregister_trigger(trigger);
 958                         ok(loop_ret == 0, "Unregister trigger: %s", test_tuple_string);
 959
 960                         /*
 961                          * Test that unregistration of a non-previously
 962                          * registered trigger fail.
 963                          */
 964                         loop_ret = lttng_unregister_trigger(trigger);
 965                         ok(loop_ret == -LTTNG_ERR_TRIGGER_NOT_FOUND, "Unregister of a non-registered trigger fails as expected: %s", test_tuple_string);
 966                 } else {
 967                         ok(loop_ret == -LTTNG_ERR_INVALID_TRIGGER, "Trigger is invalid as expected and cannot be registered: %s", test_tuple_string);
 968                 }
 969
 970 loop_cleanup:
 971                 free(test_tuple_string);
 972                 lttng_trigger_destroy(trigger);
 973                 lttng_condition_destroy(condition);
 974         }
 975
 976 end:
 977         lttng_action_destroy(action);
 978 }
 979
 980 static
 981 void wait_data_pending(const char *session_name)
 982 {
 983         int ret;
 984
 985         do {
 986                 ret = lttng_data_pending(session_name);
 987                 assert(ret >= 0);
 988         } while (ret != 0);
 989 }
 990
 991 static
 992 int setup_buffer_usage_condition(struct lttng_condition *condition,
 993                 const char *condition_name,
 994                 const char *session_name,
 995                 const char *channel_name,
 996                 const enum lttng_domain_type domain_type)
 997 {
 998         enum lttng_condition_status condition_status;
 999         int ret = 0;
1000
1001         condition_status = lttng_condition_buffer_usage_set_session_name(
1002                         condition, session_name);
1003         if (condition_status != LTTNG_CONDITION_STATUS_OK) {
1004                 fail("Failed to set session name on creation of condition `%s`",
1005                                 condition_name);
1006                 ret = -1;
1007                 goto end;
1008         }
1009
1010         condition_status = lttng_condition_buffer_usage_set_channel_name(
1011                         condition, channel_name);
1012         if (condition_status != LTTNG_CONDITION_STATUS_OK) {
1013                 fail("Failed to set channel name on creation of condition `%s`",
1014                                 condition_name);
1015                 ret = -1;
1016                 goto end;
1017         }
1018
1019         condition_status = lttng_condition_buffer_usage_set_domain_type(
1020                         condition, domain_type);
1021         if (condition_status != LTTNG_CONDITION_STATUS_OK) {
1022                 fail("Failed to set domain type on creation of condition `%s`",
1023                                 condition_name);
1024                 ret = -1;
1025                 goto end;
1026         }
1027
1028 end:
1029         return ret;
1030 }
1031
1032 static
1033 void test_invalid_channel_subscription(
1034                 const enum lttng_domain_type domain_type)
1035 {
1036         enum lttng_condition_status condition_status;
1037         enum lttng_notification_channel_status nc_status;
1038         struct lttng_condition *dummy_condition = NULL;
1039         struct lttng_condition *dummy_invalid_condition = NULL;
1040         struct lttng_notification_channel *notification_channel = NULL;
1041         int ret = 0;
1042
1043         notification_channel = lttng_notification_channel_create(
1044                         lttng_session_daemon_notification_endpoint);
1045         ok(notification_channel, "Notification channel object creation");
1046         if (!notification_channel) {
1047                 goto end;
1048         }
1049
1050         /*
1051          * Create a dummy, empty (thus invalid) condition to test error paths.
1052          */
1053         dummy_invalid_condition = lttng_condition_buffer_usage_low_create();
1054         if (!dummy_invalid_condition) {
1055                 fail("Setup error on condition creation");
1056                 goto end;
1057         }
1058
1059         /*
1060          * Test subscription and unsubscription of an invalid condition to/from
1061          * a channel.
1062          */
1063         nc_status = lttng_notification_channel_subscribe(
1064                         notification_channel, dummy_invalid_condition);
1065         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
1066                         "Subscribing to an invalid condition");
1067
1068         nc_status = lttng_notification_channel_unsubscribe(
1069                         notification_channel, dummy_invalid_condition);
1070         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
1071                         "Unsubscribing from an invalid condition");
1072
1073         /* Create a valid dummy condition with a ratio of 0.5 */
1074         dummy_condition = lttng_condition_buffer_usage_low_create();
1075         if (!dummy_condition) {
1076                 fail("Setup error on dummy_condition creation");
1077                 goto end;
1078         }
1079
1080         condition_status = lttng_condition_buffer_usage_set_threshold_ratio(
1081                         dummy_condition, 0.5);
1082         if (condition_status != LTTNG_CONDITION_STATUS_OK) {
1083                 fail("Setup error on condition creation");
1084                 goto end;
1085         }
1086
1087         ret = setup_buffer_usage_condition(dummy_condition, "dummy_condition",
1088                         "dummy_session", "dummy_channel", domain_type);
1089         if (ret) {
1090                 fail("Setup error on dummy condition creation");
1091                 goto end;
1092         }
1093
1094         /*
1095          * Test subscription and unsubscription to/from a channel with invalid
1096          * parameters.
1097          */
1098         nc_status = lttng_notification_channel_subscribe(NULL, NULL);
1099         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
1100                         "Notification channel subscription is invalid: NULL, NULL");
1101
1102         nc_status = lttng_notification_channel_subscribe(
1103                         notification_channel, NULL);
1104         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
1105                         "Notification channel subscription is invalid: NON-NULL, NULL");
1106
1107         nc_status = lttng_notification_channel_subscribe(NULL, dummy_condition);
1108         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
1109                         "Notification channel subscription is invalid: NULL, NON-NULL");
1110
1111         nc_status = lttng_notification_channel_unsubscribe(
1112                         notification_channel, dummy_condition);
1113         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_UNKNOWN_CONDITION,
1114                         "Unsubscribing from a valid unknown condition");
1115
1116 end:
1117         lttng_notification_channel_destroy(notification_channel);
1118         lttng_condition_destroy(dummy_invalid_condition);
1119         lttng_condition_destroy(dummy_condition);
1120         return;
1121 }
1122
1123 enum buffer_usage_type {
1124         BUFFER_USAGE_TYPE_LOW,
1125         BUFFER_USAGE_TYPE_HIGH,
1126 };
1127
1128 static int register_buffer_usage_notify_trigger(const char *session_name,
1129                 const char *channel_name,
1130                 const enum lttng_domain_type domain_type,
1131                 enum buffer_usage_type buffer_usage_type,
1132                 double ratio,
1133                 struct lttng_condition **condition,
1134                 struct lttng_action **action,
1135                 struct lttng_trigger **trigger)
1136 {
1137         enum lttng_condition_status condition_status;
1138         struct lttng_action *tmp_action = NULL;
1139         struct lttng_condition *tmp_condition = NULL;
1140         struct lttng_trigger *tmp_trigger = NULL;
1141         int ret = 0;
1142
1143         /* Set-up */
1144         tmp_action = lttng_action_notify_create();
1145         if (!action) {
1146                 fail("Setup error on action creation");
1147                 ret = -1;
1148                 goto error;
1149         }
1150
1151         if (buffer_usage_type == BUFFER_USAGE_TYPE_LOW) {
1152                 tmp_condition = lttng_condition_buffer_usage_low_create();
1153         } else {
1154                 tmp_condition = lttng_condition_buffer_usage_high_create();
1155         }
1156
1157         if (!tmp_condition) {
1158                 fail("Setup error on condition creation");
1159                 ret = -1;
1160                 goto error;
1161         }
1162
1163         /* Set the buffer usage threashold */
1164         condition_status = lttng_condition_buffer_usage_set_threshold_ratio(
1165                         tmp_condition, ratio);
1166         if (condition_status != LTTNG_CONDITION_STATUS_OK) {
1167                 fail("Setup error on condition creation");
1168                 ret = -1;
1169                 goto error;
1170         }
1171
1172         ret = setup_buffer_usage_condition(tmp_condition, "condition_name",
1173                         session_name, channel_name, domain_type);
1174         if (ret) {
1175                 fail("Setup error on condition creation");
1176                 ret = -1;
1177                 goto error;
1178         }
1179
1180         /* Register the trigger for condition. */
1181         tmp_trigger = lttng_trigger_create(tmp_condition, tmp_action);
1182         if (!tmp_trigger) {
1183                 fail("Setup error on trigger creation");
1184                 ret = -1;
1185                 goto error;
1186         }
1187
1188         ret = lttng_register_trigger(tmp_trigger);
1189         if (ret) {
1190                 fail("Setup error on trigger registration");
1191                 ret = -1;
1192                 goto error;
1193         }
1194
1195         *condition = tmp_condition;
1196         *trigger = tmp_trigger;
1197         *action = tmp_action;
1198         goto end;
1199
1200 error:
1201         lttng_action_destroy(tmp_action);
1202         lttng_condition_destroy(tmp_condition);
1203         lttng_trigger_destroy(tmp_trigger);
1204
1205 end:
1206         return ret;
1207 }
1208
1209 static void test_subscription_twice(const char *session_name,
1210                 const char *channel_name,
1211                 const enum lttng_domain_type domain_type)
1212 {
1213         int ret = 0;
1214         enum lttng_notification_channel_status nc_status;
1215
1216         struct lttng_action *action = NULL;
1217         struct lttng_notification_channel *notification_channel = NULL;
1218         struct lttng_trigger *trigger = NULL;
1219
1220         struct lttng_condition *condition = NULL;
1221
1222         ret = register_buffer_usage_notify_trigger(session_name, channel_name,
1223                         domain_type, BUFFER_USAGE_TYPE_LOW, 0.99, &condition,
1224                         &action, &trigger);
1225         if (ret) {
1226                 fail("Setup error on trigger registration");
1227                 goto end;
1228         }
1229
1230         /* Begin testing. */
1231         notification_channel = lttng_notification_channel_create(
1232                         lttng_session_daemon_notification_endpoint);
1233         ok(notification_channel, "Notification channel object creation");
1234         if (!notification_channel) {
1235                 goto end;
1236         }
1237
1238         /* Subscribe a valid condition. */
1239         nc_status = lttng_notification_channel_subscribe(
1240                         notification_channel, condition);
1241         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1242                         "Subscribe to condition");
1243
1244         /* Subscribing again should fail. */
1245         nc_status = lttng_notification_channel_subscribe(
1246                         notification_channel, condition);
1247         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_ALREADY_SUBSCRIBED,
1248                         "Subscribe to a condition for which subscription was already done");
1249
1250 end:
1251         lttng_unregister_trigger(trigger);
1252         lttng_trigger_destroy(trigger);
1253         lttng_notification_channel_destroy(notification_channel);
1254         lttng_action_destroy(action);
1255         lttng_condition_destroy(condition);
1256 }
1257
1258 static void test_buffer_usage_notification_channel(const char *session_name,
1259                 const char *channel_name,
1260                 const enum lttng_domain_type domain_type,
1261                 const char **argv)
1262 {
1263         int ret = 0;
1264         enum lttng_notification_channel_status nc_status;
1265
1266         struct lttng_action *low_action = NULL;
1267         struct lttng_action *high_action = NULL;
1268         struct lttng_notification *notification = NULL;
1269         struct lttng_notification_channel *notification_channel = NULL;
1270         struct lttng_trigger *low_trigger = NULL;
1271         struct lttng_trigger *high_trigger = NULL;
1272
1273         struct lttng_condition *low_condition = NULL;
1274         struct lttng_condition *high_condition = NULL;
1275
1276         const double low_ratio = 0.0;
1277         const double high_ratio = 0.90;
1278
1279         ret = register_buffer_usage_notify_trigger(session_name, channel_name,
1280                         domain_type, BUFFER_USAGE_TYPE_LOW, low_ratio,
1281                         &low_condition, &low_action, &low_trigger);
1282         if (ret) {
1283                 fail("Setup error on low trigger registration");
1284                 goto end;
1285         }
1286
1287         ret = register_buffer_usage_notify_trigger(session_name, channel_name,
1288                         domain_type, BUFFER_USAGE_TYPE_HIGH, high_ratio,
1289                         &high_condition, &high_action, &high_trigger);
1290         if (ret) {
1291                 fail("Setup error on high trigger registration");
1292                 goto end;
1293         }
1294
1295         /* Begin testing */
1296         notification_channel = lttng_notification_channel_create(
1297                         lttng_session_daemon_notification_endpoint);
1298         ok(notification_channel, "Notification channel object creation");
1299         if (!notification_channel) {
1300                 goto end;
1301         }
1302
1303         /* Subscribe a valid low condition */
1304         nc_status = lttng_notification_channel_subscribe(
1305                         notification_channel, low_condition);
1306         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1307                         "Subscribe to low condition");
1308
1309         /* Subscribe a valid high condition */
1310         nc_status = lttng_notification_channel_subscribe(
1311                         notification_channel, high_condition);
1312         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1313                         "Subscribe to high condition");
1314
1315         resume_application();
1316
1317         /* Wait for notification to happen */
1318         stop_consumer(argv);
1319         lttng_start_tracing(session_name);
1320
1321         /* Wait for high notification */
1322         do {
1323                 nc_status = lttng_notification_channel_get_next_notification(
1324                                 notification_channel, &notification);
1325         } while (nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INTERRUPTED);
1326         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK && notification &&
1327                                         lttng_condition_get_type(lttng_notification_get_condition(
1328                                                         notification)) ==
1329                                                         LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH,
1330                         "High notification received after intermediary communication");
1331         lttng_notification_destroy(notification);
1332         notification = NULL;
1333
1334         suspend_application();
1335         lttng_stop_tracing_no_wait(session_name);
1336         resume_consumer(argv);
1337         wait_data_pending(session_name);
1338
1339         /*
1340          * Test that communication still work even if there is notification
1341          * waiting for consumption.
1342          */
1343
1344         nc_status = lttng_notification_channel_unsubscribe(
1345                         notification_channel, low_condition);
1346         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1347                         "Unsubscribe with pending notification");
1348
1349         nc_status = lttng_notification_channel_subscribe(
1350                         notification_channel, low_condition);
1351         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1352                         "Subscribe with pending notification");
1353
1354         do {
1355                 nc_status = lttng_notification_channel_get_next_notification(
1356                                 notification_channel, &notification);
1357         } while (nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INTERRUPTED);
1358         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK && notification &&
1359                                         lttng_condition_get_type(lttng_notification_get_condition(
1360                                                         notification)) ==
1361                                                         LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW,
1362                         "Low notification received after intermediary communication");
1363         lttng_notification_destroy(notification);
1364         notification = NULL;
1365
1366         /* Stop consumer to force a high notification */
1367         stop_consumer(argv);
1368         resume_application();
1369         lttng_start_tracing(session_name);
1370
1371         do {
1372                 nc_status = lttng_notification_channel_get_next_notification(
1373                                 notification_channel, &notification);
1374         } while (nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INTERRUPTED);
1375         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK && notification &&
1376                                         lttng_condition_get_type(lttng_notification_get_condition(
1377                                                         notification)) ==
1378                                                         LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH,
1379                         "High notification received after intermediary communication");
1380         lttng_notification_destroy(notification);
1381         notification = NULL;
1382
1383         suspend_application();
1384         lttng_stop_tracing_no_wait(session_name);
1385         resume_consumer(argv);
1386         wait_data_pending(session_name);
1387
1388         do {
1389                 nc_status = lttng_notification_channel_get_next_notification(
1390                                 notification_channel, &notification);
1391         } while (nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INTERRUPTED);
1392         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK && notification &&
1393                                         lttng_condition_get_type(lttng_notification_get_condition(
1394                                                         notification)) ==
1395                                                         LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW,
1396                         "Low notification received after re-subscription");
1397         lttng_notification_destroy(notification);
1398         notification = NULL;
1399
1400         stop_consumer(argv);
1401         resume_application();
1402         /* Stop consumer to force a high notification */
1403         lttng_start_tracing(session_name);
1404
1405         do {
1406                 nc_status = lttng_notification_channel_get_next_notification(
1407                                 notification_channel, &notification);
1408         } while (nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INTERRUPTED);
1409         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK && notification &&
1410                                         lttng_condition_get_type(lttng_notification_get_condition(
1411                                                         notification)) ==
1412                                                         LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH,
1413                         "High notification");
1414         lttng_notification_destroy(notification);
1415         notification = NULL;
1416
1417         suspend_application();
1418
1419         /* Resume consumer to allow event consumption */
1420         lttng_stop_tracing_no_wait(session_name);
1421         resume_consumer(argv);
1422         wait_data_pending(session_name);
1423
1424         nc_status = lttng_notification_channel_unsubscribe(
1425                         notification_channel, low_condition);
1426         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1427                         "Unsubscribe low condition with pending notification");
1428
1429         nc_status = lttng_notification_channel_unsubscribe(
1430                         notification_channel, high_condition);
1431         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1432                         "Unsubscribe high condition with pending notification");
1433
1434 end:
1435         lttng_notification_channel_destroy(notification_channel);
1436         lttng_trigger_destroy(low_trigger);
1437         lttng_trigger_destroy(high_trigger);
1438         lttng_action_destroy(low_action);
1439         lttng_action_destroy(high_action);
1440         lttng_condition_destroy(low_condition);
1441         lttng_condition_destroy(high_condition);
1442 }
1443
1444 static void create_tracepoint_event_rule_trigger(const char *event_pattern,
1445                 const char *trigger_name,
1446                 const char *filter,
1447                 unsigned int exclusion_count,
1448                 const char * const *exclusions,
1449                 enum lttng_domain_type domain_type,
1450                 condition_capture_desc_cb capture_desc_cb,
1451                 struct lttng_condition **condition,
1452                 struct lttng_trigger **trigger)
1453 {
1454         enum lttng_event_rule_status event_rule_status;
1455         enum lttng_trigger_status trigger_status;
1456
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
1463         assert(event_pattern);
1464         assert(trigger_name);
1465         assert(condition);
1466         assert(trigger);
1467
1468         event_rule = lttng_event_rule_tracepoint_create(domain_type);
1469         ok(event_rule, "Tracepoint event rule object creation");
1470
1471         event_rule_status = lttng_event_rule_tracepoint_set_pattern(
1472                         event_rule, event_pattern);
1473         ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
1474                         "Setting tracepoint event rule pattern: '%s'",
1475                         event_pattern);
1476
1477         if (filter) {
1478                 event_rule_status = lttng_event_rule_tracepoint_set_filter(
1479                                 event_rule, filter);
1480                 ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
1481                                 "Setting tracepoint event rule filter: '%s'",
1482                                 filter);
1483         }
1484
1485         if (exclusions) {
1486                 int i;
1487                 bool success = true;
1488
1489                 assert(domain_type == LTTNG_DOMAIN_UST);
1490                 assert(exclusion_count > 0);
1491
1492                 for (i = 0; i < exclusion_count; i++) {
1493                         event_rule_status =
1494                                         lttng_event_rule_tracepoint_add_exclusion(
1495                                                         event_rule,
1496                                                         exclusions[i]);
1497                         if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
1498                                 fail("Setting tracepoint event rule exclusion '%s'.",
1499                                                 exclusions[i]);
1500                                 success = false;
1501                         }
1502                 }
1503
1504                 ok(success, "Setting tracepoint event rule exclusions");
1505         }
1506
1507         tmp_condition = lttng_condition_on_event_create(event_rule);
1508         ok(tmp_condition, "Condition event rule object creation");
1509
1510         if (capture_desc_cb) {
1511                 ret = capture_desc_cb(tmp_condition);
1512                 if (ret) {
1513                         fail("Failed to generate the condition capture descriptor");
1514                         abort();
1515                 }
1516         }
1517
1518         tmp_action = lttng_action_notify_create();
1519         ok(tmp_action, "Action event rule object creation");
1520
1521         tmp_trigger = lttng_trigger_create(tmp_condition, tmp_action);
1522         ok(tmp_trigger, "Trigger object creation %s", trigger_name);
1523
1524         trigger_status = lttng_trigger_set_name(tmp_trigger, trigger_name);
1525         ok(trigger_status == LTTNG_TRIGGER_STATUS_OK,
1526                         "Setting name to trigger %s", trigger_name);
1527
1528         ret = lttng_register_trigger(tmp_trigger);
1529         ok(ret == 0, "Trigger registration %s", trigger_name);
1530
1531         lttng_event_rule_destroy(event_rule);
1532
1533         *condition = tmp_condition;
1534         *trigger = tmp_trigger;
1535
1536         return;
1537 }
1538
1539 static struct lttng_notification *get_next_notification(
1540                 struct lttng_notification_channel *notification_channel)
1541 {
1542         struct lttng_notification *local_notification = NULL;
1543         enum lttng_notification_channel_status status;
1544
1545         /* Receive the next notification. */
1546         status = lttng_notification_channel_get_next_notification(
1547                         notification_channel, &local_notification);
1548
1549         switch (status) {
1550         case LTTNG_NOTIFICATION_CHANNEL_STATUS_OK:
1551                 break;
1552         case LTTNG_NOTIFICATION_CHANNEL_STATUS_NOTIFICATIONS_DROPPED:
1553                 fail("Notifications have been dropped");
1554                 local_notification = NULL;
1555                 break;
1556         default:
1557                 /* Unhandled conditions / errors. */
1558                 fail("Failed to get next notification (unknown notification channel status): status = %d",
1559                                 (int) status);
1560                 local_notification = NULL;
1561                 break;
1562         }
1563
1564         return local_notification;
1565 }
1566
1567 static void test_tracepoint_event_rule_notification(
1568                 enum lttng_domain_type domain_type)
1569 {
1570         int i;
1571         int ret;
1572         const int notification_count = 3;
1573         enum lttng_notification_channel_status nc_status;
1574         struct lttng_action *action = NULL;
1575         struct lttng_condition *condition = NULL;
1576         struct lttng_notification_channel *notification_channel = NULL;
1577         struct lttng_trigger *trigger = NULL;
1578         const char * const trigger_name = "my_precious";
1579         const char *pattern;
1580
1581         if (domain_type == LTTNG_DOMAIN_UST) {
1582                 pattern = "tp:tptest";
1583         } else {
1584                 pattern = "lttng_test_filter_event";
1585         }
1586
1587         create_tracepoint_event_rule_trigger(pattern, trigger_name, NULL, 0,
1588                         NULL, domain_type, NULL, &condition, &trigger);
1589
1590         notification_channel = lttng_notification_channel_create(
1591                         lttng_session_daemon_notification_endpoint);
1592         ok(notification_channel, "Notification channel object creation");
1593
1594         nc_status = lttng_notification_channel_subscribe(
1595                         notification_channel, condition);
1596         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1597                         "Subscribe to tracepoint event rule condition");
1598
1599         resume_application();
1600
1601         /* Get notifications. */
1602         for (i = 0; i < notification_count; i++) {
1603                 struct lttng_notification *notification = get_next_notification(
1604                                 notification_channel);
1605
1606                 ok(notification, "Received notification (%d/%d)", i + 1,
1607                                 notification_count);
1608
1609                 /* Error. */
1610                 if (notification == NULL) {
1611                         goto end;
1612                 }
1613
1614                 ret = validator_notification_trigger_name(notification, trigger_name);
1615                 lttng_notification_destroy(notification);
1616                 if (ret) {
1617                         goto end;
1618                 }
1619         }
1620
1621 end:
1622         suspend_application();
1623         lttng_notification_channel_destroy(notification_channel);
1624         lttng_unregister_trigger(trigger);
1625         lttng_trigger_destroy(trigger);
1626         lttng_action_destroy(action);
1627         lttng_condition_destroy(condition);
1628         return;
1629 }
1630
1631 static void test_tracepoint_event_rule_notification_filter(
1632                 enum lttng_domain_type domain_type)
1633 {
1634         int i;
1635         const int notification_count = 3;
1636         enum lttng_notification_channel_status nc_status;
1637         struct lttng_condition *ctrl_condition = NULL, *condition = NULL;
1638         struct lttng_notification_channel *notification_channel = NULL;
1639         struct lttng_trigger *ctrl_trigger = NULL, *trigger = NULL;
1640         const char * const ctrl_trigger_name = "control_trigger";
1641         const char * const trigger_name = "trigger";
1642         const char *pattern;
1643         int ctrl_count = 0, count = 0;
1644
1645         if (domain_type == LTTNG_DOMAIN_UST) {
1646                 pattern = "tp:tptest";
1647         } else {
1648                 pattern = "lttng_test_filter_event";
1649         }
1650
1651         notification_channel = lttng_notification_channel_create(
1652                         lttng_session_daemon_notification_endpoint);
1653         ok(notification_channel, "Notification channel object creation");
1654
1655         create_tracepoint_event_rule_trigger(pattern, ctrl_trigger_name, NULL,
1656                         0, NULL, domain_type, NULL, &ctrl_condition, &ctrl_trigger);
1657
1658         nc_status = lttng_notification_channel_subscribe(
1659                         notification_channel, ctrl_condition);
1660         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1661                         "Subscribe to tracepoint event rule condition");
1662
1663         /*
1664          * Attach a filter expression to get notification only if the
1665          * `intfield` is even.
1666          */
1667         create_tracepoint_event_rule_trigger(pattern, trigger_name,
1668                         "(intfield & 1) == 0", 0, NULL, domain_type, NULL, &condition,
1669                         &trigger);
1670
1671         nc_status = lttng_notification_channel_subscribe(
1672                         notification_channel, condition);
1673         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1674                         "Subscribe to tracepoint event rule condition");
1675
1676         /*
1677          * We registered 2 notifications triggers, one with a filter and one
1678          * without (control). The one with a filter will only fired when the
1679          * `intfield` is a multiple of 2. We should get two times as many
1680          * control notifications as filter notifications.
1681          */
1682         resume_application();
1683
1684         /*
1685          * Get 3 notifications. We should get 1 for the regular trigger (with
1686          * the filter) and 2 from the control trigger. This works whatever
1687          * the order we receive the notifications.
1688          */
1689         for (i = 0; i < notification_count; i++) {
1690                 const char *name;
1691                 struct lttng_notification *notification = get_next_notification(
1692                                 notification_channel);
1693
1694                 ok(notification, "Received notification (%d/%d)", i + 1,
1695                                 notification_count);
1696
1697                 /* Error. */
1698                 if (notification == NULL) {
1699                         goto end;
1700                 }
1701
1702                 name = get_notification_trigger_name(notification);
1703                 if (name == NULL) {
1704                         lttng_notification_destroy(notification);
1705                         goto end;
1706                 }
1707
1708                 if (strcmp(ctrl_trigger_name, name) == 0) {
1709                         ctrl_count++;
1710                 } else if (strcmp(trigger_name, name) == 0) {
1711                         count++;
1712                 }
1713
1714                 lttng_notification_destroy(notification);
1715         }
1716
1717         ok(ctrl_count / 2 == count,
1718                         "Get twice as many control notif as of regular notif");
1719
1720 end:
1721         suspend_application();
1722
1723         lttng_unregister_trigger(trigger);
1724         lttng_unregister_trigger(ctrl_trigger);
1725         lttng_notification_channel_destroy(notification_channel);
1726         lttng_trigger_destroy(trigger);
1727         lttng_trigger_destroy(ctrl_trigger);
1728         lttng_condition_destroy(condition);
1729         lttng_condition_destroy(ctrl_condition);
1730 }
1731
1732 static void test_tracepoint_event_rule_notification_exclusion(
1733                 enum lttng_domain_type domain_type)
1734 {
1735         enum lttng_notification_channel_status nc_status;
1736         struct lttng_condition *ctrl_condition = NULL, *condition = NULL;
1737         struct lttng_notification_channel *notification_channel = NULL;
1738         struct lttng_trigger *ctrl_trigger = NULL, *trigger = NULL;
1739         int ctrl_count = 0, count = 0, i;
1740         const int notification_count = 6;
1741         const char * const ctrl_trigger_name = "control_exclusion_trigger";
1742         const char * const trigger_name = "exclusion_trigger";
1743         const char * const pattern = "tp:tptest*";
1744         const char * const exclusions[] = {
1745                 "tp:tptest2",
1746                 "tp:tptest3",
1747                 "tp:tptest4",
1748                 "tp:tptest5"
1749         };
1750
1751         notification_channel = lttng_notification_channel_create(
1752                         lttng_session_daemon_notification_endpoint);
1753         ok(notification_channel, "Notification channel object creation");
1754
1755         create_tracepoint_event_rule_trigger(pattern, ctrl_trigger_name, NULL,
1756                         0, NULL, domain_type, NULL, &ctrl_condition,
1757                         &ctrl_trigger);
1758
1759         nc_status = lttng_notification_channel_subscribe(
1760                         notification_channel, ctrl_condition);
1761         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1762                         "Subscribe to tracepoint event rule condition");
1763
1764         create_tracepoint_event_rule_trigger(pattern, trigger_name, NULL, 4,
1765                         exclusions, domain_type, NULL, &condition,
1766                         &trigger);
1767
1768         nc_status = lttng_notification_channel_subscribe(
1769                         notification_channel, condition);
1770         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1771                         "Subscribe to tracepoint event rule condition");
1772
1773         /*
1774          * We registered 2 notifications triggers, one with an exclusion and
1775          * one without (control).
1776          * - The trigger with an exclusion will fire once every iteration.
1777          * - The trigger without an exclusion will fire 5 times every
1778          *   iteration.
1779          *
1780          *   We should get 5 times as many notifications from the control
1781          *   trigger.
1782          */
1783         resume_application();
1784
1785         /*
1786          * Get 6 notifications. We should get 1 for the regular trigger (with
1787          * the exclusion) and 5 from the control trigger. This works whatever
1788          * the order we receive the notifications.
1789          */
1790         for (i = 0; i < notification_count; i++) {
1791                 const char *name;
1792                 struct lttng_notification *notification = get_next_notification(
1793                                 notification_channel);
1794
1795                 ok(notification, "Received notification (%d/%d)", i + 1,
1796                                 notification_count);
1797
1798                 /* Error. */
1799                 if (notification == NULL) {
1800                         goto end;
1801                 }
1802
1803                 name = get_notification_trigger_name(notification);
1804                 if (name == NULL) {
1805                         lttng_notification_destroy(notification);
1806                         goto end;
1807                 }
1808
1809                 if (strcmp(ctrl_trigger_name, name) == 0) {
1810                         ctrl_count++;
1811                 } else if (strcmp(trigger_name, name) == 0) {
1812                         count++;
1813                 }
1814
1815                 lttng_notification_destroy(notification);
1816         }
1817
1818         ok(ctrl_count / 5 == count,
1819                         "Got 5 times as many control notif as of regular notif");
1820
1821 end:
1822         suspend_application();
1823
1824         lttng_unregister_trigger(trigger);
1825         lttng_unregister_trigger(ctrl_trigger);
1826         lttng_notification_channel_destroy(notification_channel);
1827         lttng_trigger_destroy(trigger);
1828         lttng_trigger_destroy(ctrl_trigger);
1829         lttng_condition_destroy(condition);
1830         lttng_condition_destroy(ctrl_condition);
1831         return;
1832 }
1833
1834 static void test_kprobe_event_rule_notification(
1835                 enum lttng_domain_type domain_type)
1836 {
1837         int i, ret;
1838         const int notification_count = 3;
1839         enum lttng_notification_channel_status nc_status;
1840         enum lttng_event_rule_status event_rule_status;
1841         enum lttng_trigger_status trigger_status;
1842         struct lttng_notification_channel *notification_channel = NULL;
1843         struct lttng_condition *condition = NULL;
1844         struct lttng_kernel_probe_location *location = NULL;
1845         struct lttng_event_rule *event_rule = NULL;
1846         struct lttng_action *action = NULL;
1847         struct lttng_trigger *trigger = NULL;
1848         const char * const trigger_name = "kprobe_trigger";
1849         const char * const symbol_name = "lttng_test_filter_event_write";
1850
1851         action = lttng_action_notify_create();
1852         if (!action) {
1853                 fail("Failed to create notify action");
1854                 goto end;
1855         }
1856
1857         location = lttng_kernel_probe_location_symbol_create(symbol_name, 0);
1858         if (!location) {
1859                 fail("Failed to create kernel probe location");
1860                 goto end;
1861         }
1862
1863         notification_channel = lttng_notification_channel_create(
1864                         lttng_session_daemon_notification_endpoint);
1865         ok(notification_channel, "Notification channel object creation");
1866
1867         event_rule = lttng_event_rule_kernel_probe_create(location);
1868         ok(event_rule, "kprobe event rule object creation");
1869
1870         event_rule_status = lttng_event_rule_kernel_probe_set_event_name(
1871                         event_rule, trigger_name);
1872         ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
1873                         "Setting kprobe event rule name: '%s'", trigger_name);
1874
1875         condition = lttng_condition_on_event_create(event_rule);
1876         ok(condition, "Condition event rule object creation");
1877
1878         /* Register the trigger for condition. */
1879         trigger = lttng_trigger_create(condition, action);
1880         if (!trigger) {
1881                 fail("Failed to create trigger with kernel probe event rule condition and notify action");
1882                 goto end;
1883         }
1884
1885         trigger_status = lttng_trigger_set_name(trigger, trigger_name);
1886         ok(trigger_status == LTTNG_TRIGGER_STATUS_OK,
1887                         "Setting trigger name to '%s'", trigger_name);
1888
1889         ret = lttng_register_trigger(trigger);
1890         if (ret) {
1891                 fail("Failed to register trigger with kernel probe event rule condition and notify action");
1892                 goto end;
1893         }
1894
1895         nc_status = lttng_notification_channel_subscribe(
1896                         notification_channel, condition);
1897         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
1898                         "Subscribe to tracepoint event rule condition");
1899
1900         resume_application();
1901
1902         for (i = 0; i < notification_count; i++) {
1903                 struct lttng_notification *notification = get_next_notification(
1904                                 notification_channel);
1905
1906                 ok(notification, "Received notification (%d/%d)", i + 1,
1907                                 notification_count);
1908
1909                 /* Error. */
1910                 if (notification == NULL) {
1911                         goto end;
1912                 }
1913
1914                 ret = validator_notification_trigger_name(notification, trigger_name);
1915                 lttng_notification_destroy(notification);
1916                 if (ret) {
1917                         goto end;
1918                 }
1919         }
1920
1921 end:
1922         suspend_application();
1923         lttng_notification_channel_destroy(notification_channel);
1924         lttng_unregister_trigger(trigger);
1925         lttng_trigger_destroy(trigger);
1926         lttng_action_destroy(action);
1927         lttng_event_rule_destroy(event_rule);
1928         lttng_condition_destroy(condition);
1929         lttng_kernel_probe_location_destroy(location);
1930         return;
1931 }
1932
1933 static void test_uprobe_event_rule_notification(
1934                 enum lttng_domain_type domain_type,
1935                 const char *testapp_path,
1936                 const char *test_symbol_name)
1937 {
1938         int i, ret;
1939         const int notification_count = 3;
1940         enum lttng_notification_channel_status nc_status;
1941         enum lttng_event_rule_status event_rule_status;
1942         enum lttng_trigger_status trigger_status;
1943         struct lttng_notification_channel *notification_channel = NULL;
1944         struct lttng_userspace_probe_location *probe_location = NULL;
1945         struct lttng_userspace_probe_location_lookup_method *lookup_method =
1946                         NULL;
1947         struct lttng_condition *condition = NULL;
1948         struct lttng_event_rule *event_rule = NULL;
1949         struct lttng_action *action = NULL;
1950         struct lttng_trigger *trigger = NULL;
1951         const char * const trigger_name = "uprobe_trigger";
1952
1953         action = lttng_action_notify_create();
1954         if (!action) {
1955                 fail("Failed to create notify action");
1956                 goto end;
1957         }
1958
1959         lookup_method = lttng_userspace_probe_location_lookup_method_function_elf_create();
1960         if (!lookup_method) {
1961                 fail("Setup error on userspace probe lookup method creation");
1962                 goto end;
1963         }
1964
1965         probe_location = lttng_userspace_probe_location_function_create(
1966                         testapp_path, test_symbol_name, lookup_method);
1967         if (!probe_location) {
1968                 fail("Failed to create userspace probe location");
1969                 goto end;
1970         }
1971
1972         notification_channel = lttng_notification_channel_create(
1973                         lttng_session_daemon_notification_endpoint);
1974         ok(notification_channel, "Notification channel object creation");
1975
1976         event_rule = lttng_event_rule_userspace_probe_create();
1977         ok(event_rule, "kprobe event rule object creation");
1978
1979         event_rule_status = lttng_event_rule_userspace_probe_set_location(
1980                         event_rule, probe_location);
1981         ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
1982                         "Setting uprobe event rule location");
1983
1984         event_rule_status = lttng_event_rule_userspace_probe_set_name(
1985                         event_rule, trigger_name);
1986         ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
1987                         "Setting uprobe event rule name: '%s'", trigger_name);
1988
1989         condition = lttng_condition_on_event_create(event_rule);
1990         ok(condition, "Condition event rule object creation");
1991
1992         /* Register the trigger for condition. */
1993         trigger = lttng_trigger_create(condition, action);
1994         if (!trigger) {
1995                 fail("Failed to create trigger with userspace probe event rule condition and notify action");
1996                 goto end;
1997         }
1998
1999         trigger_status = lttng_trigger_set_name(trigger, trigger_name);
2000         ok(trigger_status == LTTNG_TRIGGER_STATUS_OK,
2001                         "Setting name to trigger '%s'", trigger_name);
2002
2003         ret = lttng_register_trigger(trigger);
2004         if (ret) {
2005                 fail("Failed to register trigger with userspace probe event rule condition and notify action");
2006                 goto end;
2007         }
2008
2009         nc_status = lttng_notification_channel_subscribe(
2010                         notification_channel, condition);
2011         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
2012                         "Subscribe to tracepoint event rule condition");
2013
2014         resume_application();
2015
2016         for (i = 0; i < 3; i++) {
2017                 struct lttng_notification *notification = get_next_notification(
2018                                 notification_channel);
2019
2020                 ok(notification, "Received notification (%d/%d)", i + 1,
2021                                 notification_count);
2022
2023                 /* Error. */
2024                 if (notification == NULL) {
2025                         goto end;
2026                 }
2027
2028                 ret = validator_notification_trigger_name(notification, trigger_name);
2029                 lttng_notification_destroy(notification);
2030                 if (ret) {
2031                         goto end;
2032                 }
2033         }
2034 end:
2035         suspend_application();
2036
2037         lttng_notification_channel_destroy(notification_channel);
2038         lttng_unregister_trigger(trigger);
2039         lttng_trigger_destroy(trigger);
2040         lttng_action_destroy(action);
2041         lttng_userspace_probe_location_destroy(probe_location);
2042         lttng_event_rule_destroy(event_rule);
2043         lttng_condition_destroy(condition);
2044         return;
2045 }
2046
2047 static void test_syscall_event_rule_notification(
2048                 enum lttng_domain_type domain_type)
2049 {
2050         int i, ret;
2051         const int notification_count = 3;
2052         enum lttng_notification_channel_status nc_status;
2053         enum lttng_event_rule_status event_rule_status;
2054         enum lttng_trigger_status trigger_status;
2055         struct lttng_notification_channel *notification_channel = NULL;
2056         struct lttng_condition *condition = NULL;
2057         struct lttng_event_rule *event_rule = NULL;
2058         struct lttng_action *action = NULL;
2059         struct lttng_trigger *trigger = NULL;
2060         const char * const trigger_name = "syscall_trigger";
2061         const char * const syscall_name = "openat";
2062
2063         action = lttng_action_notify_create();
2064         if (!action) {
2065                 fail("Failed to create notify action");
2066                 goto end;
2067         }
2068
2069         notification_channel = lttng_notification_channel_create(
2070                         lttng_session_daemon_notification_endpoint);
2071         ok(notification_channel, "Notification channel object creation");
2072
2073         event_rule = lttng_event_rule_syscall_create();
2074         ok(event_rule, "syscall event rule object creation");
2075
2076         event_rule_status = lttng_event_rule_syscall_set_pattern(
2077                         event_rule, syscall_name);
2078         ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
2079                         "Setting syscall event rule pattern: '%s'", syscall_name);
2080
2081         condition = lttng_condition_on_event_create(event_rule);
2082         ok(condition, "Condition syscall event rule object creation");
2083
2084         /* Register the trigger for condition. */
2085         trigger = lttng_trigger_create(condition, action);
2086         if (!trigger) {
2087                 fail("Failed to create trigger with syscall event rule condition and notify action");
2088                 goto end;
2089         }
2090
2091         trigger_status = lttng_trigger_set_name(trigger, trigger_name);
2092         ok(trigger_status == LTTNG_TRIGGER_STATUS_OK,
2093                         "Setting name to trigger '%s'", trigger_name);
2094
2095         ret = lttng_register_trigger(trigger);
2096         if (ret) {
2097                 fail("Failed to register trigger with syscall event rule condition and notify action");
2098                 goto end;
2099         }
2100
2101         nc_status = lttng_notification_channel_subscribe(
2102                         notification_channel, condition);
2103         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
2104                         "Subscribe to tracepoint event rule condition");
2105
2106         resume_application();
2107
2108         for (i = 0; i < notification_count; i++) {
2109                 struct lttng_notification *notification = get_next_notification(
2110                                 notification_channel);
2111
2112                 ok(notification, "Received notification (%d/%d)", i + 1,
2113                                 notification_count);
2114
2115                 /* Error. */
2116                 if (notification == NULL) {
2117                         goto end;
2118                 }
2119
2120                 ret = validator_notification_trigger_name(notification, trigger_name);
2121                 lttng_notification_destroy(notification);
2122                 if (ret) {
2123                         goto end;
2124                 }
2125         }
2126 end:
2127         suspend_application();
2128         lttng_notification_channel_destroy(notification_channel);
2129         lttng_unregister_trigger(trigger);
2130         lttng_trigger_destroy(trigger);
2131         lttng_action_destroy(action);
2132         lttng_condition_destroy(condition);
2133         return;
2134 }
2135
2136 static void test_syscall_event_rule_notification_filter(
2137                 enum lttng_domain_type domain_type)
2138 {
2139         int i, ret;
2140         const int notification_count = 3;
2141         enum lttng_notification_channel_status nc_status;
2142         enum lttng_event_rule_status event_rule_status;
2143         enum lttng_trigger_status trigger_status;
2144         struct lttng_notification_channel *notification_channel = NULL;
2145         struct lttng_condition *condition = NULL;
2146         struct lttng_event_rule *event_rule = NULL;
2147         struct lttng_action *action = NULL;
2148         struct lttng_trigger *trigger = NULL;
2149         const char * const trigger_name = "syscall_trigger";
2150         const char * const syscall_name = "openat";
2151         const char * const filter_pattern = "filename == \"/proc/cpuinfo\"";
2152
2153         action = lttng_action_notify_create();
2154         if (!action) {
2155                 fail("Failed to create notify action");
2156                 goto end;
2157         }
2158
2159         notification_channel = lttng_notification_channel_create(
2160                         lttng_session_daemon_notification_endpoint);
2161         ok(notification_channel, "Notification channel object creation");
2162
2163         event_rule = lttng_event_rule_syscall_create();
2164         ok(event_rule, "syscall event rule object creation");
2165
2166         event_rule_status = lttng_event_rule_syscall_set_pattern(
2167                         event_rule, syscall_name);
2168         ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
2169                         "Setting syscall event rule pattern: '%s'", syscall_name);
2170
2171         event_rule_status = lttng_event_rule_syscall_set_filter(
2172                         event_rule, filter_pattern);
2173         ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK,
2174                         "Setting filter: '%s'", filter_pattern);
2175
2176         condition = lttng_condition_on_event_create(event_rule);
2177         ok(condition, "Condition event rule object creation");
2178
2179         /* Register the triggers for condition */
2180         trigger = lttng_trigger_create(condition, action);
2181         if (!trigger) {
2182                 fail("Failed to create trigger with syscall filtering event rule condition and notify action");
2183                 goto end;
2184         }
2185
2186         trigger_status = lttng_trigger_set_name(trigger, trigger_name);
2187         ok(trigger_status == LTTNG_TRIGGER_STATUS_OK,
2188                         "Setting name to trigger '%s'", trigger_name);
2189
2190         ret = lttng_register_trigger(trigger);
2191         if (ret) {
2192                 fail("Failed to register trigger with syscall filtering event rule condition and notify action");
2193                 goto end;
2194         }
2195
2196         nc_status = lttng_notification_channel_subscribe(
2197                         notification_channel, condition);
2198         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
2199                         "Subscribe to tracepoint event rule condition");
2200
2201         resume_application();
2202
2203         for (i = 0; i < notification_count; i++) {
2204                 struct lttng_notification *notification = get_next_notification(
2205                                 notification_channel);
2206
2207                 ok(notification, "Received notification (%d/%d)", i + 1,
2208                                 notification_count);
2209
2210                 /* Error. */
2211                 if (notification == NULL) {
2212                         goto end;
2213                 }
2214
2215                 ret = validator_notification_trigger_name(notification, trigger_name);
2216                 lttng_notification_destroy(notification);
2217                 if (ret) {
2218                         goto end;
2219                 }
2220         }
2221
2222 end:
2223         suspend_application();
2224
2225         lttng_unregister_trigger(trigger);
2226         lttng_notification_channel_destroy(notification_channel);
2227         lttng_trigger_destroy(trigger);
2228         lttng_event_rule_destroy(event_rule);
2229         lttng_condition_destroy(condition);
2230         return;
2231 }
2232
2233 static int generate_capture_descr(struct lttng_condition *condition)
2234 {
2235         int ret, i;
2236         struct lttng_event_expr *expr = NULL;
2237         const unsigned int basic_field_count = sizeof(test_capture_base_fields) /
2238                         sizeof(*test_capture_base_fields);
2239         enum lttng_condition_status cond_status;
2240
2241         for (i = 0; i < basic_field_count; i++) {
2242                 diag("Adding capture descriptor '%s'",
2243                                 test_capture_base_fields[i].field_name);
2244
2245                 switch (test_capture_base_fields[i].field_type) {
2246                 case FIELD_TYPE_PAYLOAD:
2247                         expr = lttng_event_expr_event_payload_field_create(
2248                                         test_capture_base_fields[i].field_name);
2249                         break;
2250                 case FIELD_TYPE_CONTEXT:
2251                         expr = lttng_event_expr_channel_context_field_create(
2252                                         test_capture_base_fields[i].field_name);
2253                         break;
2254                 case FIELD_TYPE_ARRAY_FIELD:
2255                 {
2256                         int nb_matches;
2257                         unsigned int index;
2258                         char field_name[FIELD_NAME_MAX_LEN];
2259                         struct lttng_event_expr *array_expr = NULL;
2260
2261                         nb_matches = sscanf(test_capture_base_fields[i].field_name,
2262                                         "%[^[][%u]", field_name, &index);
2263                         if (nb_matches != 2) {
2264                                 fail("Unexpected array field name format: field name = '%s'",
2265                                                 test_capture_base_fields[i].field_name);
2266                                 ret = 1;
2267                                 goto end;
2268                         }
2269
2270                         array_expr = lttng_event_expr_event_payload_field_create(
2271                                 field_name);
2272
2273                         expr = lttng_event_expr_array_field_element_create(
2274                                 array_expr, index);
2275                         break;
2276                 }
2277                 case FIELD_TYPE_APP_CONTEXT:
2278                         fail("Application context tests are not implemented yet.");
2279                         /* fallthrough. */
2280                 default:
2281                         ret = 1;
2282                         goto end;
2283                 }
2284
2285                 if (expr == NULL) {
2286                         fail("Failed to create capture expression");
2287                         ret = -1;
2288                         goto end;
2289                 }
2290
2291                 cond_status = lttng_condition_on_event_append_capture_descriptor(
2292                                 condition, expr);
2293                 if (cond_status != LTTNG_CONDITION_STATUS_OK) {
2294                         fail("Failed to append capture descriptor");
2295                         ret = -1;
2296                         lttng_event_expr_destroy(expr);
2297                         goto end;
2298                 }
2299         }
2300
2301         ret = 0;
2302
2303 end:
2304         return ret;
2305 }
2306
2307 static int validator_notification_trigger_capture(
2308                 enum lttng_domain_type domain,
2309                 struct lttng_notification *notification,
2310                 const int iteration)
2311 {
2312         int ret;
2313         unsigned int capture_count, i;
2314         enum lttng_evaluation_status evaluation_status;
2315         enum lttng_event_field_value_status event_field_value_status;
2316         const struct lttng_evaluation *evaluation;
2317         const struct lttng_event_field_value *captured_fields;
2318         bool at_least_one_error = false;
2319
2320         evaluation = lttng_notification_get_evaluation(notification);
2321         if (evaluation == NULL) {
2322                 fail("Failed to get evaluation from notification during trigger capture test");
2323                 ret = 1;
2324                 goto end;
2325         }
2326
2327         evaluation_status = lttng_evaluation_on_event_get_captured_values(
2328                         evaluation, &captured_fields);
2329         if (evaluation_status != LTTNG_EVALUATION_STATUS_OK) {
2330                 diag("Failed to get event rule evaluation captured values: status = %d",
2331                                 (int) evaluation_status);
2332                 ret = 1;
2333                 goto end;
2334         }
2335
2336         event_field_value_status =
2337                 lttng_event_field_value_array_get_length(captured_fields,
2338                                 &capture_count);
2339         if (event_field_value_status != LTTNG_EVENT_FIELD_VALUE_STATUS_OK) {
2340                 fail("Failed to get count of captured value field array");
2341                 ret = 1;
2342                 goto end;
2343         }
2344
2345         for (i = 0; i < capture_count; i++) {
2346                 const struct lttng_event_field_value *captured_field = NULL;
2347                 validate_cb validate;
2348                 bool expected;
2349
2350                 diag("Validating capture of field '%s'",
2351                                 test_capture_base_fields[i].field_name);
2352                 event_field_value_status =
2353                                 lttng_event_field_value_array_get_element_at_index(
2354                                                 captured_fields, i,
2355                                                 &captured_field);
2356
2357                 switch(domain) {
2358                 case LTTNG_DOMAIN_UST:
2359                         expected = test_capture_base_fields[i].expected_ust;
2360                         break;
2361                 case LTTNG_DOMAIN_KERNEL:
2362                         expected = test_capture_base_fields[i].expected_kernel;
2363                         break;
2364                 default:
2365                         fail("Unexpected domain encountered: domain = %d",
2366                                         (int) domain);
2367                         ret = 1;
2368                         goto end;
2369                 }
2370
2371                 if (domain == LTTNG_DOMAIN_UST) {
2372                         validate = test_capture_base_fields[i].validate_ust;
2373                 } else {
2374                         validate = test_capture_base_fields[i].validate_kernel;
2375                 }
2376
2377                 if (!expected) {
2378                         ok(event_field_value_status == LTTNG_EVENT_FIELD_VALUE_STATUS_UNAVAILABLE,
2379                                         "No payload captured");
2380                         continue;
2381                 }
2382
2383                 if (event_field_value_status != LTTNG_EVENT_FIELD_VALUE_STATUS_OK) {
2384                         if (event_field_value_status ==
2385                                         LTTNG_EVENT_FIELD_VALUE_STATUS_UNAVAILABLE) {
2386                                 fail("Expected a capture but it is unavailable");
2387                         } else {
2388                                 fail("lttng_event_field_value_array_get_element_at_index returned an error: status = %d",
2389                                                 (int) event_field_value_status);
2390                         }
2391
2392                         ret = 1;
2393                         goto end;
2394                 }
2395
2396                 diag("Captured field of type %s",
2397                                 field_value_type_to_str(
2398                                         lttng_event_field_value_get_type(captured_field)));
2399
2400                 assert(validate);
2401                 ret = validate(captured_field, iteration);
2402                 if (ret) {
2403                         at_least_one_error = true;
2404                 }
2405         }
2406
2407         ret = at_least_one_error;
2408
2409 end:
2410         return ret;
2411 }
2412
2413 static void test_tracepoint_event_rule_notification_capture(
2414                 enum lttng_domain_type domain_type)
2415 {
2416         enum lttng_notification_channel_status nc_status;
2417
2418         int i, ret;
2419         struct lttng_condition *condition = NULL;
2420         struct lttng_notification_channel *notification_channel = NULL;
2421         struct lttng_trigger *trigger = NULL;
2422         const char *trigger_name = "my_precious";
2423         const char *pattern;
2424
2425         if (domain_type == LTTNG_DOMAIN_UST) {
2426                 pattern = "tp:tptest";
2427         } else {
2428                 pattern = "lttng_test_filter_event";
2429         }
2430
2431         create_tracepoint_event_rule_trigger(pattern, trigger_name, NULL, 0,
2432                         NULL, domain_type, generate_capture_descr, &condition,
2433                         &trigger);
2434
2435         notification_channel = lttng_notification_channel_create(
2436                         lttng_session_daemon_notification_endpoint);
2437         ok(notification_channel, "Notification channel object creation");
2438
2439         nc_status = lttng_notification_channel_subscribe(
2440                         notification_channel, condition);
2441         ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
2442                         "Subscribe to tracepoint event rule condition");
2443
2444         resume_application();
2445
2446         /* Get 3 notifications */
2447         for (i = 0; i < 3; i++) {
2448                 struct lttng_notification *notification = get_next_notification(
2449                                 notification_channel);
2450                 ok(notification, "Received notification");
2451
2452                 /* Error */
2453                 if (notification == NULL) {
2454                         goto end;
2455                 }
2456
2457                 ret = validator_notification_trigger_name(notification, trigger_name);
2458                 if (ret) {
2459                         lttng_notification_destroy(notification);
2460                         goto end;
2461                 }
2462
2463                 ret = validator_notification_trigger_capture(domain_type, notification, i);
2464                 if (ret) {
2465                         lttng_notification_destroy(notification);
2466                         goto end;
2467                 }
2468
2469                 lttng_notification_destroy(notification);
2470         }
2471
2472 end:
2473         suspend_application();
2474         lttng_notification_channel_destroy(notification_channel);
2475         lttng_unregister_trigger(trigger);
2476         lttng_trigger_destroy(trigger);
2477         lttng_condition_destroy(condition);
2478         return;
2479 }
2480
2481 int main(int argc, const char *argv[])
2482 {
2483         int test_scenario;
2484         const char *domain_type_string = NULL;
2485         enum lttng_domain_type domain_type = LTTNG_DOMAIN_NONE;
2486
2487         if (argc < 5) {
2488                 fail("Missing test scenario, domain type, pid, or application state file argument(s)");
2489                 goto error;
2490         }
2491
2492         test_scenario = atoi(argv[1]);
2493         domain_type_string = argv[2];
2494         app_pid = (pid_t) atoi(argv[3]);
2495         app_state_file = argv[4];
2496
2497         if (!strcmp("LTTNG_DOMAIN_UST", domain_type_string)) {
2498                 domain_type = LTTNG_DOMAIN_UST;
2499         }
2500         if (!strcmp("LTTNG_DOMAIN_KERNEL", domain_type_string)) {
2501                 domain_type = LTTNG_DOMAIN_KERNEL;
2502         }
2503         if (domain_type == LTTNG_DOMAIN_NONE) {
2504                 fail("Unknown domain type");
2505                 goto error;
2506         }
2507
2508         /*
2509          * Test cases are responsible for resuming the app when needed
2510          * and making sure it's suspended when returning.
2511          */
2512         suspend_application();
2513
2514         switch (test_scenario) {
2515         case 1:
2516         {
2517                 plan_tests(44);
2518
2519                 /* Test cases that need gen-ust-event testapp. */
2520                 diag("Test basic notification error paths for %s domain",
2521                                 domain_type_string);
2522                 test_invalid_channel_subscription(domain_type);
2523
2524                 diag("Test tracepoint event rule notifications for domain %s",
2525                                 domain_type_string);
2526                 test_tracepoint_event_rule_notification(domain_type);
2527
2528                 diag("Test tracepoint event rule notifications with filter for domain %s",
2529                                 domain_type_string);
2530                 test_tracepoint_event_rule_notification_filter(domain_type);
2531                 break;
2532         }
2533         case 2:
2534         {
2535                 const char *session_name, *channel_name;
2536
2537                 /* Test cases that need a tracing session enabled. */
2538                 plan_tests(99);
2539
2540                 /*
2541                  * Argument 7 and upward are named pipe location for consumerd
2542                  * control.
2543                  */
2544                 named_pipe_args_start = 7;
2545
2546                 if (argc < 8) {
2547                         fail("Missing parameter for tests to run %d", argc);
2548                         goto error;
2549                 }
2550
2551                 nb_args = argc;
2552
2553                 session_name = argv[5];
2554                 channel_name = argv[6];
2555
2556                 test_subscription_twice(session_name, channel_name,
2557                                 domain_type);
2558
2559                 diag("Test trigger for domain %s with buffer_usage_low condition",
2560                                 domain_type_string);
2561                 test_triggers_buffer_usage_condition(session_name, channel_name,
2562                                 domain_type,
2563                                 LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW);
2564
2565                 diag("Test trigger for domain %s with buffer_usage_high condition",
2566                                 domain_type_string);
2567                 test_triggers_buffer_usage_condition(session_name, channel_name,
2568                                 domain_type,
2569                                 LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH);
2570
2571                 diag("Test buffer usage notification channel api for domain %s",
2572                                 domain_type_string);
2573                 test_buffer_usage_notification_channel(session_name, channel_name,
2574                                 domain_type, argv);
2575                 break;
2576         }
2577         case 3:
2578         {
2579                 /*
2580                  * Test cases that need a test app with more than one event
2581                  * type.
2582                  */
2583                 plan_tests(25);
2584
2585                 /*
2586                  * At the moment, the only test case of this scenario is
2587                  * exclusion which is only supported by UST.
2588                  */
2589                 assert(domain_type == LTTNG_DOMAIN_UST);
2590                 diag("Test tracepoint event rule notifications with exclusion for domain %s",
2591                                 domain_type_string);
2592                 test_tracepoint_event_rule_notification_exclusion(domain_type);
2593
2594                 break;
2595         }
2596         case 4:
2597         {
2598                 plan_tests(12);
2599                 /* Test cases that need the kernel tracer. */
2600                 assert(domain_type == LTTNG_DOMAIN_KERNEL);
2601
2602                 diag("Test kprobe event rule notifications for domain %s",
2603                                 domain_type_string);
2604
2605                 test_kprobe_event_rule_notification(domain_type);
2606
2607                 break;
2608         }
2609         case 5:
2610         {
2611                 plan_tests(25);
2612                 /* Test cases that need the kernel tracer. */
2613                 assert(domain_type == LTTNG_DOMAIN_KERNEL);
2614
2615                 diag("Test syscall event rule notifications for domain %s",
2616                                 domain_type_string);
2617
2618                 test_syscall_event_rule_notification(domain_type);
2619
2620                 diag("Test syscall filtering event rule notifications for domain %s",
2621                                 domain_type_string);
2622
2623                 test_syscall_event_rule_notification_filter(domain_type);
2624
2625                 break;
2626         }
2627         case 6:
2628         {
2629                 const char *testapp_path, *test_symbol_name;
2630
2631                 plan_tests(13);
2632
2633                 if (argc < 7) {
2634                         fail("Missing parameter for tests to run %d", argc);
2635                         goto error;
2636                 }
2637
2638                 testapp_path = argv[5];
2639                 test_symbol_name = argv[6];
2640                 /* Test cases that need the kernel tracer. */
2641                 assert(domain_type == LTTNG_DOMAIN_KERNEL);
2642
2643                 diag("Test userspace-probe event rule notifications for domain %s",
2644                                 domain_type_string);
2645
2646                 test_uprobe_event_rule_notification(
2647                                 domain_type, testapp_path, test_symbol_name);
2648
2649                 break;
2650         }
2651         case 7:
2652         {
2653                 switch(domain_type) {
2654                 case LTTNG_DOMAIN_UST:
2655                         plan_tests(222);
2656                         break;
2657                 case LTTNG_DOMAIN_KERNEL:
2658                         plan_tests(216);
2659                         break;
2660                 default:
2661                         assert(0);
2662                 }
2663
2664                 diag("Test tracepoint event rule notification captures for domain %s",
2665                                 domain_type_string);
2666                 test_tracepoint_event_rule_notification_capture(domain_type);
2667
2668                 break;
2669         }
2670
2671         default:
2672                 abort();
2673         }
2674
2675 error:
2676         return exit_status();
2677 }
2678