cleanup error paths in trimmer, writer and ctfcopytrace

Signed-off-by: Julien Desfossez <jdesfossez@efficios.com>
Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>

diff --git a/plugins/libctfcopytrace/clock-fields.c b/plugins/libctfcopytrace/clock-fields.c
index 86f4f28bdfdae82811fc423af98355b30454d443..7400f1cebb6461d66aae5fbaf65f91851294455b 100644 (file)
--- a/plugins/libctfcopytrace/clock-fields.c
+++ b/plugins/libctfcopytrace/clock-fields.c
@@ -89,14 +89,14 @@ static
 int update_header_clock_int_field_type(FILE *err, struct bt_ctf_field_type *type,
                struct bt_ctf_clock_class *writer_clock_class)
 {
-       struct bt_ctf_clock_class *clock;
+       struct bt_ctf_clock_class *clock = NULL;
        int ret;
 
        clock = bt_ctf_field_type_integer_get_mapped_clock_class(type);
        if (!clock) {
                return 0;
        }
-       bt_put(clock);
+       BT_PUT(clock);
 
        ret = bt_ctf_field_type_integer_set_size(type, 64);
        if (ret) {
@@ -158,10 +158,10 @@ int find_update_variant_clock_fields(FILE *err, struct bt_ctf_field_type *type,
                struct bt_ctf_clock_class *writer_clock_class)
 {
        int count, i, ret;
+       struct bt_ctf_field_type *entry_type = NULL;
 
        count = bt_ctf_field_type_variant_get_field_count(type);
        for (i = 0; i < count; i++) {
-               struct bt_ctf_field_type *entry_type;
                const char *entry_name;
 
                ret = bt_ctf_field_type_variant_get_field(type,
@@ -169,23 +169,25 @@ int find_update_variant_clock_fields(FILE *err, struct bt_ctf_field_type *type,
                if (ret) {
                        fprintf(err, "[error] %s in %s:%d\n",
                                        __func__, __FILE__, __LINE__);
-                       ret = -1;
-                       goto end;
+                       goto error;
                }
                ret = find_update_clock_fields(err, entry_type,
                                writer_clock_class);
-               bt_put(entry_type);
                if (ret) {
                        fprintf(err, "[error] %s in %s:%d\n",
                                        __func__, __FILE__, __LINE__);
-                       ret = -1;
-                       goto end;
+                       goto error;
                }
+               BT_PUT(entry_type);
        }
 
        ret = 0;
+       goto end;
 
+error:
+       ret = -1;
 end:
+       bt_put(entry_type);
        return ret;
 }
 
@@ -194,10 +196,10 @@ int find_update_struct_clock_fields(FILE *err, struct bt_ctf_field_type *type,
                struct bt_ctf_clock_class *writer_clock_class)
 {
        int count, i, ret;
+       struct bt_ctf_field_type *entry_type = NULL;
 
        count = bt_ctf_field_type_structure_get_field_count(type);
        for (i = 0; i < count; i++) {
-               struct bt_ctf_field_type *entry_type;
                const char *entry_name;
 
                ret = bt_ctf_field_type_structure_get_field(type,
@@ -205,22 +207,23 @@ int find_update_struct_clock_fields(FILE *err, struct bt_ctf_field_type *type,
                if (ret) {
                        fprintf(err, "[error] %s in %s:%d\n",
                                        __func__, __FILE__, __LINE__);
-                       ret = -1;
-                       goto end;
+                       goto error;
                }
                ret = find_update_clock_fields(err, entry_type,
                                writer_clock_class);
-               bt_put(entry_type);
                if (ret) {
                        fprintf(err, "[error] %s in %s:%d\n",
                                        __func__, __FILE__, __LINE__);
-                       ret = -1;
-                       goto end;
+                       goto error;
                }
+               BT_PUT(entry_type);
        }
 
        ret = 0;
+       goto end;
 
+error:
+       bt_put(entry_type);
 end:
        return ret;
 }
@@ -230,20 +233,27 @@ int find_update_sequence_clock_fields(FILE *err, struct bt_ctf_field_type *type,
                struct bt_ctf_clock_class *writer_clock_class)
 {
        int ret;
-       struct bt_ctf_field_type *entry_type;
+       struct bt_ctf_field_type *entry_type = NULL;
 
        entry_type = bt_ctf_field_type_sequence_get_element_type(type);
+       if (!entry_type) {
+               fprintf(err, "[error] %s in %s:%d\n",
+                               __func__, __FILE__, __LINE__);
+               goto error;
+       }
        ret = find_update_clock_fields(err, entry_type, writer_clock_class);
-       bt_put(entry_type);
+       BT_PUT(entry_type);
        if (ret) {
                fprintf(err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               ret = -1;
-               goto end;
+               goto error;
        }
 
        ret = 0;
+       goto end;
 
+error:
+       ret = -1;
 end:
        return ret;
 }
@@ -253,11 +263,16 @@ int find_update_array_clock_fields(FILE *err, struct bt_ctf_field_type *type,
                struct bt_ctf_clock_class *writer_clock_class)
 {
        int ret;
-       struct bt_ctf_field_type *entry_type;
+       struct bt_ctf_field_type *entry_type = NULL;
 
        entry_type = bt_ctf_field_type_array_get_element_type(type);
+       if (!entry_type) {
+               fprintf(err, "[error] %s in %s:%d\n",
+                               __func__, __FILE__, __LINE__);
+               goto error;
+       }
        ret = find_update_clock_fields(err, entry_type, writer_clock_class);
-       bt_put(entry_type);
+       BT_PUT(entry_type);
        if (ret) {
                fprintf(err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
@@ -266,7 +281,10 @@ int find_update_array_clock_fields(FILE *err, struct bt_ctf_field_type *type,
        }
 
        ret = 0;
+       goto end;
 
+error:
+       ret = -1;
 end:
        return ret;
 }
@@ -276,20 +294,27 @@ int find_update_enum_clock_fields(FILE *err, struct bt_ctf_field_type *type,
                struct bt_ctf_clock_class *writer_clock_class)
 {
        int ret;
-       struct bt_ctf_field_type *entry_type;
+       struct bt_ctf_field_type *entry_type = NULL;
 
        entry_type = bt_ctf_field_type_enumeration_get_container_type(type);
+       if (!entry_type) {
+               fprintf(err, "[error] %s in %s:%d\n",
+                               __func__, __FILE__, __LINE__);
+               goto error;
+       }
        ret = find_update_clock_fields(err, entry_type, writer_clock_class);
-       bt_put(entry_type);
+       BT_PUT(entry_type);
        if (ret) {
                fprintf(err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               ret = -1;
-               goto end;
+               goto error;
        }
 
        ret = 0;
+       goto end;
 
+error:
+       ret = -1;
 end:
        return ret;
 }
@@ -300,22 +325,22 @@ struct bt_ctf_field_type *override_header_type(FILE *err,
                struct bt_ctf_trace *writer_trace)
 {
        struct bt_ctf_field_type *new_type = NULL;
+       struct bt_ctf_clock_class *writer_clock_class = NULL;
        int ret;
-       struct bt_ctf_clock_class *writer_clock_class;
 
        /* FIXME multi-clock? */
        writer_clock_class = bt_ctf_trace_get_clock_class(writer_trace, 0);
        if (!writer_clock_class) {
                fprintf(err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end;
+               goto error;
        }
 
        new_type = bt_ctf_field_type_copy(type);
        if (!new_type) {
                fprintf(err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end_put;
+               goto error;
        }
 
        if (bt_ctf_field_type_get_type_id(new_type) != BT_CTF_TYPE_ID_STRUCT) {
@@ -329,13 +354,13 @@ struct bt_ctf_field_type *override_header_type(FILE *err,
                                __func__, __FILE__, __LINE__);
                goto error;
        }
+       BT_PUT(writer_clock_class);
 
-       goto end_put;
+       goto end;
 
 error:
-       BT_PUT(new_type);
-end_put:
        bt_put(writer_clock_class);
+       BT_PUT(new_type);
 end:
        return new_type;
 }
@@ -403,7 +428,7 @@ int copy_override_field(FILE *err, struct bt_ctf_event *event,
                struct bt_ctf_event *writer_event, struct bt_ctf_field *field,
                struct bt_ctf_field *copy_field)
 {
-       struct bt_ctf_field_type *type;
+       struct bt_ctf_field_type *type = NULL;
        int ret;
 
        type = bt_ctf_field_get_type(field);
@@ -453,7 +478,7 @@ int copy_override_field(FILE *err, struct bt_ctf_event *event,
        }
 
        ret = 0;
-       bt_put(type);
+       BT_PUT(type);
 
 end:
        return ret;
@@ -465,7 +490,7 @@ int copy_find_clock_enum_field(FILE *err, struct bt_ctf_event *event,
                struct bt_ctf_field_type *type, struct bt_ctf_field *copy_field)
 {
        int ret;
-       struct bt_ctf_field *container, *copy_container;
+       struct bt_ctf_field *container = NULL, *copy_container = NULL;
 
        container = bt_ctf_field_enumeration_get_container(field);
        if (!container) {
@@ -480,7 +505,7 @@ int copy_find_clock_enum_field(FILE *err, struct bt_ctf_event *event,
                ret = -1;
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_container;
+               goto error;
        }
 
        ret = copy_override_field(err, event, writer_event, container,
@@ -489,14 +514,17 @@ int copy_find_clock_enum_field(FILE *err, struct bt_ctf_event *event,
                ret = -1;
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_copy_container;
+               goto error;
        }
+       
+       ret = 0;
+       goto end;
 
-end_put_copy_container:
+error:
+       ret = -1;
+end:
        bt_put(copy_container);
-end_put_container:
        bt_put(container);
-end:
        return ret;
 }
 
@@ -506,52 +534,47 @@ int copy_find_clock_variant_field(FILE *err, struct bt_ctf_event *event,
                struct bt_ctf_field_type *type, struct bt_ctf_field *copy_field)
 {
        int ret;
-       struct bt_ctf_field *tag;
-       struct bt_ctf_field *variant_field, *copy_variant_field;
+       struct bt_ctf_field *tag = NULL;
+       struct bt_ctf_field *variant_field = NULL, *copy_variant_field = NULL;
 
        tag = bt_ctf_field_variant_get_tag(field);
        if (!tag) {
-               ret = -1;
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end;
+               goto error;
        }
 
        variant_field = bt_ctf_field_variant_get_field(field, tag);
        if (!variant_field) {
-               ret = -1;
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_tag;
+               goto error;
        }
 
        copy_variant_field = bt_ctf_field_variant_get_field(copy_field, tag);
        if (!copy_variant_field) {
-               bt_put(variant_field);
-               ret = -1;
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_variant_field;
+               goto error;
        }
 
        ret = copy_override_field(err, event, writer_event, variant_field,
                        copy_variant_field);
        if (ret) {
-               ret = -1;
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_copy_variand_field;
+               goto error;
        }
 
        ret = 0;
+       goto end;
 
-end_put_copy_variand_field:
+error:
+       ret = -1;
+end:
        bt_put(copy_variant_field);
-end_put_variant_field:
        bt_put(variant_field);
-end_put_tag:
        bt_put(tag);
-end:
        return ret;
 }
 
@@ -563,77 +586,65 @@ int copy_find_clock_sequence_field(FILE *err,
 {
        int ret;
        uint64_t i, count;
-       struct bt_ctf_field_type *entry_type;
-       struct bt_ctf_field *length_field;
-
-       entry_type = bt_ctf_field_type_sequence_get_element_type(type);
-       if (!entry_type) {
-               ret = -1;
-               fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-                               __LINE__);
-               goto end;
-       }
+       struct bt_ctf_field *length_field = NULL;
+       struct bt_ctf_field *entry_field = NULL, *entry_copy = NULL;
 
        length_field = bt_ctf_field_sequence_get_length(field);
        if (!length_field) {
-               ret = -1;
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end;
+               goto error;
        }
 
        ret = bt_ctf_field_unsigned_integer_get_value(length_field, &count);
        if (ret) {
-               bt_put(length_field);
-               ret = -1;
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end;
+               goto error;
        }
 
        ret = bt_ctf_field_sequence_set_length(copy_field, length_field);
-       bt_put(length_field);
        if (ret) {
-               ret = -1;
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end;
+               goto error;
        }
+       BT_PUT(length_field);
 
        for (i = 0; i < count; i++) {
-               struct bt_ctf_field *entry_field, *entry_copy;
-
                entry_field = bt_ctf_field_sequence_get_field(field, i);
                if (!entry_field) {
-                       ret = -1;
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
-                       goto end;
+                       goto error;
                }
 
                entry_copy = bt_ctf_field_sequence_get_field(copy_field, i);
                if (!entry_copy) {
-                       ret = -1;
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
-                       goto end;
+                       goto error;
                }
 
                ret = copy_override_field(err, event, writer_event, entry_field,
                                entry_copy);
-               bt_put(entry_field);
-               bt_put(entry_copy);
                if (ret) {
-                       ret = -1;
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
-                       goto end;
+                       goto error;
                }
+               BT_PUT(entry_field);
+               BT_PUT(entry_copy);
        }
 
-       bt_put(entry_type);
        ret = 0;
+       goto end;
 
+error:
+       bt_put(length_field);
+       bt_put(entry_field);
+       bt_put(entry_copy);
+       ret = -1;
 end:
        return ret;
 }
@@ -645,49 +656,42 @@ int copy_find_clock_array_field(FILE *err,
                struct bt_ctf_field *copy_field)
 {
        int ret, count, i;
-       struct bt_ctf_field_type *entry_type;
+       struct bt_ctf_field *entry_field = NULL, *entry_copy = NULL;
 
        count = bt_ctf_field_type_array_get_length(type);
-       entry_type = bt_ctf_field_type_array_get_element_type(type);
-       if (!entry_type) {
-               ret = -1;
-               fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-                               __LINE__);
-               goto end;
-       }
        for (i = 0; i < count; i++) {
-               struct bt_ctf_field *entry_field, *entry_copy;
-
                entry_field = bt_ctf_field_array_get_field(field, i);
                if (!entry_field) {
-                       ret = -1;
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
-                       goto end;
+                       goto error;
                }
 
                entry_copy = bt_ctf_field_array_get_field(copy_field, i);
                if (!entry_copy) {
-                       ret = -1;
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
-                       goto end;
+                       goto error;
                }
 
                ret = copy_override_field(err, event, writer_event, entry_field,
                                entry_copy);
-               bt_put(entry_field);
-               bt_put(entry_copy);
                if (ret) {
                        ret = -1;
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
-                       goto end;
+                       goto error;
                }
+               BT_PUT(entry_field);
+               BT_PUT(entry_copy);
        }
 
-       bt_put(entry_type);
        ret = 0;
+       goto end;
+
+error:
+       bt_put(entry_field);
+       bt_put(entry_copy);
 
 end:
        return ret;
@@ -700,59 +704,55 @@ int copy_find_clock_struct_field(FILE *err,
                struct bt_ctf_field *copy_field)
 {
        int count, i, ret;
+       struct bt_ctf_field_type *entry_type = NULL;
+       struct bt_ctf_field *entry_field = NULL, *entry_copy = NULL;
 
        count = bt_ctf_field_type_structure_get_field_count(type);
        for (i = 0; i < count; i++) {
-               struct bt_ctf_field_type *entry_type;
-               struct bt_ctf_field *entry_field;
                const char *entry_name;
-               struct bt_ctf_field *entry_copy;
 
                entry_field = bt_ctf_field_structure_get_field_by_index(field, i);
                if (!entry_field) {
-                       ret = -1;
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
-                       goto end;
+                       goto error;
                }
 
                ret = bt_ctf_field_type_structure_get_field(type, &entry_name,
                                &entry_type, i);
                if (ret) {
-                       bt_put(entry_field);
-                       ret = -1;
                        fprintf(err, "[error] %s in %s:%d\n",
                                        __func__, __FILE__, __LINE__);
-                       goto end;
+                       goto error;
                }
 
                entry_copy = bt_ctf_field_structure_get_field_by_index(copy_field, i);
                if (!entry_copy) {
-                       bt_put(entry_field);
-                       bt_put(entry_type);
-                       ret = -1;
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
-                       goto end;
+                       goto error;
                }
 
                ret = copy_override_field(err, event, writer_event, entry_field,
                                entry_copy);
-
-               bt_put(entry_copy);
-               bt_put(entry_field);
-               bt_put(entry_type);
                if (ret) {
-                       BT_PUT(entry_copy);
-                       ret = -1;
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
-                       goto end;
+                       goto error;
                }
+               BT_PUT(entry_copy);
+               BT_PUT(entry_field);
+               BT_PUT(entry_type);
        }
 
        ret = 0;
+       goto end;
 
+error:
+       bt_put(entry_type);
+       bt_put(entry_field);
+       bt_put(entry_copy);
+       ret = -1;
 end:
        return ret;
 }
@@ -774,7 +774,6 @@ int set_int_value(FILE *err, struct bt_ctf_field *field,
                                        __FILE__, __LINE__);
                        goto end;
                }
-               printf(" - v(s) = %ld\n", value);
                ret = bt_ctf_field_signed_integer_set_value(copy_field, value);
                if (ret) {
                        ret = -1;
@@ -808,7 +807,7 @@ end:
 struct bt_ctf_clock_class *stream_class_get_clock_class(FILE *err,
                struct bt_ctf_stream_class *stream_class)
 {
-       struct bt_ctf_trace *trace;
+       struct bt_ctf_trace *trace = NULL;
        struct bt_ctf_clock_class *clock_class = NULL;
 
        trace = bt_ctf_stream_class_get_trace(stream_class);
@@ -828,8 +827,8 @@ end:
 
 struct bt_ctf_clock_class *event_get_clock_class(FILE *err, struct bt_ctf_event *event)
 {
-       struct bt_ctf_event_class *event_class;
-       struct bt_ctf_stream_class *stream_class;
+       struct bt_ctf_event_class *event_class = NULL;
+       struct bt_ctf_stream_class *stream_class = NULL;
        struct bt_ctf_clock_class *clock_class = NULL;
 
        event_class = bt_ctf_event_get_class(event);
@@ -840,17 +839,16 @@ struct bt_ctf_clock_class *event_get_clock_class(FILE *err, struct bt_ctf_event
        }
 
        stream_class = bt_ctf_event_class_get_stream_class(event_class);
+       BT_PUT(event_class);
        if (!stream_class) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_event_class;
+               goto end;
        }
 
        clock_class = stream_class_get_clock_class(err, stream_class);
        bt_put(stream_class);
 
-end_put_event_class:
-       bt_put(event_class);
 end:
        return clock_class;
 }
@@ -861,8 +859,8 @@ int copy_find_clock_int_field(FILE *err,
                struct bt_ctf_field *field, struct bt_ctf_field_type *type,
                struct bt_ctf_field *copy_field)
 {
-       struct bt_ctf_clock_class *clock_class, *writer_clock_class;
-       struct bt_ctf_clock_value *clock_value, *writer_clock_value;
+       struct bt_ctf_clock_class *clock_class = NULL, *writer_clock_class = NULL;
+       struct bt_ctf_clock_value *clock_value = NULL, *writer_clock_value = NULL;
        uint64_t value;
        int ret;
 
@@ -872,53 +870,56 @@ int copy_find_clock_int_field(FILE *err,
        }
 
        clock_value = bt_ctf_event_get_clock_value(event, clock_class);
-       bt_put(clock_class);
+       BT_PUT(clock_class);
        if (!clock_value) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end;
+               goto error;
        }
 
        ret = bt_ctf_clock_value_get_value(clock_value, &value);
-       bt_put(clock_value);
+       BT_PUT(clock_value);
        if (ret) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end;
+               goto error;
        }
 
        ret = bt_ctf_field_unsigned_integer_set_value(copy_field, value);
        if (ret) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end;
+               goto error;
        }
 
        writer_clock_class = event_get_clock_class(err, writer_event);
        if (!writer_clock_class) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end;
+               goto error;
        }
 
        writer_clock_value = bt_ctf_clock_value_create(writer_clock_class, value);
-       bt_put(writer_clock_class);
+       BT_PUT(writer_clock_class);
        if (!writer_clock_value) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end;
+               goto error;
        }
 
        ret = bt_ctf_event_set_clock_value(writer_event, writer_clock_value);
-       bt_put(writer_clock_value);
+       BT_PUT(writer_clock_value);
        if (ret) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end;
+               goto error;
        }
 
        ret = 0;
+       goto end;
 
+error:
+       ret = -1;
 end:
        return ret;
 }

diff --git a/plugins/libctfcopytrace/ctfcopytrace.c b/plugins/libctfcopytrace/ctfcopytrace.c
index d2d422100ee7228f7b96e6513d208d0ec7dd1388..a2e2bffc7b3ee847552ae7d24f16b78f2ca6e51a 100644 (file)
--- a/plugins/libctfcopytrace/ctfcopytrace.c
+++ b/plugins/libctfcopytrace/ctfcopytrace.c
@@ -238,25 +238,22 @@ struct bt_ctf_event_class *ctf_copy_event_class(FILE *err,
                if (!attr_name) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
-                       BT_PUT(writer_event_class);
-                       goto end;
+                       goto error;
                }
                attr_value = bt_ctf_event_class_get_attribute_value(event_class, i);
                if (!attr_value) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
-                       BT_PUT(writer_event_class);
-                       goto end;
+                       goto error;
                }
 
                ret = bt_ctf_event_class_set_attribute(writer_event_class,
                                attr_name, attr_value);
-               bt_put(attr_value);
+               BT_PUT(attr_value);
                if (ret < 0) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
-                       BT_PUT(writer_event_class);
-                       goto end;
+                       goto error;
                }
        }
 
@@ -270,22 +267,23 @@ struct bt_ctf_event_class *ctf_copy_event_class(FILE *err,
                                &field_type, i);
                if (ret < 0) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
-                       BT_PUT(writer_event_class);
-                       goto end;
+                       goto error;
                }
 
                ret = bt_ctf_event_class_add_field(writer_event_class, field_type,
                                field_name);
+               BT_PUT(field_type);
                if (ret < 0) {
                        fprintf(err, "[error] Cannot add field %s\n", field_name);
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
-                       bt_put(field_type);
-                       BT_PUT(writer_event_class);
-                       goto end;
+                       goto error;
                }
-               bt_put(field_type);
        }
 
+       goto end;
+
+error:
+       BT_PUT(writer_event_class);
 end:
        return writer_event_class;
 }
@@ -295,6 +293,7 @@ enum bt_component_status ctf_copy_event_classes(FILE *err,
                struct bt_ctf_stream_class *writer_stream_class)
 {
        enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
+       struct bt_ctf_event_class *event_class = NULL, *writer_event_class = NULL;
        int count, i;
 
        count = bt_ctf_stream_class_get_event_class_count(stream_class);
@@ -305,7 +304,6 @@ enum bt_component_status ctf_copy_event_classes(FILE *err,
        }
 
        for (i = 0; i < count; i++) {
-               struct bt_ctf_event_class *event_class, *writer_event_class;
                struct bt_ctf_field_type *context;
                int int_ret;
 
@@ -315,25 +313,29 @@ enum bt_component_status ctf_copy_event_classes(FILE *err,
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
                        ret = BT_COMPONENT_STATUS_ERROR;
-                       bt_put(event_class);
-                       goto end;
+                       goto error;
                }
                writer_event_class = ctf_copy_event_class(err, event_class);
                if (!writer_event_class) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
                        ret = BT_COMPONENT_STATUS_ERROR;
-                       bt_put(event_class);
-                       goto end;
+                       goto error;
                }
 
                context = bt_ctf_event_class_get_context_type(event_class);
+               if (!context) {
+                       fprintf(err, "[error] %s in %s:%d\n", __func__,
+                                       __FILE__, __LINE__);
+                       ret = BT_COMPONENT_STATUS_ERROR;
+                       goto error;
+               }
                ret = bt_ctf_event_class_set_context_type(writer_event_class, context);
-               bt_put(context);
+               BT_PUT(context);
                if (ret < 0) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
-                       goto end;
+                       goto error;
                }
 
                int_ret = bt_ctf_stream_class_add_event_class(writer_stream_class,
@@ -343,13 +345,17 @@ enum bt_component_status ctf_copy_event_classes(FILE *err,
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
                        ret = BT_COMPONENT_STATUS_ERROR;
-                       bt_put(event_class);
-                       goto end;
+                       goto error;
                }
-               bt_put(event_class);
-               bt_put(writer_event_class);
+               BT_PUT(writer_event_class);
+               BT_PUT(event_class);
        }
 
+       goto end;
+
+error:
+       bt_put(event_class);
+       bt_put(writer_event_class);
 end:
        return ret;
 }
@@ -359,8 +365,8 @@ struct bt_ctf_stream_class *ctf_copy_stream_class(FILE *err,
                struct bt_ctf_trace *writer_trace,
                bool override_ts64)
 {
-       struct bt_ctf_field_type *type, *new_event_header_type;
-       struct bt_ctf_stream_class *writer_stream_class;
+       struct bt_ctf_field_type *type = NULL;
+       struct bt_ctf_stream_class *writer_stream_class = NULL;
        int ret_int;
        const char *name = bt_ctf_stream_class_get_name(stream_class);
 
@@ -384,12 +390,12 @@ struct bt_ctf_stream_class *ctf_copy_stream_class(FILE *err,
 
        ret_int = bt_ctf_stream_class_set_packet_context_type(
                        writer_stream_class, type);
-       bt_put(type);
        if (ret_int < 0) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
                goto error;
        }
+       BT_PUT(type);
 
        type = bt_ctf_stream_class_get_event_header_type(stream_class);
        if (!type) {
@@ -399,9 +405,10 @@ struct bt_ctf_stream_class *ctf_copy_stream_class(FILE *err,
        }
 
        if (override_ts64) {
+               struct bt_ctf_field_type *new_event_header_type;
+
                new_event_header_type = override_header_type(err, type,
                                writer_trace);
-               bt_put(type);
                if (!new_event_header_type) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
@@ -409,7 +416,7 @@ struct bt_ctf_stream_class *ctf_copy_stream_class(FILE *err,
                }
                ret_int = bt_ctf_stream_class_set_event_header_type(
                                writer_stream_class, new_event_header_type);
-               bt_put(new_event_header_type);
+               BT_PUT(new_event_header_type);
                if (ret_int < 0) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
@@ -418,31 +425,32 @@ struct bt_ctf_stream_class *ctf_copy_stream_class(FILE *err,
        } else {
                ret_int = bt_ctf_stream_class_set_event_header_type(
                                writer_stream_class, type);
-               bt_put(type);
                if (ret_int < 0) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
                        goto error;
                }
        }
+       BT_PUT(type);
 
        type = bt_ctf_stream_class_get_event_context_type(stream_class);
        if (type) {
                ret_int = bt_ctf_stream_class_set_event_context_type(
                                writer_stream_class, type);
-               bt_put(type);
                if (ret_int < 0) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
                        goto error;
                }
        }
+       BT_PUT(type);
 
        goto end;
 
 error:
        BT_PUT(writer_stream_class);
 end:
+       bt_put(type);
        return writer_stream_class;
 }
 
@@ -452,8 +460,8 @@ enum bt_component_status ctf_copy_packet_context_field(FILE *err,
                struct bt_ctf_field_type *writer_packet_context_type)
 {
        enum bt_component_status ret;
-       struct bt_ctf_field *writer_field;
-       struct bt_ctf_field_type *field_type;
+       struct bt_ctf_field *writer_field = NULL;
+       struct bt_ctf_field_type *field_type = NULL;
        int int_ret;
        uint64_t value;
 
@@ -469,17 +477,11 @@ enum bt_component_status ctf_copy_packet_context_field(FILE *err,
         */
        if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_TYPE_ID_INTEGER) {
                fprintf(err, "[error] Unsupported packet context field type\n");
-               bt_put(field_type);
                ret = BT_COMPONENT_STATUS_ERROR;
-               goto end;
+               goto error;
        }
-       bt_put(field_type);
+       BT_PUT(field_type);
 
-       /*
-        * TODO: handle the special case of the first/last packet that might
-        * be trimmed. In these cases, the timestamp_begin/end need to be
-        * explicitely set to the first/last event timestamps.
-        */
        writer_field = bt_ctf_field_structure_get_field(writer_packet_context,
                        field_name);
        if (!writer_field) {
@@ -489,14 +491,13 @@ enum bt_component_status ctf_copy_packet_context_field(FILE *err,
                goto end;
        }
 
-
        int_ret = bt_ctf_field_unsigned_integer_get_value(field, &value);
        if (int_ret < 0) {
                fprintf(err, "[error] Wrong packet_context field type\n");
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
                ret = BT_COMPONENT_STATUS_ERROR;
-               goto end_put_writer_field;
+               goto end;
        }
 
        int_ret = bt_ctf_field_unsigned_integer_set_value(writer_field, value);
@@ -504,14 +505,17 @@ enum bt_component_status ctf_copy_packet_context_field(FILE *err,
                ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_writer_field;
+               goto end;
        }
 
        ret = BT_COMPONENT_STATUS_OK;
 
-end_put_writer_field:
-       bt_put(writer_field);
+       goto end;
+
+error:
+       bt_put(field_type);
 end:
+       bt_put(writer_field);
        return ret;
 }
 
@@ -520,105 +524,102 @@ struct bt_ctf_field *ctf_copy_packet_context(FILE *err,
                struct bt_ctf_stream *writer_stream)
 {
        enum bt_component_status ret;
-       struct bt_ctf_field *packet_context, *writer_packet_context = NULL;
-       struct bt_ctf_field_type *struct_type, *writer_packet_context_type;
-       struct bt_ctf_stream_class *writer_stream_class;
+       struct bt_ctf_field *packet_context = NULL, *writer_packet_context = NULL;
+       struct bt_ctf_field_type *struct_type = NULL, *writer_packet_context_type = NULL;
+       struct bt_ctf_stream_class *writer_stream_class = NULL;
+       struct bt_ctf_field *field;
+       struct bt_ctf_field_type *field_type;
        int nr_fields, i;
 
        packet_context = bt_ctf_packet_get_context(packet);
        if (!packet_context) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end;
+               goto error;
        }
 
        writer_stream_class = bt_ctf_stream_get_class(writer_stream);
        if (!writer_stream_class) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_packet_context;
+               goto error;
        }
 
        writer_packet_context_type = bt_ctf_stream_class_get_packet_context_type(
                        writer_stream_class);
+       BT_PUT(writer_stream_class);
        if (!writer_packet_context_type) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_writer_stream_class;
+               goto error;
        }
 
        struct_type = bt_ctf_field_get_type(packet_context);
        if (!struct_type) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_writer_packet_context_type;
+               goto error;
        }
 
        writer_packet_context = bt_ctf_field_create(writer_packet_context_type);
        if (!writer_packet_context) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_struct_type;
