From afb0f12beee7f3aa65156e27a76b627dfb3b52e1 Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Mon, 23 Oct 2023 22:18:14 -0400 Subject: [PATCH] ctf: allocate some structures with new Allocate some key structures in the ctf plugin with new (and free with delete), so we can start using non-POD fields in them. Initialize all fields to 0 / nullptr to replicate what g_new0 did. Add ctf_fs_ds_index_entry_destroy, to abstract how this object is destroyed (it is currently being g_free'd at multiple places) and to use it as a g_ptr_array_new_with_free_func callback. Change-Id: Ic0f893655db22c964641639aa0625d820af71587 Signed-off-by: Simon Marchi Reviewed-on: https://review.lttng.org/c/babeltrace/+/8021 Reviewed-by: Philippe Proulx Reviewed-on: https://review.lttng.org/c/babeltrace/+/12195 Tested-by: jenkins --- src/plugins/ctf/common/src/bfcr/bfcr.cpp | 47 +++---- .../src/metadata/tsdl/ctf-meta-resolve.cpp | 30 ++--- .../ctf/common/src/metadata/tsdl/decoder.cpp | 25 ++-- .../ctf/common/src/metadata/tsdl/decoder.hpp | 16 +-- .../src/metadata/tsdl/visitor-generate-ir.cpp | 22 +--- .../ctf/common/src/msg-iter/msg-iter.cpp | 97 +++++++------- src/plugins/ctf/fs-src/data-stream-file.cpp | 74 ++++------- src/plugins/ctf/fs-src/data-stream-file.hpp | 24 ++-- src/plugins/ctf/fs-src/file.cpp | 9 +- src/plugins/ctf/fs-src/fs.cpp | 66 +++------- src/plugins/ctf/fs-src/fs.hpp | 89 ++++++------- src/plugins/ctf/fs-src/metadata.cpp | 13 +- src/plugins/ctf/fs-src/metadata.hpp | 6 +- src/plugins/ctf/fs-src/query.cpp | 4 +- src/plugins/ctf/lttng-live/data-stream.cpp | 11 +- src/plugins/ctf/lttng-live/lttng-live.cpp | 59 +++------ src/plugins/ctf/lttng-live/lttng-live.hpp | 123 +++++++++--------- src/plugins/ctf/lttng-live/metadata.cpp | 12 +- .../ctf/lttng-live/viewer-connection.cpp | 5 +- .../ctf/lttng-live/viewer-connection.hpp | 28 ++-- 20 files changed, 314 insertions(+), 446 deletions(-) diff --git a/src/plugins/ctf/common/src/bfcr/bfcr.cpp b/src/plugins/ctf/common/src/bfcr/bfcr.cpp index 9682d30d..920d892e 100644 --- a/src/plugins/ctf/common/src/bfcr/bfcr.cpp +++ b/src/plugins/ctf/common/src/bfcr/bfcr.cpp @@ -80,19 +80,19 @@ enum bfcr_state /* Binary class reader */ struct bt_bfcr { - bt_logging_level log_level; + bt_logging_level log_level = static_cast(0); /* Weak */ - bt_self_component *self_comp; + bt_self_component *self_comp = nullptr; /* BFCR stack */ - struct stack *stack; + struct stack *stack = nullptr; /* Current basic field class */ - struct ctf_field_class *cur_basic_field_class; + struct ctf_field_class *cur_basic_field_class = nullptr; /* Current state */ - enum bfcr_state state; + enum bfcr_state state = static_cast(0); /* * Last basic field class's byte order. @@ -104,54 +104,54 @@ struct bt_bfcr * This is set to CTF_BYTE_ORDER_UNKNOWN on reset and when the last * basic field class was a string class. */ - enum ctf_byte_order last_bo; + enum ctf_byte_order last_bo = CTF_BYTE_ORDER_UNKNOWN; /* Current byte order (copied to last_bo after a successful read) */ - enum ctf_byte_order cur_bo; + enum ctf_byte_order cur_bo = CTF_BYTE_ORDER_UNKNOWN; /* Stitch buffer infos */ struct { /* Stitch buffer */ - uint8_t buf[16]; + uint8_t buf[16] {}; /* Offset, within stitch buffer, of first bit */ - size_t offset; + size_t offset = 0; /* Length (bits) of data in stitch buffer from offset */ - size_t at; + size_t at = 0; } stitch; /* User buffer infos */ struct { /* Address */ - const uint8_t *addr; + const uint8_t *addr = nullptr; /* Offset of data from address (bits) */ - size_t offset; + size_t offset = 0; /* Current position from offset (bits) */ - size_t at; + size_t at = 0; /* Offset of offset within whole packet (bits) */ - size_t packet_offset; + size_t packet_offset = 0; /* Data size in buffer (bits) */ - size_t sz; + size_t sz = 0; /* Buffer size (bytes) */ - size_t buf_sz; + size_t buf_sz = 0; } buf; /* User stuff */ struct { /* Callback functions */ - struct bt_bfcr_cbs cbs; + bt_bfcr_cbs cbs {}; /* Private data */ - void *data; + void *data = nullptr; } user; }; @@ -1103,17 +1103,10 @@ static inline enum bt_bfcr_status handle_state(struct bt_bfcr *bfcr) struct bt_bfcr *bt_bfcr_create(struct bt_bfcr_cbs cbs, void *data, bt_logging_level log_level, bt_self_component *self_comp) { - struct bt_bfcr *bfcr; - BT_COMP_LOG_CUR_LVL(BT_LOG_DEBUG, log_level, self_comp, "Creating binary field class reader (BFCR)."); - bfcr = g_new0(struct bt_bfcr, 1); - if (!bfcr) { - BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp, - "Failed to allocate one binary class reader."); - goto end; - } + bt_bfcr *bfcr = new bt_bfcr; bfcr->log_level = log_level; bfcr->self_comp = self_comp; bfcr->stack = stack_new(bfcr); @@ -1140,7 +1133,7 @@ void bt_bfcr_destroy(struct bt_bfcr *bfcr) } BT_COMP_LOGD("Destroying BFCR: addr=%p", bfcr); - g_free(bfcr); + delete bfcr; } static void reset(struct bt_bfcr *bfcr) diff --git a/src/plugins/ctf/common/src/metadata/tsdl/ctf-meta-resolve.cpp b/src/plugins/ctf/common/src/metadata/tsdl/ctf-meta-resolve.cpp index 1f7ffe57..6f8ca2d9 100644 --- a/src/plugins/ctf/common/src/metadata/tsdl/ctf-meta-resolve.cpp +++ b/src/plugins/ctf/common/src/metadata/tsdl/ctf-meta-resolve.cpp @@ -46,30 +46,30 @@ struct field_class_stack_frame */ struct resolve_context { - bt_logging_level log_level; + bt_logging_level log_level = (bt_logging_level) 0; /* Weak, exactly one of these must be set */ - bt_self_component *self_comp; - bt_self_component_class *self_comp_class; + bt_self_component *self_comp = nullptr; + bt_self_component_class *self_comp_class = nullptr; - struct ctf_trace_class *tc; - struct ctf_stream_class *sc; - struct ctf_event_class *ec; + struct ctf_trace_class *tc = nullptr; + struct ctf_stream_class *sc = nullptr; + struct ctf_event_class *ec = nullptr; struct { - struct ctf_field_class *packet_header; - struct ctf_field_class *packet_context; - struct ctf_field_class *event_header; - struct ctf_field_class *event_common_context; - struct ctf_field_class *event_spec_context; - struct ctf_field_class *event_payload; + struct ctf_field_class *packet_header = nullptr; + struct ctf_field_class *packet_context = nullptr; + struct ctf_field_class *event_header = nullptr; + struct ctf_field_class *event_common_context = nullptr; + struct ctf_field_class *event_spec_context = nullptr; + struct ctf_field_class *event_payload = nullptr; } scopes; /* Root scope being visited */ - enum ctf_scope root_scope; - field_class_stack_t *field_class_stack; - struct ctf_field_class *cur_fc; + enum ctf_scope root_scope = CTF_SCOPE_PACKET_HEADER; + field_class_stack_t *field_class_stack = nullptr; + struct ctf_field_class *cur_fc = nullptr; }; /* TSDL dynamic scope prefixes as defined in CTF Section 7.3.2 */ diff --git a/src/plugins/ctf/common/src/metadata/tsdl/decoder.cpp b/src/plugins/ctf/common/src/metadata/tsdl/decoder.cpp index deaeedb4..382de995 100644 --- a/src/plugins/ctf/common/src/metadata/tsdl/decoder.cpp +++ b/src/plugins/ctf/common/src/metadata/tsdl/decoder.cpp @@ -34,15 +34,15 @@ struct ctf_metadata_decoder { - struct ctf_scanner *scanner; - GString *text; - struct ctf_visitor_generate_ir *visitor; - bt_uuid_t uuid; - bool is_uuid_set; - int bo; + struct ctf_scanner *scanner = nullptr; + GString *text = nullptr; + struct ctf_visitor_generate_ir *visitor = nullptr; + bt_uuid_t uuid {}; + bool is_uuid_set = false; + int bo = 0; struct ctf_metadata_decoder_config config; struct meta_log_config log_cfg; - bool has_checked_plaintext_signature; + bool has_checked_plaintext_signature = false; }; struct packet_header @@ -95,8 +95,6 @@ end: struct ctf_metadata_decoder * ctf_metadata_decoder_create(const struct ctf_metadata_decoder_config *config) { - struct ctf_metadata_decoder *mdec = g_new0(struct ctf_metadata_decoder, 1); - BT_ASSERT(config); BT_COMP_LOG_CUR_LVL(BT_LOG_DEBUG, config->log_level, config->self_comp, "Creating CTF metadata decoder: " @@ -104,12 +102,7 @@ ctf_metadata_decoder_create(const struct ctf_metadata_decoder_config *config) "clock-class-offset-ns=%" PRId64, config->clock_class_offset_s, config->clock_class_offset_ns); - if (!mdec) { - BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, config->log_level, config->self_comp, - "Failed to allocate one CTF metadata decoder."); - goto end; - } - + ctf_metadata_decoder *mdec = new ctf_metadata_decoder; mdec->log_cfg.log_level = config->log_level; mdec->log_cfg.self_comp = config->self_comp; mdec->log_cfg.self_comp_class = config->self_comp_class; @@ -169,7 +162,7 @@ void ctf_metadata_decoder_destroy(struct ctf_metadata_decoder *mdec) BT_COMP_LOGD("Destroying CTF metadata decoder: addr=%p", mdec); ctf_visitor_generate_ir_destroy(mdec->visitor); - g_free(mdec); + delete mdec; } enum ctf_metadata_decoder_status diff --git a/src/plugins/ctf/common/src/metadata/tsdl/decoder.hpp b/src/plugins/ctf/common/src/metadata/tsdl/decoder.hpp index d4385f4c..7bb650ca 100644 --- a/src/plugins/ctf/common/src/metadata/tsdl/decoder.hpp +++ b/src/plugins/ctf/common/src/metadata/tsdl/decoder.hpp @@ -29,28 +29,28 @@ enum ctf_metadata_decoder_status struct ctf_metadata_decoder_config { /* Active log level to use */ - bt_logging_level log_level; + bt_logging_level log_level = (bt_logging_level) 0; /* * Component or component class to use for logging (exactly one of * them must be non-`NULL`); weak */ - bt_self_component *self_comp; - bt_self_component_class *self_comp_class; + bt_self_component *self_comp = nullptr; + bt_self_component_class *self_comp_class = nullptr; /* Additional clock class offset to apply */ - int64_t clock_class_offset_s; - int64_t clock_class_offset_ns; - bool force_clock_class_origin_unix_epoch; + int64_t clock_class_offset_s = 0; + int64_t clock_class_offset_ns = 0; + bool force_clock_class_origin_unix_epoch = false; /* True to create trace class objects */ - bool create_trace_class; + bool create_trace_class = false; /* * True to keep the plain text when content is appended with * ctf_metadata_decoder_append_content(). */ - bool keep_plain_text; + bool keep_plain_text = false; }; /* diff --git a/src/plugins/ctf/common/src/metadata/tsdl/visitor-generate-ir.cpp b/src/plugins/ctf/common/src/metadata/tsdl/visitor-generate-ir.cpp index c53c4d8a..6155641d 100644 --- a/src/plugins/ctf/common/src/metadata/tsdl/visitor-generate-ir.cpp +++ b/src/plugins/ctf/common/src/metadata/tsdl/visitor-generate-ir.cpp @@ -186,19 +186,19 @@ struct ctf_visitor_generate_ir struct meta_log_config log_cfg; /* Trace IR trace class being filled (owned by this) */ - bt_trace_class *trace_class; + bt_trace_class *trace_class = nullptr; /* CTF meta trace being filled (owned by this) */ - struct ctf_trace_class *ctf_tc; + struct ctf_trace_class *ctf_tc = nullptr; /* Current declaration scope (top of the stack) (owned by this) */ - struct ctx_decl_scope *current_scope; + struct ctx_decl_scope *current_scope = nullptr; /* True if trace declaration is visited */ - bool is_trace_visited; + bool is_trace_visited = false; /* True if this is an LTTng trace */ - bool is_lttng; + bool is_lttng = false; /* Config passed by the user */ struct ctf_metadata_decoder_config decoder_config; @@ -512,7 +512,7 @@ static void ctx_destroy(struct ctf_visitor_generate_ir *ctx) ctf_trace_class_destroy(ctx->ctf_tc); } - g_free(ctx); + delete ctx; end: return; @@ -527,17 +527,9 @@ end: static struct ctf_visitor_generate_ir * ctx_create(const struct ctf_metadata_decoder_config *decoder_config) { - struct ctf_visitor_generate_ir *ctx = NULL; - BT_ASSERT(decoder_config); - ctx = g_new0(struct ctf_visitor_generate_ir, 1); - if (!ctx) { - BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, decoder_config->log_level, decoder_config->self_comp, - "Failed to allocate one visitor context."); - goto error; - } - + ctf_visitor_generate_ir *ctx = new ctf_visitor_generate_ir; ctx->log_cfg.log_level = decoder_config->log_level; ctx->log_cfg.self_comp = decoder_config->self_comp; ctx->log_cfg.self_comp_class = decoder_config->self_comp_class; diff --git a/src/plugins/ctf/common/src/msg-iter/msg-iter.cpp b/src/plugins/ctf/common/src/msg-iter/msg-iter.cpp index 37e88c17..311affd8 100644 --- a/src/plugins/ctf/common/src/msg-iter/msg-iter.cpp +++ b/src/plugins/ctf/common/src/msg-iter/msg-iter.cpp @@ -97,26 +97,26 @@ enum state struct end_of_packet_snapshots { - uint64_t discarded_events; - uint64_t packets; - uint64_t beginning_clock; - uint64_t end_clock; + uint64_t discarded_events = 0; + uint64_t packets = 0; + uint64_t beginning_clock = 0; + uint64_t end_clock = 0; }; /* CTF message iterator */ struct ctf_msg_iter { /* Visit stack */ - struct stack *stack; + struct stack *stack = nullptr; /* Current message iterator to create messages (weak) */ - bt_self_message_iterator *self_msg_iter; + bt_self_message_iterator *self_msg_iter = nullptr; /* * True if library objects are unavailable during the decoding and * should not be created/used. */ - bool dry_run; + bool dry_run = false; /* * Current dynamic scope field pointer. @@ -124,48 +124,48 @@ struct ctf_msg_iter * This is set by read_dscope_begin_state() and contains the * value of one of the pointers in `dscopes` below. */ - bt_field *cur_dscope_field; + bt_field *cur_dscope_field = nullptr; /* * True if we're done filling a string field from a text * array/sequence payload. */ - bool done_filling_string; + bool done_filling_string = false; /* Trace and classes */ /* True to set IR fields */ - bool set_ir_fields; + bool set_ir_fields = false; struct { - struct ctf_trace_class *tc; - struct ctf_stream_class *sc; - struct ctf_event_class *ec; + struct ctf_trace_class *tc = nullptr; + struct ctf_stream_class *sc = nullptr; + struct ctf_event_class *ec = nullptr; } meta; /* Current packet (NULL if not created yet) */ - bt_packet *packet; + bt_packet *packet = nullptr; /* Current stream (NULL if not set yet) */ - bt_stream *stream; + bt_stream *stream = nullptr; /* Current event (NULL if not created yet) */ - bt_event *event; + bt_event *event = nullptr; /* Current event message (NULL if not created yet) */ - bt_message *event_msg; + bt_message *event_msg = nullptr; /* * True if we need to emit a packet beginning message before we emit * the next event message or the packet end message. */ - bool emit_delayed_packet_beginning_msg; + bool emit_delayed_packet_beginning_msg = false; /* * True if this is the first packet we are reading, and therefore if we * should emit a stream beginning message. */ - bool emit_stream_beginning_message; + bool emit_stream_beginning_message = false; /* * True if we need to emit a stream end message at the end of the @@ -173,73 +173,73 @@ struct ctf_msg_iter * never send a stream beginning message which removes the need to emit * a stream end message. */ - bool emit_stream_end_message; + bool emit_stream_end_message = false; /* Database of current dynamic scopes */ struct { - bt_field *stream_packet_context; - bt_field *event_common_context; - bt_field *event_spec_context; - bt_field *event_payload; + bt_field *stream_packet_context = nullptr; + bt_field *event_common_context = nullptr; + bt_field *event_spec_context = nullptr; + bt_field *event_payload = nullptr; } dscopes; /* Current state */ - enum state state; + enum state state = STATE_INIT; /* Current medium buffer data */ struct { /* Last address provided by medium */ - const uint8_t *addr; + const uint8_t *addr = nullptr; /* Buffer size provided by medium (bytes) */ - size_t sz; + size_t sz = 0; /* Offset within whole packet of addr (bits) */ - size_t packet_offset; + size_t packet_offset = 0; /* Current position from addr (bits) */ - size_t at; + size_t at = 0; /* Position of the last event header from addr (bits) */ - size_t last_eh_at; + size_t last_eh_at = 0; } buf; /* Binary type reader */ - struct bt_bfcr *bfcr; + struct bt_bfcr *bfcr = nullptr; /* Current medium data */ struct { struct ctf_msg_iter_medium_ops medops; - size_t max_request_sz; - void *data; + size_t max_request_sz = 0; + void *data = nullptr; } medium; /* Current packet size (bits) (-1 if unknown) */ - int64_t cur_exp_packet_total_size; + int64_t cur_exp_packet_total_size = 0; /* Current content size (bits) (-1 if unknown) */ - int64_t cur_exp_packet_content_size; + int64_t cur_exp_packet_content_size = 0; /* Current stream class ID */ - int64_t cur_stream_class_id; + int64_t cur_stream_class_id = 0; /* Current event class ID */ - int64_t cur_event_class_id; + int64_t cur_event_class_id = 0; /* Current data stream ID */ - int64_t cur_data_stream_id; + int64_t cur_data_stream_id = 0; /* * Offset, in the underlying media, of the current packet's * start (-1 if unknown). */ - off_t cur_packet_offset; + off_t cur_packet_offset = 0; /* Default clock's current value */ - uint64_t default_clock_snapshot; + uint64_t default_clock_snapshot = 0; /* End of current packet snapshots */ struct end_of_packet_snapshots snapshots; @@ -248,13 +248,13 @@ struct ctf_msg_iter struct end_of_packet_snapshots prev_packet_snapshots; /* Stored values (for sequence lengths, variant tags) */ - GArray *stored_values; + GArray *stored_values = nullptr; /* Iterator's current log level */ - bt_logging_level log_level; + bt_logging_level log_level = (bt_logging_level) 0; /* Iterator's owning self component, or `NULL` if none (query) */ - bt_self_component *self_comp; + bt_self_component *self_comp = nullptr; }; static inline const char *state_string(enum state state) @@ -2594,7 +2594,6 @@ struct ctf_msg_iter *ctf_msg_iter_create(struct ctf_trace_class *tc, size_t max_ bt_logging_level log_level, bt_self_component *self_comp, bt_self_message_iterator *self_msg_iter) { - struct ctf_msg_iter *msg_it = NULL; struct bt_bfcr_cbs cbs = { .classes = { @@ -2624,12 +2623,8 @@ struct ctf_msg_iter *ctf_msg_iter_create(struct ctf_trace_class *tc, size_t max_ "trace-addr=%p, max-request-size=%zu, " "data=%p, log-level=%s", tc, max_request_sz, data, bt_common_logging_level_string(log_level)); - msg_it = g_new0(struct ctf_msg_iter, 1); - if (!msg_it) { - BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp, - "Failed to allocate one CTF plugin message iterator."); - goto end; - } + + ctf_msg_iter *msg_it = new ctf_msg_iter; msg_it->self_comp = self_comp; msg_it->self_msg_iter = self_msg_iter; msg_it->log_level = log_level; @@ -2690,7 +2685,7 @@ void ctf_msg_iter_destroy(struct ctf_msg_iter *msg_it) g_array_free(msg_it->stored_values, TRUE); } - g_free(msg_it); + delete msg_it; } enum ctf_msg_iter_status ctf_msg_iter_get_next_message(struct ctf_msg_iter *msg_it, diff --git a/src/plugins/ctf/fs-src/data-stream-file.cpp b/src/plugins/ctf/fs-src/data-stream-file.cpp index 7261fc74..89afb04f 100644 --- a/src/plugins/ctf/fs-src/data-stream-file.cpp +++ b/src/plugins/ctf/fs-src/data-stream-file.cpp @@ -274,14 +274,14 @@ struct ctf_msg_iter_medium_ops ctf_fs_ds_file_medops = { struct ctf_fs_ds_group_medops_data { /* Weak, set once at creation time. */ - struct ctf_fs_ds_file_group *ds_file_group; + struct ctf_fs_ds_file_group *ds_file_group = nullptr; /* * Index (as in element rank) of the index entry of ds_file_groups' * index we will read next (so, the one after the one we are reading * right now). */ - guint next_index_entry_index; + guint next_index_entry_index = 0; /* * File we are currently reading. Changes whenever we switch to @@ -289,11 +289,11 @@ struct ctf_fs_ds_group_medops_data * * Owned by this. */ - struct ctf_fs_ds_file *file; + struct ctf_fs_ds_file *file = nullptr; /* Weak, for context / logging / appending causes. */ - bt_self_message_iterator *self_msg_iter; - bt_logging_level log_level; + bt_self_message_iterator *self_msg_iter = nullptr; + bt_logging_level log_level = (bt_logging_level) 0; }; static enum ctf_msg_iter_medium_status medop_group_request_bytes(size_t request_sz, @@ -400,7 +400,7 @@ void ctf_fs_ds_group_medops_data_destroy(struct ctf_fs_ds_group_medops_data *dat ctf_fs_ds_file_destroy(data->file); - g_free(data); + delete data; end: return; @@ -410,22 +410,12 @@ enum ctf_msg_iter_medium_status ctf_fs_ds_group_medops_data_create( struct ctf_fs_ds_file_group *ds_file_group, bt_self_message_iterator *self_msg_iter, bt_logging_level log_level, struct ctf_fs_ds_group_medops_data **out) { - struct ctf_fs_ds_group_medops_data *data; - enum ctf_msg_iter_medium_status status; - BT_ASSERT(self_msg_iter); BT_ASSERT(ds_file_group); BT_ASSERT(ds_file_group->index); BT_ASSERT(ds_file_group->index->entries->len > 0); - data = g_new0(struct ctf_fs_ds_group_medops_data, 1); - if (!data) { - BT_MSG_ITER_LOGE_APPEND_CAUSE(self_msg_iter, - "Failed to allocate a struct ctf_fs_ds_group_medops_data"); - status = CTF_MSG_ITER_MEDIUM_STATUS_MEMORY_ERROR; - goto error; - } - + ctf_fs_ds_group_medops_data *data = new ctf_fs_ds_group_medops_data; data->ds_file_group = ds_file_group; data->self_msg_iter = self_msg_iter; data->log_level = log_level; @@ -437,14 +427,7 @@ enum ctf_msg_iter_medium_status ctf_fs_ds_group_medops_data_create( */ *out = data; - status = CTF_MSG_ITER_MEDIUM_STATUS_OK; - goto end; - -error: - ctf_fs_ds_group_medops_data_destroy(data); - -end: - return status; + return CTF_MSG_ITER_MEDIUM_STATUS_OK; } void ctf_fs_ds_group_medops_data_reset(struct ctf_fs_ds_group_medops_data *data) @@ -465,20 +448,16 @@ struct ctf_msg_iter_medium_ops ctf_fs_ds_group_medops = { .borrow_stream = medop_group_borrow_stream, }; -static struct ctf_fs_ds_index_entry *ctf_fs_ds_index_entry_create(bt_self_component *self_comp, - bt_logging_level log_level) +static void ctf_fs_ds_index_entry_destroy(ctf_fs_ds_index_entry *entry) { - struct ctf_fs_ds_index_entry *entry; - - entry = g_new0(struct ctf_fs_ds_index_entry, 1); - if (!entry) { - BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to allocate a ctf_fs_ds_index_entry."); - goto end; - } + delete entry; +} +static struct ctf_fs_ds_index_entry *ctf_fs_ds_index_entry_create() +{ + ctf_fs_ds_index_entry *entry = new ctf_fs_ds_index_entry; entry->packet_seq_num = UINT64_MAX; -end: return entry; } @@ -618,7 +597,7 @@ static struct ctf_fs_ds_index *build_index_from_idx_file(struct ctf_fs_ds_file * goto error; } - index_entry = ctf_fs_ds_index_entry_create(ds_file->self_comp, ds_file->log_level); + index_entry = ctf_fs_ds_index_entry_create(); if (!index_entry) { BT_COMP_LOGE_APPEND_CAUSE(ds_file->self_comp, "Failed to create a ctf_fs_ds_index_entry."); @@ -701,7 +680,7 @@ end: return index; error: ctf_fs_ds_index_destroy(index); - g_free(index_entry); + ctf_fs_ds_index_entry_destroy(index_entry); index = NULL; goto end; } @@ -815,7 +794,7 @@ static struct ctf_fs_ds_index *build_index_from_stream_file(struct ctf_fs_ds_fil goto error; } - index_entry = ctf_fs_ds_index_entry_create(ds_file->self_comp, ds_file->log_level); + index_entry = ctf_fs_ds_index_entry_create(); if (!index_entry) { BT_COMP_LOGE_APPEND_CAUSE(ds_file->self_comp, "Failed to create a ctf_fs_ds_index_entry."); @@ -828,7 +807,7 @@ static struct ctf_fs_ds_index *build_index_from_stream_file(struct ctf_fs_ds_fil ret = init_index_entry(index_entry, ds_file, &props, current_packet_size_bytes, current_packet_offset_bytes); if (ret) { - g_free(index_entry); + ctf_fs_ds_index_entry_destroy(index_entry); goto error; } @@ -855,7 +834,7 @@ struct ctf_fs_ds_file *ctf_fs_ds_file_create(struct ctf_fs_trace *ctf_fs_trace, { int ret; const size_t offset_align = bt_mmap_get_offset_align_size(log_level); - struct ctf_fs_ds_file *ds_file = g_new0(struct ctf_fs_ds_file, 1); + ctf_fs_ds_file *ds_file = new ctf_fs_ds_file; if (!ds_file) { goto error; @@ -913,14 +892,8 @@ end: struct ctf_fs_ds_index *ctf_fs_ds_index_create(bt_logging_level log_level, bt_self_component *self_comp) { - struct ctf_fs_ds_index *index = g_new0(struct ctf_fs_ds_index, 1); - - if (!index) { - BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp, "Failed to allocate index"); - goto error; - } - - index->entries = g_ptr_array_new_with_free_func((GDestroyNotify) g_free); + ctf_fs_ds_index *index = new ctf_fs_ds_index; + index->entries = g_ptr_array_new_with_free_func((GDestroyNotify) ctf_fs_ds_index_entry_destroy); if (!index->entries) { BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp, "Failed to allocate index entries."); @@ -949,7 +922,7 @@ void ctf_fs_ds_file_destroy(struct ctf_fs_ds_file *ds_file) ctf_fs_file_destroy(ds_file->file); } - g_free(ds_file); + delete ds_file; } void ctf_fs_ds_index_destroy(struct ctf_fs_ds_index *index) @@ -961,5 +934,6 @@ void ctf_fs_ds_index_destroy(struct ctf_fs_ds_index *index) if (index->entries) { g_ptr_array_free(index->entries, TRUE); } - g_free(index); + + delete index; } diff --git a/src/plugins/ctf/fs-src/data-stream-file.hpp b/src/plugins/ctf/fs-src/data-stream-file.hpp index 011abe85..f0e7edda 100644 --- a/src/plugins/ctf/fs-src/data-stream-file.hpp +++ b/src/plugins/ctf/fs-src/data-stream-file.hpp @@ -17,47 +17,47 @@ struct ctf_fs_ds_file_info { /* Owned by this. */ - GString *path; + GString *path = nullptr; /* Guaranteed to be set, as opposed to the index. */ - int64_t begin_ns; + int64_t begin_ns = 0; }; struct ctf_fs_ds_file { - bt_logging_level log_level; + bt_logging_level log_level = (bt_logging_level) 0; /* Weak */ - bt_self_component *self_comp; + bt_self_component *self_comp = nullptr; /* Weak */ - struct ctf_fs_metadata *metadata; + struct ctf_fs_metadata *metadata = nullptr; /* Owned by this */ - struct ctf_fs_file *file; + struct ctf_fs_file *file = nullptr; /* Owned by this */ - bt_stream *stream; + bt_stream *stream = nullptr; - void *mmap_addr; + void *mmap_addr = nullptr; /* * Max length of chunk to mmap() when updating the current mapping. * This value must be page-aligned. */ - size_t mmap_max_len; + size_t mmap_max_len = 0; /* Length of the current mapping. Never exceeds the file's length. */ - size_t mmap_len; + size_t mmap_len = 0; /* Offset in the file where the current mapping starts. */ - off_t mmap_offset_in_file; + off_t mmap_offset_in_file = 0; /* * Offset, in the current mapping, of the address to return on the next * request. */ - off_t request_offset_in_mapping; + off_t request_offset_in_mapping = 0; }; struct ctf_fs_ds_file *ctf_fs_ds_file_create(struct ctf_fs_trace *ctf_fs_trace, bt_stream *stream, diff --git a/src/plugins/ctf/fs-src/file.cpp b/src/plugins/ctf/fs-src/file.cpp index 25a29d0a..5184de45 100644 --- a/src/plugins/ctf/fs-src/file.cpp +++ b/src/plugins/ctf/fs-src/file.cpp @@ -35,17 +35,12 @@ void ctf_fs_file_destroy(struct ctf_fs_file *file) g_string_free(file->path, TRUE); } - g_free(file); + delete file; } struct ctf_fs_file *ctf_fs_file_create(bt_logging_level log_level, bt_self_component *self_comp) { - struct ctf_fs_file *file = g_new0(struct ctf_fs_file, 1); - - if (!file) { - goto error; - } - + ctf_fs_file *file = new ctf_fs_file; file->log_level = log_level; file->self_comp = self_comp; file->path = g_string_new(NULL); diff --git a/src/plugins/ctf/fs-src/fs.cpp b/src/plugins/ctf/fs-src/fs.cpp index a60c8ddc..4ffe410b 100644 --- a/src/plugins/ctf/fs-src/fs.cpp +++ b/src/plugins/ctf/fs-src/fs.cpp @@ -53,7 +53,7 @@ static void ctf_fs_msg_iter_data_destroy(struct ctf_fs_msg_iter_data *msg_iter_d ctf_fs_ds_group_medops_data_destroy(msg_iter_data->msg_iter_medops_data); } - g_free(msg_iter_data); + delete msg_iter_data; } static bt_message_iterator_class_next_method_status @@ -204,7 +204,6 @@ ctf_fs_iterator_init(bt_self_message_iterator *self_msg_iter, bt_self_component_port_output *self_port) { struct ctf_fs_port_data *port_data; - struct ctf_fs_msg_iter_data *msg_iter_data = NULL; bt_message_iterator_class_initialize_method_status status; bt_logging_level log_level; enum ctf_msg_iter_medium_status medium_status; @@ -214,12 +213,8 @@ ctf_fs_iterator_init(bt_self_message_iterator *self_msg_iter, bt_self_component_port_output_as_self_component_port(self_port)); BT_ASSERT(port_data); log_level = port_data->ctf_fs->log_level; - msg_iter_data = g_new0(struct ctf_fs_msg_iter_data, 1); - if (!msg_iter_data) { - status = BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR; - goto error; - } + ctf_fs_msg_iter_data *msg_iter_data = new ctf_fs_msg_iter_data; msg_iter_data->log_level = log_level; msg_iter_data->self_comp = self_comp; msg_iter_data->self_msg_iter = self_msg_iter; @@ -287,10 +282,10 @@ static void ctf_fs_trace_destroy(struct ctf_fs_trace *ctf_fs_trace) if (ctf_fs_trace->metadata) { ctf_fs_metadata_fini(ctf_fs_trace->metadata); - g_free(ctf_fs_trace->metadata); + delete ctf_fs_trace->metadata; } - g_free(ctf_fs_trace); + delete ctf_fs_trace; } void ctf_fs_destroy(struct ctf_fs_component *ctf_fs) @@ -305,7 +300,7 @@ void ctf_fs_destroy(struct ctf_fs_component *ctf_fs) g_ptr_array_free(ctf_fs->port_data, TRUE); } - g_free(ctf_fs); + delete ctf_fs; } static void port_data_destroy(struct ctf_fs_port_data *port_data) @@ -314,7 +309,7 @@ static void port_data_destroy(struct ctf_fs_port_data *port_data) return; } - g_free(port_data); + delete port_data; } static void port_data_destroy_notifier(void *data) @@ -330,13 +325,7 @@ static void ctf_fs_trace_destroy_notifier(void *data) struct ctf_fs_component *ctf_fs_component_create(bt_logging_level log_level) { - struct ctf_fs_component *ctf_fs; - - ctf_fs = g_new0(struct ctf_fs_component, 1); - if (!ctf_fs) { - goto error; - } - + ctf_fs_component *ctf_fs = new ctf_fs_component; ctf_fs->log_level = log_level; ctf_fs->port_data = g_ptr_array_new_with_free_func(port_data_destroy_notifier); if (!ctf_fs->port_data) { @@ -421,11 +410,7 @@ static int create_one_port_for_trace(struct ctf_fs_component *ctf_fs, BT_COMP_LOGI("Creating one port named `%s`", port_name); /* Create output port for this file */ - port_data = g_new0(struct ctf_fs_port_data, 1); - if (!port_data) { - goto error; - } - + port_data = new ctf_fs_port_data; port_data->ctf_fs = ctf_fs; port_data->ds_file_group = ds_file_group; ret = bt_self_component_source_add_output_port(self_comp_src, port_name, port_data, NULL); @@ -482,18 +467,12 @@ static void ctf_fs_ds_file_info_destroy(struct ctf_fs_ds_file_info *ds_file_info g_string_free(ds_file_info->path, TRUE); } - g_free(ds_file_info); + delete ds_file_info; } static struct ctf_fs_ds_file_info *ctf_fs_ds_file_info_create(const char *path, int64_t begin_ns) { - struct ctf_fs_ds_file_info *ds_file_info; - - ds_file_info = g_new0(struct ctf_fs_ds_file_info, 1); - if (!ds_file_info) { - goto end; - } - + ctf_fs_ds_file_info *ds_file_info = new ctf_fs_ds_file_info; ds_file_info->path = g_string_new(path); if (!ds_file_info->path) { ctf_fs_ds_file_info_destroy(ds_file_info); @@ -520,7 +499,7 @@ static void ctf_fs_ds_file_group_destroy(struct ctf_fs_ds_file_group *ds_file_gr ctf_fs_ds_index_destroy(ds_file_group->index); bt_stream_put_ref(ds_file_group->stream); - g_free(ds_file_group); + delete ds_file_group; } static struct ctf_fs_ds_file_group *ctf_fs_ds_file_group_create(struct ctf_fs_trace *ctf_fs_trace, @@ -528,13 +507,7 @@ static struct ctf_fs_ds_file_group *ctf_fs_ds_file_group_create(struct ctf_fs_tr uint64_t stream_instance_id, struct ctf_fs_ds_index *index) { - struct ctf_fs_ds_file_group *ds_file_group; - - ds_file_group = g_new0(struct ctf_fs_ds_file_group, 1); - if (!ds_file_group) { - goto error; - } - + ctf_fs_ds_file_group *ds_file_group = new ctf_fs_ds_file_group; ds_file_group->ds_file_infos = g_ptr_array_new_with_free_func((GDestroyNotify) ctf_fs_ds_file_info_destroy); if (!ds_file_group->ds_file_infos) { @@ -655,7 +628,7 @@ static void ds_index_insert_ds_index_entry_sorted(struct ctf_fs_ds_index *index, if (i == index->entries->len || !ds_index_entries_equal(entry, other_entry)) { array_insert(index->entries, entry, i); } else { - g_free(entry); + delete entry; } } @@ -988,17 +961,12 @@ static struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component *self_comp, struct ctf_fs_metadata_config *metadata_config, bt_logging_level log_level) { - struct ctf_fs_trace *ctf_fs_trace; int ret; /* Only one of them must be set. */ BT_ASSERT(!self_comp != !self_comp_class); - ctf_fs_trace = g_new0(struct ctf_fs_trace, 1); - if (!ctf_fs_trace) { - goto end; - } - + ctf_fs_trace *ctf_fs_trace = new struct ctf_fs_trace; ctf_fs_trace->log_level = log_level; ctf_fs_trace->self_comp = self_comp; ctf_fs_trace->self_comp_class = self_comp_class; @@ -1007,11 +975,7 @@ static struct ctf_fs_trace *ctf_fs_trace_create(bt_self_component *self_comp, goto error; } - ctf_fs_trace->metadata = g_new0(struct ctf_fs_metadata, 1); - if (!ctf_fs_trace->metadata) { - goto error; - } - + ctf_fs_trace->metadata = new ctf_fs_metadata; ctf_fs_metadata_init(ctf_fs_trace->metadata); ctf_fs_trace->ds_file_groups = g_ptr_array_new_with_free_func((GDestroyNotify) ctf_fs_ds_file_group_destroy); diff --git a/src/plugins/ctf/fs-src/fs.hpp b/src/plugins/ctf/fs-src/fs.hpp index fadef78b..320b755a 100644 --- a/src/plugins/ctf/fs-src/fs.hpp +++ b/src/plugins/ctf/fs-src/fs.hpp @@ -20,111 +20,111 @@ extern bool ctf_fs_debug; struct ctf_fs_file { - bt_logging_level log_level; + bt_logging_level log_level = (bt_logging_level) 0; /* Weak */ - bt_self_component *self_comp; + bt_self_component *self_comp = nullptr; /* Owned by this */ - GString *path; + GString *path = nullptr; /* Owned by this */ - FILE *fp; + FILE *fp = nullptr; - off_t size; + off_t size = 0; }; struct ctf_fs_metadata { /* Owned by this */ - struct ctf_metadata_decoder *decoder; + struct ctf_metadata_decoder *decoder = nullptr; /* Owned by this */ - bt_trace_class *trace_class; + bt_trace_class *trace_class = nullptr; /* Weak (owned by `decoder` above) */ - struct ctf_trace_class *tc; + struct ctf_trace_class *tc = nullptr; /* Owned by this */ - char *text; + char *text = nullptr; - int bo; + int bo = 0; }; struct ctf_fs_component { - bt_logging_level log_level; + bt_logging_level log_level = (bt_logging_level) 0; /* Array of struct ctf_fs_port_data *, owned by this */ - GPtrArray *port_data; + GPtrArray *port_data = nullptr; /* Owned by this */ - struct ctf_fs_trace *trace; + struct ctf_fs_trace *trace = nullptr; struct ctf_fs_metadata_config metadata_config; }; struct ctf_fs_trace { - bt_logging_level log_level; + bt_logging_level log_level = (bt_logging_level) 0; /* * Weak. These are mostly used to generate log messages or to append * error causes. They are mutually exclusive, only one of them must be * set. */ - bt_self_component *self_comp; - bt_self_component_class *self_comp_class; + bt_self_component *self_comp = nullptr; + bt_self_component_class *self_comp_class = nullptr; /* Owned by this */ - struct ctf_fs_metadata *metadata; + struct ctf_fs_metadata *metadata = nullptr; /* Owned by this */ - bt_trace *trace; + bt_trace *trace = nullptr; /* Array of struct ctf_fs_ds_file_group *, owned by this */ - GPtrArray *ds_file_groups; + GPtrArray *ds_file_groups = nullptr; /* Owned by this */ - GString *path; + GString *path = nullptr; /* Next automatic stream ID when not provided by packet header */ - uint64_t next_stream_id; + uint64_t next_stream_id = 0; }; struct ctf_fs_ds_index_entry { /* Weak, belongs to ctf_fs_ds_file_info. */ - const char *path; + const char *path = nullptr; /* Position, in bytes, of the packet from the beginning of the file. */ - uint64_t offset; + uint64_t offset = 0; /* Size of the packet, in bytes. */ - uint64_t packet_size; + uint64_t packet_size = 0; /* * Extracted from the packet context, relative to the respective fields' * mapped clock classes (in cycles). */ - uint64_t timestamp_begin, timestamp_end; + uint64_t timestamp_begin = 0, timestamp_end = 0; /* * Converted from the packet context, relative to the trace's EPOCH * (in ns since EPOCH). */ - int64_t timestamp_begin_ns, timestamp_end_ns; + int64_t timestamp_begin_ns = 0, timestamp_end_ns = 0; /* * Packet sequence number, or UINT64_MAX if not present in the index. */ - uint64_t packet_seq_num; + uint64_t packet_seq_num = 0; }; struct ctf_fs_ds_index { /* Array of pointer to struct ctf_fs_ds_index_entry. */ - GPtrArray *entries; + GPtrArray *entries = nullptr; }; struct ctf_fs_ds_file_group @@ -138,60 +138,61 @@ struct ctf_fs_ds_file_group * You can call ctf_fs_ds_file_create() with one of those paths * and the trace IR stream below. */ - GPtrArray *ds_file_infos; + GPtrArray *ds_file_infos = nullptr; /* Owned by this */ - struct ctf_stream_class *sc; + struct ctf_stream_class *sc = nullptr; /* Owned by this */ - bt_stream *stream; + bt_stream *stream = nullptr; /* Stream (instance) ID; -1ULL means none */ - uint64_t stream_id; + uint64_t stream_id = 0; /* Weak, belongs to component */ - struct ctf_fs_trace *ctf_fs_trace; + struct ctf_fs_trace *ctf_fs_trace = nullptr; /* * Owned by this. */ - struct ctf_fs_ds_index *index; + struct ctf_fs_ds_index *index = nullptr; }; struct ctf_fs_port_data { /* Weak, belongs to ctf_fs_trace */ - struct ctf_fs_ds_file_group *ds_file_group; + struct ctf_fs_ds_file_group *ds_file_group = nullptr; /* Weak */ - struct ctf_fs_component *ctf_fs; + struct ctf_fs_component *ctf_fs = nullptr; }; struct ctf_fs_msg_iter_data { - bt_logging_level log_level; + bt_logging_level log_level = (bt_logging_level) 0; /* Weak */ - bt_self_component *self_comp; + bt_self_component *self_comp = nullptr; /* Weak */ - bt_self_message_iterator *self_msg_iter; + bt_self_message_iterator *self_msg_iter = nullptr; /* Weak, belongs to ctf_fs_trace */ - struct ctf_fs_ds_file_group *ds_file_group; + struct ctf_fs_ds_file_group *ds_file_group = nullptr; /* Owned by this */ - struct ctf_msg_iter *msg_iter; + struct ctf_msg_iter *msg_iter = nullptr; /* * Saved error. If we hit an error in the _next method, but have some * messages ready to return, we save the error here and return it on * the next _next call. */ - bt_message_iterator_class_next_method_status next_saved_status; - const struct bt_error *next_saved_error; + bt_message_iterator_class_next_method_status next_saved_status = + BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK; + const struct bt_error *next_saved_error = nullptr; - struct ctf_fs_ds_group_medops_data *msg_iter_medops_data; + struct ctf_fs_ds_group_medops_data *msg_iter_medops_data = nullptr; }; bt_component_class_initialize_method_status diff --git a/src/plugins/ctf/fs-src/metadata.cpp b/src/plugins/ctf/fs-src/metadata.cpp index 021512e8..da8e1fe1 100644 --- a/src/plugins/ctf/fs-src/metadata.cpp +++ b/src/plugins/ctf/fs-src/metadata.cpp @@ -82,13 +82,14 @@ int ctf_fs_metadata_set_trace_class(bt_self_component *self_comp, struct ctf_fs_ struct ctf_fs_file *file = NULL; bt_logging_level log_level = ctf_fs_trace->log_level; - ctf_metadata_decoder_config decoder_config {}; - decoder_config.log_level = ctf_fs_trace->log_level, decoder_config.self_comp = self_comp, - decoder_config.clock_class_offset_s = config ? config->clock_class_offset_s : 0, - decoder_config.clock_class_offset_ns = config ? config->clock_class_offset_ns : 0, + ctf_metadata_decoder_config decoder_config; + decoder_config.log_level = ctf_fs_trace->log_level; + decoder_config.self_comp = self_comp; + decoder_config.clock_class_offset_s = config ? config->clock_class_offset_s : 0; + decoder_config.clock_class_offset_ns = config ? config->clock_class_offset_ns : 0; decoder_config.force_clock_class_origin_unix_epoch = - config ? config->force_clock_class_origin_unix_epoch : false, - decoder_config.create_trace_class = true, + config ? config->force_clock_class_origin_unix_epoch : false; + decoder_config.create_trace_class = true; file = get_file(ctf_fs_trace->path->str, log_level, self_comp); if (!file) { diff --git a/src/plugins/ctf/fs-src/metadata.hpp b/src/plugins/ctf/fs-src/metadata.hpp index 60790ada..bd8d2496 100644 --- a/src/plugins/ctf/fs-src/metadata.hpp +++ b/src/plugins/ctf/fs-src/metadata.hpp @@ -15,9 +15,9 @@ struct ctf_fs_metadata_config { - bool force_clock_class_origin_unix_epoch; - int64_t clock_class_offset_s; - int64_t clock_class_offset_ns; + bool force_clock_class_origin_unix_epoch = false; + int64_t clock_class_offset_s = 0; + int64_t clock_class_offset_ns = 0; }; int ctf_fs_metadata_init(struct ctf_fs_metadata *metadata); diff --git a/src/plugins/ctf/fs-src/query.cpp b/src/plugins/ctf/fs-src/query.cpp index 22f35106..c2f6253d 100644 --- a/src/plugins/ctf/fs-src/query.cpp +++ b/src/plugins/ctf/fs-src/query.cpp @@ -48,7 +48,7 @@ metadata_info_query(bt_self_component_class_source *self_comp_class_src, const b const char *path; bool is_packetized; struct ctf_metadata_decoder *decoder = NULL; - ctf_metadata_decoder_config decoder_cfg {}; + ctf_metadata_decoder_config decoder_cfg; enum ctf_metadata_decoder_status decoder_status; GString *g_metadata_text = NULL; const char *plaintext; @@ -428,10 +428,10 @@ support_info_query(bt_self_component_class_source *comp_class, const bt_value *p metadata_file = g_fopen(metadata_path, "rb"); if (metadata_file) { - ctf_metadata_decoder_config metadata_decoder_config {}; enum ctf_metadata_decoder_status decoder_status; bt_uuid_t uuid; + ctf_metadata_decoder_config metadata_decoder_config; metadata_decoder_config.log_level = log_level; metadata_decoder_config.self_comp_class = bt_self_component_class_source_as_self_component_class(comp_class); diff --git a/src/plugins/ctf/lttng-live/data-stream.cpp b/src/plugins/ctf/lttng-live/data-stream.cpp index d749816c..e0dca453 100644 --- a/src/plugins/ctf/lttng-live/data-stream.cpp +++ b/src/plugins/ctf/lttng-live/data-stream.cpp @@ -176,7 +176,6 @@ struct lttng_live_stream_iterator * lttng_live_stream_iterator_create(struct lttng_live_session *session, uint64_t ctf_trace_id, uint64_t stream_id, bt_self_message_iterator *self_msg_iter) { - struct lttng_live_stream_iterator *stream_iter; struct lttng_live_component *lttng_live; struct lttng_live_trace *trace; bt_logging_level log_level; @@ -190,13 +189,7 @@ lttng_live_stream_iterator_create(struct lttng_live_session *session, uint64_t c lttng_live = session->lttng_live_msg_iter->lttng_live_comp; - stream_iter = g_new0(struct lttng_live_stream_iterator, 1); - if (!stream_iter) { - BT_COMP_LOGE_APPEND_CAUSE(self_comp, - "Failed to allocate struct lttng_live_stream_iterator"); - goto error; - } - + lttng_live_stream_iterator *stream_iter = new lttng_live_stream_iterator; stream_iter->log_level = log_level; stream_iter->self_comp = self_comp; trace = lttng_live_session_borrow_or_create_trace_by_id(session, ctf_trace_id); @@ -278,5 +271,5 @@ void lttng_live_stream_iterator_destroy(struct lttng_live_stream_iterator *strea /* Track the number of active stream iterator. */ stream_iter->trace->session->lttng_live_msg_iter->active_stream_iter--; - g_free(stream_iter); + delete stream_iter; } diff --git a/src/plugins/ctf/lttng-live/lttng-live.cpp b/src/plugins/ctf/lttng-live/lttng-live.cpp index 35cbff95..0d9a7044 100644 --- a/src/plugins/ctf/lttng-live/lttng-live.cpp +++ b/src/plugins/ctf/lttng-live/lttng-live.cpp @@ -153,24 +153,20 @@ static void lttng_live_destroy_trace(struct lttng_live_trace *trace) BT_TRACE_CLASS_PUT_REF_AND_RESET(trace->trace_class); lttng_live_metadata_fini(trace); - g_free(trace); + delete trace; } static struct lttng_live_trace *lttng_live_create_trace(struct lttng_live_session *session, uint64_t trace_id) { - struct lttng_live_trace *trace = NULL; bt_logging_level log_level = session->log_level; bt_self_component *self_comp = session->self_comp; BT_COMP_LOGD("Creating live trace: " "session-id=%" PRIu64 ", trace-id=%" PRIu64, session->id, trace_id); - trace = g_new0(struct lttng_live_trace, 1); - if (!trace) { - BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to allocate live trace"); - goto error; - } + + lttng_live_trace *trace = new lttng_live_trace; trace->log_level = session->log_level; trace->self_comp = session->self_comp; trace->session = session; @@ -183,11 +179,6 @@ static struct lttng_live_trace *lttng_live_create_trace(struct lttng_live_sessio trace->metadata_stream_state = LTTNG_LIVE_METADATA_STREAM_STATE_NEEDED; g_ptr_array_add(session->traces, trace); - goto end; -error: - g_free(trace); - trace = NULL; -end: return trace; } @@ -212,8 +203,6 @@ end: int lttng_live_add_session(struct lttng_live_msg_iter *lttng_live_msg_iter, uint64_t session_id, const char *hostname, const char *session_name) { - int ret = 0; - struct lttng_live_session *session; bt_logging_level log_level = lttng_live_msg_iter->log_level; bt_self_component *self_comp = lttng_live_msg_iter->self_comp; @@ -221,12 +210,7 @@ int lttng_live_add_session(struct lttng_live_msg_iter *lttng_live_msg_iter, uint "session-id=%" PRIu64 ", hostname=\"%s\" session-name=\"%s\"", session_id, hostname, session_name); - session = g_new0(struct lttng_live_session, 1); - if (!session) { - BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to allocate live session"); - goto error; - } - + lttng_live_session *session = new lttng_live_session; session->log_level = lttng_live_msg_iter->log_level; session->self_comp = lttng_live_msg_iter->self_comp; session->id = session_id; @@ -241,12 +225,8 @@ int lttng_live_add_session(struct lttng_live_msg_iter *lttng_live_msg_iter, uint BT_ASSERT(session->session_name); g_ptr_array_add(lttng_live_msg_iter->sessions, session); - goto end; -error: - g_free(session); - ret = -1; -end: - return ret; + + return 0; } static void lttng_live_destroy_session(struct lttng_live_session *session) @@ -280,10 +260,12 @@ static void lttng_live_destroy_session(struct lttng_live_session *session) if (session->hostname) { g_string_free(session->hostname, TRUE); } + if (session->session_name) { g_string_free(session->session_name, TRUE); } - g_free(session); + + delete session; end: return; @@ -309,7 +291,7 @@ static void lttng_live_msg_iter_destroy(struct lttng_live_msg_iter *lttng_live_m BT_ASSERT(lttng_live_msg_iter->active_stream_iter == 0); lttng_live_msg_iter->lttng_live_comp->has_msg_iter = false; - g_free(lttng_live_msg_iter); + delete lttng_live_msg_iter; end: return; @@ -1749,15 +1731,7 @@ static struct lttng_live_msg_iter * lttng_live_msg_iter_create(struct lttng_live_component *lttng_live_comp, bt_self_message_iterator *self_msg_it) { - bt_self_component *self_comp = lttng_live_comp->self_comp; - bt_logging_level log_level = lttng_live_comp->log_level; - - struct lttng_live_msg_iter *lttng_live_msg_iter = g_new0(struct lttng_live_msg_iter, 1); - if (!lttng_live_msg_iter) { - BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to allocate lttng_live_msg_iter"); - goto end; - } - + lttng_live_msg_iter *lttng_live_msg_iter = new struct lttng_live_msg_iter; lttng_live_msg_iter->log_level = lttng_live_comp->log_level; lttng_live_msg_iter->self_comp = lttng_live_comp->self_comp; lttng_live_msg_iter->lttng_live_comp = lttng_live_comp; @@ -1771,7 +1745,6 @@ lttng_live_msg_iter_create(struct lttng_live_component *lttng_live_comp, g_ptr_array_new_with_free_func((GDestroyNotify) lttng_live_destroy_session); BT_ASSERT(lttng_live_msg_iter->sessions); -end: return lttng_live_msg_iter; } @@ -2049,10 +2022,12 @@ static void lttng_live_component_destroy_data(struct lttng_live_component *lttng if (!lttng_live) { return; } + if (lttng_live->params.url) { g_string_free(lttng_live->params.url, TRUE); } - g_free(lttng_live); + + delete lttng_live; } void lttng_live_component_finalize(bt_self_component_source *component) @@ -2123,11 +2098,7 @@ lttng_live_component_create(const bt_value *params, bt_logging_level log_level, goto error; } - lttng_live = g_new0(struct lttng_live_component, 1); - if (!lttng_live) { - status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR; - goto end; - } + lttng_live = new lttng_live_component; lttng_live->log_level = log_level; lttng_live->self_comp = self_comp; lttng_live->max_query_size = MAX_QUERY_SIZE; diff --git a/src/plugins/ctf/lttng-live/lttng-live.hpp b/src/plugins/ctf/lttng-live/lttng-live.hpp index d79cec7e..4f84ca79 100644 --- a/src/plugins/ctf/lttng-live/lttng-live.hpp +++ b/src/plugins/ctf/lttng-live/lttng-live.hpp @@ -43,35 +43,35 @@ enum lttng_live_stream_state /* Iterator over a live stream. */ struct lttng_live_stream_iterator { - bt_logging_level log_level; - bt_self_component *self_comp; + bt_logging_level log_level = (bt_logging_level) 0; + bt_self_component *self_comp = nullptr; /* Owned by this. */ - bt_stream *stream; + bt_stream *stream = nullptr; /* Weak reference. */ - struct lttng_live_trace *trace; + struct lttng_live_trace *trace = nullptr; /* * Since only a single iterator per viewer connection, we have * only a single message iterator per stream. */ - struct ctf_msg_iter *msg_iter; + struct ctf_msg_iter *msg_iter = nullptr; - uint64_t viewer_stream_id; + uint64_t viewer_stream_id = 0; struct { - bool is_set; - uint64_t value; + bool is_set = false; + uint64_t value = 0; } ctf_stream_class_id; /* base offset in current index. */ - uint64_t base_offset; + uint64_t base_offset = 0; /* len to read in current index. */ - uint64_t len; + uint64_t len = 0; /* offset in current index. */ - uint64_t offset; + uint64_t offset = 0; /* * Clock Snapshot value of the last message iterator inactivity message @@ -79,45 +79,45 @@ struct lttng_live_stream_iterator */ struct { - bool is_set; - uint64_t value; + bool is_set = false; + uint64_t value = 0; } last_inactivity_ts; /* * Clock Snapshot value of the current message iterator inactivity * message we might want to send downstream. */ - uint64_t current_inactivity_ts; + uint64_t current_inactivity_ts = 0; - enum lttng_live_stream_state state; + enum lttng_live_stream_state state = LTTNG_LIVE_STREAM_QUIESCENT; /* * The current message produced by this live stream iterator. Owned by * this. */ - const bt_message *current_msg; + const bt_message *current_msg = nullptr; /* Timestamp in nanoseconds of the current message (current_msg). */ - int64_t current_msg_ts_ns; + int64_t current_msg_ts_ns = 0; /* Owned by this. */ - uint8_t *buf; - size_t buflen; + uint8_t *buf = nullptr; + size_t buflen = 0; /* Owned by this. */ - GString *name; + GString *name = nullptr; - bool has_stream_hung_up; + bool has_stream_hung_up = false; }; struct lttng_live_metadata { - bt_logging_level log_level; - bt_self_component *self_comp; + bt_logging_level log_level = (bt_logging_level) 0; + bt_self_component *self_comp = nullptr; - uint64_t stream_id; + uint64_t stream_id = 0; /* Weak reference. */ - struct ctf_metadata_decoder *decoder; + struct ctf_metadata_decoder *decoder = nullptr; }; enum lttng_live_metadata_stream_state @@ -144,55 +144,56 @@ enum lttng_live_metadata_stream_state struct lttng_live_trace { - bt_logging_level log_level; - bt_self_component *self_comp; + bt_logging_level log_level = (bt_logging_level) 0; + bt_self_component *self_comp = nullptr; /* Back reference to session. */ - struct lttng_live_session *session; + struct lttng_live_session *session = nullptr; /* ctf trace ID within the session. */ - uint64_t id; + uint64_t id = 0; /* Owned by this. */ - bt_trace *trace; + bt_trace *trace = nullptr; /* Weak reference. */ - bt_trace_class *trace_class; + bt_trace_class *trace_class = nullptr; - struct lttng_live_metadata *metadata; + struct lttng_live_metadata *metadata = nullptr; - const bt_clock_class *clock_class; + const bt_clock_class *clock_class = nullptr; /* Array of pointers to struct lttng_live_stream_iterator. */ /* Owned by this. */ - GPtrArray *stream_iterators; + GPtrArray *stream_iterators = nullptr; - enum lttng_live_metadata_stream_state metadata_stream_state; + enum lttng_live_metadata_stream_state metadata_stream_state = + LTTNG_LIVE_METADATA_STREAM_STATE_NEEDED; }; struct lttng_live_session { - bt_logging_level log_level; - bt_self_component *self_comp; + bt_logging_level log_level = (bt_logging_level) 0; + bt_self_component *self_comp = nullptr; /* Weak reference. */ - struct lttng_live_msg_iter *lttng_live_msg_iter; + struct lttng_live_msg_iter *lttng_live_msg_iter = nullptr; /* Owned by this. */ - GString *hostname; + GString *hostname = nullptr; /* Owned by this. */ - GString *session_name; + GString *session_name = nullptr; - uint64_t id; + uint64_t id = 0; /* Array of pointers to struct lttng_live_trace. */ - GPtrArray *traces; + GPtrArray *traces = nullptr; - bool attached; - bool new_streams_needed; - bool lazy_stream_msg_init; - bool closed; + bool attached = false; + bool new_streams_needed = false; + bool lazy_stream_msg_init = false; + bool closed = false; }; enum session_not_found_action @@ -207,51 +208,51 @@ enum session_not_found_action */ struct lttng_live_component { - bt_logging_level log_level; + bt_logging_level log_level = (bt_logging_level) 0; /* Weak reference. */ - bt_self_component *self_comp; + bt_self_component *self_comp = nullptr; struct { - GString *url; - enum session_not_found_action sess_not_found_act; + GString *url = nullptr; + enum session_not_found_action sess_not_found_act = SESSION_NOT_FOUND_ACTION_CONTINUE; } params; - size_t max_query_size; + size_t max_query_size = 0; /* * Keeps track of whether the downstream component already has a * message iterator on this component. */ - bool has_msg_iter; + bool has_msg_iter = false; }; struct lttng_live_msg_iter { - bt_logging_level log_level; - bt_self_component *self_comp; + bt_logging_level log_level = (bt_logging_level) 0; + bt_self_component *self_comp = nullptr; /* Weak reference. */ - struct lttng_live_component *lttng_live_comp; + struct lttng_live_component *lttng_live_comp = nullptr; /* Weak reference. */ - bt_self_message_iterator *self_msg_iter; + bt_self_message_iterator *self_msg_iter = nullptr; /* Owned by this. */ - struct live_viewer_connection *viewer_connection; + struct live_viewer_connection *viewer_connection = nullptr; /* Array of pointers to struct lttng_live_session. */ - GPtrArray *sessions; + GPtrArray *sessions = nullptr; /* Number of live stream iterator this message iterator has.*/ - uint64_t active_stream_iter; + uint64_t active_stream_iter = 0; /* Timestamp in nanosecond of the last message sent downstream. */ - int64_t last_msg_ts_ns; + int64_t last_msg_ts_ns = 0; /* True if the iterator was interrupted. */ - bool was_interrupted; + bool was_interrupted = false; }; enum lttng_live_iterator_status diff --git a/src/plugins/ctf/lttng-live/metadata.cpp b/src/plugins/ctf/lttng-live/metadata.cpp index 46a11511..4cc750b8 100644 --- a/src/plugins/ctf/lttng-live/metadata.cpp +++ b/src/plugins/ctf/lttng-live/metadata.cpp @@ -294,20 +294,16 @@ int lttng_live_metadata_create_stream(struct lttng_live_session *session, uint64 { bt_self_component *self_comp = session->self_comp; bt_logging_level log_level = session->log_level; - struct lttng_live_metadata *metadata = NULL; struct lttng_live_trace *trace; - ctf_metadata_decoder_config cfg {}; + ctf_metadata_decoder_config cfg; cfg.log_level = session->log_level; cfg.self_comp = session->self_comp; cfg.clock_class_offset_s = 0; cfg.clock_class_offset_ns = 0; cfg.create_trace_class = true; - metadata = g_new0(struct lttng_live_metadata, 1); - if (!metadata) { - return -1; - } + lttng_live_metadata *metadata = new lttng_live_metadata; metadata->log_level = session->log_level; metadata->self_comp = session->self_comp; metadata->stream_id = stream_id; @@ -327,7 +323,7 @@ int lttng_live_metadata_create_stream(struct lttng_live_session *session, uint64 error: ctf_metadata_decoder_destroy(metadata->decoder); - g_free(metadata); + delete metadata; return -1; } @@ -340,5 +336,5 @@ void lttng_live_metadata_fini(struct lttng_live_trace *trace) } ctf_metadata_decoder_destroy(metadata->decoder); trace->metadata = NULL; - g_free(metadata); + delete metadata; } diff --git a/src/plugins/ctf/lttng-live/viewer-connection.cpp b/src/plugins/ctf/lttng-live/viewer-connection.cpp index 5ea98cdd..61b8a8cf 100644 --- a/src/plugins/ctf/lttng-live/viewer-connection.cpp +++ b/src/plugins/ctf/lttng-live/viewer-connection.cpp @@ -1714,10 +1714,9 @@ enum lttng_live_viewer_status live_viewer_connection_create( bt_logging_level log_level, const char *url, bool in_query, struct lttng_live_msg_iter *lttng_live_msg_iter, struct live_viewer_connection **viewer) { - struct live_viewer_connection *viewer_connection; enum lttng_live_viewer_status status; - viewer_connection = g_new0(struct live_viewer_connection, 1); + live_viewer_connection *viewer_connection = new live_viewer_connection; if (bt_socket_init(log_level) != 0) { BT_COMP_OR_COMP_CLASS_LOGE_APPEND_CAUSE(self_comp, self_comp_class, @@ -1810,7 +1809,7 @@ void live_viewer_connection_destroy(struct live_viewer_connection *viewer_connec g_string_free(viewer_connection->proto, true); } - g_free(viewer_connection); + delete viewer_connection; bt_socket_fini(); diff --git a/src/plugins/ctf/lttng-live/viewer-connection.hpp b/src/plugins/ctf/lttng-live/viewer-connection.hpp index 67e71e0c..4e17d506 100644 --- a/src/plugins/ctf/lttng-live/viewer-connection.hpp +++ b/src/plugins/ctf/lttng-live/viewer-connection.hpp @@ -46,25 +46,25 @@ enum lttng_live_get_one_metadata_status struct live_viewer_connection { - bt_logging_level log_level; - bt_self_component *self_comp; - bt_self_component_class *self_comp_class; + bt_logging_level log_level = (bt_logging_level) 0; + bt_self_component *self_comp = nullptr; + bt_self_component_class *self_comp_class = nullptr; - GString *url; + GString *url = nullptr; - GString *relay_hostname; - GString *target_hostname; - GString *session_name; - GString *proto; + GString *relay_hostname = nullptr; + GString *target_hostname = nullptr; + GString *session_name = nullptr; + GString *proto = nullptr; - BT_SOCKET control_sock; - int port; + BT_SOCKET control_sock {}; + int port = 0; - int32_t major; - int32_t minor; + int32_t major = 0; + int32_t minor = 0; - bool in_query; - struct lttng_live_msg_iter *lttng_live_msg_iter; + bool in_query = false; + struct lttng_live_msg_iter *lttng_live_msg_iter = nullptr; }; struct packet_index_time -- 2.34.1