projects / lttng-tools.git / blob
? search:


26dc201ec892d435c4214570043581611cd52b76
[lttng-tools.git] / src / bin / lttng / commands / list_triggers.c
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"
17 #include "lttng/condition/event-rule-matches.h"
18 #include "lttng/condition/event-rule-matches-internal.h"
19 /* For lttng_domain_type_str(). */
20 #include "lttng/domain-internal.h"
21 /* For lttng_event_rule_syscall_emission_site_str() */
22 #include "lttng/event-rule/syscall-internal.h"
23 #include "../loglevel.h"
24 #include <lttng/lttng.h>
25
26 #ifdef LTTNG_EMBED_HELP
27 static const char help_msg[] =
28 #include <lttng-list-triggers.1.h>
29 ;
30 #endif
31
32 enum {
33 OPT_HELP,
34 OPT_LIST_OPTIONS,
35 };
36
37 static const
38 struct argpar_opt_descr list_trigger_options[] = {
39 { OPT_HELP, 'h', "help", false },
40 { OPT_LIST_OPTIONS, '\0', "list-options", false },
41 ARGPAR_OPT_DESCR_SENTINEL,
42 };
43
44 static void print_condition_session_consumed_size(
45 const struct lttng_condition *condition)
46 {
47 enum lttng_condition_status condition_status;
48 const char *session_name;
49 uint64_t threshold;
50
51 condition_status =
52 lttng_condition_session_consumed_size_get_session_name(
53 condition, &session_name);
54 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
55
56 lttng_condition_session_consumed_size_get_threshold(
57 condition, &threshold);
58 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
59
60 MSG(" session name: %s", session_name);
61 MSG(" threshold: %" PRIu64 " bytes", threshold);
62 }
63
64 static void print_condition_buffer_usage(
65 const struct lttng_condition *condition)
66 {
67 enum lttng_condition_status condition_status;
68 const char *session_name, *channel_name;
69 enum lttng_domain_type domain_type;
70 uint64_t threshold;
71
72 condition_status = lttng_condition_buffer_usage_get_session_name(
73 condition, &session_name);
74 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
75
76 condition_status = lttng_condition_buffer_usage_get_channel_name(
77 condition, &channel_name);
78 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
79
80 condition_status = lttng_condition_buffer_usage_get_domain_type(
81 condition, &domain_type);
82 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
83
84 MSG(" session name: %s", session_name);
85 MSG(" channel name: %s", channel_name);
86 MSG(" domain: %s", lttng_domain_type_str(domain_type));
87
88 condition_status = lttng_condition_buffer_usage_get_threshold(
89 condition, &threshold);
90 if (condition_status == LTTNG_CONDITION_STATUS_OK) {
91 MSG(" threshold (bytes): %" PRIu64, threshold);
92 } else {
93 double threshold_ratio;
94
95 assert(condition_status == LTTNG_CONDITION_STATUS_UNSET);
96
97 condition_status =
98 lttng_condition_buffer_usage_get_threshold_ratio(
99 condition, &threshold_ratio);
100 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
101
102 MSG(" threshold (ratio): %.2f", threshold_ratio);
103 }
104 }
105
106 static void print_condition_session_rotation(
107 const struct lttng_condition *condition)
108 {
109 enum lttng_condition_status condition_status;
110 const char *session_name;
111
112 condition_status = lttng_condition_session_rotation_get_session_name(
113 condition, &session_name);
114 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
115
116 MSG(" session name: %s", session_name);
117 }
118
119 /*
120 * Returns the human-readable log level name associated with a numerical value
121 * if there is one. The Log4j and JUL domains have discontinuous log level
122 * values (a value can fall between two labels). In those cases, NULL is
123 * returned.
124 */
125 static const char *get_pretty_loglevel_name(
126 enum lttng_domain_type domain, int loglevel)
127 {
128 const char *name = NULL;
129
130 switch (domain) {
131 case LTTNG_DOMAIN_UST:
132 name = loglevel_value_to_name(loglevel);
133 break;
134 case LTTNG_DOMAIN_LOG4J:
135 name = loglevel_log4j_value_to_name(loglevel);
136 break;
137 case LTTNG_DOMAIN_JUL:
138 name = loglevel_jul_value_to_name(loglevel);
139 break;
140 case LTTNG_DOMAIN_PYTHON:
141 name = loglevel_python_value_to_name(loglevel);
142 break;
143 default:
144 break;
145 }
146
147 return name;
148 }
149
150 static
151 void print_event_rule_tracepoint(const struct lttng_event_rule *event_rule)
152 {
153 enum lttng_event_rule_status event_rule_status;
154 enum lttng_domain_type domain_type;
155 const char *pattern;
156 const char *filter;
157 int log_level;
158 const struct lttng_log_level_rule *log_level_rule = NULL;
159 unsigned int exclusions_count;
160 int i;
161
162 event_rule_status = lttng_event_rule_tracepoint_get_name_pattern(
163 event_rule, &pattern);
164 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK);
165
166 event_rule_status = lttng_event_rule_tracepoint_get_domain_type(
167 event_rule, &domain_type);
168 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK);
169
170 _MSG(" rule: %s (type: tracepoint, domain: %s", pattern,
171 lttng_domain_type_str(domain_type));
172
173 event_rule_status = lttng_event_rule_tracepoint_get_filter(
174 event_rule, &filter);
175 if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) {
176 _MSG(", filter: %s", filter);
177 } else {
178 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
179 }
180
181 event_rule_status = lttng_event_rule_tracepoint_get_log_level_rule(
182 event_rule, &log_level_rule);
183 if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) {
184 enum lttng_log_level_rule_status llr_status;
185 const char *log_level_op;
186 const char *pretty_loglevel_name;
187
188 switch (lttng_log_level_rule_get_type(log_level_rule)) {
189 case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY:
190 log_level_op = "is";
191 llr_status = lttng_log_level_rule_exactly_get_level(
192 log_level_rule, &log_level);
193 break;
194 case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS:
195 log_level_op = "at least";
196 llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level(
197 log_level_rule, &log_level);
198 break;
199 default:
200 abort();
201 }
202
203 assert(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK);
204
205 pretty_loglevel_name = get_pretty_loglevel_name(
206 domain_type, log_level);
207 if (pretty_loglevel_name) {
208 _MSG(", log level %s %s", log_level_op,
209 pretty_loglevel_name);
210 } else {
211 _MSG(", log level %s %d", log_level_op, log_level);
212 }
213 } else {
214 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
215 }
216
217 event_rule_status = lttng_event_rule_tracepoint_get_name_pattern_exclusion_count(
218 event_rule, &exclusions_count);
219 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK);
220 if (exclusions_count > 0) {
221 _MSG(", exclusions: ");
222 for (i = 0; i < exclusions_count; i++) {
223 const char *exclusion;
224
225 event_rule_status = lttng_event_rule_tracepoint_get_name_pattern_exclusion_at_index(
226 event_rule, i, &exclusion);
227 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK);
228
229 _MSG("%s%s", i > 0 ? "," : "", exclusion);
230 }
231 }
232
233 MSG(")");
234 }
235
236 static void print_kernel_probe_location(
237 const struct lttng_kernel_probe_location *location)
238 {
239 enum lttng_kernel_probe_location_status status;
240 switch (lttng_kernel_probe_location_get_type(location)) {
241 case LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS:
242 {
243 uint64_t address;
244
245 status = lttng_kernel_probe_location_address_get_address(
246 location, &address);
247 if (status != LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK) {
248 ERR("Getting kernel probe location address failed.");
249 goto end;
250 }
251
252 _MSG("0x%" PRIx64, address);
253
254 break;
255 }
256 case LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET:
257 {
258 uint64_t offset;
259 const char *symbol_name;
260
261 symbol_name = lttng_kernel_probe_location_symbol_get_name(
262 location);
263 if (!symbol_name) {
264 ERR("Getting kernel probe location symbol name failed.");
265 goto end;
266 }
267
268 status = lttng_kernel_probe_location_symbol_get_offset(
269 location, &offset);
270 if (status != LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK) {
271 ERR("Getting kernel probe location address failed.");
272 goto end;
273 }
274
275 if (offset == 0) {
276 _MSG("%s", symbol_name);
277 } else {
278 _MSG("%s+0x%" PRIx64, symbol_name, offset);
279 }
280
281 break;
282 }
283 default:
284 abort();
285 };
286 end:
287 return;
288 }
289
290 static
291 void print_event_rule_kernel_probe(const struct lttng_event_rule *event_rule)
292 {
293 enum lttng_event_rule_status event_rule_status;
294 const char *name;
295 const struct lttng_kernel_probe_location *location;
296
297 assert(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE);
298
299 event_rule_status = lttng_event_rule_kernel_probe_get_event_name(event_rule, &name);
300 if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
301 ERR("Failed to get kprobe event rule's name.");
302 goto end;
303 }
304
305 event_rule_status = lttng_event_rule_kernel_probe_get_location(
306 event_rule, &location);
307 if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
308 ERR("Failed to get kprobe event rule's location.");
309 goto end;
310 }
311
312 _MSG(" rule: %s (type: probe, location: ", name);
313
314 print_kernel_probe_location(location);
315
316 MSG(")");
317
318 end:
319 return;
320 }
321
322 static
323 void print_event_rule_userspace_probe(const struct lttng_event_rule *event_rule)
324 {
325 enum lttng_event_rule_status event_rule_status;
326 const char *name;
327 const struct lttng_userspace_probe_location *location;
328 enum lttng_userspace_probe_location_type userspace_probe_location_type;
329
330 assert(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE);
331
332 event_rule_status = lttng_event_rule_userspace_probe_get_event_name(
333 event_rule, &name);
334 if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
335 ERR("Failed to get uprobe event rule's name.");
336 goto end;
337 }
338
339 event_rule_status = lttng_event_rule_userspace_probe_get_location(
340 event_rule, &location);
341 if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
342 ERR("Failed to get uprobe event rule's location.");
343 goto end;
344 }
345
346 _MSG(" rule: %s (type: userspace probe, ", name);
347
348 userspace_probe_location_type =
349 lttng_userspace_probe_location_get_type(location);
350
351 switch (userspace_probe_location_type) {
352 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
353 {
354 const char *binary_path, *function_name;
355
356 binary_path = lttng_userspace_probe_location_function_get_binary_path(
357 location);
358 function_name = lttng_userspace_probe_location_function_get_function_name(
359 location);
360
361 _MSG("location type: ELF, location: %s:%s", binary_path, function_name);
362 break;
363 }
364 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT:
365 {
366 const char *binary_path, *provider_name, *probe_name;
367
368 binary_path = lttng_userspace_probe_location_tracepoint_get_binary_path(
369 location);
370 provider_name = lttng_userspace_probe_location_tracepoint_get_provider_name(
371 location);
372 probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(
373 location);
374 _MSG("location type: SDT, location: %s:%s:%s", binary_path, provider_name, probe_name);
375 break;
376 }
377 default:
378 abort();
379 }
380
381 MSG(")");
382
383 end:
384 return;
385 }
386
387 static
388 void print_event_rule_syscall(const struct lttng_event_rule *event_rule)
389 {
390 const char *pattern, *filter;
391 enum lttng_event_rule_status event_rule_status;
392 enum lttng_event_rule_syscall_emission_site emission_site;
393
394 assert(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_SYSCALL);
395
396 emission_site =
397 lttng_event_rule_syscall_get_emission_site(event_rule);
398
399 event_rule_status = lttng_event_rule_syscall_get_name_pattern(
400 event_rule, &pattern);
401 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK);
402
403 _MSG(" rule: %s (type: syscall:%s", pattern,
404 lttng_event_rule_syscall_emission_site_str(
405 emission_site));
406
407 event_rule_status = lttng_event_rule_syscall_get_filter(
408 event_rule, &filter);
409 if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) {
410 _MSG(", filter: %s", filter);
411 } else {
412 assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_UNSET);
413 }
414
415 MSG(")");
416 }
417
418 static
419 void print_event_rule(const struct lttng_event_rule *event_rule)
420 {
421 const enum lttng_event_rule_type event_rule_type =
422 lttng_event_rule_get_type(event_rule);
423
424 switch (event_rule_type) {
425 case LTTNG_EVENT_RULE_TYPE_TRACEPOINT:
426 print_event_rule_tracepoint(event_rule);
427 break;
428 case LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE:
429 print_event_rule_kernel_probe(event_rule);
430 break;
431 case LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE:
432 print_event_rule_userspace_probe(event_rule);
433 break;
434 case LTTNG_EVENT_RULE_TYPE_SYSCALL:
435 print_event_rule_syscall(event_rule);
436 break;
437 default:
438 abort();
439 }
440 }
441
442 static
443 void print_one_event_expr(const struct lttng_event_expr *event_expr)
444 {
445 enum lttng_event_expr_type type;
446
447 type = lttng_event_expr_get_type(event_expr);
448
449 switch (type) {
450 case LTTNG_EVENT_EXPR_TYPE_EVENT_PAYLOAD_FIELD:
451 {
452 const char *name;
453
454 name = lttng_event_expr_event_payload_field_get_name(
455 event_expr);
456 _MSG("%s", name);
457
458 break;
459 }
460 case LTTNG_EVENT_EXPR_TYPE_CHANNEL_CONTEXT_FIELD:
461 {
462 const char *name;
463
464 name = lttng_event_expr_channel_context_field_get_name(
465 event_expr);
466 _MSG("$ctx.%s", name);
467
468 break;
469 }
470 case LTTNG_EVENT_EXPR_TYPE_APP_SPECIFIC_CONTEXT_FIELD:
471 {
472 const char *provider_name;
473 const char *type_name;
474
475 provider_name = lttng_event_expr_app_specific_context_field_get_provider_name(
476 event_expr);
477 type_name = lttng_event_expr_app_specific_context_field_get_type_name(
478 event_expr);
479
480 _MSG("$app.%s:%s", provider_name, type_name);
481
482 break;
483 }
484 case LTTNG_EVENT_EXPR_TYPE_ARRAY_FIELD_ELEMENT:
485 {
486 unsigned int index;
487 const struct lttng_event_expr *parent_expr;
488 enum lttng_event_expr_status status;
489
490 parent_expr = lttng_event_expr_array_field_element_get_parent_expr(
491 event_expr);
492 assert(parent_expr != NULL);
493
494 print_one_event_expr(parent_expr);
495
496 status = lttng_event_expr_array_field_element_get_index(
497 event_expr, &index);
498 assert(status == LTTNG_EVENT_EXPR_STATUS_OK);
499
500 _MSG("[%u]", index);
501
502 break;
503 }
504 default:
505 abort();
506 }
507 }
508
509 static void print_condition_event_rule_matches(
510 const struct lttng_condition *condition)
511 {
512 const struct lttng_event_rule *event_rule;
513 enum lttng_condition_status condition_status;
514 unsigned int cap_desc_count, i;
515
516 condition_status = lttng_condition_event_rule_matches_get_rule(
517 condition, &event_rule);
518 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
519
520 print_event_rule(event_rule);
521
522 condition_status =
523 lttng_condition_event_rule_matches_get_capture_descriptor_count(
524 condition, &cap_desc_count);
525 assert(condition_status == LTTNG_CONDITION_STATUS_OK);
526
527 if (cap_desc_count > 0) {
528 MSG(" captures:");
529
530 for (i = 0; i < cap_desc_count; i++) {
531 const struct lttng_event_expr *cap_desc =
532 lttng_condition_event_rule_matches_get_capture_descriptor_at_index(
533 condition, i);
534
535 _MSG(" - ");
536 print_one_event_expr(cap_desc);
537 MSG("");
538 }
539 }
540 }
541
542 static void print_action_errors(const struct lttng_trigger *trigger,
543 const struct lttng_action *action,
544 const uint64_t *action_path_indexes,
545 size_t action_path_length)
546 {
547 unsigned int i, count, printed_errors_count = 0;
548 enum lttng_error_code error_query_ret;
549 enum lttng_error_query_results_status results_status;
550 struct lttng_error_query_results *results = NULL;
551 const char *trigger_name;
552 uid_t trigger_uid;
553 enum lttng_trigger_status trigger_status;
554 struct lttng_error_query *query;
555 struct lttng_action_path *action_path = lttng_action_path_create(
556 action_path_indexes, action_path_length);
557
558 assert(action_path);
559
560 query = lttng_error_query_action_create(trigger, action_path);
561 assert(query);
562
563 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
564 /*
565 * Anonymous triggers are not listed; this would be an internal error.
566 */
567 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
568
569 trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid);
570 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
571
572 error_query_ret = lttng_error_query_execute(
573 query, lttng_session_daemon_command_endpoint, &results);
574 if (error_query_ret != LTTNG_OK) {
575 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
576 trigger_name, (int) trigger_uid,
577 lttng_strerror(-error_query_ret));
578 goto end;
579 }
580
581 results_status = lttng_error_query_results_get_count(results, &count);
582 assert(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK);
583
584 _MSG(" errors:");
585
586 for (i = 0; i < count; i++) {
587 const struct lttng_error_query_result *result;
588 enum lttng_error_query_result_status result_status;
589 const char *result_name;
590 const char *result_description;
591 uint64_t result_value;
592
593 results_status = lttng_error_query_results_get_result(
594 results, &result, i);
595 assert(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK);
596
597 result_status = lttng_error_query_result_get_name(
598 result, &result_name);
599 assert(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
600 result_status = lttng_error_query_result_get_description(
601 result, &result_description);
602 assert(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
603
604 if (lttng_error_query_result_get_type(result) ==
605 LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER) {
606 result_status = lttng_error_query_result_counter_get_value(
607 result, &result_value);
608 assert(result_status ==
609 LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
610 if (result_value == 0) {
611 continue;
612 }
613
614 MSG("");
615 _MSG(" %s: %" PRIu64, result_name,
616 result_value);
617 printed_errors_count++;
618 } else {
619 _MSG(" Unknown error query result type for result '%s' (%s)",
620 result_name, result_description);
621 continue;
622 }
623 }
624
625 if (printed_errors_count == 0) {
626 _MSG(" none");
627 }
628
629 end:
630 MSG("");
631 lttng_error_query_destroy(query);
632 lttng_error_query_results_destroy(results);
633 lttng_action_path_destroy(action_path);
634 }
635
636 static
637 void print_one_action(const struct lttng_trigger *trigger,
638 const struct lttng_action *action,
639 const uint64_t *action_path_indexes,
640 size_t action_path_length)
641 {
642 enum lttng_action_type action_type;
643 enum lttng_action_status action_status;
644 const struct lttng_rate_policy *policy = NULL;
645 const char *value;
646
647 action_type = lttng_action_get_type(action);
648 assert(action_type != LTTNG_ACTION_TYPE_LIST);
649
650 switch (action_type) {
651 case LTTNG_ACTION_TYPE_NOTIFY:
652 _MSG("notify");
653
654 action_status = lttng_action_notify_get_rate_policy(
655 action, &policy);
656 if (action_status != LTTNG_ACTION_STATUS_OK) {
657 ERR("Failed to retrieve rate policy.");
658 goto end;
659 }
660 break;
661 case LTTNG_ACTION_TYPE_START_SESSION:
662 action_status = lttng_action_start_session_get_session_name(
663 action, &value);
664 assert(action_status == LTTNG_ACTION_STATUS_OK);
665 _MSG("start session `%s`", value);
666
667 action_status = lttng_action_start_session_get_rate_policy(
668 action, &policy);
669 if (action_status != LTTNG_ACTION_STATUS_OK) {
670 ERR("Failed to retrieve rate policy.");
671 goto end;
672 }
673 break;
674 case LTTNG_ACTION_TYPE_STOP_SESSION:
675 action_status = lttng_action_stop_session_get_session_name(
676 action, &value);
677 assert(action_status == LTTNG_ACTION_STATUS_OK);
678 _MSG("stop session `%s`", value);
679
680 action_status = lttng_action_stop_session_get_rate_policy(
681 action, &policy);
682 if (action_status != LTTNG_ACTION_STATUS_OK) {
683 ERR("Failed to retrieve rate policy.");
684 goto end;
685 }
686 break;
687 case LTTNG_ACTION_TYPE_ROTATE_SESSION:
688 action_status = lttng_action_rotate_session_get_session_name(
689 action, &value);
690 assert(action_status == LTTNG_ACTION_STATUS_OK);
691 _MSG("rotate session `%s`", value);
692
693 action_status = lttng_action_rotate_session_get_rate_policy(
694 action, &policy);
695 if (action_status != LTTNG_ACTION_STATUS_OK) {
696 ERR("Failed to retrieve rate policy.");
697 goto end;
698 }
699 break;
700 case LTTNG_ACTION_TYPE_SNAPSHOT_SESSION:
701 {
702 const struct lttng_snapshot_output *output;
703
704 action_status = lttng_action_snapshot_session_get_session_name(
705 action, &value);
706 assert(action_status == LTTNG_ACTION_STATUS_OK);
707 _MSG("snapshot session `%s`", value);
708
709 action_status = lttng_action_snapshot_session_get_output(
710 action, &output);
711 if (action_status == LTTNG_ACTION_STATUS_OK) {
712 const char *name;
713 uint64_t max_size;
714 const char *ctrl_url, *data_url;
715 bool starts_with_file, starts_with_net, starts_with_net6;
716
717 ctrl_url = lttng_snapshot_output_get_ctrl_url(output);
718 assert(ctrl_url && strlen(ctrl_url) > 0);
719
720 data_url = lttng_snapshot_output_get_data_url(output);
721 assert(data_url);
722
723 starts_with_file = strncmp(ctrl_url, "file://", strlen("file://")) == 0;
724 starts_with_net = strncmp(ctrl_url, "net://", strlen("net://")) == 0;
725 starts_with_net6 = strncmp(ctrl_url, "net6://", strlen("net6://")) == 0;
726
727 if (ctrl_url[0] == '/' || starts_with_file) {
728 if (starts_with_file) {
729 ctrl_url += strlen("file://");
730 }
731
732 _MSG(", path: %s", ctrl_url);
733 } else if (starts_with_net || starts_with_net6) {
734 _MSG(", url: %s", ctrl_url);
735 } else {
736 assert(strlen(data_url) > 0);
737
738 _MSG(", control url: %s, data url: %s", ctrl_url, data_url);
739 }
740
741 name = lttng_snapshot_output_get_name(output);
742 assert(name);
743 if (strlen(name) > 0) {
744 _MSG(", name: %s", name);
745 }
746
747 max_size = lttng_snapshot_output_get_maxsize(output);
748 if (max_size != -1ULL) {
749 _MSG(", max size: %" PRIu64, max_size);
750 }
751 }
752
753 action_status = lttng_action_snapshot_session_get_rate_policy(
754 action, &policy);
755 if (action_status != LTTNG_ACTION_STATUS_OK) {
756 ERR("Failed to retrieve rate policy.");
757 goto end;
758 }
759 break;
760 }
761 default:
762 abort();
763 }
764
765 if (policy) {
766 enum lttng_rate_policy_type policy_type;
767 enum lttng_rate_policy_status policy_status;
768 uint64_t policy_value = 0;
769
770 policy_type = lttng_rate_policy_get_type(policy);
771
772 switch (policy_type) {
773 case LTTNG_RATE_POLICY_TYPE_EVERY_N:
774 policy_status = lttng_rate_policy_every_n_get_interval(
775 policy, &policy_value);
776 if (policy_status != LTTNG_RATE_POLICY_STATUS_OK) {
777 ERR("Failed to get action rate policy interval");
778 goto end;
779 }
780 if (policy_value > 1) {
781 /* The default is 1 so print only when it is a
782 * special case.
783 */
784 _MSG(", rate policy: every %" PRIu64
785 " occurrences",
786 policy_value);
787 }
788 break;
789 case LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N:
790 policy_status = lttng_rate_policy_once_after_n_get_threshold(
791 policy, &policy_value);
792 if (policy_status != LTTNG_RATE_POLICY_STATUS_OK) {
793 ERR("Failed to get action rate policy interval");
794 goto end;
795 }
796 _MSG(", rate policy: once after %" PRIu64
797 " occurrences",
798 policy_value);
799 break;
800 default:
801 abort();
802 }
803 }
804
805 MSG("");
806 print_action_errors(trigger, action, action_path_indexes,
807 action_path_length);
808
809 end:
810 return;
811 }
812
813 static
814 void print_trigger_errors(const struct lttng_trigger *trigger)
815 {
816 unsigned int i, count, printed_errors_count = 0;
817 enum lttng_error_code error_query_ret;
818 enum lttng_error_query_results_status results_status;
819 struct lttng_error_query_results *results = NULL;
820 enum lttng_trigger_status trigger_status;
821 const char *trigger_name;
822 uid_t trigger_uid;
823 struct lttng_error_query *query =
824 lttng_error_query_trigger_create(trigger);
825
826 assert(query);
827 /*
828 * Anonymous triggers are not listed; this would be an internal error.
829 */
830 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
831 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
832
833 trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid);
834 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
835
836 error_query_ret = lttng_error_query_execute(
837 query, lttng_session_daemon_command_endpoint, &results);
838 if (error_query_ret != LTTNG_OK) {
839 ERR("Failed to query errors of trigger '%s' (owner uid: %d): %s",
840 trigger_name, (int) trigger_uid,
841 lttng_strerror(-error_query_ret));
842 goto end;
843 }
844
845 results_status = lttng_error_query_results_get_count(results, &count);
846 assert(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK);
847
848 _MSG(" errors:");
849
850 for (i = 0; i < count; i++) {
851 const struct lttng_error_query_result *result;
852 enum lttng_error_query_result_status result_status;
853 const char *result_name;
854 const char *result_description;
855 uint64_t result_value;
856
857 results_status = lttng_error_query_results_get_result(
858 results, &result, i);
859 assert(results_status == LTTNG_ERROR_QUERY_RESULTS_STATUS_OK);
860
861 result_status = lttng_error_query_result_get_name(
862 result, &result_name);
863 assert(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
864 result_status = lttng_error_query_result_get_description(
865 result, &result_description);
866 assert(result_status == LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
867
868 if (lttng_error_query_result_get_type(result) ==
869 LTTNG_ERROR_QUERY_RESULT_TYPE_COUNTER) {
870 result_status = lttng_error_query_result_counter_get_value(
871 result, &result_value);
872 assert(result_status ==
873 LTTNG_ERROR_QUERY_RESULT_STATUS_OK);
874 if (result_value == 0) {
875 continue;
876 }
877
878 MSG("");
879 _MSG(" %s: %" PRIu64, result_name,
880 result_value);
881 printed_errors_count++;
882 } else {
883 _MSG(" Unknown error query result type for result '%s' (%s)",
884 result_name, result_description);
885 continue;
886 }
887 }
888
889 if (printed_errors_count == 0) {
890 _MSG(" none");
891 }
892
893 end:
894 MSG("");
895 lttng_error_query_destroy(query);
896 lttng_error_query_results_destroy(results);
897 }
898
899 static
900 void print_one_trigger(const struct lttng_trigger *trigger)
901 {
902 const struct lttng_condition *condition;
903 enum lttng_condition_type condition_type;
904 const struct lttng_action *action;
905 enum lttng_action_type action_type;
906 enum lttng_trigger_status trigger_status;
907 const char *name;
908 uid_t trigger_uid;
909
910 /*
911 * Anonymous triggers are not listed since they can't be specified nor
912 * referenced through the CLI.
913 */
914 trigger_status = lttng_trigger_get_name(trigger, &name);
915 if (trigger_status == LTTNG_TRIGGER_STATUS_UNSET) {
916 goto end;
917 }
918
919 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
920
921 trigger_status = lttng_trigger_get_owner_uid(trigger, &trigger_uid);
922 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
923
924 MSG("- name: %s", name);
925 MSG(" owner uid: %d", trigger_uid);
926
927 condition = lttng_trigger_get_const_condition(trigger);
928 condition_type = lttng_condition_get_type(condition);
929 MSG(" condition: %s", lttng_condition_type_str(condition_type));
930 switch (condition_type) {
931 case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE:
932 print_condition_session_consumed_size(condition);
933 break;
934 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
935 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
936 print_condition_buffer_usage(condition);
937 break;
938 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING:
939 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED:
940 print_condition_session_rotation(condition);
941 break;
942 case LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES:
943 print_condition_event_rule_matches(condition);
944 break;
945 default:
946 abort();
947 }
948
949 action = lttng_trigger_get_const_action(trigger);
950 action_type = lttng_action_get_type(action);
951 if (action_type == LTTNG_ACTION_TYPE_LIST) {
952 unsigned int count, i;
953 enum lttng_action_status action_status;
954
955 MSG(" actions:");
956
957 action_status = lttng_action_list_get_count(action, &count);
958 assert(action_status == LTTNG_ACTION_STATUS_OK);
959
960 for (i = 0; i < count; i++) {
961 const uint64_t action_path_index = i;
962 const struct lttng_action *subaction =
963 lttng_action_list_get_at_index(
964 action, i);
965
966 _MSG(" ");
967 print_one_action(trigger, subaction, &action_path_index,
968 1);
969 }
970 } else {
971 _MSG(" action:");
972 print_one_action(trigger, action, NULL, 0);
973 }
974
975 print_trigger_errors(trigger);
976 end:
977 return;
978 }
979
980 static
981 int compare_triggers_by_name(const void *a, const void *b)
982 {
983 const struct lttng_trigger *trigger_a = *((const struct lttng_trigger **) a);
984 const struct lttng_trigger *trigger_b = *((const struct lttng_trigger **) b);
985 const char *name_a, *name_b;
986 enum lttng_trigger_status trigger_status;
987
988 /* Anonymous triggers are not reachable here. */
989 trigger_status = lttng_trigger_get_name(trigger_a, &name_a);
990 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
991
992 trigger_status = lttng_trigger_get_name(trigger_b, &name_b);
993 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
994
995 return strcmp(name_a, name_b);
996 }
997
998 int cmd_list_triggers(int argc, const char **argv)
999 {
1000 int ret;
1001 struct argpar_parse_ret argpar_parse_ret = {};
1002 struct lttng_triggers *triggers = NULL;
1003 int i;
1004 struct lttng_dynamic_pointer_array sorted_triggers;
1005 enum lttng_trigger_status trigger_status;
1006 unsigned int num_triggers;
1007
1008 lttng_dynamic_pointer_array_init(&sorted_triggers, NULL);
1009
1010 argpar_parse_ret = argpar_parse(
1011 argc - 1, argv + 1, list_trigger_options, true);
1012 if (!argpar_parse_ret.items) {
1013 ERR("%s", argpar_parse_ret.error);
1014 goto error;
1015 }
1016
1017 for (i = 0; i < argpar_parse_ret.items->n_items; i++) {
1018 const struct argpar_item *item =
1019 argpar_parse_ret.items->items[i];
1020
1021 if (item->type == ARGPAR_ITEM_TYPE_OPT) {
1022 const struct argpar_item_opt *item_opt =
1023 (const struct argpar_item_opt *) item;
1024
1025 switch (item_opt->descr->id) {
1026 case OPT_HELP:
1027 SHOW_HELP();
1028 ret = 0;
1029 goto end;
1030
1031 case OPT_LIST_OPTIONS:
1032 list_cmd_options_argpar(stdout,
1033 list_trigger_options);
1034 ret = 0;
1035 goto end;
1036
1037 default:
1038 abort();
1039 }
1040
1041 } else {
1042 const struct argpar_item_non_opt *item_non_opt =
1043 (const struct argpar_item_non_opt *) item;
1044
1045 ERR("Unexpected argument: %s", item_non_opt->arg);
1046 }
1047 }
1048
1049 ret = lttng_list_triggers(&triggers);
1050 if (ret != LTTNG_OK) {
1051 ERR("Error listing triggers: %s.", lttng_strerror(-ret));
1052 goto error;
1053 }
1054
1055 trigger_status = lttng_triggers_get_count(triggers, &num_triggers);
1056 if (trigger_status != LTTNG_TRIGGER_STATUS_OK) {
1057 ERR("Failed to get trigger count.");
1058 goto error;
1059 }
1060
1061 for (i = 0; i < num_triggers; i++) {
1062 int add_ret;
1063 const char *unused_name;
1064 const struct lttng_trigger *trigger =
1065 lttng_triggers_get_at_index(triggers, i);
1066
1067 trigger_status = lttng_trigger_get_name(trigger, &unused_name);
1068 switch (trigger_status) {
1069 case LTTNG_TRIGGER_STATUS_OK:
1070 break;
1071 case LTTNG_TRIGGER_STATUS_UNSET:
1072 /* Don't list anonymous triggers. */
1073 continue;
1074 default:
1075 abort();
1076 }
1077
1078 add_ret = lttng_dynamic_pointer_array_add_pointer(
1079 &sorted_triggers, (void *) trigger);
1080
1081 if (add_ret) {
1082 ERR("Failed to allocate array of struct lttng_trigger *.");
1083 goto error;
1084 }
1085 }
1086
1087 qsort(sorted_triggers.array.buffer.data, num_triggers,
1088 sizeof(struct lttng_trigger *),
1089 compare_triggers_by_name);
1090
1091 for (i = 0; i < num_triggers; i++) {
1092 const struct lttng_trigger *trigger_to_print =
1093 (const struct lttng_trigger *)
1094 lttng_dynamic_pointer_array_get_pointer(
1095 &sorted_triggers, i);
1096
1097 print_one_trigger(trigger_to_print);
1098 }
1099
1100 ret = 0;
1101 goto end;
1102
1103 error:
1104 ret = 1;
1105
1106 end:
1107 argpar_parse_ret_fini(&argpar_parse_ret);
1108 lttng_triggers_destroy(triggers);
1109 lttng_dynamic_pointer_array_reset(&sorted_triggers);
1110
1111 return ret;
1112 }
LTTng 2.0 tools and control repository
This page took 0.052507 seconds and 3 git commands to generate.