projects / deliverable / lttng-tools.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix: lttng: list-trigger: leak of error query in query callbacks
[deliverable/lttng-tools.git] / src / bin / lttng / commands / list_triggers.c
CommitLineData
0de2479d
SM		 1/*
2 * Copyright (C) 2021 Simon Marchi <simon.marchi@efficios.com>
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 */
7
8#include <stdio.h>
9
10#include "../command.h"
11
12#include "common/argpar/argpar.h"
13#include "common/dynamic-array.h"
14#include "common/mi-lttng.h"
15/* For lttng_condition_type_str(). */
16#include "lttng/condition/condition-internal.h"
670a26e4
JR		 17#include "lttng/condition/event-rule-matches.h"
18#include "lttng/condition/event-rule-matches-internal.h"
0de2479d
SM		 19/* For lttng_domain_type_str(). */
20#include "lttng/domain-internal.h"
4f7da553
JR		 21/* For lttng_event_rule_kernel_syscall_emission_site_str() */
22#include "lttng/event-rule/kernel-syscall-internal.h"
85b05318 23#include "../loglevel.h"
709fb83f 24#include <lttng/lttng.h>
0de2479d
SM		 25
26#ifdef LTTNG_EMBED_HELP
27static const char help_msg[] =
279eb769 28#include <lttng-list-triggers.1.h>
0de2479d
SM		 29;
30#endif
31
63dd3d7b
JG		 32#define INDENTATION_LEVEL_STR " "
33
695f7044
JR		 34typedef enum lttng_event_rule_status (*event_rule_logging_get_name_pattern)(
35 const struct lttng_event_rule *rule, const char **pattern);
36typedef enum lttng_event_rule_status (*event_rule_logging_get_filter)(
37 const struct lttng_event_rule *rule, const char **expression);
38typedef enum lttng_event_rule_status (*event_rule_logging_get_log_level_rule)(
39 const struct lttng_event_rule *rule,
40 const struct lttng_log_level_rule **log_level_rule);
41
0de2479d
SM		 42enum {
43 OPT_HELP,
44 OPT_LIST_OPTIONS,
45};
46
47static const
48struct argpar_opt_descr list_trigger_options[] = {
49 { OPT_HELP, 'h', "help", false },
50 { OPT_LIST_OPTIONS, '\0', "list-options", false },
51 ARGPAR_OPT_DESCR_SENTINEL,
52};
53
19904669
SM		 54static void print_condition_session_consumed_size(
55 const struct lttng_condition *condition)
56{
57 enum lttng_condition_status condition_status;
58 const char *session_name;
59 uint64_t threshold;
60
61 condition_status =
62 lttng_condition_session_consumed_size_get_session_name(
63 condition, &session_name);
64 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
65
66 lttng_condition_session_consumed_size_get_threshold(
67 condition, &threshold);
68 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
69
70 MSG(" session name: %s", session_name);
71 MSG(" threshold: %" PRIu64 " bytes", threshold);
72}
73
74static void print_condition_buffer_usage(
75 const struct lttng_condition *condition)
76{
77 enum lttng_condition_status condition_status;
78 const char *session_name, *channel_name;
79 enum lttng_domain_type domain_type;
80 uint64_t threshold;
81
82 condition_status = lttng_condition_buffer_usage_get_session_name(
83 condition, &session_name);
84 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
85
86 condition_status = lttng_condition_buffer_usage_get_channel_name(
87 condition, &channel_name);
88 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
89
90 condition_status = lttng_condition_buffer_usage_get_domain_type(
91 condition, &domain_type);
92 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
93
94 MSG(" session name: %s", session_name);
95 MSG(" channel name: %s", channel_name);
96 MSG(" domain: %s", lttng_domain_type_str(domain_type));
97
98 condition_status = lttng_condition_buffer_usage_get_threshold(
99 condition, &threshold);
100 if (condition_status == LTTNG_CONDITION_STATUS_OK) {
101 MSG(" threshold (bytes): %" PRIu64, threshold);
102 } else {
103 double threshold_ratio;
104
105 assert(condition_status == LTTNG_CONDITION_STATUS_UNSET);
106
107 condition_status =
108 lttng_condition_buffer_usage_get_threshold_ratio(
109 condition, &threshold_ratio);
110 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
111
112 MSG(" threshold (ratio): %.2f", threshold_ratio);
113 }
114}
115
116static void print_condition_session_rotation(
117 const struct lttng_condition *condition)
118{
119 enum lttng_condition_status condition_status;
120 const char *session_name;
121
122 condition_status = lttng_condition_session_rotation_get_session_name(
123 condition, &session_name);
124 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
125
126 MSG(" session name: %s", session_name);
127}
128
85b05318
JR		 129/*
130 * Returns the human-readable log level name associated with a numerical value
695f7044 131 * if there is one. The Log4j and JUL event rule have discontinuous log level
85b05318
JR		 132 * values (a value can fall between two labels). In those cases, NULL is
133 * returned.
134 */
135static const char *get_pretty_loglevel_name(
695f7044 136 enum lttng_event_rule_type event_rule_type, int loglevel)
85b05318
JR		 137{
138 const char *name = NULL;
139
695f7044
JR		 140 switch (event_rule_type) {
141 case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT:
85b05318
JR		 142 name = loglevel_value_to_name(loglevel);
143 break;
695f7044 144 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
85b05318
JR		 145 name = loglevel_log4j_value_to_name(loglevel);
146 break;
695f7044 147 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
85b05318
JR		 148 name = loglevel_jul_value_to_name(loglevel);
149 break;
695f7044 150 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
85b05318
JR		 151 name = loglevel_python_value_to_name(loglevel);
152 break;
153 default:
154 break;
155 }
156
157 return name;
158}
159
0de2479d 160static
695f7044 161void print_event_rule_user_tracepoint(const struct lttng_event_rule *event_rule)
0de2479d
SM		 162{
163 enum lttng_event_rule_status event_rule_status;
0de2479d
SM		 164 const char *pattern;
165 const char *filter;
166 int log_level;
85b05318 167 const struct lttng_log_level_rule *log_level_rule = NULL;
0de2479d
SM		 168 unsigned int exclusions_count;
169 int i;
170
695f7044 171 event_rule_status = lttng_event_rule_user_tracepoint_get_name_pattern(
0de2479d
SM		 172 event_rule, &pattern);
173 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK);
174
695f7044 175 _MSG(" rule: %s (type: user tracepoint", pattern);
0de2479d 176
695f7044 177 event_rule_status = lttng_event_rule_user_tracepoint_get_filter(
0de2479d
SM		 178 event_rule, &filter);
179 if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) {
180 _MSG(", filter: %s", filter);
181 } else {
182 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
183 }
184
695f7044 185 event_rule_status = lttng_event_rule_user_tracepoint_get_log_level_rule(
85b05318 186 event_rule, &log_level_rule);
0de2479d 187 if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) {
85b05318 188 enum lttng_log_level_rule_status llr_status;
0de2479d 189 const char *log_level_op;
85b05318
JR		 190 const char *pretty_loglevel_name;
191
192 switch (lttng_log_level_rule_get_type(log_level_rule)) {
193 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
194 log_level_op = "is";
195 llr_status = lttng_log_level_rule_exactly_get_level(
196 log_level_rule, &log_level);
197 break;
198 case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS:
199 log_level_op = "at least";
200 llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level(
201 log_level_rule, &log_level);
202 break;
203 default:
204 abort();
205 }
206
207 assert(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK);
208
209 pretty_loglevel_name = get_pretty_loglevel_name(
695f7044 210 LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT, log_level);
85b05318
JR		 211 if (pretty_loglevel_name) {
212 _MSG(", log level %s %s", log_level_op,
213 pretty_loglevel_name);
214 } else {
215 _MSG(", log level %s %d", log_level_op, log_level);
216 }
0de2479d
SM		 217 } else {
218 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
219 }
220
695f7044 221 event_rule_status = lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_count(
0de2479d
SM		 222 event_rule, &exclusions_count);
223 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK);
224 if (exclusions_count > 0) {
225 _MSG(", exclusions: ");
226 for (i = 0; i < exclusions_count; i++) {
227 const char *exclusion;
228
695f7044 229 event_rule_status = lttng_event_rule_user_tracepoint_get_name_pattern_exclusion_at_index(
0de2479d
SM		 230 event_rule, i, &exclusion);
231 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK);
232
233 _MSG("%s%s", i > 0 ? "," : "", exclusion);
234 }
235 }
236
237 MSG(")");
238}
239
695f7044
JR		 240static
241void print_event_rule_kernel_tracepoint(const struct lttng_event_rule *event_rule)
242{
243 enum lttng_event_rule_status event_rule_status;
244 const char *pattern;
245 const char *filter;
246
247 event_rule_status = lttng_event_rule_kernel_tracepoint_get_name_pattern(
248 event_rule, &pattern);
249 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK);
250
251 _MSG(" rule: %s (type: kernel tracepoint", pattern);
252
253 event_rule_status = lttng_event_rule_kernel_tracepoint_get_filter(
254 event_rule, &filter);
255 if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) {
256 _MSG(", filter: %s", filter);
257 } else {
258 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
259 }
260
261 MSG(")");
262}
263
264static
265void print_event_rule_logging(const struct lttng_event_rule *event_rule)
266{
267 enum lttng_event_rule_status event_rule_status;
268 enum lttng_event_rule_type event_rule_type = lttng_event_rule_get_type(event_rule);
269 const char *pattern;
270 const char *filter;
271 int log_level;
272 const struct lttng_log_level_rule *log_level_rule = NULL;
273 const char *type_str = NULL;
274
275 event_rule_logging_get_name_pattern logging_get_name_pattern;
276 event_rule_logging_get_filter logging_get_filter;
277 event_rule_logging_get_log_level_rule logging_get_log_level_rule;
278
279 switch (event_rule_type) {
280 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
281 logging_get_name_pattern =
282 lttng_event_rule_jul_logging_get_name_pattern;
283 logging_get_filter = lttng_event_rule_jul_logging_get_filter;
284 logging_get_log_level_rule =
285 lttng_event_rule_jul_logging_get_log_level_rule;
286 type_str = "jul";
287 break;
288 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
289 logging_get_name_pattern =
290 lttng_event_rule_log4j_logging_get_name_pattern;
291 logging_get_filter = lttng_event_rule_log4j_logging_get_filter;
292 logging_get_log_level_rule =
293 lttng_event_rule_log4j_logging_get_log_level_rule;
294 type_str = "log4j";
295 break;
296 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
297 logging_get_name_pattern =
298 lttng_event_rule_python_logging_get_name_pattern;
299 logging_get_filter = lttng_event_rule_python_logging_get_filter;
300 logging_get_log_level_rule =
301 lttng_event_rule_python_logging_get_log_level_rule;
302 type_str = "python";
303 break;
304 default:
305 abort();
306 break;
307 }
308
309 event_rule_status = logging_get_name_pattern(
310 event_rule, &pattern);
311 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK);
312
313 _MSG(" rule: %s (type: %s:logging", pattern, type_str);
314
315 event_rule_status = logging_get_filter(
316 event_rule, &filter);
317 if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) {
318 _MSG(", filter: %s", filter);
319 } else {
320 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
321 }
322
323 event_rule_status = logging_get_log_level_rule(
324 event_rule, &log_level_rule);
325 if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) {
326 enum lttng_log_level_rule_status llr_status;
327 const char *log_level_op;
328 const char *pretty_loglevel_name;
329
330 switch (lttng_log_level_rule_get_type(log_level_rule)) {
331 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
332 log_level_op = "is";
333 llr_status = lttng_log_level_rule_exactly_get_level(
334 log_level_rule, &log_level);
335 break;
336 case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS:
337 log_level_op = "at least";
338 llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level(
339 log_level_rule, &log_level);
340 break;
341 default:
342 abort();
343 }
344
345 assert(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK);
346
347 pretty_loglevel_name = get_pretty_loglevel_name(
348 event_rule_type, log_level);
349 if (pretty_loglevel_name) {
350 _MSG(", log level %s %s", log_level_op,
351 pretty_loglevel_name);
352 } else {
353 _MSG(", log level %s %d", log_level_op, log_level);
354 }
355 } else {
356 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
357 }
358
359 MSG(")");
360}
361
0de2479d
SM		 362static void print_kernel_probe_location(
363 const struct lttng_kernel_probe_location *location)
364{
365 enum lttng_kernel_probe_location_status status;
366 switch (lttng_kernel_probe_location_get_type(location)) {
367 case LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS:
368 {
369 uint64_t address;
370
371 status = lttng_kernel_probe_location_address_get_address(
372 location, &address);
373 if (status != LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK) {
374 ERR("Getting kernel probe location address failed.");
375 goto end;
376 }
377
378 _MSG("0x%" PRIx64, address);
379
380 break;
381 }
382 case LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET:
383 {
384 uint64_t offset;
385 const char *symbol_name;
386
387 symbol_name = lttng_kernel_probe_location_symbol_get_name(
388 location);
389 if (!symbol_name) {
390 ERR("Getting kernel probe location symbol name failed.");
391 goto end;
392 }
393
394 status = lttng_kernel_probe_location_symbol_get_offset(
395 location, &offset);
396 if (status != LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK) {
397 ERR("Getting kernel probe location address failed.");
398 goto end;
399 }
400
401 if (offset == 0) {
402 _MSG("%s", symbol_name);
403 } else {
404 _MSG("%s+0x%" PRIx64, symbol_name, offset);
405 }
406
407 break;
408 }
409 default:
410 abort();
411 };
412end:
413 return;
414}
415
416static
f2791161 417void print_event_rule_kernel_probe(const struct lttng_event_rule *event_rule)
0de2479d
SM		 418{
419 enum lttng_event_rule_status event_rule_status;
420 const char *name;
421 const struct lttng_kernel_probe_location *location;
422
85522de5 423 assert(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE);
0de2479d 424
85522de5 425 event_rule_status = lttng_event_rule_kernel_kprobe_get_event_name(event_rule, &name);
0de2479d
SM		 426 if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
427 ERR("Failed to get kprobe event rule's name.");
428 goto end;
429 }
430
85522de5 431 event_rule_status = lttng_event_rule_kernel_kprobe_get_location(
0de2479d
SM		 432 event_rule, &location);
433 if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
434 ERR("Failed to get kprobe event rule's location.");
435 goto end;
436 }
437
85522de5 438 _MSG(" rule: %s (type: kernel:kprobe, location: ", name);
0de2479d
SM		 439
440 print_kernel_probe_location(location);
441
442 MSG(")");
443
444end:
445 return;
446}
447
448static
1f1567a5 449void print_event_rule_userspace_probe(const struct lttng_event_rule *event_rule)
0de2479d
SM		 450{
451 enum lttng_event_rule_status event_rule_status;
452 const char *name;
453 const struct lttng_userspace_probe_location *location;
454 enum lttng_userspace_probe_location_type userspace_probe_location_type;
455
46fd07ac 456 assert(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE);
0de2479d 457
46fd07ac 458 event_rule_status = lttng_event_rule_kernel_uprobe_get_event_name(
405f9e7d 459 event_rule, &name);
0de2479d
SM		 460 if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
461 ERR("Failed to get uprobe event rule's name.");
462 goto end;
463 }
464
46fd07ac 465 event_rule_status = lttng_event_rule_kernel_uprobe_get_location(
0de2479d
SM		 466 event_rule, &location);
467 if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
468 ERR("Failed to get uprobe event rule's location.");
469 goto end;
470 }
471
46fd07ac 472 _MSG(" rule: %s (type: kernel:uprobe, ", name);
0de2479d
SM		 473
474 userspace_probe_location_type =
475 lttng_userspace_probe_location_get_type(location);
476
477 switch (userspace_probe_location_type) {
478 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
479 {
480 const char *binary_path, *function_name;
481
482 binary_path = lttng_userspace_probe_location_function_get_binary_path(
483 location);
484 function_name = lttng_userspace_probe_location_function_get_function_name(
485 location);
486
8a917ae8 487 _MSG("location type: ELF, location: %s:%s", binary_path, function_name);
0de2479d
SM		 488 break;
489 }
490 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT:
8a917ae8
FD		 491 {
492 const char *binary_path, *provider_name, *probe_name;
493
494 binary_path = lttng_userspace_probe_location_tracepoint_get_binary_path(
495 location);
496 provider_name = lttng_userspace_probe_location_tracepoint_get_provider_name(
497 location);
498 probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(
499 location);
500 _MSG("location type: SDT, location: %s:%s:%s", binary_path, provider_name, probe_name);
0de2479d 501 break;
8a917ae8 502 }
0de2479d
SM		 503 default:
504 abort();
505 }
506
507 MSG(")");
508
509end:
510 return;
511}
512
513static
514void print_event_rule_syscall(const struct lttng_event_rule *event_rule)
515{
516 const char *pattern, *filter;
517 enum lttng_event_rule_status event_rule_status;
4f7da553 518 enum lttng_event_rule_kernel_syscall_emission_site emission_site;
0de2479d 519
4f7da553 520 assert(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL);
0de2479d 521
f6a5af19 522 emission_site =
4f7da553 523 lttng_event_rule_kernel_syscall_get_emission_site(event_rule);
57739a6b 524
4f7da553 525 event_rule_status = lttng_event_rule_kernel_syscall_get_name_pattern(
0de2479d
SM		 526 event_rule, &pattern);
527 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK);
528
4f7da553
JR		 529 _MSG(" rule: %s (type: kernel:syscall:%s", pattern,
530 lttng_event_rule_kernel_syscall_emission_site_str(
f6a5af19 531 emission_site));
0de2479d 532
4f7da553 533 event_rule_status = lttng_event_rule_kernel_syscall_get_filter(
0de2479d
SM		 534 event_rule, &filter);
535 if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) {
536 _MSG(", filter: %s", filter);
537 } else {
538 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
539 }
540
541 MSG(")");
542}
543
544static
545void print_event_rule(const struct lttng_event_rule *event_rule)
546{
547 const enum lttng_event_rule_type event_rule_type =
548 lttng_event_rule_get_type(event_rule);
549
550 switch (event_rule_type) {
695f7044
JR		 551 case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT:
552 print_event_rule_user_tracepoint(event_rule);
553 break;
554 case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT:
555 print_event_rule_kernel_tracepoint(event_rule);
556 break;
557 case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
558 case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
559 case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
560 print_event_rule_logging(event_rule);
0de2479d 561 break;
85522de5 562 case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
f2791161 563 print_event_rule_kernel_probe(event_rule);
0de2479d 564 break;
46fd07ac 565 case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
1f1567a5 566 print_event_rule_userspace_probe(event_rule);
0de2479d 567 break;
4f7da553 568 case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
0de2479d
SM		 569 print_event_rule_syscall(event_rule);
570 break;
571 default:
572 abort();
573 }
574}
575
b203b4b0
SM		 576static
577void print_one_event_expr(const struct lttng_event_expr *event_expr)
578{
579 enum lttng_event_expr_type type;
580
581 type = lttng_event_expr_get_type(event_expr);
582
583 switch (type) {
584 case LTTNG_EVENT_EXPR_TYPE_EVENT_PAYLOAD_FIELD:
585 {
586 const char *name;
587
588 name = lttng_event_expr_event_payload_field_get_name(
589 event_expr);
590 _MSG("%s", name);
591
592 break;
593 }
594 case LTTNG_EVENT_EXPR_TYPE_CHANNEL_CONTEXT_FIELD:
595 {
596 const char *name;
597
598 name = lttng_event_expr_channel_context_field_get_name(
599 event_expr);
600 _MSG("$ctx.%s", name);
601
602 break;
603 }
604 case LTTNG_EVENT_EXPR_TYPE_APP_SPECIFIC_CONTEXT_FIELD:
605 {
606 const char *provider_name;
607 const char *type_name;
608
609 provider_name = lttng_event_expr_app_specific_context_field_get_provider_name(
610 event_expr);
611 type_name = lttng_event_expr_app_specific_context_field_get_type_name(
612 event_expr);
613
614 _MSG("$app.%s:%s", provider_name, type_name);
615
616 break;
617 }
618 case LTTNG_EVENT_EXPR_TYPE_ARRAY_FIELD_ELEMENT:
619 {
620 unsigned int index;
621 const struct lttng_event_expr *parent_expr;
622 enum lttng_event_expr_status status;
623
624 parent_expr = lttng_event_expr_array_field_element_get_parent_expr(
625 event_expr);
626 assert(parent_expr != NULL);
627
628 print_one_event_expr(parent_expr);
629
630 status = lttng_event_expr_array_field_element_get_index(
631 event_expr, &index);
632 assert(status == LTTNG_EVENT_EXPR_STATUS_OK);
633
634 _MSG("[%u]", index);
635
636 break;
637 }
638 default:
639 abort();
640 }
641}
642
63dd3d7b
JG		 643static
644void print_indentation(unsigned int indentation_level)
645{
646 unsigned int i;
647
648 for (i = 0; i < indentation_level; i++) {
649 _MSG(INDENTATION_LEVEL_STR);
650 }
651}
652
653static
654void print_error_query_results(struct lttng_error_query_results *results,
655 unsigned int base_indentation_level)
656{
657 unsigned int i, count, printed_errors_count = 0;
658 enum lttng_error_query_results_status results_status;
659
660 results_status = lttng_error_query_results_get_count(results, &count);
661 assert(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK);
662
663 assert(results);
664
665 print_indentation(base_indentation_level);
666 _MSG("errors:");
667
668 for (i = 0; i < count; i++) {
669 const struct lttng_error_query_result *result;
670 enum lttng_error_query_result_status result_status;
671 const char *result_name;
672 const char *result_description;
673 uint64_t result_value;
674
675 results_status = lttng_error_query_results_get_result(
676 results, &result, i);
677 assert(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK);
678
679 result_status = lttng_error_query_result_get_name(
680 result, &result_name);
681 assert(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
682 result_status = lttng_error_query_result_get_description(
683 result, &result_description);
684 assert(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
685
686
687 if (lttng_error_query_result_get_type(result) ==
688 LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER) {
689 result_status = lttng_error_query_result_counter_get_value(
690 result, &result_value);
691 assert(result_status ==
692 LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
693 if (result_value == 0) {
694 continue;
695 }
696
697 MSG("");
698 print_indentation(base_indentation_level + 1);
699
700 _MSG("%s: %" PRIu64, result_name, result_value);
701 printed_errors_count++;
702 } else {
703 MSG("");
704 print_indentation(base_indentation_level + 1);
705 _MSG("Unknown error query result type for result '%s' (%s)",
706 result_name, result_description);
707 continue;
708 }
709 }
710
711 if (printed_errors_count == 0) {
712 _MSG(" none");
713 }
714}
715
8dbb86b8
JR		 716static void print_condition_event_rule_matches(
717 const struct lttng_condition *condition)
0de2479d
SM		 718{
719 const struct lttng_event_rule *event_rule;
720 enum lttng_condition_status condition_status;
b203b4b0 721 unsigned int cap_desc_count, i;
0de2479d 722
8dbb86b8
JR		 723 condition_status = lttng_condition_event_rule_matches_get_rule(
724 condition, &event_rule);
0de2479d
SM		 725 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
726
727 print_event_rule(event_rule);
b203b4b0
SM		 728
729 condition_status =
8dbb86b8 730 lttng_condition_event_rule_matches_get_capture_descriptor_count(
b203b4b0
SM		 731 condition, &cap_desc_count);
732 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
733
734 if (cap_desc_count > 0) {
735 MSG(" captures:");
736
737 for (i = 0; i < cap_desc_count; i++) {
738 const struct lttng_event_expr *cap_desc =
8dbb86b8 739 lttng_condition_event_rule_matches_get_capture_descriptor_at_index(
b203b4b0
SM		 740 condition, i);
741
742 _MSG(" - ");
743 print_one_event_expr(cap_desc);
744 MSG("");
745 }
746 }
0de2479d
SM		 747}
748
cb9222ff
JG		 749static void print_action_errors(const struct lttng_trigger *trigger,
750 const struct lttng_action *action,
751 const uint64_t *action_path_indexes,
752 size_t action_path_length)
709fb83f 753{
709fb83f 754 enum lttng_error_code error_query_ret;
709fb83f
JG		 755 struct lttng_error_query_results *results = NULL;
756 const char *trigger_name;
757 uid_t trigger_uid;
758 enum lttng_trigger_status trigger_status;
cb9222ff
JG		 759 struct lttng_error_query *query;
760 struct lttng_action_path *action_path = lttng_action_path_create(
761 action_path_indexes, action_path_length);
762
763 assert(action_path);
709fb83f 764
cb9222ff 765 query = lttng_error_query_action_create(trigger, action_path);
709fb83f
JG		 766 assert(query);
767
768 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
0efb2ad7
JG		 769 /*
770 * Anonymous triggers are not listed; this would be an internal error.
771 */
709fb83f
JG		 772 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
773
774 trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid);
775 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
776
777 error_query_ret = lttng_error_query_execute(
778 query, lttng_session_daemon_command_endpoint, &results);
779 if (error_query_ret != LTTNG_OK) {
780 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
781 trigger_name, (int) trigger_uid,
782 lttng_strerror(-error_query_ret));
783 goto end;
784 }
785
63dd3d7b 786 print_error_query_results(results, 3);
709fb83f
JG		 787
788end:
789 MSG("");
790 lttng_error_query_destroy(query);
791 lttng_error_query_results_destroy(results);
cb9222ff 792 lttng_action_path_destroy(action_path);
709fb83f
JG		 793}
794
795static
796void print_one_action(const struct lttng_trigger *trigger,
cb9222ff
JG		 797 const struct lttng_action *action,
798 const uint64_t *action_path_indexes,
799 size_t action_path_length)
0de2479d
SM		 800{
801 enum lttng_action_type action_type;
802 enum lttng_action_status action_status;
7f4d5b07 803 const struct lttng_rate_policy *policy = NULL;
0de2479d
SM		 804 const char *value;
805
806 action_type = lttng_action_get_type(action);
7c2fae7c 807 assert(action_type != LTTNG_ACTION_TYPE_LIST);
0de2479d
SM		 808
809 switch (action_type) {
810 case LTTNG_ACTION_TYPE_NOTIFY:
e45dd625
JR		 811 _MSG("notify");
812
7f4d5b07 813 action_status = lttng_action_notify_get_rate_policy(
e45dd625
JR		 814 action, &policy);
815 if (action_status != LTTNG_ACTION_STATUS_OK) {
7f4d5b07 816 ERR("Failed to retrieve rate policy.");
e45dd625
JR		 817 goto end;
818 }
0de2479d
SM		 819 break;
820 case LTTNG_ACTION_TYPE_START_SESSION:
821 action_status = lttng_action_start_session_get_session_name(
822 action, &value);
823 assert(action_status == LTTNG_ACTION_STATUS_OK);
e45dd625
JR		 824 _MSG("start session `%s`", value);
825
7f4d5b07 826 action_status = lttng_action_start_session_get_rate_policy(
e45dd625
JR		 827 action, &policy);
828 if (action_status != LTTNG_ACTION_STATUS_OK) {
7f4d5b07 829 ERR("Failed to retrieve rate policy.");
e45dd625
JR		 830 goto end;
831 }
0de2479d
SM		 832 break;
833 case LTTNG_ACTION_TYPE_STOP_SESSION:
834 action_status = lttng_action_stop_session_get_session_name(
835 action, &value);
836 assert(action_status == LTTNG_ACTION_STATUS_OK);
e45dd625
JR		 837 _MSG("stop session `%s`", value);
838
7f4d5b07 839 action_status = lttng_action_stop_session_get_rate_policy(
e45dd625
JR		 840 action, &policy);
841 if (action_status != LTTNG_ACTION_STATUS_OK) {
7f4d5b07 842 ERR("Failed to retrieve rate policy.");
e45dd625
JR		 843 goto end;
844 }
0de2479d
SM		 845 break;
846 case LTTNG_ACTION_TYPE_ROTATE_SESSION:
847 action_status = lttng_action_rotate_session_get_session_name(
848 action, &value);
849 assert(action_status == LTTNG_ACTION_STATUS_OK);
e45dd625
JR		 850 _MSG("rotate session `%s`", value);
851
7f4d5b07 852 action_status = lttng_action_rotate_session_get_rate_policy(
e45dd625
JR		 853 action, &policy);
854 if (action_status != LTTNG_ACTION_STATUS_OK) {
7f4d5b07 855 ERR("Failed to retrieve rate policy.");
e45dd625
JR		 856 goto end;
857 }
0de2479d
SM		 858 break;
859 case LTTNG_ACTION_TYPE_SNAPSHOT_SESSION:
860 {
861 const struct lttng_snapshot_output *output;
862
863 action_status = lttng_action_snapshot_session_get_session_name(
864 action, &value);
865 assert(action_status == LTTNG_ACTION_STATUS_OK);
866 _MSG("snapshot session `%s`", value);
867
868 action_status = lttng_action_snapshot_session_get_output(
869 action, &output);
870 if (action_status == LTTNG_ACTION_STATUS_OK) {
871 const char *name;
872 uint64_t max_size;
873 const char *ctrl_url, *data_url;
874 bool starts_with_file, starts_with_net, starts_with_net6;
875
876 ctrl_url = lttng_snapshot_output_get_ctrl_url(output);
877 assert(ctrl_url && strlen(ctrl_url) > 0);
878
879 data_url = lttng_snapshot_output_get_data_url(output);
880 assert(data_url);
881
882 starts_with_file = strncmp(ctrl_url, "file://", strlen("file://")) == 0;
883 starts_with_net = strncmp(ctrl_url, "net://", strlen("net://")) == 0;
884 starts_with_net6 = strncmp(ctrl_url, "net6://", strlen("net6://")) == 0;
885
886 if (ctrl_url[0] == '/' || starts_with_file) {
887 if (starts_with_file) {
888 ctrl_url += strlen("file://");
889 }
890
891 _MSG(", path: %s", ctrl_url);
892 } else if (starts_with_net || starts_with_net6) {
893 _MSG(", url: %s", ctrl_url);
894 } else {
895 assert(strlen(data_url) > 0);
896
897 _MSG(", control url: %s, data url: %s", ctrl_url, data_url);
898 }
899
900 name = lttng_snapshot_output_get_name(output);
901 assert(name);
902 if (strlen(name) > 0) {
903 _MSG(", name: %s", name);
904 }
905
906 max_size = lttng_snapshot_output_get_maxsize(output);
907 if (max_size != -1ULL) {
908 _MSG(", max size: %" PRIu64, max_size);
909 }
910 }
911
7f4d5b07 912 action_status = lttng_action_snapshot_session_get_rate_policy(
e45dd625
JR		 913 action, &policy);
914 if (action_status != LTTNG_ACTION_STATUS_OK) {
7f4d5b07 915 ERR("Failed to retrieve rate policy.");
e45dd625
JR		 916 goto end;
917 }
0de2479d
SM		 918 break;
919 }
0de2479d
SM		 920 default:
921 abort();
922 }
e45dd625
JR		 923
924 if (policy) {
7f4d5b07
JR		 925 enum lttng_rate_policy_type policy_type;
926 enum lttng_rate_policy_status policy_status;
e45dd625
JR		 927 uint64_t policy_value = 0;
928
7f4d5b07 929 policy_type = lttng_rate_policy_get_type(policy);
e45dd625
JR		 930
931 switch (policy_type) {
7f4d5b07
JR		 932 case LTTNG_RATE_POLICY_TYPE_EVERY_N:
933 policy_status = lttng_rate_policy_every_n_get_interval(
e45dd625 934 policy, &policy_value);
7f4d5b07
JR		 935 if (policy_status != LTTNG_RATE_POLICY_STATUS_OK) {
936 ERR("Failed to get action rate policy interval");
e45dd625
JR		 937 goto end;
938 }
939 if (policy_value > 1) {
940 /* The default is 1 so print only when it is a
941 * special case.
942 */
4edabba8 943 _MSG(", rate policy: every %" PRIu64
e45dd625
JR		 944 " occurrences",
945 policy_value);
946 }
947 break;
7f4d5b07
JR		 948 case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N:
949 policy_status = lttng_rate_policy_once_after_n_get_threshold(
e45dd625 950 policy, &policy_value);
7f4d5b07
JR		 951 if (policy_status != LTTNG_RATE_POLICY_STATUS_OK) {
952 ERR("Failed to get action rate policy interval");
e45dd625
JR		 953 goto end;
954 }
7f4d5b07 955 _MSG(", rate policy: once after %" PRIu64
e45dd625
JR		 956 " occurrences",
957 policy_value);
958 break;
959 default:
960 abort();
961 }
962 }
963
964 MSG("");
cb9222ff
JG		 965 print_action_errors(trigger, action, action_path_indexes,
966 action_path_length);
709fb83f 967
e45dd625
JR		 968end:
969 return;
0de2479d
SM		 970}
971
709fb83f
JG		 972static
973void print_trigger_errors(const struct lttng_trigger *trigger)
974{
709fb83f 975 enum lttng_error_code error_query_ret;
709fb83f
JG		 976 struct lttng_error_query_results *results = NULL;
977 enum lttng_trigger_status trigger_status;
978 const char *trigger_name;
979 uid_t trigger_uid;
980 struct lttng_error_query *query =
981 lttng_error_query_trigger_create(trigger);
982
983 assert(query);
0efb2ad7
JG		 984 /*
985 * Anonymous triggers are not listed; this would be an internal error.
986 */
709fb83f
JG		 987 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
988 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
989
990 trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid);
991 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
992
993 error_query_ret = lttng_error_query_execute(
994 query, lttng_session_daemon_command_endpoint, &results);
995 if (error_query_ret != LTTNG_OK) {
996 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
997 trigger_name, (int) trigger_uid,
998 lttng_strerror(-error_query_ret));
999 goto end;
1000 }
1001
63dd3d7b 1002 print_error_query_results(results, 1);
709fb83f 1003
63dd3d7b
JG		 1004end:
1005 MSG("");
1006 lttng_error_query_destroy(query);
1007 lttng_error_query_results_destroy(results);
1008}
709fb83f 1009
63dd3d7b
JG		 1010static
1011void print_condition_errors(const struct lttng_trigger *trigger)
1012{
1013 enum lttng_error_code error_query_ret;
1014 struct lttng_error_query_results *results = NULL;
1015 enum lttng_trigger_status trigger_status;
1016 const char *trigger_name;
1017 uid_t trigger_uid;
1018 struct lttng_error_query *query =
1019 lttng_error_query_condition_create(trigger);
709fb83f 1020
63dd3d7b
JG		 1021 assert(query);
1022 /*
1023 * Anonymous triggers are not listed; this would be an internal error.
1024 */
1025 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
1026 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
709fb83f 1027
63dd3d7b
JG		 1028 trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid);
1029 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
709fb83f 1030
63dd3d7b
JG		 1031 error_query_ret = lttng_error_query_execute(
1032 query, lttng_session_daemon_command_endpoint, &results);
1033 if (error_query_ret != LTTNG_OK) {
1034 ERR("Failed to query errors of condition of trigger '%s' (owner uid: %d): %s",
1035 trigger_name, (int) trigger_uid,
1036 lttng_strerror(-error_query_ret));
1037 goto end;
709fb83f
JG		 1038 }
1039
63dd3d7b 1040 print_error_query_results(results, 2);
709fb83f
JG		 1041
1042end:
1043 MSG("");
1044 lttng_error_query_destroy(query);
1045 lttng_error_query_results_destroy(results);
1046}
1047
0de2479d
SM		 1048static
1049void print_one_trigger(const struct lttng_trigger *trigger)
1050{
1051 const struct lttng_condition *condition;
1052 enum lttng_condition_type condition_type;
1053 const struct lttng_action *action;
1054 enum lttng_action_type action_type;
1055 enum lttng_trigger_status trigger_status;
1056 const char *name;
0de2479d
SM		 1057 uid_t trigger_uid;
1058
0efb2ad7
JG		 1059 /*
1060 * Anonymous triggers are not listed since they can't be specified nor
1061 * referenced through the CLI.
1062 */
0de2479d 1063 trigger_status = lttng_trigger_get_name(trigger, &name);
0efb2ad7
JG		 1064 if (trigger_status == LTTNG_TRIGGER_STATUS_UNSET) {
1065 goto end;
1066 }
1067
0de2479d
SM		 1068 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1069
1070 trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid);
1071 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1072
1d4b59f2 1073 MSG("- name: %s", name);
481c5310 1074 MSG(" owner uid: %d", trigger_uid);
0de2479d 1075
0de2479d
SM		 1076 condition = lttng_trigger_get_const_condition(trigger);
1077 condition_type = lttng_condition_get_type(condition);
1078 MSG(" condition: %s", lttng_condition_type_str(condition_type));
1079 switch (condition_type) {
19904669
SM		 1080 case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE:
1081 print_condition_session_consumed_size(condition);
1082 break;
1083 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
1084 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
1085 print_condition_buffer_usage(condition);
1086 break;
1087 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING:
1088 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED:
1089 print_condition_session_rotation(condition);
1090 break;
8dbb86b8
JR		 1091 case LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES:
1092 print_condition_event_rule_matches(condition);
0de2479d
SM		 1093 break;
1094 default:
19904669 1095 abort();
0de2479d
SM		 1096 }
1097
63dd3d7b
JG		 1098 print_condition_errors(trigger);
1099
0de2479d
SM		 1100 action = lttng_trigger_get_const_action(trigger);
1101 action_type = lttng_action_get_type(action);
7c2fae7c 1102 if (action_type == LTTNG_ACTION_TYPE_LIST) {
0de2479d
SM		 1103 unsigned int count, i;
1104 enum lttng_action_status action_status;
1105
1106 MSG(" actions:");
1107
702f26c8 1108 action_status = lttng_action_list_get_count(action, &count);
0de2479d
SM		 1109 assert(action_status == LTTNG_ACTION_STATUS_OK);
1110
1111 for (i = 0; i < count; i++) {
cb9222ff 1112 const uint64_t action_path_index = i;
0de2479d 1113 const struct lttng_action *subaction =
702f26c8 1114 lttng_action_list_get_at_index(
0de2479d
SM		 1115 action, i);
1116
1117 _MSG(" ");
cb9222ff
JG		 1118 print_one_action(trigger, subaction, &action_path_index,
1119 1);
0de2479d
SM		 1120 }
1121 } else {
1122 _MSG(" action:");
cb9222ff 1123 print_one_action(trigger, action, NULL, 0);
0de2479d
SM		 1124 }
1125
709fb83f 1126 print_trigger_errors(trigger);
0efb2ad7
JG		 1127end:
1128 return;
0de2479d
SM		 1129}
1130
1131static
1132int compare_triggers_by_name(const void *a, const void *b)
1133{
1134 const struct lttng_trigger *trigger_a = *((const struct lttng_trigger **) a);
1135 const struct lttng_trigger *trigger_b = *((const struct lttng_trigger **) b);
1136 const char *name_a, *name_b;
1137 enum lttng_trigger_status trigger_status;
1138
0efb2ad7 1139 /* Anonymous triggers are not reachable here. */
0de2479d
SM		 1140 trigger_status = lttng_trigger_get_name(trigger_a, &name_a);
1141 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1142
1143 trigger_status = lttng_trigger_get_name(trigger_b, &name_b);
1144 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1145
1146 return strcmp(name_a, name_b);
1147}
1148
523c4f8c 1149static int print_sorted_triggers(const struct lttng_triggers *triggers)
0de2479d
SM		 1150{
1151 int ret;
0de2479d
SM		 1152 int i;
1153 struct lttng_dynamic_pointer_array sorted_triggers;
1154 enum lttng_trigger_status trigger_status;
1155 unsigned int num_triggers;
1156
1157 lttng_dynamic_pointer_array_init(&sorted_triggers, NULL);
1158
523c4f8c
JR		 1159 trigger_status = lttng_triggers_get_count(triggers, &num_triggers);
1160 if (trigger_status != LTTNG_TRIGGER_STATUS_OK) {
1161 ERR("Failed to get trigger count.");
1162 goto error;
1163 }
1164
1165 for (i = 0; i < num_triggers; i++) {
1166 int add_ret;
1167 const char *unused_name;
1168 const struct lttng_trigger *trigger =
1169 lttng_triggers_get_at_index(triggers, i);
1170
1171 trigger_status = lttng_trigger_get_name(trigger, &unused_name);
1172 switch (trigger_status) {
1173 case LTTNG_TRIGGER_STATUS_OK:
1174 break;
1175 case LTTNG_TRIGGER_STATUS_UNSET:
1176 /* Don't list anonymous triggers. */
1177 continue;
1178 default:
1179 abort();
1180 }
1181
1182 add_ret = lttng_dynamic_pointer_array_add_pointer(
1183 &sorted_triggers, (void *) trigger);
1184 if (add_ret) {
1185 ERR("Failed to allocate array of struct lttng_trigger *.");
1186 goto error;
1187 }
1188 }
1189
1190 qsort(sorted_triggers.array.buffer.data, num_triggers,
1191 sizeof(struct lttng_trigger *),
1192 compare_triggers_by_name);
1193
9fa6c437
JR		 1194 for (i = 0; i < lttng_dynamic_pointer_array_get_count(&sorted_triggers);
1195 i++) {
1196 const struct lttng_trigger *trigger_to_print = (const struct lttng_trigger
1197 *)
523c4f8c
JR		 1198 lttng_dynamic_pointer_array_get_pointer(
1199 &sorted_triggers, i);
1200
1201 print_one_trigger(trigger_to_print);
1202 }
1203
1204 ret = 0;
1205 goto end;
1206error:
1207 ret = 1;
1208
1209end:
1210 lttng_dynamic_pointer_array_reset(&sorted_triggers);
1211 return ret;
1212}
1213
1214static enum lttng_error_code mi_error_query_trigger_callback(
1215 const struct lttng_trigger *trigger,
1216 struct lttng_error_query_results **results)
1217{
1218 enum lttng_error_code ret_code;
1219 struct lttng_error_query *query =
1220 lttng_error_query_trigger_create(trigger);
1221
1222 assert(results);
1223 assert(query);
1224
1225 ret_code = lttng_error_query_execute(
1226 query, lttng_session_daemon_command_endpoint, results);
1227 if (ret_code != LTTNG_OK) {
1228 enum lttng_trigger_status trigger_status;
1229 const char *trigger_name;
1230 uid_t trigger_uid;
1231
1232 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
1233 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1234
1235 trigger_status = lttng_trigger_get_owner_uid(
1236 trigger, &trigger_uid);
1237 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1238
1239 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
1240 trigger_name, (int) trigger_uid,
1241 lttng_strerror(-ret_code));
1242 }
1243
71637130 1244 lttng_error_query_destroy(query);
523c4f8c
JR		 1245 return ret_code;
1246}
1247
1248static enum lttng_error_code mi_error_query_action_callback(
1249 const struct lttng_trigger *trigger,
1250 const struct lttng_action_path *action_path,
1251 struct lttng_error_query_results **results)
1252{
1253 enum lttng_error_code ret_code;
1254 struct lttng_error_query *query =
1255 lttng_error_query_action_create(trigger, action_path);
1256
1257 assert(results);
1258 assert(query);
1259
1260 ret_code = lttng_error_query_execute(
1261 query, lttng_session_daemon_command_endpoint, results);
1262 if (ret_code != LTTNG_OK) {
1263 enum lttng_trigger_status trigger_status;
1264 const char *trigger_name;
1265 uid_t trigger_uid;
1266
1267 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
1268 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1269
1270 trigger_status = lttng_trigger_get_owner_uid(
1271 trigger, &trigger_uid);
1272 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1273
1274 ERR("Failed to query errors of an action for trigger '%s' (owner uid: %d): %s",
1275 trigger_name, (int) trigger_uid,
1276 lttng_strerror(-ret_code));
1277 }
71637130
JG		 1278
1279 lttng_error_query_destroy(query);
523c4f8c
JR		 1280 return ret_code;
1281}
1282
1283static enum lttng_error_code mi_error_query_condition_callback(
1284 const struct lttng_trigger *trigger,
1285 struct lttng_error_query_results **results)
1286{
1287 enum lttng_error_code ret_code;
1288 struct lttng_error_query *query =
1289 lttng_error_query_condition_create(trigger);
1290
1291 assert(results);
1292 assert(query);
1293
1294 ret_code = lttng_error_query_execute(
1295 query, lttng_session_daemon_command_endpoint, results);
1296 if (ret_code != LTTNG_OK) {
1297 enum lttng_trigger_status trigger_status;
1298 const char *trigger_name;
1299 uid_t trigger_uid;
1300
1301 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
1302 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1303
1304 trigger_status = lttng_trigger_get_owner_uid(
1305 trigger, &trigger_uid);
1306 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1307
1308 ERR("Failed to query errors of of condition for condition of trigger '%s' (owner uid: %d): %s",
1309 trigger_name, (int) trigger_uid,
1310 lttng_strerror(-ret_code));
1311 }
1312
71637130 1313 lttng_error_query_destroy(query);
523c4f8c
JR		 1314 return ret_code;
1315}
71637130 1316
523c4f8c
JR		 1317int cmd_list_triggers(int argc, const char **argv)
1318{
1319 int ret;
1320 struct argpar_parse_ret argpar_parse_ret = {};
1321 struct lttng_triggers *triggers = NULL;
1322 int i;
1323 struct mi_writer *mi_writer = NULL;
1324
0de2479d
SM		 1325 argpar_parse_ret = argpar_parse(
1326 argc - 1, argv + 1, list_trigger_options, true);
1327 if (!argpar_parse_ret.items) {
1328 ERR("%s", argpar_parse_ret.error);
1329 goto error;
1330 }
1331
1332 for (i = 0; i < argpar_parse_ret.items->n_items; i++) {
1333 const struct argpar_item *item =
1334 argpar_parse_ret.items->items[i];
1335
1336 if (item->type == ARGPAR_ITEM_TYPE_OPT) {
1337 const struct argpar_item_opt *item_opt =
1338 (const struct argpar_item_opt *) item;
1339
1340 switch (item_opt->descr->id) {
1341 case OPT_HELP:
1342 SHOW_HELP();
1343 ret = 0;
1344 goto end;
1345
1346 case OPT_LIST_OPTIONS:
523c4f8c
JR		 1347 list_cmd_options_argpar(
1348 stdout, list_trigger_options);
0de2479d
SM		 1349 ret = 0;
1350 goto end;
1351
1352 default:
1353 abort();
1354 }
1355
1356 } else {
1357 const struct argpar_item_non_opt *item_non_opt =
1358 (const struct argpar_item_non_opt *) item;
1359
1360 ERR("Unexpected argument: %s", item_non_opt->arg);
1361 }
1362 }
1363
1364 ret = lttng_list_triggers(&triggers);
1365 if (ret != LTTNG_OK) {
1366 ERR("Error listing triggers: %s.", lttng_strerror(-ret));
1367 goto error;
1368 }
1369
523c4f8c
JR		 1370 if (lttng_opt_mi) {
1371 mi_writer = mi_lttng_writer_create(
1372 fileno(stdout), lttng_opt_mi);
1373 if (!mi_writer) {
1374 ret = CMD_ERROR;
1375 goto end;
1376 }
0efb2ad7 1377
523c4f8c
JR		 1378 /* Open command element. */
1379 ret = mi_lttng_writer_command_open(mi_writer,
1380 mi_lttng_element_command_list_trigger);
1381 if (ret) {
1382 ret = CMD_ERROR;
1383 goto end;
0efb2ad7
JG		 1384 }
1385
523c4f8c
JR		 1386 /* Open output element. */
1387 ret = mi_lttng_writer_open_element(
1388 mi_writer, mi_lttng_element_command_output);
1389 if (ret) {
1390 ret = CMD_ERROR;
1391 goto end;
1392 }
1393 }
0de2479d 1394
523c4f8c
JR		 1395 if (lttng_opt_mi) {
1396 const struct mi_lttng_error_query_callbacks callbacks = {
1397 .trigger_cb = mi_error_query_trigger_callback,
1398 .action_cb = mi_error_query_action_callback,
1399 .condition_cb = mi_error_query_condition_callback,
1400 };
1401
1402 ret = lttng_triggers_mi_serialize(
1403 triggers, mi_writer, &callbacks);
1404 if (ret != LTTNG_OK) {
1405 ERR("Error printing MI triggers: %s.",
1406 lttng_strerror(-ret));
1407 goto error;
1408 }
1409 } else {
1410 ret = print_sorted_triggers(triggers);
1411 if (ret) {
1412 ERR("Error printing triggers");
0de2479d
SM		 1413 goto error;
1414 }
1415 }
1416
523c4f8c
JR		 1417 /* Mi closing. */
1418 if (lttng_opt_mi) {
1419 /* Close output element. */
1420 ret = mi_lttng_writer_close_element(mi_writer);
1421 if (ret) {
1422 ret = CMD_ERROR;
1423 goto end;
1424 }
0de2479d 1425
523c4f8c
JR		 1426 /* Command element close. */
1427 ret = mi_lttng_writer_command_close(mi_writer);
1428 if (ret) {
1429 ret = CMD_ERROR;
1430 goto end;
1431 }
0de2479d
SM		 1432 }
1433
1434 ret = 0;
1435 goto end;
1436
1437error:
1438 ret = 1;
1439
1440end:
1441 argpar_parse_ret_fini(&argpar_parse_ret);
1442 lttng_triggers_destroy(triggers);
523c4f8c
JR		 1443 /* Mi clean-up. */
1444 if (mi_writer && mi_lttng_writer_destroy(mi_writer)) {
1445 /* Preserve original error code. */
1446 ret = ret ? ret : CMD_ERROR;
1447 }
0de2479d
SM		 1448 return ret;
1449}
LTTng tools - Deliverables
This page took 0.096902 seconds and 5 git commands to generate.