X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fir%2Fevent-fields.c;h=f524d5dbb8ce2fef86b935a5d4e69226e4c1999d;hb=70996764ff14d6f6d0710a8a45e23a907a0900f9;hp=ac77cfb7bf3648f9ca8282b67b96d4eeb52c448f;hpb=de9dd3975ba39e915d7e046877af9059990c595e;p=babeltrace.git

diff --git a/formats/ctf/ir/event-fields.c b/formats/ctf/ir/event-fields.c
index ac77cfb7..f524d5db 100644
--- a/formats/ctf/ir/event-fields.c
+++ b/formats/ctf/ir/event-fields.c
@@ -1,7 +1,7 @@
 /*
  * event-fields.c
  *
- * Babeltrace CTF Writer
+ * Babeltrace CTF IR - Event Fields
  *
  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
  *
@@ -76,17 +76,32 @@ static
 void bt_ctf_field_string_destroy(struct bt_ctf_field *);
 
 static
-int bt_ctf_field_generic_validate(struct bt_ctf_field *field);
+int bt_ctf_field_generic_validate(struct bt_ctf_field *);
 static
-int bt_ctf_field_structure_validate(struct bt_ctf_field *field);
+int bt_ctf_field_structure_validate(struct bt_ctf_field *);
 static
-int bt_ctf_field_variant_validate(struct bt_ctf_field *field);
+int bt_ctf_field_variant_validate(struct bt_ctf_field *);
 static
-int bt_ctf_field_enumeration_validate(struct bt_ctf_field *field);
+int bt_ctf_field_enumeration_validate(struct bt_ctf_field *);
 static
-int bt_ctf_field_array_validate(struct bt_ctf_field *field);
+int bt_ctf_field_array_validate(struct bt_ctf_field *);
 static
-int bt_ctf_field_sequence_validate(struct bt_ctf_field *field);
+int bt_ctf_field_sequence_validate(struct bt_ctf_field *);
+
+static
+int bt_ctf_field_generic_reset(struct bt_ctf_field *);
+static
+int bt_ctf_field_structure_reset(struct bt_ctf_field *);
+static
+int bt_ctf_field_variant_reset(struct bt_ctf_field *);
+static
+int bt_ctf_field_enumeration_reset(struct bt_ctf_field *);
+static
+int bt_ctf_field_array_reset(struct bt_ctf_field *);
+static
+int bt_ctf_field_sequence_reset(struct bt_ctf_field *);
+static
+int bt_ctf_field_string_reset(struct bt_ctf_field *);
 
 static
 int bt_ctf_field_integer_serialize(struct bt_ctf_field *,
@@ -113,11 +128,29 @@ static
 int bt_ctf_field_string_serialize(struct bt_ctf_field *,
 		struct ctf_stream_pos *);
 
+static
+int bt_ctf_field_integer_copy(struct bt_ctf_field *, struct bt_ctf_field *);
+static
+int bt_ctf_field_enumeration_copy(struct bt_ctf_field *, struct bt_ctf_field *);
+static
+int bt_ctf_field_floating_point_copy(struct bt_ctf_field *,
+		struct bt_ctf_field *);
+static
+int bt_ctf_field_structure_copy(struct bt_ctf_field *, struct bt_ctf_field *);
+static
+int bt_ctf_field_variant_copy(struct bt_ctf_field *, struct bt_ctf_field *);
+static
+int bt_ctf_field_array_copy(struct bt_ctf_field *, struct bt_ctf_field *);
+static
+int bt_ctf_field_sequence_copy(struct bt_ctf_field *, struct bt_ctf_field *);
+static
+int bt_ctf_field_string_copy(struct bt_ctf_field *, struct bt_ctf_field *);
+
 static
 int increase_packet_size(struct ctf_stream_pos *pos);
 
 static
-struct bt_ctf_field *(*field_create_funcs[])(
+struct bt_ctf_field *(* const field_create_funcs[])(
 		struct bt_ctf_field_type *) = {
 	[CTF_TYPE_INTEGER] = bt_ctf_field_integer_create,
 	[CTF_TYPE_ENUM] = bt_ctf_field_enumeration_create,
@@ -131,7 +164,7 @@ struct bt_ctf_field *(*field_create_funcs[])(
 };
 
 static
-void (*field_destroy_funcs[])(struct bt_ctf_field *) = {
+void (* const field_destroy_funcs[])(struct bt_ctf_field *) = {
 	[CTF_TYPE_INTEGER] = bt_ctf_field_integer_destroy,
 	[CTF_TYPE_ENUM] = bt_ctf_field_enumeration_destroy,
 	[CTF_TYPE_FLOAT] =
@@ -144,7 +177,7 @@ void (*field_destroy_funcs[])(struct bt_ctf_field *) = {
 };
 
 static
-int (*field_validate_funcs[])(struct bt_ctf_field *) = {
+int (* const field_validate_funcs[])(struct bt_ctf_field *) = {
 	[CTF_TYPE_INTEGER] = bt_ctf_field_generic_validate,
 	[CTF_TYPE_ENUM] = bt_ctf_field_enumeration_validate,
 	[CTF_TYPE_FLOAT] = bt_ctf_field_generic_validate,
@@ -156,7 +189,19 @@ int (*field_validate_funcs[])(struct bt_ctf_field *) = {
 };
 
 static
-int (*field_serialize_funcs[])(struct bt_ctf_field *,
+int (* const field_reset_funcs[])(struct bt_ctf_field *) = {
+	[CTF_TYPE_INTEGER] = bt_ctf_field_generic_reset,
+	[CTF_TYPE_ENUM] = bt_ctf_field_enumeration_reset,
+	[CTF_TYPE_FLOAT] = bt_ctf_field_generic_reset,
+	[CTF_TYPE_STRUCT] = bt_ctf_field_structure_reset,
+	[CTF_TYPE_VARIANT] = bt_ctf_field_variant_reset,
+	[CTF_TYPE_ARRAY] = bt_ctf_field_array_reset,
+	[CTF_TYPE_SEQUENCE] = bt_ctf_field_sequence_reset,
+	[CTF_TYPE_STRING] = bt_ctf_field_string_reset,
+};
+
+static
+int (* const field_serialize_funcs[])(struct bt_ctf_field *,
 		struct ctf_stream_pos *) = {
 	[CTF_TYPE_INTEGER] = bt_ctf_field_integer_serialize,
 	[CTF_TYPE_ENUM] = bt_ctf_field_enumeration_serialize,
@@ -169,6 +214,19 @@ int (*field_serialize_funcs[])(struct bt_ctf_field *,
 	[CTF_TYPE_STRING] = bt_ctf_field_string_serialize,
 };
 
+static
+int (* const field_copy_funcs[])(struct bt_ctf_field *,
+		struct bt_ctf_field *) = {
+	[CTF_TYPE_INTEGER] = bt_ctf_field_integer_copy,
+	[CTF_TYPE_ENUM] = bt_ctf_field_enumeration_copy,
+	[CTF_TYPE_FLOAT] = bt_ctf_field_floating_point_copy,
+	[CTF_TYPE_STRUCT] = bt_ctf_field_structure_copy,
+	[CTF_TYPE_VARIANT] = bt_ctf_field_variant_copy,
+	[CTF_TYPE_ARRAY] = bt_ctf_field_array_copy,
+	[CTF_TYPE_SEQUENCE] = bt_ctf_field_sequence_copy,
+	[CTF_TYPE_STRING] = bt_ctf_field_string_copy,
+};
+
 struct bt_ctf_field *bt_ctf_field_create(struct bt_ctf_field_type *type)
 {
 	struct bt_ctf_field *field = NULL;
@@ -305,8 +363,7 @@ struct bt_ctf_field *bt_ctf_field_structure_get_field(
 	struct bt_ctf_field *new_field = NULL;
 	GQuark field_quark;
 	struct bt_ctf_field_structure *structure;
-	struct bt_ctf_field_type_structure *structure_type;
-	struct bt_ctf_field_type *field_type;
+	struct bt_ctf_field_type *field_type = NULL;
 	size_t index;
 
 	if (!field || !name ||
@@ -317,9 +374,9 @@ struct bt_ctf_field *bt_ctf_field_structure_get_field(
 
 	field_quark = g_quark_from_string(name);
 	structure = container_of(field, struct bt_ctf_field_structure, parent);
-	structure_type = container_of(field->type,
-		struct bt_ctf_field_type_structure, parent);
-	field_type = bt_ctf_field_type_structure_get_type(structure_type, name);
+	field_type =
+		bt_ctf_field_type_structure_get_field_type_by_name(field->type,
+		name);
 	if (!g_hash_table_lookup_extended(structure->field_name_to_index,
 		GUINT_TO_POINTER(field_quark), NULL, (gpointer *)&index)) {
 		goto error;
@@ -339,11 +396,14 @@ struct bt_ctf_field *bt_ctf_field_structure_get_field(
 end:
 	bt_ctf_field_get(new_field);
 error:
+	if (field_type) {
+		bt_ctf_field_type_put(field_type);
+	}
 	return new_field;
 }
 
 struct bt_ctf_field *bt_ctf_field_structure_get_field_by_index(
-		struct bt_ctf_field *field, size_t index)
+		struct bt_ctf_field *field, int index)
 {
 	int ret;
 	const char *field_name;
@@ -402,8 +462,7 @@ int bt_ctf_field_structure_set_field(struct bt_ctf_field *field,
 	int ret = 0;
 	GQuark field_quark;
 	struct bt_ctf_field_structure *structure;
-	struct bt_ctf_field_type_structure *structure_type;
-	struct bt_ctf_field_type *expected_field_type;
+	struct bt_ctf_field_type *expected_field_type = NULL;
 	size_t index;
 
 	if (!field || !name || !value ||
@@ -415,10 +474,9 @@ int bt_ctf_field_structure_set_field(struct bt_ctf_field *field,
 
 	field_quark = g_quark_from_string(name);
 	structure = container_of(field, struct bt_ctf_field_structure, parent);
-	structure_type = container_of(field->type,
-		struct bt_ctf_field_type_structure, parent);
-	expected_field_type = bt_ctf_field_type_structure_get_type(
-		structure_type, name);
+	expected_field_type =
+		bt_ctf_field_type_structure_get_field_type_by_name(field->type,
+		name);
 	if (expected_field_type != value->type) {
 		ret = -1;
 		goto end;
@@ -436,6 +494,9 @@ int bt_ctf_field_structure_set_field(struct bt_ctf_field *field,
 	structure->fields->pdata[index] = value;
 	bt_ctf_field_get(value);
 end:
+	if (expected_field_type) {
+		bt_ctf_field_type_put(expected_field_type);
+	}
 	return ret;
 }
 
@@ -443,9 +504,8 @@ struct bt_ctf_field *bt_ctf_field_array_get_field(struct bt_ctf_field *field,
 		uint64_t index)
 {
 	struct bt_ctf_field *new_field = NULL;
+	struct bt_ctf_field_type *field_type = NULL;
 	struct bt_ctf_field_array *array;
-	struct bt_ctf_field_type_array *array_type;
-	struct bt_ctf_field_type *field_type;
 
 	if (!field || bt_ctf_field_type_get_type_id(field->type) !=
 		CTF_TYPE_ARRAY) {
@@ -457,9 +517,7 @@ struct bt_ctf_field *bt_ctf_field_array_get_field(struct bt_ctf_field *field,
 		goto end;
 	}
 
-	array_type = container_of(field->type, struct bt_ctf_field_type_array,
-		parent);
-	field_type = bt_ctf_field_type_array_get_element_type(array_type);
+	field_type = bt_ctf_field_type_array_get_element_type(field->type);
 	if (array->elements->pdata[(size_t)index]) {
 		new_field = array->elements->pdata[(size_t)index];
 		goto end;
@@ -469,6 +527,9 @@ struct bt_ctf_field *bt_ctf_field_array_get_field(struct bt_ctf_field *field,
 	bt_ctf_field_get(new_field);
 	array->elements->pdata[(size_t)index] = new_field;
 end:
+	if (field_type) {
+		bt_ctf_field_type_put(field_type);
+	}
 	return new_field;
 }
 
@@ -476,9 +537,8 @@ struct bt_ctf_field *bt_ctf_field_sequence_get_field(struct bt_ctf_field *field,
 		uint64_t index)
 {
 	struct bt_ctf_field *new_field = NULL;
+	struct bt_ctf_field_type *field_type = NULL;
 	struct bt_ctf_field_sequence *sequence;
-	struct bt_ctf_field_type_sequence *sequence_type;
-	struct bt_ctf_field_type *field_type;
 
 	if (!field || bt_ctf_field_type_get_type_id(field->type) !=
 		CTF_TYPE_SEQUENCE) {
@@ -490,9 +550,7 @@ struct bt_ctf_field *bt_ctf_field_sequence_get_field(struct bt_ctf_field *field,
 		goto end;
 	}
 
-	sequence_type = container_of(field->type,
-		struct bt_ctf_field_type_sequence, parent);
-	field_type = bt_ctf_field_type_sequence_get_element_type(sequence_type);
+	field_type = bt_ctf_field_type_sequence_get_element_type(field->type);
 	if (sequence->elements->pdata[(size_t)index]) {
 		new_field = sequence->elements->pdata[(size_t)index];
 		goto end;
@@ -502,6 +560,9 @@ struct bt_ctf_field *bt_ctf_field_sequence_get_field(struct bt_ctf_field *field,
 	bt_ctf_field_get(new_field);
 	sequence->elements->pdata[(size_t)index] = new_field;
 end:
+	if (field_type) {
+		bt_ctf_field_type_put(field_type);
+	}
 	return new_field;
 }
 
@@ -535,13 +596,13 @@ struct bt_ctf_field *bt_ctf_field_variant_get_field(struct bt_ctf_field *field,
 	tag_enum_integer = container_of(tag_enum, struct bt_ctf_field_integer,
 		parent);
 
-	if (!bt_ctf_field_validate(variant->tag)) {
+	if (bt_ctf_field_validate(tag_field) < 0) {
 		goto end;
 	}
 
 	tag_enum_value = tag_enum_integer->definition.value._signed;
-	field_type = bt_ctf_field_type_variant_get_field_type(variant_type,
-		tag_enum_value);
+	field_type = bt_ctf_field_type_variant_get_field_type_signed(
+		variant_type, tag_enum_value);
 	if (!field_type) {
 		goto end;
 	}
@@ -568,7 +629,8 @@ struct bt_ctf_field *bt_ctf_field_enumeration_get_container(
 	struct bt_ctf_field *container = NULL;
 	struct bt_ctf_field_enumeration *enumeration;
 
-	if (!field) {
+	if (!field || bt_ctf_field_type_get_type_id(field->type) !=
+		CTF_TYPE_ENUM) {
 		goto end;
 	}
 
@@ -847,15 +909,82 @@ int bt_ctf_field_string_set_value(struct bt_ctf_field *field,
 
 	string = container_of(field, struct bt_ctf_field_string, parent);
 	if (string->payload) {
-		g_string_free(string->payload, TRUE);
+		g_string_assign(string->payload, value);
+	} else {
+		string->payload = g_string_new(value);
 	}
 
-	string->payload = g_string_new(value);
 	string->parent.payload_set = 1;
 end:
 	return ret;
 }
 
+int bt_ctf_field_string_append(struct bt_ctf_field *field,
+		const char *value)
+{
+	int ret = 0;
+	struct bt_ctf_field_string *string_field;
+
+	if (!field || !value ||
+		bt_ctf_field_type_get_type_id(field->type) !=
+			CTF_TYPE_STRING) {
+		ret = -1;
+		goto end;
+	}
+
+	string_field = container_of(field, struct bt_ctf_field_string, parent);
+
+	if (string_field->payload) {
+		g_string_append(string_field->payload, value);
+	} else {
+		string_field->payload = g_string_new(value);
+	}
+
+	string_field->parent.payload_set = 1;
+
+end:
+	return ret;
+}
+
+int bt_ctf_field_string_append_len(struct bt_ctf_field *field,
+		const char *value, unsigned int length)
+{
+	int i;
+	int ret = 0;
+	unsigned int effective_length = length;
+	struct bt_ctf_field_string *string_field;
+
+	if (!field || !value ||
+		bt_ctf_field_type_get_type_id(field->type) !=
+			CTF_TYPE_STRING) {
+		ret = -1;
+		goto end;
+	}
+
+	string_field = container_of(field, struct bt_ctf_field_string, parent);
+
+	/* make sure no null bytes are appended */
+	for (i = 0; i < length; ++i) {
+		if (value[i] == '\0') {
+			effective_length = i;
+			break;
+		}
+	}
+
+	if (string_field->payload) {
+		g_string_append_len(string_field->payload, value,
+			effective_length);
+	} else {
+		string_field->payload = g_string_new_len(value,
+			effective_length);
+	}
+
+	string_field->parent.payload_set = 1;
+
+end:
+	return ret;
+}
+
 BT_HIDDEN
 int bt_ctf_field_validate(struct bt_ctf_field *field)
 {
@@ -878,6 +1007,28 @@ end:
 	return ret;
 }
 
