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>
36 #include "trace-ust.h"
39 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
41 int save_kernel_channel_attributes(struct config_writer
*writer
,
42 struct lttng_channel_attr
*attr
)
46 ret
= config_writer_write_element_string(writer
,
47 config_element_overwrite_mode
,
48 attr
->overwrite
? config_overwrite_mode_overwrite
:
49 config_overwrite_mode_discard
);
51 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
55 ret
= config_writer_write_element_unsigned_int(writer
,
56 config_element_subbuf_size
, attr
->subbuf_size
);
58 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
62 ret
= config_writer_write_element_unsigned_int(writer
,
63 config_element_num_subbuf
,
66 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
70 ret
= config_writer_write_element_unsigned_int(writer
,
71 config_element_switch_timer_interval
,
72 attr
->switch_timer_interval
);
74 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
78 ret
= config_writer_write_element_unsigned_int(writer
,
79 config_element_read_timer_interval
,
80 attr
->read_timer_interval
);
82 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
86 ret
= config_writer_write_element_string(writer
,
87 config_element_output_type
,
88 attr
->output
== LTTNG_EVENT_SPLICE
?
89 config_output_type_splice
: config_output_type_mmap
);
91 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
95 ret
= config_writer_write_element_unsigned_int(writer
,
96 config_element_tracefile_size
, attr
->tracefile_size
);
98 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
102 ret
= config_writer_write_element_unsigned_int(writer
,
103 config_element_tracefile_count
,
104 attr
->tracefile_count
);
106 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
110 ret
= config_writer_write_element_unsigned_int(writer
,
111 config_element_live_timer_interval
,
112 attr
->live_timer_interval
);
114 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
121 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
123 int save_ust_channel_attributes(struct config_writer
*writer
,
124 struct lttng_ust_channel_attr
*attr
)
128 ret
= config_writer_write_element_string(writer
,
129 config_element_overwrite_mode
,
130 attr
->overwrite
? config_overwrite_mode_overwrite
:
131 config_overwrite_mode_discard
);
133 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
137 ret
= config_writer_write_element_unsigned_int(writer
,
138 config_element_subbuf_size
, attr
->subbuf_size
);
140 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
144 ret
= config_writer_write_element_unsigned_int(writer
,
145 config_element_num_subbuf
,
148 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
152 ret
= config_writer_write_element_unsigned_int(writer
,
153 config_element_switch_timer_interval
,
154 attr
->switch_timer_interval
);
156 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
160 ret
= config_writer_write_element_unsigned_int(writer
,
161 config_element_read_timer_interval
,
162 attr
->read_timer_interval
);
164 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
168 ret
= config_writer_write_element_string(writer
,
169 config_element_output_type
,
170 attr
->output
== LTTNG_UST_MMAP
?
171 config_output_type_mmap
: config_output_type_splice
);
173 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
183 const char *get_kernel_instrumentation_string(
184 enum lttng_kernel_instrumentation instrumentation
)
186 const char *instrumentation_string
;
188 switch (instrumentation
) {
189 case LTTNG_KERNEL_ALL
:
190 instrumentation_string
= config_event_type_all
;
192 case LTTNG_KERNEL_TRACEPOINT
:
193 instrumentation_string
= config_event_type_tracepoint
;
195 case LTTNG_KERNEL_KPROBE
:
196 instrumentation_string
= config_event_type_kprobe
;
198 case LTTNG_KERNEL_FUNCTION
:
199 instrumentation_string
= config_event_type_function
;
201 case LTTNG_KERNEL_KRETPROBE
:
202 instrumentation_string
= config_event_type_kretprobe
;
204 case LTTNG_KERNEL_NOOP
:
205 instrumentation_string
= config_event_type_noop
;
207 case LTTNG_KERNEL_SYSCALL
:
208 instrumentation_string
= config_event_type_syscall
;
211 instrumentation_string
= NULL
;
214 return instrumentation_string
;
218 const char *get_kernel_context_type_string(
219 enum lttng_kernel_context_type context_type
)
221 const char *context_type_string
;
223 switch (context_type
) {
224 case LTTNG_KERNEL_CONTEXT_PID
:
225 context_type_string
= config_event_context_pid
;
227 case LTTNG_KERNEL_CONTEXT_PROCNAME
:
228 context_type_string
= config_event_context_procname
;
230 case LTTNG_KERNEL_CONTEXT_PRIO
:
231 context_type_string
= config_event_context_prio
;
233 case LTTNG_KERNEL_CONTEXT_NICE
:
234 context_type_string
= config_event_context_nice
;
236 case LTTNG_KERNEL_CONTEXT_VPID
:
237 context_type_string
= config_event_context_vpid
;
239 case LTTNG_KERNEL_CONTEXT_TID
:
240 context_type_string
= config_event_context_tid
;
242 case LTTNG_KERNEL_CONTEXT_VTID
:
243 context_type_string
= config_event_context_vtid
;
245 case LTTNG_KERNEL_CONTEXT_PPID
:
246 context_type_string
= config_event_context_ppid
;
248 case LTTNG_KERNEL_CONTEXT_VPPID
:
249 context_type_string
= config_event_context_vppid
;
251 case LTTNG_KERNEL_CONTEXT_HOSTNAME
:
252 context_type_string
= config_event_context_hostname
;
254 case LTTNG_KERNEL_CONTEXT_INTERRUPTIBLE
:
255 context_type_string
= config_event_context_interruptible
;
257 case LTTNG_KERNEL_CONTEXT_PREEMPTIBLE
:
258 context_type_string
= config_event_context_preemptible
;
260 case LTTNG_KERNEL_CONTEXT_NEED_RESCHEDULE
:
261 context_type_string
= config_event_context_need_reschedule
;
263 case LTTNG_KERNEL_CONTEXT_MIGRATABLE
:
264 context_type_string
= config_event_context_migratable
;
267 context_type_string
= NULL
;
270 return context_type_string
;
274 const char *get_ust_context_type_string(
275 enum lttng_ust_context_type context_type
)
277 const char *context_type_string
;
279 switch (context_type
) {
280 case LTTNG_UST_CONTEXT_PROCNAME
:
281 context_type_string
= config_event_context_procname
;
283 case LTTNG_UST_CONTEXT_VPID
:
284 context_type_string
= config_event_context_vpid
;
286 case LTTNG_UST_CONTEXT_VTID
:
287 context_type_string
= config_event_context_vtid
;
289 case LTTNG_UST_CONTEXT_IP
:
290 context_type_string
= config_event_context_ip
;
292 case LTTNG_UST_CONTEXT_PTHREAD_ID
:
293 context_type_string
= config_event_context_pthread_id
;
295 case LTTNG_UST_CONTEXT_APP_CONTEXT
:
296 context_type_string
= config_event_context_app
;
298 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
:
300 * Error, should not be stored in the XML, perf contexts
301 * are stored as a node of type event_perf_context_type.
304 context_type_string
= NULL
;
308 return context_type_string
;
312 const char *get_buffer_type_string(
313 enum lttng_buffer_type buffer_type
)
315 const char *buffer_type_string
;
317 switch (buffer_type
) {
318 case LTTNG_BUFFER_PER_PID
:
319 buffer_type_string
= config_buffer_type_per_pid
;
321 case LTTNG_BUFFER_PER_UID
:
322 buffer_type_string
= config_buffer_type_per_uid
;
324 case LTTNG_BUFFER_GLOBAL
:
325 buffer_type_string
= config_buffer_type_global
;
328 buffer_type_string
= NULL
;
331 return buffer_type_string
;
335 const char *get_loglevel_type_string(
336 enum lttng_ust_loglevel_type loglevel_type
)
338 const char *loglevel_type_string
;
340 switch (loglevel_type
) {
341 case LTTNG_UST_LOGLEVEL_ALL
:
342 loglevel_type_string
= config_loglevel_type_all
;
344 case LTTNG_UST_LOGLEVEL_RANGE
:
345 loglevel_type_string
= config_loglevel_type_range
;
347 case LTTNG_UST_LOGLEVEL_SINGLE
:
348 loglevel_type_string
= config_loglevel_type_single
;
351 loglevel_type_string
= NULL
;
354 return loglevel_type_string
;
357 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
359 int save_kernel_event(struct config_writer
*writer
,
360 struct ltt_kernel_event
*event
)
363 const char *instrumentation_type
;
365 ret
= config_writer_open_element(writer
, config_element_event
);
367 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
371 if (event
->event
->name
[0]) {
372 ret
= config_writer_write_element_string(writer
,
373 config_element_name
, event
->event
->name
);
375 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
380 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
383 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
387 instrumentation_type
= get_kernel_instrumentation_string(
388 event
->event
->instrumentation
);
389 if (!instrumentation_type
) {
390 ret
= LTTNG_ERR_INVALID
;
394 ret
= config_writer_write_element_string(writer
, config_element_type
,
395 instrumentation_type
);
397 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
401 if (event
->filter_expression
) {
402 ret
= config_writer_write_element_string(writer
,
403 config_element_filter
,
404 event
->filter_expression
);
406 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
411 if (event
->event
->instrumentation
== LTTNG_KERNEL_FUNCTION
||
412 event
->event
->instrumentation
== LTTNG_KERNEL_KPROBE
||
413 event
->event
->instrumentation
== LTTNG_KERNEL_KRETPROBE
) {
415 ret
= config_writer_open_element(writer
,
416 config_element_attributes
);
418 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
422 switch (event
->event
->instrumentation
) {
423 case LTTNG_KERNEL_SYSCALL
:
424 case LTTNG_KERNEL_FUNCTION
:
425 ret
= config_writer_open_element(writer
,
426 config_element_function_attributes
);
428 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
432 ret
= config_writer_write_element_string(writer
,
434 event
->event
->u
.ftrace
.symbol_name
);
436 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
440 /* /function attributes */
441 ret
= config_writer_close_element(writer
);
443 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
447 case LTTNG_KERNEL_KPROBE
:
448 case LTTNG_KERNEL_KRETPROBE
:
450 const char *symbol_name
;
454 if (event
->event
->instrumentation
==
455 LTTNG_KERNEL_KPROBE
) {
457 * Comments in lttng-kernel.h mention that
458 * either addr or symbol_name are set, not both.
460 addr
= event
->event
->u
.kprobe
.addr
;
461 offset
= event
->event
->u
.kprobe
.offset
;
462 symbol_name
= addr
? NULL
:
463 event
->event
->u
.kprobe
.symbol_name
;
466 event
->event
->u
.kretprobe
.symbol_name
;
467 addr
= event
->event
->u
.kretprobe
.addr
;
468 offset
= event
->event
->u
.kretprobe
.offset
;
471 ret
= config_writer_open_element(writer
,
472 config_element_probe_attributes
);
474 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
479 ret
= config_writer_write_element_string(writer
,
480 config_element_symbol_name
,
483 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
489 ret
= config_writer_write_element_unsigned_int(
490 writer
, config_element_address
, addr
);
492 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
498 ret
= config_writer_write_element_unsigned_int(
499 writer
, config_element_offset
, offset
);
501 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
506 ret
= config_writer_close_element(writer
);
508 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
514 ERR("Unsupported kernel instrumentation type.");
515 ret
= LTTNG_ERR_INVALID
;
520 ret
= config_writer_close_element(writer
);
522 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
528 ret
= config_writer_close_element(writer
);
530 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
539 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
541 int save_kernel_events(struct config_writer
*writer
,
542 struct ltt_kernel_channel
*kchan
)
545 struct ltt_kernel_event
*event
;
547 ret
= config_writer_open_element(writer
, config_element_events
);
549 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
553 cds_list_for_each_entry(event
, &kchan
->events_list
.head
, list
) {
554 ret
= save_kernel_event(writer
, event
);
555 if (ret
!= LTTNG_OK
) {
561 ret
= config_writer_close_element(writer
);
563 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
572 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
574 int save_ust_event(struct config_writer
*writer
,
575 struct ltt_ust_event
*event
)
578 const char *loglevel_type_string
;
580 ret
= config_writer_open_element(writer
, config_element_event
);
582 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
586 if (event
->attr
.name
[0]) {
587 ret
= config_writer_write_element_string(writer
,
588 config_element_name
, event
->attr
.name
);
590 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
595 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
598 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
602 if (event
->attr
.instrumentation
!= LTTNG_UST_TRACEPOINT
) {
603 ERR("Unsupported UST instrumentation type.");
604 ret
= LTTNG_ERR_INVALID
;
607 ret
= config_writer_write_element_string(writer
, config_element_type
,
608 config_event_type_tracepoint
);
610 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
614 loglevel_type_string
= get_loglevel_type_string(
615 event
->attr
.loglevel_type
);
616 if (!loglevel_type_string
) {
617 ERR("Unsupported UST loglevel type.");
618 ret
= LTTNG_ERR_INVALID
;
622 ret
= config_writer_write_element_string(writer
,
623 config_element_loglevel_type
, loglevel_type_string
);
625 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
629 /* The log level is irrelevant if no "filtering" is enabled */
630 if (event
->attr
.loglevel_type
!= LTTNG_UST_LOGLEVEL_ALL
) {
631 ret
= config_writer_write_element_signed_int(writer
,
632 config_element_loglevel
, event
->attr
.loglevel
);
634 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
639 if (event
->filter_expression
) {
640 ret
= config_writer_write_element_string(writer
,
641 config_element_filter
, event
->filter_expression
);
643 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
648 if (event
->exclusion
&& event
->exclusion
->count
) {
651 ret
= config_writer_open_element(writer
,
652 config_element_exclusions
);
654 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
658 for (i
= 0; i
< event
->exclusion
->count
; i
++) {
659 ret
= config_writer_write_element_string(writer
,
660 config_element_exclusion
,
661 LTTNG_EVENT_EXCLUSION_NAME_AT(
662 event
->exclusion
, i
));
664 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
670 ret
= config_writer_close_element(writer
);
672 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
678 ret
= config_writer_close_element(writer
);
680 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
689 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
691 int save_ust_events(struct config_writer
*writer
,
692 struct lttng_ht
*events
)
695 struct ltt_ust_event
*event
;
696 struct lttng_ht_node_str
*node
;
697 struct lttng_ht_iter iter
;
699 ret
= config_writer_open_element(writer
, config_element_events
);
701 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
706 cds_lfht_for_each_entry(events
->ht
, &iter
.iter
, node
, node
) {
707 event
= caa_container_of(node
, struct ltt_ust_event
, node
);
709 if (event
->internal
) {
710 /* Internal events must not be exposed to clients */
713 ret
= save_ust_event(writer
, event
);
714 if (ret
!= LTTNG_OK
) {
722 ret
= config_writer_close_element(writer
);
724 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
733 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
735 int init_ust_event_from_agent_event(struct ltt_ust_event
*ust_event
,
736 struct agent_event
*agent_event
)
739 enum lttng_ust_loglevel_type ust_loglevel_type
;
741 ust_event
->enabled
= agent_event
->enabled
;
742 ust_event
->attr
.instrumentation
= LTTNG_UST_TRACEPOINT
;
743 if (lttng_strncpy(ust_event
->attr
.name
, agent_event
->name
,
744 LTTNG_SYMBOL_NAME_LEN
)) {
745 ret
= LTTNG_ERR_INVALID
;
748 switch (agent_event
->loglevel_type
) {
749 case LTTNG_EVENT_LOGLEVEL_ALL
:
750 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_ALL
;
752 case LTTNG_EVENT_LOGLEVEL_SINGLE
:
753 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_SINGLE
;
755 case LTTNG_EVENT_LOGLEVEL_RANGE
:
756 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_RANGE
;
759 ERR("Invalid agent_event loglevel_type.");
760 ret
= LTTNG_ERR_INVALID
;
764 ust_event
->attr
.loglevel_type
= ust_loglevel_type
;
765 ust_event
->attr
.loglevel
= agent_event
->loglevel_value
;
766 ust_event
->filter_expression
= agent_event
->filter_expression
;
767 ust_event
->exclusion
= agent_event
->exclusion
;
774 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
776 int save_agent_events(struct config_writer
*writer
,
777 struct ltt_ust_channel
*chan
,
781 struct lttng_ht_iter iter
;
782 struct lttng_ht_node_str
*node
;
784 ret
= config_writer_open_element(writer
, config_element_events
);
786 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
791 cds_lfht_for_each_entry(agent
->events
->ht
, &iter
.iter
, node
, node
) {
793 struct agent_event
*agent_event
;
794 struct ltt_ust_event fake_event
;
796 memset(&fake_event
, 0, sizeof(fake_event
));
797 agent_event
= caa_container_of(node
, struct agent_event
, node
);
800 * Initialize a fake ust event to reuse the same serialization
801 * function since UST and agent events contain the same info
802 * (and one could wonder why they don't reuse the same
805 ret
= init_ust_event_from_agent_event(&fake_event
, agent_event
);
806 if (ret
!= LTTNG_OK
) {
810 ret
= save_ust_event(writer
, &fake_event
);
811 if (ret
!= LTTNG_OK
) {
819 ret
= config_writer_close_element(writer
);
821 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
830 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
832 int save_kernel_context(struct config_writer
*writer
,
833 struct lttng_kernel_context
*ctx
)
841 ret
= config_writer_open_element(writer
, config_element_context
);
843 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
847 if (ctx
->ctx
== LTTNG_KERNEL_CONTEXT_PERF_CPU_COUNTER
) {
848 ret
= config_writer_open_element(writer
,
849 config_element_context_perf
);
851 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
855 ret
= config_writer_write_element_unsigned_int(writer
,
856 config_element_type
, ctx
->u
.perf_counter
.type
);
858 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
862 ret
= config_writer_write_element_unsigned_int(writer
,
863 config_element_config
, ctx
->u
.perf_counter
.config
);
865 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
869 ret
= config_writer_write_element_string(writer
,
870 config_element_name
, ctx
->u
.perf_counter
.name
);
872 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
877 ret
= config_writer_close_element(writer
);
879 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
883 const char *context_type_string
=
884 get_kernel_context_type_string(ctx
->ctx
);
886 if (!context_type_string
) {
887 ERR("Unsupported kernel context type.");
888 ret
= LTTNG_ERR_INVALID
;
892 ret
= config_writer_write_element_string(writer
,
893 config_element_type
, context_type_string
);
895 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
901 ret
= config_writer_close_element(writer
);
903 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
912 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
914 int save_kernel_contexts(struct config_writer
*writer
,
915 struct ltt_kernel_channel
*kchan
)
918 struct ltt_kernel_context
*ctx
;
920 if (cds_list_empty(&kchan
->ctx_list
)) {
925 ret
= config_writer_open_element(writer
, config_element_contexts
);
927 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
931 cds_list_for_each_entry(ctx
, &kchan
->ctx_list
, list
) {
932 ret
= save_kernel_context(writer
, &ctx
->ctx
);
933 if (ret
!= LTTNG_OK
) {
939 ret
= config_writer_close_element(writer
);
941 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
950 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
952 int save_ust_context_perf_thread_counter(struct config_writer
*writer
,
953 struct ltt_ust_context
*ctx
)
960 /* Perf contexts are saved as event_perf_context_type */
961 ret
= config_writer_open_element(writer
, config_element_context_perf
);
963 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
967 ret
= config_writer_write_element_unsigned_int(writer
,
968 config_element_type
, ctx
->ctx
.u
.perf_counter
.type
);
970 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
974 ret
= config_writer_write_element_unsigned_int(writer
,
975 config_element_config
, ctx
->ctx
.u
.perf_counter
.config
);
977 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
981 ret
= config_writer_write_element_string(writer
, config_element_name
,
982 ctx
->ctx
.u
.perf_counter
.name
);
984 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
989 ret
= config_writer_close_element(writer
);
991 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1000 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1002 int save_ust_context_app_ctx(struct config_writer
*writer
,
1003 struct ltt_ust_context
*ctx
)
1010 /* Application contexts are saved as application_context_type */
1011 ret
= config_writer_open_element(writer
, config_element_context_app
);
1013 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1017 ret
= config_writer_write_element_string(writer
,
1018 config_element_context_app_provider_name
,
1019 ctx
->ctx
.u
.app_ctx
.provider_name
);
1021 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1025 ret
= config_writer_write_element_string(writer
,
1026 config_element_context_app_ctx_name
,
1027 ctx
->ctx
.u
.app_ctx
.ctx_name
);
1029 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1034 ret
= config_writer_close_element(writer
);
1036 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1045 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1047 int save_ust_context_generic(struct config_writer
*writer
,
1048 struct ltt_ust_context
*ctx
)
1051 const char *context_type_string
;
1056 /* Save context as event_context_type_type */
1057 context_type_string
= get_ust_context_type_string(
1059 if (!context_type_string
) {
1060 ERR("Unsupported UST context type.");
1061 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1065 ret
= config_writer_write_element_string(writer
,
1066 config_element_type
, context_type_string
);
1068 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1077 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1079 int save_ust_context(struct config_writer
*writer
,
1080 struct cds_list_head
*ctx_list
)
1083 struct ltt_ust_context
*ctx
;
1088 ret
= config_writer_open_element(writer
, config_element_contexts
);
1090 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1094 cds_list_for_each_entry(ctx
, ctx_list
, list
) {
1095 ret
= config_writer_open_element(writer
,
1096 config_element_context
);
1098 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1102 switch (ctx
->ctx
.ctx
) {
1103 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
:
1104 ret
= save_ust_context_perf_thread_counter(writer
, ctx
);
1106 case LTTNG_UST_CONTEXT_APP_CONTEXT
:
1107 ret
= save_ust_context_app_ctx(writer
, ctx
);
1110 /* Save generic context. */
1111 ret
= save_ust_context_generic(writer
, ctx
);
1113 if (ret
!= LTTNG_OK
) {
1118 ret
= config_writer_close_element(writer
);
1120 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1126 ret
= config_writer_close_element(writer
);
1128 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1137 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1139 int save_kernel_channel(struct config_writer
*writer
,
1140 struct ltt_kernel_channel
*kchan
)
1147 ret
= config_writer_open_element(writer
, config_element_channel
);
1149 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1153 ret
= config_writer_write_element_string(writer
, config_element_name
,
1154 kchan
->channel
->name
);
1156 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1160 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1161 kchan
->channel
->enabled
);
1163 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1167 ret
= save_kernel_channel_attributes(writer
, &kchan
->channel
->attr
);
1168 if (ret
!= LTTNG_OK
) {
1172 ret
= save_kernel_events(writer
, kchan
);
1173 if (ret
!= LTTNG_OK
) {
1177 ret
= save_kernel_contexts(writer
, kchan
);
1178 if (ret
!= LTTNG_OK
) {
1183 ret
= config_writer_close_element(writer
);
1185 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1194 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1196 int save_ust_channel(struct config_writer
*writer
,
1197 struct ltt_ust_channel
*ust_chan
,
1198 struct ltt_ust_session
*session
)
1206 ret
= config_writer_open_element(writer
, config_element_channel
);
1208 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1212 ret
= config_writer_write_element_string(writer
, config_element_name
,
1215 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1219 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1222 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1226 ret
= save_ust_channel_attributes(writer
, &ust_chan
->attr
);
1227 if (ret
!= LTTNG_OK
) {
1231 ret
= config_writer_write_element_unsigned_int(writer
,
1232 config_element_tracefile_size
, ust_chan
->tracefile_size
);
1234 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1238 ret
= config_writer_write_element_unsigned_int(writer
,
1239 config_element_tracefile_count
, ust_chan
->tracefile_count
);
1241 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1245 ret
= config_writer_write_element_unsigned_int(writer
,
1246 config_element_live_timer_interval
,
1247 session
->live_timer_interval
);
1249 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1253 if (ust_chan
->domain
== LTTNG_DOMAIN_UST
) {
1254 ret
= save_ust_events(writer
, ust_chan
->events
);
1255 if (ret
!= LTTNG_OK
) {
1259 struct agent
*agent
= NULL
;
1261 agent
= trace_ust_find_agent(session
, ust_chan
->domain
);
1263 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1264 ERR("Could not find agent associated to UST subdomain");
1269 * Channels associated with a UST sub-domain (such as JUL, Log4j
1270 * or Python) don't have any non-internal events. We retrieve
1271 * the "agent" events associated with this channel and serialize
1274 ret
= save_agent_events(writer
, ust_chan
, agent
);
1275 if (ret
!= LTTNG_OK
) {
1280 ret
= save_ust_context(writer
, &ust_chan
->ctx_list
);
1281 if (ret
!= LTTNG_OK
) {
1286 ret
= config_writer_close_element(writer
);
1288 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1297 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1299 int save_kernel_session(struct config_writer
*writer
,
1300 struct ltt_session
*session
)
1303 struct ltt_kernel_channel
*kchan
;
1308 ret
= config_writer_write_element_string(writer
, config_element_type
,
1309 config_domain_type_kernel
);
1311 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1315 ret
= config_writer_write_element_string(writer
,
1316 config_element_buffer_type
, config_buffer_type_global
);
1318 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1322 ret
= config_writer_open_element(writer
,
1323 config_element_channels
);
1325 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1329 cds_list_for_each_entry(kchan
, &session
->kernel_session
->channel_list
.head
,
1331 ret
= save_kernel_channel(writer
, kchan
);
1332 if (ret
!= LTTNG_OK
) {
1338 ret
= config_writer_close_element(writer
);
1340 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1350 const char *get_config_domain_str(enum lttng_domain_type domain
)
1352 const char *str_dom
;
1355 case LTTNG_DOMAIN_KERNEL
:
1356 str_dom
= config_domain_type_kernel
;
1358 case LTTNG_DOMAIN_UST
:
1359 str_dom
= config_domain_type_ust
;
1361 case LTTNG_DOMAIN_JUL
:
1362 str_dom
= config_domain_type_jul
;
1364 case LTTNG_DOMAIN_LOG4J
:
1365 str_dom
= config_domain_type_log4j
;
1367 case LTTNG_DOMAIN_PYTHON
:
1368 str_dom
= config_domain_type_python
;
1377 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1379 int save_id_tracker(struct config_writer
*writer
,
1380 struct ltt_session
*sess
, int domain
,
1381 enum lttng_tracker_type tracker_type
)
1384 ssize_t nr_ids
= 0, i
;
1385 struct lttng_tracker_id
*ids
= NULL
;
1386 const char *element_id_tracker
, *element_target_id
, *element_id
;
1388 switch (tracker_type
) {
1389 case LTTNG_TRACKER_PID
:
1390 element_id_tracker
= config_element_pid_tracker
;
1391 element_target_id
= config_element_target_pid
;
1392 element_id
= config_element_pid
;
1394 case LTTNG_TRACKER_VPID
:
1395 element_id_tracker
= config_element_vpid_tracker
;
1396 element_target_id
= config_element_target_vpid
;
1397 element_id
= config_element_id
;
1399 case LTTNG_TRACKER_UID
:
1400 element_id_tracker
= config_element_uid_tracker
;
1401 element_target_id
= config_element_target_uid
;
1402 element_id
= config_element_id
;
1404 case LTTNG_TRACKER_VUID
:
1405 element_id_tracker
= config_element_vuid_tracker
;
1406 element_target_id
= config_element_target_vuid
;
1407 element_id
= config_element_id
;
1409 case LTTNG_TRACKER_GID
:
1410 element_id_tracker
= config_element_gid_tracker
;
1411 element_target_id
= config_element_target_gid
;
1412 element_id
= config_element_id
;
1414 case LTTNG_TRACKER_VGID
:
1415 element_id_tracker
= config_element_vgid_tracker
;
1416 element_target_id
= config_element_target_vgid
;
1417 element_id
= config_element_id
;
1420 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1425 case LTTNG_DOMAIN_KERNEL
:
1427 nr_ids
= kernel_list_tracker_ids(tracker_type
, sess
->kernel_session
, &ids
);
1429 ret
= LTTNG_ERR_KERN_LIST_FAIL
;
1434 case LTTNG_DOMAIN_UST
:
1436 nr_ids
= trace_ust_list_tracker_ids(tracker_type
, sess
->ust_session
, &ids
);
1438 ret
= LTTNG_ERR_UST_LIST_FAIL
;
1443 case LTTNG_DOMAIN_JUL
:
1444 case LTTNG_DOMAIN_LOG4J
:
1445 case LTTNG_DOMAIN_PYTHON
:
1447 ret
= LTTNG_ERR_UNKNOWN_DOMAIN
;
1452 if (nr_ids
== 1 && ids
[0].type
== LTTNG_ID_ALL
) {
1453 /* Tracking all, nothing to output. */
1458 ret
= config_writer_open_element(writer
, element_id_tracker
);
1460 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1464 ret
= config_writer_open_element(writer
,
1465 config_element_targets
);
1467 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1472 /* Tracking none: empty list. */
1473 ret
= config_writer_open_element(writer
,
1476 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1480 /* /$element_target_id */
1481 ret
= config_writer_close_element(writer
);
1483 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1487 /* Tracking list. */
1488 for (i
= 0; i
< nr_ids
; i
++) {
1489 switch (ids
[i
].type
) {
1490 case LTTNG_ID_VALUE
:
1491 ret
= config_writer_open_element(writer
,
1494 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1497 ret
= config_writer_write_element_unsigned_int(writer
,
1498 element_id
, ids
[i
].value
);
1500 case LTTNG_ID_STRING
:
1501 ret
= config_writer_open_element(writer
,
1504 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1507 ret
= config_writer_write_element_string(writer
,
1508 config_element_name
, ids
[i
].string
);
1512 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1516 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1520 /* /$element_target_id */
1521 ret
= config_writer_close_element(writer
);
1523 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1530 ret
= config_writer_close_element(writer
);
1532 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1536 /* /$element_id_tracker */
1537 ret
= config_writer_close_element(writer
);
1539 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1549 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1551 int save_id_trackers(struct config_writer
*writer
,
1552 struct ltt_session
*sess
, int domain
)
1557 case LTTNG_DOMAIN_KERNEL
:
1558 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_PID
);
1559 if (ret
!= LTTNG_OK
)
1561 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_VPID
);
1562 if (ret
!= LTTNG_OK
)
1564 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_UID
);
1565 if (ret
!= LTTNG_OK
)
1567 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_VUID
);
1568 if (ret
!= LTTNG_OK
)
1570 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_GID
);
1571 if (ret
!= LTTNG_OK
)
1573 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_VGID
);
1574 if (ret
!= LTTNG_OK
)
1577 case LTTNG_DOMAIN_UST
:
1578 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_VPID
);
1579 if (ret
!= LTTNG_OK
)
1581 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_VUID
);
1582 if (ret
!= LTTNG_OK
)
1584 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_VGID
);
1585 if (ret
!= LTTNG_OK
)
1589 return LTTNG_ERR_INVALID
;
1594 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1596 int save_ust_domain(struct config_writer
*writer
,
1597 struct ltt_session
*session
, enum lttng_domain_type domain
)
1600 struct ltt_ust_channel
*ust_chan
;
1601 const char *buffer_type_string
;
1602 struct lttng_ht_node_str
*node
;
1603 struct lttng_ht_iter iter
;
1604 const char *config_domain_name
;
1609 ret
= config_writer_open_element(writer
,
1610 config_element_domain
);
1612 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1616 config_domain_name
= get_config_domain_str(domain
);
1617 if (!config_domain_name
) {
1618 ret
= LTTNG_ERR_INVALID
;
1622 ret
= config_writer_write_element_string(writer
,
1623 config_element_type
, config_domain_name
);
1625 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1629 buffer_type_string
= get_buffer_type_string(
1630 session
->ust_session
->buffer_type
);
1631 if (!buffer_type_string
) {
1632 ERR("Unsupported buffer type.");
1633 ret
= LTTNG_ERR_INVALID
;
1637 ret
= config_writer_write_element_string(writer
,
1638 config_element_buffer_type
, buffer_type_string
);
1640 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1644 ret
= config_writer_open_element(writer
, config_element_channels
);
1646 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1651 cds_lfht_for_each_entry(session
->ust_session
->domain_global
.channels
->ht
,
1652 &iter
.iter
, node
, node
) {
1653 ust_chan
= caa_container_of(node
, struct ltt_ust_channel
, node
);
1654 if (domain
== ust_chan
->domain
) {
1655 ret
= save_ust_channel(writer
, ust_chan
, session
->ust_session
);
1656 if (ret
!= LTTNG_OK
) {
1665 ret
= config_writer_close_element(writer
);
1667 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1671 if (domain
== LTTNG_DOMAIN_UST
) {
1672 ret
= config_writer_open_element(writer
,
1673 config_element_trackers
);
1675 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1679 ret
= save_id_trackers(writer
, session
, LTTNG_DOMAIN_UST
);
1680 if (ret
!= LTTNG_OK
) {
1685 ret
= config_writer_close_element(writer
);
1687 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1693 ret
= config_writer_close_element(writer
);
1695 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1704 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1706 int save_domains(struct config_writer
*writer
, struct ltt_session
*session
)
1713 if (!session
->kernel_session
&& !session
->ust_session
) {
1717 ret
= config_writer_open_element(writer
, config_element_domains
);
1719 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1723 if (session
->kernel_session
) {
1724 ret
= config_writer_open_element(writer
,
1725 config_element_domain
);
1727 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1731 ret
= save_kernel_session(writer
, session
);
1732 if (ret
!= LTTNG_OK
) {
1736 ret
= config_writer_open_element(writer
,
1737 config_element_trackers
);
1739 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1743 ret
= save_id_trackers(writer
, session
, LTTNG_DOMAIN_KERNEL
);
1744 if (ret
!= LTTNG_OK
) {
1749 ret
= config_writer_close_element(writer
);
1751 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1755 ret
= config_writer_close_element(writer
);
1757 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1762 if (session
->ust_session
) {
1763 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_UST
);
1764 if (ret
!= LTTNG_OK
) {
1768 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_JUL
);
1769 if (ret
!= LTTNG_OK
) {
1773 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_LOG4J
);
1774 if (ret
!= LTTNG_OK
) {
1778 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_PYTHON
);
1779 if (ret
!= LTTNG_OK
) {
1785 ret
= config_writer_close_element(writer
);
1787 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1796 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1798 int save_consumer_output(struct config_writer
*writer
,
1799 struct consumer_output
*output
)
1806 ret
= config_writer_open_element(writer
, config_element_consumer_output
);
1808 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1812 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1815 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1819 ret
= config_writer_open_element(writer
, config_element_destination
);
1821 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1825 switch (output
->type
) {
1826 case CONSUMER_DST_LOCAL
:
1827 ret
= config_writer_write_element_string(writer
,
1828 config_element_path
, output
->dst
.trace_path
);
1830 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1834 case CONSUMER_DST_NET
:
1838 uri
= zmalloc(PATH_MAX
);
1840 ret
= LTTNG_ERR_NOMEM
;
1844 ret
= config_writer_open_element(writer
, config_element_net_output
);
1846 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1847 goto end_net_output
;
1850 if (output
->dst
.net
.control_isset
&&
1851 output
->dst
.net
.data_isset
) {
1852 ret
= uri_to_str_url(&output
->dst
.net
.control
, uri
, PATH_MAX
);
1854 ret
= LTTNG_ERR_INVALID
;
1855 goto end_net_output
;
1858 ret
= config_writer_write_element_string(writer
,
1859 config_element_control_uri
, uri
);
1861 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1862 goto end_net_output
;
1865 ret
= uri_to_str_url(&output
->dst
.net
.data
, uri
, PATH_MAX
);
1867 ret
= LTTNG_ERR_INVALID
;
1868 goto end_net_output
;
1871 ret
= config_writer_write_element_string(writer
,
1872 config_element_data_uri
, uri
);
1874 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1875 goto end_net_output
;
1880 if (ret
!= LTTNG_OK
) {
1884 ret
= !output
->dst
.net
.control_isset
?
1885 LTTNG_ERR_URL_CTRL_MISS
:
1886 LTTNG_ERR_URL_DATA_MISS
;
1891 ret
= config_writer_close_element(writer
);
1893 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1899 ERR("Unsupported consumer output type.");
1900 ret
= LTTNG_ERR_INVALID
;
1905 ret
= config_writer_close_element(writer
);
1907 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1911 /* /consumer_output */
1912 ret
= config_writer_close_element(writer
);
1914 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1923 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1925 int save_snapshot_outputs(struct config_writer
*writer
,
1926 struct snapshot
*snapshot
)
1929 struct lttng_ht_iter iter
;
1930 struct snapshot_output
*output
;
1935 ret
= config_writer_open_element(writer
, config_element_snapshot_outputs
);
1937 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1942 cds_lfht_for_each_entry(snapshot
->output_ht
->ht
, &iter
.iter
, output
,
1944 ret
= config_writer_open_element(writer
,
1945 config_element_output
);
1947 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1951 ret
= config_writer_write_element_string(writer
,
1952 config_element_name
, output
->name
);
1954 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1958 ret
= config_writer_write_element_unsigned_int(writer
,
1959 config_element_max_size
, output
->max_size
);
1961 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1965 ret
= save_consumer_output(writer
, output
->consumer
);
1966 if (ret
!= LTTNG_OK
) {
1971 ret
= config_writer_close_element(writer
);
1973 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1979 /* /snapshot_outputs */
1980 ret
= config_writer_close_element(writer
);
1982 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1994 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1996 int save_session_output(struct config_writer
*writer
,
1997 struct ltt_session
*session
)
2004 if ((session
->snapshot_mode
&& session
->snapshot
.nb_output
== 0) ||
2005 (!session
->snapshot_mode
&& !session
->consumer
)) {
2006 /* Session is in no output mode */
2011 ret
= config_writer_open_element(writer
, config_element_output
);
2013 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2017 if (session
->snapshot_mode
) {
2018 ret
= save_snapshot_outputs(writer
, &session
->snapshot
);
2019 if (ret
!= LTTNG_OK
) {
2023 if (session
->consumer
) {
2024 ret
= save_consumer_output(writer
, session
->consumer
);
2025 if (ret
!= LTTNG_OK
) {
2032 ret
= config_writer_close_element(writer
);
2034 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2043 * Save the given session.
2045 * Return LTTNG_OK on success else a LTTNG_ERR* code.
2048 int save_session(struct ltt_session
*session
,
2049 struct lttng_save_session_attr
*attr
, lttng_sock_cred
*creds
)
2052 unsigned int file_opened
= 0; /* Indicate if the file has been opened */
2053 char config_file_path
[PATH_MAX
];
2055 struct config_writer
*writer
= NULL
;
2056 size_t session_name_len
;
2057 const char *provided_path
;
2063 session_name_len
= strlen(session
->name
);
2064 memset(config_file_path
, 0, sizeof(config_file_path
));
2066 if (!session_access_ok(session
,
2067 LTTNG_SOCK_GET_UID_CRED(creds
),
2068 LTTNG_SOCK_GET_GID_CRED(creds
))) {
2069 ret
= LTTNG_ERR_EPERM
;
2073 provided_path
= lttng_save_session_attr_get_output_url(attr
);
2074 if (provided_path
) {
2075 DBG3("Save session in provided path %s", provided_path
);
2076 len
= strlen(provided_path
);
2077 if (len
>= sizeof(config_file_path
)) {
2078 ret
= LTTNG_ERR_SET_URL
;
2081 strncpy(config_file_path
, provided_path
, len
);
2084 char *home_dir
= utils_get_user_home_dir(
2085 LTTNG_SOCK_GET_UID_CRED(creds
));
2087 ret
= LTTNG_ERR_SET_URL
;
2091 ret_len
= snprintf(config_file_path
, sizeof(config_file_path
),
2092 DEFAULT_SESSION_HOME_CONFIGPATH
, home_dir
);
2095 PERROR("snprintf save session");
2096 ret
= LTTNG_ERR_SET_URL
;
2103 * Check the path fits in the config file path dst including the '/'
2104 * followed by trailing .lttng extension and the NULL terminated string.
2106 if ((len
+ session_name_len
+ 2 +
2107 sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
))
2108 > sizeof(config_file_path
)) {
2109 ret
= LTTNG_ERR_SET_URL
;
2113 ret
= run_as_mkdir_recursive(config_file_path
, S_IRWXU
| S_IRWXG
,
2114 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
2116 ret
= LTTNG_ERR_SET_URL
;
2121 * At this point, we know that everything fits in the buffer. Validation
2122 * was done just above.
2124 config_file_path
[len
++] = '/';
2125 strncpy(config_file_path
+ len
, session
->name
, session_name_len
);
2126 len
+= session_name_len
;
2127 strcpy(config_file_path
+ len
, DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
2128 len
+= sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
2129 config_file_path
[len
] = '\0';
2131 if (!access(config_file_path
, F_OK
) && !attr
->overwrite
) {
2132 /* File exists, notify the user since the overwrite flag is off. */
2133 ret
= LTTNG_ERR_SAVE_FILE_EXIST
;
2137 fd
= run_as_open(config_file_path
, O_CREAT
| O_WRONLY
| O_TRUNC
,
2138 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
,
2139 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
2141 PERROR("Could not create configuration file");
2142 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2147 writer
= config_writer_create(fd
, 1);
2149 ret
= LTTNG_ERR_NOMEM
;
2153 ret
= config_writer_open_element(writer
, config_element_sessions
);
2155 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2159 ret
= config_writer_open_element(writer
, config_element_session
);
2161 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2165 ret
= config_writer_write_element_string(writer
, config_element_name
,
2168 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2172 if (session
->shm_path
[0] != '\0') {
2173 ret
= config_writer_write_element_string(writer
,
2174 config_element_shared_memory_path
,
2177 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2182 ret
= save_domains(writer
, session
);
2183 if (ret
!= LTTNG_OK
) {
2187 ret
= config_writer_write_element_bool(writer
, config_element_started
,
2190 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2194 if (session
->snapshot_mode
|| session
->live_timer
) {
2195 ret
= config_writer_open_element(writer
, config_element_attributes
);
2197 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2201 if (session
->snapshot_mode
) {
2202 ret
= config_writer_write_element_bool(writer
,
2203 config_element_snapshot_mode
, 1);
2205 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2209 ret
= config_writer_write_element_unsigned_int(writer
,
2210 config_element_live_timer_interval
, session
->live_timer
);
2212 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2218 ret
= config_writer_close_element(writer
);
2220 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2225 ret
= save_session_output(writer
, session
);
2226 if (ret
!= LTTNG_OK
) {
2231 ret
= config_writer_close_element(writer
);
2233 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2238 ret
= config_writer_close_element(writer
);
2240 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2246 if (writer
&& config_writer_destroy(writer
)) {
2247 /* Preserve the original error code */
2248 ret
= ret
!= LTTNG_OK
? ret
: LTTNG_ERR_SAVE_IO_FAIL
;
2250 if (ret
!= LTTNG_OK
) {
2251 /* Delete file in case of error */
2252 if (file_opened
&& unlink(config_file_path
)) {
2253 PERROR("Unlinking XML session configuration.");
2260 closeret
= close(fd
);
2262 PERROR("Closing XML session configuration");
2269 int cmd_save_sessions(struct lttng_save_session_attr
*attr
,
2270 lttng_sock_cred
*creds
)
2273 const char *session_name
;
2274 struct ltt_session
*session
;
2276 session_lock_list();
2278 session_name
= lttng_save_session_attr_get_session_name(attr
);
2280 session
= session_find_by_name(session_name
);
2282 ret
= LTTNG_ERR_SESS_NOT_FOUND
;
2286 session_lock(session
);
2287 ret
= save_session(session
, attr
, creds
);
2288 session_unlock(session
);
2289 if (ret
!= LTTNG_OK
) {
2293 struct ltt_session_list
*list
= session_get_list();
2295 cds_list_for_each_entry(session
, &list
->head
, list
) {
2296 session_lock(session
);
2297 ret
= save_session(session
, attr
, creds
);
2298 session_unlock(session
);
2300 /* Don't abort if we don't have the required permissions. */
2301 if (ret
!= LTTNG_OK
&& ret
!= LTTNG_ERR_EPERM
) {
2309 session_unlock_list();