X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust-comm%2Flttng-ust-comm.c;h=d2057daf95d9320b095e6a67c2d3b644c7b16f32;hb=a834901f2890deadb815d7f9e3ab79c3ba673994;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..d2057daf 100644
--- a/liblttng-ust-comm/lttng-ust-comm.c
+++ b/liblttng-ust-comm/lttng-ust-comm.c
@@ -17,8 +17,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#define _GNU_SOURCE
 #include <limits.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -33,9 +33,11 @@
 
 #include <lttng/ust-ctl.h>
 #include <ust-comm.h>
+#include <ust-fd.h>
 #include <helper.h>
 #include <lttng/ust-error.h>
 #include <lttng/ust-events.h>
+#include <lttng/ust-dynamic-type.h>
 #include <usterr-signal-safe.h>
 
 #include "../liblttng-ust/compat.h"
@@ -45,6 +47,19 @@
 
 #define USTCOMM_MAX_SEND_FDS	4
 
+static
+ssize_t count_fields_recursive(size_t nr_fields,
+		const struct lttng_event_field *lttng_fields);
+static
+int serialize_one_field(struct lttng_session *session,
+		struct ustctl_field *fields, size_t *iter_output,
+		const struct lttng_event_field *lf);
+static
+int serialize_fields(struct lttng_session *session,
+		struct ustctl_field *ustctl_fields,
+		size_t *iter_output, size_t nr_lttng_fields,
+		const struct lttng_event_field *lttng_fields);
+
 /*
  * Human readable error message.
  */
