2 * SPDX-License-Identifier: LGPL-2.1-only
4 * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
5 * Copyright (C) 2011-2013 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
13 #include <sys/socket.h>
15 #include <sys/types.h>
22 #include <lttng/ust-ctl.h>
23 #include "common/ustcomm.h"
24 #include "common/ust-fd.h"
25 #include "common/macros.h"
26 #include "common/dynamic-type.h"
27 #include "common/logging.h"
29 #include "common/events.h"
30 #include "common/compat/pthread.h"
32 #define USTCOMM_MAX_SEND_FDS 4
35 ssize_t
count_fields_recursive(size_t nr_fields
,
36 const struct lttng_ust_event_field
* const *lttng_fields
);
38 int serialize_one_field(struct lttng_ust_session
*session
,
39 struct lttng_ust_ctl_field
*fields
, size_t *iter_output
,
40 const struct lttng_ust_event_field
*lf
,
41 const char **prev_field_name
);
43 int serialize_fields(struct lttng_ust_session
*session
,
44 struct lttng_ust_ctl_field
*lttng_ust_ctl_fields
,
45 size_t *iter_output
, size_t nr_lttng_fields
,
46 const struct lttng_ust_event_field
* const *lttng_fields
);
49 * ustcomm_connect_unix_sock
51 * Connect to unix socket using the path name.
53 * Caller handles FD tracker.
55 int ustcomm_connect_unix_sock(const char *pathname
, long timeout
)
57 struct sockaddr_un sun
;
61 * libust threads require the close-on-exec flag for all
62 * resources so it does not leak file descriptors upon exec.
63 * SOCK_CLOEXEC is not used since it is linux specific.
65 fd
= socket(PF_UNIX
, SOCK_STREAM
, 0);
72 /* Give at least 10ms. */
75 ret
= ustcomm_setsockopt_snd_timeout(fd
, timeout
);
77 WARN("Error setting connect socket send timeout");
80 ret
= fcntl(fd
, F_SETFD
, FD_CLOEXEC
);
87 memset(&sun
, 0, sizeof(sun
));
88 sun
.sun_family
= AF_UNIX
;
89 strncpy(sun
.sun_path
, pathname
, sizeof(sun
.sun_path
));
90 sun
.sun_path
[sizeof(sun
.sun_path
) - 1] = '\0';
92 ret
= connect(fd
, (struct sockaddr
*) &sun
, sizeof(sun
));
95 * Don't print message on connect ENOENT error, because
96 * connect is used in normal execution to detect if
97 * sessiond is alive. ENOENT is when the unix socket
98 * file does not exist, and ECONNREFUSED is when the
99 * file exists but no sessiond is listening.
101 if (errno
!= ECONNREFUSED
&& errno
!= ECONNRESET
102 && errno
!= ENOENT
&& errno
!= EACCES
)
105 if (ret
== -ECONNREFUSED
|| ret
== -ECONNRESET
)
117 closeret
= close(fd
);
126 * ustcomm_accept_unix_sock
128 * Do an accept(2) on the sock and return the
129 * new file descriptor. The socket MUST be bind(2) before.
131 int ustcomm_accept_unix_sock(int sock
)
134 struct sockaddr_un sun
;
138 new_fd
= accept(sock
, (struct sockaddr
*) &sun
, &len
);
140 if (errno
!= ECONNABORTED
)
143 if (new_fd
== -ECONNABORTED
)
150 * ustcomm_create_unix_sock
152 * Creates a AF_UNIX local socket using pathname
153 * bind the socket upon creation and return the fd.
155 int ustcomm_create_unix_sock(const char *pathname
)
157 struct sockaddr_un sun
;
160 /* Create server socket */
161 if ((fd
= socket(PF_UNIX
, SOCK_STREAM
, 0)) < 0) {
167 memset(&sun
, 0, sizeof(sun
));
168 sun
.sun_family
= AF_UNIX
;
169 strncpy(sun
.sun_path
, pathname
, sizeof(sun
.sun_path
));
170 sun
.sun_path
[sizeof(sun
.sun_path
) - 1] = '\0';
172 /* Unlink the old file if present */
173 (void) unlink(pathname
);
174 ret
= bind(fd
, (struct sockaddr
*) &sun
, sizeof(sun
));
187 closeret
= close(fd
);
197 * ustcomm_listen_unix_sock
199 * Make the socket listen using LTTNG_UST_COMM_MAX_LISTEN.
201 int ustcomm_listen_unix_sock(int sock
)
205 ret
= listen(sock
, LTTNG_UST_COMM_MAX_LISTEN
);
215 * ustcomm_close_unix_sock
219 * Handles fd tracker internally.
221 int ustcomm_close_unix_sock(int sock
)
225 lttng_ust_lock_fd_tracker();
228 lttng_ust_delete_fd_from_tracker(sock
);
233 lttng_ust_unlock_fd_tracker();
239 * ustcomm_shutdown_unix_sock
241 * Shutdown unix socket. Keeps the file descriptor open, but shutdown
244 int ustcomm_shutdown_unix_sock(int sock
)
248 ret
= shutdown(sock
, SHUT_RDWR
);
250 PERROR("Socket shutdown error");
257 * ustcomm_recv_unix_sock
259 * Receive data of size len in put that data into
260 * the buf param. Using recvmsg API.
261 * Return the size of received data.
262 * Return 0 on orderly shutdown.
264 ssize_t
ustcomm_recv_unix_sock(int sock
, void *buf
, size_t len
)
271 memset(&msg
, 0, sizeof(msg
));
273 iov
[0].iov_base
= buf
;
274 iov
[0].iov_len
= len
;
279 len_last
= iov
[0].iov_len
;
280 ret
= recvmsg(sock
, &msg
, 0);
282 iov
[0].iov_base
+= ret
;
283 iov
[0].iov_len
-= ret
;
284 assert(ret
<= len_last
);
286 } while ((ret
> 0 && ret
< len_last
) || (ret
< 0 && errno
== EINTR
));
289 if (errno
!= EPIPE
&& errno
!= ECONNRESET
&& errno
!= ECONNREFUSED
)
292 if (ret
== -ECONNRESET
|| ret
== -ECONNREFUSED
)
295 (void) ustcomm_shutdown_unix_sock(sock
);
296 } else if (ret
> 0) {
299 /* ret = 0 means an orderly shutdown. */
305 * ustcomm_send_unix_sock
307 * Send buf data of size len. Using sendmsg API.
308 * Return the size of sent data.
310 ssize_t
ustcomm_send_unix_sock(int sock
, const void *buf
, size_t len
)
316 memset(&msg
, 0, sizeof(msg
));
318 iov
[0].iov_base
= (void *) buf
;
319 iov
[0].iov_len
= len
;
324 * Using the MSG_NOSIGNAL when sending data from sessiond to
325 * libust, so libust does not receive an unhandled SIGPIPE or
326 * SIGURG. The sessiond receiver side can be made more resilient
327 * by ignoring SIGPIPE, but we don't have this luxury on the
331 ret
= sendmsg(sock
, &msg
, MSG_NOSIGNAL
);
332 } while (ret
< 0 && errno
== EINTR
);
335 if (errno
!= EPIPE
&& errno
!= ECONNRESET
)
338 if (ret
== -ECONNRESET
)
341 (void) ustcomm_shutdown_unix_sock(sock
);
348 * Send a message accompanied by fd(s) over a unix socket.
350 * Returns the size of data sent, or negative error value.
352 ssize_t
ustcomm_send_fds_unix_sock(int sock
, int *fds
, size_t nb_fd
)
355 struct cmsghdr
*cmptr
;
358 unsigned int sizeof_fds
= nb_fd
* sizeof(int);
359 char tmp
[CMSG_SPACE(sizeof_fds
)];
362 memset(&msg
, 0, sizeof(msg
));
363 memset(tmp
, 0, CMSG_SPACE(sizeof_fds
) * sizeof(char));
365 if (nb_fd
> USTCOMM_MAX_SEND_FDS
)
368 msg
.msg_control
= (caddr_t
)tmp
;
369 msg
.msg_controllen
= CMSG_LEN(sizeof_fds
);
371 cmptr
= CMSG_FIRSTHDR(&msg
);
374 cmptr
->cmsg_level
= SOL_SOCKET
;
375 cmptr
->cmsg_type
= SCM_RIGHTS
;
376 cmptr
->cmsg_len
= CMSG_LEN(sizeof_fds
);
377 memcpy(CMSG_DATA(cmptr
), fds
, sizeof_fds
);
378 /* Sum of the length of all control messages in the buffer: */
379 msg
.msg_controllen
= cmptr
->cmsg_len
;
381 iov
[0].iov_base
= &dummy
;
387 ret
= sendmsg(sock
, &msg
, MSG_NOSIGNAL
);
388 } while (ret
< 0 && errno
== EINTR
);
391 * We consider EPIPE and ECONNRESET as expected.
393 if (errno
!= EPIPE
&& errno
!= ECONNRESET
) {
397 if (ret
== -ECONNRESET
)
404 * Recv a message accompanied by fd(s) from a unix socket.
406 * Expect at most "nb_fd" file descriptors. Returns the number of fd
407 * actually received in nb_fd.
408 * Returns -EPIPE on orderly shutdown.
410 ssize_t
ustcomm_recv_fds_unix_sock(int sock
, int *fds
, size_t nb_fd
)
414 struct cmsghdr
*cmsg
;
415 size_t sizeof_fds
= nb_fd
* sizeof(int);
416 char recv_fd
[CMSG_SPACE(sizeof_fds
)];
421 memset(&msg
, 0, sizeof(msg
));
423 /* Prepare to receive the structures */
424 iov
[0].iov_base
= &dummy
;
428 msg
.msg_control
= recv_fd
;
429 msg
.msg_controllen
= sizeof(recv_fd
);
432 ret
= recvmsg(sock
, &msg
, 0);
433 } while (ret
< 0 && errno
== EINTR
);
435 if (errno
!= EPIPE
&& errno
!= ECONNRESET
) {
436 PERROR("recvmsg fds");
439 if (ret
== -ECONNRESET
)
444 /* orderly shutdown */
449 ERR("Error: Received %zd bytes, expected %d\n",
453 if (msg
.msg_flags
& MSG_CTRUNC
) {
454 ERR("Error: Control message truncated.\n");
458 cmsg
= CMSG_FIRSTHDR(&msg
);
460 ERR("Error: Invalid control message header\n");
464 if (cmsg
->cmsg_level
!= SOL_SOCKET
|| cmsg
->cmsg_type
!= SCM_RIGHTS
) {
465 ERR("Didn't received any fd\n");
469 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof_fds
)) {
470 ERR("Error: Received %zu bytes of ancillary data, expected %zu\n",
471 (size_t) cmsg
->cmsg_len
, (size_t) CMSG_LEN(sizeof_fds
));
476 memcpy(fds
, CMSG_DATA(cmsg
), sizeof_fds
);
479 for (i
= 0; i
< nb_fd
; i
++) {
480 ret
= fcntl(fds
[i
], F_SETFD
, FD_CLOEXEC
);
482 PERROR("fcntl failed to set FD_CLOEXEC on fd %d",
492 int ustcomm_send_app_msg(int sock
, struct ustcomm_ust_msg
*lum
)
496 len
= ustcomm_send_unix_sock(sock
, lum
, sizeof(*lum
));
504 ERR("incorrect message size: %zd\n", len
);
511 int ustcomm_recv_app_reply(int sock
, struct ustcomm_ust_reply
*lur
,
512 uint32_t expected_handle
, uint32_t expected_cmd
)
516 memset(lur
, 0, sizeof(*lur
));
517 len
= ustcomm_recv_unix_sock(sock
, lur
, sizeof(*lur
));
519 case 0: /* orderly shutdown */
525 if (lur
->handle
!= expected_handle
) {
526 ERR("Unexpected result message handle: "
527 "expected: %u vs received: %u\n",
528 expected_handle
, lur
->handle
);
531 if (lur
->cmd
!= expected_cmd
) {
532 ERR("Unexpected result message command "
533 "expected: %u vs received: %u\n",
534 expected_cmd
, lur
->cmd
);
540 return lur
->ret_code
;
545 ERR("incorrect message size: %zd\n", len
);
551 int ustcomm_send_app_cmd(int sock
,
552 struct ustcomm_ust_msg
*lum
,
553 struct ustcomm_ust_reply
*lur
)
557 ret
= ustcomm_send_app_msg(sock
, lum
);
560 ret
= ustcomm_recv_app_reply(sock
, lur
, lum
->handle
, lum
->cmd
);
567 * chan_data is allocated internally if this function returns the
570 ssize_t
ustcomm_recv_channel_from_sessiond(int sock
,
571 void **_chan_data
, uint64_t var_len
,
578 if (var_len
> LTTNG_UST_ABI_CHANNEL_DATA_MAX_LEN
) {
582 /* Receive variable length data */
583 chan_data
= zmalloc(var_len
);
588 len
= ustcomm_recv_unix_sock(sock
, chan_data
, var_len
);
589 if (len
!= var_len
) {
593 lttng_ust_lock_fd_tracker();
594 nr_fd
= ustcomm_recv_fds_unix_sock(sock
, &wakeup_fd
, 1);
596 lttng_ust_unlock_fd_tracker();
606 ret
= lttng_ust_add_fd_to_tracker(wakeup_fd
);
608 ret
= close(wakeup_fd
);
610 PERROR("close on wakeup_fd");
613 lttng_ust_unlock_fd_tracker();
618 lttng_ust_unlock_fd_tracker();
620 *_chan_data
= chan_data
;
630 ssize_t
ustcomm_recv_event_notifier_notif_fd_from_sessiond(int sock
,
631 int *_event_notifier_notif_fd
)
634 int event_notifier_notif_fd
, ret
;
636 /* Receive event_notifier notification fd */
637 lttng_ust_lock_fd_tracker();
638 nr_fd
= ustcomm_recv_fds_unix_sock(sock
, &event_notifier_notif_fd
, 1);
640 lttng_ust_unlock_fd_tracker();
650 ret
= lttng_ust_add_fd_to_tracker(event_notifier_notif_fd
);
652 ret
= close(event_notifier_notif_fd
);
654 PERROR("close on event_notifier notif fd");
657 lttng_ust_unlock_fd_tracker();
661 *_event_notifier_notif_fd
= ret
;
662 lttng_ust_unlock_fd_tracker();
670 int ustcomm_recv_stream_from_sessiond(int sock
,
671 uint64_t *memory_map_size
__attribute__((unused
)),
672 int *shm_fd
, int *wakeup_fd
)
678 /* recv shm fd and wakeup fd */
679 lttng_ust_lock_fd_tracker();
680 len
= ustcomm_recv_fds_unix_sock(sock
, fds
, 2);
682 lttng_ust_unlock_fd_tracker();
692 ret
= lttng_ust_add_fd_to_tracker(fds
[0]);
696 PERROR("close on received shm_fd");
699 lttng_ust_unlock_fd_tracker();
704 ret
= lttng_ust_add_fd_to_tracker(fds
[1]);
706 ret
= close(*shm_fd
);
708 PERROR("close on shm_fd");
713 PERROR("close on received wakeup_fd");
716 lttng_ust_unlock_fd_tracker();
720 lttng_ust_unlock_fd_tracker();
727 ssize_t
ustcomm_recv_counter_from_sessiond(int sock
,
728 void **_counter_data
, uint64_t var_len
)
733 if (var_len
> LTTNG_UST_ABI_COUNTER_DATA_MAX_LEN
) {
737 /* Receive variable length data */
738 counter_data
= zmalloc(var_len
);
743 len
= ustcomm_recv_unix_sock(sock
, counter_data
, var_len
);
744 if (len
!= var_len
) {
747 *_counter_data
= counter_data
;
757 int ustcomm_recv_counter_shm_from_sessiond(int sock
,
765 lttng_ust_lock_fd_tracker();
766 len
= ustcomm_recv_fds_unix_sock(sock
, fds
, 1);
768 lttng_ust_unlock_fd_tracker();
778 ret
= lttng_ust_add_fd_to_tracker(fds
[0]);
782 PERROR("close on received shm_fd");
785 lttng_ust_unlock_fd_tracker();
789 lttng_ust_unlock_fd_tracker();
797 * Returns 0 on success, negative error value on error.
799 int ustcomm_send_reg_msg(int sock
,
800 enum lttng_ust_ctl_socket_type type
,
801 uint32_t bits_per_long
,
802 uint32_t uint8_t_alignment
,
803 uint32_t uint16_t_alignment
,
804 uint32_t uint32_t_alignment
,
805 uint32_t uint64_t_alignment
,
806 uint32_t long_alignment
)
809 struct lttng_ust_ctl_reg_msg reg_msg
;
811 reg_msg
.magic
= LTTNG_UST_ABI_COMM_MAGIC
;
812 reg_msg
.major
= LTTNG_UST_ABI_MAJOR_VERSION
;
813 reg_msg
.minor
= LTTNG_UST_ABI_MINOR_VERSION
;
814 reg_msg
.pid
= getpid();
815 reg_msg
.ppid
= getppid();
816 reg_msg
.uid
= getuid();
817 reg_msg
.gid
= getgid();
818 reg_msg
.bits_per_long
= bits_per_long
;
819 reg_msg
.uint8_t_alignment
= uint8_t_alignment
;
820 reg_msg
.uint16_t_alignment
= uint16_t_alignment
;
821 reg_msg
.uint32_t_alignment
= uint32_t_alignment
;
822 reg_msg
.uint64_t_alignment
= uint64_t_alignment
;
823 reg_msg
.long_alignment
= long_alignment
;
824 reg_msg
.socket_type
= type
;
825 lttng_pthread_getname_np(reg_msg
.name
, LTTNG_UST_ABI_PROCNAME_LEN
);
826 memset(reg_msg
.padding
, 0, sizeof(reg_msg
.padding
));
828 len
= ustcomm_send_unix_sock(sock
, ®_msg
, sizeof(reg_msg
));
829 if (len
> 0 && len
!= sizeof(reg_msg
))
837 ssize_t
count_one_type(const struct lttng_ust_type_common
*lt
)
840 case lttng_ust_type_integer
:
841 case lttng_ust_type_float
:
842 case lttng_ust_type_string
:
844 case lttng_ust_type_enum
:
845 return count_one_type(lttng_ust_get_type_enum(lt
)->container_type
) + 1;
846 case lttng_ust_type_array
:
847 return count_one_type(lttng_ust_get_type_array(lt
)->elem_type
) + 1;
848 case lttng_ust_type_sequence
:
849 return count_one_type(lttng_ust_get_type_sequence(lt
)->elem_type
) + 1;
850 case lttng_ust_type_struct
:
851 return count_fields_recursive(lttng_ust_get_type_struct(lt
)->nr_fields
,
852 lttng_ust_get_type_struct(lt
)->fields
) + 1;
854 case lttng_ust_type_dynamic
:
856 const struct lttng_ust_event_field
* const *choices
;
860 ret
= lttng_ust_dynamic_type_choices(&nr_choices
,
865 * Two fields for enum, one field for variant, and
866 * one field per choice.
868 return count_fields_recursive(nr_choices
, choices
) + 3;
878 ssize_t
count_fields_recursive(size_t nr_fields
,
879 const struct lttng_ust_event_field
* const *lttng_fields
)
882 ssize_t ret
, count
= 0;
884 for (i
= 0; i
< nr_fields
; i
++) {
885 const struct lttng_ust_event_field
*lf
;
887 lf
= lttng_fields
[i
];
888 /* skip 'nowrite' fields */
891 ret
= count_one_type(lf
->type
);
893 return ret
; /* error */
900 ssize_t
count_ctx_fields_recursive(size_t nr_fields
,
901 struct lttng_ust_ctx_field
*lttng_fields
)
904 ssize_t ret
, count
= 0;
906 for (i
= 0; i
< nr_fields
; i
++) {
907 const struct lttng_ust_event_field
*lf
;
909 lf
= lttng_fields
[i
].event_field
;
910 /* skip 'nowrite' fields */
913 ret
= count_one_type(lf
->type
);
915 return ret
; /* error */
922 int serialize_string_encoding(int32_t *ue
,
923 enum lttng_ust_string_encoding le
)
926 case lttng_ust_string_encoding_none
:
927 *ue
= lttng_ust_ctl_encode_none
;
929 case lttng_ust_string_encoding_UTF8
:
930 *ue
= lttng_ust_ctl_encode_UTF8
;
932 case lttng_ust_string_encoding_ASCII
:
933 *ue
= lttng_ust_ctl_encode_ASCII
;
942 int serialize_integer_type(struct lttng_ust_ctl_integer_type
*uit
,
943 const struct lttng_ust_type_integer
*lit
,
944 enum lttng_ust_string_encoding lencoding
)
948 uit
->size
= lit
->size
;
949 uit
->signedness
= lit
->signedness
;
950 uit
->reverse_byte_order
= lit
->reverse_byte_order
;
951 uit
->base
= lit
->base
;
952 if (serialize_string_encoding(&encoding
, lencoding
))
954 uit
->encoding
= encoding
;
955 uit
->alignment
= lit
->alignment
;
960 int serialize_dynamic_type(struct lttng_ust_session
*session
,
961 struct lttng_ust_ctl_field
*fields
, size_t *iter_output
,
962 const char *field_name
)
964 const struct lttng_ust_event_field
* const *choices
;
965 char tag_field_name
[LTTNG_UST_ABI_SYM_NAME_LEN
];
966 const struct lttng_ust_type_common
*tag_type
;
967 const struct lttng_ust_event_field
*tag_field_generic
;
968 struct lttng_ust_event_field tag_field
= {
969 .name
= tag_field_name
,
972 struct lttng_ust_ctl_field
*uf
;
973 size_t nr_choices
, i
;
976 tag_field_generic
= lttng_ust_dynamic_type_tag_field();
977 tag_type
= tag_field_generic
->type
;
979 /* Serialize enum field. */
980 strncpy(tag_field_name
, field_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
981 tag_field_name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
982 strncat(tag_field_name
,
984 LTTNG_UST_ABI_SYM_NAME_LEN
- strlen(tag_field_name
) - 1);
985 tag_field
.type
= tag_type
;
986 ret
= serialize_one_field(session
, fields
, iter_output
,
991 /* Serialize variant field. */
992 uf
= &fields
[*iter_output
];
993 ret
= lttng_ust_dynamic_type_choices(&nr_choices
, &choices
);
997 strncpy(uf
->name
, field_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
998 uf
->name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
999 uf
->type
.atype
= lttng_ust_ctl_atype_variant
;
1000 uf
->type
.u
.variant_nestable
.nr_choices
= nr_choices
;
1001 strncpy(uf
->type
.u
.variant_nestable
.tag_name
,
1003 LTTNG_UST_ABI_SYM_NAME_LEN
);
1004 uf
->type
.u
.variant_nestable
.tag_name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
1005 uf
->type
.u
.variant_nestable
.alignment
= 0;
1008 /* Serialize choice fields after variant. */
1009 for (i
= 0; i
< nr_choices
; i
++) {
1010 ret
= serialize_one_field(session
, fields
,
1011 iter_output
, choices
[i
], NULL
);
1019 int serialize_one_type(struct lttng_ust_session
*session
,
1020 struct lttng_ust_ctl_field
*fields
, size_t *iter_output
,
1021 const char *field_name
, const struct lttng_ust_type_common
*lt
,
1022 enum lttng_ust_string_encoding parent_encoding
,
1023 const char *prev_field_name
)
1028 * Serializing a type (rather than a field) generates a lttng_ust_ctl_field
1029 * entry with 0-length name.
1033 case lttng_ust_type_integer
:
1035 struct lttng_ust_ctl_field
*uf
= &fields
[*iter_output
];
1036 struct lttng_ust_ctl_type
*ut
= &uf
->type
;
1039 strncpy(uf
->name
, field_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
1040 uf
->name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
1044 ret
= serialize_integer_type(&ut
->u
.integer
, lttng_ust_get_type_integer(lt
),
1048 ut
->atype
= lttng_ust_ctl_atype_integer
;
1052 case lttng_ust_type_float
:
1054 struct lttng_ust_ctl_field
*uf
= &fields
[*iter_output
];
1055 struct lttng_ust_ctl_type
*ut
= &uf
->type
;
1056 struct lttng_ust_ctl_float_type
*uft
;
1057 const struct lttng_ust_type_float
*lft
;
1060 strncpy(uf
->name
, field_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
1061 uf
->name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
1065 uft
= &ut
->u
._float
;
1066 lft
= lttng_ust_get_type_float(lt
);
1067 uft
->exp_dig
= lft
->exp_dig
;
1068 uft
->mant_dig
= lft
->mant_dig
;
1069 uft
->alignment
= lft
->alignment
;
1070 uft
->reverse_byte_order
= lft
->reverse_byte_order
;
1071 ut
->atype
= lttng_ust_ctl_atype_float
;
1075 case lttng_ust_type_string
:
1077 struct lttng_ust_ctl_field
*uf
= &fields
[*iter_output
];
1078 struct lttng_ust_ctl_type
*ut
= &uf
->type
;
1082 strncpy(uf
->name
, field_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
1083 uf
->name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
1087 ret
= serialize_string_encoding(&encoding
, lttng_ust_get_type_string(lt
)->encoding
);
1090 ut
->u
.string
.encoding
= encoding
;
1091 ut
->atype
= lttng_ust_ctl_atype_string
;
1095 case lttng_ust_type_array
:
1097 struct lttng_ust_ctl_field
*uf
= &fields
[*iter_output
];
1098 struct lttng_ust_ctl_type
*ut
= &uf
->type
;
1101 strncpy(uf
->name
, field_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
1102 uf
->name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
1106 ut
->atype
= lttng_ust_ctl_atype_array_nestable
;
1107 ut
->u
.array_nestable
.length
= lttng_ust_get_type_array(lt
)->length
;
1108 ut
->u
.array_nestable
.alignment
= lttng_ust_get_type_array(lt
)->alignment
;
1111 ret
= serialize_one_type(session
, fields
, iter_output
, NULL
,
1112 lttng_ust_get_type_array(lt
)->elem_type
,
1113 lttng_ust_get_type_array(lt
)->encoding
, NULL
);
1118 case lttng_ust_type_sequence
:
1120 struct lttng_ust_ctl_field
*uf
= &fields
[*iter_output
];
1121 struct lttng_ust_ctl_type
*ut
= &uf
->type
;
1122 const char *length_name
= lttng_ust_get_type_sequence(lt
)->length_name
;
1125 strncpy(uf
->name
, field_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
1126 uf
->name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
1130 ut
->atype
= lttng_ust_ctl_atype_sequence_nestable
;
1132 * If length_name field is NULL, use the previous field
1136 length_name
= prev_field_name
;
1139 strncpy(ut
->u
.sequence_nestable
.length_name
,
1140 length_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
1141 ut
->u
.sequence_nestable
.length_name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
1142 ut
->u
.sequence_nestable
.alignment
= lttng_ust_get_type_sequence(lt
)->alignment
;
1145 ret
= serialize_one_type(session
, fields
, iter_output
, NULL
,
1146 lttng_ust_get_type_sequence(lt
)->elem_type
,
1147 lttng_ust_get_type_sequence(lt
)->encoding
, NULL
);
1152 case lttng_ust_type_dynamic
:
1154 ret
= serialize_dynamic_type(session
, fields
, iter_output
,
1160 case lttng_ust_type_struct
:
1162 struct lttng_ust_ctl_field
*uf
= &fields
[*iter_output
];
1165 strncpy(uf
->name
, field_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
1166 uf
->name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
1170 uf
->type
.atype
= lttng_ust_ctl_atype_struct_nestable
;
1171 uf
->type
.u
.struct_nestable
.nr_fields
= lttng_ust_get_type_struct(lt
)->nr_fields
;
1172 uf
->type
.u
.struct_nestable
.alignment
= lttng_ust_get_type_struct(lt
)->alignment
;
1175 ret
= serialize_fields(session
, fields
, iter_output
,
1176 lttng_ust_get_type_struct(lt
)->nr_fields
,
1177 lttng_ust_get_type_struct(lt
)->fields
);
1182 case lttng_ust_type_enum
:
1184 struct lttng_ust_ctl_field
*uf
= &fields
[*iter_output
];
1185 struct lttng_ust_ctl_type
*ut
= &uf
->type
;
1188 strncpy(uf
->name
, field_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
1189 uf
->name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
1193 strncpy(ut
->u
.enum_nestable
.name
, lttng_ust_get_type_enum(lt
)->desc
->name
,
1194 LTTNG_UST_ABI_SYM_NAME_LEN
);
1195 ut
->u
.enum_nestable
.name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
1196 ut
->atype
= lttng_ust_ctl_atype_enum_nestable
;
1199 ret
= serialize_one_type(session
, fields
, iter_output
, NULL
,
1200 lttng_ust_get_type_enum(lt
)->container_type
,
1201 lttng_ust_string_encoding_none
, NULL
);
1205 const struct lttng_enum
*_enum
;
1207 _enum
= lttng_ust_enum_get_from_desc(session
, lttng_ust_get_type_enum(lt
)->desc
);
1210 ut
->u
.enum_nestable
.id
= _enum
->id
;
1212 ut
->u
.enum_nestable
.id
= -1ULL;
1223 int serialize_one_field(struct lttng_ust_session
*session
,
1224 struct lttng_ust_ctl_field
*fields
, size_t *iter_output
,
1225 const struct lttng_ust_event_field
*lf
,
1226 const char **prev_field_name_p
)
1228 const char *prev_field_name
= NULL
;
1231 /* skip 'nowrite' fields */
1235 if (prev_field_name_p
)
1236 prev_field_name
= *prev_field_name_p
;
1237 ret
= serialize_one_type(session
, fields
, iter_output
, lf
->name
, lf
->type
,
1238 lttng_ust_string_encoding_none
, prev_field_name
);
1239 if (prev_field_name_p
)
1240 *prev_field_name_p
= lf
->name
;
1245 int serialize_fields(struct lttng_ust_session
*session
,
1246 struct lttng_ust_ctl_field
*lttng_ust_ctl_fields
,
1247 size_t *iter_output
, size_t nr_lttng_fields
,
1248 const struct lttng_ust_event_field
* const *lttng_fields
)
1250 const char *prev_field_name
= NULL
;
1254 for (i
= 0; i
< nr_lttng_fields
; i
++) {
1255 ret
= serialize_one_field(session
, lttng_ust_ctl_fields
,
1256 iter_output
, lttng_fields
[i
],
1265 int alloc_serialize_fields(struct lttng_ust_session
*session
,
1266 size_t *_nr_write_fields
,
1267 struct lttng_ust_ctl_field
**lttng_ust_ctl_fields
,
1269 const struct lttng_ust_event_field
* const *lttng_fields
)
1271 struct lttng_ust_ctl_field
*fields
;
1273 size_t iter_output
= 0;
1274 ssize_t nr_write_fields
;
1276 nr_write_fields
= count_fields_recursive(nr_fields
, lttng_fields
);
1277 if (nr_write_fields
< 0) {
1278 return (int) nr_write_fields
;
1281 fields
= zmalloc(nr_write_fields
* sizeof(*fields
));
1285 ret
= serialize_fields(session
, fields
, &iter_output
, nr_fields
,
1290 *_nr_write_fields
= nr_write_fields
;
1291 *lttng_ust_ctl_fields
= fields
;
1300 int serialize_entries(struct lttng_ust_ctl_enum_entry
**_entries
,
1302 const struct lttng_ust_enum_entry
* const *lttng_entries
)
1304 struct lttng_ust_ctl_enum_entry
*entries
;
1307 /* Serialize the entries */
1308 entries
= zmalloc(nr_entries
* sizeof(*entries
));
1311 for (i
= 0; i
< nr_entries
; i
++) {
1312 struct lttng_ust_ctl_enum_entry
*uentry
;
1313 const struct lttng_ust_enum_entry
*lentry
;
1315 uentry
= &entries
[i
];
1316 lentry
= lttng_entries
[i
];
1318 uentry
->start
.value
= lentry
->start
.value
;
1319 uentry
->start
.signedness
= lentry
->start
.signedness
;
1320 uentry
->end
.value
= lentry
->end
.value
;
1321 uentry
->end
.signedness
= lentry
->end
.signedness
;
1322 strncpy(uentry
->string
, lentry
->string
, LTTNG_UST_ABI_SYM_NAME_LEN
);
1323 uentry
->string
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
1325 if (lentry
->options
& LTTNG_UST_ENUM_ENTRY_OPTION_IS_AUTO
) {
1326 uentry
->u
.extra
.options
|=
1327 LTTNG_UST_CTL_UST_ENUM_ENTRY_OPTION_IS_AUTO
;
1330 *_entries
= entries
;
1335 int serialize_ctx_fields(struct lttng_ust_session
*session
,
1336 size_t *_nr_write_fields
,
1337 struct lttng_ust_ctl_field
**lttng_ust_ctl_fields
,
1339 struct lttng_ust_ctx_field
*lttng_fields
)
1341 struct lttng_ust_ctl_field
*fields
;
1342 const char *prev_field_name
= NULL
;
1343 size_t i
, iter_output
= 0;
1344 ssize_t nr_write_fields
;
1347 nr_write_fields
= count_ctx_fields_recursive(nr_fields
,
1349 if (nr_write_fields
< 0) {
1350 return (int) nr_write_fields
;
1353 fields
= zmalloc(nr_write_fields
* sizeof(*fields
));
1357 for (i
= 0; i
< nr_fields
; i
++) {
1358 ret
= serialize_one_field(session
, fields
, &iter_output
,
1359 lttng_fields
[i
].event_field
, &prev_field_name
);
1364 *_nr_write_fields
= nr_write_fields
;
1365 *lttng_ust_ctl_fields
= fields
;
1374 * Returns 0 on success, negative error value on error.
1376 int ustcomm_register_event(int sock
,
1377 struct lttng_ust_session
*session
,
1378 int session_objd
, /* session descriptor */
1379 int channel_objd
, /* channel descriptor */
1380 const char *event_name
, /* event name (input) */
1382 const char *signature
, /* event signature (input) */
1383 size_t nr_fields
, /* fields */
1384 const struct lttng_ust_event_field
* const *lttng_fields
,
1385 const char *model_emf_uri
,
1386 uint32_t *id
) /* event id (output) */
1390 struct ustcomm_notify_hdr header
;
1391 struct ustcomm_notify_event_msg m
;
1394 struct ustcomm_notify_hdr header
;
1395 struct ustcomm_notify_event_reply r
;
1397 size_t signature_len
, fields_len
, model_emf_uri_len
;
1398 struct lttng_ust_ctl_field
*fields
= NULL
;
1399 size_t nr_write_fields
= 0;
1402 memset(&msg
, 0, sizeof(msg
));
1403 msg
.header
.notify_cmd
= LTTNG_UST_CTL_NOTIFY_CMD_EVENT
;
1404 msg
.m
.session_objd
= session_objd
;
1405 msg
.m
.channel_objd
= channel_objd
;
1406 strncpy(msg
.m
.event_name
, event_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
1407 msg
.m
.event_name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
1408 msg
.m
.loglevel
= loglevel
;
1409 signature_len
= strlen(signature
) + 1;
1410 msg
.m
.signature_len
= signature_len
;
1412 /* Calculate fields len, serialize fields. */
1413 if (nr_fields
> 0) {
1414 ret
= alloc_serialize_fields(session
, &nr_write_fields
, &fields
,
1415 nr_fields
, lttng_fields
);
1420 fields_len
= sizeof(*fields
) * nr_write_fields
;
1421 msg
.m
.fields_len
= fields_len
;
1422 if (model_emf_uri
) {
1423 model_emf_uri_len
= strlen(model_emf_uri
) + 1;
1425 model_emf_uri_len
= 0;
1427 msg
.m
.model_emf_uri_len
= model_emf_uri_len
;
1429 len
= ustcomm_send_unix_sock(sock
, &msg
, sizeof(msg
));
1430 if (len
> 0 && len
!= sizeof(msg
)) {
1439 /* send signature */
1440 len
= ustcomm_send_unix_sock(sock
, signature
, signature_len
);
1441 if (len
> 0 && len
!= signature_len
) {
1451 if (fields_len
> 0) {
1452 len
= ustcomm_send_unix_sock(sock
, fields
, fields_len
);
1453 if (len
> 0 && len
!= fields_len
) {
1464 if (model_emf_uri_len
) {
1465 /* send model_emf_uri */
1466 len
= ustcomm_send_unix_sock(sock
, model_emf_uri
,
1468 if (len
> 0 && len
!= model_emf_uri_len
) {
1477 len
= ustcomm_recv_unix_sock(sock
, &reply
, sizeof(reply
));
1479 case 0: /* orderly shutdown */
1482 if (reply
.header
.notify_cmd
!= msg
.header
.notify_cmd
) {
1483 ERR("Unexpected result message command "
1484 "expected: %u vs received: %u\n",
1485 msg
.header
.notify_cmd
, reply
.header
.notify_cmd
);
1488 if (reply
.r
.ret_code
> 0)
1490 if (reply
.r
.ret_code
< 0)
1491 return reply
.r
.ret_code
;
1492 *id
= reply
.r
.event_id
;
1493 DBG("Sent register event notification for name \"%s\": ret_code %d, event_id %u\n",
1494 event_name
, reply
.r
.ret_code
, reply
.r
.event_id
);
1498 /* Transport level error */
1499 if (errno
== EPIPE
|| errno
== ECONNRESET
)
1503 ERR("incorrect message size: %zd\n", len
);
1509 /* Error path only. */
1516 * Returns 0 on success, negative error value on error.
1517 * Returns -EPIPE or -ECONNRESET if other end has hung up.
1519 int ustcomm_register_enum(int sock
,
1520 int session_objd
, /* session descriptor */
1521 const char *enum_name
, /* enum name (input) */
1522 size_t nr_entries
, /* entries */
1523 const struct lttng_ust_enum_entry
* const *lttng_entries
,
1528 struct ustcomm_notify_hdr header
;
1529 struct ustcomm_notify_enum_msg m
;
1532 struct ustcomm_notify_hdr header
;
1533 struct ustcomm_notify_enum_reply r
;
1536 struct lttng_ust_ctl_enum_entry
*entries
= NULL
;
1539 memset(&msg
, 0, sizeof(msg
));
1540 msg
.header
.notify_cmd
= LTTNG_UST_CTL_NOTIFY_CMD_ENUM
;
1541 msg
.m
.session_objd
= session_objd
;
1542 strncpy(msg
.m
.enum_name
, enum_name
, LTTNG_UST_ABI_SYM_NAME_LEN
);
1543 msg
.m
.enum_name
[LTTNG_UST_ABI_SYM_NAME_LEN
- 1] = '\0';
1545 /* Calculate entries len, serialize entries. */
1546 if (nr_entries
> 0) {
1547 ret
= serialize_entries(&entries
,
1548 nr_entries
, lttng_entries
);
1553 entries_len
= sizeof(*entries
) * nr_entries
;
1554 msg
.m
.entries_len
= entries_len
;
1556 len
= ustcomm_send_unix_sock(sock
, &msg
, sizeof(msg
));
1557 if (len
> 0 && len
!= sizeof(msg
)) {
1567 if (entries_len
> 0) {
1568 len
= ustcomm_send_unix_sock(sock
, entries
, entries_len
);
1569 if (len
> 0 && len
!= entries_len
) {
1582 len
= ustcomm_recv_unix_sock(sock
, &reply
, sizeof(reply
));
1584 case 0: /* orderly shutdown */
1587 if (reply
.header
.notify_cmd
!= msg
.header
.notify_cmd
) {
1588 ERR("Unexpected result message command "
1589 "expected: %u vs received: %u\n",
1590 msg
.header
.notify_cmd
, reply
.header
.notify_cmd
);
1593 if (reply
.r
.ret_code
> 0)
1595 if (reply
.r
.ret_code
< 0)
1596 return reply
.r
.ret_code
;
1597 *id
= reply
.r
.enum_id
;
1598 DBG("Sent register enum notification for name \"%s\": ret_code %d\n",
1599 enum_name
, reply
.r
.ret_code
);
1603 /* Transport level error */
1604 if (errno
== EPIPE
|| errno
== ECONNRESET
)
1608 ERR("incorrect message size: %zd\n", len
);
1620 * Returns 0 on success, negative error value on error.
1621 * Returns -EPIPE or -ECONNRESET if other end has hung up.
1623 int ustcomm_register_channel(int sock
,
1624 struct lttng_ust_session
*session
,
1625 int session_objd
, /* session descriptor */
1626 int channel_objd
, /* channel descriptor */
1627 size_t nr_ctx_fields
,
1628 struct lttng_ust_ctx_field
*ctx_fields
,
1629 uint32_t *chan_id
, /* channel id (output) */
1630 int *header_type
) /* header type (output) */
1634 struct ustcomm_notify_hdr header
;
1635 struct ustcomm_notify_channel_msg m
;
1638 struct ustcomm_notify_hdr header
;
1639 struct ustcomm_notify_channel_reply r
;
1642 struct lttng_ust_ctl_field
*fields
= NULL
;
1644 size_t nr_write_fields
= 0;
1646 memset(&msg
, 0, sizeof(msg
));
1647 msg
.header
.notify_cmd
= LTTNG_UST_CTL_NOTIFY_CMD_CHANNEL
;
1648 msg
.m
.session_objd
= session_objd
;
1649 msg
.m
.channel_objd
= channel_objd
;
1651 /* Calculate fields len, serialize fields. */
1652 if (nr_ctx_fields
> 0) {
1653 ret
= serialize_ctx_fields(session
, &nr_write_fields
, &fields
,
1654 nr_ctx_fields
, ctx_fields
);
1659 fields_len
= sizeof(*fields
) * nr_write_fields
;
1660 msg
.m
.ctx_fields_len
= fields_len
;
1661 len
= ustcomm_send_unix_sock(sock
, &msg
, sizeof(msg
));
1662 if (len
> 0 && len
!= sizeof(msg
)) {
1672 if (fields_len
> 0) {
1673 len
= ustcomm_send_unix_sock(sock
, fields
, fields_len
);
1675 if (len
> 0 && len
!= fields_len
) {
1685 len
= ustcomm_recv_unix_sock(sock
, &reply
, sizeof(reply
));
1687 case 0: /* orderly shutdown */
1690 if (reply
.header
.notify_cmd
!= msg
.header
.notify_cmd
) {
1691 ERR("Unexpected result message command "
1692 "expected: %u vs received: %u\n",
1693 msg
.header
.notify_cmd
, reply
.header
.notify_cmd
);
1696 if (reply
.r
.ret_code
> 0)
1698 if (reply
.r
.ret_code
< 0)
1699 return reply
.r
.ret_code
;
1700 *chan_id
= reply
.r
.chan_id
;
1701 switch (reply
.r
.header_type
) {
1704 *header_type
= reply
.r
.header_type
;
1707 ERR("Unexpected channel header type %u\n",
1708 reply
.r
.header_type
);
1711 DBG("Sent register channel notification: chan_id %d, header_type %d\n",
1712 reply
.r
.chan_id
, reply
.r
.header_type
);
1716 /* Transport level error */
1717 if (errno
== EPIPE
|| errno
== ECONNRESET
)
1721 ERR("incorrect message size: %zd\n", len
);
1728 * Set socket reciving timeout.
1730 int ustcomm_setsockopt_rcv_timeout(int sock
, unsigned int msec
)
1735 tv
.tv_sec
= msec
/ 1000;
1736 tv
.tv_usec
= (msec
* 1000 % 1000000);
1738 ret
= setsockopt(sock
, SOL_SOCKET
, SO_RCVTIMEO
, &tv
, sizeof(tv
));
1740 PERROR("setsockopt SO_RCVTIMEO");
1748 * Set socket sending timeout.
1750 int ustcomm_setsockopt_snd_timeout(int sock
, unsigned int msec
)
1755 tv
.tv_sec
= msec
/ 1000;
1756 tv
.tv_usec
= (msec
* 1000) % 1000000;
1758 ret
= setsockopt(sock
, SOL_SOCKET
, SO_SNDTIMEO
, &tv
, sizeof(tv
));
1760 PERROR("setsockopt SO_SNDTIMEO");