+BT_HIDDEN
+int bt_ctf_field_reset(struct bt_ctf_field *field)
+{
+	int ret = 0;
+	enum ctf_type_id type_id;
+
+	if (!field) {
+		ret = -1;
+		goto end;
+	}
+
+	type_id = bt_ctf_field_type_get_type_id(field->type);
+	if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
+		ret = -1;
+		goto end;
+	}
+
+	ret = field_reset_funcs[type_id](field);
+end:
+	return ret;
+}
+
 BT_HIDDEN
 int bt_ctf_field_serialize(struct bt_ctf_field *field,
 		struct ctf_stream_pos *pos)
@@ -901,6 +1052,37 @@ end:
 	return ret;
 }
 
+BT_HIDDEN
+struct bt_ctf_field *bt_ctf_field_copy(struct bt_ctf_field *field)
+{
+	int ret;
+	struct bt_ctf_field *copy = NULL;
+	enum ctf_type_id type_id;
+
+	if (!field) {
+		goto end;
+	}
+
+	type_id = bt_ctf_field_type_get_type_id(field->type);
+	if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
+		goto end;
+	}
+
+	copy = bt_ctf_field_create(field->type);
+	if (!copy) {
+		goto end;
+	}
+
+	copy->payload_set = field->payload_set;
+	ret = field_copy_funcs[type_id](field, copy);
+	if (ret) {
+		bt_ctf_field_put(copy);
+		copy = NULL;
+	}
+end:
+	return copy;
+}
+
 static
 struct bt_ctf_field *bt_ctf_field_integer_create(struct bt_ctf_field_type *type)
 {
@@ -1173,7 +1355,9 @@ void bt_ctf_field_string_destroy(struct bt_ctf_field *field)
 	}
 
 	string = container_of(field, struct bt_ctf_field_string, parent);
