X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fir%2Fstream.c;h=cc5548b548033345239bd1e4c0234e2c116f3460;hb=09840de5d022697671dafe2bed427fa5c09b40b9;hp=298749240dbefa052eb2b6bd5a104512db1ac6bd;hpb=de3dd40e6fcad56e227f5fc8a8290fbaa88b4e07;p=babeltrace.git

diff --git a/formats/ctf/ir/stream.c b/formats/ctf/ir/stream.c
index 29874924..cc5548b5 100644
--- a/formats/ctf/ir/stream.c
+++ b/formats/ctf/ir/stream.c
@@ -35,15 +35,14 @@
 #include <babeltrace/ctf-ir/stream.h>
 #include <babeltrace/ctf-ir/stream-internal.h>
 #include <babeltrace/ctf-ir/stream-class-internal.h>
-#include <babeltrace/ctf-ir/ref.h>
-#include <babeltrace/ctf-ir/common-internal.h>
+#include <babeltrace/ref.h>
 #include <babeltrace/ctf-writer/functor-internal.h>
 #include <babeltrace/compiler.h>
 #include <babeltrace/align.h>
 #include <babeltrace/ctf/ctf-index.h>
 
 static
-void bt_ctf_stream_destroy(struct bt_ref *ref);
+void bt_ctf_stream_destroy(struct bt_object *obj);
 static
 int set_structure_field_integer(struct bt_ctf_field *, char *, uint64_t);
 
@@ -92,12 +91,8 @@ int set_packet_header_magic(struct bt_ctf_stream *stream)
 			(uint64_t) 0xC1FC1FC1);
 	}
 end:
-	if (magic_field) {
-		bt_ctf_field_put(magic_field);
-	}
-	if (magic_field_type) {
-		bt_ctf_field_type_put(magic_field_type);
-	}
+	bt_put(magic_field);
+	bt_put(magic_field_type);
 	return ret;
 }
 
@@ -105,6 +100,7 @@ static
 int set_packet_header_uuid(struct bt_ctf_stream *stream)
 {
 	int i, ret = 0;
+	struct bt_ctf_trace *trace = NULL;
 	struct bt_ctf_field_type *uuid_field_type = NULL;
 	struct bt_ctf_field_type *element_field_type = NULL;
 	struct bt_ctf_field *uuid_field = bt_ctf_field_structure_get_field(
@@ -145,6 +141,7 @@ int set_packet_header_uuid(struct bt_ctf_stream *stream)
 		goto end;
 	}
 
+	trace = (struct bt_ctf_trace *) bt_object_get_parent(stream);
 	for (i = 0; i < 16; i++) {
 		struct bt_ctf_field *uuid_element =
 			bt_ctf_field_array_get_field(uuid_field, i);
@@ -154,28 +151,23 @@ int set_packet_header_uuid(struct bt_ctf_stream *stream)
 
 		if (ret) {
 			ret = bt_ctf_field_signed_integer_set_value(
-				uuid_element, (int64_t) stream->trace->uuid[i]);
+				uuid_element, (int64_t) trace->uuid[i]);
 		} else {
 			ret = bt_ctf_field_unsigned_integer_set_value(
 				uuid_element,
-				(uint64_t) stream->trace->uuid[i]);
+				(uint64_t) trace->uuid[i]);
 		}
-		bt_ctf_field_put(uuid_element);
+		bt_put(uuid_element);
 		if (ret) {
 			goto end;
 		}
 	}
 
 end:
-	if (uuid_field) {
-		bt_ctf_field_put(uuid_field);
-	}
-	if (uuid_field_type) {
-		bt_ctf_field_type_put(uuid_field_type);
-	}
-	if (element_field_type) {
-		bt_ctf_field_type_put(element_field_type);
-	}
+	bt_put(uuid_field);
+	bt_put(uuid_field_type);
+	bt_put(element_field_type);
+	BT_PUT(trace);
 	return ret;
 }
 static
@@ -216,12 +208,8 @@ int set_packet_header_stream_id(struct bt_ctf_stream *stream)
 			(uint64_t) stream_id);
 	}
 end:
-	if (stream_id_field) {
-		bt_ctf_field_put(stream_id_field);
-	}
-	if (stream_id_field_type) {
-		bt_ctf_field_type_put(stream_id_field_type);
-	}
+	bt_put(stream_id_field);
+	bt_put(stream_id_field_type);
 	return ret;
 }
 
