tests/unit/test_event_rule.cpp

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