From 0b29603d15c2b685ecb2359242b733edc0a09d83 Mon Sep 17 00:00:00 2001 From: Philippe Proulx Date: Mon, 16 Apr 2018 20:25:31 -0400 Subject: [PATCH] src.ctf.fs: use "borrow" functions where possible Use "borrow" API functions when possible to avoid useless reference count changes. Signed-off-by: Philippe Proulx --- plugins/ctf/common/utils/utils.c | 9 +++-- plugins/ctf/common/utils/utils.h | 2 +- plugins/ctf/fs-src/data-stream-file.c | 52 +++++++++++---------------- plugins/ctf/fs-src/fs.c | 27 +++++--------- plugins/ctf/fs-src/query.c | 10 +++--- 5 files changed, 39 insertions(+), 61 deletions(-) diff --git a/plugins/ctf/common/utils/utils.c b/plugins/ctf/common/utils/utils.c index 70261f91..10662a80 100644 --- a/plugins/ctf/common/utils/utils.c +++ b/plugins/ctf/common/utils/utils.c @@ -27,7 +27,7 @@ #include "utils.h" -struct bt_stream_class *ctf_utils_stream_class_from_packet_header( +struct bt_stream_class *ctf_utils_borrow_stream_class_from_packet_header( struct bt_trace *trace, struct bt_field *packet_header_field) { @@ -40,7 +40,7 @@ struct bt_stream_class *ctf_utils_stream_class_from_packet_header( goto single_stream_class; } - stream_id_field = bt_field_structure_get_field_by_name( + stream_id_field = bt_field_structure_borrow_field_by_name( packet_header_field, "stream_id"); if (!stream_id_field) { goto single_stream_class; @@ -59,13 +59,12 @@ single_stream_class: goto end; } - stream_class = bt_trace_get_stream_class_by_index(trace, 0); + stream_class = bt_trace_borrow_stream_class_by_index(trace, 0); } else { - stream_class = bt_trace_get_stream_class_by_id(trace, + stream_class = bt_trace_borrow_stream_class_by_id(trace, stream_id); } end: - bt_put(stream_id_field); return stream_class; } diff --git a/plugins/ctf/common/utils/utils.h b/plugins/ctf/common/utils/utils.h index f6d170bb..179c97bc 100644 --- a/plugins/ctf/common/utils/utils.h +++ b/plugins/ctf/common/utils/utils.h @@ -28,7 +28,7 @@ #include #include -struct bt_stream_class *ctf_utils_stream_class_from_packet_header( +struct bt_stream_class *ctf_utils_borrow_stream_class_from_packet_header( struct bt_trace *trace, struct bt_field *packet_header_field); diff --git a/plugins/ctf/fs-src/data-stream-file.c b/plugins/ctf/fs-src/data-stream-file.c index 9053b2f7..db266af1 100644 --- a/plugins/ctf/fs-src/data-stream-file.c +++ b/plugins/ctf/fs-src/data-stream-file.c @@ -181,9 +181,7 @@ struct bt_stream *medop_get_stream( struct bt_stream_class *ds_file_stream_class; struct bt_stream *stream = NULL; - ds_file_stream_class = bt_stream_get_class(ds_file->stream); - bt_put(ds_file_stream_class); - + ds_file_stream_class = bt_stream_borrow_class(ds_file->stream); if (stream_class != ds_file_stream_class) { /* * Not supported: two packets described by two different @@ -293,29 +291,29 @@ struct ctf_fs_ds_index_entry *ctf_fs_ds_index_add_new_entry( } static -struct bt_clock_class *get_field_mapped_clock_class( +struct bt_clock_class *borrow_field_mapped_clock_class( struct bt_field *field) { struct bt_field_type *field_type; struct bt_clock_class *clock_class = NULL; - field_type = bt_field_get_type(field); + field_type = bt_field_borrow_type(field); if (!field_type) { goto end; } - clock_class = bt_field_type_integer_get_mapped_clock_class( - field_type); + clock_class = bt_field_type_integer_borrow_mapped_clock_class( + field_type); if (!clock_class) { goto end; } + end: - bt_put(field_type); return clock_class; } static -int get_packet_bounds_from_packet_context( +int borrow_packet_bounds_from_packet_context( struct bt_field *packet_context, struct bt_clock_class **_timestamp_begin_cc, struct bt_field **_timestamp_begin, @@ -328,7 +326,7 @@ int get_packet_bounds_from_packet_context( struct bt_field *timestamp_begin = NULL; struct bt_field *timestamp_end = NULL; - timestamp_begin = bt_field_structure_get_field_by_name( + timestamp_begin = bt_field_structure_borrow_field_by_name( packet_context, "timestamp_begin"); if (!timestamp_begin) { BT_LOGD_STR("Cannot retrieve timestamp_begin field in packet context."); @@ -336,12 +334,12 @@ int get_packet_bounds_from_packet_context( goto end; } - timestamp_begin_cc = get_field_mapped_clock_class(timestamp_begin); + timestamp_begin_cc = borrow_field_mapped_clock_class(timestamp_begin); if (!timestamp_begin_cc) { BT_LOGD_STR("Cannot retrieve the clock mapped to timestamp_begin."); } - timestamp_end = bt_field_structure_get_field_by_name( + timestamp_end = bt_field_structure_borrow_field_by_name( packet_context, "timestamp_end"); if (!timestamp_end) { BT_LOGD_STR("Cannot retrieve timestamp_end field in packet context."); @@ -349,33 +347,29 @@ int get_packet_bounds_from_packet_context( goto end; } - timestamp_end_cc = get_field_mapped_clock_class(timestamp_end); + timestamp_end_cc = borrow_field_mapped_clock_class(timestamp_end); if (!timestamp_end_cc) { BT_LOGD_STR("Cannot retrieve the clock mapped to timestamp_end."); } if (_timestamp_begin_cc) { - *_timestamp_begin_cc = bt_get(timestamp_begin_cc); + *_timestamp_begin_cc = timestamp_begin_cc; } if (_timestamp_begin) { - *_timestamp_begin = bt_get(timestamp_begin); + *_timestamp_begin = timestamp_begin; } if (_timestamp_end_cc) { - *_timestamp_end_cc = bt_get(timestamp_end_cc); + *_timestamp_end_cc = timestamp_end_cc; } if (_timestamp_end) { - *_timestamp_end = bt_get(timestamp_end); + *_timestamp_end = timestamp_end; } end: - bt_put(timestamp_begin_cc); - bt_put(timestamp_end_cc); - bt_put(timestamp_begin); - bt_put(timestamp_end); return ret; } static -int get_ds_file_packet_bounds_clock_classes(struct ctf_fs_ds_file *ds_file, +int borrow_ds_file_packet_bounds_clock_classes(struct ctf_fs_ds_file *ds_file, struct bt_clock_class **timestamp_begin_cc, struct bt_clock_class **timestamp_end_cc) { @@ -390,9 +384,10 @@ int get_ds_file_packet_bounds_clock_classes(struct ctf_fs_ds_file *ds_file, goto end; } - ret = get_packet_bounds_from_packet_context(packet_context, + ret = borrow_packet_bounds_from_packet_context(packet_context, timestamp_begin_cc, NULL, timestamp_end_cc, NULL); + end: bt_put(packet_context); return ret; @@ -446,7 +441,7 @@ struct ctf_fs_ds_index *build_index_from_idx_file( BT_LOGD("Building index from .idx file of stream file %s", ds_file->file->path->str); - ret = get_ds_file_packet_bounds_clock_classes(ds_file, + ret = borrow_ds_file_packet_bounds_clock_classes(ds_file, ×tamp_begin_cc, ×tamp_end_cc); if (ret) { BT_LOGD_STR("Cannot get clock classes of \"timestamp_begin\" " @@ -594,8 +589,6 @@ end: if (mapped_file) { g_mapped_file_unref(mapped_file); } - bt_put(timestamp_begin_cc); - bt_put(timestamp_end_cc); return index; error: ctf_fs_ds_index_destroy(index); @@ -614,7 +607,7 @@ int init_index_entry(struct ctf_fs_ds_index_entry *entry, struct bt_clock_class *timestamp_begin_cc = NULL; struct bt_clock_class *timestamp_end_cc = NULL; - ret = get_packet_bounds_from_packet_context(packet_context, + ret = borrow_packet_bounds_from_packet_context(packet_context, ×tamp_begin_cc, ×tamp_begin, ×tamp_end_cc, ×tamp_end); if (ret || !timestamp_begin_cc || !timestamp_begin || @@ -656,11 +649,8 @@ int init_index_entry(struct ctf_fs_ds_index_entry *entry, BT_LOGD_STR("Failed to convert raw timestamp to nanoseconds since Epoch."); goto end; } + end: - bt_put(timestamp_begin); - bt_put(timestamp_begin_cc); - bt_put(timestamp_end); - bt_put(timestamp_end_cc); return ret; } diff --git a/plugins/ctf/fs-src/fs.c b/plugins/ctf/fs-src/fs.c index 4d8fea74..523f6c34 100644 --- a/plugins/ctf/fs-src/fs.c +++ b/plugins/ctf/fs-src/fs.c @@ -425,7 +425,7 @@ uint64_t get_packet_header_stream_instance_id(struct ctf_fs_trace *ctf_fs_trace, goto end; } - stream_instance_id_field = bt_field_structure_get_field_by_name( + stream_instance_id_field = bt_field_structure_borrow_field_by_name( packet_header_field, "stream_instance_id"); if (!stream_instance_id_field) { goto end; @@ -460,16 +460,16 @@ uint64_t get_packet_context_timestamp_begin_ns( goto end; } - timestamp_begin_field = bt_field_structure_get_field_by_name( + timestamp_begin_field = bt_field_structure_borrow_field_by_name( packet_context_field, "timestamp_begin"); if (!timestamp_begin_field) { goto end; } - timestamp_begin_ft = bt_field_get_type(timestamp_begin_field); + timestamp_begin_ft = bt_field_borrow_type(timestamp_begin_field); BT_ASSERT(timestamp_begin_ft); timestamp_begin_clock_class = - bt_field_type_integer_get_mapped_clock_class(timestamp_begin_ft); + bt_field_type_integer_borrow_mapped_clock_class(timestamp_begin_ft); if (!timestamp_begin_clock_class) { goto end; } @@ -495,9 +495,6 @@ uint64_t get_packet_context_timestamp_begin_ns( timestamp_begin_ns = (uint64_t) timestamp_begin_ns_signed; end: - bt_put(timestamp_begin_field); - bt_put(timestamp_begin_ft); - bt_put(timestamp_begin_clock_class); bt_put(clock_value); return timestamp_begin_ns; } @@ -693,7 +690,7 @@ int add_ds_file_to_ds_file_group(struct ctf_fs_trace *ctf_fs_trace, packet_header_field); begin_ns = get_packet_context_timestamp_begin_ns(ctf_fs_trace, packet_context_field); - stream_class = ctf_utils_stream_class_from_packet_header( + stream_class = ctf_utils_borrow_stream_class_from_packet_header( ctf_fs_trace->metadata->trace, packet_header_field); if (!stream_class) { goto error; @@ -794,7 +791,6 @@ end: ctf_fs_ds_index_destroy(index); bt_put(packet_header_field); bt_put(packet_context_field); - bt_put(stream_class); return ret; } @@ -953,13 +949,12 @@ int create_cc_prio_map(struct ctf_fs_trace *ctf_fs_trace) for (i = 0; i < count; i++) { struct bt_clock_class *clock_class = - bt_trace_get_clock_class_by_index( + bt_trace_borrow_clock_class_by_index( ctf_fs_trace->metadata->trace, i); BT_ASSERT(clock_class); ret = bt_clock_class_priority_map_add_clock_class( ctf_fs_trace->cc_prio_map, clock_class, 0); - BT_PUT(clock_class); if (ret) { goto end; @@ -1330,15 +1325,14 @@ struct ctf_fs_component *ctf_fs_create(struct bt_private_component *priv_comp, * private component should also exist. */ ctf_fs->priv_comp = priv_comp; - value = bt_value_map_get(params, "path"); + value = bt_value_map_borrow(params, "path"); if (value && !bt_value_is_string(value)) { goto error; } value_ret = bt_value_string_get(value, &path_param); BT_ASSERT(value_ret == BT_VALUE_STATUS_OK); - BT_PUT(value); - value = bt_value_map_get(params, "clock-class-offset-s"); + value = bt_value_map_borrow(params, "clock-class-offset-s"); if (value) { if (!bt_value_is_integer(value)) { BT_LOGE("clock-class-offset-s should be an integer"); @@ -1347,10 +1341,9 @@ struct ctf_fs_component *ctf_fs_create(struct bt_private_component *priv_comp, value_ret = bt_value_integer_get(value, &ctf_fs->metadata_config.clock_class_offset_s); BT_ASSERT(value_ret == BT_VALUE_STATUS_OK); - BT_PUT(value); } - value = bt_value_map_get(params, "clock-class-offset-ns"); + value = bt_value_map_borrow(params, "clock-class-offset-ns"); if (value) { if (!bt_value_is_integer(value)) { BT_LOGE("clock-class-offset-ns should be an integer"); @@ -1359,7 +1352,6 @@ struct ctf_fs_component *ctf_fs_create(struct bt_private_component *priv_comp, value_ret = bt_value_integer_get(value, &ctf_fs->metadata_config.clock_class_offset_ns); BT_ASSERT(value_ret == BT_VALUE_STATUS_OK); - BT_PUT(value); } ctf_fs->port_data = g_ptr_array_new_with_free_func(port_data_destroy); @@ -1386,7 +1378,6 @@ error: BT_ASSERT(ret == BT_COMPONENT_STATUS_OK); end: - bt_put(value); return ctf_fs; } diff --git a/plugins/ctf/fs-src/query.c b/plugins/ctf/fs-src/query.c index 04ab457f..a54cbb0d 100644 --- a/plugins/ctf/fs-src/query.c +++ b/plugins/ctf/fs-src/query.c @@ -78,7 +78,7 @@ struct bt_component_class_query_method_return metadata_info_query( goto error; } - path_value = bt_value_map_get(params, "path"); + path_value = bt_value_map_borrow(params, "path"); ret = bt_value_string_get(path_value, &path); if (ret) { BT_LOGE_STR("Cannot get `path` string parameter."); @@ -172,7 +172,6 @@ error: } end: - bt_put(path_value); free(metadata_text); if (g_metadata_text) { @@ -247,7 +246,7 @@ int add_stream_ids(struct bt_value *info, struct bt_stream *stream) } } - stream_class = bt_stream_get_class(stream); + stream_class = bt_stream_borrow_class(stream); if (!stream_class) { ret = -1; goto end; @@ -264,8 +263,8 @@ int add_stream_ids(struct bt_value *info, struct bt_stream *stream) ret = -1; goto end; } + end: - bt_put(stream_class); return ret; } @@ -489,7 +488,7 @@ struct bt_component_class_query_method_return trace_info_query( goto error; } - path_value = bt_value_map_get(params, "path"); + path_value = bt_value_map_borrow(params, "path"); ret = bt_value_string_get(path_value, &path); if (ret) { BT_LOGE("Cannot get `path` string parameter."); @@ -581,6 +580,5 @@ end: g_list_free(trace_names); } /* "path" becomes invalid with the release of path_value. */ - bt_put(path_value); return query_ret; } -- 2.34.1