plugins/text/pretty/print.c

   1 /*
   2  * print.c
   3  *
   4  * Babeltrace CTF Text Output Plugin Event Printing
   5  *
   6  * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  * Copyright 2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   8  *
   9  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining a copy
  12  * of this software and associated documentation files (the "Software"), to deal
  13  * in the Software without restriction, including without limitation the rights
  14  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  15  * copies of the Software, and to permit persons to whom the Software is
  16  * furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be included in
  19  * all copies or substantial portions of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  24  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  26  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  27  * SOFTWARE.
  28  */
  29
  30 #include <babeltrace/babeltrace.h>
  31 #include <babeltrace/bitfield-internal.h>
  32 #include <babeltrace/common-internal.h>
  33 #include <babeltrace/compat/time-internal.h>
  34 #include <babeltrace/assert-internal.h>
  35 #include <inttypes.h>
  36 #include <ctype.h>
  37 #include "pretty.h"
  38
  39 #define NSEC_PER_SEC 1000000000LL
  40
  41 #define COLOR_NAME              BT_COMMON_COLOR_BOLD
  42 #define COLOR_FIELD_NAME        BT_COMMON_COLOR_FG_CYAN
  43 #define COLOR_RST               BT_COMMON_COLOR_RESET
  44 #define COLOR_STRING_VALUE      BT_COMMON_COLOR_BOLD
  45 #define COLOR_NUMBER_VALUE      BT_COMMON_COLOR_BOLD
  46 #define COLOR_ENUM_MAPPING_NAME BT_COMMON_COLOR_BOLD
  47 #define COLOR_UNKNOWN           BT_COMMON_COLOR_BOLD BT_COMMON_COLOR_FG_RED
  48 #define COLOR_EVENT_NAME        BT_COMMON_COLOR_BOLD BT_COMMON_COLOR_FG_MAGENTA
  49 #define COLOR_TIMESTAMP         BT_COMMON_COLOR_BOLD BT_COMMON_COLOR_FG_YELLOW
  50
  51 struct timestamp {
  52         int64_t real_timestamp; /* Relative to UNIX epoch. */
  53         uint64_t clock_value;   /* In cycles. */
  54 };
  55
  56 static
  57 enum bt_component_status print_field(struct pretty_component *pretty,
  58                 struct bt_field *field, bool print_names,
  59                 GQuark *filters_fields, int filter_array_len);
  60
  61 static
  62 void print_name_equal(struct pretty_component *pretty, const char *name)
  63 {
  64         if (pretty->use_colors) {
  65                 g_string_append_printf(pretty->string, "%s%s%s = ", COLOR_NAME,
  66                         name, COLOR_RST);
  67         } else {
  68                 g_string_append_printf(pretty->string, "%s = ", name);
  69         }
  70 }
  71
  72 static
  73 void print_field_name_equal(struct pretty_component *pretty, const char *name)
  74 {
  75         if (pretty->use_colors) {
  76                 g_string_append_printf(pretty->string, "%s%s%s = ",
  77                         COLOR_FIELD_NAME, name, COLOR_RST);
  78         } else {
  79                 g_string_append_printf(pretty->string, "%s = ", name);
  80         }
  81 }
  82
  83 static
  84 void print_timestamp_cycles(struct pretty_component *pretty,
  85                 struct bt_event *event)
  86 {
  87         struct bt_clock_value *clock_value;
  88         uint64_t cycles;
  89         enum bt_clock_value_status cv_status;
  90
  91         cv_status = bt_event_borrow_default_clock_value(event, &clock_value);
  92         if (cv_status != BT_CLOCK_VALUE_STATUS_KNOWN || !clock_value) {
  93                 g_string_append(pretty->string, "????????????????????");
  94                 return;
  95         }
  96
  97         cycles = bt_clock_value_get_value(clock_value);
  98         g_string_append_printf(pretty->string, "%020" PRIu64, cycles);
  99
 100         if (pretty->last_cycles_timestamp != -1ULL) {
 101                 pretty->delta_cycles = cycles - pretty->last_cycles_timestamp;
 102         }
 103         pretty->last_cycles_timestamp = cycles;
 104 }
 105
 106 static
 107 void print_timestamp_wall(struct pretty_component *pretty,
 108                 struct bt_clock_value *clock_value)
 109 {
 110         int ret;
 111         int64_t ts_nsec = 0;    /* add configurable offset */
 112         int64_t ts_sec = 0;     /* add configurable offset */
 113         uint64_t ts_sec_abs, ts_nsec_abs;
 114         bool is_negative;
 115
 116         if (!clock_value) {
 117                 g_string_append(pretty->string, "??:??:??.?????????");
 118                 return;
 119         }
 120
 121         ret = bt_clock_value_get_ns_from_origin(clock_value, &ts_nsec);
 122         if (ret) {
 123                 // TODO: log, this is unexpected
 124                 g_string_append(pretty->string, "Error");
 125                 return;
 126         }
 127
 128         if (pretty->last_real_timestamp != -1ULL) {
 129                 pretty->delta_real_timestamp = ts_nsec - pretty->last_real_timestamp;
 130         }
 131
 132         pretty->last_real_timestamp = ts_nsec;
 133         ts_sec += ts_nsec / NSEC_PER_SEC;
 134         ts_nsec = ts_nsec % NSEC_PER_SEC;
 135
 136         if (ts_sec >= 0 && ts_nsec >= 0) {
 137                 is_negative = false;
 138                 ts_sec_abs = ts_sec;
 139                 ts_nsec_abs = ts_nsec;
 140         } else if (ts_sec > 0 && ts_nsec < 0) {
 141                 is_negative = false;
 142                 ts_sec_abs = ts_sec - 1;
 143                 ts_nsec_abs = NSEC_PER_SEC + ts_nsec;
 144         } else if (ts_sec == 0 && ts_nsec < 0) {
 145                 is_negative = true;
 146                 ts_sec_abs = ts_sec;
 147                 ts_nsec_abs = -ts_nsec;
 148         } else if (ts_sec < 0 && ts_nsec > 0) {
 149                 is_negative = true;
 150                 ts_sec_abs = -(ts_sec + 1);
 151                 ts_nsec_abs = NSEC_PER_SEC - ts_nsec;
 152         } else if (ts_sec < 0 && ts_nsec == 0) {
 153                 is_negative = true;
 154                 ts_sec_abs = -ts_sec;
 155                 ts_nsec_abs = ts_nsec;
 156         } else {        /* (ts_sec < 0 && ts_nsec < 0) */
 157                 is_negative = true;
 158                 ts_sec_abs = -ts_sec;
 159                 ts_nsec_abs = -ts_nsec;
 160         }
 161
 162         if (!pretty->options.clock_seconds) {
 163                 struct tm tm;
 164                 time_t time_s = (time_t) ts_sec_abs;
 165
 166                 if (is_negative && !pretty->negative_timestamp_warning_done) {
 167                         // TODO: log instead
 168                         fprintf(stderr, "[warning] Fallback to [sec.ns] to print negative time value. Use --clock-seconds.\n");
 169                         pretty->negative_timestamp_warning_done = true;
 170                         goto seconds;
 171                 }
 172
 173                 if (!pretty->options.clock_gmt) {
 174                         struct tm *res;
 175
 176                         res = bt_localtime_r(&time_s, &tm);
 177                         if (!res) {
 178                                 // TODO: log instead
 179                                 fprintf(stderr, "[warning] Unable to get localtime.\n");
 180                                 goto seconds;
 181                         }
 182                 } else {
 183                         struct tm *res;
 184
 185                         res = bt_gmtime_r(&time_s, &tm);
 186                         if (!res) {
 187                                 // TODO: log instead
 188                                 fprintf(stderr, "[warning] Unable to get gmtime.\n");
 189                                 goto seconds;
 190                         }
 191                 }
 192                 if (pretty->options.clock_date) {
 193                         char timestr[26];
 194                         size_t res;
 195
 196                         /* Print date and time */
 197                         res = strftime(timestr, sizeof(timestr),
 198                                         "%Y-%m-%d ", &tm);
 199                         if (!res) {
 200                                 // TODO: log instead
 201                                 fprintf(stderr, "[warning] Unable to print ascii time.\n");
 202                                 goto seconds;
 203                         }
 204
 205                         g_string_append(pretty->string, timestr);
 206                 }
 207
 208                 /* Print time in HH:MM:SS.ns */
 209                 g_string_append_printf(pretty->string,
 210                         "%02d:%02d:%02d.%09" PRIu64, tm.tm_hour, tm.tm_min,
 211                         tm.tm_sec, ts_nsec_abs);
 212                 goto end;
 213         }
 214 seconds:
 215         g_string_append_printf(pretty->string, "%s%" PRId64 ".%09" PRIu64,
 216                 is_negative ? "-" : "", ts_sec_abs, ts_nsec_abs);
 217 end:
 218         return;
 219 }
 220
 221 static
 222 enum bt_component_status print_event_timestamp(struct pretty_component *pretty,
 223                 struct bt_event *event, bool *start_line)
 224 {
 225         bool print_names = pretty->options.print_header_field_names;
 226         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 227         struct bt_stream *stream = NULL;
 228         struct bt_stream_class *stream_class = NULL;
 229         struct bt_trace *trace = NULL;
 230         struct bt_clock_value *clock_value = NULL;
 231         enum bt_clock_value_status cv_status;
 232
 233         stream = bt_event_borrow_stream(event);
 234         if (!stream) {
 235                 ret = BT_COMPONENT_STATUS_ERROR;
 236                 goto end;
 237         }
 238
 239         stream_class = bt_stream_borrow_class(stream);
 240         if (!stream_class) {
 241                 ret = BT_COMPONENT_STATUS_ERROR;
 242                 goto end;
 243         }
 244         trace = bt_stream_class_borrow_trace(stream_class);
 245         if (!trace) {
 246                 ret = BT_COMPONENT_STATUS_ERROR;
 247                 goto end;
 248         }
 249
 250         cv_status = bt_event_borrow_default_clock_value(event, &clock_value);
 251         if (cv_status != BT_CLOCK_VALUE_STATUS_KNOWN || !clock_value) {
 252                 /* No default clock value: skip the timestamp without an error */
 253                 goto end;
 254         }
 255
 256         if (print_names) {
 257                 print_name_equal(pretty, "timestamp");
 258         } else {
 259                 g_string_append(pretty->string, "[");
 260         }
 261         if (pretty->use_colors) {
 262                 g_string_append(pretty->string, COLOR_TIMESTAMP);
 263         }
 264         if (pretty->options.print_timestamp_cycles) {
 265                 print_timestamp_cycles(pretty, event);
 266         } else {
 267                 clock_value = NULL;
 268                 cv_status = bt_event_borrow_default_clock_value(event,
 269                         &clock_value);
 270                 print_timestamp_wall(pretty, clock_value);
 271         }
 272         if (pretty->use_colors) {
 273                 g_string_append(pretty->string, COLOR_RST);
 274         }
 275
 276         if (!print_names)
 277                 g_string_append(pretty->string, "] ");
 278
 279         if (pretty->options.print_delta_field) {
 280                 if (print_names) {
 281                         g_string_append(pretty->string, ", ");
 282                         print_name_equal(pretty, "delta");
 283                 } else {
 284                         g_string_append(pretty->string, "(");
 285                 }
 286                 if (pretty->options.print_timestamp_cycles) {
 287                         if (pretty->delta_cycles == -1ULL) {
 288                                 g_string_append(pretty->string,
 289                                         "+??????????\?\?) "); /* Not a trigraph. */
 290                         } else {
 291                                 g_string_append_printf(pretty->string,
 292                                         "+%012" PRIu64, pretty->delta_cycles);
 293                         }
 294                 } else {
 295                         if (pretty->delta_real_timestamp != -1ULL) {
 296                                 uint64_t delta_sec, delta_nsec, delta;
 297
 298                                 delta = pretty->delta_real_timestamp;
 299                                 delta_sec = delta / NSEC_PER_SEC;
 300                                 delta_nsec = delta % NSEC_PER_SEC;
 301                                 g_string_append_printf(pretty->string,
 302                                         "+%" PRIu64 ".%09" PRIu64,
 303                                         delta_sec, delta_nsec);
 304                         } else {
 305                                 g_string_append(pretty->string, "+?.?????????");
 306                         }
 307                 }
 308                 if (!print_names) {
 309                         g_string_append(pretty->string, ") ");
 310                 }
 311         }
 312         *start_line = !print_names;
 313
 314 end:
 315         return ret;
 316 }
 317
 318 static
 319 enum bt_component_status print_event_header(struct pretty_component *pretty,
 320                 struct bt_event *event)
 321 {
 322         bool print_names = pretty->options.print_header_field_names;
 323         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 324         struct bt_event_class *event_class = NULL;
 325         struct bt_stream_class *stream_class = NULL;
 326         struct bt_trace *trace_class = NULL;
 327         int dom_print = 0;
 328         enum bt_property_availability prop_avail;
 329
 330         event_class = bt_event_borrow_class(event);
 331         if (!event_class) {
 332                 ret = BT_COMPONENT_STATUS_ERROR;
 333                 goto end;
 334         }
 335         stream_class = bt_event_class_borrow_stream_class(event_class);
 336         if (!stream_class) {
 337                 ret = BT_COMPONENT_STATUS_ERROR;
 338                 goto end;
 339         }
 340         trace_class = bt_stream_class_borrow_trace(stream_class);
 341         if (!trace_class) {
 342                 ret = BT_COMPONENT_STATUS_ERROR;
 343                 goto end;
 344         }
 345         ret = print_event_timestamp(pretty, event, &pretty->start_line);
 346         if (ret != BT_COMPONENT_STATUS_OK) {
 347                 goto end;
 348         }
 349         if (pretty->options.print_trace_field) {
 350                 const char *name;
 351
 352                 name = bt_trace_get_name(trace_class);
 353                 if (name) {
 354                         if (!pretty->start_line) {
 355                                 g_string_append(pretty->string, ", ");
 356                         }
 357                         if (print_names) {
 358                                 print_name_equal(pretty, "trace");
 359                         }
 360
 361                         g_string_append(pretty->string, name);
 362
 363                         if (!print_names) {
 364                                 g_string_append(pretty->string, " ");
 365                         }
 366                 }
 367         }
 368         if (pretty->options.print_trace_hostname_field) {
 369                 struct bt_value *hostname_str;
 370
 371                 hostname_str = bt_trace_borrow_environment_entry_value_by_name(
 372                         trace_class, "hostname");
 373                 if (hostname_str) {
 374                         const char *str;
 375
 376                         if (!pretty->start_line) {
 377                                 g_string_append(pretty->string, ", ");
 378                         }
 379                         if (print_names) {
 380                                 print_name_equal(pretty, "trace:hostname");
 381                         }
 382                         str = bt_value_string_get(hostname_str);
 383                         g_string_append(pretty->string, str);
 384                         dom_print = 1;
 385                 }
 386         }
 387         if (pretty->options.print_trace_domain_field) {
 388                 struct bt_value *domain_str;
 389
 390                 domain_str = bt_trace_borrow_environment_entry_value_by_name(
 391                         trace_class, "domain");
 392                 if (domain_str) {
 393                         const char *str;
 394
 395                         if (!pretty->start_line) {
 396                                 g_string_append(pretty->string, ", ");
 397                         }
 398                         if (print_names) {
 399                                 print_name_equal(pretty, "trace:domain");
 400                         } else if (dom_print) {
 401                                 g_string_append(pretty->string, ":");
 402                         }
 403                         str = bt_value_string_get(domain_str);
 404                         g_string_append(pretty->string, str);
 405                         dom_print = 1;
 406                 }
 407         }
 408         if (pretty->options.print_trace_procname_field) {
 409                 struct bt_value *procname_str;
 410
 411                 procname_str = bt_trace_borrow_environment_entry_value_by_name(
 412                         trace_class, "procname");
 413                 if (procname_str) {
 414                         const char *str;
 415
 416                         if (!pretty->start_line) {
 417                                 g_string_append(pretty->string, ", ");
 418                         }
 419                         if (print_names) {
 420                                 print_name_equal(pretty, "trace:procname");
 421                         } else if (dom_print) {
 422                                 g_string_append(pretty->string, ":");
 423                         }
 424                         str = bt_value_string_get(procname_str);
 425                         g_string_append(pretty->string, str);
 426                         dom_print = 1;
 427                 }
 428         }
 429         if (pretty->options.print_trace_vpid_field) {
 430                 struct bt_value *vpid_value;
 431
 432                 vpid_value = bt_trace_borrow_environment_entry_value_by_name(
 433                         trace_class, "vpid");
 434                 if (vpid_value) {
 435                         int64_t value;
 436
 437                         if (!pretty->start_line) {
 438                                 g_string_append(pretty->string, ", ");
 439                         }
 440                         if (print_names) {
 441                                 print_name_equal(pretty, "trace:vpid");
 442                         } else if (dom_print) {
 443                                 g_string_append(pretty->string, ":");
 444                         }
 445                         value = bt_value_integer_get(vpid_value);
 446                         g_string_append_printf(pretty->string,
 447                                 "(%" PRId64 ")", value);
 448                         dom_print = 1;
 449                 }
 450         }
 451         if (pretty->options.print_loglevel_field) {
 452                 static const char *log_level_names[] = {
 453                         [ BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY ] = "TRACE_EMERG",
 454                         [ BT_EVENT_CLASS_LOG_LEVEL_ALERT ] = "TRACE_ALERT",
 455                         [ BT_EVENT_CLASS_LOG_LEVEL_CRITICAL ] = "TRACE_CRIT",
 456                         [ BT_EVENT_CLASS_LOG_LEVEL_ERROR ] = "TRACE_ERR",
 457                         [ BT_EVENT_CLASS_LOG_LEVEL_WARNING ] = "TRACE_WARNING",
 458                         [ BT_EVENT_CLASS_LOG_LEVEL_NOTICE ] = "TRACE_NOTICE",
 459                         [ BT_EVENT_CLASS_LOG_LEVEL_INFO ] = "TRACE_INFO",
 460                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM ] = "TRACE_DEBUG_SYSTEM",
 461                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM ] = "TRACE_DEBUG_PROGRAM",
 462                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS ] = "TRACE_DEBUG_PROCESS",
 463                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE ] = "TRACE_DEBUG_MODULE",
 464                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT ] = "TRACE_DEBUG_UNIT",
 465                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION ] = "TRACE_DEBUG_FUNCTION",
 466                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE ] = "TRACE_DEBUG_LINE",
 467                         [ BT_EVENT_CLASS_LOG_LEVEL_DEBUG ] = "TRACE_DEBUG",
 468                 };
 469                 enum bt_event_class_log_level log_level;
 470                 const char *log_level_str = NULL;
 471
 472                 prop_avail = bt_event_class_get_log_level(event_class,
 473                         &log_level);
 474                 if (prop_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
 475                         log_level_str = log_level_names[log_level];
 476                         BT_ASSERT(log_level_str);
 477
 478                         if (!pretty->start_line) {
 479                                 g_string_append(pretty->string, ", ");
 480                         }
 481                         if (print_names) {
 482                                 print_name_equal(pretty, "loglevel");
 483                         } else if (dom_print) {
 484                                 g_string_append(pretty->string, ":");
 485                         }
 486
 487                         g_string_append(pretty->string, log_level_str);
 488                         g_string_append_printf(
 489                                 pretty->string, " (%d)", (int) log_level);
 490                         dom_print = 1;
 491                 }
 492         }
 493         if (pretty->options.print_emf_field) {
 494                 const char *uri_str;
 495
 496                 uri_str = bt_event_class_get_emf_uri(event_class);
 497                 if (uri_str) {
 498                         if (!pretty->start_line) {
 499                                 g_string_append(pretty->string, ", ");
 500                         }
 501                         if (print_names) {
 502                                 print_name_equal(pretty, "model.emf.uri");
 503                         } else if (dom_print) {
 504                                 g_string_append(pretty->string, ":");
 505                         }
 506
 507                         g_string_append(pretty->string, uri_str);
 508                         dom_print = 1;
 509                 }
 510         }
 511         if (dom_print && !print_names) {
 512                 g_string_append(pretty->string, " ");
 513         }
 514         if (!pretty->start_line) {
 515                 g_string_append(pretty->string, ", ");
 516         }
 517         pretty->start_line = true;
 518         if (print_names) {
 519                 print_name_equal(pretty, "name");
 520         }
 521         if (pretty->use_colors) {
 522                 g_string_append(pretty->string, COLOR_EVENT_NAME);
 523         }
 524         g_string_append(pretty->string, bt_event_class_get_name(event_class));
 525         if (pretty->use_colors) {
 526                 g_string_append(pretty->string, COLOR_RST);
 527         }
 528         if (!print_names) {
 529                 g_string_append(pretty->string, ": ");
 530         } else {
 531                 g_string_append(pretty->string, ", ");
 532         }
 533
 534 end:
 535         return ret;
 536 }
 537
 538 static
 539 enum bt_component_status print_integer(struct pretty_component *pretty,
 540                 struct bt_field *field)
 541 {
 542         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 543         enum bt_field_class_integer_preferred_display_base base;
 544         struct bt_field_class *int_fc;
 545         union {
 546                 uint64_t u;
 547                 int64_t s;
 548         } v;
 549         bool rst_color = false;
 550         enum bt_field_class_type ft_type;
 551
 552         int_fc = bt_field_borrow_class(field);
 553         BT_ASSERT(int_fc);
 554         ft_type = bt_field_get_class_type(field);
 555         if (ft_type == BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER ||
 556                         ft_type == BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION) {
 557                 v.u = bt_field_unsigned_integer_get_value(field);
 558         } else {
 559                 v.s = bt_field_signed_integer_get_value(field);
 560         }
 561
 562         if (pretty->use_colors) {
 563                 g_string_append(pretty->string, COLOR_NUMBER_VALUE);
 564                 rst_color = true;
 565         }
 566
 567         base = bt_field_class_integer_get_preferred_display_base(int_fc);
 568         switch (base) {
 569         case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY:
 570         {
 571                 int bitnr, len;
 572
 573                 len = bt_field_class_integer_get_field_value_range(int_fc);
 574                 g_string_append(pretty->string, "0b");
 575                 v.u = _bt_piecewise_lshift(v.u, 64 - len);
 576                 for (bitnr = 0; bitnr < len; bitnr++) {
 577                         g_string_append_printf(pretty->string, "%u", (v.u & (1ULL << 63)) ? 1 : 0);
 578                         v.u = _bt_piecewise_lshift(v.u, 1);
 579                 }
 580                 break;
 581         }
 582         case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL:
 583         {
 584                 if (ft_type == BT_FIELD_CLASS_TYPE_SIGNED_INTEGER ||
 585                                 ft_type == BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION) {
 586                         int len;
 587
 588                         len = bt_field_class_integer_get_field_value_range(
 589                                 int_fc);
 590                         if (len < 64) {
 591                                 size_t rounded_len;
 592
 593                                 BT_ASSERT(len != 0);
 594                                 /* Round length to the nearest 3-bit */
 595                                 rounded_len = (((len - 1) / 3) + 1) * 3;
 596                                 v.u &= ((uint64_t) 1 << rounded_len) - 1;
 597                         }
 598                 }
 599
 600                 g_string_append_printf(pretty->string, "0%" PRIo64, v.u);
 601                 break;
 602         }
 603         case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL:
 604                 if (ft_type == BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER ||
 605                                 ft_type == BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION) {
 606                         g_string_append_printf(pretty->string, "%" PRIu64, v.u);
 607                 } else {
 608                         g_string_append_printf(pretty->string, "%" PRId64, v.s);
 609                 }
 610                 break;
 611         case BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL:
 612         {
 613                 int len;
 614
 615                 len = bt_field_class_integer_get_field_value_range(int_fc);
 616                 if (len < 64) {
 617                         /* Round length to the nearest nibble */
 618                         uint8_t rounded_len = ((len + 3) & ~0x3);
 619
 620                         v.u &= ((uint64_t) 1 << rounded_len) - 1;
 621                 }
 622
 623                 g_string_append_printf(pretty->string, "0x%" PRIX64, v.u);
 624                 break;
 625         }
 626         default:
 627                 ret = BT_COMPONENT_STATUS_ERROR;
 628                 goto end;
 629         }
 630 end:
 631         if (rst_color) {
 632                 g_string_append(pretty->string, COLOR_RST);
 633         }
 634         return ret;
 635 }
 636
 637 static
 638 void print_escape_string(struct pretty_component *pretty, const char *str)
 639 {
 640         int i;
 641
 642         g_string_append_c(pretty->string, '"');
 643
 644         for (i = 0; i < strlen(str); i++) {
 645                 /* Escape sequences not recognized by iscntrl(). */
 646                 switch (str[i]) {
 647                 case '\\':
 648                         g_string_append(pretty->string, "\\\\");
 649                         continue;
 650                 case '\'':
 651                         g_string_append(pretty->string, "\\\'");
 652                         continue;
 653                 case '\"':
 654                         g_string_append(pretty->string, "\\\"");
 655                         continue;
 656                 case '\?':
 657                         g_string_append(pretty->string, "\\\?");
 658                         continue;
 659                 }
 660
 661                 /* Standard characters. */
 662                 if (!iscntrl(str[i])) {
 663                         g_string_append_c(pretty->string, str[i]);
 664                         continue;
 665                 }
 666
 667                 switch (str[i]) {
 668                 case '\0':
 669                         g_string_append(pretty->string, "\\0");
 670                         break;
 671                 case '\a':
 672                         g_string_append(pretty->string, "\\a");
 673                         break;
 674                 case '\b':
 675                         g_string_append(pretty->string, "\\b");
 676                         break;
 677                 case '\e':
 678                         g_string_append(pretty->string, "\\e");
 679                         break;
 680                 case '\f':
 681                         g_string_append(pretty->string, "\\f");
 682                         break;
 683                 case '\n':
 684                         g_string_append(pretty->string, "\\n");
 685                         break;
 686                 case '\r':
 687                         g_string_append(pretty->string, "\\r");
 688                         break;
 689                 case '\t':
 690                         g_string_append(pretty->string, "\\t");
 691                         break;
 692                 case '\v':
 693                         g_string_append(pretty->string, "\\v");
 694                         break;
 695                 default:
 696                         /* Unhandled control-sequence, print as hex. */
 697                         g_string_append_printf(pretty->string, "\\x%02x", str[i]);
 698                         break;
 699                 }
 700         }
 701
 702         g_string_append_c(pretty->string, '"');
 703 }
 704
 705 static
 706 enum bt_component_status print_enum(struct pretty_component *pretty,
 707                 struct bt_field *field)
 708 {
 709         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 710         struct bt_field_class *enumeration_field_class = NULL;
 711         bt_field_class_enumeration_mapping_label_array label_array;
 712         uint64_t label_count;
 713         uint64_t i;
 714
 715         enumeration_field_class = bt_field_borrow_class(field);
 716         if (!enumeration_field_class) {
 717                 ret = BT_COMPONENT_STATUS_ERROR;
 718                 goto end;
 719         }
 720
 721         switch (bt_field_get_class_type(field)) {
 722         case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
 723                 ret = bt_field_unsigned_enumeration_get_mapping_labels(field,
 724                         &label_array, &label_count);
 725                 break;
 726         case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
 727                 ret = bt_field_signed_enumeration_get_mapping_labels(field,
 728                         &label_array, &label_count);
 729                 break;
 730         default:
 731                 abort();
 732         }
 733
 734         if (ret) {
 735                 ret = BT_COMPONENT_STATUS_ERROR;
 736                 goto end;
 737         }
 738
 739         g_string_append(pretty->string, "( ");
 740         if (label_count == 0) {
 741                 if (pretty->use_colors) {
 742                         g_string_append(pretty->string, COLOR_UNKNOWN);
 743                 }
 744                 g_string_append(pretty->string, "<unknown>");
 745                 if (pretty->use_colors) {
 746                         g_string_append(pretty->string, COLOR_RST);
 747                 }
 748                 goto skip_loop;
 749         }
 750         for (i = 0; i < label_count; i++) {
 751                 const char *mapping_name = label_array[i];
 752
 753                 if (i == 0) {
 754                         g_string_append(pretty->string, ", ");
 755                 }
 756                 if (pretty->use_colors) {
 757                         g_string_append(pretty->string, COLOR_ENUM_MAPPING_NAME);
 758                 }
 759                 print_escape_string(pretty, mapping_name);
 760                 if (pretty->use_colors) {
 761                         g_string_append(pretty->string, COLOR_RST);
 762                 }
 763         }
 764 skip_loop:
 765         g_string_append(pretty->string, " : container = ");
 766         ret = print_integer(pretty, field);
 767         if (ret != BT_COMPONENT_STATUS_OK) {
 768                 goto end;
 769         }
 770         g_string_append(pretty->string, " )");
 771 end:
 772         return ret;
 773 }
 774
 775 static
 776 int filter_field_name(struct pretty_component *pretty, const char *field_name,
 777                 GQuark *filter_fields, int filter_array_len)
 778 {
 779         int i;
 780         GQuark field_quark = g_quark_try_string(field_name);
 781
 782         if (!field_quark || pretty->options.verbose) {
 783                 return 1;
 784         }
 785
 786         for (i = 0; i < filter_array_len; i++) {
 787                 if (field_quark == filter_fields[i]) {
 788                         return 0;
 789                 }
 790         }
 791         return 1;
 792 }
 793
 794 static
 795 enum bt_component_status print_struct_field(struct pretty_component *pretty,
 796                 struct bt_field *_struct,
 797                 struct bt_field_class *struct_class,
 798                 uint64_t i, bool print_names, uint64_t *nr_printed_fields,
 799                 GQuark *filter_fields, int filter_array_len)
 800 {
 801         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 802         const char *field_name;
 803         struct bt_field *field = NULL;
 804         struct bt_field_class *field_class = NULL;;
 805
 806         field = bt_field_structure_borrow_member_field_by_index(_struct, i);
 807         if (!field) {
 808                 ret = BT_COMPONENT_STATUS_ERROR;
 809                 goto end;
 810         }
 811
 812         bt_field_class_structure_borrow_member_by_index(struct_class, i,
 813                 &field_name, &field_class);
 814
 815         if (filter_fields && !filter_field_name(pretty, field_name,
 816                                 filter_fields, filter_array_len)) {
 817                 ret = BT_COMPONENT_STATUS_OK;
 818                 goto end;
 819         }
 820
 821         if (*nr_printed_fields > 0) {
 822                 g_string_append(pretty->string, ", ");
 823         } else {
 824                 g_string_append(pretty->string, " ");
 825         }
 826         if (print_names) {
 827                 print_field_name_equal(pretty, field_name);
 828         }
 829         ret = print_field(pretty, field, print_names, NULL, 0);
 830         *nr_printed_fields += 1;
 831
 832 end:
 833         return ret;
 834 }
 835
 836 static
 837 enum bt_component_status print_struct(struct pretty_component *pretty,
 838                 struct bt_field *_struct, bool print_names,
 839                 GQuark *filter_fields, int filter_array_len)
 840 {
 841         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 842         struct bt_field_class *struct_class = NULL;
 843         uint64_t nr_fields, i, nr_printed_fields;
 844
 845         struct_class = bt_field_borrow_class(_struct);
 846         if (!struct_class) {
 847                 ret = BT_COMPONENT_STATUS_ERROR;
 848                 goto end;
 849         }
 850         nr_fields = bt_field_class_structure_get_member_count(struct_class);
 851         if (nr_fields < 0) {
 852                 ret = BT_COMPONENT_STATUS_ERROR;
 853                 goto end;
 854         }
 855         g_string_append(pretty->string, "{");
 856         pretty->depth++;
 857         nr_printed_fields = 0;
 858         for (i = 0; i < nr_fields; i++) {
 859                 ret = print_struct_field(pretty, _struct, struct_class, i,
 860                                 print_names, &nr_printed_fields, filter_fields,
 861                                 filter_array_len);
 862                 if (ret != BT_COMPONENT_STATUS_OK) {
 863                         goto end;
 864                 }
 865         }
 866         pretty->depth--;
 867         g_string_append(pretty->string, " }");
 868
 869 end:
 870         return ret;
 871 }
 872
 873 static
 874 enum bt_component_status print_array_field(struct pretty_component *pretty,
 875                 struct bt_field *array, uint64_t i, bool print_names)
 876 {
 877         struct bt_field *field = NULL;
 878
 879         if (i != 0) {
 880                 g_string_append(pretty->string, ", ");
 881         } else {
 882                 g_string_append(pretty->string, " ");
 883         }
 884         if (print_names) {
 885                 g_string_append_printf(pretty->string, "[%" PRIu64 "] = ", i);
 886         }
 887
 888         field = bt_field_array_borrow_element_field_by_index(array, i);
 889         BT_ASSERT(field);
 890         return print_field(pretty, field, print_names, NULL, 0);
 891 }
 892
 893 static
 894 enum bt_component_status print_array(struct pretty_component *pretty,
 895                 struct bt_field *array, bool print_names)
 896 {
 897         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 898         struct bt_field_class *array_class = NULL;
 899         uint64_t len;
 900         uint64_t i;
 901
 902         array_class = bt_field_borrow_class(array);
 903         if (!array_class) {
 904                 ret = BT_COMPONENT_STATUS_ERROR;
 905                 goto end;
 906         }
 907         len = bt_field_array_get_length(array);
 908         g_string_append(pretty->string, "[");
 909         pretty->depth++;
 910         for (i = 0; i < len; i++) {
 911                 ret = print_array_field(pretty, array, i, print_names);
 912                 if (ret != BT_COMPONENT_STATUS_OK) {
 913                         goto end;
 914                 }
 915         }
 916         pretty->depth--;
 917         g_string_append(pretty->string, " ]");
 918
 919 end:
 920         return ret;
 921 }
 922
 923 static
 924 enum bt_component_status print_sequence_field(struct pretty_component *pretty,
 925                 struct bt_field *seq, uint64_t i, bool print_names)
 926 {
 927         struct bt_field *field = NULL;
 928
 929         if (i != 0) {
 930                 g_string_append(pretty->string, ", ");
 931         } else {
 932                 g_string_append(pretty->string, " ");
 933         }
 934         if (print_names) {
 935                 g_string_append_printf(pretty->string, "[%" PRIu64 "] = ", i);
 936         }
 937
 938         field = bt_field_array_borrow_element_field_by_index(seq, i);
 939         BT_ASSERT(field);
 940         return print_field(pretty, field, print_names, NULL, 0);
 941 }
 942
 943 static
 944 enum bt_component_status print_sequence(struct pretty_component *pretty,
 945                 struct bt_field *seq, bool print_names)
 946 {
 947         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 948         uint64_t len;
 949         uint64_t i;
 950
 951         len = bt_field_array_get_length(seq);
 952         if (len < 0) {
 953                 ret = BT_COMPONENT_STATUS_ERROR;
 954                 goto end;
 955         }
 956
 957         g_string_append(pretty->string, "[");
 958
 959         pretty->depth++;
 960         for (i = 0; i < len; i++) {
 961                 ret = print_sequence_field(pretty, seq, i, print_names);
 962                 if (ret != BT_COMPONENT_STATUS_OK) {
 963                         goto end;
 964                 }
 965         }
 966         pretty->depth--;
 967         g_string_append(pretty->string, " ]");
 968
 969 end:
 970         return ret;
 971 }
 972
 973 static
 974 enum bt_component_status print_variant(struct pretty_component *pretty,
 975                 struct bt_field *variant, bool print_names)
 976 {
 977         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 978         struct bt_field *field = NULL;
 979
 980         field = bt_field_variant_borrow_selected_option_field(variant);
 981         BT_ASSERT(field);
 982         g_string_append(pretty->string, "{ ");
 983         pretty->depth++;
 984         if (print_names) {
 985                 // TODO: find tag's name using field path
 986                 // print_field_name_equal(pretty, tag_choice);
 987         }
 988         ret = print_field(pretty, field, print_names, NULL, 0);
 989         if (ret != BT_COMPONENT_STATUS_OK) {
 990                 goto end;
 991         }
 992         pretty->depth--;
 993         g_string_append(pretty->string, " }");
 994
 995 end:
 996         return ret;
 997 }
 998
 999 static
