2 * Copyright (C) 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * SPDX-License-Identifier: GPL-2.0-only
12 #include <urcu/uatomic.h>
15 #include <common/defaults.h>
16 #include <common/error.h>
17 #include <common/config/session-config.h>
18 #include <common/utils.h>
19 #include <common/runas.h>
20 #include <lttng/save-internal.h>
25 #include "lttng-syscall.h"
26 #include "trace-ust.h"
29 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
31 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(writer
,
46 config_element_subbuf_size
, attr
->subbuf_size
);
48 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
52 ret
= config_writer_write_element_unsigned_int(writer
,
53 config_element_num_subbuf
,
56 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
60 ret
= config_writer_write_element_unsigned_int(writer
,
61 config_element_switch_timer_interval
,
62 attr
->switch_timer_interval
);
64 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
68 ret
= config_writer_write_element_unsigned_int(writer
,
69 config_element_read_timer_interval
,
70 attr
->read_timer_interval
);
72 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
76 ret
= config_writer_write_element_string(writer
,
77 config_element_output_type
,
78 attr
->output
== LTTNG_EVENT_SPLICE
?
79 config_output_type_splice
: config_output_type_mmap
);
81 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
85 ret
= config_writer_write_element_unsigned_int(writer
,
86 config_element_tracefile_size
, attr
->tracefile_size
);
88 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
92 ret
= config_writer_write_element_unsigned_int(writer
,
93 config_element_tracefile_count
,
94 attr
->tracefile_count
);
96 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
100 ret
= config_writer_write_element_unsigned_int(writer
,
101 config_element_live_timer_interval
,
102 attr
->live_timer_interval
);
104 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
108 if (attr
->extended
.ptr
) {
109 struct lttng_channel_extended
*ext
= NULL
;
111 ext
= (struct lttng_channel_extended
*) attr
->extended
.ptr
;
112 ret
= config_writer_write_element_unsigned_int(writer
,
113 config_element_monitor_timer_interval
,
114 ext
->monitor_timer_interval
);
116 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
120 ret
= config_writer_write_element_signed_int(writer
,
121 config_element_blocking_timeout
,
122 ext
->blocking_timeout
);
124 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
135 int save_map_attributes(struct config_writer
*writer
,
136 struct lttng_map
*map
)
141 ret
= config_writer_write_element_unsigned_int(writer
,
142 config_element_bitness
,
143 lttng_map_get_bitness(map
)==LTTNG_MAP_BITNESS_32BITS
? 32: 64);
145 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
149 assert( lttng_map_get_boundary_policy(map
) == LTTNG_MAP_BOUNDARY_POLICY_OVERFLOW
);
150 ret
= config_writer_write_element_string(writer
,
151 config_element_boundary_policy
, config_boundary_policy_overflow
);
153 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
157 ret
= config_writer_write_element_bool(writer
,
158 config_element_coalesce_hits
,
159 lttng_map_get_coalesce_hits(map
));
161 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
165 ret
= config_writer_open_element(writer
,
166 config_element_dimensions
);
168 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
171 for (i
= 0; i
< lttng_map_get_dimension_count(map
); i
++) {
172 enum lttng_map_status map_status
;
175 ret
= config_writer_open_element(writer
,
176 config_element_dimension
);
178 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
182 map_status
= lttng_map_get_dimension_length(map
, i
, &dim_len
);
183 if (map_status
!= LTTNG_MAP_STATUS_OK
) {
184 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
188 ret
= config_writer_write_element_unsigned_int(writer
,
189 config_element_dimension_size
, dim_len
);
191 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
196 ret
= config_writer_close_element(writer
);
198 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
204 ret
= config_writer_close_element(writer
);
206 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
215 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
217 int save_ust_channel_attributes(struct config_writer
*writer
,
218 struct lttng_ust_channel_attr
*attr
)
221 struct ltt_ust_channel
*channel
= NULL
;
223 ret
= config_writer_write_element_string(writer
,
224 config_element_overwrite_mode
,
225 attr
->overwrite
? config_overwrite_mode_overwrite
:
226 config_overwrite_mode_discard
);
228 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
232 ret
= config_writer_write_element_unsigned_int(writer
,
233 config_element_subbuf_size
, attr
->subbuf_size
);
235 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
239 ret
= config_writer_write_element_unsigned_int(writer
,
240 config_element_num_subbuf
,
243 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
247 ret
= config_writer_write_element_unsigned_int(writer
,
248 config_element_switch_timer_interval
,
249 attr
->switch_timer_interval
);
251 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
255 ret
= config_writer_write_element_unsigned_int(writer
,
256 config_element_read_timer_interval
,
257 attr
->read_timer_interval
);
259 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
263 ret
= config_writer_write_element_string(writer
,
264 config_element_output_type
,
265 attr
->output
== LTTNG_UST_MMAP
?
266 config_output_type_mmap
: config_output_type_splice
);
268 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
272 ret
= config_writer_write_element_signed_int(writer
,
273 config_element_blocking_timeout
,
274 attr
->u
.s
.blocking_timeout
);
276 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
281 * Fetch the monitor timer which is located in the parent of
282 * lttng_ust_channel_attr
284 channel
= caa_container_of(attr
, struct ltt_ust_channel
, attr
);
285 ret
= config_writer_write_element_unsigned_int(writer
,
286 config_element_monitor_timer_interval
,
287 channel
->monitor_timer_interval
);
289 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
299 const char *get_kernel_instrumentation_string(
300 enum lttng_kernel_instrumentation instrumentation
)
302 const char *instrumentation_string
;
304 switch (instrumentation
) {
305 case LTTNG_KERNEL_ALL
:
306 instrumentation_string
= config_event_type_all
;
308 case LTTNG_KERNEL_TRACEPOINT
:
309 instrumentation_string
= config_event_type_tracepoint
;
311 case LTTNG_KERNEL_KPROBE
:
312 instrumentation_string
= config_event_type_probe
;
314 case LTTNG_KERNEL_UPROBE
:
315 instrumentation_string
= config_event_type_userspace_probe
;
317 case LTTNG_KERNEL_FUNCTION
:
318 instrumentation_string
= config_event_type_function_entry
;
320 case LTTNG_KERNEL_KRETPROBE
:
321 instrumentation_string
= config_event_type_function
;
323 case LTTNG_KERNEL_NOOP
:
324 instrumentation_string
= config_event_type_noop
;
326 case LTTNG_KERNEL_SYSCALL
:
327 instrumentation_string
= config_event_type_syscall
;
330 instrumentation_string
= NULL
;
333 return instrumentation_string
;
337 const char *get_kernel_context_type_string(
338 enum lttng_kernel_context_type context_type
)
340 const char *context_type_string
;
342 switch (context_type
) {
343 case LTTNG_KERNEL_CONTEXT_PID
:
344 context_type_string
= config_event_context_pid
;
346 case LTTNG_KERNEL_CONTEXT_PROCNAME
:
347 context_type_string
= config_event_context_procname
;
349 case LTTNG_KERNEL_CONTEXT_PRIO
:
350 context_type_string
= config_event_context_prio
;
352 case LTTNG_KERNEL_CONTEXT_NICE
:
353 context_type_string
= config_event_context_nice
;
355 case LTTNG_KERNEL_CONTEXT_VPID
:
356 context_type_string
= config_event_context_vpid
;
358 case LTTNG_KERNEL_CONTEXT_TID
:
359 context_type_string
= config_event_context_tid
;
361 case LTTNG_KERNEL_CONTEXT_VTID
:
362 context_type_string
= config_event_context_vtid
;
364 case LTTNG_KERNEL_CONTEXT_PPID
:
365 context_type_string
= config_event_context_ppid
;
367 case LTTNG_KERNEL_CONTEXT_VPPID
:
368 context_type_string
= config_event_context_vppid
;
370 case LTTNG_KERNEL_CONTEXT_HOSTNAME
:
371 context_type_string
= config_event_context_hostname
;
373 case LTTNG_KERNEL_CONTEXT_INTERRUPTIBLE
:
374 context_type_string
= config_event_context_interruptible
;
376 case LTTNG_KERNEL_CONTEXT_PREEMPTIBLE
:
377 context_type_string
= config_event_context_preemptible
;
379 case LTTNG_KERNEL_CONTEXT_NEED_RESCHEDULE
:
380 context_type_string
= config_event_context_need_reschedule
;
382 case LTTNG_KERNEL_CONTEXT_MIGRATABLE
:
383 context_type_string
= config_event_context_migratable
;
385 case LTTNG_KERNEL_CONTEXT_CALLSTACK_USER
:
386 context_type_string
= config_event_context_callstack_user
;
388 case LTTNG_KERNEL_CONTEXT_CALLSTACK_KERNEL
:
389 context_type_string
= config_event_context_callstack_kernel
;
391 case LTTNG_KERNEL_CONTEXT_CGROUP_NS
:
392 context_type_string
= config_event_context_cgroup_ns
;
394 case LTTNG_KERNEL_CONTEXT_IPC_NS
:
395 context_type_string
= config_event_context_ipc_ns
;
397 case LTTNG_KERNEL_CONTEXT_MNT_NS
:
398 context_type_string
= config_event_context_mnt_ns
;
400 case LTTNG_KERNEL_CONTEXT_NET_NS
:
401 context_type_string
= config_event_context_net_ns
;
403 case LTTNG_KERNEL_CONTEXT_PID_NS
:
404 context_type_string
= config_event_context_pid_ns
;
406 case LTTNG_KERNEL_CONTEXT_TIME_NS
:
407 context_type_string
= config_event_context_time_ns
;
409 case LTTNG_KERNEL_CONTEXT_USER_NS
:
410 context_type_string
= config_event_context_user_ns
;
412 case LTTNG_KERNEL_CONTEXT_UTS_NS
:
413 context_type_string
= config_event_context_uts_ns
;
415 case LTTNG_KERNEL_CONTEXT_UID
:
416 context_type_string
= config_event_context_uid
;
418 case LTTNG_KERNEL_CONTEXT_EUID
:
419 context_type_string
= config_event_context_euid
;
421 case LTTNG_KERNEL_CONTEXT_SUID
:
422 context_type_string
= config_event_context_suid
;
424 case LTTNG_KERNEL_CONTEXT_GID
:
425 context_type_string
= config_event_context_gid
;
427 case LTTNG_KERNEL_CONTEXT_EGID
:
428 context_type_string
= config_event_context_egid
;
430 case LTTNG_KERNEL_CONTEXT_SGID
:
431 context_type_string
= config_event_context_sgid
;
433 case LTTNG_KERNEL_CONTEXT_VUID
:
434 context_type_string
= config_event_context_vuid
;
436 case LTTNG_KERNEL_CONTEXT_VEUID
:
437 context_type_string
= config_event_context_veuid
;
439 case LTTNG_KERNEL_CONTEXT_VSUID
:
440 context_type_string
= config_event_context_vsuid
;
442 case LTTNG_KERNEL_CONTEXT_VGID
:
443 context_type_string
= config_event_context_vgid
;
445 case LTTNG_KERNEL_CONTEXT_VEGID
:
446 context_type_string
= config_event_context_vegid
;
448 case LTTNG_KERNEL_CONTEXT_VSGID
:
449 context_type_string
= config_event_context_vsgid
;
452 context_type_string
= NULL
;
455 return context_type_string
;
459 const char *get_ust_context_type_string(
460 enum lttng_ust_context_type context_type
)
462 const char *context_type_string
;
464 switch (context_type
) {
465 case LTTNG_UST_CONTEXT_PROCNAME
:
466 context_type_string
= config_event_context_procname
;
468 case LTTNG_UST_CONTEXT_VPID
:
469 context_type_string
= config_event_context_vpid
;
471 case LTTNG_UST_CONTEXT_VTID
:
472 context_type_string
= config_event_context_vtid
;
474 case LTTNG_UST_CONTEXT_IP
:
475 context_type_string
= config_event_context_ip
;
477 case LTTNG_UST_CONTEXT_PTHREAD_ID
:
478 context_type_string
= config_event_context_pthread_id
;
480 case LTTNG_UST_CONTEXT_APP_CONTEXT
:
481 context_type_string
= config_event_context_app
;
483 case LTTNG_UST_CONTEXT_CGROUP_NS
:
484 context_type_string
= config_event_context_cgroup_ns
;
486 case LTTNG_UST_CONTEXT_IPC_NS
:
487 context_type_string
= config_event_context_ipc_ns
;
489 case LTTNG_UST_CONTEXT_MNT_NS
:
490 context_type_string
= config_event_context_mnt_ns
;
492 case LTTNG_UST_CONTEXT_NET_NS
:
493 context_type_string
= config_event_context_net_ns
;
495 case LTTNG_UST_CONTEXT_TIME_NS
:
496 context_type_string
= config_event_context_time_ns
;
498 case LTTNG_UST_CONTEXT_PID_NS
:
499 context_type_string
= config_event_context_pid_ns
;
501 case LTTNG_UST_CONTEXT_USER_NS
:
502 context_type_string
= config_event_context_user_ns
;
504 case LTTNG_UST_CONTEXT_UTS_NS
:
505 context_type_string
= config_event_context_uts_ns
;
507 case LTTNG_UST_CONTEXT_VUID
:
508 context_type_string
= config_event_context_vuid
;
510 case LTTNG_UST_CONTEXT_VEUID
:
511 context_type_string
= config_event_context_veuid
;
513 case LTTNG_UST_CONTEXT_VSUID
:
514 context_type_string
= config_event_context_vsuid
;
516 case LTTNG_UST_CONTEXT_VGID
:
517 context_type_string
= config_event_context_vgid
;
519 case LTTNG_UST_CONTEXT_VEGID
:
520 context_type_string
= config_event_context_vegid
;
522 case LTTNG_UST_CONTEXT_VSGID
:
523 context_type_string
= config_event_context_vsgid
;
525 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
:
527 * Error, should not be stored in the XML, perf contexts
528 * are stored as a node of type event_perf_context_type.
531 context_type_string
= NULL
;
535 return context_type_string
;
539 const char *get_buffer_type_string(
540 enum lttng_buffer_type buffer_type
)
542 const char *buffer_type_string
;
544 switch (buffer_type
) {
545 case LTTNG_BUFFER_PER_PID
:
546 buffer_type_string
= config_buffer_type_per_pid
;
548 case LTTNG_BUFFER_PER_UID
:
549 buffer_type_string
= config_buffer_type_per_uid
;
551 case LTTNG_BUFFER_GLOBAL
:
552 buffer_type_string
= config_buffer_type_global
;
555 buffer_type_string
= NULL
;
558 return buffer_type_string
;
562 const char *get_loglevel_type_string(
563 enum lttng_ust_loglevel_type loglevel_type
)
565 const char *loglevel_type_string
;
567 switch (loglevel_type
) {
568 case LTTNG_UST_LOGLEVEL_ALL
:
569 loglevel_type_string
= config_loglevel_type_all
;
571 case LTTNG_UST_LOGLEVEL_RANGE
:
572 loglevel_type_string
= config_loglevel_type_range
;
574 case LTTNG_UST_LOGLEVEL_SINGLE
:
575 loglevel_type_string
= config_loglevel_type_single
;
578 loglevel_type_string
= NULL
;
581 return loglevel_type_string
;
584 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
586 int save_kernel_function_event(struct config_writer
*writer
,
587 struct ltt_kernel_event
*event
)
591 ret
= config_writer_open_element(writer
, config_element_function_attributes
);
593 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
597 ret
= config_writer_write_element_string(writer
, config_element_name
,
598 event
->event
->u
.ftrace
.symbol_name
);
600 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
604 /* /function attributes */
605 ret
= config_writer_close_element(writer
);
607 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
615 int save_kernel_kprobe_event(struct config_writer
*writer
,
616 struct ltt_kernel_event
*event
)
619 const char *symbol_name
;
623 switch (event
->event
->instrumentation
) {
624 case LTTNG_KERNEL_KPROBE
:
626 * Comments in lttng-kernel.h mention that
627 * either addr or symbol_name are set, not both.
629 addr
= event
->event
->u
.kprobe
.addr
;
630 offset
= event
->event
->u
.kprobe
.offset
;
631 symbol_name
= addr
? NULL
: event
->event
->u
.kprobe
.symbol_name
;
633 case LTTNG_KERNEL_KRETPROBE
:
634 addr
= event
->event
->u
.kretprobe
.addr
;
635 offset
= event
->event
->u
.kretprobe
.offset
;
636 symbol_name
= addr
? NULL
: event
->event
->u
.kretprobe
.symbol_name
;
640 ERR("Unsupported kernel instrumentation type.");
641 ret
= LTTNG_ERR_INVALID
;
645 ret
= config_writer_open_element(writer
, config_element_probe_attributes
);
647 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
652 ret
= config_writer_write_element_unsigned_int( writer
,
653 config_element_address
, addr
);
655 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
658 } else if (symbol_name
) {
659 ret
= config_writer_write_element_string(writer
,
660 config_element_symbol_name
, symbol_name
);
662 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
665 /* If the offset is non-zero, write it.*/
667 ret
= config_writer_write_element_unsigned_int(writer
,
668 config_element_offset
, offset
);
670 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
676 * This really should not happen as we are either setting the
677 * address or the symbol above.
679 ERR("Invalid probe/function description.");
680 ret
= LTTNG_ERR_INVALID
;
685 ret
= config_writer_close_element(writer
);
687 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
695 * Save the userspace probe tracepoint event associated with the event to the
699 int save_kernel_userspace_probe_tracepoint_event(struct config_writer
*writer
,
700 struct ltt_kernel_event
*event
)
703 const char *probe_name
, *provider_name
, *binary_path
;
704 const struct lttng_userspace_probe_location
*userspace_probe_location
;
705 const struct lttng_userspace_probe_location_lookup_method
*lookup_method
;
706 enum lttng_userspace_probe_location_lookup_method_type lookup_type
;
708 /* Get userspace probe location from the event. */
709 userspace_probe_location
= event
->userspace_probe_location
;
710 if (!userspace_probe_location
) {
711 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
715 /* Get lookup method and lookup method type. */
716 lookup_method
= lttng_userspace_probe_location_get_lookup_method(userspace_probe_location
);
717 if (!lookup_method
) {
718 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
722 lookup_type
= lttng_userspace_probe_location_lookup_method_get_type(lookup_method
);
724 /* Get the binary path, probe name and provider name. */
726 lttng_userspace_probe_location_tracepoint_get_binary_path(
727 userspace_probe_location
);
729 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
734 lttng_userspace_probe_location_tracepoint_get_probe_name(
735 userspace_probe_location
);
737 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
742 lttng_userspace_probe_location_tracepoint_get_provider_name(
743 userspace_probe_location
);
744 if (!provider_name
) {
745 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
749 /* Open a userspace probe tracepoint attribute. */
750 ret
= config_writer_open_element(writer
, config_element_userspace_probe_tracepoint_attributes
);
752 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
756 switch (lookup_type
) {
757 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT
:
758 ret
= config_writer_write_element_string(writer
,
759 config_element_userspace_probe_lookup
,
760 config_element_userspace_probe_lookup_tracepoint_sdt
);
762 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
767 ERR("Unsupported kernel userspace probe tracepoint lookup method.");
768 ret
= LTTNG_ERR_INVALID
;
772 /* Write the binary path, provider name and the probe name. */
773 ret
= config_writer_write_element_string(writer
,
774 config_element_userspace_probe_location_binary_path
,
777 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
781 ret
= config_writer_write_element_string(writer
,
782 config_element_userspace_probe_tracepoint_location_provider_name
,
785 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
789 ret
= config_writer_write_element_string(writer
,
790 config_element_userspace_probe_tracepoint_location_probe_name
,
793 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
797 /* Close the userspace probe tracepoint attribute. */
798 ret
= config_writer_close_element(writer
);
800 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
809 * Save the userspace probe function event associated with the event to the
813 int save_kernel_userspace_probe_function_event(struct config_writer
*writer
,
814 struct ltt_kernel_event
*event
)
817 const char *function_name
, *binary_path
;
818 const struct lttng_userspace_probe_location
*userspace_probe_location
;
819 const struct lttng_userspace_probe_location_lookup_method
*lookup_method
;
820 enum lttng_userspace_probe_location_lookup_method_type lookup_type
;
822 /* Get userspace probe location from the event. */
823 userspace_probe_location
= event
->userspace_probe_location
;
824 if (!userspace_probe_location
) {
825 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
829 /* Get lookup method and lookup method type. */
830 lookup_method
= lttng_userspace_probe_location_get_lookup_method(
831 userspace_probe_location
);
832 if (!lookup_method
) {
833 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
837 /* Get the binary path and the function name. */
839 lttng_userspace_probe_location_function_get_binary_path(
840 userspace_probe_location
);
842 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
847 lttng_userspace_probe_location_function_get_function_name(
848 userspace_probe_location
);
849 if (!function_name
) {
850 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
854 /* Open a userspace probe function attribute. */
855 ret
= config_writer_open_element(writer
,
856 config_element_userspace_probe_function_attributes
);
858 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
862 lookup_type
= lttng_userspace_probe_location_lookup_method_get_type(lookup_method
);
863 switch (lookup_type
) {
864 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF
:
865 ret
= config_writer_write_element_string(writer
,
866 config_element_userspace_probe_lookup
,
867 config_element_userspace_probe_lookup_function_elf
);
869 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
873 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT
:
874 ret
= config_writer_write_element_string(writer
,
875 config_element_userspace_probe_lookup
,
876 config_element_userspace_probe_lookup_function_default
);
878 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
883 ERR("Unsupported kernel userspace probe function lookup method.");
884 ret
= LTTNG_ERR_INVALID
;
888 /* Write the binary path and the function name. */
889 ret
= config_writer_write_element_string(writer
,
890 config_element_userspace_probe_location_binary_path
,
893 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
897 ret
= config_writer_write_element_string(writer
,
898 config_element_userspace_probe_function_location_function_name
,
901 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
905 /* Close the userspace probe function attribute. */
906 ret
= config_writer_close_element(writer
);
908 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
917 int save_kernel_userspace_probe_event(struct config_writer
*writer
,
918 struct ltt_kernel_event
*event
)
921 struct lttng_userspace_probe_location
*userspace_probe_location
;
923 /* Get userspace probe location from the event. */
924 userspace_probe_location
= event
->userspace_probe_location
;
925 if (!userspace_probe_location
) {
926 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
930 switch(lttng_userspace_probe_location_get_type(userspace_probe_location
)) {
931 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION
:
933 ret
= save_kernel_userspace_probe_function_event(writer
, event
);
935 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
940 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT
:
942 ret
= save_kernel_userspace_probe_tracepoint_event(writer
, event
);
944 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
949 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_UNKNOWN
:
951 ERR("Unsupported kernel userspace probe location type.");
952 ret
= LTTNG_ERR_INVALID
;
961 int save_kernel_event(struct config_writer
*writer
,
962 struct ltt_kernel_event
*event
)
965 const char *instrumentation_type
;
967 ret
= config_writer_open_element(writer
, config_element_event
);
969 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
973 if (event
->event
->name
[0]) {
974 ret
= config_writer_write_element_string(writer
,
975 config_element_name
, event
->event
->name
);
977 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
982 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
985 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
989 instrumentation_type
= get_kernel_instrumentation_string(
990 event
->event
->instrumentation
);
991 if (!instrumentation_type
) {
992 ret
= LTTNG_ERR_INVALID
;
996 ret
= config_writer_write_element_string(writer
, config_element_type
,
997 instrumentation_type
);
999 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1003 if (event
->filter_expression
) {
1004 ret
= config_writer_write_element_string(writer
,
1005 config_element_filter
,
1006 event
->filter_expression
);
1008 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1013 if (event
->event
->instrumentation
== LTTNG_KERNEL_FUNCTION
||
1014 event
->event
->instrumentation
== LTTNG_KERNEL_KPROBE
||
1015 event
->event
->instrumentation
== LTTNG_KERNEL_UPROBE
||
1016 event
->event
->instrumentation
== LTTNG_KERNEL_KRETPROBE
) {
1018 ret
= config_writer_open_element(writer
,
1019 config_element_attributes
);
1021 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1025 switch (event
->event
->instrumentation
) {
1026 case LTTNG_KERNEL_SYSCALL
:
1027 case LTTNG_KERNEL_FUNCTION
:
1028 ret
= save_kernel_function_event(writer
, event
);
1033 case LTTNG_KERNEL_KPROBE
:
1034 case LTTNG_KERNEL_KRETPROBE
:
1035 ret
= save_kernel_kprobe_event(writer
, event
);
1040 case LTTNG_KERNEL_UPROBE
:
1041 ret
= save_kernel_userspace_probe_event(writer
, event
);
1047 ERR("Unsupported kernel instrumentation type.");
1048 ret
= LTTNG_ERR_INVALID
;
1053 ret
= config_writer_close_element(writer
);
1055 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1061 ret
= config_writer_close_element(writer
);
1063 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1072 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1074 int save_kernel_events(struct config_writer
*writer
,
1075 struct ltt_kernel_channel
*kchan
)
1078 struct ltt_kernel_event
*event
;
1080 ret
= config_writer_open_element(writer
, config_element_events
);
1082 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1086 cds_list_for_each_entry(event
, &kchan
->events_list
.head
, list
) {
1087 ret
= save_kernel_event(writer
, event
);
1088 if (ret
!= LTTNG_OK
) {
1094 ret
= config_writer_close_element(writer
);
1096 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1105 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1107 int save_ust_event(struct config_writer
*writer
,
1108 struct ltt_ust_event
*event
)
1111 const char *loglevel_type_string
;
1113 ret
= config_writer_open_element(writer
, config_element_event
);
1115 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1119 if (event
->attr
.name
[0]) {
1120 ret
= config_writer_write_element_string(writer
,
1121 config_element_name
, event
->attr
.name
);
1123 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1128 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1131 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1135 if (event
->attr
.instrumentation
!= LTTNG_UST_TRACEPOINT
) {
1136 ERR("Unsupported UST instrumentation type.");
1137 ret
= LTTNG_ERR_INVALID
;
1140 ret
= config_writer_write_element_string(writer
, config_element_type
,
1141 config_event_type_tracepoint
);
1143 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1147 loglevel_type_string
= get_loglevel_type_string(
1148 event
->attr
.loglevel_type
);
1149 if (!loglevel_type_string
) {
1150 ERR("Unsupported UST loglevel type.");
1151 ret
= LTTNG_ERR_INVALID
;
1155 ret
= config_writer_write_element_string(writer
,
1156 config_element_loglevel_type
, loglevel_type_string
);
1158 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1162 /* The log level is irrelevant if no "filtering" is enabled */
1163 if (event
->attr
.loglevel_type
!= LTTNG_UST_LOGLEVEL_ALL
) {
1164 ret
= config_writer_write_element_signed_int(writer
,
1165 config_element_loglevel
, event
->attr
.loglevel
);
1167 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1172 if (event
->filter_expression
) {
1173 ret
= config_writer_write_element_string(writer
,
1174 config_element_filter
, event
->filter_expression
);
1176 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1181 if (event
->exclusion
&& event
->exclusion
->count
) {
1184 ret
= config_writer_open_element(writer
,
1185 config_element_exclusions
);
1187 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1191 for (i
= 0; i
< event
->exclusion
->count
; i
++) {
1192 ret
= config_writer_write_element_string(writer
,
1193 config_element_exclusion
,
1194 LTTNG_EVENT_EXCLUSION_NAME_AT(
1195 event
->exclusion
, i
));
1197 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1203 ret
= config_writer_close_element(writer
);
1205 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1211 ret
= config_writer_close_element(writer
);
1213 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1222 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1224 int save_ust_events(struct config_writer
*writer
,
1225 struct lttng_ht
*events
)
1228 struct ltt_ust_event
*event
;
1229 struct lttng_ht_node_str
*node
;
1230 struct lttng_ht_iter iter
;
1232 ret
= config_writer_open_element(writer
, config_element_events
);
1234 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1239 cds_lfht_for_each_entry(events
->ht
, &iter
.iter
, node
, node
) {
1240 event
= caa_container_of(node
, struct ltt_ust_event
, node
);
1242 if (event
->internal
) {
1243 /* Internal events must not be exposed to clients */
1246 ret
= save_ust_event(writer
, event
);
1247 if (ret
!= LTTNG_OK
) {
1255 ret
= config_writer_close_element(writer
);
1257 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1266 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1268 int init_ust_event_from_agent_event(struct ltt_ust_event
*ust_event
,
1269 struct agent_event
*agent_event
)
1272 enum lttng_ust_loglevel_type ust_loglevel_type
;
1274 ust_event
->enabled
= AGENT_EVENT_IS_ENABLED(agent_event
);
1275 ust_event
->attr
.instrumentation
= LTTNG_UST_TRACEPOINT
;
1276 if (lttng_strncpy(ust_event
->attr
.name
, agent_event
->name
,
1277 LTTNG_SYMBOL_NAME_LEN
)) {
1278 ret
= LTTNG_ERR_INVALID
;
1281 switch (agent_event
->loglevel_type
) {
1282 case LTTNG_EVENT_LOGLEVEL_ALL
:
1283 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_ALL
;
1285 case LTTNG_EVENT_LOGLEVEL_SINGLE
:
1286 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_SINGLE
;
1288 case LTTNG_EVENT_LOGLEVEL_RANGE
:
1289 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_RANGE
;
1292 ERR("Invalid agent_event loglevel_type.");
1293 ret
= LTTNG_ERR_INVALID
;
1297 ust_event
->attr
.loglevel_type
= ust_loglevel_type
;
1298 ust_event
->attr
.loglevel
= agent_event
->loglevel_value
;
1299 ust_event
->filter_expression
= agent_event
->filter_expression
;
1300 ust_event
->exclusion
= agent_event
->exclusion
;
1307 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1309 int save_agent_events(struct config_writer
*writer
,
1310 struct agent
*agent
)
1313 struct lttng_ht_iter iter
;
1314 struct lttng_ht_node_str
*node
;
1316 ret
= config_writer_open_element(writer
, config_element_events
);
1318 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1323 cds_lfht_for_each_entry(agent
->events
->ht
, &iter
.iter
, node
, node
) {
1325 struct agent_event
*agent_event
;
1326 struct ltt_ust_event fake_event
;
1328 memset(&fake_event
, 0, sizeof(fake_event
));
1329 agent_event
= caa_container_of(node
, struct agent_event
, node
);
1332 * Initialize a fake ust event to reuse the same serialization
1333 * function since UST and agent events contain the same info
1334 * (and one could wonder why they don't reuse the same
1337 ret
= init_ust_event_from_agent_event(&fake_event
, agent_event
);
1338 if (ret
!= LTTNG_OK
) {
1342 ret
= save_ust_event(writer
, &fake_event
);
1343 if (ret
!= LTTNG_OK
) {
1351 ret
= config_writer_close_element(writer
);
1353 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1362 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1364 int save_kernel_context(struct config_writer
*writer
,
1365 struct lttng_kernel_context
*ctx
)
1373 ret
= config_writer_open_element(writer
, config_element_context
);
1375 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1379 if (ctx
->ctx
== LTTNG_KERNEL_CONTEXT_PERF_CPU_COUNTER
) {
1380 ret
= config_writer_open_element(writer
,
1381 config_element_context_perf
);
1383 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1387 ret
= config_writer_write_element_unsigned_int(writer
,
1388 config_element_type
, ctx
->u
.perf_counter
.type
);
1390 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1394 ret
= config_writer_write_element_unsigned_int(writer
,
1395 config_element_config
, ctx
->u
.perf_counter
.config
);
1397 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1401 ret
= config_writer_write_element_string(writer
,
1402 config_element_name
, ctx
->u
.perf_counter
.name
);
1404 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1409 ret
= config_writer_close_element(writer
);
1411 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1415 const char *context_type_string
=
1416 get_kernel_context_type_string(ctx
->ctx
);
1418 if (!context_type_string
) {
1419 ERR("Unsupported kernel context type.");
1420 ret
= LTTNG_ERR_INVALID
;
1424 ret
= config_writer_write_element_string(writer
,
1425 config_element_type
, context_type_string
);
1427 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1433 ret
= config_writer_close_element(writer
);
1435 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1444 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1446 int save_kernel_contexts(struct config_writer
*writer
,
1447 struct ltt_kernel_channel
*kchan
)
1450 struct ltt_kernel_context
*ctx
;
1452 if (cds_list_empty(&kchan
->ctx_list
)) {
1457 ret
= config_writer_open_element(writer
, config_element_contexts
);
1459 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1463 cds_list_for_each_entry(ctx
, &kchan
->ctx_list
, list
) {
1464 ret
= save_kernel_context(writer
, &ctx
->ctx
);
1465 if (ret
!= LTTNG_OK
) {
1471 ret
= config_writer_close_element(writer
);
1473 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1482 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1484 int save_ust_context_perf_thread_counter(struct config_writer
*writer
,
1485 struct ltt_ust_context
*ctx
)
1492 /* Perf contexts are saved as event_perf_context_type */
1493 ret
= config_writer_open_element(writer
, config_element_context_perf
);
1495 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1499 ret
= config_writer_write_element_unsigned_int(writer
,
1500 config_element_type
, ctx
->ctx
.u
.perf_counter
.type
);
1502 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1506 ret
= config_writer_write_element_unsigned_int(writer
,
1507 config_element_config
, ctx
->ctx
.u
.perf_counter
.config
);
1509 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1513 ret
= config_writer_write_element_string(writer
, config_element_name
,
1514 ctx
->ctx
.u
.perf_counter
.name
);
1516 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1521 ret
= config_writer_close_element(writer
);
1523 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1532 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1534 int save_ust_context_app_ctx(struct config_writer
*writer
,
1535 struct ltt_ust_context
*ctx
)
1542 /* Application contexts are saved as application_context_type */
1543 ret
= config_writer_open_element(writer
, config_element_context_app
);
1545 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1549 ret
= config_writer_write_element_string(writer
,
1550 config_element_context_app_provider_name
,
1551 ctx
->ctx
.u
.app_ctx
.provider_name
);
1553 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1557 ret
= config_writer_write_element_string(writer
,
1558 config_element_context_app_ctx_name
,
1559 ctx
->ctx
.u
.app_ctx
.ctx_name
);
1561 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1566 ret
= config_writer_close_element(writer
);
1568 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1577 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1579 int save_ust_context_generic(struct config_writer
*writer
,
1580 struct ltt_ust_context
*ctx
)
1583 const char *context_type_string
;
1588 /* Save context as event_context_type_type */
1589 context_type_string
= get_ust_context_type_string(
1591 if (!context_type_string
) {
1592 ERR("Unsupported UST context type.");
1593 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1597 ret
= config_writer_write_element_string(writer
,
1598 config_element_type
, context_type_string
);
1600 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1609 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1611 int save_ust_context(struct config_writer
*writer
,
1612 struct cds_list_head
*ctx_list
)
1615 struct ltt_ust_context
*ctx
;
1620 ret
= config_writer_open_element(writer
, config_element_contexts
);
1622 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1626 cds_list_for_each_entry(ctx
, ctx_list
, list
) {
1627 ret
= config_writer_open_element(writer
,
1628 config_element_context
);
1630 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1634 switch (ctx
->ctx
.ctx
) {
1635 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
:
1636 ret
= save_ust_context_perf_thread_counter(writer
, ctx
);
1638 case LTTNG_UST_CONTEXT_APP_CONTEXT
:
1639 ret
= save_ust_context_app_ctx(writer
, ctx
);
1642 /* Save generic context. */
1643 ret
= save_ust_context_generic(writer
, ctx
);
1645 if (ret
!= LTTNG_OK
) {
1650 ret
= config_writer_close_element(writer
);
1652 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1658 ret
= config_writer_close_element(writer
);
1660 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1669 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1671 int save_kernel_channel(struct config_writer
*writer
,
1672 struct ltt_kernel_channel
*kchan
)
1679 ret
= config_writer_open_element(writer
, config_element_channel
);
1681 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1685 ret
= config_writer_write_element_string(writer
, config_element_name
,
1686 kchan
->channel
->name
);
1688 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1692 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1693 kchan
->channel
->enabled
);
1695 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1699 ret
= save_kernel_channel_attributes(writer
, &kchan
->channel
->attr
);
1700 if (ret
!= LTTNG_OK
) {
1704 ret
= save_kernel_events(writer
, kchan
);
1705 if (ret
!= LTTNG_OK
) {
1709 ret
= save_kernel_contexts(writer
, kchan
);
1710 if (ret
!= LTTNG_OK
) {
1715 ret
= config_writer_close_element(writer
);
1717 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1726 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1728 int save_kernel_map(struct config_writer
*writer
,
1729 struct ltt_kernel_map
*kmap
)
1732 const char *map_name
= NULL
;
1733 enum lttng_map_status map_status
;
1738 ret
= config_writer_open_element(writer
, config_element_map
);
1740 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1744 map_status
= lttng_map_get_name(kmap
->map
, &map_name
);
1745 if (map_status
!= LTTNG_MAP_STATUS_OK
) {
1746 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1750 ret
= config_writer_write_element_string(writer
, config_element_name
,
1753 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1757 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1758 lttng_map_get_is_enabled(kmap
->map
));
1760 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1764 ret
= save_map_attributes(writer
, kmap
->map
);
1770 ret
= config_writer_close_element(writer
);
1772 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1781 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1783 int save_ust_channel(struct config_writer
*writer
,
1784 struct ltt_ust_channel
*ust_chan
,
1785 struct ltt_ust_session
*session
)
1793 ret
= config_writer_open_element(writer
, config_element_channel
);
1795 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1799 ret
= config_writer_write_element_string(writer
, config_element_name
,
1802 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1806 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1809 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1813 ret
= save_ust_channel_attributes(writer
, &ust_chan
->attr
);
1814 if (ret
!= LTTNG_OK
) {
1818 ret
= config_writer_write_element_unsigned_int(writer
,
1819 config_element_tracefile_size
, ust_chan
->tracefile_size
);
1821 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1825 ret
= config_writer_write_element_unsigned_int(writer
,
1826 config_element_tracefile_count
, ust_chan
->tracefile_count
);
1828 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1832 ret
= config_writer_write_element_unsigned_int(writer
,
1833 config_element_live_timer_interval
,
1834 session
->live_timer_interval
);
1836 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1840 if (ust_chan
->domain
== LTTNG_DOMAIN_UST
) {
1841 ret
= save_ust_events(writer
, ust_chan
->events
);
1842 if (ret
!= LTTNG_OK
) {
1846 struct agent
*agent
= NULL
;
1848 agent
= trace_ust_find_agent(session
, ust_chan
->domain
);
1850 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1851 ERR("Could not find agent associated to UST subdomain");
1856 * Channels associated with a UST sub-domain (such as JUL, Log4j
1857 * or Python) don't have any non-internal events. We retrieve
1858 * the "agent" events associated with this channel and serialize
1861 ret
= save_agent_events(writer
, agent
);
1862 if (ret
!= LTTNG_OK
) {
1867 ret
= save_ust_context(writer
, &ust_chan
->ctx_list
);
1868 if (ret
!= LTTNG_OK
) {
1873 ret
= config_writer_close_element(writer
);
1875 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1884 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1886 int save_ust_map(struct config_writer
*writer
,
1887 struct ltt_ust_map
*ust_map
,
1888 struct ltt_ust_session
*session
)
1896 ret
= config_writer_open_element(writer
, config_element_map
);
1898 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1902 ret
= config_writer_write_element_string(writer
, config_element_name
,
1905 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1909 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1912 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1916 ret
= save_map_attributes(writer
, ust_map
->map
);
1918 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1923 ret
= config_writer_close_element(writer
);
1925 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1934 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
1936 int save_kernel_session(struct config_writer
*writer
,
1937 struct ltt_session
*session
)
1940 struct ltt_kernel_channel
*kchan
;
1941 struct ltt_kernel_map
*kmap
;
1946 ret
= config_writer_write_element_string(writer
, config_element_type
,
1947 config_domain_type_kernel
);
1949 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1953 ret
= config_writer_write_element_string(writer
,
1954 config_element_buffer_type
, config_buffer_type_global
);
1956 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1960 ret
= config_writer_open_element(writer
,
1961 config_element_channels
);
1963 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1967 cds_list_for_each_entry(kchan
, &session
->kernel_session
->channel_list
.head
,
1969 ret
= save_kernel_channel(writer
, kchan
);
1970 if (ret
!= LTTNG_OK
) {
1975 cds_list_for_each_entry(kmap
, &session
->kernel_session
->map_list
.head
,
1977 ret
= save_kernel_map(writer
, kmap
);
1978 if (ret
!= LTTNG_OK
) {
1984 ret
= config_writer_close_element(writer
);
1986 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1996 const char *get_config_domain_str(enum lttng_domain_type domain
)
1998 const char *str_dom
;
2001 case LTTNG_DOMAIN_KERNEL
:
2002 str_dom
= config_domain_type_kernel
;
2004 case LTTNG_DOMAIN_UST
:
2005 str_dom
= config_domain_type_ust
;
2007 case LTTNG_DOMAIN_JUL
:
2008 str_dom
= config_domain_type_jul
;
2010 case LTTNG_DOMAIN_LOG4J
:
2011 str_dom
= config_domain_type_log4j
;
2013 case LTTNG_DOMAIN_PYTHON
:
2014 str_dom
= config_domain_type_python
;
2023 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2024 static int save_process_attr_tracker(struct config_writer
*writer
,
2025 struct ltt_session
*sess
,
2027 enum lttng_process_attr process_attr
)
2030 const char *element_id_tracker
, *element_target_id
, *element_id
;
2031 const struct process_attr_tracker
*tracker
;
2032 enum lttng_tracking_policy tracking_policy
;
2033 struct lttng_process_attr_values
*values
= NULL
;
2035 switch (process_attr
) {
2036 case LTTNG_PROCESS_ATTR_PROCESS_ID
:
2037 element_id_tracker
= config_element_process_attr_tracker_pid
;
2038 element_target_id
= config_element_process_attr_pid_value
;
2039 element_id
= config_element_process_attr_id
;
2041 case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
:
2042 element_id_tracker
= config_element_process_attr_tracker_vpid
;
2043 element_target_id
= config_element_process_attr_vpid_value
;
2044 element_id
= config_element_process_attr_id
;
2046 case LTTNG_PROCESS_ATTR_USER_ID
:
2047 element_id_tracker
= config_element_process_attr_tracker_uid
;
2048 element_target_id
= config_element_process_attr_uid_value
;
2049 element_id
= config_element_process_attr_id
;
2051 case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
:
2052 element_id_tracker
= config_element_process_attr_tracker_vuid
;
2053 element_target_id
= config_element_process_attr_vuid_value
;
2054 element_id
= config_element_process_attr_id
;
2056 case LTTNG_PROCESS_ATTR_GROUP_ID
:
2057 element_id_tracker
= config_element_process_attr_tracker_gid
;
2058 element_target_id
= config_element_process_attr_gid_value
;
2059 element_id
= config_element_process_attr_id
;
2061 case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
:
2062 element_id_tracker
= config_element_process_attr_tracker_vgid
;
2063 element_target_id
= config_element_process_attr_vgid_value
;
2064 element_id
= config_element_process_attr_id
;
2067 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2072 case LTTNG_DOMAIN_KERNEL
:
2074 tracker
= kernel_get_process_attr_tracker(
2075 sess
->kernel_session
, process_attr
);
2079 case LTTNG_DOMAIN_UST
:
2081 tracker
= trace_ust_get_process_attr_tracker(
2082 sess
->ust_session
, process_attr
);
2086 case LTTNG_DOMAIN_JUL
:
2087 case LTTNG_DOMAIN_LOG4J
:
2088 case LTTNG_DOMAIN_PYTHON
:
2090 ret
= LTTNG_ERR_UNSUPPORTED_DOMAIN
;
2094 tracking_policy
= process_attr_tracker_get_tracking_policy(tracker
);
2095 if (tracking_policy
== LTTNG_TRACKING_POLICY_INCLUDE_ALL
) {
2096 /* Tracking all, nothing to output. */
2101 ret
= config_writer_open_element(writer
, element_id_tracker
);
2103 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2107 ret
= config_writer_open_element(
2108 writer
, config_element_process_attr_values
);
2110 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2114 if (tracking_policy
== LTTNG_TRACKING_POLICY_INCLUDE_SET
) {
2115 unsigned int i
, count
;
2116 enum process_attr_tracker_status status
=
2117 process_attr_tracker_get_inclusion_set(
2120 if (status
!= PROCESS_ATTR_TRACKER_STATUS_OK
) {
2121 ret
= LTTNG_ERR_NOMEM
;
2125 count
= _lttng_process_attr_values_get_count(values
);
2127 for (i
= 0; i
< count
; i
++) {
2128 unsigned int integral_value
= UINT_MAX
;
2129 const char *name
= NULL
;
2130 const struct process_attr_value
*value
=
2131 lttng_process_attr_tracker_values_get_at_index(
2135 ret
= config_writer_open_element(
2136 writer
, element_target_id
);
2138 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2142 switch (value
->type
) {
2143 case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID
:
2145 (unsigned int) value
->value
.pid
;
2147 case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID
:
2149 (unsigned int) value
->value
.uid
;
2151 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID
:
2153 (unsigned int) value
->value
.gid
;
2155 case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME
:
2156 name
= value
->value
.user_name
;
2159 case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME
:
2160 name
= value
->value
.group_name
;
2168 ret
= config_writer_write_element_string(writer
,
2169 config_element_name
, name
);
2171 ret
= config_writer_write_element_unsigned_int(
2177 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2181 /* /$element_target_id */
2182 ret
= config_writer_close_element(writer
);
2184 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2191 ret
= config_writer_close_element(writer
);
2193 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2197 /* /$element_id_tracker */
2198 ret
= config_writer_close_element(writer
);
2200 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2206 lttng_process_attr_values_destroy(values
);
2210 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2211 static int save_process_attr_trackers(struct config_writer
*writer
,
2212 struct ltt_session
*sess
,
2218 case LTTNG_DOMAIN_KERNEL
:
2219 ret
= save_process_attr_tracker(writer
, sess
, domain
,
2220 LTTNG_PROCESS_ATTR_PROCESS_ID
);
2221 if (ret
!= LTTNG_OK
) {
2224 ret
= save_process_attr_tracker(writer
, sess
, domain
,
2225 LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
);
2226 if (ret
!= LTTNG_OK
) {
2229 ret
= save_process_attr_tracker(writer
, sess
, domain
,
2230 LTTNG_PROCESS_ATTR_USER_ID
);
2231 if (ret
!= LTTNG_OK
) {
2234 ret
= save_process_attr_tracker(writer
, sess
, domain
,
2235 LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
);
2236 if (ret
!= LTTNG_OK
) {
2239 ret
= save_process_attr_tracker(writer
, sess
, domain
,
2240 LTTNG_PROCESS_ATTR_GROUP_ID
);
2241 if (ret
!= LTTNG_OK
) {
2244 ret
= save_process_attr_tracker(writer
, sess
, domain
,
2245 LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
);
2246 if (ret
!= LTTNG_OK
) {
2250 case LTTNG_DOMAIN_UST
:
2251 ret
= save_process_attr_tracker(writer
, sess
, domain
,
2252 LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID
);
2253 if (ret
!= LTTNG_OK
) {
2256 ret
= save_process_attr_tracker(writer
, sess
, domain
,
2257 LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID
);
2258 if (ret
!= LTTNG_OK
) {
2261 ret
= save_process_attr_tracker(writer
, sess
, domain
,
2262 LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID
);
2263 if (ret
!= LTTNG_OK
) {
2268 ret
= LTTNG_ERR_INVALID
;
2276 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2278 int save_ust_domain(struct config_writer
*writer
,
2279 struct ltt_session
*session
, enum lttng_domain_type domain
)
2282 struct ltt_ust_channel
*ust_chan
;
2283 struct ltt_ust_map
*ust_map
;
2284 const char *buffer_type_string
;
2285 struct lttng_ht_node_str
*node
;
2286 struct lttng_ht_iter iter
;
2287 const char *config_domain_name
;
2292 ret
= config_writer_open_element(writer
,
2293 config_element_domain
);
2295 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2299 config_domain_name
= get_config_domain_str(domain
);
2300 if (!config_domain_name
) {
2301 ret
= LTTNG_ERR_INVALID
;
2305 ret
= config_writer_write_element_string(writer
,
2306 config_element_type
, config_domain_name
);
2308 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2312 buffer_type_string
= get_buffer_type_string(
2313 session
->ust_session
->buffer_type
);
2314 if (!buffer_type_string
) {
2315 ERR("Unsupported buffer type.");
2316 ret
= LTTNG_ERR_INVALID
;
2320 ret
= config_writer_write_element_string(writer
,
2321 config_element_buffer_type
, buffer_type_string
);
2323 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2327 ret
= config_writer_open_element(writer
, config_element_channels
);
2329 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2334 cds_lfht_for_each_entry(session
->ust_session
->domain_global
.channels
->ht
,
2335 &iter
.iter
, node
, node
) {
2336 ust_chan
= caa_container_of(node
, struct ltt_ust_channel
, node
);
2337 if (domain
== ust_chan
->domain
) {
2338 ret
= save_ust_channel(writer
, ust_chan
, session
->ust_session
);
2339 if (ret
!= LTTNG_OK
) {
2348 ret
= config_writer_close_element(writer
);
2350 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2354 ret
= config_writer_open_element(writer
, config_element_maps
);
2356 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2360 cds_lfht_for_each_entry(session
->ust_session
->domain_global
.maps
->ht
,
2361 &iter
.iter
, node
, node
) {
2362 ust_map
= caa_container_of(node
, struct ltt_ust_map
, node
);
2363 if (domain
== LTTNG_DOMAIN_UST
) {
2364 ret
= save_ust_map(writer
, ust_map
, session
->ust_session
);
2365 if (ret
!= LTTNG_OK
) {
2374 ret
= config_writer_close_element(writer
);
2376 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2380 if (domain
== LTTNG_DOMAIN_UST
) {
2381 ret
= config_writer_open_element(
2382 writer
, config_element_process_attr_trackers
);
2384 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2388 ret
= save_process_attr_trackers(
2389 writer
, session
, LTTNG_DOMAIN_UST
);
2390 if (ret
!= LTTNG_OK
) {
2395 ret
= config_writer_close_element(writer
);
2397 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2403 ret
= config_writer_close_element(writer
);
2405 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2414 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2416 int save_domains(struct config_writer
*writer
, struct ltt_session
*session
)
2423 if (!session
->kernel_session
&& !session
->ust_session
) {
2427 ret
= config_writer_open_element(writer
, config_element_domains
);
2429 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2433 if (session
->kernel_session
) {
2434 ret
= config_writer_open_element(writer
,
2435 config_element_domain
);
2437 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2441 ret
= save_kernel_session(writer
, session
);
2442 if (ret
!= LTTNG_OK
) {
2446 ret
= config_writer_open_element(
2447 writer
, config_element_process_attr_trackers
);
2449 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2453 ret
= save_process_attr_trackers(
2454 writer
, session
, LTTNG_DOMAIN_KERNEL
);
2455 if (ret
!= LTTNG_OK
) {
2460 ret
= config_writer_close_element(writer
);
2462 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2466 ret
= config_writer_close_element(writer
);
2468 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2473 if (session
->ust_session
) {
2474 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_UST
);
2475 if (ret
!= LTTNG_OK
) {
2479 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_JUL
);
2480 if (ret
!= LTTNG_OK
) {
2484 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_LOG4J
);
2485 if (ret
!= LTTNG_OK
) {
2489 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_PYTHON
);
2490 if (ret
!= LTTNG_OK
) {
2496 ret
= config_writer_close_element(writer
);
2498 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2507 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2509 int save_consumer_output(struct config_writer
*writer
,
2510 struct consumer_output
*output
)
2517 ret
= config_writer_open_element(writer
, config_element_consumer_output
);
2519 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2523 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
2526 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2530 ret
= config_writer_open_element(writer
, config_element_destination
);
2532 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2536 switch (output
->type
) {
2537 case CONSUMER_DST_LOCAL
:
2538 ret
= config_writer_write_element_string(writer
,
2539 config_element_path
, output
->dst
.session_root_path
);
2541 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2545 case CONSUMER_DST_NET
:
2549 uri
= zmalloc(PATH_MAX
);
2551 ret
= LTTNG_ERR_NOMEM
;
2555 ret
= config_writer_open_element(writer
, config_element_net_output
);
2557 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2558 goto end_net_output
;
2561 if (output
->dst
.net
.control_isset
&&
2562 output
->dst
.net
.data_isset
) {
2563 ret
= uri_to_str_url(&output
->dst
.net
.control
, uri
, PATH_MAX
);
2565 ret
= LTTNG_ERR_INVALID
;
2566 goto end_net_output
;
2569 ret
= config_writer_write_element_string(writer
,
2570 config_element_control_uri
, uri
);
2572 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2573 goto end_net_output
;
2576 ret
= uri_to_str_url(&output
->dst
.net
.data
, uri
, PATH_MAX
);
2578 ret
= LTTNG_ERR_INVALID
;
2579 goto end_net_output
;
2582 ret
= config_writer_write_element_string(writer
,
2583 config_element_data_uri
, uri
);
2585 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2586 goto end_net_output
;
2591 if (ret
!= LTTNG_OK
) {
2595 ret
= !output
->dst
.net
.control_isset
?
2596 LTTNG_ERR_URL_CTRL_MISS
:
2597 LTTNG_ERR_URL_DATA_MISS
;
2602 ret
= config_writer_close_element(writer
);
2604 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2610 ERR("Unsupported consumer output type.");
2611 ret
= LTTNG_ERR_INVALID
;
2616 ret
= config_writer_close_element(writer
);
2618 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2622 /* /consumer_output */
2623 ret
= config_writer_close_element(writer
);
2625 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2634 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2636 int save_snapshot_outputs(struct config_writer
*writer
,
2637 struct snapshot
*snapshot
)
2640 struct lttng_ht_iter iter
;
2641 struct snapshot_output
*output
;
2646 ret
= config_writer_open_element(writer
, config_element_snapshot_outputs
);
2648 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2653 cds_lfht_for_each_entry(snapshot
->output_ht
->ht
, &iter
.iter
, output
,
2655 ret
= config_writer_open_element(writer
,
2656 config_element_output
);
2658 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2662 ret
= config_writer_write_element_string(writer
,
2663 config_element_name
, output
->name
);
2665 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2669 ret
= config_writer_write_element_unsigned_int(writer
,
2670 config_element_max_size
, output
->max_size
);
2672 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2676 ret
= save_consumer_output(writer
, output
->consumer
);
2677 if (ret
!= LTTNG_OK
) {
2682 ret
= config_writer_close_element(writer
);
2684 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2690 /* /snapshot_outputs */
2691 ret
= config_writer_close_element(writer
);
2693 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2705 /* Return LTTNG_OK on success else a LTTNG_ERR* code. */
2707 int save_session_output(struct config_writer
*writer
,
2708 struct ltt_session
*session
)
2715 if ((session
->snapshot_mode
&& session
->snapshot
.nb_output
== 0) ||
2716 (!session
->snapshot_mode
&& !session
->consumer
)) {
2717 /* Session is in no output mode */
2722 ret
= config_writer_open_element(writer
, config_element_output
);
2724 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2728 if (session
->snapshot_mode
) {
2729 ret
= save_snapshot_outputs(writer
, &session
->snapshot
);
2730 if (ret
!= LTTNG_OK
) {
2734 if (session
->consumer
) {
2735 ret
= save_consumer_output(writer
, session
->consumer
);
2736 if (ret
!= LTTNG_OK
) {
2743 ret
= config_writer_close_element(writer
);
2745 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2754 int save_session_rotation_schedule(struct config_writer
*writer
,
2755 enum lttng_rotation_schedule_type type
, uint64_t value
)
2758 const char *element_name
;
2759 const char *value_name
;
2762 case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
:
2763 element_name
= config_element_rotation_schedule_periodic
;
2764 value_name
= config_element_rotation_schedule_periodic_time_us
;
2766 case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
:
2767 element_name
= config_element_rotation_schedule_size_threshold
;
2768 value_name
= config_element_rotation_schedule_size_threshold_bytes
;
2775 ret
= config_writer_open_element(writer
, element_name
);
2780 ret
= config_writer_write_element_unsigned_int(writer
,
2786 /* Close schedule descriptor element. */
2787 ret
= config_writer_close_element(writer
);
2796 int save_session_rotation_schedules(struct config_writer
*writer
,
2797 struct ltt_session
*session
)
2801 ret
= config_writer_open_element(writer
,
2802 config_element_rotation_schedules
);
2806 if (session
->rotate_timer_period
) {
2807 ret
= save_session_rotation_schedule(writer
,
2808 LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
,
2809 session
->rotate_timer_period
);
2811 goto close_schedules
;
2814 if (session
->rotate_size
) {
2815 ret
= save_session_rotation_schedule(writer
,
2816 LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
,
2817 session
->rotate_size
);
2819 goto close_schedules
;
2824 /* Close rotation schedules element. */
2825 ret
= config_writer_close_element(writer
);
2834 * Save the given session.
2836 * Return LTTNG_OK on success else a LTTNG_ERR* code.
2839 int save_session(struct ltt_session
*session
,
2840 struct lttng_save_session_attr
*attr
, lttng_sock_cred
*creds
)
2843 char config_file_path
[LTTNG_PATH_MAX
];
2845 struct config_writer
*writer
= NULL
;
2846 size_t session_name_len
;
2847 const char *provided_path
;
2848 int file_open_flags
= O_CREAT
| O_WRONLY
| O_TRUNC
;
2854 session_name_len
= strlen(session
->name
);
2855 memset(config_file_path
, 0, sizeof(config_file_path
));
2857 if (!session_access_ok(session
,
2858 LTTNG_SOCK_GET_UID_CRED(creds
)) || session
->destroyed
) {
2859 ret
= LTTNG_ERR_EPERM
;
2863 provided_path
= lttng_save_session_attr_get_output_url(attr
);
2864 if (provided_path
) {
2865 DBG3("Save session in provided path %s", provided_path
);
2866 len
= strlen(provided_path
);
2867 if (len
>= sizeof(config_file_path
)) {
2868 ret
= LTTNG_ERR_SET_URL
;
2871 strncpy(config_file_path
, provided_path
, sizeof(config_file_path
));
2874 char *home_dir
= utils_get_user_home_dir(
2875 LTTNG_SOCK_GET_UID_CRED(creds
));
2877 ret
= LTTNG_ERR_SET_URL
;
2881 ret_len
= snprintf(config_file_path
, sizeof(config_file_path
),
2882 DEFAULT_SESSION_HOME_CONFIGPATH
, home_dir
);
2885 PERROR("snprintf save session");
2886 ret
= LTTNG_ERR_SET_URL
;
2893 * Check the path fits in the config file path dst including the '/'
2894 * followed by trailing .lttng extension and the NULL terminated string.
2896 if ((len
+ session_name_len
+ 2 +
2897 sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
))
2898 > sizeof(config_file_path
)) {
2899 ret
= LTTNG_ERR_SET_URL
;
2903 ret
= run_as_mkdir_recursive(config_file_path
, S_IRWXU
| S_IRWXG
,
2904 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
2906 ret
= LTTNG_ERR_SET_URL
;
2911 * At this point, we know that everything fits in the buffer. Validation
2912 * was done just above.
2914 config_file_path
[len
++] = '/';
2915 strncpy(config_file_path
+ len
, session
->name
, sizeof(config_file_path
) - len
);
2916 len
+= session_name_len
;
2917 strcpy(config_file_path
+ len
, DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
2918 len
+= sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
2919 config_file_path
[len
] = '\0';
2921 if (!attr
->overwrite
) {
2922 file_open_flags
|= O_EXCL
;
2925 fd
= run_as_open(config_file_path
, file_open_flags
,
2926 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
,
2927 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
2929 PERROR("Could not create configuration file");
2932 ret
= LTTNG_ERR_SAVE_FILE_EXIST
;
2935 ret
= LTTNG_ERR_EPERM
;
2938 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2944 writer
= config_writer_create(fd
, 1);
2946 ret
= LTTNG_ERR_NOMEM
;
2950 ret
= config_writer_open_element(writer
, config_element_sessions
);
2952 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2956 ret
= config_writer_open_element(writer
, config_element_session
);
2958 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2962 ret
= config_writer_write_element_string(writer
, config_element_name
,
2965 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2969 if (session
->shm_path
[0] != '\0') {
2970 ret
= config_writer_write_element_string(writer
,
2971 config_element_shared_memory_path
,
2974 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2979 ret
= save_domains(writer
, session
);
2980 if (ret
!= LTTNG_OK
) {
2984 ret
= config_writer_write_element_bool(writer
, config_element_started
,
2987 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2991 if (session
->snapshot_mode
|| session
->live_timer
||
2992 session
->rotate_timer_period
|| session
->rotate_size
) {
2993 ret
= config_writer_open_element(writer
, config_element_attributes
);
2995 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2999 if (session
->snapshot_mode
) {
3000 ret
= config_writer_write_element_bool(writer
,
3001 config_element_snapshot_mode
, 1);
3003 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
3006 } else if (session
->live_timer
) {
3007 ret
= config_writer_write_element_unsigned_int(writer
,
3008 config_element_live_timer_interval
, session
->live_timer
);
3010 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
3014 if (session
->rotate_timer_period
|| session
->rotate_size
) {
3015 ret
= save_session_rotation_schedules(writer
,
3018 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
3024 ret
= config_writer_close_element(writer
);
3026 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
3031 ret
= save_session_output(writer
, session
);
3032 if (ret
!= LTTNG_OK
) {
3037 ret
= config_writer_close_element(writer
);
3039 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
3044 ret
= config_writer_close_element(writer
);
3046 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
3052 if (writer
&& config_writer_destroy(writer
)) {
3053 /* Preserve the original error code */
3054 ret
= ret
!= LTTNG_OK
? ret
: LTTNG_ERR_SAVE_IO_FAIL
;
3056 if (ret
!= LTTNG_OK
) {
3057 /* Delete file in case of error */
3058 if ((fd
>= 0) && unlink(config_file_path
)) {
3059 PERROR("Unlinking XML session configuration.");
3066 closeret
= close(fd
);
3068 PERROR("Closing XML session configuration");
3075 int cmd_save_sessions(struct lttng_save_session_attr
*attr
,
3076 lttng_sock_cred
*creds
)
3079 const char *session_name
;
3080 struct ltt_session
*session
;
3082 session_lock_list();
3084 session_name
= lttng_save_session_attr_get_session_name(attr
);
3086 session
= session_find_by_name(session_name
);
3088 ret
= LTTNG_ERR_SESS_NOT_FOUND
;
3092 session_lock(session
);
3093 ret
= save_session(session
, attr
, creds
);
3094 session_unlock(session
);
3095 session_put(session
);
3096 if (ret
!= LTTNG_OK
) {
3100 struct ltt_session_list
*list
= session_get_list();
3102 cds_list_for_each_entry(session
, &list
->head
, list
) {
3103 if (!session_get(session
)) {
3106 session_lock(session
);
3107 ret
= save_session(session
, attr
, creds
);
3108 session_unlock(session
);
3109 session_put(session
);
3110 /* Don't abort if we don't have the required permissions. */
3111 if (ret
!= LTTNG_OK
&& ret
!= LTTNG_ERR_EPERM
) {
3119 session_unlock_list();