/** * A simple event has the following payload: * - uint8_t payload_8; * - uint16_t payload_16; * - uint32_t payload_32; */ static struct bt_ctf_event_class *create_simple_event(const char *name) { int ret; struct bt_ctf_event_class *event = NULL; struct bt_ctf_field_type *payload = NULL; assert(name); event = bt_ctf_event_class_create(name); if (!event) { diag("Failed to create simple event"); goto error; } payload = create_integer_struct(); if (!payload) { diag("Failed to initialize integer structure"); goto error; } ret = bt_ctf_event_class_set_payload_type(event, payload); if (ret) { diag("Failed to set simple event payload"); goto error; } end: BT_PUT(payload); return event; error: BT_PUT(event); goto end;; }
static struct bt_ctf_stream_class *create_sc2(void) { int ret; struct bt_ctf_event_class *ec3 = NULL; struct bt_ctf_stream_class *sc2 = NULL, *ret_stream = NULL; sc2 = bt_ctf_stream_class_create("sc2"); if (!sc2) { diag("Failed to create Stream Class"); goto error; } ec3 = create_simple_event("ec3"); if (!ec3) { diag("Failed to create simple event EC3"); goto error; } ret = bt_ctf_stream_class_add_event_class(sc2, ec3); if (ret) { diag("Failed to add EC3 to SC2"); goto error; } ret_stream = bt_ctf_event_class_get_stream_class(ec3); ok(ret_stream == sc2, "Get parent stream SC2 from EC3"); end: BT_PUT(ret_stream); BT_PUT(ec3); return sc2; error: BT_PUT(sc2); goto end; }
struct bt_ctf_event_class *bt_ctf_event_class_create(const char *name) { int ret; struct bt_value *obj = NULL; struct bt_ctf_event_class *event_class = NULL; if (bt_ctf_validate_identifier(name)) { goto error; } event_class = g_new0(struct bt_ctf_event_class, 1); if (!event_class) { goto error; } bt_object_init(event_class, bt_ctf_event_class_destroy); event_class->fields = bt_ctf_field_type_structure_create(); if (!event_class->fields) { goto error; } event_class->attributes = bt_ctf_attributes_create(); if (!event_class->attributes) { goto error; } obj = bt_value_integer_create_init(-1); if (!obj) { goto error; } ret = bt_ctf_attributes_set_field_value(event_class->attributes, "id", obj); if (ret) { goto error; } BT_PUT(obj); obj = bt_value_string_create_init(name); if (!obj) { goto error; } ret = bt_ctf_attributes_set_field_value(event_class->attributes, "name", obj); if (ret) { goto error; } BT_PUT(obj); return event_class; error: BT_PUT(event_class); BT_PUT(obj); return event_class; }
static struct bt_value *bt_attributes_get_field_by_name( struct bt_value *attr_obj, const char *name) { uint64_t i; int64_t attr_size; struct bt_value *value_obj = NULL; struct bt_value *attr_field_name_obj = NULL; attr_size = bt_value_array_size(attr_obj); if (attr_size < 0) { BT_LOGE("Cannot get array value's size: value-addr=%p", attr_obj); goto error; } for (i = 0; i < attr_size; ++i) { int ret; const char *field_name; value_obj = bt_value_array_get(attr_obj, i); if (!value_obj) { BT_LOGE("Cannot get attributes object's array value's element by index: " "value-addr=%p, index=%" PRIu64, attr_obj, i); goto error; } attr_field_name_obj = bt_value_array_get(value_obj, 0); if (!attr_field_name_obj) { BT_LOGE("Cannot get attribute array value's element by index: " "value-addr=%p, index=%" PRIu64, value_obj, (int64_t) 0); goto error; } ret = bt_value_string_get(attr_field_name_obj, &field_name); if (ret) { BT_LOGE("Cannot get raw value from string value: value-addr=%p", attr_field_name_obj); goto error; } if (!strcmp(field_name, name)) { BT_PUT(attr_field_name_obj); break; } BT_PUT(attr_field_name_obj); BT_PUT(value_obj); } return value_obj; error: BT_PUT(attr_field_name_obj); BT_PUT(value_obj); return value_obj; }
BT_HIDDEN struct bt_ctf_packet *trimmer_new_packet( struct trimmer_iterator *trim_it, struct bt_ctf_packet *packet) { struct bt_ctf_stream *stream = NULL; struct bt_ctf_field *writer_packet_context = NULL; struct bt_ctf_packet *writer_packet = NULL; int int_ret; stream = bt_ctf_packet_get_stream(packet); if (!stream) { fprintf(trim_it->err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__); goto error; } /* * If a packet was already opened, close it and remove it from * the HT. */ writer_packet = lookup_packet(trim_it, packet); if (writer_packet) { g_hash_table_remove(trim_it->packet_map, 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 error; } bt_get(writer_packet); writer_packet_context = ctf_copy_packet_context(trim_it->err, packet, stream); if (!writer_packet_context) { fprintf(trim_it->err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__); goto error; } int_ret = bt_ctf_packet_set_context(writer_packet, writer_packet_context); if (int_ret) { fprintf(trim_it->err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__); goto error; } goto end; error: BT_PUT(writer_packet); end: bt_put(writer_packet_context); bt_put(stream); return writer_packet; }
static void create_user_full(struct user *user) { char trace_path[] = "/tmp/ctfwriter_XXXXXX"; struct bt_ctf_field_type *ft; struct bt_ctf_field *field; struct bt_ctf_clock *clock; int ret; if (!bt_mkdtemp(trace_path)) { perror("# perror"); } user->writer = bt_ctf_writer_create(trace_path); assert(user->writer); user->tc = bt_ctf_writer_get_trace(user->writer); assert(user->tc); user->sc = bt_ctf_stream_class_create("sc"); assert(user->sc); clock = bt_ctf_clock_create("the_clock"); assert(clock); ret = bt_ctf_stream_class_set_clock(user->sc, clock); assert(!ret); ret = bt_ctf_clock_set_value(clock, 23); assert(!ret); BT_PUT(clock); user->stream = bt_ctf_writer_create_stream(user->writer, user->sc); assert(user->stream); user->ec = bt_ctf_event_class_create("ec"); assert(user->ec); ft = create_integer_struct(); assert(ft); ret = bt_ctf_event_class_set_payload_type(user->ec, ft); BT_PUT(ft); assert(!ret); ret = bt_ctf_stream_class_add_event_class(user->sc, user->ec); assert(!ret); user->event = bt_ctf_event_create(user->ec); assert(user->event); field = bt_ctf_event_get_payload(user->event, "payload_8"); assert(field); ret = bt_ctf_field_unsigned_integer_set_value(field, 10); assert(!ret); BT_PUT(field); field = bt_ctf_event_get_payload(user->event, "payload_16"); assert(field); ret = bt_ctf_field_unsigned_integer_set_value(field, 20); assert(!ret); BT_PUT(field); field = bt_ctf_event_get_payload(user->event, "payload_32"); assert(field); ret = bt_ctf_field_unsigned_integer_set_value(field, 30); assert(!ret); BT_PUT(field); ret = bt_ctf_stream_append_event(user->stream, user->event); assert(!ret); recursive_rmdir(trace_path); }
static void bt_notification_event_destroy(struct bt_object *obj) { struct bt_notification_event *notification = (struct bt_notification_event *) obj; BT_PUT(notification->event); BT_PUT(notification->cc_prio_map); g_free(notification); }
/** * Returns a structure containing the following fields: * - uint8_t payload_8; * - uint16_t payload_16; * - uint32_t payload_32; */ static struct bt_ctf_field_type *create_integer_struct(void) { int ret; struct bt_ctf_field_type *structure = NULL; struct bt_ctf_field_type *ui8 = NULL, *ui16 = NULL, *ui32 = NULL; structure = bt_ctf_field_type_structure_create(); if (!structure) { goto error; } ui8 = bt_ctf_field_type_integer_create(8); if (!ui8) { diag("Failed to create uint8_t type"); goto error; } ret = bt_ctf_field_type_structure_add_field(structure, ui8, "payload_8"); if (ret) { diag("Failed to add uint8_t to structure"); goto error; } ui16 = bt_ctf_field_type_integer_create(16); if (!ui16) { diag("Failed to create uint16_t type"); goto error; } ret = bt_ctf_field_type_structure_add_field(structure, ui16, "payload_16"); if (ret) { diag("Failed to add uint16_t to structure"); goto error; } ui32 = bt_ctf_field_type_integer_create(32); if (!ui32) { diag("Failed to create uint32_t type"); goto error; } ret = bt_ctf_field_type_structure_add_field(structure, ui32, "payload_32"); if (ret) { diag("Failed to add uint32_t to structure"); goto error; } end: BT_PUT(ui8); BT_PUT(ui16); BT_PUT(ui32); return structure; error: BT_PUT(structure); goto end; }
static struct bt_ctf_stream_class *create_sc1(void) { int ret; struct bt_ctf_event_class *ec1 = NULL, *ec2 = NULL; struct bt_ctf_stream_class *sc1 = NULL, *ret_stream = NULL; sc1 = bt_ctf_stream_class_create("sc1"); if (!sc1) { diag("Failed to create Stream Class"); goto error; } ec1 = create_complex_event("ec1"); if (!ec1) { diag("Failed to create complex event EC1"); goto error; } ret = bt_ctf_stream_class_add_event_class(sc1, ec1); if (ret) { diag("Failed to add EC1 to SC1"); goto error; } ec2 = create_simple_event("ec2"); if (!ec2) { diag("Failed to create simple event EC2"); goto error; } ret = bt_ctf_stream_class_add_event_class(sc1, ec2); if (ret) { diag("Failed to add EC1 to SC1"); goto error; } ret_stream = bt_ctf_event_class_get_stream_class(ec1); ok(ret_stream == sc1, "Get parent stream SC1 from EC1"); BT_PUT(ret_stream); ret_stream = bt_ctf_event_class_get_stream_class(ec2); ok(ret_stream == sc1, "Get parent stream SC1 from EC2"); end: BT_PUT(ret_stream); BT_PUT(ec1); BT_PUT(ec2); return sc1; error: BT_PUT(sc1); goto end; }
BT_HIDDEN int bt_ctf_event_set_packet(struct bt_ctf_event *event, struct bt_ctf_packet *packet) { struct bt_ctf_stream_class *event_stream_class = NULL; struct bt_ctf_stream_class *packet_stream_class = NULL; struct bt_ctf_stream *stream = NULL; int ret = 0; if (!event || !packet || event->frozen) { ret = -1; goto end; } /* * Make sure the new packet was created by this event's * stream, if it is set. */ stream = bt_ctf_event_get_stream(event); if (stream) { if (packet->stream != stream) { ret = -1; goto end; } } else { event_stream_class = bt_ctf_event_class_get_stream_class(event->event_class); packet_stream_class = bt_ctf_stream_get_class(packet->stream); assert(event_stream_class); assert(packet_stream_class); if (event_stream_class != packet_stream_class) { ret = -1; goto end; } } bt_get(packet); BT_MOVE(event->packet, packet); end: BT_PUT(stream); BT_PUT(event_stream_class); BT_PUT(packet_stream_class); return ret; }
struct bt_config *bt_config_cli_args_create_with_default(int argc, const char *argv[], int *retcode) { struct bt_value *initial_plugin_paths; struct bt_config *cfg = NULL; int ret; initial_plugin_paths = bt_value_array_create(); if (!initial_plugin_paths) { goto error; } ret = bt_config_append_plugin_paths(initial_plugin_paths, CONFIG_IN_TREE_PLUGIN_PATH); if (ret) { goto error; } cfg = bt_config_cli_args_create(argc, argv, retcode, true, true, BT_ENABLE_DEBUG_INFO == 0, initial_plugin_paths); goto end; error: *retcode = 1; BT_PUT(cfg); end: bt_put(initial_plugin_paths); return cfg; }
BT_HIDDEN int bt_ctf_stream_set_packet_header(struct bt_ctf_stream *stream, struct bt_ctf_field *field) { int ret = 0; struct bt_ctf_trace *trace = NULL; struct bt_ctf_field_type *field_type = NULL; if (!stream || !field || stream->pos.fd < 0) { ret = -1; goto end; } trace = (struct bt_ctf_trace *) bt_object_get_parent(stream); field_type = bt_ctf_field_get_type(field); if (bt_ctf_field_type_compare(field_type, trace->packet_header_type)) { ret = -1; goto end; } bt_get(field); bt_put(stream->packet_header); stream->packet_header = field; end: BT_PUT(trace); bt_put(field_type); return ret; }
BT_HIDDEN struct bt_value *bt_attributes_get_field_value_by_name( struct bt_value *attr_obj, const char *name) { struct bt_value *value_obj = NULL; struct bt_value *attr_field_obj = NULL; if (!attr_obj || !name) { BT_LOGW("Invalid parameter: attributes object or name is NULL: " "value-addr=%p, name-addr=%p", attr_obj, name); goto end; } attr_field_obj = bt_attributes_get_field_by_name(attr_obj, name); if (!attr_field_obj) { BT_LOGD("Cannot find attributes object's field by name: " "value-addr=%p, name=\"%s\"", attr_obj, name); goto end; } value_obj = bt_value_array_get(attr_field_obj, BT_ATTR_VALUE_INDEX); if (!value_obj) { BT_LOGE("Cannot get attribute array value's element by index: " "value-addr=%p, index=%" PRIu64, attr_field_obj, (uint64_t) BT_ATTR_VALUE_INDEX); } end: BT_PUT(attr_field_obj); return value_obj; }
struct bt_ctf_clock *bt_ctf_clock_create(const char *name) { int ret; struct bt_ctf_clock *clock = NULL; clock = _bt_ctf_clock_create(); if (!clock) { goto error; } ret = bt_ctf_clock_set_name(clock, name); if (ret) { goto error; } ret = bt_uuid_generate(clock->uuid); if (ret) { goto error; } clock->uuid_set = 1; return clock; error: BT_PUT(clock); return clock; }
BT_HIDDEN int bt_ctf_event_set_stream_event_context(struct bt_ctf_event *event, struct bt_ctf_field *stream_event_context) { int ret = 0; struct bt_ctf_field_type *field_type = NULL; struct bt_ctf_stream_class *stream_class = NULL; if (!event || !stream_event_context || event->frozen) { ret = -1; goto end; } stream_class = bt_ctf_event_class_get_stream_class(event->event_class); /* * We should not have been able to create the event without associating * the event class to a stream class. */ assert(stream_class); field_type = bt_ctf_field_get_type(stream_event_context); if (bt_ctf_field_type_compare(field_type, stream_class->event_context_type)) { ret = -1; goto end; } bt_get(stream_event_context); BT_MOVE(event->stream_event_context, stream_event_context); end: BT_PUT(stream_class); bt_put(field_type); return ret; }
struct bt_ctf_clock *bt_ctf_clock_create(const char *name) { int ret; struct bt_ctf_clock *clock = NULL; clock = _bt_ctf_clock_create(); if (!clock) { goto error; } ret = bt_ctf_clock_set_name(clock, name); if (ret) { goto error; } ret = bt_uuid_generate(clock->uuid); if (ret) { goto error; } /* * For backward compatibility reasons, a fresh clock can have * a value because it could be added to a trace created by a * CTF writer. As soon as this clock is added to a non-writer * trace, then its value/time functions will be disabled. */ clock->has_value = 1; clock->uuid_set = 1; return clock; error: BT_PUT(clock); return clock; }
BT_HIDDEN int bt_ctf_event_class_set_stream_id(struct bt_ctf_event_class *event_class, uint32_t stream_id) { int ret = 0; struct bt_value *obj; obj = bt_value_integer_create_init(stream_id); if (!obj) { ret = -1; goto end; } ret = bt_ctf_attributes_set_field_value(event_class->attributes, "stream_id", obj); if (event_class->frozen) { bt_ctf_attributes_freeze(event_class->attributes); } end: BT_PUT(obj); return ret; }
BT_HIDDEN struct bt_value *bt_attributes_get_field_value(struct bt_value *attr_obj, uint64_t index) { struct bt_value *value_obj = NULL; struct bt_value *attr_field_obj = NULL; if (!attr_obj) { BT_LOGW_STR("Invalid parameter: attributes object is NULL."); goto end; } attr_field_obj = bt_value_array_get(attr_obj, index); if (!attr_field_obj) { BT_LOGE("Cannot get attributes object's array value's element by index: " "value-addr=%p, index=%" PRIu64, attr_obj, index); goto end; } value_obj = bt_value_array_get(attr_field_obj, BT_ATTR_VALUE_INDEX); if (!value_obj) { BT_LOGE("Cannot get attribute array value's element by index: " "value-addr=%p, index=%" PRIu64, attr_field_obj, (uint64_t) BT_ATTR_VALUE_INDEX); } end: BT_PUT(attr_field_obj); return value_obj; }
BT_HIDDEN int64_t bt_ctf_event_class_get_id(struct bt_ctf_event_class *event_class) { struct bt_value *obj = NULL; int64_t ret = 0; if (!event_class) { ret = -1; goto end; } obj = bt_ctf_attributes_get_field_value(event_class->attributes, BT_CTF_EVENT_CLASS_ATTR_ID_INDEX); if (!obj) { goto end; } if (bt_value_integer_get(obj, &ret)) { ret = -1; } if (ret < 0) { /* means ID is not set */ ret = -1; goto end; } end: BT_PUT(obj); return ret; }
int ctf_fs_metadata_set_trace(struct ctf_fs_trace *ctf_fs_trace, struct ctf_fs_metadata_config *config) { int ret = 0; struct ctf_fs_file *file = NULL; struct ctf_metadata_decoder *metadata_decoder = NULL; struct ctf_metadata_decoder_config decoder_config = { .clock_class_offset_s = config ? config->clock_class_offset_s : 0, .clock_class_offset_ns = config ? config->clock_class_offset_ns : 0, }; file = get_file(ctf_fs_trace->path->str); if (!file) { BT_LOGE("Cannot create metadata file object"); ret = -1; goto end; } metadata_decoder = ctf_metadata_decoder_create( config ? &decoder_config : NULL, ctf_fs_trace->name->str); if (!metadata_decoder) { BT_LOGE("Cannot create metadata decoder object"); ret = -1; goto end; } ret = ctf_metadata_decoder_decode(metadata_decoder, file->fp); if (ret) { BT_LOGE("Cannot decode metadata file"); goto end; } ctf_fs_trace->metadata->trace = ctf_metadata_decoder_get_trace( metadata_decoder); assert(ctf_fs_trace->metadata->trace); end: ctf_fs_file_destroy(file); ctf_metadata_decoder_destroy(metadata_decoder); return ret; } int ctf_fs_metadata_init(struct ctf_fs_metadata *metadata) { /* Nothing to initialize for the moment. */ return 0; } void ctf_fs_metadata_fini(struct ctf_fs_metadata *metadata) { if (metadata->text) { free(metadata->text); } if (metadata->trace) { BT_PUT(metadata->trace); } }
static void stack_entry_free_func(gpointer data) { struct stack_entry *entry = data; BT_PUT(entry->base_type); g_free(entry); }
/** * A complex event has the following payload: * - uint8_t payload_8; * - uint16_t payload_16; * - uint32_t payload_32; * - struct payload_struct: * - uint8_t payload_8; * - uint16_t payload_16; * - uint32_t payload_32; */ static struct bt_ctf_event_class *create_complex_event(const char *name) { int ret; struct bt_ctf_event_class *event = NULL; struct bt_ctf_field_type *inner = NULL, *outer = NULL; assert(name); event = bt_ctf_event_class_create(name); if (!event) { diag("Failed to create complex event"); goto error; } outer = create_integer_struct(); if (!outer) { diag("Failed to initialize integer structure"); goto error; } inner = create_integer_struct(); if (!inner) { diag("Failed to initialize integer structure"); goto error; } ret = bt_ctf_field_type_structure_add_field(outer, inner, "payload_struct"); if (ret) { diag("Failed to add inner structure to outer structure"); goto error; } ret = bt_ctf_event_class_set_payload_type(event, outer); if (ret) { diag("Failed to set complex event payload"); goto error; } end: BT_PUT(inner); BT_PUT(outer); return event; error: BT_PUT(event); goto end;; }
static void bt_notification_packet_end_destroy(struct bt_object *obj) { struct bt_notification_packet_end *notification = (struct bt_notification_packet_end *) obj; BT_PUT(notification->packet); g_free(notification); }
int bt_ctf_trace_set_environment_field_string(struct bt_ctf_trace *trace, const char *name, const char *value) { int ret = 0; struct bt_value *env_value_string_obj = NULL; if (!trace || !name || !value) { ret = -1; goto end; } if (trace->frozen) { /* * New environment fields may be added to a frozen trace, * but existing fields may not be changed. */ struct bt_value *attribute = bt_ctf_attributes_get_field_value_by_name( trace->environment, name); if (attribute) { BT_PUT(attribute); ret = -1; goto end; } } env_value_string_obj = bt_value_string_create_init(value); if (!env_value_string_obj) { ret = -1; goto end; } if (trace->frozen) { bt_value_freeze(env_value_string_obj); } ret = bt_ctf_trace_set_environment_field(trace, name, env_value_string_obj); end: BT_PUT(env_value_string_obj); return ret; }
void bt_btr_destroy(struct bt_btr *btr) { if (btr->stack) { stack_destroy(btr->stack); } BT_LOGD("Destroying BTR: addr=%p", btr); BT_PUT(btr->cur_basic_field_type); g_free(btr); }
static void reset(struct bt_btr *btr) { BT_LOGD("Resetting BTR: addr=%p", btr); stack_clear(btr->stack); BT_PUT(btr->cur_basic_field_type); stitch_reset(btr); btr->buf.addr = NULL; btr->last_bo = BT_BYTE_ORDER_UNKNOWN; }
BT_HIDDEN const char *bt_attributes_get_field_name(struct bt_value *attr_obj, uint64_t index) { int rc; const char *ret = NULL; struct bt_value *attr_field_obj = NULL; struct bt_value *attr_field_name_obj = NULL; if (!attr_obj) { BT_LOGW_STR("Invalid parameter: attributes object is NULL."); goto end; } attr_field_obj = bt_value_array_get(attr_obj, index); if (!attr_field_obj) { BT_LOGE("Cannot get attributes object's array value's element by index: " "value-addr=%p, index=%" PRIu64, attr_obj, index); goto end; } attr_field_name_obj = bt_value_array_get(attr_field_obj, BT_ATTR_NAME_INDEX); if (!attr_field_name_obj) { BT_LOGE("Cannot get attribute array value's element by index: " "value-addr=%p, index=%" PRIu64, attr_field_obj, (uint64_t) BT_ATTR_NAME_INDEX); goto end; } rc = bt_value_string_get(attr_field_name_obj, &ret); if (rc) { BT_LOGE("Cannot get raw value from string value: value-addr=%p", attr_field_name_obj); ret = NULL; } end: BT_PUT(attr_field_name_obj); BT_PUT(attr_field_obj); return ret; }
static struct bt_ctf_trace *create_tc1(void) { int ret; struct bt_ctf_trace *tc1 = NULL; struct bt_ctf_stream_class *sc1 = NULL, *sc2 = NULL; tc1 = bt_ctf_trace_create(); if (!tc1) { diag("bt_ctf_trace_create returned NULL"); goto error; } sc1 = create_sc1(); ok(sc1, "Create SC1"); if (!sc1) { goto error; } ret = bt_ctf_trace_add_stream_class(tc1, sc1); ok(!ret, "Add SC1 to TC1"); if (ret) { goto error; } sc2 = create_sc2(); ok(sc2, "Create SC2"); if (!sc2) { goto error; } ret = bt_ctf_trace_add_stream_class(tc1, sc2); ok(!ret, "Add SC2 to TC1"); if (ret) { goto error; } end: BT_PUT(sc1); BT_PUT(sc2); return tc1; error: BT_PUT(tc1); goto end; }
struct bt_ctf_packet *bt_ctf_packet_create( struct bt_ctf_stream *stream) { struct bt_ctf_packet *packet = NULL; struct bt_ctf_stream_class *stream_class = NULL; struct bt_ctf_trace *trace = NULL; if (!stream || stream->pos.fd >= 0) { goto end; } stream_class = bt_ctf_stream_get_class(stream); assert(stream_class); trace = bt_ctf_stream_class_get_trace(stream_class); assert(trace); packet = g_new0(struct bt_ctf_packet, 1); if (!packet) { goto end; } bt_object_init(packet, bt_ctf_packet_destroy); packet->stream = bt_get(stream); packet->header = bt_ctf_field_create(trace->packet_header_type); if (!packet->header) { BT_PUT(packet); goto end; } packet->context = bt_ctf_field_create( stream->stream_class->packet_context_type); if (!packet->context) { BT_PUT(packet); goto end; } end: BT_PUT(trace); BT_PUT(stream_class); return packet; }
BT_HIDDEN int bt_ctf_event_class_set_id(struct bt_ctf_event_class *event_class, uint32_t id) { int ret = 0; struct bt_value *obj = NULL; struct bt_ctf_stream_class *stream_class = NULL; if (!event_class) { ret = -1; goto end; } stream_class = bt_ctf_event_class_get_stream_class(event_class); if (stream_class) { /* * We don't allow changing the id if the event class has already * been added to a stream class. */ ret = -1; goto end; } obj = bt_ctf_attributes_get_field_value(event_class->attributes, BT_CTF_EVENT_CLASS_ATTR_ID_INDEX); if (!obj) { goto end; } if (bt_value_integer_set(obj, id)) { ret = -1; goto end; } end: BT_PUT(obj); BT_PUT(stream_class); return ret; }