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/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/tracepoint-internal.h>
28 #include <lttng/event-rule/tracepoint.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"
43 int lttng_opt_quiet
= 1;
44 int lttng_opt_verbose
;
49 struct tracepoint_test
{
50 enum lttng_domain_type type
;
51 bool support_name_pattern_exclusion
;
54 typedef const char *(*log_level_name_getter
)(int log_level
);
57 void test_event_rule_tracepoint_by_domain(const struct tracepoint_test
*test
)
60 struct lttng_event_rule
*tracepoint
= NULL
;
61 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
62 enum lttng_event_rule_status status
;
63 enum lttng_domain_type domain_type
, type
;
64 const char *pattern
="my_event_*";
65 const char *filter
="msg_id == 23 && size >= 2048";
67 const char *name_pattern_exclusions
[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
68 struct lttng_log_level_rule
*log_level_rule
= NULL
;
69 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
70 struct lttng_payload payload
;
73 diag("Testing domain %d.", type
);
75 lttng_payload_init(&payload
);
77 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
78 assert(log_level_rule
);
80 tracepoint
= lttng_event_rule_tracepoint_create(type
);
81 ok(tracepoint
, "tracepoint object.");
83 status
= lttng_event_rule_tracepoint_get_domain_type(tracepoint
, &domain_type
);
84 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get tracepoint domain.");
85 ok(domain_type
== type
, "domain type got %d expected %d.", domain_type
, type
);
87 status
= lttng_event_rule_tracepoint_set_name_pattern(tracepoint
, pattern
);
88 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
89 status
= lttng_event_rule_tracepoint_get_name_pattern(tracepoint
, &tmp
);
90 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
91 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
93 status
= lttng_event_rule_tracepoint_set_filter(tracepoint
, filter
);
94 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
95 status
= lttng_event_rule_tracepoint_get_filter(tracepoint
, &tmp
);
96 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
97 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
99 status
= lttng_event_rule_tracepoint_get_log_level_rule(tracepoint
, &log_level_rule_return
);
100 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
102 if (type
!= LTTNG_DOMAIN_KERNEL
) {
103 status
= lttng_event_rule_tracepoint_set_log_level_rule(tracepoint
, log_level_rule
);
104 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
105 status
= lttng_event_rule_tracepoint_get_log_level_rule(tracepoint
, &log_level_rule_return
);
106 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
109 if (test
->support_name_pattern_exclusion
) {
112 for (i
= 0; i
< 3; i
++) {
113 status
= lttng_event_rule_tracepoint_add_name_pattern_exclusion(tracepoint
, name_pattern_exclusions
[i
]);
114 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting name pattern exclusions \"%s\"", name_pattern_exclusions
[i
]);
117 status
= lttng_event_rule_tracepoint_get_name_pattern_exclusion_count(tracepoint
, &count
);
118 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting name pattern exclusion count.");
119 ok(count
== 3, "count is %d/3", count
);
121 for (i
= 0; i
< count
; i
++) {
122 status
= lttng_event_rule_tracepoint_get_name_pattern_exclusion_at_index(tracepoint
, i
, &tmp
);
123 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting name pattern exclusion at index %d.", i
);
124 ok(!strncmp(name_pattern_exclusions
[i
], tmp
, strlen(name_pattern_exclusions
[i
])), "%s == %s.", tmp
, name_pattern_exclusions
[i
]);
129 for (i
= 0; i
< 3; i
++) {
130 status
= lttng_event_rule_tracepoint_add_name_pattern_exclusion(tracepoint
, name_pattern_exclusions
[i
]);
131 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSUPPORTED
, "setting name pattern exclusions unsupported \"%s\".", name_pattern_exclusions
[i
]);
134 status
= lttng_event_rule_tracepoint_get_name_pattern_exclusion_count(tracepoint
, &count
);
135 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting name pattern exclusion count.");
136 ok(count
== 0, "count is %d/0", count
);
139 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
142 struct lttng_payload_view view
=
143 lttng_payload_view_from_payload(
146 ok(lttng_event_rule_create_from_payload(
147 &view
, &tracepoint_from_buffer
) > 0,
151 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
153 lttng_payload_reset(&payload
);
154 lttng_event_rule_destroy(tracepoint
);
155 lttng_event_rule_destroy(tracepoint_from_buffer
);
156 lttng_log_level_rule_destroy(log_level_rule
);
160 void test_event_rule_tracepoint(void)
163 struct lttng_event_rule
*tracepoint
= NULL
;
164 struct tracepoint_test tests
[] = {{LTTNG_DOMAIN_JUL
, false},
165 {LTTNG_DOMAIN_KERNEL
, false},
166 {LTTNG_DOMAIN_LOG4J
, false},
167 {LTTNG_DOMAIN_PYTHON
, false},
168 {LTTNG_DOMAIN_UST
, true}};
170 diag("Testing lttng_event_rule_tracepoint.");
171 tracepoint
= lttng_event_rule_tracepoint_create(LTTNG_DOMAIN_NONE
);
172 ok(!tracepoint
, "Domain type restriction on create.");
174 for (i
= 0; i
< sizeof(tests
) / sizeof(tests
[0]); i
++) {
175 test_event_rule_tracepoint_by_domain(&tests
[i
]);
180 void test_event_rule_kernel_tracepoint(void)
182 struct lttng_event_rule
*tracepoint
= NULL
;
183 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
184 enum lttng_event_rule_status status
;
185 const char *pattern
="my_event_*";
186 const char *filter
="msg_id == 23 && size >= 2048";
188 struct lttng_payload payload
;
190 diag("Testing lttng_event_rule_kernel_tracepoint.");
192 lttng_payload_init(&payload
);
194 tracepoint
= lttng_event_rule_kernel_tracepoint_create();
195 ok(tracepoint
, "tracepoint object.");
197 status
= lttng_event_rule_kernel_tracepoint_set_name_pattern(tracepoint
, pattern
);
198 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
199 status
= lttng_event_rule_kernel_tracepoint_get_name_pattern(tracepoint
, &tmp
);
200 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
201 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
203 status
= lttng_event_rule_kernel_tracepoint_set_filter(tracepoint
, filter
);
204 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
205 status
= lttng_event_rule_kernel_tracepoint_get_filter(tracepoint
, &tmp
);
206 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
207 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
209 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
212 struct lttng_payload_view view
=
213 lttng_payload_view_from_payload(
216 ok(lttng_event_rule_create_from_payload(
217 &view
, &tracepoint_from_buffer
) > 0,
221 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
223 lttng_payload_reset(&payload
);
224 lttng_event_rule_destroy(tracepoint
);
225 lttng_event_rule_destroy(tracepoint_from_buffer
);
229 void test_event_rule_user_tracepoint(void)
233 struct lttng_event_rule
*tracepoint
= NULL
;
234 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
235 enum lttng_event_rule_status status
;
236 const char *pattern
="my_event_*";
237 const char *filter
="msg_id == 23 && size >= 2048";
239 const char *name_pattern_exclusions
[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
240 struct lttng_log_level_rule
*log_level_rule
= NULL
;
241 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
242 struct lttng_payload payload
;
244 diag("Testing lttng_event_rule_user_tracepoint.");
246 lttng_payload_init(&payload
);
248 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
249 assert(log_level_rule
);
251 tracepoint
= lttng_event_rule_user_tracepoint_create();
252 ok(tracepoint
, "user tracepoint object.");
254 status
= lttng_event_rule_user_tracepoint_set_name_pattern(tracepoint
, pattern
);
255 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
256 status
= lttng_event_rule_user_tracepoint_get_name_pattern(tracepoint
, &tmp
);
257 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
258 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
260 status
= lttng_event_rule_user_tracepoint_set_filter(tracepoint
, filter
);
261 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
262 status
= lttng_event_rule_user_tracepoint_get_filter(tracepoint
, &tmp
);
263 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
264 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
266 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(tracepoint
, &log_level_rule_return
);
267 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
269 status
= lttng_event_rule_user_tracepoint_set_log_level_rule(
270 tracepoint
, log_level_rule
);
271 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
272 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(
273 tracepoint
, &log_level_rule_return
);
274 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
276 /* Name pattern exclusions */
277 for (i
= 0; i
< 3; i
++) {
278 status
= lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(
279 tracepoint
, name_pattern_exclusions
[i
]);
280 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
281 "setting name pattern exclusions \"%s\"",
282 name_pattern_exclusions
[i
]);
285 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
287 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
288 "getting name pattern exclusion count.");
289 ok(count
== 3, "count is %d/3", count
);
291 for (i
= 0; i
< count
; i
++) {
292 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
293 tracepoint
, i
, &tmp
);
294 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
295 "getting name pattern exclusion at index %d.",
297 ok(!strncmp(name_pattern_exclusions
[i
], tmp
,
298 strlen(name_pattern_exclusions
[i
])),
299 "%s == %s.", tmp
, name_pattern_exclusions
[i
]);
302 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
305 struct lttng_payload_view view
=
306 lttng_payload_view_from_payload(
309 ok(lttng_event_rule_create_from_payload(
310 &view
, &tracepoint_from_buffer
) > 0,
314 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
316 lttng_payload_reset(&payload
);
317 lttng_event_rule_destroy(tracepoint
);
318 lttng_event_rule_destroy(tracepoint_from_buffer
);
319 lttng_log_level_rule_destroy(log_level_rule
);
322 static void test_event_rule_syscall(void)
324 struct lttng_event_rule
*syscall
= NULL
;
325 struct lttng_event_rule
*syscall_from_buffer
= NULL
;
326 enum lttng_event_rule_status status
;
327 const char *pattern
= "my_event_*";
328 const char *filter
= "msg_id == 23 && size >= 2048";
330 struct lttng_payload payload
;
332 diag("Event rule syscall.");
334 lttng_payload_init(&payload
);
336 syscall
= lttng_event_rule_kernel_syscall_create(LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY
);
337 ok(syscall
, "syscall object.");
339 status
= lttng_event_rule_kernel_syscall_set_name_pattern(syscall
, pattern
);
340 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
341 status
= lttng_event_rule_kernel_syscall_get_name_pattern(syscall
, &tmp
);
342 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
343 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
345 status
= lttng_event_rule_kernel_syscall_set_filter(syscall
, filter
);
346 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
347 status
= lttng_event_rule_kernel_syscall_get_filter(syscall
, &tmp
);
348 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
349 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
351 ok(lttng_event_rule_serialize(syscall
, &payload
) == 0, "Serializing.");
354 struct lttng_payload_view view
=
355 lttng_payload_view_from_payload(
358 ok(lttng_event_rule_create_from_payload(
359 &view
, &syscall_from_buffer
) > 0,
363 ok(lttng_event_rule_is_equal(syscall
, syscall_from_buffer
),
364 "serialized and from buffer are equal.");
366 lttng_payload_reset(&payload
);
367 lttng_event_rule_destroy(syscall
);
368 lttng_event_rule_destroy(syscall_from_buffer
);
372 void test_event_rule_jul_logging(void)
374 struct lttng_event_rule
*jul_logging
= NULL
;
375 struct lttng_event_rule
*jul_logging_from_buffer
= NULL
;
376 enum lttng_event_rule_status status
;
377 const char *pattern
="my_event_*";
378 const char *filter
="msg_id == 23 && size >= 2048";
380 struct lttng_log_level_rule
*log_level_rule
= NULL
;
381 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
382 struct lttng_payload payload
;
384 diag("Testing lttng_event_rule_user_jul_logging.");
386 lttng_payload_init(&payload
);
388 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
389 assert(log_level_rule
);
391 jul_logging
= lttng_event_rule_jul_logging_create();
392 ok(jul_logging
, "jul_logging object.");
394 status
= lttng_event_rule_jul_logging_set_name_pattern(jul_logging
, pattern
);
395 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
396 status
= lttng_event_rule_jul_logging_get_name_pattern(jul_logging
, &tmp
);
397 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
398 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
400 status
= lttng_event_rule_jul_logging_set_filter(jul_logging
, filter
);
401 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
402 status
= lttng_event_rule_jul_logging_get_filter(jul_logging
, &tmp
);
403 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
404 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
406 status
= lttng_event_rule_jul_logging_get_log_level_rule(jul_logging
, &log_level_rule_return
);
407 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
409 status
= lttng_event_rule_jul_logging_set_log_level_rule(
410 jul_logging
, log_level_rule
);
411 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
412 status
= lttng_event_rule_jul_logging_get_log_level_rule(
413 jul_logging
, &log_level_rule_return
);
414 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
416 ok(lttng_event_rule_serialize(jul_logging
, &payload
) == 0, "Serializing.");
419 struct lttng_payload_view view
=
420 lttng_payload_view_from_payload(
423 ok(lttng_event_rule_create_from_payload(
424 &view
, &jul_logging_from_buffer
) > 0,
428 ok(lttng_event_rule_is_equal(jul_logging
, jul_logging_from_buffer
), "serialized and from buffer are equal.");
430 lttng_payload_reset(&payload
);
431 lttng_event_rule_destroy(jul_logging
);
432 lttng_event_rule_destroy(jul_logging_from_buffer
);
433 lttng_log_level_rule_destroy(log_level_rule
);
436 static void test_event_rule_userspace_probe(void)
438 struct lttng_event_rule
*uprobe
= NULL
;
439 struct lttng_event_rule
*uprobe_from_buffer
= NULL
;
440 struct lttng_userspace_probe_location_lookup_method
*lookup_method
=
442 struct lttng_userspace_probe_location
*probe_location
= NULL
;
443 const struct lttng_userspace_probe_location
*probe_location_tmp
= NULL
;
444 enum lttng_event_rule_status status
;
446 const char *probe_name
= "my_probe.";
448 struct lttng_payload payload
;
450 diag("Event rule uprobe.");
452 lookup_method
= lttng_userspace_probe_location_lookup_method_function_elf_create();
453 if (!lookup_method
) {
454 fail("Setup error on userspace probe lookup method creation.");
458 probe_location
= lttng_userspace_probe_location_function_create(
460 "lttng_userspace_probe_location_tracepoint_create",
462 if (!probe_location
) {
463 fail("Setup error on userspace probe location creation.");
467 /* Ownership transferred to the probe location function object. */
468 lookup_method
= NULL
;
470 lttng_payload_init(&payload
);
472 uprobe
= lttng_event_rule_kernel_uprobe_create(probe_location
);
473 ok(uprobe
, "uprobe event rule object creation.");
475 status
= lttng_event_rule_kernel_uprobe_get_location(
476 uprobe
, &probe_location_tmp
);
477 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
478 "Getting uprobe event rule location.");
479 ok(lttng_userspace_probe_location_is_equal(
480 probe_location
, probe_location_tmp
),
481 "Location is equal.");
483 status
= lttng_event_rule_kernel_uprobe_set_event_name(uprobe
, probe_name
);
484 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
485 "Setting uprobe event rule name: %s.", probe_name
);
486 status
= lttng_event_rule_kernel_uprobe_get_event_name(uprobe
, &tmp
);
487 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "Getting uprobe name.");
488 ok(!strcmp(probe_name
, tmp
), "Uprobe name are equal.");
490 ok(lttng_event_rule_serialize(uprobe
, &payload
) == 0, "Serializing.");
493 struct lttng_payload_view view
=
494 lttng_payload_view_from_payload(
497 ok(lttng_event_rule_create_from_payload(
498 &view
, &uprobe_from_buffer
) > 0,
502 ok(lttng_event_rule_is_equal(uprobe
, uprobe_from_buffer
),
503 "serialized and from buffer are equal.");
506 lttng_payload_reset(&payload
);
507 lttng_event_rule_destroy(uprobe
);
508 lttng_event_rule_destroy(uprobe_from_buffer
);
509 lttng_userspace_probe_location_destroy(probe_location
);
510 lttng_userspace_probe_location_lookup_method_destroy(lookup_method
);
513 static void test_event_rule_kernel_probe_by_location(
514 const struct lttng_kernel_probe_location
*location
)
516 struct lttng_event_rule
*kprobe
= NULL
;
517 struct lttng_event_rule
*kprobe_from_buffer
= NULL
;
518 enum lttng_event_rule_status status
;
519 const struct lttng_kernel_probe_location
*_location
;
521 const char *probe_name
= "my_probe";
523 struct lttng_payload payload
;
525 diag("Event rule kprobe for location type %d.",
526 lttng_kernel_probe_location_get_type(location
));
528 lttng_payload_init(&payload
);
530 kprobe
= lttng_event_rule_kernel_kprobe_create(location
);
531 ok(kprobe
, "kprobe event rule object creation.");
533 status
= lttng_event_rule_kernel_kprobe_get_location(kprobe
, &_location
);
534 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
535 "Getting kprobe event rule location.");
536 ok(lttng_kernel_probe_location_is_equal(location
, _location
), "Locations are equal.");
538 status
= lttng_event_rule_kernel_kprobe_set_event_name(kprobe
, probe_name
);
539 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
540 "Setting kprobe event rule name: %s.", probe_name
);
541 status
= lttng_event_rule_kernel_kprobe_get_event_name(kprobe
, &tmp
);
542 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "Getting kprobe name.");
543 ok(!strcmp(probe_name
, tmp
), "kprobe name are equal.");
545 ok(lttng_event_rule_serialize(kprobe
, &payload
) == 0, "Serializing.");
548 struct lttng_payload_view view
=
549 lttng_payload_view_from_payload(
552 ok(lttng_event_rule_create_from_payload(
553 &view
, &kprobe_from_buffer
) > 0,
557 ok(lttng_event_rule_is_equal(kprobe
, kprobe_from_buffer
),
558 "serialized and from buffer are equal.");
560 lttng_payload_reset(&payload
);
561 lttng_event_rule_destroy(kprobe
);
562 lttng_event_rule_destroy(kprobe_from_buffer
);
565 static void test_event_rule_kernel_probe(void)
567 struct lttng_kernel_probe_location
*address_location
= NULL
;
568 struct lttng_kernel_probe_location
*symbol_location
= NULL
;
570 address_location
= lttng_kernel_probe_location_address_create(50);
571 symbol_location
= lttng_kernel_probe_location_symbol_create("une_bonne", 50);
572 assert(address_location
);
573 assert(symbol_location
);
575 test_event_rule_kernel_probe_by_location(address_location
);
576 test_event_rule_kernel_probe_by_location(symbol_location
);
578 lttng_kernel_probe_location_destroy(address_location
);
579 lttng_kernel_probe_location_destroy(symbol_location
);
582 static void test_set_event_rule_log_level_rules(
583 struct lttng_event_rule
*event_rule
,
585 enum lttng_event_rule_status
*exactly_status
,
586 enum lttng_event_rule_status
*as_severe_status
)
588 struct lttng_log_level_rule
*log_level_rule
;
590 log_level_rule
= lttng_log_level_rule_at_least_as_severe_as_create(
592 assert(log_level_rule
);
594 *as_severe_status
= lttng_event_rule_tracepoint_set_log_level_rule(
595 event_rule
, log_level_rule
);
596 lttng_log_level_rule_destroy(log_level_rule
);
598 log_level_rule
= lttng_log_level_rule_exactly_create(log_level
);
599 assert(log_level_rule
);
601 *exactly_status
= lttng_event_rule_tracepoint_set_log_level_rule(
602 event_rule
, log_level_rule
);
603 lttng_log_level_rule_destroy(log_level_rule
);
606 static void test_event_rule_log_level_generic(const char *domain_name
,
607 enum lttng_domain_type domain
,
608 log_level_name_getter get_log_level_name
,
609 const int tagged_log_level_values
[],
610 size_t tagged_log_level_values_count
,
611 const int valid_log_level_values
[],
612 size_t valid_log_level_values_count
,
613 const int invalid_log_level_values
[],
614 size_t invalid_log_level_values_count
)
617 struct lttng_event_rule
*tracepoint_rule
;
618 enum lttng_event_rule_status er_exactly_status
, er_as_severe_status
;
620 diag("Test %s event rule + log level rule", domain_name
);
621 tracepoint_rule
= lttng_event_rule_tracepoint_create(domain
);
622 assert(tracepoint_rule
);
624 for (i
= 0; i
< tagged_log_level_values_count
; i
++) {
625 const int tagged_log_level_value
= tagged_log_level_values
[i
];
627 test_set_event_rule_log_level_rules(tracepoint_rule
,
628 tagged_log_level_value
,
629 &er_exactly_status
, &er_as_severe_status
);
630 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_OK
,
631 "Log level rule \"exactly\" accepted by %s tracepoint event rule: level = %s",
634 tagged_log_level_value
));
635 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_OK
,
636 "Log level rule \"as least as severe as\" accepted by %s tracepoint event rule: level = %s",
639 tagged_log_level_value
));
642 for (i
= 0; i
< valid_log_level_values_count
; i
++) {
643 const int valid_log_level_value
= valid_log_level_values
[i
];
645 test_set_event_rule_log_level_rules(tracepoint_rule
,
646 valid_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 tracepoint event rule: level = %d",
651 valid_log_level_value
);
652 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_OK
,
653 "Log level rule \"as least as severe as\" accepted by %s tracepoint event rule: level = %d",
655 valid_log_level_value
);
658 for (i
= 0; i
< invalid_log_level_values_count
; i
++) {
659 const int invalid_log_level_value
= invalid_log_level_values
[i
];
661 test_set_event_rule_log_level_rules(tracepoint_rule
,
662 invalid_log_level_value
,
663 &er_exactly_status
, &er_as_severe_status
);
664 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_INVALID
,
665 "Log level rule \"exactly\" rejected by %s tracepoint event rule: level = %d",
667 invalid_log_level_value
);
668 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_INVALID
,
669 "Log level rule \"as least as severe as\" rejected by %s tracepoint event rule: level = %d",
671 invalid_log_level_value
);
674 lttng_event_rule_destroy(tracepoint_rule
);
677 static void test_event_rule_log_level_ust(void)
679 const int tagged_log_level_values
[] = {
680 LTTNG_LOGLEVEL_EMERG
,
681 LTTNG_LOGLEVEL_ALERT
,
684 LTTNG_LOGLEVEL_WARNING
,
685 LTTNG_LOGLEVEL_NOTICE
,
687 LTTNG_LOGLEVEL_DEBUG_SYSTEM
,
688 LTTNG_LOGLEVEL_DEBUG_PROGRAM
,
689 LTTNG_LOGLEVEL_DEBUG_PROCESS
,
690 LTTNG_LOGLEVEL_DEBUG_MODULE
,
691 LTTNG_LOGLEVEL_DEBUG_UNIT
,
692 LTTNG_LOGLEVEL_DEBUG_FUNCTION
,
693 LTTNG_LOGLEVEL_DEBUG_LINE
,
694 LTTNG_LOGLEVEL_DEBUG
,
696 const int invalid_log_level_values
[] = {
699 LTTNG_LOGLEVEL_DEBUG
+ 1,
700 LTTNG_LOGLEVEL_EMERG
- 1,
703 test_event_rule_log_level_generic("user space", LTTNG_DOMAIN_UST
,
704 loglevel_value_to_name
, tagged_log_level_values
,
705 ARRAY_SIZE(tagged_log_level_values
),
707 invalid_log_level_values
,
708 ARRAY_SIZE(invalid_log_level_values
));
711 static void test_event_rule_log_level_jul(void)
713 const int tagged_log_level_values
[] = {
714 LTTNG_LOGLEVEL_JUL_OFF
,
715 LTTNG_LOGLEVEL_JUL_SEVERE
,
716 LTTNG_LOGLEVEL_JUL_WARNING
,
717 LTTNG_LOGLEVEL_JUL_INFO
,
718 LTTNG_LOGLEVEL_JUL_CONFIG
,
719 LTTNG_LOGLEVEL_JUL_FINE
,
720 LTTNG_LOGLEVEL_JUL_FINER
,
721 LTTNG_LOGLEVEL_JUL_FINEST
,
722 LTTNG_LOGLEVEL_JUL_ALL
,
724 const int valid_log_level_values
[] = {
730 test_event_rule_log_level_generic("Java Util Logging", LTTNG_DOMAIN_JUL
,
731 loglevel_jul_value_to_name
, tagged_log_level_values
,
732 ARRAY_SIZE(tagged_log_level_values
),
733 valid_log_level_values
,
734 ARRAY_SIZE(valid_log_level_values
), NULL
, 0);
737 static void test_event_rule_log_level_log4j(void)
739 const int tagged_log_level_values
[] = {
740 LTTNG_LOGLEVEL_LOG4J_OFF
,
741 LTTNG_LOGLEVEL_LOG4J_FATAL
,
742 LTTNG_LOGLEVEL_LOG4J_ERROR
,
743 LTTNG_LOGLEVEL_LOG4J_WARN
,
744 LTTNG_LOGLEVEL_LOG4J_INFO
,
745 LTTNG_LOGLEVEL_LOG4J_DEBUG
,
746 LTTNG_LOGLEVEL_LOG4J_TRACE
,
747 LTTNG_LOGLEVEL_LOG4J_ALL
,
749 const int valid_log_level_values
[] = {
755 test_event_rule_log_level_generic("Log4j", LTTNG_DOMAIN_LOG4J
,
756 loglevel_log4j_value_to_name
, tagged_log_level_values
,
757 ARRAY_SIZE(tagged_log_level_values
),
758 valid_log_level_values
,
759 ARRAY_SIZE(valid_log_level_values
), NULL
, 0);
762 static void test_event_rule_log_level_python(void)
764 const int tagged_log_level_values
[] = {
765 LTTNG_LOGLEVEL_PYTHON_CRITICAL
,
766 LTTNG_LOGLEVEL_PYTHON_ERROR
,
767 LTTNG_LOGLEVEL_PYTHON_WARNING
,
768 LTTNG_LOGLEVEL_PYTHON_INFO
,
769 LTTNG_LOGLEVEL_PYTHON_DEBUG
,
770 LTTNG_LOGLEVEL_PYTHON_NOTSET
,
772 const int valid_log_level_values
[] = {
779 test_event_rule_log_level_generic("Python", LTTNG_DOMAIN_PYTHON
,
780 loglevel_python_value_to_name
, tagged_log_level_values
,
781 ARRAY_SIZE(tagged_log_level_values
),
782 valid_log_level_values
,
783 ARRAY_SIZE(valid_log_level_values
),
787 int main(int argc
, const char *argv
[])
789 plan_tests(NUM_TESTS
);
790 test_event_rule_tracepoint();
791 test_event_rule_kernel_tracepoint();
792 test_event_rule_user_tracepoint();
793 test_event_rule_syscall();
794 test_event_rule_userspace_probe();
795 test_event_rule_kernel_probe();
796 test_event_rule_jul_logging();
797 test_event_rule_log_level_ust();
798 test_event_rule_log_level_jul();
799 test_event_rule_log_level_log4j();
800 test_event_rule_log_level_python();
801 return exit_status();