@@ -61,6 +76,8 @@ 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.",
 };
 
 /*
@@ -85,8 +102,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 +113,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 +121,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 +268,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 +446,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 +459,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 +515,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,7 +616,7 @@ 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) {
 		len = -EINVAL;
@@ -588,8 +633,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 +645,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,6 +670,46 @@ 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,
 		int *shm_fd, int *wakeup_fd)
@@ -618,8 +719,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 +731,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_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:
@@ -665,7 +865,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,7 +877,98 @@ int ustcomm_send_reg_msg(int sock,
 }
 
 static
-int serialize_string_encoding(enum ustctl_string_encodings *ue,
+ssize_t count_one_type(const struct lttng_type *lt)
+{
+	switch (lt->atype) {
+	case atype_integer:
+	case atype_float:
+	case atype_string:
+	case atype_enum:
+	case atype_array:
+	case atype_sequence:
+		return 1;
+	case atype_struct:
+		return count_fields_recursive(lt->u.legacy._struct.nr_fields,
+				lt->u.legacy._struct.fields) + 1;
+	case atype_enum_nestable:
+		return count_one_type(lt->u.enum_nestable.container_type) + 1;
+	case atype_array_nestable:
+		return count_one_type(lt->u.array_nestable.elem_type) + 1;
+	case atype_sequence_nestable:
+		return count_one_type(lt->u.sequence_nestable.elem_type) + 1;
+	case atype_struct_nestable:
+		return count_fields_recursive(lt->u.struct_nestable.nr_fields,
+				lt->u.struct_nestable.fields) + 1;
+
+	case atype_dynamic:
+	{
+		const struct lttng_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_event_field *lttng_fields)
+{
+	int i;
+	ssize_t ret, count = 0;
+
+	for (i = 0; i < nr_fields; i++) {
+		const struct lttng_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,
+		const struct lttng_ctx_field *lttng_fields)
+{
+	int i;
+	ssize_t ret, count = 0;
+
+	for (i = 0; i < nr_fields; i++) {
+		const struct lttng_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_string_encodings le)
 {
 	switch (le) {
@@ -700,12 +991,15 @@ static
 int serialize_integer_type(struct ustctl_integer_type *uit,
 		const struct lttng_integer_type *lit)
 {
+	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, lit->encoding))
 		return -EINVAL;
+	uit->encoding = encoding;
 	uit->alignment = lit->alignment;
 	return 0;
 }
@@ -727,9 +1021,11 @@ int serialize_basic_type(struct lttng_session *session,
 	}
 	case atype_string:
 	{
-		if (serialize_string_encoding(&ubt->string.encoding,
-				lbt->string.encoding))
+		int32_t encoding;
+
+		if (serialize_string_encoding(&encoding, lbt->string.encoding))
 			return -EINVAL;
+		ubt->string.encoding = encoding;
 		*uatype = ustctl_atype_string;
 		break;
 	}
@@ -758,8 +1054,7 @@ int serialize_basic_type(struct lttng_session *session,
 		if (session) {
 			const struct lttng_enum *_enum;
 
-			_enum = lttng_ust_enum_get(session,
-					lbt->enumeration.desc->name);
+			_enum = lttng_ust_enum_get_from_desc(session, lbt->enumeration.desc);
 			if (!_enum)
 				return -EINVAL;
 			ubt->enumeration.id = _enum->id;
@@ -770,64 +1065,298 @@ int serialize_basic_type(struct lttng_session *session,
 		break;
 	}
 	case atype_array:
+	case atype_array_nestable:
 	case atype_sequence:
+	case atype_sequence_nestable:
+	case atype_enum_nestable:
 	default:
 		return -EINVAL;
 	}
 	return 0;
 }
 
+static
+int serialize_dynamic_type(struct lttng_session *session,
+		struct ustctl_field *fields, size_t *iter_output,
+		const char *field_name)
+{
+	const struct lttng_event_field *choices;
+	char tag_field_name[LTTNG_UST_SYM_NAME_LEN];
+	const struct lttng_type *tag_type;
+	const struct lttng_event_field *tag_field_generic;
+	struct lttng_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_SYM_NAME_LEN);
+	tag_field_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+	strncat(tag_field_name,
+		"_tag",
+		LTTNG_UST_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_SYM_NAME_LEN);
+	uf->name[LTTNG_UST_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_SYM_NAME_LEN);
+	uf->type.u.variant_nestable.tag_name[LTTNG_UST_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;
+	}
+	return 0;
+}
+
 static
 int serialize_one_type(struct lttng_session *session,
-		struct ustctl_type *ut, const struct lttng_type *lt)
+		struct ustctl_field *fields, size_t *iter_output,
+		const char *field_name, const struct lttng_type *lt)
 {
 	int ret;
 
+	/*
+	 * Serializing a type (rather than a field) generates a ustctl_field
+	 * entry with 0-length name.
+	 */
+
 	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);
+	{
+		struct ustctl_field *uf = &fields[*iter_output];
+		struct ustctl_type *ut = &uf->type;
+		enum ustctl_abstract_types atype;
+
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+		} else {
+			uf->name[0] = '\0';
+		}
+		ret = serialize_basic_type(session, &atype, lt->atype,
+			&ut->u.legacy.basic, &lt->u.legacy.basic);
 		if (ret)
 			return ret;
+		ut->atype = atype;
+		(*iter_output)++;
 		break;
+	}
 	case atype_array:
 	{
+		struct ustctl_field *uf = &fields[*iter_output];
+		struct ustctl_type *ut = &uf->type;
 		struct ustctl_basic_type *ubt;
 		const struct lttng_basic_type *lbt;
-		int ret;
+		enum ustctl_abstract_types atype;
 
-		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,
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+		} else {
+			uf->name[0] = '\0';
+		}
+		ut->atype = ustctl_atype_array;
+		ubt = &ut->u.legacy.array.elem_type;
+		lbt = &lt->u.legacy.array.elem_type;
+		ut->u.legacy.array.length = lt->u.legacy.array.length;
+		ret = serialize_basic_type(session, &atype, lbt->atype,
 			&ubt->u.basic, &lbt->u.basic);
 		if (ret)
 			return -EINVAL;
