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
17 #include <common/payload-view.hpp>
18 #include <common/payload.hpp>
19 #include <lttng/domain.h>
20 #include <lttng/event-rule/jul-logging-internal.hpp>
21 #include <lttng/event-rule/jul-logging.h>
22 #include <lttng/event-rule/kernel-kprobe-internal.hpp>
23 #include <lttng/event-rule/kernel-kprobe.h>
24 #include <lttng/event-rule/kernel-syscall-internal.hpp>
25 #include <lttng/event-rule/kernel-syscall.h>
26 #include <lttng/event-rule/python-logging-internal.hpp>
27 #include <lttng/event-rule/python-logging.h>
28 #include <lttng/event-rule/kernel-tracepoint-internal.hpp>
29 #include <lttng/event-rule/kernel-tracepoint.h>
30 #include <lttng/event-rule/kernel-uprobe-internal.hpp>
31 #include <lttng/event-rule/kernel-uprobe.h>
32 #include <lttng/event-rule/user-tracepoint-internal.hpp>
33 #include <lttng/event-rule/user-tracepoint.h>
34 #include <lttng/event.h>
35 #include <lttng/kernel-probe-internal.hpp>
36 #include <lttng/kernel-probe.h>
37 #include <lttng/userspace-probe-internal.hpp>
38 #include <lttng/userspace-probe.h>
39 #include "bin/lttng/loglevel.hpp"
42 int lttng_opt_quiet
= 1;
43 int lttng_opt_verbose
;
49 struct tracepoint_test
{
50 enum lttng_domain_type type
;
51 bool support_name_pattern_exclusion
;
55 typedef const char *(*log_level_name_getter
)(int log_level
);
57 typedef struct lttng_event_rule
*(*event_rule_create
)(void);
58 typedef enum lttng_event_rule_status (*event_rule_set_log_level
)(
59 struct lttng_event_rule
*rule
,
60 const struct lttng_log_level_rule
*log_level_rule
);
63 void test_event_rule_kernel_tracepoint(void)
65 struct lttng_event_rule
*tracepoint
= NULL
;
66 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
67 enum lttng_event_rule_status status
;
68 const char *pattern
="my_event_*";
69 const char *filter
="msg_id == 23 && size >= 2048";
71 struct lttng_payload payload
;
73 diag("Testing lttng_event_rule_kernel_tracepoint.");
75 lttng_payload_init(&payload
);
77 tracepoint
= lttng_event_rule_kernel_tracepoint_create();
78 ok(tracepoint
, "tracepoint object.");
80 status
= lttng_event_rule_kernel_tracepoint_set_name_pattern(tracepoint
, pattern
);
81 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
82 status
= lttng_event_rule_kernel_tracepoint_get_name_pattern(tracepoint
, &tmp
);
83 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
84 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
86 status
= lttng_event_rule_kernel_tracepoint_set_filter(tracepoint
, filter
);
87 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
88 status
= lttng_event_rule_kernel_tracepoint_get_filter(tracepoint
, &tmp
);
89 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
90 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
92 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
95 struct lttng_payload_view view
=
96 lttng_payload_view_from_payload(
99 ok(lttng_event_rule_create_from_payload(
100 &view
, &tracepoint_from_buffer
) > 0,
104 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
106 lttng_payload_reset(&payload
);
107 lttng_event_rule_destroy(tracepoint
);
108 lttng_event_rule_destroy(tracepoint_from_buffer
);
112 void test_event_rule_user_tracepoint(void)
116 struct lttng_event_rule
*tracepoint
= NULL
;
117 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
118 enum lttng_event_rule_status status
;
119 const char *pattern
="my_event_*";
120 const char *filter
="msg_id == 23 && size >= 2048";
122 const char *name_pattern_exclusions
[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
123 struct lttng_log_level_rule
*log_level_rule
= NULL
;
124 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
125 struct lttng_payload payload
;
127 diag("Testing lttng_event_rule_user_tracepoint.");
129 lttng_payload_init(&payload
);
131 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
132 LTTNG_ASSERT(log_level_rule
);
134 tracepoint
= lttng_event_rule_user_tracepoint_create();
135 ok(tracepoint
, "user tracepoint object.");
137 status
= lttng_event_rule_user_tracepoint_set_name_pattern(tracepoint
, pattern
);
138 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
139 status
= lttng_event_rule_user_tracepoint_get_name_pattern(tracepoint
, &tmp
);
140 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
141 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
143 status
= lttng_event_rule_user_tracepoint_set_filter(tracepoint
, filter
);
144 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
145 status
= lttng_event_rule_user_tracepoint_get_filter(tracepoint
, &tmp
);
146 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
147 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
149 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(tracepoint
, &log_level_rule_return
);
150 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
152 status
= lttng_event_rule_user_tracepoint_set_log_level_rule(
153 tracepoint
, log_level_rule
);
154 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
155 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(
156 tracepoint
, &log_level_rule_return
);
157 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
159 /* Name pattern exclusions */
160 for (i
= 0; i
< 3; i
++) {
161 status
= lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(
162 tracepoint
, name_pattern_exclusions
[i
]);
163 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
164 "setting name pattern exclusions \"%s\"",
165 name_pattern_exclusions
[i
]);
168 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
170 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
171 "getting name pattern exclusion count.");
172 ok(count
== 3, "count is %d/3", count
);
174 for (i
= 0; i
< count
; i
++) {
175 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
176 tracepoint
, i
, &tmp
);
177 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
178 "getting name pattern exclusion at index %d.",
180 ok(!strncmp(name_pattern_exclusions
[i
], tmp
,
181 strlen(name_pattern_exclusions
[i
])),
182 "%s == %s.", tmp
, name_pattern_exclusions
[i
]);
185 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
188 struct lttng_payload_view view
=
189 lttng_payload_view_from_payload(
192 ok(lttng_event_rule_create_from_payload(
193 &view
, &tracepoint_from_buffer
) > 0,
197 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
199 lttng_payload_reset(&payload
);
200 lttng_event_rule_destroy(tracepoint
);
201 lttng_event_rule_destroy(tracepoint_from_buffer
);
202 lttng_log_level_rule_destroy(log_level_rule
);
205 static void test_event_rule_syscall(void)
207 struct lttng_event_rule
*syscall
= NULL
;
208 struct lttng_event_rule
*syscall_from_buffer
= NULL
;
209 enum lttng_event_rule_status status
;
210 const char *pattern
= "my_event_*";
211 const char *filter
= "msg_id == 23 && size >= 2048";
213 struct lttng_payload payload
;
215 diag("Event rule syscall.");
217 lttng_payload_init(&payload
);
219 syscall
= lttng_event_rule_kernel_syscall_create(LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY
);
220 ok(syscall
, "syscall object.");
222 status
= lttng_event_rule_kernel_syscall_set_name_pattern(syscall
, pattern
);
223 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
224 status
= lttng_event_rule_kernel_syscall_get_name_pattern(syscall
, &tmp
);
225 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
226 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
228 status
= lttng_event_rule_kernel_syscall_set_filter(syscall
, filter
);
229 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
230 status
= lttng_event_rule_kernel_syscall_get_filter(syscall
, &tmp
);
231 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
232 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
234 ok(lttng_event_rule_serialize(syscall
, &payload
) == 0, "Serializing.");
237 struct lttng_payload_view view
=
238 lttng_payload_view_from_payload(
241 ok(lttng_event_rule_create_from_payload(
242 &view
, &syscall_from_buffer
) > 0,
246 ok(lttng_event_rule_is_equal(syscall
, syscall_from_buffer
),
247 "serialized and from buffer are equal.");
249 lttng_payload_reset(&payload
);
250 lttng_event_rule_destroy(syscall
);
251 lttng_event_rule_destroy(syscall_from_buffer
);
255 void test_event_rule_jul_logging(void)
257 struct lttng_event_rule
*jul_logging
= NULL
;
258 struct lttng_event_rule
*jul_logging_from_buffer
= NULL
;
259 enum lttng_event_rule_status status
;
260 const char *pattern
="my_event_*";
261 const char *filter
="msg_id == 23 && size >= 2048";
263 struct lttng_log_level_rule
*log_level_rule
= NULL
;
264 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
265 struct lttng_payload payload
;
267 diag("Testing lttng_event_rule_user_jul_logging.");
269 lttng_payload_init(&payload
);
271 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
272 LTTNG_ASSERT(log_level_rule
);
274 jul_logging
= lttng_event_rule_jul_logging_create();
275 ok(jul_logging
, "jul_logging object.");
277 status
= lttng_event_rule_jul_logging_set_name_pattern(jul_logging
, pattern
);
278 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
279 status
= lttng_event_rule_jul_logging_get_name_pattern(jul_logging
, &tmp
);
280 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
281 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
283 status
= lttng_event_rule_jul_logging_set_filter(jul_logging
, filter
);
284 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
285 status
= lttng_event_rule_jul_logging_get_filter(jul_logging
, &tmp
);
286 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
287 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
289 status
= lttng_event_rule_jul_logging_get_log_level_rule(jul_logging
, &log_level_rule_return
);
290 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
292 status
= lttng_event_rule_jul_logging_set_log_level_rule(
293 jul_logging
, log_level_rule
);
294 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
295 status
= lttng_event_rule_jul_logging_get_log_level_rule(
296 jul_logging
, &log_level_rule_return
);
297 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
299 ok(lttng_event_rule_serialize(jul_logging
, &payload
) == 0, "Serializing.");
302 struct lttng_payload_view view
=
303 lttng_payload_view_from_payload(
306 ok(lttng_event_rule_create_from_payload(
307 &view
, &jul_logging_from_buffer
) > 0,
311 ok(lttng_event_rule_is_equal(jul_logging
, jul_logging_from_buffer
), "serialized and from buffer are equal.");
313 lttng_payload_reset(&payload
);
314 lttng_event_rule_destroy(jul_logging
);
315 lttng_event_rule_destroy(jul_logging_from_buffer
);
316 lttng_log_level_rule_destroy(log_level_rule
);
320 void test_event_rule_log4j_logging(void)
322 struct lttng_event_rule
*log4j_logging
= NULL
;
323 struct lttng_event_rule
*log4j_logging_from_buffer
= NULL
;
324 enum lttng_event_rule_status status
;
325 const char *pattern
="my_event_*";
326 const char *filter
="msg_id == 23 && size >= 2048";
328 struct lttng_log_level_rule
*log_level_rule
= NULL
;
329 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
330 struct lttng_payload payload
;
332 diag("Testing lttng_event_rule_user_log4j_logging.");
334 lttng_payload_init(&payload
);
336 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
337 LTTNG_ASSERT(log_level_rule
);
339 log4j_logging
= lttng_event_rule_log4j_logging_create();
340 ok(log4j_logging
, "log4j_logging object.");
342 status
= lttng_event_rule_log4j_logging_set_name_pattern(log4j_logging
, pattern
);
343 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
344 status
= lttng_event_rule_log4j_logging_get_name_pattern(log4j_logging
, &tmp
);
345 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
346 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
348 status
= lttng_event_rule_log4j_logging_set_filter(log4j_logging
, filter
);
349 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
350 status
= lttng_event_rule_log4j_logging_get_filter(log4j_logging
, &tmp
);
351 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
352 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
354 status
= lttng_event_rule_log4j_logging_get_log_level_rule(log4j_logging
, &log_level_rule_return
);
355 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
357 status
= lttng_event_rule_log4j_logging_set_log_level_rule(
358 log4j_logging
, log_level_rule
);
359 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
360 status
= lttng_event_rule_log4j_logging_get_log_level_rule(
361 log4j_logging
, &log_level_rule_return
);
362 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
364 ok(lttng_event_rule_serialize(log4j_logging
, &payload
) == 0, "Serializing.");
367 struct lttng_payload_view view
=
368 lttng_payload_view_from_payload(
371 ok(lttng_event_rule_create_from_payload(
372 &view
, &log4j_logging_from_buffer
) > 0,
376 ok(lttng_event_rule_is_equal(log4j_logging
, log4j_logging_from_buffer
), "serialized and from buffer are equal.");
378 lttng_payload_reset(&payload
);
379 lttng_event_rule_destroy(log4j_logging
);
380 lttng_event_rule_destroy(log4j_logging_from_buffer
);
381 lttng_log_level_rule_destroy(log_level_rule
);
385 void test_event_rule_python_logging(void)
387 struct lttng_event_rule
*python_logging
= NULL
;
388 struct lttng_event_rule
*python_logging_from_buffer
= NULL
;
389 enum lttng_event_rule_status status
;
390 const char *pattern
="my_event_*";
391 const char *filter
="msg_id == 23 && size >= 2048";
393 struct lttng_log_level_rule
*log_level_rule
= NULL
;
394 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
395 struct lttng_payload payload
;
397 diag("Testing lttng_event_rule_user_python_logging.");
399 lttng_payload_init(&payload
);
401 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
402 LTTNG_ASSERT(log_level_rule
);
404 python_logging
= lttng_event_rule_python_logging_create();
405 ok(python_logging
, "python_logging object.");
407 status
= lttng_event_rule_python_logging_set_name_pattern(python_logging
, pattern
);
408 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
409 status
= lttng_event_rule_python_logging_get_name_pattern(python_logging
, &tmp
);
410 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
411 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
413 status
= lttng_event_rule_python_logging_set_filter(python_logging
, filter
);
414 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
415 status
= lttng_event_rule_python_logging_get_filter(python_logging
, &tmp
);
416 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
417 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
419 status
= lttng_event_rule_python_logging_get_log_level_rule(python_logging
, &log_level_rule_return
);
420 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
422 status
= lttng_event_rule_python_logging_set_log_level_rule(
423 python_logging
, log_level_rule
);
424 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
425 status
= lttng_event_rule_python_logging_get_log_level_rule(
426 python_logging
, &log_level_rule_return
);
427 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
429 ok(lttng_event_rule_serialize(python_logging
, &payload
) == 0, "Serializing.");
432 struct lttng_payload_view view
=
433 lttng_payload_view_from_payload(
436 ok(lttng_event_rule_create_from_payload(
437 &view
, &python_logging_from_buffer
) > 0,
441 ok(lttng_event_rule_is_equal(python_logging
, python_logging_from_buffer
), "serialized and from buffer are equal.");
443 lttng_payload_reset(&payload
);
444 lttng_event_rule_destroy(python_logging
);
445 lttng_event_rule_destroy(python_logging_from_buffer
);
446 lttng_log_level_rule_destroy(log_level_rule
);
449 static void test_event_rule_userspace_probe(void)
451 struct lttng_event_rule
*uprobe
= NULL
;
452 struct lttng_event_rule
*uprobe_from_buffer
= NULL
;
453 struct lttng_userspace_probe_location_lookup_method
*lookup_method
=
455 struct lttng_userspace_probe_location
*probe_location
= NULL
;
456 const struct lttng_userspace_probe_location
*probe_location_tmp
= NULL
;
457 enum lttng_event_rule_status status
;
459 const char *probe_name
= "my_probe.";
461 struct lttng_payload payload
;
463 diag("Event rule uprobe.");
464 lttng_payload_init(&payload
);
466 lookup_method
= lttng_userspace_probe_location_lookup_method_function_elf_create();
467 if (!lookup_method
) {
468 fail("Setup error on userspace probe lookup method creation.");
472 probe_location
= lttng_userspace_probe_location_function_create(
474 "lttng_userspace_probe_location_tracepoint_create",
476 if (!probe_location
) {
477 fail("Setup error on userspace probe location creation.");
481 /* Ownership transferred to the probe location function object. */
482 lookup_method
= NULL
;
484 lttng_payload_init(&payload
);
486 uprobe
= lttng_event_rule_kernel_uprobe_create(probe_location
);
487 ok(uprobe
, "uprobe event rule object creation.");
489 status
= lttng_event_rule_kernel_uprobe_get_location(
490 uprobe
, &probe_location_tmp
);
491 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
492 "Getting uprobe event rule location.");
493 ok(lttng_userspace_probe_location_is_equal(
494 probe_location
, probe_location_tmp
),
495 "Location is equal.");
497 status
= lttng_event_rule_kernel_uprobe_set_event_name(uprobe
, probe_name
);
498 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
499 "Setting uprobe event rule name: %s.", probe_name
);
500 status
= lttng_event_rule_kernel_uprobe_get_event_name(uprobe
, &tmp
);
501 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "Getting uprobe name.");
502 ok(!strcmp(probe_name
, tmp
), "Uprobe name are equal.");
504 ok(lttng_event_rule_serialize(uprobe
, &payload
) == 0, "Serializing.");
507 struct lttng_payload_view view
=
508 lttng_payload_view_from_payload(
511 ok(lttng_event_rule_create_from_payload(
512 &view
, &uprobe_from_buffer
) > 0,
516 ok(lttng_event_rule_is_equal(uprobe
, uprobe_from_buffer
),
517 "serialized and from buffer are equal.");
520 lttng_payload_reset(&payload
);
521 lttng_event_rule_destroy(uprobe
);
522 lttng_event_rule_destroy(uprobe_from_buffer
);
523 lttng_userspace_probe_location_destroy(probe_location
);
524 lttng_userspace_probe_location_lookup_method_destroy(lookup_method
);
527 static void test_event_rule_kernel_probe_by_location(
528 const struct lttng_kernel_probe_location
*location
)
530 struct lttng_event_rule
*kprobe
= NULL
;
531 struct lttng_event_rule
*kprobe_from_buffer
= NULL
;
532 enum lttng_event_rule_status status
;
533 const struct lttng_kernel_probe_location
*_location
;
535 const char *probe_name
= "my_probe";
537 struct lttng_payload payload
;
539 diag("Event rule kprobe for location type %d.",
540 lttng_kernel_probe_location_get_type(location
));
542 lttng_payload_init(&payload
);
544 kprobe
= lttng_event_rule_kernel_kprobe_create(location
);
545 ok(kprobe
, "kprobe event rule object creation.");
547 status
= lttng_event_rule_kernel_kprobe_get_location(kprobe
, &_location
);
548 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
549 "Getting kprobe event rule location.");
550 ok(lttng_kernel_probe_location_is_equal(location
, _location
), "Locations are equal.");
552 status
= lttng_event_rule_kernel_kprobe_set_event_name(kprobe
, probe_name
);
553 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
554 "Setting kprobe event rule name: %s.", probe_name
);
555 status
= lttng_event_rule_kernel_kprobe_get_event_name(kprobe
, &tmp
);
556 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "Getting kprobe name.");
557 ok(!strcmp(probe_name
, tmp
), "kprobe name are equal.");
559 ok(lttng_event_rule_serialize(kprobe
, &payload
) == 0, "Serializing.");
562 struct lttng_payload_view view
=
563 lttng_payload_view_from_payload(
566 ok(lttng_event_rule_create_from_payload(
567 &view
, &kprobe_from_buffer
) > 0,
571 ok(lttng_event_rule_is_equal(kprobe
, kprobe_from_buffer
),
572 "serialized and from buffer are equal.");
574 lttng_payload_reset(&payload
);
575 lttng_event_rule_destroy(kprobe
);
576 lttng_event_rule_destroy(kprobe_from_buffer
);
579 static void test_event_rule_kernel_probe(void)
581 struct lttng_kernel_probe_location
*address_location
= NULL
;
582 struct lttng_kernel_probe_location
*symbol_location
= NULL
;
584 address_location
= lttng_kernel_probe_location_address_create(50);
585 symbol_location
= lttng_kernel_probe_location_symbol_create("une_bonne", 50);
586 LTTNG_ASSERT(address_location
);
587 LTTNG_ASSERT(symbol_location
);
589 test_event_rule_kernel_probe_by_location(address_location
);
590 test_event_rule_kernel_probe_by_location(symbol_location
);
592 lttng_kernel_probe_location_destroy(address_location
);
593 lttng_kernel_probe_location_destroy(symbol_location
);
596 static void test_set_event_rule_log_level_rules(
597 struct lttng_event_rule
*event_rule
,
598 event_rule_set_log_level set_log_level
,
600 enum lttng_event_rule_status
*exactly_status
,
601 enum lttng_event_rule_status
*as_severe_status
)
603 struct lttng_log_level_rule
*log_level_rule
;
605 log_level_rule
= lttng_log_level_rule_at_least_as_severe_as_create(
607 LTTNG_ASSERT(log_level_rule
);
609 *as_severe_status
= set_log_level(
610 event_rule
, log_level_rule
);
611 lttng_log_level_rule_destroy(log_level_rule
);
613 log_level_rule
= lttng_log_level_rule_exactly_create(log_level
);
614 LTTNG_ASSERT(log_level_rule
);
616 *exactly_status
= set_log_level(
617 event_rule
, log_level_rule
);
618 lttng_log_level_rule_destroy(log_level_rule
);
621 static void test_event_rule_log_level_generic(enum lttng_event_rule_type event_rule_type
,
622 log_level_name_getter get_log_level_name
,
623 event_rule_create create_event_rule
,
624 event_rule_set_log_level set_log_level
,
625 const int tagged_log_level_values
[],
626 size_t tagged_log_level_values_count
,
627 const int valid_log_level_values
[],
628 size_t valid_log_level_values_count
,
629 const int invalid_log_level_values
[],
630 size_t invalid_log_level_values_count
)
633 struct lttng_event_rule
*rule
;
634 enum lttng_event_rule_status er_exactly_status
, er_as_severe_status
;
635 const char *event_rule_type_str
= lttng_event_rule_type_str(event_rule_type
);
638 diag("Test %s event rule + log level rule", event_rule_type_str
);
640 rule
= create_event_rule();
643 for (i
= 0; i
< tagged_log_level_values_count
; i
++) {
644 const int tagged_log_level_value
= tagged_log_level_values
[i
];
646 test_set_event_rule_log_level_rules(rule
, set_log_level
,
647 tagged_log_level_value
,
648 &er_exactly_status
, &er_as_severe_status
);
649 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_OK
,
650 "Log level rule \"exactly\" accepted by %s event rule: level = %s",
653 tagged_log_level_value
));
654 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_OK
,
655 "Log level rule \"as least as severe as\" accepted by %s event rule: level = %s",
658 tagged_log_level_value
));
661 for (i
= 0; i
< valid_log_level_values_count
; i
++) {
662 const int valid_log_level_value
= valid_log_level_values
[i
];
664 test_set_event_rule_log_level_rules(rule
, set_log_level
,
665 valid_log_level_value
,
666 &er_exactly_status
, &er_as_severe_status
);
667 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_OK
,
668 "Log level rule \"exactly\" accepted by %s event rule: level = %d",
670 valid_log_level_value
);
671 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_OK
,
672 "Log level rule \"as least as severe as\" accepted by %s event rule: level = %d",
674 valid_log_level_value
);
677 for (i
= 0; i
< invalid_log_level_values_count
; i
++) {
678 const int invalid_log_level_value
= invalid_log_level_values
[i
];
680 test_set_event_rule_log_level_rules(rule
, set_log_level
,
681 invalid_log_level_value
,
682 &er_exactly_status
, &er_as_severe_status
);
683 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_INVALID
,
684 "Log level rule \"exactly\" rejected by %s event rule: level = %d",
686 invalid_log_level_value
);
687 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_INVALID
,
688 "Log level rule \"as least as severe as\" rejected by %s event rule: level = %d",
690 invalid_log_level_value
);
693 lttng_event_rule_destroy(rule
);
696 static void test_event_rule_log_level_ust(void)
698 const int tagged_log_level_values
[] = {
699 LTTNG_LOGLEVEL_EMERG
,
700 LTTNG_LOGLEVEL_ALERT
,
703 LTTNG_LOGLEVEL_WARNING
,
704 LTTNG_LOGLEVEL_NOTICE
,
706 LTTNG_LOGLEVEL_DEBUG_SYSTEM
,
707 LTTNG_LOGLEVEL_DEBUG_PROGRAM
,
708 LTTNG_LOGLEVEL_DEBUG_PROCESS
,
709 LTTNG_LOGLEVEL_DEBUG_MODULE
,
710 LTTNG_LOGLEVEL_DEBUG_UNIT
,
711 LTTNG_LOGLEVEL_DEBUG_FUNCTION
,
712 LTTNG_LOGLEVEL_DEBUG_LINE
,
713 LTTNG_LOGLEVEL_DEBUG
,
715 const int invalid_log_level_values
[] = {
718 LTTNG_LOGLEVEL_DEBUG
+ 1,
719 LTTNG_LOGLEVEL_EMERG
- 1,
722 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
,
723 loglevel_value_to_name
,
724 lttng_event_rule_user_tracepoint_create
,
725 lttng_event_rule_user_tracepoint_set_log_level_rule
,
726 tagged_log_level_values
,
727 ARRAY_SIZE(tagged_log_level_values
), NULL
, 0,
728 invalid_log_level_values
,
729 ARRAY_SIZE(invalid_log_level_values
));
732 static void test_event_rule_log_level_jul(void)
734 const int tagged_log_level_values
[] = {
735 LTTNG_LOGLEVEL_JUL_OFF
,
736 LTTNG_LOGLEVEL_JUL_SEVERE
,
737 LTTNG_LOGLEVEL_JUL_WARNING
,
738 LTTNG_LOGLEVEL_JUL_INFO
,
739 LTTNG_LOGLEVEL_JUL_CONFIG
,
740 LTTNG_LOGLEVEL_JUL_FINE
,
741 LTTNG_LOGLEVEL_JUL_FINER
,
742 LTTNG_LOGLEVEL_JUL_FINEST
,
743 LTTNG_LOGLEVEL_JUL_ALL
,
745 const int valid_log_level_values
[] = {
751 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
,
752 loglevel_jul_value_to_name
,
753 lttng_event_rule_jul_logging_create
,
754 lttng_event_rule_jul_logging_set_log_level_rule
,
755 tagged_log_level_values
,
756 ARRAY_SIZE(tagged_log_level_values
),
757 valid_log_level_values
,
758 ARRAY_SIZE(valid_log_level_values
), NULL
, 0);
761 static void test_event_rule_log_level_log4j(void)
763 const int tagged_log_level_values
[] = {
764 LTTNG_LOGLEVEL_LOG4J_OFF
,
765 LTTNG_LOGLEVEL_LOG4J_FATAL
,
766 LTTNG_LOGLEVEL_LOG4J_ERROR
,
767 LTTNG_LOGLEVEL_LOG4J_WARN
,
768 LTTNG_LOGLEVEL_LOG4J_INFO
,
769 LTTNG_LOGLEVEL_LOG4J_DEBUG
,
770 LTTNG_LOGLEVEL_LOG4J_TRACE
,
771 LTTNG_LOGLEVEL_LOG4J_ALL
,
773 const int valid_log_level_values
[] = {
779 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
,
780 loglevel_log4j_value_to_name
,
781 lttng_event_rule_log4j_logging_create
,
782 lttng_event_rule_log4j_logging_set_log_level_rule
,
783 tagged_log_level_values
,
784 ARRAY_SIZE(tagged_log_level_values
),
785 valid_log_level_values
,
786 ARRAY_SIZE(valid_log_level_values
), NULL
, 0);
789 static void test_event_rule_log_level_python(void)
791 const int tagged_log_level_values
[] = {
792 LTTNG_LOGLEVEL_PYTHON_CRITICAL
,
793 LTTNG_LOGLEVEL_PYTHON_ERROR
,
794 LTTNG_LOGLEVEL_PYTHON_WARNING
,
795 LTTNG_LOGLEVEL_PYTHON_INFO
,
796 LTTNG_LOGLEVEL_PYTHON_DEBUG
,
797 LTTNG_LOGLEVEL_PYTHON_NOTSET
,
799 const int valid_log_level_values
[] = {
806 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
,
807 loglevel_python_value_to_name
,
808 lttng_event_rule_python_logging_create
,
809 lttng_event_rule_python_logging_set_log_level_rule
,
810 tagged_log_level_values
,
811 ARRAY_SIZE(tagged_log_level_values
),
812 valid_log_level_values
,
813 ARRAY_SIZE(valid_log_level_values
),
819 plan_tests(NUM_TESTS
);
820 test_event_rule_kernel_tracepoint();
821 test_event_rule_user_tracepoint();
822 test_event_rule_syscall();
823 test_event_rule_userspace_probe();
824 test_event_rule_kernel_probe();
825 test_event_rule_log4j_logging();
826 test_event_rule_jul_logging();
827 test_event_rule_python_logging();
828 test_event_rule_log_level_ust();
829 test_event_rule_log_level_jul();
830 test_event_rule_log_level_log4j();
831 test_event_rule_log_level_python();
832 return exit_status();