2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 * Copyright (C) 2011-2013 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; only
8 * version 2.1 of the License.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 #include <sys/socket.h>
27 #include <sys/types.h>
34 #include <lttng/ust-ctl.h>
38 #include <lttng/ust-error.h>
39 #include <lttng/ust-events.h>
40 #include <lttng/ust-dynamic-type.h>
41 #include <usterr-signal-safe.h>
43 #include "../liblttng-ust/compat.h"
45 #define USTCOMM_CODE_OFFSET(code) \
46 (code == LTTNG_UST_OK ? 0 : (code - LTTNG_UST_ERR + 1))
48 #define USTCOMM_MAX_SEND_FDS 4
51 ssize_t
count_fields_recursive(size_t nr_fields
,
52 const struct lttng_event_field
*lttng_fields
);
54 int serialize_one_field(struct lttng_session
*session
,
55 struct ustctl_field
*fields
, size_t *iter_output
,
56 const struct lttng_event_field
*lf
);
58 int serialize_fields(struct lttng_session
*session
,
59 struct ustctl_field
*ustctl_fields
,
60 size_t *iter_output
, size_t nr_lttng_fields
,
61 const struct lttng_event_field
*lttng_fields
);
64 * Human readable error message.
66 static const char *ustcomm_readable_code
[] = {
67 [ USTCOMM_CODE_OFFSET(LTTNG_UST_OK
) ] = "Success",
68 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR
) ] = "Unknown error",
69 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_NOENT
) ] = "No entry",
70 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_EXIST
) ] = "Object already exists",
71 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_INVAL
) ] = "Invalid argument",
72 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_PERM
) ] = "Permission denied",
73 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_NOSYS
) ] = "Not implemented",
74 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_EXITING
) ] = "Process is exiting",
76 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_INVAL_MAGIC
) ] = "Invalid magic number",
77 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_INVAL_SOCKET_TYPE
) ] = "Invalid socket type",
78 [ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_UNSUP_MAJOR
) ] = "Unsupported major version",
84 * Receives positive error value.
85 * Return ptr to string representing a human readable
86 * error code from the ustcomm_return_code enum.
88 const char *lttng_ust_strerror(int code
)
90 if (code
== LTTNG_UST_OK
)
91 return ustcomm_readable_code
[USTCOMM_CODE_OFFSET(code
)];
92 if (code
< LTTNG_UST_ERR
)
93 return strerror(code
);
94 if (code
>= LTTNG_UST_ERR_NR
)
96 return ustcomm_readable_code
[USTCOMM_CODE_OFFSET(code
)];
100 * ustcomm_connect_unix_sock
102 * Connect to unix socket using the path name.
104 * Caller handles FD tracker.
106 int ustcomm_connect_unix_sock(const char *pathname
, long timeout
)
108 struct sockaddr_un sun
;
112 * libust threads require the close-on-exec flag for all
113 * resources so it does not leak file descriptors upon exec.
114 * SOCK_CLOEXEC is not used since it is linux specific.
116 fd
= socket(PF_UNIX
, SOCK_STREAM
, 0);
123 /* Give at least 10ms. */
126 ret
= ustcomm_setsockopt_snd_timeout(fd
, timeout
);
128 WARN("Error setting connect socket send timeout");
131 ret
= fcntl(fd
, F_SETFD
, FD_CLOEXEC
);
138 memset(&sun
, 0, sizeof(sun
));
139 sun
.sun_family
= AF_UNIX
;
140 strncpy(sun
.sun_path
, pathname
, sizeof(sun
.sun_path
));
141 sun
.sun_path
[sizeof(sun
.sun_path
) - 1] = '\0';
143 ret
= connect(fd
, (struct sockaddr
*) &sun
, sizeof(sun
));
146 * Don't print message on connect ENOENT error, because
147 * connect is used in normal execution to detect if
148 * sessiond is alive. ENOENT is when the unix socket
149 * file does not exist, and ECONNREFUSED is when the
150 * file exists but no sessiond is listening.
152 if (errno
!= ECONNREFUSED
&& errno
!= ECONNRESET
153 && errno
!= ENOENT
&& errno
!= EACCES
)
156 if (ret
== -ECONNREFUSED
|| ret
== -ECONNRESET
)
168 closeret
= close(fd
);
177 * ustcomm_accept_unix_sock
179 * Do an accept(2) on the sock and return the
180 * new file descriptor. The socket MUST be bind(2) before.
182 int ustcomm_accept_unix_sock(int sock
)
185 struct sockaddr_un sun
;
189 new_fd
= accept(sock
, (struct sockaddr
*) &sun
, &len
);
191 if (errno
!= ECONNABORTED
)
194 if (new_fd
== -ECONNABORTED
)
201 * ustcomm_create_unix_sock
203 * Creates a AF_UNIX local socket using pathname
204 * bind the socket upon creation and return the fd.
206 int ustcomm_create_unix_sock(const char *pathname
)
208 struct sockaddr_un sun
;
211 /* Create server socket */
212 if ((fd
= socket(PF_UNIX
, SOCK_STREAM
, 0)) < 0) {
218 memset(&sun
, 0, sizeof(sun
));
219 sun
.sun_family
= AF_UNIX
;
220 strncpy(sun
.sun_path
, pathname
, sizeof(sun
.sun_path
));
221 sun
.sun_path
[sizeof(sun
.sun_path
) - 1] = '\0';
223 /* Unlink the old file if present */
224 (void) unlink(pathname
);
225 ret
= bind(fd
, (struct sockaddr
*) &sun
, sizeof(sun
));
238 closeret
= close(fd
);
248 * ustcomm_listen_unix_sock
250 * Make the socket listen using LTTNG_UST_COMM_MAX_LISTEN.
252 int ustcomm_listen_unix_sock(int sock
)
256 ret
= listen(sock
, LTTNG_UST_COMM_MAX_LISTEN
);
266 * ustcomm_close_unix_sock
268 * Shutdown cleanly a unix socket.
270 * Handles fd tracker internally.
272 int ustcomm_close_unix_sock(int sock
)
276 lttng_ust_lock_fd_tracker();
279 lttng_ust_delete_fd_from_tracker(sock
);
284 lttng_ust_unlock_fd_tracker();
290 * ustcomm_recv_unix_sock
292 * Receive data of size len in put that data into
293 * the buf param. Using recvmsg API.
294 * Return the size of received data.
295 * Return 0 on orderly shutdown.
297 ssize_t
ustcomm_recv_unix_sock(int sock
, void *buf
, size_t len
)
304 memset(&msg
, 0, sizeof(msg
));
306 iov
[0].iov_base
= buf
;
307 iov
[0].iov_len
= len
;
312 len_last
= iov
[0].iov_len
;
313 ret
= recvmsg(sock
, &msg
, 0);
315 iov
[0].iov_base
+= ret
;
316 iov
[0].iov_len
-= ret
;
317 assert(ret
<= len_last
);
319 } while ((ret
> 0 && ret
< len_last
) || (ret
< 0 && errno
== EINTR
));
324 if (errno
!= EPIPE
&& errno
!= ECONNRESET
&& errno
!= ECONNREFUSED
)
327 if (ret
== -ECONNRESET
|| ret
== -ECONNREFUSED
)
330 shutret
= shutdown(sock
, SHUT_RDWR
);
332 ERR("Socket shutdown error");
333 } else if (ret
> 0) {
336 /* ret = 0 means an orderly shutdown. */
342 * ustcomm_send_unix_sock
344 * Send buf data of size len. Using sendmsg API.
345 * Return the size of sent data.
347 ssize_t
ustcomm_send_unix_sock(int sock
, const void *buf
, size_t len
)
353 memset(&msg
, 0, sizeof(msg
));
355 iov
[0].iov_base
= (void *) buf
;
356 iov
[0].iov_len
= len
;
361 * Using the MSG_NOSIGNAL when sending data from sessiond to
362 * libust, so libust does not receive an unhandled SIGPIPE or
363 * SIGURG. The sessiond receiver side can be made more resilient
364 * by ignoring SIGPIPE, but we don't have this luxury on the
368 ret
= sendmsg(sock
, &msg
, MSG_NOSIGNAL
);
369 } while (ret
< 0 && errno
== EINTR
);
374 if (errno
!= EPIPE
&& errno
!= ECONNRESET
)
377 if (ret
== -ECONNRESET
)
380 shutret
= shutdown(sock
, SHUT_RDWR
);
382 ERR("Socket shutdown error");
389 * Send a message accompanied by fd(s) over a unix socket.
391 * Returns the size of data sent, or negative error value.
393 ssize_t
ustcomm_send_fds_unix_sock(int sock
, int *fds
, size_t nb_fd
)
396 struct cmsghdr
*cmptr
;
399 unsigned int sizeof_fds
= nb_fd
* sizeof(int);
400 char tmp
[CMSG_SPACE(sizeof_fds
)];
403 memset(&msg
, 0, sizeof(msg
));
404 memset(tmp
, 0, CMSG_SPACE(sizeof_fds
) * sizeof(char));
406 if (nb_fd
> USTCOMM_MAX_SEND_FDS
)
409 msg
.msg_control
= (caddr_t
)tmp
;
410 msg
.msg_controllen
= CMSG_LEN(sizeof_fds
);
412 cmptr
= CMSG_FIRSTHDR(&msg
);
415 cmptr
->cmsg_level
= SOL_SOCKET
;
416 cmptr
->cmsg_type
= SCM_RIGHTS
;
417 cmptr
->cmsg_len
= CMSG_LEN(sizeof_fds
);
418 memcpy(CMSG_DATA(cmptr
), fds
, sizeof_fds
);
419 /* Sum of the length of all control messages in the buffer: */
420 msg
.msg_controllen
= cmptr
->cmsg_len
;
422 iov
[0].iov_base
= &dummy
;
428 ret
= sendmsg(sock
, &msg
, MSG_NOSIGNAL
);
429 } while (ret
< 0 && errno
== EINTR
);
432 * We consider EPIPE and ECONNRESET as expected.
434 if (errno
!= EPIPE
&& errno
!= ECONNRESET
) {
438 if (ret
== -ECONNRESET
)
445 * Recv a message accompanied by fd(s) from a unix socket.
447 * Expect at most "nb_fd" file descriptors. Returns the number of fd
448 * actually received in nb_fd.
449 * Returns -EPIPE on orderly shutdown.
451 ssize_t
ustcomm_recv_fds_unix_sock(int sock
, int *fds
, size_t nb_fd
)
455 struct cmsghdr
*cmsg
;
456 size_t sizeof_fds
= nb_fd
* sizeof(int);
457 char recv_fd
[CMSG_SPACE(sizeof_fds
)];
462 memset(&msg
, 0, sizeof(msg
));
464 /* Prepare to receive the structures */
465 iov
[0].iov_base
= &dummy
;
469 msg
.msg_control
= recv_fd
;
470 msg
.msg_controllen
= sizeof(recv_fd
);
473 ret
= recvmsg(sock
, &msg
, 0);
474 } while (ret
< 0 && errno
== EINTR
);
476 if (errno
!= EPIPE
&& errno
!= ECONNRESET
) {
477 PERROR("recvmsg fds");
480 if (ret
== -ECONNRESET
)
485 /* orderly shutdown */
490 ERR("Error: Received %zd bytes, expected %d\n",
494 if (msg
.msg_flags
& MSG_CTRUNC
) {
495 ERR("Error: Control message truncated.\n");
499 cmsg
= CMSG_FIRSTHDR(&msg
);
501 ERR("Error: Invalid control message header\n");
505 if (cmsg
->cmsg_level
!= SOL_SOCKET
|| cmsg
->cmsg_type
!= SCM_RIGHTS
) {
506 ERR("Didn't received any fd\n");
510 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof_fds
)) {
511 ERR("Error: Received %zu bytes of ancillary data, expected %zu\n",
512 (size_t) cmsg
->cmsg_len
, (size_t) CMSG_LEN(sizeof_fds
));
517 memcpy(fds
, CMSG_DATA(cmsg
), sizeof_fds
);
520 for (i
= 0; i
< nb_fd
; i
++) {
521 ret
= fcntl(fds
[i
], F_SETFD
, FD_CLOEXEC
);
523 PERROR("fcntl failed to set FD_CLOEXEC on fd %d",
533 int ustcomm_send_app_msg(int sock
, struct ustcomm_ust_msg
*lum
)
537 len
= ustcomm_send_unix_sock(sock
, lum
, sizeof(*lum
));
545 ERR("incorrect message size: %zd\n", len
);
552 int ustcomm_recv_app_reply(int sock
, struct ustcomm_ust_reply
*lur
,
553 uint32_t expected_handle
, uint32_t expected_cmd
)
557 memset(lur
, 0, sizeof(*lur
));
558 len
= ustcomm_recv_unix_sock(sock
, lur
, sizeof(*lur
));
560 case 0: /* orderly shutdown */
566 if (lur
->handle
!= expected_handle
) {
567 ERR("Unexpected result message handle: "
568 "expected: %u vs received: %u\n",
569 expected_handle
, lur
->handle
);
572 if (lur
->cmd
!= expected_cmd
) {
573 ERR("Unexpected result message command "
574 "expected: %u vs received: %u\n",
575 expected_cmd
, lur
->cmd
);
581 return lur
->ret_code
;
586 ERR("incorrect message size: %zd\n", len
);
592 int ustcomm_send_app_cmd(int sock
,
593 struct ustcomm_ust_msg
*lum
,
594 struct ustcomm_ust_reply
*lur
)
598 ret
= ustcomm_send_app_msg(sock
, lum
);
601 ret
= ustcomm_recv_app_reply(sock
, lur
, lum
->handle
, lum
->cmd
);
608 * chan_data is allocated internally if this function returns the
611 ssize_t
ustcomm_recv_channel_from_sessiond(int sock
,
612 void **_chan_data
, uint64_t var_len
,
619 if (var_len
> LTTNG_UST_CHANNEL_DATA_MAX_LEN
) {
623 /* Receive variable length data */
624 chan_data
= zmalloc(var_len
);
629 len
= ustcomm_recv_unix_sock(sock
, chan_data
, var_len
);
630 if (len
!= var_len
) {
634 lttng_ust_lock_fd_tracker();
635 nr_fd
= ustcomm_recv_fds_unix_sock(sock
, &wakeup_fd
, 1);
637 lttng_ust_unlock_fd_tracker();
647 ret
= lttng_ust_add_fd_to_tracker(wakeup_fd
);
649 ret
= close(wakeup_fd
);
651 PERROR("close on wakeup_fd");
654 lttng_ust_unlock_fd_tracker();
659 lttng_ust_unlock_fd_tracker();
661 *_chan_data
= chan_data
;
671 ssize_t
ustcomm_recv_event_notifier_notif_fd_from_sessiond(int sock
,
672 int *_event_notifier_notif_fd
)
675 int event_notifier_notif_fd
, ret
;
677 /* Receive event_notifier notification fd */
678 lttng_ust_lock_fd_tracker();
679 nr_fd
= ustcomm_recv_fds_unix_sock(sock
, &event_notifier_notif_fd
, 1);
681 lttng_ust_unlock_fd_tracker();
691 ret
= lttng_ust_add_fd_to_tracker(event_notifier_notif_fd
);
693 ret
= close(event_notifier_notif_fd
);
695 PERROR("close on event_notifier notif fd");
698 lttng_ust_unlock_fd_tracker();
702 *_event_notifier_notif_fd
= ret
;
703 lttng_ust_unlock_fd_tracker();
711 int ustcomm_recv_stream_from_sessiond(int sock
,
712 uint64_t *memory_map_size
,
713 int *shm_fd
, int *wakeup_fd
)
719 /* recv shm fd and wakeup fd */
720 lttng_ust_lock_fd_tracker();
721 len
= ustcomm_recv_fds_unix_sock(sock
, fds
, 2);
723 lttng_ust_unlock_fd_tracker();
733 ret
= lttng_ust_add_fd_to_tracker(fds
[0]);
737 PERROR("close on received shm_fd");
740 lttng_ust_unlock_fd_tracker();
745 ret
= lttng_ust_add_fd_to_tracker(fds
[1]);
747 ret
= close(*shm_fd
);
749 PERROR("close on shm_fd");
754 PERROR("close on received wakeup_fd");
757 lttng_ust_unlock_fd_tracker();
761 lttng_ust_unlock_fd_tracker();
769 * Returns 0 on success, negative error value on error.
771 int ustcomm_send_reg_msg(int sock
,
772 enum ustctl_socket_type type
,
773 uint32_t bits_per_long
,
774 uint32_t uint8_t_alignment
,
775 uint32_t uint16_t_alignment
,
776 uint32_t uint32_t_alignment
,
777 uint32_t uint64_t_alignment
,
778 uint32_t long_alignment
)
781 struct ustctl_reg_msg reg_msg
;
783 reg_msg
.magic
= LTTNG_UST_COMM_MAGIC
;
784 reg_msg
.major
= LTTNG_UST_ABI_MAJOR_VERSION
;
785 reg_msg
.minor
= LTTNG_UST_ABI_MINOR_VERSION
;
786 reg_msg
.pid
= getpid();
787 reg_msg
.ppid
= getppid();
788 reg_msg
.uid
= getuid();
789 reg_msg
.gid
= getgid();
790 reg_msg
.bits_per_long
= bits_per_long
;
791 reg_msg
.uint8_t_alignment
= uint8_t_alignment
;
792 reg_msg
.uint16_t_alignment
= uint16_t_alignment
;
793 reg_msg
.uint32_t_alignment
= uint32_t_alignment
;
794 reg_msg
.uint64_t_alignment
= uint64_t_alignment
;
795 reg_msg
.long_alignment
= long_alignment
;
796 reg_msg
.socket_type
= type
;
797 lttng_pthread_getname_np(reg_msg
.name
, LTTNG_UST_ABI_PROCNAME_LEN
);
798 memset(reg_msg
.padding
, 0, sizeof(reg_msg
.padding
));
800 len
= ustcomm_send_unix_sock(sock
, ®_msg
, sizeof(reg_msg
));
801 if (len
> 0 && len
!= sizeof(reg_msg
))
809 ssize_t
count_one_type(const struct lttng_type
*lt
)
820 return count_fields_recursive(lt
->u
.legacy
._struct
.nr_fields
,
821 lt
->u
.legacy
._struct
.fields
) + 1;
822 case atype_enum_nestable
:
823 return count_one_type(lt
->u
.enum_nestable
.container_type
) + 1;
824 case atype_array_nestable
:
825 return count_one_type(lt
->u
.array_nestable
.elem_type
) + 1;
826 case atype_sequence_nestable
:
827 return count_one_type(lt
->u
.sequence_nestable
.elem_type
) + 1;
828 case atype_struct_nestable
:
829 return count_fields_recursive(lt
->u
.struct_nestable
.nr_fields
,
830 lt
->u
.struct_nestable
.fields
) + 1;
834 const struct lttng_event_field
*choices
;
838 ret
= lttng_ust_dynamic_type_choices(&nr_choices
,
843 * Two fields for enum, one field for variant, and
844 * one field per choice.
846 return count_fields_recursive(nr_choices
, choices
) + 3;
856 ssize_t
count_fields_recursive(size_t nr_fields
,
857 const struct lttng_event_field
*lttng_fields
)
860 ssize_t ret
, count
= 0;
862 for (i
= 0; i
< nr_fields
; i
++) {
863 const struct lttng_event_field
*lf
;
865 lf
= <tng_fields
[i
];
866 /* skip 'nowrite' fields */
869 ret
= count_one_type(&lf
->type
);
871 return ret
; /* error */
878 ssize_t
count_ctx_fields_recursive(size_t nr_fields
,
879 const struct lttng_ctx_field
*lttng_fields
)
882 ssize_t ret
, count
= 0;
884 for (i
= 0; i
< nr_fields
; i
++) {
885 const struct lttng_event_field
*lf
;
887 lf
= <tng_fields
[i
].event_field
;
888 /* skip 'nowrite' fields */
891 ret
= count_one_type(&lf
->type
);
893 return ret
; /* error */
900 int serialize_string_encoding(int32_t *ue
,
901 enum lttng_string_encodings le
)
904 case lttng_encode_none
:
905 *ue
= ustctl_encode_none
;
907 case lttng_encode_UTF8
:
908 *ue
= ustctl_encode_UTF8
;
910 case lttng_encode_ASCII
:
911 *ue
= ustctl_encode_ASCII
;
920 int serialize_integer_type(struct ustctl_integer_type
*uit
,
921 const struct lttng_integer_type
*lit
)
925 uit
->size
= lit
->size
;
926 uit
->signedness
= lit
->signedness
;
927 uit
->reverse_byte_order
= lit
->reverse_byte_order
;
928 uit
->base
= lit
->base
;
929 if (serialize_string_encoding(&encoding
, lit
->encoding
))
931 uit
->encoding
= encoding
;
932 uit
->alignment
= lit
->alignment
;
937 int serialize_basic_type(struct lttng_session
*session
,
938 enum ustctl_abstract_types
*uatype
,
939 enum lttng_abstract_types atype
,
940 union _ustctl_basic_type
*ubt
,
941 const union _lttng_basic_type
*lbt
)
946 if (serialize_integer_type(&ubt
->integer
, &lbt
->integer
))
948 *uatype
= ustctl_atype_integer
;
955 if (serialize_string_encoding(&encoding
, lbt
->string
.encoding
))
957 ubt
->string
.encoding
= encoding
;
958 *uatype
= ustctl_atype_string
;
963 struct ustctl_float_type
*uft
;
964 const struct lttng_float_type
*lft
;
968 uft
->exp_dig
= lft
->exp_dig
;
969 uft
->mant_dig
= lft
->mant_dig
;
970 uft
->alignment
= lft
->alignment
;
971 uft
->reverse_byte_order
= lft
->reverse_byte_order
;
972 *uatype
= ustctl_atype_float
;
977 strncpy(ubt
->enumeration
.name
, lbt
->enumeration
.desc
->name
,
978 LTTNG_UST_SYM_NAME_LEN
);
979 ubt
->enumeration
.name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
980 if (serialize_integer_type(&ubt
->enumeration
.container_type
,
981 &lbt
->enumeration
.container_type
))
984 const struct lttng_enum
*_enum
;
986 _enum
= lttng_ust_enum_get_from_desc(session
, lbt
->enumeration
.desc
);
989 ubt
->enumeration
.id
= _enum
->id
;
991 ubt
->enumeration
.id
= -1ULL;
993 *uatype
= ustctl_atype_enum
;
997 case atype_array_nestable
:
999 case atype_sequence_nestable
:
1000 case atype_enum_nestable
:
1008 int serialize_dynamic_type(struct lttng_session
*session
,
1009 struct ustctl_field
*fields
, size_t *iter_output
,
1010 const char *field_name
)
1012 const struct lttng_event_field
*choices
;
1013 char tag_field_name
[LTTNG_UST_SYM_NAME_LEN
];
1014 const struct lttng_type
*tag_type
;
1015 const struct lttng_event_field
*tag_field_generic
;
1016 struct lttng_event_field tag_field
= {
1017 .name
= tag_field_name
,
1020 struct ustctl_field
*uf
;
1021 size_t nr_choices
, i
;
1024 tag_field_generic
= lttng_ust_dynamic_type_tag_field();
1025 tag_type
= &tag_field_generic
->type
;
1027 /* Serialize enum field. */
1028 strncpy(tag_field_name
, field_name
, LTTNG_UST_SYM_NAME_LEN
);
1029 tag_field_name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1030 strncat(tag_field_name
,
1032 LTTNG_UST_SYM_NAME_LEN
- strlen(tag_field_name
) - 1);
1033 tag_field
.type
= *tag_type
;
1034 ret
= serialize_one_field(session
, fields
, iter_output
,
1039 /* Serialize variant field. */
1040 uf
= &fields
[*iter_output
];
1041 ret
= lttng_ust_dynamic_type_choices(&nr_choices
, &choices
);
1045 strncpy(uf
->name
, field_name
, LTTNG_UST_SYM_NAME_LEN
);
1046 uf
->name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1047 uf
->type
.atype
= ustctl_atype_variant
;
1048 uf
->type
.u
.variant_nestable
.nr_choices
= nr_choices
;
1049 strncpy(uf
->type
.u
.variant_nestable
.tag_name
,
1051 LTTNG_UST_SYM_NAME_LEN
);
1052 uf
->type
.u
.variant_nestable
.tag_name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1053 uf
->type
.u
.variant_nestable
.alignment
= 0;
1056 /* Serialize choice fields after variant. */
1057 for (i
= 0; i
< nr_choices
; i
++) {
1058 ret
= serialize_one_field(session
, fields
,
1059 iter_output
, &choices
[i
]);
1067 int serialize_one_type(struct lttng_session
*session
,
1068 struct ustctl_field
*fields
, size_t *iter_output
,
1069 const char *field_name
, const struct lttng_type
*lt
)
1074 * Serializing a type (rather than a field) generates a ustctl_field
1075 * entry with 0-length name.
1078 switch (lt
->atype
) {
1084 struct ustctl_field
*uf
= &fields
[*iter_output
];
1085 struct ustctl_type
*ut
= &uf
->type
;
1086 enum ustctl_abstract_types atype
;
1089 strncpy(uf
->name
, field_name
, LTTNG_UST_SYM_NAME_LEN
);
1090 uf
->name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1094 ret
= serialize_basic_type(session
, &atype
, lt
->atype
,
1095 &ut
->u
.legacy
.basic
, <
->u
.legacy
.basic
);
1104 struct ustctl_field
*uf
= &fields
[*iter_output
];
1105 struct ustctl_type
*ut
= &uf
->type
;
1106 struct ustctl_basic_type
*ubt
;
1107 const struct lttng_basic_type
*lbt
;
1108 enum ustctl_abstract_types atype
;
1111 strncpy(uf
->name
, field_name
, LTTNG_UST_SYM_NAME_LEN
);
1112 uf
->name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1116 ut
->atype
= ustctl_atype_array
;
1117 ubt
= &ut
->u
.legacy
.array
.elem_type
;
1118 lbt
= <
->u
.legacy
.array
.elem_type
;
1119 ut
->u
.legacy
.array
.length
= lt
->u
.legacy
.array
.length
;
1120 ret
= serialize_basic_type(session
, &atype
, lbt
->atype
,
1121 &ubt
->u
.basic
, &lbt
->u
.basic
);
1128 case atype_array_nestable
:
1130 struct ustctl_field
*uf
= &fields
[*iter_output
];
1131 struct ustctl_type
*ut
= &uf
->type
;
1134 strncpy(uf
->name
, field_name
, LTTNG_UST_SYM_NAME_LEN
);
1135 uf
->name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1139 ut
->atype
= ustctl_atype_array_nestable
;
1140 ut
->u
.array_nestable
.length
= lt
->u
.array_nestable
.length
;
1141 ut
->u
.array_nestable
.alignment
= lt
->u
.array_nestable
.alignment
;
1144 ret
= serialize_one_type(session
, fields
, iter_output
, NULL
,
1145 lt
->u
.array_nestable
.elem_type
);
1150 case atype_sequence
:
1152 struct ustctl_field
*uf
= &fields
[*iter_output
];
1153 struct ustctl_type
*ut
= &uf
->type
;
1154 struct ustctl_basic_type
*ubt
;
1155 const struct lttng_basic_type
*lbt
;
1156 enum ustctl_abstract_types atype
;
1159 strncpy(uf
->name
, field_name
, LTTNG_UST_SYM_NAME_LEN
);
1160 uf
->name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1164 uf
->type
.atype
= ustctl_atype_sequence
;
1165 ubt
= &ut
->u
.legacy
.sequence
.length_type
;
1166 lbt
= <
->u
.legacy
.sequence
.length_type
;
1167 ret
= serialize_basic_type(session
, &atype
, lbt
->atype
,
1168 &ubt
->u
.basic
, &lbt
->u
.basic
);
1172 ubt
= &ut
->u
.legacy
.sequence
.elem_type
;
1173 lbt
= <
->u
.legacy
.sequence
.elem_type
;
1174 ret
= serialize_basic_type(session
, &atype
, lbt
->atype
,
1175 &ubt
->u
.basic
, &lbt
->u
.basic
);
1182 case atype_sequence_nestable
:
1184 struct ustctl_field
*uf
= &fields
[*iter_output
];
1185 struct ustctl_type
*ut
= &uf
->type
;
1188 strncpy(uf
->name
, field_name
, LTTNG_UST_SYM_NAME_LEN
);
1189 uf
->name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1193 ut
->atype
= ustctl_atype_sequence_nestable
;
1194 strncpy(ut
->u
.sequence_nestable
.length_name
,
1195 lt
->u
.sequence_nestable
.length_name
,
1196 LTTNG_UST_SYM_NAME_LEN
);
1197 ut
->u
.sequence_nestable
.length_name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1198 ut
->u
.sequence_nestable
.alignment
= lt
->u
.sequence_nestable
.alignment
;
1201 ret
= serialize_one_type(session
, fields
, iter_output
, NULL
,
1202 lt
->u
.sequence_nestable
.elem_type
);
1209 ret
= serialize_dynamic_type(session
, fields
, iter_output
,
1217 struct ustctl_field
*uf
= &fields
[*iter_output
];
1220 strncpy(uf
->name
, field_name
, LTTNG_UST_SYM_NAME_LEN
);
1221 uf
->name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1225 uf
->type
.atype
= ustctl_atype_struct
;
1226 uf
->type
.u
.legacy
._struct
.nr_fields
= lt
->u
.legacy
._struct
.nr_fields
;
1229 ret
= serialize_fields(session
, fields
, iter_output
,
1230 lt
->u
.legacy
._struct
.nr_fields
,
1231 lt
->u
.legacy
._struct
.fields
);
1236 case atype_struct_nestable
:
1238 struct ustctl_field
*uf
= &fields
[*iter_output
];
1241 strncpy(uf
->name
, field_name
, LTTNG_UST_SYM_NAME_LEN
);
1242 uf
->name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1246 uf
->type
.atype
= ustctl_atype_struct_nestable
;
1247 uf
->type
.u
.struct_nestable
.nr_fields
= lt
->u
.struct_nestable
.nr_fields
;
1248 uf
->type
.u
.struct_nestable
.alignment
= lt
->u
.struct_nestable
.alignment
;
1251 ret
= serialize_fields(session
, fields
, iter_output
,
1252 lt
->u
.struct_nestable
.nr_fields
,
1253 lt
->u
.struct_nestable
.fields
);
1258 case atype_enum_nestable
:
1260 struct ustctl_field
*uf
= &fields
[*iter_output
];
1261 struct ustctl_type
*ut
= &uf
->type
;
1264 strncpy(uf
->name
, field_name
, LTTNG_UST_SYM_NAME_LEN
);
1265 uf
->name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1269 strncpy(ut
->u
.enum_nestable
.name
, lt
->u
.enum_nestable
.desc
->name
,
1270 LTTNG_UST_SYM_NAME_LEN
);
1271 ut
->u
.enum_nestable
.name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1272 ut
->atype
= ustctl_atype_enum_nestable
;
1275 ret
= serialize_one_type(session
, fields
, iter_output
, NULL
,
1276 lt
->u
.enum_nestable
.container_type
);
1280 const struct lttng_enum
*_enum
;
1282 _enum
= lttng_ust_enum_get_from_desc(session
, lt
->u
.enum_nestable
.desc
);
1285 ut
->u
.enum_nestable
.id
= _enum
->id
;
1287 ut
->u
.enum_nestable
.id
= -1ULL;
1298 int serialize_one_field(struct lttng_session
*session
,
1299 struct ustctl_field
*fields
, size_t *iter_output
,
1300 const struct lttng_event_field
*lf
)
1302 /* skip 'nowrite' fields */
1306 return serialize_one_type(session
, fields
, iter_output
, lf
->name
, &lf
->type
);
1310 int serialize_fields(struct lttng_session
*session
,
1311 struct ustctl_field
*ustctl_fields
,
1312 size_t *iter_output
, size_t nr_lttng_fields
,
1313 const struct lttng_event_field
*lttng_fields
)
1318 for (i
= 0; i
< nr_lttng_fields
; i
++) {
1319 ret
= serialize_one_field(session
, ustctl_fields
,
1320 iter_output
, <tng_fields
[i
]);
1328 int alloc_serialize_fields(struct lttng_session
*session
,
1329 size_t *_nr_write_fields
,
1330 struct ustctl_field
**ustctl_fields
,
1332 const struct lttng_event_field
*lttng_fields
)
1334 struct ustctl_field
*fields
;
1336 size_t iter_output
= 0;
1337 ssize_t nr_write_fields
;
1339 nr_write_fields
= count_fields_recursive(nr_fields
, lttng_fields
);
1340 if (nr_write_fields
< 0) {
1341 return (int) nr_write_fields
;
1344 fields
= zmalloc(nr_write_fields
* sizeof(*fields
));
1348 ret
= serialize_fields(session
, fields
, &iter_output
, nr_fields
,
1353 *_nr_write_fields
= nr_write_fields
;
1354 *ustctl_fields
= fields
;
1363 int serialize_entries(struct ustctl_enum_entry
**_entries
,
1365 const struct lttng_enum_entry
*lttng_entries
)
1367 struct ustctl_enum_entry
*entries
;
1370 /* Serialize the entries */
1371 entries
= zmalloc(nr_entries
* sizeof(*entries
));
1374 for (i
= 0; i
< nr_entries
; i
++) {
1375 struct ustctl_enum_entry
*uentry
;
1376 const struct lttng_enum_entry
*lentry
;
1378 uentry
= &entries
[i
];
1379 lentry
= <tng_entries
[i
];
1381 uentry
->start
.value
= lentry
->start
.value
;
1382 uentry
->start
.signedness
= lentry
->start
.signedness
;
1383 uentry
->end
.value
= lentry
->end
.value
;
1384 uentry
->end
.signedness
= lentry
->end
.signedness
;
1385 strncpy(uentry
->string
, lentry
->string
, LTTNG_UST_SYM_NAME_LEN
);
1386 uentry
->string
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1388 if (lentry
->u
.extra
.options
& LTTNG_ENUM_ENTRY_OPTION_IS_AUTO
) {
1389 uentry
->u
.extra
.options
|=
1390 USTCTL_UST_ENUM_ENTRY_OPTION_IS_AUTO
;
1393 *_entries
= entries
;
1398 int serialize_ctx_fields(struct lttng_session
*session
,
1399 size_t *_nr_write_fields
,
1400 struct ustctl_field
**ustctl_fields
,
1402 const struct lttng_ctx_field
*lttng_fields
)
1404 struct ustctl_field
*fields
;
1406 size_t i
, iter_output
= 0;
1407 ssize_t nr_write_fields
;
1409 nr_write_fields
= count_ctx_fields_recursive(nr_fields
,
1411 if (nr_write_fields
< 0) {
1412 return (int) nr_write_fields
;
1415 fields
= zmalloc(nr_write_fields
* sizeof(*fields
));
1419 for (i
= 0; i
< nr_fields
; i
++) {
1420 ret
= serialize_one_field(session
, fields
, &iter_output
,
1421 <tng_fields
[i
].event_field
);
1426 *_nr_write_fields
= nr_write_fields
;
1427 *ustctl_fields
= fields
;
1436 * Returns 0 on success, negative error value on error.
1438 int ustcomm_register_event(int sock
,
1439 struct lttng_session
*session
,
1440 int session_objd
, /* session descriptor */
1441 int channel_objd
, /* channel descriptor */
1442 const char *event_name
, /* event name (input) */
1444 const char *signature
, /* event signature (input) */
1445 size_t nr_fields
, /* fields */
1446 const struct lttng_event_field
*lttng_fields
,
1447 const char *model_emf_uri
,
1448 uint32_t *id
) /* event id (output) */
1452 struct ustcomm_notify_hdr header
;
1453 struct ustcomm_notify_event_msg m
;
1456 struct ustcomm_notify_hdr header
;
1457 struct ustcomm_notify_event_reply r
;
1459 size_t signature_len
, fields_len
, model_emf_uri_len
;
1460 struct ustctl_field
*fields
= NULL
;
1461 size_t nr_write_fields
= 0;
1464 memset(&msg
, 0, sizeof(msg
));
1465 msg
.header
.notify_cmd
= USTCTL_NOTIFY_CMD_EVENT
;
1466 msg
.m
.session_objd
= session_objd
;
1467 msg
.m
.channel_objd
= channel_objd
;
1468 strncpy(msg
.m
.event_name
, event_name
, LTTNG_UST_SYM_NAME_LEN
);
1469 msg
.m
.event_name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1470 msg
.m
.loglevel
= loglevel
;
1471 signature_len
= strlen(signature
) + 1;
1472 msg
.m
.signature_len
= signature_len
;
1474 /* Calculate fields len, serialize fields. */
1475 if (nr_fields
> 0) {
1476 ret
= alloc_serialize_fields(session
, &nr_write_fields
, &fields
,
1477 nr_fields
, lttng_fields
);
1482 fields_len
= sizeof(*fields
) * nr_write_fields
;
1483 msg
.m
.fields_len
= fields_len
;
1484 if (model_emf_uri
) {
1485 model_emf_uri_len
= strlen(model_emf_uri
) + 1;
1487 model_emf_uri_len
= 0;
1489 msg
.m
.model_emf_uri_len
= model_emf_uri_len
;
1491 len
= ustcomm_send_unix_sock(sock
, &msg
, sizeof(msg
));
1492 if (len
> 0 && len
!= sizeof(msg
)) {
1501 /* send signature */
1502 len
= ustcomm_send_unix_sock(sock
, signature
, signature_len
);
1503 if (len
> 0 && len
!= signature_len
) {
1513 if (fields_len
> 0) {
1514 len
= ustcomm_send_unix_sock(sock
, fields
, fields_len
);
1515 if (len
> 0 && len
!= fields_len
) {
1526 if (model_emf_uri_len
) {
1527 /* send model_emf_uri */
1528 len
= ustcomm_send_unix_sock(sock
, model_emf_uri
,
1530 if (len
> 0 && len
!= model_emf_uri_len
) {
1539 len
= ustcomm_recv_unix_sock(sock
, &reply
, sizeof(reply
));
1541 case 0: /* orderly shutdown */
1544 if (reply
.header
.notify_cmd
!= msg
.header
.notify_cmd
) {
1545 ERR("Unexpected result message command "
1546 "expected: %u vs received: %u\n",
1547 msg
.header
.notify_cmd
, reply
.header
.notify_cmd
);
1550 if (reply
.r
.ret_code
> 0)
1552 if (reply
.r
.ret_code
< 0)
1553 return reply
.r
.ret_code
;
1554 *id
= reply
.r
.event_id
;
1555 DBG("Sent register event notification for name \"%s\": ret_code %d, event_id %u\n",
1556 event_name
, reply
.r
.ret_code
, reply
.r
.event_id
);
1560 /* Transport level error */
1561 if (errno
== EPIPE
|| errno
== ECONNRESET
)
1565 ERR("incorrect message size: %zd\n", len
);
1571 /* Error path only. */
1578 * Returns 0 on success, negative error value on error.
1579 * Returns -EPIPE or -ECONNRESET if other end has hung up.
1581 int ustcomm_register_enum(int sock
,
1582 int session_objd
, /* session descriptor */
1583 const char *enum_name
, /* enum name (input) */
1584 size_t nr_entries
, /* entries */
1585 const struct lttng_enum_entry
*lttng_entries
,
1590 struct ustcomm_notify_hdr header
;
1591 struct ustcomm_notify_enum_msg m
;
1594 struct ustcomm_notify_hdr header
;
1595 struct ustcomm_notify_enum_reply r
;
1598 struct ustctl_enum_entry
*entries
= NULL
;
1601 memset(&msg
, 0, sizeof(msg
));
1602 msg
.header
.notify_cmd
= USTCTL_NOTIFY_CMD_ENUM
;
1603 msg
.m
.session_objd
= session_objd
;
1604 strncpy(msg
.m
.enum_name
, enum_name
, LTTNG_UST_SYM_NAME_LEN
);
1605 msg
.m
.enum_name
[LTTNG_UST_SYM_NAME_LEN
- 1] = '\0';
1607 /* Calculate entries len, serialize entries. */
1608 if (nr_entries
> 0) {
1609 ret
= serialize_entries(&entries
,
1610 nr_entries
, lttng_entries
);
1615 entries_len
= sizeof(*entries
) * nr_entries
;
1616 msg
.m
.entries_len
= entries_len
;
1618 len
= ustcomm_send_unix_sock(sock
, &msg
, sizeof(msg
));
1619 if (len
> 0 && len
!= sizeof(msg
)) {
1629 if (entries_len
> 0) {
1630 len
= ustcomm_send_unix_sock(sock
, entries
, entries_len
);
1631 if (len
> 0 && len
!= entries_len
) {
1644 len
= ustcomm_recv_unix_sock(sock
, &reply
, sizeof(reply
));
1646 case 0: /* orderly shutdown */
1649 if (reply
.header
.notify_cmd
!= msg
.header
.notify_cmd
) {
1650 ERR("Unexpected result message command "
1651 "expected: %u vs received: %u\n",
1652 msg
.header
.notify_cmd
, reply
.header
.notify_cmd
);
1655 if (reply
.r
.ret_code
> 0)
1657 if (reply
.r
.ret_code
< 0)
1658 return reply
.r
.ret_code
;
1659 *id
= reply
.r
.enum_id
;
1660 DBG("Sent register enum notification for name \"%s\": ret_code %d\n",
1661 enum_name
, reply
.r
.ret_code
);
1665 /* Transport level error */
1666 if (errno
== EPIPE
|| errno
== ECONNRESET
)
1670 ERR("incorrect message size: %zd\n", len
);
1682 * Returns 0 on success, negative error value on error.
1683 * Returns -EPIPE or -ECONNRESET if other end has hung up.
1685 int ustcomm_register_channel(int sock
,
1686 struct lttng_session
*session
,
1687 int session_objd
, /* session descriptor */
1688 int channel_objd
, /* channel descriptor */
1689 size_t nr_ctx_fields
,
1690 const struct lttng_ctx_field
*ctx_fields
,
1691 uint32_t *chan_id
, /* channel id (output) */
1692 int *header_type
) /* header type (output) */
1696 struct ustcomm_notify_hdr header
;
1697 struct ustcomm_notify_channel_msg m
;
1700 struct ustcomm_notify_hdr header
;
1701 struct ustcomm_notify_channel_reply r
;
1704 struct ustctl_field
*fields
= NULL
;
1706 size_t nr_write_fields
= 0;
1708 memset(&msg
, 0, sizeof(msg
));
1709 msg
.header
.notify_cmd
= USTCTL_NOTIFY_CMD_CHANNEL
;
1710 msg
.m
.session_objd
= session_objd
;
1711 msg
.m
.channel_objd
= channel_objd
;
1713 /* Calculate fields len, serialize fields. */
1714 if (nr_ctx_fields
> 0) {
1715 ret
= serialize_ctx_fields(session
, &nr_write_fields
, &fields
,
1716 nr_ctx_fields
, ctx_fields
);
1721 fields_len
= sizeof(*fields
) * nr_write_fields
;
1722 msg
.m
.ctx_fields_len
= fields_len
;
1723 len
= ustcomm_send_unix_sock(sock
, &msg
, sizeof(msg
));
1724 if (len
> 0 && len
!= sizeof(msg
)) {
1734 if (fields_len
> 0) {
1735 len
= ustcomm_send_unix_sock(sock
, fields
, fields_len
);
1737 if (len
> 0 && len
!= fields_len
) {
1747 len
= ustcomm_recv_unix_sock(sock
, &reply
, sizeof(reply
));
1749 case 0: /* orderly shutdown */
1752 if (reply
.header
.notify_cmd
!= msg
.header
.notify_cmd
) {
1753 ERR("Unexpected result message command "
1754 "expected: %u vs received: %u\n",
1755 msg
.header
.notify_cmd
, reply
.header
.notify_cmd
);
1758 if (reply
.r
.ret_code
> 0)
1760 if (reply
.r
.ret_code
< 0)
1761 return reply
.r
.ret_code
;
1762 *chan_id
= reply
.r
.chan_id
;
1763 switch (reply
.r
.header_type
) {
1766 *header_type
= reply
.r
.header_type
;
1769 ERR("Unexpected channel header type %u\n",
1770 reply
.r
.header_type
);
1773 DBG("Sent register channel notification: chan_id %d, header_type %d\n",
1774 reply
.r
.chan_id
, reply
.r
.header_type
);
1778 /* Transport level error */
1779 if (errno
== EPIPE
|| errno
== ECONNRESET
)
1783 ERR("incorrect message size: %zd\n", len
);
1790 * Set socket reciving timeout.
1792 int ustcomm_setsockopt_rcv_timeout(int sock
, unsigned int msec
)
1797 tv
.tv_sec
= msec
/ 1000;
1798 tv
.tv_usec
= (msec
* 1000 % 1000000);
1800 ret
= setsockopt(sock
, SOL_SOCKET
, SO_RCVTIMEO
, &tv
, sizeof(tv
));
1802 PERROR("setsockopt SO_RCVTIMEO");
1810 * Set socket sending timeout.
1812 int ustcomm_setsockopt_snd_timeout(int sock
, unsigned int msec
)
1817 tv
.tv_sec
= msec
/ 1000;
1818 tv
.tv_usec
= (msec
* 1000) % 1000000;
1820 ret
= setsockopt(sock
, SOL_SOCKET
, SO_SNDTIMEO
, &tv
, sizeof(tv
));
1822 PERROR("setsockopt SO_SNDTIMEO");