static
void print_timestamp_cycles(struct pretty_component *pretty,
- struct bt_clock_class *clock_class,
struct bt_event *event)
{
int ret;
struct bt_clock_value *clock_value;
uint64_t cycles;
- clock_value = bt_event_borrow_clock_value(event, clock_class);
+ clock_value = bt_event_borrow_default_clock_value(event);
if (!clock_value) {
g_string_append(pretty->string, "????????????????????");
return;
static
enum bt_component_status print_event_timestamp(struct pretty_component *pretty,
- struct bt_event *event,
- struct bt_clock_class_priority_map *cc_prio_map,
- bool *start_line)
+ struct bt_event *event, bool *start_line)
{
bool print_names = pretty->options.print_header_field_names;
enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
struct bt_stream *stream = NULL;
struct bt_stream_class *stream_class = NULL;
struct bt_trace *trace = NULL;
- struct bt_clock_class *clock_class = NULL;
+ struct bt_clock_value *clock_value = NULL;
stream = bt_event_borrow_stream(event);
if (!stream) {
goto end;
}
- if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map) == 0) {
- /* No clock class: skip the timestamp without an error */
- goto end;
- }
-
- clock_class =
- bt_clock_class_priority_map_borrow_highest_priority_clock_class(
- cc_prio_map);
- if (!clock_class) {
- ret = BT_COMPONENT_STATUS_ERROR;
+ clock_value = bt_event_borrow_default_clock_value(event);
+ if (!clock_value) {
+ /* No default clock value: skip the timestamp without an error */
goto end;
}
g_string_append(pretty->string, COLOR_TIMESTAMP);
}
if (pretty->options.print_timestamp_cycles) {
- print_timestamp_cycles(pretty, clock_class, event);
+ print_timestamp_cycles(pretty, event);
} else {
struct bt_clock_value *clock_value =
- bt_event_borrow_clock_value(event, clock_class);
+ bt_event_borrow_default_clock_value(event);
print_timestamp_wall(pretty, clock_value);
}
static
enum bt_component_status print_event_header(struct pretty_component *pretty,
- struct bt_event *event,
- struct bt_clock_class_priority_map *cc_prio_map)
+ struct bt_event *event)
{
bool print_names = pretty->options.print_header_field_names;
enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
- ret = print_event_timestamp(pretty, event, cc_prio_map,
- &pretty->start_line);
+ ret = print_event_timestamp(pretty, event, &pretty->start_line);
if (ret != BT_COMPONENT_STATUS_OK) {
goto end;
}
type_id = bt_field_get_type_id(field);
switch (type_id) {
- case BT_CTF_FIELD_TYPE_ID_INTEGER:
+ case BT_FIELD_TYPE_ID_INTEGER:
return print_integer(pretty, field);
- case BT_CTF_FIELD_TYPE_ID_FLOAT:
+ case BT_FIELD_TYPE_ID_FLOAT:
{
double v;
}
return BT_COMPONENT_STATUS_OK;
}
- case BT_CTF_FIELD_TYPE_ID_ENUM:
+ case BT_FIELD_TYPE_ID_ENUM:
return print_enum(pretty, field);
- case BT_CTF_FIELD_TYPE_ID_STRING:
+ case BT_FIELD_TYPE_ID_STRING:
{
const char *str;
}
return BT_COMPONENT_STATUS_OK;
}
- case BT_CTF_FIELD_TYPE_ID_STRUCT:
+ case BT_FIELD_TYPE_ID_STRUCT:
return print_struct(pretty, field, print_names, filter_fields,
filter_array_len);
- case BT_CTF_FIELD_TYPE_ID_VARIANT:
+ case BT_FIELD_TYPE_ID_VARIANT:
return print_variant(pretty, field, print_names);
- case BT_CTF_FIELD_TYPE_ID_ARRAY:
+ case BT_FIELD_TYPE_ID_ARRAY:
return print_array(pretty, field, print_names);
- case BT_CTF_FIELD_TYPE_ID_SEQUENCE:
+ case BT_FIELD_TYPE_ID_SEQUENCE:
return print_sequence(pretty, field, print_names);
default:
// TODO: log instead
}
static
-int flush_buf(struct pretty_component *pretty)
+int flush_buf(FILE *stream, struct pretty_component *pretty)
{
int ret = 0;
goto end;
}
- if (fwrite(pretty->string->str, pretty->string->len, 1, pretty->out) != 1) {
+ if (fwrite(pretty->string->str, pretty->string->len, 1, stream) != 1) {
ret = -1;
}
enum bt_component_status ret;
struct bt_event *event =
bt_notification_event_borrow_event(event_notif);
- struct bt_clock_class_priority_map *cc_prio_map =
- bt_notification_event_borrow_clock_class_priority_map(
- event_notif);
BT_ASSERT(event);
- BT_ASSERT(cc_prio_map);
pretty->start_line = true;
g_string_assign(pretty->string, "");
- ret = print_event_header(pretty, event, cc_prio_map);
+ ret = print_event_header(pretty, event);
if (ret != BT_COMPONENT_STATUS_OK) {
goto end;
}
}
g_string_append_c(pretty->string, '\n');
- if (flush_buf(pretty)) {
+ if (flush_buf(pretty->out, pretty)) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
return ret;
}
-BT_HIDDEN
-enum bt_component_status pretty_print_discarded_elements(
- struct pretty_component *pretty,
- struct bt_notification *notif)
+static
+enum bt_component_status print_discarded_elements_msg(
+ struct pretty_component *pretty, struct bt_packet *packet,
+ uint64_t count, const char *elem_type)
{
enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
struct bt_stream *stream = NULL;
const unsigned char *trace_uuid;
int64_t stream_class_id;
int64_t stream_id;
- bool is_discarded_events;
- int64_t count;
- struct bt_clock_value *clock_value = NULL;
+ struct bt_clock_value *begin_clock_value = NULL;
+ struct bt_clock_value *end_clock_value = NULL;
/* Stream name */
- switch (bt_notification_get_type(notif)) {
- case BT_NOTIFICATION_TYPE_DISCARDED_EVENTS:
- stream = bt_notification_discarded_events_borrow_stream(notif);
- count = bt_notification_discarded_events_get_count(notif);
- is_discarded_events = true;
- break;
- case BT_NOTIFICATION_TYPE_DISCARDED_PACKETS:
- stream = bt_notification_discarded_packets_borrow_stream(notif);
- count = bt_notification_discarded_packets_get_count(notif);
- is_discarded_events = false;
- break;
- default:
- abort();
- }
-
+ BT_ASSERT(packet);
+ stream = bt_packet_borrow_stream(packet);
BT_ASSERT(stream);
stream_name = bt_stream_get_name(stream);
/* Stream ID */
stream_id = bt_stream_get_id(stream);
- /* Trace path */
+ /* Trace name */
trace = bt_stream_class_borrow_trace(stream_class);
BT_ASSERT(trace);
trace_name = bt_trace_get_name(trace);
/* Trace UUID */
trace_uuid = bt_trace_get_uuid(trace);
- /*
- * Print to standard error stream to remain backward compatible
- * with Babeltrace 1.
- */
- fprintf(stderr,
- "%s%sWARNING%s%s: Tracer discarded %" PRId64 " %s%s between [",
+ /* Beginning and end times */
+ (void) bt_packet_borrow_previous_packet_default_end_clock_value(
+ packet, &begin_clock_value);
+ (void) bt_packet_borrow_default_end_clock_value(packet,
+ &end_clock_value);
+
+ /* Format message */
+ g_string_assign(pretty->string, "");
+ g_string_append_printf(pretty->string,
+ "%s%sWARNING%s%s: Tracer discarded %" PRId64 " %s%s ",
bt_common_color_fg_yellow(),
bt_common_color_bold(),
bt_common_color_reset(),
bt_common_color_fg_yellow(),
- count, is_discarded_events ? "event" : "packet",
- count == 1 ? "" : "s");
- g_string_assign(pretty->string, "");
- clock_value = is_discarded_events ?
- bt_notification_discarded_events_borrow_begin_clock_value(notif) :
- bt_notification_discarded_packets_borrow_begin_clock_value(notif);
- print_timestamp_wall(pretty, clock_value);
- fprintf(stderr, "%s] and [", pretty->string->str);
- g_string_assign(pretty->string, "");
- clock_value = is_discarded_events ?
- bt_notification_discarded_events_borrow_end_clock_value(notif) :
- bt_notification_discarded_packets_borrow_end_clock_value(notif);
- print_timestamp_wall(pretty, clock_value);
- fprintf(stderr, "%s] in trace \"%s\" ",
- pretty->string->str, trace_name);
+ count, elem_type, count == 1 ? "" : "s");
+
+ if (begin_clock_value && end_clock_value) {
+ g_string_append(pretty->string, "between [");
+ print_timestamp_wall(pretty, begin_clock_value);
+ g_string_append(pretty->string, "] and [");
+ print_timestamp_wall(pretty, end_clock_value);
+ g_string_append(pretty->string, "]");
+ } else {
+ g_string_append(pretty->string, "(unknown time range)");
+ }
+
+ g_string_append_printf(pretty->string, " in trace \"%s\" ", trace_name);
if (trace_uuid) {
- fprintf(stderr,
+ g_string_append_printf(pretty->string,
"(UUID: %02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x) ",
trace_uuid[0],
trace_uuid[1],
trace_uuid[14],
trace_uuid[15]);
} else {
- fprintf(stderr, "(no UUID) ");
+ g_string_append(pretty->string, "(no UUID) ");
}
- fprintf(stderr, "within stream \"%s\" (stream class ID: %" PRId64 ", ",
+ g_string_append_printf(pretty->string,
+ "within stream \"%s\" (stream class ID: %" PRId64 ", ",
stream_name, stream_class_id);
if (stream_id >= 0) {
- fprintf(stderr, "stream ID: %" PRId64, stream_id);
+ g_string_append_printf(pretty->string,
+ "stream ID: %" PRId64, stream_id);
} else {
- fprintf(stderr, "no stream ID");
+ g_string_append(pretty->string, "no stream ID");
+ }
+
+ g_string_append_printf(pretty->string, ").%s\n",
+ bt_common_color_reset());
+
+ /*
+ * Print to standard error stream to remain backward compatible
+ * with Babeltrace 1.
+ */
+ if (flush_buf(stderr, pretty)) {
+ ret = BT_COMPONENT_STATUS_ERROR;
}
- fprintf(stderr, ").%s\n", bt_common_color_reset());
return ret;
}
+
+BT_HIDDEN
+enum bt_component_status pretty_print_packet(struct pretty_component *pretty,
+ struct bt_notification *packet_beginning_notif)
+{
+ struct bt_packet *packet = bt_notification_packet_begin_borrow_packet(
+ packet_beginning_notif);
+ uint64_t count;
+ enum bt_component_status status = BT_COMPONENT_STATUS_OK;
+
+ if (bt_packet_get_discarded_event_count(packet, &count) ==
+ BT_PACKET_PROPERTY_AVAILABILITY_AVAILABLE &&
+ count > 0) {
+ status = print_discarded_elements_msg(pretty, packet,
+ count, "event");
+ if (status != BT_COMPONENT_STATUS_OK) {
+ goto end;
+ }
+ }
+
+ if (bt_packet_get_discarded_packet_count(packet, &count) ==
+ BT_PACKET_PROPERTY_AVAILABILITY_AVAILABLE &&
+ count > 0) {
+ status = print_discarded_elements_msg(pretty, packet,
+ count, "packet");
+ if (status != BT_COMPONENT_STATUS_OK) {
+ goto end;
+ }
+ }
+
+end:
+ return status;
+}
projects / babeltrace.git / blobdiff