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