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"
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
);
54 ret
= config_writer_write_element_unsigned_int(writer
,
55 config_element_subbuf_size
, attr
->subbuf_size
);
60 ret
= config_writer_write_element_unsigned_int(writer
,
61 config_element_num_subbuf
,
67 ret
= config_writer_write_element_unsigned_int(writer
,
68 config_element_switch_timer_interval
,
69 attr
->switch_timer_interval
);
74 ret
= config_writer_write_element_unsigned_int(writer
,
75 config_element_read_timer_interval
,
76 attr
->read_timer_interval
);
81 ret
= config_writer_write_element_string(writer
,
82 config_element_output_type
,
83 attr
->output
== LTTNG_EVENT_SPLICE
?
84 config_output_type_splice
: config_output_type_mmap
);
89 ret
= config_writer_write_element_unsigned_int(writer
,
90 config_element_tracefile_size
, attr
->tracefile_size
);
95 ret
= config_writer_write_element_unsigned_int(writer
,
96 config_element_tracefile_count
,
97 attr
->tracefile_count
);
102 ret
= config_writer_write_element_unsigned_int(writer
,
103 config_element_live_timer_interval
,
104 attr
->live_timer_interval
);
109 return ret
? LTTNG_ERR_SAVE_IO_FAIL
: 0;
113 int save_ust_channel_attributes(struct config_writer
*writer
,
114 struct lttng_ust_channel_attr
*attr
)
118 ret
= config_writer_write_element_string(writer
,
119 config_element_overwrite_mode
,
120 attr
->overwrite
? config_overwrite_mode_overwrite
:
121 config_overwrite_mode_discard
);
126 ret
= config_writer_write_element_unsigned_int(writer
,
127 config_element_subbuf_size
, attr
->subbuf_size
);
132 ret
= config_writer_write_element_unsigned_int(writer
,
133 config_element_num_subbuf
,
139 ret
= config_writer_write_element_unsigned_int(writer
,
140 config_element_switch_timer_interval
,
141 attr
->switch_timer_interval
);
146 ret
= config_writer_write_element_unsigned_int(writer
,
147 config_element_read_timer_interval
,
148 attr
->read_timer_interval
);
153 ret
= config_writer_write_element_string(writer
,
154 config_element_output_type
,
155 attr
->output
== LTTNG_UST_MMAP
?
156 config_output_type_mmap
: config_output_type_splice
);
161 return ret
? LTTNG_ERR_SAVE_IO_FAIL
: 0;
165 const char *get_kernel_instrumentation_string(
166 enum lttng_kernel_instrumentation instrumentation
)
168 const char *instrumentation_string
;
170 switch (instrumentation
) {
171 case LTTNG_KERNEL_ALL
:
172 instrumentation_string
= config_event_type_all
;
174 case LTTNG_KERNEL_TRACEPOINT
:
175 instrumentation_string
= config_event_type_tracepoint
;
177 case LTTNG_KERNEL_KPROBE
:
178 instrumentation_string
= config_event_type_kprobe
;
180 case LTTNG_KERNEL_FUNCTION
:
181 instrumentation_string
= config_event_type_function
;
183 case LTTNG_KERNEL_KRETPROBE
:
184 instrumentation_string
= config_event_type_kretprobe
;
186 case LTTNG_KERNEL_NOOP
:
187 instrumentation_string
= config_event_type_noop
;
189 case LTTNG_KERNEL_SYSCALL
:
190 instrumentation_string
= config_event_type_syscall
;
193 instrumentation_string
= NULL
;
196 return instrumentation_string
;
200 const char *get_kernel_context_type_string(
201 enum lttng_kernel_context_type context_type
)
203 const char *context_type_string
;
205 switch (context_type
) {
206 case LTTNG_KERNEL_CONTEXT_PID
:
207 context_type_string
= config_event_context_pid
;
209 case LTTNG_KERNEL_CONTEXT_PROCNAME
:
210 context_type_string
= config_event_context_procname
;
212 case LTTNG_KERNEL_CONTEXT_PRIO
:
213 context_type_string
= config_event_context_prio
;
215 case LTTNG_KERNEL_CONTEXT_NICE
:
216 context_type_string
= config_event_context_nice
;
218 case LTTNG_KERNEL_CONTEXT_VPID
:
219 context_type_string
= config_event_context_vpid
;
221 case LTTNG_KERNEL_CONTEXT_TID
:
222 context_type_string
= config_event_context_tid
;
224 case LTTNG_KERNEL_CONTEXT_VTID
:
225 context_type_string
= config_event_context_vtid
;
227 case LTTNG_KERNEL_CONTEXT_PPID
:
228 context_type_string
= config_event_context_ppid
;
230 case LTTNG_KERNEL_CONTEXT_VPPID
:
231 context_type_string
= config_event_context_vppid
;
233 case LTTNG_KERNEL_CONTEXT_HOSTNAME
:
234 context_type_string
= config_event_context_hostname
;
237 context_type_string
= NULL
;
240 return context_type_string
;
244 const char *get_ust_context_type_string(
245 enum lttng_ust_context_type context_type
)
247 const char *context_type_string
;
249 switch (context_type
) {
250 case LTTNG_UST_CONTEXT_PROCNAME
:
251 context_type_string
= config_event_context_procname
;
253 case LTTNG_UST_CONTEXT_VPID
:
254 context_type_string
= config_event_context_vpid
;
256 case LTTNG_UST_CONTEXT_VTID
:
257 context_type_string
= config_event_context_vtid
;
259 case LTTNG_UST_CONTEXT_IP
:
260 context_type_string
= config_event_context_ip
;
262 case LTTNG_UST_CONTEXT_PTHREAD_ID
:
263 context_type_string
= config_event_context_pthread_id
;
265 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
:
267 * Error, should not be stored in the XML, perf contexts
268 * are stored as a node of type event_perf_context_type.
271 context_type_string
= NULL
;
275 return context_type_string
;
279 const char *get_buffer_type_string(
280 enum lttng_buffer_type buffer_type
)
282 const char *buffer_type_string
;
284 switch (buffer_type
) {
285 case LTTNG_BUFFER_PER_PID
:
286 buffer_type_string
= config_buffer_type_per_pid
;
288 case LTTNG_BUFFER_PER_UID
:
289 buffer_type_string
= config_buffer_type_per_uid
;
291 case LTTNG_BUFFER_GLOBAL
:
292 buffer_type_string
= config_buffer_type_global
;
295 buffer_type_string
= NULL
;
298 return buffer_type_string
;
302 const char *get_loglevel_type_string(
303 enum lttng_ust_loglevel_type loglevel_type
)
305 const char *loglevel_type_string
;
307 switch (loglevel_type
) {
308 case LTTNG_UST_LOGLEVEL_ALL
:
309 loglevel_type_string
= config_loglevel_type_all
;
311 case LTTNG_UST_LOGLEVEL_RANGE
:
312 loglevel_type_string
= config_loglevel_type_range
;
314 case LTTNG_UST_LOGLEVEL_SINGLE
:
315 loglevel_type_string
= config_loglevel_type_single
;
318 loglevel_type_string
= NULL
;
321 return loglevel_type_string
;
325 int save_kernel_event(struct config_writer
*writer
,
326 struct ltt_kernel_event
*event
)
329 const char *instrumentation_type
;
331 ret
= config_writer_open_element(writer
, config_element_event
);
333 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
337 if (event
->event
->name
[0]) {
338 ret
= config_writer_write_element_string(writer
,
339 config_element_name
, event
->event
->name
);
341 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
346 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
349 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
353 instrumentation_type
= get_kernel_instrumentation_string(
354 event
->event
->instrumentation
);
355 if (!instrumentation_type
) {
356 ret
= LTTNG_ERR_INVALID
;
360 ret
= config_writer_write_element_string(writer
, config_element_type
,
361 instrumentation_type
);
363 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
367 if (event
->filter_expression
) {
368 ret
= config_writer_write_element_string(writer
,
369 config_element_filter
,
370 event
->filter_expression
);
372 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
377 if (event
->event
->instrumentation
== LTTNG_KERNEL_FUNCTION
||
378 event
->event
->instrumentation
== LTTNG_KERNEL_KPROBE
||
379 event
->event
->instrumentation
== LTTNG_KERNEL_KRETPROBE
) {
381 ret
= config_writer_open_element(writer
,
382 config_element_attributes
);
384 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
388 switch (event
->event
->instrumentation
) {
389 case LTTNG_KERNEL_SYSCALL
:
390 case LTTNG_KERNEL_FUNCTION
:
391 ret
= config_writer_open_element(writer
,
392 config_element_function_attributes
);
394 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
398 ret
= config_writer_write_element_string(writer
,
400 event
->event
->u
.ftrace
.symbol_name
);
402 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
406 /* /function attributes */
407 ret
= config_writer_close_element(writer
);
409 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
413 case LTTNG_KERNEL_KPROBE
:
414 case LTTNG_KERNEL_KRETPROBE
:
416 const char *symbol_name
;
420 if (event
->event
->instrumentation
==
421 LTTNG_KERNEL_KPROBE
) {
423 * Comments in lttng-kernel.h mention that
424 * either addr or symbol_name are set, not both.
426 addr
= event
->event
->u
.kprobe
.addr
;
427 offset
= event
->event
->u
.kprobe
.offset
;
428 symbol_name
= addr
? NULL
:
429 event
->event
->u
.kprobe
.symbol_name
;
432 event
->event
->u
.kretprobe
.symbol_name
;
433 addr
= event
->event
->u
.kretprobe
.addr
;
434 offset
= event
->event
->u
.kretprobe
.offset
;
437 ret
= config_writer_open_element(writer
,
438 config_element_probe_attributes
);
440 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
445 ret
= config_writer_write_element_string(writer
,
446 config_element_symbol_name
,
449 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
455 ret
= config_writer_write_element_unsigned_int(
456 writer
, config_element_address
, addr
);
458 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
464 ret
= config_writer_write_element_unsigned_int(
465 writer
, config_element_offset
, offset
);
467 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
472 ret
= config_writer_close_element(writer
);
474 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
480 ERR("Unsupported kernel instrumentation type.");
481 ret
= LTTNG_ERR_INVALID
;
486 ret
= config_writer_close_element(writer
);
488 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
494 ret
= config_writer_close_element(writer
);
496 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
504 int save_kernel_syscall(struct config_writer
*writer
,
505 struct ltt_kernel_channel
*kchan
)
509 struct lttng_event
*events
= NULL
;
514 count
= syscall_list_channel(kchan
, &events
, 0);
516 /* No syscalls, just gracefully return. */
521 for (i
= 0; i
< count
; i
++) {
522 struct ltt_kernel_event
*kevent
;
524 /* Create a temporary kevent in order to save it. */
526 * TODO: struct lttng_event does not really work for a filter,
527 * but unfortunately, it is exposed as external API (and used as
528 * internal representation. Using NULL meanwhile.
530 kevent
= trace_kernel_create_event(&events
[i
],
536 /* Init list in order so the destroy call can del the node. */
537 CDS_INIT_LIST_HEAD(&kevent
->list
);
539 ret
= save_kernel_event(writer
, kevent
);
540 trace_kernel_destroy_event(kevent
);
546 /* Everything went well */
555 int save_kernel_events(struct config_writer
*writer
,
556 struct ltt_kernel_channel
*kchan
)
559 struct ltt_kernel_event
*event
;
561 ret
= config_writer_open_element(writer
, config_element_events
);
563 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
567 cds_list_for_each_entry(event
, &kchan
->events_list
.head
, list
) {
568 ret
= save_kernel_event(writer
, event
);
574 /* Save syscalls if any. */
575 ret
= save_kernel_syscall(writer
, kchan
);
581 ret
= config_writer_close_element(writer
);
583 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
591 int save_ust_event(struct config_writer
*writer
,
592 struct ltt_ust_event
*event
)
595 const char *loglevel_type_string
;
597 ret
= config_writer_open_element(writer
, config_element_event
);
599 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
603 if (event
->attr
.name
[0]) {
604 ret
= config_writer_write_element_string(writer
,
605 config_element_name
, event
->attr
.name
);
607 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
612 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
615 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
619 if (event
->attr
.instrumentation
!= LTTNG_UST_TRACEPOINT
) {
620 ERR("Unsupported UST instrumentation type.");
621 ret
= LTTNG_ERR_INVALID
;
624 ret
= config_writer_write_element_string(writer
, config_element_type
,
625 config_event_type_tracepoint
);
627 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
631 loglevel_type_string
= get_loglevel_type_string(
632 event
->attr
.loglevel_type
);
633 if (!loglevel_type_string
) {
634 ERR("Unsupported UST loglevel type.");
635 ret
= LTTNG_ERR_INVALID
;
639 ret
= config_writer_write_element_string(writer
,
640 config_element_loglevel_type
, loglevel_type_string
);
642 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
646 /* The log level is irrelevant if no "filtering" is enabled */
647 if (event
->attr
.loglevel_type
!= LTTNG_UST_LOGLEVEL_ALL
) {
648 ret
= config_writer_write_element_signed_int(writer
,
649 config_element_loglevel
, event
->attr
.loglevel
);
651 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
656 if (event
->filter_expression
) {
657 ret
= config_writer_write_element_string(writer
,
658 config_element_filter
, event
->filter_expression
);
660 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
665 if (event
->exclusion
&& event
->exclusion
->count
) {
668 ret
= config_writer_open_element(writer
,
669 config_element_exclusions
);
671 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
675 for (i
= 0; i
< event
->exclusion
->count
; i
++) {
676 ret
= config_writer_write_element_string(writer
,
677 config_element_exclusion
,
678 &event
->exclusion
->names
[0][i
]);
680 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
686 ret
= config_writer_close_element(writer
);
688 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
694 ret
= config_writer_close_element(writer
);
696 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
704 int save_ust_events(struct config_writer
*writer
,
705 struct lttng_ht
*events
)
708 struct ltt_ust_event
*event
;
709 struct lttng_ht_node_str
*node
;
710 struct lttng_ht_iter iter
;
712 ret
= config_writer_open_element(writer
, config_element_events
);
714 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
719 cds_lfht_for_each_entry(events
->ht
, &iter
.iter
, node
, node
) {
720 event
= caa_container_of(node
, struct ltt_ust_event
, node
);
722 if (event
->internal
) {
723 /* Internal events must not be exposed to clients */
726 ret
= save_ust_event(writer
, event
);
735 ret
= config_writer_close_element(writer
);
737 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
745 int init_ust_event_from_agent_event(struct ltt_ust_event
*ust_event
,
746 struct agent_event
*agent_event
)
749 enum lttng_ust_loglevel_type ust_loglevel_type
;
751 ust_event
->enabled
= agent_event
->enabled
;
752 ust_event
->attr
.instrumentation
= LTTNG_UST_TRACEPOINT
;
753 strncpy(ust_event
->attr
.name
, agent_event
->name
, LTTNG_SYMBOL_NAME_LEN
);
754 switch (agent_event
->loglevel_type
) {
755 case LTTNG_EVENT_LOGLEVEL_ALL
:
756 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_ALL
;
758 case LTTNG_EVENT_LOGLEVEL_SINGLE
:
759 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_SINGLE
;
761 case LTTNG_EVENT_LOGLEVEL_RANGE
:
762 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_RANGE
;
765 ERR("Invalid agent_event loglevel_type.");
770 ust_event
->attr
.loglevel_type
= ust_loglevel_type
;
771 ust_event
->attr
.loglevel
= agent_event
->loglevel_value
;
772 ust_event
->filter_expression
= agent_event
->filter_expression
;
773 ust_event
->exclusion
= agent_event
->exclusion
;
779 int save_agent_events(struct config_writer
*writer
,
780 struct ltt_ust_channel
*chan
,
784 struct lttng_ht_iter iter
;
785 struct lttng_ht_node_str
*node
;
787 ret
= config_writer_open_element(writer
, config_element_events
);
789 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
794 cds_lfht_for_each_entry(agent
->events
->ht
, &iter
.iter
, node
, node
) {
796 struct agent_event
*agent_event
;
797 struct ltt_ust_event fake_event
;
799 memset(&fake_event
, 0, sizeof(fake_event
));
800 agent_event
= caa_container_of(node
, struct agent_event
, node
);
803 * Initialize a fake ust event to reuse the same serialization
804 * function since UST and agent events contain the same info
805 * (and one could wonder why they don't reuse the same
808 ret
= init_ust_event_from_agent_event(&fake_event
, agent_event
);
813 ret
= save_ust_event(writer
, &fake_event
);
822 ret
= config_writer_close_element(writer
);
824 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
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
, config_element_perf
);
850 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
854 ret
= config_writer_write_element_unsigned_int(writer
,
855 config_element_type
, ctx
->u
.perf_counter
.type
);
857 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
861 ret
= config_writer_write_element_unsigned_int(writer
,
862 config_element_config
, ctx
->u
.perf_counter
.config
);
864 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
868 ret
= config_writer_write_element_string(writer
,
869 config_element_name
, ctx
->u
.perf_counter
.name
);
871 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
876 ret
= config_writer_close_element(writer
);
878 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
882 const char *context_type_string
=
883 get_kernel_context_type_string(ctx
->ctx
);
885 if (!context_type_string
) {
886 ERR("Unsupported kernel context type.");
887 ret
= LTTNG_ERR_INVALID
;
891 ret
= config_writer_write_element_string(writer
,
892 config_element_type
, context_type_string
);
894 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
900 ret
= config_writer_close_element(writer
);
902 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
911 int save_kernel_contexts(struct config_writer
*writer
,
912 struct ltt_kernel_channel
*kchan
)
915 struct ltt_kernel_context
*ctx
;
917 if (cds_list_empty(&kchan
->ctx_list
)) {
922 ret
= config_writer_open_element(writer
, config_element_contexts
);
924 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
928 cds_list_for_each_entry(ctx
, &kchan
->ctx_list
, list
) {
929 ret
= save_kernel_context(writer
, &ctx
->ctx
);
936 ret
= config_writer_close_element(writer
);
938 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
946 int save_ust_context(struct config_writer
*writer
,
947 struct cds_list_head
*ctx_list
)
950 struct ltt_ust_context
*ctx
;
955 ret
= config_writer_open_element(writer
, config_element_contexts
);
957 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
961 cds_list_for_each_entry(ctx
, ctx_list
, list
) {
962 const char *context_type_string
;
965 ret
= config_writer_open_element(writer
,
966 config_element_context
);
968 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
972 if (ctx
->ctx
.ctx
== LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
) {
973 /* Perf contexts are saved as event_perf_context_type */
974 ret
= config_writer_open_element(writer
,
975 config_element_perf
);
977 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
981 ret
= config_writer_write_element_unsigned_int(writer
,
983 ctx
->ctx
.u
.perf_counter
.type
);
985 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
989 ret
= config_writer_write_element_unsigned_int(writer
,
990 config_element_config
,
991 ctx
->ctx
.u
.perf_counter
.config
);
993 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
997 ret
= config_writer_write_element_string(writer
,
999 ctx
->ctx
.u
.perf_counter
.name
);
1001 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1006 ret
= config_writer_close_element(writer
);
1008 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1012 /* Save context as event_context_type_type */
1013 context_type_string
= get_ust_context_type_string(
1015 if (!context_type_string
) {
1016 ERR("Unsupported UST context type.")
1017 ret
= LTTNG_ERR_INVALID
;
1021 ret
= config_writer_write_element_string(writer
,
1022 config_element_type
, context_type_string
);
1024 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1030 ret
= config_writer_close_element(writer
);
1032 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1038 ret
= config_writer_close_element(writer
);
1040 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1048 int save_kernel_channel(struct config_writer
*writer
,
1049 struct ltt_kernel_channel
*kchan
)
1056 ret
= config_writer_open_element(writer
, config_element_channel
);
1058 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1062 ret
= config_writer_write_element_string(writer
, config_element_name
,
1063 kchan
->channel
->name
);
1065 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1069 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1070 kchan
->channel
->enabled
);
1072 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1076 ret
= save_kernel_channel_attributes(writer
, &kchan
->channel
->attr
);
1081 ret
= save_kernel_events(writer
, kchan
);
1086 ret
= save_kernel_contexts(writer
, kchan
);
1092 ret
= config_writer_close_element(writer
);
1094 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1102 int save_ust_channel(struct config_writer
*writer
,
1103 struct ltt_ust_channel
*ust_chan
,
1104 struct ltt_ust_session
*session
)
1112 ret
= config_writer_open_element(writer
, config_element_channel
);
1114 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1118 ret
= config_writer_write_element_string(writer
, config_element_name
,
1121 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1125 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1128 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1132 ret
= save_ust_channel_attributes(writer
, &ust_chan
->attr
);
1137 ret
= config_writer_write_element_unsigned_int(writer
,
1138 config_element_tracefile_size
, ust_chan
->tracefile_size
);
1140 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1144 ret
= config_writer_write_element_unsigned_int(writer
,
1145 config_element_tracefile_count
, ust_chan
->tracefile_count
);
1147 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1151 ret
= config_writer_write_element_unsigned_int(writer
,
1152 config_element_live_timer_interval
,
1153 session
->live_timer_interval
);
1155 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1159 if (ust_chan
->domain
== LTTNG_DOMAIN_UST
) {
1160 ret
= save_ust_events(writer
, ust_chan
->events
);
1165 struct agent
*agent
= NULL
;
1167 agent
= trace_ust_find_agent(session
, ust_chan
->domain
);
1169 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1170 ERR("Could not find agent associated to UST subdomain");
1175 * Channels associated with a UST sub-domain (such as JUL, Log4j
1176 * or Python) don't have any non-internal events. We retrieve
1177 * the "agent" events associated with this channel and serialize
1180 ret
= save_agent_events(writer
, ust_chan
, agent
);
1186 ret
= save_ust_context(writer
, &ust_chan
->ctx_list
);
1192 ret
= config_writer_close_element(writer
);
1194 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1202 int save_kernel_session(struct config_writer
*writer
,
1203 struct ltt_session
*session
)
1206 struct ltt_kernel_channel
*kchan
;
1211 ret
= config_writer_write_element_string(writer
, config_element_type
,
1212 config_domain_type_kernel
);
1214 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1218 ret
= config_writer_write_element_string(writer
,
1219 config_element_buffer_type
, config_buffer_type_global
);
1221 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1225 ret
= config_writer_open_element(writer
,
1226 config_element_channels
);
1228 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1232 cds_list_for_each_entry(kchan
, &session
->kernel_session
->channel_list
.head
,
1234 ret
= save_kernel_channel(writer
, kchan
);
1241 ret
= config_writer_close_element(writer
);
1243 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1251 const char *get_config_domain_str(enum lttng_domain_type domain
)
1253 const char *str_dom
;
1256 case LTTNG_DOMAIN_KERNEL
:
1257 str_dom
= config_domain_type_kernel
;
1259 case LTTNG_DOMAIN_UST
:
1260 str_dom
= config_domain_type_ust
;
1262 case LTTNG_DOMAIN_JUL
:
1263 str_dom
= config_domain_type_jul
;
1265 case LTTNG_DOMAIN_LOG4J
:
1266 str_dom
= config_domain_type_log4j
;
1268 case LTTNG_DOMAIN_PYTHON
:
1269 str_dom
= config_domain_type_python
;
1279 int save_pid_tracker(struct config_writer
*writer
,
1280 struct ltt_session
*sess
, int domain
)
1283 ssize_t nr_pids
= 0, i
;
1284 int32_t *pids
= NULL
;
1287 case LTTNG_DOMAIN_KERNEL
:
1289 nr_pids
= kernel_list_tracker_pids(sess
->kernel_session
, &pids
);
1291 ret
= LTTNG_ERR_KERN_LIST_FAIL
;
1296 case LTTNG_DOMAIN_UST
:
1298 nr_pids
= trace_ust_list_tracker_pids(sess
->ust_session
, &pids
);
1300 ret
= LTTNG_ERR_UST_LIST_FAIL
;
1305 case LTTNG_DOMAIN_JUL
:
1306 case LTTNG_DOMAIN_LOG4J
:
1307 case LTTNG_DOMAIN_PYTHON
:
1309 ret
= LTTNG_ERR_UNKNOWN_DOMAIN
;
1313 /* Only create a pid_tracker if enabled or untrack all */
1314 if (nr_pids
!= 1 || (nr_pids
== 1 && pids
[0] != -1)) {
1315 ret
= config_writer_open_element(writer
,
1316 config_element_pid_tracker
);
1318 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1322 ret
= config_writer_open_element(writer
,
1323 config_element_targets
);
1325 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1329 for (i
= 0; i
< nr_pids
; i
++) {
1330 ret
= config_writer_open_element(writer
,
1331 config_element_target_pid
);
1333 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1337 ret
= config_writer_write_element_unsigned_int(writer
,
1338 config_element_pid
, pids
[i
]);
1340 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1345 ret
= config_writer_close_element(writer
);
1347 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1353 ret
= config_writer_close_element(writer
);
1355 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1360 ret
= config_writer_close_element(writer
);
1362 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1372 int save_ust_domain(struct config_writer
*writer
,
1373 struct ltt_session
*session
, enum lttng_domain_type domain
)
1376 struct ltt_ust_channel
*ust_chan
;
1377 const char *buffer_type_string
;
1378 struct lttng_ht_node_str
*node
;
1379 struct lttng_ht_iter iter
;
1380 const char *config_domain_name
;
1385 ret
= config_writer_open_element(writer
,
1386 config_element_domain
);
1388 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1392 config_domain_name
= get_config_domain_str(domain
);
1393 if (!config_domain_name
) {
1394 ret
= LTTNG_ERR_INVALID
;
1398 ret
= config_writer_write_element_string(writer
,
1399 config_element_type
, config_domain_name
);
1401 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1405 buffer_type_string
= get_buffer_type_string(
1406 session
->ust_session
->buffer_type
);
1407 if (!buffer_type_string
) {
1408 ERR("Unsupported buffer type.");
1409 ret
= LTTNG_ERR_INVALID
;
1413 ret
= config_writer_write_element_string(writer
,
1414 config_element_buffer_type
, buffer_type_string
);
1416 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1420 ret
= config_writer_open_element(writer
, config_element_channels
);
1422 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1427 cds_lfht_for_each_entry(session
->ust_session
->domain_global
.channels
->ht
,
1428 &iter
.iter
, node
, node
) {
1429 ust_chan
= caa_container_of(node
, struct ltt_ust_channel
, node
);
1430 if (domain
== ust_chan
->domain
) {
1431 ret
= save_ust_channel(writer
, ust_chan
, session
->ust_session
);
1441 ret
= config_writer_close_element(writer
);
1443 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1447 if (domain
== LTTNG_DOMAIN_UST
) {
1448 ret
= config_writer_open_element(writer
,
1449 config_element_trackers
);
1451 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1455 ret
= save_pid_tracker(writer
, session
, LTTNG_DOMAIN_UST
);
1461 ret
= config_writer_close_element(writer
);
1468 ret
= config_writer_close_element(writer
);
1470 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1479 int save_domains(struct config_writer
*writer
, struct ltt_session
*session
)
1486 if (!session
->kernel_session
&& !session
->ust_session
) {
1490 ret
= config_writer_open_element(writer
, config_element_domains
);
1492 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1497 if (session
->kernel_session
) {
1498 ret
= config_writer_open_element(writer
,
1499 config_element_domain
);
1501 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1505 ret
= save_kernel_session(writer
, session
);
1510 ret
= config_writer_open_element(writer
,
1511 config_element_trackers
);
1513 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1517 ret
= save_pid_tracker(writer
, session
, LTTNG_DOMAIN_KERNEL
);
1523 ret
= config_writer_close_element(writer
);
1525 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1529 ret
= config_writer_close_element(writer
);
1531 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1536 if (session
->ust_session
) {
1537 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_UST
);
1542 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_JUL
);
1547 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_LOG4J
);
1552 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_PYTHON
);
1558 if (session
->ust_session
) {
1562 ret
= config_writer_close_element(writer
);
1564 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1572 int save_consumer_output(struct config_writer
*writer
,
1573 struct consumer_output
*output
)
1580 ret
= config_writer_open_element(writer
, config_element_consumer_output
);
1582 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1586 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1589 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1593 ret
= config_writer_open_element(writer
, config_element_destination
);
1595 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1599 switch (output
->type
) {
1600 case CONSUMER_DST_LOCAL
:
1601 ret
= config_writer_write_element_string(writer
,
1602 config_element_path
, output
->dst
.trace_path
);
1604 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1608 case CONSUMER_DST_NET
:
1612 uri
= zmalloc(PATH_MAX
);
1614 ret
= LTTNG_ERR_NOMEM
;
1618 ret
= config_writer_open_element(writer
, config_element_net_output
);
1620 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1621 goto end_net_output
;
1624 if (output
->dst
.net
.control_isset
&&
1625 output
->dst
.net
.data_isset
) {
1626 ret
= uri_to_str_url(&output
->dst
.net
.control
, uri
, PATH_MAX
);
1628 ret
= LTTNG_ERR_INVALID
;
1629 goto end_net_output
;
1632 ret
= config_writer_write_element_string(writer
,
1633 config_element_control_uri
, uri
);
1635 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1636 goto end_net_output
;
1639 ret
= uri_to_str_url(&output
->dst
.net
.data
, uri
, PATH_MAX
);
1641 ret
= LTTNG_ERR_INVALID
;
1642 goto end_net_output
;
1645 ret
= config_writer_write_element_string(writer
,
1646 config_element_data_uri
, uri
);
1648 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1649 goto end_net_output
;
1658 ret
= !output
->dst
.net
.control_isset
?
1659 LTTNG_ERR_URL_CTRL_MISS
:
1660 LTTNG_ERR_URL_DATA_MISS
;
1665 ret
= config_writer_close_element(writer
);
1667 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1673 ERR("Unsupported consumer output type.");
1674 ret
= LTTNG_ERR_INVALID
;
1679 ret
= config_writer_close_element(writer
);
1681 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1685 /* /consumer_output */
1686 ret
= config_writer_close_element(writer
);
1688 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1696 int save_snapshot_outputs(struct config_writer
*writer
,
1697 struct snapshot
*snapshot
)
1700 struct lttng_ht_iter iter
;
1701 struct snapshot_output
*output
;
1706 ret
= config_writer_open_element(writer
, config_element_snapshot_outputs
);
1708 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1713 cds_lfht_for_each_entry(snapshot
->output_ht
->ht
, &iter
.iter
, output
,
1715 ret
= config_writer_open_element(writer
,
1716 config_element_output
);
1718 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1722 ret
= config_writer_write_element_string(writer
,
1723 config_element_name
, output
->name
);
1725 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1729 ret
= config_writer_write_element_unsigned_int(writer
,
1730 config_element_max_size
, output
->max_size
);
1732 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1736 ret
= save_consumer_output(writer
, output
->consumer
);
1742 ret
= config_writer_close_element(writer
);
1744 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1750 /* /snapshot_outputs */
1751 ret
= config_writer_close_element(writer
);
1753 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1765 int save_session_output(struct config_writer
*writer
,
1766 struct ltt_session
*session
)
1773 if ((session
->snapshot_mode
&& session
->snapshot
.nb_output
== 0) ||
1774 (!session
->snapshot_mode
&& !session
->consumer
)) {
1775 /* Session is in no output mode */
1780 ret
= config_writer_open_element(writer
, config_element_output
);
1782 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1786 if (session
->snapshot_mode
) {
1787 ret
= save_snapshot_outputs(writer
, &session
->snapshot
);
1792 if (session
->consumer
) {
1793 ret
= save_consumer_output(writer
, session
->consumer
);
1801 ret
= config_writer_close_element(writer
);
1803 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1811 * Save the given session.
1813 * Return 0 on success else a LTTNG_ERR* code.
1816 int save_session(struct ltt_session
*session
,
1817 struct lttng_save_session_attr
*attr
, lttng_sock_cred
*creds
)
1820 unsigned int file_opened
= 0; /* Indicate if the file has been opened */
1821 char config_file_path
[PATH_MAX
];
1823 struct config_writer
*writer
= NULL
;
1824 size_t session_name_len
;
1825 const char *provided_path
;
1831 session_name_len
= strlen(session
->name
);
1832 memset(config_file_path
, 0, sizeof(config_file_path
));
1834 if (!session_access_ok(session
,
1835 LTTNG_SOCK_GET_UID_CRED(creds
),
1836 LTTNG_SOCK_GET_GID_CRED(creds
))) {
1837 ret
= LTTNG_ERR_EPERM
;
1841 provided_path
= lttng_save_session_attr_get_output_url(attr
);
1842 if (provided_path
) {
1843 DBG3("Save session in provided path %s", provided_path
);
1844 len
= strlen(provided_path
);
1845 if (len
>= sizeof(config_file_path
)) {
1846 ret
= LTTNG_ERR_SET_URL
;
1849 strncpy(config_file_path
, provided_path
, len
);
1852 char *home_dir
= utils_get_user_home_dir(
1853 LTTNG_SOCK_GET_UID_CRED(creds
));
1855 ret
= LTTNG_ERR_SET_URL
;
1859 ret_len
= snprintf(config_file_path
, sizeof(config_file_path
),
1860 DEFAULT_SESSION_HOME_CONFIGPATH
, home_dir
);
1863 PERROR("snprintf save session");
1864 ret
= LTTNG_ERR_SET_URL
;
1871 * Check the path fits in the config file path dst including the '/'
1872 * followed by trailing .lttng extension and the NULL terminated string.
1874 if ((len
+ session_name_len
+ 2 +
1875 sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
))
1876 > sizeof(config_file_path
)) {
1877 ret
= LTTNG_ERR_SET_URL
;
1881 ret
= run_as_mkdir_recursive(config_file_path
, S_IRWXU
| S_IRWXG
,
1882 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
1884 ret
= LTTNG_ERR_SET_URL
;
1889 * At this point, we know that everything fits in the buffer. Validation
1890 * was done just above.
1892 config_file_path
[len
++] = '/';
1893 strncpy(config_file_path
+ len
, session
->name
, session_name_len
);
1894 len
+= session_name_len
;
1895 strcpy(config_file_path
+ len
, DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
1896 len
+= sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
1897 config_file_path
[len
] = '\0';
1899 if (!access(config_file_path
, F_OK
) && !attr
->overwrite
) {
1900 /* File exists, notify the user since the overwrite flag is off. */
1901 ret
= LTTNG_ERR_SAVE_FILE_EXIST
;
1905 fd
= run_as_open(config_file_path
, O_CREAT
| O_WRONLY
| O_TRUNC
,
1906 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
,
1907 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
1909 PERROR("Could not create configuration file");
1910 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1915 writer
= config_writer_create(fd
, 1);
1917 ret
= LTTNG_ERR_NOMEM
;
1921 ret
= config_writer_open_element(writer
, config_element_sessions
);
1923 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1927 ret
= config_writer_open_element(writer
, config_element_session
);
1929 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1933 ret
= config_writer_write_element_string(writer
, config_element_name
,
1936 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1940 if(session
->shm_path
[0] != '\0') {
1941 ret
= config_writer_write_element_string(writer
,
1942 config_element_shared_memory_path
,
1945 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1950 ret
= save_domains(writer
, session
);
1955 ret
= config_writer_write_element_bool(writer
, config_element_started
,
1958 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1962 if (session
->snapshot_mode
|| session
->live_timer
) {
1963 ret
= config_writer_open_element(writer
, config_element_attributes
);
1965 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1969 if (session
->snapshot_mode
) {
1970 ret
= config_writer_write_element_bool(writer
,
1971 config_element_snapshot_mode
, 1);
1973 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1977 ret
= config_writer_write_element_unsigned_int(writer
,
1978 config_element_live_timer_interval
, session
->live_timer
);
1980 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1986 ret
= config_writer_close_element(writer
);
1988 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1993 ret
= save_session_output(writer
, session
);
1999 ret
= config_writer_close_element(writer
);
2001 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2006 ret
= config_writer_close_element(writer
);
2008 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2012 if (writer
&& config_writer_destroy(writer
)) {
2013 /* Preserve the original error code */
2014 ret
= ret
? ret
: LTTNG_ERR_SAVE_IO_FAIL
;
2017 /* Delete file in case of error */
2018 if (file_opened
&& unlink(config_file_path
)) {
2019 PERROR("Unlinking XML session configuration.");
2026 int cmd_save_sessions(struct lttng_save_session_attr
*attr
,
2027 lttng_sock_cred
*creds
)
2030 const char *session_name
;
2031 struct ltt_session
*session
;
2033 session_lock_list();
2035 session_name
= lttng_save_session_attr_get_session_name(attr
);
2037 session
= session_find_by_name(session_name
);
2039 ret
= LTTNG_ERR_SESS_NOT_FOUND
;
2043 session_lock(session
);
2044 ret
= save_session(session
, attr
, creds
);
2045 session_unlock(session
);
2050 struct ltt_session_list
*list
= session_get_list();
2052 cds_list_for_each_entry(session
, &list
->head
, list
) {
2053 session_lock(session
);
2054 ret
= save_session(session
, attr
, creds
);
2055 session_unlock(session
);
2057 /* Don't abort if we don't have the required permissions. */
2058 if (ret
&& ret
!= LTTNG_ERR_EPERM
) {
2066 session_unlock_list();