tests/unit/test_event_rule.c

   1 /*
   2  * Unit tests for the notification API.
   3  *
   4  * Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
   5  *
   6  * SPDX-License-Identifier: LGPL-2.1-only
   7  *
   8  */
   9
  10 #include <assert.h>
  11 #include <inttypes.h>
  12 #include <stdio.h>
  13 #include <string.h>
  14 #include <unistd.h>
  15
  16 #include <tap/tap.h>
  17
  18 #include <common/payload-view.h>
  19 #include <common/payload.h>
  20 #include <lttng/domain.h>
  21 #include <lttng/event-rule/kernel-kprobe-internal.h>
  22 #include <lttng/event-rule/kernel-kprobe.h>
  23 #include <lttng/event-rule/kernel-syscall-internal.h>
  24 #include <lttng/event-rule/kernel-syscall.h>
  25 #include <lttng/event-rule/tracepoint-internal.h>
  26 #include <lttng/event-rule/tracepoint.h>
  27 #include <lttng/event-rule/kernel-tracepoint-internal.h>
  28 #include <lttng/event-rule/kernel-tracepoint.h>
  29 #include <lttng/event-rule/kernel-uprobe-internal.h>
  30 #include <lttng/event-rule/kernel-uprobe.h>
  31 #include <lttng/event-rule/user-tracepoint-internal.h>
  32 #include <lttng/event-rule/user-tracepoint.h>
  33 #include <lttng/event.h>
  34 #include <lttng/kernel-probe-internal.h>
  35 #include <lttng/kernel-probe.h>
  36 #include <lttng/userspace-probe-internal.h>
  37 #include <lttng/userspace-probe.h>
  38 #include "bin/lttng/loglevel.h"
  39
  40 /* For error.h. */
  41 int lttng_opt_quiet = 1;
  42 int lttng_opt_verbose;
  43 int lttng_opt_mi;
  44
  45 #define NUM_TESTS 278
  46
  47 struct tracepoint_test {
  48         enum lttng_domain_type type;
  49         bool support_name_pattern_exclusion;
  50 };
  51
  52 typedef const char *(*log_level_name_getter)(int log_level);
  53
  54 static
  55 void test_event_rule_tracepoint_by_domain(const struct tracepoint_test *test)
  56 {
  57         unsigned int count;
  58         struct lttng_event_rule *tracepoint = NULL;
  59         struct lttng_event_rule *tracepoint_from_buffer = NULL;
  60         enum lttng_event_rule_status status;
  61         enum lttng_domain_type domain_type, type;
  62         const char *pattern="my_event_*";
  63         const char *filter="msg_id == 23 && size >= 2048";
  64         const char *tmp;
  65         const char *name_pattern_exclusions[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
  66         struct lttng_log_level_rule *log_level_rule = NULL;
  67         const struct lttng_log_level_rule *log_level_rule_return = NULL;
  68         struct lttng_payload payload;
  69
  70         type = test->type;
  71         diag("Testing domain %d.", type);
  72
  73         lttng_payload_init(&payload);
  74
  75         log_level_rule = lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO);
  76         assert(log_level_rule);
  77
  78         tracepoint = lttng_event_rule_tracepoint_create(type);
  79         ok(tracepoint, "tracepoint object.");
  80
  81         status = lttng_event_rule_tracepoint_get_domain_type(tracepoint, &domain_type);
  82         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "get tracepoint domain.");
  83         ok(domain_type == type, "domain type got %d expected %d.", domain_type, type);
  84
  85         status = lttng_event_rule_tracepoint_set_name_pattern(tracepoint, pattern);
  86         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
  87         status = lttng_event_rule_tracepoint_get_name_pattern(tracepoint, &tmp);
  88         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
  89         ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
  90
  91         status = lttng_event_rule_tracepoint_set_filter(tracepoint, filter);
  92         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
  93         status = lttng_event_rule_tracepoint_get_filter(tracepoint, &tmp);
  94         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
  95         ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
  96
  97         status = lttng_event_rule_tracepoint_get_log_level_rule(tracepoint, &log_level_rule_return);
  98         ok(status == LTTNG_EVENT_RULE_STATUS_UNSET, "get unset log level rule.");
  99
 100         if (type != LTTNG_DOMAIN_KERNEL) {
 101                 status = lttng_event_rule_tracepoint_set_log_level_rule(tracepoint, log_level_rule);
 102                 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting log level rule.");
 103                 status = lttng_event_rule_tracepoint_get_log_level_rule(tracepoint, &log_level_rule_return);
 104                 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "get log level rule.");
 105         }
 106
 107         if (test->support_name_pattern_exclusion) {
 108                 int i;
 109
 110                 for (i = 0; i < 3; i++) {
 111                         status = lttng_event_rule_tracepoint_add_name_pattern_exclusion(tracepoint, name_pattern_exclusions[i]);
 112                         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting name pattern exclusions \"%s\"", name_pattern_exclusions[i]);
 113                 }
 114
 115                 status = lttng_event_rule_tracepoint_get_name_pattern_exclusion_count(tracepoint, &count);
 116                 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting name pattern exclusion count.");
 117                 ok(count == 3, "count is %d/3", count);
 118
 119                 for (i = 0; i < count; i++) {
 120                         status = lttng_event_rule_tracepoint_get_name_pattern_exclusion_at_index(tracepoint, i, &tmp);
 121                         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting name pattern exclusion at index %d.", i);
 122                         ok(!strncmp(name_pattern_exclusions[i], tmp, strlen(name_pattern_exclusions[i])), "%s == %s.", tmp, name_pattern_exclusions[i]);
 123                 }
 124         } else {
 125                 int i;
 126
 127                 for (i = 0; i < 3; i++) {
 128                         status = lttng_event_rule_tracepoint_add_name_pattern_exclusion(tracepoint, name_pattern_exclusions[i]);
 129                         ok(status == LTTNG_EVENT_RULE_STATUS_UNSUPPORTED, "setting name pattern exclusions unsupported \"%s\".", name_pattern_exclusions[i]);
 130                 }
 131
 132                 status = lttng_event_rule_tracepoint_get_name_pattern_exclusion_count(tracepoint, &count);
 133                 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting name pattern exclusion count.");
 134                 ok(count == 0, "count is %d/0", count);
 135         }
 136
 137         ok(lttng_event_rule_serialize(tracepoint, &payload) == 0, "Serializing.");
 138
 139         {
 140                 struct lttng_payload_view view =
 141                                 lttng_payload_view_from_payload(
 142                                                 &payload, 0, -1);
 143
 144                 ok(lttng_event_rule_create_from_payload(
 145                                 &view, &tracepoint_from_buffer) > 0,
 146                                 "Deserializing.");
 147         }
 148
 149         ok(lttng_event_rule_is_equal(tracepoint, tracepoint_from_buffer), "serialized and from buffer are equal.");
 150
 151         lttng_payload_reset(&payload);
 152         lttng_event_rule_destroy(tracepoint);
 153         lttng_event_rule_destroy(tracepoint_from_buffer);
 154         lttng_log_level_rule_destroy(log_level_rule);
 155 }
 156
 157 static
 158 void test_event_rule_tracepoint(void)
 159 {
 160         int i;
 161         struct lttng_event_rule *tracepoint = NULL;
 162         struct tracepoint_test tests[] = {{LTTNG_DOMAIN_JUL, false},
 163                         {LTTNG_DOMAIN_KERNEL, false},
 164                         {LTTNG_DOMAIN_LOG4J, false},
 165                         {LTTNG_DOMAIN_PYTHON, false},
 166                         {LTTNG_DOMAIN_UST, true}};
 167
 168         diag("Testing lttng_event_rule_tracepoint.");
 169         tracepoint = lttng_event_rule_tracepoint_create(LTTNG_DOMAIN_NONE);
 170         ok(!tracepoint, "Domain type restriction on create.");
 171
 172         for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
 173                 test_event_rule_tracepoint_by_domain(&tests[i]);
 174         }
 175 }
 176
 177 static
 178 void test_event_rule_kernel_tracepoint(void)
 179 {
 180         struct lttng_event_rule *tracepoint = NULL;
 181         struct lttng_event_rule *tracepoint_from_buffer = NULL;
 182         enum lttng_event_rule_status status;
 183         const char *pattern="my_event_*";
 184         const char *filter="msg_id == 23 && size >= 2048";
 185         const char *tmp;
 186         struct lttng_payload payload;
 187
 188         diag("Testing lttng_event_rule_kernel_tracepoint.");
 189
 190         lttng_payload_init(&payload);
 191
 192         tracepoint = lttng_event_rule_kernel_tracepoint_create();
 193         ok(tracepoint, "tracepoint object.");
 194
 195         status = lttng_event_rule_kernel_tracepoint_set_name_pattern(tracepoint, pattern);
 196         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
 197         status = lttng_event_rule_kernel_tracepoint_get_name_pattern(tracepoint, &tmp);
 198         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
 199         ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
 200
 201         status = lttng_event_rule_kernel_tracepoint_set_filter(tracepoint, filter);
 202         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
 203         status = lttng_event_rule_kernel_tracepoint_get_filter(tracepoint, &tmp);
 204         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
 205         ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
 206
 207         ok(lttng_event_rule_serialize(tracepoint, &payload) == 0, "Serializing.");
 208
 209         {
 210                 struct lttng_payload_view view =
 211                                 lttng_payload_view_from_payload(
 212                                                 &payload, 0, -1);
 213
 214                 ok(lttng_event_rule_create_from_payload(
 215                                 &view, &tracepoint_from_buffer) > 0,
 216                                 "Deserializing.");
 217         }
 218
 219         ok(lttng_event_rule_is_equal(tracepoint, tracepoint_from_buffer), "serialized and from buffer are equal.");
 220
 221         lttng_payload_reset(&payload);
 222         lttng_event_rule_destroy(tracepoint);
 223         lttng_event_rule_destroy(tracepoint_from_buffer);
 224 }
 225
 226 static
 227 void test_event_rule_user_tracepoint(void)
 228 {
 229         int i;
 230         unsigned int count;
 231         struct lttng_event_rule *tracepoint = NULL;
 232         struct lttng_event_rule *tracepoint_from_buffer = NULL;
 233         enum lttng_event_rule_status status;
 234         const char *pattern="my_event_*";
 235         const char *filter="msg_id == 23 && size >= 2048";
 236         const char *tmp;
 237         const char *name_pattern_exclusions[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
 238         struct lttng_log_level_rule *log_level_rule = NULL;
 239         const struct lttng_log_level_rule *log_level_rule_return = NULL;
 240         struct lttng_payload payload;
 241
 242         diag("Testing lttng_event_rule_user_tracepoint.");
 243
 244         lttng_payload_init(&payload);
 245
 246         log_level_rule = lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO);
 247         assert(log_level_rule);
 248
 249         tracepoint = lttng_event_rule_user_tracepoint_create();
 250         ok(tracepoint, "user tracepoint object.");
 251
 252         status = lttng_event_rule_user_tracepoint_set_name_pattern(tracepoint, pattern);
 253         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
 254         status = lttng_event_rule_user_tracepoint_get_name_pattern(tracepoint, &tmp);
 255         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
 256         ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
 257
 258         status = lttng_event_rule_user_tracepoint_set_filter(tracepoint, filter);
 259         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
 260         status = lttng_event_rule_user_tracepoint_get_filter(tracepoint, &tmp);
 261         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
 262         ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
 263
 264         status = lttng_event_rule_user_tracepoint_get_log_level_rule(tracepoint, &log_level_rule_return);
 265         ok(status == LTTNG_EVENT_RULE_STATUS_UNSET, "get unset log level rule.");
 266
 267         status = lttng_event_rule_user_tracepoint_set_log_level_rule(
 268                         tracepoint, log_level_rule);
 269         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting log level rule.");
 270         status = lttng_event_rule_user_tracepoint_get_log_level_rule(
 271                         tracepoint, &log_level_rule_return);
 272         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "get log level rule.");
 273
 274         /* Name pattern exclusions */
 275         for (i = 0; i < 3; i++) {
 276                 status = lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(
 277                                 tracepoint, name_pattern_exclusions[i]);
 278                 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
 279                                 "setting name pattern exclusions \"%s\"",
 280                                 name_pattern_exclusions[i]);
 281         }
 282
 283         status = lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
 284                         tracepoint, &count);
 285         ok(status == LTTNG_EVENT_RULE_STATUS_OK,
 286                         "getting name pattern exclusion count.");
 287         ok(count == 3, "count is %d/3", count);
 288
 289         for (i = 0; i < count; i++) {
 290                 status = lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
 291                                 tracepoint, i, &tmp);
 292                 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
 293                                 "getting name pattern exclusion at index %d.",
 294                                 i);
 295                 ok(!strncmp(name_pattern_exclusions[i], tmp,
 296                                    strlen(name_pattern_exclusions[i])),
 297                                 "%s == %s.", tmp, name_pattern_exclusions[i]);
 298         }
 299
 300         ok(lttng_event_rule_serialize(tracepoint, &payload) == 0, "Serializing.");
 301
 302         {
 303                 struct lttng_payload_view view =
 304                                 lttng_payload_view_from_payload(
 305                                                 &payload, 0, -1);
 306
 307                 ok(lttng_event_rule_create_from_payload(
 308                                 &view, &tracepoint_from_buffer) > 0,
 309                                 "Deserializing.");
 310         }
 311
 312         ok(lttng_event_rule_is_equal(tracepoint, tracepoint_from_buffer), "serialized and from buffer are equal.");
 313
 314         lttng_payload_reset(&payload);
 315         lttng_event_rule_destroy(tracepoint);
 316         lttng_event_rule_destroy(tracepoint_from_buffer);
 317         lttng_log_level_rule_destroy(log_level_rule);
 318 }
 319
 320 static void test_event_rule_syscall(void)
 321 {
 322         struct lttng_event_rule *syscall = NULL;
 323         struct lttng_event_rule *syscall_from_buffer = NULL;
 324         enum lttng_event_rule_status status;
 325         const char *pattern = "my_event_*";
 326         const char *filter = "msg_id == 23 && size >= 2048";
 327         const char *tmp;
 328         struct lttng_payload payload;
 329
 330         diag("Event rule syscall.");
 331
 332         lttng_payload_init(&payload);
 333
 334         syscall = lttng_event_rule_kernel_syscall_create(LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY);
 335         ok(syscall, "syscall object.");
 336
 337         status = lttng_event_rule_kernel_syscall_set_name_pattern(syscall, pattern);
 338         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
 339         status = lttng_event_rule_kernel_syscall_get_name_pattern(syscall, &tmp);
 340         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
 341         ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
 342
 343         status = lttng_event_rule_kernel_syscall_set_filter(syscall, filter);
 344         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
 345         status = lttng_event_rule_kernel_syscall_get_filter(syscall, &tmp);
 346         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
 347         ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
 348
 349         ok(lttng_event_rule_serialize(syscall, &payload) == 0, "Serializing.");
 350
 351         {
 352                 struct lttng_payload_view view =
 353                                 lttng_payload_view_from_payload(
 354                                                 &payload, 0, -1);
 355
 356                 ok(lttng_event_rule_create_from_payload(
 357                                    &view, &syscall_from_buffer) > 0,
 358                                 "Deserializing.");
 359         }
 360
 361         ok(lttng_event_rule_is_equal(syscall, syscall_from_buffer),
 362                         "serialized and from buffer are equal.");
 363
 364         lttng_payload_reset(&payload);
 365         lttng_event_rule_destroy(syscall);
 366         lttng_event_rule_destroy(syscall_from_buffer);
 367 }
 368
 369 static void test_event_rule_userspace_probe(void)
 370 {
 371         struct lttng_event_rule *uprobe = NULL;
 372         struct lttng_event_rule *uprobe_from_buffer = NULL;
 373         struct lttng_userspace_probe_location_lookup_method *lookup_method =
 374                         NULL;
 375         struct lttng_userspace_probe_location *probe_location = NULL;
 376         const struct lttng_userspace_probe_location *probe_location_tmp = NULL;
 377         enum lttng_event_rule_status status;
 378
 379         const char *probe_name = "my_probe.";
 380         const char *tmp;
 381         struct lttng_payload payload;
 382
 383         diag("Event rule uprobe.");
 384
 385         lookup_method = lttng_userspace_probe_location_lookup_method_function_elf_create();
 386         if (!lookup_method) {
 387                 fail("Setup error on userspace probe lookup method creation.");
 388                 goto end;
 389         }
 390
 391         probe_location = lttng_userspace_probe_location_function_create(
 392                         "/proc/self/exe",
 393                         "lttng_userspace_probe_location_tracepoint_create",
 394                         lookup_method);
 395         if (!probe_location) {
 396                 fail("Setup error on userspace probe location creation.");
 397                 goto end;
 398         }
 399
 400         /* Ownership transferred to the probe location function object. */
 401         lookup_method = NULL;
 402
 403         lttng_payload_init(&payload);
 404
 405         uprobe = lttng_event_rule_kernel_uprobe_create(probe_location);
 406         ok(uprobe, "uprobe event rule object creation.");
 407
 408         status = lttng_event_rule_kernel_uprobe_get_location(
 409                         uprobe, &probe_location_tmp);
 410         ok(status == LTTNG_EVENT_RULE_STATUS_OK,
 411                         "Getting uprobe event rule location.");
 412         ok(lttng_userspace_probe_location_is_equal(
 413                            probe_location, probe_location_tmp),
 414                         "Location is equal.");
 415
 416         status = lttng_event_rule_kernel_uprobe_set_event_name(uprobe, probe_name);
 417         ok(status == LTTNG_EVENT_RULE_STATUS_OK,
 418                         "Setting uprobe event rule name: %s.", probe_name);
 419         status = lttng_event_rule_kernel_uprobe_get_event_name(uprobe, &tmp);
 420         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "Getting uprobe name.");
 421         ok(!strcmp(probe_name, tmp), "Uprobe name are equal.");
 422
 423         ok(lttng_event_rule_serialize(uprobe, &payload) == 0, "Serializing.");
 424
 425         {
 426                 struct lttng_payload_view view =
 427                                 lttng_payload_view_from_payload(
 428                                                 &payload, 0, -1);
 429
 430                 ok(lttng_event_rule_create_from_payload(
 431                                    &view, &uprobe_from_buffer) > 0,
 432                                 "Deserializing.");
 433         }
 434
 435         ok(lttng_event_rule_is_equal(uprobe, uprobe_from_buffer),
 436                         "serialized and from buffer are equal.");
 437
 438 end:
 439         lttng_payload_reset(&payload);
 440         lttng_event_rule_destroy(uprobe);
 441         lttng_event_rule_destroy(uprobe_from_buffer);
 442         lttng_userspace_probe_location_destroy(probe_location);
 443         lttng_userspace_probe_location_lookup_method_destroy(lookup_method);
 444 }
 445
 446 static void test_event_rule_kernel_probe_by_location(
 447                 const struct lttng_kernel_probe_location *location)
 448 {
 449         struct lttng_event_rule *kprobe = NULL;
 450         struct lttng_event_rule *kprobe_from_buffer = NULL;
 451         enum lttng_event_rule_status status;
 452         const struct lttng_kernel_probe_location *_location;
 453
 454         const char *probe_name = "my_probe";
 455         const char *tmp;
 456         struct lttng_payload payload;
 457
 458         diag("Event rule kprobe for location type %d.",
 459                         lttng_kernel_probe_location_get_type(location));
 460
 461         lttng_payload_init(&payload);
 462
 463         kprobe = lttng_event_rule_kernel_kprobe_create(location);
 464         ok(kprobe, "kprobe event rule object creation.");
 465
 466         status = lttng_event_rule_kernel_kprobe_get_location(kprobe, &_location);
 467         ok(status == LTTNG_EVENT_RULE_STATUS_OK,
 468                         "Getting kprobe event rule location.");
 469         ok(lttng_kernel_probe_location_is_equal(location, _location), "Locations are equal.");
 470
 471         status = lttng_event_rule_kernel_kprobe_set_event_name(kprobe, probe_name);
 472         ok(status == LTTNG_EVENT_RULE_STATUS_OK,
 473                         "Setting kprobe event rule name: %s.", probe_name);
 474         status = lttng_event_rule_kernel_kprobe_get_event_name(kprobe, &tmp);
 475         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "Getting kprobe name.");
 476         ok(!strcmp(probe_name, tmp), "kprobe name are equal.");
 477
 478         ok(lttng_event_rule_serialize(kprobe, &payload) == 0, "Serializing.");
 479
 480         {
 481                 struct lttng_payload_view view =
 482                                 lttng_payload_view_from_payload(
 483                                                 &payload, 0, -1);
 484
 485                 ok(lttng_event_rule_create_from_payload(
 486                                    &view, &kprobe_from_buffer) > 0,
 487                                 "Deserializing.");
 488         }
 489
 490         ok(lttng_event_rule_is_equal(kprobe, kprobe_from_buffer),
 491                         "serialized and from buffer are equal.");
 492
 493         lttng_payload_reset(&payload);
 494         lttng_event_rule_destroy(kprobe);
 495         lttng_event_rule_destroy(kprobe_from_buffer);
 496 }
 497
 498 static void test_event_rule_kernel_probe(void)
 499 {
 500         struct lttng_kernel_probe_location *address_location = NULL;
 501         struct lttng_kernel_probe_location *symbol_location = NULL;
 502
 503         address_location = lttng_kernel_probe_location_address_create(50);
 504         symbol_location = lttng_kernel_probe_location_symbol_create("une_bonne", 50);
 505         assert(address_location);
 506         assert(symbol_location);
 507
 508         test_event_rule_kernel_probe_by_location(address_location);
 509         test_event_rule_kernel_probe_by_location(symbol_location);
 510
 511         lttng_kernel_probe_location_destroy(address_location);
 512         lttng_kernel_probe_location_destroy(symbol_location);
 513 }
 514
 515 static void test_set_event_rule_log_level_rules(
 516                 struct lttng_event_rule *event_rule,
 517                 int log_level,
 518                 enum lttng_event_rule_status *exactly_status,
 519                 enum lttng_event_rule_status *as_severe_status)
 520 {
 521         struct lttng_log_level_rule *log_level_rule;
 522
 523         log_level_rule = lttng_log_level_rule_at_least_as_severe_as_create(
 524                         log_level);
 525         assert(log_level_rule);
 526
 527         *as_severe_status = lttng_event_rule_tracepoint_set_log_level_rule(
 528                         event_rule, log_level_rule);
 529         lttng_log_level_rule_destroy(log_level_rule);
 530
 531         log_level_rule = lttng_log_level_rule_exactly_create(log_level);
 532         assert(log_level_rule);
 533
 534         *exactly_status = lttng_event_rule_tracepoint_set_log_level_rule(
 535                         event_rule, log_level_rule);
 536         lttng_log_level_rule_destroy(log_level_rule);
 537 }
 538
 539 static void test_event_rule_log_level_generic(const char *domain_name,
 540                 enum lttng_domain_type domain,
 541                 log_level_name_getter get_log_level_name,
 542                 const int tagged_log_level_values[],
 543                 size_t tagged_log_level_values_count,
 544                 const int valid_log_level_values[],
 545                 size_t valid_log_level_values_count,
 546                 const int invalid_log_level_values[],
 547                 size_t invalid_log_level_values_count)
 548 {
 549         size_t i;
 550         struct lttng_event_rule *tracepoint_rule;
 551         enum lttng_event_rule_status er_exactly_status, er_as_severe_status;
 552
 553         diag("Test %s event rule + log level rule", domain_name);
 554         tracepoint_rule = lttng_event_rule_tracepoint_create(domain);
 555         assert(tracepoint_rule);
 556
 557         for (i = 0; i < tagged_log_level_values_count; i++) {
 558                 const int tagged_log_level_value = tagged_log_level_values[i];
 559
 560                 test_set_event_rule_log_level_rules(tracepoint_rule,
 561                                 tagged_log_level_value,
 562                                 &er_exactly_status, &er_as_severe_status);
 563                 ok(er_exactly_status == LTTNG_EVENT_RULE_STATUS_OK,
 564                                 "Log level rule \"exactly\" accepted by %s tracepoint event rule: level = %s",
 565                                 domain_name,
 566                                 get_log_level_name(
 567                                                 tagged_log_level_value));
 568                 ok(er_as_severe_status == LTTNG_EVENT_RULE_STATUS_OK,
 569                                 "Log level rule \"as least as severe as\" accepted by %s tracepoint event rule: level = %s",
 570                                 domain_name,
 571                                 get_log_level_name(
 572                                                 tagged_log_level_value));
 573         }
 574
 575         for (i = 0; i < valid_log_level_values_count; i++) {
 576                 const int valid_log_level_value = valid_log_level_values[i];
 577
 578                 test_set_event_rule_log_level_rules(tracepoint_rule,
 579                                 valid_log_level_value,
 580                                 &er_exactly_status, &er_as_severe_status);
 581                 ok(er_exactly_status == LTTNG_EVENT_RULE_STATUS_OK,
 582                                 "Log level rule \"exactly\" accepted by %s tracepoint event rule: level = %d",
 583                                 domain_name,
 584                                 valid_log_level_value);
 585                 ok(er_as_severe_status == LTTNG_EVENT_RULE_STATUS_OK,
 586                                 "Log level rule \"as least as severe as\" accepted by %s tracepoint event rule: level = %d",
 587                                 domain_name,
 588                                 valid_log_level_value);
 589         }
 590
 591         for (i = 0; i < invalid_log_level_values_count; i++) {
 592                 const int invalid_log_level_value = invalid_log_level_values[i];
 593
 594                 test_set_event_rule_log_level_rules(tracepoint_rule,
 595                                 invalid_log_level_value,
 596                                 &er_exactly_status, &er_as_severe_status);
 597                 ok(er_exactly_status == LTTNG_EVENT_RULE_STATUS_INVALID,
 598                                 "Log level rule \"exactly\" rejected by %s tracepoint event rule: level = %d",
 599                                 domain_name,
 600                                 invalid_log_level_value);
 601                 ok(er_as_severe_status == LTTNG_EVENT_RULE_STATUS_INVALID,
 602                                 "Log level rule \"as least as severe as\" rejected by %s tracepoint event rule: level = %d",
 603                                 domain_name,
 604                                 invalid_log_level_value);
 605         }
 606
 607         lttng_event_rule_destroy(tracepoint_rule);
 608 }
 609
 610 static void test_event_rule_log_level_ust(void)
 611 {
 612         const int tagged_log_level_values[] = {
 613                 LTTNG_LOGLEVEL_EMERG,
 614                 LTTNG_LOGLEVEL_ALERT,
 615                 LTTNG_LOGLEVEL_CRIT,
 616                 LTTNG_LOGLEVEL_ERR,
 617                 LTTNG_LOGLEVEL_WARNING,
 618                 LTTNG_LOGLEVEL_NOTICE,
 619                 LTTNG_LOGLEVEL_INFO,
 620                 LTTNG_LOGLEVEL_DEBUG_SYSTEM,
 621                 LTTNG_LOGLEVEL_DEBUG_PROGRAM,
 622                 LTTNG_LOGLEVEL_DEBUG_PROCESS,
 623                 LTTNG_LOGLEVEL_DEBUG_MODULE,
 624                 LTTNG_LOGLEVEL_DEBUG_UNIT,
 625                 LTTNG_LOGLEVEL_DEBUG_FUNCTION,
 626                 LTTNG_LOGLEVEL_DEBUG_LINE,
 627                 LTTNG_LOGLEVEL_DEBUG,
 628         };
 629         const int invalid_log_level_values[] = {
 630                 -1980,
 631                 1995,
 632                 LTTNG_LOGLEVEL_DEBUG + 1,
 633                 LTTNG_LOGLEVEL_EMERG - 1,
 634         };
 635
 636         test_event_rule_log_level_generic("user space", LTTNG_DOMAIN_UST,
 637                         loglevel_value_to_name, tagged_log_level_values,
 638                         ARRAY_SIZE(tagged_log_level_values),
 639                         NULL, 0,
 640                         invalid_log_level_values,
 641                         ARRAY_SIZE(invalid_log_level_values));
 642 }
 643
 644 static void test_event_rule_log_level_jul(void)
 645 {
 646         const int tagged_log_level_values[] = {
 647                 LTTNG_LOGLEVEL_JUL_OFF,
 648                 LTTNG_LOGLEVEL_JUL_SEVERE,
 649                 LTTNG_LOGLEVEL_JUL_WARNING,
 650                 LTTNG_LOGLEVEL_JUL_INFO,
 651                 LTTNG_LOGLEVEL_JUL_CONFIG,
 652                 LTTNG_LOGLEVEL_JUL_FINE,
 653                 LTTNG_LOGLEVEL_JUL_FINER,
 654                 LTTNG_LOGLEVEL_JUL_FINEST,
 655                 LTTNG_LOGLEVEL_JUL_ALL,
 656         };
 657         const int valid_log_level_values[] = {
 658                 0,
 659                 -1980,
 660                 1995
 661         };
 662
 663         test_event_rule_log_level_generic("Java Util Logging", LTTNG_DOMAIN_JUL,
 664                         loglevel_jul_value_to_name, tagged_log_level_values,
 665                         ARRAY_SIZE(tagged_log_level_values),
 666                         valid_log_level_values,
 667                         ARRAY_SIZE(valid_log_level_values), NULL, 0);
 668 }
 669
 670 static void test_event_rule_log_level_log4j(void)
 671 {
 672         const int tagged_log_level_values[] = {
 673                 LTTNG_LOGLEVEL_LOG4J_OFF,
 674                 LTTNG_LOGLEVEL_LOG4J_FATAL,
 675                 LTTNG_LOGLEVEL_LOG4J_ERROR,
 676                 LTTNG_LOGLEVEL_LOG4J_WARN,
 677                 LTTNG_LOGLEVEL_LOG4J_INFO,
 678                 LTTNG_LOGLEVEL_LOG4J_DEBUG,
 679                 LTTNG_LOGLEVEL_LOG4J_TRACE,
 680                 LTTNG_LOGLEVEL_LOG4J_ALL,
 681         };
 682         const int valid_log_level_values[] = {
 683                 0
 684                 -1980,
 685                 1995
 686         };
 687
 688         test_event_rule_log_level_generic("Log4j", LTTNG_DOMAIN_LOG4J,
 689                         loglevel_log4j_value_to_name, tagged_log_level_values,
 690                         ARRAY_SIZE(tagged_log_level_values),
 691                         valid_log_level_values,
 692                         ARRAY_SIZE(valid_log_level_values), NULL, 0);
 693 }
 694
 695 static void test_event_rule_log_level_python(void)
 696 {
 697         const int tagged_log_level_values[] = {
 698                 LTTNG_LOGLEVEL_PYTHON_CRITICAL,
 699                 LTTNG_LOGLEVEL_PYTHON_ERROR,
 700                 LTTNG_LOGLEVEL_PYTHON_WARNING,
 701                 LTTNG_LOGLEVEL_PYTHON_INFO,
 702                 LTTNG_LOGLEVEL_PYTHON_DEBUG,
 703                 LTTNG_LOGLEVEL_PYTHON_NOTSET,
 704         };
 705         const int valid_log_level_values[] = {
 706                 45,
 707                 35,
 708                 0,
 709                 -657,
 710         };
 711
 712         test_event_rule_log_level_generic("Python", LTTNG_DOMAIN_PYTHON,
 713                         loglevel_python_value_to_name, tagged_log_level_values,
 714                         ARRAY_SIZE(tagged_log_level_values),
 715                         valid_log_level_values,
 716                         ARRAY_SIZE(valid_log_level_values),
 717                         NULL, 0);
 718 }
 719
 720 int main(int argc, const char *argv[])
 721 {
 722         plan_tests(NUM_TESTS);
 723         test_event_rule_tracepoint();
 724         test_event_rule_kernel_tracepoint();
 725         test_event_rule_user_tracepoint();
 726         test_event_rule_syscall();
 727         test_event_rule_userspace_probe();
 728         test_event_rule_kernel_probe();
 729         test_event_rule_log_level_ust();
 730         test_event_rule_log_level_jul();
 731         test_event_rule_log_level_log4j();
 732         test_event_rule_log_level_python();
 733         return exit_status();
 734 }