1000 enum bt_component_status print_field(struct pretty_component *pretty,
1001                 struct bt_field *field, bool print_names,
1002                 GQuark *filter_fields, int filter_array_len)
1003 {
1004         enum bt_field_class_type class_id;
1005
1006         class_id = bt_field_get_class_type(field);
1007         switch (class_id) {
1008         case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER:
1009         case BT_FIELD_CLASS_TYPE_SIGNED_INTEGER:
1010                 return print_integer(pretty, field);
1011         case BT_FIELD_CLASS_TYPE_REAL:
1012         {
1013                 double v;
1014
1015                 v = bt_field_real_get_value(field);
1016                 if (pretty->use_colors) {
1017                         g_string_append(pretty->string, COLOR_NUMBER_VALUE);
1018                 }
1019                 g_string_append_printf(pretty->string, "%g", v);
1020                 if (pretty->use_colors) {
1021                         g_string_append(pretty->string, COLOR_RST);
1022                 }
1023                 return BT_COMPONENT_STATUS_OK;
1024         }
1025         case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
1026         case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
1027                 return print_enum(pretty, field);
1028         case BT_FIELD_CLASS_TYPE_STRING:
1029         {
1030                 const char *str;
1031
1032                 str = bt_field_string_get_value(field);
1033                 if (!str) {
1034                         return BT_COMPONENT_STATUS_ERROR;
1035                 }
1036
1037                 if (pretty->use_colors) {
1038                         g_string_append(pretty->string, COLOR_STRING_VALUE);
1039                 }
1040                 print_escape_string(pretty, str);
1041                 if (pretty->use_colors) {
1042                         g_string_append(pretty->string, COLOR_RST);
1043                 }
1044                 return BT_COMPONENT_STATUS_OK;
1045         }
1046         case BT_FIELD_CLASS_TYPE_STRUCTURE:
1047                 return print_struct(pretty, field, print_names, filter_fields,
1048                                 filter_array_len);
1049         case BT_FIELD_CLASS_TYPE_VARIANT:
1050                 return print_variant(pretty, field, print_names);
1051         case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
1052                 return print_array(pretty, field, print_names);
1053         case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY:
1054                 return print_sequence(pretty, field, print_names);
1055         default:
1056                 // TODO: log instead
1057                 fprintf(pretty->err, "[error] Unknown type id: %d\n", (int) class_id);
1058                 return BT_COMPONENT_STATUS_ERROR;
1059         }
1060 }
1061
1062 static
1063 enum bt_component_status print_stream_packet_context(struct pretty_component *pretty,
1064                 struct bt_event *event)
1065 {
1066         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
1067         struct bt_packet *packet = NULL;
1068         struct bt_field *main_field = NULL;
1069
1070         packet = bt_event_borrow_packet(event);
1071         if (!packet) {
1072                 ret = BT_COMPONENT_STATUS_ERROR;
1073                 goto end;
1074         }
1075         main_field = bt_packet_borrow_context_field(packet);
1076         if (!main_field) {
1077                 goto end;
1078         }
1079         if (!pretty->start_line) {
1080                 g_string_append(pretty->string, ", ");
1081         }
1082         pretty->start_line = false;
1083         if (pretty->options.print_scope_field_names) {
1084                 print_name_equal(pretty, "stream.packet.context");
1085         }
1086         ret = print_field(pretty, main_field,
1087                         pretty->options.print_context_field_names,
1088                         stream_packet_context_quarks,
1089                         STREAM_PACKET_CONTEXT_QUARKS_LEN);
1090
1091 end:
1092         return ret;
1093 }
1094
1095 static
1096 enum bt_component_status print_event_header_raw(struct pretty_component *pretty,
1097                 struct bt_event *event)
1098 {
1099         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
1100         struct bt_field *main_field = NULL;
1101
1102         main_field = bt_event_borrow_header_field(event);
1103         if (!main_field) {
1104                 goto end;
1105         }
1106         if (!pretty->start_line) {
1107                 g_string_append(pretty->string, ", ");
1108         }
1109         pretty->start_line = false;
1110         if (pretty->options.print_scope_field_names) {
1111                 print_name_equal(pretty, "stream.event.header");
1112         }
1113         ret = print_field(pretty, main_field,
1114                         pretty->options.print_header_field_names, NULL, 0);
1115
1116 end:
1117         return ret;
1118 }
1119
1120 static
1121 enum bt_component_status print_stream_event_context(struct pretty_component *pretty,
1122                 struct bt_event *event)
1123 {
1124         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
1125         struct bt_field *main_field = NULL;
1126
1127         main_field = bt_event_borrow_common_context_field(event);
1128         if (!main_field) {
1129                 goto end;
1130         }
1131         if (!pretty->start_line) {
1132                 g_string_append(pretty->string, ", ");
1133         }
1134         pretty->start_line = false;
1135         if (pretty->options.print_scope_field_names) {
1136                 print_name_equal(pretty, "stream.event.context");
1137         }
1138         ret = print_field(pretty, main_field,
1139                         pretty->options.print_context_field_names, NULL, 0);
1140
1141 end:
1142         return ret;
1143 }
1144
1145 static
1146 enum bt_component_status print_event_context(struct pretty_component *pretty,
1147                 struct bt_event *event)
1148 {
1149         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
1150         struct bt_field *main_field = NULL;
1151
1152         main_field = bt_event_borrow_specific_context_field(event);
1153         if (!main_field) {
1154                 goto end;
1155         }
1156         if (!pretty->start_line) {
1157                 g_string_append(pretty->string, ", ");
1158         }
1159         pretty->start_line = false;
1160         if (pretty->options.print_scope_field_names) {
1161                 print_name_equal(pretty, "event.context");
1162         }
1163         ret = print_field(pretty, main_field,
1164                         pretty->options.print_context_field_names, NULL, 0);
1165
1166 end:
1167         return ret;
1168 }
1169
1170 static
1171 enum bt_component_status print_event_payload(struct pretty_component *pretty,
1172                 struct bt_event *event)
1173 {
1174         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
1175         struct bt_field *main_field = NULL;
1176
1177         main_field = bt_event_borrow_payload_field(event);
1178         if (!main_field) {
1179                 goto end;
1180         }
1181         if (!pretty->start_line) {
1182                 g_string_append(pretty->string, ", ");
1183         }
1184         pretty->start_line = false;
1185         if (pretty->options.print_scope_field_names) {
1186                 print_name_equal(pretty, "event.fields");
1187         }
1188         ret = print_field(pretty, main_field,
1189                         pretty->options.print_payload_field_names, NULL, 0);
1190
1191 end:
1192         return ret;
1193 }
1194
1195 static
1196 int flush_buf(FILE *stream, struct pretty_component *pretty)
1197 {
1198         int ret = 0;
1199
1200         if (pretty->string->len == 0) {
1201                 goto end;
1202         }
1203
1204         if (fwrite(pretty->string->str, pretty->string->len, 1, stream) != 1) {
1205                 ret = -1;
1206         }
1207
1208 end:
1209         return ret;
1210 }
1211
1212 BT_HIDDEN
1213 enum bt_component_status pretty_print_event(struct pretty_component *pretty,
1214                 struct bt_notification *event_notif)
1215 {
1216         enum bt_component_status ret;
1217         struct bt_event *event =
1218                 bt_notification_event_borrow_event(event_notif);
1219
1220         BT_ASSERT(event);
1221         pretty->start_line = true;
1222         g_string_assign(pretty->string, "");
1223         ret = print_event_header(pretty, event);
1224         if (ret != BT_COMPONENT_STATUS_OK) {
1225                 goto end;
1226         }
1227
1228         ret = print_stream_packet_context(pretty, event);
1229         if (ret != BT_COMPONENT_STATUS_OK) {
1230                 goto end;
1231         }
1232
1233         if (pretty->options.verbose) {
1234                 ret = print_event_header_raw(pretty, event);
1235                 if (ret != BT_COMPONENT_STATUS_OK) {
1236                         goto end;
1237                 }
1238         }
1239
1240         ret = print_stream_event_context(pretty, event);
1241         if (ret != BT_COMPONENT_STATUS_OK) {
1242                 goto end;
1243         }
1244
1245         ret = print_event_context(pretty, event);
1246         if (ret != BT_COMPONENT_STATUS_OK) {
1247                 goto end;
1248         }
1249
1250         ret = print_event_payload(pretty, event);
1251         if (ret != BT_COMPONENT_STATUS_OK) {
1252                 goto end;
1253         }
1254
1255         g_string_append_c(pretty->string, '\n');
1256         if (flush_buf(pretty->out, pretty)) {
1257                 ret = BT_COMPONENT_STATUS_ERROR;
1258                 goto end;
1259         }
1260
1261 end:
1262         return ret;
1263 }
1264
1265 static
1266 enum bt_component_status print_discarded_elements_msg(
1267                 struct pretty_component *pretty, struct bt_packet *packet,
1268                 uint64_t count, const char *elem_type)
1269 {
1270 #if 0
1271         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
1272         struct bt_stream *stream = NULL;
1273         struct bt_stream_class *stream_class = NULL;
1274         struct bt_trace *trace = NULL;
1275         const char *stream_name;
1276         const char *trace_name;
1277         const unsigned char *trace_uuid;
1278         int64_t stream_class_id;
1279         int64_t stream_id;
1280         struct bt_clock_value *begin_clock_value = NULL;
1281         struct bt_clock_value *end_clock_value = NULL;
1282
1283         /* Stream name */
1284         BT_ASSERT(packet);
1285         stream = bt_packet_borrow_stream(packet);
1286         BT_ASSERT(stream);
1287         stream_name = bt_stream_get_name(stream);
1288
1289         /* Stream class ID */
1290         stream_class = bt_stream_borrow_class(stream);
1291         BT_ASSERT(stream_class);
1292         stream_class_id = bt_stream_class_get_id(stream_class);
1293
1294         /* Stream ID */
1295         stream_id = bt_stream_get_id(stream);
1296
1297         /* Trace name */
1298         trace = bt_stream_class_borrow_trace(stream_class);
1299         BT_ASSERT(trace);
1300         trace_name = bt_trace_get_name(trace);
1301         if (!trace_name) {
1302                 trace_name = "(unknown)";
1303         }
1304
1305         /* Trace UUID */
1306         trace_uuid = bt_trace_get_uuid(trace);
1307
1308         /* Beginning and end times */
1309         (void) bt_packet_borrow_previous_packet_default_end_clock_value(
1310                 packet, &begin_clock_value);
1311         (void) bt_packet_borrow_default_end_clock_value(packet,
1312                 &end_clock_value);
1313
1314         /* Format message */
1315         g_string_assign(pretty->string, "");
1316         g_string_append_printf(pretty->string,
1317                 "%s%sWARNING%s%s: Tracer discarded %" PRId64 " %s%s ",
1318                 bt_common_color_fg_yellow(),
1319                 bt_common_color_bold(),
1320                 bt_common_color_reset(),
1321                 bt_common_color_fg_yellow(),
1322                 count, elem_type, count == 1 ? "" : "s");
1323
1324         if (begin_clock_value && end_clock_value) {
1325                 g_string_append(pretty->string, "between [");
1326                 print_timestamp_wall(pretty, begin_clock_value);
1327                 g_string_append(pretty->string, "] and [");
1328                 print_timestamp_wall(pretty, end_clock_value);
1329                 g_string_append(pretty->string, "]");
1330         } else {
1331                 g_string_append(pretty->string, "(unknown time range)");
1332         }
1333
1334         g_string_append_printf(pretty->string, " in trace \"%s\" ", trace_name);
1335
1336         if (trace_uuid) {
1337                 g_string_append_printf(pretty->string,
1338                         "(UUID: %02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x) ",
1339                         trace_uuid[0],
1340                         trace_uuid[1],
1341                         trace_uuid[2],
1342                         trace_uuid[3],
1343                         trace_uuid[4],
1344                         trace_uuid[5],
1345                         trace_uuid[6],
1346                         trace_uuid[7],
1347                         trace_uuid[8],
1348                         trace_uuid[9],
1349                         trace_uuid[10],
1350                         trace_uuid[11],
1351                         trace_uuid[12],
1352                         trace_uuid[13],
1353                         trace_uuid[14],
1354                         trace_uuid[15]);
1355         } else {
1356                 g_string_append(pretty->string, "(no UUID) ");
1357         }
1358
1359         g_string_append_printf(pretty->string,
1360                 "within stream \"%s\" (stream class ID: %" PRId64 ", ",
1361                 stream_name, stream_class_id);
1362
1363         if (stream_id >= 0) {
1364                 g_string_append_printf(pretty->string,
1365                         "stream ID: %" PRId64, stream_id);
1366         } else {
1367                 g_string_append(pretty->string, "no stream ID");
1368         }
1369
1370         g_string_append_printf(pretty->string, ").%s\n",
1371                 bt_common_color_reset());
1372
1373         /*
1374          * Print to standard error stream to remain backward compatible
1375          * with Babeltrace 1.
1376          */
1377         if (flush_buf(stderr, pretty)) {
1378                 ret = BT_COMPONENT_STATUS_ERROR;
1379         }
1380
1381         return ret;
1382 #endif
1383         return 0;
1384 }
1385
1386 BT_HIDDEN
1387 enum bt_component_status pretty_print_packet(struct pretty_component *pretty,
1388                 struct bt_notification *packet_beginning_notif)
1389 {
1390 #if 0
1391         struct bt_packet *packet = bt_notification_packet_begin_borrow_packet(
1392                 packet_beginning_notif);
1393         uint64_t count;
1394         enum bt_component_status status = BT_COMPONENT_STATUS_OK;
1395
1396         if (bt_packet_get_discarded_event_count(packet, &count) ==
1397                         BT_PACKET_PROPERTY_AVAILABILITY_AVAILABLE &&
1398                         count > 0) {
1399                 status = print_discarded_elements_msg(pretty, packet,
1400                         count, "event");
1401                 if (status != BT_COMPONENT_STATUS_OK) {
1402                         goto end;
1403                 }
1404         }
1405
1406         if (bt_packet_get_discarded_packet_count(packet, &count) ==
1407                         BT_PACKET_PROPERTY_AVAILABILITY_AVAILABLE &&
1408                         count > 0) {
1409                 status = print_discarded_elements_msg(pretty, packet,
1410                         count, "packet");
1411                 if (status != BT_COMPONENT_STATUS_OK) {
1412                         goto end;
1413                 }
1414         }
1415
1416 end:
1417         return status;
1418 #endif
1419         return 0;
1420 }