+               goto error;
        }
 
        nr_fields = bt_ctf_field_type_structure_get_field_count(struct_type);
        for (i = 0; i < nr_fields; i++) {
-               struct bt_ctf_field *field;
-               struct bt_ctf_field_type *field_type;
                const char *field_name;
 
                field = bt_ctf_field_structure_get_field_by_index(
                                packet_context, i);
                if (!field) {
-                       BT_PUT(writer_packet_context);
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
-                       goto end_put_struct_type;
+                       goto error;
                }
                if (bt_ctf_field_type_structure_get_field(struct_type,
                                        &field_name, &field_type, i) < 0) {
-                       bt_put(field);
-                       BT_PUT(writer_packet_context);
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
-                       goto end_put_struct_type;
+                       goto error;
                }
                if (!strncmp(field_name, "content_size", strlen("content_size")) ||
                                !strncmp(field_name, "packet_size",
                                        strlen("packet_size"))) {
-                       bt_put(field_type);
-                       bt_put(field);
+                       BT_PUT(field_type);
+                       BT_PUT(field);
                        continue;
                }
 
                if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_TYPE_ID_INTEGER) {
                        fprintf(err, "[error] Unexpected packet context field type\n");
-                       bt_put(field);
-                       BT_PUT(writer_packet_context);
-                       goto end_put_struct_type;
+                       goto error;
                }
 
                ret = ctf_copy_packet_context_field(err, field, field_name,
                                writer_packet_context, writer_packet_context_type);
