X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=liblttng-ust-comm%2Flttng-ust-comm.c;h=d5d193d75ff60c39cd5d14bd9a068dc74d67bf1f;hb=6ba6fd60507f8e045bdc4f1be14e9d99c6a15f7f;hp=42c9ddb2eae152d88acdba3e177ab9482b4426e8;hpb=c785c634a51956094130218c2bffeff32756cb69;p=lttng-ust.git

diff --git a/liblttng-ust-comm/lttng-ust-comm.c b/liblttng-ust-comm/lttng-ust-comm.c
index 42c9ddb2..d5d193d7 100644
--- a/liblttng-ust-comm/lttng-ust-comm.c
+++ b/liblttng-ust-comm/lttng-ust-comm.c
@@ -1,24 +1,12 @@
 /*
- * Copyright (C)  2011 - David Goulet <david.goulet@polymtl.ca>
- * Copyright (C)  2011-2013 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ * SPDX-License-Identifier: LGPL-2.1-only
  *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; only
- * version 2.1 of the License.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
+ * Copyright (C) 2011-2013 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
  */
 
-#define _GNU_SOURCE
 #include <limits.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -33,11 +21,13 @@
 
 #include <lttng/ust-ctl.h>
 #include <ust-comm.h>
-#include <helper.h>
+#include <ust-fd.h>
+#include <ust-helper.h>
 #include <lttng/ust-error.h>
-#include <lttng/ust-events.h>
+#include <ust-dynamic-type.h>
 #include <usterr-signal-safe.h>
 
+#include "../liblttng-ust/ust-events-internal.h"
 #include "../liblttng-ust/compat.h"
 
 #define USTCOMM_CODE_OFFSET(code)	\
@@ -45,6 +35,19 @@
 
 #define USTCOMM_MAX_SEND_FDS	4
 
+static
+ssize_t count_fields_recursive(size_t nr_fields,
+		const struct lttng_ust_event_field **lttng_fields);
+static
+int serialize_one_field(struct lttng_ust_session *session,
+		struct ustctl_field *fields, size_t *iter_output,
+		const struct lttng_ust_event_field *lf);
+static
+int serialize_fields(struct lttng_ust_session *session,
+		struct ustctl_field *ustctl_fields,
+		size_t *iter_output, size_t nr_lttng_fields,
+		const struct lttng_ust_event_field **lttng_fields);
+
 /*
  * Human readable error message.
  */
@@ -61,23 +64,24 @@ static const char *ustcomm_readable_code[] = {
 	[ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_INVAL_MAGIC) ] = "Invalid magic number",
 	[ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_INVAL_SOCKET_TYPE) ] = "Invalid socket type",
 	[ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_UNSUP_MAJOR) ] = "Unsupported major version",
+	[ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_PEERCRED) ] = "Cannot get unix socket peer credentials",
+	[ USTCOMM_CODE_OFFSET(LTTNG_UST_ERR_PEERCRED_PID) ] = "Peer credentials PID is invalid. Socket appears to belong to a distinct, non-nested pid namespace.",
 };
 
 /*
  * lttng_ust_strerror
+ * @code: must be a negative value of enum lttng_ust_error_code (or 0).
  *
- * Receives positive error value.
- * Return ptr to string representing a human readable
- * error code from the ustcomm_return_code enum.
+ * Returns a ptr to a string representing a human readable error code from the
+ * ustcomm_return_code enum.
  */
 const char *lttng_ust_strerror(int code)
 {
-	if (code == LTTNG_UST_OK)
-		return ustcomm_readable_code[USTCOMM_CODE_OFFSET(code)];
-	if (code < LTTNG_UST_ERR)
-		return strerror(code);
-	if (code >= LTTNG_UST_ERR_NR)
+	code = -code;
+
+	if (code < LTTNG_UST_OK || code >= LTTNG_UST_ERR_NR)
 		code = LTTNG_UST_ERR;
+
 	return ustcomm_readable_code[USTCOMM_CODE_OFFSET(code)];
 }
 
@@ -85,8 +89,10 @@ const char *lttng_ust_strerror(int code)
  * ustcomm_connect_unix_sock
  *
  * Connect to unix socket using the path name.
+ *
+ * Caller handles FD tracker.
  */