-	g_string_free(string->payload, TRUE);
+	if (string->payload) {
+		g_string_free(string->payload, TRUE);
+	}
 	g_free(string);
 }
 
@@ -1292,6 +1476,185 @@ end:
 	return ret;
 }
 
+static
+int bt_ctf_field_generic_reset(struct bt_ctf_field *field)
+{
+	int ret = 0;
+
+	if (!field) {
+		ret = -1;
+		goto end;
+	}
+
+	field->payload_set = 0;
+end:
+	return ret;
+}
+
+static
+int bt_ctf_field_enumeration_reset(struct bt_ctf_field *field)
+{
+	int ret = 0;
+	struct bt_ctf_field_enumeration *enumeration;
+
+	if (!field) {
+		ret = -1;
+		goto end;
+	}
+
+	enumeration = container_of(field, struct bt_ctf_field_enumeration,
+		parent);
+	if (!enumeration->payload) {
+		goto end;
+	}
+
+	ret = bt_ctf_field_reset(enumeration->payload);
+end:
+	return ret;
+}
+
+static
+int bt_ctf_field_structure_reset(struct bt_ctf_field *field)
+{
+	size_t i;
+	int ret = 0;
+	struct bt_ctf_field_structure *structure;
+
+	if (!field) {
+		ret = -1;
+		goto end;
+	}
+
+	structure = container_of(field, struct bt_ctf_field_structure, parent);
+	for (i = 0; i < structure->fields->len; i++) {
+		struct bt_ctf_field *member = structure->fields->pdata[i];
+
+		if (!member) {
+			/*
+			 * Structure members are lazily initialized; skip if
+			 * this member has not been allocated yet.
+			 */
+			continue;
+		}
+
+		ret = bt_ctf_field_reset(member);
+		if (ret) {
+			goto end;
+		}
+	}
+end:
+	return ret;
+}
+
+static
+int bt_ctf_field_variant_reset(struct bt_ctf_field *field)
+{
+	int ret = 0;
+	struct bt_ctf_field_variant *variant;
+
+	if (!field) {
+		ret = -1;
+		goto end;
+	}
+
+	variant = container_of(field, struct bt_ctf_field_variant, parent);
+	if (variant->payload) {
+		ret = bt_ctf_field_reset(variant->payload);
+	}
+end:
+	return ret;
+}
+
+static
+int bt_ctf_field_array_reset(struct bt_ctf_field *field)
+{
+	size_t i;
+	int ret = 0;
+	struct bt_ctf_field_array *array;
+
+	if (!field) {
+		ret = -1;
+		goto end;
+	}
+
+	array = container_of(field, struct bt_ctf_field_array, parent);
+	for (i = 0; i < array->elements->len; i++) {
+		struct bt_ctf_field *member = array->elements->pdata[i];
+
+		if (!member) {
+			/*
+			 * Array elements are lazily initialized; skip if
+			 * this member has not been allocated yet.
+			 */
+			continue;
+		}
+
+		ret = bt_ctf_field_reset(member);
+		if (ret) {
+			goto end;
+		}
+	}
+end:
+	return ret;
+}
+
+static
+int bt_ctf_field_sequence_reset(struct bt_ctf_field *field)
+{
+	size_t i;
+	int ret = 0;
+	struct bt_ctf_field_sequence *sequence;
+
+	if (!field) {
+		ret = -1;
+		goto end;
+	}
+
+	sequence = container_of(field, struct bt_ctf_field_sequence, parent);
+	for (i = 0; i < sequence->elements->len; i++) {
+		struct bt_ctf_field *member = sequence->elements->pdata[i];
+
+		if (!member) {
+			/*
+			 * Sequence elements are lazily initialized; skip if
+			 * this member has not been allocated yet.
+			 */
+			continue;
+		}
+
+		ret = bt_ctf_field_reset(member);
+		if (ret) {
+			goto end;
+		}
+	}
+end:
+	return ret;
+}
+
+static
+int bt_ctf_field_string_reset(struct bt_ctf_field *field)
+{
+	int ret = 0;
+	struct bt_ctf_field_string *string;
+
+	if (!field) {
+		ret = -1;
+		goto end;
+	}
+
+	ret = bt_ctf_field_generic_reset(field);
+	if (ret) {
+		goto end;
+	}
+
+	string = container_of(field, struct bt_ctf_field_string, parent);
+	if (string->payload) {
+		g_string_truncate(string->payload, 0);
+	}
+end:
+	return ret;
+}
+
 static
 int bt_ctf_field_integer_serialize(struct bt_ctf_field *field,
 		struct ctf_stream_pos *pos)
