2 * Unit tests for the notification API.
4 * Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
6 * SPDX-License-Identifier: LGPL-2.1-only
18 #include <common/payload-view.h>
19 #include <common/payload.h>
20 #include <lttng/domain.h>
21 #include <lttng/event-rule/kernel-kprobe-internal.h>
22 #include <lttng/event-rule/kernel-kprobe.h>
23 #include <lttng/event-rule/kernel-syscall-internal.h>
24 #include <lttng/event-rule/kernel-syscall.h>
25 #include <lttng/event-rule/tracepoint-internal.h>
26 #include <lttng/event-rule/tracepoint.h>
27 #include <lttng/event-rule/kernel-tracepoint-internal.h>
28 #include <lttng/event-rule/kernel-tracepoint.h>
29 #include <lttng/event-rule/kernel-uprobe-internal.h>
30 #include <lttng/event-rule/kernel-uprobe.h>
31 #include <lttng/event-rule/user-tracepoint-internal.h>
32 #include <lttng/event-rule/user-tracepoint.h>
33 #include <lttng/event.h>
34 #include <lttng/kernel-probe-internal.h>
35 #include <lttng/kernel-probe.h>
36 #include <lttng/userspace-probe-internal.h>
37 #include <lttng/userspace-probe.h>
38 #include "bin/lttng/loglevel.h"
41 int lttng_opt_quiet
= 1;
42 int lttng_opt_verbose
;
47 struct tracepoint_test
{
48 enum lttng_domain_type type
;
49 bool support_name_pattern_exclusion
;
52 typedef const char *(*log_level_name_getter
)(int log_level
);
55 void test_event_rule_tracepoint_by_domain(const struct tracepoint_test
*test
)
58 struct lttng_event_rule
*tracepoint
= NULL
;
59 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
60 enum lttng_event_rule_status status
;
61 enum lttng_domain_type domain_type
, type
;
62 const char *pattern
="my_event_*";
63 const char *filter
="msg_id == 23 && size >= 2048";
65 const char *name_pattern_exclusions
[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
66 struct lttng_log_level_rule
*log_level_rule
= NULL
;
67 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
68 struct lttng_payload payload
;
71 diag("Testing domain %d.", type
);
73 lttng_payload_init(&payload
);
75 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
76 assert(log_level_rule
);
78 tracepoint
= lttng_event_rule_tracepoint_create(type
);
79 ok(tracepoint
, "tracepoint object.");
81 status
= lttng_event_rule_tracepoint_get_domain_type(tracepoint
, &domain_type
);
82 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get tracepoint domain.");
83 ok(domain_type
== type
, "domain type got %d expected %d.", domain_type
, type
);
85 status
= lttng_event_rule_tracepoint_set_name_pattern(tracepoint
, pattern
);
86 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
87 status
= lttng_event_rule_tracepoint_get_name_pattern(tracepoint
, &tmp
);
88 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
89 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
91 status
= lttng_event_rule_tracepoint_set_filter(tracepoint
, filter
);
92 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
93 status
= lttng_event_rule_tracepoint_get_filter(tracepoint
, &tmp
);
94 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
95 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
97 status
= lttng_event_rule_tracepoint_get_log_level_rule(tracepoint
, &log_level_rule_return
);
98 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
100 if (type
!= LTTNG_DOMAIN_KERNEL
) {
101 status
= lttng_event_rule_tracepoint_set_log_level_rule(tracepoint
, log_level_rule
);
102 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
103 status
= lttng_event_rule_tracepoint_get_log_level_rule(tracepoint
, &log_level_rule_return
);
104 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
107 if (test
->support_name_pattern_exclusion
) {
110 for (i
= 0; i
< 3; i
++) {
111 status
= lttng_event_rule_tracepoint_add_name_pattern_exclusion(tracepoint
, name_pattern_exclusions
[i
]);
112 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting name pattern exclusions \"%s\"", name_pattern_exclusions
[i
]);
115 status
= lttng_event_rule_tracepoint_get_name_pattern_exclusion_count(tracepoint
, &count
);
116 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting name pattern exclusion count.");
117 ok(count
== 3, "count is %d/3", count
);
119 for (i
= 0; i
< count
; i
++) {
120 status
= lttng_event_rule_tracepoint_get_name_pattern_exclusion_at_index(tracepoint
, i
, &tmp
);
121 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting name pattern exclusion at index %d.", i
);
122 ok(!strncmp(name_pattern_exclusions
[i
], tmp
, strlen(name_pattern_exclusions
[i
])), "%s == %s.", tmp
, name_pattern_exclusions
[i
]);
127 for (i
= 0; i
< 3; i
++) {
128 status
= lttng_event_rule_tracepoint_add_name_pattern_exclusion(tracepoint
, name_pattern_exclusions
[i
]);
129 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSUPPORTED
, "setting name pattern exclusions unsupported \"%s\".", name_pattern_exclusions
[i
]);
132 status
= lttng_event_rule_tracepoint_get_name_pattern_exclusion_count(tracepoint
, &count
);
133 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting name pattern exclusion count.");
134 ok(count
== 0, "count is %d/0", count
);
137 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
140 struct lttng_payload_view view
=
141 lttng_payload_view_from_payload(
144 ok(lttng_event_rule_create_from_payload(
145 &view
, &tracepoint_from_buffer
) > 0,
149 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
151 lttng_payload_reset(&payload
);
152 lttng_event_rule_destroy(tracepoint
);
153 lttng_event_rule_destroy(tracepoint_from_buffer
);
154 lttng_log_level_rule_destroy(log_level_rule
);
158 void test_event_rule_tracepoint(void)
161 struct lttng_event_rule
*tracepoint
= NULL
;
162 struct tracepoint_test tests
[] = {{LTTNG_DOMAIN_JUL
, false},
163 {LTTNG_DOMAIN_KERNEL
, false},
164 {LTTNG_DOMAIN_LOG4J
, false},
165 {LTTNG_DOMAIN_PYTHON
, false},
166 {LTTNG_DOMAIN_UST
, true}};
168 diag("Testing lttng_event_rule_tracepoint.");
169 tracepoint
= lttng_event_rule_tracepoint_create(LTTNG_DOMAIN_NONE
);
170 ok(!tracepoint
, "Domain type restriction on create.");
172 for (i
= 0; i
< sizeof(tests
) / sizeof(tests
[0]); i
++) {
173 test_event_rule_tracepoint_by_domain(&tests
[i
]);
178 void test_event_rule_kernel_tracepoint(void)
180 struct lttng_event_rule
*tracepoint
= NULL
;
181 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
182 enum lttng_event_rule_status status
;
183 const char *pattern
="my_event_*";
184 const char *filter
="msg_id == 23 && size >= 2048";
186 struct lttng_payload payload
;
188 diag("Testing lttng_event_rule_kernel_tracepoint.");
190 lttng_payload_init(&payload
);
192 tracepoint
= lttng_event_rule_kernel_tracepoint_create();
193 ok(tracepoint
, "tracepoint object.");
195 status
= lttng_event_rule_kernel_tracepoint_set_name_pattern(tracepoint
, pattern
);
196 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
197 status
= lttng_event_rule_kernel_tracepoint_get_name_pattern(tracepoint
, &tmp
);
198 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
199 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
201 status
= lttng_event_rule_kernel_tracepoint_set_filter(tracepoint
, filter
);
202 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
203 status
= lttng_event_rule_kernel_tracepoint_get_filter(tracepoint
, &tmp
);
204 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
205 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
207 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
210 struct lttng_payload_view view
=
211 lttng_payload_view_from_payload(
214 ok(lttng_event_rule_create_from_payload(
215 &view
, &tracepoint_from_buffer
) > 0,
219 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
221 lttng_payload_reset(&payload
);
222 lttng_event_rule_destroy(tracepoint
);
223 lttng_event_rule_destroy(tracepoint_from_buffer
);
227 void test_event_rule_user_tracepoint(void)
231 struct lttng_event_rule
*tracepoint
= NULL
;
232 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
233 enum lttng_event_rule_status status
;
234 const char *pattern
="my_event_*";
235 const char *filter
="msg_id == 23 && size >= 2048";
237 const char *name_pattern_exclusions
[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
238 struct lttng_log_level_rule
*log_level_rule
= NULL
;
239 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
240 struct lttng_payload payload
;
242 diag("Testing lttng_event_rule_user_tracepoint.");
244 lttng_payload_init(&payload
);
246 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
247 assert(log_level_rule
);
249 tracepoint
= lttng_event_rule_user_tracepoint_create();
250 ok(tracepoint
, "user tracepoint object.");
252 status
= lttng_event_rule_user_tracepoint_set_name_pattern(tracepoint
, pattern
);
253 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
254 status
= lttng_event_rule_user_tracepoint_get_name_pattern(tracepoint
, &tmp
);
255 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
256 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
258 status
= lttng_event_rule_user_tracepoint_set_filter(tracepoint
, filter
);
259 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
260 status
= lttng_event_rule_user_tracepoint_get_filter(tracepoint
, &tmp
);
261 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
262 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
264 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(tracepoint
, &log_level_rule_return
);
265 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
267 status
= lttng_event_rule_user_tracepoint_set_log_level_rule(
268 tracepoint
, log_level_rule
);
269 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
270 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(
271 tracepoint
, &log_level_rule_return
);
272 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
274 /* Name pattern exclusions */
275 for (i
= 0; i
< 3; i
++) {
276 status
= lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(
277 tracepoint
, name_pattern_exclusions
[i
]);
278 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
279 "setting name pattern exclusions \"%s\"",
280 name_pattern_exclusions
[i
]);
283 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
285 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
286 "getting name pattern exclusion count.");
287 ok(count
== 3, "count is %d/3", count
);
289 for (i
= 0; i
< count
; i
++) {
290 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
291 tracepoint
, i
, &tmp
);
292 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
293 "getting name pattern exclusion at index %d.",
295 ok(!strncmp(name_pattern_exclusions
[i
], tmp
,
296 strlen(name_pattern_exclusions
[i
])),
297 "%s == %s.", tmp
, name_pattern_exclusions
[i
]);
300 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
303 struct lttng_payload_view view
=
304 lttng_payload_view_from_payload(
307 ok(lttng_event_rule_create_from_payload(
308 &view
, &tracepoint_from_buffer
) > 0,
312 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
314 lttng_payload_reset(&payload
);
315 lttng_event_rule_destroy(tracepoint
);
316 lttng_event_rule_destroy(tracepoint_from_buffer
);
317 lttng_log_level_rule_destroy(log_level_rule
);
320 static void test_event_rule_syscall(void)
322 struct lttng_event_rule
*syscall
= NULL
;
323 struct lttng_event_rule
*syscall_from_buffer
= NULL
;
324 enum lttng_event_rule_status status
;
325 const char *pattern
= "my_event_*";
326 const char *filter
= "msg_id == 23 && size >= 2048";
328 struct lttng_payload payload
;
330 diag("Event rule syscall.");
332 lttng_payload_init(&payload
);
334 syscall
= lttng_event_rule_kernel_syscall_create(LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY
);
335 ok(syscall
, "syscall object.");
337 status
= lttng_event_rule_kernel_syscall_set_name_pattern(syscall
, pattern
);
338 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
339 status
= lttng_event_rule_kernel_syscall_get_name_pattern(syscall
, &tmp
);
340 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
341 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
343 status
= lttng_event_rule_kernel_syscall_set_filter(syscall
, filter
);
344 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
345 status
= lttng_event_rule_kernel_syscall_get_filter(syscall
, &tmp
);
346 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
347 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
349 ok(lttng_event_rule_serialize(syscall
, &payload
) == 0, "Serializing.");
352 struct lttng_payload_view view
=
353 lttng_payload_view_from_payload(
356 ok(lttng_event_rule_create_from_payload(
357 &view
, &syscall_from_buffer
) > 0,
361 ok(lttng_event_rule_is_equal(syscall
, syscall_from_buffer
),
362 "serialized and from buffer are equal.");
364 lttng_payload_reset(&payload
);
365 lttng_event_rule_destroy(syscall
);
366 lttng_event_rule_destroy(syscall_from_buffer
);
369 static void test_event_rule_userspace_probe(void)
371 struct lttng_event_rule
*uprobe
= NULL
;
372 struct lttng_event_rule
*uprobe_from_buffer
= NULL
;
373 struct lttng_userspace_probe_location_lookup_method
*lookup_method
=
375 struct lttng_userspace_probe_location
*probe_location
= NULL
;
376 const struct lttng_userspace_probe_location
*probe_location_tmp
= NULL
;
377 enum lttng_event_rule_status status
;
379 const char *probe_name
= "my_probe.";
381 struct lttng_payload payload
;
383 diag("Event rule uprobe.");
385 lookup_method
= lttng_userspace_probe_location_lookup_method_function_elf_create();
386 if (!lookup_method
) {
387 fail("Setup error on userspace probe lookup method creation.");
391 probe_location
= lttng_userspace_probe_location_function_create(
393 "lttng_userspace_probe_location_tracepoint_create",
395 if (!probe_location
) {
396 fail("Setup error on userspace probe location creation.");
400 /* Ownership transferred to the probe location function object. */
401 lookup_method
= NULL
;
403 lttng_payload_init(&payload
);
405 uprobe
= lttng_event_rule_kernel_uprobe_create(probe_location
);
406 ok(uprobe
, "uprobe event rule object creation.");
408 status
= lttng_event_rule_kernel_uprobe_get_location(
409 uprobe
, &probe_location_tmp
);
410 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
411 "Getting uprobe event rule location.");
412 ok(lttng_userspace_probe_location_is_equal(
413 probe_location
, probe_location_tmp
),
414 "Location is equal.");
416 status
= lttng_event_rule_kernel_uprobe_set_event_name(uprobe
, probe_name
);
417 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
418 "Setting uprobe event rule name: %s.", probe_name
);
419 status
= lttng_event_rule_kernel_uprobe_get_event_name(uprobe
, &tmp
);
420 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "Getting uprobe name.");
421 ok(!strcmp(probe_name
, tmp
), "Uprobe name are equal.");
423 ok(lttng_event_rule_serialize(uprobe
, &payload
) == 0, "Serializing.");
426 struct lttng_payload_view view
=
427 lttng_payload_view_from_payload(
430 ok(lttng_event_rule_create_from_payload(
431 &view
, &uprobe_from_buffer
) > 0,
435 ok(lttng_event_rule_is_equal(uprobe
, uprobe_from_buffer
),
436 "serialized and from buffer are equal.");
439 lttng_payload_reset(&payload
);
440 lttng_event_rule_destroy(uprobe
);
441 lttng_event_rule_destroy(uprobe_from_buffer
);
442 lttng_userspace_probe_location_destroy(probe_location
);
443 lttng_userspace_probe_location_lookup_method_destroy(lookup_method
);
446 static void test_event_rule_kernel_probe_by_location(
447 const struct lttng_kernel_probe_location
*location
)
449 struct lttng_event_rule
*kprobe
= NULL
;
450 struct lttng_event_rule
*kprobe_from_buffer
= NULL
;
451 enum lttng_event_rule_status status
;
452 const struct lttng_kernel_probe_location
*_location
;
454 const char *probe_name
= "my_probe";
456 struct lttng_payload payload
;
458 diag("Event rule kprobe for location type %d.",
459 lttng_kernel_probe_location_get_type(location
));
461 lttng_payload_init(&payload
);
463 kprobe
= lttng_event_rule_kernel_kprobe_create(location
);
464 ok(kprobe
, "kprobe event rule object creation.");
466 status
= lttng_event_rule_kernel_kprobe_get_location(kprobe
, &_location
);
467 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
468 "Getting kprobe event rule location.");
469 ok(lttng_kernel_probe_location_is_equal(location
, _location
), "Locations are equal.");
471 status
= lttng_event_rule_kernel_kprobe_set_event_name(kprobe
, probe_name
);
472 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
473 "Setting kprobe event rule name: %s.", probe_name
);
474 status
= lttng_event_rule_kernel_kprobe_get_event_name(kprobe
, &tmp
);
475 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "Getting kprobe name.");
476 ok(!strcmp(probe_name
, tmp
), "kprobe name are equal.");
478 ok(lttng_event_rule_serialize(kprobe
, &payload
) == 0, "Serializing.");
481 struct lttng_payload_view view
=
482 lttng_payload_view_from_payload(
485 ok(lttng_event_rule_create_from_payload(
486 &view
, &kprobe_from_buffer
) > 0,
490 ok(lttng_event_rule_is_equal(kprobe
, kprobe_from_buffer
),
491 "serialized and from buffer are equal.");
493 lttng_payload_reset(&payload
);
494 lttng_event_rule_destroy(kprobe
);
495 lttng_event_rule_destroy(kprobe_from_buffer
);
498 static void test_event_rule_kernel_probe(void)
500 struct lttng_kernel_probe_location
*address_location
= NULL
;
501 struct lttng_kernel_probe_location
*symbol_location
= NULL
;
503 address_location
= lttng_kernel_probe_location_address_create(50);
504 symbol_location
= lttng_kernel_probe_location_symbol_create("une_bonne", 50);
505 assert(address_location
);
506 assert(symbol_location
);
508 test_event_rule_kernel_probe_by_location(address_location
);
509 test_event_rule_kernel_probe_by_location(symbol_location
);
511 lttng_kernel_probe_location_destroy(address_location
);
512 lttng_kernel_probe_location_destroy(symbol_location
);
515 static void test_set_event_rule_log_level_rules(
516 struct lttng_event_rule
*event_rule
,
518 enum lttng_event_rule_status
*exactly_status
,
519 enum lttng_event_rule_status
*as_severe_status
)
521 struct lttng_log_level_rule
*log_level_rule
;
523 log_level_rule
= lttng_log_level_rule_at_least_as_severe_as_create(
525 assert(log_level_rule
);
527 *as_severe_status
= lttng_event_rule_tracepoint_set_log_level_rule(
528 event_rule
, log_level_rule
);
529 lttng_log_level_rule_destroy(log_level_rule
);
531 log_level_rule
= lttng_log_level_rule_exactly_create(log_level
);
532 assert(log_level_rule
);
534 *exactly_status
= lttng_event_rule_tracepoint_set_log_level_rule(
535 event_rule
, log_level_rule
);
536 lttng_log_level_rule_destroy(log_level_rule
);
539 static void test_event_rule_log_level_generic(const char *domain_name
,
540 enum lttng_domain_type domain
,
541 log_level_name_getter get_log_level_name
,
542 const int tagged_log_level_values
[],
543 size_t tagged_log_level_values_count
,
544 const int valid_log_level_values
[],
545 size_t valid_log_level_values_count
,
546 const int invalid_log_level_values
[],
547 size_t invalid_log_level_values_count
)
550 struct lttng_event_rule
*tracepoint_rule
;
551 enum lttng_event_rule_status er_exactly_status
, er_as_severe_status
;
553 diag("Test %s event rule + log level rule", domain_name
);
554 tracepoint_rule
= lttng_event_rule_tracepoint_create(domain
);
555 assert(tracepoint_rule
);
557 for (i
= 0; i
< tagged_log_level_values_count
; i
++) {
558 const int tagged_log_level_value
= tagged_log_level_values
[i
];
560 test_set_event_rule_log_level_rules(tracepoint_rule
,
561 tagged_log_level_value
,
562 &er_exactly_status
, &er_as_severe_status
);
563 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_OK
,
564 "Log level rule \"exactly\" accepted by %s tracepoint event rule: level = %s",
567 tagged_log_level_value
));
568 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_OK
,
569 "Log level rule \"as least as severe as\" accepted by %s tracepoint event rule: level = %s",
572 tagged_log_level_value
));
575 for (i
= 0; i
< valid_log_level_values_count
; i
++) {
576 const int valid_log_level_value
= valid_log_level_values
[i
];
578 test_set_event_rule_log_level_rules(tracepoint_rule
,
579 valid_log_level_value
,
580 &er_exactly_status
, &er_as_severe_status
);
581 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_OK
,
582 "Log level rule \"exactly\" accepted by %s tracepoint event rule: level = %d",
584 valid_log_level_value
);
585 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_OK
,
586 "Log level rule \"as least as severe as\" accepted by %s tracepoint event rule: level = %d",
588 valid_log_level_value
);
591 for (i
= 0; i
< invalid_log_level_values_count
; i
++) {
592 const int invalid_log_level_value
= invalid_log_level_values
[i
];
594 test_set_event_rule_log_level_rules(tracepoint_rule
,
595 invalid_log_level_value
,
596 &er_exactly_status
, &er_as_severe_status
);
597 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_INVALID
,
598 "Log level rule \"exactly\" rejected by %s tracepoint event rule: level = %d",
600 invalid_log_level_value
);
601 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_INVALID
,
602 "Log level rule \"as least as severe as\" rejected by %s tracepoint event rule: level = %d",
604 invalid_log_level_value
);
607 lttng_event_rule_destroy(tracepoint_rule
);
610 static void test_event_rule_log_level_ust(void)
612 const int tagged_log_level_values
[] = {
613 LTTNG_LOGLEVEL_EMERG
,
614 LTTNG_LOGLEVEL_ALERT
,
617 LTTNG_LOGLEVEL_WARNING
,
618 LTTNG_LOGLEVEL_NOTICE
,
620 LTTNG_LOGLEVEL_DEBUG_SYSTEM
,
621 LTTNG_LOGLEVEL_DEBUG_PROGRAM
,
622 LTTNG_LOGLEVEL_DEBUG_PROCESS
,
623 LTTNG_LOGLEVEL_DEBUG_MODULE
,
624 LTTNG_LOGLEVEL_DEBUG_UNIT
,
625 LTTNG_LOGLEVEL_DEBUG_FUNCTION
,
626 LTTNG_LOGLEVEL_DEBUG_LINE
,
627 LTTNG_LOGLEVEL_DEBUG
,
629 const int invalid_log_level_values
[] = {
632 LTTNG_LOGLEVEL_DEBUG
+ 1,
633 LTTNG_LOGLEVEL_EMERG
- 1,
636 test_event_rule_log_level_generic("user space", LTTNG_DOMAIN_UST
,
637 loglevel_value_to_name
, tagged_log_level_values
,
638 ARRAY_SIZE(tagged_log_level_values
),
640 invalid_log_level_values
,
641 ARRAY_SIZE(invalid_log_level_values
));
644 static void test_event_rule_log_level_jul(void)
646 const int tagged_log_level_values
[] = {
647 LTTNG_LOGLEVEL_JUL_OFF
,
648 LTTNG_LOGLEVEL_JUL_SEVERE
,
649 LTTNG_LOGLEVEL_JUL_WARNING
,
650 LTTNG_LOGLEVEL_JUL_INFO
,
651 LTTNG_LOGLEVEL_JUL_CONFIG
,
652 LTTNG_LOGLEVEL_JUL_FINE
,
653 LTTNG_LOGLEVEL_JUL_FINER
,
654 LTTNG_LOGLEVEL_JUL_FINEST
,
655 LTTNG_LOGLEVEL_JUL_ALL
,
657 const int valid_log_level_values
[] = {
663 test_event_rule_log_level_generic("Java Util Logging", LTTNG_DOMAIN_JUL
,
664 loglevel_jul_value_to_name
, tagged_log_level_values
,
665 ARRAY_SIZE(tagged_log_level_values
),
666 valid_log_level_values
,
667 ARRAY_SIZE(valid_log_level_values
), NULL
, 0);
670 static void test_event_rule_log_level_log4j(void)
672 const int tagged_log_level_values
[] = {
673 LTTNG_LOGLEVEL_LOG4J_OFF
,
674 LTTNG_LOGLEVEL_LOG4J_FATAL
,
675 LTTNG_LOGLEVEL_LOG4J_ERROR
,
676 LTTNG_LOGLEVEL_LOG4J_WARN
,
677 LTTNG_LOGLEVEL_LOG4J_INFO
,
678 LTTNG_LOGLEVEL_LOG4J_DEBUG
,
679 LTTNG_LOGLEVEL_LOG4J_TRACE
,
680 LTTNG_LOGLEVEL_LOG4J_ALL
,
682 const int valid_log_level_values
[] = {
688 test_event_rule_log_level_generic("Log4j", LTTNG_DOMAIN_LOG4J
,
689 loglevel_log4j_value_to_name
, tagged_log_level_values
,
690 ARRAY_SIZE(tagged_log_level_values
),
691 valid_log_level_values
,
692 ARRAY_SIZE(valid_log_level_values
), NULL
, 0);
695 static void test_event_rule_log_level_python(void)
697 const int tagged_log_level_values
[] = {
698 LTTNG_LOGLEVEL_PYTHON_CRITICAL
,
699 LTTNG_LOGLEVEL_PYTHON_ERROR
,
700 LTTNG_LOGLEVEL_PYTHON_WARNING
,
701 LTTNG_LOGLEVEL_PYTHON_INFO
,
702 LTTNG_LOGLEVEL_PYTHON_DEBUG
,
703 LTTNG_LOGLEVEL_PYTHON_NOTSET
,
705 const int valid_log_level_values
[] = {
712 test_event_rule_log_level_generic("Python", LTTNG_DOMAIN_PYTHON
,
713 loglevel_python_value_to_name
, tagged_log_level_values
,
714 ARRAY_SIZE(tagged_log_level_values
),
715 valid_log_level_values
,
716 ARRAY_SIZE(valid_log_level_values
),
720 int main(int argc
, const char *argv
[])
722 plan_tests(NUM_TESTS
);
723 test_event_rule_tracepoint();
724 test_event_rule_kernel_tracepoint();
725 test_event_rule_user_tracepoint();
726 test_event_rule_syscall();
727 test_event_rule_userspace_probe();
728 test_event_rule_kernel_probe();
729 test_event_rule_log_level_ust();
730 test_event_rule_log_level_jul();
731 test_event_rule_log_level_log4j();
732 test_event_rule_log_level_python();
733 return exit_status();