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"
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
);
121 return ret
? LTTNG_ERR_SAVE_IO_FAIL
: 0;
125 int save_ust_channel_attributes(struct config_writer
*writer
,
126 struct lttng_ust_channel_attr
*attr
)
129 struct ltt_ust_channel
*channel
= NULL
;
131 ret
= config_writer_write_element_string(writer
,
132 config_element_overwrite_mode
,
133 attr
->overwrite
? config_overwrite_mode_overwrite
:
134 config_overwrite_mode_discard
);
139 ret
= config_writer_write_element_unsigned_int(writer
,
140 config_element_subbuf_size
, attr
->subbuf_size
);
145 ret
= config_writer_write_element_unsigned_int(writer
,
146 config_element_num_subbuf
,
152 ret
= config_writer_write_element_unsigned_int(writer
,
153 config_element_switch_timer_interval
,
154 attr
->switch_timer_interval
);
159 ret
= config_writer_write_element_unsigned_int(writer
,
160 config_element_read_timer_interval
,
161 attr
->read_timer_interval
);
166 ret
= config_writer_write_element_string(writer
,
167 config_element_output_type
,
168 attr
->output
== LTTNG_UST_MMAP
?
169 config_output_type_mmap
: config_output_type_splice
);
175 * Fetch the monitor timer which is located in the parent of
176 * lttng_ust_channel_attr
178 channel
= caa_container_of(attr
, struct ltt_ust_channel
, attr
);
179 ret
= config_writer_write_element_unsigned_int(writer
,
180 config_element_monitor_timer_interval
,
181 channel
->monitor_timer_interval
);
187 return ret
? LTTNG_ERR_SAVE_IO_FAIL
: 0;
191 const char *get_kernel_instrumentation_string(
192 enum lttng_kernel_instrumentation instrumentation
)
194 const char *instrumentation_string
;
196 switch (instrumentation
) {
197 case LTTNG_KERNEL_ALL
:
198 instrumentation_string
= config_event_type_all
;
200 case LTTNG_KERNEL_TRACEPOINT
:
201 instrumentation_string
= config_event_type_tracepoint
;
203 case LTTNG_KERNEL_KPROBE
:
204 instrumentation_string
= config_event_type_kprobe
;
206 case LTTNG_KERNEL_FUNCTION
:
207 instrumentation_string
= config_event_type_function
;
209 case LTTNG_KERNEL_KRETPROBE
:
210 instrumentation_string
= config_event_type_kretprobe
;
212 case LTTNG_KERNEL_NOOP
:
213 instrumentation_string
= config_event_type_noop
;
215 case LTTNG_KERNEL_SYSCALL
:
216 instrumentation_string
= config_event_type_syscall
;
219 instrumentation_string
= NULL
;
222 return instrumentation_string
;
226 const char *get_kernel_context_type_string(
227 enum lttng_kernel_context_type context_type
)
229 const char *context_type_string
;
231 switch (context_type
) {
232 case LTTNG_KERNEL_CONTEXT_PID
:
233 context_type_string
= config_event_context_pid
;
235 case LTTNG_KERNEL_CONTEXT_PROCNAME
:
236 context_type_string
= config_event_context_procname
;
238 case LTTNG_KERNEL_CONTEXT_PRIO
:
239 context_type_string
= config_event_context_prio
;
241 case LTTNG_KERNEL_CONTEXT_NICE
:
242 context_type_string
= config_event_context_nice
;
244 case LTTNG_KERNEL_CONTEXT_VPID
:
245 context_type_string
= config_event_context_vpid
;
247 case LTTNG_KERNEL_CONTEXT_TID
:
248 context_type_string
= config_event_context_tid
;
250 case LTTNG_KERNEL_CONTEXT_VTID
:
251 context_type_string
= config_event_context_vtid
;
253 case LTTNG_KERNEL_CONTEXT_PPID
:
254 context_type_string
= config_event_context_ppid
;
256 case LTTNG_KERNEL_CONTEXT_VPPID
:
257 context_type_string
= config_event_context_vppid
;
259 case LTTNG_KERNEL_CONTEXT_HOSTNAME
:
260 context_type_string
= config_event_context_hostname
;
262 case LTTNG_KERNEL_CONTEXT_INTERRUPTIBLE
:
263 context_type_string
= config_event_context_interruptible
;
265 case LTTNG_KERNEL_CONTEXT_PREEMPTIBLE
:
266 context_type_string
= config_event_context_preemptible
;
268 case LTTNG_KERNEL_CONTEXT_NEED_RESCHEDULE
:
269 context_type_string
= config_event_context_need_reschedule
;
271 case LTTNG_KERNEL_CONTEXT_MIGRATABLE
:
272 context_type_string
= config_event_context_migratable
;
275 context_type_string
= NULL
;
278 return context_type_string
;
282 const char *get_ust_context_type_string(
283 enum lttng_ust_context_type context_type
)
285 const char *context_type_string
;
287 switch (context_type
) {
288 case LTTNG_UST_CONTEXT_PROCNAME
:
289 context_type_string
= config_event_context_procname
;
291 case LTTNG_UST_CONTEXT_VPID
:
292 context_type_string
= config_event_context_vpid
;
294 case LTTNG_UST_CONTEXT_VTID
:
295 context_type_string
= config_event_context_vtid
;
297 case LTTNG_UST_CONTEXT_IP
:
298 context_type_string
= config_event_context_ip
;
300 case LTTNG_UST_CONTEXT_PTHREAD_ID
:
301 context_type_string
= config_event_context_pthread_id
;
303 case LTTNG_UST_CONTEXT_APP_CONTEXT
:
304 context_type_string
= config_event_context_app
;
306 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
:
308 * Error, should not be stored in the XML, perf contexts
309 * are stored as a node of type event_perf_context_type.
312 context_type_string
= NULL
;
316 return context_type_string
;
320 const char *get_buffer_type_string(
321 enum lttng_buffer_type buffer_type
)
323 const char *buffer_type_string
;
325 switch (buffer_type
) {
326 case LTTNG_BUFFER_PER_PID
:
327 buffer_type_string
= config_buffer_type_per_pid
;
329 case LTTNG_BUFFER_PER_UID
:
330 buffer_type_string
= config_buffer_type_per_uid
;
332 case LTTNG_BUFFER_GLOBAL
:
333 buffer_type_string
= config_buffer_type_global
;
336 buffer_type_string
= NULL
;
339 return buffer_type_string
;
343 const char *get_loglevel_type_string(
344 enum lttng_ust_loglevel_type loglevel_type
)
346 const char *loglevel_type_string
;
348 switch (loglevel_type
) {
349 case LTTNG_UST_LOGLEVEL_ALL
:
350 loglevel_type_string
= config_loglevel_type_all
;
352 case LTTNG_UST_LOGLEVEL_RANGE
:
353 loglevel_type_string
= config_loglevel_type_range
;
355 case LTTNG_UST_LOGLEVEL_SINGLE
:
356 loglevel_type_string
= config_loglevel_type_single
;
359 loglevel_type_string
= NULL
;
362 return loglevel_type_string
;
366 int save_kernel_event(struct config_writer
*writer
,
367 struct ltt_kernel_event
*event
)
370 const char *instrumentation_type
;
372 ret
= config_writer_open_element(writer
, config_element_event
);
374 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
378 if (event
->event
->name
[0]) {
379 ret
= config_writer_write_element_string(writer
,
380 config_element_name
, event
->event
->name
);
382 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
387 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
390 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
394 instrumentation_type
= get_kernel_instrumentation_string(
395 event
->event
->instrumentation
);
396 if (!instrumentation_type
) {
397 ret
= LTTNG_ERR_INVALID
;
401 ret
= config_writer_write_element_string(writer
, config_element_type
,
402 instrumentation_type
);
404 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
408 if (event
->filter_expression
) {
409 ret
= config_writer_write_element_string(writer
,
410 config_element_filter
,
411 event
->filter_expression
);
413 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
418 if (event
->event
->instrumentation
== LTTNG_KERNEL_FUNCTION
||
419 event
->event
->instrumentation
== LTTNG_KERNEL_KPROBE
||
420 event
->event
->instrumentation
== LTTNG_KERNEL_KRETPROBE
) {
422 ret
= config_writer_open_element(writer
,
423 config_element_attributes
);
425 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
429 switch (event
->event
->instrumentation
) {
430 case LTTNG_KERNEL_SYSCALL
:
431 case LTTNG_KERNEL_FUNCTION
:
432 ret
= config_writer_open_element(writer
,
433 config_element_function_attributes
);
435 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
439 ret
= config_writer_write_element_string(writer
,
441 event
->event
->u
.ftrace
.symbol_name
);
443 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
447 /* /function attributes */
448 ret
= config_writer_close_element(writer
);
450 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
454 case LTTNG_KERNEL_KPROBE
:
455 case LTTNG_KERNEL_KRETPROBE
:
457 const char *symbol_name
;
461 if (event
->event
->instrumentation
==
462 LTTNG_KERNEL_KPROBE
) {
464 * Comments in lttng-kernel.h mention that
465 * either addr or symbol_name are set, not both.
467 addr
= event
->event
->u
.kprobe
.addr
;
468 offset
= event
->event
->u
.kprobe
.offset
;
469 symbol_name
= addr
? NULL
:
470 event
->event
->u
.kprobe
.symbol_name
;
473 event
->event
->u
.kretprobe
.symbol_name
;
474 addr
= event
->event
->u
.kretprobe
.addr
;
475 offset
= event
->event
->u
.kretprobe
.offset
;
478 ret
= config_writer_open_element(writer
,
479 config_element_probe_attributes
);
481 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
486 ret
= config_writer_write_element_string(writer
,
487 config_element_symbol_name
,
490 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
496 ret
= config_writer_write_element_unsigned_int(
497 writer
, config_element_address
, addr
);
499 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
505 ret
= config_writer_write_element_unsigned_int(
506 writer
, config_element_offset
, offset
);
508 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
513 ret
= config_writer_close_element(writer
);
515 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
521 ERR("Unsupported kernel instrumentation type.");
522 ret
= LTTNG_ERR_INVALID
;
527 ret
= config_writer_close_element(writer
);
529 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
535 ret
= config_writer_close_element(writer
);
537 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
545 int save_kernel_events(struct config_writer
*writer
,
546 struct ltt_kernel_channel
*kchan
)
549 struct ltt_kernel_event
*event
;
551 ret
= config_writer_open_element(writer
, config_element_events
);
553 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
557 cds_list_for_each_entry(event
, &kchan
->events_list
.head
, list
) {
558 ret
= save_kernel_event(writer
, event
);
565 ret
= config_writer_close_element(writer
);
567 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
575 int save_ust_event(struct config_writer
*writer
,
576 struct ltt_ust_event
*event
)
579 const char *loglevel_type_string
;
581 ret
= config_writer_open_element(writer
, config_element_event
);
583 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
587 if (event
->attr
.name
[0]) {
588 ret
= config_writer_write_element_string(writer
,
589 config_element_name
, event
->attr
.name
);
591 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
596 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
599 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
603 if (event
->attr
.instrumentation
!= LTTNG_UST_TRACEPOINT
) {
604 ERR("Unsupported UST instrumentation type.");
605 ret
= LTTNG_ERR_INVALID
;
608 ret
= config_writer_write_element_string(writer
, config_element_type
,
609 config_event_type_tracepoint
);
611 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
615 loglevel_type_string
= get_loglevel_type_string(
616 event
->attr
.loglevel_type
);
617 if (!loglevel_type_string
) {
618 ERR("Unsupported UST loglevel type.");
619 ret
= LTTNG_ERR_INVALID
;
623 ret
= config_writer_write_element_string(writer
,
624 config_element_loglevel_type
, loglevel_type_string
);
626 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
630 /* The log level is irrelevant if no "filtering" is enabled */
631 if (event
->attr
.loglevel_type
!= LTTNG_UST_LOGLEVEL_ALL
) {
632 ret
= config_writer_write_element_signed_int(writer
,
633 config_element_loglevel
, event
->attr
.loglevel
);
635 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
640 if (event
->filter_expression
) {
641 ret
= config_writer_write_element_string(writer
,
642 config_element_filter
, event
->filter_expression
);
644 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
649 if (event
->exclusion
&& event
->exclusion
->count
) {
652 ret
= config_writer_open_element(writer
,
653 config_element_exclusions
);
655 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
659 for (i
= 0; i
< event
->exclusion
->count
; i
++) {
660 ret
= config_writer_write_element_string(writer
,
661 config_element_exclusion
,
662 LTTNG_EVENT_EXCLUSION_NAME_AT(
663 event
->exclusion
, i
));
665 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
671 ret
= config_writer_close_element(writer
);
673 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
679 ret
= config_writer_close_element(writer
);
681 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
689 int save_ust_events(struct config_writer
*writer
,
690 struct lttng_ht
*events
)
693 struct ltt_ust_event
*event
;
694 struct lttng_ht_node_str
*node
;
695 struct lttng_ht_iter iter
;
697 ret
= config_writer_open_element(writer
, config_element_events
);
699 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
704 cds_lfht_for_each_entry(events
->ht
, &iter
.iter
, node
, node
) {
705 event
= caa_container_of(node
, struct ltt_ust_event
, node
);
707 if (event
->internal
) {
708 /* Internal events must not be exposed to clients */
711 ret
= save_ust_event(writer
, event
);
720 ret
= config_writer_close_element(writer
);
722 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
730 int init_ust_event_from_agent_event(struct ltt_ust_event
*ust_event
,
731 struct agent_event
*agent_event
)
734 enum lttng_ust_loglevel_type ust_loglevel_type
;
736 ust_event
->enabled
= agent_event
->enabled
;
737 ust_event
->attr
.instrumentation
= LTTNG_UST_TRACEPOINT
;
738 if (lttng_strncpy(ust_event
->attr
.name
, agent_event
->name
,
739 LTTNG_SYMBOL_NAME_LEN
)) {
743 switch (agent_event
->loglevel_type
) {
744 case LTTNG_EVENT_LOGLEVEL_ALL
:
745 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_ALL
;
747 case LTTNG_EVENT_LOGLEVEL_SINGLE
:
748 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_SINGLE
;
750 case LTTNG_EVENT_LOGLEVEL_RANGE
:
751 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_RANGE
;
754 ERR("Invalid agent_event loglevel_type.");
759 ust_event
->attr
.loglevel_type
= ust_loglevel_type
;
760 ust_event
->attr
.loglevel
= agent_event
->loglevel_value
;
761 ust_event
->filter_expression
= agent_event
->filter_expression
;
762 ust_event
->exclusion
= agent_event
->exclusion
;
768 int save_agent_events(struct config_writer
*writer
,
769 struct ltt_ust_channel
*chan
,
773 struct lttng_ht_iter iter
;
774 struct lttng_ht_node_str
*node
;
776 ret
= config_writer_open_element(writer
, config_element_events
);
778 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
783 cds_lfht_for_each_entry(agent
->events
->ht
, &iter
.iter
, node
, node
) {
785 struct agent_event
*agent_event
;
786 struct ltt_ust_event fake_event
;
788 memset(&fake_event
, 0, sizeof(fake_event
));
789 agent_event
= caa_container_of(node
, struct agent_event
, node
);
792 * Initialize a fake ust event to reuse the same serialization
793 * function since UST and agent events contain the same info
794 * (and one could wonder why they don't reuse the same
797 ret
= init_ust_event_from_agent_event(&fake_event
, agent_event
);
802 ret
= save_ust_event(writer
, &fake_event
);
811 ret
= config_writer_close_element(writer
);
813 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
821 int save_kernel_context(struct config_writer
*writer
,
822 struct lttng_kernel_context
*ctx
)
830 ret
= config_writer_open_element(writer
, config_element_context
);
832 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
836 if (ctx
->ctx
== LTTNG_KERNEL_CONTEXT_PERF_CPU_COUNTER
) {
837 ret
= config_writer_open_element(writer
,
838 config_element_context_perf
);
840 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
844 ret
= config_writer_write_element_unsigned_int(writer
,
845 config_element_type
, ctx
->u
.perf_counter
.type
);
847 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
851 ret
= config_writer_write_element_unsigned_int(writer
,
852 config_element_config
, ctx
->u
.perf_counter
.config
);
854 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
858 ret
= config_writer_write_element_string(writer
,
859 config_element_name
, ctx
->u
.perf_counter
.name
);
861 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
866 ret
= config_writer_close_element(writer
);
868 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
872 const char *context_type_string
=
873 get_kernel_context_type_string(ctx
->ctx
);
875 if (!context_type_string
) {
876 ERR("Unsupported kernel context type.");
877 ret
= LTTNG_ERR_INVALID
;
881 ret
= config_writer_write_element_string(writer
,
882 config_element_type
, context_type_string
);
884 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
890 ret
= config_writer_close_element(writer
);
892 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
901 int save_kernel_contexts(struct config_writer
*writer
,
902 struct ltt_kernel_channel
*kchan
)
905 struct ltt_kernel_context
*ctx
;
907 if (cds_list_empty(&kchan
->ctx_list
)) {
912 ret
= config_writer_open_element(writer
, config_element_contexts
);
914 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
918 cds_list_for_each_entry(ctx
, &kchan
->ctx_list
, list
) {
919 ret
= save_kernel_context(writer
, &ctx
->ctx
);
926 ret
= config_writer_close_element(writer
);
928 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
936 int save_ust_context_perf_thread_counter(struct config_writer
*writer
,
937 struct ltt_ust_context
*ctx
)
944 /* Perf contexts are saved as event_perf_context_type */
945 ret
= config_writer_open_element(writer
, config_element_context_perf
);
947 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
951 ret
= config_writer_write_element_unsigned_int(writer
,
952 config_element_type
, ctx
->ctx
.u
.perf_counter
.type
);
954 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
958 ret
= config_writer_write_element_unsigned_int(writer
,
959 config_element_config
, ctx
->ctx
.u
.perf_counter
.config
);
961 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
965 ret
= config_writer_write_element_string(writer
, config_element_name
,
966 ctx
->ctx
.u
.perf_counter
.name
);
968 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
973 ret
= config_writer_close_element(writer
);
975 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
983 int save_ust_context_app_ctx(struct config_writer
*writer
,
984 struct ltt_ust_context
*ctx
)
991 /* Application contexts are saved as application_context_type */
992 ret
= config_writer_open_element(writer
, config_element_context_app
);
994 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
998 ret
= config_writer_write_element_string(writer
,
999 config_element_context_app_provider_name
,
1000 ctx
->ctx
.u
.app_ctx
.provider_name
);
1002 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1006 ret
= config_writer_write_element_string(writer
,
1007 config_element_context_app_ctx_name
,
1008 ctx
->ctx
.u
.app_ctx
.ctx_name
);
1010 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1015 ret
= config_writer_close_element(writer
);
1017 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1025 int save_ust_context_generic(struct config_writer
*writer
,
1026 struct ltt_ust_context
*ctx
)
1029 const char *context_type_string
;
1034 /* Save context as event_context_type_type */
1035 context_type_string
= get_ust_context_type_string(
1037 if (!context_type_string
) {
1038 ERR("Unsupported UST context type.");
1039 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1043 ret
= config_writer_write_element_string(writer
,
1044 config_element_type
, context_type_string
);
1046 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1054 int save_ust_context(struct config_writer
*writer
,
1055 struct cds_list_head
*ctx_list
)
1058 struct ltt_ust_context
*ctx
;
1063 ret
= config_writer_open_element(writer
, config_element_contexts
);
1065 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1069 cds_list_for_each_entry(ctx
, ctx_list
, list
) {
1070 ret
= config_writer_open_element(writer
,
1071 config_element_context
);
1073 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1077 switch (ctx
->ctx
.ctx
) {
1078 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
:
1079 ret
= save_ust_context_perf_thread_counter(writer
, ctx
);
1081 case LTTNG_UST_CONTEXT_APP_CONTEXT
:
1082 ret
= save_ust_context_app_ctx(writer
, ctx
);
1085 /* Save generic context. */
1086 ret
= save_ust_context_generic(writer
, ctx
);
1093 ret
= config_writer_close_element(writer
);
1095 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1101 ret
= config_writer_close_element(writer
);
1103 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1111 int save_kernel_channel(struct config_writer
*writer
,
1112 struct ltt_kernel_channel
*kchan
)
1119 ret
= config_writer_open_element(writer
, config_element_channel
);
1121 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1125 ret
= config_writer_write_element_string(writer
, config_element_name
,
1126 kchan
->channel
->name
);
1128 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1132 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1133 kchan
->channel
->enabled
);
1135 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1139 ret
= save_kernel_channel_attributes(writer
, &kchan
->channel
->attr
);
1144 ret
= save_kernel_events(writer
, kchan
);
1149 ret
= save_kernel_contexts(writer
, kchan
);
1155 ret
= config_writer_close_element(writer
);
1157 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1165 int save_ust_channel(struct config_writer
*writer
,
1166 struct ltt_ust_channel
*ust_chan
,
1167 struct ltt_ust_session
*session
)
1175 ret
= config_writer_open_element(writer
, config_element_channel
);
1177 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1181 ret
= config_writer_write_element_string(writer
, config_element_name
,
1184 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1188 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1191 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1195 ret
= save_ust_channel_attributes(writer
, &ust_chan
->attr
);
1200 ret
= config_writer_write_element_unsigned_int(writer
,
1201 config_element_tracefile_size
, ust_chan
->tracefile_size
);
1203 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1207 ret
= config_writer_write_element_unsigned_int(writer
,
1208 config_element_tracefile_count
, ust_chan
->tracefile_count
);
1210 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1214 ret
= config_writer_write_element_unsigned_int(writer
,
1215 config_element_live_timer_interval
,
1216 session
->live_timer_interval
);
1218 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1222 if (ust_chan
->domain
== LTTNG_DOMAIN_UST
) {
1223 ret
= save_ust_events(writer
, ust_chan
->events
);
1228 struct agent
*agent
= NULL
;
1230 agent
= trace_ust_find_agent(session
, ust_chan
->domain
);
1232 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1233 ERR("Could not find agent associated to UST subdomain");
1238 * Channels associated with a UST sub-domain (such as JUL, Log4j
1239 * or Python) don't have any non-internal events. We retrieve
1240 * the "agent" events associated with this channel and serialize
1243 ret
= save_agent_events(writer
, ust_chan
, agent
);
1249 ret
= save_ust_context(writer
, &ust_chan
->ctx_list
);
1255 ret
= config_writer_close_element(writer
);
1257 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1265 int save_kernel_session(struct config_writer
*writer
,
1266 struct ltt_session
*session
)
1269 struct ltt_kernel_channel
*kchan
;
1274 ret
= config_writer_write_element_string(writer
, config_element_type
,
1275 config_domain_type_kernel
);
1277 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1281 ret
= config_writer_write_element_string(writer
,
1282 config_element_buffer_type
, config_buffer_type_global
);
1284 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1288 ret
= config_writer_open_element(writer
,
1289 config_element_channels
);
1291 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1295 cds_list_for_each_entry(kchan
, &session
->kernel_session
->channel_list
.head
,
1297 ret
= save_kernel_channel(writer
, kchan
);
1304 ret
= config_writer_close_element(writer
);
1306 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1314 const char *get_config_domain_str(enum lttng_domain_type domain
)
1316 const char *str_dom
;
1319 case LTTNG_DOMAIN_KERNEL
:
1320 str_dom
= config_domain_type_kernel
;
1322 case LTTNG_DOMAIN_UST
:
1323 str_dom
= config_domain_type_ust
;
1325 case LTTNG_DOMAIN_JUL
:
1326 str_dom
= config_domain_type_jul
;
1328 case LTTNG_DOMAIN_LOG4J
:
1329 str_dom
= config_domain_type_log4j
;
1331 case LTTNG_DOMAIN_PYTHON
:
1332 str_dom
= config_domain_type_python
;
1342 int save_pid_tracker(struct config_writer
*writer
,
1343 struct ltt_session
*sess
, int domain
)
1346 ssize_t nr_pids
= 0, i
;
1347 int32_t *pids
= NULL
;
1350 case LTTNG_DOMAIN_KERNEL
:
1352 nr_pids
= kernel_list_tracker_pids(sess
->kernel_session
, &pids
);
1354 ret
= LTTNG_ERR_KERN_LIST_FAIL
;
1359 case LTTNG_DOMAIN_UST
:
1361 nr_pids
= trace_ust_list_tracker_pids(sess
->ust_session
, &pids
);
1363 ret
= LTTNG_ERR_UST_LIST_FAIL
;
1368 case LTTNG_DOMAIN_JUL
:
1369 case LTTNG_DOMAIN_LOG4J
:
1370 case LTTNG_DOMAIN_PYTHON
:
1372 ret
= LTTNG_ERR_UNKNOWN_DOMAIN
;
1376 /* Only create a pid_tracker if enabled or untrack all */
1377 if (nr_pids
!= 1 || (nr_pids
== 1 && pids
[0] != -1)) {
1378 ret
= config_writer_open_element(writer
,
1379 config_element_pid_tracker
);
1381 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1385 ret
= config_writer_open_element(writer
,
1386 config_element_targets
);
1388 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1392 for (i
= 0; i
< nr_pids
; i
++) {
1393 ret
= config_writer_open_element(writer
,
1394 config_element_target_pid
);
1396 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1400 ret
= config_writer_write_element_unsigned_int(writer
,
1401 config_element_pid
, pids
[i
]);
1403 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1408 ret
= config_writer_close_element(writer
);
1410 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1416 ret
= config_writer_close_element(writer
);
1418 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1423 ret
= config_writer_close_element(writer
);
1425 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1435 int save_ust_domain(struct config_writer
*writer
,
1436 struct ltt_session
*session
, enum lttng_domain_type domain
)
1439 struct ltt_ust_channel
*ust_chan
;
1440 const char *buffer_type_string
;
1441 struct lttng_ht_node_str
*node
;
1442 struct lttng_ht_iter iter
;
1443 const char *config_domain_name
;
1448 ret
= config_writer_open_element(writer
,
1449 config_element_domain
);
1451 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1455 config_domain_name
= get_config_domain_str(domain
);
1456 if (!config_domain_name
) {
1457 ret
= LTTNG_ERR_INVALID
;
1461 ret
= config_writer_write_element_string(writer
,
1462 config_element_type
, config_domain_name
);
1464 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1468 buffer_type_string
= get_buffer_type_string(
1469 session
->ust_session
->buffer_type
);
1470 if (!buffer_type_string
) {
1471 ERR("Unsupported buffer type.");
1472 ret
= LTTNG_ERR_INVALID
;
1476 ret
= config_writer_write_element_string(writer
,
1477 config_element_buffer_type
, buffer_type_string
);
1479 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1483 ret
= config_writer_open_element(writer
, config_element_channels
);
1485 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1490 cds_lfht_for_each_entry(session
->ust_session
->domain_global
.channels
->ht
,
1491 &iter
.iter
, node
, node
) {
1492 ust_chan
= caa_container_of(node
, struct ltt_ust_channel
, node
);
1493 if (domain
== ust_chan
->domain
) {
1494 ret
= save_ust_channel(writer
, ust_chan
, session
->ust_session
);
1504 ret
= config_writer_close_element(writer
);
1506 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1510 if (domain
== LTTNG_DOMAIN_UST
) {
1511 ret
= config_writer_open_element(writer
,
1512 config_element_trackers
);
1514 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1518 ret
= save_pid_tracker(writer
, session
, LTTNG_DOMAIN_UST
);
1524 ret
= config_writer_close_element(writer
);
1531 ret
= config_writer_close_element(writer
);
1533 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1542 int save_domains(struct config_writer
*writer
, struct ltt_session
*session
)
1549 if (!session
->kernel_session
&& !session
->ust_session
) {
1553 ret
= config_writer_open_element(writer
, config_element_domains
);
1555 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1560 if (session
->kernel_session
) {
1561 ret
= config_writer_open_element(writer
,
1562 config_element_domain
);
1564 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1568 ret
= save_kernel_session(writer
, session
);
1573 ret
= config_writer_open_element(writer
,
1574 config_element_trackers
);
1576 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1580 ret
= save_pid_tracker(writer
, session
, LTTNG_DOMAIN_KERNEL
);
1586 ret
= config_writer_close_element(writer
);
1588 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1592 ret
= config_writer_close_element(writer
);
1594 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1599 if (session
->ust_session
) {
1600 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_UST
);
1605 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_JUL
);
1610 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_LOG4J
);
1615 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_PYTHON
);
1622 ret
= config_writer_close_element(writer
);
1624 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1632 int save_consumer_output(struct config_writer
*writer
,
1633 struct consumer_output
*output
)
1640 ret
= config_writer_open_element(writer
, config_element_consumer_output
);
1642 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1646 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1649 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1653 ret
= config_writer_open_element(writer
, config_element_destination
);
1655 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1659 switch (output
->type
) {
1660 case CONSUMER_DST_LOCAL
:
1661 ret
= config_writer_write_element_string(writer
,
1662 config_element_path
, output
->dst
.trace_path
);
1664 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1668 case CONSUMER_DST_NET
:
1672 uri
= zmalloc(PATH_MAX
);
1674 ret
= LTTNG_ERR_NOMEM
;
1678 ret
= config_writer_open_element(writer
, config_element_net_output
);
1680 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1681 goto end_net_output
;
1684 if (output
->dst
.net
.control_isset
&&
1685 output
->dst
.net
.data_isset
) {
1686 ret
= uri_to_str_url(&output
->dst
.net
.control
, uri
, PATH_MAX
);
1688 ret
= LTTNG_ERR_INVALID
;
1689 goto end_net_output
;
1692 ret
= config_writer_write_element_string(writer
,
1693 config_element_control_uri
, uri
);
1695 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1696 goto end_net_output
;
1699 ret
= uri_to_str_url(&output
->dst
.net
.data
, uri
, PATH_MAX
);
1701 ret
= LTTNG_ERR_INVALID
;
1702 goto end_net_output
;
1705 ret
= config_writer_write_element_string(writer
,
1706 config_element_data_uri
, uri
);
1708 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1709 goto end_net_output
;
1718 ret
= !output
->dst
.net
.control_isset
?
1719 LTTNG_ERR_URL_CTRL_MISS
:
1720 LTTNG_ERR_URL_DATA_MISS
;
1725 ret
= config_writer_close_element(writer
);
1727 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1733 ERR("Unsupported consumer output type.");
1734 ret
= LTTNG_ERR_INVALID
;
1739 ret
= config_writer_close_element(writer
);
1741 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1745 /* /consumer_output */
1746 ret
= config_writer_close_element(writer
);
1748 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1756 int save_snapshot_outputs(struct config_writer
*writer
,
1757 struct snapshot
*snapshot
)
1760 struct lttng_ht_iter iter
;
1761 struct snapshot_output
*output
;
1766 ret
= config_writer_open_element(writer
, config_element_snapshot_outputs
);
1768 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1773 cds_lfht_for_each_entry(snapshot
->output_ht
->ht
, &iter
.iter
, output
,
1775 ret
= config_writer_open_element(writer
,
1776 config_element_output
);
1778 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1782 ret
= config_writer_write_element_string(writer
,
1783 config_element_name
, output
->name
);
1785 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1789 ret
= config_writer_write_element_unsigned_int(writer
,
1790 config_element_max_size
, output
->max_size
);
1792 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1796 ret
= save_consumer_output(writer
, output
->consumer
);
1802 ret
= config_writer_close_element(writer
);
1804 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1810 /* /snapshot_outputs */
1811 ret
= config_writer_close_element(writer
);
1813 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1825 int save_session_output(struct config_writer
*writer
,
1826 struct ltt_session
*session
)
1833 if ((session
->snapshot_mode
&& session
->snapshot
.nb_output
== 0) ||
1834 (!session
->snapshot_mode
&& !session
->consumer
)) {
1835 /* Session is in no output mode */
1840 ret
= config_writer_open_element(writer
, config_element_output
);
1842 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1846 if (session
->snapshot_mode
) {
1847 ret
= save_snapshot_outputs(writer
, &session
->snapshot
);
1852 if (session
->consumer
) {
1853 ret
= save_consumer_output(writer
, session
->consumer
);
1861 ret
= config_writer_close_element(writer
);
1863 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1871 * Save the given session.
1873 * Return 0 on success else a LTTNG_ERR* code.
1876 int save_session(struct ltt_session
*session
,
1877 struct lttng_save_session_attr
*attr
, lttng_sock_cred
*creds
)
1880 unsigned int file_opened
= 0; /* Indicate if the file has been opened */
1881 char config_file_path
[PATH_MAX
];
1883 struct config_writer
*writer
= NULL
;
1884 size_t session_name_len
;
1885 const char *provided_path
;
1891 session_name_len
= strlen(session
->name
);
1892 memset(config_file_path
, 0, sizeof(config_file_path
));
1894 if (!session_access_ok(session
,
1895 LTTNG_SOCK_GET_UID_CRED(creds
),
1896 LTTNG_SOCK_GET_GID_CRED(creds
))) {
1897 ret
= LTTNG_ERR_EPERM
;
1901 provided_path
= lttng_save_session_attr_get_output_url(attr
);
1902 if (provided_path
) {
1903 DBG3("Save session in provided path %s", provided_path
);
1904 len
= strlen(provided_path
);
1905 if (len
>= sizeof(config_file_path
)) {
1906 ret
= LTTNG_ERR_SET_URL
;
1909 strncpy(config_file_path
, provided_path
, len
);
1912 char *home_dir
= utils_get_user_home_dir(
1913 LTTNG_SOCK_GET_UID_CRED(creds
));
1915 ret
= LTTNG_ERR_SET_URL
;
1919 ret_len
= snprintf(config_file_path
, sizeof(config_file_path
),
1920 DEFAULT_SESSION_HOME_CONFIGPATH
, home_dir
);
1923 PERROR("snprintf save session");
1924 ret
= LTTNG_ERR_SET_URL
;
1931 * Check the path fits in the config file path dst including the '/'
1932 * followed by trailing .lttng extension and the NULL terminated string.
1934 if ((len
+ session_name_len
+ 2 +
1935 sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
))
1936 > sizeof(config_file_path
)) {
1937 ret
= LTTNG_ERR_SET_URL
;
1941 ret
= run_as_mkdir_recursive(config_file_path
, S_IRWXU
| S_IRWXG
,
1942 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
1944 ret
= LTTNG_ERR_SET_URL
;
1949 * At this point, we know that everything fits in the buffer. Validation
1950 * was done just above.
1952 config_file_path
[len
++] = '/';
1953 strncpy(config_file_path
+ len
, session
->name
, session_name_len
);
1954 len
+= session_name_len
;
1955 strcpy(config_file_path
+ len
, DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
1956 len
+= sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
1957 config_file_path
[len
] = '\0';
1959 if (!access(config_file_path
, F_OK
) && !attr
->overwrite
) {
1960 /* File exists, notify the user since the overwrite flag is off. */
1961 ret
= LTTNG_ERR_SAVE_FILE_EXIST
;
1965 fd
= run_as_open(config_file_path
, O_CREAT
| O_WRONLY
| O_TRUNC
,
1966 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
,
1967 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
1969 PERROR("Could not create configuration file");
1970 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1975 writer
= config_writer_create(fd
, 1);
1977 ret
= LTTNG_ERR_NOMEM
;
1981 ret
= config_writer_open_element(writer
, config_element_sessions
);
1983 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1987 ret
= config_writer_open_element(writer
, config_element_session
);
1989 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1993 ret
= config_writer_write_element_string(writer
, config_element_name
,
1996 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2000 if(session
->shm_path
[0] != '\0') {
2001 ret
= config_writer_write_element_string(writer
,
2002 config_element_shared_memory_path
,
2005 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2010 ret
= save_domains(writer
, session
);
2015 ret
= config_writer_write_element_bool(writer
, config_element_started
,
2018 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2022 if (session
->snapshot_mode
|| session
->live_timer
) {
2023 ret
= config_writer_open_element(writer
, config_element_attributes
);
2025 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2029 if (session
->snapshot_mode
) {
2030 ret
= config_writer_write_element_bool(writer
,
2031 config_element_snapshot_mode
, 1);
2033 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2037 ret
= config_writer_write_element_unsigned_int(writer
,
2038 config_element_live_timer_interval
, session
->live_timer
);
2040 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2046 ret
= config_writer_close_element(writer
);
2048 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2053 ret
= save_session_output(writer
, session
);
2059 ret
= config_writer_close_element(writer
);
2061 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2066 ret
= config_writer_close_element(writer
);
2068 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2072 if (writer
&& config_writer_destroy(writer
)) {
2073 /* Preserve the original error code */
2074 ret
= ret
? ret
: LTTNG_ERR_SAVE_IO_FAIL
;
2077 /* Delete file in case of error */
2078 if (file_opened
&& unlink(config_file_path
)) {
2079 PERROR("Unlinking XML session configuration.");
2086 PERROR("Closing XML session configuration");
2093 int cmd_save_sessions(struct lttng_save_session_attr
*attr
,
2094 lttng_sock_cred
*creds
)
2097 const char *session_name
;
2098 struct ltt_session
*session
;
2100 session_lock_list();
2102 session_name
= lttng_save_session_attr_get_session_name(attr
);
2104 session
= session_find_by_name(session_name
);
2106 ret
= LTTNG_ERR_SESS_NOT_FOUND
;
2110 session_lock(session
);
2111 ret
= save_session(session
, attr
, creds
);
2112 session_unlock(session
);
2117 struct ltt_session_list
*list
= session_get_list();
2119 cds_list_for_each_entry(session
, &list
->head
, list
) {
2120 session_lock(session
);
2121 ret
= save_session(session
, attr
, creds
);
2122 session_unlock(session
);
2124 /* Don't abort if we don't have the required permissions. */
2125 if (ret
&& ret
!= LTTNG_ERR_EPERM
) {
2133 session_unlock_list();