2 * Copyright (C) 2014 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License, version 2 only, as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 51
15 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23 #include <urcu/uatomic.h>
26 #include <common/defaults.h>
27 #include <common/error.h>
28 #include <common/config/config.h>
29 #include <common/utils.h>
30 #include <common/runas.h>
31 #include <lttng/save-internal.h>
37 #include "trace-ust.h"
40 int save_kernel_channel_attributes(struct config_writer
*writer
,
41 struct lttng_channel_attr
*attr
)
45 ret
= config_writer_write_element_string(writer
,
46 config_element_overwrite_mode
,
47 attr
->overwrite
? config_overwrite_mode_overwrite
:
48 config_overwrite_mode_discard
);
53 ret
= config_writer_write_element_unsigned_int(writer
,
54 config_element_subbuf_size
, attr
->subbuf_size
);
59 ret
= config_writer_write_element_unsigned_int(writer
,
60 config_element_num_subbuf
,
66 ret
= config_writer_write_element_unsigned_int(writer
,
67 config_element_switch_timer_interval
,
68 attr
->switch_timer_interval
);
73 ret
= config_writer_write_element_unsigned_int(writer
,
74 config_element_read_timer_interval
,
75 attr
->read_timer_interval
);
80 ret
= config_writer_write_element_string(writer
,
81 config_element_output_type
,
82 attr
->output
== LTTNG_EVENT_SPLICE
?
83 config_output_type_splice
: config_output_type_mmap
);
88 ret
= config_writer_write_element_unsigned_int(writer
,
89 config_element_tracefile_size
, attr
->tracefile_size
);
94 ret
= config_writer_write_element_unsigned_int(writer
,
95 config_element_tracefile_count
,
96 attr
->tracefile_count
);
101 ret
= config_writer_write_element_unsigned_int(writer
,
102 config_element_live_timer_interval
,
103 attr
->live_timer_interval
);
108 return ret
? LTTNG_ERR_SAVE_IO_FAIL
: 0;
112 int save_ust_channel_attributes(struct config_writer
*writer
,
113 struct lttng_ust_channel_attr
*attr
)
117 ret
= config_writer_write_element_string(writer
,
118 config_element_overwrite_mode
,
119 attr
->overwrite
? config_overwrite_mode_overwrite
:
120 config_overwrite_mode_discard
);
125 ret
= config_writer_write_element_unsigned_int(writer
,
126 config_element_subbuf_size
, attr
->subbuf_size
);
131 ret
= config_writer_write_element_unsigned_int(writer
,
132 config_element_num_subbuf
,
138 ret
= config_writer_write_element_unsigned_int(writer
,
139 config_element_switch_timer_interval
,
140 attr
->switch_timer_interval
);
145 ret
= config_writer_write_element_unsigned_int(writer
,
146 config_element_read_timer_interval
,
147 attr
->read_timer_interval
);
152 ret
= config_writer_write_element_string(writer
,
153 config_element_output_type
,
154 attr
->output
== LTTNG_UST_MMAP
?
155 config_output_type_mmap
: config_output_type_splice
);
160 return ret
? LTTNG_ERR_SAVE_IO_FAIL
: 0;
164 const char *get_kernel_instrumentation_string(
165 enum lttng_kernel_instrumentation instrumentation
)
167 const char *instrumentation_string
;
169 switch (instrumentation
) {
170 case LTTNG_KERNEL_ALL
:
171 instrumentation_string
= config_event_type_all
;
173 case LTTNG_KERNEL_TRACEPOINT
:
174 instrumentation_string
= config_event_type_tracepoint
;
176 case LTTNG_KERNEL_KPROBE
:
177 instrumentation_string
= config_event_type_kprobe
;
179 case LTTNG_KERNEL_FUNCTION
:
180 instrumentation_string
= config_event_type_function
;
182 case LTTNG_KERNEL_KRETPROBE
:
183 instrumentation_string
= config_event_type_kretprobe
;
185 case LTTNG_KERNEL_NOOP
:
186 instrumentation_string
= config_event_type_noop
;
188 case LTTNG_KERNEL_SYSCALL
:
189 instrumentation_string
= config_event_type_syscall
;
192 instrumentation_string
= NULL
;
195 return instrumentation_string
;
199 const char *get_kernel_context_type_string(
200 enum lttng_kernel_context_type context_type
)
202 const char *context_type_string
;
204 switch (context_type
) {
205 case LTTNG_KERNEL_CONTEXT_PID
:
206 context_type_string
= config_event_context_pid
;
208 case LTTNG_KERNEL_CONTEXT_PROCNAME
:
209 context_type_string
= config_event_context_procname
;
211 case LTTNG_KERNEL_CONTEXT_PRIO
:
212 context_type_string
= config_event_context_prio
;
214 case LTTNG_KERNEL_CONTEXT_NICE
:
215 context_type_string
= config_event_context_nice
;
217 case LTTNG_KERNEL_CONTEXT_VPID
:
218 context_type_string
= config_event_context_vpid
;
220 case LTTNG_KERNEL_CONTEXT_TID
:
221 context_type_string
= config_event_context_tid
;
223 case LTTNG_KERNEL_CONTEXT_VTID
:
224 context_type_string
= config_event_context_vtid
;
226 case LTTNG_KERNEL_CONTEXT_PPID
:
227 context_type_string
= config_event_context_ppid
;
229 case LTTNG_KERNEL_CONTEXT_VPPID
:
230 context_type_string
= config_event_context_vppid
;
232 case LTTNG_KERNEL_CONTEXT_HOSTNAME
:
233 context_type_string
= config_event_context_hostname
;
236 context_type_string
= NULL
;
239 return context_type_string
;
243 const char *get_ust_context_type_string(
244 enum lttng_ust_context_type context_type
)
246 const char *context_type_string
;
248 switch (context_type
) {
249 case LTTNG_UST_CONTEXT_PROCNAME
:
250 context_type_string
= config_event_context_procname
;
252 case LTTNG_UST_CONTEXT_VPID
:
253 context_type_string
= config_event_context_vpid
;
255 case LTTNG_UST_CONTEXT_VTID
:
256 context_type_string
= config_event_context_vtid
;
258 case LTTNG_UST_CONTEXT_IP
:
259 context_type_string
= config_event_context_ip
;
261 case LTTNG_UST_CONTEXT_PTHREAD_ID
:
262 context_type_string
= config_event_context_pthread_id
;
264 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
:
266 * Error, should not be stored in the XML, perf contexts
267 * are stored as a node of type event_perf_context_type.
270 context_type_string
= NULL
;
274 return context_type_string
;
278 const char *get_buffer_type_string(
279 enum lttng_buffer_type buffer_type
)
281 const char *buffer_type_string
;
283 switch (buffer_type
) {
284 case LTTNG_BUFFER_PER_PID
:
285 buffer_type_string
= config_buffer_type_per_pid
;
287 case LTTNG_BUFFER_PER_UID
:
288 buffer_type_string
= config_buffer_type_per_uid
;
290 case LTTNG_BUFFER_GLOBAL
:
291 buffer_type_string
= config_buffer_type_global
;
294 buffer_type_string
= NULL
;
297 return buffer_type_string
;
301 const char *get_loglevel_type_string(
302 enum lttng_ust_loglevel_type loglevel_type
)
304 const char *loglevel_type_string
;
306 switch (loglevel_type
) {
307 case LTTNG_UST_LOGLEVEL_ALL
:
308 loglevel_type_string
= config_loglevel_type_all
;
310 case LTTNG_UST_LOGLEVEL_RANGE
:
311 loglevel_type_string
= config_loglevel_type_range
;
313 case LTTNG_UST_LOGLEVEL_SINGLE
:
314 loglevel_type_string
= config_loglevel_type_single
;
317 loglevel_type_string
= NULL
;
320 return loglevel_type_string
;
324 int save_kernel_event(struct config_writer
*writer
,
325 struct ltt_kernel_event
*event
)
328 const char *instrumentation_type
;
330 ret
= config_writer_open_element(writer
, config_element_event
);
332 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
336 if (event
->event
->name
[0]) {
337 ret
= config_writer_write_element_string(writer
,
338 config_element_name
, event
->event
->name
);
340 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
345 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
348 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
352 instrumentation_type
= get_kernel_instrumentation_string(
353 event
->event
->instrumentation
);
354 if (!instrumentation_type
) {
355 ret
= LTTNG_ERR_INVALID
;
359 ret
= config_writer_write_element_string(writer
, config_element_type
,
360 instrumentation_type
);
362 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
366 if (event
->filter_expression
) {
367 ret
= config_writer_write_element_string(writer
,
368 config_element_filter
,
369 event
->filter_expression
);
371 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
376 if (event
->event
->instrumentation
== LTTNG_KERNEL_FUNCTION
||
377 event
->event
->instrumentation
== LTTNG_KERNEL_KPROBE
||
378 event
->event
->instrumentation
== LTTNG_KERNEL_KRETPROBE
) {
380 ret
= config_writer_open_element(writer
,
381 config_element_attributes
);
383 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
387 switch (event
->event
->instrumentation
) {
388 case LTTNG_KERNEL_SYSCALL
:
389 case LTTNG_KERNEL_FUNCTION
:
390 ret
= config_writer_open_element(writer
,
391 config_element_function_attributes
);
393 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
397 ret
= config_writer_write_element_string(writer
,
399 event
->event
->u
.ftrace
.symbol_name
);
401 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
405 /* /function attributes */
406 ret
= config_writer_close_element(writer
);
408 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
412 case LTTNG_KERNEL_KPROBE
:
413 case LTTNG_KERNEL_KRETPROBE
:
415 const char *symbol_name
;
419 if (event
->event
->instrumentation
==
420 LTTNG_KERNEL_KPROBE
) {
422 * Comments in lttng-kernel.h mention that
423 * either addr or symbol_name are set, not both.
425 addr
= event
->event
->u
.kprobe
.addr
;
426 offset
= event
->event
->u
.kprobe
.offset
;
427 symbol_name
= addr
? NULL
:
428 event
->event
->u
.kprobe
.symbol_name
;
431 event
->event
->u
.kretprobe
.symbol_name
;
432 addr
= event
->event
->u
.kretprobe
.addr
;
433 offset
= event
->event
->u
.kretprobe
.offset
;
436 ret
= config_writer_open_element(writer
,
437 config_element_probe_attributes
);
439 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
444 ret
= config_writer_write_element_string(writer
,
445 config_element_symbol_name
,
448 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
454 ret
= config_writer_write_element_unsigned_int(
455 writer
, config_element_address
, addr
);
457 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
463 ret
= config_writer_write_element_unsigned_int(
464 writer
, config_element_offset
, offset
);
466 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
471 ret
= config_writer_close_element(writer
);
473 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
479 ERR("Unsupported kernel instrumentation type.");
480 ret
= LTTNG_ERR_INVALID
;
485 ret
= config_writer_close_element(writer
);
487 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
493 ret
= config_writer_close_element(writer
);
495 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
503 int save_kernel_syscall(struct config_writer
*writer
,
504 struct ltt_kernel_channel
*kchan
)
508 struct lttng_event
*events
= NULL
;
513 count
= syscall_list_channel(kchan
, &events
, 0);
515 /* No syscalls, just gracefully return. */
520 for (i
= 0; i
< count
; i
++) {
521 struct ltt_kernel_event
*kevent
;
523 /* Create a temporary kevent in order to save it. */
525 * TODO: struct lttng_event does not really work for a filter,
526 * but unfortunately, it is exposed as external API (and used as
527 * internal representation. Using NULL meanwhile.
529 kevent
= trace_kernel_create_event(&events
[i
],
535 /* Init list in order so the destroy call can del the node. */
536 CDS_INIT_LIST_HEAD(&kevent
->list
);
538 ret
= save_kernel_event(writer
, kevent
);
539 trace_kernel_destroy_event(kevent
);
545 /* Everything went well */
554 int save_kernel_events(struct config_writer
*writer
,
555 struct ltt_kernel_channel
*kchan
)
558 struct ltt_kernel_event
*event
;
560 ret
= config_writer_open_element(writer
, config_element_events
);
562 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
566 cds_list_for_each_entry(event
, &kchan
->events_list
.head
, list
) {
567 ret
= save_kernel_event(writer
, event
);
573 /* Save syscalls if any. */
574 ret
= save_kernel_syscall(writer
, kchan
);
580 ret
= config_writer_close_element(writer
);
582 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
590 int save_ust_event(struct config_writer
*writer
,
591 struct ltt_ust_event
*event
)
594 const char *loglevel_type_string
;
596 ret
= config_writer_open_element(writer
, config_element_event
);
598 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
602 if (event
->attr
.name
[0]) {
603 ret
= config_writer_write_element_string(writer
,
604 config_element_name
, event
->attr
.name
);
606 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
611 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
614 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
618 if (event
->attr
.instrumentation
!= LTTNG_UST_TRACEPOINT
) {
619 ERR("Unsupported UST instrumentation type.");
620 ret
= LTTNG_ERR_INVALID
;
623 ret
= config_writer_write_element_string(writer
, config_element_type
,
624 config_event_type_tracepoint
);
626 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
630 loglevel_type_string
= get_loglevel_type_string(
631 event
->attr
.loglevel_type
);
632 if (!loglevel_type_string
) {
633 ERR("Unsupported UST loglevel type.");
634 ret
= LTTNG_ERR_INVALID
;
638 ret
= config_writer_write_element_string(writer
,
639 config_element_loglevel_type
, loglevel_type_string
);
641 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
645 /* The log level is irrelevant if no "filtering" is enabled */
646 if (event
->attr
.loglevel_type
!= LTTNG_UST_LOGLEVEL_ALL
) {
647 ret
= config_writer_write_element_signed_int(writer
,
648 config_element_loglevel
, event
->attr
.loglevel
);
650 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
655 if (event
->filter_expression
) {
656 ret
= config_writer_write_element_string(writer
,
657 config_element_filter
, event
->filter_expression
);
659 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
664 if (event
->exclusion
&& event
->exclusion
->count
) {
667 ret
= config_writer_open_element(writer
,
668 config_element_exclusions
);
670 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
674 for (i
= 0; i
< event
->exclusion
->count
; i
++) {
675 ret
= config_writer_write_element_string(writer
,
676 config_element_exclusion
,
677 &event
->exclusion
->names
[0][i
]);
679 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
685 ret
= config_writer_close_element(writer
);
687 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
693 ret
= config_writer_close_element(writer
);
695 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
703 int save_ust_events(struct config_writer
*writer
,
704 struct lttng_ht
*events
)
707 struct ltt_ust_event
*event
;
708 struct lttng_ht_node_str
*node
;
709 struct lttng_ht_iter iter
;
711 ret
= config_writer_open_element(writer
, config_element_events
);
713 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
718 cds_lfht_for_each_entry(events
->ht
, &iter
.iter
, node
, node
) {
719 event
= caa_container_of(node
, struct ltt_ust_event
, node
);
721 if (event
->internal
) {
722 /* Internal events must not be exposed to clients */
725 ret
= save_ust_event(writer
, event
);
734 ret
= config_writer_close_element(writer
);
736 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
744 int save_kernel_context(struct config_writer
*writer
,
745 struct lttng_kernel_context
*ctx
)
753 ret
= config_writer_open_element(writer
, config_element_context
);
755 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
759 if (ctx
->ctx
== LTTNG_KERNEL_CONTEXT_PERF_CPU_COUNTER
) {
760 ret
= config_writer_open_element(writer
, config_element_perf
);
762 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
766 ret
= config_writer_write_element_unsigned_int(writer
,
767 config_element_type
, ctx
->u
.perf_counter
.type
);
769 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
773 ret
= config_writer_write_element_unsigned_int(writer
,
774 config_element_config
, ctx
->u
.perf_counter
.config
);
776 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
780 ret
= config_writer_write_element_string(writer
,
781 config_element_name
, ctx
->u
.perf_counter
.name
);
783 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
788 ret
= config_writer_close_element(writer
);
790 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
794 const char *context_type_string
=
795 get_kernel_context_type_string(ctx
->ctx
);
797 if (!context_type_string
) {
798 ERR("Unsupported kernel context type.");
799 ret
= LTTNG_ERR_INVALID
;
803 ret
= config_writer_write_element_string(writer
,
804 config_element_type
, context_type_string
);
806 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
812 ret
= config_writer_close_element(writer
);
814 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
823 int save_kernel_contexts(struct config_writer
*writer
,
824 struct ltt_kernel_channel
*kchan
)
827 struct ltt_kernel_context
*ctx
;
829 if (cds_list_empty(&kchan
->ctx_list
)) {
834 ret
= config_writer_open_element(writer
, config_element_contexts
);
836 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
840 cds_list_for_each_entry(ctx
, &kchan
->ctx_list
, list
) {
841 ret
= save_kernel_context(writer
, &ctx
->ctx
);
848 ret
= config_writer_close_element(writer
);
850 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
858 int save_ust_context(struct config_writer
*writer
,
859 struct cds_list_head
*ctx_list
)
862 struct ltt_ust_context
*ctx
;
867 ret
= config_writer_open_element(writer
, config_element_contexts
);
869 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
873 cds_list_for_each_entry(ctx
, ctx_list
, list
) {
874 const char *context_type_string
;
877 ret
= config_writer_open_element(writer
,
878 config_element_context
);
880 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
884 if (ctx
->ctx
.ctx
== LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
) {
885 /* Perf contexts are saved as event_perf_context_type */
886 ret
= config_writer_open_element(writer
,
887 config_element_perf
);
889 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
893 ret
= config_writer_write_element_unsigned_int(writer
,
895 ctx
->ctx
.u
.perf_counter
.type
);
897 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
901 ret
= config_writer_write_element_unsigned_int(writer
,
902 config_element_config
,
903 ctx
->ctx
.u
.perf_counter
.config
);
905 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
909 ret
= config_writer_write_element_string(writer
,
911 ctx
->ctx
.u
.perf_counter
.name
);
913 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
918 ret
= config_writer_close_element(writer
);
920 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
924 /* Save context as event_context_type_type */
925 context_type_string
= get_ust_context_type_string(
927 if (!context_type_string
) {
928 ERR("Unsupported UST context type.")
929 ret
= LTTNG_ERR_INVALID
;
933 ret
= config_writer_write_element_string(writer
,
934 config_element_type
, context_type_string
);
936 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
942 ret
= config_writer_close_element(writer
);
944 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
950 ret
= config_writer_close_element(writer
);
952 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
960 int save_kernel_channel(struct config_writer
*writer
,
961 struct ltt_kernel_channel
*kchan
)
968 ret
= config_writer_open_element(writer
, config_element_channel
);
970 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
974 ret
= config_writer_write_element_string(writer
, config_element_name
,
975 kchan
->channel
->name
);
977 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
981 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
982 kchan
->channel
->enabled
);
984 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
988 ret
= save_kernel_channel_attributes(writer
, &kchan
->channel
->attr
);
993 ret
= save_kernel_events(writer
, kchan
);
998 ret
= save_kernel_contexts(writer
, kchan
);
1004 ret
= config_writer_close_element(writer
);
1006 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1014 int save_ust_channel(struct config_writer
*writer
,
1015 struct ltt_ust_channel
*ust_chan
,
1016 struct ltt_ust_session
*session
)
1024 ret
= config_writer_open_element(writer
, config_element_channel
);
1026 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1030 ret
= config_writer_write_element_string(writer
, config_element_name
,
1033 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1037 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1040 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1044 ret
= save_ust_channel_attributes(writer
, &ust_chan
->attr
);
1049 ret
= config_writer_write_element_unsigned_int(writer
,
1050 config_element_tracefile_size
, ust_chan
->tracefile_size
);
1052 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1056 ret
= config_writer_write_element_unsigned_int(writer
,
1057 config_element_tracefile_count
, ust_chan
->tracefile_count
);
1059 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1063 ret
= config_writer_write_element_unsigned_int(writer
,
1064 config_element_live_timer_interval
,
1065 session
->live_timer_interval
);
1067 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1071 ret
= save_ust_events(writer
, ust_chan
->events
);
1073 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1077 ret
= save_ust_context(writer
, &ust_chan
->ctx_list
);
1083 ret
= config_writer_close_element(writer
);
1085 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1093 int save_kernel_session(struct config_writer
*writer
,
1094 struct ltt_session
*session
)
1097 struct ltt_kernel_channel
*kchan
;
1102 ret
= config_writer_write_element_string(writer
, config_element_type
,
1103 config_domain_type_kernel
);
1105 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1109 ret
= config_writer_write_element_string(writer
,
1110 config_element_buffer_type
, config_buffer_type_global
);
1112 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1116 ret
= config_writer_open_element(writer
,
1117 config_element_channels
);
1119 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1123 cds_list_for_each_entry(kchan
, &session
->kernel_session
->channel_list
.head
,
1125 ret
= save_kernel_channel(writer
, kchan
);
1132 ret
= config_writer_close_element(writer
);
1134 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1142 int save_ust_session(struct config_writer
*writer
,
1143 struct ltt_session
*session
, int save_agent
)
1146 struct ltt_ust_channel
*ust_chan
;
1147 const char *buffer_type_string
;
1148 struct lttng_ht_node_str
*node
;
1149 struct lttng_ht_iter iter
;
1154 ret
= config_writer_write_element_string(writer
, config_element_type
,
1155 save_agent
? config_domain_type_jul
: config_domain_type_ust
);
1157 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1161 buffer_type_string
= get_buffer_type_string(
1162 session
->ust_session
->buffer_type
);
1163 if (!buffer_type_string
) {
1164 ERR("Unsupported buffer type.");
1165 ret
= LTTNG_ERR_INVALID
;
1169 ret
= config_writer_write_element_string(writer
,
1170 config_element_buffer_type
, buffer_type_string
);
1172 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1176 ret
= config_writer_open_element(writer
, config_element_channels
);
1178 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1183 cds_lfht_for_each_entry(session
->ust_session
->domain_global
.channels
->ht
,
1184 &iter
.iter
, node
, node
) {
1187 ust_chan
= caa_container_of(node
, struct ltt_ust_channel
, node
);
1188 agent_channel
= !strcmp(DEFAULT_JUL_CHANNEL_NAME
, ust_chan
->name
) ||
1189 !strcmp(DEFAULT_LOG4J_CHANNEL_NAME
, ust_chan
->name
) ||
1190 !strcmp(DEFAULT_PYTHON_CHANNEL_NAME
, ust_chan
->name
);
1191 if (!(save_agent
^ agent_channel
)) {
1192 ret
= save_ust_channel(writer
, ust_chan
, session
->ust_session
);
1202 ret
= config_writer_close_element(writer
);
1204 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1212 int save_pid_tracker(struct config_writer
*writer
,
1213 struct ltt_session
*sess
, int domain
)
1216 ssize_t nr_pids
= 0, i
;
1217 int32_t *pids
= NULL
;
1220 case LTTNG_DOMAIN_KERNEL
:
1222 nr_pids
= kernel_list_tracker_pids(sess
->kernel_session
, &pids
);
1224 ret
= LTTNG_ERR_KERN_LIST_FAIL
;
1229 case LTTNG_DOMAIN_UST
:
1231 nr_pids
= trace_ust_list_tracker_pids(sess
->ust_session
, &pids
);
1233 ret
= LTTNG_ERR_UST_LIST_FAIL
;
1238 case LTTNG_DOMAIN_JUL
:
1239 case LTTNG_DOMAIN_LOG4J
:
1240 case LTTNG_DOMAIN_PYTHON
:
1242 ret
= LTTNG_ERR_UNKNOWN_DOMAIN
;
1246 /* Only create a pid_tracker if enabled or untrack all */
1247 if (nr_pids
!= 1 || (nr_pids
== 1 && pids
[0] != -1)) {
1248 ret
= config_writer_open_element(writer
,
1249 config_element_pid_tracker
);
1251 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1255 ret
= config_writer_open_element(writer
,
1256 config_element_targets
);
1258 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1262 for (i
= 0; i
< nr_pids
; i
++) {
1263 ret
= config_writer_open_element(writer
,
1264 config_element_target_pid
);
1266 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1270 ret
= config_writer_write_element_unsigned_int(writer
,
1271 config_element_pid
, pids
[i
]);
1273 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1278 ret
= config_writer_close_element(writer
);
1280 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1286 ret
= config_writer_close_element(writer
);
1288 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1293 ret
= config_writer_close_element(writer
);
1295 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1305 int save_domains(struct config_writer
*writer
, struct ltt_session
*session
)
1312 if (!session
->kernel_session
&& !session
->ust_session
) {
1316 ret
= config_writer_open_element(writer
, config_element_domains
);
1318 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1323 if (session
->kernel_session
) {
1324 ret
= config_writer_open_element(writer
,
1325 config_element_domain
);
1327 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1331 ret
= save_kernel_session(writer
, session
);
1336 ret
= config_writer_open_element(writer
,
1337 config_element_trackers
);
1339 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1343 ret
= save_pid_tracker(writer
, session
, LTTNG_DOMAIN_KERNEL
);
1349 ret
= config_writer_close_element(writer
);
1351 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1355 ret
= config_writer_close_element(writer
);
1357 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1362 if (session
->ust_session
) {
1363 unsigned long agent_count
;
1365 ret
= config_writer_open_element(writer
,
1366 config_element_domain
);
1368 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1372 ret
= save_ust_session(writer
, session
, 0);
1377 ret
= config_writer_open_element(writer
,
1378 config_element_trackers
);
1380 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1384 ret
= save_pid_tracker(writer
, session
, LTTNG_DOMAIN_UST
);
1390 ret
= config_writer_close_element(writer
);
1392 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1396 ret
= config_writer_close_element(writer
);
1398 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1402 agent_count
= lttng_ht_get_count(session
->ust_session
->agents
);
1403 if (agent_count
> 0) {
1404 ret
= config_writer_open_element(writer
,
1405 config_element_domain
);
1407 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1411 ret
= save_ust_session(writer
, session
, 1);
1417 ret
= config_writer_close_element(writer
);
1419 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1426 ret
= config_writer_close_element(writer
);
1428 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1436 int save_consumer_output(struct config_writer
*writer
,
1437 struct consumer_output
*output
)
1444 ret
= config_writer_open_element(writer
, config_element_consumer_output
);
1446 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1450 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1453 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1457 ret
= config_writer_open_element(writer
, config_element_destination
);
1459 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1463 switch (output
->type
) {
1464 case CONSUMER_DST_LOCAL
:
1465 ret
= config_writer_write_element_string(writer
,
1466 config_element_path
, output
->dst
.trace_path
);
1468 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1472 case CONSUMER_DST_NET
:
1476 uri
= zmalloc(PATH_MAX
);
1478 ret
= LTTNG_ERR_NOMEM
;
1482 ret
= config_writer_open_element(writer
, config_element_net_output
);
1484 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1485 goto end_net_output
;
1488 if (output
->dst
.net
.control_isset
&&
1489 output
->dst
.net
.data_isset
) {
1490 ret
= uri_to_str_url(&output
->dst
.net
.control
, uri
, PATH_MAX
);
1492 ret
= LTTNG_ERR_INVALID
;
1493 goto end_net_output
;
1496 ret
= config_writer_write_element_string(writer
,
1497 config_element_control_uri
, uri
);
1499 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1500 goto end_net_output
;
1503 ret
= uri_to_str_url(&output
->dst
.net
.data
, uri
, PATH_MAX
);
1505 ret
= LTTNG_ERR_INVALID
;
1506 goto end_net_output
;
1509 ret
= config_writer_write_element_string(writer
,
1510 config_element_data_uri
, uri
);
1512 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1513 goto end_net_output
;
1522 ret
= !output
->dst
.net
.control_isset
?
1523 LTTNG_ERR_URL_CTRL_MISS
:
1524 LTTNG_ERR_URL_DATA_MISS
;
1529 ret
= config_writer_close_element(writer
);
1531 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1537 ERR("Unsupported consumer output type.");
1538 ret
= LTTNG_ERR_INVALID
;
1543 ret
= config_writer_close_element(writer
);
1545 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1549 /* /consumer_output */
1550 ret
= config_writer_close_element(writer
);
1552 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1560 int save_snapshot_outputs(struct config_writer
*writer
,
1561 struct snapshot
*snapshot
)
1564 struct lttng_ht_iter iter
;
1565 struct snapshot_output
*output
;
1570 ret
= config_writer_open_element(writer
, config_element_snapshot_outputs
);
1572 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1577 cds_lfht_for_each_entry(snapshot
->output_ht
->ht
, &iter
.iter
, output
,
1579 ret
= config_writer_open_element(writer
,
1580 config_element_output
);
1582 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1586 ret
= config_writer_write_element_string(writer
,
1587 config_element_name
, output
->name
);
1589 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1593 ret
= config_writer_write_element_unsigned_int(writer
,
1594 config_element_max_size
, output
->max_size
);
1596 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1600 ret
= save_consumer_output(writer
, output
->consumer
);
1606 ret
= config_writer_close_element(writer
);
1608 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1614 /* /snapshot_outputs */
1615 ret
= config_writer_close_element(writer
);
1617 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1629 int save_session_output(struct config_writer
*writer
,
1630 struct ltt_session
*session
)
1637 if ((session
->snapshot_mode
&& session
->snapshot
.nb_output
== 0) ||
1638 (!session
->snapshot_mode
&& !session
->consumer
)) {
1639 /* Session is in no output mode */
1644 ret
= config_writer_open_element(writer
, config_element_output
);
1646 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1650 if (session
->snapshot_mode
) {
1651 ret
= save_snapshot_outputs(writer
, &session
->snapshot
);
1656 if (session
->consumer
) {
1657 ret
= save_consumer_output(writer
, session
->consumer
);
1665 ret
= config_writer_close_element(writer
);
1667 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1675 * Save the given session.
1677 * Return 0 on success else a LTTNG_ERR* code.
1680 int save_session(struct ltt_session
*session
,
1681 struct lttng_save_session_attr
*attr
, lttng_sock_cred
*creds
)
1684 unsigned int file_opened
= 0; /* Indicate if the file has been opened */
1685 char config_file_path
[PATH_MAX
];
1687 struct config_writer
*writer
= NULL
;
1688 size_t session_name_len
;
1689 const char *provided_path
;
1695 session_name_len
= strlen(session
->name
);
1696 memset(config_file_path
, 0, sizeof(config_file_path
));
1698 if (!session_access_ok(session
,
1699 LTTNG_SOCK_GET_UID_CRED(creds
),
1700 LTTNG_SOCK_GET_GID_CRED(creds
))) {
1701 ret
= LTTNG_ERR_EPERM
;
1705 provided_path
= lttng_save_session_attr_get_output_url(attr
);
1706 if (provided_path
) {
1707 DBG3("Save session in provided path %s", provided_path
);
1708 len
= strlen(provided_path
);
1709 if (len
>= sizeof(config_file_path
)) {
1710 ret
= LTTNG_ERR_SET_URL
;
1713 strncpy(config_file_path
, provided_path
, len
);
1716 char *home_dir
= utils_get_user_home_dir(
1717 LTTNG_SOCK_GET_UID_CRED(creds
));
1719 ret
= LTTNG_ERR_SET_URL
;
1723 ret_len
= snprintf(config_file_path
, sizeof(config_file_path
),
1724 DEFAULT_SESSION_HOME_CONFIGPATH
, home_dir
);
1727 PERROR("snprintf save session");
1728 ret
= LTTNG_ERR_SET_URL
;
1735 * Check the path fits in the config file path dst including the '/'
1736 * followed by trailing .lttng extension and the NULL terminated string.
1738 if ((len
+ session_name_len
+ 2 +
1739 sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
))
1740 > sizeof(config_file_path
)) {
1741 ret
= LTTNG_ERR_SET_URL
;
1745 ret
= run_as_mkdir_recursive(config_file_path
, S_IRWXU
| S_IRWXG
,
1746 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
1748 ret
= LTTNG_ERR_SET_URL
;
1753 * At this point, we know that everything fits in the buffer. Validation
1754 * was done just above.
1756 config_file_path
[len
++] = '/';
1757 strncpy(config_file_path
+ len
, session
->name
, session_name_len
);
1758 len
+= session_name_len
;
1759 strcpy(config_file_path
+ len
, DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
1760 len
+= sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
1761 config_file_path
[len
] = '\0';
1763 if (!access(config_file_path
, F_OK
) && !attr
->overwrite
) {
1764 /* File exists, notify the user since the overwrite flag is off. */
1765 ret
= LTTNG_ERR_SAVE_FILE_EXIST
;
1769 fd
= run_as_open(config_file_path
, O_CREAT
| O_WRONLY
| O_TRUNC
,
1770 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
,
1771 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
1773 PERROR("Could not create configuration file");
1774 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1779 writer
= config_writer_create(fd
, 1);
1781 ret
= LTTNG_ERR_NOMEM
;
1785 ret
= config_writer_open_element(writer
, config_element_sessions
);
1787 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1791 ret
= config_writer_open_element(writer
, config_element_session
);
1793 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1797 ret
= config_writer_write_element_string(writer
, config_element_name
,
1800 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1804 if(session
->shm_path
[0] != '\0') {
1805 ret
= config_writer_write_element_string(writer
,
1806 config_element_shared_memory_path
,
1809 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1814 ret
= save_domains(writer
, session
);
1819 ret
= config_writer_write_element_bool(writer
, config_element_started
,
1822 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1826 if (session
->snapshot_mode
|| session
->live_timer
) {
1827 ret
= config_writer_open_element(writer
, config_element_attributes
);
1829 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1833 if (session
->snapshot_mode
) {
1834 ret
= config_writer_write_element_bool(writer
,
1835 config_element_snapshot_mode
, 1);
1837 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1841 ret
= config_writer_write_element_unsigned_int(writer
,
1842 config_element_live_timer_interval
, session
->live_timer
);
1844 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1850 ret
= config_writer_close_element(writer
);
1852 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1857 ret
= save_session_output(writer
, session
);
1863 ret
= config_writer_close_element(writer
);
1865 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1870 ret
= config_writer_close_element(writer
);
1872 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1876 if (writer
&& config_writer_destroy(writer
)) {
1877 /* Preserve the original error code */
1878 ret
= ret
? ret
: LTTNG_ERR_SAVE_IO_FAIL
;
1881 /* Delete file in case of error */
1882 if (file_opened
&& unlink(config_file_path
)) {
1883 PERROR("Unlinking XML session configuration.");
1890 int cmd_save_sessions(struct lttng_save_session_attr
*attr
,
1891 lttng_sock_cred
*creds
)
1894 const char *session_name
;
1895 struct ltt_session
*session
;
1897 session_lock_list();
1899 session_name
= lttng_save_session_attr_get_session_name(attr
);
1901 session
= session_find_by_name(session_name
);
1903 ret
= LTTNG_ERR_SESS_NOT_FOUND
;
1907 session_lock(session
);
1908 ret
= save_session(session
, attr
, creds
);
1909 session_unlock(session
);
1914 struct ltt_session_list
*list
= session_get_list();
1916 cds_list_for_each_entry(session
, &list
->head
, list
) {
1917 session_lock(session
);
1918 ret
= save_session(session
, attr
, creds
);
1919 session_unlock(session
);
1921 /* Don't abort if we don't have the required permissions. */
1922 if (ret
&& ret
!= LTTNG_ERR_EPERM
) {
1930 session_unlock_list();