-               bt_put(field_type);
-               bt_put(field);
+               BT_PUT(field_type);
+               BT_PUT(field);
                if (ret != BT_COMPONENT_STATUS_OK) {
-                       BT_PUT(writer_packet_context);
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
-                       goto end_put_struct_type;
+                       goto error;
                }
        }
 
-end_put_struct_type:
+       goto end;
+
+error:
+       BT_PUT(writer_packet_context);
+end:
+       bt_put(field);
+       bt_put(field_type);
        bt_put(struct_type);
-end_put_writer_packet_context_type:
        bt_put(writer_packet_context_type);
-end_put_writer_stream_class:
        bt_put(writer_stream_class);
-end_put_packet_context:
        bt_put(packet_context);
-end:
        return writer_packet_context;
 }
 
@@ -627,8 +628,8 @@ int ctf_copy_event_header(FILE *err, struct bt_ctf_event *event,
                struct bt_ctf_event *writer_event,
                struct bt_ctf_field *event_header)
 {
-       struct bt_ctf_clock_class *clock_class, *writer_clock_class;
-       struct bt_ctf_clock_value *clock_value, *writer_clock_value;
+       struct bt_ctf_clock_class *clock_class = NULL, *writer_clock_class = NULL;
+       struct bt_ctf_clock_value *clock_value = NULL, *writer_clock_value = NULL;
 
        int ret;
        struct bt_ctf_field *writer_event_header = NULL;
@@ -642,7 +643,7 @@ int ctf_copy_event_header(FILE *err, struct bt_ctf_event *event,
        }
 
        clock_value = bt_ctf_event_get_clock_value(event, clock_class);
-       bt_put(clock_class);
+       BT_PUT(clock_class);
        if (!clock_value) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
@@ -650,7 +651,7 @@ int ctf_copy_event_header(FILE *err, struct bt_ctf_event *event,
        }
 
        ret = bt_ctf_clock_value_get_value(clock_value, &value);
-       bt_put(clock_value);
+       BT_PUT(clock_value);
        if (ret) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
@@ -665,15 +666,15 @@ int ctf_copy_event_header(FILE *err, struct bt_ctf_event *event,
        }
 
        writer_clock_value = bt_ctf_clock_value_create(writer_clock_class, value);
-       bt_put(writer_clock_class);
+       BT_PUT(writer_clock_class);
        if (!writer_clock_value) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end;
+               goto error;
        }
 
        ret = bt_ctf_event_set_clock_value(writer_event, writer_clock_value);
