projects / lttng-tools.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
port: tests: uprobe is Linux specific
[lttng-tools.git] / tests / unit / test_event_rule.cpp
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
dbc20d3c
JR		 10#include <inttypes.h>
11#include <stdio.h>
12#include <string.h>
13#include <unistd.h>
14
15#include <tap/tap.h>
16
c9e313bc
SM		 17#include <common/payload-view.hpp>
18#include <common/payload.hpp>
dbc20d3c 19#include <lttng/domain.h>
c9e313bc 20#include <lttng/event-rule/jul-logging-internal.hpp>
b47b01d8 21#include <lttng/event-rule/jul-logging.h>
c9e313bc 22#include <lttng/event-rule/kernel-kprobe-internal.hpp>
85522de5 23#include <lttng/event-rule/kernel-kprobe.h>
c9e313bc 24#include <lttng/event-rule/kernel-syscall-internal.hpp>
4f7da553 25#include <lttng/event-rule/kernel-syscall.h>
c9e313bc 26#include <lttng/event-rule/python-logging-internal.hpp>
6530ec7d 27#include <lttng/event-rule/python-logging.h>
c9e313bc 28#include <lttng/event-rule/kernel-tracepoint-internal.hpp>
af0818ef 29#include <lttng/event-rule/kernel-tracepoint.h>
c9e313bc 30#include <lttng/event-rule/kernel-uprobe-internal.hpp>
46fd07ac 31#include <lttng/event-rule/kernel-uprobe.h>
c9e313bc 32#include <lttng/event-rule/user-tracepoint-internal.hpp>
0a23a07d 33#include <lttng/event-rule/user-tracepoint.h>
dbc20d3c 34#include <lttng/event.h>
c9e313bc 35#include <lttng/kernel-probe-internal.hpp>
dbc20d3c 36#include <lttng/kernel-probe.h>
c9e313bc 37#include <lttng/userspace-probe-internal.hpp>
dbc20d3c 38#include <lttng/userspace-probe.h>
c9e313bc 39#include "bin/lttng/loglevel.hpp"
dbc20d3c
JR		 40
41/* For error.h. */
42int lttng_opt_quiet = 1;
43int lttng_opt_verbose;
44int lttng_opt_mi;
45
93128834
MJ		 46#ifdef __linux__
47#define UPROBE_NUM_TESTS 9
48#else /* __linux__ */
49#define UPROBE_NUM_TESTS 0
50#endif /* __linux__ */
51
52#define NUM_TESTS (203 + UPROBE_NUM_TESTS)
dbc20d3c 53
f1494934 54namespace {
dbc20d3c
JR		 55struct tracepoint_test {
56 enum lttng_domain_type type;
975d26c5 57 bool support_name_pattern_exclusion;
dbc20d3c 58};
f1494934 59} /* namespace */
dbc20d3c 60
2b4c142d
JG		 61typedef const char *(*log_level_name_getter)(int log_level);
62
cade690d
JR		 63typedef struct lttng_event_rule *(*event_rule_create)(void);
64typedef enum lttng_event_rule_status (*event_rule_set_log_level)(
65 struct lttng_event_rule *rule,
66 const struct lttng_log_level_rule *log_level_rule);
67
af0818ef
JR		 68static
69void test_event_rule_kernel_tracepoint(void)
70{
71 struct lttng_event_rule *tracepoint = NULL;
72 struct lttng_event_rule *tracepoint_from_buffer = NULL;
73 enum lttng_event_rule_status status;
74 const char *pattern="my_event_*";
75 const char *filter="msg_id == 23 && size >= 2048";
76 const char *tmp;
77 struct lttng_payload payload;
78
79 diag("Testing lttng_event_rule_kernel_tracepoint.");
80
81 lttng_payload_init(&payload);
82
83 tracepoint = lttng_event_rule_kernel_tracepoint_create();
84 ok(tracepoint, "tracepoint object.");
85
86 status = lttng_event_rule_kernel_tracepoint_set_name_pattern(tracepoint, pattern);
87 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
88 status = lttng_event_rule_kernel_tracepoint_get_name_pattern(tracepoint, &tmp);
89 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
90 ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
91
92 status = lttng_event_rule_kernel_tracepoint_set_filter(tracepoint, filter);
93 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
94 status = lttng_event_rule_kernel_tracepoint_get_filter(tracepoint, &tmp);
95 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
96 ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
97
98 ok(lttng_event_rule_serialize(tracepoint, &payload) == 0, "Serializing.");
99
100 {
101 struct lttng_payload_view view =
102 lttng_payload_view_from_payload(
103 &payload, 0, -1);
104
105 ok(lttng_event_rule_create_from_payload(
106 &view, &tracepoint_from_buffer) > 0,
107 "Deserializing.");
108 }
109
110 ok(lttng_event_rule_is_equal(tracepoint, tracepoint_from_buffer), "serialized and from buffer are equal.");
111
112 lttng_payload_reset(&payload);
113 lttng_event_rule_destroy(tracepoint);
114 lttng_event_rule_destroy(tracepoint_from_buffer);
115}
116
0a23a07d
JR		 117static
118void test_event_rule_user_tracepoint(void)
119{
120 int i;
121 unsigned int count;
122 struct lttng_event_rule *tracepoint = NULL;
123 struct lttng_event_rule *tracepoint_from_buffer = NULL;
124 enum lttng_event_rule_status status;
125 const char *pattern="my_event_*";
126 const char *filter="msg_id == 23 && size >= 2048";
127 const char *tmp;
128 const char *name_pattern_exclusions[] = {"my_event_test1", "my_event_test2" ,"my_event_test3"};
129 struct lttng_log_level_rule *log_level_rule = NULL;
130 const struct lttng_log_level_rule *log_level_rule_return = NULL;
131 struct lttng_payload payload;
132
133 diag("Testing lttng_event_rule_user_tracepoint.");
134
135 lttng_payload_init(&payload);
136
137 log_level_rule = lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO);
a0377dfe 138 LTTNG_ASSERT(log_level_rule);
0a23a07d
JR		 139
140 tracepoint = lttng_event_rule_user_tracepoint_create();
141 ok(tracepoint, "user tracepoint object.");
142
143 status = lttng_event_rule_user_tracepoint_set_name_pattern(tracepoint, pattern);
144 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
145 status = lttng_event_rule_user_tracepoint_get_name_pattern(tracepoint, &tmp);
146 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
147 ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
148
149 status = lttng_event_rule_user_tracepoint_set_filter(tracepoint, filter);
150 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
151 status = lttng_event_rule_user_tracepoint_get_filter(tracepoint, &tmp);
152 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
153 ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
154
155 status = lttng_event_rule_user_tracepoint_get_log_level_rule(tracepoint, &log_level_rule_return);
156 ok(status == LTTNG_EVENT_RULE_STATUS_UNSET, "get unset log level rule.");
157
158 status = lttng_event_rule_user_tracepoint_set_log_level_rule(
159 tracepoint, log_level_rule);
160 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting log level rule.");
161 status = lttng_event_rule_user_tracepoint_get_log_level_rule(
162 tracepoint, &log_level_rule_return);
163 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "get log level rule.");
164
165 /* Name pattern exclusions */
166 for (i = 0; i < 3; i++) {
167 status = lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(
168 tracepoint, name_pattern_exclusions[i]);
169 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
170 "setting name pattern exclusions \"%s\"",
171 name_pattern_exclusions[i]);
172 }
173
174 status = lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
175 tracepoint, &count);
176 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
177 "getting name pattern exclusion count.");
178 ok(count == 3, "count is %d/3", count);
179
180 for (i = 0; i < count; i++) {
181 status = lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
182 tracepoint, i, &tmp);
183 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
184 "getting name pattern exclusion at index %d.",
185 i);
186 ok(!strncmp(name_pattern_exclusions[i], tmp,
187 strlen(name_pattern_exclusions[i])),
188 "%s == %s.", tmp, name_pattern_exclusions[i]);
189 }
190
191 ok(lttng_event_rule_serialize(tracepoint, &payload) == 0, "Serializing.");
192
193 {
194 struct lttng_payload_view view =
195 lttng_payload_view_from_payload(
196 &payload, 0, -1);
197
198 ok(lttng_event_rule_create_from_payload(
199 &view, &tracepoint_from_buffer) > 0,
200 "Deserializing.");
201 }
202
203 ok(lttng_event_rule_is_equal(tracepoint, tracepoint_from_buffer), "serialized and from buffer are equal.");
204
205 lttng_payload_reset(&payload);
206 lttng_event_rule_destroy(tracepoint);
207 lttng_event_rule_destroy(tracepoint_from_buffer);
208 lttng_log_level_rule_destroy(log_level_rule);
209}
210
dbc20d3c
JR		 211static void test_event_rule_syscall(void)
212{
213 struct lttng_event_rule *syscall = NULL;
214 struct lttng_event_rule *syscall_from_buffer = NULL;
215 enum lttng_event_rule_status status;
216 const char *pattern = "my_event_*";
217 const char *filter = "msg_id == 23 && size >= 2048";
218 const char *tmp;
219 struct lttng_payload payload;
220
221 diag("Event rule syscall.");
222
223 lttng_payload_init(&payload);
224
4f7da553 225 syscall = lttng_event_rule_kernel_syscall_create(LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY);
dbc20d3c
JR		 226 ok(syscall, "syscall object.");
227
4f7da553 228 status = lttng_event_rule_kernel_syscall_set_name_pattern(syscall, pattern);
dbc20d3c 229 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
4f7da553 230 status = lttng_event_rule_kernel_syscall_get_name_pattern(syscall, &tmp);
dbc20d3c
JR		 231 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
232 ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
233
4f7da553 234 status = lttng_event_rule_kernel_syscall_set_filter(syscall, filter);
dbc20d3c 235 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
4f7da553 236 status = lttng_event_rule_kernel_syscall_get_filter(syscall, &tmp);
dbc20d3c
JR		 237 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
238 ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
239
240 ok(lttng_event_rule_serialize(syscall, &payload) == 0, "Serializing.");
241
242 {
243 struct lttng_payload_view view =
244 lttng_payload_view_from_payload(
245 &payload, 0, -1);
246
247 ok(lttng_event_rule_create_from_payload(
248 &view, &syscall_from_buffer) > 0,
249 "Deserializing.");
250 }
251
252 ok(lttng_event_rule_is_equal(syscall, syscall_from_buffer),
253 "serialized and from buffer are equal.");
254
255 lttng_payload_reset(&payload);
256 lttng_event_rule_destroy(syscall);
257 lttng_event_rule_destroy(syscall_from_buffer);
258}
259
b47b01d8
JR		 260static
261void test_event_rule_jul_logging(void)
262{
263 struct lttng_event_rule *jul_logging = NULL;
264 struct lttng_event_rule *jul_logging_from_buffer = NULL;
265 enum lttng_event_rule_status status;
266 const char *pattern="my_event_*";
267 const char *filter="msg_id == 23 && size >= 2048";
268 const char *tmp;
269 struct lttng_log_level_rule *log_level_rule = NULL;
270 const struct lttng_log_level_rule *log_level_rule_return = NULL;
271 struct lttng_payload payload;
272
273 diag("Testing lttng_event_rule_user_jul_logging.");
274
275 lttng_payload_init(&payload);
276
277 log_level_rule = lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO);
a0377dfe 278 LTTNG_ASSERT(log_level_rule);
b47b01d8
JR		 279
280 jul_logging = lttng_event_rule_jul_logging_create();
281 ok(jul_logging, "jul_logging object.");
282
283 status = lttng_event_rule_jul_logging_set_name_pattern(jul_logging, pattern);
284 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
285 status = lttng_event_rule_jul_logging_get_name_pattern(jul_logging, &tmp);
286 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
287 ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
288
289 status = lttng_event_rule_jul_logging_set_filter(jul_logging, filter);
290 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
291 status = lttng_event_rule_jul_logging_get_filter(jul_logging, &tmp);
292 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
293 ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
294
295 status = lttng_event_rule_jul_logging_get_log_level_rule(jul_logging, &log_level_rule_return);
296 ok(status == LTTNG_EVENT_RULE_STATUS_UNSET, "get unset log level rule.");
297
298 status = lttng_event_rule_jul_logging_set_log_level_rule(
299 jul_logging, log_level_rule);
300 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting log level rule.");
301 status = lttng_event_rule_jul_logging_get_log_level_rule(
302 jul_logging, &log_level_rule_return);
303 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "get log level rule.");
304
305 ok(lttng_event_rule_serialize(jul_logging, &payload) == 0, "Serializing.");
306
307 {
308 struct lttng_payload_view view =
309 lttng_payload_view_from_payload(
310 &payload, 0, -1);
311
312 ok(lttng_event_rule_create_from_payload(
313 &view, &jul_logging_from_buffer) > 0,
314 "Deserializing.");
315 }
316
317 ok(lttng_event_rule_is_equal(jul_logging, jul_logging_from_buffer), "serialized and from buffer are equal.");
318
319 lttng_payload_reset(&payload);
320 lttng_event_rule_destroy(jul_logging);
321 lttng_event_rule_destroy(jul_logging_from_buffer);
322 lttng_log_level_rule_destroy(log_level_rule);
323}
324
138d6838
JR		 325static
326void test_event_rule_log4j_logging(void)
327{
328 struct lttng_event_rule *log4j_logging = NULL;
329 struct lttng_event_rule *log4j_logging_from_buffer = NULL;
330 enum lttng_event_rule_status status;
331 const char *pattern="my_event_*";
332 const char *filter="msg_id == 23 && size >= 2048";
333 const char *tmp;
334 struct lttng_log_level_rule *log_level_rule = NULL;
335 const struct lttng_log_level_rule *log_level_rule_return = NULL;
336 struct lttng_payload payload;
337
338 diag("Testing lttng_event_rule_user_log4j_logging.");
339
340 lttng_payload_init(&payload);
341
342 log_level_rule = lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO);
a0377dfe 343 LTTNG_ASSERT(log_level_rule);
138d6838
JR		 344
345 log4j_logging = lttng_event_rule_log4j_logging_create();
346 ok(log4j_logging, "log4j_logging object.");
347
348 status = lttng_event_rule_log4j_logging_set_name_pattern(log4j_logging, pattern);
349 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
350 status = lttng_event_rule_log4j_logging_get_name_pattern(log4j_logging, &tmp);
351 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
352 ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
353
354 status = lttng_event_rule_log4j_logging_set_filter(log4j_logging, filter);
355 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
356 status = lttng_event_rule_log4j_logging_get_filter(log4j_logging, &tmp);
357 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
358 ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
359
360 status = lttng_event_rule_log4j_logging_get_log_level_rule(log4j_logging, &log_level_rule_return);
361 ok(status == LTTNG_EVENT_RULE_STATUS_UNSET, "get unset log level rule.");
362
363 status = lttng_event_rule_log4j_logging_set_log_level_rule(
364 log4j_logging, log_level_rule);
365 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting log level rule.");
366 status = lttng_event_rule_log4j_logging_get_log_level_rule(
367 log4j_logging, &log_level_rule_return);
368 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "get log level rule.");
369
370 ok(lttng_event_rule_serialize(log4j_logging, &payload) == 0, "Serializing.");
371
372 {
373 struct lttng_payload_view view =
374 lttng_payload_view_from_payload(
375 &payload, 0, -1);
376
377 ok(lttng_event_rule_create_from_payload(
378 &view, &log4j_logging_from_buffer) > 0,
379 "Deserializing.");
380 }
381
382 ok(lttng_event_rule_is_equal(log4j_logging, log4j_logging_from_buffer), "serialized and from buffer are equal.");
383
384 lttng_payload_reset(&payload);
385 lttng_event_rule_destroy(log4j_logging);
386 lttng_event_rule_destroy(log4j_logging_from_buffer);
387 lttng_log_level_rule_destroy(log_level_rule);
388}
389
6530ec7d
JR		 390static
391void test_event_rule_python_logging(void)
392{
393 struct lttng_event_rule *python_logging = NULL;
394 struct lttng_event_rule *python_logging_from_buffer = NULL;
395 enum lttng_event_rule_status status;
396 const char *pattern="my_event_*";
397 const char *filter="msg_id == 23 && size >= 2048";
398 const char *tmp;
399 struct lttng_log_level_rule *log_level_rule = NULL;
400 const struct lttng_log_level_rule *log_level_rule_return = NULL;
401 struct lttng_payload payload;
402
403 diag("Testing lttng_event_rule_user_python_logging.");
404
405 lttng_payload_init(&payload);
406
407 log_level_rule = lttng_log_level_rule_exactly_create(LTTNG_LOGLEVEL_INFO);
a0377dfe 408 LTTNG_ASSERT(log_level_rule);
6530ec7d
JR		 409
410 python_logging = lttng_event_rule_python_logging_create();
411 ok(python_logging, "python_logging object.");
412
413 status = lttng_event_rule_python_logging_set_name_pattern(python_logging, pattern);
414 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern.");
415 status = lttng_event_rule_python_logging_get_name_pattern(python_logging, &tmp);
416 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern.");
417 ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal.");
418
419 status = lttng_event_rule_python_logging_set_filter(python_logging, filter);
420 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter.");
421 status = lttng_event_rule_python_logging_get_filter(python_logging, &tmp);
422 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter.");
423 ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal.");
424
425 status = lttng_event_rule_python_logging_get_log_level_rule(python_logging, &log_level_rule_return);
426 ok(status == LTTNG_EVENT_RULE_STATUS_UNSET, "get unset log level rule.");
427
428 status = lttng_event_rule_python_logging_set_log_level_rule(
429 python_logging, log_level_rule);
430 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting log level rule.");
431 status = lttng_event_rule_python_logging_get_log_level_rule(
432 python_logging, &log_level_rule_return);
433 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "get log level rule.");
434
435 ok(lttng_event_rule_serialize(python_logging, &payload) == 0, "Serializing.");
436
437 {
438 struct lttng_payload_view view =
439 lttng_payload_view_from_payload(
440 &payload, 0, -1);
441
442 ok(lttng_event_rule_create_from_payload(
443 &view, &python_logging_from_buffer) > 0,
444 "Deserializing.");
445 }
446
447 ok(lttng_event_rule_is_equal(python_logging, python_logging_from_buffer), "serialized and from buffer are equal.");
448
449 lttng_payload_reset(&payload);
450 lttng_event_rule_destroy(python_logging);
451 lttng_event_rule_destroy(python_logging_from_buffer);
452 lttng_log_level_rule_destroy(log_level_rule);
453}
454
93128834 455#ifdef __linux__
1f1567a5 456static void test_event_rule_userspace_probe(void)
dbc20d3c
JR		 457{
458 struct lttng_event_rule *uprobe = NULL;
459 struct lttng_event_rule *uprobe_from_buffer = NULL;
460 struct lttng_userspace_probe_location_lookup_method *lookup_method =
461 NULL;
462 struct lttng_userspace_probe_location *probe_location = NULL;
463 const struct lttng_userspace_probe_location *probe_location_tmp = NULL;
464 enum lttng_event_rule_status status;
465
466 const char *probe_name = "my_probe.";
467 const char *tmp;
468 struct lttng_payload payload;
469
470 diag("Event rule uprobe.");
6610d7be 471 lttng_payload_init(&payload);
dbc20d3c
JR		 472
473 lookup_method = lttng_userspace_probe_location_lookup_method_function_elf_create();
474 if (!lookup_method) {
475 fail("Setup error on userspace probe lookup method creation.");
476 goto end;
477 }
478
479 probe_location = lttng_userspace_probe_location_function_create(
480 "/proc/self/exe",
481 "lttng_userspace_probe_location_tracepoint_create",
482 lookup_method);
483 if (!probe_location) {
484 fail("Setup error on userspace probe location creation.");
485 goto end;
486 }
487
488 /* Ownership transferred to the probe location function object. */
489 lookup_method = NULL;
490
491 lttng_payload_init(&payload);
492
46fd07ac 493 uprobe = lttng_event_rule_kernel_uprobe_create(probe_location);
dbc20d3c
JR		 494 ok(uprobe, "uprobe event rule object creation.");
495
46fd07ac 496 status = lttng_event_rule_kernel_uprobe_get_location(
dbc20d3c
JR		 497 uprobe, &probe_location_tmp);
498 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
499 "Getting uprobe event rule location.");
500 ok(lttng_userspace_probe_location_is_equal(
501 probe_location, probe_location_tmp),
502 "Location is equal.");
503
46fd07ac 504 status = lttng_event_rule_kernel_uprobe_set_event_name(uprobe, probe_name);
dbc20d3c
JR		 505 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
506 "Setting uprobe event rule name: %s.", probe_name);
46fd07ac 507 status = lttng_event_rule_kernel_uprobe_get_event_name(uprobe, &tmp);
dbc20d3c
JR		 508 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "Getting uprobe name.");
509 ok(!strcmp(probe_name, tmp), "Uprobe name are equal.");
510
511 ok(lttng_event_rule_serialize(uprobe, &payload) == 0, "Serializing.");
512
513 {
514 struct lttng_payload_view view =
515 lttng_payload_view_from_payload(
516 &payload, 0, -1);
517
518 ok(lttng_event_rule_create_from_payload(
519 &view, &uprobe_from_buffer) > 0,
520 "Deserializing.");
521 }
522
523 ok(lttng_event_rule_is_equal(uprobe, uprobe_from_buffer),
524 "serialized and from buffer are equal.");
525
526end:
527 lttng_payload_reset(&payload);
528 lttng_event_rule_destroy(uprobe);
529 lttng_event_rule_destroy(uprobe_from_buffer);
530 lttng_userspace_probe_location_destroy(probe_location);
531 lttng_userspace_probe_location_lookup_method_destroy(lookup_method);
532}
93128834
MJ		 533#else
534static void test_event_rule_userspace_probe(void) {}
535#endif
dbc20d3c 536
f2791161 537static void test_event_rule_kernel_probe_by_location(
dbc20d3c
JR		 538 const struct lttng_kernel_probe_location *location)
539{
540 struct lttng_event_rule *kprobe = NULL;
541 struct lttng_event_rule *kprobe_from_buffer = NULL;
542 enum lttng_event_rule_status status;
543 const struct lttng_kernel_probe_location *_location;
544
545 const char *probe_name = "my_probe";
546 const char *tmp;
547 struct lttng_payload payload;
548
549 diag("Event rule kprobe for location type %d.",
550 lttng_kernel_probe_location_get_type(location));
551
552 lttng_payload_init(&payload);
553
85522de5 554 kprobe = lttng_event_rule_kernel_kprobe_create(location);
dbc20d3c
JR		 555 ok(kprobe, "kprobe event rule object creation.");
556
85522de5 557 status = lttng_event_rule_kernel_kprobe_get_location(kprobe, &_location);
dbc20d3c
JR		 558 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
559 "Getting kprobe event rule location.");
560 ok(lttng_kernel_probe_location_is_equal(location, _location), "Locations are equal.");
561
85522de5 562 status = lttng_event_rule_kernel_kprobe_set_event_name(kprobe, probe_name);
dbc20d3c
JR		 563 ok(status == LTTNG_EVENT_RULE_STATUS_OK,
564 "Setting kprobe event rule name: %s.", probe_name);
85522de5 565 status = lttng_event_rule_kernel_kprobe_get_event_name(kprobe, &tmp);
dbc20d3c
JR		 566 ok(status == LTTNG_EVENT_RULE_STATUS_OK, "Getting kprobe name.");
567 ok(!strcmp(probe_name, tmp), "kprobe name are equal.");
568
569 ok(lttng_event_rule_serialize(kprobe, &payload) == 0, "Serializing.");
570
571 {
572 struct lttng_payload_view view =
573 lttng_payload_view_from_payload(
574 &payload, 0, -1);
575
576 ok(lttng_event_rule_create_from_payload(
577 &view, &kprobe_from_buffer) > 0,
578 "Deserializing.");
579 }
580
581 ok(lttng_event_rule_is_equal(kprobe, kprobe_from_buffer),
582 "serialized and from buffer are equal.");
583
584 lttng_payload_reset(&payload);
585 lttng_event_rule_destroy(kprobe);
586 lttng_event_rule_destroy(kprobe_from_buffer);
587}
588
f2791161 589static void test_event_rule_kernel_probe(void)
dbc20d3c
JR		 590{
591 struct lttng_kernel_probe_location *address_location = NULL;
592 struct lttng_kernel_probe_location *symbol_location = NULL;
593
594 address_location = lttng_kernel_probe_location_address_create(50);
595 symbol_location = lttng_kernel_probe_location_symbol_create("une_bonne", 50);
a0377dfe
FD		 596 LTTNG_ASSERT(address_location);
597 LTTNG_ASSERT(symbol_location);
dbc20d3c 598
f2791161
JR		 599 test_event_rule_kernel_probe_by_location(address_location);
600 test_event_rule_kernel_probe_by_location(symbol_location);
dbc20d3c
JR		 601
602 lttng_kernel_probe_location_destroy(address_location);
603 lttng_kernel_probe_location_destroy(symbol_location);
604}
605
2b4c142d
JG		 606static void test_set_event_rule_log_level_rules(
607 struct lttng_event_rule *event_rule,
cade690d 608 event_rule_set_log_level set_log_level,
2b4c142d
JG		 609 int log_level,
610 enum lttng_event_rule_status *exactly_status,
611 enum lttng_event_rule_status *as_severe_status)
612{
613 struct lttng_log_level_rule *log_level_rule;
614
615 log_level_rule = lttng_log_level_rule_at_least_as_severe_as_create(
616 log_level);
a0377dfe 617 LTTNG_ASSERT(log_level_rule);
2b4c142d 618
cade690d 619 *as_severe_status = set_log_level(
2b4c142d
JG		 620 event_rule, log_level_rule);
621 lttng_log_level_rule_destroy(log_level_rule);
622
623 log_level_rule = lttng_log_level_rule_exactly_create(log_level);
a0377dfe 624 LTTNG_ASSERT(log_level_rule);
2b4c142d 625
cade690d 626 *exactly_status = set_log_level(
2b4c142d
JG		 627 event_rule, log_level_rule);
628 lttng_log_level_rule_destroy(log_level_rule);
629}
630
cade690d 631static void test_event_rule_log_level_generic(enum lttng_event_rule_type event_rule_type,
2b4c142d 632 log_level_name_getter get_log_level_name,
cade690d
JR		 633 event_rule_create create_event_rule,
634 event_rule_set_log_level set_log_level,
2b4c142d
JG		 635 const int tagged_log_level_values[],
636 size_t tagged_log_level_values_count,
637 const int valid_log_level_values[],
638 size_t valid_log_level_values_count,
639 const int invalid_log_level_values[],
640 size_t invalid_log_level_values_count)
641{
642 size_t i;
cade690d 643 struct lttng_event_rule *rule;
2b4c142d 644 enum lttng_event_rule_status er_exactly_status, er_as_severe_status;
cade690d
JR		 645 const char *event_rule_type_str = lttng_event_rule_type_str(event_rule_type);
646
2b4c142d 647
cade690d
JR		 648 diag("Test %s event rule + log level rule", event_rule_type_str);
649
650 rule = create_event_rule();
a0377dfe 651 LTTNG_ASSERT(rule);
2b4c142d
JG		 652
653 for (i = 0; i < tagged_log_level_values_count; i++) {
654 const int tagged_log_level_value = tagged_log_level_values[i];
655
cade690d 656 test_set_event_rule_log_level_rules(rule, set_log_level,
2b4c142d
JG		 657 tagged_log_level_value,
658 &er_exactly_status, &er_as_severe_status);
659 ok(er_exactly_status == LTTNG_EVENT_RULE_STATUS_OK,
cade690d
JR		 660 "Log level rule \"exactly\" accepted by %s event rule: level = %s",
661 event_rule_type_str,
2b4c142d
JG		 662 get_log_level_name(
663 tagged_log_level_value));
664 ok(er_as_severe_status == LTTNG_EVENT_RULE_STATUS_OK,
cade690d
JR		 665 "Log level rule \"as least as severe as\" accepted by %s event rule: level = %s",
666 event_rule_type_str,
2b4c142d
JG		 667 get_log_level_name(
668 tagged_log_level_value));
669 }
670
671 for (i = 0; i < valid_log_level_values_count; i++) {
672 const int valid_log_level_value = valid_log_level_values[i];
673
cade690d 674 test_set_event_rule_log_level_rules(rule, set_log_level,
2b4c142d
JG		 675 valid_log_level_value,
676 &er_exactly_status, &er_as_severe_status);
677 ok(er_exactly_status == LTTNG_EVENT_RULE_STATUS_OK,
cade690d
JR		 678 "Log level rule \"exactly\" accepted by %s event rule: level = %d",
679 event_rule_type_str,
2b4c142d
JG		 680 valid_log_level_value);
681 ok(er_as_severe_status == LTTNG_EVENT_RULE_STATUS_OK,
cade690d
JR		 682 "Log level rule \"as least as severe as\" accepted by %s event rule: level = %d",
683 event_rule_type_str,
2b4c142d
JG		 684 valid_log_level_value);
685 }
686
687 for (i = 0; i < invalid_log_level_values_count; i++) {
688 const int invalid_log_level_value = invalid_log_level_values[i];
689
cade690d 690 test_set_event_rule_log_level_rules(rule, set_log_level,
2b4c142d
JG		 691 invalid_log_level_value,
692 &er_exactly_status, &er_as_severe_status);
693 ok(er_exactly_status == LTTNG_EVENT_RULE_STATUS_INVALID,
cade690d
JR		 694 "Log level rule \"exactly\" rejected by %s event rule: level = %d",
695 event_rule_type_str,
2b4c142d
JG		 696 invalid_log_level_value);
697 ok(er_as_severe_status == LTTNG_EVENT_RULE_STATUS_INVALID,
cade690d
JR		 698 "Log level rule \"as least as severe as\" rejected by %s event rule: level = %d",
699 event_rule_type_str,
2b4c142d
JG		 700 invalid_log_level_value);
701 }
702
cade690d 703 lttng_event_rule_destroy(rule);
2b4c142d
JG		 704}
705
706static void test_event_rule_log_level_ust(void)
707{
708 const int tagged_log_level_values[] = {
709 LTTNG_LOGLEVEL_EMERG,
710 LTTNG_LOGLEVEL_ALERT,
711 LTTNG_LOGLEVEL_CRIT,
712 LTTNG_LOGLEVEL_ERR,
713 LTTNG_LOGLEVEL_WARNING,
714 LTTNG_LOGLEVEL_NOTICE,
715 LTTNG_LOGLEVEL_INFO,
716 LTTNG_LOGLEVEL_DEBUG_SYSTEM,
717 LTTNG_LOGLEVEL_DEBUG_PROGRAM,
718 LTTNG_LOGLEVEL_DEBUG_PROCESS,
719 LTTNG_LOGLEVEL_DEBUG_MODULE,
720 LTTNG_LOGLEVEL_DEBUG_UNIT,
721 LTTNG_LOGLEVEL_DEBUG_FUNCTION,
722 LTTNG_LOGLEVEL_DEBUG_LINE,
723 LTTNG_LOGLEVEL_DEBUG,
724 };
725 const int invalid_log_level_values[] = {
726 -1980,
727 1995,
728 LTTNG_LOGLEVEL_DEBUG + 1,
729 LTTNG_LOGLEVEL_EMERG - 1,
730 };
731
cade690d
JR		 732 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT,
733 loglevel_value_to_name,
734 lttng_event_rule_user_tracepoint_create,
735 lttng_event_rule_user_tracepoint_set_log_level_rule,
736 tagged_log_level_values,
737 ARRAY_SIZE(tagged_log_level_values), NULL, 0,
2b4c142d
JG		 738 invalid_log_level_values,
739 ARRAY_SIZE(invalid_log_level_values));
740}
741
742static void test_event_rule_log_level_jul(void)
743{
744 const int tagged_log_level_values[] = {
745 LTTNG_LOGLEVEL_JUL_OFF,
746 LTTNG_LOGLEVEL_JUL_SEVERE,
747 LTTNG_LOGLEVEL_JUL_WARNING,
748 LTTNG_LOGLEVEL_JUL_INFO,
749 LTTNG_LOGLEVEL_JUL_CONFIG,
750 LTTNG_LOGLEVEL_JUL_FINE,
751 LTTNG_LOGLEVEL_JUL_FINER,
752 LTTNG_LOGLEVEL_JUL_FINEST,
753 LTTNG_LOGLEVEL_JUL_ALL,
754 };
755 const int valid_log_level_values[] = {
756 0,
757 -1980,
758 1995
759 };
760
cade690d
JR		 761 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_JUL_LOGGING,
762 loglevel_jul_value_to_name,
763 lttng_event_rule_jul_logging_create,
764 lttng_event_rule_jul_logging_set_log_level_rule,
765 tagged_log_level_values,
2b4c142d
JG		 766 ARRAY_SIZE(tagged_log_level_values),
767 valid_log_level_values,
768 ARRAY_SIZE(valid_log_level_values), NULL, 0);
769}
770
771static void test_event_rule_log_level_log4j(void)
772{
773 const int tagged_log_level_values[] = {
774 LTTNG_LOGLEVEL_LOG4J_OFF,
775 LTTNG_LOGLEVEL_LOG4J_FATAL,
776 LTTNG_LOGLEVEL_LOG4J_ERROR,
777 LTTNG_LOGLEVEL_LOG4J_WARN,
778 LTTNG_LOGLEVEL_LOG4J_INFO,
779 LTTNG_LOGLEVEL_LOG4J_DEBUG,
780 LTTNG_LOGLEVEL_LOG4J_TRACE,
781 LTTNG_LOGLEVEL_LOG4J_ALL,
782 };
783 const int valid_log_level_values[] = {
784 0
785 -1980,
786 1995
787 };
788
cade690d
JR		 789 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING,
790 loglevel_log4j_value_to_name,
791 lttng_event_rule_log4j_logging_create,
792 lttng_event_rule_log4j_logging_set_log_level_rule,
793 tagged_log_level_values,
2b4c142d
JG		 794 ARRAY_SIZE(tagged_log_level_values),
795 valid_log_level_values,
796 ARRAY_SIZE(valid_log_level_values), NULL, 0);
797}
798
799static void test_event_rule_log_level_python(void)
800{
801 const int tagged_log_level_values[] = {
802 LTTNG_LOGLEVEL_PYTHON_CRITICAL,
803 LTTNG_LOGLEVEL_PYTHON_ERROR,
804 LTTNG_LOGLEVEL_PYTHON_WARNING,
805 LTTNG_LOGLEVEL_PYTHON_INFO,
806 LTTNG_LOGLEVEL_PYTHON_DEBUG,
807 LTTNG_LOGLEVEL_PYTHON_NOTSET,
808 };
809 const int valid_log_level_values[] = {
810 45,
811 35,
812 0,
813 -657,
814 };
815
cade690d
JR		 816 test_event_rule_log_level_generic(LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING,
817 loglevel_python_value_to_name,
818 lttng_event_rule_python_logging_create,
819 lttng_event_rule_python_logging_set_log_level_rule,
820 tagged_log_level_values,
2b4c142d
JG		 821 ARRAY_SIZE(tagged_log_level_values),
822 valid_log_level_values,
823 ARRAY_SIZE(valid_log_level_values),
824 NULL, 0);
825}
826
f46376a1 827int main(void)
dbc20d3c
JR		 828{
829 plan_tests(NUM_TESTS);
af0818ef 830 test_event_rule_kernel_tracepoint();
0a23a07d 831 test_event_rule_user_tracepoint();
dbc20d3c 832 test_event_rule_syscall();
1f1567a5 833 test_event_rule_userspace_probe();
f2791161 834 test_event_rule_kernel_probe();
138d6838 835 test_event_rule_log4j_logging();
b47b01d8 836 test_event_rule_jul_logging();
6530ec7d 837 test_event_rule_python_logging();
2b4c142d
JG		 838 test_event_rule_log_level_ust();
839 test_event_rule_log_level_jul();
840 test_event_rule_log_level_log4j();
841 test_event_rule_log_level_python();
dbc20d3c
JR		 842 return exit_status();
843}
LTTng 2.0 tools and control repository
This page took 0.068544 seconds and 4 git commands to generate.