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