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