@@ -249,10 +237,19 @@ end:
 }
 
 static
-void put_event(struct bt_ctf_event *event)
+void release_event(struct bt_ctf_event *event)
 {
-	bt_ctf_event_set_stream(event, NULL);
-	bt_ctf_event_put(event);
+	if (bt_object_get_ref_count(event)) {
+		/*
+		 * The event is being orphaned, but it must guarantee the
+		 * existence of its event class for the duration of its
+		 * lifetime.
+		 */
+		bt_get(event->event_class);
+		BT_PUT(event->base.parent);
+	} else {
+		bt_object_release(event);
+	}
 }
 
 BT_HIDDEN
@@ -272,13 +269,16 @@ struct bt_ctf_stream *bt_ctf_stream_create(
 		goto end;
 	}
 
-	/* A stream has no ownership of its trace (weak ptr) */
-	stream->trace = trace;
-	bt_ctf_base_init(stream, bt_ctf_stream_destroy);
+	bt_object_init(stream, bt_ctf_stream_destroy);
+	/*
+	 * Acquire reference to parent since stream will become publicly
+	 * reachable; it needs its parent to remain valid.
+	 */
+	bt_object_set_parent(stream, trace);
 	stream->packet_context = bt_ctf_field_create(
 		stream_class->packet_context_type);
 	if (!stream->packet_context) {
-		goto error_destroy;
+		goto error;
 	}
 
 	/*
@@ -290,8 +290,8 @@ struct bt_ctf_stream *bt_ctf_stream_create(
 	if (stream_class->event_context_type) {
 		stream->event_context = bt_ctf_field_create(
 			stream_class->event_context_type);
-		if (!stream->packet_context) {
-			goto error_destroy;
+		if (!stream->event_context) {
+			goto error;
 		}
 	}
 
@@ -299,23 +299,22 @@ struct bt_ctf_stream *bt_ctf_stream_create(
 	ret = set_structure_field_integer(stream->packet_context,
 		"events_discarded", 0);
 	if (ret) {
-		goto error_destroy;
+		goto error;
 	}
 
 	stream->pos.fd = -1;
 	stream->id = stream_class->next_stream_id++;
 	stream->stream_class = stream_class;
-	bt_ctf_stream_class_get(stream_class);
 	stream->events = g_ptr_array_new_with_free_func(
-		(GDestroyNotify) put_event);
+		(GDestroyNotify) release_event);
 	if (!stream->events) {
-		goto error_destroy;
+		goto error;
 	}
 	if (stream_class->event_context_type) {
 		stream->event_contexts = g_ptr_array_new_with_free_func(
-			(GDestroyNotify) bt_ctf_field_put);
+			(GDestroyNotify) bt_put);
 		if (!stream->event_contexts) {
-			goto error_destroy;
+			goto error;
 		}
 	}
 
@@ -323,7 +322,7 @@ struct bt_ctf_stream *bt_ctf_stream_create(
 	assert(trace->packet_header_type);
 	stream->packet_header = bt_ctf_field_create(trace->packet_header_type);
 	if (!stream->packet_header) {
-		goto error_destroy;
+		goto error;
 	}
 	/*
 	 * Attempt to populate the default trace packet header fields
@@ -335,13 +334,14 @@ struct bt_ctf_stream *bt_ctf_stream_create(
 	 */
 	ret = set_packet_header(stream);
 	if (ret) {
-		goto error_destroy;
+		goto error;
 	}
 end:
 	return stream;
-error_destroy:
-	bt_ctf_stream_destroy(&stream->base.ref_count);
-	return NULL;
+error:
+	BT_PUT(stream);
+	bt_put(trace);
+	return stream;
 }
 
 BT_HIDDEN
@@ -370,7 +370,7 @@ struct bt_ctf_stream_class *bt_ctf_stream_get_class(
 	}
 
 	stream_class = stream->stream_class;
-	bt_ctf_stream_class_get(stream_class);
+	bt_get(stream_class);
 end:
 	return stream_class;
 }
@@ -431,12 +431,8 @@ int bt_ctf_stream_get_discarded_events_count(
 		}
 	}
 end:
