X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=liblttng-ust-comm%2Flttng-ust-comm.c;h=f9398e0d9891311ef2cdb3837905a4a67944c9ca;hb=cf22367fec17f2b2650e637de84fc2f614e4d2ac;hp=4e9de57bd0d48e20840b1c168a4e76309f94ad45;hpb=735ea6a81120f85d94666245f24aac233519568e;p=lttng-ust.git

diff --git a/liblttng-ust-comm/lttng-ust-comm.c b/liblttng-ust-comm/lttng-ust-comm.c
index 4e9de57b..f9398e0d 100644
--- a/liblttng-ust-comm/lttng-ust-comm.c
+++ b/liblttng-ust-comm/lttng-ust-comm.c
@@ -19,6 +19,7 @@
 
 #define _GNU_SOURCE
 #include <limits.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -33,6 +34,7 @@
 
 #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>
@@ -53,6 +55,11 @@ 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.
@@ -94,8 +101,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;
@@ -103,6 +112,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) {
@@ -110,6 +120,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");
@@ -248,16 +267,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;
 }
@@ -420,8 +445,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.
@@ -435,6 +458,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));
 
@@ -490,8 +514,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;
 }
@@ -580,7 +615,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;
@@ -597,8 +632,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;
@@ -607,7 +644,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;
 
@@ -627,8 +678,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;
@@ -637,8 +690,36 @@ 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:
@@ -697,8 +778,18 @@ ssize_t count_one_type(const struct lttng_type *lt)
 	case atype_sequence:
 		return 1;
 	case atype_struct:
-		//TODO: implement non-empty struct.
-		return 1;
+		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;
@@ -710,11 +801,12 @@ ssize_t count_one_type(const struct lttng_type *lt)
 		if (ret)
 			return ret;
 		/*
-		 * One field for enum, one field for variant, and
+		 * Two fields for enum, one field for variant, and
 		 * one field per choice.
 		 */
-		return count_fields_recursive(nr_choices, choices) + 2;
+		return count_fields_recursive(nr_choices, choices) + 3;
 	}
+
 	default:
 		return -EINVAL;
 	}
@@ -789,12 +881,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;
 }
@@ -816,9 +911,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;
 	}
@@ -847,8 +944,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;
@@ -859,7 +955,10 @@ 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;
 	}
@@ -869,7 +968,7 @@ int serialize_basic_type(struct lttng_session *session,
 static
 int serialize_dynamic_type(struct lttng_session *session,
 		struct ustctl_field *fields, size_t *iter_output,
-		const struct lttng_event_field *lf)
+		const char *field_name)
 {
 	const struct lttng_event_field *choices;
 	char tag_field_name[LTTNG_UST_SYM_NAME_LEN];
@@ -887,7 +986,7 @@ int serialize_dynamic_type(struct lttng_session *session,
 	tag_type = &tag_field_generic->type;
 
 	/* Serialize enum field. */
-	strncpy(tag_field_name, lf->name, LTTNG_UST_SYM_NAME_LEN);
+	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",
@@ -904,14 +1003,15 @@ int serialize_dynamic_type(struct lttng_session *session,
 	if (ret)
 		return ret;
 
-	strncpy(uf->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
+	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.nr_choices = nr_choices;
-	strncpy(uf->type.u.variant.tag_name,
+	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.tag_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+	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. */
@@ -925,16 +1025,16 @@ int serialize_dynamic_type(struct lttng_session *session,
 }
 
 static
-int serialize_one_field(struct lttng_session *session,
+int serialize_one_type(struct lttng_session *session,
 		struct ustctl_field *fields, size_t *iter_output,
-		const struct lttng_event_field *lf)
+		const char *field_name, const struct lttng_type *lt)
 {
-	const struct lttng_type *lt = &lf->type;
 	int ret;
 
-	/* skip 'nowrite' fields */
-	if (lf->nowrite)
-		return 0;
+	/*
+	 * Serializing a type (rather than a field) generates a ustctl_field
+	 * entry with 0-length name.
+	 */
 
 	switch (lt->atype) {
 	case atype_integer:
@@ -944,13 +1044,19 @@ int serialize_one_field(struct lttng_session *session,
 	{
 		struct ustctl_field *uf = &fields[*iter_output];
 		struct ustctl_type *ut = &uf->type;
+		enum ustctl_abstract_types atype;
 
-		strncpy(uf->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
-		uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
-		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_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;
 	}
@@ -960,19 +1066,46 @@ int serialize_one_field(struct lttng_session *session,
 		struct ustctl_type *ut = &uf->type;
 		struct ustctl_basic_type *ubt;
 		const struct lttng_basic_type *lbt;
+		enum ustctl_abstract_types atype;
 
-		strncpy(uf->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
-		uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
-		uf->type.atype = ustctl_atype_array;
-		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:
@@ -981,30 +1114,61 @@ int serialize_one_field(struct lttng_session *session,
 		struct ustctl_type *ut = &uf->type;
 		struct ustctl_basic_type *ubt;
 		const struct lttng_basic_type *lbt;
-		int ret;
+		enum ustctl_abstract_types atype;
 
-		strncpy(uf->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
-		uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
+		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.sequence.length_type;
-		lbt = &lt->u.sequence.length_type;
-		ret = serialize_basic_type(session, &ubt->atype, lbt->atype,
+		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, lf);
+		ret = serialize_dynamic_type(session, fields, iter_output,
+				field_name);
 		if (ret)
 			return -EINVAL;
 		break;
@@ -1013,17 +1177,76 @@ int serialize_one_field(struct lttng_session *session,
 	{
 		struct ustctl_field *uf = &fields[*iter_output];
 
-		/*
-		 * TODO: add support for non-empty struct.
-		 */
-		if (lf->type.u._struct.nr_fields != 0) {
-			return -EINVAL;
+		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(uf->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
-		uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
 		uf->type.atype = ustctl_atype_struct;
-		uf->type.u._struct.nr_fields = 0;
+		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:
@@ -1032,8 +1255,38 @@ int serialize_one_field(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,
@@ -1041,7 +1294,7 @@ int serialize_fields(struct lttng_session *session,
 {
 	struct ustctl_field *fields;
 	int ret;
-	size_t i, iter_output = 0;
+	size_t iter_output = 0;
 	ssize_t nr_write_fields;
 
 	nr_write_fields = count_fields_recursive(nr_fields, lttng_fields);
@@ -1053,12 +1306,10 @@ int serialize_fields(struct lttng_session *session,
 	if (!fields)
 		return -ENOMEM;
 
-	for (i = 0; i < nr_fields; i++) {
-		ret = serialize_one_field(session, fields, &iter_output,
-				&lttng_fields[i]);
-		if (ret)
-			goto error_type;
-	}
+	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;
@@ -1094,6 +1345,11 @@ int serialize_entries(struct ustctl_enum_entry **_entries,
 		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;
@@ -1178,7 +1434,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;