X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=plugins%2Ftext%2Fdmesg%2Fdmesg.c;h=d8afa858c4af47006a1d8d2a51603c0cb4de0c76;hb=7fcdb0a96f75d66f5ff4f32d3ca78d7ca6067e4c;hp=4da898bdb4f75559c57519be1d50c93f16af1a8b;hpb=bb5bb16080ef123c91a690eb267a8d83bd4fb199;p=babeltrace.git diff --git a/plugins/text/dmesg/dmesg.c b/plugins/text/dmesg/dmesg.c index 4da898bd..d8afa858 100644 --- a/plugins/text/dmesg/dmesg.c +++ b/plugins/text/dmesg/dmesg.c @@ -31,7 +31,7 @@ #include #include #include -#include +#include #include #include #include @@ -43,19 +43,22 @@ struct dmesg_component; -struct dmesg_notif_iter { +struct dmesg_msg_iter { struct dmesg_component *dmesg_comp; - struct bt_self_notification_iterator *pc_notif_iter; /* Weak */ + bt_self_message_iterator *pc_msg_iter; /* Weak */ char *linebuf; size_t linebuf_len; FILE *fp; - struct bt_notification *tmp_event_notif; + bt_message *tmp_event_msg; + uint64_t last_clock_value; enum { STATE_EMIT_STREAM_BEGINNING, + STATE_EMIT_STREAM_ACTIVITY_BEGINNING, STATE_EMIT_PACKET_BEGINNING, STATE_EMIT_EVENT, STATE_EMIT_PACKET_END, + STATE_EMIT_STREAM_ACTIVITY_END, STATE_EMIT_STREAM_END, STATE_DONE, } state; @@ -68,29 +71,30 @@ struct dmesg_component { bt_bool no_timestamp; } params; - struct bt_trace_class *trace_class; - struct bt_stream_class *stream_class; - struct bt_event_class *event_class; - struct bt_trace *trace; - struct bt_stream *stream; - struct bt_packet *packet; - struct bt_clock_class *clock_class; + bt_self_component_source *self_comp; + bt_trace_class *trace_class; + bt_stream_class *stream_class; + bt_event_class *event_class; + bt_trace *trace; + bt_stream *stream; + bt_packet *packet; + bt_clock_class *clock_class; }; static -struct bt_field_class *create_event_payload_fc(void) +bt_field_class *create_event_payload_fc(bt_trace_class *trace_class) { - struct bt_field_class *root_fc = NULL; - struct bt_field_class *fc = NULL; + bt_field_class *root_fc = NULL; + bt_field_class *fc = NULL; int ret; - root_fc = bt_field_class_structure_create(); + root_fc = bt_field_class_structure_create(trace_class); if (!root_fc) { BT_LOGE_STR("Cannot create an empty structure field class object."); goto error; } - fc = bt_field_class_string_create(); + fc = bt_field_class_string_create(trace_class); if (!fc) { BT_LOGE_STR("Cannot create a string field class object."); goto error; @@ -107,20 +111,22 @@ struct bt_field_class *create_event_payload_fc(void) goto end; error: - BT_OBJECT_PUT_REF_AND_RESET(root_fc); + BT_FIELD_CLASS_PUT_REF_AND_RESET(root_fc); end: - bt_object_put_ref(fc); + bt_field_class_put_ref(fc); return root_fc; } static int create_meta(struct dmesg_component *dmesg_comp, bool has_ts) { - struct bt_field_class *fc = NULL; + bt_field_class *fc = NULL; int ret = 0; - dmesg_comp->trace_class = bt_trace_class_create(); + dmesg_comp->trace_class = bt_trace_class_create( + bt_self_component_source_as_self_component( + dmesg_comp->self_comp)); if (!dmesg_comp->trace_class) { BT_LOGE_STR("Cannot create an empty trace class object."); goto error; @@ -134,12 +140,21 @@ int create_meta(struct dmesg_component *dmesg_comp, bool has_ts) } if (has_ts) { - dmesg_comp->clock_class = bt_clock_class_create(); + dmesg_comp->clock_class = bt_clock_class_create( + bt_self_component_source_as_self_component( + dmesg_comp->self_comp)); if (!dmesg_comp->clock_class) { BT_LOGE_STR("Cannot create clock class."); goto error; } + /* + * The `dmesg` timestamp's origin is not the Unix epoch, + * it's the boot time. + */ + bt_clock_class_set_origin_is_unix_epoch(dmesg_comp->clock_class, + BT_FALSE); + ret = bt_stream_class_set_default_clock_class( dmesg_comp->stream_class, dmesg_comp->clock_class); if (ret) { @@ -161,7 +176,7 @@ int create_meta(struct dmesg_component *dmesg_comp, bool has_ts) goto error; } - fc = create_event_payload_fc(); + fc = create_event_payload_fc(dmesg_comp->trace_class); if (!fc) { BT_LOGE_STR("Cannot create event payload field class."); goto error; @@ -179,16 +194,16 @@ error: ret = -1; end: - bt_object_put_ref(fc); + bt_field_class_put_ref(fc); return ret; } static int handle_params(struct dmesg_component *dmesg_comp, - const struct bt_value *params) + const bt_value *params) { - const struct bt_value *no_timestamp = NULL; - const struct bt_value *path = NULL; + const bt_value *no_timestamp = NULL; + const bt_value *path = NULL; const char *path_str; int ret = 0; @@ -241,7 +256,7 @@ static int create_packet_and_stream_and_trace(struct dmesg_component *dmesg_comp) { int ret = 0; - const char *trace_name; + const char *trace_name = NULL; gchar *basename = NULL; dmesg_comp->trace = bt_trace_create(dmesg_comp->trace_class); @@ -348,37 +363,39 @@ void destroy_dmesg_component(struct dmesg_component *dmesg_comp) g_string_free(dmesg_comp->params.path, TRUE); } - 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_packet_put_ref(dmesg_comp->packet); + bt_trace_put_ref(dmesg_comp->trace); + bt_stream_class_put_ref(dmesg_comp->stream_class); + bt_event_class_put_ref(dmesg_comp->event_class); + bt_stream_put_ref(dmesg_comp->stream); + bt_clock_class_put_ref(dmesg_comp->clock_class); + bt_trace_class_put_ref(dmesg_comp->trace_class); g_free(dmesg_comp); } static -enum bt_self_component_status create_port( - struct bt_self_component_source *self_comp) +bt_self_component_status create_port( + bt_self_component_source *self_comp) { return bt_self_component_source_add_output_port(self_comp, "out", NULL, NULL); } BT_HIDDEN -enum bt_self_component_status dmesg_init( - struct bt_self_component_source *self_comp, - struct bt_value *params, void *init_method_data) +bt_self_component_status dmesg_init( + bt_self_component_source *self_comp, + bt_value *params, void *init_method_data) { int ret = 0; struct dmesg_component *dmesg_comp = g_new0(struct dmesg_component, 1); - enum bt_self_component_status status = BT_SELF_COMPONENT_STATUS_OK; + bt_self_component_status status = BT_SELF_COMPONENT_STATUS_OK; if (!dmesg_comp) { BT_LOGE_STR("Failed to allocate one dmesg component structure."); goto error; } + dmesg_comp->self_comp = self_comp; dmesg_comp->params.path = g_string_new(NULL); if (!dmesg_comp->params.path) { BT_LOGE_STR("Failed to allocate a GString."); @@ -425,25 +442,25 @@ end: } BT_HIDDEN -void dmesg_finalize(struct bt_self_component_source *self_comp) +void dmesg_finalize(bt_self_component_source *self_comp) { destroy_dmesg_component(bt_self_component_get_data( bt_self_component_source_as_self_component(self_comp))); } static -struct bt_notification *create_init_event_notif_from_line( - struct dmesg_notif_iter *notif_iter, +bt_message *create_init_event_msg_from_line( + struct dmesg_msg_iter *msg_iter, const char *line, const char **new_start) { - struct bt_event *event; - struct bt_notification *notif = NULL; + bt_event *event; + bt_message *msg = NULL; bool has_timestamp = false; unsigned long sec, usec, msec; unsigned int year, mon, mday, hour, min; uint64_t ts = 0; int ret = 0; - struct dmesg_component *dmesg_comp = notif_iter->dmesg_comp; + struct dmesg_component *dmesg_comp = msg_iter->dmesg_comp; *new_start = line; @@ -507,35 +524,38 @@ skip_ts: 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; + if (dmesg_comp->clock_class) { + msg = bt_message_event_create_with_default_clock_snapshot( + msg_iter->pc_msg_iter, + dmesg_comp->event_class, dmesg_comp->packet, ts); + msg_iter->last_clock_value = ts; + } else { + msg = bt_message_event_create(msg_iter->pc_msg_iter, + dmesg_comp->event_class, dmesg_comp->packet); } - event = bt_notification_event_borrow_event(notif); - BT_ASSERT(event); - - if (dmesg_comp->clock_class) { - bt_event_set_default_clock_value(event, ts); + if (!msg) { + BT_LOGE_STR("Cannot create event message."); + goto error; } + event = bt_message_event_borrow_event(msg); + BT_ASSERT(event); goto end; error: - BT_OBJECT_PUT_REF_AND_RESET(notif); + BT_MESSAGE_PUT_REF_AND_RESET(msg); end: - return notif; + return msg; } static int fill_event_payload_from_line(const char *line, - struct bt_event *event) + bt_event *event) { - struct bt_field *ep_field = NULL; - struct bt_field *str_field = NULL; + bt_field *ep_field = NULL; + bt_field *str_field = NULL; size_t len; int ret; @@ -577,22 +597,22 @@ end: } static -struct bt_notification *create_notif_from_line( - struct dmesg_notif_iter *dmesg_notif_iter, const char *line) +bt_message *create_msg_from_line( + struct dmesg_msg_iter *dmesg_msg_iter, const char *line) { - struct bt_event *event = NULL; - struct bt_notification *notif = NULL; + bt_event *event = NULL; + bt_message *msg = NULL; const char *new_start; int ret; - notif = create_init_event_notif_from_line(dmesg_notif_iter, + msg = create_init_event_msg_from_line(dmesg_msg_iter, line, &new_start); - if (!notif) { - BT_LOGE_STR("Cannot create and initialize event notification from line."); + if (!msg) { + BT_LOGE_STR("Cannot create and initialize event message from line."); goto error; } - event = bt_notification_event_borrow_event(notif); + event = bt_message_event_borrow_event(msg); BT_ASSERT(event); ret = fill_event_payload_from_line(new_start, event); if (ret) { @@ -604,73 +624,75 @@ struct bt_notification *create_notif_from_line( goto end; error: - BT_OBJECT_PUT_REF_AND_RESET(notif); + BT_MESSAGE_PUT_REF_AND_RESET(msg); end: - return notif; + return msg; } static -void destroy_dmesg_notif_iter(struct dmesg_notif_iter *dmesg_notif_iter) +void destroy_dmesg_msg_iter(struct dmesg_msg_iter *dmesg_msg_iter) { - if (!dmesg_notif_iter) { + if (!dmesg_msg_iter) { return; } - if (dmesg_notif_iter->fp && dmesg_notif_iter->fp != stdin) { - if (fclose(dmesg_notif_iter->fp)) { + if (dmesg_msg_iter->fp && dmesg_msg_iter->fp != stdin) { + if (fclose(dmesg_msg_iter->fp)) { BT_LOGE_ERRNO("Cannot close input file", "."); } } - bt_object_put_ref(dmesg_notif_iter->tmp_event_notif); - free(dmesg_notif_iter->linebuf); - g_free(dmesg_notif_iter); + bt_message_put_ref(dmesg_msg_iter->tmp_event_msg); + free(dmesg_msg_iter->linebuf); + g_free(dmesg_msg_iter); } + + BT_HIDDEN -enum bt_self_notification_iterator_status dmesg_notif_iter_init( - struct bt_self_notification_iterator *self_notif_iter, - struct bt_self_component_source *self_comp, - struct bt_self_component_port_output *self_port) +bt_self_message_iterator_status dmesg_msg_iter_init( + bt_self_message_iterator *self_msg_iter, + bt_self_component_source *self_comp, + bt_self_component_port_output *self_port) { struct dmesg_component *dmesg_comp; - struct dmesg_notif_iter *dmesg_notif_iter = - g_new0(struct dmesg_notif_iter, 1); - enum bt_self_notification_iterator_status status = - BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK; + struct dmesg_msg_iter *dmesg_msg_iter = + g_new0(struct dmesg_msg_iter, 1); + bt_self_message_iterator_status status = + BT_SELF_MESSAGE_ITERATOR_STATUS_OK; - if (!dmesg_notif_iter) { - BT_LOGE_STR("Failed to allocate on dmesg notification iterator structure."); + if (!dmesg_msg_iter) { + BT_LOGE_STR("Failed to allocate on dmesg message iterator structure."); goto error; } dmesg_comp = bt_self_component_get_data( bt_self_component_source_as_self_component(self_comp)); BT_ASSERT(dmesg_comp); - dmesg_notif_iter->dmesg_comp = dmesg_comp; - dmesg_notif_iter->pc_notif_iter = self_notif_iter; + dmesg_msg_iter->dmesg_comp = dmesg_comp; + dmesg_msg_iter->pc_msg_iter = self_msg_iter; if (dmesg_comp->params.read_from_stdin) { - dmesg_notif_iter->fp = stdin; + dmesg_msg_iter->fp = stdin; } else { - dmesg_notif_iter->fp = fopen(dmesg_comp->params.path->str, "r"); - if (!dmesg_notif_iter->fp) { + dmesg_msg_iter->fp = fopen(dmesg_comp->params.path->str, "r"); + if (!dmesg_msg_iter->fp) { BT_LOGE_ERRNO("Cannot open input file in read mode", ": path=\"%s\"", dmesg_comp->params.path->str); goto error; } } - bt_self_notification_iterator_set_data(self_notif_iter, - dmesg_notif_iter); + bt_self_message_iterator_set_data(self_msg_iter, + dmesg_msg_iter); goto end; error: - destroy_dmesg_notif_iter(dmesg_notif_iter); - bt_self_notification_iterator_set_data(self_notif_iter, NULL); + destroy_dmesg_msg_iter(dmesg_msg_iter); + bt_self_message_iterator_set_data(self_msg_iter, NULL); if (status >= 0) { - status = BT_SELF_NOTIFICATION_ITERATOR_STATUS_ERROR; + status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR; } end: @@ -678,35 +700,36 @@ end: } BT_HIDDEN -void dmesg_notif_iter_finalize( - struct bt_self_notification_iterator *priv_notif_iter) +void dmesg_msg_iter_finalize( + bt_self_message_iterator *priv_msg_iter) { - destroy_dmesg_notif_iter(bt_self_notification_iterator_get_data( - priv_notif_iter)); + destroy_dmesg_msg_iter(bt_self_message_iterator_get_data( + priv_msg_iter)); } static -enum bt_self_notification_iterator_status dmesg_notif_iter_next_one( - struct dmesg_notif_iter *dmesg_notif_iter, - struct bt_notification **notif) +bt_self_message_iterator_status dmesg_msg_iter_next_one( + struct dmesg_msg_iter *dmesg_msg_iter, + bt_message **msg) { ssize_t len; struct dmesg_component *dmesg_comp; - enum bt_self_notification_iterator_status status = - BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK; + bt_self_message_iterator_status status = + BT_SELF_MESSAGE_ITERATOR_STATUS_OK; - BT_ASSERT(dmesg_notif_iter); - dmesg_comp = dmesg_notif_iter->dmesg_comp; + BT_ASSERT(dmesg_msg_iter); + dmesg_comp = dmesg_msg_iter->dmesg_comp; BT_ASSERT(dmesg_comp); - if (dmesg_notif_iter->state == STATE_DONE) { - status = BT_SELF_NOTIFICATION_ITERATOR_STATUS_END; + if (dmesg_msg_iter->state == STATE_DONE) { + status = BT_SELF_MESSAGE_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) { + if (dmesg_msg_iter->tmp_event_msg || + dmesg_msg_iter->state == STATE_EMIT_PACKET_END || + dmesg_msg_iter->state == STATE_EMIT_STREAM_ACTIVITY_END || + dmesg_msg_iter->state == STATE_EMIT_STREAM_END) { goto handle_state; } @@ -714,22 +737,22 @@ enum bt_self_notification_iterator_status dmesg_notif_iter_next_one( const char *ch; bool only_spaces = true; - len = bt_getline(&dmesg_notif_iter->linebuf, - &dmesg_notif_iter->linebuf_len, dmesg_notif_iter->fp); + len = bt_getline(&dmesg_msg_iter->linebuf, + &dmesg_msg_iter->linebuf_len, dmesg_msg_iter->fp); if (len < 0) { if (errno == EINVAL) { - status = BT_SELF_NOTIFICATION_ITERATOR_STATUS_ERROR; + status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR; } else if (errno == ENOMEM) { status = - BT_SELF_NOTIFICATION_ITERATOR_STATUS_NOMEM; + BT_SELF_MESSAGE_ITERATOR_STATUS_NOMEM; } else { - if (dmesg_notif_iter->state == STATE_EMIT_STREAM_BEGINNING) { + if (dmesg_msg_iter->state == STATE_EMIT_STREAM_BEGINNING) { /* Stream did not even begin */ - status = BT_SELF_NOTIFICATION_ITERATOR_STATUS_END; + status = BT_SELF_MESSAGE_ITERATOR_STATUS_END; goto end; } else { /* End current packet now */ - dmesg_notif_iter->state = + dmesg_msg_iter->state = STATE_EMIT_PACKET_END; goto handle_state; } @@ -738,10 +761,10 @@ enum bt_self_notification_iterator_status dmesg_notif_iter_next_one( goto end; } - BT_ASSERT(dmesg_notif_iter->linebuf); + BT_ASSERT(dmesg_msg_iter->linebuf); /* Ignore empty lines, once trimmed */ - for (ch = dmesg_notif_iter->linebuf; *ch != '\0'; ch++) { + for (ch = dmesg_msg_iter->linebuf; *ch != '\0'; ch++) { if (!isspace(*ch)) { only_spaces = false; break; @@ -753,54 +776,80 @@ enum bt_self_notification_iterator_status dmesg_notif_iter_next_one( } } - 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_msg_iter->tmp_event_msg = create_msg_from_line( + dmesg_msg_iter, dmesg_msg_iter->linebuf); + if (!dmesg_msg_iter->tmp_event_msg) { + BT_LOGE("Cannot create event message from line: " "dmesg-comp-addr=%p, line=\"%s\"", dmesg_comp, - dmesg_notif_iter->linebuf); + dmesg_msg_iter->linebuf); goto end; } handle_state: BT_ASSERT(dmesg_comp->trace); - switch (dmesg_notif_iter->state) { + switch (dmesg_msg_iter->state) { case STATE_EMIT_STREAM_BEGINNING: - BT_ASSERT(dmesg_notif_iter->tmp_event_notif); - *notif = bt_notification_stream_beginning_create( - dmesg_notif_iter->pc_notif_iter, dmesg_comp->stream); - dmesg_notif_iter->state = STATE_EMIT_PACKET_BEGINNING; + BT_ASSERT(dmesg_msg_iter->tmp_event_msg); + *msg = bt_message_stream_beginning_create( + dmesg_msg_iter->pc_msg_iter, dmesg_comp->stream); + dmesg_msg_iter->state = STATE_EMIT_STREAM_ACTIVITY_BEGINNING; + break; + case STATE_EMIT_STREAM_ACTIVITY_BEGINNING: + BT_ASSERT(dmesg_msg_iter->tmp_event_msg); + *msg = bt_message_stream_activity_beginning_create( + dmesg_msg_iter->pc_msg_iter, dmesg_comp->stream); + dmesg_msg_iter->state = STATE_EMIT_PACKET_BEGINNING; break; case STATE_EMIT_PACKET_BEGINNING: - BT_ASSERT(dmesg_notif_iter->tmp_event_notif); - *notif = bt_notification_packet_beginning_create( - dmesg_notif_iter->pc_notif_iter, dmesg_comp->packet); - dmesg_notif_iter->state = STATE_EMIT_EVENT; + BT_ASSERT(dmesg_msg_iter->tmp_event_msg); + + if (dmesg_comp->clock_class) { + *msg = bt_message_packet_beginning_create_with_default_clock_snapshot( + dmesg_msg_iter->pc_msg_iter, dmesg_comp->packet, + dmesg_msg_iter->last_clock_value); + } else { + *msg = bt_message_packet_beginning_create( + dmesg_msg_iter->pc_msg_iter, dmesg_comp->packet); + } + + dmesg_msg_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; + BT_ASSERT(dmesg_msg_iter->tmp_event_msg); + *msg = dmesg_msg_iter->tmp_event_msg; + dmesg_msg_iter->tmp_event_msg = 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; + if (dmesg_comp->clock_class) { + *msg = bt_message_packet_end_create_with_default_clock_snapshot( + dmesg_msg_iter->pc_msg_iter, dmesg_comp->packet, + dmesg_msg_iter->last_clock_value); + } else { + *msg = bt_message_packet_end_create( + dmesg_msg_iter->pc_msg_iter, dmesg_comp->packet); + } + + dmesg_msg_iter->state = STATE_EMIT_STREAM_ACTIVITY_END; + break; + case STATE_EMIT_STREAM_ACTIVITY_END: + *msg = bt_message_stream_activity_end_create( + dmesg_msg_iter->pc_msg_iter, dmesg_comp->stream); + dmesg_msg_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; + *msg = bt_message_stream_end_create( + dmesg_msg_iter->pc_msg_iter, dmesg_comp->stream); + dmesg_msg_iter->state = STATE_DONE; break; default: break; } - if (!*notif) { - BT_LOGE("Cannot create notification: dmesg-comp-addr=%p", + if (!*msg) { + BT_LOGE("Cannot create message: dmesg-comp-addr=%p", dmesg_comp); - status = BT_SELF_NOTIFICATION_ITERATOR_STATUS_ERROR; + status = BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR; } end: @@ -808,46 +857,72 @@ end: } BT_HIDDEN -enum bt_self_notification_iterator_status dmesg_notif_iter_next( - struct bt_self_notification_iterator *self_notif_iter, - bt_notification_array_const notifs, uint64_t capacity, +bt_self_message_iterator_status dmesg_msg_iter_next( + bt_self_message_iterator *self_msg_iter, + bt_message_array_const msgs, uint64_t capacity, uint64_t *count) { - struct dmesg_notif_iter *dmesg_notif_iter = - bt_self_notification_iterator_get_data( - self_notif_iter); - enum bt_self_notification_iterator_status status = - BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK; + struct dmesg_msg_iter *dmesg_msg_iter = + bt_self_message_iterator_get_data( + self_msg_iter); + bt_self_message_iterator_status status = + BT_SELF_MESSAGE_ITERATOR_STATUS_OK; uint64_t i = 0; while (i < capacity && - status == BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK) { - struct bt_notification *priv_notif = NULL; + status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK) { + bt_message *priv_msg = NULL; - status = dmesg_notif_iter_next_one(dmesg_notif_iter, - &priv_notif); - notifs[i] = priv_notif; - if (status == BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK) { + status = dmesg_msg_iter_next_one(dmesg_msg_iter, + &priv_msg); + msgs[i] = priv_msg; + if (status == BT_SELF_MESSAGE_ITERATOR_STATUS_OK) { i++; } } if (i > 0) { /* - * Even if dmesg_notif_iter_next_one() returned + * Even if dmesg_msg_iter_next_one() returned * something else than - * BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK, we - * accumulated notification objects in the output - * notification array, so we need to return - * BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK so that they + * BT_SELF_MESSAGE_ITERATOR_STATUS_OK, we + * accumulated message objects in the output + * message array, so we need to return + * BT_SELF_MESSAGE_ITERATOR_STATUS_OK so that they * are transfered to downstream. This other status - * occurs again the next time muxer_notif_iter_do_next() + * occurs again the next time muxer_msg_iter_do_next() * is called, possibly without any accumulated - * notification, in which case we'll return it. + * message, in which case we'll return it. */ *count = i; - status = BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK; + status = BT_SELF_MESSAGE_ITERATOR_STATUS_OK; } return status; } + +BT_HIDDEN +bt_bool dmesg_msg_iter_can_seek_beginning( + bt_self_message_iterator *self_msg_iter) +{ + struct dmesg_msg_iter *dmesg_msg_iter = + bt_self_message_iterator_get_data(self_msg_iter); + + /* Can't seek the beginning of the standard input stream */ + return !dmesg_msg_iter->dmesg_comp->params.read_from_stdin; +} + +BT_HIDDEN +bt_self_message_iterator_status dmesg_msg_iter_seek_beginning( + bt_self_message_iterator *self_msg_iter) +{ + struct dmesg_msg_iter *dmesg_msg_iter = + bt_self_message_iterator_get_data(self_msg_iter); + + BT_ASSERT(!dmesg_msg_iter->dmesg_comp->params.read_from_stdin); + + BT_MESSAGE_PUT_REF_AND_RESET(dmesg_msg_iter->tmp_event_msg); + dmesg_msg_iter->last_clock_value = 0; + dmesg_msg_iter->state = STATE_EMIT_STREAM_BEGINNING; + return BT_SELF_MESSAGE_ITERATOR_STATUS_OK; +}