-	if (events_discarded_field) {
-		bt_ctf_field_put(events_discarded_field);
-	}
-	if (events_discarded_field_type) {
-		bt_ctf_field_type_put(events_discarded_field_type);
-	}
+	bt_put(events_discarded_field);
+	bt_put(events_discarded_field_type);
 	return ret;
 }
 
@@ -494,12 +490,8 @@ void bt_ctf_stream_append_discarded_events(struct bt_ctf_stream *stream,
 	}
 
 end:
-	if (events_discarded_field) {
-		bt_ctf_field_put(events_discarded_field);
-	}
-	if (events_discarded_field_type) {
-		bt_ctf_field_type_put(events_discarded_field_type);
-	}
+	bt_put(events_discarded_field);
+	bt_put(events_discarded_field_type);
 }
 
 int bt_ctf_stream_append_event(struct bt_ctf_stream *stream,
@@ -513,13 +505,7 @@ int bt_ctf_stream_append_event(struct bt_ctf_stream *stream,
 		goto end;
 	}
 
-	ret = bt_ctf_event_set_stream(event, stream);
-	if (ret) {
-		/* Event was already associated to a stream */
-		ret = -1;
-		goto end;
-	}
-
+	bt_object_set_parent(event, stream);
 	ret = bt_ctf_event_populate_event_header(event);
 	if (ret) {
 		goto end;
@@ -546,15 +532,25 @@ int bt_ctf_stream_append_event(struct bt_ctf_stream *stream,
 		}
 	}
 
-	bt_ctf_event_get(event);
 	/* Save the new event along with its associated stream event context */
 	g_ptr_array_add(stream->events, event);
 	if (event_context_copy) {
 		g_ptr_array_add(stream->event_contexts, event_context_copy);
 	}
+	/*
+	 * Event had to hold a reference to its event class as long as it wasn't
+	 * part of the same trace hierarchy. From now on, the event and its
+	 * class share the same lifetime guarantees and the reference is no
+	 * longer needed.
+	 */
+	bt_put(event->event_class);
 end:
 	if (ret) {
-		(void) bt_ctf_event_set_stream(event, NULL);
+		/*
+		 * Orphan the event; we were not succesful in associating it to
+		 * a stream.
+		 */
+		bt_object_set_parent(event, NULL);
 	}
 	return ret;
 }
