projects / lttng-tools.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Introduce lttng_event_rule_user_tracepoint
[lttng-tools.git] / tests / unit / test_event_rule.c
CommitLineData
dbc20d3c
JR		 1/*
2 * Unit tests for the notification API.
3 *
4 * Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
5 *
6 * SPDX-License-Identifier: LGPL-2.1-only
7 *
8 */
9
10#include <assert.h>
11#include <inttypes.h>
12#include <stdio.h>
13#include <string.h>
14#include <unistd.h>
15
16#include <tap/tap.h>
17
18#include <common/payload-view.h>
19#include <common/payload.h>
20#include <lttng/domain.h>
d84633c4
JR		 21#include <lttng/event-rule/kernel-kprobe-internal.h>
22#include <lttng/event-rule/kernel-kprobe.h>
213efb0c
JR		 23#include <lttng/event-rule/kernel-syscall-internal.h>
24#include <lttng/event-rule/kernel-syscall.h>
dbc20d3c
JR		 25#include <lttng/event-rule/tracepoint-internal.h>
26#include <lttng/event-rule/tracepoint.h>
b25b2570
JR		 27#include <lttng/event-rule/kernel-tracepoint-internal.h>
28#include <lttng/event-rule/kernel-tracepoint.h>
e60e9a9a
JR		 29#include <lttng/event-rule/kernel-uprobe-internal.h>
30#include <lttng/event-rule/kernel-uprobe.h>
cc66eccf
JR		 31#include <lttng/event-rule/user-tracepoint-internal.h>
32#include <lttng/event-rule/user-tracepoint.h>
dbc20d3c
JR		 33#include <lttng/event.h>
34#include <lttng/kernel-probe-internal.h>
35#include <lttng/kernel-probe.h>
36#include <lttng/userspace-probe-internal.h>
37#include <lttng/userspace-probe.h>
2b4c142d 38#include "bin/lttng/loglevel.h"
dbc20d3c
JR		 39
40/* For error.h. */
41int lttng_opt_quiet = 1;
42int lttng_opt_verbose;
43int lttng_opt_mi;
44
cc66eccf 45#define NUM_TESTS 278
dbc20d3c
JR		 46
47struct tracepoint_test {
48 enum lttng_domain_type type;
001590c6 49 bool support_name_pattern_exclusion;
dbc20d3c
JR		 50};
51
2b4c142d
JG		 52typedef const char *(*log_level_name_getter)(int log_level);
53
dbc20d3c
JR		 54static
55void test_event_rule_tracepoint_by_domain(const struct tracepoint_test *test)
56{
dbc20d3c
JR		 57 unsigned int count;
58 struct lttng_event_rule *tracepoint = NULL;
59 struct lttng_event_rule *tracepoint_from_buffer = NULL;
60 enum lttng_event_rule_status status;
61 enum lttng_domain_type domain_type, type;
dbc20d3c
JR		 62 const char *pattern="my_event_*";
63 const char *filter="msg_id == 23 && size >= 2048";
64 const char *tmp;
001590c6 65 const char *name_pattern_exclusions[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
85b05318
JR		 66 struct lttng_log_level_rule *log_level_rule = NULL;
67 const struct lttng_log_level_rule *log_level_rule_return = NULL;
dbc20d3c
JR		 68 struct lttng_payload payload;
69
70 type = test->type;
71 diag("Testing domain %d.", type);
72
73 lttng_payload_init(&payload);
74
85b05318
JR		 75 log_level_rule = lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO);
76 assert(log_level_rule);
77
dbc20d3c
JR		 78 tracepoint = lttng_event_rule_tracepoint_create(type);
79 ok(tracepoint, "tracepoint object.");
80
81 status = lttng_event_rule_tracepoint_get_domain_type(tracepoint, &domain_type);
82 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "get tracepoint domain.");
83 ok(domain_type == type, "domain type got %d expected %d.", domain_type, type);
84
6296f20c 85 status = lttng_event_rule_tracepoint_set_name_pattern(tracepoint, pattern);
dbc20d3c 86 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
6296f20c 87 status = lttng_event_rule_tracepoint_get_name_pattern(tracepoint, &tmp);
dbc20d3c
JR		 88 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
89 ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
90
91 status = lttng_event_rule_tracepoint_set_filter(tracepoint, filter);
92 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
93 status = lttng_event_rule_tracepoint_get_filter(tracepoint, &tmp);
94 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
95 ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
96
85b05318
JR		 97 status = lttng_event_rule_tracepoint_get_log_level_rule(tracepoint, &log_level_rule_return);
98 ok(status == LTTNG_EVENT_RULE_STATUS_UNSET, "get unset log level rule.");
99
2b4c142d
JG		 100 if (type != LTTNG_DOMAIN_KERNEL) {
101 status = lttng_event_rule_tracepoint_set_log_level_rule(tracepoint, log_level_rule);
102 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting log level rule.");
103 status = lttng_event_rule_tracepoint_get_log_level_rule(tracepoint, &log_level_rule_return);
104 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "get log level rule.");
105 }
dbc20d3c 106
001590c6 107 if (test->support_name_pattern_exclusion) {
dbc20d3c
JR		 108 int i;
109
110 for (i = 0; i < 3; i++) {
001590c6
JR		 111 status = lttng_event_rule_tracepoint_add_name_pattern_exclusion(tracepoint, name_pattern_exclusions[i]);
112 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting name pattern exclusions \"%s\"", name_pattern_exclusions[i]);
dbc20d3c
JR		 113 }
114
001590c6
JR		 115 status = lttng_event_rule_tracepoint_get_name_pattern_exclusion_count(tracepoint, &count);
116 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting name pattern exclusion count.");
dbc20d3c
JR		 117 ok(count == 3, "count is %d/3", count);
118
119 for (i = 0; i < count; i++) {
001590c6
JR		 120 status = lttng_event_rule_tracepoint_get_name_pattern_exclusion_at_index(tracepoint, i, &tmp);
121 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting name pattern exclusion at index %d.", i);
122 ok(!strncmp(name_pattern_exclusions[i], tmp, strlen(name_pattern_exclusions[i])), "%s == %s.", tmp, name_pattern_exclusions[i]);
dbc20d3c
JR		 123 }
124 } else {
125 int i;
126
127 for (i = 0; i < 3; i++) {
001590c6
JR		 128 status = lttng_event_rule_tracepoint_add_name_pattern_exclusion(tracepoint, name_pattern_exclusions[i]);
129 ok(status == LTTNG_EVENT_RULE_STATUS_UNSUPPORTED, "setting name pattern exclusions unsupported \"%s\".", name_pattern_exclusions[i]);
dbc20d3c
JR		 130 }
131
001590c6
JR		 132 status = lttng_event_rule_tracepoint_get_name_pattern_exclusion_count(tracepoint, &count);
133 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting name pattern exclusion count.");
dbc20d3c
JR		 134 ok(count == 0, "count is %d/0", count);
135 }
136
137 ok(lttng_event_rule_serialize(tracepoint, &payload) == 0, "Serializing.");
138
139 {
140 struct lttng_payload_view view =
141 lttng_payload_view_from_payload(
142 &payload, 0, -1);
143
144 ok(lttng_event_rule_create_from_payload(
145 &view, &tracepoint_from_buffer) > 0,
146 "Deserializing.");
147 }
148
149 ok(lttng_event_rule_is_equal(tracepoint, tracepoint_from_buffer), "serialized and from buffer are equal.");
150
151 lttng_payload_reset(&payload);
152 lttng_event_rule_destroy(tracepoint);
153 lttng_event_rule_destroy(tracepoint_from_buffer);
85b05318 154 lttng_log_level_rule_destroy(log_level_rule);
dbc20d3c
JR		 155}
156
157static
158void test_event_rule_tracepoint(void)
159{
160 int i;
161 struct lttng_event_rule *tracepoint = NULL;
162 struct tracepoint_test tests[] = {{LTTNG_DOMAIN_JUL, false},
163 {LTTNG_DOMAIN_KERNEL, false},
164 {LTTNG_DOMAIN_LOG4J, false},
165 {LTTNG_DOMAIN_PYTHON, false},
166 {LTTNG_DOMAIN_UST, true}};
167
168 diag("Testing lttng_event_rule_tracepoint.");
169 tracepoint = lttng_event_rule_tracepoint_create(LTTNG_DOMAIN_NONE);
170 ok(!tracepoint, "Domain type restriction on create.");
171
172 for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
173 test_event_rule_tracepoint_by_domain(&tests[i]);
174 }
175}
176
b25b2570
JR		 177static
178void test_event_rule_kernel_tracepoint(void)
179{
180 struct lttng_event_rule *tracepoint = NULL;
181 struct lttng_event_rule *tracepoint_from_buffer = NULL;
182 enum lttng_event_rule_status status;
183 const char *pattern="my_event_*";
184 const char *filter="msg_id == 23 && size >= 2048";
185 const char *tmp;
186 struct lttng_payload payload;
187
188 diag("Testing lttng_event_rule_kernel_tracepoint.");
189
190 lttng_payload_init(&payload);
191
192 tracepoint = lttng_event_rule_kernel_tracepoint_create();
193 ok(tracepoint, "tracepoint object.");
194
195 status = lttng_event_rule_kernel_tracepoint_set_name_pattern(tracepoint, pattern);
196 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
197 status = lttng_event_rule_kernel_tracepoint_get_name_pattern(tracepoint, &tmp);
198 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
199 ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
200
201 status = lttng_event_rule_kernel_tracepoint_set_filter(tracepoint, filter);
202 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
203 status = lttng_event_rule_kernel_tracepoint_get_filter(tracepoint, &tmp);
204 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
205 ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
206
207 ok(lttng_event_rule_serialize(tracepoint, &payload) == 0, "Serializing.");
208
209 {
210 struct lttng_payload_view view =
211 lttng_payload_view_from_payload(
212 &payload, 0, -1);
213
214 ok(lttng_event_rule_create_from_payload(
215 &view, &tracepoint_from_buffer) > 0,
216 "Deserializing.");
217 }
218
219 ok(lttng_event_rule_is_equal(tracepoint, tracepoint_from_buffer), "serialized and from buffer are equal.");
220
221 lttng_payload_reset(&payload);
222 lttng_event_rule_destroy(tracepoint);
223 lttng_event_rule_destroy(tracepoint_from_buffer);
224}
225
cc66eccf
JR		 226static
227void test_event_rule_user_tracepoint(void)
228{
229 int i;
230 unsigned int count;
231 struct lttng_event_rule *tracepoint = NULL;
232 struct lttng_event_rule *tracepoint_from_buffer = NULL;
233 enum lttng_event_rule_status status;
234 const char *pattern="my_event_*";
235 const char *filter="msg_id == 23 && size >= 2048";
236 const char *tmp;
237 const char *name_pattern_exclusions[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
238 struct lttng_log_level_rule *log_level_rule = NULL;
239 const struct lttng_log_level_rule *log_level_rule_return = NULL;
240 struct lttng_payload payload;
241
242 diag("Testing lttng_event_rule_user_tracepoint.");
243
244 lttng_payload_init(&payload);
245
246 log_level_rule = lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO);
247 assert(log_level_rule);
248
249 tracepoint = lttng_event_rule_user_tracepoint_create();
250 ok(tracepoint, "user tracepoint object.");
251
252 status = lttng_event_rule_user_tracepoint_set_name_pattern(tracepoint, pattern);
253 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
254 status = lttng_event_rule_user_tracepoint_get_name_pattern(tracepoint, &tmp);
255 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
256 ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
257
258 status = lttng_event_rule_user_tracepoint_set_filter(tracepoint, filter);
259 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
260 status = lttng_event_rule_user_tracepoint_get_filter(tracepoint, &tmp);
261 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
262 ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
263
264 status = lttng_event_rule_user_tracepoint_get_log_level_rule(tracepoint, &log_level_rule_return);
265 ok(status == LTTNG_EVENT_RULE_STATUS_UNSET, "get unset log level rule.");
266
267 status = lttng_event_rule_user_tracepoint_set_log_level_rule(
268 tracepoint, log_level_rule);
269 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting log level rule.");
270 status = lttng_event_rule_user_tracepoint_get_log_level_rule(
271 tracepoint, &log_level_rule_return);
272 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "get log level rule.");
273
274 /* Name pattern exclusions */
275 for (i = 0; i < 3; i++) {
276 status = lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(
277 tracepoint, name_pattern_exclusions[i]);
278 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
279 "setting name pattern exclusions \"%s\"",
280 name_pattern_exclusions[i]);
281 }
282
283 status = lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
284 tracepoint, &count);
285 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
286 "getting name pattern exclusion count.");
287 ok(count == 3, "count is %d/3", count);
288
289 for (i = 0; i < count; i++) {
290 status = lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
291 tracepoint, i, &tmp);
292 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
293 "getting name pattern exclusion at index %d.",
294 i);
295 ok(!strncmp(name_pattern_exclusions[i], tmp,
296 strlen(name_pattern_exclusions[i])),
297 "%s == %s.", tmp, name_pattern_exclusions[i]);
298 }
299
300 ok(lttng_event_rule_serialize(tracepoint, &payload) == 0, "Serializing.");
301
302 {
303 struct lttng_payload_view view =
304 lttng_payload_view_from_payload(
305 &payload, 0, -1);
306
307 ok(lttng_event_rule_create_from_payload(
308 &view, &tracepoint_from_buffer) > 0,
309 "Deserializing.");
310 }
311
312 ok(lttng_event_rule_is_equal(tracepoint, tracepoint_from_buffer), "serialized and from buffer are equal.");
313
314 lttng_payload_reset(&payload);
315 lttng_event_rule_destroy(tracepoint);
316 lttng_event_rule_destroy(tracepoint_from_buffer);
317 lttng_log_level_rule_destroy(log_level_rule);
318}
319
dbc20d3c
JR		 320static void test_event_rule_syscall(void)
321{
322 struct lttng_event_rule *syscall = NULL;
323 struct lttng_event_rule *syscall_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";
327 const char *tmp;
328 struct lttng_payload payload;
329
330 diag("Event rule syscall.");
331
332 lttng_payload_init(&payload);
333
213efb0c 334 syscall = lttng_event_rule_kernel_syscall_create(LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY);
dbc20d3c
JR		 335 ok(syscall, "syscall object.");
336
213efb0c 337 status = lttng_event_rule_kernel_syscall_set_name_pattern(syscall, pattern);
dbc20d3c 338 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
213efb0c 339 status = lttng_event_rule_kernel_syscall_get_name_pattern(syscall, &tmp);
dbc20d3c
JR		 340 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
341 ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
342
213efb0c 343 status = lttng_event_rule_kernel_syscall_set_filter(syscall, filter);
dbc20d3c 344 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
213efb0c 345 status = lttng_event_rule_kernel_syscall_get_filter(syscall, &tmp);
dbc20d3c
JR		 346 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
347 ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
348
349 ok(lttng_event_rule_serialize(syscall, &payload) == 0, "Serializing.");
350
351 {
352 struct lttng_payload_view view =
353 lttng_payload_view_from_payload(
354 &payload, 0, -1);
355
356 ok(lttng_event_rule_create_from_payload(
357 &view, &syscall_from_buffer) > 0,
358 "Deserializing.");
359 }
360
361 ok(lttng_event_rule_is_equal(syscall, syscall_from_buffer),
362 "serialized and from buffer are equal.");
363
364 lttng_payload_reset(&payload);
365 lttng_event_rule_destroy(syscall);
366 lttng_event_rule_destroy(syscall_from_buffer);
367}
368
1f1567a5 369static void test_event_rule_userspace_probe(void)
dbc20d3c
JR		 370{
371 struct lttng_event_rule *uprobe = NULL;
372 struct lttng_event_rule *uprobe_from_buffer = NULL;
373 struct lttng_userspace_probe_location_lookup_method *lookup_method =
374 NULL;
375 struct lttng_userspace_probe_location *probe_location = NULL;
376 const struct lttng_userspace_probe_location *probe_location_tmp = NULL;
377 enum lttng_event_rule_status status;
378
379 const char *probe_name = "my_probe.";
380 const char *tmp;
381 struct lttng_payload payload;
382
383 diag("Event rule uprobe.");
384
385 lookup_method = lttng_userspace_probe_location_lookup_method_function_elf_create();
386 if (!lookup_method) {
387 fail("Setup error on userspace probe lookup method creation.");
388 goto end;
389 }
390
391 probe_location = lttng_userspace_probe_location_function_create(
392 "/proc/self/exe",
393 "lttng_userspace_probe_location_tracepoint_create",
394 lookup_method);
395 if (!probe_location) {
396 fail("Setup error on userspace probe location creation.");
397 goto end;
398 }
399
400 /* Ownership transferred to the probe location function object. */
401 lookup_method = NULL;
402
403 lttng_payload_init(&payload);
404
e60e9a9a 405 uprobe = lttng_event_rule_kernel_uprobe_create(probe_location);
dbc20d3c
JR		 406 ok(uprobe, "uprobe event rule object creation.");
407
e60e9a9a 408 status = lttng_event_rule_kernel_uprobe_get_location(
dbc20d3c
JR		 409 uprobe, &probe_location_tmp);
410 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
411 "Getting uprobe event rule location.");
412 ok(lttng_userspace_probe_location_is_equal(
413 probe_location, probe_location_tmp),
414 "Location is equal.");
415
e60e9a9a 416 status = lttng_event_rule_kernel_uprobe_set_event_name(uprobe, probe_name);
dbc20d3c
JR		 417 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
418 "Setting uprobe event rule name: %s.", probe_name);
e60e9a9a 419 status = lttng_event_rule_kernel_uprobe_get_event_name(uprobe, &tmp);
dbc20d3c
JR		 420 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "Getting uprobe name.");
421 ok(!strcmp(probe_name, tmp), "Uprobe name are equal.");
422
423 ok(lttng_event_rule_serialize(uprobe, &payload) == 0, "Serializing.");
424
425 {
426 struct lttng_payload_view view =
427 lttng_payload_view_from_payload(
428 &payload, 0, -1);
429
430 ok(lttng_event_rule_create_from_payload(
431 &view, &uprobe_from_buffer) > 0,
432 "Deserializing.");
433 }
434
435 ok(lttng_event_rule_is_equal(uprobe, uprobe_from_buffer),
436 "serialized and from buffer are equal.");
437
438end:
439 lttng_payload_reset(&payload);
440 lttng_event_rule_destroy(uprobe);
441 lttng_event_rule_destroy(uprobe_from_buffer);
442 lttng_userspace_probe_location_destroy(probe_location);
443 lttng_userspace_probe_location_lookup_method_destroy(lookup_method);
444}
445
f2791161 446static void test_event_rule_kernel_probe_by_location(
dbc20d3c
JR		 447 const struct lttng_kernel_probe_location *location)
448{
449 struct lttng_event_rule *kprobe = NULL;
450 struct lttng_event_rule *kprobe_from_buffer = NULL;
451 enum lttng_event_rule_status status;
452 const struct lttng_kernel_probe_location *_location;
453
454 const char *probe_name = "my_probe";
455 const char *tmp;
456 struct lttng_payload payload;
457
458 diag("Event rule kprobe for location type %d.",
459 lttng_kernel_probe_location_get_type(location));
460
461 lttng_payload_init(&payload);
462
d84633c4 463 kprobe = lttng_event_rule_kernel_kprobe_create(location);
dbc20d3c
JR		 464 ok(kprobe, "kprobe event rule object creation.");
465
d84633c4 466 status = lttng_event_rule_kernel_kprobe_get_location(kprobe, &_location);
dbc20d3c
JR		 467 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
468 "Getting kprobe event rule location.");
469 ok(lttng_kernel_probe_location_is_equal(location, _location), "Locations are equal.");
470
d84633c4 471 status = lttng_event_rule_kernel_kprobe_set_event_name(kprobe, probe_name);
dbc20d3c
JR		 472 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
473 "Setting kprobe event rule name: %s.", probe_name);
d84633c4 474 status = lttng_event_rule_kernel_kprobe_get_event_name(kprobe, &tmp);
dbc20d3c
JR		 475 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "Getting kprobe name.");
476 ok(!strcmp(probe_name, tmp), "kprobe name are equal.");
477
478 ok(lttng_event_rule_serialize(kprobe, &payload) == 0, "Serializing.");
479
480 {
481 struct lttng_payload_view view =
482 lttng_payload_view_from_payload(
483 &payload, 0, -1);
484
485 ok(lttng_event_rule_create_from_payload(
486 &view, &kprobe_from_buffer) > 0,
487 "Deserializing.");
488 }
489
490 ok(lttng_event_rule_is_equal(kprobe, kprobe_from_buffer),
491 "serialized and from buffer are equal.");
492
493 lttng_payload_reset(&payload);
494 lttng_event_rule_destroy(kprobe);
495 lttng_event_rule_destroy(kprobe_from_buffer);
496}
497
f2791161 498static void test_event_rule_kernel_probe(void)
dbc20d3c
JR		 499{
500 struct lttng_kernel_probe_location *address_location = NULL;
501 struct lttng_kernel_probe_location *symbol_location = NULL;
502
503 address_location = lttng_kernel_probe_location_address_create(50);
504 symbol_location = lttng_kernel_probe_location_symbol_create("une_bonne", 50);
505 assert(address_location);
506 assert(symbol_location);
507
f2791161
JR		 508 test_event_rule_kernel_probe_by_location(address_location);
509 test_event_rule_kernel_probe_by_location(symbol_location);
dbc20d3c
JR		 510
511 lttng_kernel_probe_location_destroy(address_location);
512 lttng_kernel_probe_location_destroy(symbol_location);
513}
514
2b4c142d
JG		 515static void test_set_event_rule_log_level_rules(
516 struct lttng_event_rule *event_rule,
517 int log_level,
518 enum lttng_event_rule_status *exactly_status,
519 enum lttng_event_rule_status *as_severe_status)
520{
521 struct lttng_log_level_rule *log_level_rule;
522
523 log_level_rule = lttng_log_level_rule_at_least_as_severe_as_create(
524 log_level);
525 assert(log_level_rule);
526
527 *as_severe_status = lttng_event_rule_tracepoint_set_log_level_rule(
528 event_rule, log_level_rule);
529 lttng_log_level_rule_destroy(log_level_rule);
530
531 log_level_rule = lttng_log_level_rule_exactly_create(log_level);
532 assert(log_level_rule);
533
534 *exactly_status = lttng_event_rule_tracepoint_set_log_level_rule(
535 event_rule, log_level_rule);
536 lttng_log_level_rule_destroy(log_level_rule);
537}
538
2b4c142d
JG		 539static void test_event_rule_log_level_generic(const char *domain_name,
540 enum lttng_domain_type domain,
541 log_level_name_getter get_log_level_name,
542 const int tagged_log_level_values[],
543 size_t tagged_log_level_values_count,
544 const int valid_log_level_values[],
545 size_t valid_log_level_values_count,
546 const int invalid_log_level_values[],
547 size_t invalid_log_level_values_count)
548{
549 size_t i;
550 struct lttng_event_rule *tracepoint_rule;
551 enum lttng_event_rule_status er_exactly_status, er_as_severe_status;
552
553 diag("Test %s event rule + log level rule", domain_name);
554 tracepoint_rule = lttng_event_rule_tracepoint_create(domain);
555 assert(tracepoint_rule);
556
557 for (i = 0; i < tagged_log_level_values_count; i++) {
558 const int tagged_log_level_value = tagged_log_level_values[i];
559
560 test_set_event_rule_log_level_rules(tracepoint_rule,
561 tagged_log_level_value,
562 &er_exactly_status, &er_as_severe_status);
563 ok(er_exactly_status == LTTNG_EVENT_RULE_STATUS_OK,
564 "Log level rule \"exactly\" accepted by %s tracepoint event rule: level = %s",
565 domain_name,
566 get_log_level_name(
567 tagged_log_level_value));
568 ok(er_as_severe_status == LTTNG_EVENT_RULE_STATUS_OK,
569 "Log level rule \"as least as severe as\" accepted by %s tracepoint event rule: level = %s",
570 domain_name,
571 get_log_level_name(
572 tagged_log_level_value));
573 }
574
575 for (i = 0; i < valid_log_level_values_count; i++) {
576 const int valid_log_level_value = valid_log_level_values[i];
577
578 test_set_event_rule_log_level_rules(tracepoint_rule,
579 valid_log_level_value,
580 &er_exactly_status, &er_as_severe_status);
581 ok(er_exactly_status == LTTNG_EVENT_RULE_STATUS_OK,
582 "Log level rule \"exactly\" accepted by %s tracepoint event rule: level = %d",
583 domain_name,
584 valid_log_level_value);
585 ok(er_as_severe_status == LTTNG_EVENT_RULE_STATUS_OK,
586 "Log level rule \"as least as severe as\" accepted by %s tracepoint event rule: level = %d",
587 domain_name,
588 valid_log_level_value);
589 }
590
591 for (i = 0; i < invalid_log_level_values_count; i++) {
592 const int invalid_log_level_value = invalid_log_level_values[i];
593
594 test_set_event_rule_log_level_rules(tracepoint_rule,
595 invalid_log_level_value,
596 &er_exactly_status, &er_as_severe_status);
597 ok(er_exactly_status == LTTNG_EVENT_RULE_STATUS_INVALID,
598 "Log level rule \"exactly\" rejected by %s tracepoint event rule: level = %d",
599 domain_name,
600 invalid_log_level_value);
601 ok(er_as_severe_status == LTTNG_EVENT_RULE_STATUS_INVALID,
602 "Log level rule \"as least as severe as\" rejected by %s tracepoint event rule: level = %d",
603 domain_name,
604 invalid_log_level_value);
605 }
606
607 lttng_event_rule_destroy(tracepoint_rule);
608}
609
610static void test_event_rule_log_level_ust(void)
611{
612 const int tagged_log_level_values[] = {
613 LTTNG_LOGLEVEL_EMERG,
614 LTTNG_LOGLEVEL_ALERT,
615 LTTNG_LOGLEVEL_CRIT,
616 LTTNG_LOGLEVEL_ERR,
617 LTTNG_LOGLEVEL_WARNING,
618 LTTNG_LOGLEVEL_NOTICE,
619 LTTNG_LOGLEVEL_INFO,
620 LTTNG_LOGLEVEL_DEBUG_SYSTEM,
621 LTTNG_LOGLEVEL_DEBUG_PROGRAM,
622 LTTNG_LOGLEVEL_DEBUG_PROCESS,
623 LTTNG_LOGLEVEL_DEBUG_MODULE,
624 LTTNG_LOGLEVEL_DEBUG_UNIT,
625 LTTNG_LOGLEVEL_DEBUG_FUNCTION,
626 LTTNG_LOGLEVEL_DEBUG_LINE,
627 LTTNG_LOGLEVEL_DEBUG,
628 };
629 const int invalid_log_level_values[] = {
630 -1980,
631 1995,
632 LTTNG_LOGLEVEL_DEBUG + 1,
633 LTTNG_LOGLEVEL_EMERG - 1,
634 };
635
636 test_event_rule_log_level_generic("user space", LTTNG_DOMAIN_UST,
637 loglevel_value_to_name, tagged_log_level_values,
638 ARRAY_SIZE(tagged_log_level_values),
639 NULL, 0,
640 invalid_log_level_values,
641 ARRAY_SIZE(invalid_log_level_values));
642}
643
644static void test_event_rule_log_level_jul(void)
645{
646 const int tagged_log_level_values[] = {
647 LTTNG_LOGLEVEL_JUL_OFF,
648 LTTNG_LOGLEVEL_JUL_SEVERE,
649 LTTNG_LOGLEVEL_JUL_WARNING,
650 LTTNG_LOGLEVEL_JUL_INFO,
651 LTTNG_LOGLEVEL_JUL_CONFIG,
652 LTTNG_LOGLEVEL_JUL_FINE,
653 LTTNG_LOGLEVEL_JUL_FINER,
654 LTTNG_LOGLEVEL_JUL_FINEST,
655 LTTNG_LOGLEVEL_JUL_ALL,
656 };
657 const int valid_log_level_values[] = {
658 0,
659 -1980,
660 1995
661 };
662
663 test_event_rule_log_level_generic("Java Util Logging", LTTNG_DOMAIN_JUL,
664 loglevel_jul_value_to_name, tagged_log_level_values,
665 ARRAY_SIZE(tagged_log_level_values),
666 valid_log_level_values,
667 ARRAY_SIZE(valid_log_level_values), NULL, 0);
668}
669
670static void test_event_rule_log_level_log4j(void)
671{
672 const int tagged_log_level_values[] = {
673 LTTNG_LOGLEVEL_LOG4J_OFF,
674 LTTNG_LOGLEVEL_LOG4J_FATAL,
675 LTTNG_LOGLEVEL_LOG4J_ERROR,
676 LTTNG_LOGLEVEL_LOG4J_WARN,
677 LTTNG_LOGLEVEL_LOG4J_INFO,
678 LTTNG_LOGLEVEL_LOG4J_DEBUG,
679 LTTNG_LOGLEVEL_LOG4J_TRACE,
680 LTTNG_LOGLEVEL_LOG4J_ALL,
681 };
682 const int valid_log_level_values[] = {
683 0
684 -1980,
685 1995
686 };
687
688 test_event_rule_log_level_generic("Log4j", LTTNG_DOMAIN_LOG4J,
689 loglevel_log4j_value_to_name, tagged_log_level_values,
690 ARRAY_SIZE(tagged_log_level_values),
691 valid_log_level_values,
692 ARRAY_SIZE(valid_log_level_values), NULL, 0);
693}
694
695static void test_event_rule_log_level_python(void)
696{
697 const int tagged_log_level_values[] = {
698 LTTNG_LOGLEVEL_PYTHON_CRITICAL,
699 LTTNG_LOGLEVEL_PYTHON_ERROR,
700 LTTNG_LOGLEVEL_PYTHON_WARNING,
701 LTTNG_LOGLEVEL_PYTHON_INFO,
702 LTTNG_LOGLEVEL_PYTHON_DEBUG,
703 LTTNG_LOGLEVEL_PYTHON_NOTSET,
704 };
705 const int valid_log_level_values[] = {
706 45,
707 35,
708 0,
709 -657,
710 };
711
712 test_event_rule_log_level_generic("Python", LTTNG_DOMAIN_PYTHON,
713 loglevel_python_value_to_name, tagged_log_level_values,
714 ARRAY_SIZE(tagged_log_level_values),
715 valid_log_level_values,
716 ARRAY_SIZE(valid_log_level_values),
717 NULL, 0);
718}
719
dbc20d3c
JR		 720int main(int argc, const char *argv[])
721{
722 plan_tests(NUM_TESTS);
723 test_event_rule_tracepoint();
b25b2570 724 test_event_rule_kernel_tracepoint();
cc66eccf 725 test_event_rule_user_tracepoint();
dbc20d3c 726 test_event_rule_syscall();
1f1567a5 727 test_event_rule_userspace_probe();
f2791161 728 test_event_rule_kernel_probe();
2b4c142d
JG		 729 test_event_rule_log_level_ust();
730 test_event_rule_log_level_jul();
731 test_event_rule_log_level_log4j();
732 test_event_rule_log_level_python();
dbc20d3c
JR		 733 return exit_status();
734}
LTTng tools - Deliverables
This page took 0.059135 seconds and 5 git commands to generate.