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