@@ -570,7 +566,7 @@ struct bt_ctf_field *bt_ctf_stream_get_packet_context(
 
 	packet_context = stream->packet_context;
 	if (packet_context) {
-		bt_ctf_field_get(packet_context);
+		bt_get(packet_context);
 	}
 end:
 	return packet_context;
@@ -588,14 +584,15 @@ int bt_ctf_stream_set_packet_context(struct bt_ctf_stream *stream,
 	}
 
 	field_type = bt_ctf_field_get_type(field);
-	if (field_type != stream->stream_class->packet_context_type) {
+	if (bt_ctf_field_type_compare(field_type,
+			stream->stream_class->packet_context_type)) {
 		ret = -1;
 		goto end;
 	}
 
-	bt_ctf_field_type_put(field_type);
-	bt_ctf_field_get(field);
-	bt_ctf_field_put(stream->packet_context);
+	bt_put(field_type);
+	bt_get(field);
+	bt_put(stream->packet_context);
 	stream->packet_context = field;
 end:
 	return ret;
@@ -612,7 +609,7 @@ struct bt_ctf_field *bt_ctf_stream_get_event_context(
 
 	event_context = stream->event_context;
 	if (event_context) {
-		bt_ctf_field_get(event_context);
+		bt_get(event_context);
 	}
 end:
 	return event_context;
@@ -630,18 +627,17 @@ int bt_ctf_stream_set_event_context(struct bt_ctf_stream *stream,
 	}
 
 	field_type = bt_ctf_field_get_type(field);
-	if (field_type != stream->stream_class->event_context_type) {
+	if (bt_ctf_field_type_compare(field_type,
+			stream->stream_class->event_context_type)) {
 		ret = -1;
 		goto end;
 	}
 
-	bt_ctf_field_get(field);
-	bt_ctf_field_put(stream->event_context);
+	bt_get(field);
+	bt_put(stream->event_context);
 	stream->event_context = field;
 end:
-	if (field_type) {
-		bt_ctf_field_type_put(field_type);
-	}
+	bt_put(field_type);
 	return ret;
 }
 
@@ -656,7 +652,7 @@ struct bt_ctf_field *bt_ctf_stream_get_packet_header(
 
 	packet_header = stream->packet_header;
 	if (packet_header) {
-		bt_ctf_field_get(packet_header);
+		bt_get(packet_header);
 	}
 end:
 	return packet_header;
@@ -666,6 +662,7 @@ int bt_ctf_stream_set_packet_header(struct bt_ctf_stream *stream,
 		struct bt_ctf_field *field)
 {
 	int ret = 0;
+	struct bt_ctf_trace *trace = NULL;
 	struct bt_ctf_field_type *field_type = NULL;
 
 	if (!stream || !field) {
@@ -673,19 +670,19 @@ int bt_ctf_stream_set_packet_header(struct bt_ctf_stream *stream,
 		goto end;
 	}
 
+	trace = (struct bt_ctf_trace *) bt_object_get_parent(stream);
 	field_type = bt_ctf_field_get_type(field);
-	if (field_type != stream->trace->packet_header_type) {
+	if (bt_ctf_field_type_compare(field_type, trace->packet_header_type)) {
 		ret = -1;
 		goto end;
 	}
 
-	bt_ctf_field_get(field);
-	bt_ctf_field_put(stream->packet_header);
+	bt_get(field);
+	bt_put(stream->packet_header);
 	stream->packet_header = field;
 end:
-	if (field_type) {
-		bt_ctf_field_type_put(field_type);
-	}
+	BT_PUT(trace);
+	bt_put(field_type);
 	return ret;
 }
 
@@ -728,8 +725,8 @@ int get_event_header_timestamp(struct bt_ctf_field *event_header, uint64_t *time
 		}
 	}
 end:
-	bt_ctf_field_put(timestamp_field);
-	bt_ctf_field_type_put(timestamp_field_type);
+	bt_put(timestamp_field);
+	bt_put(timestamp_field_type);
 	return ret;
 }
 
@@ -893,55 +890,40 @@ int bt_ctf_stream_flush(struct bt_ctf_stream *stream)
 	}
 	stream->flushed_packet_count++;
 end:
-	bt_ctf_field_put(integer);
+	bt_put(integer);
 	return ret;
 }
 
 void bt_ctf_stream_get(struct bt_ctf_stream *stream)
 {
-	bt_ctf_get(stream);
+	bt_get(stream);
 }
 
 void bt_ctf_stream_put(struct bt_ctf_stream *stream)
 {
-	bt_ctf_put(stream);
+	bt_put(stream);
 }
 
 static
-void bt_ctf_stream_destroy(struct bt_ref *ref)
+void bt_ctf_stream_destroy(struct bt_object *obj)
 {
 	struct bt_ctf_stream *stream;
-	struct bt_ctf_base *base;
 
-	if (!ref) {
-		return;
-	}
-
-	base = container_of(ref, struct bt_ctf_base, ref_count);
-	stream = container_of(base, struct bt_ctf_stream, base);
+	stream = container_of(obj, struct bt_ctf_stream, base);
 	ctf_fini_pos(&stream->pos);
 	if (stream->pos.fd >= 0 && close(stream->pos.fd)) {
 		perror("close");
 	}
 
-	if (stream->stream_class) {
-		bt_ctf_stream_class_put(stream->stream_class);
-	}
 	if (stream->events) {
 		g_ptr_array_free(stream->events, TRUE);
 	}
 	if (stream->event_contexts) {
 		g_ptr_array_free(stream->event_contexts, TRUE);
 	}
-	if (stream->packet_header) {
-		bt_ctf_field_put(stream->packet_header);
-	}
-	if (stream->packet_context) {
-		bt_ctf_field_put(stream->packet_context);
-	}
-	if (stream->event_context) {
-		bt_ctf_field_put(stream->event_context);
-	}
+	bt_put(stream->packet_header);
+	bt_put(stream->packet_context);
+	bt_put(stream->event_context);
 	g_free(stream);
 }
 
@@ -990,11 +972,7 @@ int set_structure_field_integer(struct bt_ctf_field *structure, char *name,
 		ret = bt_ctf_field_unsigned_integer_set_value(integer, value);
 	}
 end:
-	if (integer) {
-		bt_ctf_field_put(integer);
-	}
-	if (field_type) {
-		bt_ctf_field_type_put(field_type);
-	}
+	bt_put(integer);
+	bt_put(field_type);
 	return ret;
 }