struct bt_ctf_field *bt_ctf_field_structure_get_field_by_index( struct bt_ctf_field *field, size_t index) { int ret; const char *field_name; struct bt_ctf_field_structure *structure; struct bt_ctf_field_type *structure_type; struct bt_ctf_field_type *field_type = NULL; struct bt_ctf_field *ret_field = NULL; if (!field || bt_ctf_field_type_get_type_id(field->type) != CTF_TYPE_STRUCT) { goto end; } structure = container_of(field, struct bt_ctf_field_structure, parent); if (index >= structure->fields->len) { goto error; } ret_field = structure->fields->pdata[index]; if (ret_field) { goto end; } /* Field has not been instanciated yet, create it */ structure_type = bt_ctf_field_get_type(field); if (!structure_type) { goto error; } ret = bt_ctf_field_type_structure_get_field(structure_type, &field_name, &field_type, index); bt_ctf_field_type_put(structure_type); if (ret) { goto error; } ret_field = bt_ctf_field_create(field_type); if (!ret_field) { goto error; } structure->fields->pdata[index] = ret_field; end: bt_ctf_field_get(ret_field); error: if (field_type) { bt_ctf_field_type_put(field_type); } return ret_field; }
struct bt_ctf_field *bt_ctf_field_sequence_get_field(struct bt_ctf_field *field, uint64_t index) { struct bt_ctf_field *new_field = NULL; struct bt_ctf_field_type *field_type = NULL; struct bt_ctf_field_sequence *sequence; if (!field || bt_ctf_field_type_get_type_id(field->type) != CTF_TYPE_SEQUENCE) { goto end; } sequence = container_of(field, struct bt_ctf_field_sequence, parent); if (!sequence->elements || sequence->elements->len <= index) { 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]; goto end; } new_field = bt_ctf_field_create(field_type); bt_ctf_field_get(new_field); sequence->elements->pdata[(size_t)index] = new_field; end: if (field_type) { bt_ctf_field_type_put(field_type); } return new_field; }
struct bt_ctf_field *bt_ctf_field_array_get_field(struct bt_ctf_field *field, uint64_t index) { struct bt_ctf_field *new_field = NULL; struct bt_ctf_field_type *field_type = NULL; struct bt_ctf_field_array *array; if (!field || bt_ctf_field_type_get_type_id(field->type) != CTF_TYPE_ARRAY) { goto end; } array = container_of(field, struct bt_ctf_field_array, parent); if (index >= array->elements->len) { goto end; } field_type = bt_ctf_field_type_array_get_element_type(field->type); if (array->elements->pdata[(size_t)index]) { new_field = array->elements->pdata[(size_t)index]; goto end; } 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); } return new_field; }
static int bt_ctf_field_string_serialize(struct bt_ctf_field *field, struct ctf_stream_pos *pos) { size_t i; int ret = 0; struct bt_ctf_field_string *string = container_of(field, struct bt_ctf_field_string, parent); struct bt_ctf_field_type *character_type = get_field_type(FIELD_TYPE_ALIAS_UINT8_T); struct bt_ctf_field *character = bt_ctf_field_create(character_type); for (i = 0; i < string->payload->len + 1; i++) { ret = bt_ctf_field_unsigned_integer_set_value(character, (uint64_t) string->payload->str[i]); if (ret) { goto end; } ret = bt_ctf_field_integer_serialize(character, pos); if (ret) { goto end; } } end: bt_ctf_field_put(character); bt_ctf_field_type_put(character_type); return ret; }
void bt_ctf_trace_destroy(struct bt_ctf_ref *ref) { struct bt_ctf_trace *trace; if (!ref) { return; } trace = container_of(ref, struct bt_ctf_trace, ref_count); if (trace->environment) { g_ptr_array_free(trace->environment, TRUE); } if (trace->clocks) { g_ptr_array_free(trace->clocks, TRUE); } if (trace->streams) { g_ptr_array_free(trace->streams, TRUE); } if (trace->stream_classes) { g_ptr_array_free(trace->stream_classes, TRUE); } bt_ctf_field_type_put(trace->trace_packet_header_type); bt_ctf_field_put(trace->trace_packet_header); g_free(trace); }
const char *bt_ctf_field_enumeration_get_mapping_name( struct bt_ctf_field *field) { int ret; const char *name = NULL; struct bt_ctf_field *container = NULL; struct bt_ctf_field_type *container_type = NULL; struct bt_ctf_field_type_integer *integer_type = NULL; struct bt_ctf_field_type_enumeration *enumeration_type = NULL; container = bt_ctf_field_enumeration_get_container(field); if (!container) { goto end; } container_type = bt_ctf_field_get_type(container); if (!container_type) { goto error_put_container; } integer_type = container_of(container_type, struct bt_ctf_field_type_integer, parent); enumeration_type = container_of(field->type, struct bt_ctf_field_type_enumeration, parent); if (!integer_type->declaration.signedness) { uint64_t value; ret = bt_ctf_field_unsigned_integer_get_value(container, &value); if (ret) { goto error_put_container_type; } name = bt_ctf_field_type_enumeration_get_mapping_name_unsigned( enumeration_type, value); } else { int64_t value; ret = bt_ctf_field_signed_integer_get_value(container, &value); if (ret) { goto error_put_container_type; } name = bt_ctf_field_type_enumeration_get_mapping_name_signed( enumeration_type, value); } error_put_container_type: bt_ctf_field_type_put(container_type); error_put_container: bt_ctf_field_put(container); end: return name; }
void bt_ctf_writer_destroy(struct bt_ctf_ref *ref) { struct bt_ctf_writer *writer; if (!ref) { return; } writer = container_of(ref, struct bt_ctf_writer, ref_count); bt_ctf_writer_flush_metadata(writer); if (writer->path) { g_string_free(writer->path, TRUE); } if (writer->trace_dir_fd > 0) { if (close(writer->trace_dir_fd)) { perror("close"); abort(); } } if (writer->metadata_fd > 0) { if (close(writer->metadata_fd)) { perror("close"); abort(); } } if (writer->environment) { g_ptr_array_free(writer->environment, TRUE); } if (writer->clocks) { g_ptr_array_free(writer->clocks, TRUE); } if (writer->streams) { g_ptr_array_free(writer->streams, TRUE); } if (writer->stream_classes) { g_ptr_array_free(writer->stream_classes, TRUE); } bt_ctf_field_type_put(writer->trace_packet_header_type); bt_ctf_field_put(writer->trace_packet_header); g_free(writer); }
const char *_bt_python_ctf_event_class_get_field_name( struct bt_ctf_event_class *event_class, size_t index) { int ret; const char *name; struct bt_ctf_field_type *type; ret = bt_ctf_event_class_get_field(event_class, &name, &type, index); if (ret) { name = NULL; goto end; } bt_ctf_field_type_put(type); end: return name; }
BT_HIDDEN int bt_ctf_field_structure_set_field(struct bt_ctf_field *field, const char *name, struct bt_ctf_field *value) { int ret = 0; GQuark field_quark; struct bt_ctf_field_structure *structure; struct bt_ctf_field_type *expected_field_type = NULL; size_t index; if (!field || !name || !value || bt_ctf_field_type_get_type_id(field->type) != CTF_TYPE_STRUCT) { ret = -1; goto end; } field_quark = g_quark_from_string(name); structure = container_of(field, struct bt_ctf_field_structure, parent); expected_field_type = bt_ctf_field_type_structure_get_field_type_by_name(field->type, name); if (expected_field_type != value->type) { ret = -1; goto end; } if (!g_hash_table_lookup_extended(structure->field_name_to_index, GUINT_TO_POINTER(field_quark), NULL, (gpointer *) &index)) { goto end; } if (structure->fields->pdata[index]) { bt_ctf_field_put(structure->fields->pdata[index]); } structure->fields->pdata[index] = value; bt_ctf_field_get(value); end: if (expected_field_type) { bt_ctf_field_type_put(expected_field_type); } return ret; }
struct bt_ctf_field *bt_ctf_field_structure_get_field( struct bt_ctf_field *field, const char *name) { struct bt_ctf_field *new_field = NULL; GQuark field_quark; struct bt_ctf_field_structure *structure; struct bt_ctf_field_type *field_type = NULL; size_t index; if (!field || !name || bt_ctf_field_type_get_type_id(field->type) != CTF_TYPE_STRUCT) { goto error; } field_quark = g_quark_from_string(name); structure = container_of(field, struct bt_ctf_field_structure, parent); field_type = bt_ctf_field_type_structure_get_field_type_by_name(field->type, name); if (!g_hash_table_lookup_extended(structure->field_name_to_index, GUINT_TO_POINTER(field_quark), NULL, (gpointer *)&index)) { goto error; } if (structure->fields->pdata[index]) { new_field = structure->fields->pdata[index]; goto end; } new_field = bt_ctf_field_create(field_type); if (!new_field) { goto error; } structure->fields->pdata[index] = new_field; end: bt_ctf_field_get(new_field); error: if (field_type) { bt_ctf_field_type_put(field_type); } return new_field; }
static void bt_ctf_field_destroy(struct bt_ctf_ref *ref) { struct bt_ctf_field *field; struct bt_ctf_field_type *type; enum ctf_type_id type_id; if (!ref) { return; } field = container_of(ref, struct bt_ctf_field, ref_count); type = field->type; type_id = bt_ctf_field_type_get_type_id(type); if (type_id <= CTF_TYPE_UNKNOWN || type_id >= NR_CTF_TYPES) { return; } field_destroy_funcs[type_id](field); if (type) { bt_ctf_field_type_put(type); } }
static int init_trace_packet_header(struct bt_ctf_writer *writer) { size_t i; int ret = 0; struct bt_ctf_field *trace_packet_header = NULL, *magic = NULL, *uuid_array = NULL; struct bt_ctf_field_type *_uint32_t = get_field_type(FIELD_TYPE_ALIAS_UINT32_T); struct bt_ctf_field_type *_uint8_t = get_field_type(FIELD_TYPE_ALIAS_UINT8_T); struct bt_ctf_field_type *trace_packet_header_type = bt_ctf_field_type_structure_create(); struct bt_ctf_field_type *uuid_array_type = bt_ctf_field_type_array_create(_uint8_t, 16); if (!trace_packet_header_type || !uuid_array_type) { ret = -1; goto end; } ret = bt_ctf_field_type_set_byte_order(_uint32_t, (writer->byte_order == LITTLE_ENDIAN ? BT_CTF_BYTE_ORDER_LITTLE_ENDIAN : BT_CTF_BYTE_ORDER_BIG_ENDIAN)); if (ret) { goto end; } ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type, _uint32_t, "magic"); if (ret) { goto end; } ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type, uuid_array_type, "uuid"); if (ret) { goto end; } ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type, _uint32_t, "stream_id"); if (ret) { goto end; } trace_packet_header = bt_ctf_field_create(trace_packet_header_type); if (!trace_packet_header) { ret = -1; goto end; } magic = bt_ctf_field_structure_get_field(trace_packet_header, "magic"); ret = bt_ctf_field_unsigned_integer_set_value(magic, 0xC1FC1FC1); if (ret) { goto end; } uuid_array = bt_ctf_field_structure_get_field(trace_packet_header, "uuid"); for (i = 0; i < 16; i++) { struct bt_ctf_field *uuid_element = bt_ctf_field_array_get_field(uuid_array, i); ret = bt_ctf_field_unsigned_integer_set_value(uuid_element, writer->uuid[i]); bt_ctf_field_put(uuid_element); if (ret) { goto end; } } bt_ctf_field_type_put(writer->trace_packet_header_type); bt_ctf_field_put(writer->trace_packet_header); writer->trace_packet_header_type = trace_packet_header_type; writer->trace_packet_header = trace_packet_header; end: bt_ctf_field_type_put(uuid_array_type); bt_ctf_field_type_put(_uint32_t); bt_ctf_field_type_put(_uint8_t); bt_ctf_field_put(magic); bt_ctf_field_put(uuid_array); if (ret) { bt_ctf_field_type_put(trace_packet_header_type); bt_ctf_field_put(trace_packet_header); } return ret; }