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