#include <babeltrace/ctf-writer/event-fields.h>
#include <babeltrace/ctf-ir/event-fields-internal.h>
#include <babeltrace/ctf-ir/event-types-internal.h>
+#include <babeltrace/object-internal.h>
+#include <babeltrace/ref.h>
#include <babeltrace/compiler.h>
+#include <babeltrace/compat/fcntl.h>
#define PACKET_LEN_INCREMENT (getpagesize() * 8 * CHAR_BIT)
struct bt_ctf_field *bt_ctf_field_string_create(struct bt_ctf_field_type *);
static
-void bt_ctf_field_destroy(struct bt_ctf_ref *);
+void bt_ctf_field_destroy(struct bt_object *);
static
void bt_ctf_field_integer_destroy(struct bt_ctf_field *);
static
static
struct bt_ctf_field *(* const field_create_funcs[])(
struct bt_ctf_field_type *) = {
- [CTF_TYPE_INTEGER] = bt_ctf_field_integer_create,
- [CTF_TYPE_ENUM] = bt_ctf_field_enumeration_create,
- [CTF_TYPE_FLOAT] =
+ [BT_CTF_TYPE_ID_INTEGER] = bt_ctf_field_integer_create,
+ [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_create,
+ [BT_CTF_TYPE_ID_FLOAT] =
bt_ctf_field_floating_point_create,
- [CTF_TYPE_STRUCT] = bt_ctf_field_structure_create,
- [CTF_TYPE_VARIANT] = bt_ctf_field_variant_create,
- [CTF_TYPE_ARRAY] = bt_ctf_field_array_create,
- [CTF_TYPE_SEQUENCE] = bt_ctf_field_sequence_create,
- [CTF_TYPE_STRING] = bt_ctf_field_string_create,
+ [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_create,
+ [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_create,
+ [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_create,
+ [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_create,
+ [BT_CTF_TYPE_ID_STRING] = bt_ctf_field_string_create,
};
static
void (* const field_destroy_funcs[])(struct bt_ctf_field *) = {
- [CTF_TYPE_INTEGER] = bt_ctf_field_integer_destroy,
- [CTF_TYPE_ENUM] = bt_ctf_field_enumeration_destroy,
- [CTF_TYPE_FLOAT] =
+ [BT_CTF_TYPE_ID_INTEGER] = bt_ctf_field_integer_destroy,
+ [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_destroy,
+ [BT_CTF_TYPE_ID_FLOAT] =
bt_ctf_field_floating_point_destroy,
- [CTF_TYPE_STRUCT] = bt_ctf_field_structure_destroy,
- [CTF_TYPE_VARIANT] = bt_ctf_field_variant_destroy,
- [CTF_TYPE_ARRAY] = bt_ctf_field_array_destroy,
- [CTF_TYPE_SEQUENCE] = bt_ctf_field_sequence_destroy,
- [CTF_TYPE_STRING] = bt_ctf_field_string_destroy,
+ [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_destroy,
+ [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_destroy,
+ [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_destroy,
+ [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_destroy,
+ [BT_CTF_TYPE_ID_STRING] = bt_ctf_field_string_destroy,
};
static
int (* const field_validate_funcs[])(struct bt_ctf_field *) = {
- [CTF_TYPE_INTEGER] = bt_ctf_field_generic_validate,
- [CTF_TYPE_ENUM] = bt_ctf_field_enumeration_validate,
- [CTF_TYPE_FLOAT] = bt_ctf_field_generic_validate,
- [CTF_TYPE_STRUCT] = bt_ctf_field_structure_validate,
- [CTF_TYPE_VARIANT] = bt_ctf_field_variant_validate,
- [CTF_TYPE_ARRAY] = bt_ctf_field_array_validate,
- [CTF_TYPE_SEQUENCE] = bt_ctf_field_sequence_validate,
- [CTF_TYPE_STRING] = bt_ctf_field_generic_validate,
+ [BT_CTF_TYPE_ID_INTEGER] = bt_ctf_field_generic_validate,
+ [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_validate,
+ [BT_CTF_TYPE_ID_FLOAT] = bt_ctf_field_generic_validate,
+ [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_validate,
+ [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_validate,
+ [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_validate,
+ [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_validate,
+ [BT_CTF_TYPE_ID_STRING] = bt_ctf_field_generic_validate,
};
static
int (* const field_reset_funcs[])(struct bt_ctf_field *) = {
- [CTF_TYPE_INTEGER] = bt_ctf_field_generic_reset,
- [CTF_TYPE_ENUM] = bt_ctf_field_enumeration_reset,
- [CTF_TYPE_FLOAT] = bt_ctf_field_generic_reset,
- [CTF_TYPE_STRUCT] = bt_ctf_field_structure_reset,
- [CTF_TYPE_VARIANT] = bt_ctf_field_variant_reset,
- [CTF_TYPE_ARRAY] = bt_ctf_field_array_reset,
- [CTF_TYPE_SEQUENCE] = bt_ctf_field_sequence_reset,
- [CTF_TYPE_STRING] = bt_ctf_field_string_reset,
+ [BT_CTF_TYPE_ID_INTEGER] = bt_ctf_field_generic_reset,
+ [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_reset,
+ [BT_CTF_TYPE_ID_FLOAT] = bt_ctf_field_generic_reset,
+ [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_reset,
+ [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_reset,
+ [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_reset,
+ [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_reset,
+ [BT_CTF_TYPE_ID_STRING] = bt_ctf_field_string_reset,
};
static
int (* const field_serialize_funcs[])(struct bt_ctf_field *,
struct ctf_stream_pos *) = {
- [CTF_TYPE_INTEGER] = bt_ctf_field_integer_serialize,
- [CTF_TYPE_ENUM] = bt_ctf_field_enumeration_serialize,
- [CTF_TYPE_FLOAT] =
+ [BT_CTF_TYPE_ID_INTEGER] = bt_ctf_field_integer_serialize,
+ [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_serialize,
+ [BT_CTF_TYPE_ID_FLOAT] =
bt_ctf_field_floating_point_serialize,
- [CTF_TYPE_STRUCT] = bt_ctf_field_structure_serialize,
- [CTF_TYPE_VARIANT] = bt_ctf_field_variant_serialize,
- [CTF_TYPE_ARRAY] = bt_ctf_field_array_serialize,
- [CTF_TYPE_SEQUENCE] = bt_ctf_field_sequence_serialize,
- [CTF_TYPE_STRING] = bt_ctf_field_string_serialize,
+ [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_serialize,
+ [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_serialize,
+ [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_serialize,
+ [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_serialize,
+ [BT_CTF_TYPE_ID_STRING] = bt_ctf_field_string_serialize,
};
static
int (* const field_copy_funcs[])(struct bt_ctf_field *,
struct bt_ctf_field *) = {
- [CTF_TYPE_INTEGER] = bt_ctf_field_integer_copy,
- [CTF_TYPE_ENUM] = bt_ctf_field_enumeration_copy,
- [CTF_TYPE_FLOAT] = bt_ctf_field_floating_point_copy,
- [CTF_TYPE_STRUCT] = bt_ctf_field_structure_copy,
- [CTF_TYPE_VARIANT] = bt_ctf_field_variant_copy,
- [CTF_TYPE_ARRAY] = bt_ctf_field_array_copy,
- [CTF_TYPE_SEQUENCE] = bt_ctf_field_sequence_copy,
- [CTF_TYPE_STRING] = bt_ctf_field_string_copy,
+ [BT_CTF_TYPE_ID_INTEGER] = bt_ctf_field_integer_copy,
+ [BT_CTF_TYPE_ID_ENUM] = bt_ctf_field_enumeration_copy,
+ [BT_CTF_TYPE_ID_FLOAT] = bt_ctf_field_floating_point_copy,
+ [BT_CTF_TYPE_ID_STRUCT] = bt_ctf_field_structure_copy,
+ [BT_CTF_TYPE_ID_VARIANT] = bt_ctf_field_variant_copy,
+ [BT_CTF_TYPE_ID_ARRAY] = bt_ctf_field_array_copy,
+ [BT_CTF_TYPE_ID_SEQUENCE] = bt_ctf_field_sequence_copy,
+ [BT_CTF_TYPE_ID_STRING] = bt_ctf_field_string_copy,
};
struct bt_ctf_field *bt_ctf_field_create(struct bt_ctf_field_type *type)
{
struct bt_ctf_field *field = NULL;
- enum ctf_type_id type_id;
+ enum bt_ctf_type_id type_id;
+ int ret;
if (!type) {
goto error;
}
type_id = bt_ctf_field_type_get_type_id(type);
- if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES ||
- bt_ctf_field_type_validate(type)) {
+ if (type_id <= BT_CTF_TYPE_ID_UNKNOWN ||
+ type_id >= BT_CTF_NR_TYPE_IDS) {
+ goto error;
+ }
+
+ /* Field class MUST be valid */
+ ret = bt_ctf_field_type_validate(type);
+
+ if (ret) {
+ /* Invalid */
goto error;
}
/* The type's declaration can't change after this point */
bt_ctf_field_type_freeze(type);
- bt_ctf_field_type_get(type);
- bt_ctf_ref_init(&field->ref_count);
+ bt_get(type);
+ bt_object_init(field, bt_ctf_field_destroy);
field->type = type;
error:
return field;
void bt_ctf_field_get(struct bt_ctf_field *field)
{
- if (field) {
- bt_ctf_ref_get(&field->ref_count);
- }
+ bt_get(field);
}
void bt_ctf_field_put(struct bt_ctf_field *field)
{
- if (field) {
- bt_ctf_ref_put(&field->ref_count, bt_ctf_field_destroy);
- }
+ bt_put(field);
}
struct bt_ctf_field_type *bt_ctf_field_get_type(struct bt_ctf_field *field)
}
ret = field->type;
- bt_ctf_field_type_get(ret);
+ bt_get(ret);
end:
return ret;
}
+enum bt_ctf_type_id bt_ctf_field_get_type_id(struct bt_ctf_field *field)
+{
+ enum bt_ctf_type_id ret = BT_CTF_TYPE_ID_UNKNOWN;
+
+ if (!field) {
+ goto end;
+ }
+
+ ret = bt_ctf_field_type_get_type_id(field->type);
+end:
+ return ret;
+}
+
+int bt_ctf_field_is_integer(struct bt_ctf_field *field)
+{
+ return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_INTEGER;
+}
+
+int bt_ctf_field_is_floating_point(struct bt_ctf_field *field)
+{
+ return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_FLOAT;
+}
+
+int bt_ctf_field_is_enumeration(struct bt_ctf_field *field)
+{
+ return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_ENUM;
+}
+
+int bt_ctf_field_is_string(struct bt_ctf_field *field)
+{
+ return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_STRING;
+}
+
+int bt_ctf_field_is_structure(struct bt_ctf_field *field)
+{
+ return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_STRUCT;
+}
+
+int bt_ctf_field_is_array(struct bt_ctf_field *field)
+{
+ return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_ARRAY;
+}
+
+int bt_ctf_field_is_sequence(struct bt_ctf_field *field)
+{
+ return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_SEQUENCE;
+}
+
+int bt_ctf_field_is_variant(struct bt_ctf_field *field)
+{
+ return bt_ctf_field_get_type_id(field) == BT_CTF_TYPE_ID_VARIANT;
+}
+
struct bt_ctf_field *bt_ctf_field_sequence_get_length(
struct bt_ctf_field *field)
{
}
if (bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_SEQUENCE) {
+ BT_CTF_TYPE_ID_SEQUENCE) {
goto end;
}
sequence = container_of(field, struct bt_ctf_field_sequence, parent);
ret = sequence->length;
- bt_ctf_field_get(ret);
+ bt_get(ret);
end:
return ret;
}
goto end;
}
if (bt_ctf_field_type_get_type_id(length_field->type) !=
- CTF_TYPE_INTEGER) {
+ BT_CTF_TYPE_ID_INTEGER) {
ret = -1;
goto end;
}
sequence = container_of(field, struct bt_ctf_field_sequence, parent);
if (sequence->elements) {
g_ptr_array_free(sequence->elements, TRUE);
- bt_ctf_field_put(sequence->length);
+ bt_put(sequence->length);
}
sequence->elements = g_ptr_array_sized_new((size_t)sequence_length);
}
g_ptr_array_set_free_func(sequence->elements,
- (GDestroyNotify)bt_ctf_field_put);
- g_ptr_array_set_size(sequence->elements, (size_t)sequence_length);
- bt_ctf_field_get(length_field);
+ (GDestroyNotify) bt_put);
+ g_ptr_array_set_size(sequence->elements, (size_t) sequence_length);
+ bt_get(length_field);
sequence->length = length_field;
end:
return ret;
if (!field || !name ||
bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_STRUCT) {
+ BT_CTF_TYPE_ID_STRUCT) {
goto error;
}
structure->fields->pdata[index] = new_field;
end:
- bt_ctf_field_get(new_field);
+ bt_get(new_field);
error:
if (field_type) {
- bt_ctf_field_type_put(field_type);
+ bt_put(field_type);
}
return new_field;
}
struct bt_ctf_field *ret_field = NULL;
if (!field ||
- bt_ctf_field_type_get_type_id(field->type) != CTF_TYPE_STRUCT) {
+ bt_ctf_field_type_get_type_id(field->type) !=
+ BT_CTF_TYPE_ID_STRUCT) {
goto end;
}
ret = bt_ctf_field_type_structure_get_field(structure_type,
&field_name, &field_type, index);
- bt_ctf_field_type_put(structure_type);
+ bt_put(structure_type);
if (ret) {
goto error;
}
structure->fields->pdata[index] = ret_field;
end:
- bt_ctf_field_get(ret_field);
+ bt_get(ret_field);
error:
- if (field_type) {
- bt_ctf_field_type_put(field_type);
- }
+ bt_put(field_type);
return ret_field;
}
if (!field || !name || !value ||
bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_STRUCT) {
+ BT_CTF_TYPE_ID_STRUCT) {
ret = -1;
goto end;
}
expected_field_type =
bt_ctf_field_type_structure_get_field_type_by_name(field->type,
name);
- if (expected_field_type != value->type) {
+
+ if (bt_ctf_field_type_compare(expected_field_type, value->type)) {
ret = -1;
goto end;
}
}
if (structure->fields->pdata[index]) {
- bt_ctf_field_put(structure->fields->pdata[index]);
+ bt_put(structure->fields->pdata[index]);
}
structure->fields->pdata[index] = value;
- bt_ctf_field_get(value);
+ bt_get(value);
end:
if (expected_field_type) {
- bt_ctf_field_type_put(expected_field_type);
+ bt_put(expected_field_type);
}
return ret;
}
struct bt_ctf_field_array *array;
if (!field || bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_ARRAY) {
+ BT_CTF_TYPE_ID_ARRAY) {
goto end;
}
}
new_field = bt_ctf_field_create(field_type);
- bt_ctf_field_get(new_field);
array->elements->pdata[(size_t)index] = new_field;
end:
if (field_type) {
- bt_ctf_field_type_put(field_type);
+ bt_put(field_type);
+ }
+ if (new_field) {
+ bt_get(new_field);
}
return new_field;
}
struct bt_ctf_field_sequence *sequence;
if (!field || bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_SEQUENCE) {
+ BT_CTF_TYPE_ID_SEQUENCE) {
goto end;
}
}
field_type = bt_ctf_field_type_sequence_get_element_type(field->type);
- if (sequence->elements->pdata[(size_t)index]) {
- new_field = sequence->elements->pdata[(size_t)index];
+ if (sequence->elements->pdata[(size_t) index]) {
+ new_field = sequence->elements->pdata[(size_t) index];
goto end;
}
new_field = bt_ctf_field_create(field_type);
- bt_ctf_field_get(new_field);
- sequence->elements->pdata[(size_t)index] = new_field;
+ sequence->elements->pdata[(size_t) index] = new_field;
end:
if (field_type) {
- bt_ctf_field_type_put(field_type);
+ bt_put(field_type);
+ }
+ if (new_field) {
+ bt_get(new_field);
}
return new_field;
}
if (!field || !tag_field ||
bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_VARIANT ||
+ BT_CTF_TYPE_ID_VARIANT ||
bt_ctf_field_type_get_type_id(tag_field->type) !=
- CTF_TYPE_ENUM) {
+ BT_CTF_TYPE_ID_ENUM) {
goto end;
}
}
tag_enum_value = tag_enum_integer->definition.value._signed;
+
+ /*
+ * If the variant currently has a tag and a payload, and if the
+ * requested tag value is the same as the current one, return
+ * the current payload instead of creating a fresh one.
+ */
+ if (variant->tag && variant->payload) {
+ struct bt_ctf_field *cur_tag_container = NULL;
+ struct bt_ctf_field_integer *cur_tag_enum_integer;
+ int64_t cur_tag_value;
+
+ cur_tag_container =
+ bt_ctf_field_enumeration_get_container(variant->tag);
+ assert(cur_tag_container);
+ cur_tag_enum_integer = container_of(cur_tag_container,
+ struct bt_ctf_field_integer, parent);
+ bt_put(cur_tag_container);
+ cur_tag_value = cur_tag_enum_integer->definition.value._signed;
+
+ if (cur_tag_value == tag_enum_value) {
+ new_field = variant->payload;
+ bt_get(new_field);
+ goto end;
+ }
+ }
+
field_type = bt_ctf_field_type_variant_get_field_type_signed(
variant_type, tag_enum_value);
if (!field_type) {
goto end;
}
- bt_ctf_field_put(variant->tag);
- bt_ctf_field_put(variant->payload);
- bt_ctf_field_get(new_field);
- bt_ctf_field_get(tag_field);
+ bt_put(variant->tag);
+ bt_put(variant->payload);
+ bt_get(new_field);
+ bt_get(tag_field);
variant->tag = tag_field;
variant->payload = new_field;
end:
- bt_ctf_field_put(tag_enum);
+ bt_put(tag_enum);
return new_field;
}
+struct bt_ctf_field *bt_ctf_field_variant_get_current_field(
+ struct bt_ctf_field *variant_field)
+{
+ struct bt_ctf_field *current_field = NULL;
+ struct bt_ctf_field_variant *variant;
+
+ if (!variant_field ||
+ bt_ctf_field_type_get_type_id(variant_field->type) !=
+ BT_CTF_TYPE_ID_VARIANT) {
+ goto end;
+ }
+
+ variant = container_of(variant_field, struct bt_ctf_field_variant,
+ parent);
+
+ if (variant->payload) {
+ current_field = variant->payload;
+ bt_get(current_field);
+ goto end;
+ }
+
+end:
+ return current_field;
+}
+
struct bt_ctf_field *bt_ctf_field_enumeration_get_container(
struct bt_ctf_field *field)
{
struct bt_ctf_field_enumeration *enumeration;
if (!field || bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_ENUM) {
+ BT_CTF_TYPE_ID_ENUM) {
goto end;
}
}
container = enumeration->payload;
- bt_ctf_field_get(container);
+ bt_get(container);
end:
return container;
}
}
error_put_container_type:
- bt_ctf_field_type_put(container_type);
+ bt_put(container_type);
error_put_container:
- bt_ctf_field_put(container);
+ bt_put(container);
end:
return name;
}
if (!field || !value || !field->payload_set ||
bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_INTEGER) {
+ BT_CTF_TYPE_ID_INTEGER) {
ret = -1;
goto end;
}
if (!field ||
bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_INTEGER) {
+ BT_CTF_TYPE_ID_INTEGER) {
ret = -1;
goto end;
}
if (!field || !value || !field->payload_set ||
bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_INTEGER) {
+ BT_CTF_TYPE_ID_INTEGER) {
ret = -1;
goto end;
}
if (!field ||
bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_INTEGER) {
+ BT_CTF_TYPE_ID_INTEGER) {
ret = -1;
goto end;
}
if (!field || !value || !field->payload_set ||
bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_FLOAT) {
+ BT_CTF_TYPE_ID_FLOAT) {
ret = -1;
goto end;
}
if (!field ||
bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_FLOAT) {
+ BT_CTF_TYPE_ID_FLOAT) {
ret = -1;
goto end;
}
if (!field || !field->payload_set ||
bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_STRING) {
+ BT_CTF_TYPE_ID_STRING) {
goto end;
}
if (!field || !value ||
bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_STRING) {
+ BT_CTF_TYPE_ID_STRING) {
ret = -1;
goto end;
}
if (!field || !value ||
bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_STRING) {
+ BT_CTF_TYPE_ID_STRING) {
ret = -1;
goto end;
}
if (!field || !value ||
bt_ctf_field_type_get_type_id(field->type) !=
- CTF_TYPE_STRING) {
+ BT_CTF_TYPE_ID_STRING) {
ret = -1;
goto end;
}
int bt_ctf_field_validate(struct bt_ctf_field *field)
{
int ret = 0;
- enum ctf_type_id type_id;
+ enum bt_ctf_type_id type_id;
if (!field) {
ret = -1;
}
type_id = bt_ctf_field_type_get_type_id(field->type);
- if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
+ if (type_id <= BT_CTF_TYPE_ID_UNKNOWN || type_id >= BT_CTF_NR_TYPE_IDS) {
ret = -1;
goto end;
}
int bt_ctf_field_reset(struct bt_ctf_field *field)
{
int ret = 0;
- enum ctf_type_id type_id;
+ enum bt_ctf_type_id type_id;
if (!field) {
ret = -1;
}
type_id = bt_ctf_field_type_get_type_id(field->type);
- if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
+ if (type_id <= BT_CTF_TYPE_ID_UNKNOWN || type_id >= BT_CTF_NR_TYPE_IDS) {
ret = -1;
goto end;
}
struct ctf_stream_pos *pos)
{
int ret = 0;
- enum ctf_type_id type_id;
+ enum bt_ctf_type_id type_id;
if (!field || !pos) {
ret = -1;
}
type_id = bt_ctf_field_type_get_type_id(field->type);
- if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
+ if (type_id <= BT_CTF_TYPE_ID_UNKNOWN || type_id >= BT_CTF_NR_TYPE_IDS) {
ret = -1;
goto end;
}
return ret;
}
-BT_HIDDEN
struct bt_ctf_field *bt_ctf_field_copy(struct bt_ctf_field *field)
{
int ret;
struct bt_ctf_field *copy = NULL;
- enum ctf_type_id type_id;
+ enum bt_ctf_type_id type_id;
if (!field) {
goto end;
}
type_id = bt_ctf_field_type_get_type_id(field->type);
- if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) {
+ if (type_id <= BT_CTF_TYPE_ID_UNKNOWN || type_id >= BT_CTF_NR_TYPE_IDS) {
goto end;
}
copy->payload_set = field->payload_set;
ret = field_copy_funcs[type_id](field, copy);
if (ret) {
- bt_ctf_field_put(copy);
+ bt_put(copy);
copy = NULL;
}
end:
struct bt_ctf_field_structure, 1);
struct bt_ctf_field *field = NULL;
- if (!structure || !structure_type->fields->len) {
+ if (!structure) {
goto end;
}
}
static
-void bt_ctf_field_destroy(struct bt_ctf_ref *ref)
+void bt_ctf_field_destroy(struct bt_object *obj)
{
struct bt_ctf_field *field;
struct bt_ctf_field_type *type;
- enum ctf_type_id type_id;
-
- if (!ref) {
- return;
- }
+ enum bt_ctf_type_id type_id;
- field = container_of(ref, struct bt_ctf_field, ref_count);
+ field = container_of(obj, struct bt_ctf_field, base);
type = field->type;
type_id = bt_ctf_field_type_get_type_id(type);
- if (type_id <= CTF_TYPE_UNKNOWN ||
- type_id >= NR_CTF_TYPES) {
+ if (type_id <= BT_CTF_TYPE_ID_UNKNOWN ||
+ type_id >= BT_CTF_NR_TYPE_IDS) {
return;
}
field_destroy_funcs[type_id](field);
- if (type) {
- bt_ctf_field_type_put(type);
- }
+ bt_put(type);
}
static
enumeration = container_of(field, struct bt_ctf_field_enumeration,
parent);
- bt_ctf_field_put(enumeration->payload);
+ bt_put(enumeration->payload);
g_free(enumeration);
}
}
variant = container_of(field, struct bt_ctf_field_variant, parent);
- bt_ctf_field_put(variant->tag);
- bt_ctf_field_put(variant->payload);
+ bt_put(variant->tag);
+ bt_put(variant->payload);
g_free(variant);
}
}
sequence = container_of(field, struct bt_ctf_field_sequence, parent);
- g_ptr_array_free(sequence->elements, TRUE);
- bt_ctf_field_put(sequence->length);
+ if (sequence->elements) {
+ g_ptr_array_free(sequence->elements, TRUE);
+ }
+ bt_put(sequence->length);
g_free(sequence);
}
}
}
end:
- bt_ctf_field_put(character);
- bt_ctf_field_type_put(character_type);
+ bt_put(character);
+ bt_put(character_type);
return ret;
}
g_ptr_array_set_size(struct_dst->fields, struct_src->fields->len);
for (i = 0; i < struct_src->fields->len; i++) {
- struct bt_ctf_field *field_copy = bt_ctf_field_copy(
- g_ptr_array_index(struct_src->fields, i));
+ struct bt_ctf_field *field =
+ g_ptr_array_index(struct_src->fields, i);
+ struct bt_ctf_field *field_copy = NULL;
- if (!field_copy) {
- ret = -1;
- goto end;
+ if (field) {
+ field_copy = bt_ctf_field_copy(field);
+
+ if (!field_copy) {
+ ret = -1;
+ goto end;
+ }
}
+
g_ptr_array_index(struct_dst->fields, i) = field_copy;
}
end:
g_ptr_array_set_size(array_dst->elements, array_src->elements->len);
for (i = 0; i < array_src->elements->len; i++) {
- struct bt_ctf_field *field_copy = bt_ctf_field_copy(
- g_ptr_array_index(array_src->elements, i));
+ struct bt_ctf_field *field =
+ g_ptr_array_index(array_src->elements, i);
+ struct bt_ctf_field *field_copy = NULL;
- if (!field_copy) {
- ret = -1;
- goto end;
+ if (field) {
+ field_copy = bt_ctf_field_copy(field);
+
+ if (!field_copy) {
+ ret = -1;
+ goto end;
+ }
}
+
g_ptr_array_index(array_dst->elements, i) = field_copy;
}
end:
/* copy source length */
dst_length = bt_ctf_field_copy(src_length);
- bt_ctf_field_put(src_length);
+ bt_put(src_length);
if (!dst_length) {
ret = -1;
/* this will initialize the destination sequence's internal array */
ret = bt_ctf_field_sequence_set_length(dst, dst_length);
- bt_ctf_field_put(dst_length);
+ bt_put(dst_length);
if (ret) {
goto end;
assert(sequence_dst->elements->len == sequence_src->elements->len);
for (i = 0; i < sequence_src->elements->len; i++) {
- struct bt_ctf_field *field_copy = bt_ctf_field_copy(
- g_ptr_array_index(sequence_src->elements, i));
+ struct bt_ctf_field *field =
+ g_ptr_array_index(sequence_src->elements, i);
+ struct bt_ctf_field *field_copy = NULL;
- if (!field_copy) {
- ret = -1;
- goto end;
+ if (field) {
+ field_copy = bt_ctf_field_copy(field);
+
+ if (!field_copy) {
+ ret = -1;
+ goto end;
+ }
}
g_ptr_array_index(sequence_dst->elements, i) = field_copy;
}
pos->packet_size += PACKET_LEN_INCREMENT;
- ret = posix_fallocate(pos->fd, pos->mmap_offset,
- pos->packet_size / CHAR_BIT);
+ do {
+ ret = bt_posix_fallocate(pos->fd, pos->mmap_offset,
+ pos->packet_size / CHAR_BIT);
+ } while (ret == EINTR);
if (ret) {
+ errno = EINTR;
+ ret = -1;
goto end;
}