-       bt_put(writer_clock_value);
+       BT_PUT(writer_clock_value);
        if (ret) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
@@ -684,12 +685,11 @@ int ctf_copy_event_header(FILE *err, struct bt_ctf_event *event,
        if (!writer_event_header) {
                fprintf(err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
-               ret = -1;
                goto end;
        }
 
        ret = bt_ctf_event_set_header(writer_event, writer_event_header);
-       bt_put(writer_event_header);
+       BT_PUT(writer_event_header);
        if (ret < 0) {
                fprintf(err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
@@ -701,7 +701,6 @@ int ctf_copy_event_header(FILE *err, struct bt_ctf_event *event,
        goto end;
 
 error:
-       BT_PUT(writer_event_header);
        ret = -1;
 end:
        return ret;
@@ -711,8 +710,8 @@ struct bt_ctf_event *ctf_copy_event(FILE *err, struct bt_ctf_event *event,
                struct bt_ctf_event_class *writer_event_class,
                bool override_ts64)
 {
-       struct bt_ctf_event *writer_event;
-       struct bt_ctf_field *field, *copy_field;
+       struct bt_ctf_event *writer_event = NULL;
+       struct bt_ctf_field *field = NULL, *copy_field = NULL;
        int ret;
 
        writer_event = bt_ctf_event_create(writer_event_class);
@@ -724,10 +723,9 @@ struct bt_ctf_event *ctf_copy_event(FILE *err, struct bt_ctf_event *event,
 
        field = bt_ctf_event_get_header(event);
        if (!field) {
-               BT_PUT(writer_event);
                fprintf(err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
-               goto end;
+               goto error;
        }
 
        /*
@@ -737,86 +735,84 @@ struct bt_ctf_event *ctf_copy_event(FILE *err, struct bt_ctf_event *event,
        if (override_ts64) {
                copy_field = bt_ctf_event_get_header(writer_event);
                if (!copy_field) {
-                       BT_PUT(writer_event);
-                       bt_put(field);
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
-                       goto end;
+                       goto error;
                }
 
                ret = copy_override_field(err, event, writer_event, field,
                                copy_field);
-               bt_put(field);
                if (ret) {
-                       BT_PUT(writer_event);
-                       BT_PUT(copy_field);
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
-                       goto end;
+                       goto error;
                }
+               BT_PUT(copy_field);
        } else {
                ret = ctf_copy_event_header(err, event, writer_event_class,
                                writer_event, field);
                if (ret) {
-                       BT_PUT(writer_event);
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
-                       goto end;
+                       goto error;
                }
        }
+       BT_PUT(field);
 
        /* Optional field, so it can fail silently. */
        field = bt_ctf_event_get_stream_event_context(event);
        copy_field = bt_ctf_field_copy(field);
-       bt_put(field);
        if (copy_field) {
                ret = bt_ctf_event_set_stream_event_context(writer_event,
                                copy_field);
-               bt_put(copy_field);
                if (ret < 0) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
                        goto error;
                }
        }
+       BT_PUT(field);
+       BT_PUT(copy_field);
 
        /* Optional field, so it can fail silently. */
        field = bt_ctf_event_get_event_context(event);
        copy_field = bt_ctf_field_copy(field);
-       bt_put(field);
        if (copy_field) {
                ret = bt_ctf_event_set_event_context(writer_event, copy_field);
-               bt_put(copy_field);
                if (ret < 0) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
                        goto error;
                }
        }
+       BT_PUT(field);
+       BT_PUT(copy_field);
 
        field = bt_ctf_event_get_payload_field(event);
        if (!field) {
-               BT_PUT(writer_event);
                fprintf(err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
-               goto end;
+               goto error;
        }
        copy_field = bt_ctf_field_copy(field);
-       bt_put(field);
        if (copy_field) {
                ret = bt_ctf_event_set_payload_field(writer_event, copy_field);
-               bt_put(copy_field);
                if (ret < 0) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
                        goto error;
                }
        }
+       BT_PUT(field);
+       BT_PUT(copy_field);
+
        goto end;
 
 error:
        BT_PUT(writer_event);
 end:
+       bt_put(field);
+       bt_put(copy_field);
        return writer_event;
 }
 
@@ -825,39 +821,39 @@ enum bt_component_status ctf_copy_trace(FILE *err, struct bt_ctf_trace *trace,
 {
        enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
        int field_count, i, int_ret;
-       struct bt_ctf_field_type *header_type;
+       struct bt_ctf_field_type *header_type = NULL;
 
        field_count = bt_ctf_trace_get_environment_field_count(trace);
        for (i = 0; i < field_count; i++) {
                int ret_int;
                const char *name;
-               struct bt_value *value;
+               struct bt_value *value = NULL;
 
                name = bt_ctf_trace_get_environment_field_name(trace, i);
                if (!name) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
                        ret = BT_COMPONENT_STATUS_ERROR;
-                       goto end_put_writer_trace;
+                       goto end;
                }
                value = bt_ctf_trace_get_environment_field_value(trace, i);
                if (!value) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
                        ret = BT_COMPONENT_STATUS_ERROR;
-                       goto end_put_writer_trace;
+                       goto end;
                }
 
                ret_int = bt_ctf_trace_set_environment_field(writer_trace,
                                name, value);
-               bt_put(value);
+               BT_PUT(value);
                if (ret_int < 0) {
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
                        fprintf(err, "[error] Unable to set environment field %s\n",
                                        name);
                        ret = BT_COMPONENT_STATUS_ERROR;
-                       goto end_put_writer_trace;
+                       goto end;
                }
        }
 
@@ -865,19 +861,17 @@ enum bt_component_status ctf_copy_trace(FILE *err, struct bt_ctf_trace *trace,
        if (!header_type) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
                ret = BT_COMPONENT_STATUS_ERROR;
-               goto end_put_writer_trace;
+               goto end;
        }
 
        int_ret = bt_ctf_trace_set_packet_header_type(writer_trace, header_type);
+       BT_PUT(header_type);
        if (int_ret < 0) {
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
                ret = BT_COMPONENT_STATUS_ERROR;
-               goto end_put_header_type;
+               goto end;
        }
 
-end_put_header_type:
-       bt_put(header_type);
-end_put_writer_trace:
+end:
        return ret;
 }
-

diff --git a/plugins/utils/trimmer/copy.c b/plugins/utils/trimmer/copy.c
index a8c5d5cdd9bcd521543d0dc7cecf85c3d88930c2..c485448ec46ffa7e3e209a2266b5ee3f7ebd364e 100644 (file)
--- a/plugins/utils/trimmer/copy.c
+++ b/plugins/utils/trimmer/copy.c
@@ -53,7 +53,7 @@ struct bt_ctf_packet *insert_new_packet(struct trimmer_iterator *trim_it,
                struct bt_ctf_packet *packet,
                struct bt_ctf_stream *stream)
 {
-       struct bt_ctf_packet *writer_packet;
+       struct bt_ctf_packet *writer_packet = NULL;
 
        writer_packet = bt_ctf_packet_create(stream);
        if (!writer_packet) {
@@ -73,131 +73,88 @@ enum bt_component_status update_packet_context_field(FILE *err,
                const char *name, int64_t value)
 {
        enum bt_component_status ret;
-       struct bt_ctf_field *packet_context, *writer_packet_context;
-       struct bt_ctf_field_type *struct_type, *writer_packet_context_type;
-       struct bt_ctf_stream_class *stream_class;
-       struct bt_ctf_stream *stream;
+       struct bt_ctf_field *packet_context = NULL, *writer_packet_context = NULL;
+       struct bt_ctf_field_type *struct_type = NULL, *field_type = NULL;
+       struct bt_ctf_field *field = NULL, *writer_field = NULL;
        int nr_fields, i, int_ret;
 
        packet_context = bt_ctf_packet_get_context(writer_packet);
        if (!packet_context) {
-               ret = BT_COMPONENT_STATUS_ERROR;
-               fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-                               __LINE__);
-               goto end;
-       }
-
-       stream = bt_ctf_packet_get_stream(writer_packet);
-       if (!stream) {
-               ret = BT_COMPONENT_STATUS_ERROR;
-               fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-                               __LINE__);
-               goto end_put_packet_context;
-       }
-
-       stream_class = bt_ctf_stream_get_class(stream);
-       if (!stream_class) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_stream;
-       }
-
-       writer_packet_context_type = bt_ctf_stream_class_get_packet_context_type(
-                       stream_class);
-       if (!writer_packet_context_type) {
-               ret = BT_COMPONENT_STATUS_ERROR;
-               fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
-                               __LINE__);
-               goto end_put_stream_class;
+               goto error;
        }
 
        struct_type = bt_ctf_field_get_type(packet_context);
        if (!struct_type) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_writer_packet_context_type;
+               goto error;
        }
 
        writer_packet_context = bt_ctf_packet_get_context(writer_packet);
        if (!writer_packet_context) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_struct_type;
+               goto error;
        }
 
        nr_fields = bt_ctf_field_type_structure_get_field_count(struct_type);
        for (i = 0; i < nr_fields; i++) {
-               struct bt_ctf_field *field, *writer_field;
-               struct bt_ctf_field_type *field_type;
                const char *field_name;
 
                field = bt_ctf_field_structure_get_field_by_index(
                                packet_context, i);
                if (!field) {
-                       ret = BT_COMPONENT_STATUS_ERROR;
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
-                       goto end_put_writer_packet_context;
+                       goto error;
                }
                if (bt_ctf_field_type_structure_get_field(struct_type,
                                        &field_name, &field_type, i) < 0) {
-                       ret = BT_COMPONENT_STATUS_ERROR;
-                       bt_put(field);
                        fprintf(err, "[error] %s in %s:%d\n", __func__,
                                        __FILE__, __LINE__);
-                       goto end_put_writer_packet_context;
+                       goto error;
                }
                if (strcmp(field_name, name)) {
-                       bt_put(field_type);
-                       bt_put(field);
+                       BT_PUT(field_type);
+                       BT_PUT(field);
                        continue;
                }
                if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_TYPE_ID_INTEGER) {
                        fprintf(err, "[error] Unexpected packet context field type\n");
-                       bt_put(field);
-                       ret = BT_COMPONENT_STATUS_ERROR;
-                       goto end_put_writer_packet_context;
+                       goto error;
                }
                writer_field = bt_ctf_field_structure_get_field(writer_packet_context,
                                field_name);
                if (!writer_field) {
-                       ret = BT_COMPONENT_STATUS_ERROR;
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
-                       goto end;
+                       goto error;
                }
 
                int_ret = bt_ctf_field_unsigned_integer_set_value(writer_field, value);
-               bt_put(writer_field);
                if (int_ret < 0) {
-                       ret = BT_COMPONENT_STATUS_ERROR;
                        fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
                                        __LINE__);
-                       goto end_put_writer_packet_context;
+                       goto error;
                }
