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/python-logging-internal.h>
28 #include <lttng/event-rule/python-logging.h>
29 #include <lttng/event-rule/tracepoint-internal.h>
30 #include <lttng/event-rule/tracepoint.h>
31 #include <lttng/event-rule/kernel-tracepoint-internal.h>
32 #include <lttng/event-rule/kernel-tracepoint.h>
33 #include <lttng/event-rule/kernel-uprobe-internal.h>
34 #include <lttng/event-rule/kernel-uprobe.h>
35 #include <lttng/event-rule/user-tracepoint-internal.h>
36 #include <lttng/event-rule/user-tracepoint.h>
37 #include <lttng/event.h>
38 #include <lttng/kernel-probe-internal.h>
39 #include <lttng/kernel-probe.h>
40 #include <lttng/userspace-probe-internal.h>
41 #include <lttng/userspace-probe.h>
42 #include "bin/lttng/loglevel.h"
45 int lttng_opt_quiet
= 1;
46 int lttng_opt_verbose
;
51 struct tracepoint_test
{
52 enum lttng_domain_type type
;
53 bool support_name_pattern_exclusion
;
56 typedef const char *(*log_level_name_getter
)(int log_level
);
58 typedef struct lttng_event_rule
*(*event_rule_create
)(void);
59 typedef enum lttng_event_rule_status (*event_rule_set_log_level
)(
60 struct lttng_event_rule
*rule
,
61 const struct lttng_log_level_rule
*log_level_rule
);
64 void test_event_rule_tracepoint_by_domain(const struct tracepoint_test
*test
)
67 struct lttng_event_rule
*tracepoint
= NULL
;
68 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
69 enum lttng_event_rule_status status
;
70 enum lttng_domain_type domain_type
, type
;
71 const char *pattern
="my_event_*";
72 const char *filter
="msg_id == 23 && size >= 2048";
74 const char *name_pattern_exclusions
[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
75 struct lttng_log_level_rule
*log_level_rule
= NULL
;
76 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
77 struct lttng_payload payload
;
80 diag("Testing domain %d.", type
);
82 lttng_payload_init(&payload
);
84 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
85 assert(log_level_rule
);
87 tracepoint
= lttng_event_rule_tracepoint_create(type
);
88 ok(tracepoint
, "tracepoint object.");
90 status
= lttng_event_rule_tracepoint_get_domain_type(tracepoint
, &domain_type
);
91 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get tracepoint domain.");
92 ok(domain_type
== type
, "domain type got %d expected %d.", domain_type
, type
);
94 status
= lttng_event_rule_tracepoint_set_name_pattern(tracepoint
, pattern
);
95 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
96 status
= lttng_event_rule_tracepoint_get_name_pattern(tracepoint
, &tmp
);
97 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
98 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
100 status
= lttng_event_rule_tracepoint_set_filter(tracepoint
, filter
);
101 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
102 status
= lttng_event_rule_tracepoint_get_filter(tracepoint
, &tmp
);
103 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
104 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
106 status
= lttng_event_rule_tracepoint_get_log_level_rule(tracepoint
, &log_level_rule_return
);
107 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
109 if (type
!= LTTNG_DOMAIN_KERNEL
) {
110 status
= lttng_event_rule_tracepoint_set_log_level_rule(tracepoint
, log_level_rule
);
111 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
112 status
= lttng_event_rule_tracepoint_get_log_level_rule(tracepoint
, &log_level_rule_return
);
113 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
116 if (test
->support_name_pattern_exclusion
) {
119 for (i
= 0; i
< 3; i
++) {
120 status
= lttng_event_rule_tracepoint_add_name_pattern_exclusion(tracepoint
, name_pattern_exclusions
[i
]);
121 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting name pattern exclusions \"%s\"", name_pattern_exclusions
[i
]);
124 status
= lttng_event_rule_tracepoint_get_name_pattern_exclusion_count(tracepoint
, &count
);
125 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting name pattern exclusion count.");
126 ok(count
== 3, "count is %d/3", count
);
128 for (i
= 0; i
< count
; i
++) {
129 status
= lttng_event_rule_tracepoint_get_name_pattern_exclusion_at_index(tracepoint
, i
, &tmp
);
130 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting name pattern exclusion at index %d.", i
);
131 ok(!strncmp(name_pattern_exclusions
[i
], tmp
, strlen(name_pattern_exclusions
[i
])), "%s == %s.", tmp
, name_pattern_exclusions
[i
]);
136 for (i
= 0; i
< 3; i
++) {
137 status
= lttng_event_rule_tracepoint_add_name_pattern_exclusion(tracepoint
, name_pattern_exclusions
[i
]);
138 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSUPPORTED
, "setting name pattern exclusions unsupported \"%s\".", name_pattern_exclusions
[i
]);
141 status
= lttng_event_rule_tracepoint_get_name_pattern_exclusion_count(tracepoint
, &count
);
142 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting name pattern exclusion count.");
143 ok(count
== 0, "count is %d/0", count
);
146 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
149 struct lttng_payload_view view
=
150 lttng_payload_view_from_payload(
153 ok(lttng_event_rule_create_from_payload(
154 &view
, &tracepoint_from_buffer
) > 0,
158 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
160 lttng_payload_reset(&payload
);
161 lttng_event_rule_destroy(tracepoint
);
162 lttng_event_rule_destroy(tracepoint_from_buffer
);
163 lttng_log_level_rule_destroy(log_level_rule
);
167 void test_event_rule_tracepoint(void)
170 struct lttng_event_rule
*tracepoint
= NULL
;
171 struct tracepoint_test tests
[] = {{LTTNG_DOMAIN_JUL
, false},
172 {LTTNG_DOMAIN_KERNEL
, false},
173 {LTTNG_DOMAIN_LOG4J
, false},
174 {LTTNG_DOMAIN_PYTHON
, false},
175 {LTTNG_DOMAIN_UST
, true}};
177 diag("Testing lttng_event_rule_tracepoint.");
178 tracepoint
= lttng_event_rule_tracepoint_create(LTTNG_DOMAIN_NONE
);
179 ok(!tracepoint
, "Domain type restriction on create.");
181 for (i
= 0; i
< sizeof(tests
) / sizeof(tests
[0]); i
++) {
182 test_event_rule_tracepoint_by_domain(&tests
[i
]);
187 void test_event_rule_kernel_tracepoint(void)
189 struct lttng_event_rule
*tracepoint
= NULL
;
190 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
191 enum lttng_event_rule_status status
;
192 const char *pattern
="my_event_*";
193 const char *filter
="msg_id == 23 && size >= 2048";
195 struct lttng_payload payload
;
197 diag("Testing lttng_event_rule_kernel_tracepoint.");
199 lttng_payload_init(&payload
);
201 tracepoint
= lttng_event_rule_kernel_tracepoint_create();
202 ok(tracepoint
, "tracepoint object.");
204 status
= lttng_event_rule_kernel_tracepoint_set_name_pattern(tracepoint
, pattern
);
205 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
206 status
= lttng_event_rule_kernel_tracepoint_get_name_pattern(tracepoint
, &tmp
);
207 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
208 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
210 status
= lttng_event_rule_kernel_tracepoint_set_filter(tracepoint
, filter
);
211 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
212 status
= lttng_event_rule_kernel_tracepoint_get_filter(tracepoint
, &tmp
);
213 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
214 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
216 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
219 struct lttng_payload_view view
=
220 lttng_payload_view_from_payload(
223 ok(lttng_event_rule_create_from_payload(
224 &view
, &tracepoint_from_buffer
) > 0,
228 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
230 lttng_payload_reset(&payload
);
231 lttng_event_rule_destroy(tracepoint
);
232 lttng_event_rule_destroy(tracepoint_from_buffer
);
236 void test_event_rule_user_tracepoint(void)
240 struct lttng_event_rule
*tracepoint
= NULL
;
241 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
242 enum lttng_event_rule_status status
;
243 const char *pattern
="my_event_*";
244 const char *filter
="msg_id == 23 && size >= 2048";
246 const char *name_pattern_exclusions
[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
247 struct lttng_log_level_rule
*log_level_rule
= NULL
;
248 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
249 struct lttng_payload payload
;
251 diag("Testing lttng_event_rule_user_tracepoint.");
253 lttng_payload_init(&payload
);
255 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
256 assert(log_level_rule
);
258 tracepoint
= lttng_event_rule_user_tracepoint_create();
259 ok(tracepoint
, "user tracepoint object.");
261 status
= lttng_event_rule_user_tracepoint_set_name_pattern(tracepoint
, pattern
);
262 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
263 status
= lttng_event_rule_user_tracepoint_get_name_pattern(tracepoint
, &tmp
);
264 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
265 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
267 status
= lttng_event_rule_user_tracepoint_set_filter(tracepoint
, filter
);
268 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
269 status
= lttng_event_rule_user_tracepoint_get_filter(tracepoint
, &tmp
);
270 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
271 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
273 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(tracepoint
, &log_level_rule_return
);
274 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
276 status
= lttng_event_rule_user_tracepoint_set_log_level_rule(
277 tracepoint
, log_level_rule
);
278 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
279 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(
280 tracepoint
, &log_level_rule_return
);
281 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
283 /* Name pattern exclusions */
284 for (i
= 0; i
< 3; i
++) {
285 status
= lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(
286 tracepoint
, name_pattern_exclusions
[i
]);
287 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
288 "setting name pattern exclusions \"%s\"",
289 name_pattern_exclusions
[i
]);
292 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
294 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
295 "getting name pattern exclusion count.");
296 ok(count
== 3, "count is %d/3", count
);
298 for (i
= 0; i
< count
; i
++) {
299 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
300 tracepoint
, i
, &tmp
);
301 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
302 "getting name pattern exclusion at index %d.",
304 ok(!strncmp(name_pattern_exclusions
[i
], tmp
,
305 strlen(name_pattern_exclusions
[i
])),
306 "%s == %s.", tmp
, name_pattern_exclusions
[i
]);
309 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
312 struct lttng_payload_view view
=
313 lttng_payload_view_from_payload(
316 ok(lttng_event_rule_create_from_payload(
317 &view
, &tracepoint_from_buffer
) > 0,
321 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
323 lttng_payload_reset(&payload
);
324 lttng_event_rule_destroy(tracepoint
);
325 lttng_event_rule_destroy(tracepoint_from_buffer
);
326 lttng_log_level_rule_destroy(log_level_rule
);
329 static void test_event_rule_syscall(void)
331 struct lttng_event_rule
*syscall
= NULL
;
332 struct lttng_event_rule
*syscall_from_buffer
= NULL
;
333 enum lttng_event_rule_status status
;
334 const char *pattern
= "my_event_*";
335 const char *filter
= "msg_id == 23 && size >= 2048";
337 struct lttng_payload payload
;
339 diag("Event rule syscall.");
341 lttng_payload_init(&payload
);
343 syscall
= lttng_event_rule_kernel_syscall_create(LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY
);
344 ok(syscall
, "syscall object.");
346 status
= lttng_event_rule_kernel_syscall_set_name_pattern(syscall
, pattern
);
347 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
348 status
= lttng_event_rule_kernel_syscall_get_name_pattern(syscall
, &tmp
);
349 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
350 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
352 status
= lttng_event_rule_kernel_syscall_set_filter(syscall
, filter
);
353 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
354 status
= lttng_event_rule_kernel_syscall_get_filter(syscall
, &tmp
);
355 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
356 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
358 ok(lttng_event_rule_serialize(syscall
, &payload
) == 0, "Serializing.");
361 struct lttng_payload_view view
=
362 lttng_payload_view_from_payload(
365 ok(lttng_event_rule_create_from_payload(
366 &view
, &syscall_from_buffer
) > 0,
370 ok(lttng_event_rule_is_equal(syscall
, syscall_from_buffer
),
371 "serialized and from buffer are equal.");
373 lttng_payload_reset(&payload
);
374 lttng_event_rule_destroy(syscall
);
375 lttng_event_rule_destroy(syscall_from_buffer
);
379 void test_event_rule_jul_logging(void)
381 struct lttng_event_rule
*jul_logging
= NULL
;
382 struct lttng_event_rule
*jul_logging_from_buffer
= NULL
;
383 enum lttng_event_rule_status status
;
384 const char *pattern
="my_event_*";
385 const char *filter
="msg_id == 23 && size >= 2048";
387 struct lttng_log_level_rule
*log_level_rule
= NULL
;
388 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
389 struct lttng_payload payload
;
391 diag("Testing lttng_event_rule_user_jul_logging.");
393 lttng_payload_init(&payload
);
395 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
396 assert(log_level_rule
);
398 jul_logging
= lttng_event_rule_jul_logging_create();
399 ok(jul_logging
, "jul_logging object.");
401 status
= lttng_event_rule_jul_logging_set_name_pattern(jul_logging
, pattern
);
402 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
403 status
= lttng_event_rule_jul_logging_get_name_pattern(jul_logging
, &tmp
);
404 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
405 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
407 status
= lttng_event_rule_jul_logging_set_filter(jul_logging
, filter
);
408 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
409 status
= lttng_event_rule_jul_logging_get_filter(jul_logging
, &tmp
);
410 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
411 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
413 status
= lttng_event_rule_jul_logging_get_log_level_rule(jul_logging
, &log_level_rule_return
);
414 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
416 status
= lttng_event_rule_jul_logging_set_log_level_rule(
417 jul_logging
, log_level_rule
);
418 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
419 status
= lttng_event_rule_jul_logging_get_log_level_rule(
420 jul_logging
, &log_level_rule_return
);
421 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
423 ok(lttng_event_rule_serialize(jul_logging
, &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
, &jul_logging_from_buffer
) > 0,
435 ok(lttng_event_rule_is_equal(jul_logging
, jul_logging_from_buffer
), "serialized and from buffer are equal.");
437 lttng_payload_reset(&payload
);
438 lttng_event_rule_destroy(jul_logging
);
439 lttng_event_rule_destroy(jul_logging_from_buffer
);
440 lttng_log_level_rule_destroy(log_level_rule
);
444 void test_event_rule_log4j_logging(void)
446 struct lttng_event_rule
*log4j_logging
= NULL
;
447 struct lttng_event_rule
*log4j_logging_from_buffer
= NULL
;
448 enum lttng_event_rule_status status
;
449 const char *pattern
="my_event_*";
450 const char *filter
="msg_id == 23 && size >= 2048";
452 struct lttng_log_level_rule
*log_level_rule
= NULL
;
453 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
454 struct lttng_payload payload
;
456 diag("Testing lttng_event_rule_user_log4j_logging.");
458 lttng_payload_init(&payload
);
460 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
461 assert(log_level_rule
);
463 log4j_logging
= lttng_event_rule_log4j_logging_create();
464 ok(log4j_logging
, "log4j_logging object.");
466 status
= lttng_event_rule_log4j_logging_set_name_pattern(log4j_logging
, pattern
);
467 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
468 status
= lttng_event_rule_log4j_logging_get_name_pattern(log4j_logging
, &tmp
);
469 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
470 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
472 status
= lttng_event_rule_log4j_logging_set_filter(log4j_logging
, filter
);
473 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
474 status
= lttng_event_rule_log4j_logging_get_filter(log4j_logging
, &tmp
);
475 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
476 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
478 status
= lttng_event_rule_log4j_logging_get_log_level_rule(log4j_logging
, &log_level_rule_return
);
479 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
481 status
= lttng_event_rule_log4j_logging_set_log_level_rule(
482 log4j_logging
, log_level_rule
);
483 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
484 status
= lttng_event_rule_log4j_logging_get_log_level_rule(
485 log4j_logging
, &log_level_rule_return
);
486 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
488 ok(lttng_event_rule_serialize(log4j_logging
, &payload
) == 0, "Serializing.");
491 struct lttng_payload_view view
=
492 lttng_payload_view_from_payload(
495 ok(lttng_event_rule_create_from_payload(
496 &view
, &log4j_logging_from_buffer
) > 0,
500 ok(lttng_event_rule_is_equal(log4j_logging
, log4j_logging_from_buffer
), "serialized and from buffer are equal.");
502 lttng_payload_reset(&payload
);
503 lttng_event_rule_destroy(log4j_logging
);
504 lttng_event_rule_destroy(log4j_logging_from_buffer
);
505 lttng_log_level_rule_destroy(log_level_rule
);
509 void test_event_rule_python_logging(void)
511 struct lttng_event_rule
*python_logging
= NULL
;
512 struct lttng_event_rule
*python_logging_from_buffer
= NULL
;
513 enum lttng_event_rule_status status
;
514 const char *pattern
="my_event_*";
515 const char *filter
="msg_id == 23 && size >= 2048";
517 struct lttng_log_level_rule
*log_level_rule
= NULL
;
518 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
519 struct lttng_payload payload
;
521 diag("Testing lttng_event_rule_user_python_logging.");
523 lttng_payload_init(&payload
);
525 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
526 assert(log_level_rule
);
528 python_logging
= lttng_event_rule_python_logging_create();
529 ok(python_logging
, "python_logging object.");
531 status
= lttng_event_rule_python_logging_set_name_pattern(python_logging
, pattern
);
532 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
533 status
= lttng_event_rule_python_logging_get_name_pattern(python_logging
, &tmp
);
534 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
535 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
537 status
= lttng_event_rule_python_logging_set_filter(python_logging
, filter
);
538 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
539 status
= lttng_event_rule_python_logging_get_filter(python_logging
, &tmp
);
540 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
541 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
543 status
= lttng_event_rule_python_logging_get_log_level_rule(python_logging
, &log_level_rule_return
);
544 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
546 status
= lttng_event_rule_python_logging_set_log_level_rule(
547 python_logging
, log_level_rule
);
548 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
549 status
= lttng_event_rule_python_logging_get_log_level_rule(
550 python_logging
, &log_level_rule_return
);
551 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
553 ok(lttng_event_rule_serialize(python_logging
, &payload
) == 0, "Serializing.");
556 struct lttng_payload_view view
=
557 lttng_payload_view_from_payload(
560 ok(lttng_event_rule_create_from_payload(
561 &view
, &python_logging_from_buffer
) > 0,
565 ok(lttng_event_rule_is_equal(python_logging
, python_logging_from_buffer
), "serialized and from buffer are equal.");
567 lttng_payload_reset(&payload
);
568 lttng_event_rule_destroy(python_logging
);
569 lttng_event_rule_destroy(python_logging_from_buffer
);
570 lttng_log_level_rule_destroy(log_level_rule
);
573 static void test_event_rule_userspace_probe(void)
575 struct lttng_event_rule
*uprobe
= NULL
;
576 struct lttng_event_rule
*uprobe_from_buffer
= NULL
;
577 struct lttng_userspace_probe_location_lookup_method
*lookup_method
=
579 struct lttng_userspace_probe_location
*probe_location
= NULL
;
580 const struct lttng_userspace_probe_location
*probe_location_tmp
= NULL
;
581 enum lttng_event_rule_status status
;
583 const char *probe_name
= "my_probe.";
585 struct lttng_payload payload
;
587 diag("Event rule uprobe.");
589 lookup_method
= lttng_userspace_probe_location_lookup_method_function_elf_create();
590 if (!lookup_method
) {
591 fail("Setup error on userspace probe lookup method creation.");
595 probe_location
= lttng_userspace_probe_location_function_create(
597 "lttng_userspace_probe_location_tracepoint_create",
599 if (!probe_location
) {
600 fail("Setup error on userspace probe location creation.");
604 /* Ownership transferred to the probe location function object. */
605 lookup_method
= NULL
;
607 lttng_payload_init(&payload
);
609 uprobe
= lttng_event_rule_kernel_uprobe_create(probe_location
);
610 ok(uprobe
, "uprobe event rule object creation.");
612 status
= lttng_event_rule_kernel_uprobe_get_location(
613 uprobe
, &probe_location_tmp
);
614 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
615 "Getting uprobe event rule location.");
616 ok(lttng_userspace_probe_location_is_equal(
617 probe_location
, probe_location_tmp
),
618 "Location is equal.");
620 status
= lttng_event_rule_kernel_uprobe_set_event_name(uprobe
, probe_name
);
621 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
622 "Setting uprobe event rule name: %s.", probe_name
);
623 status
= lttng_event_rule_kernel_uprobe_get_event_name(uprobe
, &tmp
);
624 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "Getting uprobe name.");
625 ok(!strcmp(probe_name
, tmp
), "Uprobe name are equal.");
627 ok(lttng_event_rule_serialize(uprobe
, &payload
) == 0, "Serializing.");
630 struct lttng_payload_view view
=
631 lttng_payload_view_from_payload(
634 ok(lttng_event_rule_create_from_payload(
635 &view
, &uprobe_from_buffer
) > 0,
639 ok(lttng_event_rule_is_equal(uprobe
, uprobe_from_buffer
),
640 "serialized and from buffer are equal.");
643 lttng_payload_reset(&payload
);
644 lttng_event_rule_destroy(uprobe
);
645 lttng_event_rule_destroy(uprobe_from_buffer
);
646 lttng_userspace_probe_location_destroy(probe_location
);
647 lttng_userspace_probe_location_lookup_method_destroy(lookup_method
);
650 static void test_event_rule_kernel_probe_by_location(
651 const struct lttng_kernel_probe_location
*location
)
653 struct lttng_event_rule
*kprobe
= NULL
;
654 struct lttng_event_rule
*kprobe_from_buffer
= NULL
;
655 enum lttng_event_rule_status status
;
656 const struct lttng_kernel_probe_location
*_location
;
658 const char *probe_name
= "my_probe";
660 struct lttng_payload payload
;
662 diag("Event rule kprobe for location type %d.",
663 lttng_kernel_probe_location_get_type(location
));
665 lttng_payload_init(&payload
);
667 kprobe
= lttng_event_rule_kernel_kprobe_create(location
);
668 ok(kprobe
, "kprobe event rule object creation.");
670 status
= lttng_event_rule_kernel_kprobe_get_location(kprobe
, &_location
);
671 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
672 "Getting kprobe event rule location.");
673 ok(lttng_kernel_probe_location_is_equal(location
, _location
), "Locations are equal.");
675 status
= lttng_event_rule_kernel_kprobe_set_event_name(kprobe
, probe_name
);
676 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
677 "Setting kprobe event rule name: %s.", probe_name
);
678 status
= lttng_event_rule_kernel_kprobe_get_event_name(kprobe
, &tmp
);
679 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "Getting kprobe name.");
680 ok(!strcmp(probe_name
, tmp
), "kprobe name are equal.");
682 ok(lttng_event_rule_serialize(kprobe
, &payload
) == 0, "Serializing.");
685 struct lttng_payload_view view
=
686 lttng_payload_view_from_payload(
689 ok(lttng_event_rule_create_from_payload(
690 &view
, &kprobe_from_buffer
) > 0,
694 ok(lttng_event_rule_is_equal(kprobe
, kprobe_from_buffer
),
695 "serialized and from buffer are equal.");
697 lttng_payload_reset(&payload
);
698 lttng_event_rule_destroy(kprobe
);
699 lttng_event_rule_destroy(kprobe_from_buffer
);
702 static void test_event_rule_kernel_probe(void)
704 struct lttng_kernel_probe_location
*address_location
= NULL
;
705 struct lttng_kernel_probe_location
*symbol_location
= NULL
;
707 address_location
= lttng_kernel_probe_location_address_create(50);
708 symbol_location
= lttng_kernel_probe_location_symbol_create("une_bonne", 50);
709 assert(address_location
);
710 assert(symbol_location
);
712 test_event_rule_kernel_probe_by_location(address_location
);
713 test_event_rule_kernel_probe_by_location(symbol_location
);
715 lttng_kernel_probe_location_destroy(address_location
);
716 lttng_kernel_probe_location_destroy(symbol_location
);
719 static void test_set_event_rule_log_level_rules(
720 struct lttng_event_rule
*event_rule
,
721 event_rule_set_log_level set_log_level
,
723 enum lttng_event_rule_status
*exactly_status
,
724 enum lttng_event_rule_status
*as_severe_status
)
726 struct lttng_log_level_rule
*log_level_rule
;
728 log_level_rule
= lttng_log_level_rule_at_least_as_severe_as_create(
730 assert(log_level_rule
);
732 *as_severe_status
= set_log_level(
733 event_rule
, log_level_rule
);
734 lttng_log_level_rule_destroy(log_level_rule
);
736 log_level_rule
= lttng_log_level_rule_exactly_create(log_level
);
737 assert(log_level_rule
);
739 *exactly_status
= set_log_level(
740 event_rule
, log_level_rule
);
741 lttng_log_level_rule_destroy(log_level_rule
);
744 static void test_event_rule_log_level_generic(enum lttng_event_rule_type event_rule_type
,
745 log_level_name_getter get_log_level_name
,
746 event_rule_create create_event_rule
,
747 event_rule_set_log_level set_log_level
,
748 const int tagged_log_level_values
[],
749 size_t tagged_log_level_values_count
,
750 const int valid_log_level_values
[],
751 size_t valid_log_level_values_count
,
752 const int invalid_log_level_values
[],
753 size_t invalid_log_level_values_count
)
756 struct lttng_event_rule
*rule
;
757 enum lttng_event_rule_status er_exactly_status
, er_as_severe_status
;
758 const char *event_rule_type_str
= lttng_event_rule_type_str(event_rule_type
);
761 diag("Test %s event rule + log level rule", event_rule_type_str
);
763 rule
= create_event_rule();
766 for (i
= 0; i
< tagged_log_level_values_count
; i
++) {
767 const int tagged_log_level_value
= tagged_log_level_values
[i
];
769 test_set_event_rule_log_level_rules(rule
, set_log_level
,
770 tagged_log_level_value
,
771 &er_exactly_status
, &er_as_severe_status
);
772 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_OK
,
773 "Log level rule \"exactly\" accepted by %s event rule: level = %s",
776 tagged_log_level_value
));
777 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_OK
,
778 "Log level rule \"as least as severe as\" accepted by %s event rule: level = %s",
781 tagged_log_level_value
));
784 for (i
= 0; i
< valid_log_level_values_count
; i
++) {
785 const int valid_log_level_value
= valid_log_level_values
[i
];
787 test_set_event_rule_log_level_rules(rule
, set_log_level
,
788 valid_log_level_value
,
789 &er_exactly_status
, &er_as_severe_status
);
790 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_OK
,
791 "Log level rule \"exactly\" accepted by %s event rule: level = %d",
793 valid_log_level_value
);
794 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_OK
,
795 "Log level rule \"as least as severe as\" accepted by %s event rule: level = %d",
797 valid_log_level_value
);
800 for (i
= 0; i
< invalid_log_level_values_count
; i
++) {
801 const int invalid_log_level_value
= invalid_log_level_values
[i
];
803 test_set_event_rule_log_level_rules(rule
, set_log_level
,
804 invalid_log_level_value
,
805 &er_exactly_status
, &er_as_severe_status
);
806 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_INVALID
,
807 "Log level rule \"exactly\" rejected by %s event rule: level = %d",
809 invalid_log_level_value
);
810 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_INVALID
,
811 "Log level rule \"as least as severe as\" rejected by %s event rule: level = %d",
813 invalid_log_level_value
);
816 lttng_event_rule_destroy(rule
);
819 static void test_event_rule_log_level_ust(void)
821 const int tagged_log_level_values
[] = {
822 LTTNG_LOGLEVEL_EMERG
,
823 LTTNG_LOGLEVEL_ALERT
,
826 LTTNG_LOGLEVEL_WARNING
,
827 LTTNG_LOGLEVEL_NOTICE
,
829 LTTNG_LOGLEVEL_DEBUG_SYSTEM
,
830 LTTNG_LOGLEVEL_DEBUG_PROGRAM
,
831 LTTNG_LOGLEVEL_DEBUG_PROCESS
,
832 LTTNG_LOGLEVEL_DEBUG_MODULE
,
833 LTTNG_LOGLEVEL_DEBUG_UNIT
,
834 LTTNG_LOGLEVEL_DEBUG_FUNCTION
,
835 LTTNG_LOGLEVEL_DEBUG_LINE
,
836 LTTNG_LOGLEVEL_DEBUG
,
838 const int invalid_log_level_values
[] = {
841 LTTNG_LOGLEVEL_DEBUG
+ 1,
842 LTTNG_LOGLEVEL_EMERG
- 1,
845 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
,
846 loglevel_value_to_name
,
847 lttng_event_rule_user_tracepoint_create
,
848 lttng_event_rule_user_tracepoint_set_log_level_rule
,
849 tagged_log_level_values
,
850 ARRAY_SIZE(tagged_log_level_values
), NULL
, 0,
851 invalid_log_level_values
,
852 ARRAY_SIZE(invalid_log_level_values
));
855 static void test_event_rule_log_level_jul(void)
857 const int tagged_log_level_values
[] = {
858 LTTNG_LOGLEVEL_JUL_OFF
,
859 LTTNG_LOGLEVEL_JUL_SEVERE
,
860 LTTNG_LOGLEVEL_JUL_WARNING
,
861 LTTNG_LOGLEVEL_JUL_INFO
,
862 LTTNG_LOGLEVEL_JUL_CONFIG
,
863 LTTNG_LOGLEVEL_JUL_FINE
,
864 LTTNG_LOGLEVEL_JUL_FINER
,
865 LTTNG_LOGLEVEL_JUL_FINEST
,
866 LTTNG_LOGLEVEL_JUL_ALL
,
868 const int valid_log_level_values
[] = {
874 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
,
875 loglevel_jul_value_to_name
,
876 lttng_event_rule_jul_logging_create
,
877 lttng_event_rule_jul_logging_set_log_level_rule
,
878 tagged_log_level_values
,
879 ARRAY_SIZE(tagged_log_level_values
),
880 valid_log_level_values
,
881 ARRAY_SIZE(valid_log_level_values
), NULL
, 0);
884 static void test_event_rule_log_level_log4j(void)
886 const int tagged_log_level_values
[] = {
887 LTTNG_LOGLEVEL_LOG4J_OFF
,
888 LTTNG_LOGLEVEL_LOG4J_FATAL
,
889 LTTNG_LOGLEVEL_LOG4J_ERROR
,
890 LTTNG_LOGLEVEL_LOG4J_WARN
,
891 LTTNG_LOGLEVEL_LOG4J_INFO
,
892 LTTNG_LOGLEVEL_LOG4J_DEBUG
,
893 LTTNG_LOGLEVEL_LOG4J_TRACE
,
894 LTTNG_LOGLEVEL_LOG4J_ALL
,
896 const int valid_log_level_values
[] = {
902 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
,
903 loglevel_log4j_value_to_name
,
904 lttng_event_rule_log4j_logging_create
,
905 lttng_event_rule_log4j_logging_set_log_level_rule
,
906 tagged_log_level_values
,
907 ARRAY_SIZE(tagged_log_level_values
),
908 valid_log_level_values
,
909 ARRAY_SIZE(valid_log_level_values
), NULL
, 0);
912 static void test_event_rule_log_level_python(void)
914 const int tagged_log_level_values
[] = {
915 LTTNG_LOGLEVEL_PYTHON_CRITICAL
,
916 LTTNG_LOGLEVEL_PYTHON_ERROR
,
917 LTTNG_LOGLEVEL_PYTHON_WARNING
,
918 LTTNG_LOGLEVEL_PYTHON_INFO
,
919 LTTNG_LOGLEVEL_PYTHON_DEBUG
,
920 LTTNG_LOGLEVEL_PYTHON_NOTSET
,
922 const int valid_log_level_values
[] = {
929 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
,
930 loglevel_python_value_to_name
,
931 lttng_event_rule_python_logging_create
,
932 lttng_event_rule_python_logging_set_log_level_rule
,
933 tagged_log_level_values
,
934 ARRAY_SIZE(tagged_log_level_values
),
935 valid_log_level_values
,
936 ARRAY_SIZE(valid_log_level_values
),
940 int main(int argc
, const char *argv
[])
942 plan_tests(NUM_TESTS
);
943 test_event_rule_tracepoint();
944 test_event_rule_kernel_tracepoint();
945 test_event_rule_user_tracepoint();
946 test_event_rule_syscall();
947 test_event_rule_userspace_probe();
948 test_event_rule_kernel_probe();
949 test_event_rule_log4j_logging();
950 test_event_rule_jul_logging();
951 test_event_rule_python_logging();
952 test_event_rule_log_level_ust();
953 test_event_rule_log_level_jul();
954 test_event_rule_log_level_log4j();
955 test_event_rule_log_level_python();
956 return exit_status();