@@ -1468,6 +1831,191 @@ end:
 	return ret;
 }
 
+static
+int bt_ctf_field_integer_copy(struct bt_ctf_field *src,
+		struct bt_ctf_field *dst)
+{
+	struct bt_ctf_field_integer *integer_src, *integer_dst;
+
+	integer_src = container_of(src, struct bt_ctf_field_integer, parent);
+	integer_dst = container_of(dst, struct bt_ctf_field_integer, parent);
+
+	memcpy(&integer_dst->definition, &integer_src->definition,
+		sizeof(struct definition_integer));
+	return 0;
+}
+
+static
+int bt_ctf_field_enumeration_copy(struct bt_ctf_field *src,
+		struct bt_ctf_field *dst)
+{
+	int ret = 0;
+	struct bt_ctf_field_enumeration *enum_src, *enum_dst;
+
+	enum_src = container_of(src, struct bt_ctf_field_enumeration, parent);
+	enum_dst = container_of(dst, struct bt_ctf_field_enumeration, parent);
+
+	if (enum_src->payload) {
+		enum_dst->payload = bt_ctf_field_copy(enum_src->payload);
+		if (!enum_dst->payload) {
+			ret = -1;
+			goto end;
+		}
+	}
+end:
+	return ret;
+}
+
+static
+int bt_ctf_field_floating_point_copy(
+		struct bt_ctf_field *src, struct bt_ctf_field *dst)
+{
+	struct bt_ctf_field_floating_point *float_src, *float_dst;
+
+	float_src = container_of(src, struct bt_ctf_field_floating_point,
+		parent);
+	float_dst = container_of(dst, struct bt_ctf_field_floating_point,
+		parent);
+
+	memcpy(&float_dst->definition, &float_src->definition,
+		sizeof(struct definition_float));
+	memcpy(&float_dst->sign, &float_src->sign,
+		sizeof(struct definition_integer));
+	memcpy(&float_dst->mantissa, &float_src->mantissa,
+		sizeof(struct definition_integer));
+	memcpy(&float_dst->exp, &float_src->exp,
+		sizeof(struct definition_integer));
+	return 0;
+}
+
+static
+int bt_ctf_field_structure_copy(struct bt_ctf_field *src,
+		struct bt_ctf_field *dst)
+{
+	int ret = 0, i;
+	struct bt_ctf_field_structure *struct_src, *struct_dst;
+
+	struct_src = container_of(src, struct bt_ctf_field_structure, parent);
+	struct_dst = container_of(dst, struct bt_ctf_field_structure, parent);
+
+	/* This field_name_to_index HT is owned by the structure field type */
+	struct_dst->field_name_to_index = struct_src->field_name_to_index;
+	g_ptr_array_set_size(struct_dst->fields, struct_src->fields->len);
+
+	for (i = 0; i < struct_src->fields->len; i++) {
+		struct bt_ctf_field *field_copy = bt_ctf_field_copy(
+			g_ptr_array_index(struct_src->fields, i));
+
+		if (!field_copy) {
+			ret = -1;
+			goto end;
+		}
+		g_ptr_array_index(struct_dst->fields, i) = field_copy;
+	}
+end:
+	return ret;
+}
+
+static
+int bt_ctf_field_variant_copy(struct bt_ctf_field *src,
+		struct bt_ctf_field *dst)
+{
+	int ret = 0;
+	struct bt_ctf_field_variant *variant_src, *variant_dst;
+
+	variant_src = container_of(src, struct bt_ctf_field_variant, parent);
+	variant_dst = container_of(dst, struct bt_ctf_field_variant, parent);
+
+	if (variant_src->tag) {
+		variant_dst->tag = bt_ctf_field_copy(variant_src->tag);
+		if (!variant_dst->tag) {
+			ret = -1;
+			goto end;
+		}
+	}
+	if (variant_src->payload) {
+		variant_dst->payload = bt_ctf_field_copy(variant_src->payload);
+		if (!variant_dst->payload) {
+			ret = -1;
+			goto end;
+		}
+	}
+end:
+	return ret;
+}
+
+static
+int bt_ctf_field_array_copy(struct bt_ctf_field *src,
+		struct bt_ctf_field *dst)
+{
+	int ret = 0, i;
+	struct bt_ctf_field_array *array_src, *array_dst;
+
+	array_src = container_of(src, struct bt_ctf_field_array, parent);
+	array_dst = container_of(dst, struct bt_ctf_field_array, parent);
+
+	g_ptr_array_set_size(array_dst->elements, array_src->elements->len);
+	for (i = 0; i < array_src->elements->len; i++) {
+		struct bt_ctf_field *field_copy = bt_ctf_field_copy(
+			g_ptr_array_index(array_src->elements, i));
+
+		if (!field_copy) {
+			ret = -1;
+			goto end;
+		}
+		g_ptr_array_index(array_dst->elements, i) = field_copy;
+	}
+end:
+	return ret;
+}
+
+static
+int bt_ctf_field_sequence_copy(struct bt_ctf_field *src,
+		struct bt_ctf_field *dst)
+{
+	int ret = 0, i;
+	struct bt_ctf_field_sequence *sequence_src, *sequence_dst;
+
+	sequence_src = container_of(src, struct bt_ctf_field_sequence, parent);
+	sequence_dst = container_of(dst, struct bt_ctf_field_sequence, parent);
+
+	g_ptr_array_set_size(sequence_dst->elements,
+		sequence_src->elements->len);
+	for (i = 0; i < sequence_src->elements->len; i++) {
+		struct bt_ctf_field *field_copy = bt_ctf_field_copy(
+			g_ptr_array_index(sequence_src->elements, i));
+
+		if (!field_copy) {
+			ret = -1;
+			goto end;
+		}
+		g_ptr_array_index(sequence_dst->elements, i) = field_copy;
+	}
+end:
+	return ret;
+}
+
+static
+int bt_ctf_field_string_copy(struct bt_ctf_field *src,
+		struct bt_ctf_field *dst)
+{
+	int ret = 0;
+	struct bt_ctf_field_string *string_src, *string_dst;
+
+	string_src = container_of(src, struct bt_ctf_field_string, parent);
+	string_dst = container_of(dst, struct bt_ctf_field_string, parent);
+
+	if (string_src->payload) {
+		string_dst->payload = g_string_new(string_src->payload->str);
+		if (!string_dst->payload) {
+			ret = -1;
+			goto end;
+		}
+	}
+end:
+	return ret;
+}
+
 static
 int increase_packet_size(struct ctf_stream_pos *pos)
 {