-
-               bt_put(field_type);
-               bt_put(field);
+               BT_PUT(writer_field);
+               BT_PUT(field_type);
+               BT_PUT(field);
        }
 
        ret = BT_COMPONENT_STATUS_OK;
+       goto end;
 
-end_put_writer_packet_context:
-       bt_put(writer_packet_context);
-end_put_struct_type:
+error:
+       bt_put(writer_field);
+       bt_put(field_type);
+       bt_put(field);
+       ret = BT_COMPONENT_STATUS_ERROR;
+end:
        bt_put(struct_type);
-end_put_writer_packet_context_type:
-       bt_put(writer_packet_context_type);
-end_put_stream_class:
-       bt_put(stream_class);
-end_put_packet_context:
        bt_put(packet_context);
-end_put_stream:
-       bt_put(stream);
-end:
        return ret;
 }
 
@@ -206,8 +163,8 @@ struct bt_ctf_packet *trimmer_new_packet(
                struct trimmer_iterator *trim_it,
                struct bt_ctf_packet *packet)
 {
-       struct bt_ctf_stream *stream;
-       struct bt_ctf_field *writer_packet_context;
+       struct bt_ctf_stream *stream = NULL;
+       struct bt_ctf_field *writer_packet_context = NULL;
        struct bt_ctf_packet *writer_packet = NULL;
        int int_ret;
 
@@ -215,7 +172,7 @@ struct bt_ctf_packet *trimmer_new_packet(
        if (!stream) {
                fprintf(trim_it->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end;
+               goto error;
        }
 
        /*
@@ -225,39 +182,39 @@ struct bt_ctf_packet *trimmer_new_packet(
        writer_packet = lookup_packet(trim_it, packet);
        if (writer_packet) {
                g_hash_table_remove(trim_it->packet_map, packet);
-               bt_put(writer_packet);
+               BT_PUT(writer_packet);
        }
 
        writer_packet = insert_new_packet(trim_it, packet, stream);
        if (!writer_packet) {
                fprintf(trim_it->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end_put_stream;
+               goto error;
        }
        bt_get(writer_packet);
 
        writer_packet_context = ctf_copy_packet_context(trim_it->err, packet,
                        stream);
        if (!writer_packet_context) {
-               BT_PUT(writer_packet);
                fprintf(trim_it->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end_put_stream;
+               goto error;
        }
 
        int_ret = bt_ctf_packet_set_context(writer_packet, writer_packet_context);
        if (int_ret) {
-               BT_PUT(writer_packet);
                fprintf(trim_it->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end_put_writer_packet_context;
+               goto error;
        }
 
-end_put_writer_packet_context:
+       goto end;
+
+error:
+       BT_PUT(writer_packet);
+end:
        bt_put(writer_packet_context);
-end_put_stream:
        bt_put(stream);
-end:
        return writer_packet;
 }
 
@@ -266,7 +223,7 @@ struct bt_ctf_packet *trimmer_close_packet(
                struct trimmer_iterator *trim_it,
                struct bt_ctf_packet *packet)
 {
-       struct bt_ctf_packet *writer_packet;
+       struct bt_ctf_packet *writer_packet = NULL;
 
        writer_packet = lookup_packet(trim_it, packet);
        if (!writer_packet) {
@@ -286,11 +243,9 @@ struct bt_ctf_event *trimmer_output_event(
                struct trimmer_iterator *trim_it,
                struct bt_ctf_event *event)
 {
-       struct bt_ctf_event_class *event_class;
-       struct bt_ctf_stream *stream;
-       struct bt_ctf_stream_class *stream_class;
+       struct bt_ctf_event_class *event_class = NULL;
        struct bt_ctf_event *writer_event = NULL;
-       struct bt_ctf_packet *packet, *writer_packet;
+       struct bt_ctf_packet *packet = NULL, *writer_packet = NULL;
        const char *event_name;
        int int_ret;
 
@@ -298,28 +253,14 @@ struct bt_ctf_event *trimmer_output_event(
        if (!event_class) {
                fprintf(trim_it->err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
-               goto end;
+               goto error;
        }
 
        event_name = bt_ctf_event_class_get_name(event_class);
        if (!event_name) {
                fprintf(trim_it->err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
-               goto end_put_event_class;
-       }
-
-       stream = bt_ctf_event_get_stream(event);
-       if (!stream) {
-               fprintf(trim_it->err, "[error] %s in %s:%d\n", __func__,
-                               __FILE__, __LINE__);
-               goto end_put_event_class;
-       }
-
-       stream_class = bt_ctf_event_class_get_stream_class(event_class);
-       if (!stream_class) {
-               fprintf(trim_it->err, "[error] %s in %s:%d\n", __func__,
-                               __FILE__, __LINE__);
-               goto end_put_stream;
+               goto error;
        }
 
        writer_event = ctf_copy_event(trim_it->err, event, event_class, false);
@@ -328,48 +269,41 @@ struct bt_ctf_event *trimmer_output_event(
                                __FILE__, __LINE__);
                fprintf(trim_it->err, "[error] Failed to copy event %s\n",
                                bt_ctf_event_class_get_name(event_class));
-               goto end_put_stream_class;
+               goto error;
        }
 
        packet = bt_ctf_event_get_packet(event);
        if (!packet) {
-               BT_PUT(writer_event);
                fprintf(trim_it->err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
-               goto end_put_stream_class;
+               goto error;
        }
 
        writer_packet = lookup_packet(trim_it, packet);
        if (!writer_packet) {
-               BT_PUT(writer_event);
                fprintf(trim_it->err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
-               goto end_put_packet;
+               goto error;
        }
        bt_get(writer_packet);
 
        int_ret = bt_ctf_event_set_packet(writer_event, writer_packet);
        if (int_ret < 0) {
-               BT_PUT(writer_event);
                fprintf(trim_it->err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
                fprintf(trim_it->err, "[error] Failed to append event %s\n",
                                bt_ctf_event_class_get_name(event_class));
-               goto end_put_writer_packet;
+               goto error;
        }
 
-       /* We keep the reference on the writer event */
+       /* We keep the reference on the writer_event to create a notification. */
+       goto end;
 
-end_put_writer_packet:
+error:
+       BT_PUT(writer_event);
+end:
        bt_put(writer_packet);
-end_put_packet:
        bt_put(packet);
-end_put_stream_class:
-       bt_put(stream_class);
-end_put_stream:
-       bt_put(stream);
-end_put_event_class:
        bt_put(event_class);
-end:
        return writer_event;
 }

diff --git a/plugins/writer/write.c b/plugins/writer/write.c
index 5f65ddcb40c333c8a1adff18b40ea7c93097d00f..cd692db2aa0edccc10446041ebf1e0e6bc2bdf30 100644 (file)
--- a/plugins/writer/write.c
+++ b/plugins/writer/write.c
@@ -47,7 +47,7 @@ struct bt_ctf_stream_class *insert_new_stream_class(
                struct bt_ctf_stream_class *stream_class)
 {
        struct bt_ctf_stream_class *writer_stream_class = NULL;
-       struct bt_ctf_trace *trace, *writer_trace;
+       struct bt_ctf_trace *trace = NULL, *writer_trace = NULL;
        enum bt_component_status ret;
 
        trace = bt_ctf_stream_class_get_trace(stream_class);
@@ -55,27 +55,24 @@ struct bt_ctf_stream_class *insert_new_stream_class(
                fprintf(writer_component->err,
                                "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end;
+               goto error;
        }
 
        writer_trace = bt_ctf_writer_get_trace(ctf_writer);
        if (!writer_trace) {
-               bt_put(trace);
                fprintf(writer_component->err,
                                "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               ret = BT_COMPONENT_STATUS_ERROR;
-               goto end_put_trace;
+               goto error;
        }
 
        ret = ctf_copy_clock_classes(writer_component->err, writer_trace,
                        writer_stream_class, trace);
        if (ret != BT_COMPONENT_STATUS_OK) {
-               bt_put(trace);
                fprintf(writer_component->err,
                                "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end_put_writer_trace;
+               goto error;
        }
 
        writer_stream_class = ctf_copy_stream_class(writer_component->err,
@@ -84,17 +81,19 @@ struct bt_ctf_stream_class *insert_new_stream_class(
                fprintf(writer_component->err, "[error] Failed to copy stream class\n");
                fprintf(writer_component->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end_put_writer_trace;
+               goto error;
        }
 
        g_hash_table_insert(writer_component->stream_class_map,
                        (gpointer) stream_class, writer_stream_class);
 
-end_put_writer_trace:
+       goto end;
+
+error:
+       BT_PUT(writer_stream_class);
+end:
        bt_put(writer_trace);
-end_put_trace:
        bt_put(trace);
-end:
        return writer_stream_class;
 }
 
@@ -105,46 +104,40 @@ struct bt_ctf_stream *insert_new_stream(
                struct bt_ctf_stream_class *stream_class,
                struct bt_ctf_stream *stream)
 {
-       struct bt_ctf_stream *writer_stream;
-       struct bt_ctf_stream_class *writer_stream_class;
+       struct bt_ctf_stream *writer_stream = NULL;
+       struct bt_ctf_stream_class *writer_stream_class = NULL;
 
        writer_stream_class = g_hash_table_lookup(
                        writer_component->stream_class_map,
                        (gpointer) stream_class);
-       if (writer_stream_class) {
-               if (!bt_get(writer_stream_class)) {
-                       writer_stream = NULL;
-                       fprintf(writer_component->err, "[error] %s in %s:%d\n",
-                                       __func__, __FILE__, __LINE__);
-                       goto end;
-               }
-       } else {
+       if (!writer_stream_class) {
                writer_stream_class = insert_new_stream_class(
                                writer_component, ctf_writer, stream_class);
                if (!writer_stream_class) {
-                       writer_stream = NULL;
                        fprintf(writer_component->err, "[error] %s in %s:%d\n",
                                        __func__, __FILE__, __LINE__);
-                       goto end_put;
+                       goto error;
                }
        }
+       bt_get(writer_stream_class);
 
        writer_stream = bt_ctf_writer_create_stream(ctf_writer,
                        writer_stream_class);
        if (!writer_stream) {
                fprintf(writer_component->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end_put;
+               goto error;
        }
 
        g_hash_table_insert(writer_component->stream_map, (gpointer) stream,
                        writer_stream);
 
-       bt_ctf_writer_flush_metadata(ctf_writer);
+       goto end;
 
-end_put:
-       bt_put(writer_stream_class);
+error:
+       BT_PUT(writer_stream);
 end:
+       bt_put(writer_stream_class);
        return writer_stream;
 }
 
@@ -170,11 +163,12 @@ struct bt_ctf_writer *insert_new_writer(
                struct writer_component *writer_component,
                struct bt_ctf_trace *trace)
 {
-       struct bt_ctf_writer *ctf_writer;
-       struct bt_ctf_trace *writer_trace;
+       struct bt_ctf_writer *ctf_writer = NULL;
+       struct bt_ctf_trace *writer_trace = NULL;
        char trace_name[PATH_MAX];
        enum bt_component_status ret;
 
+       /* FIXME: replace with trace name when it will work. */
        snprintf(trace_name, PATH_MAX, "%s/%s_%03d",
                        writer_component->base_path->str,
                        writer_component->trace_name_base->str,
@@ -185,20 +179,18 @@ struct bt_ctf_writer *insert_new_writer(
        if (!ctf_writer) {
                fprintf(writer_component->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end;
+               goto error;
        }
 
        writer_trace = bt_ctf_writer_get_trace(ctf_writer);
        if (!writer_trace) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err,
                                "[error] %s in %s:%d\n", __func__, __FILE__,
                                __LINE__);
-               goto end;
+               goto error;
        }
 
        ret = ctf_copy_trace(writer_component->err, trace, writer_trace);
-       bt_put(writer_trace);
        if (ret != BT_COMPONENT_STATUS_OK) {
                fprintf(writer_component->err, "[error] Failed to copy trace\n");
                fprintf(writer_component->err, "[error] %s in %s:%d\n",
@@ -206,10 +198,16 @@ struct bt_ctf_writer *insert_new_writer(
                BT_PUT(ctf_writer);
                goto end;
        }
+       BT_PUT(writer_trace);
 
        g_hash_table_insert(writer_component->trace_map, (gpointer) trace,
                        ctf_writer);
 
+       goto end;
+
+error:
+       bt_put(writer_trace);
+       BT_PUT(ctf_writer);
 end:
        return ctf_writer;
 }
@@ -218,31 +216,28 @@ static
 struct bt_ctf_writer *get_writer(struct writer_component *writer_component,
                struct bt_ctf_stream_class *stream_class)
 {
-       struct bt_ctf_trace *trace;
-       struct bt_ctf_writer *ctf_writer;
+       struct bt_ctf_trace *trace = NULL;
+       struct bt_ctf_writer *ctf_writer = NULL;
 
        trace = bt_ctf_stream_class_get_trace(stream_class);
        if (!trace) {
                ctf_writer = NULL;
                fprintf(writer_component->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end;
+               goto error;
        }
 
        ctf_writer = g_hash_table_lookup(writer_component->trace_map,
                        (gpointer) trace);
-       if (ctf_writer) {
-               if (!bt_get(ctf_writer)) {
-                       ctf_writer = NULL;
-                       fprintf(writer_component->err, "[error] %s in %s:%d\n",
-                                       __func__, __FILE__, __LINE__);
-                       goto end;
-               }
-       } else {
+       if (!ctf_writer) {
                ctf_writer = insert_new_writer(writer_component, trace);
        }
-       bt_put(trace);
+       bt_get(ctf_writer);
+       BT_PUT(trace);
+       goto end;
 
+error:
+       BT_PUT(ctf_writer);
 end:
        return ctf_writer;
 }
@@ -252,45 +247,38 @@ struct bt_ctf_stream *get_writer_stream(
                struct writer_component *writer_component,
                struct bt_ctf_packet *packet, struct bt_ctf_stream *stream)
 {
-       struct bt_ctf_stream_class *stream_class;
-       struct bt_ctf_writer *ctf_writer;
-       struct bt_ctf_stream *writer_stream;
+       struct bt_ctf_stream_class *stream_class = NULL;
+       struct bt_ctf_writer *ctf_writer = NULL;
+       struct bt_ctf_stream *writer_stream = NULL;
 
        stream_class = bt_ctf_stream_get_class(stream);
        if (!stream_class) {
-               writer_stream = NULL;
                fprintf(writer_component->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end;
+               goto error;
        }
 
        ctf_writer = get_writer(writer_component, stream_class);
        if (!ctf_writer) {
-               writer_stream = NULL;
                fprintf(writer_component->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end_put_stream_class;
+               goto error;
        }
 
        writer_stream = lookup_stream(writer_component, stream);
-
-       if (writer_stream) {
-               if (!bt_get(writer_stream)) {
-                       writer_stream = NULL;
-                       fprintf(writer_component->err, "[error] %s in %s:%d\n",
-                                       __func__, __FILE__, __LINE__);
-                       goto end_put_stream_class;
-               }
-       } else {
+       if (!writer_stream) {
                writer_stream = insert_new_stream(writer_component, ctf_writer,
                                stream_class, stream);
-               bt_get(writer_stream);
        }
+       bt_get(writer_stream);
+
+       goto end;
 
+error:
+       BT_PUT(writer_stream);
+end:
        bt_put(ctf_writer);
-end_put_stream_class:
        bt_put(stream_class);
-end:
        return writer_stream;
 }
 
@@ -299,52 +287,52 @@ enum bt_component_status writer_new_packet(
                struct writer_component *writer_component,
                struct bt_ctf_packet *packet)
 {
-       struct bt_ctf_stream *stream, *writer_stream;
-       struct bt_ctf_field *writer_packet_context;
+       struct bt_ctf_stream *stream = NULL, *writer_stream = NULL;
+       struct bt_ctf_field *writer_packet_context = NULL;
        enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
        int int_ret;
 
        stream = bt_ctf_packet_get_stream(packet);
        if (!stream) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end;
+               goto error;
        }
 
        writer_stream = get_writer_stream(writer_component, packet, stream);
        if (!writer_stream) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end_put;
+               goto error;
        }
+       BT_PUT(stream);
 
        writer_packet_context = ctf_copy_packet_context(writer_component->err,
                        packet, writer_stream);
        if (!writer_packet_context) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end_put;
+               goto error;
        }
 
        int_ret = bt_ctf_stream_set_packet_context(writer_stream,
                        writer_packet_context);
        if (int_ret < 0) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
-               goto end_put_writer_packet_context;
+               goto error;
        }
+       BT_PUT(writer_stream);
+       BT_PUT(writer_packet_context);
 
-       bt_put(writer_stream);
+       goto end;
 
-end_put_writer_packet_context:
+error:
+       ret = BT_COMPONENT_STATUS_ERROR;
+end:
+       bt_put(writer_stream);
        bt_put(writer_packet_context);
-end_put:
        bt_put(stream);
-end:
        return ret;
 }
 
@@ -353,48 +341,42 @@ enum bt_component_status writer_close_packet(
                struct writer_component *writer_component,
                struct bt_ctf_packet *packet)
 {
-       struct bt_ctf_stream *stream, *writer_stream;
+       struct bt_ctf_stream *stream = NULL, *writer_stream = NULL;
        enum bt_component_status ret;
 
        stream = bt_ctf_packet_get_stream(packet);
        if (!stream) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end;
+               goto error;
        }
 
        writer_stream = lookup_stream(writer_component, stream);
        if (!writer_stream) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err, "[error] %s in %s:%d\n",
                                __func__, __FILE__, __LINE__);
-               goto end_put;
+               goto error;
        }
+       BT_PUT(stream);
 
-       if (!bt_get(writer_stream)) {
-               fprintf(writer_component->err,
-                               "[error] Failed to get reference on writer stream\n");
-               fprintf(writer_component->err, "[error] %s in %s:%d\n",
-                               __func__, __FILE__, __LINE__);
-               ret = BT_COMPONENT_STATUS_ERROR;
-               goto end_put;
-       }
+       bt_get(writer_stream);
 
        ret = bt_ctf_stream_flush(writer_stream);
        if (ret < 0) {
                fprintf(writer_component->err,
                                "[error] Failed to flush packet\n");
-               ret = BT_COMPONENT_STATUS_ERROR;
+               goto error;
        }
+       BT_PUT(writer_stream);
 
        ret = BT_COMPONENT_STATUS_OK;
+       goto end;
 
+error:
+       ret = BT_COMPONENT_STATUS_ERROR;
+end:
        bt_put(writer_stream);
-
-end_put:
        bt_put(stream);
-end:
        return ret;
 }
 
@@ -404,61 +386,55 @@ enum bt_component_status writer_output_event(
                struct bt_ctf_event *event)
 {
        enum bt_component_status ret;
-       struct bt_ctf_event_class *event_class, *writer_event_class;
-       struct bt_ctf_stream *stream, *writer_stream;
-       struct bt_ctf_stream_class *stream_class, *writer_stream_class;
-       struct bt_ctf_event *writer_event;
+       struct bt_ctf_event_class *event_class = NULL, *writer_event_class = NULL;
+       struct bt_ctf_stream *stream = NULL, *writer_stream = NULL;
+       struct bt_ctf_stream_class *stream_class = NULL, *writer_stream_class = NULL;
+       struct bt_ctf_event *writer_event = NULL;
        const char *event_name;
        int int_ret;
 
        event_class = bt_ctf_event_get_class(event);
        if (!event_class) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
-               goto end;
+               goto error;
        }
 
        event_name = bt_ctf_event_class_get_name(event_class);
        if (!event_name) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
-               goto end_put_event_class;
+               goto error;
        }
 
        stream = bt_ctf_event_get_stream(event);
        if (!stream) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
-               goto end_put_event_class;
+               goto error;
        }
 
        writer_stream = lookup_stream(writer_component, stream);
        if (!writer_stream || !bt_get(writer_stream)) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
-               goto end_put_stream;
+               goto error;
        }
 
        stream_class = bt_ctf_event_class_get_stream_class(event_class);
        if (!stream_class) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
-               goto end_put_writer_stream;
+               goto error;
        }
 
        writer_stream_class = g_hash_table_lookup(
                        writer_component->stream_class_map,
                        (gpointer) stream_class);
        if (!writer_stream_class || !bt_get(writer_stream_class)) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
-               goto end_put_stream_class;
+               goto error;
        }
 
        writer_event_class = get_event_class(writer_component,
@@ -467,58 +443,50 @@ enum bt_component_status writer_output_event(
                writer_event_class = ctf_copy_event_class(writer_component->err,
                                event_class);
                if (!writer_event_class) {
-                       ret = BT_COMPONENT_STATUS_ERROR;
                        fprintf(writer_component->err, "[error] %s in %s:%d\n",
                                        __func__, __FILE__, __LINE__);
-                       goto end_put_writer_stream_class;
+                       goto error;
                }
                int_ret = bt_ctf_stream_class_add_event_class(
                                writer_stream_class, writer_event_class);
                if (int_ret) {
-                       ret = BT_COMPONENT_STATUS_ERROR;
                        fprintf(writer_component->err, "[error] %s in %s:%d\n",
                                        __func__, __FILE__, __LINE__);
-                       goto end_put_writer_stream_class;
+                       goto error;
                }
        }
 
        writer_event = ctf_copy_event(writer_component->err, event,
                        writer_event_class, true);
        if (!writer_event) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
                fprintf(writer_component->err, "[error] Failed to copy event %s\n",
                                bt_ctf_event_class_get_name(writer_event_class));
-               goto end_put_writer_event_class;
+               goto error;
        }
 
        int_ret = bt_ctf_stream_append_event(writer_stream, writer_event);
        if (int_ret < 0) {
-               ret = BT_COMPONENT_STATUS_ERROR;
                fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
                                __FILE__, __LINE__);
                fprintf(writer_component->err, "[error] Failed to append event %s\n",
                                bt_ctf_event_class_get_name(writer_event_class));
-               goto end_put_writer_event;
+               goto error;
        }
 
        ret = BT_COMPONENT_STATUS_OK;
+       goto end;
 
-end_put_writer_event:
+error:
+       ret = BT_COMPONENT_STATUS_ERROR;
+end:
        bt_put(writer_event);
-end_put_writer_event_class:
        bt_put(writer_event_class);
-end_put_writer_stream_class:
        bt_put(writer_stream_class);
-end_put_stream_class:
        bt_put(stream_class);
-end_put_writer_stream:
        bt_put(writer_stream);
-end_put_stream:
        bt_put(stream);
-end_put_event_class:
        bt_put(event_class);
-end:
        return ret;
 }

diff --git a/plugins/writer/writer.c b/plugins/writer/writer.c
index f0aa8badf371603df8d30e225eacb03bfcb36161..3d99a086df5befae20521a4d804afa1a4be06945 100644 (file)
--- a/plugins/writer/writer.c
+++ b/plugins/writer/writer.c
@@ -69,7 +69,7 @@ void finalize_writer_component(struct bt_private_component *component)
 static
 void unref_stream_class(struct bt_ctf_stream_class *writer_stream_class)
 {
-       return;
+       bt_put(writer_stream_class);
 }
 
 static
@@ -81,7 +81,7 @@ void unref_stream(struct bt_ctf_stream_class *writer_stream)
 static
 void unref_trace(struct bt_ctf_writer *writer)
 {
-       return;
+       bt_put(writer);
 }
 
 static