2 * Copyright (C) 2014 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License, version 2 only, as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 51
15 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 #include <urcu/uatomic.h>
25 #include <common/defaults.h>
26 #include <common/error.h>
27 #include <common/config/session-config.h>
28 #include <common/utils.h>
29 #include <common/runas.h>
30 #include <lttng/save-internal.h>
35 #include "lttng-syscall.h"
36 #include "trace-ust.h"
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
;
118 if (attr
->extended
.ptr
) {
119 struct lttng_channel_extended
*ext
= NULL
;
121 ext
= (struct lttng_channel_extended
*) attr
->extended
.ptr
;
122 ret
= config_writer_write_element_unsigned_int(writer
,
123 config_element_monitor_timer_interval
,
124 ext
->monitor_timer_interval
);
126 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
130 ret
= config_writer_write_element_signed_int(writer
,
131 config_element_blocking_timeout
,
132 ext
->blocking_timeout
);
134 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
144 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
146 int save_ust_channel_attributes(struct config_writer
*writer
,
147 struct lttng_ust_channel_attr
*attr
)
150 struct ltt_ust_channel
*channel
= NULL
;
152 ret
= config_writer_write_element_string(writer
,
153 config_element_overwrite_mode
,
154 attr
->overwrite
? config_overwrite_mode_overwrite
:
155 config_overwrite_mode_discard
);
157 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
161 ret
= config_writer_write_element_unsigned_int(writer
,
162 config_element_subbuf_size
, attr
->subbuf_size
);
164 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
168 ret
= config_writer_write_element_unsigned_int(writer
,
169 config_element_num_subbuf
,
172 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
176 ret
= config_writer_write_element_unsigned_int(writer
,
177 config_element_switch_timer_interval
,
178 attr
->switch_timer_interval
);
180 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
184 ret
= config_writer_write_element_unsigned_int(writer
,
185 config_element_read_timer_interval
,
186 attr
->read_timer_interval
);
188 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
192 ret
= config_writer_write_element_string(writer
,
193 config_element_output_type
,
194 attr
->output
== LTTNG_UST_MMAP
?
195 config_output_type_mmap
: config_output_type_splice
);
197 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
201 ret
= config_writer_write_element_signed_int(writer
,
202 config_element_blocking_timeout
,
203 attr
->u
.s
.blocking_timeout
);
205 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
210 * Fetch the monitor timer which is located in the parent of
211 * lttng_ust_channel_attr
213 channel
= caa_container_of(attr
, struct ltt_ust_channel
, attr
);
214 ret
= config_writer_write_element_unsigned_int(writer
,
215 config_element_monitor_timer_interval
,
216 channel
->monitor_timer_interval
);
218 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
228 const char *get_kernel_instrumentation_string(
229 enum lttng_kernel_instrumentation instrumentation
)
231 const char *instrumentation_string
;
233 switch (instrumentation
) {
234 case LTTNG_KERNEL_ALL
:
235 instrumentation_string
= config_event_type_all
;
237 case LTTNG_KERNEL_TRACEPOINT
:
238 instrumentation_string
= config_event_type_tracepoint
;
240 case LTTNG_KERNEL_KPROBE
:
241 instrumentation_string
= config_event_type_probe
;
243 case LTTNG_KERNEL_UPROBE
:
244 instrumentation_string
= config_event_type_userspace_probe
;
246 case LTTNG_KERNEL_FUNCTION
:
247 instrumentation_string
= config_event_type_function_entry
;
249 case LTTNG_KERNEL_KRETPROBE
:
250 instrumentation_string
= config_event_type_function
;
252 case LTTNG_KERNEL_NOOP
:
253 instrumentation_string
= config_event_type_noop
;
255 case LTTNG_KERNEL_SYSCALL
:
256 instrumentation_string
= config_event_type_syscall
;
259 instrumentation_string
= NULL
;
262 return instrumentation_string
;
266 const char *get_kernel_context_type_string(
267 enum lttng_kernel_context_type context_type
)
269 const char *context_type_string
;
271 switch (context_type
) {
272 case LTTNG_KERNEL_CONTEXT_PID
:
273 context_type_string
= config_event_context_pid
;
275 case LTTNG_KERNEL_CONTEXT_PROCNAME
:
276 context_type_string
= config_event_context_procname
;
278 case LTTNG_KERNEL_CONTEXT_PRIO
:
279 context_type_string
= config_event_context_prio
;
281 case LTTNG_KERNEL_CONTEXT_NICE
:
282 context_type_string
= config_event_context_nice
;
284 case LTTNG_KERNEL_CONTEXT_VPID
:
285 context_type_string
= config_event_context_vpid
;
287 case LTTNG_KERNEL_CONTEXT_TID
:
288 context_type_string
= config_event_context_tid
;
290 case LTTNG_KERNEL_CONTEXT_VTID
:
291 context_type_string
= config_event_context_vtid
;
293 case LTTNG_KERNEL_CONTEXT_PPID
:
294 context_type_string
= config_event_context_ppid
;
296 case LTTNG_KERNEL_CONTEXT_VPPID
:
297 context_type_string
= config_event_context_vppid
;
299 case LTTNG_KERNEL_CONTEXT_HOSTNAME
:
300 context_type_string
= config_event_context_hostname
;
302 case LTTNG_KERNEL_CONTEXT_INTERRUPTIBLE
:
303 context_type_string
= config_event_context_interruptible
;
305 case LTTNG_KERNEL_CONTEXT_PREEMPTIBLE
:
306 context_type_string
= config_event_context_preemptible
;
308 case LTTNG_KERNEL_CONTEXT_NEED_RESCHEDULE
:
309 context_type_string
= config_event_context_need_reschedule
;
311 case LTTNG_KERNEL_CONTEXT_MIGRATABLE
:
312 context_type_string
= config_event_context_migratable
;
314 case LTTNG_KERNEL_CONTEXT_CALLSTACK_USER
:
315 context_type_string
= config_event_context_callstack_user
;
317 case LTTNG_KERNEL_CONTEXT_CALLSTACK_KERNEL
:
318 context_type_string
= config_event_context_callstack_kernel
;
320 case LTTNG_KERNEL_CONTEXT_CGROUP_NS
:
321 context_type_string
= config_event_context_cgroup_ns
;
323 case LTTNG_KERNEL_CONTEXT_IPC_NS
:
324 context_type_string
= config_event_context_ipc_ns
;
326 case LTTNG_KERNEL_CONTEXT_MNT_NS
:
327 context_type_string
= config_event_context_mnt_ns
;
329 case LTTNG_KERNEL_CONTEXT_NET_NS
:
330 context_type_string
= config_event_context_net_ns
;
332 case LTTNG_KERNEL_CONTEXT_PID_NS
:
333 context_type_string
= config_event_context_pid_ns
;
335 case LTTNG_KERNEL_CONTEXT_USER_NS
:
336 context_type_string
= config_event_context_user_ns
;
338 case LTTNG_KERNEL_CONTEXT_UTS_NS
:
339 context_type_string
= config_event_context_uts_ns
;
341 case LTTNG_KERNEL_CONTEXT_UID
:
342 context_type_string
= config_event_context_uid
;
344 case LTTNG_KERNEL_CONTEXT_EUID
:
345 context_type_string
= config_event_context_euid
;
347 case LTTNG_KERNEL_CONTEXT_SUID
:
348 context_type_string
= config_event_context_suid
;
350 case LTTNG_KERNEL_CONTEXT_GID
:
351 context_type_string
= config_event_context_gid
;
353 case LTTNG_KERNEL_CONTEXT_EGID
:
354 context_type_string
= config_event_context_egid
;
356 case LTTNG_KERNEL_CONTEXT_SGID
:
357 context_type_string
= config_event_context_sgid
;
359 case LTTNG_KERNEL_CONTEXT_VUID
:
360 context_type_string
= config_event_context_vuid
;
362 case LTTNG_KERNEL_CONTEXT_VEUID
:
363 context_type_string
= config_event_context_veuid
;
365 case LTTNG_KERNEL_CONTEXT_VSUID
:
366 context_type_string
= config_event_context_vsuid
;
368 case LTTNG_KERNEL_CONTEXT_VGID
:
369 context_type_string
= config_event_context_vgid
;
371 case LTTNG_KERNEL_CONTEXT_VEGID
:
372 context_type_string
= config_event_context_vegid
;
374 case LTTNG_KERNEL_CONTEXT_VSGID
:
375 context_type_string
= config_event_context_vsgid
;
378 context_type_string
= NULL
;
381 return context_type_string
;
385 const char *get_ust_context_type_string(
386 enum lttng_ust_context_type context_type
)
388 const char *context_type_string
;
390 switch (context_type
) {
391 case LTTNG_UST_CONTEXT_PROCNAME
:
392 context_type_string
= config_event_context_procname
;
394 case LTTNG_UST_CONTEXT_VPID
:
395 context_type_string
= config_event_context_vpid
;
397 case LTTNG_UST_CONTEXT_VTID
:
398 context_type_string
= config_event_context_vtid
;
400 case LTTNG_UST_CONTEXT_IP
:
401 context_type_string
= config_event_context_ip
;
403 case LTTNG_UST_CONTEXT_PTHREAD_ID
:
404 context_type_string
= config_event_context_pthread_id
;
406 case LTTNG_UST_CONTEXT_APP_CONTEXT
:
407 context_type_string
= config_event_context_app
;
409 case LTTNG_UST_CONTEXT_CGROUP_NS
:
410 context_type_string
= config_event_context_cgroup_ns
;
412 case LTTNG_UST_CONTEXT_IPC_NS
:
413 context_type_string
= config_event_context_ipc_ns
;
415 case LTTNG_UST_CONTEXT_MNT_NS
:
416 context_type_string
= config_event_context_mnt_ns
;
418 case LTTNG_UST_CONTEXT_NET_NS
:
419 context_type_string
= config_event_context_net_ns
;
421 case LTTNG_UST_CONTEXT_PID_NS
:
422 context_type_string
= config_event_context_pid_ns
;
424 case LTTNG_UST_CONTEXT_USER_NS
:
425 context_type_string
= config_event_context_user_ns
;
427 case LTTNG_UST_CONTEXT_UTS_NS
:
428 context_type_string
= config_event_context_uts_ns
;
430 case LTTNG_UST_CONTEXT_VUID
:
431 context_type_string
= config_event_context_vuid
;
433 case LTTNG_UST_CONTEXT_VEUID
:
434 context_type_string
= config_event_context_veuid
;
436 case LTTNG_UST_CONTEXT_VSUID
:
437 context_type_string
= config_event_context_vsuid
;
439 case LTTNG_UST_CONTEXT_VGID
:
440 context_type_string
= config_event_context_vgid
;
442 case LTTNG_UST_CONTEXT_VEGID
:
443 context_type_string
= config_event_context_vegid
;
445 case LTTNG_UST_CONTEXT_VSGID
:
446 context_type_string
= config_event_context_vsgid
;
448 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
:
450 * Error, should not be stored in the XML, perf contexts
451 * are stored as a node of type event_perf_context_type.
454 context_type_string
= NULL
;
458 return context_type_string
;
462 const char *get_buffer_type_string(
463 enum lttng_buffer_type buffer_type
)
465 const char *buffer_type_string
;
467 switch (buffer_type
) {
468 case LTTNG_BUFFER_PER_PID
:
469 buffer_type_string
= config_buffer_type_per_pid
;
471 case LTTNG_BUFFER_PER_UID
:
472 buffer_type_string
= config_buffer_type_per_uid
;
474 case LTTNG_BUFFER_GLOBAL
:
475 buffer_type_string
= config_buffer_type_global
;
478 buffer_type_string
= NULL
;
481 return buffer_type_string
;
485 const char *get_loglevel_type_string(
486 enum lttng_ust_loglevel_type loglevel_type
)
488 const char *loglevel_type_string
;
490 switch (loglevel_type
) {
491 case LTTNG_UST_LOGLEVEL_ALL
:
492 loglevel_type_string
= config_loglevel_type_all
;
494 case LTTNG_UST_LOGLEVEL_RANGE
:
495 loglevel_type_string
= config_loglevel_type_range
;
497 case LTTNG_UST_LOGLEVEL_SINGLE
:
498 loglevel_type_string
= config_loglevel_type_single
;
501 loglevel_type_string
= NULL
;
504 return loglevel_type_string
;
507 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
509 int save_kernel_function_event(struct config_writer
*writer
,
510 struct ltt_kernel_event
*event
)
514 ret
= config_writer_open_element(writer
, config_element_function_attributes
);
516 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
520 ret
= config_writer_write_element_string(writer
, config_element_name
,
521 event
->event
->u
.ftrace
.symbol_name
);
523 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
527 /* /function attributes */
528 ret
= config_writer_close_element(writer
);
530 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
538 int save_kernel_kprobe_event(struct config_writer
*writer
,
539 struct ltt_kernel_event
*event
)
542 const char *symbol_name
;
546 switch (event
->event
->instrumentation
) {
547 case LTTNG_KERNEL_KPROBE
:
549 * Comments in lttng-kernel.h mention that
550 * either addr or symbol_name are set, not both.
552 addr
= event
->event
->u
.kprobe
.addr
;
553 offset
= event
->event
->u
.kprobe
.offset
;
554 symbol_name
= addr
? NULL
: event
->event
->u
.kprobe
.symbol_name
;
556 case LTTNG_KERNEL_KRETPROBE
:
557 addr
= event
->event
->u
.kretprobe
.addr
;
558 offset
= event
->event
->u
.kretprobe
.offset
;
559 symbol_name
= addr
? NULL
: event
->event
->u
.kretprobe
.symbol_name
;
563 ERR("Unsupported kernel instrumentation type.");
564 ret
= LTTNG_ERR_INVALID
;
568 ret
= config_writer_open_element(writer
, config_element_probe_attributes
);
570 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
575 ret
= config_writer_write_element_unsigned_int( writer
,
576 config_element_address
, addr
);
578 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
581 } else if (symbol_name
) {
582 ret
= config_writer_write_element_string(writer
,
583 config_element_symbol_name
, symbol_name
);
585 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
588 /* If the offset is non-zero, write it.*/
590 ret
= config_writer_write_element_unsigned_int(writer
,
591 config_element_offset
, offset
);
593 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
599 * This really should not happen as we are either setting the
600 * address or the symbol above.
602 ERR("Invalid probe/function description.");
603 ret
= LTTNG_ERR_INVALID
;
608 ret
= config_writer_close_element(writer
);
610 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
618 * Save the userspace probe tracepoint event associated with the event to the
622 int save_kernel_userspace_probe_tracepoint_event(struct config_writer
*writer
,
623 struct ltt_kernel_event
*event
)
626 const char *probe_name
, *provider_name
, *binary_path
;
627 const struct lttng_userspace_probe_location
*userspace_probe_location
;
628 const struct lttng_userspace_probe_location_lookup_method
*lookup_method
;
629 enum lttng_userspace_probe_location_lookup_method_type lookup_type
;
631 /* Get userspace probe location from the event. */
632 userspace_probe_location
= event
->userspace_probe_location
;
633 if (!userspace_probe_location
) {
634 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
638 /* Get lookup method and lookup method type. */
639 lookup_method
= lttng_userspace_probe_location_get_lookup_method(userspace_probe_location
);
640 if (!lookup_method
) {
641 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
645 lookup_type
= lttng_userspace_probe_location_lookup_method_get_type(lookup_method
);
647 /* Get the binary path, probe name and provider name. */
649 lttng_userspace_probe_location_tracepoint_get_binary_path(
650 userspace_probe_location
);
652 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
657 lttng_userspace_probe_location_tracepoint_get_probe_name(
658 userspace_probe_location
);
660 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
665 lttng_userspace_probe_location_tracepoint_get_provider_name(
666 userspace_probe_location
);
667 if (!provider_name
) {
668 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
672 /* Open a userspace probe tracepoint attribute. */
673 ret
= config_writer_open_element(writer
, config_element_userspace_probe_tracepoint_attributes
);
675 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
679 switch (lookup_type
) {
680 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT
:
681 ret
= config_writer_write_element_string(writer
,
682 config_element_userspace_probe_lookup
,
683 config_element_userspace_probe_lookup_tracepoint_sdt
);
685 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
690 ERR("Unsupported kernel userspace probe tracepoint lookup method.");
691 ret
= LTTNG_ERR_INVALID
;
695 /* Write the binary path, provider name and the probe name. */
696 ret
= config_writer_write_element_string(writer
,
697 config_element_userspace_probe_location_binary_path
,
700 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
704 ret
= config_writer_write_element_string(writer
,
705 config_element_userspace_probe_tracepoint_location_provider_name
,
708 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
712 ret
= config_writer_write_element_string(writer
,
713 config_element_userspace_probe_tracepoint_location_probe_name
,
716 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
720 /* Close the userspace probe tracepoint attribute. */
721 ret
= config_writer_close_element(writer
);
723 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
732 * Save the userspace probe function event associated with the event to the
736 int save_kernel_userspace_probe_function_event(struct config_writer
*writer
,
737 struct ltt_kernel_event
*event
)
740 const char *function_name
, *binary_path
;
741 const struct lttng_userspace_probe_location
*userspace_probe_location
;
742 const struct lttng_userspace_probe_location_lookup_method
*lookup_method
;
743 enum lttng_userspace_probe_location_lookup_method_type lookup_type
;
745 /* Get userspace probe location from the event. */
746 userspace_probe_location
= event
->userspace_probe_location
;
747 if (!userspace_probe_location
) {
748 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
752 /* Get lookup method and lookup method type. */
753 lookup_method
= lttng_userspace_probe_location_get_lookup_method(
754 userspace_probe_location
);
755 if (!lookup_method
) {
756 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
760 /* Get the binary path and the function name. */
762 lttng_userspace_probe_location_function_get_binary_path(
763 userspace_probe_location
);
765 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
770 lttng_userspace_probe_location_function_get_function_name(
771 userspace_probe_location
);
772 if (!function_name
) {
773 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
777 /* Open a userspace probe function attribute. */
778 ret
= config_writer_open_element(writer
,
779 config_element_userspace_probe_function_attributes
);
781 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
785 lookup_type
= lttng_userspace_probe_location_lookup_method_get_type(lookup_method
);
786 switch (lookup_type
) {
787 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF
:
788 ret
= config_writer_write_element_string(writer
,
789 config_element_userspace_probe_lookup
,
790 config_element_userspace_probe_lookup_function_elf
);
792 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
796 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT
:
797 ret
= config_writer_write_element_string(writer
,
798 config_element_userspace_probe_lookup
,
799 config_element_userspace_probe_lookup_function_default
);
801 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
806 ERR("Unsupported kernel userspace probe function lookup method.");
807 ret
= LTTNG_ERR_INVALID
;
811 /* Write the binary path and the function name. */
812 ret
= config_writer_write_element_string(writer
,
813 config_element_userspace_probe_location_binary_path
,
816 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
820 ret
= config_writer_write_element_string(writer
,
821 config_element_userspace_probe_function_location_function_name
,
824 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
828 /* Close the userspace probe function attribute. */
829 ret
= config_writer_close_element(writer
);
831 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
840 int save_kernel_userspace_probe_event(struct config_writer
*writer
,
841 struct ltt_kernel_event
*event
)
844 struct lttng_userspace_probe_location
*userspace_probe_location
;
846 /* Get userspace probe location from the event. */
847 userspace_probe_location
= event
->userspace_probe_location
;
848 if (!userspace_probe_location
) {
849 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
853 switch(lttng_userspace_probe_location_get_type(userspace_probe_location
)) {
854 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION
:
856 ret
= save_kernel_userspace_probe_function_event(writer
, event
);
858 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
863 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT
:
865 ret
= save_kernel_userspace_probe_tracepoint_event(writer
, event
);
867 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
872 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_UNKNOWN
:
874 ERR("Unsupported kernel userspace probe location type.");
875 ret
= LTTNG_ERR_INVALID
;
884 int save_kernel_event(struct config_writer
*writer
,
885 struct ltt_kernel_event
*event
)
888 const char *instrumentation_type
;
890 ret
= config_writer_open_element(writer
, config_element_event
);
892 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
896 if (event
->event
->name
[0]) {
897 ret
= config_writer_write_element_string(writer
,
898 config_element_name
, event
->event
->name
);
900 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
905 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
908 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
912 instrumentation_type
= get_kernel_instrumentation_string(
913 event
->event
->instrumentation
);
914 if (!instrumentation_type
) {
915 ret
= LTTNG_ERR_INVALID
;
919 ret
= config_writer_write_element_string(writer
, config_element_type
,
920 instrumentation_type
);
922 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
926 if (event
->filter_expression
) {
927 ret
= config_writer_write_element_string(writer
,
928 config_element_filter
,
929 event
->filter_expression
);
931 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
936 if (event
->event
->instrumentation
== LTTNG_KERNEL_FUNCTION
||
937 event
->event
->instrumentation
== LTTNG_KERNEL_KPROBE
||
938 event
->event
->instrumentation
== LTTNG_KERNEL_UPROBE
||
939 event
->event
->instrumentation
== LTTNG_KERNEL_KRETPROBE
) {
941 ret
= config_writer_open_element(writer
,
942 config_element_attributes
);
944 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
948 switch (event
->event
->instrumentation
) {
949 case LTTNG_KERNEL_SYSCALL
:
950 case LTTNG_KERNEL_FUNCTION
:
951 ret
= save_kernel_function_event(writer
, event
);
956 case LTTNG_KERNEL_KPROBE
:
957 case LTTNG_KERNEL_KRETPROBE
:
958 ret
= save_kernel_kprobe_event(writer
, event
);
963 case LTTNG_KERNEL_UPROBE
:
964 ret
= save_kernel_userspace_probe_event(writer
, event
);
970 ERR("Unsupported kernel instrumentation type.");
971 ret
= LTTNG_ERR_INVALID
;
976 ret
= config_writer_close_element(writer
);
978 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
984 ret
= config_writer_close_element(writer
);
986 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
995 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
997 int save_kernel_events(struct config_writer
*writer
,
998 struct ltt_kernel_channel
*kchan
)
1001 struct ltt_kernel_event
*event
;
1003 ret
= config_writer_open_element(writer
, config_element_events
);
1005 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1009 cds_list_for_each_entry(event
, &kchan
->events_list
.head
, list
) {
1010 ret
= save_kernel_event(writer
, event
);
1011 if (ret
!= LTTNG_OK
) {
1017 ret
= config_writer_close_element(writer
);
1019 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1028 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1030 int save_ust_event(struct config_writer
*writer
,
1031 struct ltt_ust_event
*event
)
1034 const char *loglevel_type_string
;
1036 ret
= config_writer_open_element(writer
, config_element_event
);
1038 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1042 if (event
->attr
.name
[0]) {
1043 ret
= config_writer_write_element_string(writer
,
1044 config_element_name
, event
->attr
.name
);
1046 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1051 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1054 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1058 if (event
->attr
.instrumentation
!= LTTNG_UST_TRACEPOINT
) {
1059 ERR("Unsupported UST instrumentation type.");
1060 ret
= LTTNG_ERR_INVALID
;
1063 ret
= config_writer_write_element_string(writer
, config_element_type
,
1064 config_event_type_tracepoint
);
1066 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1070 loglevel_type_string
= get_loglevel_type_string(
1071 event
->attr
.loglevel_type
);
1072 if (!loglevel_type_string
) {
1073 ERR("Unsupported UST loglevel type.");
1074 ret
= LTTNG_ERR_INVALID
;
1078 ret
= config_writer_write_element_string(writer
,
1079 config_element_loglevel_type
, loglevel_type_string
);
1081 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1085 /* The log level is irrelevant if no "filtering" is enabled */
1086 if (event
->attr
.loglevel_type
!= LTTNG_UST_LOGLEVEL_ALL
) {
1087 ret
= config_writer_write_element_signed_int(writer
,
1088 config_element_loglevel
, event
->attr
.loglevel
);
1090 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1095 if (event
->filter_expression
) {
1096 ret
= config_writer_write_element_string(writer
,
1097 config_element_filter
, event
->filter_expression
);
1099 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1104 if (event
->exclusion
&& event
->exclusion
->count
) {
1107 ret
= config_writer_open_element(writer
,
1108 config_element_exclusions
);
1110 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1114 for (i
= 0; i
< event
->exclusion
->count
; i
++) {
1115 ret
= config_writer_write_element_string(writer
,
1116 config_element_exclusion
,
1117 LTTNG_EVENT_EXCLUSION_NAME_AT(
1118 event
->exclusion
, i
));
1120 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1126 ret
= config_writer_close_element(writer
);
1128 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1134 ret
= config_writer_close_element(writer
);
1136 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1145 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1147 int save_ust_events(struct config_writer
*writer
,
1148 struct lttng_ht
*events
)
1151 struct ltt_ust_event
*event
;
1152 struct lttng_ht_node_str
*node
;
1153 struct lttng_ht_iter iter
;
1155 ret
= config_writer_open_element(writer
, config_element_events
);
1157 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1162 cds_lfht_for_each_entry(events
->ht
, &iter
.iter
, node
, node
) {
1163 event
= caa_container_of(node
, struct ltt_ust_event
, node
);
1165 if (event
->internal
) {
1166 /* Internal events must not be exposed to clients */
1169 ret
= save_ust_event(writer
, event
);
1170 if (ret
!= LTTNG_OK
) {
1178 ret
= config_writer_close_element(writer
);
1180 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1189 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1191 int init_ust_event_from_agent_event(struct ltt_ust_event
*ust_event
,
1192 struct agent_event
*agent_event
)
1195 enum lttng_ust_loglevel_type ust_loglevel_type
;
1197 ust_event
->enabled
= agent_event
->enabled
;
1198 ust_event
->attr
.instrumentation
= LTTNG_UST_TRACEPOINT
;
1199 if (lttng_strncpy(ust_event
->attr
.name
, agent_event
->name
,
1200 LTTNG_SYMBOL_NAME_LEN
)) {
1201 ret
= LTTNG_ERR_INVALID
;
1204 switch (agent_event
->loglevel_type
) {
1205 case LTTNG_EVENT_LOGLEVEL_ALL
:
1206 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_ALL
;
1208 case LTTNG_EVENT_LOGLEVEL_SINGLE
:
1209 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_SINGLE
;
1211 case LTTNG_EVENT_LOGLEVEL_RANGE
:
1212 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_RANGE
;
1215 ERR("Invalid agent_event loglevel_type.");
1216 ret
= LTTNG_ERR_INVALID
;
1220 ust_event
->attr
.loglevel_type
= ust_loglevel_type
;
1221 ust_event
->attr
.loglevel
= agent_event
->loglevel_value
;
1222 ust_event
->filter_expression
= agent_event
->filter_expression
;
1223 ust_event
->exclusion
= agent_event
->exclusion
;
1230 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1232 int save_agent_events(struct config_writer
*writer
,
1233 struct agent
*agent
)
1236 struct lttng_ht_iter iter
;
1237 struct lttng_ht_node_str
*node
;
1239 ret
= config_writer_open_element(writer
, config_element_events
);
1241 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1246 cds_lfht_for_each_entry(agent
->events
->ht
, &iter
.iter
, node
, node
) {
1248 struct agent_event
*agent_event
;
1249 struct ltt_ust_event fake_event
;
1251 memset(&fake_event
, 0, sizeof(fake_event
));
1252 agent_event
= caa_container_of(node
, struct agent_event
, node
);
1255 * Initialize a fake ust event to reuse the same serialization
1256 * function since UST and agent events contain the same info
1257 * (and one could wonder why they don't reuse the same
1260 ret
= init_ust_event_from_agent_event(&fake_event
, agent_event
);
1261 if (ret
!= LTTNG_OK
) {
1265 ret
= save_ust_event(writer
, &fake_event
);
1266 if (ret
!= LTTNG_OK
) {
1274 ret
= config_writer_close_element(writer
);
1276 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1285 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1287 int save_kernel_context(struct config_writer
*writer
,
1288 struct lttng_kernel_context
*ctx
)
1296 ret
= config_writer_open_element(writer
, config_element_context
);
1298 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1302 if (ctx
->ctx
== LTTNG_KERNEL_CONTEXT_PERF_CPU_COUNTER
) {
1303 ret
= config_writer_open_element(writer
,
1304 config_element_context_perf
);
1306 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1310 ret
= config_writer_write_element_unsigned_int(writer
,
1311 config_element_type
, ctx
->u
.perf_counter
.type
);
1313 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1317 ret
= config_writer_write_element_unsigned_int(writer
,
1318 config_element_config
, ctx
->u
.perf_counter
.config
);
1320 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1324 ret
= config_writer_write_element_string(writer
,
1325 config_element_name
, ctx
->u
.perf_counter
.name
);
1327 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1332 ret
= config_writer_close_element(writer
);
1334 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1338 const char *context_type_string
=
1339 get_kernel_context_type_string(ctx
->ctx
);
1341 if (!context_type_string
) {
1342 ERR("Unsupported kernel context type.");
1343 ret
= LTTNG_ERR_INVALID
;
1347 ret
= config_writer_write_element_string(writer
,
1348 config_element_type
, context_type_string
);
1350 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1356 ret
= config_writer_close_element(writer
);
1358 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1367 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1369 int save_kernel_contexts(struct config_writer
*writer
,
1370 struct ltt_kernel_channel
*kchan
)
1373 struct ltt_kernel_context
*ctx
;
1375 if (cds_list_empty(&kchan
->ctx_list
)) {
1380 ret
= config_writer_open_element(writer
, config_element_contexts
);
1382 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1386 cds_list_for_each_entry(ctx
, &kchan
->ctx_list
, list
) {
1387 ret
= save_kernel_context(writer
, &ctx
->ctx
);
1388 if (ret
!= LTTNG_OK
) {
1394 ret
= config_writer_close_element(writer
);
1396 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1405 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1407 int save_ust_context_perf_thread_counter(struct config_writer
*writer
,
1408 struct ltt_ust_context
*ctx
)
1415 /* Perf contexts are saved as event_perf_context_type */
1416 ret
= config_writer_open_element(writer
, config_element_context_perf
);
1418 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1422 ret
= config_writer_write_element_unsigned_int(writer
,
1423 config_element_type
, ctx
->ctx
.u
.perf_counter
.type
);
1425 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1429 ret
= config_writer_write_element_unsigned_int(writer
,
1430 config_element_config
, ctx
->ctx
.u
.perf_counter
.config
);
1432 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1436 ret
= config_writer_write_element_string(writer
, config_element_name
,
1437 ctx
->ctx
.u
.perf_counter
.name
);
1439 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1444 ret
= config_writer_close_element(writer
);
1446 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1455 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1457 int save_ust_context_app_ctx(struct config_writer
*writer
,
1458 struct ltt_ust_context
*ctx
)
1465 /* Application contexts are saved as application_context_type */
1466 ret
= config_writer_open_element(writer
, config_element_context_app
);
1468 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1472 ret
= config_writer_write_element_string(writer
,
1473 config_element_context_app_provider_name
,
1474 ctx
->ctx
.u
.app_ctx
.provider_name
);
1476 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1480 ret
= config_writer_write_element_string(writer
,
1481 config_element_context_app_ctx_name
,
1482 ctx
->ctx
.u
.app_ctx
.ctx_name
);
1484 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1489 ret
= config_writer_close_element(writer
);
1491 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1500 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1502 int save_ust_context_generic(struct config_writer
*writer
,
1503 struct ltt_ust_context
*ctx
)
1506 const char *context_type_string
;
1511 /* Save context as event_context_type_type */
1512 context_type_string
= get_ust_context_type_string(
1514 if (!context_type_string
) {
1515 ERR("Unsupported UST context type.");
1516 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1520 ret
= config_writer_write_element_string(writer
,
1521 config_element_type
, context_type_string
);
1523 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1532 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1534 int save_ust_context(struct config_writer
*writer
,
1535 struct cds_list_head
*ctx_list
)
1538 struct ltt_ust_context
*ctx
;
1543 ret
= config_writer_open_element(writer
, config_element_contexts
);
1545 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1549 cds_list_for_each_entry(ctx
, ctx_list
, list
) {
1550 ret
= config_writer_open_element(writer
,
1551 config_element_context
);
1553 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1557 switch (ctx
->ctx
.ctx
) {
1558 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
:
1559 ret
= save_ust_context_perf_thread_counter(writer
, ctx
);
1561 case LTTNG_UST_CONTEXT_APP_CONTEXT
:
1562 ret
= save_ust_context_app_ctx(writer
, ctx
);
1565 /* Save generic context. */
1566 ret
= save_ust_context_generic(writer
, ctx
);
1568 if (ret
!= LTTNG_OK
) {
1573 ret
= config_writer_close_element(writer
);
1575 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1581 ret
= config_writer_close_element(writer
);
1583 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1592 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1594 int save_kernel_channel(struct config_writer
*writer
,
1595 struct ltt_kernel_channel
*kchan
)
1602 ret
= config_writer_open_element(writer
, config_element_channel
);
1604 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1608 ret
= config_writer_write_element_string(writer
, config_element_name
,
1609 kchan
->channel
->name
);
1611 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1615 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1616 kchan
->channel
->enabled
);
1618 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1622 ret
= save_kernel_channel_attributes(writer
, &kchan
->channel
->attr
);
1623 if (ret
!= LTTNG_OK
) {
1627 ret
= save_kernel_events(writer
, kchan
);
1628 if (ret
!= LTTNG_OK
) {
1632 ret
= save_kernel_contexts(writer
, kchan
);
1633 if (ret
!= LTTNG_OK
) {
1638 ret
= config_writer_close_element(writer
);
1640 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1649 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1651 int save_ust_channel(struct config_writer
*writer
,
1652 struct ltt_ust_channel
*ust_chan
,
1653 struct ltt_ust_session
*session
)
1661 ret
= config_writer_open_element(writer
, config_element_channel
);
1663 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1667 ret
= config_writer_write_element_string(writer
, config_element_name
,
1670 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1674 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1677 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1681 ret
= save_ust_channel_attributes(writer
, &ust_chan
->attr
);
1682 if (ret
!= LTTNG_OK
) {
1686 ret
= config_writer_write_element_unsigned_int(writer
,
1687 config_element_tracefile_size
, ust_chan
->tracefile_size
);
1689 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1693 ret
= config_writer_write_element_unsigned_int(writer
,
1694 config_element_tracefile_count
, ust_chan
->tracefile_count
);
1696 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1700 ret
= config_writer_write_element_unsigned_int(writer
,
1701 config_element_live_timer_interval
,
1702 session
->live_timer_interval
);
1704 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1708 if (ust_chan
->domain
== LTTNG_DOMAIN_UST
) {
1709 ret
= save_ust_events(writer
, ust_chan
->events
);
1710 if (ret
!= LTTNG_OK
) {
1714 struct agent
*agent
= NULL
;
1716 agent
= trace_ust_find_agent(session
, ust_chan
->domain
);
1718 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1719 ERR("Could not find agent associated to UST subdomain");
1724 * Channels associated with a UST sub-domain (such as JUL, Log4j
1725 * or Python) don't have any non-internal events. We retrieve
1726 * the "agent" events associated with this channel and serialize
1729 ret
= save_agent_events(writer
, agent
);
1730 if (ret
!= LTTNG_OK
) {
1735 ret
= save_ust_context(writer
, &ust_chan
->ctx_list
);
1736 if (ret
!= LTTNG_OK
) {
1741 ret
= config_writer_close_element(writer
);
1743 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1752 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1754 int save_kernel_session(struct config_writer
*writer
,
1755 struct ltt_session
*session
)
1758 struct ltt_kernel_channel
*kchan
;
1763 ret
= config_writer_write_element_string(writer
, config_element_type
,
1764 config_domain_type_kernel
);
1766 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1770 ret
= config_writer_write_element_string(writer
,
1771 config_element_buffer_type
, config_buffer_type_global
);
1773 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1777 ret
= config_writer_open_element(writer
,
1778 config_element_channels
);
1780 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1784 cds_list_for_each_entry(kchan
, &session
->kernel_session
->channel_list
.head
,
1786 ret
= save_kernel_channel(writer
, kchan
);
1787 if (ret
!= LTTNG_OK
) {
1793 ret
= config_writer_close_element(writer
);
1795 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1805 const char *get_config_domain_str(enum lttng_domain_type domain
)
1807 const char *str_dom
;
1810 case LTTNG_DOMAIN_KERNEL
:
1811 str_dom
= config_domain_type_kernel
;
1813 case LTTNG_DOMAIN_UST
:
1814 str_dom
= config_domain_type_ust
;
1816 case LTTNG_DOMAIN_JUL
:
1817 str_dom
= config_domain_type_jul
;
1819 case LTTNG_DOMAIN_LOG4J
:
1820 str_dom
= config_domain_type_log4j
;
1822 case LTTNG_DOMAIN_PYTHON
:
1823 str_dom
= config_domain_type_python
;
1832 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1833 static int save_id_tracker(struct config_writer
*writer
,
1834 struct ltt_session
*sess
,
1836 enum lttng_tracker_type tracker_type
)
1839 unsigned int nr_ids
, i
;
1840 struct lttng_tracker_ids
*ids
= NULL
;
1841 const char *element_id_tracker
, *element_target_id
, *element_id
;
1842 const struct lttng_tracker_id
*id
;
1843 enum lttng_tracker_id_status status
;
1847 switch (tracker_type
) {
1848 case LTTNG_TRACKER_PID
:
1849 element_id_tracker
= config_element_pid_tracker
;
1850 element_target_id
= config_element_target_pid
;
1851 element_id
= config_element_pid
;
1853 case LTTNG_TRACKER_VPID
:
1854 element_id_tracker
= config_element_vpid_tracker
;
1855 element_target_id
= config_element_target_vpid
;
1856 element_id
= config_element_id
;
1858 case LTTNG_TRACKER_UID
:
1859 element_id_tracker
= config_element_uid_tracker
;
1860 element_target_id
= config_element_target_uid
;
1861 element_id
= config_element_id
;
1863 case LTTNG_TRACKER_VUID
:
1864 element_id_tracker
= config_element_vuid_tracker
;
1865 element_target_id
= config_element_target_vuid
;
1866 element_id
= config_element_id
;
1868 case LTTNG_TRACKER_GID
:
1869 element_id_tracker
= config_element_gid_tracker
;
1870 element_target_id
= config_element_target_gid
;
1871 element_id
= config_element_id
;
1873 case LTTNG_TRACKER_VGID
:
1874 element_id_tracker
= config_element_vgid_tracker
;
1875 element_target_id
= config_element_target_vgid
;
1876 element_id
= config_element_id
;
1879 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1884 case LTTNG_DOMAIN_KERNEL
:
1886 ret
= kernel_list_tracker_ids(
1887 tracker_type
, sess
->kernel_session
, &ids
);
1888 if (ret
!= LTTNG_OK
) {
1889 ret
= LTTNG_ERR_KERN_LIST_FAIL
;
1894 case LTTNG_DOMAIN_UST
:
1896 ret
= trace_ust_list_tracker_ids(
1897 tracker_type
, sess
->ust_session
, &ids
);
1898 if (ret
!= LTTNG_OK
) {
1899 ret
= LTTNG_ERR_UST_LIST_FAIL
;
1904 case LTTNG_DOMAIN_JUL
:
1905 case LTTNG_DOMAIN_LOG4J
:
1906 case LTTNG_DOMAIN_PYTHON
:
1908 ret
= LTTNG_ERR_UNKNOWN_DOMAIN
;
1912 status
= lttng_tracker_ids_get_count(ids
, &nr_ids
);
1913 if (status
!= LTTNG_TRACKER_ID_STATUS_OK
) {
1914 ret
= LTTNG_ERR_INVALID
;
1919 id
= lttng_tracker_ids_get_at_index(ids
, 0);
1920 if (id
&& lttng_tracker_id_get_type(id
) == LTTNG_ID_ALL
) {
1921 /* Tracking all, nothing to output. */
1927 ret
= config_writer_open_element(writer
, element_id_tracker
);
1929 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1933 ret
= config_writer_open_element(writer
, config_element_targets
);
1935 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1940 /* Tracking none: empty list. */
1941 ret
= config_writer_open_element(writer
, element_target_id
);
1943 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1947 /* /$element_target_id */
1948 ret
= config_writer_close_element(writer
);
1950 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1954 /* Tracking list. */
1955 for (i
= 0; i
< nr_ids
; i
++) {
1956 id
= lttng_tracker_ids_get_at_index(ids
, i
);
1958 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1961 switch (lttng_tracker_id_get_type(id
)) {
1962 case LTTNG_ID_VALUE
:
1963 ret
= config_writer_open_element(
1964 writer
, element_target_id
);
1966 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1969 status
= lttng_tracker_id_get_value(id
, &value
);
1970 ret
= config_writer_write_element_unsigned_int(
1971 writer
, element_id
, value
);
1973 case LTTNG_ID_STRING
:
1974 ret
= config_writer_open_element(
1975 writer
, element_target_id
);
1977 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1980 status
= lttng_tracker_id_get_string(
1982 ret
= config_writer_write_element_string(writer
,
1983 config_element_name
, string
);
1987 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1991 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1994 if (status
!= LTTNG_TRACKER_ID_STATUS_OK
) {
1995 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1999 /* /$element_target_id */
2000 ret
= config_writer_close_element(writer
);
2002 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2009 ret
= config_writer_close_element(writer
);
2011 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2015 /* /$element_id_tracker */
2016 ret
= config_writer_close_element(writer
);
2018 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2024 lttng_tracker_ids_destroy(ids
);
2028 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2029 static int save_id_trackers(struct config_writer
*writer
,
2030 struct ltt_session
*sess
,
2036 case LTTNG_DOMAIN_KERNEL
:
2037 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_PID
);
2038 if (ret
!= LTTNG_OK
)
2040 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_VPID
);
2041 if (ret
!= LTTNG_OK
)
2043 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_UID
);
2044 if (ret
!= LTTNG_OK
)
2046 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_VUID
);
2047 if (ret
!= LTTNG_OK
)
2049 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_GID
);
2050 if (ret
!= LTTNG_OK
)
2052 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_VGID
);
2053 if (ret
!= LTTNG_OK
)
2056 case LTTNG_DOMAIN_UST
:
2057 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_VPID
);
2058 if (ret
!= LTTNG_OK
)
2060 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_VUID
);
2061 if (ret
!= LTTNG_OK
)
2063 ret
= save_id_tracker(writer
, sess
, domain
, LTTNG_TRACKER_VGID
);
2064 if (ret
!= LTTNG_OK
)
2068 return LTTNG_ERR_INVALID
;
2073 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2075 int save_ust_domain(struct config_writer
*writer
,
2076 struct ltt_session
*session
, enum lttng_domain_type domain
)
2079 struct ltt_ust_channel
*ust_chan
;
2080 const char *buffer_type_string
;
2081 struct lttng_ht_node_str
*node
;
2082 struct lttng_ht_iter iter
;
2083 const char *config_domain_name
;
2088 ret
= config_writer_open_element(writer
,
2089 config_element_domain
);
2091 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2095 config_domain_name
= get_config_domain_str(domain
);
2096 if (!config_domain_name
) {
2097 ret
= LTTNG_ERR_INVALID
;
2101 ret
= config_writer_write_element_string(writer
,
2102 config_element_type
, config_domain_name
);
2104 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2108 buffer_type_string
= get_buffer_type_string(
2109 session
->ust_session
->buffer_type
);
2110 if (!buffer_type_string
) {
2111 ERR("Unsupported buffer type.");
2112 ret
= LTTNG_ERR_INVALID
;
2116 ret
= config_writer_write_element_string(writer
,
2117 config_element_buffer_type
, buffer_type_string
);
2119 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2123 ret
= config_writer_open_element(writer
, config_element_channels
);
2125 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2130 cds_lfht_for_each_entry(session
->ust_session
->domain_global
.channels
->ht
,
2131 &iter
.iter
, node
, node
) {
2132 ust_chan
= caa_container_of(node
, struct ltt_ust_channel
, node
);
2133 if (domain
== ust_chan
->domain
) {
2134 ret
= save_ust_channel(writer
, ust_chan
, session
->ust_session
);
2135 if (ret
!= LTTNG_OK
) {
2144 ret
= config_writer_close_element(writer
);
2146 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2150 if (domain
== LTTNG_DOMAIN_UST
) {
2151 ret
= config_writer_open_element(writer
,
2152 config_element_trackers
);
2154 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2158 ret
= save_id_trackers(writer
, session
, LTTNG_DOMAIN_UST
);
2159 if (ret
!= LTTNG_OK
) {
2164 ret
= config_writer_close_element(writer
);
2166 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2172 ret
= config_writer_close_element(writer
);
2174 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2183 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2185 int save_domains(struct config_writer
*writer
, struct ltt_session
*session
)
2192 if (!session
->kernel_session
&& !session
->ust_session
) {
2196 ret
= config_writer_open_element(writer
, config_element_domains
);
2198 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2202 if (session
->kernel_session
) {
2203 ret
= config_writer_open_element(writer
,
2204 config_element_domain
);
2206 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2210 ret
= save_kernel_session(writer
, session
);
2211 if (ret
!= LTTNG_OK
) {
2215 ret
= config_writer_open_element(writer
,
2216 config_element_trackers
);
2218 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2222 ret
= save_id_trackers(writer
, session
, LTTNG_DOMAIN_KERNEL
);
2223 if (ret
!= LTTNG_OK
) {
2228 ret
= config_writer_close_element(writer
);
2230 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2234 ret
= config_writer_close_element(writer
);
2236 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2241 if (session
->ust_session
) {
2242 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_UST
);
2243 if (ret
!= LTTNG_OK
) {
2247 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_JUL
);
2248 if (ret
!= LTTNG_OK
) {
2252 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_LOG4J
);
2253 if (ret
!= LTTNG_OK
) {
2257 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_PYTHON
);
2258 if (ret
!= LTTNG_OK
) {
2264 ret
= config_writer_close_element(writer
);
2266 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2275 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2277 int save_consumer_output(struct config_writer
*writer
,
2278 struct consumer_output
*output
)
2285 ret
= config_writer_open_element(writer
, config_element_consumer_output
);
2287 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2291 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
2294 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2298 ret
= config_writer_open_element(writer
, config_element_destination
);
2300 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2304 switch (output
->type
) {
2305 case CONSUMER_DST_LOCAL
:
2306 ret
= config_writer_write_element_string(writer
,
2307 config_element_path
, output
->dst
.session_root_path
);
2309 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2313 case CONSUMER_DST_NET
:
2317 uri
= zmalloc(PATH_MAX
);
2319 ret
= LTTNG_ERR_NOMEM
;
2323 ret
= config_writer_open_element(writer
, config_element_net_output
);
2325 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2326 goto end_net_output
;
2329 if (output
->dst
.net
.control_isset
&&
2330 output
->dst
.net
.data_isset
) {
2331 ret
= uri_to_str_url(&output
->dst
.net
.control
, uri
, PATH_MAX
);
2333 ret
= LTTNG_ERR_INVALID
;
2334 goto end_net_output
;
2337 ret
= config_writer_write_element_string(writer
,
2338 config_element_control_uri
, uri
);
2340 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2341 goto end_net_output
;
2344 ret
= uri_to_str_url(&output
->dst
.net
.data
, uri
, PATH_MAX
);
2346 ret
= LTTNG_ERR_INVALID
;
2347 goto end_net_output
;
2350 ret
= config_writer_write_element_string(writer
,
2351 config_element_data_uri
, uri
);
2353 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2354 goto end_net_output
;
2359 if (ret
!= LTTNG_OK
) {
2363 ret
= !output
->dst
.net
.control_isset
?
2364 LTTNG_ERR_URL_CTRL_MISS
:
2365 LTTNG_ERR_URL_DATA_MISS
;
2370 ret
= config_writer_close_element(writer
);
2372 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2378 ERR("Unsupported consumer output type.");
2379 ret
= LTTNG_ERR_INVALID
;
2384 ret
= config_writer_close_element(writer
);
2386 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2390 /* /consumer_output */
2391 ret
= config_writer_close_element(writer
);
2393 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2402 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2404 int save_snapshot_outputs(struct config_writer
*writer
,
2405 struct snapshot
*snapshot
)
2408 struct lttng_ht_iter iter
;
2409 struct snapshot_output
*output
;
2414 ret
= config_writer_open_element(writer
, config_element_snapshot_outputs
);
2416 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2421 cds_lfht_for_each_entry(snapshot
->output_ht
->ht
, &iter
.iter
, output
,
2423 ret
= config_writer_open_element(writer
,
2424 config_element_output
);
2426 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2430 ret
= config_writer_write_element_string(writer
,
2431 config_element_name
, output
->name
);
2433 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2437 ret
= config_writer_write_element_unsigned_int(writer
,
2438 config_element_max_size
, output
->max_size
);
2440 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2444 ret
= save_consumer_output(writer
, output
->consumer
);
2445 if (ret
!= LTTNG_OK
) {
2450 ret
= config_writer_close_element(writer
);
2452 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2458 /* /snapshot_outputs */
2459 ret
= config_writer_close_element(writer
);
2461 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2473 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2475 int save_session_output(struct config_writer
*writer
,
2476 struct ltt_session
*session
)
2483 if ((session
->snapshot_mode
&& session
->snapshot
.nb_output
== 0) ||
2484 (!session
->snapshot_mode
&& !session
->consumer
)) {
2485 /* Session is in no output mode */
2490 ret
= config_writer_open_element(writer
, config_element_output
);
2492 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2496 if (session
->snapshot_mode
) {
2497 ret
= save_snapshot_outputs(writer
, &session
->snapshot
);
2498 if (ret
!= LTTNG_OK
) {
2502 if (session
->consumer
) {
2503 ret
= save_consumer_output(writer
, session
->consumer
);
2504 if (ret
!= LTTNG_OK
) {
2511 ret
= config_writer_close_element(writer
);
2513 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2522 int save_session_rotation_schedule(struct config_writer
*writer
,
2523 enum lttng_rotation_schedule_type type
, uint64_t value
)
2526 const char *element_name
;
2527 const char *value_name
;
2530 case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
:
2531 element_name
= config_element_rotation_schedule_periodic
;
2532 value_name
= config_element_rotation_schedule_periodic_time_us
;
2534 case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
:
2535 element_name
= config_element_rotation_schedule_size_threshold
;
2536 value_name
= config_element_rotation_schedule_size_threshold_bytes
;
2543 ret
= config_writer_open_element(writer
, element_name
);
2548 ret
= config_writer_write_element_unsigned_int(writer
,
2554 /* Close schedule descriptor element. */
2555 ret
= config_writer_close_element(writer
);
2564 int save_session_rotation_schedules(struct config_writer
*writer
,
2565 struct ltt_session
*session
)
2569 ret
= config_writer_open_element(writer
,
2570 config_element_rotation_schedules
);
2574 if (session
->rotate_timer_period
) {
2575 ret
= save_session_rotation_schedule(writer
,
2576 LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
,
2577 session
->rotate_timer_period
);
2579 goto close_schedules
;
2582 if (session
->rotate_size
) {
2583 ret
= save_session_rotation_schedule(writer
,
2584 LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
,
2585 session
->rotate_size
);
2587 goto close_schedules
;
2592 /* Close rotation schedules element. */
2593 ret
= config_writer_close_element(writer
);
2602 * Save the given session.
2604 * Return LTTNG_OK on success else a LTTNG_ERR* code.
2607 int save_session(struct ltt_session
*session
,
2608 struct lttng_save_session_attr
*attr
, lttng_sock_cred
*creds
)
2611 char config_file_path
[LTTNG_PATH_MAX
];
2613 struct config_writer
*writer
= NULL
;
2614 size_t session_name_len
;
2615 const char *provided_path
;
2616 int file_open_flags
= O_CREAT
| O_WRONLY
| O_TRUNC
;
2622 session_name_len
= strlen(session
->name
);
2623 memset(config_file_path
, 0, sizeof(config_file_path
));
2625 if (!session_access_ok(session
,
2626 LTTNG_SOCK_GET_UID_CRED(creds
),
2627 LTTNG_SOCK_GET_GID_CRED(creds
)) || session
->destroyed
) {
2628 ret
= LTTNG_ERR_EPERM
;
2632 provided_path
= lttng_save_session_attr_get_output_url(attr
);
2633 if (provided_path
) {
2634 DBG3("Save session in provided path %s", provided_path
);
2635 len
= strlen(provided_path
);
2636 if (len
>= sizeof(config_file_path
)) {
2637 ret
= LTTNG_ERR_SET_URL
;
2640 strncpy(config_file_path
, provided_path
, sizeof(config_file_path
));
2643 char *home_dir
= utils_get_user_home_dir(
2644 LTTNG_SOCK_GET_UID_CRED(creds
));
2646 ret
= LTTNG_ERR_SET_URL
;
2650 ret_len
= snprintf(config_file_path
, sizeof(config_file_path
),
2651 DEFAULT_SESSION_HOME_CONFIGPATH
, home_dir
);
2654 PERROR("snprintf save session");
2655 ret
= LTTNG_ERR_SET_URL
;
2662 * Check the path fits in the config file path dst including the '/'
2663 * followed by trailing .lttng extension and the NULL terminated string.
2665 if ((len
+ session_name_len
+ 2 +
2666 sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
))
2667 > sizeof(config_file_path
)) {
2668 ret
= LTTNG_ERR_SET_URL
;
2672 ret
= run_as_mkdir_recursive(config_file_path
, S_IRWXU
| S_IRWXG
,
2673 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
2675 ret
= LTTNG_ERR_SET_URL
;
2680 * At this point, we know that everything fits in the buffer. Validation
2681 * was done just above.
2683 config_file_path
[len
++] = '/';
2684 strncpy(config_file_path
+ len
, session
->name
, sizeof(config_file_path
) - len
);
2685 len
+= session_name_len
;
2686 strcpy(config_file_path
+ len
, DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
2687 len
+= sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
2688 config_file_path
[len
] = '\0';
2690 if (!attr
->overwrite
) {
2691 file_open_flags
|= O_EXCL
;
2694 fd
= run_as_open(config_file_path
, file_open_flags
,
2695 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
,
2696 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
2698 PERROR("Could not create configuration file");
2701 ret
= LTTNG_ERR_SAVE_FILE_EXIST
;
2704 ret
= LTTNG_ERR_EPERM
;
2707 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2713 writer
= config_writer_create(fd
, 1);
2715 ret
= LTTNG_ERR_NOMEM
;
2719 ret
= config_writer_open_element(writer
, config_element_sessions
);
2721 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2725 ret
= config_writer_open_element(writer
, config_element_session
);
2727 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2731 ret
= config_writer_write_element_string(writer
, config_element_name
,
2734 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2738 if (session
->shm_path
[0] != '\0') {
2739 ret
= config_writer_write_element_string(writer
,
2740 config_element_shared_memory_path
,
2743 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2748 ret
= save_domains(writer
, session
);
2749 if (ret
!= LTTNG_OK
) {
2753 ret
= config_writer_write_element_bool(writer
, config_element_started
,
2756 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2760 if (session
->snapshot_mode
|| session
->live_timer
||
2761 session
->rotate_timer_period
|| session
->rotate_size
) {
2762 ret
= config_writer_open_element(writer
, config_element_attributes
);
2764 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2768 if (session
->snapshot_mode
) {
2769 ret
= config_writer_write_element_bool(writer
,
2770 config_element_snapshot_mode
, 1);
2772 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2775 } else if (session
->live_timer
) {
2776 ret
= config_writer_write_element_unsigned_int(writer
,
2777 config_element_live_timer_interval
, session
->live_timer
);
2779 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2783 if (session
->rotate_timer_period
|| session
->rotate_size
) {
2784 ret
= save_session_rotation_schedules(writer
,
2787 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2793 ret
= config_writer_close_element(writer
);
2795 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2800 ret
= save_session_output(writer
, session
);
2801 if (ret
!= LTTNG_OK
) {
2806 ret
= config_writer_close_element(writer
);
2808 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2813 ret
= config_writer_close_element(writer
);
2815 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2821 if (writer
&& config_writer_destroy(writer
)) {
2822 /* Preserve the original error code */
2823 ret
= ret
!= LTTNG_OK
? ret
: LTTNG_ERR_SAVE_IO_FAIL
;
2825 if (ret
!= LTTNG_OK
) {
2826 /* Delete file in case of error */
2827 if ((fd
>= 0) && unlink(config_file_path
)) {
2828 PERROR("Unlinking XML session configuration.");
2835 closeret
= close(fd
);
2837 PERROR("Closing XML session configuration");
2844 int cmd_save_sessions(struct lttng_save_session_attr
*attr
,
2845 lttng_sock_cred
*creds
)
2848 const char *session_name
;
2849 struct ltt_session
*session
;
2851 session_lock_list();
2853 session_name
= lttng_save_session_attr_get_session_name(attr
);
2855 session
= session_find_by_name(session_name
);
2857 ret
= LTTNG_ERR_SESS_NOT_FOUND
;
2861 session_lock(session
);
2862 ret
= save_session(session
, attr
, creds
);
2863 session_unlock(session
);
2864 session_put(session
);
2865 if (ret
!= LTTNG_OK
) {
2869 struct ltt_session_list
*list
= session_get_list();
2871 cds_list_for_each_entry(session
, &list
->head
, list
) {
2872 if (!session_get(session
)) {
2875 session_lock(session
);
2876 ret
= save_session(session
, attr
, creds
);
2877 session_unlock(session
);
2878 session_put(session
);
2879 /* Don't abort if we don't have the required permissions. */
2880 if (ret
!= LTTNG_OK
&& ret
!= LTTNG_ERR_EPERM
) {
2888 session_unlock_list();