2 * Copyright (C) 2014 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License, version 2 only, as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 51
15 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 #include <urcu/uatomic.h>
25 #include <common/defaults.h>
26 #include <common/error.h>
27 #include <common/config/session-config.h>
28 #include <common/utils.h>
29 #include <common/runas.h>
30 #include <lttng/save-internal.h>
35 #include "lttng-syscall.h"
36 #include "trace-ust.h"
40 int save_kernel_channel_attributes(struct config_writer
*writer
,
41 struct lttng_channel_attr
*attr
)
45 ret
= config_writer_write_element_string(writer
,
46 config_element_overwrite_mode
,
47 attr
->overwrite
? config_overwrite_mode_overwrite
:
48 config_overwrite_mode_discard
);
53 ret
= config_writer_write_element_unsigned_int(writer
,
54 config_element_subbuf_size
, attr
->subbuf_size
);
59 ret
= config_writer_write_element_unsigned_int(writer
,
60 config_element_num_subbuf
,
66 ret
= config_writer_write_element_unsigned_int(writer
,
67 config_element_switch_timer_interval
,
68 attr
->switch_timer_interval
);
73 ret
= config_writer_write_element_unsigned_int(writer
,
74 config_element_read_timer_interval
,
75 attr
->read_timer_interval
);
80 ret
= config_writer_write_element_string(writer
,
81 config_element_output_type
,
82 attr
->output
== LTTNG_EVENT_SPLICE
?
83 config_output_type_splice
: config_output_type_mmap
);
88 ret
= config_writer_write_element_unsigned_int(writer
,
89 config_element_tracefile_size
, attr
->tracefile_size
);
94 ret
= config_writer_write_element_unsigned_int(writer
,
95 config_element_tracefile_count
,
96 attr
->tracefile_count
);
101 ret
= config_writer_write_element_unsigned_int(writer
,
102 config_element_live_timer_interval
,
103 attr
->live_timer_interval
);
108 if (attr
->extended
.ptr
) {
109 struct lttng_channel_extended
*ext
= NULL
;
111 ext
= (struct lttng_channel_extended
*) attr
->extended
.ptr
;
112 ret
= config_writer_write_element_unsigned_int(writer
,
113 config_element_monitor_timer_interval
,
114 ext
->monitor_timer_interval
);
119 ret
= config_writer_write_element_signed_int(writer
,
120 config_element_blocking_timeout
,
121 ext
->blocking_timeout
);
128 return ret
? LTTNG_ERR_SAVE_IO_FAIL
: 0;
132 int save_ust_channel_attributes(struct config_writer
*writer
,
133 struct lttng_ust_channel_attr
*attr
)
136 struct ltt_ust_channel
*channel
= NULL
;
138 ret
= config_writer_write_element_string(writer
,
139 config_element_overwrite_mode
,
140 attr
->overwrite
? config_overwrite_mode_overwrite
:
141 config_overwrite_mode_discard
);
146 ret
= config_writer_write_element_unsigned_int(writer
,
147 config_element_subbuf_size
, attr
->subbuf_size
);
152 ret
= config_writer_write_element_unsigned_int(writer
,
153 config_element_num_subbuf
,
159 ret
= config_writer_write_element_unsigned_int(writer
,
160 config_element_switch_timer_interval
,
161 attr
->switch_timer_interval
);
166 ret
= config_writer_write_element_unsigned_int(writer
,
167 config_element_read_timer_interval
,
168 attr
->read_timer_interval
);
173 ret
= config_writer_write_element_string(writer
,
174 config_element_output_type
,
175 attr
->output
== LTTNG_UST_MMAP
?
176 config_output_type_mmap
: config_output_type_splice
);
181 ret
= config_writer_write_element_signed_int(writer
,
182 config_element_blocking_timeout
,
183 attr
->u
.s
.blocking_timeout
);
189 * Fetch the monitor timer which is located in the parent of
190 * lttng_ust_channel_attr
192 channel
= caa_container_of(attr
, struct ltt_ust_channel
, attr
);
193 ret
= config_writer_write_element_unsigned_int(writer
,
194 config_element_monitor_timer_interval
,
195 channel
->monitor_timer_interval
);
201 return ret
? LTTNG_ERR_SAVE_IO_FAIL
: 0;
205 const char *get_kernel_instrumentation_string(
206 enum lttng_kernel_instrumentation instrumentation
)
208 const char *instrumentation_string
;
210 switch (instrumentation
) {
211 case LTTNG_KERNEL_ALL
:
212 instrumentation_string
= config_event_type_all
;
214 case LTTNG_KERNEL_TRACEPOINT
:
215 instrumentation_string
= config_event_type_tracepoint
;
217 case LTTNG_KERNEL_KPROBE
:
218 instrumentation_string
= config_event_type_probe
;
220 case LTTNG_KERNEL_UPROBE
:
221 instrumentation_string
= config_event_type_userspace_probe
;
223 case LTTNG_KERNEL_FUNCTION
:
224 instrumentation_string
= config_event_type_function_entry
;
226 case LTTNG_KERNEL_KRETPROBE
:
227 instrumentation_string
= config_event_type_function
;
229 case LTTNG_KERNEL_NOOP
:
230 instrumentation_string
= config_event_type_noop
;
232 case LTTNG_KERNEL_SYSCALL
:
233 instrumentation_string
= config_event_type_syscall
;
236 instrumentation_string
= NULL
;
239 return instrumentation_string
;
243 const char *get_kernel_context_type_string(
244 enum lttng_kernel_context_type context_type
)
246 const char *context_type_string
;
248 switch (context_type
) {
249 case LTTNG_KERNEL_CONTEXT_PID
:
250 context_type_string
= config_event_context_pid
;
252 case LTTNG_KERNEL_CONTEXT_PROCNAME
:
253 context_type_string
= config_event_context_procname
;
255 case LTTNG_KERNEL_CONTEXT_PRIO
:
256 context_type_string
= config_event_context_prio
;
258 case LTTNG_KERNEL_CONTEXT_NICE
:
259 context_type_string
= config_event_context_nice
;
261 case LTTNG_KERNEL_CONTEXT_VPID
:
262 context_type_string
= config_event_context_vpid
;
264 case LTTNG_KERNEL_CONTEXT_TID
:
265 context_type_string
= config_event_context_tid
;
267 case LTTNG_KERNEL_CONTEXT_VTID
:
268 context_type_string
= config_event_context_vtid
;
270 case LTTNG_KERNEL_CONTEXT_PPID
:
271 context_type_string
= config_event_context_ppid
;
273 case LTTNG_KERNEL_CONTEXT_VPPID
:
274 context_type_string
= config_event_context_vppid
;
276 case LTTNG_KERNEL_CONTEXT_HOSTNAME
:
277 context_type_string
= config_event_context_hostname
;
279 case LTTNG_KERNEL_CONTEXT_INTERRUPTIBLE
:
280 context_type_string
= config_event_context_interruptible
;
282 case LTTNG_KERNEL_CONTEXT_PREEMPTIBLE
:
283 context_type_string
= config_event_context_preemptible
;
285 case LTTNG_KERNEL_CONTEXT_NEED_RESCHEDULE
:
286 context_type_string
= config_event_context_need_reschedule
;
288 case LTTNG_KERNEL_CONTEXT_MIGRATABLE
:
289 context_type_string
= config_event_context_migratable
;
291 case LTTNG_KERNEL_CONTEXT_CALLSTACK_USER
:
292 context_type_string
= config_event_context_callstack_user
;
294 case LTTNG_KERNEL_CONTEXT_CALLSTACK_KERNEL
:
295 context_type_string
= config_event_context_callstack_kernel
;
297 case LTTNG_KERNEL_CONTEXT_CGROUP_NS
:
298 context_type_string
= config_event_context_cgroup_ns
;
300 case LTTNG_KERNEL_CONTEXT_IPC_NS
:
301 context_type_string
= config_event_context_ipc_ns
;
303 case LTTNG_KERNEL_CONTEXT_MNT_NS
:
304 context_type_string
= config_event_context_mnt_ns
;
306 case LTTNG_KERNEL_CONTEXT_NET_NS
:
307 context_type_string
= config_event_context_net_ns
;
309 case LTTNG_KERNEL_CONTEXT_PID_NS
:
310 context_type_string
= config_event_context_pid_ns
;
312 case LTTNG_KERNEL_CONTEXT_USER_NS
:
313 context_type_string
= config_event_context_user_ns
;
315 case LTTNG_KERNEL_CONTEXT_UTS_NS
:
316 context_type_string
= config_event_context_uts_ns
;
318 case LTTNG_KERNEL_CONTEXT_UID
:
319 context_type_string
= config_event_context_uid
;
321 case LTTNG_KERNEL_CONTEXT_EUID
:
322 context_type_string
= config_event_context_euid
;
324 case LTTNG_KERNEL_CONTEXT_SUID
:
325 context_type_string
= config_event_context_suid
;
327 case LTTNG_KERNEL_CONTEXT_GID
:
328 context_type_string
= config_event_context_gid
;
330 case LTTNG_KERNEL_CONTEXT_EGID
:
331 context_type_string
= config_event_context_egid
;
333 case LTTNG_KERNEL_CONTEXT_SGID
:
334 context_type_string
= config_event_context_sgid
;
336 case LTTNG_KERNEL_CONTEXT_VUID
:
337 context_type_string
= config_event_context_vuid
;
339 case LTTNG_KERNEL_CONTEXT_VEUID
:
340 context_type_string
= config_event_context_veuid
;
342 case LTTNG_KERNEL_CONTEXT_VSUID
:
343 context_type_string
= config_event_context_vsuid
;
345 case LTTNG_KERNEL_CONTEXT_VGID
:
346 context_type_string
= config_event_context_vgid
;
348 case LTTNG_KERNEL_CONTEXT_VEGID
:
349 context_type_string
= config_event_context_vegid
;
351 case LTTNG_KERNEL_CONTEXT_VSGID
:
352 context_type_string
= config_event_context_vsgid
;
355 context_type_string
= NULL
;
358 return context_type_string
;
362 const char *get_ust_context_type_string(
363 enum lttng_ust_context_type context_type
)
365 const char *context_type_string
;
367 switch (context_type
) {
368 case LTTNG_UST_CONTEXT_PROCNAME
:
369 context_type_string
= config_event_context_procname
;
371 case LTTNG_UST_CONTEXT_VPID
:
372 context_type_string
= config_event_context_vpid
;
374 case LTTNG_UST_CONTEXT_VTID
:
375 context_type_string
= config_event_context_vtid
;
377 case LTTNG_UST_CONTEXT_IP
:
378 context_type_string
= config_event_context_ip
;
380 case LTTNG_UST_CONTEXT_PTHREAD_ID
:
381 context_type_string
= config_event_context_pthread_id
;
383 case LTTNG_UST_CONTEXT_APP_CONTEXT
:
384 context_type_string
= config_event_context_app
;
386 case LTTNG_UST_CONTEXT_CGROUP_NS
:
387 context_type_string
= config_event_context_cgroup_ns
;
389 case LTTNG_UST_CONTEXT_IPC_NS
:
390 context_type_string
= config_event_context_ipc_ns
;
392 case LTTNG_UST_CONTEXT_MNT_NS
:
393 context_type_string
= config_event_context_mnt_ns
;
395 case LTTNG_UST_CONTEXT_NET_NS
:
396 context_type_string
= config_event_context_net_ns
;
398 case LTTNG_UST_CONTEXT_PID_NS
:
399 context_type_string
= config_event_context_pid_ns
;
401 case LTTNG_UST_CONTEXT_USER_NS
:
402 context_type_string
= config_event_context_user_ns
;
404 case LTTNG_UST_CONTEXT_UTS_NS
:
405 context_type_string
= config_event_context_uts_ns
;
407 case LTTNG_UST_CONTEXT_VUID
:
408 context_type_string
= config_event_context_vuid
;
410 case LTTNG_UST_CONTEXT_VEUID
:
411 context_type_string
= config_event_context_veuid
;
413 case LTTNG_UST_CONTEXT_VSUID
:
414 context_type_string
= config_event_context_vsuid
;
416 case LTTNG_UST_CONTEXT_VGID
:
417 context_type_string
= config_event_context_vgid
;
419 case LTTNG_UST_CONTEXT_VEGID
:
420 context_type_string
= config_event_context_vegid
;
422 case LTTNG_UST_CONTEXT_VSGID
:
423 context_type_string
= config_event_context_vsgid
;
425 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
:
427 * Error, should not be stored in the XML, perf contexts
428 * are stored as a node of type event_perf_context_type.
431 context_type_string
= NULL
;
435 return context_type_string
;
439 const char *get_buffer_type_string(
440 enum lttng_buffer_type buffer_type
)
442 const char *buffer_type_string
;
444 switch (buffer_type
) {
445 case LTTNG_BUFFER_PER_PID
:
446 buffer_type_string
= config_buffer_type_per_pid
;
448 case LTTNG_BUFFER_PER_UID
:
449 buffer_type_string
= config_buffer_type_per_uid
;
451 case LTTNG_BUFFER_GLOBAL
:
452 buffer_type_string
= config_buffer_type_global
;
455 buffer_type_string
= NULL
;
458 return buffer_type_string
;
462 const char *get_loglevel_type_string(
463 enum lttng_ust_loglevel_type loglevel_type
)
465 const char *loglevel_type_string
;
467 switch (loglevel_type
) {
468 case LTTNG_UST_LOGLEVEL_ALL
:
469 loglevel_type_string
= config_loglevel_type_all
;
471 case LTTNG_UST_LOGLEVEL_RANGE
:
472 loglevel_type_string
= config_loglevel_type_range
;
474 case LTTNG_UST_LOGLEVEL_SINGLE
:
475 loglevel_type_string
= config_loglevel_type_single
;
478 loglevel_type_string
= NULL
;
481 return loglevel_type_string
;
485 int save_kernel_function_event(struct config_writer
*writer
,
486 struct ltt_kernel_event
*event
)
490 ret
= config_writer_open_element(writer
, config_element_function_attributes
);
492 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
496 ret
= config_writer_write_element_string(writer
, config_element_name
,
497 event
->event
->u
.ftrace
.symbol_name
);
499 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
503 /* /function attributes */
504 ret
= config_writer_close_element(writer
);
506 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
514 int save_kernel_kprobe_event(struct config_writer
*writer
,
515 struct ltt_kernel_event
*event
)
518 const char *symbol_name
;
522 switch (event
->event
->instrumentation
) {
523 case LTTNG_KERNEL_KPROBE
:
525 * Comments in lttng-kernel.h mention that
526 * either addr or symbol_name are set, not both.
528 addr
= event
->event
->u
.kprobe
.addr
;
529 offset
= event
->event
->u
.kprobe
.offset
;
530 symbol_name
= addr
? NULL
: event
->event
->u
.kprobe
.symbol_name
;
532 case LTTNG_KERNEL_KRETPROBE
:
533 addr
= event
->event
->u
.kretprobe
.addr
;
534 offset
= event
->event
->u
.kretprobe
.offset
;
535 symbol_name
= addr
? NULL
: event
->event
->u
.kretprobe
.symbol_name
;
539 ERR("Unsupported kernel instrumentation type.");
540 ret
= LTTNG_ERR_INVALID
;
544 ret
= config_writer_open_element(writer
, config_element_probe_attributes
);
546 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
551 ret
= config_writer_write_element_unsigned_int( writer
,
552 config_element_address
, addr
);
554 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
557 } else if (symbol_name
) {
558 ret
= config_writer_write_element_string(writer
,
559 config_element_symbol_name
, symbol_name
);
561 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
564 /* If the offset is non-zero, write it.*/
566 ret
= config_writer_write_element_unsigned_int(writer
,
567 config_element_offset
, offset
);
569 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
575 * This really should not happen as we are either setting the
576 * address or the symbol above.
578 ERR("Invalid probe/function description.");
579 ret
= LTTNG_ERR_INVALID
;
584 ret
= config_writer_close_element(writer
);
586 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
594 * Save the userspace probe tracepoint event associated with the event to the
598 int save_kernel_userspace_probe_tracepoint_event(struct config_writer
*writer
,
599 struct ltt_kernel_event
*event
)
602 const char *probe_name
, *provider_name
, *binary_path
;
603 const struct lttng_userspace_probe_location
*userspace_probe_location
;
604 const struct lttng_userspace_probe_location_lookup_method
*lookup_method
;
605 enum lttng_userspace_probe_location_lookup_method_type lookup_type
;
607 /* Get userspace probe location from the event. */
608 userspace_probe_location
= event
->userspace_probe_location
;
609 if (!userspace_probe_location
) {
610 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
614 /* Get lookup method and lookup method type. */
615 lookup_method
= lttng_userspace_probe_location_get_lookup_method(userspace_probe_location
);
616 if (!lookup_method
) {
617 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
621 lookup_type
= lttng_userspace_probe_location_lookup_method_get_type(lookup_method
);
623 /* Get the binary path, probe name and provider name. */
625 lttng_userspace_probe_location_tracepoint_get_binary_path(
626 userspace_probe_location
);
628 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
633 lttng_userspace_probe_location_tracepoint_get_probe_name(
634 userspace_probe_location
);
636 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
641 lttng_userspace_probe_location_tracepoint_get_provider_name(
642 userspace_probe_location
);
643 if (!provider_name
) {
644 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
648 /* Open a userspace probe tracepoint attribute. */
649 ret
= config_writer_open_element(writer
, config_element_userspace_probe_tracepoint_attributes
);
651 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
655 switch (lookup_type
) {
656 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT
:
657 ret
= config_writer_write_element_string(writer
,
658 config_element_userspace_probe_lookup
,
659 config_element_userspace_probe_lookup_tracepoint_sdt
);
661 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
666 ERR("Unsupported kernel userspace probe tracepoint lookup method.");
667 ret
= LTTNG_ERR_INVALID
;
671 /* Write the binary path, provider name and the probe name. */
672 ret
= config_writer_write_element_string(writer
,
673 config_element_userspace_probe_location_binary_path
,
676 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
680 ret
= config_writer_write_element_string(writer
,
681 config_element_userspace_probe_tracepoint_location_provider_name
,
684 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
688 ret
= config_writer_write_element_string(writer
,
689 config_element_userspace_probe_tracepoint_location_probe_name
,
692 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
696 /* Close the userspace probe tracepoint attribute. */
697 ret
= config_writer_close_element(writer
);
699 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
708 * Save the userspace probe function event associated with the event to the
712 int save_kernel_userspace_probe_function_event(struct config_writer
*writer
,
713 struct ltt_kernel_event
*event
)
716 const char *function_name
, *binary_path
;
717 const struct lttng_userspace_probe_location
*userspace_probe_location
;
718 const struct lttng_userspace_probe_location_lookup_method
*lookup_method
;
719 enum lttng_userspace_probe_location_lookup_method_type lookup_type
;
721 /* Get userspace probe location from the event. */
722 userspace_probe_location
= event
->userspace_probe_location
;
723 if (!userspace_probe_location
) {
724 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
728 /* Get lookup method and lookup method type. */
729 lookup_method
= lttng_userspace_probe_location_get_lookup_method(
730 userspace_probe_location
);
731 if (!lookup_method
) {
732 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
736 /* Get the binary path and the function name. */
738 lttng_userspace_probe_location_function_get_binary_path(
739 userspace_probe_location
);
741 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
746 lttng_userspace_probe_location_function_get_function_name(
747 userspace_probe_location
);
748 if (!function_name
) {
749 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
753 /* Open a userspace probe function attribute. */
754 ret
= config_writer_open_element(writer
,
755 config_element_userspace_probe_function_attributes
);
757 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
761 lookup_type
= lttng_userspace_probe_location_lookup_method_get_type(lookup_method
);
762 switch (lookup_type
) {
763 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF
:
764 ret
= config_writer_write_element_string(writer
,
765 config_element_userspace_probe_lookup
,
766 config_element_userspace_probe_lookup_function_elf
);
768 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
772 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT
:
773 ret
= config_writer_write_element_string(writer
,
774 config_element_userspace_probe_lookup
,
775 config_element_userspace_probe_lookup_function_default
);
777 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
782 ERR("Unsupported kernel userspace probe function lookup method.");
783 ret
= LTTNG_ERR_INVALID
;
787 /* Write the binary path and the function name. */
788 ret
= config_writer_write_element_string(writer
,
789 config_element_userspace_probe_location_binary_path
,
792 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
796 ret
= config_writer_write_element_string(writer
,
797 config_element_userspace_probe_function_location_function_name
,
800 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
804 /* Close the userspace probe function attribute. */
805 ret
= config_writer_close_element(writer
);
807 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
816 int save_kernel_userspace_probe_event(struct config_writer
*writer
,
817 struct ltt_kernel_event
*event
)
820 struct lttng_userspace_probe_location
*userspace_probe_location
;
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 switch(lttng_userspace_probe_location_get_type(userspace_probe_location
)) {
830 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION
:
832 ret
= save_kernel_userspace_probe_function_event(writer
, event
);
834 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
839 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT
:
841 ret
= save_kernel_userspace_probe_tracepoint_event(writer
, event
);
843 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
848 case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_UNKNOWN
:
850 ERR("Unsupported kernel userspace probe location type.");
851 ret
= LTTNG_ERR_INVALID
;
860 int save_kernel_event(struct config_writer
*writer
,
861 struct ltt_kernel_event
*event
)
864 const char *instrumentation_type
;
866 ret
= config_writer_open_element(writer
, config_element_event
);
868 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
872 if (event
->event
->name
[0]) {
873 ret
= config_writer_write_element_string(writer
,
874 config_element_name
, event
->event
->name
);
876 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
881 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
884 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
888 instrumentation_type
= get_kernel_instrumentation_string(
889 event
->event
->instrumentation
);
890 if (!instrumentation_type
) {
891 ret
= LTTNG_ERR_INVALID
;
895 ret
= config_writer_write_element_string(writer
, config_element_type
,
896 instrumentation_type
);
898 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
902 if (event
->filter_expression
) {
903 ret
= config_writer_write_element_string(writer
,
904 config_element_filter
,
905 event
->filter_expression
);
907 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
912 if (event
->event
->instrumentation
== LTTNG_KERNEL_FUNCTION
||
913 event
->event
->instrumentation
== LTTNG_KERNEL_KPROBE
||
914 event
->event
->instrumentation
== LTTNG_KERNEL_UPROBE
||
915 event
->event
->instrumentation
== LTTNG_KERNEL_KRETPROBE
) {
917 ret
= config_writer_open_element(writer
,
918 config_element_attributes
);
920 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
924 switch (event
->event
->instrumentation
) {
925 case LTTNG_KERNEL_SYSCALL
:
926 case LTTNG_KERNEL_FUNCTION
:
927 ret
= save_kernel_function_event(writer
, event
);
932 case LTTNG_KERNEL_KPROBE
:
933 case LTTNG_KERNEL_KRETPROBE
:
934 ret
= save_kernel_kprobe_event(writer
, event
);
939 case LTTNG_KERNEL_UPROBE
:
940 ret
= save_kernel_userspace_probe_event(writer
, event
);
946 ERR("Unsupported kernel instrumentation type.");
947 ret
= LTTNG_ERR_INVALID
;
952 ret
= config_writer_close_element(writer
);
954 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
960 ret
= config_writer_close_element(writer
);
962 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
970 int save_kernel_events(struct config_writer
*writer
,
971 struct ltt_kernel_channel
*kchan
)
974 struct ltt_kernel_event
*event
;
976 ret
= config_writer_open_element(writer
, config_element_events
);
978 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
982 cds_list_for_each_entry(event
, &kchan
->events_list
.head
, list
) {
983 ret
= save_kernel_event(writer
, event
);
990 ret
= config_writer_close_element(writer
);
992 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1000 int save_ust_event(struct config_writer
*writer
,
1001 struct ltt_ust_event
*event
)
1004 const char *loglevel_type_string
;
1006 ret
= config_writer_open_element(writer
, config_element_event
);
1008 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1012 if (event
->attr
.name
[0]) {
1013 ret
= config_writer_write_element_string(writer
,
1014 config_element_name
, event
->attr
.name
);
1016 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1021 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1024 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1028 if (event
->attr
.instrumentation
!= LTTNG_UST_TRACEPOINT
) {
1029 ERR("Unsupported UST instrumentation type.");
1030 ret
= LTTNG_ERR_INVALID
;
1033 ret
= config_writer_write_element_string(writer
, config_element_type
,
1034 config_event_type_tracepoint
);
1036 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1040 loglevel_type_string
= get_loglevel_type_string(
1041 event
->attr
.loglevel_type
);
1042 if (!loglevel_type_string
) {
1043 ERR("Unsupported UST loglevel type.");
1044 ret
= LTTNG_ERR_INVALID
;
1048 ret
= config_writer_write_element_string(writer
,
1049 config_element_loglevel_type
, loglevel_type_string
);
1051 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1055 /* The log level is irrelevant if no "filtering" is enabled */
1056 if (event
->attr
.loglevel_type
!= LTTNG_UST_LOGLEVEL_ALL
) {
1057 ret
= config_writer_write_element_signed_int(writer
,
1058 config_element_loglevel
, event
->attr
.loglevel
);
1060 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1065 if (event
->filter_expression
) {
1066 ret
= config_writer_write_element_string(writer
,
1067 config_element_filter
, event
->filter_expression
);
1069 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1074 if (event
->exclusion
&& event
->exclusion
->count
) {
1077 ret
= config_writer_open_element(writer
,
1078 config_element_exclusions
);
1080 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1084 for (i
= 0; i
< event
->exclusion
->count
; i
++) {
1085 ret
= config_writer_write_element_string(writer
,
1086 config_element_exclusion
,
1087 LTTNG_EVENT_EXCLUSION_NAME_AT(
1088 event
->exclusion
, i
));
1090 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1096 ret
= config_writer_close_element(writer
);
1098 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1104 ret
= config_writer_close_element(writer
);
1106 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1114 int save_ust_events(struct config_writer
*writer
,
1115 struct lttng_ht
*events
)
1118 struct ltt_ust_event
*event
;
1119 struct lttng_ht_node_str
*node
;
1120 struct lttng_ht_iter iter
;
1122 ret
= config_writer_open_element(writer
, config_element_events
);
1124 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1129 cds_lfht_for_each_entry(events
->ht
, &iter
.iter
, node
, node
) {
1130 event
= caa_container_of(node
, struct ltt_ust_event
, node
);
1132 if (event
->internal
) {
1133 /* Internal events must not be exposed to clients */
1136 ret
= save_ust_event(writer
, event
);
1145 ret
= config_writer_close_element(writer
);
1147 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1155 int init_ust_event_from_agent_event(struct ltt_ust_event
*ust_event
,
1156 struct agent_event
*agent_event
)
1159 enum lttng_ust_loglevel_type ust_loglevel_type
;
1161 ust_event
->enabled
= agent_event
->enabled
;
1162 ust_event
->attr
.instrumentation
= LTTNG_UST_TRACEPOINT
;
1163 if (lttng_strncpy(ust_event
->attr
.name
, agent_event
->name
,
1164 LTTNG_SYMBOL_NAME_LEN
)) {
1168 switch (agent_event
->loglevel_type
) {
1169 case LTTNG_EVENT_LOGLEVEL_ALL
:
1170 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_ALL
;
1172 case LTTNG_EVENT_LOGLEVEL_SINGLE
:
1173 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_SINGLE
;
1175 case LTTNG_EVENT_LOGLEVEL_RANGE
:
1176 ust_loglevel_type
= LTTNG_UST_LOGLEVEL_RANGE
;
1179 ERR("Invalid agent_event loglevel_type.");
1184 ust_event
->attr
.loglevel_type
= ust_loglevel_type
;
1185 ust_event
->attr
.loglevel
= agent_event
->loglevel_value
;
1186 ust_event
->filter_expression
= agent_event
->filter_expression
;
1187 ust_event
->exclusion
= agent_event
->exclusion
;
1193 int save_agent_events(struct config_writer
*writer
,
1194 struct agent
*agent
)
1197 struct lttng_ht_iter iter
;
1198 struct lttng_ht_node_str
*node
;
1200 ret
= config_writer_open_element(writer
, config_element_events
);
1202 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1207 cds_lfht_for_each_entry(agent
->events
->ht
, &iter
.iter
, node
, node
) {
1209 struct agent_event
*agent_event
;
1210 struct ltt_ust_event fake_event
;
1212 memset(&fake_event
, 0, sizeof(fake_event
));
1213 agent_event
= caa_container_of(node
, struct agent_event
, node
);
1216 * Initialize a fake ust event to reuse the same serialization
1217 * function since UST and agent events contain the same info
1218 * (and one could wonder why they don't reuse the same
1221 ret
= init_ust_event_from_agent_event(&fake_event
, agent_event
);
1226 ret
= save_ust_event(writer
, &fake_event
);
1235 ret
= config_writer_close_element(writer
);
1237 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1245 int save_kernel_context(struct config_writer
*writer
,
1246 struct lttng_kernel_context
*ctx
)
1254 ret
= config_writer_open_element(writer
, config_element_context
);
1256 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1260 if (ctx
->ctx
== LTTNG_KERNEL_CONTEXT_PERF_CPU_COUNTER
) {
1261 ret
= config_writer_open_element(writer
,
1262 config_element_context_perf
);
1264 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1268 ret
= config_writer_write_element_unsigned_int(writer
,
1269 config_element_type
, ctx
->u
.perf_counter
.type
);
1271 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1275 ret
= config_writer_write_element_unsigned_int(writer
,
1276 config_element_config
, ctx
->u
.perf_counter
.config
);
1278 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1282 ret
= config_writer_write_element_string(writer
,
1283 config_element_name
, ctx
->u
.perf_counter
.name
);
1285 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1290 ret
= config_writer_close_element(writer
);
1292 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1296 const char *context_type_string
=
1297 get_kernel_context_type_string(ctx
->ctx
);
1299 if (!context_type_string
) {
1300 ERR("Unsupported kernel context type.");
1301 ret
= LTTNG_ERR_INVALID
;
1305 ret
= config_writer_write_element_string(writer
,
1306 config_element_type
, context_type_string
);
1308 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1314 ret
= config_writer_close_element(writer
);
1316 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1325 int save_kernel_contexts(struct config_writer
*writer
,
1326 struct ltt_kernel_channel
*kchan
)
1329 struct ltt_kernel_context
*ctx
;
1331 if (cds_list_empty(&kchan
->ctx_list
)) {
1336 ret
= config_writer_open_element(writer
, config_element_contexts
);
1338 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1342 cds_list_for_each_entry(ctx
, &kchan
->ctx_list
, list
) {
1343 ret
= save_kernel_context(writer
, &ctx
->ctx
);
1350 ret
= config_writer_close_element(writer
);
1352 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1360 int save_ust_context_perf_thread_counter(struct config_writer
*writer
,
1361 struct ltt_ust_context
*ctx
)
1368 /* Perf contexts are saved as event_perf_context_type */
1369 ret
= config_writer_open_element(writer
, config_element_context_perf
);
1371 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1375 ret
= config_writer_write_element_unsigned_int(writer
,
1376 config_element_type
, ctx
->ctx
.u
.perf_counter
.type
);
1378 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1382 ret
= config_writer_write_element_unsigned_int(writer
,
1383 config_element_config
, ctx
->ctx
.u
.perf_counter
.config
);
1385 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1389 ret
= config_writer_write_element_string(writer
, config_element_name
,
1390 ctx
->ctx
.u
.perf_counter
.name
);
1392 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1397 ret
= config_writer_close_element(writer
);
1399 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1407 int save_ust_context_app_ctx(struct config_writer
*writer
,
1408 struct ltt_ust_context
*ctx
)
1415 /* Application contexts are saved as application_context_type */
1416 ret
= config_writer_open_element(writer
, config_element_context_app
);
1418 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1422 ret
= config_writer_write_element_string(writer
,
1423 config_element_context_app_provider_name
,
1424 ctx
->ctx
.u
.app_ctx
.provider_name
);
1426 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1430 ret
= config_writer_write_element_string(writer
,
1431 config_element_context_app_ctx_name
,
1432 ctx
->ctx
.u
.app_ctx
.ctx_name
);
1434 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1439 ret
= config_writer_close_element(writer
);
1441 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1449 int save_ust_context_generic(struct config_writer
*writer
,
1450 struct ltt_ust_context
*ctx
)
1453 const char *context_type_string
;
1458 /* Save context as event_context_type_type */
1459 context_type_string
= get_ust_context_type_string(
1461 if (!context_type_string
) {
1462 ERR("Unsupported UST context type.");
1463 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1467 ret
= config_writer_write_element_string(writer
,
1468 config_element_type
, context_type_string
);
1470 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1478 int save_ust_context(struct config_writer
*writer
,
1479 struct cds_list_head
*ctx_list
)
1482 struct ltt_ust_context
*ctx
;
1487 ret
= config_writer_open_element(writer
, config_element_contexts
);
1489 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1493 cds_list_for_each_entry(ctx
, ctx_list
, list
) {
1494 ret
= config_writer_open_element(writer
,
1495 config_element_context
);
1497 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1501 switch (ctx
->ctx
.ctx
) {
1502 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER
:
1503 ret
= save_ust_context_perf_thread_counter(writer
, ctx
);
1505 case LTTNG_UST_CONTEXT_APP_CONTEXT
:
1506 ret
= save_ust_context_app_ctx(writer
, ctx
);
1509 /* Save generic context. */
1510 ret
= save_ust_context_generic(writer
, ctx
);
1517 ret
= config_writer_close_element(writer
);
1519 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1525 ret
= config_writer_close_element(writer
);
1527 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1535 int save_kernel_channel(struct config_writer
*writer
,
1536 struct ltt_kernel_channel
*kchan
)
1543 ret
= config_writer_open_element(writer
, config_element_channel
);
1545 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1549 ret
= config_writer_write_element_string(writer
, config_element_name
,
1550 kchan
->channel
->name
);
1552 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1556 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1557 kchan
->channel
->enabled
);
1559 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1563 ret
= save_kernel_channel_attributes(writer
, &kchan
->channel
->attr
);
1568 ret
= save_kernel_events(writer
, kchan
);
1573 ret
= save_kernel_contexts(writer
, kchan
);
1579 ret
= config_writer_close_element(writer
);
1581 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1589 int save_ust_channel(struct config_writer
*writer
,
1590 struct ltt_ust_channel
*ust_chan
,
1591 struct ltt_ust_session
*session
)
1599 ret
= config_writer_open_element(writer
, config_element_channel
);
1601 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1605 ret
= config_writer_write_element_string(writer
, config_element_name
,
1608 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1612 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
1615 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1619 ret
= save_ust_channel_attributes(writer
, &ust_chan
->attr
);
1624 ret
= config_writer_write_element_unsigned_int(writer
,
1625 config_element_tracefile_size
, ust_chan
->tracefile_size
);
1627 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1631 ret
= config_writer_write_element_unsigned_int(writer
,
1632 config_element_tracefile_count
, ust_chan
->tracefile_count
);
1634 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1638 ret
= config_writer_write_element_unsigned_int(writer
,
1639 config_element_live_timer_interval
,
1640 session
->live_timer_interval
);
1642 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1646 if (ust_chan
->domain
== LTTNG_DOMAIN_UST
) {
1647 ret
= save_ust_events(writer
, ust_chan
->events
);
1652 struct agent
*agent
= NULL
;
1654 agent
= trace_ust_find_agent(session
, ust_chan
->domain
);
1656 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1657 ERR("Could not find agent associated to UST subdomain");
1662 * Channels associated with a UST sub-domain (such as JUL, Log4j
1663 * or Python) don't have any non-internal events. We retrieve
1664 * the "agent" events associated with this channel and serialize
1667 ret
= save_agent_events(writer
, agent
);
1673 ret
= save_ust_context(writer
, &ust_chan
->ctx_list
);
1679 ret
= config_writer_close_element(writer
);
1681 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1689 int save_kernel_session(struct config_writer
*writer
,
1690 struct ltt_session
*session
)
1693 struct ltt_kernel_channel
*kchan
;
1698 ret
= config_writer_write_element_string(writer
, config_element_type
,
1699 config_domain_type_kernel
);
1701 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1705 ret
= config_writer_write_element_string(writer
,
1706 config_element_buffer_type
, config_buffer_type_global
);
1708 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1712 ret
= config_writer_open_element(writer
,
1713 config_element_channels
);
1715 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1719 cds_list_for_each_entry(kchan
, &session
->kernel_session
->channel_list
.head
,
1721 ret
= save_kernel_channel(writer
, kchan
);
1728 ret
= config_writer_close_element(writer
);
1730 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1738 const char *get_config_domain_str(enum lttng_domain_type domain
)
1740 const char *str_dom
;
1743 case LTTNG_DOMAIN_KERNEL
:
1744 str_dom
= config_domain_type_kernel
;
1746 case LTTNG_DOMAIN_UST
:
1747 str_dom
= config_domain_type_ust
;
1749 case LTTNG_DOMAIN_JUL
:
1750 str_dom
= config_domain_type_jul
;
1752 case LTTNG_DOMAIN_LOG4J
:
1753 str_dom
= config_domain_type_log4j
;
1755 case LTTNG_DOMAIN_PYTHON
:
1756 str_dom
= config_domain_type_python
;
1766 int save_pid_tracker(struct config_writer
*writer
,
1767 struct ltt_session
*sess
, int domain
)
1770 ssize_t nr_pids
= 0, i
;
1771 int32_t *pids
= NULL
;
1774 case LTTNG_DOMAIN_KERNEL
:
1776 nr_pids
= kernel_list_tracker_pids(sess
->kernel_session
, &pids
);
1778 ret
= LTTNG_ERR_KERN_LIST_FAIL
;
1783 case LTTNG_DOMAIN_UST
:
1785 nr_pids
= trace_ust_list_tracker_pids(sess
->ust_session
, &pids
);
1787 ret
= LTTNG_ERR_UST_LIST_FAIL
;
1792 case LTTNG_DOMAIN_JUL
:
1793 case LTTNG_DOMAIN_LOG4J
:
1794 case LTTNG_DOMAIN_PYTHON
:
1796 ret
= LTTNG_ERR_UNKNOWN_DOMAIN
;
1800 /* Only create a pid_tracker if enabled or untrack all */
1801 if (nr_pids
!= 1 || (nr_pids
== 1 && pids
[0] != -1)) {
1802 ret
= config_writer_open_element(writer
,
1803 config_element_pid_tracker
);
1805 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1809 ret
= config_writer_open_element(writer
,
1810 config_element_targets
);
1812 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1816 for (i
= 0; i
< nr_pids
; i
++) {
1817 ret
= config_writer_open_element(writer
,
1818 config_element_target_pid
);
1820 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1824 ret
= config_writer_write_element_unsigned_int(writer
,
1825 config_element_pid
, pids
[i
]);
1827 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1832 ret
= config_writer_close_element(writer
);
1834 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1840 ret
= config_writer_close_element(writer
);
1842 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1847 ret
= config_writer_close_element(writer
);
1849 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1859 int save_ust_domain(struct config_writer
*writer
,
1860 struct ltt_session
*session
, enum lttng_domain_type domain
)
1863 struct ltt_ust_channel
*ust_chan
;
1864 const char *buffer_type_string
;
1865 struct lttng_ht_node_str
*node
;
1866 struct lttng_ht_iter iter
;
1867 const char *config_domain_name
;
1872 ret
= config_writer_open_element(writer
,
1873 config_element_domain
);
1875 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1879 config_domain_name
= get_config_domain_str(domain
);
1880 if (!config_domain_name
) {
1881 ret
= LTTNG_ERR_INVALID
;
1885 ret
= config_writer_write_element_string(writer
,
1886 config_element_type
, config_domain_name
);
1888 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1892 buffer_type_string
= get_buffer_type_string(
1893 session
->ust_session
->buffer_type
);
1894 if (!buffer_type_string
) {
1895 ERR("Unsupported buffer type.");
1896 ret
= LTTNG_ERR_INVALID
;
1900 ret
= config_writer_write_element_string(writer
,
1901 config_element_buffer_type
, buffer_type_string
);
1903 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1907 ret
= config_writer_open_element(writer
, config_element_channels
);
1909 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1914 cds_lfht_for_each_entry(session
->ust_session
->domain_global
.channels
->ht
,
1915 &iter
.iter
, node
, node
) {
1916 ust_chan
= caa_container_of(node
, struct ltt_ust_channel
, node
);
1917 if (domain
== ust_chan
->domain
) {
1918 ret
= save_ust_channel(writer
, ust_chan
, session
->ust_session
);
1928 ret
= config_writer_close_element(writer
);
1930 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1934 if (domain
== LTTNG_DOMAIN_UST
) {
1935 ret
= config_writer_open_element(writer
,
1936 config_element_trackers
);
1938 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1942 ret
= save_pid_tracker(writer
, session
, LTTNG_DOMAIN_UST
);
1948 ret
= config_writer_close_element(writer
);
1955 ret
= config_writer_close_element(writer
);
1957 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1966 int save_domains(struct config_writer
*writer
, struct ltt_session
*session
)
1973 if (!session
->kernel_session
&& !session
->ust_session
) {
1977 ret
= config_writer_open_element(writer
, config_element_domains
);
1979 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1984 if (session
->kernel_session
) {
1985 ret
= config_writer_open_element(writer
,
1986 config_element_domain
);
1988 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
1992 ret
= save_kernel_session(writer
, session
);
1997 ret
= config_writer_open_element(writer
,
1998 config_element_trackers
);
2000 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2004 ret
= save_pid_tracker(writer
, session
, LTTNG_DOMAIN_KERNEL
);
2010 ret
= config_writer_close_element(writer
);
2012 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2016 ret
= config_writer_close_element(writer
);
2018 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2023 if (session
->ust_session
) {
2024 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_UST
);
2029 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_JUL
);
2034 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_LOG4J
);
2039 ret
= save_ust_domain(writer
, session
, LTTNG_DOMAIN_PYTHON
);
2046 ret
= config_writer_close_element(writer
);
2048 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2056 int save_consumer_output(struct config_writer
*writer
,
2057 struct consumer_output
*output
)
2064 ret
= config_writer_open_element(writer
, config_element_consumer_output
);
2066 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2070 ret
= config_writer_write_element_bool(writer
, config_element_enabled
,
2073 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2077 ret
= config_writer_open_element(writer
, config_element_destination
);
2079 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2083 switch (output
->type
) {
2084 case CONSUMER_DST_LOCAL
:
2085 ret
= config_writer_write_element_string(writer
,
2086 config_element_path
, output
->dst
.session_root_path
);
2088 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2092 case CONSUMER_DST_NET
:
2096 uri
= zmalloc(PATH_MAX
);
2098 ret
= LTTNG_ERR_NOMEM
;
2102 ret
= config_writer_open_element(writer
, config_element_net_output
);
2104 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2105 goto end_net_output
;
2108 if (output
->dst
.net
.control_isset
&&
2109 output
->dst
.net
.data_isset
) {
2110 ret
= uri_to_str_url(&output
->dst
.net
.control
, uri
, PATH_MAX
);
2112 ret
= LTTNG_ERR_INVALID
;
2113 goto end_net_output
;
2116 ret
= config_writer_write_element_string(writer
,
2117 config_element_control_uri
, uri
);
2119 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2120 goto end_net_output
;
2123 ret
= uri_to_str_url(&output
->dst
.net
.data
, uri
, PATH_MAX
);
2125 ret
= LTTNG_ERR_INVALID
;
2126 goto end_net_output
;
2129 ret
= config_writer_write_element_string(writer
,
2130 config_element_data_uri
, uri
);
2132 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2133 goto end_net_output
;
2142 ret
= !output
->dst
.net
.control_isset
?
2143 LTTNG_ERR_URL_CTRL_MISS
:
2144 LTTNG_ERR_URL_DATA_MISS
;
2149 ret
= config_writer_close_element(writer
);
2151 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2157 ERR("Unsupported consumer output type.");
2158 ret
= LTTNG_ERR_INVALID
;
2163 ret
= config_writer_close_element(writer
);
2165 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2169 /* /consumer_output */
2170 ret
= config_writer_close_element(writer
);
2172 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2180 int save_snapshot_outputs(struct config_writer
*writer
,
2181 struct snapshot
*snapshot
)
2184 struct lttng_ht_iter iter
;
2185 struct snapshot_output
*output
;
2190 ret
= config_writer_open_element(writer
, config_element_snapshot_outputs
);
2192 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2197 cds_lfht_for_each_entry(snapshot
->output_ht
->ht
, &iter
.iter
, output
,
2199 ret
= config_writer_open_element(writer
,
2200 config_element_output
);
2202 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2206 ret
= config_writer_write_element_string(writer
,
2207 config_element_name
, output
->name
);
2209 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2213 ret
= config_writer_write_element_unsigned_int(writer
,
2214 config_element_max_size
, output
->max_size
);
2216 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2220 ret
= save_consumer_output(writer
, output
->consumer
);
2226 ret
= config_writer_close_element(writer
);
2228 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2234 /* /snapshot_outputs */
2235 ret
= config_writer_close_element(writer
);
2237 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2249 int save_session_output(struct config_writer
*writer
,
2250 struct ltt_session
*session
)
2257 if ((session
->snapshot_mode
&& session
->snapshot
.nb_output
== 0) ||
2258 (!session
->snapshot_mode
&& !session
->consumer
)) {
2259 /* Session is in no output mode */
2264 ret
= config_writer_open_element(writer
, config_element_output
);
2266 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2270 if (session
->snapshot_mode
) {
2271 ret
= save_snapshot_outputs(writer
, &session
->snapshot
);
2276 if (session
->consumer
) {
2277 ret
= save_consumer_output(writer
, session
->consumer
);
2285 ret
= config_writer_close_element(writer
);
2287 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2295 int save_session_rotation_schedule(struct config_writer
*writer
,
2296 enum lttng_rotation_schedule_type type
, uint64_t value
)
2299 const char *element_name
;
2300 const char *value_name
;
2303 case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
:
2304 element_name
= config_element_rotation_schedule_periodic
;
2305 value_name
= config_element_rotation_schedule_periodic_time_us
;
2307 case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
:
2308 element_name
= config_element_rotation_schedule_size_threshold
;
2309 value_name
= config_element_rotation_schedule_size_threshold_bytes
;
2316 ret
= config_writer_open_element(writer
, element_name
);
2321 ret
= config_writer_write_element_unsigned_int(writer
,
2327 /* Close schedule descriptor element. */
2328 ret
= config_writer_close_element(writer
);
2337 int save_session_rotation_schedules(struct config_writer
*writer
,
2338 struct ltt_session
*session
)
2342 ret
= config_writer_open_element(writer
,
2343 config_element_rotation_schedules
);
2347 if (session
->rotate_timer_period
) {
2348 ret
= save_session_rotation_schedule(writer
,
2349 LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC
,
2350 session
->rotate_timer_period
);
2352 goto close_schedules
;
2355 if (session
->rotate_size
) {
2356 ret
= save_session_rotation_schedule(writer
,
2357 LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD
,
2358 session
->rotate_size
);
2360 goto close_schedules
;
2365 /* Close rotation schedules element. */
2366 ret
= config_writer_close_element(writer
);
2375 * Save the given session.
2377 * Return 0 on success else a LTTNG_ERR* code.
2380 int save_session(struct ltt_session
*session
,
2381 struct lttng_save_session_attr
*attr
, lttng_sock_cred
*creds
)
2384 char config_file_path
[LTTNG_PATH_MAX
];
2386 struct config_writer
*writer
= NULL
;
2387 size_t session_name_len
;
2388 const char *provided_path
;
2389 int file_open_flags
= O_CREAT
| O_WRONLY
| O_TRUNC
;
2395 session_name_len
= strlen(session
->name
);
2396 memset(config_file_path
, 0, sizeof(config_file_path
));
2398 if (!session_access_ok(session
,
2399 LTTNG_SOCK_GET_UID_CRED(creds
),
2400 LTTNG_SOCK_GET_GID_CRED(creds
)) || session
->destroyed
) {
2401 ret
= LTTNG_ERR_EPERM
;
2405 provided_path
= lttng_save_session_attr_get_output_url(attr
);
2406 if (provided_path
) {
2407 DBG3("Save session in provided path %s", provided_path
);
2408 len
= strlen(provided_path
);
2409 if (len
>= sizeof(config_file_path
)) {
2410 ret
= LTTNG_ERR_SET_URL
;
2413 strncpy(config_file_path
, provided_path
, sizeof(config_file_path
));
2416 char *home_dir
= utils_get_user_home_dir(
2417 LTTNG_SOCK_GET_UID_CRED(creds
));
2419 ret
= LTTNG_ERR_SET_URL
;
2423 ret_len
= snprintf(config_file_path
, sizeof(config_file_path
),
2424 DEFAULT_SESSION_HOME_CONFIGPATH
, home_dir
);
2427 PERROR("snprintf save session");
2428 ret
= LTTNG_ERR_SET_URL
;
2435 * Check the path fits in the config file path dst including the '/'
2436 * followed by trailing .lttng extension and the NULL terminated string.
2438 if ((len
+ session_name_len
+ 2 +
2439 sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
))
2440 > sizeof(config_file_path
)) {
2441 ret
= LTTNG_ERR_SET_URL
;
2445 ret
= run_as_mkdir_recursive(config_file_path
, S_IRWXU
| S_IRWXG
,
2446 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
2448 ret
= LTTNG_ERR_SET_URL
;
2453 * At this point, we know that everything fits in the buffer. Validation
2454 * was done just above.
2456 config_file_path
[len
++] = '/';
2457 strncpy(config_file_path
+ len
, session
->name
, sizeof(config_file_path
) - len
);
2458 len
+= session_name_len
;
2459 strcpy(config_file_path
+ len
, DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
2460 len
+= sizeof(DEFAULT_SESSION_CONFIG_FILE_EXTENSION
);
2461 config_file_path
[len
] = '\0';
2463 if (!attr
->overwrite
) {
2464 file_open_flags
|= O_EXCL
;
2467 fd
= run_as_open(config_file_path
, file_open_flags
,
2468 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
,
2469 LTTNG_SOCK_GET_UID_CRED(creds
), LTTNG_SOCK_GET_GID_CRED(creds
));
2471 PERROR("Could not create configuration file");
2474 ret
= LTTNG_ERR_SAVE_FILE_EXIST
;
2477 ret
= LTTNG_ERR_EPERM
;
2480 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2486 writer
= config_writer_create(fd
, 1);
2488 ret
= LTTNG_ERR_NOMEM
;
2492 ret
= config_writer_open_element(writer
, config_element_sessions
);
2494 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2498 ret
= config_writer_open_element(writer
, config_element_session
);
2500 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2504 ret
= config_writer_write_element_string(writer
, config_element_name
,
2507 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2511 if(session
->shm_path
[0] != '\0') {
2512 ret
= config_writer_write_element_string(writer
,
2513 config_element_shared_memory_path
,
2516 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2521 ret
= save_domains(writer
, session
);
2526 ret
= config_writer_write_element_bool(writer
, config_element_started
,
2529 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2533 if (session
->snapshot_mode
|| session
->live_timer
||
2534 session
->rotate_timer_period
|| session
->rotate_size
) {
2535 ret
= config_writer_open_element(writer
, config_element_attributes
);
2537 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2541 if (session
->snapshot_mode
) {
2542 ret
= config_writer_write_element_bool(writer
,
2543 config_element_snapshot_mode
, 1);
2545 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2548 } else if (session
->live_timer
) {
2549 ret
= config_writer_write_element_unsigned_int(writer
,
2550 config_element_live_timer_interval
, session
->live_timer
);
2552 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2556 if (session
->rotate_timer_period
|| session
->rotate_size
) {
2557 ret
= save_session_rotation_schedules(writer
,
2560 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2566 ret
= config_writer_close_element(writer
);
2568 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2573 ret
= save_session_output(writer
, session
);
2579 ret
= config_writer_close_element(writer
);
2581 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2586 ret
= config_writer_close_element(writer
);
2588 ret
= LTTNG_ERR_SAVE_IO_FAIL
;
2592 if (writer
&& config_writer_destroy(writer
)) {
2593 /* Preserve the original error code */
2594 ret
= ret
? ret
: LTTNG_ERR_SAVE_IO_FAIL
;
2597 /* Delete file in case of error */
2598 if ((fd
>= 0) && unlink(config_file_path
)) {
2599 PERROR("Unlinking XML session configuration.");
2606 PERROR("Closing XML session configuration");
2613 int cmd_save_sessions(struct lttng_save_session_attr
*attr
,
2614 lttng_sock_cred
*creds
)
2617 const char *session_name
;
2618 struct ltt_session
*session
;
2620 session_lock_list();
2622 session_name
= lttng_save_session_attr_get_session_name(attr
);
2624 session
= session_find_by_name(session_name
);
2626 ret
= LTTNG_ERR_SESS_NOT_FOUND
;
2630 session_lock(session
);
2631 ret
= save_session(session
, attr
, creds
);
2632 session_unlock(session
);
2633 session_put(session
);
2638 struct ltt_session_list
*list
= session_get_list();
2640 cds_list_for_each_entry(session
, &list
->head
, list
) {
2641 if (!session_get(session
)) {
2644 session_lock(session
);
2645 ret
= save_session(session
, attr
, creds
);
2646 session_unlock(session
);
2647 session_put(session
);
2648 /* Don't abort if we don't have the required permissions. */
2649 if (ret
&& ret
!= LTTNG_ERR_EPERM
) {
2657 session_unlock_list();