-		ut->atype = ustctl_atype_array;
+		ubt->atype = atype;
+		(*iter_output)++;
+		break;
+	}
+	case atype_array_nestable:
+	{
+		struct ustctl_field *uf = &fields[*iter_output];
+		struct ustctl_type *ut = &uf->type;
+
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+		} else {
+			uf->name[0] = '\0';
+		}
+		ut->atype = ustctl_atype_array_nestable;
+		ut->u.array_nestable.length = lt->u.array_nestable.length;
+		ut->u.array_nestable.alignment = lt->u.array_nestable.alignment;
+		(*iter_output)++;
+
+		ret = serialize_one_type(session, fields, iter_output, NULL,
+				lt->u.array_nestable.elem_type);
+		if (ret)
+			return -EINVAL;
 		break;
 	}
 	case atype_sequence:
 	{
+		struct ustctl_field *uf = &fields[*iter_output];
+		struct ustctl_type *ut = &uf->type;
 		struct ustctl_basic_type *ubt;
 		const struct lttng_basic_type *lbt;
-		int ret;
+		enum ustctl_abstract_types atype;
 
-		ubt = &ut->u.sequence.length_type;
-		lbt = &lt->u.sequence.length_type;
-		ret = serialize_basic_type(session, &ubt->atype, lbt->atype,
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+		} else {
+			uf->name[0] = '\0';
+		}
+		uf->type.atype = ustctl_atype_sequence;
+		ubt = &ut->u.legacy.sequence.length_type;
+		lbt = &lt->u.legacy.sequence.length_type;
+		ret = serialize_basic_type(session, &atype, lbt->atype,
 			&ubt->u.basic, &lbt->u.basic);
 		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->atype = atype;
+		ubt = &ut->u.legacy.sequence.elem_type;
+		lbt = &lt->u.legacy.sequence.elem_type;
+		ret = serialize_basic_type(session, &atype, lbt->atype,
 			&ubt->u.basic, &lbt->u.basic);
 		if (ret)
 			return -EINVAL;
-		ut->atype = ustctl_atype_sequence;
+		ubt->atype = atype;
+		(*iter_output)++;
+		break;
+	}
+	case atype_sequence_nestable:
+	{
+		struct ustctl_field *uf = &fields[*iter_output];
+		struct ustctl_type *ut = &uf->type;
+
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+		} else {
+			uf->name[0] = '\0';
+		}
+		ut->atype = ustctl_atype_sequence_nestable;
+		strncpy(ut->u.sequence_nestable.length_name,
+			lt->u.sequence_nestable.length_name,
+			LTTNG_UST_SYM_NAME_LEN);
+		ut->u.sequence_nestable.length_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+		ut->u.sequence_nestable.alignment = lt->u.sequence_nestable.alignment;
+		(*iter_output)++;
+
+		ret = serialize_one_type(session, fields, iter_output, NULL,
+				lt->u.sequence_nestable.elem_type);
+		if (ret)
+			return -EINVAL;
+		break;
+	}
+	case atype_dynamic:
+	{
+		ret = serialize_dynamic_type(session, fields, iter_output,
+				field_name);
+		if (ret)
+			return -EINVAL;
+		break;
+	}
+	case atype_struct:
+	{
+		struct ustctl_field *uf = &fields[*iter_output];
+
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+		} else {
+			uf->name[0] = '\0';
+		}
+		uf->type.atype = ustctl_atype_struct;
+		uf->type.u.legacy._struct.nr_fields = lt->u.legacy._struct.nr_fields;
+		(*iter_output)++;
+
+		ret = serialize_fields(session, fields, iter_output,
+				lt->u.legacy._struct.nr_fields,
+				lt->u.legacy._struct.fields);
+		if (ret)
+			return -EINVAL;
+		break;
+	}
+	case atype_struct_nestable:
+	{
+		struct ustctl_field *uf = &fields[*iter_output];
+
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+		} else {
+			uf->name[0] = '\0';
+		}
+		uf->type.atype = ustctl_atype_struct_nestable;
+		uf->type.u.struct_nestable.nr_fields = lt->u.struct_nestable.nr_fields;
+		uf->type.u.struct_nestable.alignment = lt->u.struct_nestable.alignment;
+		(*iter_output)++;
+
+		ret = serialize_fields(session, fields, iter_output,
+				lt->u.struct_nestable.nr_fields,
+				lt->u.struct_nestable.fields);
+		if (ret)
+			return -EINVAL;
+		break;
+	}
+	case atype_enum_nestable:
+	{
+		struct ustctl_field *uf = &fields[*iter_output];
+		struct ustctl_type *ut = &uf->type;
+
+		if (field_name) {
+			strncpy(uf->name, field_name, LTTNG_UST_SYM_NAME_LEN);
+			uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+		} else {
+			uf->name[0] = '\0';
+		}
+		strncpy(ut->u.enum_nestable.name, lt->u.enum_nestable.desc->name,
+				LTTNG_UST_SYM_NAME_LEN);
+		ut->u.enum_nestable.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+		ut->atype = ustctl_atype_enum_nestable;
+		(*iter_output)++;
+
+		ret = serialize_one_type(session, fields, iter_output, NULL,
+				lt->u.enum_nestable.container_type);
+		if (ret)
+			return -EINVAL;
+		if (session) {
+			const struct lttng_enum *_enum;
+
+			_enum = lttng_ust_enum_get_from_desc(session, lt->u.enum_nestable.desc);
+			if (!_enum)
+				return -EINVAL;
+			ut->u.enum_nestable.id = _enum->id;
+		} else {
+			ut->u.enum_nestable.id = -1ULL;
+		}
 		break;
 	}
 	default:
