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
);
59 void test_event_rule_tracepoint_by_domain(const struct tracepoint_test
*test
)
62 struct lttng_event_rule
*tracepoint
= NULL
;
63 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
64 enum lttng_event_rule_status status
;
65 enum lttng_domain_type domain_type
, type
;
66 const char *pattern
="my_event_*";
67 const char *filter
="msg_id == 23 && size >= 2048";
69 const char *name_pattern_exclusions
[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
70 struct lttng_log_level_rule
*log_level_rule
= NULL
;
71 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
72 struct lttng_payload payload
;
75 diag("Testing domain %d.", type
);
77 lttng_payload_init(&payload
);
79 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
80 assert(log_level_rule
);
82 tracepoint
= lttng_event_rule_tracepoint_create(type
);
83 ok(tracepoint
, "tracepoint object.");
85 status
= lttng_event_rule_tracepoint_get_domain_type(tracepoint
, &domain_type
);
86 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get tracepoint domain.");
87 ok(domain_type
== type
, "domain type got %d expected %d.", domain_type
, type
);
89 status
= lttng_event_rule_tracepoint_set_name_pattern(tracepoint
, pattern
);
90 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
91 status
= lttng_event_rule_tracepoint_get_name_pattern(tracepoint
, &tmp
);
92 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
93 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
95 status
= lttng_event_rule_tracepoint_set_filter(tracepoint
, filter
);
96 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
97 status
= lttng_event_rule_tracepoint_get_filter(tracepoint
, &tmp
);
98 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
99 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
101 status
= lttng_event_rule_tracepoint_get_log_level_rule(tracepoint
, &log_level_rule_return
);
102 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
104 if (type
!= LTTNG_DOMAIN_KERNEL
) {
105 status
= lttng_event_rule_tracepoint_set_log_level_rule(tracepoint
, log_level_rule
);
106 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
107 status
= lttng_event_rule_tracepoint_get_log_level_rule(tracepoint
, &log_level_rule_return
);
108 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
111 if (test
->support_name_pattern_exclusion
) {
114 for (i
= 0; i
< 3; i
++) {
115 status
= lttng_event_rule_tracepoint_add_name_pattern_exclusion(tracepoint
, name_pattern_exclusions
[i
]);
116 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting name pattern exclusions \"%s\"", name_pattern_exclusions
[i
]);
119 status
= lttng_event_rule_tracepoint_get_name_pattern_exclusion_count(tracepoint
, &count
);
120 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting name pattern exclusion count.");
121 ok(count
== 3, "count is %d/3", count
);
123 for (i
= 0; i
< count
; i
++) {
124 status
= lttng_event_rule_tracepoint_get_name_pattern_exclusion_at_index(tracepoint
, i
, &tmp
);
125 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting name pattern exclusion at index %d.", i
);
126 ok(!strncmp(name_pattern_exclusions
[i
], tmp
, strlen(name_pattern_exclusions
[i
])), "%s == %s.", tmp
, name_pattern_exclusions
[i
]);
131 for (i
= 0; i
< 3; i
++) {
132 status
= lttng_event_rule_tracepoint_add_name_pattern_exclusion(tracepoint
, name_pattern_exclusions
[i
]);
133 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSUPPORTED
, "setting name pattern exclusions unsupported \"%s\".", name_pattern_exclusions
[i
]);
136 status
= lttng_event_rule_tracepoint_get_name_pattern_exclusion_count(tracepoint
, &count
);
137 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting name pattern exclusion count.");
138 ok(count
== 0, "count is %d/0", count
);
141 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
144 struct lttng_payload_view view
=
145 lttng_payload_view_from_payload(
148 ok(lttng_event_rule_create_from_payload(
149 &view
, &tracepoint_from_buffer
) > 0,
153 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
155 lttng_payload_reset(&payload
);
156 lttng_event_rule_destroy(tracepoint
);
157 lttng_event_rule_destroy(tracepoint_from_buffer
);
158 lttng_log_level_rule_destroy(log_level_rule
);
162 void test_event_rule_tracepoint(void)
165 struct lttng_event_rule
*tracepoint
= NULL
;
166 struct tracepoint_test tests
[] = {{LTTNG_DOMAIN_JUL
, false},
167 {LTTNG_DOMAIN_KERNEL
, false},
168 {LTTNG_DOMAIN_LOG4J
, false},
169 {LTTNG_DOMAIN_PYTHON
, false},
170 {LTTNG_DOMAIN_UST
, true}};
172 diag("Testing lttng_event_rule_tracepoint.");
173 tracepoint
= lttng_event_rule_tracepoint_create(LTTNG_DOMAIN_NONE
);
174 ok(!tracepoint
, "Domain type restriction on create.");
176 for (i
= 0; i
< sizeof(tests
) / sizeof(tests
[0]); i
++) {
177 test_event_rule_tracepoint_by_domain(&tests
[i
]);
182 void test_event_rule_kernel_tracepoint(void)
184 struct lttng_event_rule
*tracepoint
= NULL
;
185 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
186 enum lttng_event_rule_status status
;
187 const char *pattern
="my_event_*";
188 const char *filter
="msg_id == 23 && size >= 2048";
190 struct lttng_payload payload
;
192 diag("Testing lttng_event_rule_kernel_tracepoint.");
194 lttng_payload_init(&payload
);
196 tracepoint
= lttng_event_rule_kernel_tracepoint_create();
197 ok(tracepoint
, "tracepoint object.");
199 status
= lttng_event_rule_kernel_tracepoint_set_name_pattern(tracepoint
, pattern
);
200 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
201 status
= lttng_event_rule_kernel_tracepoint_get_name_pattern(tracepoint
, &tmp
);
202 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
203 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
205 status
= lttng_event_rule_kernel_tracepoint_set_filter(tracepoint
, filter
);
206 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
207 status
= lttng_event_rule_kernel_tracepoint_get_filter(tracepoint
, &tmp
);
208 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
209 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
211 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
214 struct lttng_payload_view view
=
215 lttng_payload_view_from_payload(
218 ok(lttng_event_rule_create_from_payload(
219 &view
, &tracepoint_from_buffer
) > 0,
223 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
225 lttng_payload_reset(&payload
);
226 lttng_event_rule_destroy(tracepoint
);
227 lttng_event_rule_destroy(tracepoint_from_buffer
);
231 void test_event_rule_user_tracepoint(void)
235 struct lttng_event_rule
*tracepoint
= NULL
;
236 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
237 enum lttng_event_rule_status status
;
238 const char *pattern
="my_event_*";
239 const char *filter
="msg_id == 23 && size >= 2048";
241 const char *name_pattern_exclusions
[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
242 struct lttng_log_level_rule
*log_level_rule
= NULL
;
243 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
244 struct lttng_payload payload
;
246 diag("Testing lttng_event_rule_user_tracepoint.");
248 lttng_payload_init(&payload
);
250 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
251 assert(log_level_rule
);
253 tracepoint
= lttng_event_rule_user_tracepoint_create();
254 ok(tracepoint
, "user tracepoint object.");
256 status
= lttng_event_rule_user_tracepoint_set_name_pattern(tracepoint
, pattern
);
257 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
258 status
= lttng_event_rule_user_tracepoint_get_name_pattern(tracepoint
, &tmp
);
259 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
260 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
262 status
= lttng_event_rule_user_tracepoint_set_filter(tracepoint
, filter
);
263 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
264 status
= lttng_event_rule_user_tracepoint_get_filter(tracepoint
, &tmp
);
265 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
266 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
268 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(tracepoint
, &log_level_rule_return
);
269 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
271 status
= lttng_event_rule_user_tracepoint_set_log_level_rule(
272 tracepoint
, log_level_rule
);
273 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
274 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(
275 tracepoint
, &log_level_rule_return
);
276 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
278 /* Name pattern exclusions */
279 for (i
= 0; i
< 3; i
++) {
280 status
= lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(
281 tracepoint
, name_pattern_exclusions
[i
]);
282 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
283 "setting name pattern exclusions \"%s\"",
284 name_pattern_exclusions
[i
]);
287 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
289 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
290 "getting name pattern exclusion count.");
291 ok(count
== 3, "count is %d/3", count
);
293 for (i
= 0; i
< count
; i
++) {
294 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
295 tracepoint
, i
, &tmp
);
296 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
297 "getting name pattern exclusion at index %d.",
299 ok(!strncmp(name_pattern_exclusions
[i
], tmp
,
300 strlen(name_pattern_exclusions
[i
])),
301 "%s == %s.", tmp
, name_pattern_exclusions
[i
]);
304 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
307 struct lttng_payload_view view
=
308 lttng_payload_view_from_payload(
311 ok(lttng_event_rule_create_from_payload(
312 &view
, &tracepoint_from_buffer
) > 0,
316 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
318 lttng_payload_reset(&payload
);
319 lttng_event_rule_destroy(tracepoint
);
320 lttng_event_rule_destroy(tracepoint_from_buffer
);
321 lttng_log_level_rule_destroy(log_level_rule
);
324 static void test_event_rule_syscall(void)
326 struct lttng_event_rule
*syscall
= NULL
;
327 struct lttng_event_rule
*syscall_from_buffer
= NULL
;
328 enum lttng_event_rule_status status
;
329 const char *pattern
= "my_event_*";
330 const char *filter
= "msg_id == 23 && size >= 2048";
332 struct lttng_payload payload
;
334 diag("Event rule syscall.");
336 lttng_payload_init(&payload
);
338 syscall
= lttng_event_rule_kernel_syscall_create(LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY
);
339 ok(syscall
, "syscall object.");
341 status
= lttng_event_rule_kernel_syscall_set_name_pattern(syscall
, pattern
);
342 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
343 status
= lttng_event_rule_kernel_syscall_get_name_pattern(syscall
, &tmp
);
344 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
345 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
347 status
= lttng_event_rule_kernel_syscall_set_filter(syscall
, filter
);
348 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
349 status
= lttng_event_rule_kernel_syscall_get_filter(syscall
, &tmp
);
350 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
351 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
353 ok(lttng_event_rule_serialize(syscall
, &payload
) == 0, "Serializing.");
356 struct lttng_payload_view view
=
357 lttng_payload_view_from_payload(
360 ok(lttng_event_rule_create_from_payload(
361 &view
, &syscall_from_buffer
) > 0,
365 ok(lttng_event_rule_is_equal(syscall
, syscall_from_buffer
),
366 "serialized and from buffer are equal.");
368 lttng_payload_reset(&payload
);
369 lttng_event_rule_destroy(syscall
);
370 lttng_event_rule_destroy(syscall_from_buffer
);
374 void test_event_rule_jul_logging(void)
376 struct lttng_event_rule
*jul_logging
= NULL
;
377 struct lttng_event_rule
*jul_logging_from_buffer
= NULL
;
378 enum lttng_event_rule_status status
;
379 const char *pattern
="my_event_*";
380 const char *filter
="msg_id == 23 && size >= 2048";
382 struct lttng_log_level_rule
*log_level_rule
= NULL
;
383 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
384 struct lttng_payload payload
;
386 diag("Testing lttng_event_rule_user_jul_logging.");
388 lttng_payload_init(&payload
);
390 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
391 assert(log_level_rule
);
393 jul_logging
= lttng_event_rule_jul_logging_create();
394 ok(jul_logging
, "jul_logging object.");
396 status
= lttng_event_rule_jul_logging_set_name_pattern(jul_logging
, pattern
);
397 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
398 status
= lttng_event_rule_jul_logging_get_name_pattern(jul_logging
, &tmp
);
399 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
400 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
402 status
= lttng_event_rule_jul_logging_set_filter(jul_logging
, filter
);
403 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
404 status
= lttng_event_rule_jul_logging_get_filter(jul_logging
, &tmp
);
405 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
406 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
408 status
= lttng_event_rule_jul_logging_get_log_level_rule(jul_logging
, &log_level_rule_return
);
409 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
411 status
= lttng_event_rule_jul_logging_set_log_level_rule(
412 jul_logging
, log_level_rule
);
413 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
414 status
= lttng_event_rule_jul_logging_get_log_level_rule(
415 jul_logging
, &log_level_rule_return
);
416 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
418 ok(lttng_event_rule_serialize(jul_logging
, &payload
) == 0, "Serializing.");
421 struct lttng_payload_view view
=
422 lttng_payload_view_from_payload(
425 ok(lttng_event_rule_create_from_payload(
426 &view
, &jul_logging_from_buffer
) > 0,
430 ok(lttng_event_rule_is_equal(jul_logging
, jul_logging_from_buffer
), "serialized and from buffer are equal.");
432 lttng_payload_reset(&payload
);
433 lttng_event_rule_destroy(jul_logging
);
434 lttng_event_rule_destroy(jul_logging_from_buffer
);
435 lttng_log_level_rule_destroy(log_level_rule
);
439 void test_event_rule_log4j_logging(void)
441 struct lttng_event_rule
*log4j_logging
= NULL
;
442 struct lttng_event_rule
*log4j_logging_from_buffer
= NULL
;
443 enum lttng_event_rule_status status
;
444 const char *pattern
="my_event_*";
445 const char *filter
="msg_id == 23 && size >= 2048";
447 struct lttng_log_level_rule
*log_level_rule
= NULL
;
448 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
449 struct lttng_payload payload
;
451 diag("Testing lttng_event_rule_user_log4j_logging.");
453 lttng_payload_init(&payload
);
455 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
456 assert(log_level_rule
);
458 log4j_logging
= lttng_event_rule_log4j_logging_create();
459 ok(log4j_logging
, "log4j_logging object.");
461 status
= lttng_event_rule_log4j_logging_set_name_pattern(log4j_logging
, pattern
);
462 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
463 status
= lttng_event_rule_log4j_logging_get_name_pattern(log4j_logging
, &tmp
);
464 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
465 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
467 status
= lttng_event_rule_log4j_logging_set_filter(log4j_logging
, filter
);
468 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
469 status
= lttng_event_rule_log4j_logging_get_filter(log4j_logging
, &tmp
);
470 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
471 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
473 status
= lttng_event_rule_log4j_logging_get_log_level_rule(log4j_logging
, &log_level_rule_return
);
474 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
476 status
= lttng_event_rule_log4j_logging_set_log_level_rule(
477 log4j_logging
, log_level_rule
);
478 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
479 status
= lttng_event_rule_log4j_logging_get_log_level_rule(
480 log4j_logging
, &log_level_rule_return
);
481 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
483 ok(lttng_event_rule_serialize(log4j_logging
, &payload
) == 0, "Serializing.");
486 struct lttng_payload_view view
=
487 lttng_payload_view_from_payload(
490 ok(lttng_event_rule_create_from_payload(
491 &view
, &log4j_logging_from_buffer
) > 0,
495 ok(lttng_event_rule_is_equal(log4j_logging
, log4j_logging_from_buffer
), "serialized and from buffer are equal.");
497 lttng_payload_reset(&payload
);
498 lttng_event_rule_destroy(log4j_logging
);
499 lttng_event_rule_destroy(log4j_logging_from_buffer
);
500 lttng_log_level_rule_destroy(log_level_rule
);
504 void test_event_rule_python_logging(void)
506 struct lttng_event_rule
*python_logging
= NULL
;
507 struct lttng_event_rule
*python_logging_from_buffer
= NULL
;
508 enum lttng_event_rule_status status
;
509 const char *pattern
="my_event_*";
510 const char *filter
="msg_id == 23 && size >= 2048";
512 struct lttng_log_level_rule
*log_level_rule
= NULL
;
513 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
514 struct lttng_payload payload
;
516 diag("Testing lttng_event_rule_user_python_logging.");
518 lttng_payload_init(&payload
);
520 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
521 assert(log_level_rule
);
523 python_logging
= lttng_event_rule_python_logging_create();
524 ok(python_logging
, "python_logging object.");
526 status
= lttng_event_rule_python_logging_set_name_pattern(python_logging
, pattern
);
527 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
528 status
= lttng_event_rule_python_logging_get_name_pattern(python_logging
, &tmp
);
529 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
530 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
532 status
= lttng_event_rule_python_logging_set_filter(python_logging
, filter
);
533 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
534 status
= lttng_event_rule_python_logging_get_filter(python_logging
, &tmp
);
535 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
536 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
538 status
= lttng_event_rule_python_logging_get_log_level_rule(python_logging
, &log_level_rule_return
);
539 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
541 status
= lttng_event_rule_python_logging_set_log_level_rule(
542 python_logging
, log_level_rule
);
543 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
544 status
= lttng_event_rule_python_logging_get_log_level_rule(
545 python_logging
, &log_level_rule_return
);
546 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
548 ok(lttng_event_rule_serialize(python_logging
, &payload
) == 0, "Serializing.");
551 struct lttng_payload_view view
=
552 lttng_payload_view_from_payload(
555 ok(lttng_event_rule_create_from_payload(
556 &view
, &python_logging_from_buffer
) > 0,
560 ok(lttng_event_rule_is_equal(python_logging
, python_logging_from_buffer
), "serialized and from buffer are equal.");
562 lttng_payload_reset(&payload
);
563 lttng_event_rule_destroy(python_logging
);
564 lttng_event_rule_destroy(python_logging_from_buffer
);
565 lttng_log_level_rule_destroy(log_level_rule
);
568 static void test_event_rule_userspace_probe(void)
570 struct lttng_event_rule
*uprobe
= NULL
;
571 struct lttng_event_rule
*uprobe_from_buffer
= NULL
;
572 struct lttng_userspace_probe_location_lookup_method
*lookup_method
=
574 struct lttng_userspace_probe_location
*probe_location
= NULL
;
575 const struct lttng_userspace_probe_location
*probe_location_tmp
= NULL
;
576 enum lttng_event_rule_status status
;
578 const char *probe_name
= "my_probe.";
580 struct lttng_payload payload
;
582 diag("Event rule uprobe.");
584 lookup_method
= lttng_userspace_probe_location_lookup_method_function_elf_create();
585 if (!lookup_method
) {
586 fail("Setup error on userspace probe lookup method creation.");
590 probe_location
= lttng_userspace_probe_location_function_create(
592 "lttng_userspace_probe_location_tracepoint_create",
594 if (!probe_location
) {
595 fail("Setup error on userspace probe location creation.");
599 /* Ownership transferred to the probe location function object. */
600 lookup_method
= NULL
;
602 lttng_payload_init(&payload
);
604 uprobe
= lttng_event_rule_kernel_uprobe_create(probe_location
);
605 ok(uprobe
, "uprobe event rule object creation.");
607 status
= lttng_event_rule_kernel_uprobe_get_location(
608 uprobe
, &probe_location_tmp
);
609 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
610 "Getting uprobe event rule location.");
611 ok(lttng_userspace_probe_location_is_equal(
612 probe_location
, probe_location_tmp
),
613 "Location is equal.");
615 status
= lttng_event_rule_kernel_uprobe_set_event_name(uprobe
, probe_name
);
616 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
617 "Setting uprobe event rule name: %s.", probe_name
);
618 status
= lttng_event_rule_kernel_uprobe_get_event_name(uprobe
, &tmp
);
619 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "Getting uprobe name.");
620 ok(!strcmp(probe_name
, tmp
), "Uprobe name are equal.");
622 ok(lttng_event_rule_serialize(uprobe
, &payload
) == 0, "Serializing.");
625 struct lttng_payload_view view
=
626 lttng_payload_view_from_payload(
629 ok(lttng_event_rule_create_from_payload(
630 &view
, &uprobe_from_buffer
) > 0,
634 ok(lttng_event_rule_is_equal(uprobe
, uprobe_from_buffer
),
635 "serialized and from buffer are equal.");
638 lttng_payload_reset(&payload
);
639 lttng_event_rule_destroy(uprobe
);
640 lttng_event_rule_destroy(uprobe_from_buffer
);
641 lttng_userspace_probe_location_destroy(probe_location
);
642 lttng_userspace_probe_location_lookup_method_destroy(lookup_method
);
645 static void test_event_rule_kernel_probe_by_location(
646 const struct lttng_kernel_probe_location
*location
)
648 struct lttng_event_rule
*kprobe
= NULL
;
649 struct lttng_event_rule
*kprobe_from_buffer
= NULL
;
650 enum lttng_event_rule_status status
;
651 const struct lttng_kernel_probe_location
*_location
;
653 const char *probe_name
= "my_probe";
655 struct lttng_payload payload
;
657 diag("Event rule kprobe for location type %d.",
658 lttng_kernel_probe_location_get_type(location
));
660 lttng_payload_init(&payload
);
662 kprobe
= lttng_event_rule_kernel_kprobe_create(location
);
663 ok(kprobe
, "kprobe event rule object creation.");
665 status
= lttng_event_rule_kernel_kprobe_get_location(kprobe
, &_location
);
666 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
667 "Getting kprobe event rule location.");
668 ok(lttng_kernel_probe_location_is_equal(location
, _location
), "Locations are equal.");
670 status
= lttng_event_rule_kernel_kprobe_set_event_name(kprobe
, probe_name
);
671 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
672 "Setting kprobe event rule name: %s.", probe_name
);
673 status
= lttng_event_rule_kernel_kprobe_get_event_name(kprobe
, &tmp
);
674 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "Getting kprobe name.");
675 ok(!strcmp(probe_name
, tmp
), "kprobe name are equal.");
677 ok(lttng_event_rule_serialize(kprobe
, &payload
) == 0, "Serializing.");
680 struct lttng_payload_view view
=
681 lttng_payload_view_from_payload(
684 ok(lttng_event_rule_create_from_payload(
685 &view
, &kprobe_from_buffer
) > 0,
689 ok(lttng_event_rule_is_equal(kprobe
, kprobe_from_buffer
),
690 "serialized and from buffer are equal.");
692 lttng_payload_reset(&payload
);
693 lttng_event_rule_destroy(kprobe
);
694 lttng_event_rule_destroy(kprobe_from_buffer
);
697 static void test_event_rule_kernel_probe(void)
699 struct lttng_kernel_probe_location
*address_location
= NULL
;
700 struct lttng_kernel_probe_location
*symbol_location
= NULL
;
702 address_location
= lttng_kernel_probe_location_address_create(50);
703 symbol_location
= lttng_kernel_probe_location_symbol_create("une_bonne", 50);
704 assert(address_location
);
705 assert(symbol_location
);
707 test_event_rule_kernel_probe_by_location(address_location
);
708 test_event_rule_kernel_probe_by_location(symbol_location
);
710 lttng_kernel_probe_location_destroy(address_location
);
711 lttng_kernel_probe_location_destroy(symbol_location
);
714 static void test_set_event_rule_log_level_rules(
715 struct lttng_event_rule
*event_rule
,
717 enum lttng_event_rule_status
*exactly_status
,
718 enum lttng_event_rule_status
*as_severe_status
)
720 struct lttng_log_level_rule
*log_level_rule
;
722 log_level_rule
= lttng_log_level_rule_at_least_as_severe_as_create(
724 assert(log_level_rule
);
726 *as_severe_status
= lttng_event_rule_tracepoint_set_log_level_rule(
727 event_rule
, log_level_rule
);
728 lttng_log_level_rule_destroy(log_level_rule
);
730 log_level_rule
= lttng_log_level_rule_exactly_create(log_level
);
731 assert(log_level_rule
);
733 *exactly_status
= lttng_event_rule_tracepoint_set_log_level_rule(
734 event_rule
, log_level_rule
);
735 lttng_log_level_rule_destroy(log_level_rule
);
738 static void test_event_rule_log_level_generic(const char *domain_name
,
739 enum lttng_domain_type domain
,
740 log_level_name_getter get_log_level_name
,
741 const int tagged_log_level_values
[],
742 size_t tagged_log_level_values_count
,
743 const int valid_log_level_values
[],
744 size_t valid_log_level_values_count
,
745 const int invalid_log_level_values
[],
746 size_t invalid_log_level_values_count
)
749 struct lttng_event_rule
*tracepoint_rule
;
750 enum lttng_event_rule_status er_exactly_status
, er_as_severe_status
;
752 diag("Test %s event rule + log level rule", domain_name
);
753 tracepoint_rule
= lttng_event_rule_tracepoint_create(domain
);
754 assert(tracepoint_rule
);
756 for (i
= 0; i
< tagged_log_level_values_count
; i
++) {
757 const int tagged_log_level_value
= tagged_log_level_values
[i
];
759 test_set_event_rule_log_level_rules(tracepoint_rule
,
760 tagged_log_level_value
,
761 &er_exactly_status
, &er_as_severe_status
);
762 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_OK
,
763 "Log level rule \"exactly\" accepted by %s tracepoint event rule: level = %s",
766 tagged_log_level_value
));
767 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_OK
,
768 "Log level rule \"as least as severe as\" accepted by %s tracepoint event rule: level = %s",
771 tagged_log_level_value
));
774 for (i
= 0; i
< valid_log_level_values_count
; i
++) {
775 const int valid_log_level_value
= valid_log_level_values
[i
];
777 test_set_event_rule_log_level_rules(tracepoint_rule
,
778 valid_log_level_value
,
779 &er_exactly_status
, &er_as_severe_status
);
780 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_OK
,
781 "Log level rule \"exactly\" accepted by %s tracepoint event rule: level = %d",
783 valid_log_level_value
);
784 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_OK
,
785 "Log level rule \"as least as severe as\" accepted by %s tracepoint event rule: level = %d",
787 valid_log_level_value
);
790 for (i
= 0; i
< invalid_log_level_values_count
; i
++) {
791 const int invalid_log_level_value
= invalid_log_level_values
[i
];
793 test_set_event_rule_log_level_rules(tracepoint_rule
,
794 invalid_log_level_value
,
795 &er_exactly_status
, &er_as_severe_status
);
796 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_INVALID
,
797 "Log level rule \"exactly\" rejected by %s tracepoint event rule: level = %d",
799 invalid_log_level_value
);
800 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_INVALID
,
801 "Log level rule \"as least as severe as\" rejected by %s tracepoint event rule: level = %d",
803 invalid_log_level_value
);
806 lttng_event_rule_destroy(tracepoint_rule
);
809 static void test_event_rule_log_level_ust(void)
811 const int tagged_log_level_values
[] = {
812 LTTNG_LOGLEVEL_EMERG
,
813 LTTNG_LOGLEVEL_ALERT
,
816 LTTNG_LOGLEVEL_WARNING
,
817 LTTNG_LOGLEVEL_NOTICE
,
819 LTTNG_LOGLEVEL_DEBUG_SYSTEM
,
820 LTTNG_LOGLEVEL_DEBUG_PROGRAM
,
821 LTTNG_LOGLEVEL_DEBUG_PROCESS
,
822 LTTNG_LOGLEVEL_DEBUG_MODULE
,
823 LTTNG_LOGLEVEL_DEBUG_UNIT
,
824 LTTNG_LOGLEVEL_DEBUG_FUNCTION
,
825 LTTNG_LOGLEVEL_DEBUG_LINE
,
826 LTTNG_LOGLEVEL_DEBUG
,
828 const int invalid_log_level_values
[] = {
831 LTTNG_LOGLEVEL_DEBUG
+ 1,
832 LTTNG_LOGLEVEL_EMERG
- 1,
835 test_event_rule_log_level_generic("user space", LTTNG_DOMAIN_UST
,
836 loglevel_value_to_name
, tagged_log_level_values
,
837 ARRAY_SIZE(tagged_log_level_values
),
839 invalid_log_level_values
,
840 ARRAY_SIZE(invalid_log_level_values
));
843 static void test_event_rule_log_level_jul(void)
845 const int tagged_log_level_values
[] = {
846 LTTNG_LOGLEVEL_JUL_OFF
,
847 LTTNG_LOGLEVEL_JUL_SEVERE
,
848 LTTNG_LOGLEVEL_JUL_WARNING
,
849 LTTNG_LOGLEVEL_JUL_INFO
,
850 LTTNG_LOGLEVEL_JUL_CONFIG
,
851 LTTNG_LOGLEVEL_JUL_FINE
,
852 LTTNG_LOGLEVEL_JUL_FINER
,
853 LTTNG_LOGLEVEL_JUL_FINEST
,
854 LTTNG_LOGLEVEL_JUL_ALL
,
856 const int valid_log_level_values
[] = {
862 test_event_rule_log_level_generic("Java Util Logging", LTTNG_DOMAIN_JUL
,
863 loglevel_jul_value_to_name
, tagged_log_level_values
,
864 ARRAY_SIZE(tagged_log_level_values
),
865 valid_log_level_values
,
866 ARRAY_SIZE(valid_log_level_values
), NULL
, 0);
869 static void test_event_rule_log_level_log4j(void)
871 const int tagged_log_level_values
[] = {
872 LTTNG_LOGLEVEL_LOG4J_OFF
,
873 LTTNG_LOGLEVEL_LOG4J_FATAL
,
874 LTTNG_LOGLEVEL_LOG4J_ERROR
,
875 LTTNG_LOGLEVEL_LOG4J_WARN
,
876 LTTNG_LOGLEVEL_LOG4J_INFO
,
877 LTTNG_LOGLEVEL_LOG4J_DEBUG
,
878 LTTNG_LOGLEVEL_LOG4J_TRACE
,
879 LTTNG_LOGLEVEL_LOG4J_ALL
,
881 const int valid_log_level_values
[] = {
887 test_event_rule_log_level_generic("Log4j", LTTNG_DOMAIN_LOG4J
,
888 loglevel_log4j_value_to_name
, tagged_log_level_values
,
889 ARRAY_SIZE(tagged_log_level_values
),
890 valid_log_level_values
,
891 ARRAY_SIZE(valid_log_level_values
), NULL
, 0);
894 static void test_event_rule_log_level_python(void)
896 const int tagged_log_level_values
[] = {
897 LTTNG_LOGLEVEL_PYTHON_CRITICAL
,
898 LTTNG_LOGLEVEL_PYTHON_ERROR
,
899 LTTNG_LOGLEVEL_PYTHON_WARNING
,
900 LTTNG_LOGLEVEL_PYTHON_INFO
,
901 LTTNG_LOGLEVEL_PYTHON_DEBUG
,
902 LTTNG_LOGLEVEL_PYTHON_NOTSET
,
904 const int valid_log_level_values
[] = {
911 test_event_rule_log_level_generic("Python", LTTNG_DOMAIN_PYTHON
,
912 loglevel_python_value_to_name
, tagged_log_level_values
,
913 ARRAY_SIZE(tagged_log_level_values
),
914 valid_log_level_values
,
915 ARRAY_SIZE(valid_log_level_values
),
919 int main(int argc
, const char *argv
[])
921 plan_tests(NUM_TESTS
);
922 test_event_rule_tracepoint();
923 test_event_rule_kernel_tracepoint();
924 test_event_rule_user_tracepoint();
925 test_event_rule_syscall();
926 test_event_rule_userspace_probe();
927 test_event_rule_kernel_probe();
928 test_event_rule_log4j_logging();
929 test_event_rule_jul_logging();
930 test_event_rule_python_logging();
931 test_event_rule_log_level_ust();
932 test_event_rule_log_level_jul();
933 test_event_rule_log_level_log4j();
934 test_event_rule_log_level_python();
935 return exit_status();