X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=formats%2Fctf%2Fir%2Fevent.c;h=beac9d489ca3f895938c977c730018471c81d3b8;hb=61ec14e66eb9e2329776dfe56a928232bc68b94e;hp=82ed0d947528546d436b3c8566116603f42c103e;hpb=272df73edf74c3d8d6cbbf6450258fdbc9fbad36;p=babeltrace.git diff --git a/formats/ctf/ir/event.c b/formats/ctf/ir/event.c index 82ed0d94..beac9d48 100644 --- a/formats/ctf/ir/event.c +++ b/formats/ctf/ir/event.c @@ -33,8 +33,12 @@ #include #include #include +#include +#include +#include #include #include +#include #include #include #include @@ -61,6 +65,7 @@ struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class) struct bt_ctf_field_type *event_context_type = NULL; struct bt_ctf_field_type *event_payload_type = NULL; struct bt_ctf_field *event_header = NULL; + struct bt_ctf_field *stream_event_context = NULL; struct bt_ctf_field *event_context = NULL; struct bt_ctf_field *event_payload = NULL; struct bt_value *environment = NULL; @@ -115,7 +120,6 @@ struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class) BT_PUT(stream_event_ctx_type); BT_PUT(event_context_type); BT_PUT(event_payload_type); - if (ret) { /* * This means something went wrong during the validation @@ -151,13 +155,22 @@ struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class) * lifetime. */ event->event_class = bt_get(event_class); + event->clock_values = g_hash_table_new_full(g_direct_hash, + g_direct_equal, NULL, g_free); event_header = bt_ctf_field_create(validation_output.event_header_type); - if (!event_header) { goto error; } + if (validation_output.stream_event_ctx_type) { + stream_event_context = bt_ctf_field_create( + validation_output.stream_event_ctx_type); + if (!stream_event_context) { + goto error; + } + } + if (validation_output.event_context_type) { event_context = bt_ctf_field_create( validation_output.event_context_type); @@ -183,6 +196,7 @@ struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class) bt_ctf_validation_replace_types(trace, stream_class, event_class, &validation_output, validation_flags); BT_MOVE(event->event_header, event_header); + BT_MOVE(event->stream_event_context, stream_event_context); BT_MOVE(event->context_payload, event_context); BT_MOVE(event->fields_payload, event_payload); @@ -216,6 +230,7 @@ error: BT_PUT(stream_class); BT_PUT(trace); BT_PUT(event_header); + BT_PUT(stream_event_context); BT_PUT(event_context); BT_PUT(event_payload); assert(!packet_header_type); @@ -244,7 +259,27 @@ end: struct bt_ctf_stream *bt_ctf_event_get_stream(struct bt_ctf_event *event) { - return (struct bt_ctf_stream *) bt_object_get_parent(event); + struct bt_ctf_stream *stream = NULL; + + if (!event) { + goto end; + } + + /* + * If the event has a parent, then this is its (writer) stream. + * If the event has no parent, then if it has a packet, this + * is its (non-writer) stream. + */ + if (event->base.parent) { + stream = (struct bt_ctf_stream *) bt_object_get_parent(event); + } else { + if (event->packet) { + stream = bt_get(event->packet->stream); + } + } + +end: + return stream; } struct bt_ctf_clock *bt_ctf_event_get_clock(struct bt_ctf_event *event) @@ -286,7 +321,7 @@ int bt_ctf_event_set_payload(struct bt_ctf_event *event, { int ret = 0; - if (!event || !payload) { + if (!event || !payload || event->frozen) { ret = -1; goto end; } @@ -334,7 +369,7 @@ int bt_ctf_event_set_payload_field(struct bt_ctf_event *event, int ret = 0; struct bt_ctf_field_type *payload_type = NULL; - if (!event || !payload) { + if (!event || !payload || event->frozen) { ret = -1; goto end; } @@ -417,7 +452,7 @@ int bt_ctf_event_set_header(struct bt_ctf_event *event, struct bt_ctf_field_type *field_type = NULL; struct bt_ctf_stream_class *stream_class = NULL; - if (!event || !header) { + if (!event || !header || event->frozen) { ret = -1; goto end; } @@ -465,7 +500,7 @@ int bt_ctf_event_set_event_context(struct bt_ctf_event *event, int ret = 0; struct bt_ctf_field_type *field_type = NULL; - if (!event || !context) { + if (!event || !context || event->frozen) { ret = -1; goto end; } @@ -485,6 +520,54 @@ end: return ret; } +struct bt_ctf_field *bt_ctf_event_get_stream_event_context( + struct bt_ctf_event *event) +{ + struct bt_ctf_field *stream_event_context = NULL; + + if (!event || !event->stream_event_context) { + goto end; + } + + stream_event_context = event->stream_event_context; +end: + return bt_get(stream_event_context); +} + +int bt_ctf_event_set_stream_event_context(struct bt_ctf_event *event, + struct bt_ctf_field *stream_event_context) +{ + int ret = 0; + struct bt_ctf_field_type *field_type = NULL; + struct bt_ctf_stream_class *stream_class = NULL; + + if (!event || !stream_event_context || event->frozen) { + ret = -1; + goto end; + } + + stream_class = bt_ctf_event_class_get_stream_class(event->event_class); + /* + * We should not have been able to create the event without associating + * the event class to a stream class. + */ + assert(stream_class); + + field_type = bt_ctf_field_get_type(stream_event_context); + if (bt_ctf_field_type_compare(field_type, + stream_class->event_context_type)) { + ret = -1; + goto end; + } + + bt_get(stream_event_context); + BT_MOVE(event->stream_event_context, stream_event_context); +end: + BT_PUT(stream_class); + bt_put(field_type); + return ret; +} + void bt_ctf_event_get(struct bt_ctf_event *event) { bt_get(event); @@ -508,12 +591,36 @@ void bt_ctf_event_destroy(struct bt_object *obj) */ bt_put(event->event_class); } + g_hash_table_destroy(event->clock_values); bt_put(event->event_header); + bt_put(event->stream_event_context); bt_put(event->context_payload); bt_put(event->fields_payload); + bt_put(event->packet); g_free(event); } +uint64_t bt_ctf_event_get_clock_value(struct bt_ctf_event *event, + struct bt_ctf_clock *clock) +{ + uint64_t ret = -1ULL; + uint64_t *clock_value; + + if (!event || !clock) { + goto end; + } + + clock_value = g_hash_table_lookup(event->clock_values, clock); + if (!clock_value) { + goto end; + } + + ret = *clock_value; + +end: + return ret; +} + static int set_integer_field_value(struct bt_ctf_field* field, uint64_t value) { @@ -563,6 +670,7 @@ int bt_ctf_event_validate(struct bt_ctf_event *event) { /* Make sure each field's payload has been set */ int ret; + struct bt_ctf_stream_class *stream_class = NULL; assert(event); ret = bt_ctf_field_validate(event->event_header); @@ -570,6 +678,19 @@ int bt_ctf_event_validate(struct bt_ctf_event *event) goto end; } + stream_class = bt_ctf_event_class_get_stream_class(event->event_class); + /* + * We should not have been able to create the event without associating + * the event class to a stream class. + */ + assert(stream_class); + if (stream_class->event_context_type) { + ret = bt_ctf_field_validate(event->stream_event_context); + if (ret) { + goto end; + } + } + ret = bt_ctf_field_validate(event->fields_payload); if (ret) { goto end; @@ -579,6 +700,7 @@ int bt_ctf_event_validate(struct bt_ctf_event *event) ret = bt_ctf_field_validate(event->context_payload); } end: + bt_put(stream_class); return ret; } @@ -613,7 +735,7 @@ int bt_ctf_event_populate_event_header(struct bt_ctf_event *event) int ret = 0; struct bt_ctf_field *id_field = NULL, *timestamp_field = NULL; - if (!event) { + if (!event || event->frozen) { ret = -1; goto end; } @@ -640,13 +762,16 @@ int bt_ctf_event_populate_event_header(struct bt_ctf_event *event) timestamp_field_type); bt_put(timestamp_field_type); if (mapped_clock) { - int64_t timestamp; + int64_t timestamp = 0; + // FIXME - Clock refactoring + /* ret = bt_ctf_clock_get_time(mapped_clock, ×tamp); bt_put(mapped_clock); if (ret) { goto end; } + */ ret = set_integer_field_value(timestamp_field, timestamp); @@ -661,50 +786,76 @@ end: return ret; } -struct bt_ctf_event *bt_ctf_event_copy(struct bt_ctf_event *event) +struct bt_ctf_packet *bt_ctf_event_get_packet(struct bt_ctf_event *event) { - struct bt_ctf_event *copy = NULL; + struct bt_ctf_packet *packet = NULL; - if (!event) { - goto error; + if (!event || !event->packet) { + goto end; } - copy = g_new0(struct bt_ctf_event, 1); - if (!copy) { - goto error; - } + packet = bt_get(event->packet); +end: + return packet; +} - bt_object_init(copy, bt_ctf_event_destroy); - copy->event_class = bt_get(event->event_class); +int bt_ctf_event_set_packet(struct bt_ctf_event *event, + struct bt_ctf_packet *packet) +{ + struct bt_ctf_stream_class *event_stream_class = NULL; + struct bt_ctf_stream_class *packet_stream_class = NULL; + struct bt_ctf_stream *stream = NULL; + int ret = 0; - if (event->event_header) { - copy->event_header = bt_ctf_field_copy(event->event_header); + if (!event || !packet || event->frozen) { + ret = -1; + goto end; + } - if (!copy->event_header) { - goto error; + /* + * Make sure the new packet was created by this event's + * stream, if it is set. + */ + stream = bt_ctf_event_get_stream(event); + if (stream) { + if (packet->stream != stream) { + ret = -1; + goto end; } - } + } else { + event_stream_class = + bt_ctf_event_class_get_stream_class(event->event_class); + packet_stream_class = + bt_ctf_stream_get_class(packet->stream); - if (event->context_payload) { - copy->context_payload = bt_ctf_field_copy( - event->context_payload); + assert(event_stream_class); + assert(packet_stream_class); - if (!copy->context_payload) { - goto error; + if (event_stream_class != packet_stream_class) { + ret = -1; + goto end; } } - if (event->fields_payload) { - copy->fields_payload = bt_ctf_field_copy(event->fields_payload); + bt_get(packet); + BT_MOVE(event->packet, packet); - if (!copy->fields_payload) { - goto error; - } - } +end: + BT_PUT(stream); + BT_PUT(event_stream_class); + BT_PUT(packet_stream_class); - return copy; + return ret; +} -error: - BT_PUT(copy); - return copy; +BT_HIDDEN +void bt_ctf_event_freeze(struct bt_ctf_event *event) +{ + assert(event); + bt_ctf_packet_freeze(event->packet); + bt_ctf_field_freeze(event->event_header); + bt_ctf_field_freeze(event->stream_event_context); + bt_ctf_field_freeze(event->context_payload); + bt_ctf_field_freeze(event->fields_payload); + event->frozen = 1; }