2 * Copyright (C) 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * SPDX-License-Identifier: GPL-2.0-only
11 #include "lttng-syscall.hpp"
13 #include "session.hpp"
14 #include "trace-ust.hpp"
16 #include <common/config/session-config.hpp>
17 #include <common/defaults.hpp>
18 #include <common/error.hpp>
19 #include <common/runas.hpp>
20 #include <common/utils.hpp>
22 #include <lttng/save-internal.hpp>
27 #include <urcu/uatomic.h>
29 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
30 static int save_kernel_channel_attributes(struct config_writer
*writer
,
31 struct lttng_channel_attr
*attr
)
35 ret
= config_writer_write_element_string(writer
,
36 config_element_overwrite_mode
,
37 attr
->overwrite
? config_overwrite_mode_overwrite
:
38 config_overwrite_mode_discard
);
40 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
44 ret
= config_writer_write_element_unsigned_int(
45 writer
, config_element_subbuf_size
, attr
->subbuf_size
);
47 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
51 ret
= config_writer_write_element_unsigned_int(
52 writer
, config_element_num_subbuf
, attr
->num_subbuf
);
54 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
58 ret
= config_writer_write_element_unsigned_int(
59 writer
, config_element_switch_timer_interval
, attr
->switch_timer_interval
);
61 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
65 ret
= config_writer_write_element_unsigned_int(
66 writer
, config_element_read_timer_interval
, attr
->read_timer_interval
);
68 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
72 ret
= config_writer_write_element_string(writer
,
73 config_element_output_type
,
74 attr
->output
== LTTNG_EVENT_SPLICE
?
75 config_output_type_splice
:
76 config_output_type_mmap
);
78 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
82 ret
= config_writer_write_element_unsigned_int(
83 writer
, config_element_tracefile_size
, attr
->tracefile_size
);
85 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
89 ret
= config_writer_write_element_unsigned_int(
90 writer
, config_element_tracefile_count
, attr
->tracefile_count
);
92 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
96 ret
= config_writer_write_element_unsigned_int(
97 writer
, config_element_live_timer_interval
, attr
->live_timer_interval
);
99 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
103 if (attr
->extended
.ptr
) {
104 struct lttng_channel_extended
*ext
= NULL
;
106 ext
= (struct lttng_channel_extended
*) attr
->extended
.ptr
;
107 ret
= config_writer_write_element_unsigned_int(
108 writer
, config_element_monitor_timer_interval
, ext
->monitor_timer_interval
);
110 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
114 ret
= config_writer_write_element_signed_int(
115 writer
, config_element_blocking_timeout
, ext
->blocking_timeout
);
117 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
127 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
128 static int save_ust_channel_attributes(struct config_writer
*writer
,
129 struct lttng_ust_abi_channel_attr
*attr
)
132 struct ltt_ust_channel
*channel
= NULL
;
134 ret
= config_writer_write_element_string(writer
,
135 config_element_overwrite_mode
,
136 attr
->overwrite
? config_overwrite_mode_overwrite
:
137 config_overwrite_mode_discard
);
139 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
143 ret
= config_writer_write_element_unsigned_int(
144 writer
, config_element_subbuf_size
, attr
->subbuf_size
);
146 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
150 ret
= config_writer_write_element_unsigned_int(
151 writer
, config_element_num_subbuf
, attr
->num_subbuf
);
153 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
157 ret
= config_writer_write_element_unsigned_int(
158 writer
, config_element_switch_timer_interval
, attr
->switch_timer_interval
);
160 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
164 ret
= config_writer_write_element_unsigned_int(
165 writer
, config_element_read_timer_interval
, attr
->read_timer_interval
);
167 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
171 ret
= config_writer_write_element_string(writer
,
172 config_element_output_type
,
173 attr
->output
== LTTNG_UST_ABI_MMAP
?
174 config_output_type_mmap
:
175 config_output_type_splice
);
177 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
181 ret
= config_writer_write_element_signed_int(
182 writer
, config_element_blocking_timeout
, attr
->u
.s
.blocking_timeout
);
184 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
189 * Fetch the monitor timer which is located in the parent of
190 * lttng_ust_channel_attr
192 channel
= lttng::utils::container_of(attr
, <t_ust_channel::attr
);
193 ret
= config_writer_write_element_unsigned_int(
194 writer
, config_element_monitor_timer_interval
, channel
->monitor_timer_interval
);
196 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
206 get_kernel_instrumentation_string(enum lttng_kernel_abi_instrumentation instrumentation
)
208 const char *instrumentation_string
;
210 switch (instrumentation
) {
211 case LTTNG_KERNEL_ABI_ALL
:
212 instrumentation_string
= config_event_type_all
;
214 case LTTNG_KERNEL_ABI_TRACEPOINT
:
215 instrumentation_string
= config_event_type_tracepoint
;
217 case LTTNG_KERNEL_ABI_KPROBE
:
218 instrumentation_string
= config_event_type_probe
;
220 case LTTNG_KERNEL_ABI_UPROBE
:
221 instrumentation_string
= config_event_type_userspace_probe
;
223 case LTTNG_KERNEL_ABI_FUNCTION
:
224 instrumentation_string
= config_event_type_function_entry
;
226 case LTTNG_KERNEL_ABI_KRETPROBE
:
227 instrumentation_string
= config_event_type_function
;
229 case LTTNG_KERNEL_ABI_NOOP
:
230 instrumentation_string
= config_event_type_noop
;
232 case LTTNG_KERNEL_ABI_SYSCALL
:
233 instrumentation_string
= config_event_type_syscall
;
236 instrumentation_string
= NULL
;
239 return instrumentation_string
;
242 static const char *get_kernel_context_type_string(enum lttng_kernel_abi_context_type context_type
)
244 const char *context_type_string
;
246 switch (context_type
) {
247 case LTTNG_KERNEL_ABI_CONTEXT_PID
:
248 context_type_string
= config_event_context_pid
;
250 case LTTNG_KERNEL_ABI_CONTEXT_PROCNAME
:
251 context_type_string
= config_event_context_procname
;
253 case LTTNG_KERNEL_ABI_CONTEXT_PRIO
:
254 context_type_string
= config_event_context_prio
;
256 case LTTNG_KERNEL_ABI_CONTEXT_NICE
:
257 context_type_string
= config_event_context_nice
;
259 case LTTNG_KERNEL_ABI_CONTEXT_VPID
:
260 context_type_string
= config_event_context_vpid
;
262 case LTTNG_KERNEL_ABI_CONTEXT_TID
:
263 context_type_string
= config_event_context_tid
;
265 case LTTNG_KERNEL_ABI_CONTEXT_VTID
:
266 context_type_string
= config_event_context_vtid
;
268 case LTTNG_KERNEL_ABI_CONTEXT_PPID
:
269 context_type_string
= config_event_context_ppid
;
271 case LTTNG_KERNEL_ABI_CONTEXT_VPPID
:
272 context_type_string
= config_event_context_vppid
;
274 case LTTNG_KERNEL_ABI_CONTEXT_HOSTNAME
:
275 context_type_string
= config_event_context_hostname
;
277 case LTTNG_KERNEL_ABI_CONTEXT_INTERRUPTIBLE
:
278 context_type_string
= config_event_context_interruptible
;
280 case LTTNG_KERNEL_ABI_CONTEXT_PREEMPTIBLE
:
281 context_type_string
= config_event_context_preemptible
;
283 case LTTNG_KERNEL_ABI_CONTEXT_NEED_RESCHEDULE
:
284 context_type_string
= config_event_context_need_reschedule
;
286 case LTTNG_KERNEL_ABI_CONTEXT_MIGRATABLE
:
287 context_type_string
= config_event_context_migratable
;
289 case LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_USER
:
290 context_type_string
= config_event_context_callstack_user
;
292 case LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_KERNEL
:
293 context_type_string
= config_event_context_callstack_kernel
;
295 case LTTNG_KERNEL_ABI_CONTEXT_CGROUP_NS
:
296 context_type_string
= config_event_context_cgroup_ns
;
298 case LTTNG_KERNEL_ABI_CONTEXT_IPC_NS
:
299 context_type_string
= config_event_context_ipc_ns
;
301 case LTTNG_KERNEL_ABI_CONTEXT_MNT_NS
:
302 context_type_string
= config_event_context_mnt_ns
;
304 case LTTNG_KERNEL_ABI_CONTEXT_NET_NS
:
305 context_type_string
= config_event_context_net_ns
;
307 case LTTNG_KERNEL_ABI_CONTEXT_PID_NS
:
308 context_type_string
= config_event_context_pid_ns
;
310 case LTTNG_KERNEL_ABI_CONTEXT_TIME_NS
:
311 context_type_string
= config_event_context_time_ns
;
313 case LTTNG_KERNEL_ABI_CONTEXT_USER_NS
:
314 context_type_string
= config_event_context_user_ns
;
316 case LTTNG_KERNEL_ABI_CONTEXT_UTS_NS
:
317 context_type_string
= config_event_context_uts_ns
;
319 case LTTNG_KERNEL_ABI_CONTEXT_UID
:
320 context_type_string
= config_event_context_uid
;
322 case LTTNG_KERNEL_ABI_CONTEXT_EUID
:
323 context_type_string
= config_event_context_euid
;
325 case LTTNG_KERNEL_ABI_CONTEXT_SUID
:
326 context_type_string
= config_event_context_suid
;
328 case LTTNG_KERNEL_ABI_CONTEXT_GID
:
329 context_type_string
= config_event_context_gid
;
331 case LTTNG_KERNEL_ABI_CONTEXT_EGID
:
332 context_type_string
= config_event_context_egid
;
334 case LTTNG_KERNEL_ABI_CONTEXT_SGID
:
335 context_type_string
= config_event_context_sgid
;
337 case LTTNG_KERNEL_ABI_CONTEXT_VUID
:
338 context_type_string
= config_event_context_vuid
;
340 case LTTNG_KERNEL_ABI_CONTEXT_VEUID
:
341 context_type_string
= config_event_context_veuid
;
343 case LTTNG_KERNEL_ABI_CONTEXT_VSUID
:
344 context_type_string
= config_event_context_vsuid
;
346 case LTTNG_KERNEL_ABI_CONTEXT_VGID
:
347 context_type_string
= config_event_context_vgid
;
349 case LTTNG_KERNEL_ABI_CONTEXT_VEGID
:
350 context_type_string
= config_event_context_vegid
;
352 case LTTNG_KERNEL_ABI_CONTEXT_VSGID
:
353 context_type_string
= config_event_context_vsgid
;
356 context_type_string
= NULL
;
359 return context_type_string
;
362 static const char *get_ust_context_type_string(enum lttng_ust_abi_context_type context_type
)
364 const char *context_type_string
;
366 switch (context_type
) {
367 case LTTNG_UST_ABI_CONTEXT_PROCNAME
:
368 context_type_string
= config_event_context_procname
;
370 case LTTNG_UST_ABI_CONTEXT_VPID
:
371 context_type_string
= config_event_context_vpid
;
373 case LTTNG_UST_ABI_CONTEXT_VTID
:
374 context_type_string
= config_event_context_vtid
;
376 case LTTNG_UST_ABI_CONTEXT_IP
:
377 context_type_string
= config_event_context_ip
;
379 case LTTNG_UST_ABI_CONTEXT_PTHREAD_ID
:
380 context_type_string
= config_event_context_pthread_id
;
382 case LTTNG_UST_ABI_CONTEXT_APP_CONTEXT
:
383 context_type_string
= config_event_context_app
;
385 case LTTNG_UST_ABI_CONTEXT_CGROUP_NS
:
386 context_type_string
= config_event_context_cgroup_ns
;
388 case LTTNG_UST_ABI_CONTEXT_IPC_NS
:
389 context_type_string
= config_event_context_ipc_ns
;
391 case LTTNG_UST_ABI_CONTEXT_MNT_NS
:
392 context_type_string
= config_event_context_mnt_ns
;
394 case LTTNG_UST_ABI_CONTEXT_NET_NS
:
395 context_type_string
= config_event_context_net_ns
;
397 case LTTNG_UST_ABI_CONTEXT_TIME_NS
:
398 context_type_string
= config_event_context_time_ns
;
400 case LTTNG_UST_ABI_CONTEXT_PID_NS
:
401 context_type_string
= config_event_context_pid_ns
;
403 case LTTNG_UST_ABI_CONTEXT_USER_NS
:
404 context_type_string
= config_event_context_user_ns
;
406 case LTTNG_UST_ABI_CONTEXT_UTS_NS
:
407 context_type_string
= config_event_context_uts_ns
;
409 case LTTNG_UST_ABI_CONTEXT_VUID
:
410 context_type_string
= config_event_context_vuid
;
412 case LTTNG_UST_ABI_CONTEXT_VEUID
:
413 context_type_string
= config_event_context_veuid
;
415 case LTTNG_UST_ABI_CONTEXT_VSUID
:
416 context_type_string
= config_event_context_vsuid
;
418 case LTTNG_UST_ABI_CONTEXT_VGID
:
419 context_type_string
= config_event_context_vgid
;
421 case LTTNG_UST_ABI_CONTEXT_VEGID
:
422 context_type_string
= config_event_context_vegid
;
424 case LTTNG_UST_ABI_CONTEXT_VSGID
:
425 context_type_string
= config_event_context_vsgid
;
427 case LTTNG_UST_ABI_CONTEXT_PERF_THREAD_COUNTER
:
429 * Error, should not be stored in the XML, perf contexts
430 * are stored as a node of type event_perf_context_type.
433 context_type_string
= NULL
;
437 return context_type_string
;
440 static const char *get_buffer_type_string(enum lttng_buffer_type buffer_type
)
442 const char *buffer_type_string
;
444 switch (buffer_type
) {
445 case LTTNG_BUFFER_PER_PID
:
446 buffer_type_string
= config_buffer_type_per_pid
;
448 case LTTNG_BUFFER_PER_UID
:
449 buffer_type_string
= config_buffer_type_per_uid
;
451 case LTTNG_BUFFER_GLOBAL
:
452 buffer_type_string
= config_buffer_type_global
;
455 buffer_type_string
= NULL
;
458 return buffer_type_string
;
461 static const char *get_loglevel_type_string(enum lttng_ust_abi_loglevel_type loglevel_type
)
463 const char *loglevel_type_string
;
465 switch (loglevel_type
) {
466 case LTTNG_UST_ABI_LOGLEVEL_ALL
:
467 loglevel_type_string
= config_loglevel_type_all
;
469 case LTTNG_UST_ABI_LOGLEVEL_RANGE
:
470 loglevel_type_string
= config_loglevel_type_range
;
472 case LTTNG_UST_ABI_LOGLEVEL_SINGLE
:
473 loglevel_type_string
= config_loglevel_type_single
;
476 loglevel_type_string
= NULL
;
479 return loglevel_type_string
;
482 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
483 static int save_kernel_function_event(struct config_writer
*writer
, struct ltt_kernel_event
*event
)
487 ret
= config_writer_open_element(writer
, config_element_function_attributes
);
489 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
493 ret
= config_writer_write_element_string(
494 writer
, config_element_name
, event
->event
->u
.ftrace
.symbol_name
);
496 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
500 /* /function attributes */
501 ret
= config_writer_close_element(writer
);
503 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
510 static int save_kernel_kprobe_event(struct config_writer
*writer
, struct ltt_kernel_event
*event
)
513 const char *symbol_name
;
517 switch (event
->event
->instrumentation
) {
518 case LTTNG_KERNEL_ABI_KPROBE
:
520 * Comments in lttng-kernel.h mention that
521 * either addr or symbol_name are set, not both.
523 addr
= event
->event
->u
.kprobe
.addr
;
524 offset
= event
->event
->u
.kprobe
.offset
;
525 symbol_name
= addr
? NULL
: event
->event
->u
.kprobe
.symbol_name
;
527 case LTTNG_KERNEL_ABI_KRETPROBE
:
528 addr
= event
->event
->u
.kretprobe
.addr
;
529 offset
= event
->event
->u
.kretprobe
.offset
;
530 symbol_name
= addr
? NULL
: event
->event
->u
.kretprobe
.symbol_name
;
534 ERR("Unsupported kernel instrumentation type.");
535 ret
= LTTNG_ERR_INVALID
;
539 ret
= config_writer_open_element(writer
, config_element_probe_attributes
);
541 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
546 ret
= config_writer_write_element_unsigned_int(
547 writer
, config_element_address
, addr
);
549 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
552 } else if (symbol_name
) {
553 ret
= config_writer_write_element_string(
554 writer
, config_element_symbol_name
, symbol_name
);
556 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
559 /* If the offset is non-zero, write it.*/
561 ret
= config_writer_write_element_unsigned_int(
562 writer
, config_element_offset
, offset
);
564 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
570 * This really should not happen as we are either setting the
571 * address or the symbol above.
573 ERR("Invalid probe/function description.");
574 ret
= LTTNG_ERR_INVALID
;
578 ret
= config_writer_close_element(writer
);
580 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
588 * Save the userspace probe tracepoint event associated with the event to the
591 static int save_kernel_userspace_probe_tracepoint_event(struct config_writer
*writer
,
592 struct ltt_kernel_event
*event
)
595 const char *probe_name
, *provider_name
, *binary_path
;
596 const struct lttng_userspace_probe_location
*userspace_probe_location
;
597 const struct lttng_userspace_probe_location_lookup_method
*lookup_method
;
598 enum lttng_userspace_probe_location_lookup_method_type lookup_type
;
600 /* Get userspace probe location from the event. */
601 userspace_probe_location
= event
->userspace_probe_location
;
602 if (!userspace_probe_location
) {
603 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
607 /* Get lookup method and lookup method type. */
608 lookup_method
= lttng_userspace_probe_location_get_lookup_method(userspace_probe_location
);
609 if (!lookup_method
) {
610 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
614 lookup_type
= lttng_userspace_probe_location_lookup_method_get_type(lookup_method
);
616 /* Get the binary path, probe name and provider name. */
618 lttng_userspace_probe_location_tracepoint_get_binary_path(userspace_probe_location
);
620 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
625 lttng_userspace_probe_location_tracepoint_get_probe_name(userspace_probe_location
);
627 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
631 provider_name
= lttng_userspace_probe_location_tracepoint_get_provider_name(
632 userspace_probe_location
);
633 if (!provider_name
) {
634 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
638 /* Open a userspace probe tracepoint attribute. */
639 ret
= config_writer_open_element(writer
,
640 config_element_userspace_probe_tracepoint_attributes
);
642 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
646 switch (lookup_type
) {
647 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT
:
648 ret
= config_writer_write_element_string(
650 config_element_userspace_probe_lookup
,
651 config_element_userspace_probe_lookup_tracepoint_sdt
);
653 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
658 ERR("Unsupported kernel userspace probe tracepoint lookup method.");
659 ret
= LTTNG_ERR_INVALID
;
663 /* Write the binary path, provider name and the probe name. */
664 ret
= config_writer_write_element_string(
665 writer
, config_element_userspace_probe_location_binary_path
, binary_path
);
667 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
671 ret
= config_writer_write_element_string(
673 config_element_userspace_probe_tracepoint_location_provider_name
,
676 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
680 ret
= config_writer_write_element_string(
681 writer
, config_element_userspace_probe_tracepoint_location_probe_name
, probe_name
);
683 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
687 /* Close the userspace probe tracepoint attribute. */
688 ret
= config_writer_close_element(writer
);
690 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
699 * Save the userspace probe function event associated with the event to the
702 static int save_kernel_userspace_probe_function_event(struct config_writer
*writer
,
703 struct ltt_kernel_event
*event
)
706 const char *function_name
, *binary_path
;
707 const struct lttng_userspace_probe_location
*userspace_probe_location
;
708 const struct lttng_userspace_probe_location_lookup_method
*lookup_method
;
709 enum lttng_userspace_probe_location_lookup_method_type lookup_type
;
711 /* Get userspace probe location from the event. */
712 userspace_probe_location
= event
->userspace_probe_location
;
713 if (!userspace_probe_location
) {
714 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
718 /* Get lookup method and lookup method type. */
719 lookup_method
= lttng_userspace_probe_location_get_lookup_method(userspace_probe_location
);
720 if (!lookup_method
) {
721 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
725 /* Get the binary path and the function name. */
727 lttng_userspace_probe_location_function_get_binary_path(userspace_probe_location
);
729 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
734 lttng_userspace_probe_location_function_get_function_name(userspace_probe_location
);
735 if (!function_name
) {
736 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
740 /* Open a userspace probe function attribute. */
741 ret
= config_writer_open_element(writer
,
742 config_element_userspace_probe_function_attributes
);
744 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
748 lookup_type
= lttng_userspace_probe_location_lookup_method_get_type(lookup_method
);
749 switch (lookup_type
) {
750 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF
:
751 ret
= config_writer_write_element_string(
753 config_element_userspace_probe_lookup
,
754 config_element_userspace_probe_lookup_function_elf
);
756 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
760 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT
:
761 ret
= config_writer_write_element_string(
763 config_element_userspace_probe_lookup
,
764 config_element_userspace_probe_lookup_function_default
);
766 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
771 ERR("Unsupported kernel userspace probe function lookup method.");
772 ret
= LTTNG_ERR_INVALID
;
776 /* Write the binary path and the function name. */
777 ret
= config_writer_write_element_string(
778 writer
, config_element_userspace_probe_location_binary_path
, binary_path
);
780 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
784 ret
= config_writer_write_element_string(
786 config_element_userspace_probe_function_location_function_name
,
789 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
793 /* Close the userspace probe function attribute. */
794 ret
= config_writer_close_element(writer
);
796 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
804 static int save_kernel_userspace_probe_event(struct config_writer
*writer
,
805 struct ltt_kernel_event
*event
)
808 struct lttng_userspace_probe_location
*userspace_probe_location
;
810 /* Get userspace probe location from the event. */
811 userspace_probe_location
= event
->userspace_probe_location
;
812 if (!userspace_probe_location
) {
813 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
817 switch (lttng_userspace_probe_location_get_type(userspace_probe_location
)) {
818 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION
:
820 ret
= save_kernel_userspace_probe_function_event(writer
, event
);
822 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
827 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT
:
829 ret
= save_kernel_userspace_probe_tracepoint_event(writer
, event
);
831 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
836 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_UNKNOWN
:
838 ERR("Unsupported kernel userspace probe location type.");
839 ret
= LTTNG_ERR_INVALID
;
847 static int save_kernel_event(struct config_writer
*writer
, struct ltt_kernel_event
*event
)
850 const char *instrumentation_type
;
852 ret
= config_writer_open_element(writer
, config_element_event
);
854 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
858 if (event
->event
->name
[0]) {
859 ret
= config_writer_write_element_string(
860 writer
, config_element_name
, event
->event
->name
);
862 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
867 ret
= config_writer_write_element_bool(writer
, config_element_enabled
, event
->enabled
);
869 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
873 instrumentation_type
= get_kernel_instrumentation_string(event
->event
->instrumentation
);
874 if (!instrumentation_type
) {
875 ret
= LTTNG_ERR_INVALID
;
879 ret
= config_writer_write_element_string(writer
, config_element_type
, instrumentation_type
);
881 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
885 if (event
->filter_expression
) {
886 ret
= config_writer_write_element_string(
887 writer
, config_element_filter
, event
->filter_expression
);
889 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
894 if (event
->event
->instrumentation
== LTTNG_KERNEL_ABI_FUNCTION
||
895 event
->event
->instrumentation
== LTTNG_KERNEL_ABI_KPROBE
||
896 event
->event
->instrumentation
== LTTNG_KERNEL_ABI_UPROBE
||
897 event
->event
->instrumentation
== LTTNG_KERNEL_ABI_KRETPROBE
) {
898 ret
= config_writer_open_element(writer
, config_element_attributes
);
900 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
904 switch (event
->event
->instrumentation
) {
905 case LTTNG_KERNEL_ABI_SYSCALL
:
906 case LTTNG_KERNEL_ABI_FUNCTION
:
907 ret
= save_kernel_function_event(writer
, event
);
912 case LTTNG_KERNEL_ABI_KPROBE
:
913 case LTTNG_KERNEL_ABI_KRETPROBE
:
914 ret
= save_kernel_kprobe_event(writer
, event
);
919 case LTTNG_KERNEL_ABI_UPROBE
:
920 ret
= save_kernel_userspace_probe_event(writer
, event
);
926 ERR("Unsupported kernel instrumentation type.");
927 ret
= LTTNG_ERR_INVALID
;
932 ret
= config_writer_close_element(writer
);
934 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
940 ret
= config_writer_close_element(writer
);
942 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
951 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
952 static int save_kernel_events(struct config_writer
*writer
, struct ltt_kernel_channel
*kchan
)
955 struct ltt_kernel_event
*event
;
957 ret
= config_writer_open_element(writer
, config_element_events
);
959 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
963 cds_list_for_each_entry (event
, &kchan
->events_list
.head
, list
) {
964 ret
= save_kernel_event(writer
, event
);
965 if (ret
!= LTTNG_OK
) {
971 ret
= config_writer_close_element(writer
);
973 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
982 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
983 static int save_ust_event(struct config_writer
*writer
, struct ltt_ust_event
*event
)
986 const char *loglevel_type_string
;
988 ret
= config_writer_open_element(writer
, config_element_event
);
990 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
994 if (event
->attr
.name
[0]) {
995 ret
= config_writer_write_element_string(
996 writer
, config_element_name
, event
->attr
.name
);
998 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1003 ret
= config_writer_write_element_bool(writer
, config_element_enabled
, event
->enabled
);
1005 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1009 if (event
->attr
.instrumentation
!= LTTNG_UST_ABI_TRACEPOINT
) {
1010 ERR("Unsupported UST instrumentation type.");
1011 ret
= LTTNG_ERR_INVALID
;
1014 ret
= config_writer_write_element_string(
1015 writer
, config_element_type
, config_event_type_tracepoint
);
1017 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1021 loglevel_type_string
=
1022 get_loglevel_type_string((lttng_ust_abi_loglevel_type
) event
->attr
.loglevel_type
);
1023 if (!loglevel_type_string
) {
1024 ERR("Unsupported UST loglevel type.");
1025 ret
= LTTNG_ERR_INVALID
;
1029 ret
= config_writer_write_element_string(
1030 writer
, config_element_loglevel_type
, loglevel_type_string
);
1032 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1036 /* The log level is irrelevant if no "filtering" is enabled */
1037 if (event
->attr
.loglevel_type
!= LTTNG_UST_ABI_LOGLEVEL_ALL
) {
1038 ret
= config_writer_write_element_signed_int(
1039 writer
, config_element_loglevel
, event
->attr
.loglevel
);
1041 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1046 if (event
->filter_expression
) {
1047 ret
= config_writer_write_element_string(
1048 writer
, config_element_filter
, event
->filter_expression
);
1050 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1055 if (event
->exclusion
&& event
->exclusion
->count
) {
1058 ret
= config_writer_open_element(writer
, config_element_exclusions
);
1060 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1064 for (i
= 0; i
< event
->exclusion
->count
; i
++) {
1065 ret
= config_writer_write_element_string(
1067 config_element_exclusion
,
1068 LTTNG_EVENT_EXCLUSION_NAME_AT(event
->exclusion
, i
));
1070 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1076 ret
= config_writer_close_element(writer
);
1078 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1084 ret
= config_writer_close_element(writer
);
1086 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1095 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1096 static int save_ust_events(struct config_writer
*writer
, struct lttng_ht
*events
)
1099 struct ltt_ust_event
*event
;
1100 struct lttng_ht_node_str
*node
;
1101 struct lttng_ht_iter iter
;
1103 ret
= config_writer_open_element(writer
, config_element_events
);
1105 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1110 cds_lfht_for_each_entry (events
->ht
, &iter
.iter
, node
, node
) {
1111 event
= lttng::utils::container_of(node
, <t_ust_event::node
);
1113 if (event
->internal
) {
1114 /* Internal events must not be exposed to clients */
1117 ret
= save_ust_event(writer
, event
);
1118 if (ret
!= LTTNG_OK
) {
1126 ret
= config_writer_close_element(writer
);
1128 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1137 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1138 static int init_ust_event_from_agent_event(struct ltt_ust_event
*ust_event
,
1139 struct agent_event
*agent_event
)
1142 enum lttng_ust_abi_loglevel_type ust_loglevel_type
;
1144 ust_event
->enabled
= AGENT_EVENT_IS_ENABLED(agent_event
);
1145 ust_event
->attr
.instrumentation
= LTTNG_UST_ABI_TRACEPOINT
;
1146 if (lttng_strncpy(ust_event
->attr
.name
, agent_event
->name
, LTTNG_SYMBOL_NAME_LEN
)) {
1147 ret
= LTTNG_ERR_INVALID
;
1150 switch (agent_event
->loglevel_type
) {
1151 case LTTNG_EVENT_LOGLEVEL_ALL
:
1152 ust_loglevel_type
= LTTNG_UST_ABI_LOGLEVEL_ALL
;
1154 case LTTNG_EVENT_LOGLEVEL_SINGLE
:
1155 ust_loglevel_type
= LTTNG_UST_ABI_LOGLEVEL_SINGLE
;
1157 case LTTNG_EVENT_LOGLEVEL_RANGE
:
1158 ust_loglevel_type
= LTTNG_UST_ABI_LOGLEVEL_RANGE
;
1161 ERR("Invalid agent_event loglevel_type.");
1162 ret
= LTTNG_ERR_INVALID
;
1166 ust_event
->attr
.loglevel_type
= ust_loglevel_type
;
1167 ust_event
->attr
.loglevel
= agent_event
->loglevel_value
;
1168 ust_event
->filter_expression
= agent_event
->filter_expression
;
1169 ust_event
->exclusion
= agent_event
->exclusion
;
1176 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1177 static int save_agent_events(struct config_writer
*writer
, struct agent
*agent
)
1180 struct lttng_ht_iter iter
;
1181 struct lttng_ht_node_str
*node
;
1183 ret
= config_writer_open_element(writer
, config_element_events
);
1185 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1190 cds_lfht_for_each_entry (agent
->events
->ht
, &iter
.iter
, node
, node
) {
1191 struct agent_event
*agent_event
;
1192 struct ltt_ust_event fake_event
;
1194 memset(&fake_event
, 0, sizeof(fake_event
));
1195 agent_event
= lttng::utils::container_of(node
, &agent_event::node
);
1198 * Initialize a fake ust event to reuse the same serialization
1199 * function since UST and agent events contain the same info
1200 * (and one could wonder why they don't reuse the same
1203 ret
= init_ust_event_from_agent_event(&fake_event
, agent_event
);
1204 if (ret
!= LTTNG_OK
) {
1208 ret
= save_ust_event(writer
, &fake_event
);
1209 if (ret
!= LTTNG_OK
) {
1217 ret
= config_writer_close_element(writer
);
1219 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1228 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1229 static int save_kernel_context(struct config_writer
*writer
, struct lttng_kernel_abi_context
*ctx
)
1237 ret
= config_writer_open_element(writer
, config_element_context
);
1239 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1243 if (ctx
->ctx
== LTTNG_KERNEL_ABI_CONTEXT_PERF_CPU_COUNTER
) {
1244 ret
= config_writer_open_element(writer
, config_element_context_perf
);
1246 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1250 ret
= config_writer_write_element_unsigned_int(
1251 writer
, config_element_type
, ctx
->u
.perf_counter
.type
);
1253 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1257 ret
= config_writer_write_element_unsigned_int(
1258 writer
, config_element_config
, ctx
->u
.perf_counter
.config
);
1260 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1264 ret
= config_writer_write_element_string(
1265 writer
, config_element_name
, ctx
->u
.perf_counter
.name
);
1267 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1272 ret
= config_writer_close_element(writer
);
1274 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1278 const char *context_type_string
= get_kernel_context_type_string(ctx
->ctx
);
1280 if (!context_type_string
) {
1281 ERR("Unsupported kernel context type.");
1282 ret
= LTTNG_ERR_INVALID
;
1286 ret
= config_writer_write_element_string(
1287 writer
, config_element_type
, context_type_string
);
1289 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1295 ret
= config_writer_close_element(writer
);
1297 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1306 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1307 static int save_kernel_contexts(struct config_writer
*writer
, struct ltt_kernel_channel
*kchan
)
1310 struct ltt_kernel_context
*ctx
;
1312 if (cds_list_empty(&kchan
->ctx_list
)) {
1317 ret
= config_writer_open_element(writer
, config_element_contexts
);
1319 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1323 cds_list_for_each_entry (ctx
, &kchan
->ctx_list
, list
) {
1324 ret
= save_kernel_context(writer
, &ctx
->ctx
);
1325 if (ret
!= LTTNG_OK
) {
1331 ret
= config_writer_close_element(writer
);
1333 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1342 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1343 static int save_ust_context_perf_thread_counter(struct config_writer
*writer
,
1344 struct ltt_ust_context
*ctx
)
1348 LTTNG_ASSERT(writer
);
1351 /* Perf contexts are saved as event_perf_context_type */
1352 ret
= config_writer_open_element(writer
, config_element_context_perf
);
1354 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1358 ret
= config_writer_write_element_unsigned_int(
1359 writer
, config_element_type
, ctx
->ctx
.u
.perf_counter
.type
);
1361 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1365 ret
= config_writer_write_element_unsigned_int(
1366 writer
, config_element_config
, ctx
->ctx
.u
.perf_counter
.config
);
1368 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1372 ret
= config_writer_write_element_string(
1373 writer
, config_element_name
, ctx
->ctx
.u
.perf_counter
.name
);
1375 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1380 ret
= config_writer_close_element(writer
);
1382 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1391 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1392 static int save_ust_context_app_ctx(struct config_writer
*writer
, struct ltt_ust_context
*ctx
)
1396 LTTNG_ASSERT(writer
);
1399 /* Application contexts are saved as application_context_type */
1400 ret
= config_writer_open_element(writer
, config_element_context_app
);
1402 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1406 ret
= config_writer_write_element_string(
1407 writer
, config_element_context_app_provider_name
, ctx
->ctx
.u
.app_ctx
.provider_name
);
1409 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1413 ret
= config_writer_write_element_string(
1414 writer
, config_element_context_app_ctx_name
, ctx
->ctx
.u
.app_ctx
.ctx_name
);
1416 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1421 ret
= config_writer_close_element(writer
);
1423 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1432 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1433 static int save_ust_context_generic(struct config_writer
*writer
, struct ltt_ust_context
*ctx
)
1436 const char *context_type_string
;
1438 LTTNG_ASSERT(writer
);
1441 /* Save context as event_context_type_type */
1442 context_type_string
= get_ust_context_type_string(ctx
->ctx
.ctx
);
1443 if (!context_type_string
) {
1444 ERR("Unsupported UST context type.");
1445 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1449 ret
= config_writer_write_element_string(writer
, config_element_type
, context_type_string
);
1451 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1460 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1461 static int save_ust_context(struct config_writer
*writer
, struct cds_list_head
*ctx_list
)
1464 struct ltt_ust_context
*ctx
;
1466 LTTNG_ASSERT(writer
);
1467 LTTNG_ASSERT(ctx_list
);
1469 ret
= config_writer_open_element(writer
, config_element_contexts
);
1471 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1475 cds_list_for_each_entry (ctx
, ctx_list
, list
) {
1476 ret
= config_writer_open_element(writer
, config_element_context
);
1478 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1482 switch (ctx
->ctx
.ctx
) {
1483 case LTTNG_UST_ABI_CONTEXT_PERF_THREAD_COUNTER
:
1484 ret
= save_ust_context_perf_thread_counter(writer
, ctx
);
1486 case LTTNG_UST_ABI_CONTEXT_APP_CONTEXT
:
1487 ret
= save_ust_context_app_ctx(writer
, ctx
);
1490 /* Save generic context. */
1491 ret
= save_ust_context_generic(writer
, ctx
);
1493 if (ret
!= LTTNG_OK
) {
1498 ret
= config_writer_close_element(writer
);
1500 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1506 ret
= config_writer_close_element(writer
);
1508 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1517 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1518 static int save_kernel_channel(struct config_writer
*writer
, struct ltt_kernel_channel
*kchan
)
1522 LTTNG_ASSERT(writer
);
1523 LTTNG_ASSERT(kchan
);
1525 ret
= config_writer_open_element(writer
, config_element_channel
);
1527 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1531 ret
= config_writer_write_element_string(writer
, config_element_name
, kchan
->channel
->name
);
1533 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1537 ret
= config_writer_write_element_bool(
1538 writer
, config_element_enabled
, kchan
->channel
->enabled
);
1540 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1544 ret
= save_kernel_channel_attributes(writer
, &kchan
->channel
->attr
);
1545 if (ret
!= LTTNG_OK
) {
1549 ret
= save_kernel_events(writer
, kchan
);
1550 if (ret
!= LTTNG_OK
) {
1554 ret
= save_kernel_contexts(writer
, kchan
);
1555 if (ret
!= LTTNG_OK
) {
1560 ret
= config_writer_close_element(writer
);
1562 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1571 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1572 static int save_ust_channel(struct config_writer
*writer
,
1573 struct ltt_ust_channel
*ust_chan
,
1574 struct ltt_ust_session
*session
)
1578 LTTNG_ASSERT(writer
);
1579 LTTNG_ASSERT(ust_chan
);
1580 LTTNG_ASSERT(session
);
1582 ret
= config_writer_open_element(writer
, config_element_channel
);
1584 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1588 ret
= config_writer_write_element_string(writer
, config_element_name
, ust_chan
->name
);
1590 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1594 ret
= config_writer_write_element_bool(writer
, config_element_enabled
, ust_chan
->enabled
);
1596 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1600 ret
= save_ust_channel_attributes(writer
, &ust_chan
->attr
);
1601 if (ret
!= LTTNG_OK
) {
1605 ret
= config_writer_write_element_unsigned_int(
1606 writer
, config_element_tracefile_size
, ust_chan
->tracefile_size
);
1608 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1612 ret
= config_writer_write_element_unsigned_int(
1613 writer
, config_element_tracefile_count
, ust_chan
->tracefile_count
);
1615 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1619 ret
= config_writer_write_element_unsigned_int(
1620 writer
, config_element_live_timer_interval
, session
->live_timer_interval
);
1622 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1626 if (ust_chan
->domain
== LTTNG_DOMAIN_UST
) {
1627 ret
= save_ust_events(writer
, ust_chan
->events
);
1628 if (ret
!= LTTNG_OK
) {
1632 struct agent
*agent
= NULL
;
1634 agent
= trace_ust_find_agent(session
, ust_chan
->domain
);
1636 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1637 ERR("Could not find agent associated to UST subdomain");
1642 * Channels associated with a UST sub-domain (such as JUL, Log4j
1643 * or Python) don't have any non-internal events. We retrieve
1644 * the "agent" events associated with this channel and serialize
1647 ret
= save_agent_events(writer
, agent
);
1648 if (ret
!= LTTNG_OK
) {
1653 ret
= save_ust_context(writer
, &ust_chan
->ctx_list
);
1654 if (ret
!= LTTNG_OK
) {
1659 ret
= config_writer_close_element(writer
);
1661 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1670 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1671 static int save_kernel_session(struct config_writer
*writer
, struct ltt_session
*session
)
1674 struct ltt_kernel_channel
*kchan
;
1676 LTTNG_ASSERT(writer
);
1677 LTTNG_ASSERT(session
);
1679 ret
= config_writer_write_element_string(
1680 writer
, config_element_type
, config_domain_type_kernel
);
1682 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1686 ret
= config_writer_write_element_string(
1687 writer
, config_element_buffer_type
, config_buffer_type_global
);
1689 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1693 ret
= config_writer_open_element(writer
, config_element_channels
);
1695 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1699 cds_list_for_each_entry (kchan
, &session
->kernel_session
->channel_list
.head
, list
) {
1700 ret
= save_kernel_channel(writer
, kchan
);
1701 if (ret
!= LTTNG_OK
) {
1707 ret
= config_writer_close_element(writer
);
1709 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1718 static const char *get_config_domain_str(enum lttng_domain_type domain
)
1720 const char *str_dom
;
1723 case LTTNG_DOMAIN_KERNEL
:
1724 str_dom
= config_domain_type_kernel
;
1726 case LTTNG_DOMAIN_UST
:
1727 str_dom
= config_domain_type_ust
;
1729 case LTTNG_DOMAIN_JUL
:
1730 str_dom
= config_domain_type_jul
;
1732 case LTTNG_DOMAIN_LOG4J
:
1733 str_dom
= config_domain_type_log4j
;
1735 case LTTNG_DOMAIN_PYTHON
:
1736 str_dom
= config_domain_type_python
;
1745 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1746 static int save_process_attr_tracker(struct config_writer
*writer
,
1747 struct ltt_session
*sess
,
1749 enum lttng_process_attr process_attr
)
1752 const char *element_id_tracker
, *element_target_id
, *element_id
;
1753 const struct process_attr_tracker
*tracker
;
1754 enum lttng_tracking_policy tracking_policy
;
1755 struct lttng_process_attr_values
*values
= NULL
;
1757 switch (process_attr
) {
1758 case LTTNG_PROCESS_ATTR_PROCESS_ID
:
1759 element_id_tracker
= config_element_process_attr_tracker_pid
;
1760 element_target_id
= config_element_process_attr_pid_value
;
1761 element_id
= config_element_process_attr_id
;
1763 case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
:
1764 element_id_tracker
= config_element_process_attr_tracker_vpid
;
1765 element_target_id
= config_element_process_attr_vpid_value
;
1766 element_id
= config_element_process_attr_id
;
1768 case LTTNG_PROCESS_ATTR_USER_ID
:
1769 element_id_tracker
= config_element_process_attr_tracker_uid
;
1770 element_target_id
= config_element_process_attr_uid_value
;
1771 element_id
= config_element_process_attr_id
;
1773 case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
:
1774 element_id_tracker
= config_element_process_attr_tracker_vuid
;
1775 element_target_id
= config_element_process_attr_vuid_value
;
1776 element_id
= config_element_process_attr_id
;
1778 case LTTNG_PROCESS_ATTR_GROUP_ID
:
1779 element_id_tracker
= config_element_process_attr_tracker_gid
;
1780 element_target_id
= config_element_process_attr_gid_value
;
1781 element_id
= config_element_process_attr_id
;
1783 case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
:
1784 element_id_tracker
= config_element_process_attr_tracker_vgid
;
1785 element_target_id
= config_element_process_attr_vgid_value
;
1786 element_id
= config_element_process_attr_id
;
1789 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1794 case LTTNG_DOMAIN_KERNEL
:
1796 tracker
= kernel_get_process_attr_tracker(sess
->kernel_session
, process_attr
);
1797 LTTNG_ASSERT(tracker
);
1800 case LTTNG_DOMAIN_UST
:
1802 tracker
= trace_ust_get_process_attr_tracker(sess
->ust_session
, process_attr
);
1803 LTTNG_ASSERT(tracker
);
1806 case LTTNG_DOMAIN_JUL
:
1807 case LTTNG_DOMAIN_LOG4J
:
1808 case LTTNG_DOMAIN_PYTHON
:
1810 ret
= LTTNG_ERR_UNSUPPORTED_DOMAIN
;
1814 tracking_policy
= process_attr_tracker_get_tracking_policy(tracker
);
1815 if (tracking_policy
== LTTNG_TRACKING_POLICY_INCLUDE_ALL
) {
1816 /* Tracking all, nothing to output. */
1821 ret
= config_writer_open_element(writer
, element_id_tracker
);
1823 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1827 ret
= config_writer_open_element(writer
, config_element_process_attr_values
);
1829 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1833 if (tracking_policy
== LTTNG_TRACKING_POLICY_INCLUDE_SET
) {
1834 unsigned int i
, count
;
1835 enum process_attr_tracker_status status
=
1836 process_attr_tracker_get_inclusion_set(tracker
, &values
);
1838 if (status
!= PROCESS_ATTR_TRACKER_STATUS_OK
) {
1839 ret
= LTTNG_ERR_NOMEM
;
1843 count
= _lttng_process_attr_values_get_count(values
);
1845 for (i
= 0; i
< count
; i
++) {
1846 unsigned int integral_value
= UINT_MAX
;
1847 const char *name
= NULL
;
1848 const struct process_attr_value
*value
=
1849 lttng_process_attr_tracker_values_get_at_index(values
, i
);
1851 LTTNG_ASSERT(value
);
1852 ret
= config_writer_open_element(writer
, element_target_id
);
1854 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1858 switch (value
->type
) {
1859 case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID
:
1860 integral_value
= (unsigned int) value
->value
.pid
;
1862 case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID
:
1863 integral_value
= (unsigned int) value
->value
.uid
;
1865 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID
:
1866 integral_value
= (unsigned int) value
->value
.gid
;
1868 case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME
:
1869 name
= value
->value
.user_name
;
1872 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME
:
1873 name
= value
->value
.group_name
;
1881 ret
= config_writer_write_element_string(
1882 writer
, config_element_name
, name
);
1884 ret
= config_writer_write_element_unsigned_int(
1885 writer
, element_id
, integral_value
);
1889 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1893 /* /$element_target_id */
1894 ret
= config_writer_close_element(writer
);
1896 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1903 ret
= config_writer_close_element(writer
);
1905 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1909 /* /$element_id_tracker */
1910 ret
= config_writer_close_element(writer
);
1912 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1918 lttng_process_attr_values_destroy(values
);
1922 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1924 save_process_attr_trackers(struct config_writer
*writer
, struct ltt_session
*sess
, int domain
)
1929 case LTTNG_DOMAIN_KERNEL
:
1930 ret
= save_process_attr_tracker(
1931 writer
, sess
, domain
, LTTNG_PROCESS_ATTR_PROCESS_ID
);
1932 if (ret
!= LTTNG_OK
) {
1935 ret
= save_process_attr_tracker(
1936 writer
, sess
, domain
, LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
);
1937 if (ret
!= LTTNG_OK
) {
1940 ret
= save_process_attr_tracker(writer
, sess
, domain
, LTTNG_PROCESS_ATTR_USER_ID
);
1941 if (ret
!= LTTNG_OK
) {
1944 ret
= save_process_attr_tracker(
1945 writer
, sess
, domain
, LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
);
1946 if (ret
!= LTTNG_OK
) {
1949 ret
= save_process_attr_tracker(writer
, sess
, domain
, LTTNG_PROCESS_ATTR_GROUP_ID
);
1950 if (ret
!= LTTNG_OK
) {
1953 ret
= save_process_attr_tracker(
1954 writer
, sess
, domain
, LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
);
1955 if (ret
!= LTTNG_OK
) {
1959 case LTTNG_DOMAIN_UST
:
1960 ret
= save_process_attr_tracker(
1961 writer
, sess
, domain
, LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
);
1962 if (ret
!= LTTNG_OK
) {
1965 ret
= save_process_attr_tracker(
1966 writer
, sess
, domain
, LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
);
1967 if (ret
!= LTTNG_OK
) {
1970 ret
= save_process_attr_tracker(
1971 writer
, sess
, domain
, LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
);
1972 if (ret
!= LTTNG_OK
) {
1977 ret
= LTTNG_ERR_INVALID
;
1985 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1986 static int save_ust_domain(struct config_writer
*writer
,
1987 struct ltt_session
*session
,
1988 enum lttng_domain_type domain
)
1991 struct ltt_ust_channel
*ust_chan
;
1992 const char *buffer_type_string
;
1993 struct lttng_ht_node_str
*node
;
1994 struct lttng_ht_iter iter
;
1995 const char *config_domain_name
;
1997 LTTNG_ASSERT(writer
);
1998 LTTNG_ASSERT(session
);
2000 ret
= config_writer_open_element(writer
, config_element_domain
);
2002 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2006 config_domain_name
= get_config_domain_str(domain
);
2007 if (!config_domain_name
) {
2008 ret
= LTTNG_ERR_INVALID
;
2012 ret
= config_writer_write_element_string(writer
, config_element_type
, config_domain_name
);
2014 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2018 buffer_type_string
= get_buffer_type_string(session
->ust_session
->buffer_type
);
2019 if (!buffer_type_string
) {
2020 ERR("Unsupported buffer type.");
2021 ret
= LTTNG_ERR_INVALID
;
2025 ret
= config_writer_write_element_string(
2026 writer
, config_element_buffer_type
, buffer_type_string
);
2028 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2032 ret
= config_writer_open_element(writer
, config_element_channels
);
2034 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2039 cds_lfht_for_each_entry (
2040 session
->ust_session
->domain_global
.channels
->ht
, &iter
.iter
, node
, node
) {
2041 ust_chan
= lttng::utils::container_of(node
, <t_ust_channel::node
);
2042 if (domain
== ust_chan
->domain
) {
2043 ret
= save_ust_channel(writer
, ust_chan
, session
->ust_session
);
2044 if (ret
!= LTTNG_OK
) {
2053 ret
= config_writer_close_element(writer
);
2055 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2059 if (domain
== LTTNG_DOMAIN_UST
) {
2060 ret
= config_writer_open_element(writer
, config_element_process_attr_trackers
);
2062 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2066 ret
= save_process_attr_trackers(writer
, session
, LTTNG_DOMAIN_UST
);
2067 if (ret
!= LTTNG_OK
) {
2072 ret
= config_writer_close_element(writer
);
2074 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2080 ret
= config_writer_close_element(writer
);
2082 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2091 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2092 static int save_domains(struct config_writer
*writer
, struct ltt_session
*session
)
2096 LTTNG_ASSERT(writer
);
2097 LTTNG_ASSERT(session
);
2099 if (!session
->kernel_session
&& !session
->ust_session
) {
2103 ret
= config_writer_open_element(writer
, config_element_domains
);
2105 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2109 if (session
->kernel_session
) {
2110 ret
= config_writer_open_element(writer
, config_element_domain
);
2112 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2116 ret
= save_kernel_session(writer
, session
);
2117 if (ret
!= LTTNG_OK
) {
2121 ret
= config_writer_open_element(writer
, config_element_process_attr_trackers
);
2123 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2127 ret
= save_process_attr_trackers(writer
, session
, LTTNG_DOMAIN_KERNEL
);
2128 if (ret
!= LTTNG_OK
) {
2133 ret
= config_writer_close_element(writer
);
2135 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2139 ret
= config_writer_close_element(writer
);
2141 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2146 if (session
->ust_session
) {
2147 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_UST
);
2148 if (ret
!= LTTNG_OK
) {
2152 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_JUL
);
2153 if (ret
!= LTTNG_OK
) {
2157 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_LOG4J
);
2158 if (ret
!= LTTNG_OK
) {
2162 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_PYTHON
);
2163 if (ret
!= LTTNG_OK
) {
2169 ret
= config_writer_close_element(writer
);
2171 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2180 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2181 static int save_consumer_output(struct config_writer
*writer
, struct consumer_output
*output
)
2185 LTTNG_ASSERT(writer
);
2186 LTTNG_ASSERT(output
);
2188 ret
= config_writer_open_element(writer
, config_element_consumer_output
);
2190 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2194 ret
= config_writer_write_element_bool(writer
, config_element_enabled
, output
->enabled
);
2196 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2200 ret
= config_writer_open_element(writer
, config_element_destination
);
2202 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2206 switch (output
->type
) {
2207 case CONSUMER_DST_LOCAL
:
2208 ret
= config_writer_write_element_string(
2209 writer
, config_element_path
, output
->dst
.session_root_path
);
2211 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2215 case CONSUMER_DST_NET
:
2219 uri
= calloc
<char>(PATH_MAX
);
2221 ret
= LTTNG_ERR_NOMEM
;
2225 ret
= config_writer_open_element(writer
, config_element_net_output
);
2227 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2228 goto end_net_output
;
2231 if (output
->dst
.net
.control_isset
&& output
->dst
.net
.data_isset
) {
2232 ret
= uri_to_str_url(&output
->dst
.net
.control
, uri
, PATH_MAX
);
2234 ret
= LTTNG_ERR_INVALID
;
2235 goto end_net_output
;
2238 ret
= config_writer_write_element_string(
2239 writer
, config_element_control_uri
, uri
);
2241 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2242 goto end_net_output
;
2245 ret
= uri_to_str_url(&output
->dst
.net
.data
, uri
, PATH_MAX
);
2247 ret
= LTTNG_ERR_INVALID
;
2248 goto end_net_output
;
2251 ret
= config_writer_write_element_string(
2252 writer
, config_element_data_uri
, uri
);
2254 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2255 goto end_net_output
;
2260 if (ret
!= LTTNG_OK
) {
2264 ret
= !output
->dst
.net
.control_isset
? LTTNG_ERR_URL_CTRL_MISS
:
2265 LTTNG_ERR_URL_DATA_MISS
;
2270 ret
= config_writer_close_element(writer
);
2272 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2278 ERR("Unsupported consumer output type.");
2279 ret
= LTTNG_ERR_INVALID
;
2284 ret
= config_writer_close_element(writer
);
2286 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2290 /* /consumer_output */
2291 ret
= config_writer_close_element(writer
);
2293 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2302 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2303 static int save_snapshot_outputs(struct config_writer
*writer
, struct snapshot
*snapshot
)
2306 struct lttng_ht_iter iter
;
2307 struct snapshot_output
*output
;
2309 LTTNG_ASSERT(writer
);
2310 LTTNG_ASSERT(snapshot
);
2312 ret
= config_writer_open_element(writer
, config_element_snapshot_outputs
);
2314 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2319 cds_lfht_for_each_entry (snapshot
->output_ht
->ht
, &iter
.iter
, output
, node
.node
) {
2320 ret
= config_writer_open_element(writer
, config_element_output
);
2322 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2326 ret
= config_writer_write_element_string(writer
, config_element_name
, output
->name
);
2328 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2332 ret
= config_writer_write_element_unsigned_int(
2333 writer
, config_element_max_size
, output
->max_size
);
2335 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2339 ret
= save_consumer_output(writer
, output
->consumer
);
2340 if (ret
!= LTTNG_OK
) {
2345 ret
= config_writer_close_element(writer
);
2347 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2353 /* /snapshot_outputs */
2354 ret
= config_writer_close_element(writer
);
2356 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2368 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2369 static int save_session_output(struct config_writer
*writer
, struct ltt_session
*session
)
2373 LTTNG_ASSERT(writer
);
2374 LTTNG_ASSERT(session
);
2376 if ((session
->snapshot_mode
&& session
->snapshot
.nb_output
== 0) ||
2377 (!session
->snapshot_mode
&& !session
->consumer
)) {
2378 /* Session is in no output mode */
2383 ret
= config_writer_open_element(writer
, config_element_output
);
2385 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2389 if (session
->snapshot_mode
) {
2390 ret
= save_snapshot_outputs(writer
, &session
->snapshot
);
2391 if (ret
!= LTTNG_OK
) {
2395 if (session
->consumer
) {
2396 ret
= save_consumer_output(writer
, session
->consumer
);
2397 if (ret
!= LTTNG_OK
) {
2404 ret
= config_writer_close_element(writer
);
2406 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2414 static int save_session_rotation_schedule(struct config_writer
*writer
,
2415 enum lttng_rotation_schedule_type type
,
2419 const char *element_name
;
2420 const char *value_name
;
2423 case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
:
2424 element_name
= config_element_rotation_schedule_periodic
;
2425 value_name
= config_element_rotation_schedule_periodic_time_us
;
2427 case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
:
2428 element_name
= config_element_rotation_schedule_size_threshold
;
2429 value_name
= config_element_rotation_schedule_size_threshold_bytes
;
2436 ret
= config_writer_open_element(writer
, element_name
);
2441 ret
= config_writer_write_element_unsigned_int(writer
, value_name
, value
);
2446 /* Close schedule descriptor element. */
2447 ret
= config_writer_close_element(writer
);
2455 static int save_session_rotation_schedules(struct config_writer
*writer
,
2456 struct ltt_session
*session
)
2460 ret
= config_writer_open_element(writer
, config_element_rotation_schedules
);
2464 if (session
->rotate_timer_period
) {
2465 ret
= save_session_rotation_schedule(writer
,
2466 LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
,
2467 session
->rotate_timer_period
);
2469 goto close_schedules
;
2472 if (session
->rotate_size
) {
2473 ret
= save_session_rotation_schedule(
2474 writer
, LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
, session
->rotate_size
);
2476 goto close_schedules
;
2481 /* Close rotation schedules element. */
2482 ret
= config_writer_close_element(writer
);
2491 * Save the given session.
2493 * Return LTTNG_OK on success else a LTTNG_ERR* code.
2495 static int save_session(struct ltt_session
*session
,
2496 struct lttng_save_session_attr
*attr
,
2497 lttng_sock_cred
*creds
)
2500 char config_file_path
[LTTNG_PATH_MAX
];
2502 struct config_writer
*writer
= NULL
;
2503 size_t session_name_len
;
2504 const char *provided_path
;
2505 int file_open_flags
= O_CREAT
| O_WRONLY
| O_TRUNC
;
2507 LTTNG_ASSERT(session
);
2509 LTTNG_ASSERT(creds
);
2511 session_name_len
= strlen(session
->name
);
2512 memset(config_file_path
, 0, sizeof(config_file_path
));
2514 if (!session_access_ok(session
, LTTNG_SOCK_GET_UID_CRED(creds
)) || session
->destroyed
) {
2515 ret
= LTTNG_ERR_EPERM
;
2519 provided_path
= lttng_save_session_attr_get_output_url(attr
);
2520 if (provided_path
) {
2521 DBG3("Save session in provided path %s", provided_path
);
2522 len
= strlen(provided_path
);
2523 if (len
>= sizeof(config_file_path
)) {
2524 ret
= LTTNG_ERR_SET_URL
;
2527 strncpy(config_file_path
, provided_path
, sizeof(config_file_path
));
2530 char *home_dir
= utils_get_user_home_dir(LTTNG_SOCK_GET_UID_CRED(creds
));
2532 ret
= LTTNG_ERR_SET_URL
;
2536 ret_len
= snprintf(config_file_path
,
2537 sizeof(config_file_path
),
2538 DEFAULT_SESSION_HOME_CONFIGPATH
,
2542 PERROR("snprintf save session");
2543 ret
= LTTNG_ERR_SET_URL
;
2550 * Check the path fits in the config file path dst including the '/'
2551 * followed by trailing .lttng extension and the NULL terminated string.
2553 if ((len
+ session_name_len
+ 2 + sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
)) >
2554 sizeof(config_file_path
)) {
2555 ret
= LTTNG_ERR_SET_URL
;
2559 ret
= run_as_mkdir_recursive(config_file_path
,
2561 LTTNG_SOCK_GET_UID_CRED(creds
),
2562 LTTNG_SOCK_GET_GID_CRED(creds
));
2564 ret
= LTTNG_ERR_SET_URL
;
2569 * At this point, we know that everything fits in the buffer. Validation
2570 * was done just above.
2572 config_file_path
[len
++] = '/';
2573 strncpy(config_file_path
+ len
, session
->name
, sizeof(config_file_path
) - len
);
2574 len
+= session_name_len
;
2575 strcpy(config_file_path
+ len
, DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
2576 len
+= sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
2577 config_file_path
[len
] = '\0';
2579 if (!attr
->overwrite
) {
2580 file_open_flags
|= O_EXCL
;
2583 fd
= run_as_open(config_file_path
,
2585 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
,
2586 LTTNG_SOCK_GET_UID_CRED(creds
),
2587 LTTNG_SOCK_GET_GID_CRED(creds
));
2589 PERROR("Could not create configuration file");
2592 ret
= LTTNG_ERR_SAVE_FILE_EXIST
;
2595 ret
= LTTNG_ERR_EPERM
;
2598 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2604 writer
= config_writer_create(fd
, 1);
2606 ret
= LTTNG_ERR_NOMEM
;
2610 ret
= config_writer_open_element(writer
, config_element_sessions
);
2612 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2616 ret
= config_writer_open_element(writer
, config_element_session
);
2618 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2622 ret
= config_writer_write_element_string(writer
, config_element_name
, session
->name
);
2624 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2628 if (session
->shm_path
[0] != '\0') {
2629 ret
= config_writer_write_element_string(
2630 writer
, config_element_shared_memory_path
, session
->shm_path
);
2632 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2637 ret
= save_domains(writer
, session
);
2638 if (ret
!= LTTNG_OK
) {
2642 ret
= config_writer_write_element_bool(writer
, config_element_started
, session
->active
);
2644 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2648 if (session
->snapshot_mode
|| session
->live_timer
|| session
->rotate_timer_period
||
2649 session
->rotate_size
) {
2650 ret
= config_writer_open_element(writer
, config_element_attributes
);
2652 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2656 if (session
->snapshot_mode
) {
2657 ret
= config_writer_write_element_bool(
2658 writer
, config_element_snapshot_mode
, 1);
2660 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2663 } else if (session
->live_timer
) {
2664 ret
= config_writer_write_element_unsigned_int(
2665 writer
, config_element_live_timer_interval
, session
->live_timer
);
2667 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2671 if (session
->rotate_timer_period
|| session
->rotate_size
) {
2672 ret
= save_session_rotation_schedules(writer
, session
);
2674 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2680 ret
= config_writer_close_element(writer
);
2682 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2687 ret
= save_session_output(writer
, session
);
2688 if (ret
!= LTTNG_OK
) {
2693 ret
= config_writer_close_element(writer
);
2695 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2700 ret
= config_writer_close_element(writer
);
2702 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2708 if (writer
&& config_writer_destroy(writer
)) {
2709 /* Preserve the original error code */
2710 ret
= ret
!= LTTNG_OK
? ret
: LTTNG_ERR_SAVE_IO_FAIL
;
2712 if (ret
!= LTTNG_OK
) {
2713 /* Delete file in case of error */
2714 if ((fd
>= 0) && unlink(config_file_path
)) {
2715 PERROR("Unlinking XML session configuration.");
2722 closeret
= close(fd
);
2724 PERROR("Closing XML session configuration");
2731 int cmd_save_sessions(struct lttng_save_session_attr
*attr
, lttng_sock_cred
*creds
)
2734 const char *session_name
;
2735 struct ltt_session
*session
;
2737 session_lock_list();
2739 session_name
= lttng_save_session_attr_get_session_name(attr
);
2741 session
= session_find_by_name(session_name
);
2743 ret
= LTTNG_ERR_SESS_NOT_FOUND
;
2747 session_lock(session
);
2748 ret
= save_session(session
, attr
, creds
);
2749 session_unlock(session
);
2750 session_put(session
);
2751 if (ret
!= LTTNG_OK
) {
2755 struct ltt_session_list
*list
= session_get_list();
2757 cds_list_for_each_entry (session
, &list
->head
, list
) {
2758 if (!session_get(session
)) {
2761 session_lock(session
);
2762 ret
= save_session(session
, attr
, creds
);
2763 session_unlock(session
);
2764 session_put(session
);
2765 /* Don't abort if we don't have the required permissions. */
2766 if (ret
!= LTTNG_OK
&& ret
!= LTTNG_ERR_EPERM
) {
2774 session_unlock_list();