-int ustcomm_connect_unix_sock(const char *pathname)
+int ustcomm_connect_unix_sock(const char *pathname, long timeout)
 {
 	struct sockaddr_un sun;
 	int fd, ret;
@@ -94,6 +100,7 @@ int ustcomm_connect_unix_sock(const char *pathname)
 	/*
 	 * libust threads require the close-on-exec flag for all
 	 * resources so it does not leak file descriptors upon exec.
+	 * SOCK_CLOEXEC is not used since it is linux specific.
 	 */
 	fd = socket(PF_UNIX, SOCK_STREAM, 0);
 	if (fd < 0) {
@@ -101,6 +108,15 @@ int ustcomm_connect_unix_sock(const char *pathname)
 		ret = -errno;
 		goto error;
 	}
+	if (timeout >= 0) {
+		/* Give at least 10ms. */
+		if (timeout < 10)
+			timeout = 10;
+		ret = ustcomm_setsockopt_snd_timeout(fd, timeout);
+		if (ret < 0) {
+			WARN("Error setting connect socket send timeout");
+		}
+	}
 	ret = fcntl(fd, F_SETFD, FD_CLOEXEC);
 	if (ret < 0) {
 		PERROR("fcntl");
@@ -239,16 +255,22 @@ int ustcomm_listen_unix_sock(int sock)
  * ustcomm_close_unix_sock
  *
  * Shutdown cleanly a unix socket.
+ *
+ * Handles fd tracker internally.
  */
 int ustcomm_close_unix_sock(int sock)
 {
 	int ret;
 
+	lttng_ust_lock_fd_tracker();
 	ret = close(sock);
-	if (ret < 0) {
+	if (!ret) {
+		lttng_ust_delete_fd_from_tracker(sock);
+	} else {
 		PERROR("close");
 		ret = -errno;
 	}
+	lttng_ust_unlock_fd_tracker();
 
 	return ret;
 }
@@ -411,8 +433,6 @@ ssize_t ustcomm_send_fds_unix_sock(int sock, int *fds, size_t nb_fd)
 /*
  * Recv a message accompanied by fd(s) from a unix socket.
  *
- * Returns the size of received data, or negative error value.
- *
  * Expect at most "nb_fd" file descriptors. Returns the number of fd
  * actually received in nb_fd.
  * Returns -EPIPE on orderly shutdown.
@@ -426,6 +446,7 @@ ssize_t ustcomm_recv_fds_unix_sock(int sock, int *fds, size_t nb_fd)
 	char recv_fd[CMSG_SPACE(sizeof_fds)];
 	struct msghdr msg;
 	char dummy;
+	int i;
 
 	memset(&msg, 0, sizeof(msg));
 
@@ -481,8 +502,19 @@ ssize_t ustcomm_recv_fds_unix_sock(int sock, int *fds, size_t nb_fd)
 		ret = -1;
 		goto end;
 	}
+
 	memcpy(fds, CMSG_DATA(cmsg), sizeof_fds);
-	ret = sizeof_fds;
+
+	/* Set FD_CLOEXEC */
+	for (i = 0; i < nb_fd; i++) {
+		ret = fcntl(fds[i], F_SETFD, FD_CLOEXEC);
+		if (ret < 0) {
+			PERROR("fcntl failed to set FD_CLOEXEC on fd %d",
+			       fds[i]);
+		}
+	}
+
+	ret = nb_fd;
 end:
 	return ret;
 }
@@ -571,9 +603,9 @@ ssize_t ustcomm_recv_channel_from_sessiond(int sock,
 {
 	void *chan_data;
 	ssize_t len, nr_fd;
-	int wakeup_fd;
+	int wakeup_fd, ret;
 
-	if (var_len > LTTNG_UST_CHANNEL_DATA_MAX_LEN) {
+	if (var_len > LTTNG_UST_ABI_CHANNEL_DATA_MAX_LEN) {
 		len = -EINVAL;
 		goto error_check;
 	}
@@ -588,8 +620,10 @@ ssize_t ustcomm_recv_channel_from_sessiond(int sock,
 		goto error_recv;
 	}
 	/* recv wakeup fd */
+	lttng_ust_lock_fd_tracker();
 	nr_fd = ustcomm_recv_fds_unix_sock(sock, &wakeup_fd, 1);
 	if (nr_fd <= 0) {
+		lttng_ust_unlock_fd_tracker();
 		if (nr_fd < 0) {
 			len = nr_fd;
 			goto error_recv;
@@ -598,7 +632,21 @@ ssize_t ustcomm_recv_channel_from_sessiond(int sock,
 			goto error_recv;
 		}
 	}
-	*_wakeup_fd = wakeup_fd;
+
+	ret = lttng_ust_add_fd_to_tracker(wakeup_fd);
+	if (ret < 0) {
+		ret = close(wakeup_fd);
+		if (ret) {
+			PERROR("close on wakeup_fd");
+		}
+		len = -EIO;
+		lttng_ust_unlock_fd_tracker();
+		goto error_recv;
+	}
+
+	*_wakeup_fd = ret;
+	lttng_ust_unlock_fd_tracker();
+
 	*_chan_data = chan_data;
 	return len;
 
@@ -609,8 +657,48 @@ error_check:
 	return len;
 }
 
+ssize_t ustcomm_recv_event_notifier_notif_fd_from_sessiond(int sock,
+		int *_event_notifier_notif_fd)
+{
+	ssize_t nr_fd;
+	int event_notifier_notif_fd, ret;
+
+	/* Receive event_notifier notification fd */
+	lttng_ust_lock_fd_tracker();
+	nr_fd = ustcomm_recv_fds_unix_sock(sock, &event_notifier_notif_fd, 1);
+	if (nr_fd <= 0) {
+		lttng_ust_unlock_fd_tracker();
+		if (nr_fd < 0) {
+			ret = nr_fd;
+			goto error;
+		} else {
+			ret = -EIO;
+			goto error;
+		}
+	}
+
+	ret = lttng_ust_add_fd_to_tracker(event_notifier_notif_fd);
+	if (ret < 0) {
+		ret = close(event_notifier_notif_fd);
+		if (ret) {
+			PERROR("close on event_notifier notif fd");
+		}
+		ret = -EIO;
+		lttng_ust_unlock_fd_tracker();
+		goto error;
+	}
+
+	*_event_notifier_notif_fd = ret;
+	lttng_ust_unlock_fd_tracker();
+
+	ret = nr_fd;
+
+error:
+	return ret;
+}
+
 int ustcomm_recv_stream_from_sessiond(int sock,
-		uint64_t *memory_map_size,
+		uint64_t *memory_map_size __attribute__((unused)),
 		int *shm_fd, int *wakeup_fd)
 {
 	ssize_t len;
@@ -618,8 +706,10 @@ int ustcomm_recv_stream_from_sessiond(int sock,
 	int fds[2];
 
 	/* recv shm fd and wakeup fd */
+	lttng_ust_lock_fd_tracker();
 	len = ustcomm_recv_fds_unix_sock(sock, fds, 2);
 	if (len <= 0) {
+		lttng_ust_unlock_fd_tracker();
 		if (len < 0) {
 			ret = len;
 			goto error;
@@ -628,8 +718,105 @@ int ustcomm_recv_stream_from_sessiond(int sock,
 			goto error;
 		}
 	}
-	*shm_fd = fds[0];
-	*wakeup_fd = fds[1];
+
+	ret = lttng_ust_add_fd_to_tracker(fds[0]);
+	if (ret < 0) {
+		ret = close(fds[0]);
+		if (ret) {
+			PERROR("close on received shm_fd");
+		}
+		ret = -EIO;
+		lttng_ust_unlock_fd_tracker();
+		goto error;
+	}
+	*shm_fd = ret;
+
+	ret = lttng_ust_add_fd_to_tracker(fds[1]);
+	if (ret < 0) {
+		ret = close(*shm_fd);
+		if (ret) {
+			PERROR("close on shm_fd");
+		}
+		*shm_fd = -1;
+		ret = close(fds[1]);
+		if (ret) {
+			PERROR("close on received wakeup_fd");
+		}
+		ret = -EIO;
+		lttng_ust_unlock_fd_tracker();
+		goto error;
+	}
+	*wakeup_fd = ret;
+	lttng_ust_unlock_fd_tracker();
+	return 0;
+
+error:
+	return ret;
+}
+
+ssize_t ustcomm_recv_counter_from_sessiond(int sock,
+		void **_counter_data, uint64_t var_len)
+{
+	void *counter_data;
+	ssize_t len;
+
+	if (var_len > LTTNG_UST_ABI_COUNTER_DATA_MAX_LEN) {
+		len = -EINVAL;
+		goto error_check;
+	}
+	/* Receive variable length data */
+	counter_data = zmalloc(var_len);
+	if (!counter_data) {
+		len = -ENOMEM;
+		goto error_alloc;
+	}
+	len = ustcomm_recv_unix_sock(sock, counter_data, var_len);
+	if (len != var_len) {
+		goto error_recv;
+	}
+	*_counter_data = counter_data;
+	return len;
+
+error_recv:
+	free(counter_data);
+error_alloc:
+error_check:
+	return len;
+}
+
+int ustcomm_recv_counter_shm_from_sessiond(int sock,
+		int *shm_fd)
+{
+	ssize_t len;
+	int ret;
+	int fds[1];
+
+	/* recv shm fd fd */
+	lttng_ust_lock_fd_tracker();
+	len = ustcomm_recv_fds_unix_sock(sock, fds, 1);
+	if (len <= 0) {
+		lttng_ust_unlock_fd_tracker();
+		if (len < 0) {
+			ret = len;
+			goto error;
+		} else {
+			ret = -EIO;
+			goto error;
+		}
+	}
+
+	ret = lttng_ust_add_fd_to_tracker(fds[0]);
+	if (ret < 0) {
+		ret = close(fds[0]);
+		if (ret) {
+			PERROR("close on received shm_fd");
+		}
+		ret = -EIO;
+		lttng_ust_unlock_fd_tracker();
+		goto error;
+	}
+	*shm_fd = ret;
+	lttng_ust_unlock_fd_tracker();
 	return 0;
 
 error:
@@ -651,7 +838,7 @@ int ustcomm_send_reg_msg(int sock,
 	ssize_t len;
 	struct ustctl_reg_msg reg_msg;
 
-	reg_msg.magic = LTTNG_UST_COMM_MAGIC;
+	reg_msg.magic = LTTNG_UST_ABI_COMM_MAGIC;
 	reg_msg.major = LTTNG_UST_ABI_MAJOR_VERSION;
 	reg_msg.minor = LTTNG_UST_ABI_MINOR_VERSION;
 	reg_msg.pid = getpid();
@@ -665,7 +852,7 @@ int ustcomm_send_reg_msg(int sock,
 	reg_msg.uint64_t_alignment = uint64_t_alignment;
 	reg_msg.long_alignment = long_alignment;
 	reg_msg.socket_type = type;
-	lttng_ust_getprocname(reg_msg.name);
+	lttng_pthread_getname_np(reg_msg.name, LTTNG_UST_ABI_PROCNAME_LEN);
 	memset(reg_msg.padding, 0, sizeof(reg_msg.padding));
 
 	len = ustcomm_send_unix_sock(sock, &reg_msg, sizeof(reg_msg));
@@ -677,17 +864,102 @@ int ustcomm_send_reg_msg(int sock,
 }
 
 static
-int serialize_string_encoding(enum ustctl_string_encodings *ue,
-		enum lttng_string_encodings le)
+ssize_t count_one_type(const struct lttng_ust_type_common *lt)
+{
+	switch (lt->type) {
+	case lttng_ust_type_integer:
+	case lttng_ust_type_float:
+	case lttng_ust_type_string:
+		return 1;
+	case lttng_ust_type_enum:
+		return count_one_type(lttng_ust_get_type_enum(lt)->container_type) + 1;
+	case lttng_ust_type_array:
+		return count_one_type(lttng_ust_get_type_array(lt)->elem_type) + 1;
+	case lttng_ust_type_sequence:
+		return count_one_type(lttng_ust_get_type_sequence(lt)->elem_type) + 1;
+	case lttng_ust_type_struct:
+		return count_fields_recursive(lttng_ust_get_type_struct(lt)->nr_fields,
+				lttng_ust_get_type_struct(lt)->fields) + 1;
+
+	case lttng_ust_type_dynamic:
+	{
+		const struct lttng_ust_event_field **choices;
+		size_t nr_choices;
+		int ret;
+
+		ret = lttng_ust_dynamic_type_choices(&nr_choices,
+			&choices);
+		if (ret)
+			return ret;
+		/*
+		 * Two fields for enum, one field for variant, and
+		 * one field per choice.
+		 */
+		return count_fields_recursive(nr_choices, choices) + 3;
+	}
+
+	default:
+		return -EINVAL;
+	}
+	return 0;
+}
+
+static
+ssize_t count_fields_recursive(size_t nr_fields,
+		const struct lttng_ust_event_field **lttng_fields)
+{
+	int i;
+	ssize_t ret, count = 0;
+
+	for (i = 0; i < nr_fields; i++) {
+		const struct lttng_ust_event_field *lf;
+
+		lf = lttng_fields[i];
+		/* skip 'nowrite' fields */
+		if (lf->nowrite)
+			continue;
+		ret = count_one_type(lf->type);
+		if (ret < 0)
+			return ret;	/* error */
+		count += ret;
+	}
+	return count;
+}
+
+static
+ssize_t count_ctx_fields_recursive(size_t nr_fields,
+		struct lttng_ust_ctx_field *lttng_fields)
+{
+	int i;
+	ssize_t ret, count = 0;
+
+	for (i = 0; i < nr_fields; i++) {
+		const struct lttng_ust_event_field *lf;
+
+		lf = lttng_fields[i].event_field;
+		/* skip 'nowrite' fields */
+		if (lf->nowrite)
+			continue;
+		ret = count_one_type(lf->type);
+		if (ret < 0)
+			return ret;	/* error */
+		count += ret;
+	}
+	return count;
+}
+
+static
+int serialize_string_encoding(int32_t *ue,
+		enum lttng_ust_string_encoding le)
 {
 	switch (le) {
-	case lttng_encode_none:
+	case lttng_ust_string_encoding_none:
 		*ue = ustctl_encode_none;
 		break;
-	case lttng_encode_UTF8:
+	case lttng_ust_string_encoding_UTF8:
 		*ue = ustctl_encode_UTF8;
 		break;
-	case lttng_encode_ASCII:
+	case lttng_ust_string_encoding_ASCII:
 		*ue = ustctl_encode_ASCII;
 		break;
 	default:
@@ -698,136 +970,268 @@ int serialize_string_encoding(enum ustctl_string_encodings *ue,
 
 static
 int serialize_integer_type(struct ustctl_integer_type *uit,
-		const struct lttng_integer_type *lit)
+		const struct lttng_ust_type_integer *lit,
+		enum lttng_ust_string_encoding lencoding)
 {
+	int32_t encoding;
+
 	uit->size = lit->size;
 	uit->signedness = lit->signedness;
 	uit->reverse_byte_order = lit->reverse_byte_order;
 	uit->base = lit->base;
-	if (serialize_string_encoding(&uit->encoding, lit->encoding))
+	if (serialize_string_encoding(&encoding, lencoding))
 		return -EINVAL;
+	uit->encoding = encoding;
 	uit->alignment = lit->alignment;
 	return 0;
 }
 
 static
-int serialize_basic_type(struct lttng_session *session,
-		enum ustctl_abstract_types *uatype,
-		enum lttng_abstract_types atype,
-		union _ustctl_basic_type *ubt,
-		const union _lttng_basic_type *lbt)
+int serialize_dynamic_type(struct lttng_ust_session *session,
+		struct ustctl_field *fields, size_t *iter_output,
+		const char *field_name)
 {
-	switch (atype) {
-	case atype_integer:
-	{
-		if (serialize_integer_type(&ubt->integer, &lbt->integer))
-			return -EINVAL;
-		*uatype = ustctl_atype_integer;
-		break;
+	const struct lttng_ust_event_field **choices;
+	char tag_field_name[LTTNG_UST_ABI_SYM_NAME_LEN];
+	const struct lttng_ust_type_common *tag_type;
+	const struct lttng_ust_event_field *tag_field_generic;
+	struct lttng_ust_event_field tag_field = {
+		.name = tag_field_name,
+		.nowrite = 0,
+	};
+	struct ustctl_field *uf;
+	size_t nr_choices, i;
+	int ret;
+
+	tag_field_generic = lttng_ust_dynamic_type_tag_field();
+	tag_type = tag_field_generic->type;
+
+	/* Serialize enum field. */
+	strncpy(tag_field_name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+	tag_field_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+	strncat(tag_field_name,
+		"_tag",
+		LTTNG_UST_ABI_SYM_NAME_LEN - strlen(tag_field_name) - 1);
+	tag_field.type = tag_type;
+	ret = serialize_one_field(session, fields, iter_output,
+		&tag_field);
+	if (ret)
+		return ret;
+
+	/* Serialize variant field. */
+	uf = &fields[*iter_output];
+	ret = lttng_ust_dynamic_type_choices(&nr_choices, &choices);
+	if (ret)
+		return ret;
+
+	strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+	uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+	uf->type.atype = ustctl_atype_variant;
+	uf->type.u.variant_nestable.nr_choices = nr_choices;
+	strncpy(uf->type.u.variant_nestable.tag_name,
+		tag_field_name,
+		LTTNG_UST_ABI_SYM_NAME_LEN);
+	uf->type.u.variant_nestable.tag_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+	uf->type.u.variant_nestable.alignment = 0;
+	(*iter_output)++;
+
+	/* Serialize choice fields after variant. */
+	for (i = 0; i < nr_choices; i++) {
+		ret = serialize_one_field(session, fields,
+			iter_output, choices[i]);
+		if (ret)
+			return ret;
 	}
-	case atype_string:
+	return 0;
+}
+
+static
+int serialize_one_type(struct lttng_ust_session *session,
+		struct ustctl_field *fields, size_t *iter_output,
+		const char *field_name, const struct lttng_ust_type_common *lt,
+		enum lttng_ust_string_encoding parent_encoding)
+{
+	int ret;
+
+	/*
+	 * Serializing a type (rather than a field) generates a ustctl_field
+	 * entry with 0-length name.
+	 */
+
+	switch (lt->type) {
+	case lttng_ust_type_integer:
 	{
-		if (serialize_string_encoding(&ubt->string.encoding,
-				lbt->string.encoding))
-			return -EINVAL;
-		*uatype = ustctl_atype_string;
+		struct ustctl_field *uf = &fields[*iter_output];
+		struct ustctl_type *ut = &uf->type;
+
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+		} else {
+			uf->name[0] = '\0';
+		}
+		ret = serialize_integer_type(&ut->u.integer, lttng_ust_get_type_integer(lt),
+				parent_encoding);
+		if (ret)
+			return ret;
+		ut->atype = ustctl_atype_integer;
+		(*iter_output)++;
 		break;
 	}
-	case atype_float:
+	case lttng_ust_type_float:
 	{
+		struct ustctl_field *uf = &fields[*iter_output];
+		struct ustctl_type *ut = &uf->type;
 		struct ustctl_float_type *uft;
-		const struct lttng_float_type *lft;
+		const struct lttng_ust_type_float *lft;
 
-		uft = &ubt->_float;
-		lft = &lbt->_float;
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+		} else {
+			uf->name[0] = '\0';
+		}
+		uft = &ut->u._float;
+		lft = lttng_ust_get_type_float(lt);
 		uft->exp_dig = lft->exp_dig;
 		uft->mant_dig = lft->mant_dig;
 		uft->alignment = lft->alignment;
 		uft->reverse_byte_order = lft->reverse_byte_order;
-		*uatype = ustctl_atype_float;
+		ut->atype = ustctl_atype_float;
+		(*iter_output)++;
 		break;
 	}
-	case atype_enum:
+	case lttng_ust_type_string:
 	{
-		strncpy(ubt->enumeration.name, lbt->enumeration.desc->name,
-				LTTNG_UST_SYM_NAME_LEN);
-		ubt->enumeration.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
-		if (serialize_integer_type(&ubt->enumeration.container_type,
-				&lbt->enumeration.container_type))
-			return -EINVAL;
-		if (session) {
-			const struct lttng_enum *_enum;
+		struct ustctl_field *uf = &fields[*iter_output];
+		struct ustctl_type *ut = &uf->type;
+		int32_t encoding;
 
-			_enum = lttng_ust_enum_get(session,
-					lbt->enumeration.desc->name);
-			if (!_enum)
-				return -EINVAL;
-			ubt->enumeration.id = _enum->id;
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
 		} else {
-			ubt->enumeration.id = -1ULL;
+			uf->name[0] = '\0';
 		}
-		*uatype = ustctl_atype_enum;
+		ret = serialize_string_encoding(&encoding, lttng_ust_get_type_string(lt)->encoding);
+		if (ret)
+			return ret;
+		ut->u.string.encoding = encoding;
+		ut->atype = ustctl_atype_string;
+		(*iter_output)++;
 		break;
 	}
-	case atype_array:
-	case atype_sequence:
-	default:
-		return -EINVAL;
-	}
-	return 0;
-}
-
-static
-int serialize_one_type(struct lttng_session *session,
-		struct ustctl_type *ut, const struct lttng_type *lt)
-{
-	int ret;
+	case lttng_ust_type_array:
+	{
+		struct ustctl_field *uf = &fields[*iter_output];
+		struct ustctl_type *ut = &uf->type;
 
-	switch (lt->atype) {
-	case atype_integer:
-	case atype_float:
-	case atype_string:
-	case atype_enum:
-		ret = serialize_basic_type(session, &ut->atype, lt->atype,
-			&ut->u.basic, &lt->u.basic);
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+		} else {
+			uf->name[0] = '\0';
+		}
+		ut->atype = ustctl_atype_array_nestable;
+		ut->u.array_nestable.length = lttng_ust_get_type_array(lt)->length;
+		ut->u.array_nestable.alignment = lttng_ust_get_type_array(lt)->alignment;
+		(*iter_output)++;
+
+		ret = serialize_one_type(session, fields, iter_output, NULL,
+				lttng_ust_get_type_array(lt)->elem_type,
+				lttng_ust_get_type_array(lt)->encoding);
 		if (ret)
-			return ret;
+			return -EINVAL;
 		break;
-	case atype_array:
+	}
+	case lttng_ust_type_sequence:
 	{
-		struct ustctl_basic_type *ubt;
-		const struct lttng_basic_type *lbt;
-		int ret;
+		struct ustctl_field *uf = &fields[*iter_output];
+		struct ustctl_type *ut = &uf->type;
 
-		ubt = &ut->u.array.elem_type;
-		lbt = &lt->u.array.elem_type;
-		ut->u.array.length = lt->u.array.length;
-		ret = serialize_basic_type(session, &ubt->atype, lbt->atype,
-			&ubt->u.basic, &lbt->u.basic);
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+		} else {
+			uf->name[0] = '\0';
+		}
+		ut->atype = ustctl_atype_sequence_nestable;
+		strncpy(ut->u.sequence_nestable.length_name,
+			lttng_ust_get_type_sequence(lt)->length_name,
+			LTTNG_UST_ABI_SYM_NAME_LEN);
+		ut->u.sequence_nestable.length_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+		ut->u.sequence_nestable.alignment = lttng_ust_get_type_sequence(lt)->alignment;
+		(*iter_output)++;
+
+		ret = serialize_one_type(session, fields, iter_output, NULL,
+				lttng_ust_get_type_sequence(lt)->elem_type,
+				lttng_ust_get_type_sequence(lt)->encoding);
 		if (ret)
 			return -EINVAL;
-		ut->atype = ustctl_atype_array;
 		break;
 	}
-	case atype_sequence:
+	case lttng_ust_type_dynamic:
 	{
-		struct ustctl_basic_type *ubt;
-		const struct lttng_basic_type *lbt;
-		int ret;
+		ret = serialize_dynamic_type(session, fields, iter_output,
+				field_name);
+		if (ret)
+			return -EINVAL;
+		break;
+	}
+	case lttng_ust_type_struct:
+	{
+		struct ustctl_field *uf = &fields[*iter_output];
 
-		ubt = &ut->u.sequence.length_type;
-		lbt = &lt->u.sequence.length_type;
-		ret = serialize_basic_type(session, &ubt->atype, lbt->atype,
-			&ubt->u.basic, &lbt->u.basic);
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+		} else {
+			uf->name[0] = '\0';
+		}
+		uf->type.atype = ustctl_atype_struct_nestable;
+		uf->type.u.struct_nestable.nr_fields = lttng_ust_get_type_struct(lt)->nr_fields;
+		uf->type.u.struct_nestable.alignment = lttng_ust_get_type_struct(lt)->alignment;
+		(*iter_output)++;
+
+		ret = serialize_fields(session, fields, iter_output,
+				lttng_ust_get_type_struct(lt)->nr_fields,
+				lttng_ust_get_type_struct(lt)->fields);
 		if (ret)
 			return -EINVAL;
-		ubt = &ut->u.sequence.elem_type;
-		lbt = &lt->u.sequence.elem_type;
-		ret = serialize_basic_type(session, &ubt->atype, lbt->atype,
-			&ubt->u.basic, &lbt->u.basic);
+		break;
+	}
+	case lttng_ust_type_enum:
+	{
+		struct ustctl_field *uf = &fields[*iter_output];
+		struct ustctl_type *ut = &uf->type;
+
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+		} else {
+			uf->name[0] = '\0';
+		}
+		strncpy(ut->u.enum_nestable.name, lttng_ust_get_type_enum(lt)->desc->name,
+				LTTNG_UST_ABI_SYM_NAME_LEN);
+		ut->u.enum_nestable.name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+		ut->atype = ustctl_atype_enum_nestable;
+		(*iter_output)++;
+
+		ret = serialize_one_type(session, fields, iter_output, NULL,
+				lttng_ust_get_type_enum(lt)->container_type,
+				lttng_ust_string_encoding_none);
 		if (ret)
 			return -EINVAL;
-		ut->atype = ustctl_atype_sequence;
+		if (session) {
+			const struct lttng_enum *_enum;
+
+			_enum = lttng_ust_enum_get_from_desc(session, lttng_ust_get_type_enum(lt)->desc);
+			if (!_enum)
+				return -EINVAL;
+			ut->u.enum_nestable.id = _enum->id;
+		} else {
+			ut->u.enum_nestable.id = -1ULL;
+		}
 		break;
 	}
 	default:
@@ -837,37 +1241,60 @@ int serialize_one_type(struct lttng_session *session,
 }
 
 static
-int serialize_fields(struct lttng_session *session,
+int serialize_one_field(struct lttng_ust_session *session,
+		struct ustctl_field *fields, size_t *iter_output,
+		const struct lttng_ust_event_field *lf)
+{
+	/* skip 'nowrite' fields */
+	if (lf->nowrite)
+		return 0;
+
+	return serialize_one_type(session, fields, iter_output, lf->name, lf->type, lttng_ust_string_encoding_none);
+}
+
+static
+int serialize_fields(struct lttng_ust_session *session,
+		struct ustctl_field *ustctl_fields,
+		size_t *iter_output, size_t nr_lttng_fields,
+		const struct lttng_ust_event_field **lttng_fields)
+{
+	int ret;
+	size_t i;
+
+	for (i = 0; i < nr_lttng_fields; i++) {
+		ret = serialize_one_field(session, ustctl_fields,
+				iter_output, lttng_fields[i]);
+		if (ret)
+			return ret;
+	}
+	return 0;
+}
+
+static
+int alloc_serialize_fields(struct lttng_ust_session *session,
 		size_t *_nr_write_fields,
 		struct ustctl_field **ustctl_fields,
 		size_t nr_fields,
-		const struct lttng_event_field *lttng_fields)
+		const struct lttng_ust_event_field **lttng_fields)
 {
 	struct ustctl_field *fields;
-	int i, ret;
-	size_t nr_write_fields = 0;
+	int ret;
+	size_t iter_output = 0;
+	ssize_t nr_write_fields;
+
+	nr_write_fields = count_fields_recursive(nr_fields, lttng_fields);
+	if (nr_write_fields < 0) {
+		return (int) nr_write_fields;
+	}
 
-	fields = zmalloc(nr_fields * sizeof(*fields));
+	fields = zmalloc(nr_write_fields * sizeof(*fields));
 	if (!fields)
 		return -ENOMEM;
 
-	for (i = 0; i < nr_fields; i++) {
-		struct ustctl_field *f;
-		const struct lttng_event_field *lf;
-
-		f = &fields[nr_write_fields];
-		lf = &lttng_fields[i];
-
-		/* skip 'nowrite' fields */
-		if (lf->nowrite)
-			continue;
-		strncpy(f->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
-		f->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
-		ret = serialize_one_type(session, &f->type, &lf->type);
-		if (ret)
-			goto error_type;
-		nr_write_fields++;
-	}
+	ret = serialize_fields(session, fields, &iter_output, nr_fields,
+			lttng_fields);
+	if (ret)
+		goto error_type;
 
 	*_nr_write_fields = nr_write_fields;
 	*ustctl_fields = fields;
@@ -881,7 +1308,7 @@ error_type:
 static
 int serialize_entries(struct ustctl_enum_entry **_entries,
 		size_t nr_entries,
-		const struct lttng_enum_entry *lttng_entries)
+		const struct lttng_ust_enum_entry **lttng_entries)
 {
 	struct ustctl_enum_entry *entries;
 	int i;
@@ -892,50 +1319,54 @@ int serialize_entries(struct ustctl_enum_entry **_entries,
 		return -ENOMEM;
 	for (i = 0; i < nr_entries; i++) {
 		struct ustctl_enum_entry *uentry;
-		const struct lttng_enum_entry *lentry;
+		const struct lttng_ust_enum_entry *lentry;
 
 		uentry = &entries[i];
-		lentry = &lttng_entries[i];
-
-		uentry->start = lentry->start;
-		uentry->end = lentry->end;
-		strncpy(uentry->string, lentry->string, LTTNG_UST_SYM_NAME_LEN);
-		uentry->string[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+		lentry = lttng_entries[i];
+
+		uentry->start.value = lentry->start.value;
+		uentry->start.signedness = lentry->start.signedness;
+		uentry->end.value = lentry->end.value;
+		uentry->end.signedness = lentry->end.signedness;
+		strncpy(uentry->string, lentry->string, LTTNG_UST_ABI_SYM_NAME_LEN);
+		uentry->string[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
+
+		if (lentry->options & LTTNG_UST_ENUM_ENTRY_OPTION_IS_AUTO) {
+			uentry->u.extra.options |=
+				USTCTL_UST_ENUM_ENTRY_OPTION_IS_AUTO;
+		}
 	}
 	*_entries = entries;
 	return 0;
 }
 
 static
-int serialize_ctx_fields(size_t *_nr_write_fields,
+int serialize_ctx_fields(struct lttng_ust_session *session,
+		size_t *_nr_write_fields,
 		struct ustctl_field **ustctl_fields,
 		size_t nr_fields,
-		const struct lttng_ctx_field *lttng_fields)
+		struct lttng_ust_ctx_field *lttng_fields)
 {
 	struct ustctl_field *fields;
-	int i, ret;
-	size_t nr_write_fields = 0;
+	int ret;
+	size_t i, iter_output = 0;
+	ssize_t nr_write_fields;
 
-	fields = zmalloc(nr_fields * sizeof(*fields));
+	nr_write_fields = count_ctx_fields_recursive(nr_fields,
+			lttng_fields);
+	if (nr_write_fields < 0) {
+		return (int) nr_write_fields;
+	}
+
+	fields = zmalloc(nr_write_fields * sizeof(*fields));
 	if (!fields)
 		return -ENOMEM;
 
 	for (i = 0; i < nr_fields; i++) {
-		struct ustctl_field *f;
-		const struct lttng_event_field *lf;
-
-		f = &fields[nr_write_fields];
-		lf = &lttng_fields[i].event_field;
-
-		/* skip 'nowrite' fields */
-		if (lf->nowrite)
-			continue;
-		strncpy(f->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
-		f->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
-		ret = serialize_one_type(NULL, &f->type, &lf->type);
+		ret = serialize_one_field(session, fields, &iter_output,
+				lttng_fields[i].event_field);
 		if (ret)
 			goto error_type;
-		nr_write_fields++;
 	}
 
 	*_nr_write_fields = nr_write_fields;
@@ -951,14 +1382,14 @@ error_type:
  * Returns 0 on success, negative error value on error.
  */
 int ustcomm_register_event(int sock,
-	struct lttng_session *session,
+	struct lttng_ust_session *session,
 	int session_objd,		/* session descriptor */
 	int channel_objd,		/* channel descriptor */
 	const char *event_name,		/* event name (input) */
 	int loglevel,
 	const char *signature,		/* event signature (input) */
 	size_t nr_fields,		/* fields */
-	const struct lttng_event_field *lttng_fields,
+	const struct lttng_ust_event_field **lttng_fields,
 	const char *model_emf_uri,
 	uint32_t *id)			/* event id (output) */
 {
@@ -980,15 +1411,15 @@ int ustcomm_register_event(int sock,
 	msg.header.notify_cmd = USTCTL_NOTIFY_CMD_EVENT;
 	msg.m.session_objd = session_objd;
 	msg.m.channel_objd = channel_objd;
-	strncpy(msg.m.event_name, event_name, LTTNG_UST_SYM_NAME_LEN);
-	msg.m.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+	strncpy(msg.m.event_name, event_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+	msg.m.event_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
 	msg.m.loglevel = loglevel;
 	signature_len = strlen(signature) + 1;
 	msg.m.signature_len = signature_len;
 
 	/* Calculate fields len, serialize fields. */
 	if (nr_fields > 0) {
-		ret = serialize_fields(session, &nr_write_fields, &fields,
+		ret = alloc_serialize_fields(session, &nr_write_fields, &fields,
 				nr_fields, lttng_fields);
 		if (ret)
 			return ret;
@@ -1016,18 +1447,17 @@ int ustcomm_register_event(int sock,
 	/* send signature */
 	len = ustcomm_send_unix_sock(sock, signature, signature_len);
 	if (len > 0 && len != signature_len) {
-		free(fields);
-		return -EIO;
+		ret = -EIO;
+		goto error_fields;
 	}
 	if (len < 0) {
-		free(fields);
-		return len;
+		ret = len;
+		goto error_fields;
 	}
 
 	/* send fields */
 	if (fields_len > 0) {
 		len = ustcomm_send_unix_sock(sock, fields, fields_len);
-		free(fields);
 		if (len > 0 && len != fields_len) {
 			ret = -EIO;
 			goto error_fields;
@@ -1036,21 +1466,18 @@ int ustcomm_register_event(int sock,
 			ret = len;
 			goto error_fields;
 		}
-	} else {
-		free(fields);
 	}
+	free(fields);
 
 	if (model_emf_uri_len) {
 		/* send model_emf_uri */
 		len = ustcomm_send_unix_sock(sock, model_emf_uri,
 				model_emf_uri_len);
 		if (len > 0 && len != model_emf_uri_len) {
-			ret = -EIO;
-			goto error_fields;
+			return -EIO;
 		}
 		if (len < 0) {
-			ret = len;
-			goto error_fields;
+			return len;
 		}
 	}
 
@@ -1085,7 +1512,9 @@ int ustcomm_register_event(int sock,
 			return len;
 		}
 	}
+	/* Unreached. */
 
+	/* Error path only. */
 error_fields:
 	free(fields);
 	return ret;
@@ -1099,7 +1528,7 @@ int ustcomm_register_enum(int sock,
 	int session_objd,		/* session descriptor */
 	const char *enum_name,		/* enum name (input) */
 	size_t nr_entries,		/* entries */
-	const struct lttng_enum_entry *lttng_entries,
+	const struct lttng_ust_enum_entry **lttng_entries,
 	uint64_t *id)
 {
 	ssize_t len;
@@ -1118,8 +1547,8 @@ int ustcomm_register_enum(int sock,
 	memset(&msg, 0, sizeof(msg));
 	msg.header.notify_cmd = USTCTL_NOTIFY_CMD_ENUM;
 	msg.m.session_objd = session_objd;
-	strncpy(msg.m.enum_name, enum_name, LTTNG_UST_SYM_NAME_LEN);
-	msg.m.enum_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+	strncpy(msg.m.enum_name, enum_name, LTTNG_UST_ABI_SYM_NAME_LEN);
+	msg.m.enum_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0';
 
 	/* Calculate entries len, serialize entries. */
 	if (nr_entries > 0) {
@@ -1200,10 +1629,11 @@ error_entries:
  * Returns -EPIPE or -ECONNRESET if other end has hung up.
  */
 int ustcomm_register_channel(int sock,
+	struct lttng_ust_session *session,
 	int session_objd,		/* session descriptor */
 	int channel_objd,		/* channel descriptor */
 	size_t nr_ctx_fields,
-	const struct lttng_ctx_field *ctx_fields,
+	struct lttng_ust_ctx_field *ctx_fields,
 	uint32_t *chan_id,		/* channel id (output) */
 	int *header_type) 		/* header type (output) */
 {
@@ -1228,7 +1658,7 @@ int ustcomm_register_channel(int sock,
 
 	/* Calculate fields len, serialize fields. */
 	if (nr_ctx_fields > 0) {
-		ret = serialize_ctx_fields(&nr_write_fields, &fields,
+		ret = serialize_ctx_fields(session, &nr_write_fields, &fields,
 				nr_ctx_fields, ctx_fields);
 		if (ret)
 			return ret;