2 * Copyright (C) 2011 EfficiOS Inc.
3 * Copyright (C) 2020 Jérémie Galarneau <jeremie.galarneau@efficios.com>
5 * SPDX-License-Identifier: GPL-2.0-only
17 #include <common/mi-lttng.hpp>
18 #include <common/time.hpp>
19 #include <common/tracker.hpp>
20 #include <lttng/domain-internal.hpp>
21 #include <lttng/lttng.h>
23 #include "../command.hpp"
25 static int opt_userspace
;
26 static int opt_kernel
;
29 static int opt_python
;
30 static char *opt_channel
;
31 static int opt_domain
;
32 static int opt_fields
;
33 static int opt_syscall
;
35 const char *indent4
= " ";
36 const char *indent6
= " ";
37 const char *indent8
= " ";
39 #ifdef LTTNG_EMBED_HELP
40 static const char help_msg
[] =
41 #include <lttng-list.1.h>
51 static struct lttng_handle
*the_handle
;
52 static struct mi_writer
*the_writer
;
54 /* Only set when listing a single session. */
55 static struct lttng_session the_listed_session
;
57 static struct poptOption long_options
[] = {
58 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
59 {"help", 'h', POPT_ARG_NONE
, 0, OPT_HELP
, 0, 0},
60 {"kernel", 'k', POPT_ARG_VAL
, &opt_kernel
, 1, 0, 0},
61 {"jul", 'j', POPT_ARG_VAL
, &opt_jul
, 1, 0, 0},
62 {"log4j", 'l', POPT_ARG_VAL
, &opt_log4j
, 1, 0, 0},
63 {"python", 'p', POPT_ARG_VAL
, &opt_python
, 1, 0, 0},
64 {"userspace", 'u', POPT_ARG_NONE
, 0, OPT_USERSPACE
, 0, 0},
65 {"channel", 'c', POPT_ARG_STRING
, &opt_channel
, 0, 0, 0},
66 {"domain", 'd', POPT_ARG_VAL
, &opt_domain
, 1, 0, 0},
67 {"fields", 'f', POPT_ARG_VAL
, &opt_fields
, 1, 0, 0},
68 {"syscall", 'S', POPT_ARG_VAL
, &opt_syscall
, 1, 0, 0},
69 {"list-options", 0, POPT_ARG_NONE
, NULL
, OPT_LIST_OPTIONS
, NULL
, NULL
},
74 * Get command line from /proc for a specific pid.
76 * On success, return an allocated string pointer to the proc cmdline.
77 * On error, return NULL.
79 static char *get_cmdline_by_pid(pid_t pid
)
84 /* Can't go bigger than /proc/LTTNG_MAX_PID/cmdline */
85 char path
[sizeof("/proc//cmdline") + sizeof(LTTNG_MAX_PID_STR
) - 1];
87 snprintf(path
, sizeof(path
), "/proc/%d/cmdline", pid
);
88 fp
= fopen(path
, "r");
93 /* Caller must free() *cmdline */
94 cmdline
= zmalloc
<char>(PATH_MAX
);
96 PERROR("malloc cmdline");
100 ret
= fread(cmdline
, 1, PATH_MAX
, fp
);
102 PERROR("fread proc list");
113 const char *active_string(int value
)
116 case 0: return "inactive";
117 case 1: return "active";
119 default: return NULL
;
123 static const char *snapshot_string(int value
)
134 const char *enabled_string(int value
)
137 case 0: return " [disabled]";
138 case 1: return " [enabled]";
140 default: return NULL
;
145 const char *safe_string(const char *str
)
147 return str
? str
: "";
150 static const char *logleveltype_string(enum lttng_loglevel_type value
)
153 case LTTNG_EVENT_LOGLEVEL_ALL
:
155 case LTTNG_EVENT_LOGLEVEL_RANGE
:
157 case LTTNG_EVENT_LOGLEVEL_SINGLE
:
160 return " <<TYPE UNKN>>";
164 static const char *bitness_event(enum lttng_event_flag flags
)
166 if (flags
& LTTNG_EVENT_FLAG_SYSCALL_32
) {
167 if (flags
& LTTNG_EVENT_FLAG_SYSCALL_64
) {
168 return " [32/64-bit]";
172 } else if (flags
& LTTNG_EVENT_FLAG_SYSCALL_64
) {
180 * Get exclusion names message for a single event.
182 * Returned pointer must be freed by caller. Returns NULL on error.
184 static char *get_exclusion_names_msg(struct lttng_event
*event
)
188 char *exclusion_msg
= NULL
;
191 const char * const exclusion_fmt
= " [exclusions: ";
192 const size_t exclusion_fmt_len
= strlen(exclusion_fmt
);
194 exclusion_count
= lttng_event_get_exclusion_name_count(event
);
195 if (exclusion_count
< 0) {
197 } else if (exclusion_count
== 0) {
199 * No exclusions: return copy of empty string so that
200 * it can be freed by caller.
202 exclusion_msg
= strdup("");
207 * exclusion_msg's size is bounded by the exclusion_fmt string,
208 * a comma per entry, the entry count (fixed-size), a closing
209 * bracket, and a trailing \0.
211 exclusion_msg
= (char *) malloc(exclusion_count
+
212 exclusion_count
* LTTNG_SYMBOL_NAME_LEN
+
213 exclusion_fmt_len
+ 1);
214 if (!exclusion_msg
) {
218 at
= strcpy(exclusion_msg
, exclusion_fmt
) + exclusion_fmt_len
;
219 for (i
= 0; i
< exclusion_count
; ++i
) {
222 /* Append comma between exclusion names */
228 ret
= lttng_event_get_exclusion_name(event
, i
, &name
);
230 /* Prints '?' on local error; should never happen */
236 /* Append exclusion name */
237 at
+= sprintf(at
, "%s", name
);
240 /* This also puts a final '\0' at the end of exclusion_msg */
244 return exclusion_msg
;
247 static void print_userspace_probe_location(struct lttng_event
*event
)
249 const struct lttng_userspace_probe_location
*location
;
250 const struct lttng_userspace_probe_location_lookup_method
*lookup_method
;
251 enum lttng_userspace_probe_location_lookup_method_type lookup_type
;
253 location
= lttng_event_get_userspace_probe_location(event
);
255 MSG("Event has no userspace probe location");
259 lookup_method
= lttng_userspace_probe_location_get_lookup_method(location
);
260 if (!lookup_method
) {
261 MSG("Event has no userspace probe location lookup method");
265 MSG("%s%s (type: userspace-probe)%s", indent6
, event
->name
, enabled_string(event
->enabled
));
267 lookup_type
= lttng_userspace_probe_location_lookup_method_get_type(lookup_method
);
269 switch (lttng_userspace_probe_location_get_type(location
)) {
270 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_UNKNOWN
:
271 MSG("%sType: Unknown", indent8
);
273 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION
:
275 const char *function_name
;
278 MSG("%sType: Function", indent8
);
279 function_name
= lttng_userspace_probe_location_function_get_function_name(location
);
280 binary_path
= realpath(lttng_userspace_probe_location_function_get_binary_path(location
), NULL
);
282 MSG("%sBinary path: %s", indent8
, binary_path
? binary_path
: "NULL");
283 MSG("%sFunction: %s()", indent8
, function_name
? function_name
: "NULL");
284 switch (lookup_type
) {
285 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF
:
286 MSG("%sLookup method: ELF", indent8
);
288 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT
:
289 MSG("%sLookup method: default", indent8
);
292 MSG("%sLookup method: INVALID LOOKUP TYPE ENCOUNTERED", indent8
);
299 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT
:
301 const char *probe_name
, *provider_name
;
304 MSG("%sType: Tracepoint", indent8
);
305 probe_name
= lttng_userspace_probe_location_tracepoint_get_probe_name(location
);
306 provider_name
= lttng_userspace_probe_location_tracepoint_get_provider_name(location
);
307 binary_path
= realpath(lttng_userspace_probe_location_tracepoint_get_binary_path(location
), NULL
);
308 MSG("%sBinary path: %s", indent8
, binary_path
? binary_path
: "NULL");
309 MSG("%sTracepoint: %s:%s", indent8
, provider_name
? provider_name
: "NULL", probe_name
? probe_name
: "NULL");
310 switch (lookup_type
) {
311 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT
:
312 MSG("%sLookup method: SDT", indent8
);
315 MSG("%sLookup method: INVALID LOOKUP TYPE ENCOUNTERED", indent8
);
323 ERR("Invalid probe type encountered");
328 * Pretty print single event.
330 static void print_events(struct lttng_event
*event
)
333 const char *filter_str
;
334 char *filter_msg
= NULL
;
335 char *exclusion_msg
= NULL
;
337 ret
= lttng_event_get_filter_expression(event
, &filter_str
);
340 filter_msg
= strdup(" [failed to retrieve filter]");
341 } else if (filter_str
) {
342 if (asprintf(&filter_msg
, " [filter: '%s']", filter_str
) == -1) {
347 exclusion_msg
= get_exclusion_names_msg(event
);
348 if (!exclusion_msg
) {
349 exclusion_msg
= strdup(" [failed to retrieve exclusions]");
352 switch (event
->type
) {
353 case LTTNG_EVENT_TRACEPOINT
:
355 if (event
->loglevel
!= -1) {
356 MSG("%s%s (loglevel%s %s (%d)) (type: tracepoint)%s%s%s",
357 indent6
, event
->name
,
359 event
->loglevel_type
),
360 mi_lttng_loglevel_string(
362 the_handle
->domain
.type
),
364 enabled_string(event
->enabled
),
365 safe_string(exclusion_msg
),
366 safe_string(filter_msg
));
368 MSG("%s%s (type: tracepoint)%s%s%s",
371 enabled_string(event
->enabled
),
372 safe_string(exclusion_msg
),
373 safe_string(filter_msg
));
377 case LTTNG_EVENT_FUNCTION
:
378 MSG("%s%s (type: function)%s%s", indent6
,
379 event
->name
, enabled_string(event
->enabled
),
380 safe_string(filter_msg
));
381 if (event
->attr
.probe
.addr
!= 0) {
382 MSG("%saddr: 0x%" PRIx64
, indent8
, event
->attr
.probe
.addr
);
384 MSG("%soffset: 0x%" PRIx64
, indent8
, event
->attr
.probe
.offset
);
385 MSG("%ssymbol: %s", indent8
, event
->attr
.probe
.symbol_name
);
388 case LTTNG_EVENT_PROBE
:
389 MSG("%s%s (type: probe)%s%s", indent6
,
390 event
->name
, enabled_string(event
->enabled
),
391 safe_string(filter_msg
));
392 if (event
->attr
.probe
.addr
!= 0) {
393 MSG("%saddr: 0x%" PRIx64
, indent8
, event
->attr
.probe
.addr
);
395 MSG("%soffset: 0x%" PRIx64
, indent8
, event
->attr
.probe
.offset
);
396 MSG("%ssymbol: %s", indent8
, event
->attr
.probe
.symbol_name
);
399 case LTTNG_EVENT_USERSPACE_PROBE
:
400 print_userspace_probe_location(event
);
402 case LTTNG_EVENT_FUNCTION_ENTRY
:
403 MSG("%s%s (type: function)%s%s", indent6
,
404 event
->name
, enabled_string(event
->enabled
),
405 safe_string(filter_msg
));
406 MSG("%ssymbol: \"%s\"", indent8
, event
->attr
.ftrace
.symbol_name
);
408 case LTTNG_EVENT_SYSCALL
:
409 MSG("%s%s%s%s%s%s", indent6
, event
->name
,
410 (opt_syscall
? "" : " (type:syscall)"),
411 enabled_string(event
->enabled
),
412 bitness_event(event
->flags
),
413 safe_string(filter_msg
));
415 case LTTNG_EVENT_NOOP
:
416 MSG("%s (type: noop)%s%s", indent6
,
417 enabled_string(event
->enabled
),
418 safe_string(filter_msg
));
420 case LTTNG_EVENT_ALL
:
423 /* We should never have "all" events in list. */
432 static const char *field_type(struct lttng_event_field
*field
)
434 switch(field
->type
) {
435 case LTTNG_EVENT_FIELD_INTEGER
:
437 case LTTNG_EVENT_FIELD_ENUM
:
439 case LTTNG_EVENT_FIELD_FLOAT
:
441 case LTTNG_EVENT_FIELD_STRING
:
443 case LTTNG_EVENT_FIELD_OTHER
:
444 default: /* fall-through */
450 * Pretty print single event fields.
452 static void print_event_field(struct lttng_event_field
*field
)
454 if (!field
->field_name
[0]) {
457 MSG("%sfield: %s (%s)%s", indent8
, field
->field_name
,
458 field_type(field
), field
->nowrite
? " [no write]" : "");
463 * Jul and ust event listing
465 static int mi_list_agent_ust_events(struct lttng_event
*events
, int count
,
466 struct lttng_domain
*domain
)
470 char *cmdline
= NULL
;
471 int pid_element_open
= 0;
473 /* Open domains element */
474 ret
= mi_lttng_domains_open(the_writer
);
480 ret
= mi_lttng_domain(the_writer
, domain
, 1);
485 /* Open pids element element */
486 ret
= mi_lttng_pids_open(the_writer
);
491 for (i
= 0; i
< count
; i
++) {
492 if (cur_pid
!= events
[i
].pid
) {
493 if (pid_element_open
) {
494 /* Close the previous events and pid element */
495 ret
= mi_lttng_close_multi_element(
500 pid_element_open
= 0;
503 cur_pid
= events
[i
].pid
;
504 cmdline
= get_cmdline_by_pid(cur_pid
);
510 if (!pid_element_open
) {
511 /* Open and write a pid element */
512 ret
= mi_lttng_pid(the_writer
, cur_pid
, cmdline
,
518 /* Open events element */
519 ret
= mi_lttng_events_open(the_writer
);
524 pid_element_open
= 1;
530 ret
= mi_lttng_event(the_writer
, &events
[i
], 0,
531 the_handle
->domain
.type
);
538 ret
= mi_lttng_writer_close_element(the_writer
);
543 /* Close domain, domains */
544 ret
= mi_lttng_close_multi_element(the_writer
, 2);
552 static int list_agent_events(void)
554 int i
, size
, ret
= CMD_SUCCESS
;
555 struct lttng_domain domain
;
556 struct lttng_handle
*handle
= NULL
;
557 struct lttng_event
*event_list
= NULL
;
559 char *cmdline
= NULL
;
560 const char *agent_domain_str
;
562 memset(&domain
, 0, sizeof(domain
));
564 domain
.type
= LTTNG_DOMAIN_JUL
;
565 } else if (opt_log4j
) {
566 domain
.type
= LTTNG_DOMAIN_LOG4J
;
567 } else if (opt_python
) {
568 domain
.type
= LTTNG_DOMAIN_PYTHON
;
570 ERR("Invalid agent domain selected.");
575 agent_domain_str
= lttng_domain_type_str(domain
.type
);
577 DBG("Getting %s tracing events", agent_domain_str
);
579 handle
= lttng_create_handle(NULL
, &domain
);
580 if (handle
== NULL
) {
585 size
= lttng_list_tracepoints(handle
, &event_list
);
587 ERR("Unable to list %s events: %s", agent_domain_str
,
588 lttng_strerror(size
));
595 ret
= mi_list_agent_ust_events(event_list
, size
, &domain
);
602 MSG("%s events (Logger name):\n-------------------------",
609 for (i
= 0; i
< size
; i
++) {
610 if (cur_pid
!= event_list
[i
].pid
) {
611 cur_pid
= event_list
[i
].pid
;
612 cmdline
= get_cmdline_by_pid(cur_pid
);
613 if (cmdline
== NULL
) {
617 MSG("\nPID: %d - Name: %s", cur_pid
, cmdline
);
620 MSG("%s- %s", indent6
, event_list
[i
].name
);
629 lttng_destroy_handle(handle
);
634 * Ask session daemon for all user space tracepoints available.
636 static int list_ust_events(void)
638 int i
, size
, ret
= CMD_SUCCESS
;
639 struct lttng_domain domain
;
640 struct lttng_handle
*handle
;
641 struct lttng_event
*event_list
= NULL
;
643 char *cmdline
= NULL
;
645 memset(&domain
, 0, sizeof(domain
));
647 DBG("Getting UST tracing events");
649 domain
.type
= LTTNG_DOMAIN_UST
;
651 handle
= lttng_create_handle(NULL
, &domain
);
652 if (handle
== NULL
) {
657 size
= lttng_list_tracepoints(handle
, &event_list
);
659 ERR("Unable to list UST events: %s", lttng_strerror(size
));
666 ret
= mi_list_agent_ust_events(event_list
, size
, &domain
);
669 MSG("UST events:\n-------------");
675 for (i
= 0; i
< size
; i
++) {
676 if (cur_pid
!= event_list
[i
].pid
) {
677 cur_pid
= event_list
[i
].pid
;
678 cmdline
= get_cmdline_by_pid(cur_pid
);
679 if (cmdline
== NULL
) {
683 MSG("\nPID: %d - Name: %s", cur_pid
, cmdline
);
686 print_events(&event_list
[i
]);
695 lttng_destroy_handle(handle
);
701 * List all ust event with their fields
703 static int mi_list_ust_event_fields(struct lttng_event_field
*fields
, int count
,
704 struct lttng_domain
*domain
)
708 char *cmdline
= NULL
;
709 int pid_element_open
= 0;
710 int event_element_open
= 0;
711 struct lttng_event cur_event
;
713 memset(&cur_event
, 0, sizeof(cur_event
));
715 /* Open domains element */
716 ret
= mi_lttng_domains_open(the_writer
);
722 ret
= mi_lttng_domain(the_writer
, domain
, 1);
727 /* Open pids element */
728 ret
= mi_lttng_pids_open(the_writer
);
733 for (i
= 0; i
< count
; i
++) {
734 if (cur_pid
!= fields
[i
].event
.pid
) {
735 if (pid_element_open
) {
736 if (event_element_open
) {
737 /* Close the previous field element and event. */
738 ret
= mi_lttng_close_multi_element(
743 event_element_open
= 0;
745 /* Close the previous events, pid element */
746 ret
= mi_lttng_close_multi_element(
751 pid_element_open
= 0;
754 cur_pid
= fields
[i
].event
.pid
;
755 cmdline
= get_cmdline_by_pid(cur_pid
);
756 if (!pid_element_open
) {
757 /* Open and write a pid element */
758 ret
= mi_lttng_pid(the_writer
, cur_pid
, cmdline
,
764 /* Open events element */
765 ret
= mi_lttng_events_open(the_writer
);
769 pid_element_open
= 1;
772 /* Wipe current event since we are about to print a new PID. */
773 memset(&cur_event
, 0, sizeof(cur_event
));
776 if (strcmp(cur_event
.name
, fields
[i
].event
.name
) != 0) {
777 if (event_element_open
) {
778 /* Close the previous fields element and the previous event */
779 ret
= mi_lttng_close_multi_element(
784 event_element_open
= 0;
787 memcpy(&cur_event
, &fields
[i
].event
,
790 if (!event_element_open
) {
791 /* Open and write the event */
792 ret
= mi_lttng_event(the_writer
, &cur_event
, 1,
793 the_handle
->domain
.type
);
798 /* Open a fields element */
799 ret
= mi_lttng_event_fields_open(the_writer
);
803 event_element_open
= 1;
807 /* Print the event_field */
808 ret
= mi_lttng_event_field(the_writer
, &fields
[i
]);
814 /* Close pids, domain, domains */
815 ret
= mi_lttng_close_multi_element(the_writer
, 3);
824 * Ask session daemon for all user space tracepoint fields available.
826 static int list_ust_event_fields(void)
828 int i
, size
, ret
= CMD_SUCCESS
;
829 struct lttng_domain domain
;
830 struct lttng_handle
*handle
;
831 struct lttng_event_field
*event_field_list
;
833 char *cmdline
= NULL
;
835 struct lttng_event cur_event
;
837 memset(&domain
, 0, sizeof(domain
));
838 memset(&cur_event
, 0, sizeof(cur_event
));
840 DBG("Getting UST tracing event fields");
842 domain
.type
= LTTNG_DOMAIN_UST
;
844 handle
= lttng_create_handle(NULL
, &domain
);
845 if (handle
== NULL
) {
850 size
= lttng_list_tracepoint_fields(handle
, &event_field_list
);
852 ERR("Unable to list UST event fields: %s", lttng_strerror(size
));
859 ret
= mi_list_ust_event_fields(event_field_list
, size
, &domain
);
866 MSG("UST events:\n-------------");
872 for (i
= 0; i
< size
; i
++) {
873 if (cur_pid
!= event_field_list
[i
].event
.pid
) {
874 cur_pid
= event_field_list
[i
].event
.pid
;
875 cmdline
= get_cmdline_by_pid(cur_pid
);
876 if (cmdline
== NULL
) {
880 MSG("\nPID: %d - Name: %s", cur_pid
, cmdline
);
882 /* Wipe current event since we are about to print a new PID. */
883 memset(&cur_event
, 0, sizeof(cur_event
));
885 if (strcmp(cur_event
.name
, event_field_list
[i
].event
.name
) != 0) {
886 print_events(&event_field_list
[i
].event
);
887 memcpy(&cur_event
, &event_field_list
[i
].event
,
890 print_event_field(&event_field_list
[i
]);
897 free(event_field_list
);
899 lttng_destroy_handle(handle
);
905 * Print a list of kernel events
907 static int mi_list_kernel_events(struct lttng_event
*events
, int count
,
908 struct lttng_domain
*domain
)
912 /* Open domains element */
913 ret
= mi_lttng_domains_open(the_writer
);
919 ret
= mi_lttng_domain(the_writer
, domain
, 1);
925 ret
= mi_lttng_events_open(the_writer
);
930 for (i
= 0; i
< count
; i
++) {
931 ret
= mi_lttng_event(the_writer
, &events
[i
], 0,
932 the_handle
->domain
.type
);
938 /* close events, domain and domains */
939 ret
= mi_lttng_close_multi_element(the_writer
, 3);
949 * Ask for all trace events in the kernel
951 static int list_kernel_events(void)
953 int i
, size
, ret
= CMD_SUCCESS
;
954 struct lttng_domain domain
;
955 struct lttng_handle
*handle
;
956 struct lttng_event
*event_list
;
958 memset(&domain
, 0, sizeof(domain
));
960 DBG("Getting kernel tracing events");
962 domain
.type
= LTTNG_DOMAIN_KERNEL
;
964 handle
= lttng_create_handle(NULL
, &domain
);
965 if (handle
== NULL
) {
970 size
= lttng_list_tracepoints(handle
, &event_list
);
972 ERR("Unable to list kernel events: %s", lttng_strerror(size
));
973 lttng_destroy_handle(handle
);
979 ret
= mi_list_kernel_events(event_list
, size
, &domain
);
985 MSG("Kernel events:\n-------------");
987 for (i
= 0; i
< size
; i
++) {
988 print_events(&event_list
[i
]);
997 lttng_destroy_handle(handle
);
1001 lttng_destroy_handle(handle
);
1007 * Print a list of system calls.
1009 static int mi_list_syscalls(struct lttng_event
*events
, int count
)
1014 ret
= mi_lttng_events_open(the_writer
);
1019 for (i
= 0; i
< count
; i
++) {
1020 ret
= mi_lttng_event(the_writer
, &events
[i
], 0,
1021 the_handle
->domain
.type
);
1028 ret
= mi_lttng_writer_close_element(the_writer
);
1038 * Ask for kernel system calls.
1040 static int list_syscalls(void)
1042 int i
, size
, ret
= CMD_SUCCESS
;
1043 struct lttng_event
*event_list
;
1045 DBG("Getting kernel system call events");
1047 size
= lttng_list_syscalls(&event_list
);
1049 ERR("Unable to list system calls: %s", lttng_strerror(size
));
1056 ret
= mi_list_syscalls(event_list
, size
);
1062 MSG("System calls:\n-------------");
1064 for (i
= 0; i
< size
; i
++) {
1065 print_events(&event_list
[i
]);
1081 * Print a list of agent events
1083 static int mi_list_session_agent_events(struct lttng_event
*events
, int count
)
1087 /* Open events element */
1088 ret
= mi_lttng_events_open(the_writer
);
1093 for (i
= 0; i
< count
; i
++) {
1094 ret
= mi_lttng_event(the_writer
, &events
[i
], 0,
1095 the_handle
->domain
.type
);
1101 /* Close events element */
1102 ret
= mi_lttng_writer_close_element(the_writer
);
1109 * List agent events for a specific session using the handle.
1111 * Return CMD_SUCCESS on success else a negative value.
1113 static int list_session_agent_events(void)
1115 int ret
= CMD_SUCCESS
, count
, i
;
1116 struct lttng_event
*events
= NULL
;
1118 count
= lttng_list_events(the_handle
, "", &events
);
1121 ERR("%s", lttng_strerror(count
));
1127 ret
= mi_list_session_agent_events(events
, count
);
1134 MSG("Events (Logger name):\n---------------------");
1136 MSG("%sNone\n", indent6
);
1140 for (i
= 0; i
< count
; i
++) {
1141 const char *filter_str
;
1142 char *filter_msg
= NULL
;
1143 struct lttng_event
*event
= &events
[i
];
1145 ret
= lttng_event_get_filter_expression(event
,
1148 filter_msg
= strdup(" [failed to retrieve filter]");
1149 } else if (filter_str
) {
1150 if (asprintf(&filter_msg
, " [filter: '%s']", filter_str
) == -1) {
1155 if (event
->loglevel_type
!=
1156 LTTNG_EVENT_LOGLEVEL_ALL
) {
1157 MSG("%s- %s%s (loglevel%s %s)%s", indent4
,
1159 enabled_string(event
->enabled
),
1160 logleveltype_string(
1161 event
->loglevel_type
),
1162 mi_lttng_loglevel_string(
1166 safe_string(filter_msg
));
1168 MSG("%s- %s%s%s", indent4
, event
->name
,
1169 enabled_string(event
->enabled
),
1170 safe_string(filter_msg
));
1186 * print a list of event
1188 static int mi_list_events(struct lttng_event
*events
, int count
)
1192 /* Open events element */
1193 ret
= mi_lttng_events_open(the_writer
);
1198 for (i
= 0; i
< count
; i
++) {
1199 ret
= mi_lttng_event(the_writer
, &events
[i
], 0,
1200 the_handle
->domain
.type
);
1206 /* Close events element */
1207 ret
= mi_lttng_writer_close_element(the_writer
);
1214 * List events of channel of session and domain.
1216 static int list_events(const char *channel_name
)
1218 int ret
= CMD_SUCCESS
, count
, i
;
1219 struct lttng_event
*events
= NULL
;
1221 count
= lttng_list_events(the_handle
, channel_name
, &events
);
1224 ERR("%s", lttng_strerror(count
));
1230 ret
= mi_list_events(events
, count
);
1237 MSG("\n%sRecording event rules:", indent4
);
1239 MSG("%sNone\n", indent6
);
1243 for (i
= 0; i
< count
; i
++) {
1244 print_events(&events
[i
]);
1256 void print_timer(const char *timer_name
, uint32_t space_count
, int64_t value
)
1260 _MSG("%s%s:", indent6
, timer_name
);
1261 for (i
= 0; i
< space_count
; i
++) {
1266 MSG("%" PRId64
" %s", value
, USEC_UNIT
);
1273 * Pretty print channel
1275 static void print_channel(struct lttng_channel
*channel
)
1278 uint64_t discarded_events
, lost_packets
, monitor_timer_interval
;
1279 int64_t blocking_timeout
;
1281 ret
= lttng_channel_get_discarded_event_count(channel
,
1284 ERR("Failed to retrieve discarded event count of channel");
1288 ret
= lttng_channel_get_lost_packet_count(channel
,
1291 ERR("Failed to retrieve lost packet count of channel");
1295 ret
= lttng_channel_get_monitor_timer_interval(channel
,
1296 &monitor_timer_interval
);
1298 ERR("Failed to retrieve monitor interval of channel");
1302 ret
= lttng_channel_get_blocking_timeout(channel
,
1305 ERR("Failed to retrieve blocking timeout of channel");
1309 MSG("- %s:%s\n", channel
->name
, enabled_string(channel
->enabled
));
1310 MSG("%sAttributes:", indent4
);
1311 MSG("%sEvent-loss mode: %s", indent6
, channel
->attr
.overwrite
? "overwrite" : "discard");
1312 MSG("%sSub-buffer size: %" PRIu64
" bytes", indent6
, channel
->attr
.subbuf_size
);
1313 MSG("%sSub-buffer count: %" PRIu64
, indent6
, channel
->attr
.num_subbuf
);
1315 print_timer("Switch timer", 5, channel
->attr
.switch_timer_interval
);
1316 print_timer("Read timer", 7, channel
->attr
.read_timer_interval
);
1317 print_timer("Monitor timer", 4, monitor_timer_interval
);
1319 if (!channel
->attr
.overwrite
) {
1320 if (blocking_timeout
== -1) {
1321 MSG("%sBlocking timeout: infinite", indent6
);
1323 MSG("%sBlocking timeout: %" PRId64
" %s", indent6
,
1324 blocking_timeout
, USEC_UNIT
);
1328 MSG("%sTrace file count: %" PRIu64
" per stream", indent6
,
1329 channel
->attr
.tracefile_count
== 0 ?
1330 1 : channel
->attr
.tracefile_count
);
1331 if (channel
->attr
.tracefile_size
!= 0 ) {
1332 MSG("%sTrace file size: %" PRIu64
" bytes", indent6
,
1333 channel
->attr
.tracefile_size
);
1335 MSG("%sTrace file size: %s", indent6
, "unlimited");
1337 switch (channel
->attr
.output
) {
1338 case LTTNG_EVENT_SPLICE
:
1339 MSG("%sOutput mode: splice", indent6
);
1341 case LTTNG_EVENT_MMAP
:
1342 MSG("%sOutput mode: mmap", indent6
);
1346 MSG("\n%sStatistics:", indent4
);
1347 if (the_listed_session
.snapshot_mode
) {
1349 * The lost packet count is omitted for sessions in snapshot
1350 * mode as it is misleading: it would indicate the number of
1351 * packets that the consumer could not extract during the
1352 * course of recording the snapshot. It does not have the
1353 * same meaning as the "regular" lost packet count that
1354 * would result from the consumer not keeping up with
1355 * event production in an overwrite-mode channel.
1357 * A more interesting statistic would be the number of
1358 * packets lost between the first and last extracted
1359 * packets of a given snapshot (which prevents most analyses).
1361 MSG("%sNone", indent6
);
1362 goto skip_stats_printing
;
1365 if (!channel
->attr
.overwrite
) {
1366 MSG("%sDiscarded events: %" PRIu64
, indent6
, discarded_events
);
1368 MSG("%sLost packets: %" PRIu64
, indent6
, lost_packets
);
1370 skip_stats_printing
:
1376 * Print a list of channel
1379 static int mi_list_channels(struct lttng_channel
*channels
, int count
,
1380 const char *channel_name
)
1383 unsigned int chan_found
= 0;
1385 /* Open channels element */
1386 ret
= mi_lttng_channels_open(the_writer
);
1391 for (i
= 0; i
< count
; i
++) {
1392 if (channel_name
!= NULL
) {
1393 if (strncmp(channels
[i
].name
, channel_name
, NAME_MAX
) == 0) {
1400 /* Write channel element and leave it open */
1401 ret
= mi_lttng_channel(the_writer
, &channels
[i
], 1);
1406 /* Listing events per channel */
1407 ret
= list_events(channels
[i
].name
);
1412 /* Closing the channel element we opened earlier */
1413 ret
= mi_lttng_writer_close_element(the_writer
);
1423 /* Close channels element */
1424 ret
= mi_lttng_writer_close_element(the_writer
);
1434 * List channel(s) of session and domain.
1436 * If channel_name is NULL, all channels are listed.
1438 static int list_channels(const char *channel_name
)
1440 int count
, i
, ret
= CMD_SUCCESS
;
1441 unsigned int chan_found
= 0;
1442 struct lttng_channel
*channels
= NULL
;
1444 DBG("Listing channel(s) (%s)", channel_name
? : "<all>");
1446 count
= lttng_list_channels(the_handle
, &channels
);
1449 case LTTNG_ERR_KERN_CHAN_NOT_FOUND
:
1451 /* When printing mi this is not an error
1452 * but an empty channels element */
1456 goto error_channels
;
1460 /* We had a real error */
1462 ERR("%s", lttng_strerror(count
));
1463 goto error_channels
;
1470 ret
= mi_list_channels(channels
, count
, channel_name
);
1478 MSG("Channels:\n-------------");
1481 for (i
= 0; i
< count
; i
++) {
1482 if (channel_name
!= NULL
) {
1483 if (strncmp(channels
[i
].name
, channel_name
, NAME_MAX
) == 0) {
1489 print_channel(&channels
[i
]);
1491 /* Listing events per channel */
1492 ret
= list_events(channels
[i
].name
);
1502 if (!chan_found
&& channel_name
!= NULL
) {
1504 ERR("Channel %s not found", channel_name
);
1515 static const char *get_capitalized_process_attr_str(enum lttng_process_attr process_attr
)
1517 switch (process_attr
) {
1518 case LTTNG_PROCESS_ATTR_PROCESS_ID
:
1519 return "Process ID";
1520 case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
:
1521 return "Virtual process ID";
1522 case LTTNG_PROCESS_ATTR_USER_ID
:
1524 case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
:
1525 return "Virtual user ID";
1526 case LTTNG_PROCESS_ATTR_GROUP_ID
:
1528 case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
:
1529 return "Virtual group ID";
1536 static int handle_process_attr_status(enum lttng_process_attr process_attr
,
1537 enum lttng_process_attr_tracker_handle_status status
)
1539 int ret
= CMD_SUCCESS
;
1542 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY
:
1543 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK
:
1546 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR
:
1547 ERR("Communication occurred while fetching %s tracker",
1548 lttng_process_attr_to_string(process_attr
));
1551 case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST
:
1552 ERR("Failed to get the inclusion set of the %s tracker: session `%s` no longer exists",
1553 lttng_process_attr_to_string(process_attr
),
1554 the_handle
->session_name
);
1558 ERR("Unknown error occurred while fetching the inclusion set of the %s tracker",
1559 lttng_process_attr_to_string(process_attr
));
1567 static int mi_output_empty_tracker(enum lttng_process_attr process_attr
)
1571 ret
= mi_lttng_process_attribute_tracker_open(the_writer
, process_attr
);
1576 ret
= mi_lttng_close_multi_element(the_writer
, 2);
1581 static inline bool is_value_type_name(
1582 enum lttng_process_attr_value_type value_type
)
1584 return value_type
== LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME
||
1585 value_type
== LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME
;
1589 * List a process attribute tracker for a session and domain tuple.
1591 static int list_process_attr_tracker(enum lttng_process_attr process_attr
)
1594 unsigned int count
, i
;
1595 enum lttng_tracking_policy policy
;
1596 enum lttng_error_code ret_code
;
1597 enum lttng_process_attr_tracker_handle_status handle_status
;
1598 enum lttng_process_attr_values_status values_status
;
1599 const struct lttng_process_attr_values
*values
;
1600 struct lttng_process_attr_tracker_handle
*tracker_handle
= NULL
;
1602 ret_code
= lttng_session_get_tracker_handle(the_handle
->session_name
,
1603 the_handle
->domain
.type
, process_attr
, &tracker_handle
);
1604 if (ret_code
!= LTTNG_OK
) {
1605 ERR("Failed to get process attribute tracker handle: %s",
1606 lttng_strerror(ret_code
));
1611 handle_status
= lttng_process_attr_tracker_handle_get_inclusion_set(
1612 tracker_handle
, &values
);
1613 ret
= handle_process_attr_status(process_attr
, handle_status
);
1614 if (ret
!= CMD_SUCCESS
) {
1618 handle_status
= lttng_process_attr_tracker_handle_get_tracking_policy(
1619 tracker_handle
, &policy
);
1620 ret
= handle_process_attr_status(process_attr
, handle_status
);
1621 if (ret
!= CMD_SUCCESS
) {
1626 char *process_attr_name
;
1627 const int print_ret
= asprintf(&process_attr_name
, "%ss:",
1628 get_capitalized_process_attr_str(process_attr
));
1630 if (print_ret
== -1) {
1634 _MSG(" %-22s", process_attr_name
);
1635 free(process_attr_name
);
1638 case LTTNG_TRACKING_POLICY_INCLUDE_SET
:
1640 case LTTNG_TRACKING_POLICY_EXCLUDE_ALL
:
1642 mi_output_empty_tracker(process_attr
);
1647 case LTTNG_TRACKING_POLICY_INCLUDE_ALL
:
1652 ERR("Unknown tracking policy encoutered while listing the %s process attribute tracker of session `%s`",
1653 lttng_process_attr_to_string(process_attr
),
1654 the_handle
->session_name
);
1659 values_status
= lttng_process_attr_values_get_count(values
, &count
);
1660 if (values_status
!= LTTNG_PROCESS_ATTR_VALUES_STATUS_OK
) {
1661 ERR("Failed to get the count of values in the inclusion set of the %s process attribute tracker of session `%s`",
1662 lttng_process_attr_to_string(process_attr
),
1663 the_handle
->session_name
);
1669 /* Functionally equivalent to the 'exclude all' policy. */
1671 mi_output_empty_tracker(process_attr
);
1678 /* Mi tracker_id element */
1680 /* Open tracker_id and targets elements */
1681 ret
= mi_lttng_process_attribute_tracker_open(
1682 the_writer
, process_attr
);
1688 for (i
= 0; i
< count
; i
++) {
1689 const enum lttng_process_attr_value_type value_type
=
1690 lttng_process_attr_values_get_type_at_index(
1692 int64_t integral_value
= INT64_MAX
;
1693 const char *name
= "error";
1698 switch (value_type
) {
1699 case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID
:
1703 values_status
= lttng_process_attr_values_get_pid_at_index(
1705 integral_value
= (int64_t) pid
;
1708 case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID
:
1712 values_status
= lttng_process_attr_values_get_uid_at_index(
1714 integral_value
= (int64_t) uid
;
1717 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID
:
1721 values_status
= lttng_process_attr_values_get_gid_at_index(
1723 integral_value
= (int64_t) gid
;
1726 case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME
:
1727 values_status
= lttng_process_attr_values_get_user_name_at_index(
1730 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME
:
1731 values_status
= lttng_process_attr_values_get_group_name_at_index(
1739 if (values_status
!= LTTNG_PROCESS_ATTR_VALUES_STATUS_OK
) {
1741 * Not possible given the current liblttng-ctl
1744 ERR("Unknown error occurred while fetching process attribute value in inclusion list");
1749 if (is_value_type_name(value_type
)) {
1752 _MSG("%" PRIi64
, integral_value
);
1757 ret
= is_value_type_name(value_type
) ?
1758 mi_lttng_string_process_attribute_value(
1762 mi_lttng_integral_process_attribute_value(
1765 integral_value
, false);
1773 /* Mi close tracker_id and targets */
1775 ret
= mi_lttng_close_multi_element(the_writer
, 2);
1781 lttng_process_attr_tracker_handle_destroy(tracker_handle
);
1786 * List all trackers of a domain
1788 static int list_trackers(const struct lttng_domain
*domain
)
1792 MSG("Tracked process attributes");
1793 /* Trackers listing */
1795 ret
= mi_lttng_trackers_open(the_writer
);
1801 switch (domain
->type
) {
1802 case LTTNG_DOMAIN_KERNEL
:
1804 ret
= list_process_attr_tracker(LTTNG_PROCESS_ATTR_PROCESS_ID
);
1809 ret
= list_process_attr_tracker(
1810 LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
);
1815 ret
= list_process_attr_tracker(LTTNG_PROCESS_ATTR_USER_ID
);
1820 ret
= list_process_attr_tracker(
1821 LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
);
1826 ret
= list_process_attr_tracker(LTTNG_PROCESS_ATTR_GROUP_ID
);
1831 ret
= list_process_attr_tracker(
1832 LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
);
1837 case LTTNG_DOMAIN_UST
:
1839 ret
= list_process_attr_tracker(
1840 LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
);
1845 ret
= list_process_attr_tracker(
1846 LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
);
1851 ret
= list_process_attr_tracker(
1852 LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
);
1862 /* Close trackers element */
1863 ret
= mi_lttng_writer_close_element(the_writer
);
1873 static enum cmd_error_code
print_periodic_rotation_schedule(
1874 const struct lttng_rotation_schedule
*schedule
)
1876 enum cmd_error_code ret
;
1877 enum lttng_rotation_status status
;
1880 status
= lttng_rotation_schedule_periodic_get_period(schedule
,
1882 if (status
!= LTTNG_ROTATION_STATUS_OK
) {
1883 ERR("Failed to retrieve period parameter from periodic rotation schedule.");
1888 MSG(" timer period: %" PRIu64
" %s", value
, USEC_UNIT
);
1894 static enum cmd_error_code
print_size_threshold_rotation_schedule(
1895 const struct lttng_rotation_schedule
*schedule
)
1897 enum cmd_error_code ret
;
1898 enum lttng_rotation_status status
;
1901 status
= lttng_rotation_schedule_size_threshold_get_threshold(schedule
,
1903 if (status
!= LTTNG_ROTATION_STATUS_OK
) {
1904 ERR("Failed to retrieve size parameter from size-based rotation schedule.");
1909 MSG(" size threshold: %" PRIu64
" bytes", value
);
1915 static enum cmd_error_code
print_rotation_schedule(
1916 const struct lttng_rotation_schedule
*schedule
)
1918 enum cmd_error_code ret
;
1920 switch (lttng_rotation_schedule_get_type(schedule
)) {
1921 case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
:
1922 ret
= print_size_threshold_rotation_schedule(schedule
);
1924 case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
:
1925 ret
= print_periodic_rotation_schedule(schedule
);
1934 * List the automatic rotation settings.
1936 static enum cmd_error_code
list_rotate_settings(const char *session_name
)
1939 enum cmd_error_code cmd_ret
= CMD_SUCCESS
;
1940 unsigned int count
, i
;
1941 struct lttng_rotation_schedules
*schedules
= NULL
;
1942 enum lttng_rotation_status status
;
1944 ret
= lttng_session_list_rotation_schedules(session_name
, &schedules
);
1945 if (ret
!= LTTNG_OK
) {
1946 ERR("Failed to list session rotation schedules: %s", lttng_strerror(ret
));
1947 cmd_ret
= CMD_ERROR
;
1951 status
= lttng_rotation_schedules_get_count(schedules
, &count
);
1952 if (status
!= LTTNG_ROTATION_STATUS_OK
) {
1953 ERR("Failed to retrieve the number of session rotation schedules.");
1954 cmd_ret
= CMD_ERROR
;
1959 cmd_ret
= CMD_SUCCESS
;
1963 MSG("Automatic rotation schedules:");
1965 ret
= mi_lttng_writer_open_element(the_writer
,
1966 mi_lttng_element_rotation_schedules
);
1968 cmd_ret
= CMD_ERROR
;
1973 for (i
= 0; i
< count
; i
++) {
1974 enum cmd_error_code tmp_ret
= CMD_SUCCESS
;
1975 const struct lttng_rotation_schedule
*schedule
;
1977 schedule
= lttng_rotation_schedules_get_at_index(schedules
, i
);
1979 ERR("Failed to retrieve session rotation schedule.");
1980 cmd_ret
= CMD_ERROR
;
1985 ret
= mi_lttng_rotation_schedule(the_writer
, schedule
);
1987 tmp_ret
= CMD_ERROR
;
1990 tmp_ret
= print_rotation_schedule(schedule
);
1994 * Report an error if the serialization of any of the
1995 * descriptors failed.
1997 cmd_ret
= cmd_ret
? cmd_ret
: tmp_ret
;
2002 /* Close the rotation_schedules element. */
2003 ret
= mi_lttng_writer_close_element(the_writer
);
2005 cmd_ret
= CMD_ERROR
;
2010 lttng_rotation_schedules_destroy(schedules
);
2016 * Find the session with session_name as name
2017 * and print his informations.
2019 static int mi_list_session(const char *session_name
,
2020 struct lttng_session
*sessions
, int count
)
2023 unsigned int session_found
= 0;
2025 if (session_name
== NULL
) {
2026 ret
= -LTTNG_ERR_SESS_NOT_FOUND
;
2030 for (i
= 0; i
< count
; i
++) {
2031 if (strncmp(sessions
[i
].name
, session_name
, NAME_MAX
) == 0) {
2032 /* We need to leave it open to append other informations
2033 * like domain, channel, events etc.*/
2035 ret
= mi_lttng_session(the_writer
, &sessions
[i
], 1);
2043 if (!session_found
) {
2044 ERR("Session '%s' not found", session_name
);
2045 ret
= -LTTNG_ERR_SESS_NOT_FOUND
;
2055 * List all availables session
2057 static int mi_list_sessions(struct lttng_session
*sessions
, int count
)
2061 /* Opening sessions element */
2062 ret
= mi_lttng_sessions_open(the_writer
);
2067 /* Listing sessions */
2068 for (i
= 0; i
< count
; i
++) {
2069 ret
= mi_lttng_session(the_writer
, &sessions
[i
], 0);
2075 /* Closing sessions element */
2076 ret
= mi_lttng_writer_close_element(the_writer
);
2086 * List available tracing session. List only basic information.
2088 * If session_name is NULL, all sessions are listed.
2090 static int list_sessions(const char *session_name
)
2092 int ret
= CMD_SUCCESS
;
2094 unsigned int session_found
= 0;
2095 struct lttng_session
*sessions
= NULL
;
2097 count
= lttng_list_sessions(&sessions
);
2098 DBG("Session count %d", count
);
2101 ERR("%s", lttng_strerror(count
));
2107 if (session_name
== NULL
) {
2108 /* List all sessions */
2109 ret
= mi_list_sessions(sessions
, count
);
2111 /* Note : this return an open session element */
2112 ret
= mi_list_session(session_name
, sessions
, count
);
2121 MSG("Currently no available recording session");
2125 if (session_name
== NULL
) {
2126 MSG("Available recording sessions:");
2129 for (i
= 0; i
< count
; i
++) {
2130 if (session_name
!= NULL
) {
2131 if (strncmp(sessions
[i
].name
, session_name
, NAME_MAX
) == 0) {
2133 MSG("Recording session %s: [%s%s]", session_name
,
2134 active_string(sessions
[i
].enabled
),
2135 snapshot_string(sessions
[i
].snapshot_mode
));
2136 if (*sessions
[i
].path
) {
2137 MSG("%sTrace output: %s\n", indent4
, sessions
[i
].path
);
2139 memcpy(&the_listed_session
,
2141 sizeof(the_listed_session
));
2145 MSG(" %d) %s [%s%s]", i
+ 1,
2147 active_string(sessions
[i
].enabled
),
2148 snapshot_string(sessions
[i
].snapshot_mode
));
2149 if (*sessions
[i
].path
) {
2150 MSG("%sTrace output: %s", indent4
, sessions
[i
].path
);
2152 if (sessions
[i
].live_timer_interval
!= 0) {
2153 MSG("%sLive timer interval: %u %s", indent4
,
2154 sessions
[i
].live_timer_interval
,
2161 if (!session_found
&& session_name
!= NULL
) {
2162 ERR("Session '%s' not found", session_name
);
2167 if (session_name
== NULL
) {
2168 MSG("\nUse lttng list <session_name> for more details");
2180 * list available domain(s) for a session.
2182 static int mi_list_domains(struct lttng_domain
*domains
, int count
)
2185 /* Open domains element */
2186 ret
= mi_lttng_domains_open(the_writer
);
2191 for (i
= 0; i
< count
; i
++) {
2192 ret
= mi_lttng_domain(the_writer
, &domains
[i
], 0);
2198 /* Closing domains element */
2199 ret
= mi_lttng_writer_close_element(the_writer
);
2208 * List available domain(s) for a session.
2210 static int list_domains(const char *session_name
)
2212 int i
, count
, ret
= CMD_SUCCESS
;
2213 struct lttng_domain
*domains
= NULL
;
2216 count
= lttng_list_domains(session_name
, &domains
);
2219 ERR("%s", lttng_strerror(count
));
2225 ret
= mi_list_domains(domains
, count
);
2232 MSG("Domains:\n-------------");
2238 for (i
= 0; i
< count
; i
++) {
2239 switch (domains
[i
].type
) {
2240 case LTTNG_DOMAIN_KERNEL
:
2243 case LTTNG_DOMAIN_UST
:
2244 MSG(" - UST global");
2246 case LTTNG_DOMAIN_JUL
:
2247 MSG(" - JUL (Java Util Logging)");
2249 case LTTNG_DOMAIN_LOG4J
:
2250 MSG(" - LOG4j (Logging for Java)");
2252 case LTTNG_DOMAIN_PYTHON
:
2253 MSG(" - Python (logging)");
2269 * The 'list <options>' first level command
2271 int cmd_list(int argc
, const char **argv
)
2273 int opt
, ret
= CMD_SUCCESS
;
2274 const char *arg_session_name
, *leftover
= NULL
;
2275 static poptContext pc
;
2276 struct lttng_domain domain
;
2277 struct lttng_domain
*domains
= NULL
;
2279 memset(&domain
, 0, sizeof(domain
));
2286 pc
= poptGetContext(NULL
, argc
, argv
, long_options
, 0);
2287 poptReadDefaultConfig(pc
, 0);
2289 while ((opt
= poptGetNextOpt(pc
)) != -1) {
2297 case OPT_LIST_OPTIONS
:
2298 list_cmd_options(stdout
, long_options
);
2301 ret
= CMD_UNDEFINED
;
2308 the_writer
= mi_lttng_writer_create(
2309 fileno(stdout
), lttng_opt_mi
);
2315 /* Open command element */
2316 ret
= mi_lttng_writer_command_open(
2317 the_writer
, mi_lttng_element_command_list
);
2323 /* Open output element */
2324 ret
= mi_lttng_writer_open_element(
2325 the_writer
, mi_lttng_element_command_output
);
2332 /* Get session name (trailing argument) */
2333 arg_session_name
= poptGetArg(pc
);
2334 DBG2("Session name: %s", arg_session_name
);
2336 leftover
= poptGetArg(pc
);
2338 ERR("Unknown argument: %s", leftover
);
2344 domain
.type
= LTTNG_DOMAIN_KERNEL
;
2345 } else if (opt_userspace
) {
2346 DBG2("Listing userspace global domain");
2347 domain
.type
= LTTNG_DOMAIN_UST
;
2348 } else if (opt_jul
) {
2349 DBG2("Listing JUL domain");
2350 domain
.type
= LTTNG_DOMAIN_JUL
;
2351 } else if (opt_log4j
) {
2352 domain
.type
= LTTNG_DOMAIN_LOG4J
;
2353 } else if (opt_python
) {
2354 domain
.type
= LTTNG_DOMAIN_PYTHON
;
2357 if (!opt_kernel
&& opt_syscall
) {
2358 WARN("--syscall will only work with the Kernel domain (-k)");
2363 if (opt_kernel
|| opt_userspace
|| opt_jul
|| opt_log4j
|| opt_python
) {
2364 the_handle
= lttng_create_handle(arg_session_name
, &domain
);
2365 if (the_handle
== NULL
) {
2371 if (arg_session_name
== NULL
) {
2372 if (!opt_kernel
&& !opt_userspace
&& !opt_jul
&& !opt_log4j
2374 ret
= list_sessions(NULL
);
2381 ret
= list_syscalls();
2386 ret
= list_kernel_events();
2392 if (opt_userspace
) {
2394 ret
= list_ust_event_fields();
2396 ret
= list_ust_events();
2402 if (opt_jul
|| opt_log4j
|| opt_python
) {
2403 ret
= list_agent_events();
2409 /* List session attributes */
2411 /* Open element sessions
2412 * Present for xml consistency */
2413 ret
= mi_lttng_sessions_open(the_writer
);
2418 /* MI: the ouptut of list_sessions is an unclosed session element */
2419 ret
= list_sessions(arg_session_name
);
2424 ret
= list_rotate_settings(arg_session_name
);
2429 /* Domain listing */
2431 ret
= list_domains(arg_session_name
);
2435 /* Channel listing */
2436 if (opt_kernel
|| opt_userspace
) {
2438 /* Add of domains and domain element for xml
2439 * consistency and validation
2441 ret
= mi_lttng_domains_open(the_writer
);
2446 /* Open domain and leave it open for
2447 * nested channels printing */
2448 ret
= mi_lttng_domain(the_writer
, &domain
, 1);
2457 ret
= list_trackers(&domain
);
2463 ret
= list_channels(opt_channel
);
2469 /* Close domain and domain element */
2470 ret
= mi_lttng_close_multi_element(
2481 /* We want all domain(s) */
2482 nb_domain
= lttng_list_domains(arg_session_name
, &domains
);
2483 if (nb_domain
< 0) {
2485 ERR("%s", lttng_strerror(nb_domain
));
2490 ret
= mi_lttng_domains_open(the_writer
);
2497 for (i
= 0; i
< nb_domain
; i
++) {
2498 switch (domains
[i
].type
) {
2499 case LTTNG_DOMAIN_KERNEL
:
2500 MSG("=== Domain: Linux kernel ===\n");
2502 case LTTNG_DOMAIN_UST
:
2503 MSG("=== Domain: User space ===\n");
2504 MSG("Buffering scheme: %s\n",
2505 domains
[i
].buf_type
==
2506 LTTNG_BUFFER_PER_PID
? "per-process" : "per-user");
2508 case LTTNG_DOMAIN_JUL
:
2509 MSG("=== Domain: java.util.logging (JUL) ===\n");
2511 case LTTNG_DOMAIN_LOG4J
:
2512 MSG("=== Domain: log4j ===\n");
2514 case LTTNG_DOMAIN_PYTHON
:
2515 MSG("=== Domain: Python logging ===\n");
2518 MSG("=== Domain: Unimplemented ===\n");
2523 ret
= mi_lttng_domain(the_writer
,
2531 /* Clean handle before creating a new one */
2533 lttng_destroy_handle(the_handle
);
2536 the_handle
= lttng_create_handle(
2537 arg_session_name
, &domains
[i
]);
2538 if (the_handle
== NULL
) {
2543 if (domains
[i
].type
== LTTNG_DOMAIN_JUL
||
2544 domains
[i
].type
== LTTNG_DOMAIN_LOG4J
||
2545 domains
[i
].type
== LTTNG_DOMAIN_PYTHON
) {
2546 ret
= list_session_agent_events();
2554 switch (domains
[i
].type
) {
2555 case LTTNG_DOMAIN_KERNEL
:
2556 case LTTNG_DOMAIN_UST
:
2557 ret
= list_trackers(&domains
[i
]);
2566 ret
= list_channels(opt_channel
);
2573 /* Close domain element */
2574 ret
= mi_lttng_writer_close_element(
2584 /* Close the domains, session and sessions element */
2585 ret
= mi_lttng_close_multi_element(
2597 /* Close output element */
2598 ret
= mi_lttng_writer_close_element(the_writer
);
2604 /* Command element close */
2605 ret
= mi_lttng_writer_command_close(the_writer
);
2613 if (the_writer
&& mi_lttng_writer_destroy(the_writer
)) {
2614 /* Preserve original error code */
2615 ret
= ret
? ret
: -LTTNG_ERR_MI_IO_FAIL
;
2620 lttng_destroy_handle(the_handle
);
2623 poptFreeContext(pc
);