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.
22 #include <urcu/uatomic.h>
25 #include <common/defaults.h>
26 #include <common/error.h>
27 #include <common/config/session-config.h>
28 #include <common/utils.h>
29 #include <common/runas.h>
30 #include <lttng/save-internal.h>
35 #include "lttng-syscall.h"
36 #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 if (attr
->extended
.ptr
) {
109 struct lttng_channel_extended
*ext
= NULL
;
111 ext
= (struct lttng_channel_extended
*) attr
->extended
.ptr
;
112 ret
= config_writer_write_element_unsigned_int(writer
,
113 config_element_monitor_timer_interval
,
114 ext
->monitor_timer_interval
);
119 ret
= config_writer_write_element_signed_int(writer
,
120 config_element_blocking_timeout
,
121 ext
->blocking_timeout
);
128 return ret
? LTTNG_ERR_SAVE_IO_FAIL
: 0;
132 int save_ust_channel_attributes(struct config_writer
*writer
,
133 struct lttng_ust_channel_attr
*attr
)
136 struct ltt_ust_channel
*channel
= NULL
;
138 ret
= config_writer_write_element_string(writer
,
139 config_element_overwrite_mode
,
140 attr
->overwrite
? config_overwrite_mode_overwrite
:
141 config_overwrite_mode_discard
);
146 ret
= config_writer_write_element_unsigned_int(writer
,
147 config_element_subbuf_size
, attr
->subbuf_size
);
152 ret
= config_writer_write_element_unsigned_int(writer
,
153 config_element_num_subbuf
,
159 ret
= config_writer_write_element_unsigned_int(writer
,
160 config_element_switch_timer_interval
,
161 attr
->switch_timer_interval
);
166 ret
= config_writer_write_element_unsigned_int(writer
,
167 config_element_read_timer_interval
,
168 attr
->read_timer_interval
);
173 ret
= config_writer_write_element_string(writer
,
174 config_element_output_type
,
175 attr
->output
== LTTNG_UST_MMAP
?
176 config_output_type_mmap
: config_output_type_splice
);
181 ret
= config_writer_write_element_signed_int(writer
,
182 config_element_blocking_timeout
,
183 attr
->u
.s
.blocking_timeout
);
189 * Fetch the monitor timer which is located in the parent of
190 * lttng_ust_channel_attr
192 channel
= caa_container_of(attr
, struct ltt_ust_channel
, attr
);
193 ret
= config_writer_write_element_unsigned_int(writer
,
194 config_element_monitor_timer_interval
,
195 channel
->monitor_timer_interval
);
201 return ret
? LTTNG_ERR_SAVE_IO_FAIL
: 0;
205 const char *get_kernel_instrumentation_string(
206 enum lttng_kernel_instrumentation instrumentation
)
208 const char *instrumentation_string
;
210 switch (instrumentation
) {
211 case LTTNG_KERNEL_ALL
:
212 instrumentation_string
= config_event_type_all
;
214 case LTTNG_KERNEL_TRACEPOINT
:
215 instrumentation_string
= config_event_type_tracepoint
;
217 case LTTNG_KERNEL_KPROBE
:
218 instrumentation_string
= config_event_type_kprobe
;
220 case LTTNG_KERNEL_FUNCTION
:
221 instrumentation_string
= config_event_type_function
;
223 case LTTNG_KERNEL_KRETPROBE
:
224 instrumentation_string
= config_event_type_kretprobe
;
226 case LTTNG_KERNEL_NOOP
:
227 instrumentation_string
= config_event_type_noop
;
229 case LTTNG_KERNEL_SYSCALL
:
230 instrumentation_string
= config_event_type_syscall
;
233 instrumentation_string
= NULL
;
236 return instrumentation_string
;
240 const char *get_kernel_context_type_string(
241 enum lttng_kernel_context_type context_type
)
243 const char *context_type_string
;
245 switch (context_type
) {
246 case LTTNG_KERNEL_CONTEXT_PID
:
247 context_type_string
= config_event_context_pid
;
249 case LTTNG_KERNEL_CONTEXT_PROCNAME
:
250 context_type_string
= config_event_context_procname
;
252 case LTTNG_KERNEL_CONTEXT_PRIO
:
253 context_type_string
= config_event_context_prio
;
255 case LTTNG_KERNEL_CONTEXT_NICE
:
256 context_type_string
= config_event_context_nice
;
258 case LTTNG_KERNEL_CONTEXT_VPID
:
259 context_type_string
= config_event_context_vpid
;
261 case LTTNG_KERNEL_CONTEXT_TID
:
262 context_type_string
= config_event_context_tid
;
264 case LTTNG_KERNEL_CONTEXT_VTID
:
265 context_type_string
= config_event_context_vtid
;
267 case LTTNG_KERNEL_CONTEXT_PPID
:
268 context_type_string
= config_event_context_ppid
;
270 case LTTNG_KERNEL_CONTEXT_VPPID
:
271 context_type_string
= config_event_context_vppid
;
273 case LTTNG_KERNEL_CONTEXT_HOSTNAME
:
274 context_type_string
= config_event_context_hostname
;
276 case LTTNG_KERNEL_CONTEXT_INTERRUPTIBLE
:
277 context_type_string
= config_event_context_interruptible
;
279 case LTTNG_KERNEL_CONTEXT_PREEMPTIBLE
:
280 context_type_string
= config_event_context_preemptible
;
282 case LTTNG_KERNEL_CONTEXT_NEED_RESCHEDULE
:
283 context_type_string
= config_event_context_need_reschedule
;
285 case LTTNG_KERNEL_CONTEXT_MIGRATABLE
:
286 context_type_string
= config_event_context_migratable
;
288 case LTTNG_KERNEL_CONTEXT_CALLSTACK_USER
:
289 context_type_string
= config_event_context_callstack_user
;
291 case LTTNG_KERNEL_CONTEXT_CALLSTACK_KERNEL
:
292 context_type_string
= config_event_context_callstack_kernel
;
295 context_type_string
= NULL
;
298 return context_type_string
;
302 const char *get_ust_context_type_string(
303 enum lttng_ust_context_type context_type
)
305 const char *context_type_string
;
307 switch (context_type
) {
308 case LTTNG_UST_CONTEXT_PROCNAME
:
309 context_type_string
= config_event_context_procname
;
311 case LTTNG_UST_CONTEXT_VPID
:
312 context_type_string
= config_event_context_vpid
;
314 case LTTNG_UST_CONTEXT_VTID
:
315 context_type_string
= config_event_context_vtid
;
317 case LTTNG_UST_CONTEXT_IP
:
318 context_type_string
= config_event_context_ip
;
320 case LTTNG_UST_CONTEXT_PTHREAD_ID
:
321 context_type_string
= config_event_context_pthread_id
;
323 case LTTNG_UST_CONTEXT_APP_CONTEXT
:
324 context_type_string
= config_event_context_app
;
326 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
:
328 * Error, should not be stored in the XML, perf contexts
329 * are stored as a node of type event_perf_context_type.
332 context_type_string
= NULL
;
336 return context_type_string
;
340 const char *get_buffer_type_string(
341 enum lttng_buffer_type buffer_type
)
343 const char *buffer_type_string
;
345 switch (buffer_type
) {
346 case LTTNG_BUFFER_PER_PID
:
347 buffer_type_string
= config_buffer_type_per_pid
;
349 case LTTNG_BUFFER_PER_UID
:
350 buffer_type_string
= config_buffer_type_per_uid
;
352 case LTTNG_BUFFER_GLOBAL
:
353 buffer_type_string
= config_buffer_type_global
;
356 buffer_type_string
= NULL
;
359 return buffer_type_string
;
363 const char *get_loglevel_type_string(
364 enum lttng_ust_loglevel_type loglevel_type
)
366 const char *loglevel_type_string
;
368 switch (loglevel_type
) {
369 case LTTNG_UST_LOGLEVEL_ALL
:
370 loglevel_type_string
= config_loglevel_type_all
;
372 case LTTNG_UST_LOGLEVEL_RANGE
:
373 loglevel_type_string
= config_loglevel_type_range
;
375 case LTTNG_UST_LOGLEVEL_SINGLE
:
376 loglevel_type_string
= config_loglevel_type_single
;
379 loglevel_type_string
= NULL
;
382 return loglevel_type_string
;
386 int save_kernel_function_event(struct config_writer
*writer
,
387 struct ltt_kernel_event
*event
)
391 ret
= config_writer_open_element(writer
, config_element_function_attributes
);
393 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
397 ret
= config_writer_write_element_string(writer
, config_element_name
,
398 event
->event
->u
.ftrace
.symbol_name
);
400 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
404 /* /function attributes */
405 ret
= config_writer_close_element(writer
);
407 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
415 int save_kernel_kprobe_event(struct config_writer
*writer
,
416 struct ltt_kernel_event
*event
)
419 const char *symbol_name
;
423 switch (event
->event
->instrumentation
) {
424 case LTTNG_KERNEL_KPROBE
:
426 * Comments in lttng-kernel.h mention that
427 * either addr or symbol_name are set, not both.
429 addr
= event
->event
->u
.kprobe
.addr
;
430 offset
= event
->event
->u
.kprobe
.offset
;
431 symbol_name
= addr
? NULL
: event
->event
->u
.kprobe
.symbol_name
;
433 case LTTNG_KERNEL_KRETPROBE
:
434 addr
= event
->event
->u
.kretprobe
.addr
;
435 offset
= event
->event
->u
.kretprobe
.offset
;
436 symbol_name
= event
->event
->u
.kretprobe
.symbol_name
;
442 ret
= config_writer_open_element(writer
, config_element_probe_attributes
);
444 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
449 ret
= config_writer_write_element_string(writer
,
450 config_element_symbol_name
, symbol_name
);
452 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
458 ret
= config_writer_write_element_unsigned_int( writer
,
459 config_element_address
, addr
);
461 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
467 ret
= config_writer_write_element_unsigned_int(writer
,
468 config_element_offset
, offset
);
470 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
475 ret
= config_writer_close_element(writer
);
477 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
483 int save_kernel_event(struct config_writer
*writer
,
484 struct ltt_kernel_event
*event
)
487 const char *instrumentation_type
;
489 ret
= config_writer_open_element(writer
, config_element_event
);
491 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
495 if (event
->event
->name
[0]) {
496 ret
= config_writer_write_element_string(writer
,
497 config_element_name
, event
->event
->name
);
499 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
504 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
507 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
511 instrumentation_type
= get_kernel_instrumentation_string(
512 event
->event
->instrumentation
);
513 if (!instrumentation_type
) {
514 ret
= LTTNG_ERR_INVALID
;
518 ret
= config_writer_write_element_string(writer
, config_element_type
,
519 instrumentation_type
);
521 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
525 if (event
->filter_expression
) {
526 ret
= config_writer_write_element_string(writer
,
527 config_element_filter
,
528 event
->filter_expression
);
530 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
535 if (event
->event
->instrumentation
== LTTNG_KERNEL_FUNCTION
||
536 event
->event
->instrumentation
== LTTNG_KERNEL_KPROBE
||
537 event
->event
->instrumentation
== LTTNG_KERNEL_KRETPROBE
) {
539 ret
= config_writer_open_element(writer
,
540 config_element_attributes
);
542 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
546 switch (event
->event
->instrumentation
) {
547 case LTTNG_KERNEL_SYSCALL
:
548 case LTTNG_KERNEL_FUNCTION
:
549 ret
= save_kernel_function_event(writer
, event
);
554 case LTTNG_KERNEL_KPROBE
:
555 case LTTNG_KERNEL_KRETPROBE
:
556 ret
= save_kernel_kprobe_event(writer
, event
);
562 ERR("Unsupported kernel instrumentation type.");
563 ret
= LTTNG_ERR_INVALID
;
568 ret
= config_writer_close_element(writer
);
570 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
576 ret
= config_writer_close_element(writer
);
578 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
586 int save_kernel_events(struct config_writer
*writer
,
587 struct ltt_kernel_channel
*kchan
)
590 struct ltt_kernel_event
*event
;
592 ret
= config_writer_open_element(writer
, config_element_events
);
594 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
598 cds_list_for_each_entry(event
, &kchan
->events_list
.head
, list
) {
599 ret
= save_kernel_event(writer
, event
);
606 ret
= config_writer_close_element(writer
);
608 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
616 int save_ust_event(struct config_writer
*writer
,
617 struct ltt_ust_event
*event
)
620 const char *loglevel_type_string
;
622 ret
= config_writer_open_element(writer
, config_element_event
);
624 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
628 if (event
->attr
.name
[0]) {
629 ret
= config_writer_write_element_string(writer
,
630 config_element_name
, event
->attr
.name
);
632 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
637 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
640 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
644 if (event
->attr
.instrumentation
!= LTTNG_UST_TRACEPOINT
) {
645 ERR("Unsupported UST instrumentation type.");
646 ret
= LTTNG_ERR_INVALID
;
649 ret
= config_writer_write_element_string(writer
, config_element_type
,
650 config_event_type_tracepoint
);
652 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
656 loglevel_type_string
= get_loglevel_type_string(
657 event
->attr
.loglevel_type
);
658 if (!loglevel_type_string
) {
659 ERR("Unsupported UST loglevel type.");
660 ret
= LTTNG_ERR_INVALID
;
664 ret
= config_writer_write_element_string(writer
,
665 config_element_loglevel_type
, loglevel_type_string
);
667 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
671 /* The log level is irrelevant if no "filtering" is enabled */
672 if (event
->attr
.loglevel_type
!= LTTNG_UST_LOGLEVEL_ALL
) {
673 ret
= config_writer_write_element_signed_int(writer
,
674 config_element_loglevel
, event
->attr
.loglevel
);
676 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
681 if (event
->filter_expression
) {
682 ret
= config_writer_write_element_string(writer
,
683 config_element_filter
, event
->filter_expression
);
685 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
690 if (event
->exclusion
&& event
->exclusion
->count
) {
693 ret
= config_writer_open_element(writer
,
694 config_element_exclusions
);
696 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
700 for (i
= 0; i
< event
->exclusion
->count
; i
++) {
701 ret
= config_writer_write_element_string(writer
,
702 config_element_exclusion
,
703 LTTNG_EVENT_EXCLUSION_NAME_AT(
704 event
->exclusion
, i
));
706 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
712 ret
= config_writer_close_element(writer
);
714 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
720 ret
= config_writer_close_element(writer
);
722 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
730 int save_ust_events(struct config_writer
*writer
,
731 struct lttng_ht
*events
)
734 struct ltt_ust_event
*event
;
735 struct lttng_ht_node_str
*node
;
736 struct lttng_ht_iter iter
;
738 ret
= config_writer_open_element(writer
, config_element_events
);
740 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
745 cds_lfht_for_each_entry(events
->ht
, &iter
.iter
, node
, node
) {
746 event
= caa_container_of(node
, struct ltt_ust_event
, node
);
748 if (event
->internal
) {
749 /* Internal events must not be exposed to clients */
752 ret
= save_ust_event(writer
, event
);
761 ret
= config_writer_close_element(writer
);
763 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
771 int init_ust_event_from_agent_event(struct ltt_ust_event
*ust_event
,
772 struct agent_event
*agent_event
)
775 enum lttng_ust_loglevel_type ust_loglevel_type
;
777 ust_event
->enabled
= agent_event
->enabled
;
778 ust_event
->attr
.instrumentation
= LTTNG_UST_TRACEPOINT
;
779 if (lttng_strncpy(ust_event
->attr
.name
, agent_event
->name
,
780 LTTNG_SYMBOL_NAME_LEN
)) {
784 switch (agent_event
->loglevel_type
) {
785 case LTTNG_EVENT_LOGLEVEL_ALL
:
786 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_ALL
;
788 case LTTNG_EVENT_LOGLEVEL_SINGLE
:
789 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_SINGLE
;
791 case LTTNG_EVENT_LOGLEVEL_RANGE
:
792 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_RANGE
;
795 ERR("Invalid agent_event loglevel_type.");
800 ust_event
->attr
.loglevel_type
= ust_loglevel_type
;
801 ust_event
->attr
.loglevel
= agent_event
->loglevel_value
;
802 ust_event
->filter_expression
= agent_event
->filter_expression
;
803 ust_event
->exclusion
= agent_event
->exclusion
;
809 int save_agent_events(struct config_writer
*writer
,
813 struct lttng_ht_iter iter
;
814 struct lttng_ht_node_str
*node
;
816 ret
= config_writer_open_element(writer
, config_element_events
);
818 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
823 cds_lfht_for_each_entry(agent
->events
->ht
, &iter
.iter
, node
, node
) {
825 struct agent_event
*agent_event
;
826 struct ltt_ust_event fake_event
;
828 memset(&fake_event
, 0, sizeof(fake_event
));
829 agent_event
= caa_container_of(node
, struct agent_event
, node
);
832 * Initialize a fake ust event to reuse the same serialization
833 * function since UST and agent events contain the same info
834 * (and one could wonder why they don't reuse the same
837 ret
= init_ust_event_from_agent_event(&fake_event
, agent_event
);
842 ret
= save_ust_event(writer
, &fake_event
);
851 ret
= config_writer_close_element(writer
);
853 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
861 int save_kernel_context(struct config_writer
*writer
,
862 struct lttng_kernel_context
*ctx
)
870 ret
= config_writer_open_element(writer
, config_element_context
);
872 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
876 if (ctx
->ctx
== LTTNG_KERNEL_CONTEXT_PERF_CPU_COUNTER
) {
877 ret
= config_writer_open_element(writer
,
878 config_element_context_perf
);
880 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
884 ret
= config_writer_write_element_unsigned_int(writer
,
885 config_element_type
, ctx
->u
.perf_counter
.type
);
887 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
891 ret
= config_writer_write_element_unsigned_int(writer
,
892 config_element_config
, ctx
->u
.perf_counter
.config
);
894 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
898 ret
= config_writer_write_element_string(writer
,
899 config_element_name
, ctx
->u
.perf_counter
.name
);
901 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
906 ret
= config_writer_close_element(writer
);
908 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
912 const char *context_type_string
=
913 get_kernel_context_type_string(ctx
->ctx
);
915 if (!context_type_string
) {
916 ERR("Unsupported kernel context type.");
917 ret
= LTTNG_ERR_INVALID
;
921 ret
= config_writer_write_element_string(writer
,
922 config_element_type
, context_type_string
);
924 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
930 ret
= config_writer_close_element(writer
);
932 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
941 int save_kernel_contexts(struct config_writer
*writer
,
942 struct ltt_kernel_channel
*kchan
)
945 struct ltt_kernel_context
*ctx
;
947 if (cds_list_empty(&kchan
->ctx_list
)) {
952 ret
= config_writer_open_element(writer
, config_element_contexts
);
954 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
958 cds_list_for_each_entry(ctx
, &kchan
->ctx_list
, list
) {
959 ret
= save_kernel_context(writer
, &ctx
->ctx
);
966 ret
= config_writer_close_element(writer
);
968 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
976 int save_ust_context_perf_thread_counter(struct config_writer
*writer
,
977 struct ltt_ust_context
*ctx
)
984 /* Perf contexts are saved as event_perf_context_type */
985 ret
= config_writer_open_element(writer
, config_element_context_perf
);
987 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
991 ret
= config_writer_write_element_unsigned_int(writer
,
992 config_element_type
, ctx
->ctx
.u
.perf_counter
.type
);
994 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
998 ret
= config_writer_write_element_unsigned_int(writer
,
999 config_element_config
, ctx
->ctx
.u
.perf_counter
.config
);
1001 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1005 ret
= config_writer_write_element_string(writer
, config_element_name
,
1006 ctx
->ctx
.u
.perf_counter
.name
);
1008 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1013 ret
= config_writer_close_element(writer
);
1015 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1023 int save_ust_context_app_ctx(struct config_writer
*writer
,
1024 struct ltt_ust_context
*ctx
)
1031 /* Application contexts are saved as application_context_type */
1032 ret
= config_writer_open_element(writer
, config_element_context_app
);
1034 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1038 ret
= config_writer_write_element_string(writer
,
1039 config_element_context_app_provider_name
,
1040 ctx
->ctx
.u
.app_ctx
.provider_name
);
1042 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1046 ret
= config_writer_write_element_string(writer
,
1047 config_element_context_app_ctx_name
,
1048 ctx
->ctx
.u
.app_ctx
.ctx_name
);
1050 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1055 ret
= config_writer_close_element(writer
);
1057 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1065 int save_ust_context_generic(struct config_writer
*writer
,
1066 struct ltt_ust_context
*ctx
)
1069 const char *context_type_string
;
1074 /* Save context as event_context_type_type */
1075 context_type_string
= get_ust_context_type_string(
1077 if (!context_type_string
) {
1078 ERR("Unsupported UST context type.");
1079 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1083 ret
= config_writer_write_element_string(writer
,
1084 config_element_type
, context_type_string
);
1086 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1094 int save_ust_context(struct config_writer
*writer
,
1095 struct cds_list_head
*ctx_list
)
1098 struct ltt_ust_context
*ctx
;
1103 ret
= config_writer_open_element(writer
, config_element_contexts
);
1105 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1109 cds_list_for_each_entry(ctx
, ctx_list
, list
) {
1110 ret
= config_writer_open_element(writer
,
1111 config_element_context
);
1113 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1117 switch (ctx
->ctx
.ctx
) {
1118 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
:
1119 ret
= save_ust_context_perf_thread_counter(writer
, ctx
);
1121 case LTTNG_UST_CONTEXT_APP_CONTEXT
:
1122 ret
= save_ust_context_app_ctx(writer
, ctx
);
1125 /* Save generic context. */
1126 ret
= save_ust_context_generic(writer
, ctx
);
1133 ret
= config_writer_close_element(writer
);
1135 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1141 ret
= config_writer_close_element(writer
);
1143 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1151 int save_kernel_channel(struct config_writer
*writer
,
1152 struct ltt_kernel_channel
*kchan
)
1159 ret
= config_writer_open_element(writer
, config_element_channel
);
1161 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1165 ret
= config_writer_write_element_string(writer
, config_element_name
,
1166 kchan
->channel
->name
);
1168 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1172 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1173 kchan
->channel
->enabled
);
1175 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1179 ret
= save_kernel_channel_attributes(writer
, &kchan
->channel
->attr
);
1184 ret
= save_kernel_events(writer
, kchan
);
1189 ret
= save_kernel_contexts(writer
, kchan
);
1195 ret
= config_writer_close_element(writer
);
1197 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1205 int save_ust_channel(struct config_writer
*writer
,
1206 struct ltt_ust_channel
*ust_chan
,
1207 struct ltt_ust_session
*session
)
1215 ret
= config_writer_open_element(writer
, config_element_channel
);
1217 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1221 ret
= config_writer_write_element_string(writer
, config_element_name
,
1224 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1228 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1231 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1235 ret
= save_ust_channel_attributes(writer
, &ust_chan
->attr
);
1240 ret
= config_writer_write_element_unsigned_int(writer
,
1241 config_element_tracefile_size
, ust_chan
->tracefile_size
);
1243 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1247 ret
= config_writer_write_element_unsigned_int(writer
,
1248 config_element_tracefile_count
, ust_chan
->tracefile_count
);
1250 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1254 ret
= config_writer_write_element_unsigned_int(writer
,
1255 config_element_live_timer_interval
,
1256 session
->live_timer_interval
);
1258 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1262 if (ust_chan
->domain
== LTTNG_DOMAIN_UST
) {
1263 ret
= save_ust_events(writer
, ust_chan
->events
);
1268 struct agent
*agent
= NULL
;
1270 agent
= trace_ust_find_agent(session
, ust_chan
->domain
);
1272 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1273 ERR("Could not find agent associated to UST subdomain");
1278 * Channels associated with a UST sub-domain (such as JUL, Log4j
1279 * or Python) don't have any non-internal events. We retrieve
1280 * the "agent" events associated with this channel and serialize
1283 ret
= save_agent_events(writer
, agent
);
1289 ret
= save_ust_context(writer
, &ust_chan
->ctx_list
);
1295 ret
= config_writer_close_element(writer
);
1297 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1305 int save_kernel_session(struct config_writer
*writer
,
1306 struct ltt_session
*session
)
1309 struct ltt_kernel_channel
*kchan
;
1314 ret
= config_writer_write_element_string(writer
, config_element_type
,
1315 config_domain_type_kernel
);
1317 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1321 ret
= config_writer_write_element_string(writer
,
1322 config_element_buffer_type
, config_buffer_type_global
);
1324 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1328 ret
= config_writer_open_element(writer
,
1329 config_element_channels
);
1331 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1335 cds_list_for_each_entry(kchan
, &session
->kernel_session
->channel_list
.head
,
1337 ret
= save_kernel_channel(writer
, kchan
);
1344 ret
= config_writer_close_element(writer
);
1346 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1354 const char *get_config_domain_str(enum lttng_domain_type domain
)
1356 const char *str_dom
;
1359 case LTTNG_DOMAIN_KERNEL
:
1360 str_dom
= config_domain_type_kernel
;
1362 case LTTNG_DOMAIN_UST
:
1363 str_dom
= config_domain_type_ust
;
1365 case LTTNG_DOMAIN_JUL
:
1366 str_dom
= config_domain_type_jul
;
1368 case LTTNG_DOMAIN_LOG4J
:
1369 str_dom
= config_domain_type_log4j
;
1371 case LTTNG_DOMAIN_PYTHON
:
1372 str_dom
= config_domain_type_python
;
1382 int save_pid_tracker(struct config_writer
*writer
,
1383 struct ltt_session
*sess
, int domain
)
1386 ssize_t nr_pids
= 0, i
;
1387 int32_t *pids
= NULL
;
1390 case LTTNG_DOMAIN_KERNEL
:
1392 nr_pids
= kernel_list_tracker_pids(sess
->kernel_session
, &pids
);
1394 ret
= LTTNG_ERR_KERN_LIST_FAIL
;
1399 case LTTNG_DOMAIN_UST
:
1401 nr_pids
= trace_ust_list_tracker_pids(sess
->ust_session
, &pids
);
1403 ret
= LTTNG_ERR_UST_LIST_FAIL
;
1408 case LTTNG_DOMAIN_JUL
:
1409 case LTTNG_DOMAIN_LOG4J
:
1410 case LTTNG_DOMAIN_PYTHON
:
1412 ret
= LTTNG_ERR_UNKNOWN_DOMAIN
;
1416 /* Only create a pid_tracker if enabled or untrack all */
1417 if (nr_pids
!= 1 || (nr_pids
== 1 && pids
[0] != -1)) {
1418 ret
= config_writer_open_element(writer
,
1419 config_element_pid_tracker
);
1421 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1425 ret
= config_writer_open_element(writer
,
1426 config_element_targets
);
1428 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1432 for (i
= 0; i
< nr_pids
; i
++) {
1433 ret
= config_writer_open_element(writer
,
1434 config_element_target_pid
);
1436 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1440 ret
= config_writer_write_element_unsigned_int(writer
,
1441 config_element_pid
, pids
[i
]);
1443 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1448 ret
= config_writer_close_element(writer
);
1450 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1456 ret
= config_writer_close_element(writer
);
1458 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1463 ret
= config_writer_close_element(writer
);
1465 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1475 int save_ust_domain(struct config_writer
*writer
,
1476 struct ltt_session
*session
, enum lttng_domain_type domain
)
1479 struct ltt_ust_channel
*ust_chan
;
1480 const char *buffer_type_string
;
1481 struct lttng_ht_node_str
*node
;
1482 struct lttng_ht_iter iter
;
1483 const char *config_domain_name
;
1488 ret
= config_writer_open_element(writer
,
1489 config_element_domain
);
1491 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1495 config_domain_name
= get_config_domain_str(domain
);
1496 if (!config_domain_name
) {
1497 ret
= LTTNG_ERR_INVALID
;
1501 ret
= config_writer_write_element_string(writer
,
1502 config_element_type
, config_domain_name
);
1504 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1508 buffer_type_string
= get_buffer_type_string(
1509 session
->ust_session
->buffer_type
);
1510 if (!buffer_type_string
) {
1511 ERR("Unsupported buffer type.");
1512 ret
= LTTNG_ERR_INVALID
;
1516 ret
= config_writer_write_element_string(writer
,
1517 config_element_buffer_type
, buffer_type_string
);
1519 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1523 ret
= config_writer_open_element(writer
, config_element_channels
);
1525 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1530 cds_lfht_for_each_entry(session
->ust_session
->domain_global
.channels
->ht
,
1531 &iter
.iter
, node
, node
) {
1532 ust_chan
= caa_container_of(node
, struct ltt_ust_channel
, node
);
1533 if (domain
== ust_chan
->domain
) {
1534 ret
= save_ust_channel(writer
, ust_chan
, session
->ust_session
);
1544 ret
= config_writer_close_element(writer
);
1546 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1550 if (domain
== LTTNG_DOMAIN_UST
) {
1551 ret
= config_writer_open_element(writer
,
1552 config_element_trackers
);
1554 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1558 ret
= save_pid_tracker(writer
, session
, LTTNG_DOMAIN_UST
);
1564 ret
= config_writer_close_element(writer
);
1571 ret
= config_writer_close_element(writer
);
1573 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1582 int save_domains(struct config_writer
*writer
, struct ltt_session
*session
)
1589 if (!session
->kernel_session
&& !session
->ust_session
) {
1593 ret
= config_writer_open_element(writer
, config_element_domains
);
1595 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1600 if (session
->kernel_session
) {
1601 ret
= config_writer_open_element(writer
,
1602 config_element_domain
);
1604 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1608 ret
= save_kernel_session(writer
, session
);
1613 ret
= config_writer_open_element(writer
,
1614 config_element_trackers
);
1616 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1620 ret
= save_pid_tracker(writer
, session
, LTTNG_DOMAIN_KERNEL
);
1626 ret
= config_writer_close_element(writer
);
1628 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1632 ret
= config_writer_close_element(writer
);
1634 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1639 if (session
->ust_session
) {
1640 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_UST
);
1645 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_JUL
);
1650 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_LOG4J
);
1655 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_PYTHON
);
1662 ret
= config_writer_close_element(writer
);
1664 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1672 int save_consumer_output(struct config_writer
*writer
,
1673 struct consumer_output
*output
)
1680 ret
= config_writer_open_element(writer
, config_element_consumer_output
);
1682 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1686 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1689 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1693 ret
= config_writer_open_element(writer
, config_element_destination
);
1695 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1699 switch (output
->type
) {
1700 case CONSUMER_DST_LOCAL
:
1701 ret
= config_writer_write_element_string(writer
,
1702 config_element_path
, output
->dst
.session_root_path
);
1704 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1708 case CONSUMER_DST_NET
:
1712 uri
= zmalloc(PATH_MAX
);
1714 ret
= LTTNG_ERR_NOMEM
;
1718 ret
= config_writer_open_element(writer
, config_element_net_output
);
1720 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1721 goto end_net_output
;
1724 if (output
->dst
.net
.control_isset
&&
1725 output
->dst
.net
.data_isset
) {
1726 ret
= uri_to_str_url(&output
->dst
.net
.control
, uri
, PATH_MAX
);
1728 ret
= LTTNG_ERR_INVALID
;
1729 goto end_net_output
;
1732 ret
= config_writer_write_element_string(writer
,
1733 config_element_control_uri
, uri
);
1735 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1736 goto end_net_output
;
1739 ret
= uri_to_str_url(&output
->dst
.net
.data
, uri
, PATH_MAX
);
1741 ret
= LTTNG_ERR_INVALID
;
1742 goto end_net_output
;
1745 ret
= config_writer_write_element_string(writer
,
1746 config_element_data_uri
, uri
);
1748 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1749 goto end_net_output
;
1758 ret
= !output
->dst
.net
.control_isset
?
1759 LTTNG_ERR_URL_CTRL_MISS
:
1760 LTTNG_ERR_URL_DATA_MISS
;
1765 ret
= config_writer_close_element(writer
);
1767 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1773 ERR("Unsupported consumer output type.");
1774 ret
= LTTNG_ERR_INVALID
;
1779 ret
= config_writer_close_element(writer
);
1781 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1785 /* /consumer_output */
1786 ret
= config_writer_close_element(writer
);
1788 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1796 int save_snapshot_outputs(struct config_writer
*writer
,
1797 struct snapshot
*snapshot
)
1800 struct lttng_ht_iter iter
;
1801 struct snapshot_output
*output
;
1806 ret
= config_writer_open_element(writer
, config_element_snapshot_outputs
);
1808 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1813 cds_lfht_for_each_entry(snapshot
->output_ht
->ht
, &iter
.iter
, output
,
1815 ret
= config_writer_open_element(writer
,
1816 config_element_output
);
1818 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1822 ret
= config_writer_write_element_string(writer
,
1823 config_element_name
, output
->name
);
1825 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1829 ret
= config_writer_write_element_unsigned_int(writer
,
1830 config_element_max_size
, output
->max_size
);
1832 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1836 ret
= save_consumer_output(writer
, output
->consumer
);
1842 ret
= config_writer_close_element(writer
);
1844 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1850 /* /snapshot_outputs */
1851 ret
= config_writer_close_element(writer
);
1853 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1865 int save_session_output(struct config_writer
*writer
,
1866 struct ltt_session
*session
)
1873 if ((session
->snapshot_mode
&& session
->snapshot
.nb_output
== 0) ||
1874 (!session
->snapshot_mode
&& !session
->consumer
)) {
1875 /* Session is in no output mode */
1880 ret
= config_writer_open_element(writer
, config_element_output
);
1882 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1886 if (session
->snapshot_mode
) {
1887 ret
= save_snapshot_outputs(writer
, &session
->snapshot
);
1892 if (session
->consumer
) {
1893 ret
= save_consumer_output(writer
, session
->consumer
);
1901 ret
= config_writer_close_element(writer
);
1903 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1911 int save_session_rotation_schedule(struct config_writer
*writer
,
1912 enum lttng_rotation_schedule_type type
, uint64_t value
)
1915 const char *element_name
;
1916 const char *value_name
;
1919 case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
:
1920 element_name
= config_element_rotation_schedule_periodic
;
1921 value_name
= config_element_rotation_schedule_periodic_time_us
;
1923 case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
:
1924 element_name
= config_element_rotation_schedule_size_threshold
;
1925 value_name
= config_element_rotation_schedule_size_threshold_bytes
;
1932 ret
= config_writer_open_element(writer
, element_name
);
1937 ret
= config_writer_write_element_unsigned_int(writer
,
1943 /* Close schedule descriptor element. */
1944 ret
= config_writer_close_element(writer
);
1953 int save_session_rotation_schedules(struct config_writer
*writer
,
1954 struct ltt_session
*session
)
1958 ret
= config_writer_open_element(writer
,
1959 config_element_rotation_schedules
);
1960 if (session
->rotate_timer_period
) {
1961 ret
= save_session_rotation_schedule(writer
,
1962 LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
,
1963 session
->rotate_timer_period
);
1965 goto close_schedules
;
1968 if (session
->rotate_size
) {
1969 ret
= save_session_rotation_schedule(writer
,
1970 LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
,
1971 session
->rotate_size
);
1973 goto close_schedules
;
1978 /* Close rotation schedules element. */
1979 ret
= config_writer_close_element(writer
);
1988 * Save the given session.
1990 * Return 0 on success else a LTTNG_ERR* code.
1993 int save_session(struct ltt_session
*session
,
1994 struct lttng_save_session_attr
*attr
, lttng_sock_cred
*creds
)
1997 unsigned int file_opened
= 0; /* Indicate if the file has been opened */
1998 char config_file_path
[PATH_MAX
];
2000 struct config_writer
*writer
= NULL
;
2001 size_t session_name_len
;
2002 const char *provided_path
;
2008 session_name_len
= strlen(session
->name
);
2009 memset(config_file_path
, 0, sizeof(config_file_path
));
2011 if (!session_access_ok(session
,
2012 LTTNG_SOCK_GET_UID_CRED(creds
),
2013 LTTNG_SOCK_GET_GID_CRED(creds
))) {
2014 ret
= LTTNG_ERR_EPERM
;
2018 provided_path
= lttng_save_session_attr_get_output_url(attr
);
2019 if (provided_path
) {
2020 DBG3("Save session in provided path %s", provided_path
);
2021 len
= strlen(provided_path
);
2022 if (len
>= sizeof(config_file_path
)) {
2023 ret
= LTTNG_ERR_SET_URL
;
2026 strncpy(config_file_path
, provided_path
, len
);
2029 char *home_dir
= utils_get_user_home_dir(
2030 LTTNG_SOCK_GET_UID_CRED(creds
));
2032 ret
= LTTNG_ERR_SET_URL
;
2036 ret_len
= snprintf(config_file_path
, sizeof(config_file_path
),
2037 DEFAULT_SESSION_HOME_CONFIGPATH
, home_dir
);
2040 PERROR("snprintf save session");
2041 ret
= LTTNG_ERR_SET_URL
;
2048 * Check the path fits in the config file path dst including the '/'
2049 * followed by trailing .lttng extension and the NULL terminated string.
2051 if ((len
+ session_name_len
+ 2 +
2052 sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
))
2053 > sizeof(config_file_path
)) {
2054 ret
= LTTNG_ERR_SET_URL
;
2058 ret
= run_as_mkdir_recursive(config_file_path
, S_IRWXU
| S_IRWXG
,
2059 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
2061 ret
= LTTNG_ERR_SET_URL
;
2066 * At this point, we know that everything fits in the buffer. Validation
2067 * was done just above.
2069 config_file_path
[len
++] = '/';
2070 strncpy(config_file_path
+ len
, session
->name
, session_name_len
);
2071 len
+= session_name_len
;
2072 strcpy(config_file_path
+ len
, DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
2073 len
+= sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
2074 config_file_path
[len
] = '\0';
2076 if (!access(config_file_path
, F_OK
) && !attr
->overwrite
) {
2077 /* File exists, notify the user since the overwrite flag is off. */
2078 ret
= LTTNG_ERR_SAVE_FILE_EXIST
;
2082 fd
= run_as_open(config_file_path
, O_CREAT
| O_WRONLY
| O_TRUNC
,
2083 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
,
2084 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
2086 PERROR("Could not create configuration file");
2087 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2092 writer
= config_writer_create(fd
, 1);
2094 ret
= LTTNG_ERR_NOMEM
;
2098 ret
= config_writer_open_element(writer
, config_element_sessions
);
2100 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2104 ret
= config_writer_open_element(writer
, config_element_session
);
2106 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2110 ret
= config_writer_write_element_string(writer
, config_element_name
,
2113 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2117 if(session
->shm_path
[0] != '\0') {
2118 ret
= config_writer_write_element_string(writer
,
2119 config_element_shared_memory_path
,
2122 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2127 ret
= save_domains(writer
, session
);
2132 ret
= config_writer_write_element_bool(writer
, config_element_started
,
2135 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2139 if (session
->snapshot_mode
|| session
->live_timer
||
2140 session
->rotate_timer_period
|| session
->rotate_size
) {
2141 ret
= config_writer_open_element(writer
, config_element_attributes
);
2143 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2147 if (session
->snapshot_mode
) {
2148 ret
= config_writer_write_element_bool(writer
,
2149 config_element_snapshot_mode
, 1);
2151 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2154 } else if (session
->live_timer
) {
2155 ret
= config_writer_write_element_unsigned_int(writer
,
2156 config_element_live_timer_interval
, session
->live_timer
);
2158 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2162 if (session
->rotate_timer_period
|| session
->rotate_size
) {
2163 ret
= save_session_rotation_schedules(writer
,
2166 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2172 ret
= config_writer_close_element(writer
);
2174 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2179 ret
= save_session_output(writer
, session
);
2185 ret
= config_writer_close_element(writer
);
2187 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2192 ret
= config_writer_close_element(writer
);
2194 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2198 if (writer
&& config_writer_destroy(writer
)) {
2199 /* Preserve the original error code */
2200 ret
= ret
? ret
: LTTNG_ERR_SAVE_IO_FAIL
;
2203 /* Delete file in case of error */
2204 if (file_opened
&& unlink(config_file_path
)) {
2205 PERROR("Unlinking XML session configuration.");
2212 PERROR("Closing XML session configuration");
2219 int cmd_save_sessions(struct lttng_save_session_attr
*attr
,
2220 lttng_sock_cred
*creds
)
2223 const char *session_name
;
2224 struct ltt_session
*session
;
2226 session_lock_list();
2228 session_name
= lttng_save_session_attr_get_session_name(attr
);
2230 session
= session_find_by_name(session_name
);
2232 ret
= LTTNG_ERR_SESS_NOT_FOUND
;
2236 session_lock(session
);
2237 ret
= save_session(session
, attr
, creds
);
2238 session_unlock(session
);
2243 struct ltt_session_list
*list
= session_get_list();
2245 cds_list_for_each_entry(session
, &list
->head
, list
) {
2246 session_lock(session
);
2247 ret
= save_session(session
, attr
, creds
);
2248 session_unlock(session
);
2250 /* Don't abort if we don't have the required permissions. */
2251 if (ret
&& ret
!= LTTNG_ERR_EPERM
) {
2259 session_unlock_list();