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/kernel-probe-internal.h>
  22 #include <lttng/event-rule/kernel-probe.h>
  23 #include <lttng/event-rule/syscall-internal.h>
  24 #include <lttng/event-rule/syscall.h>
  25 #include <lttng/event-rule/tracepoint-internal.h>
  26 #include <lttng/event-rule/tracepoint.h>
  27 #include <lttng/event-rule/userspace-probe-internal.h>
  28 #include <lttng/event-rule/userspace-probe.h>
  29 #include <lttng/event.h>
  30 #include <lttng/kernel-probe-internal.h>
  31 #include <lttng/kernel-probe.h>
  32 #include <lttng/userspace-probe-internal.h>
  33 #include <lttng/userspace-probe.h>
  34
  35 /* For error.h. */
  36 int lttng_opt_quiet = 1;
  37 int lttng_opt_verbose;
  38 int lttng_opt_mi;
  39
  40 #define NUM_TESTS 144
  41
  42 struct tracepoint_test {
  43         enum lttng_domain_type type;
  44         bool support_exclusion;
  45 };
  46
  47 static
  48 void test_event_rule_tracepoint_by_domain(const struct tracepoint_test *test)
  49 {
  50         unsigned int count;
  51         struct lttng_event_rule *tracepoint = NULL;
  52         struct lttng_event_rule *tracepoint_from_buffer = NULL;
  53         enum lttng_event_rule_status status;
  54         enum lttng_domain_type domain_type, type;
  55         const char *pattern="my_event_*";
  56         const char *filter="msg_id == 23 && size >= 2048";
  57         const char *tmp;
  58         const char *exclusions[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
  59         struct lttng_log_level_rule *log_level_rule = NULL;
  60         const struct lttng_log_level_rule *log_level_rule_return = NULL;
  61         struct lttng_payload payload;
  62
  63         type = test->type;
  64         diag("Testing domain %d.", type);
  65
  66         lttng_payload_init(&payload);
  67
  68         log_level_rule = lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO);
  69         assert(log_level_rule);
  70
  71         tracepoint = lttng_event_rule_tracepoint_create(type);
  72         ok(tracepoint, "tracepoint object.");
  73
  74         status = lttng_event_rule_tracepoint_get_domain_type(tracepoint, &domain_type);
  75         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "get tracepoint domain.");
  76         ok(domain_type == type, "domain type got %d expected %d.", domain_type, type);
  77
  78         status = lttng_event_rule_tracepoint_set_pattern(tracepoint, pattern);
  79         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
  80         status = lttng_event_rule_tracepoint_get_pattern(tracepoint, &tmp);
  81         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
  82         ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
  83
  84         status = lttng_event_rule_tracepoint_set_filter(tracepoint, filter);
  85         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
  86         status = lttng_event_rule_tracepoint_get_filter(tracepoint, &tmp);
  87         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
  88         ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
  89
  90         status = lttng_event_rule_tracepoint_get_log_level_rule(tracepoint, &log_level_rule_return);
  91         ok(status == LTTNG_EVENT_RULE_STATUS_UNSET, "get unset log level rule.");
  92
  93         status = lttng_event_rule_tracepoint_set_log_level_rule(tracepoint, log_level_rule);
  94         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting log level rule.");
  95         status = lttng_event_rule_tracepoint_get_log_level_rule(tracepoint, &log_level_rule_return);
  96         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "get log level rule.");
  97
  98         if (test->support_exclusion) {
  99                 int i;
 100
 101                 for (i = 0; i < 3; i++) {
 102                         status = lttng_event_rule_tracepoint_add_exclusion(tracepoint, exclusions[i]);
 103                         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting exclusions \"%s\"", exclusions[i]);
 104                 }
 105
 106                 status = lttng_event_rule_tracepoint_get_exclusions_count(tracepoint, &count);
 107                 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting exclusion count.");
 108                 ok(count == 3, "count is %d/3", count);
 109
 110                 for (i = 0; i < count; i++) {
 111                         status = lttng_event_rule_tracepoint_get_exclusion_at_index(tracepoint, i, &tmp);
 112                         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting exclusion at index %d.", i);
 113                         ok(!strncmp(exclusions[i], tmp, strlen(exclusions[i])), "%s == %s.", tmp, exclusions[i]);
 114                 }
 115         } else {
 116                 int i;
 117
 118                 for (i = 0; i < 3; i++) {
 119                         status = lttng_event_rule_tracepoint_add_exclusion(tracepoint, exclusions[i]);
 120                         ok(status == LTTNG_EVENT_RULE_STATUS_UNSUPPORTED, "setting exclusions unsupported \"%s\".", exclusions[i]);
 121                 }
 122
 123                 status = lttng_event_rule_tracepoint_get_exclusions_count(tracepoint, &count);
 124                 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting exclusion count.");
 125                 ok(count == 0, "count is %d/0", count);
 126         }
 127
 128         ok(lttng_event_rule_serialize(tracepoint, &payload) == 0, "Serializing.");
 129
 130         {
 131                 struct lttng_payload_view view =
 132                                 lttng_payload_view_from_payload(
 133                                                 &payload, 0, -1);
 134
 135                 ok(lttng_event_rule_create_from_payload(
 136                                 &view, &tracepoint_from_buffer) > 0,
 137                                 "Deserializing.");
 138         }
 139
 140         ok(lttng_event_rule_is_equal(tracepoint, tracepoint_from_buffer), "serialized and from buffer are equal.");
 141
 142         lttng_payload_reset(&payload);
 143         lttng_event_rule_destroy(tracepoint);
 144         lttng_event_rule_destroy(tracepoint_from_buffer);
 145         lttng_log_level_rule_destroy(log_level_rule);
 146 }
 147
 148 static
 149 void test_event_rule_tracepoint(void)
 150 {
 151         int i;
 152         struct lttng_event_rule *tracepoint = NULL;
 153         struct tracepoint_test tests[] = {{LTTNG_DOMAIN_JUL, false},
 154                         {LTTNG_DOMAIN_KERNEL, false},
 155                         {LTTNG_DOMAIN_LOG4J, false},
 156                         {LTTNG_DOMAIN_PYTHON, false},
 157                         {LTTNG_DOMAIN_UST, true}};
 158
 159         diag("Testing lttng_event_rule_tracepoint.");
 160         tracepoint = lttng_event_rule_tracepoint_create(LTTNG_DOMAIN_NONE);
 161         ok(!tracepoint, "Domain type restriction on create.");
 162
 163         for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
 164                 test_event_rule_tracepoint_by_domain(&tests[i]);
 165         }
 166 }
 167
 168 static void test_event_rule_syscall(void)
 169 {
 170         struct lttng_event_rule *syscall = NULL;
 171         struct lttng_event_rule *syscall_from_buffer = NULL;
 172         enum lttng_event_rule_status status;
 173         const char *pattern = "my_event_*";
 174         const char *filter = "msg_id == 23 && size >= 2048";
 175         const char *tmp;
 176         struct lttng_payload payload;
 177
 178         diag("Event rule syscall.");
 179
 180         lttng_payload_init(&payload);
 181
 182         syscall = lttng_event_rule_syscall_create();
 183         ok(syscall, "syscall object.");
 184
 185         status = lttng_event_rule_syscall_set_pattern(syscall, pattern);
 186         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
 187         status = lttng_event_rule_syscall_get_pattern(syscall, &tmp);
 188         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
 189         ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
 190
 191         status = lttng_event_rule_syscall_set_filter(syscall, filter);
 192         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
 193         status = lttng_event_rule_syscall_get_filter(syscall, &tmp);
 194         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
 195         ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
 196
 197         ok(lttng_event_rule_serialize(syscall, &payload) == 0, "Serializing.");
 198
 199         {
 200                 struct lttng_payload_view view =
 201                                 lttng_payload_view_from_payload(
 202                                                 &payload, 0, -1);
 203
 204                 ok(lttng_event_rule_create_from_payload(
 205                                    &view, &syscall_from_buffer) > 0,
 206                                 "Deserializing.");
 207         }
 208
 209         ok(lttng_event_rule_is_equal(syscall, syscall_from_buffer),
 210                         "serialized and from buffer are equal.");
 211
 212         lttng_payload_reset(&payload);
 213         lttng_event_rule_destroy(syscall);
 214         lttng_event_rule_destroy(syscall_from_buffer);
 215 }
 216
 217 static void test_event_rule_userspace_probe(void)
 218 {
 219         struct lttng_event_rule *uprobe = NULL;
 220         struct lttng_event_rule *uprobe_from_buffer = NULL;
 221         struct lttng_userspace_probe_location_lookup_method *lookup_method =
 222                         NULL;
 223         struct lttng_userspace_probe_location *probe_location = NULL;
 224         const struct lttng_userspace_probe_location *probe_location_tmp = NULL;
 225         enum lttng_event_rule_status status;
 226
 227         const char *probe_name = "my_probe.";
 228         const char *tmp;
 229         struct lttng_payload payload;
 230
 231         diag("Event rule uprobe.");
 232
 233         lookup_method = lttng_userspace_probe_location_lookup_method_function_elf_create();
 234         if (!lookup_method) {
 235                 fail("Setup error on userspace probe lookup method creation.");
 236                 goto end;
 237         }
 238
 239         probe_location = lttng_userspace_probe_location_function_create(
 240                         "/proc/self/exe",
 241                         "lttng_userspace_probe_location_tracepoint_create",
 242                         lookup_method);
 243         if (!probe_location) {
 244                 fail("Setup error on userspace probe location creation.");
 245                 goto end;
 246         }
 247
 248         /* Ownership transferred to the probe location function object. */
 249         lookup_method = NULL;
 250
 251         lttng_payload_init(&payload);
 252
 253         uprobe = lttng_event_rule_userspace_probe_create(probe_location);
 254         ok(uprobe, "uprobe event rule object creation.");
 255
 256         status = lttng_event_rule_userspace_probe_get_location(
 257                         uprobe, &probe_location_tmp);
 258         ok(status == LTTNG_EVENT_RULE_STATUS_OK,
 259                         "Getting uprobe event rule location.");
 260         ok(lttng_userspace_probe_location_is_equal(
 261                            probe_location, probe_location_tmp),
 262                         "Location is equal.");
 263
 264         status = lttng_event_rule_userspace_probe_set_event_name(uprobe, probe_name);
 265         ok(status == LTTNG_EVENT_RULE_STATUS_OK,
 266                         "Setting uprobe event rule name: %s.", probe_name);
 267         status = lttng_event_rule_userspace_probe_get_event_name(uprobe, &tmp);
 268         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "Getting uprobe name.");
 269         ok(!strcmp(probe_name, tmp), "Uprobe name are equal.");
 270
 271         ok(lttng_event_rule_serialize(uprobe, &payload) == 0, "Serializing.");
 272
 273         {
 274                 struct lttng_payload_view view =
 275                                 lttng_payload_view_from_payload(
 276                                                 &payload, 0, -1);
 277
 278                 ok(lttng_event_rule_create_from_payload(
 279                                    &view, &uprobe_from_buffer) > 0,
 280                                 "Deserializing.");
 281         }
 282
 283         ok(lttng_event_rule_is_equal(uprobe, uprobe_from_buffer),
 284                         "serialized and from buffer are equal.");
 285
 286 end:
 287         lttng_payload_reset(&payload);
 288         lttng_event_rule_destroy(uprobe);
 289         lttng_event_rule_destroy(uprobe_from_buffer);
 290         lttng_userspace_probe_location_destroy(probe_location);
 291         lttng_userspace_probe_location_lookup_method_destroy(lookup_method);
 292 }
 293
 294 static void test_event_rule_kernel_probe_by_location(
 295                 const struct lttng_kernel_probe_location *location)
 296 {
 297         struct lttng_event_rule *kprobe = NULL;
 298         struct lttng_event_rule *kprobe_from_buffer = NULL;
 299         enum lttng_event_rule_status status;
 300         const struct lttng_kernel_probe_location *_location;
 301
 302         const char *probe_name = "my_probe";
 303         const char *tmp;
 304         struct lttng_payload payload;
 305
 306         diag("Event rule kprobe for location type %d.",
 307                         lttng_kernel_probe_location_get_type(location));
 308
 309         lttng_payload_init(&payload);
 310
 311         kprobe = lttng_event_rule_kernel_probe_create(location);
 312         ok(kprobe, "kprobe event rule object creation.");
 313
 314         status = lttng_event_rule_kernel_probe_get_location(kprobe, &_location);
 315         ok(status == LTTNG_EVENT_RULE_STATUS_OK,
 316                         "Getting kprobe event rule location.");
 317         ok(lttng_kernel_probe_location_is_equal(location, _location), "Locations are equal.");
 318
 319         status = lttng_event_rule_kernel_probe_set_event_name(kprobe, probe_name);
 320         ok(status == LTTNG_EVENT_RULE_STATUS_OK,
 321                         "Setting kprobe event rule name: %s.", probe_name);
 322         status = lttng_event_rule_kernel_probe_get_event_name(kprobe, &tmp);
 323         ok(status == LTTNG_EVENT_RULE_STATUS_OK, "Getting kprobe name.");
 324         ok(!strcmp(probe_name, tmp), "kprobe name are equal.");
 325
 326         ok(lttng_event_rule_serialize(kprobe, &payload) == 0, "Serializing.");
 327
 328         {
 329                 struct lttng_payload_view view =
 330                                 lttng_payload_view_from_payload(
 331                                                 &payload, 0, -1);
 332
 333                 ok(lttng_event_rule_create_from_payload(
 334                                    &view, &kprobe_from_buffer) > 0,
 335                                 "Deserializing.");
 336         }
 337
 338         ok(lttng_event_rule_is_equal(kprobe, kprobe_from_buffer),
 339                         "serialized and from buffer are equal.");
 340
 341         lttng_payload_reset(&payload);
 342         lttng_event_rule_destroy(kprobe);
 343         lttng_event_rule_destroy(kprobe_from_buffer);
 344 }
 345
 346 static void test_event_rule_kernel_probe(void)
 347 {
 348         struct lttng_kernel_probe_location *address_location = NULL;
 349         struct lttng_kernel_probe_location *symbol_location = NULL;
 350
 351         address_location = lttng_kernel_probe_location_address_create(50);
 352         symbol_location = lttng_kernel_probe_location_symbol_create("une_bonne", 50);
 353         assert(address_location);
 354         assert(symbol_location);
 355
 356         test_event_rule_kernel_probe_by_location(address_location);
 357         test_event_rule_kernel_probe_by_location(symbol_location);
 358
 359         lttng_kernel_probe_location_destroy(address_location);
 360         lttng_kernel_probe_location_destroy(symbol_location);
 361 }
 362
 363 int main(int argc, const char *argv[])
 364 {
 365         plan_tests(NUM_TESTS);
 366         test_event_rule_tracepoint();
 367         test_event_rule_syscall();
 368         test_event_rule_userspace_probe();
 369         test_event_rule_kernel_probe();
 370         return exit_status();
 371 }