#include <babeltrace/ctf-ir/stream.h>
#include <babeltrace/ctf-ir/clock-class.h>
#include <babeltrace/ctf-ir/event-class.h>
-#include <babeltrace/plugin/notification/packet.h>
-#include <babeltrace/plugin/notification/event.h>
-#include <babeltrace/plugin/notification/stream.h>
+#include <babeltrace/graph/notification-packet.h>
+#include <babeltrace/graph/notification-event.h>
+#include <babeltrace/graph/notification-stream.h>
+#include <babeltrace/graph/clock-class-priority-map.h>
#include <babeltrace/ref.h>
#include <glib.h>
#define PRINT_ERR_STREAM notit->err_stream
#define PRINT_PREFIX "ctf-notif-iter"
-#include "print.h"
+#include "../print.h"
#include "notif-iter.h"
#include "../btr/btr.h"
enum bt_ctf_notif_iter_status notif_iter_status_from_m_status(
enum bt_ctf_notif_iter_medium_status m_status)
{
- return m_status;
+ return (int) m_status;
}
static inline
return notit->buf.packet_offset + notit->buf.at;
}
-static inline
-size_t remaining_content_bits(struct bt_ctf_notif_iter *notit)
-{
- if (notit->cur_content_size == -1) {
- return -1;
- }
-
- return notit->cur_content_size - packet_at(notit);
-}
-
-static inline
-size_t remaining_packet_bits(struct bt_ctf_notif_iter *notit)
-{
- if (notit->cur_packet_size == -1) {
- return -1;
- }
-
- return notit->cur_packet_size - packet_at(notit);
-}
-
static inline
void buf_consume_bits(struct bt_ctf_notif_iter *notit, size_t incr)
{
notit->buf.at += incr;
}
-static inline
-bool buf_has_enough_bits(struct bt_ctf_notif_iter *notit, size_t sz)
-{
- return buf_available_bits(notit) >= sz;
-}
-
static
enum bt_ctf_notif_iter_status request_medium_bytes(
struct bt_ctf_notif_iter *notit)
bool is_struct_type(struct bt_ctf_field_type *field_type)
{
return bt_ctf_field_type_get_type_id(field_type) ==
- BT_CTF_TYPE_ID_STRUCT;
+ BT_CTF_FIELD_TYPE_ID_STRUCT;
}
static inline
bool is_variant_type(struct bt_ctf_field_type *field_type)
{
return bt_ctf_field_type_get_type_id(field_type) ==
- BT_CTF_TYPE_ID_VARIANT;
+ BT_CTF_FIELD_TYPE_ID_VARIANT;
}
static
}
switch (bt_ctf_field_type_get_type_id(base_type)) {
- case BT_CTF_TYPE_ID_STRUCT:
+ case BT_CTF_FIELD_TYPE_ID_STRUCT:
next_field = bt_ctf_field_structure_get_field_by_index(
base_field, index);
break;
- case BT_CTF_TYPE_ID_ARRAY:
+ case BT_CTF_FIELD_TYPE_ID_ARRAY:
next_field = bt_ctf_field_array_get_field(base_field, index);
break;
- case BT_CTF_TYPE_ID_SEQUENCE:
+ case BT_CTF_FIELD_TYPE_ID_SEQUENCE:
next_field = bt_ctf_field_sequence_get_field(base_field, index);
break;
- case BT_CTF_TYPE_ID_VARIANT:
+ case BT_CTF_FIELD_TYPE_ID_VARIANT:
next_field = bt_ctf_field_variant_get_current_field(base_field);
break;
default:
static
enum bt_ctf_btr_status update_clock(struct bt_ctf_notif_iter *notit,
- struct bt_ctf_field_type *int_field_type,
struct bt_ctf_field *int_field)
{
gboolean clock_class_found;
uint64_t *clock_state;
+ struct bt_ctf_field_type *int_field_type = NULL;
enum bt_ctf_btr_status ret = BT_CTF_BTR_STATUS_OK;
- struct bt_ctf_clock_class *clock_class =
- bt_ctf_field_type_integer_get_mapped_clock_class(
- int_field_type);
+ struct bt_ctf_clock_class *clock_class = NULL;
+ int_field_type = bt_ctf_field_get_type(int_field);
+ if (unlikely(!int_field_type)) {
+ goto end;
+ }
+
+ clock_class = bt_ctf_field_type_integer_get_mapped_clock_class(
+ int_field_type);
if (likely(!clock_class)) {
- goto end_no_clock;
+ goto end;
}
clock_class_found = g_hash_table_lookup_extended(notit->clock_states,
/* Update the clock's state. */
update_clock_state(clock_state, int_field);
end:
+ bt_put(int_field_type);
bt_put(clock_class);
-end_no_clock:
return ret;
}
static
enum bt_ctf_btr_status btr_unsigned_int_common(uint64_t value,
struct bt_ctf_field_type *type, void *data,
- struct bt_ctf_field **_field)
+ struct bt_ctf_field **out_int_field)
{
enum bt_ctf_btr_status status = BT_CTF_BTR_STATUS_OK;
struct bt_ctf_field *field = NULL;
}
switch(bt_ctf_field_type_get_type_id(type)) {
- case BT_CTF_TYPE_ID_INTEGER:
+ case BT_CTF_FIELD_TYPE_ID_INTEGER:
/* Integer field is created field */
BT_MOVE(int_field, field);
bt_get(type);
break;
- case BT_CTF_TYPE_ID_ENUM:
+ case BT_CTF_FIELD_TYPE_ID_ENUM:
int_field = bt_ctf_field_enumeration_get_container(field);
type = bt_ctf_field_get_type(int_field);
break;
ret = bt_ctf_field_unsigned_integer_set_value(int_field, value);
assert(!ret);
stack_top(notit->stack)->index++;
- *_field = int_field;
+ *out_int_field = int_field;
end:
BT_PUT(field);
goto end;
}
- status = update_clock(notit, type, field);
+ status = update_clock(notit, field);
BT_PUT(field);
end:
return status;
}
switch(bt_ctf_field_type_get_type_id(type)) {
- case BT_CTF_TYPE_ID_INTEGER:
+ case BT_CTF_FIELD_TYPE_ID_INTEGER:
/* Integer field is created field */
BT_MOVE(int_field, field);
bt_get(type);
break;
- case BT_CTF_TYPE_ID_ENUM:
+ case BT_CTF_FIELD_TYPE_ID_ENUM:
int_field = bt_ctf_field_enumeration_get_container(field);
type = bt_ctf_field_get_type(int_field);
break;
ret = bt_ctf_field_signed_integer_set_value(int_field, value);
assert(!ret);
stack_top(notit->stack)->index++;
- status = update_clock(notit, type, int_field);
+ status = update_clock(notit, int_field);
end:
BT_PUT(field);
BT_PUT(int_field);
ret = -1;
goto end;
}
- ret = bt_ctf_event_set_clock_value(event, clock_class,
- clock_value);
+ ret = bt_ctf_event_set_clock_value(event, clock_value);
bt_put(clock_value);
if (ret) {
goto end;
goto error;
}
- ret = bt_ctf_event_set_payload_field(event,
+ ret = bt_ctf_event_set_event_payload(event,
notit->dscopes.event_payload);
if (ret) {
goto error;
static
void notify_event(struct bt_ctf_notif_iter *notit,
+ struct bt_clock_class_priority_map *cc_prio_map,
struct bt_notification **notification)
{
struct bt_ctf_event *event;
goto end;
}
- ret = bt_notification_event_create(event);
+ ret = bt_notification_event_create(event, cc_prio_map);
if (!ret) {
goto end;
}
BT_PUT(event);
}
-//FIXME: not used ?
-static
-void notify_eos(struct bt_ctf_notif_iter *notit,
- struct bt_notification **notification)
-{
- struct bt_ctf_stream *stream = NULL;
- struct bt_notification *ret = NULL;
-
- /* Ask the user for the stream */
- stream = notit->medium.medops.get_stream(notit->meta.stream_class,
- notit->medium.data);
- if (!stream) {
- goto end;
- }
-
- ret = bt_notification_stream_end_create(stream);
- if (!ret) {
- goto end;
- }
- *notification = ret;
-end:
- BT_PUT(stream);
-}
-
static
int init_clock_states(GHashTable *clock_states, struct bt_ctf_trace *trace)
{
for (i = 0; i < clock_class_count; i++) {
struct bt_ctf_clock_class *clock_class;
- clock_class = bt_ctf_trace_get_clock_class(trace, i);
+ clock_class = bt_ctf_trace_get_clock_class_by_index(trace, i);
if (!clock_class) {
ret = -1;
goto end;
assert(trace);
assert(medops.request_bytes);
+ assert(medops.get_stream);
notit = g_new0(struct bt_ctf_notif_iter, 1);
if (!notit) {
PERR("Failed to allocate memory for CTF notification iterator\n");
enum bt_ctf_notif_iter_status bt_ctf_notif_iter_get_next_notification(
struct bt_ctf_notif_iter *notit,
+ struct bt_clock_class_priority_map *cc_prio_map,
struct bt_notification **notification)
{
enum bt_ctf_notif_iter_status status = BT_CTF_NOTIF_ITER_STATUS_OK;
while (true) {
status = handle_state(notit);
+ if (status == BT_CTF_NOTIF_ITER_STATUS_AGAIN) {
+ PDBG("Medium operation reported \"try again later\"");
+ goto end;
+ }
if (status != BT_CTF_NOTIF_ITER_STATUS_OK) {
if (status == BT_CTF_NOTIF_ITER_STATUS_EOF) {
PDBG("Medium operation reported end of stream\n");
goto end;
case STATE_EMIT_NOTIF_EVENT:
PDBG("Emitting event notification\n");
- notify_event(notit, notification);
+ notify_event(notit, cc_prio_map, notification);
if (!*notification) {
status = BT_CTF_NOTIF_ITER_STATUS_ERROR;
}
bt_ctf_field_get_type(
notit->cur_timestamp_end);
- btr_status = update_clock(notit, field_type,
- notit->cur_timestamp_end);
+ btr_status = update_clock(notit,
+ notit->cur_timestamp_end);
BT_PUT(field_type);
if (btr_status != BT_CTF_BTR_STATUS_OK) {
status = BT_CTF_NOTIF_ITER_STATUS_ERROR;
projects / babeltrace.git / blobdiff