@@ -836,38 +1365,61 @@ int serialize_one_type(struct lttng_session *session,
 	return 0;
 }
 
+static
+int serialize_one_field(struct lttng_session *session,
+		struct ustctl_field *fields, size_t *iter_output,
+		const struct lttng_event_field *lf)
+{
+	/* skip 'nowrite' fields */
+	if (lf->nowrite)
+		return 0;
+
+	return serialize_one_type(session, fields, iter_output, lf->name, &lf->type);
+}
+
 static
 int serialize_fields(struct lttng_session *session,
+		struct ustctl_field *ustctl_fields,
+		size_t *iter_output, size_t nr_lttng_fields,
+		const struct lttng_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_session *session,
 		size_t *_nr_write_fields,
 		struct ustctl_field **ustctl_fields,
 		size_t nr_fields,
 		const struct lttng_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;
 
-	fields = zmalloc(nr_fields * sizeof(*fields));
+	nr_write_fields = count_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];
-
-		/* 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;
@@ -897,45 +1449,49 @@ int serialize_entries(struct ustctl_enum_entry **_entries,
 		uentry = &entries[i];
 		lentry = &lttng_entries[i];
 
-		uentry->start = lentry->start;
-		uentry->end = lentry->end;
+		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_SYM_NAME_LEN);
 		uentry->string[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+
+		if (lentry->u.extra.options & LTTNG_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_session *session,
+		size_t *_nr_write_fields,
 		struct ustctl_field **ustctl_fields,
 		size_t nr_fields,
 		const struct lttng_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;
+
+	nr_write_fields = count_ctx_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].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;
@@ -988,7 +1544,7 @@ int ustcomm_register_event(int sock,
 
 	/* 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 +1572,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 +1591,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 +1637,9 @@ int ustcomm_register_event(int sock,
 			return len;
 		}
 	}
+	/* Unreached. */
 
+	/* Error path only. */
 error_fields:
 	free(fields);
 	return ret;
@@ -1200,6 +1754,7 @@ error_entries:
  * Returns -EPIPE or -ECONNRESET if other end has hung up.
  */
 int ustcomm_register_channel(int sock,
+	struct lttng_session *session,
 	int session_objd,		/* session descriptor */
 	int channel_objd,		/* channel descriptor */
 	size_t nr_ctx_fields,
@@ -1228,7 +1783,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;