X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=liblttng-ust-comm%2Flttng-ust-comm.c;h=9fe6d288d633a2ec67c8d78a82cf90d2e52dc2c2;hb=6548fca464f68be5ded73be6b9a479daf08e62d6;hp=1a4419f52a98fbf5e51480b2810826bad9744166;hpb=6b95617c2ec5759621a64ebf4d44c837cccd100c;p=lttng-ust.git

diff --git a/liblttng-ust-comm/lttng-ust-comm.c b/liblttng-ust-comm/lttng-ust-comm.c
index 1a4419f5..9fe6d288 100644
--- a/liblttng-ust-comm/lttng-ust-comm.c
+++ b/liblttng-ust-comm/lttng-ust-comm.c
@@ -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,14 @@
 
 #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);
+
 /*
  * Human readable error message.
  */
@@ -85,8 +95,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;
@@ -101,6 +113,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 +260,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;
 }
@@ -588,8 +615,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;
@@ -599,6 +628,8 @@ ssize_t ustcomm_recv_channel_from_sessiond(int sock,
 		}
 	}
 	*_wakeup_fd = wakeup_fd;
+	lttng_ust_add_fd_to_tracker(wakeup_fd);
+	lttng_ust_unlock_fd_tracker();
 	*_chan_data = chan_data;
 	return len;
 
@@ -618,8 +649,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;
@@ -630,6 +663,9 @@ int ustcomm_recv_stream_from_sessiond(int sock,
 	}
 	*shm_fd = fds[0];
 	*wakeup_fd = fds[1];
+	lttng_ust_add_fd_to_tracker(fds[0]);
+	lttng_ust_add_fd_to_tracker(fds[1]);
+	lttng_ust_unlock_fd_tracker();
 	return 0;
 
 error:
@@ -677,7 +713,87 @@ 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:
+		//TODO: implement non-empty struct.
+		return 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;
+		/*
+		 * One field for enum, one field for variant, and
+		 * one field per choice.
+		 */
+		return count_fields_recursive(nr_choices, choices) + 2;
+	}
+	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) {
@@ -778,27 +894,103 @@ int serialize_basic_type(struct lttng_session *session,
 }
 
 static
-int serialize_one_type(struct lttng_session *session,
-		struct ustctl_type *ut, const struct lttng_type *lt)
+int serialize_dynamic_type(struct lttng_session *session,
+		struct ustctl_field *fields, size_t *iter_output,
+		const struct lttng_event_field *lf)
 {
+	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, lf->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, lf->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,
+		tag_field_name,
+		LTTNG_UST_SYM_NAME_LEN);
+	uf->type.u.variant.tag_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\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_field(struct lttng_session *session,
+		struct ustctl_field *fields, size_t *iter_output,
+		const struct lttng_event_field *lf)
+{
+	const struct lttng_type *lt = &lf->type;
+	int ret;
+
+	/* skip 'nowrite' fields */
+	if (lf->nowrite)
+		return 0;
+
 	switch (lt->atype) {
 	case atype_integer:
 	case atype_float:
 	case atype_string:
 	case atype_enum:
+	{
+		struct ustctl_field *uf = &fields[*iter_output];
+		struct ustctl_type *ut = &uf->type;
+
+		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 (ret)
 			return ret;
+		(*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;
 
+		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;
@@ -807,14 +999,20 @@ int serialize_one_type(struct lttng_session *session,
 		if (ret)
 			return -EINVAL;
 		ut->atype = ustctl_atype_array;
+		(*iter_output)++;
 		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;
 
+		strncpy(uf->name, lf->name, LTTNG_UST_SYM_NAME_LEN);
+		uf->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\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,
@@ -828,6 +1026,31 @@ int serialize_one_type(struct lttng_session *session,
 		if (ret)
 			return -EINVAL;
 		ut->atype = ustctl_atype_sequence;
+		(*iter_output)++;
+		break;
+	}
+	case atype_dynamic:
+	{
+		ret = serialize_dynamic_type(session, fields, iter_output, lf);
+		if (ret)
+			return -EINVAL;
+		break;
+	}
+	case atype_struct:
+	{
+		struct ustctl_field *uf = &fields[*iter_output];
+
+		/*
+		 * TODO: add support for non-empty struct.
+		 */
+		if (lf->type.u._struct.nr_fields != 0) {
+			return -EINVAL;
+		}
+		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;
+		(*iter_output)++;
 		break;
 	}
 	default:
@@ -844,29 +1067,24 @@ int serialize_fields(struct lttng_session *session,
 		const struct lttng_event_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_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);
+		ret = serialize_one_field(session, fields, &iter_output,
+				&lttng_fields[i]);
 		if (ret)
 			goto error_type;
-		nr_write_fields++;
 	}
 
 	*_nr_write_fields = nr_write_fields;
@@ -897,45 +1115,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;
@@ -1198,6 +1420,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,
@@ -1226,7 +1449,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;