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/kernel-tracepoint-internal.h>
30 #include <lttng/event-rule/kernel-tracepoint.h>
31 #include <lttng/event-rule/kernel-uprobe-internal.h>
32 #include <lttng/event-rule/kernel-uprobe.h>
33 #include <lttng/event-rule/user-tracepoint-internal.h>
34 #include <lttng/event-rule/user-tracepoint.h>
35 #include <lttng/event.h>
36 #include <lttng/kernel-probe-internal.h>
37 #include <lttng/kernel-probe.h>
38 #include <lttng/userspace-probe-internal.h>
39 #include <lttng/userspace-probe.h>
40 #include "bin/lttng/loglevel.h"
43 int lttng_opt_quiet
= 1;
44 int lttng_opt_verbose
;
49 struct tracepoint_test
{
50 enum lttng_domain_type type
;
51 bool support_name_pattern_exclusion
;
54 typedef const char *(*log_level_name_getter
)(int log_level
);
56 typedef struct lttng_event_rule
*(*event_rule_create
)(void);
57 typedef enum lttng_event_rule_status (*event_rule_set_log_level
)(
58 struct lttng_event_rule
*rule
,
59 const struct lttng_log_level_rule
*log_level_rule
);
62 void test_event_rule_kernel_tracepoint(void)
64 struct lttng_event_rule
*tracepoint
= NULL
;
65 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
66 enum lttng_event_rule_status status
;
67 const char *pattern
="my_event_*";
68 const char *filter
="msg_id == 23 && size >= 2048";
70 struct lttng_payload payload
;
72 diag("Testing lttng_event_rule_kernel_tracepoint.");
74 lttng_payload_init(&payload
);
76 tracepoint
= lttng_event_rule_kernel_tracepoint_create();
77 ok(tracepoint
, "tracepoint object.");
79 status
= lttng_event_rule_kernel_tracepoint_set_name_pattern(tracepoint
, pattern
);
80 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
81 status
= lttng_event_rule_kernel_tracepoint_get_name_pattern(tracepoint
, &tmp
);
82 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
83 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
85 status
= lttng_event_rule_kernel_tracepoint_set_filter(tracepoint
, filter
);
86 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
87 status
= lttng_event_rule_kernel_tracepoint_get_filter(tracepoint
, &tmp
);
88 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
89 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
91 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
94 struct lttng_payload_view view
=
95 lttng_payload_view_from_payload(
98 ok(lttng_event_rule_create_from_payload(
99 &view
, &tracepoint_from_buffer
) > 0,
103 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
105 lttng_payload_reset(&payload
);
106 lttng_event_rule_destroy(tracepoint
);
107 lttng_event_rule_destroy(tracepoint_from_buffer
);
111 void test_event_rule_user_tracepoint(void)
115 struct lttng_event_rule
*tracepoint
= NULL
;
116 struct lttng_event_rule
*tracepoint_from_buffer
= NULL
;
117 enum lttng_event_rule_status status
;
118 const char *pattern
="my_event_*";
119 const char *filter
="msg_id == 23 && size >= 2048";
121 const char *name_pattern_exclusions
[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
122 struct lttng_log_level_rule
*log_level_rule
= NULL
;
123 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
124 struct lttng_payload payload
;
126 diag("Testing lttng_event_rule_user_tracepoint.");
128 lttng_payload_init(&payload
);
130 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
131 assert(log_level_rule
);
133 tracepoint
= lttng_event_rule_user_tracepoint_create();
134 ok(tracepoint
, "user tracepoint object.");
136 status
= lttng_event_rule_user_tracepoint_set_name_pattern(tracepoint
, pattern
);
137 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
138 status
= lttng_event_rule_user_tracepoint_get_name_pattern(tracepoint
, &tmp
);
139 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
140 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
142 status
= lttng_event_rule_user_tracepoint_set_filter(tracepoint
, filter
);
143 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
144 status
= lttng_event_rule_user_tracepoint_get_filter(tracepoint
, &tmp
);
145 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
146 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
148 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(tracepoint
, &log_level_rule_return
);
149 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
151 status
= lttng_event_rule_user_tracepoint_set_log_level_rule(
152 tracepoint
, log_level_rule
);
153 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
154 status
= lttng_event_rule_user_tracepoint_get_log_level_rule(
155 tracepoint
, &log_level_rule_return
);
156 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
158 /* Name pattern exclusions */
159 for (i
= 0; i
< 3; i
++) {
160 status
= lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(
161 tracepoint
, name_pattern_exclusions
[i
]);
162 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
163 "setting name pattern exclusions \"%s\"",
164 name_pattern_exclusions
[i
]);
167 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
169 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
170 "getting name pattern exclusion count.");
171 ok(count
== 3, "count is %d/3", count
);
173 for (i
= 0; i
< count
; i
++) {
174 status
= lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
175 tracepoint
, i
, &tmp
);
176 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
177 "getting name pattern exclusion at index %d.",
179 ok(!strncmp(name_pattern_exclusions
[i
], tmp
,
180 strlen(name_pattern_exclusions
[i
])),
181 "%s == %s.", tmp
, name_pattern_exclusions
[i
]);
184 ok(lttng_event_rule_serialize(tracepoint
, &payload
) == 0, "Serializing.");
187 struct lttng_payload_view view
=
188 lttng_payload_view_from_payload(
191 ok(lttng_event_rule_create_from_payload(
192 &view
, &tracepoint_from_buffer
) > 0,
196 ok(lttng_event_rule_is_equal(tracepoint
, tracepoint_from_buffer
), "serialized and from buffer are equal.");
198 lttng_payload_reset(&payload
);
199 lttng_event_rule_destroy(tracepoint
);
200 lttng_event_rule_destroy(tracepoint_from_buffer
);
201 lttng_log_level_rule_destroy(log_level_rule
);
204 static void test_event_rule_syscall(void)
206 struct lttng_event_rule
*syscall
= NULL
;
207 struct lttng_event_rule
*syscall_from_buffer
= NULL
;
208 enum lttng_event_rule_status status
;
209 const char *pattern
= "my_event_*";
210 const char *filter
= "msg_id == 23 && size >= 2048";
212 struct lttng_payload payload
;
214 diag("Event rule syscall.");
216 lttng_payload_init(&payload
);
218 syscall
= lttng_event_rule_kernel_syscall_create(LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY
);
219 ok(syscall
, "syscall object.");
221 status
= lttng_event_rule_kernel_syscall_set_name_pattern(syscall
, pattern
);
222 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
223 status
= lttng_event_rule_kernel_syscall_get_name_pattern(syscall
, &tmp
);
224 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
225 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
227 status
= lttng_event_rule_kernel_syscall_set_filter(syscall
, filter
);
228 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
229 status
= lttng_event_rule_kernel_syscall_get_filter(syscall
, &tmp
);
230 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
231 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
233 ok(lttng_event_rule_serialize(syscall
, &payload
) == 0, "Serializing.");
236 struct lttng_payload_view view
=
237 lttng_payload_view_from_payload(
240 ok(lttng_event_rule_create_from_payload(
241 &view
, &syscall_from_buffer
) > 0,
245 ok(lttng_event_rule_is_equal(syscall
, syscall_from_buffer
),
246 "serialized and from buffer are equal.");
248 lttng_payload_reset(&payload
);
249 lttng_event_rule_destroy(syscall
);
250 lttng_event_rule_destroy(syscall_from_buffer
);
254 void test_event_rule_jul_logging(void)
256 struct lttng_event_rule
*jul_logging
= NULL
;
257 struct lttng_event_rule
*jul_logging_from_buffer
= NULL
;
258 enum lttng_event_rule_status status
;
259 const char *pattern
="my_event_*";
260 const char *filter
="msg_id == 23 && size >= 2048";
262 struct lttng_log_level_rule
*log_level_rule
= NULL
;
263 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
264 struct lttng_payload payload
;
266 diag("Testing lttng_event_rule_user_jul_logging.");
268 lttng_payload_init(&payload
);
270 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
271 assert(log_level_rule
);
273 jul_logging
= lttng_event_rule_jul_logging_create();
274 ok(jul_logging
, "jul_logging object.");
276 status
= lttng_event_rule_jul_logging_set_name_pattern(jul_logging
, pattern
);
277 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
278 status
= lttng_event_rule_jul_logging_get_name_pattern(jul_logging
, &tmp
);
279 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
280 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
282 status
= lttng_event_rule_jul_logging_set_filter(jul_logging
, filter
);
283 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
284 status
= lttng_event_rule_jul_logging_get_filter(jul_logging
, &tmp
);
285 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
286 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
288 status
= lttng_event_rule_jul_logging_get_log_level_rule(jul_logging
, &log_level_rule_return
);
289 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
291 status
= lttng_event_rule_jul_logging_set_log_level_rule(
292 jul_logging
, log_level_rule
);
293 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
294 status
= lttng_event_rule_jul_logging_get_log_level_rule(
295 jul_logging
, &log_level_rule_return
);
296 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
298 ok(lttng_event_rule_serialize(jul_logging
, &payload
) == 0, "Serializing.");
301 struct lttng_payload_view view
=
302 lttng_payload_view_from_payload(
305 ok(lttng_event_rule_create_from_payload(
306 &view
, &jul_logging_from_buffer
) > 0,
310 ok(lttng_event_rule_is_equal(jul_logging
, jul_logging_from_buffer
), "serialized and from buffer are equal.");
312 lttng_payload_reset(&payload
);
313 lttng_event_rule_destroy(jul_logging
);
314 lttng_event_rule_destroy(jul_logging_from_buffer
);
315 lttng_log_level_rule_destroy(log_level_rule
);
319 void test_event_rule_log4j_logging(void)
321 struct lttng_event_rule
*log4j_logging
= NULL
;
322 struct lttng_event_rule
*log4j_logging_from_buffer
= NULL
;
323 enum lttng_event_rule_status status
;
324 const char *pattern
="my_event_*";
325 const char *filter
="msg_id == 23 && size >= 2048";
327 struct lttng_log_level_rule
*log_level_rule
= NULL
;
328 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
329 struct lttng_payload payload
;
331 diag("Testing lttng_event_rule_user_log4j_logging.");
333 lttng_payload_init(&payload
);
335 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
336 assert(log_level_rule
);
338 log4j_logging
= lttng_event_rule_log4j_logging_create();
339 ok(log4j_logging
, "log4j_logging object.");
341 status
= lttng_event_rule_log4j_logging_set_name_pattern(log4j_logging
, pattern
);
342 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
343 status
= lttng_event_rule_log4j_logging_get_name_pattern(log4j_logging
, &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_log4j_logging_set_filter(log4j_logging
, filter
);
348 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
349 status
= lttng_event_rule_log4j_logging_get_filter(log4j_logging
, &tmp
);
350 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
351 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
353 status
= lttng_event_rule_log4j_logging_get_log_level_rule(log4j_logging
, &log_level_rule_return
);
354 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
356 status
= lttng_event_rule_log4j_logging_set_log_level_rule(
357 log4j_logging
, log_level_rule
);
358 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
359 status
= lttng_event_rule_log4j_logging_get_log_level_rule(
360 log4j_logging
, &log_level_rule_return
);
361 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
363 ok(lttng_event_rule_serialize(log4j_logging
, &payload
) == 0, "Serializing.");
366 struct lttng_payload_view view
=
367 lttng_payload_view_from_payload(
370 ok(lttng_event_rule_create_from_payload(
371 &view
, &log4j_logging_from_buffer
) > 0,
375 ok(lttng_event_rule_is_equal(log4j_logging
, log4j_logging_from_buffer
), "serialized and from buffer are equal.");
377 lttng_payload_reset(&payload
);
378 lttng_event_rule_destroy(log4j_logging
);
379 lttng_event_rule_destroy(log4j_logging_from_buffer
);
380 lttng_log_level_rule_destroy(log_level_rule
);
384 void test_event_rule_python_logging(void)
386 struct lttng_event_rule
*python_logging
= NULL
;
387 struct lttng_event_rule
*python_logging_from_buffer
= NULL
;
388 enum lttng_event_rule_status status
;
389 const char *pattern
="my_event_*";
390 const char *filter
="msg_id == 23 && size >= 2048";
392 struct lttng_log_level_rule
*log_level_rule
= NULL
;
393 const struct lttng_log_level_rule
*log_level_rule_return
= NULL
;
394 struct lttng_payload payload
;
396 diag("Testing lttng_event_rule_user_python_logging.");
398 lttng_payload_init(&payload
);
400 log_level_rule
= lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO
);
401 assert(log_level_rule
);
403 python_logging
= lttng_event_rule_python_logging_create();
404 ok(python_logging
, "python_logging object.");
406 status
= lttng_event_rule_python_logging_set_name_pattern(python_logging
, pattern
);
407 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting pattern.");
408 status
= lttng_event_rule_python_logging_get_name_pattern(python_logging
, &tmp
);
409 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting pattern.");
410 ok(!strncmp(pattern
, tmp
, strlen(pattern
)), "pattern is equal.");
412 status
= lttng_event_rule_python_logging_set_filter(python_logging
, filter
);
413 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting filter.");
414 status
= lttng_event_rule_python_logging_get_filter(python_logging
, &tmp
);
415 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "getting filter.");
416 ok(!strncmp(filter
, tmp
, strlen(filter
)), "filter is equal.");
418 status
= lttng_event_rule_python_logging_get_log_level_rule(python_logging
, &log_level_rule_return
);
419 ok(status
== LTTNG_EVENT_RULE_STATUS_UNSET
, "get unset log level rule.");
421 status
= lttng_event_rule_python_logging_set_log_level_rule(
422 python_logging
, log_level_rule
);
423 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "setting log level rule.");
424 status
= lttng_event_rule_python_logging_get_log_level_rule(
425 python_logging
, &log_level_rule_return
);
426 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "get log level rule.");
428 ok(lttng_event_rule_serialize(python_logging
, &payload
) == 0, "Serializing.");
431 struct lttng_payload_view view
=
432 lttng_payload_view_from_payload(
435 ok(lttng_event_rule_create_from_payload(
436 &view
, &python_logging_from_buffer
) > 0,
440 ok(lttng_event_rule_is_equal(python_logging
, python_logging_from_buffer
), "serialized and from buffer are equal.");
442 lttng_payload_reset(&payload
);
443 lttng_event_rule_destroy(python_logging
);
444 lttng_event_rule_destroy(python_logging_from_buffer
);
445 lttng_log_level_rule_destroy(log_level_rule
);
448 static void test_event_rule_userspace_probe(void)
450 struct lttng_event_rule
*uprobe
= NULL
;
451 struct lttng_event_rule
*uprobe_from_buffer
= NULL
;
452 struct lttng_userspace_probe_location_lookup_method
*lookup_method
=
454 struct lttng_userspace_probe_location
*probe_location
= NULL
;
455 const struct lttng_userspace_probe_location
*probe_location_tmp
= NULL
;
456 enum lttng_event_rule_status status
;
458 const char *probe_name
= "my_probe.";
460 struct lttng_payload payload
;
462 diag("Event rule uprobe.");
463 lttng_payload_init(&payload
);
465 lookup_method
= lttng_userspace_probe_location_lookup_method_function_elf_create();
466 if (!lookup_method
) {
467 fail("Setup error on userspace probe lookup method creation.");
471 probe_location
= lttng_userspace_probe_location_function_create(
473 "lttng_userspace_probe_location_tracepoint_create",
475 if (!probe_location
) {
476 fail("Setup error on userspace probe location creation.");
480 /* Ownership transferred to the probe location function object. */
481 lookup_method
= NULL
;
483 lttng_payload_init(&payload
);
485 uprobe
= lttng_event_rule_kernel_uprobe_create(probe_location
);
486 ok(uprobe
, "uprobe event rule object creation.");
488 status
= lttng_event_rule_kernel_uprobe_get_location(
489 uprobe
, &probe_location_tmp
);
490 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
491 "Getting uprobe event rule location.");
492 ok(lttng_userspace_probe_location_is_equal(
493 probe_location
, probe_location_tmp
),
494 "Location is equal.");
496 status
= lttng_event_rule_kernel_uprobe_set_event_name(uprobe
, probe_name
);
497 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
498 "Setting uprobe event rule name: %s.", probe_name
);
499 status
= lttng_event_rule_kernel_uprobe_get_event_name(uprobe
, &tmp
);
500 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "Getting uprobe name.");
501 ok(!strcmp(probe_name
, tmp
), "Uprobe name are equal.");
503 ok(lttng_event_rule_serialize(uprobe
, &payload
) == 0, "Serializing.");
506 struct lttng_payload_view view
=
507 lttng_payload_view_from_payload(
510 ok(lttng_event_rule_create_from_payload(
511 &view
, &uprobe_from_buffer
) > 0,
515 ok(lttng_event_rule_is_equal(uprobe
, uprobe_from_buffer
),
516 "serialized and from buffer are equal.");
519 lttng_payload_reset(&payload
);
520 lttng_event_rule_destroy(uprobe
);
521 lttng_event_rule_destroy(uprobe_from_buffer
);
522 lttng_userspace_probe_location_destroy(probe_location
);
523 lttng_userspace_probe_location_lookup_method_destroy(lookup_method
);
526 static void test_event_rule_kernel_probe_by_location(
527 const struct lttng_kernel_probe_location
*location
)
529 struct lttng_event_rule
*kprobe
= NULL
;
530 struct lttng_event_rule
*kprobe_from_buffer
= NULL
;
531 enum lttng_event_rule_status status
;
532 const struct lttng_kernel_probe_location
*_location
;
534 const char *probe_name
= "my_probe";
536 struct lttng_payload payload
;
538 diag("Event rule kprobe for location type %d.",
539 lttng_kernel_probe_location_get_type(location
));
541 lttng_payload_init(&payload
);
543 kprobe
= lttng_event_rule_kernel_kprobe_create(location
);
544 ok(kprobe
, "kprobe event rule object creation.");
546 status
= lttng_event_rule_kernel_kprobe_get_location(kprobe
, &_location
);
547 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
548 "Getting kprobe event rule location.");
549 ok(lttng_kernel_probe_location_is_equal(location
, _location
), "Locations are equal.");
551 status
= lttng_event_rule_kernel_kprobe_set_event_name(kprobe
, probe_name
);
552 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
,
553 "Setting kprobe event rule name: %s.", probe_name
);
554 status
= lttng_event_rule_kernel_kprobe_get_event_name(kprobe
, &tmp
);
555 ok(status
== LTTNG_EVENT_RULE_STATUS_OK
, "Getting kprobe name.");
556 ok(!strcmp(probe_name
, tmp
), "kprobe name are equal.");
558 ok(lttng_event_rule_serialize(kprobe
, &payload
) == 0, "Serializing.");
561 struct lttng_payload_view view
=
562 lttng_payload_view_from_payload(
565 ok(lttng_event_rule_create_from_payload(
566 &view
, &kprobe_from_buffer
) > 0,
570 ok(lttng_event_rule_is_equal(kprobe
, kprobe_from_buffer
),
571 "serialized and from buffer are equal.");
573 lttng_payload_reset(&payload
);
574 lttng_event_rule_destroy(kprobe
);
575 lttng_event_rule_destroy(kprobe_from_buffer
);
578 static void test_event_rule_kernel_probe(void)
580 struct lttng_kernel_probe_location
*address_location
= NULL
;
581 struct lttng_kernel_probe_location
*symbol_location
= NULL
;
583 address_location
= lttng_kernel_probe_location_address_create(50);
584 symbol_location
= lttng_kernel_probe_location_symbol_create("une_bonne", 50);
585 assert(address_location
);
586 assert(symbol_location
);
588 test_event_rule_kernel_probe_by_location(address_location
);
589 test_event_rule_kernel_probe_by_location(symbol_location
);
591 lttng_kernel_probe_location_destroy(address_location
);
592 lttng_kernel_probe_location_destroy(symbol_location
);
595 static void test_set_event_rule_log_level_rules(
596 struct lttng_event_rule
*event_rule
,
597 event_rule_set_log_level set_log_level
,
599 enum lttng_event_rule_status
*exactly_status
,
600 enum lttng_event_rule_status
*as_severe_status
)
602 struct lttng_log_level_rule
*log_level_rule
;
604 log_level_rule
= lttng_log_level_rule_at_least_as_severe_as_create(
606 assert(log_level_rule
);
608 *as_severe_status
= set_log_level(
609 event_rule
, log_level_rule
);
610 lttng_log_level_rule_destroy(log_level_rule
);
612 log_level_rule
= lttng_log_level_rule_exactly_create(log_level
);
613 assert(log_level_rule
);
615 *exactly_status
= set_log_level(
616 event_rule
, log_level_rule
);
617 lttng_log_level_rule_destroy(log_level_rule
);
620 static void test_event_rule_log_level_generic(enum lttng_event_rule_type event_rule_type
,
621 log_level_name_getter get_log_level_name
,
622 event_rule_create create_event_rule
,
623 event_rule_set_log_level set_log_level
,
624 const int tagged_log_level_values
[],
625 size_t tagged_log_level_values_count
,
626 const int valid_log_level_values
[],
627 size_t valid_log_level_values_count
,
628 const int invalid_log_level_values
[],
629 size_t invalid_log_level_values_count
)
632 struct lttng_event_rule
*rule
;
633 enum lttng_event_rule_status er_exactly_status
, er_as_severe_status
;
634 const char *event_rule_type_str
= lttng_event_rule_type_str(event_rule_type
);
637 diag("Test %s event rule + log level rule", event_rule_type_str
);
639 rule
= create_event_rule();
642 for (i
= 0; i
< tagged_log_level_values_count
; i
++) {
643 const int tagged_log_level_value
= tagged_log_level_values
[i
];
645 test_set_event_rule_log_level_rules(rule
, set_log_level
,
646 tagged_log_level_value
,
647 &er_exactly_status
, &er_as_severe_status
);
648 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_OK
,
649 "Log level rule \"exactly\" accepted by %s event rule: level = %s",
652 tagged_log_level_value
));
653 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_OK
,
654 "Log level rule \"as least as severe as\" accepted by %s event rule: level = %s",
657 tagged_log_level_value
));
660 for (i
= 0; i
< valid_log_level_values_count
; i
++) {
661 const int valid_log_level_value
= valid_log_level_values
[i
];
663 test_set_event_rule_log_level_rules(rule
, set_log_level
,
664 valid_log_level_value
,
665 &er_exactly_status
, &er_as_severe_status
);
666 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_OK
,
667 "Log level rule \"exactly\" accepted by %s event rule: level = %d",
669 valid_log_level_value
);
670 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_OK
,
671 "Log level rule \"as least as severe as\" accepted by %s event rule: level = %d",
673 valid_log_level_value
);
676 for (i
= 0; i
< invalid_log_level_values_count
; i
++) {
677 const int invalid_log_level_value
= invalid_log_level_values
[i
];
679 test_set_event_rule_log_level_rules(rule
, set_log_level
,
680 invalid_log_level_value
,
681 &er_exactly_status
, &er_as_severe_status
);
682 ok(er_exactly_status
== LTTNG_EVENT_RULE_STATUS_INVALID
,
683 "Log level rule \"exactly\" rejected by %s event rule: level = %d",
685 invalid_log_level_value
);
686 ok(er_as_severe_status
== LTTNG_EVENT_RULE_STATUS_INVALID
,
687 "Log level rule \"as least as severe as\" rejected by %s event rule: level = %d",
689 invalid_log_level_value
);
692 lttng_event_rule_destroy(rule
);
695 static void test_event_rule_log_level_ust(void)
697 const int tagged_log_level_values
[] = {
698 LTTNG_LOGLEVEL_EMERG
,
699 LTTNG_LOGLEVEL_ALERT
,
702 LTTNG_LOGLEVEL_WARNING
,
703 LTTNG_LOGLEVEL_NOTICE
,
705 LTTNG_LOGLEVEL_DEBUG_SYSTEM
,
706 LTTNG_LOGLEVEL_DEBUG_PROGRAM
,
707 LTTNG_LOGLEVEL_DEBUG_PROCESS
,
708 LTTNG_LOGLEVEL_DEBUG_MODULE
,
709 LTTNG_LOGLEVEL_DEBUG_UNIT
,
710 LTTNG_LOGLEVEL_DEBUG_FUNCTION
,
711 LTTNG_LOGLEVEL_DEBUG_LINE
,
712 LTTNG_LOGLEVEL_DEBUG
,
714 const int invalid_log_level_values
[] = {
717 LTTNG_LOGLEVEL_DEBUG
+ 1,
718 LTTNG_LOGLEVEL_EMERG
- 1,
721 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT
,
722 loglevel_value_to_name
,
723 lttng_event_rule_user_tracepoint_create
,
724 lttng_event_rule_user_tracepoint_set_log_level_rule
,
725 tagged_log_level_values
,
726 ARRAY_SIZE(tagged_log_level_values
), NULL
, 0,
727 invalid_log_level_values
,
728 ARRAY_SIZE(invalid_log_level_values
));
731 static void test_event_rule_log_level_jul(void)
733 const int tagged_log_level_values
[] = {
734 LTTNG_LOGLEVEL_JUL_OFF
,
735 LTTNG_LOGLEVEL_JUL_SEVERE
,
736 LTTNG_LOGLEVEL_JUL_WARNING
,
737 LTTNG_LOGLEVEL_JUL_INFO
,
738 LTTNG_LOGLEVEL_JUL_CONFIG
,
739 LTTNG_LOGLEVEL_JUL_FINE
,
740 LTTNG_LOGLEVEL_JUL_FINER
,
741 LTTNG_LOGLEVEL_JUL_FINEST
,
742 LTTNG_LOGLEVEL_JUL_ALL
,
744 const int valid_log_level_values
[] = {
750 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_JUL_LOGGING
,
751 loglevel_jul_value_to_name
,
752 lttng_event_rule_jul_logging_create
,
753 lttng_event_rule_jul_logging_set_log_level_rule
,
754 tagged_log_level_values
,
755 ARRAY_SIZE(tagged_log_level_values
),
756 valid_log_level_values
,
757 ARRAY_SIZE(valid_log_level_values
), NULL
, 0);
760 static void test_event_rule_log_level_log4j(void)
762 const int tagged_log_level_values
[] = {
763 LTTNG_LOGLEVEL_LOG4J_OFF
,
764 LTTNG_LOGLEVEL_LOG4J_FATAL
,
765 LTTNG_LOGLEVEL_LOG4J_ERROR
,
766 LTTNG_LOGLEVEL_LOG4J_WARN
,
767 LTTNG_LOGLEVEL_LOG4J_INFO
,
768 LTTNG_LOGLEVEL_LOG4J_DEBUG
,
769 LTTNG_LOGLEVEL_LOG4J_TRACE
,
770 LTTNG_LOGLEVEL_LOG4J_ALL
,
772 const int valid_log_level_values
[] = {
778 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING
,
779 loglevel_log4j_value_to_name
,
780 lttng_event_rule_log4j_logging_create
,
781 lttng_event_rule_log4j_logging_set_log_level_rule
,
782 tagged_log_level_values
,
783 ARRAY_SIZE(tagged_log_level_values
),
784 valid_log_level_values
,
785 ARRAY_SIZE(valid_log_level_values
), NULL
, 0);
788 static void test_event_rule_log_level_python(void)
790 const int tagged_log_level_values
[] = {
791 LTTNG_LOGLEVEL_PYTHON_CRITICAL
,
792 LTTNG_LOGLEVEL_PYTHON_ERROR
,
793 LTTNG_LOGLEVEL_PYTHON_WARNING
,
794 LTTNG_LOGLEVEL_PYTHON_INFO
,
795 LTTNG_LOGLEVEL_PYTHON_DEBUG
,
796 LTTNG_LOGLEVEL_PYTHON_NOTSET
,
798 const int valid_log_level_values
[] = {
805 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING
,
806 loglevel_python_value_to_name
,
807 lttng_event_rule_python_logging_create
,
808 lttng_event_rule_python_logging_set_log_level_rule
,
809 tagged_log_level_values
,
810 ARRAY_SIZE(tagged_log_level_values
),
811 valid_log_level_values
,
812 ARRAY_SIZE(valid_log_level_values
),
816 int main(int argc
, const char *argv
[])
818 plan_tests(NUM_TESTS
);
819 test_event_rule_kernel_tracepoint();
820 test_event_rule_user_tracepoint();
821 test_event_rule_syscall();
822 test_event_rule_userspace_probe();
823 test_event_rule_kernel_probe();
824 test_event_rule_log4j_logging();
825 test_event_rule_jul_logging();
826 test_event_rule_python_logging();
827 test_event_rule_log_level_ust();
828 test_event_rule_log_level_jul();
829 test_event_rule_log_level_log4j();
830 test_event_rule_log_level_python();
831 return exit_status();