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/urcu.hpp>
21 #include <common/utils.hpp>
23 #include <lttng/save-internal.hpp>
28 #include <urcu/uatomic.h>
30 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
31 static int save_kernel_channel_attributes(struct config_writer
*writer
,
32 struct lttng_channel_attr
*attr
)
36 ret
= config_writer_write_element_string(writer
,
37 config_element_overwrite_mode
,
38 attr
->overwrite
? config_overwrite_mode_overwrite
:
39 config_overwrite_mode_discard
);
41 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
45 ret
= config_writer_write_element_unsigned_int(
46 writer
, config_element_subbuf_size
, attr
->subbuf_size
);
48 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
52 ret
= config_writer_write_element_unsigned_int(
53 writer
, config_element_num_subbuf
, attr
->num_subbuf
);
55 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
59 ret
= config_writer_write_element_unsigned_int(
60 writer
, config_element_switch_timer_interval
, attr
->switch_timer_interval
);
62 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
66 ret
= config_writer_write_element_unsigned_int(
67 writer
, config_element_read_timer_interval
, attr
->read_timer_interval
);
69 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
73 ret
= config_writer_write_element_string(writer
,
74 config_element_output_type
,
75 attr
->output
== LTTNG_EVENT_SPLICE
?
76 config_output_type_splice
:
77 config_output_type_mmap
);
79 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
83 ret
= config_writer_write_element_unsigned_int(
84 writer
, config_element_tracefile_size
, attr
->tracefile_size
);
86 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
90 ret
= config_writer_write_element_unsigned_int(
91 writer
, config_element_tracefile_count
, attr
->tracefile_count
);
93 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
97 ret
= config_writer_write_element_unsigned_int(
98 writer
, config_element_live_timer_interval
, attr
->live_timer_interval
);
100 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
104 if (attr
->extended
.ptr
) {
105 struct lttng_channel_extended
*ext
= nullptr;
107 ext
= (struct lttng_channel_extended
*) attr
->extended
.ptr
;
108 ret
= config_writer_write_element_unsigned_int(
109 writer
, config_element_monitor_timer_interval
, ext
->monitor_timer_interval
);
111 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
115 ret
= config_writer_write_element_signed_int(
116 writer
, config_element_blocking_timeout
, ext
->blocking_timeout
);
118 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
128 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
129 static int save_ust_channel_attributes(struct config_writer
*writer
,
130 struct lttng_ust_abi_channel_attr
*attr
)
133 struct ltt_ust_channel
*channel
= nullptr;
135 ret
= config_writer_write_element_string(writer
,
136 config_element_overwrite_mode
,
137 attr
->overwrite
? config_overwrite_mode_overwrite
:
138 config_overwrite_mode_discard
);
140 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
144 ret
= config_writer_write_element_unsigned_int(
145 writer
, config_element_subbuf_size
, attr
->subbuf_size
);
147 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
151 ret
= config_writer_write_element_unsigned_int(
152 writer
, config_element_num_subbuf
, attr
->num_subbuf
);
154 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
158 ret
= config_writer_write_element_unsigned_int(
159 writer
, config_element_switch_timer_interval
, attr
->switch_timer_interval
);
161 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
165 ret
= config_writer_write_element_unsigned_int(
166 writer
, config_element_read_timer_interval
, attr
->read_timer_interval
);
168 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
172 ret
= config_writer_write_element_string(writer
,
173 config_element_output_type
,
174 attr
->output
== LTTNG_UST_ABI_MMAP
?
175 config_output_type_mmap
:
176 config_output_type_splice
);
178 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
182 ret
= config_writer_write_element_signed_int(
183 writer
, config_element_blocking_timeout
, attr
->u
.s
.blocking_timeout
);
185 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
190 * Fetch the monitor timer which is located in the parent of
191 * lttng_ust_channel_attr
193 channel
= lttng::utils::container_of(attr
, <t_ust_channel::attr
);
194 ret
= config_writer_write_element_unsigned_int(
195 writer
, config_element_monitor_timer_interval
, channel
->monitor_timer_interval
);
197 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
207 get_kernel_instrumentation_string(enum lttng_kernel_abi_instrumentation instrumentation
)
209 const char *instrumentation_string
;
211 switch (instrumentation
) {
212 case LTTNG_KERNEL_ABI_ALL
:
213 instrumentation_string
= config_event_type_all
;
215 case LTTNG_KERNEL_ABI_TRACEPOINT
:
216 instrumentation_string
= config_event_type_tracepoint
;
218 case LTTNG_KERNEL_ABI_KPROBE
:
219 instrumentation_string
= config_event_type_probe
;
221 case LTTNG_KERNEL_ABI_UPROBE
:
222 instrumentation_string
= config_event_type_userspace_probe
;
224 case LTTNG_KERNEL_ABI_FUNCTION
:
225 instrumentation_string
= config_event_type_function_entry
;
227 case LTTNG_KERNEL_ABI_KRETPROBE
:
228 instrumentation_string
= config_event_type_function
;
230 case LTTNG_KERNEL_ABI_NOOP
:
231 instrumentation_string
= config_event_type_noop
;
233 case LTTNG_KERNEL_ABI_SYSCALL
:
234 instrumentation_string
= config_event_type_syscall
;
237 instrumentation_string
= nullptr;
240 return instrumentation_string
;
243 static const char *get_kernel_context_type_string(enum lttng_kernel_abi_context_type context_type
)
245 const char *context_type_string
;
247 switch (context_type
) {
248 case LTTNG_KERNEL_ABI_CONTEXT_PID
:
249 context_type_string
= config_event_context_pid
;
251 case LTTNG_KERNEL_ABI_CONTEXT_PROCNAME
:
252 context_type_string
= config_event_context_procname
;
254 case LTTNG_KERNEL_ABI_CONTEXT_PRIO
:
255 context_type_string
= config_event_context_prio
;
257 case LTTNG_KERNEL_ABI_CONTEXT_NICE
:
258 context_type_string
= config_event_context_nice
;
260 case LTTNG_KERNEL_ABI_CONTEXT_VPID
:
261 context_type_string
= config_event_context_vpid
;
263 case LTTNG_KERNEL_ABI_CONTEXT_TID
:
264 context_type_string
= config_event_context_tid
;
266 case LTTNG_KERNEL_ABI_CONTEXT_VTID
:
267 context_type_string
= config_event_context_vtid
;
269 case LTTNG_KERNEL_ABI_CONTEXT_PPID
:
270 context_type_string
= config_event_context_ppid
;
272 case LTTNG_KERNEL_ABI_CONTEXT_VPPID
:
273 context_type_string
= config_event_context_vppid
;
275 case LTTNG_KERNEL_ABI_CONTEXT_HOSTNAME
:
276 context_type_string
= config_event_context_hostname
;
278 case LTTNG_KERNEL_ABI_CONTEXT_INTERRUPTIBLE
:
279 context_type_string
= config_event_context_interruptible
;
281 case LTTNG_KERNEL_ABI_CONTEXT_PREEMPTIBLE
:
282 context_type_string
= config_event_context_preemptible
;
284 case LTTNG_KERNEL_ABI_CONTEXT_NEED_RESCHEDULE
:
285 context_type_string
= config_event_context_need_reschedule
;
287 case LTTNG_KERNEL_ABI_CONTEXT_MIGRATABLE
:
288 context_type_string
= config_event_context_migratable
;
290 case LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_USER
:
291 context_type_string
= config_event_context_callstack_user
;
293 case LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_KERNEL
:
294 context_type_string
= config_event_context_callstack_kernel
;
296 case LTTNG_KERNEL_ABI_CONTEXT_CGROUP_NS
:
297 context_type_string
= config_event_context_cgroup_ns
;
299 case LTTNG_KERNEL_ABI_CONTEXT_IPC_NS
:
300 context_type_string
= config_event_context_ipc_ns
;
302 case LTTNG_KERNEL_ABI_CONTEXT_MNT_NS
:
303 context_type_string
= config_event_context_mnt_ns
;
305 case LTTNG_KERNEL_ABI_CONTEXT_NET_NS
:
306 context_type_string
= config_event_context_net_ns
;
308 case LTTNG_KERNEL_ABI_CONTEXT_PID_NS
:
309 context_type_string
= config_event_context_pid_ns
;
311 case LTTNG_KERNEL_ABI_CONTEXT_TIME_NS
:
312 context_type_string
= config_event_context_time_ns
;
314 case LTTNG_KERNEL_ABI_CONTEXT_USER_NS
:
315 context_type_string
= config_event_context_user_ns
;
317 case LTTNG_KERNEL_ABI_CONTEXT_UTS_NS
:
318 context_type_string
= config_event_context_uts_ns
;
320 case LTTNG_KERNEL_ABI_CONTEXT_UID
:
321 context_type_string
= config_event_context_uid
;
323 case LTTNG_KERNEL_ABI_CONTEXT_EUID
:
324 context_type_string
= config_event_context_euid
;
326 case LTTNG_KERNEL_ABI_CONTEXT_SUID
:
327 context_type_string
= config_event_context_suid
;
329 case LTTNG_KERNEL_ABI_CONTEXT_GID
:
330 context_type_string
= config_event_context_gid
;
332 case LTTNG_KERNEL_ABI_CONTEXT_EGID
:
333 context_type_string
= config_event_context_egid
;
335 case LTTNG_KERNEL_ABI_CONTEXT_SGID
:
336 context_type_string
= config_event_context_sgid
;
338 case LTTNG_KERNEL_ABI_CONTEXT_VUID
:
339 context_type_string
= config_event_context_vuid
;
341 case LTTNG_KERNEL_ABI_CONTEXT_VEUID
:
342 context_type_string
= config_event_context_veuid
;
344 case LTTNG_KERNEL_ABI_CONTEXT_VSUID
:
345 context_type_string
= config_event_context_vsuid
;
347 case LTTNG_KERNEL_ABI_CONTEXT_VGID
:
348 context_type_string
= config_event_context_vgid
;
350 case LTTNG_KERNEL_ABI_CONTEXT_VEGID
:
351 context_type_string
= config_event_context_vegid
;
353 case LTTNG_KERNEL_ABI_CONTEXT_VSGID
:
354 context_type_string
= config_event_context_vsgid
;
357 context_type_string
= nullptr;
360 return context_type_string
;
363 static const char *get_ust_context_type_string(enum lttng_ust_abi_context_type context_type
)
365 const char *context_type_string
;
367 switch (context_type
) {
368 case LTTNG_UST_ABI_CONTEXT_PROCNAME
:
369 context_type_string
= config_event_context_procname
;
371 case LTTNG_UST_ABI_CONTEXT_VPID
:
372 context_type_string
= config_event_context_vpid
;
374 case LTTNG_UST_ABI_CONTEXT_VTID
:
375 context_type_string
= config_event_context_vtid
;
377 case LTTNG_UST_ABI_CONTEXT_IP
:
378 context_type_string
= config_event_context_ip
;
380 case LTTNG_UST_ABI_CONTEXT_PTHREAD_ID
:
381 context_type_string
= config_event_context_pthread_id
;
383 case LTTNG_UST_ABI_CONTEXT_APP_CONTEXT
:
384 context_type_string
= config_event_context_app
;
386 case LTTNG_UST_ABI_CONTEXT_CGROUP_NS
:
387 context_type_string
= config_event_context_cgroup_ns
;
389 case LTTNG_UST_ABI_CONTEXT_IPC_NS
:
390 context_type_string
= config_event_context_ipc_ns
;
392 case LTTNG_UST_ABI_CONTEXT_MNT_NS
:
393 context_type_string
= config_event_context_mnt_ns
;
395 case LTTNG_UST_ABI_CONTEXT_NET_NS
:
396 context_type_string
= config_event_context_net_ns
;
398 case LTTNG_UST_ABI_CONTEXT_TIME_NS
:
399 context_type_string
= config_event_context_time_ns
;
401 case LTTNG_UST_ABI_CONTEXT_PID_NS
:
402 context_type_string
= config_event_context_pid_ns
;
404 case LTTNG_UST_ABI_CONTEXT_USER_NS
:
405 context_type_string
= config_event_context_user_ns
;
407 case LTTNG_UST_ABI_CONTEXT_UTS_NS
:
408 context_type_string
= config_event_context_uts_ns
;
410 case LTTNG_UST_ABI_CONTEXT_VUID
:
411 context_type_string
= config_event_context_vuid
;
413 case LTTNG_UST_ABI_CONTEXT_VEUID
:
414 context_type_string
= config_event_context_veuid
;
416 case LTTNG_UST_ABI_CONTEXT_VSUID
:
417 context_type_string
= config_event_context_vsuid
;
419 case LTTNG_UST_ABI_CONTEXT_VGID
:
420 context_type_string
= config_event_context_vgid
;
422 case LTTNG_UST_ABI_CONTEXT_VEGID
:
423 context_type_string
= config_event_context_vegid
;
425 case LTTNG_UST_ABI_CONTEXT_VSGID
:
426 context_type_string
= config_event_context_vsgid
;
428 case LTTNG_UST_ABI_CONTEXT_PERF_THREAD_COUNTER
:
430 * Error, should not be stored in the XML, perf contexts
431 * are stored as a node of type event_perf_context_type.
434 context_type_string
= nullptr;
438 return context_type_string
;
441 static const char *get_buffer_type_string(enum lttng_buffer_type buffer_type
)
443 const char *buffer_type_string
;
445 switch (buffer_type
) {
446 case LTTNG_BUFFER_PER_PID
:
447 buffer_type_string
= config_buffer_type_per_pid
;
449 case LTTNG_BUFFER_PER_UID
:
450 buffer_type_string
= config_buffer_type_per_uid
;
452 case LTTNG_BUFFER_GLOBAL
:
453 buffer_type_string
= config_buffer_type_global
;
456 buffer_type_string
= nullptr;
459 return buffer_type_string
;
462 static const char *get_loglevel_type_string(enum lttng_ust_abi_loglevel_type loglevel_type
)
464 const char *loglevel_type_string
;
466 switch (loglevel_type
) {
467 case LTTNG_UST_ABI_LOGLEVEL_ALL
:
468 loglevel_type_string
= config_loglevel_type_all
;
470 case LTTNG_UST_ABI_LOGLEVEL_RANGE
:
471 loglevel_type_string
= config_loglevel_type_range
;
473 case LTTNG_UST_ABI_LOGLEVEL_SINGLE
:
474 loglevel_type_string
= config_loglevel_type_single
;
477 loglevel_type_string
= nullptr;
480 return loglevel_type_string
;
483 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
484 static int save_kernel_function_event(struct config_writer
*writer
, struct ltt_kernel_event
*event
)
488 ret
= config_writer_open_element(writer
, config_element_function_attributes
);
490 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
494 ret
= config_writer_write_element_string(
495 writer
, config_element_name
, event
->event
->u
.ftrace
.symbol_name
);
497 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
501 /* /function attributes */
502 ret
= config_writer_close_element(writer
);
504 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
511 static int save_kernel_kprobe_event(struct config_writer
*writer
, struct ltt_kernel_event
*event
)
514 const char *symbol_name
;
518 switch (event
->event
->instrumentation
) {
519 case LTTNG_KERNEL_ABI_KPROBE
:
521 * Comments in lttng-kernel.h mention that
522 * either addr or symbol_name are set, not both.
524 addr
= event
->event
->u
.kprobe
.addr
;
525 offset
= event
->event
->u
.kprobe
.offset
;
526 symbol_name
= addr
? nullptr : event
->event
->u
.kprobe
.symbol_name
;
528 case LTTNG_KERNEL_ABI_KRETPROBE
:
529 addr
= event
->event
->u
.kretprobe
.addr
;
530 offset
= event
->event
->u
.kretprobe
.offset
;
531 symbol_name
= addr
? nullptr : 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 lttng::urcu::read_lock_guard read_lock
;
1112 cds_lfht_for_each_entry (events
->ht
, &iter
.iter
, node
, node
) {
1113 event
= lttng::utils::container_of(node
, <t_ust_event::node
);
1115 if (event
->internal
) {
1116 /* Internal events must not be exposed to clients */
1119 ret
= save_ust_event(writer
, event
);
1120 if (ret
!= LTTNG_OK
) {
1127 ret
= config_writer_close_element(writer
);
1129 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1138 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1139 static int init_ust_event_from_agent_event(struct ltt_ust_event
*ust_event
,
1140 struct agent_event
*agent_event
)
1143 enum lttng_ust_abi_loglevel_type ust_loglevel_type
;
1145 ust_event
->enabled
= AGENT_EVENT_IS_ENABLED(agent_event
);
1146 ust_event
->attr
.instrumentation
= LTTNG_UST_ABI_TRACEPOINT
;
1147 if (lttng_strncpy(ust_event
->attr
.name
, agent_event
->name
, LTTNG_SYMBOL_NAME_LEN
)) {
1148 ret
= LTTNG_ERR_INVALID
;
1151 switch (agent_event
->loglevel_type
) {
1152 case LTTNG_EVENT_LOGLEVEL_ALL
:
1153 ust_loglevel_type
= LTTNG_UST_ABI_LOGLEVEL_ALL
;
1155 case LTTNG_EVENT_LOGLEVEL_SINGLE
:
1156 ust_loglevel_type
= LTTNG_UST_ABI_LOGLEVEL_SINGLE
;
1158 case LTTNG_EVENT_LOGLEVEL_RANGE
:
1159 ust_loglevel_type
= LTTNG_UST_ABI_LOGLEVEL_RANGE
;
1162 ERR("Invalid agent_event loglevel_type.");
1163 ret
= LTTNG_ERR_INVALID
;
1167 ust_event
->attr
.loglevel_type
= ust_loglevel_type
;
1168 ust_event
->attr
.loglevel
= agent_event
->loglevel_value
;
1169 ust_event
->filter_expression
= agent_event
->filter_expression
;
1170 ust_event
->exclusion
= agent_event
->exclusion
;
1177 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1178 static int save_agent_events(struct config_writer
*writer
, struct agent
*agent
)
1181 struct lttng_ht_iter iter
;
1182 struct lttng_ht_node_str
*node
;
1184 ret
= config_writer_open_element(writer
, config_element_events
);
1186 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1191 lttng::urcu::read_lock_guard read_lock
;
1193 cds_lfht_for_each_entry (agent
->events
->ht
, &iter
.iter
, node
, node
) {
1194 struct agent_event
*agent_event
;
1195 struct ltt_ust_event fake_event
;
1197 memset(&fake_event
, 0, sizeof(fake_event
));
1198 agent_event
= lttng::utils::container_of(node
, &agent_event::node
);
1201 * Initialize a fake ust event to reuse the same serialization
1202 * function since UST and agent events contain the same info
1203 * (and one could wonder why they don't reuse the same
1206 ret
= init_ust_event_from_agent_event(&fake_event
, agent_event
);
1207 if (ret
!= LTTNG_OK
) {
1210 ret
= save_ust_event(writer
, &fake_event
);
1211 if (ret
!= LTTNG_OK
) {
1218 ret
= config_writer_close_element(writer
);
1220 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1229 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1230 static int save_kernel_context(struct config_writer
*writer
, struct lttng_kernel_abi_context
*ctx
)
1238 ret
= config_writer_open_element(writer
, config_element_context
);
1240 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1244 if (ctx
->ctx
== LTTNG_KERNEL_ABI_CONTEXT_PERF_CPU_COUNTER
) {
1245 ret
= config_writer_open_element(writer
, config_element_context_perf
);
1247 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1251 ret
= config_writer_write_element_unsigned_int(
1252 writer
, config_element_type
, ctx
->u
.perf_counter
.type
);
1254 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1258 ret
= config_writer_write_element_unsigned_int(
1259 writer
, config_element_config
, ctx
->u
.perf_counter
.config
);
1261 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1265 ret
= config_writer_write_element_string(
1266 writer
, config_element_name
, ctx
->u
.perf_counter
.name
);
1268 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1273 ret
= config_writer_close_element(writer
);
1275 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1279 const char *context_type_string
= get_kernel_context_type_string(ctx
->ctx
);
1281 if (!context_type_string
) {
1282 ERR("Unsupported kernel context type.");
1283 ret
= LTTNG_ERR_INVALID
;
1287 ret
= config_writer_write_element_string(
1288 writer
, config_element_type
, context_type_string
);
1290 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1296 ret
= config_writer_close_element(writer
);
1298 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1307 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1308 static int save_kernel_contexts(struct config_writer
*writer
, struct ltt_kernel_channel
*kchan
)
1311 struct ltt_kernel_context
*ctx
;
1313 if (cds_list_empty(&kchan
->ctx_list
)) {
1318 ret
= config_writer_open_element(writer
, config_element_contexts
);
1320 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1324 cds_list_for_each_entry (ctx
, &kchan
->ctx_list
, list
) {
1325 ret
= save_kernel_context(writer
, &ctx
->ctx
);
1326 if (ret
!= LTTNG_OK
) {
1332 ret
= config_writer_close_element(writer
);
1334 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1343 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1344 static int save_ust_context_perf_thread_counter(struct config_writer
*writer
,
1345 struct ltt_ust_context
*ctx
)
1349 LTTNG_ASSERT(writer
);
1352 /* Perf contexts are saved as event_perf_context_type */
1353 ret
= config_writer_open_element(writer
, config_element_context_perf
);
1355 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1359 ret
= config_writer_write_element_unsigned_int(
1360 writer
, config_element_type
, ctx
->ctx
.u
.perf_counter
.type
);
1362 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1366 ret
= config_writer_write_element_unsigned_int(
1367 writer
, config_element_config
, ctx
->ctx
.u
.perf_counter
.config
);
1369 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1373 ret
= config_writer_write_element_string(
1374 writer
, config_element_name
, ctx
->ctx
.u
.perf_counter
.name
);
1376 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1381 ret
= config_writer_close_element(writer
);
1383 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1392 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1393 static int save_ust_context_app_ctx(struct config_writer
*writer
, struct ltt_ust_context
*ctx
)
1397 LTTNG_ASSERT(writer
);
1400 /* Application contexts are saved as application_context_type */
1401 ret
= config_writer_open_element(writer
, config_element_context_app
);
1403 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1407 ret
= config_writer_write_element_string(
1408 writer
, config_element_context_app_provider_name
, ctx
->ctx
.u
.app_ctx
.provider_name
);
1410 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1414 ret
= config_writer_write_element_string(
1415 writer
, config_element_context_app_ctx_name
, ctx
->ctx
.u
.app_ctx
.ctx_name
);
1417 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1422 ret
= config_writer_close_element(writer
);
1424 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1433 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1434 static int save_ust_context_generic(struct config_writer
*writer
, struct ltt_ust_context
*ctx
)
1437 const char *context_type_string
;
1439 LTTNG_ASSERT(writer
);
1442 /* Save context as event_context_type_type */
1443 context_type_string
= get_ust_context_type_string(ctx
->ctx
.ctx
);
1444 if (!context_type_string
) {
1445 ERR("Unsupported UST context type.");
1446 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1450 ret
= config_writer_write_element_string(writer
, config_element_type
, context_type_string
);
1452 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1461 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1462 static int save_ust_context(struct config_writer
*writer
, struct cds_list_head
*ctx_list
)
1465 struct ltt_ust_context
*ctx
;
1467 LTTNG_ASSERT(writer
);
1468 LTTNG_ASSERT(ctx_list
);
1470 ret
= config_writer_open_element(writer
, config_element_contexts
);
1472 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1476 cds_list_for_each_entry (ctx
, ctx_list
, list
) {
1477 ret
= config_writer_open_element(writer
, config_element_context
);
1479 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1483 switch (ctx
->ctx
.ctx
) {
1484 case LTTNG_UST_ABI_CONTEXT_PERF_THREAD_COUNTER
:
1485 ret
= save_ust_context_perf_thread_counter(writer
, ctx
);
1487 case LTTNG_UST_ABI_CONTEXT_APP_CONTEXT
:
1488 ret
= save_ust_context_app_ctx(writer
, ctx
);
1491 /* Save generic context. */
1492 ret
= save_ust_context_generic(writer
, ctx
);
1494 if (ret
!= LTTNG_OK
) {
1499 ret
= config_writer_close_element(writer
);
1501 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1507 ret
= config_writer_close_element(writer
);
1509 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1518 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1519 static int save_kernel_channel(struct config_writer
*writer
, struct ltt_kernel_channel
*kchan
)
1523 LTTNG_ASSERT(writer
);
1524 LTTNG_ASSERT(kchan
);
1526 ret
= config_writer_open_element(writer
, config_element_channel
);
1528 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1532 ret
= config_writer_write_element_string(writer
, config_element_name
, kchan
->channel
->name
);
1534 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1538 ret
= config_writer_write_element_bool(
1539 writer
, config_element_enabled
, kchan
->channel
->enabled
);
1541 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1545 ret
= save_kernel_channel_attributes(writer
, &kchan
->channel
->attr
);
1546 if (ret
!= LTTNG_OK
) {
1550 ret
= save_kernel_events(writer
, kchan
);
1551 if (ret
!= LTTNG_OK
) {
1555 ret
= save_kernel_contexts(writer
, kchan
);
1556 if (ret
!= LTTNG_OK
) {
1561 ret
= config_writer_close_element(writer
);
1563 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1572 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1573 static int save_ust_channel(struct config_writer
*writer
,
1574 struct ltt_ust_channel
*ust_chan
,
1575 struct ltt_ust_session
*session
)
1579 LTTNG_ASSERT(writer
);
1580 LTTNG_ASSERT(ust_chan
);
1581 LTTNG_ASSERT(session
);
1583 ret
= config_writer_open_element(writer
, config_element_channel
);
1585 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1589 ret
= config_writer_write_element_string(writer
, config_element_name
, ust_chan
->name
);
1591 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1595 ret
= config_writer_write_element_bool(writer
, config_element_enabled
, ust_chan
->enabled
);
1597 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1601 ret
= save_ust_channel_attributes(writer
, &ust_chan
->attr
);
1602 if (ret
!= LTTNG_OK
) {
1606 ret
= config_writer_write_element_unsigned_int(
1607 writer
, config_element_tracefile_size
, ust_chan
->tracefile_size
);
1609 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1613 ret
= config_writer_write_element_unsigned_int(
1614 writer
, config_element_tracefile_count
, ust_chan
->tracefile_count
);
1616 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1620 ret
= config_writer_write_element_unsigned_int(
1621 writer
, config_element_live_timer_interval
, session
->live_timer_interval
);
1623 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1627 if (ust_chan
->domain
== LTTNG_DOMAIN_UST
) {
1628 ret
= save_ust_events(writer
, ust_chan
->events
);
1629 if (ret
!= LTTNG_OK
) {
1633 struct agent
*agent
= nullptr;
1635 agent
= trace_ust_find_agent(session
, ust_chan
->domain
);
1637 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1638 ERR("Could not find agent associated to UST subdomain");
1643 * Channels associated with a UST sub-domain (such as JUL, Log4j
1644 * or Python) don't have any non-internal events. We retrieve
1645 * the "agent" events associated with this channel and serialize
1648 ret
= save_agent_events(writer
, agent
);
1649 if (ret
!= LTTNG_OK
) {
1654 ret
= save_ust_context(writer
, &ust_chan
->ctx_list
);
1655 if (ret
!= LTTNG_OK
) {
1660 ret
= config_writer_close_element(writer
);
1662 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1671 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1672 static int save_kernel_session(struct config_writer
*writer
, struct ltt_session
*session
)
1675 struct ltt_kernel_channel
*kchan
;
1677 LTTNG_ASSERT(writer
);
1678 LTTNG_ASSERT(session
);
1680 ret
= config_writer_write_element_string(
1681 writer
, config_element_type
, config_domain_type_kernel
);
1683 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1687 ret
= config_writer_write_element_string(
1688 writer
, config_element_buffer_type
, config_buffer_type_global
);
1690 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1694 ret
= config_writer_open_element(writer
, config_element_channels
);
1696 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1700 cds_list_for_each_entry (kchan
, &session
->kernel_session
->channel_list
.head
, list
) {
1701 ret
= save_kernel_channel(writer
, kchan
);
1702 if (ret
!= LTTNG_OK
) {
1708 ret
= config_writer_close_element(writer
);
1710 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1719 static const char *get_config_domain_str(enum lttng_domain_type domain
)
1721 const char *str_dom
;
1724 case LTTNG_DOMAIN_KERNEL
:
1725 str_dom
= config_domain_type_kernel
;
1727 case LTTNG_DOMAIN_UST
:
1728 str_dom
= config_domain_type_ust
;
1730 case LTTNG_DOMAIN_JUL
:
1731 str_dom
= config_domain_type_jul
;
1733 case LTTNG_DOMAIN_LOG4J
:
1734 str_dom
= config_domain_type_log4j
;
1736 case LTTNG_DOMAIN_PYTHON
:
1737 str_dom
= config_domain_type_python
;
1746 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1747 static int save_process_attr_tracker(struct config_writer
*writer
,
1748 struct ltt_session
*sess
,
1750 enum lttng_process_attr process_attr
)
1753 const char *element_id_tracker
, *element_target_id
, *element_id
;
1754 const struct process_attr_tracker
*tracker
;
1755 enum lttng_tracking_policy tracking_policy
;
1756 struct lttng_process_attr_values
*values
= nullptr;
1758 switch (process_attr
) {
1759 case LTTNG_PROCESS_ATTR_PROCESS_ID
:
1760 element_id_tracker
= config_element_process_attr_tracker_pid
;
1761 element_target_id
= config_element_process_attr_pid_value
;
1762 element_id
= config_element_process_attr_id
;
1764 case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
:
1765 element_id_tracker
= config_element_process_attr_tracker_vpid
;
1766 element_target_id
= config_element_process_attr_vpid_value
;
1767 element_id
= config_element_process_attr_id
;
1769 case LTTNG_PROCESS_ATTR_USER_ID
:
1770 element_id_tracker
= config_element_process_attr_tracker_uid
;
1771 element_target_id
= config_element_process_attr_uid_value
;
1772 element_id
= config_element_process_attr_id
;
1774 case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
:
1775 element_id_tracker
= config_element_process_attr_tracker_vuid
;
1776 element_target_id
= config_element_process_attr_vuid_value
;
1777 element_id
= config_element_process_attr_id
;
1779 case LTTNG_PROCESS_ATTR_GROUP_ID
:
1780 element_id_tracker
= config_element_process_attr_tracker_gid
;
1781 element_target_id
= config_element_process_attr_gid_value
;
1782 element_id
= config_element_process_attr_id
;
1784 case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
:
1785 element_id_tracker
= config_element_process_attr_tracker_vgid
;
1786 element_target_id
= config_element_process_attr_vgid_value
;
1787 element_id
= config_element_process_attr_id
;
1790 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1795 case LTTNG_DOMAIN_KERNEL
:
1797 tracker
= kernel_get_process_attr_tracker(sess
->kernel_session
, process_attr
);
1798 LTTNG_ASSERT(tracker
);
1801 case LTTNG_DOMAIN_UST
:
1803 tracker
= trace_ust_get_process_attr_tracker(sess
->ust_session
, process_attr
);
1804 LTTNG_ASSERT(tracker
);
1807 case LTTNG_DOMAIN_JUL
:
1808 case LTTNG_DOMAIN_LOG4J
:
1809 case LTTNG_DOMAIN_PYTHON
:
1811 ret
= LTTNG_ERR_UNSUPPORTED_DOMAIN
;
1815 tracking_policy
= process_attr_tracker_get_tracking_policy(tracker
);
1816 if (tracking_policy
== LTTNG_TRACKING_POLICY_INCLUDE_ALL
) {
1817 /* Tracking all, nothing to output. */
1822 ret
= config_writer_open_element(writer
, element_id_tracker
);
1824 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1828 ret
= config_writer_open_element(writer
, config_element_process_attr_values
);
1830 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1834 if (tracking_policy
== LTTNG_TRACKING_POLICY_INCLUDE_SET
) {
1835 unsigned int i
, count
;
1836 enum process_attr_tracker_status status
=
1837 process_attr_tracker_get_inclusion_set(tracker
, &values
);
1839 if (status
!= PROCESS_ATTR_TRACKER_STATUS_OK
) {
1840 ret
= LTTNG_ERR_NOMEM
;
1844 count
= _lttng_process_attr_values_get_count(values
);
1846 for (i
= 0; i
< count
; i
++) {
1847 unsigned int integral_value
= UINT_MAX
;
1848 const char *name
= nullptr;
1849 const struct process_attr_value
*value
=
1850 lttng_process_attr_tracker_values_get_at_index(values
, i
);
1852 LTTNG_ASSERT(value
);
1853 ret
= config_writer_open_element(writer
, element_target_id
);
1855 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1859 switch (value
->type
) {
1860 case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID
:
1861 integral_value
= (unsigned int) value
->value
.pid
;
1863 case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID
:
1864 integral_value
= (unsigned int) value
->value
.uid
;
1866 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID
:
1867 integral_value
= (unsigned int) value
->value
.gid
;
1869 case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME
:
1870 name
= value
->value
.user_name
;
1873 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME
:
1874 name
= value
->value
.group_name
;
1882 ret
= config_writer_write_element_string(
1883 writer
, config_element_name
, name
);
1885 ret
= config_writer_write_element_unsigned_int(
1886 writer
, element_id
, integral_value
);
1890 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1894 /* /$element_target_id */
1895 ret
= config_writer_close_element(writer
);
1897 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1904 ret
= config_writer_close_element(writer
);
1906 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1910 /* /$element_id_tracker */
1911 ret
= config_writer_close_element(writer
);
1913 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1919 lttng_process_attr_values_destroy(values
);
1923 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1925 save_process_attr_trackers(struct config_writer
*writer
, struct ltt_session
*sess
, int domain
)
1930 case LTTNG_DOMAIN_KERNEL
:
1931 ret
= save_process_attr_tracker(
1932 writer
, sess
, domain
, LTTNG_PROCESS_ATTR_PROCESS_ID
);
1933 if (ret
!= LTTNG_OK
) {
1936 ret
= save_process_attr_tracker(
1937 writer
, sess
, domain
, LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
);
1938 if (ret
!= LTTNG_OK
) {
1941 ret
= save_process_attr_tracker(writer
, sess
, domain
, LTTNG_PROCESS_ATTR_USER_ID
);
1942 if (ret
!= LTTNG_OK
) {
1945 ret
= save_process_attr_tracker(
1946 writer
, sess
, domain
, LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
);
1947 if (ret
!= LTTNG_OK
) {
1950 ret
= save_process_attr_tracker(writer
, sess
, domain
, LTTNG_PROCESS_ATTR_GROUP_ID
);
1951 if (ret
!= LTTNG_OK
) {
1954 ret
= save_process_attr_tracker(
1955 writer
, sess
, domain
, LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
);
1956 if (ret
!= LTTNG_OK
) {
1960 case LTTNG_DOMAIN_UST
:
1961 ret
= save_process_attr_tracker(
1962 writer
, sess
, domain
, LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
);
1963 if (ret
!= LTTNG_OK
) {
1966 ret
= save_process_attr_tracker(
1967 writer
, sess
, domain
, LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
);
1968 if (ret
!= LTTNG_OK
) {
1971 ret
= save_process_attr_tracker(
1972 writer
, sess
, domain
, LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
);
1973 if (ret
!= LTTNG_OK
) {
1978 ret
= LTTNG_ERR_INVALID
;
1986 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1987 static int save_ust_domain(struct config_writer
*writer
,
1988 struct ltt_session
*session
,
1989 enum lttng_domain_type domain
)
1992 struct ltt_ust_channel
*ust_chan
;
1993 const char *buffer_type_string
;
1994 struct lttng_ht_node_str
*node
;
1995 struct lttng_ht_iter iter
;
1996 const char *config_domain_name
;
1998 LTTNG_ASSERT(writer
);
1999 LTTNG_ASSERT(session
);
2001 ret
= config_writer_open_element(writer
, config_element_domain
);
2003 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2007 config_domain_name
= get_config_domain_str(domain
);
2008 if (!config_domain_name
) {
2009 ret
= LTTNG_ERR_INVALID
;
2013 ret
= config_writer_write_element_string(writer
, config_element_type
, config_domain_name
);
2015 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2019 buffer_type_string
= get_buffer_type_string(session
->ust_session
->buffer_type
);
2020 if (!buffer_type_string
) {
2021 ERR("Unsupported buffer type.");
2022 ret
= LTTNG_ERR_INVALID
;
2026 ret
= config_writer_write_element_string(
2027 writer
, config_element_buffer_type
, buffer_type_string
);
2029 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2033 ret
= config_writer_open_element(writer
, config_element_channels
);
2035 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2040 lttng::urcu::read_lock_guard read_lock
;
2042 cds_lfht_for_each_entry (
2043 session
->ust_session
->domain_global
.channels
->ht
, &iter
.iter
, node
, node
) {
2044 ust_chan
= lttng::utils::container_of(node
, <t_ust_channel::node
);
2045 if (domain
== ust_chan
->domain
) {
2046 ret
= save_ust_channel(writer
, ust_chan
, session
->ust_session
);
2047 if (ret
!= LTTNG_OK
) {
2055 ret
= config_writer_close_element(writer
);
2057 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2061 if (domain
== LTTNG_DOMAIN_UST
) {
2062 ret
= config_writer_open_element(writer
, config_element_process_attr_trackers
);
2064 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2068 ret
= save_process_attr_trackers(writer
, session
, LTTNG_DOMAIN_UST
);
2069 if (ret
!= LTTNG_OK
) {
2074 ret
= config_writer_close_element(writer
);
2076 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2082 ret
= config_writer_close_element(writer
);
2084 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2093 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2094 static int save_domains(struct config_writer
*writer
, struct ltt_session
*session
)
2098 LTTNG_ASSERT(writer
);
2099 LTTNG_ASSERT(session
);
2101 if (!session
->kernel_session
&& !session
->ust_session
) {
2105 ret
= config_writer_open_element(writer
, config_element_domains
);
2107 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2111 if (session
->kernel_session
) {
2112 ret
= config_writer_open_element(writer
, config_element_domain
);
2114 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2118 ret
= save_kernel_session(writer
, session
);
2119 if (ret
!= LTTNG_OK
) {
2123 ret
= config_writer_open_element(writer
, config_element_process_attr_trackers
);
2125 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2129 ret
= save_process_attr_trackers(writer
, session
, LTTNG_DOMAIN_KERNEL
);
2130 if (ret
!= LTTNG_OK
) {
2135 ret
= config_writer_close_element(writer
);
2137 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2141 ret
= config_writer_close_element(writer
);
2143 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2148 if (session
->ust_session
) {
2149 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_UST
);
2150 if (ret
!= LTTNG_OK
) {
2154 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_JUL
);
2155 if (ret
!= LTTNG_OK
) {
2159 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_LOG4J
);
2160 if (ret
!= LTTNG_OK
) {
2164 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_PYTHON
);
2165 if (ret
!= LTTNG_OK
) {
2171 ret
= config_writer_close_element(writer
);
2173 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2182 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2183 static int save_consumer_output(struct config_writer
*writer
, struct consumer_output
*output
)
2187 LTTNG_ASSERT(writer
);
2188 LTTNG_ASSERT(output
);
2190 ret
= config_writer_open_element(writer
, config_element_consumer_output
);
2192 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2196 ret
= config_writer_write_element_bool(writer
, config_element_enabled
, output
->enabled
);
2198 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2202 ret
= config_writer_open_element(writer
, config_element_destination
);
2204 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2208 switch (output
->type
) {
2209 case CONSUMER_DST_LOCAL
:
2210 ret
= config_writer_write_element_string(
2211 writer
, config_element_path
, output
->dst
.session_root_path
);
2213 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2217 case CONSUMER_DST_NET
:
2221 uri
= calloc
<char>(PATH_MAX
);
2223 ret
= LTTNG_ERR_NOMEM
;
2227 ret
= config_writer_open_element(writer
, config_element_net_output
);
2229 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2230 goto end_net_output
;
2233 if (output
->dst
.net
.control_isset
&& output
->dst
.net
.data_isset
) {
2234 ret
= uri_to_str_url(&output
->dst
.net
.control
, uri
, PATH_MAX
);
2236 ret
= LTTNG_ERR_INVALID
;
2237 goto end_net_output
;
2240 ret
= config_writer_write_element_string(
2241 writer
, config_element_control_uri
, uri
);
2243 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2244 goto end_net_output
;
2247 ret
= uri_to_str_url(&output
->dst
.net
.data
, uri
, PATH_MAX
);
2249 ret
= LTTNG_ERR_INVALID
;
2250 goto end_net_output
;
2253 ret
= config_writer_write_element_string(
2254 writer
, config_element_data_uri
, uri
);
2256 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2257 goto end_net_output
;
2262 if (ret
!= LTTNG_OK
) {
2266 ret
= !output
->dst
.net
.control_isset
? LTTNG_ERR_URL_CTRL_MISS
:
2267 LTTNG_ERR_URL_DATA_MISS
;
2272 ret
= config_writer_close_element(writer
);
2274 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2280 ERR("Unsupported consumer output type.");
2281 ret
= LTTNG_ERR_INVALID
;
2286 ret
= config_writer_close_element(writer
);
2288 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2292 /* /consumer_output */
2293 ret
= config_writer_close_element(writer
);
2295 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2304 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2305 static int save_snapshot_outputs(struct config_writer
*writer
, struct snapshot
*snapshot
)
2308 struct lttng_ht_iter iter
;
2309 struct snapshot_output
*output
;
2311 LTTNG_ASSERT(writer
);
2312 LTTNG_ASSERT(snapshot
);
2314 ret
= config_writer_open_element(writer
, config_element_snapshot_outputs
);
2316 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2321 lttng::urcu::read_lock_guard read_lock
;
2323 cds_lfht_for_each_entry (snapshot
->output_ht
->ht
, &iter
.iter
, output
, node
.node
) {
2324 ret
= config_writer_open_element(writer
, config_element_output
);
2326 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2330 ret
= config_writer_write_element_string(
2331 writer
, config_element_name
, output
->name
);
2333 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2337 ret
= config_writer_write_element_unsigned_int(
2338 writer
, config_element_max_size
, output
->max_size
);
2340 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2344 ret
= save_consumer_output(writer
, output
->consumer
);
2345 if (ret
!= LTTNG_OK
) {
2350 ret
= config_writer_close_element(writer
);
2352 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2358 /* /snapshot_outputs */
2359 ret
= config_writer_close_element(writer
);
2361 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2372 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2373 static int save_session_output(struct config_writer
*writer
, struct ltt_session
*session
)
2377 LTTNG_ASSERT(writer
);
2378 LTTNG_ASSERT(session
);
2380 if ((session
->snapshot_mode
&& session
->snapshot
.nb_output
== 0) ||
2381 (!session
->snapshot_mode
&& !session
->consumer
)) {
2382 /* Session is in no output mode */
2387 ret
= config_writer_open_element(writer
, config_element_output
);
2389 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2393 if (session
->snapshot_mode
) {
2394 ret
= save_snapshot_outputs(writer
, &session
->snapshot
);
2395 if (ret
!= LTTNG_OK
) {
2399 if (session
->consumer
) {
2400 ret
= save_consumer_output(writer
, session
->consumer
);
2401 if (ret
!= LTTNG_OK
) {
2408 ret
= config_writer_close_element(writer
);
2410 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2418 static int save_session_rotation_schedule(struct config_writer
*writer
,
2419 enum lttng_rotation_schedule_type type
,
2423 const char *element_name
;
2424 const char *value_name
;
2427 case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
:
2428 element_name
= config_element_rotation_schedule_periodic
;
2429 value_name
= config_element_rotation_schedule_periodic_time_us
;
2431 case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
:
2432 element_name
= config_element_rotation_schedule_size_threshold
;
2433 value_name
= config_element_rotation_schedule_size_threshold_bytes
;
2440 ret
= config_writer_open_element(writer
, element_name
);
2445 ret
= config_writer_write_element_unsigned_int(writer
, value_name
, value
);
2450 /* Close schedule descriptor element. */
2451 ret
= config_writer_close_element(writer
);
2459 static int save_session_rotation_schedules(struct config_writer
*writer
,
2460 struct ltt_session
*session
)
2464 ret
= config_writer_open_element(writer
, config_element_rotation_schedules
);
2468 if (session
->rotate_timer_period
) {
2469 ret
= save_session_rotation_schedule(writer
,
2470 LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
,
2471 session
->rotate_timer_period
);
2473 goto close_schedules
;
2476 if (session
->rotate_size
) {
2477 ret
= save_session_rotation_schedule(
2478 writer
, LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
, session
->rotate_size
);
2480 goto close_schedules
;
2485 /* Close rotation schedules element. */
2486 ret
= config_writer_close_element(writer
);
2495 * Save the given session.
2497 * Return LTTNG_OK on success else a LTTNG_ERR* code.
2499 static int save_session(struct ltt_session
*session
,
2500 struct lttng_save_session_attr
*attr
,
2501 lttng_sock_cred
*creds
)
2504 char config_file_path
[LTTNG_PATH_MAX
];
2506 struct config_writer
*writer
= nullptr;
2507 size_t session_name_len
;
2508 const char *provided_path
;
2509 int file_open_flags
= O_CREAT
| O_WRONLY
| O_TRUNC
;
2511 LTTNG_ASSERT(session
);
2513 LTTNG_ASSERT(creds
);
2515 session_name_len
= strlen(session
->name
);
2516 memset(config_file_path
, 0, sizeof(config_file_path
));
2518 if (!session_access_ok(session
, LTTNG_SOCK_GET_UID_CRED(creds
)) || session
->destroyed
) {
2519 ret
= LTTNG_ERR_EPERM
;
2523 provided_path
= lttng_save_session_attr_get_output_url(attr
);
2524 if (provided_path
) {
2525 DBG3("Save session in provided path %s", provided_path
);
2526 len
= strlen(provided_path
);
2527 if (len
>= sizeof(config_file_path
)) {
2528 ret
= LTTNG_ERR_SET_URL
;
2531 strncpy(config_file_path
, provided_path
, sizeof(config_file_path
));
2534 char *home_dir
= utils_get_user_home_dir(LTTNG_SOCK_GET_UID_CRED(creds
));
2536 ret
= LTTNG_ERR_SET_URL
;
2540 ret_len
= snprintf(config_file_path
,
2541 sizeof(config_file_path
),
2542 DEFAULT_SESSION_HOME_CONFIGPATH
,
2546 PERROR("snprintf save session");
2547 ret
= LTTNG_ERR_SET_URL
;
2554 * Check the path fits in the config file path dst including the '/'
2555 * followed by trailing .lttng extension and the NULL terminated string.
2557 if ((len
+ session_name_len
+ 2 + sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
)) >
2558 sizeof(config_file_path
)) {
2559 ret
= LTTNG_ERR_SET_URL
;
2563 ret
= run_as_mkdir_recursive(config_file_path
,
2565 LTTNG_SOCK_GET_UID_CRED(creds
),
2566 LTTNG_SOCK_GET_GID_CRED(creds
));
2568 ret
= LTTNG_ERR_SET_URL
;
2573 * At this point, we know that everything fits in the buffer. Validation
2574 * was done just above.
2576 config_file_path
[len
++] = '/';
2577 strncpy(config_file_path
+ len
, session
->name
, sizeof(config_file_path
) - len
);
2578 len
+= session_name_len
;
2579 strcpy(config_file_path
+ len
, DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
2580 len
+= sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
2581 config_file_path
[len
] = '\0';
2583 if (!attr
->overwrite
) {
2584 file_open_flags
|= O_EXCL
;
2587 fd
= run_as_open(config_file_path
,
2589 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
,
2590 LTTNG_SOCK_GET_UID_CRED(creds
),
2591 LTTNG_SOCK_GET_GID_CRED(creds
));
2593 PERROR("Could not create configuration file");
2596 ret
= LTTNG_ERR_SAVE_FILE_EXIST
;
2599 ret
= LTTNG_ERR_EPERM
;
2602 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2608 writer
= config_writer_create(fd
, 1);
2610 ret
= LTTNG_ERR_NOMEM
;
2614 ret
= config_writer_open_element(writer
, config_element_sessions
);
2616 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2620 ret
= config_writer_open_element(writer
, config_element_session
);
2622 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2626 ret
= config_writer_write_element_string(writer
, config_element_name
, session
->name
);
2628 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2632 if (session
->shm_path
[0] != '\0') {
2633 ret
= config_writer_write_element_string(
2634 writer
, config_element_shared_memory_path
, session
->shm_path
);
2636 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2641 ret
= save_domains(writer
, session
);
2642 if (ret
!= LTTNG_OK
) {
2646 ret
= config_writer_write_element_bool(writer
, config_element_started
, session
->active
);
2648 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2652 if (session
->snapshot_mode
|| session
->live_timer
|| session
->rotate_timer_period
||
2653 session
->rotate_size
) {
2654 ret
= config_writer_open_element(writer
, config_element_attributes
);
2656 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2660 if (session
->snapshot_mode
) {
2661 ret
= config_writer_write_element_bool(
2662 writer
, config_element_snapshot_mode
, 1);
2664 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2667 } else if (session
->live_timer
) {
2668 ret
= config_writer_write_element_unsigned_int(
2669 writer
, config_element_live_timer_interval
, session
->live_timer
);
2671 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2675 if (session
->rotate_timer_period
|| session
->rotate_size
) {
2676 ret
= save_session_rotation_schedules(writer
, session
);
2678 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2684 ret
= config_writer_close_element(writer
);
2686 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2691 ret
= save_session_output(writer
, session
);
2692 if (ret
!= LTTNG_OK
) {
2697 ret
= config_writer_close_element(writer
);
2699 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2704 ret
= config_writer_close_element(writer
);
2706 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2712 if (writer
&& config_writer_destroy(writer
)) {
2713 /* Preserve the original error code */
2714 ret
= ret
!= LTTNG_OK
? ret
: LTTNG_ERR_SAVE_IO_FAIL
;
2716 if (ret
!= LTTNG_OK
) {
2717 /* Delete file in case of error */
2718 if ((fd
>= 0) && unlink(config_file_path
)) {
2719 PERROR("Unlinking XML session configuration.");
2726 closeret
= close(fd
);
2728 PERROR("Closing XML session configuration");
2735 int cmd_save_sessions(struct lttng_save_session_attr
*attr
, lttng_sock_cred
*creds
)
2738 const char *session_name
;
2739 struct ltt_session
*session
;
2741 session_lock_list();
2743 session_name
= lttng_save_session_attr_get_session_name(attr
);
2745 session
= session_find_by_name(session_name
);
2747 ret
= LTTNG_ERR_SESS_NOT_FOUND
;
2751 session_lock(session
);
2752 ret
= save_session(session
, attr
, creds
);
2753 session_unlock(session
);
2754 session_put(session
);
2755 if (ret
!= LTTNG_OK
) {
2759 struct ltt_session_list
*list
= session_get_list();
2761 cds_list_for_each_entry (session
, &list
->head
, list
) {
2762 if (!session_get(session
)) {
2765 session_lock(session
);
2766 ret
= save_session(session
, attr
, creds
);
2767 session_unlock(session
);
2768 session_put(session
);
2769 /* Don't abort if we don't have the required permissions. */
2770 if (ret
!= LTTNG_OK
&& ret
!= LTTNG_ERR_EPERM
) {
2778 session_unlock_list();