X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=plugins%2Ftext%2Fdmesg%2Fdmesg.c;h=0edc2e6133dd7d0f4bcf42c705ed18ea48ea04bb;hb=da91b29ad2964b85601e25843f1dca92f6c97406;hp=f8f65541b8ce148c9eb572359924e9cde49566e7;hpb=707b323a92becb2487cfb0e2eb4af02f8e011d48;p=babeltrace.git diff --git a/plugins/text/dmesg/dmesg.c b/plugins/text/dmesg/dmesg.c index f8f65541..0edc2e61 100644 --- a/plugins/text/dmesg/dmesg.c +++ b/plugins/text/dmesg/dmesg.c @@ -28,7 +28,8 @@ #include #include #include -#include +#include +#include #include #include #include @@ -44,9 +45,20 @@ struct dmesg_component; struct dmesg_notif_iter { struct dmesg_component *dmesg_comp; + struct bt_private_connection_private_notification_iterator *pc_notif_iter; /* Weak */ char *linebuf; size_t linebuf_len; FILE *fp; + struct bt_notification *tmp_event_notif; + + enum { + STATE_EMIT_STREAM_BEGINNING, + STATE_EMIT_PACKET_BEGINNING, + STATE_EMIT_EVENT, + STATE_EMIT_PACKET_END, + STATE_EMIT_STREAM_END, + STATE_DONE, + } state; }; struct dmesg_component { @@ -56,178 +68,37 @@ struct dmesg_component { bt_bool no_timestamp; } params; - struct bt_ctf_trace *trace; - struct bt_ctf_stream_class *stream_class; - struct bt_ctf_event_class *event_class; - struct bt_ctf_stream *stream; - struct bt_ctf_packet *packet; - struct bt_ctf_clock_class *clock_class; + struct bt_trace *trace; + struct bt_stream_class *stream_class; + struct bt_event_class *event_class; + struct bt_stream *stream; + struct bt_packet *packet; + struct bt_clock_class *clock_class; struct bt_clock_class_priority_map *cc_prio_map; }; static -struct bt_ctf_field_type *create_packet_header_ft(void) +struct bt_field_class *create_event_payload_fc(void) { - struct bt_ctf_field_type *root_ft = NULL; - struct bt_ctf_field_type *ft = NULL; + struct bt_field_class *root_fc = NULL; + struct bt_field_class *fc = NULL; int ret; - root_ft = bt_ctf_field_type_structure_create(); - if (!root_ft) { - BT_LOGE_STR("Cannot create an empty structure field type object."); + root_fc = bt_field_class_structure_create(); + if (!root_fc) { + BT_LOGE_STR("Cannot create an empty structure field class object."); goto error; } - ft = bt_ctf_field_type_integer_create(32); - if (!ft) { - BT_LOGE_STR("Cannot create an integer field type object."); + fc = bt_field_class_string_create(); + if (!fc) { + BT_LOGE_STR("Cannot create a string field class object."); goto error; } - ret = bt_ctf_field_type_structure_add_field(root_ft, ft, "magic"); + ret = bt_field_class_structure_append_member(root_fc, "str", fc); if (ret) { - BT_LOGE("Cannot add `magic` field type to structure field type: " - "ret=%d", ret); - goto error; - } - - BT_PUT(ft); - ft = bt_ctf_field_type_integer_create(8); - if (!ft) { - BT_LOGE_STR("Cannot create an integer field type object."); - goto error; - } - - goto end; - -error: - BT_PUT(root_ft); - -end: - bt_put(ft); - return root_ft; -} - -static -struct bt_ctf_field_type *create_packet_context_ft(void) -{ - struct bt_ctf_field_type *root_ft = NULL; - struct bt_ctf_field_type *ft = NULL; - int ret; - - root_ft = bt_ctf_field_type_structure_create(); - if (!root_ft) { - BT_LOGE_STR("Cannot create an empty structure field type object."); - goto error; - } - - ft = bt_ctf_field_type_integer_create(64); - if (!ft) { - BT_LOGE_STR("Cannot create an integer field type object."); - goto error; - } - - ret = bt_ctf_field_type_structure_add_field(root_ft, - ft, "content_size"); - if (ret) { - BT_LOGE("Cannot add `content_size` field type to structure field type: " - "ret=%d", ret); - goto error; - } - - BT_PUT(ft); - ft = bt_ctf_field_type_integer_create(64); - if (!ft) { - BT_LOGE_STR("Cannot create an integer field type object."); - goto error; - } - - ret = bt_ctf_field_type_structure_add_field(root_ft, - ft, "packet_size"); - if (ret) { - BT_LOGE("Cannot add `packet_size` field type to structure field type: " - "ret=%d", ret); - goto error; - } - - goto end; - -error: - BT_PUT(root_ft); - -end: - bt_put(ft); - return root_ft; -} - -static -struct bt_ctf_field_type *create_event_header_ft( - struct bt_ctf_clock_class *clock_class) -{ - struct bt_ctf_field_type *root_ft = NULL; - struct bt_ctf_field_type *ft = NULL; - int ret; - - root_ft = bt_ctf_field_type_structure_create(); - if (!root_ft) { - BT_LOGE_STR("Cannot create an empty structure field type object."); - goto error; - } - - ft = bt_ctf_field_type_integer_create(64); - if (!ft) { - BT_LOGE_STR("Cannot create an integer field type object."); - goto error; - } - - ret = bt_ctf_field_type_integer_set_mapped_clock_class(ft, clock_class); - if (ret) { - BT_LOGE("Cannot map integer field type to clock class: " - "ret=%d", ret); - goto error; - } - - ret = bt_ctf_field_type_structure_add_field(root_ft, - ft, "timestamp"); - if (ret) { - BT_LOGE("Cannot add `timestamp` field type to structure field type: " - "ret=%d", ret); - goto error; - } - - goto end; - -error: - BT_PUT(root_ft); - -end: - bt_put(ft); - return root_ft; -} - -static -struct bt_ctf_field_type *create_event_payload_ft(void) -{ - struct bt_ctf_field_type *root_ft = NULL; - struct bt_ctf_field_type *ft = NULL; - int ret; - - root_ft = bt_ctf_field_type_structure_create(); - if (!root_ft) { - BT_LOGE_STR("Cannot create an empty structure field type object."); - goto error; - } - - ft = bt_ctf_field_type_string_create(); - if (!ft) { - BT_LOGE_STR("Cannot create a string field type object."); - goto error; - } - - ret = bt_ctf_field_type_structure_add_field(root_ft, - ft, "str"); - if (ret) { - BT_LOGE("Cannot add `str` field type to structure field type: " + BT_LOGE("Cannot add `str` member to structure field class: " "ret=%d", ret); goto error; } @@ -235,50 +106,32 @@ struct bt_ctf_field_type *create_event_payload_ft(void) goto end; error: - BT_PUT(root_ft); + BT_OBJECT_PUT_REF_AND_RESET(root_fc); end: - bt_put(ft); - return root_ft; -} - -static -struct bt_ctf_clock_class *create_clock_class(void) -{ - return bt_ctf_clock_class_create("the_clock", 1000000000); + bt_object_put_ref(fc); + return root_fc; } static int create_meta(struct dmesg_component *dmesg_comp, bool has_ts) { - struct bt_ctf_field_type *ft = NULL; + struct bt_field_class *fc = NULL; const char *trace_name = NULL; gchar *basename = NULL; int ret = 0; - dmesg_comp->trace = bt_ctf_trace_create(); + dmesg_comp->trace = bt_trace_create(); if (!dmesg_comp->trace) { BT_LOGE_STR("Cannot create an empty trace object."); goto error; } - ft = create_packet_header_ft(); - if (!ft) { - BT_LOGE_STR("Cannot create packet header field type."); - goto error; - } - - ret = bt_ctf_trace_set_packet_header_type(dmesg_comp->trace, ft); - if (ret) { - BT_LOGE_STR("Cannot set trace's packet header field type."); - goto error; - } - if (dmesg_comp->params.read_from_stdin) { trace_name = "STDIN"; } else { basename = g_path_get_basename(dmesg_comp->params.path->str); - assert(basename); + BT_ASSERT(basename); if (strcmp(basename, G_DIR_SEPARATOR_S) != 0 && strcmp(basename, ".") != 0) { @@ -287,105 +140,56 @@ int create_meta(struct dmesg_component *dmesg_comp, bool has_ts) } if (trace_name) { - ret = bt_ctf_trace_set_name(dmesg_comp->trace, trace_name); + ret = bt_trace_set_name(dmesg_comp->trace, trace_name); if (ret) { BT_LOGE("Cannot set trace's name: name=\"%s\"", trace_name); goto error; } } - dmesg_comp->stream_class = bt_ctf_stream_class_create_empty(NULL); + dmesg_comp->stream_class = bt_stream_class_create(dmesg_comp->trace); if (!dmesg_comp->stream_class) { - BT_LOGE_STR("Cannot create an empty stream class object."); - goto error; - } - - bt_put(ft); - ft = create_packet_context_ft(); - if (!ft) { - BT_LOGE_STR("Cannot create packet context field type."); - goto error; - } - - ret = bt_ctf_stream_class_set_packet_context_type( - dmesg_comp->stream_class, ft); - if (ret) { - BT_LOGE_STR("Cannot set stream class's packet context field type."); - goto error; - } - - dmesg_comp->cc_prio_map = bt_clock_class_priority_map_create(); - if (!dmesg_comp->cc_prio_map) { - BT_LOGE_STR("Cannot create empty clock class priority map."); + BT_LOGE_STR("Cannot create a stream class object."); goto error; } if (has_ts) { - dmesg_comp->clock_class = create_clock_class(); + dmesg_comp->clock_class = bt_clock_class_create(); if (!dmesg_comp->clock_class) { BT_LOGE_STR("Cannot create clock class."); goto error; } - ret = bt_ctf_trace_add_clock_class(dmesg_comp->trace, - dmesg_comp->clock_class); - if (ret) { - BT_LOGE_STR("Cannot add clock class to trace."); - goto error; - } - - ret = bt_clock_class_priority_map_add_clock_class( - dmesg_comp->cc_prio_map, dmesg_comp->clock_class, 0); + ret = bt_stream_class_set_default_clock_class( + dmesg_comp->stream_class, dmesg_comp->clock_class); if (ret) { - BT_LOGE_STR("Cannot add clock class to clock class priority map."); - goto error; - } - - bt_put(ft); - ft = create_event_header_ft(dmesg_comp->clock_class); - if (!ft) { - BT_LOGE_STR("Cannot create event header field type."); - goto error; - } - - ret = bt_ctf_stream_class_set_event_header_type( - dmesg_comp->stream_class, ft); - if (ret) { - BT_LOGE_STR("Cannot set stream class's event header field type."); + BT_LOGE_STR("Cannot set stream class's default clock class."); goto error; } } - dmesg_comp->event_class = bt_ctf_event_class_create("string"); + dmesg_comp->event_class = bt_event_class_create( + dmesg_comp->stream_class); if (!dmesg_comp->event_class) { - BT_LOGE_STR("Cannot create an empty event class object."); - goto error; - } - - bt_put(ft); - ft = create_event_payload_ft(); - if (!ft) { - BT_LOGE_STR("Cannot create event payload field type."); + BT_LOGE_STR("Cannot create an event class object."); goto error; } - ret = bt_ctf_event_class_set_payload_type(dmesg_comp->event_class, ft); + ret = bt_event_class_set_name(dmesg_comp->event_class, "string"); if (ret) { - BT_LOGE_STR("Cannot set event class's event payload field type."); + BT_LOGE_STR("Cannot set event class's name."); goto error; } - ret = bt_ctf_stream_class_add_event_class(dmesg_comp->stream_class, - dmesg_comp->event_class); - if (ret) { - BT_LOGE("Cannot add event class to stream class: ret=%d", ret); + fc = create_event_payload_fc(); + if (!fc) { + BT_LOGE_STR("Cannot create event payload field class."); goto error; } - ret = bt_ctf_trace_add_stream_class(dmesg_comp->trace, - dmesg_comp->stream_class); + ret = bt_event_class_set_payload_field_class(dmesg_comp->event_class, fc); if (ret) { - BT_LOGE("Cannot add event class to stream class: ret=%d", ret); + BT_LOGE_STR("Cannot set event class's event payload field class."); goto error; } @@ -395,7 +199,7 @@ error: ret = -1; end: - bt_put(ft); + bt_object_put_ref(fc); if (basename) { g_free(basename); @@ -407,43 +211,28 @@ end: static int handle_params(struct dmesg_component *dmesg_comp, struct bt_value *params) { - struct bt_value *read_from_stdin = NULL; struct bt_value *no_timestamp = NULL; struct bt_value *path = NULL; const char *path_str; int ret = 0; - read_from_stdin = bt_value_map_get(params, "read-from-stdin"); - if (read_from_stdin) { - if (!bt_value_is_bool(read_from_stdin)) { - BT_LOGE("Expecting a boolean value for the `read-from-stdin` parameter: " - "type=%s", - bt_value_type_string( - bt_value_get_type(read_from_stdin))); - goto error; - } - - ret = bt_value_bool_get(read_from_stdin, - &dmesg_comp->params.read_from_stdin); - assert(ret == 0); - } - - no_timestamp = bt_value_map_get(params, "no-extract-timestamp"); + no_timestamp = bt_value_map_borrow_entry_value(params, + "no-extract-timestamp"); if (no_timestamp) { if (!bt_value_is_bool(no_timestamp)) { BT_LOGE("Expecting a boolean value for the `no-extract-timestamp` parameter: " "type=%s", - bt_value_type_string( + bt_common_value_type_string( bt_value_get_type(no_timestamp))); goto error; } ret = bt_value_bool_get(no_timestamp, &dmesg_comp->params.no_timestamp); - assert(ret == 0); + BT_ASSERT(ret == 0); } - path = bt_value_map_get(params, "path"); + path = bt_value_map_borrow_entry_value(params, "path"); if (path) { if (dmesg_comp->params.read_from_stdin) { BT_LOGE_STR("Cannot specify both `read-from-stdin` and `path` parameters."); @@ -453,19 +242,16 @@ int handle_params(struct dmesg_component *dmesg_comp, struct bt_value *params) if (!bt_value_is_string(path)) { BT_LOGE("Expecting a string value for the `path` parameter: " "type=%s", - bt_value_type_string( + bt_common_value_type_string( bt_value_get_type(path))); goto error; } ret = bt_value_string_get(path, &path_str); - assert(ret == 0); + BT_ASSERT(ret == 0); g_string_assign(dmesg_comp->params.path, path_str); } else { - if (!dmesg_comp->params.read_from_stdin) { - BT_LOGE_STR("Expecting `path` parameter or true `read-from-stdin` parameter."); - goto error; - } + dmesg_comp->params.read_from_stdin = true; } goto end; @@ -474,147 +260,27 @@ error: ret = -1; end: - bt_put(read_from_stdin); - bt_put(path); - bt_put(no_timestamp); return ret; } -static -struct bt_ctf_field *create_packet_header_field(struct bt_ctf_field_type *ft) -{ - struct bt_ctf_field *ph = NULL; - struct bt_ctf_field *magic = NULL; - int ret; - - ph = bt_ctf_field_create(ft); - if (!ph) { - BT_LOGE_STR("Cannot create field object."); - goto error; - } - - magic = bt_ctf_field_structure_get_field_by_name(ph, "magic"); - if (!magic) { - BT_LOGE_STR("Cannot get `magic` field from structure field."); - goto error; - } - - ret = bt_ctf_field_unsigned_integer_set_value(magic, 0xc1fc1fc1); - if (ret) { - BT_LOGE_STR("Cannot set integer field's value."); - goto error; - } - - goto end; - -error: - BT_PUT(ph); - -end: - bt_put(magic); - return ph; -} - -static -struct bt_ctf_field *create_packet_context_field(struct bt_ctf_field_type *ft) -{ - struct bt_ctf_field *pc = NULL; - struct bt_ctf_field *field = NULL; - int ret; - - pc = bt_ctf_field_create(ft); - if (!pc) { - BT_LOGE_STR("Cannot create field object."); - goto error; - } - - field = bt_ctf_field_structure_get_field_by_name(pc, "content_size"); - if (!field) { - BT_LOGE_STR("Cannot get `content_size` field from structure field."); - goto error; - } - - ret = bt_ctf_field_unsigned_integer_set_value(field, 0); - if (ret) { - BT_LOGE_STR("Cannot set integer field's value."); - goto error; - } - - bt_put(field); - field = bt_ctf_field_structure_get_field_by_name(pc, "packet_size"); - if (!field) { - BT_LOGE_STR("Cannot get `packet_size` field from structure field."); - goto error; - } - - ret = bt_ctf_field_unsigned_integer_set_value(field, 0); - if (ret) { - BT_LOGE_STR("Cannot set integer field's value."); - goto error; - } - - goto end; - -error: - BT_PUT(pc); - -end: - bt_put(field); - return pc; -} - static int create_packet_and_stream(struct dmesg_component *dmesg_comp) { int ret = 0; - struct bt_ctf_field_type *ft = NULL; - struct bt_ctf_field *field = NULL; - dmesg_comp->stream = bt_ctf_stream_create(dmesg_comp->stream_class, - NULL); + dmesg_comp->stream = bt_stream_create(dmesg_comp->stream_class); if (!dmesg_comp->stream) { BT_LOGE_STR("Cannot create stream object."); goto error; } - dmesg_comp->packet = bt_ctf_packet_create(dmesg_comp->stream); + dmesg_comp->packet = bt_packet_create(dmesg_comp->stream); if (!dmesg_comp->packet) { BT_LOGE_STR("Cannot create packet object."); goto error; } - ft = bt_ctf_trace_get_packet_header_type(dmesg_comp->trace); - assert(ft); - field = create_packet_header_field(ft); - if (!field) { - BT_LOGE_STR("Cannot create packet header field."); - goto error; - } - - ret = bt_ctf_packet_set_header(dmesg_comp->packet, field); - if (ret) { - BT_LOGE_STR("Cannot set packet's header field."); - goto error; - } - - bt_put(ft); - bt_put(field); - ft = bt_ctf_stream_class_get_packet_context_type( - dmesg_comp->stream_class); - assert(ft); - field = create_packet_context_field(ft); - if (!field) { - BT_LOGE_STR("Cannot create packet context field."); - goto error; - } - - ret = bt_ctf_packet_set_context(dmesg_comp->packet, field); - if (ret) { - BT_LOGE_STR("Cannot set packet's context field."); - goto error; - } - - ret = bt_ctf_trace_set_is_static(dmesg_comp->trace); + ret = bt_trace_make_static(dmesg_comp->trace); if (ret) { BT_LOGE_STR("Cannot make trace static."); goto error; @@ -626,8 +292,6 @@ error: ret = -1; end: - bt_put(field); - bt_put(ft); return ret; } @@ -676,13 +340,13 @@ void destroy_dmesg_component(struct dmesg_component *dmesg_comp) g_string_free(dmesg_comp->params.path, TRUE); } - bt_put(dmesg_comp->packet); - bt_put(dmesg_comp->trace); - bt_put(dmesg_comp->stream_class); - bt_put(dmesg_comp->event_class); - bt_put(dmesg_comp->stream); - bt_put(dmesg_comp->clock_class); - bt_put(dmesg_comp->cc_prio_map); + bt_object_put_ref(dmesg_comp->packet); + bt_object_put_ref(dmesg_comp->trace); + bt_object_put_ref(dmesg_comp->stream_class); + bt_object_put_ref(dmesg_comp->event_class); + bt_object_put_ref(dmesg_comp->stream); + bt_object_put_ref(dmesg_comp->clock_class); + bt_object_put_ref(dmesg_comp->cc_prio_map); g_free(dmesg_comp); } @@ -756,24 +420,19 @@ void dmesg_finalize(struct bt_private_component *priv_comp) } static -int create_event_header_from_line( - struct dmesg_component *dmesg_comp, - const char *line, const char **new_start, - struct bt_ctf_field **user_field, - struct bt_ctf_clock_value **user_clock_value) +struct bt_notification *create_init_event_notif_from_line( + struct dmesg_notif_iter *notif_iter, + const char *line, const char **new_start) { + struct bt_event *event; + struct bt_notification *notif = NULL; bool has_timestamp = false; unsigned long sec, usec, msec; unsigned int year, mon, mday, hour, min; uint64_t ts = 0; - struct bt_ctf_clock_value *clock_value = NULL; - struct bt_ctf_field_type *ft = NULL; - struct bt_ctf_field *eh_field = NULL; - struct bt_ctf_field *ts_field = NULL; int ret = 0; + struct dmesg_component *dmesg_comp = notif_iter->dmesg_comp; - assert(user_clock_value); - assert(user_field); *new_start = line; if (dmesg_comp->params.no_timestamp) { @@ -816,7 +475,7 @@ int create_event_header_from_line( if (has_timestamp) { /* Set new start for the message portion of the line */ *new_start = strchr(line, ']'); - assert(*new_start); + BT_ASSERT(*new_start); (*new_start)++; if ((*new_start)[0] == ' ') { @@ -827,7 +486,7 @@ int create_event_header_from_line( skip_ts: /* * At this point, we know if the stream class's event header - * field type should have a timestamp or not, so we can lazily + * field class should have a timestamp or not, so we can lazily * create the metadata, stream, and packet objects. */ ret = try_create_meta_stream_packet(dmesg_comp, has_timestamp); @@ -836,78 +495,44 @@ skip_ts: goto error; } - if (dmesg_comp->clock_class) { - clock_value = bt_ctf_clock_value_create(dmesg_comp->clock_class, - ts); - if (!clock_value) { - BT_LOGE_STR("Cannot create clock value object."); - goto error; - } - - ft = bt_ctf_stream_class_get_event_header_type( - dmesg_comp->stream_class); - assert(ft); - eh_field = bt_ctf_field_create(ft); - if (!eh_field) { - BT_LOGE_STR("Cannot create event header field object."); - goto error; - } - - ts_field = bt_ctf_field_structure_get_field_by_name(eh_field, - "timestamp"); - if (!ts_field) { - BT_LOGE_STR("Cannot get `timestamp` field from structure field."); - goto error; - } + notif = bt_notification_event_create(notif_iter->pc_notif_iter, + dmesg_comp->event_class, dmesg_comp->packet); + if (!notif) { + BT_LOGE_STR("Cannot create event notification."); + goto error; + } - ret = bt_ctf_field_unsigned_integer_set_value(ts_field, ts); - if (ret) { - BT_LOGE_STR("Cannot set integer field's value."); - goto error; - } + event = bt_notification_event_borrow_event(notif); + BT_ASSERT(event); - *user_clock_value = clock_value; - clock_value = NULL; - *user_field = eh_field; - eh_field = NULL; + if (dmesg_comp->clock_class) { + ret = bt_event_set_default_clock_value(event, ts); + BT_ASSERT(ret == 0); } goto end; error: - ret = -1; + BT_OBJECT_PUT_REF_AND_RESET(notif); end: - bt_put(ft); - bt_put(ts_field); - bt_put(clock_value); - bt_put(eh_field); - return ret; + return notif; } static -int create_event_payload_from_line( - struct dmesg_component *dmesg_comp, - const char *line, struct bt_ctf_field **user_field) +int fill_event_payload_from_line(const char *line, struct bt_event *event) { - struct bt_ctf_field_type *ft = NULL; - struct bt_ctf_field *ep_field = NULL; - struct bt_ctf_field *str_field = NULL; + struct bt_field *ep_field = NULL; + struct bt_field *str_field = NULL; size_t len; int ret; - assert(user_field); - ft = bt_ctf_event_class_get_payload_type(dmesg_comp->event_class); - assert(ft); - ep_field = bt_ctf_field_create(ft); - if (!ep_field) { - BT_LOGE_STR("Cannot create event payload field object."); - goto error; - } - - str_field = bt_ctf_field_structure_get_field_by_name(ep_field, "str"); + ep_field = bt_event_borrow_payload_field(event); + BT_ASSERT(ep_field); + str_field = bt_field_structure_borrow_member_field_by_index(ep_field, + 0); if (!str_field) { - BT_LOGE_STR("Cannot get `timestamp` field from structure field."); + BT_LOGE_STR("Cannot borrow `timestamp` field from event payload structure field."); goto error; } @@ -917,106 +542,59 @@ int create_event_payload_from_line( len--; } - ret = bt_ctf_field_string_append_len(str_field, line, len); + ret = bt_field_string_clear(str_field); + if (ret) { + BT_LOGE_STR("Cannot clear string field object."); + goto error; + } + + ret = bt_field_string_append_with_length(str_field, line, len); if (ret) { BT_LOGE("Cannot append value to string field object: " "len=%zu", len); goto error; } - *user_field = ep_field; - ep_field = NULL; goto end; error: ret = -1; end: - bt_put(ft); - bt_put(ep_field); - bt_put(str_field); return ret; } static struct bt_notification *create_notif_from_line( - struct dmesg_component *dmesg_comp, const char *line) + struct dmesg_notif_iter *dmesg_notif_iter, const char *line) { - struct bt_ctf_field *eh_field = NULL; - struct bt_ctf_field *ep_field = NULL; - struct bt_ctf_clock_value *clock_value = NULL; - struct bt_ctf_event *event = NULL; + struct bt_event *event = NULL; struct bt_notification *notif = NULL; const char *new_start; int ret; - ret = create_event_header_from_line(dmesg_comp, line, &new_start, - &eh_field, &clock_value); - if (ret) { - BT_LOGE("Cannot create event header field from line: " - "ret=%d", ret); + notif = create_init_event_notif_from_line(dmesg_notif_iter, + line, &new_start); + if (!notif) { + BT_LOGE_STR("Cannot create and initialize event notification from line."); goto error; } - ret = create_event_payload_from_line(dmesg_comp, new_start, - &ep_field); + event = bt_notification_event_borrow_event(notif); + BT_ASSERT(event); + ret = fill_event_payload_from_line(new_start, event); if (ret) { - BT_LOGE("Cannot create event payload field from line: " + BT_LOGE("Cannot fill event payload field from line: " "ret=%d", ret); goto error; } - assert(ep_field); - event = bt_ctf_event_create(dmesg_comp->event_class); - if (!event) { - BT_LOGE_STR("Cannot create event object."); - goto error; - } - - ret = bt_ctf_event_set_packet(event, dmesg_comp->packet); - if (ret) { - BT_LOGE_STR("Cannot set event's packet."); - goto error; - } - - if (eh_field) { - ret = bt_ctf_event_set_header(event, eh_field); - if (ret) { - BT_LOGE_STR("Cannot set event's header field."); - goto error; - } - } - - ret = bt_ctf_event_set_event_payload(event, ep_field); - if (ret) { - BT_LOGE_STR("Cannot set event's payload field."); - goto error; - } - - if (clock_value) { - ret = bt_ctf_event_set_clock_value(event, clock_value); - if (ret) { - BT_LOGE_STR("Cannot set event's clock value."); - goto error; - } - } - - notif = bt_notification_event_create(event, dmesg_comp->cc_prio_map); - if (!notif) { - BT_LOGE_STR("Cannot create event notification."); - goto error; - } - goto end; error: - BT_PUT(notif); + BT_OBJECT_PUT_REF_AND_RESET(notif); end: - bt_put(eh_field); - bt_put(ep_field); - bt_put(clock_value); - bt_put(event); return notif; } @@ -1033,13 +611,14 @@ void destroy_dmesg_notif_iter(struct dmesg_notif_iter *dmesg_notif_iter) } } + bt_object_put_ref(dmesg_notif_iter->tmp_event_notif); free(dmesg_notif_iter->linebuf); g_free(dmesg_notif_iter); } BT_HIDDEN enum bt_notification_iterator_status dmesg_notif_iter_init( - struct bt_private_notification_iterator *priv_notif_iter, + struct bt_private_connection_private_notification_iterator *priv_notif_iter, struct bt_private_port *priv_port) { struct bt_private_component *priv_comp = NULL; @@ -1054,12 +633,13 @@ enum bt_notification_iterator_status dmesg_notif_iter_init( goto error; } - priv_comp = bt_private_notification_iterator_get_private_component( + priv_comp = bt_private_connection_private_notification_iterator_get_private_component( priv_notif_iter); - assert(priv_comp); + BT_ASSERT(priv_comp); dmesg_comp = bt_private_component_get_user_data(priv_comp); - assert(dmesg_comp); + BT_ASSERT(dmesg_comp); dmesg_notif_iter->dmesg_comp = dmesg_comp; + dmesg_notif_iter->pc_notif_iter = priv_notif_iter; if (dmesg_comp->params.read_from_stdin) { dmesg_notif_iter->fp = stdin; @@ -1072,48 +652,55 @@ enum bt_notification_iterator_status dmesg_notif_iter_init( } } - (void) bt_private_notification_iterator_set_user_data(priv_notif_iter, + (void) bt_private_connection_private_notification_iterator_set_user_data(priv_notif_iter, dmesg_notif_iter); goto end; error: destroy_dmesg_notif_iter(dmesg_notif_iter); - (void) bt_private_notification_iterator_set_user_data(priv_notif_iter, + (void) bt_private_connection_private_notification_iterator_set_user_data(priv_notif_iter, NULL); if (status >= 0) { status = BT_NOTIFICATION_ITERATOR_STATUS_ERROR; } end: - bt_put(priv_comp); + bt_object_put_ref(priv_comp); return status; } BT_HIDDEN void dmesg_notif_iter_finalize( - struct bt_private_notification_iterator *priv_notif_iter) + struct bt_private_connection_private_notification_iterator *priv_notif_iter) { - destroy_dmesg_notif_iter(bt_private_notification_iterator_get_user_data( + destroy_dmesg_notif_iter(bt_private_connection_private_notification_iterator_get_user_data( priv_notif_iter)); } -BT_HIDDEN -struct bt_notification_iterator_next_return dmesg_notif_iter_next( - struct bt_private_notification_iterator *priv_notif_iter) +static +enum bt_notification_iterator_status dmesg_notif_iter_next_one( + struct dmesg_notif_iter *dmesg_notif_iter, + struct bt_notification **notif) { ssize_t len; - struct dmesg_notif_iter *dmesg_notif_iter = - bt_private_notification_iterator_get_user_data( - priv_notif_iter); struct dmesg_component *dmesg_comp; - struct bt_notification_iterator_next_return next_ret = { - .status = BT_NOTIFICATION_ITERATOR_STATUS_OK, - .notification = NULL - }; + enum bt_notification_iterator_status status = + BT_NOTIFICATION_ITERATOR_STATUS_OK; - assert(dmesg_notif_iter); + BT_ASSERT(dmesg_notif_iter); dmesg_comp = dmesg_notif_iter->dmesg_comp; - assert(dmesg_comp); + BT_ASSERT(dmesg_comp); + + if (dmesg_notif_iter->state == STATE_DONE) { + status = BT_NOTIFICATION_ITERATOR_STATUS_END; + goto end; + } + + if (dmesg_notif_iter->tmp_event_notif || + dmesg_notif_iter->state == STATE_EMIT_PACKET_END || + dmesg_notif_iter->state == STATE_EMIT_STREAM_END) { + goto handle_state; + } while (true) { const char *ch; @@ -1123,20 +710,27 @@ struct bt_notification_iterator_next_return dmesg_notif_iter_next( &dmesg_notif_iter->linebuf_len, dmesg_notif_iter->fp); if (len < 0) { if (errno == EINVAL) { - next_ret.status = - BT_NOTIFICATION_ITERATOR_STATUS_ERROR; + status = BT_NOTIFICATION_ITERATOR_STATUS_ERROR; } else if (errno == ENOMEM) { - next_ret.status = + status = BT_NOTIFICATION_ITERATOR_STATUS_NOMEM; } else { - next_ret.status = - BT_NOTIFICATION_ITERATOR_STATUS_END; + if (dmesg_notif_iter->state == STATE_EMIT_STREAM_BEGINNING) { + /* Stream did not even begin */ + status = BT_NOTIFICATION_ITERATOR_STATUS_END; + goto end; + } else { + /* End current packet now */ + dmesg_notif_iter->state = + STATE_EMIT_PACKET_END; + goto handle_state; + } } goto end; } - assert(dmesg_notif_iter->linebuf); + BT_ASSERT(dmesg_notif_iter->linebuf); /* Ignore empty lines, once trimmed */ for (ch = dmesg_notif_iter->linebuf; *ch != '\0'; ch++) { @@ -1151,14 +745,96 @@ struct bt_notification_iterator_next_return dmesg_notif_iter_next( } } - next_ret.notification = create_notif_from_line(dmesg_comp, - dmesg_notif_iter->linebuf); - if (!next_ret.notification) { + dmesg_notif_iter->tmp_event_notif = create_notif_from_line( + dmesg_notif_iter, dmesg_notif_iter->linebuf); + if (!dmesg_notif_iter->tmp_event_notif) { BT_LOGE("Cannot create event notification from line: " "dmesg-comp-addr=%p, line=\"%s\"", dmesg_comp, dmesg_notif_iter->linebuf); + goto end; + } + +handle_state: + BT_ASSERT(dmesg_comp->trace); + + switch (dmesg_notif_iter->state) { + case STATE_EMIT_STREAM_BEGINNING: + BT_ASSERT(dmesg_notif_iter->tmp_event_notif); + *notif = bt_notification_stream_begin_create( + dmesg_notif_iter->pc_notif_iter, dmesg_comp->stream); + dmesg_notif_iter->state = STATE_EMIT_PACKET_BEGINNING; + break; + case STATE_EMIT_PACKET_BEGINNING: + BT_ASSERT(dmesg_notif_iter->tmp_event_notif); + *notif = bt_notification_packet_begin_create( + dmesg_notif_iter->pc_notif_iter, dmesg_comp->packet); + dmesg_notif_iter->state = STATE_EMIT_EVENT; + break; + case STATE_EMIT_EVENT: + BT_ASSERT(dmesg_notif_iter->tmp_event_notif); + *notif = dmesg_notif_iter->tmp_event_notif; + dmesg_notif_iter->tmp_event_notif = NULL; + break; + case STATE_EMIT_PACKET_END: + *notif = bt_notification_packet_end_create( + dmesg_notif_iter->pc_notif_iter, dmesg_comp->packet); + dmesg_notif_iter->state = STATE_EMIT_STREAM_END; + break; + case STATE_EMIT_STREAM_END: + *notif = bt_notification_stream_end_create( + dmesg_notif_iter->pc_notif_iter, dmesg_comp->stream); + dmesg_notif_iter->state = STATE_DONE; + break; + default: + break; + } + + if (!*notif) { + BT_LOGE("Cannot create notification: dmesg-comp-addr=%p", + dmesg_comp); + status = BT_NOTIFICATION_ITERATOR_STATUS_ERROR; } end: - return next_ret; + return status; +} + +BT_HIDDEN +enum bt_notification_iterator_status dmesg_notif_iter_next( + struct bt_private_connection_private_notification_iterator *priv_notif_iter, + bt_notification_array notifs, uint64_t capacity, + uint64_t *count) +{ + struct dmesg_notif_iter *dmesg_notif_iter = + bt_private_connection_private_notification_iterator_get_user_data( + priv_notif_iter); + enum bt_notification_iterator_status status = + BT_NOTIFICATION_ITERATOR_STATUS_OK; + uint64_t i = 0; + + while (i < capacity && status == BT_NOTIFICATION_ITERATOR_STATUS_OK) { + status = dmesg_notif_iter_next_one(dmesg_notif_iter, ¬ifs[i]); + if (status == BT_NOTIFICATION_ITERATOR_STATUS_OK) { + i++; + } + } + + if (i > 0) { + /* + * Even if dmesg_notif_iter_next_one() returned + * something else than + * BT_NOTIFICATION_ITERATOR_STATUS_OK, we accumulated + * notification objects in the output notification + * array, so we need to return + * BT_NOTIFICATION_ITERATOR_STATUS_OK so that they are + * transfered to downstream. This other status occurs + * again the next time muxer_notif_iter_do_next() is + * called, possibly without any accumulated + * notification, in which case we'll return it. + */ + *count = i; + status = BT_NOTIFICATION_ITERATOR_STATUS_OK; + } + + return status; }