src/lib/lib-logging.c

   1 /*
   2  * Copyright 2018 Philippe Proulx <pproulx@efficios.com>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20  * SOFTWARE.
  21  */
  22
  23 #define BT_LOG_TAG "LIB/LIB-LOGGING"
  24 #include "lib/logging.h"
  25
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <inttypes.h>
  31 #include <stdint.h>
  32 #include <wchar.h>
  33 #include <glib.h>
  34 #include "common/common.h"
  35 #include <babeltrace2/trace-ir/event-const.h>
  36 #include <babeltrace2/trace-ir/packet-const.h>
  37 #include <babeltrace2/trace-ir/stream-const.h>
  38 #include <babeltrace2/current-thread.h>
  39
  40 #include "logging.h"
  41 #include "assert-pre.h"
  42 #include "assert-post.h"
  43 #include "value.h"
  44 #include "object-pool.h"
  45 #include "graph/component-class.h"
  46 #include "graph/component-class-sink-colander.h"
  47 #include "graph/component-filter.h"
  48 #include "graph/component.h"
  49 #include "graph/component-sink.h"
  50 #include "graph/component-source.h"
  51 #include "graph/connection.h"
  52 #include "graph/graph.h"
  53 #include "graph/message/discarded-items.h"
  54 #include "graph/message/event.h"
  55 #include "graph/message/iterator.h"
  56 #include "graph/message/message.h"
  57 #include "graph/message/message-iterator-inactivity.h"
  58 #include "graph/message/packet.h"
  59 #include "graph/message/stream-activity.h"
  60 #include "graph/message/stream.h"
  61 #include "graph/port.h"
  62 #include "plugin/plugin.h"
  63 #include "plugin/plugin-so.h"
  64 #include "trace-ir/clock-class.h"
  65 #include "trace-ir/clock-snapshot.h"
  66 #include "trace-ir/event-class.h"
  67 #include "trace-ir/event.h"
  68 #include "trace-ir/field-class.h"
  69 #include "trace-ir/field.h"
  70 #include "trace-ir/field-path.h"
  71 #include "trace-ir/packet.h"
  72 #include "trace-ir/stream-class.h"
  73 #include "trace-ir/stream.h"
  74 #include "trace-ir/trace-class.h"
  75 #include "trace-ir/trace.h"
  76 #include "trace-ir/utils.h"
  77 #include "error.h"
  78 #include "assert-pre.h"
  79
  80 #define LIB_LOGGING_BUF_SIZE    (4096 * 4)
  81
  82 static __thread char lib_logging_buf[LIB_LOGGING_BUF_SIZE];
  83
  84 #define BUF_APPEND(_fmt, ...)                                           \
  85         do {                                                            \
  86                 int _count;                                             \
  87                 size_t _size = LIB_LOGGING_BUF_SIZE -                   \
  88                                 (size_t) (*buf_ch - lib_logging_buf);   \
  89                 _count = snprintf(*buf_ch, _size, (_fmt), __VA_ARGS__); \
  90                 BT_ASSERT(_count >= 0);                                 \
  91                 *buf_ch += MIN(_count, _size);                          \
  92                 if (*buf_ch >= lib_logging_buf + LIB_LOGGING_BUF_SIZE - 1) { \
  93                         return;                                         \
  94                 }                                                       \
  95         } while (0)
  96
  97 #define BUF_APPEND_UUID(_uuid)                                          \
  98         do {                                                            \
  99                 BUF_APPEND(", %suuid=", prefix);                        \
 100                 format_uuid(buf_ch, (_uuid));                           \
 101         } while (0)
 102
 103 #define PRFIELD(_expr)  prefix, (_expr)
 104
 105 #define PRFIELD_GSTRING(_expr)  PRFIELD((_expr) ? (_expr)->str : NULL)
 106
 107 #define TMP_PREFIX_LEN 64
 108 #define SET_TMP_PREFIX(_prefix2)                                        \
 109         do {                                                            \
 110                 snprintf(tmp_prefix, TMP_PREFIX_LEN - 1, "%s%s",        \
 111                         prefix, (_prefix2));                            \
 112                 tmp_prefix[TMP_PREFIX_LEN - 1] = '\0';                  \
 113         } while (0)
 114
 115 static inline void format_component(char **buf_ch, bool extended,
 116                 const char *prefix, const struct bt_component *component);
 117
 118 static inline void format_port(char **buf_ch, bool extended,
 119                 const char *prefix, const struct bt_port *port);
 120
 121 static inline void format_connection(char **buf_ch, bool extended,
 122                 const char *prefix, const struct bt_connection *connection);
 123
 124 static inline void format_clock_snapshot(char **buf_ch, bool extended,
 125                 const char *prefix, const struct bt_clock_snapshot *clock_snapshot);
 126
 127 static inline void format_field_path(char **buf_ch, bool extended,
 128                 const char *prefix, const struct bt_field_path *field_path);
 129
 130 static inline void format_object(char **buf_ch, bool extended,
 131                 const char *prefix, const struct bt_object *obj)
 132 {
 133         BUF_APPEND(", %sref-count=%llu", prefix, obj->ref_count);
 134 }
 135
 136 static inline void format_uuid(char **buf_ch, bt_uuid uuid)
 137 {
 138         BUF_APPEND("\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\"",
 139                 (unsigned int) uuid[0],
 140                 (unsigned int) uuid[1],
 141                 (unsigned int) uuid[2],
 142                 (unsigned int) uuid[3],
 143                 (unsigned int) uuid[4],
 144                 (unsigned int) uuid[5],
 145                 (unsigned int) uuid[6],
 146                 (unsigned int) uuid[7],
 147                 (unsigned int) uuid[8],
 148                 (unsigned int) uuid[9],
 149                 (unsigned int) uuid[10],
 150                 (unsigned int) uuid[11],
 151                 (unsigned int) uuid[12],
 152                 (unsigned int) uuid[13],
 153                 (unsigned int) uuid[14],
 154                 (unsigned int) uuid[15]);
 155 }
 156
 157 static inline void format_object_pool(char **buf_ch, bool extended,
 158                 const char *prefix, const struct bt_object_pool *pool)
 159 {
 160         BUF_APPEND(", %ssize=%zu", PRFIELD(pool->size));
 161
 162         if (pool->objects) {
 163                 BUF_APPEND(", %scap=%u", PRFIELD(pool->objects->len));
 164         }
 165 }
 166
 167 static inline void format_integer_field_class(char **buf_ch,
 168                 bool extended, const char *prefix,
 169                 const struct bt_field_class *field_class)
 170 {
 171         const struct bt_field_class_integer *int_fc =
 172                 (const void *) field_class;
 173
 174         BUF_APPEND(", %srange-size=%" PRIu64 ", %sbase=%s",
 175                 PRFIELD(int_fc->range),
 176                 PRFIELD(bt_common_field_class_integer_preferred_display_base_string(int_fc->base)));
 177 }
 178
 179 static inline void format_array_field_class(char **buf_ch,
 180                 bool extended, const char *prefix,
 181                 const struct bt_field_class *field_class)
 182 {
 183         const struct bt_field_class_array *array_fc =
 184                 (const void *) field_class;
 185
 186         BUF_APPEND(", %selement-fc-addr=%p, %selement-fc-type=%s",
 187                 PRFIELD(array_fc->element_fc),
 188                 PRFIELD(bt_common_field_class_type_string(array_fc->element_fc->type)));
 189 }
 190
 191 static inline void format_field_class(char **buf_ch, bool extended,
 192                 const char *prefix, const struct bt_field_class *field_class)
 193 {
 194         char tmp_prefix[TMP_PREFIX_LEN];
 195
 196         BUF_APPEND(", %stype=%s",
 197                 PRFIELD(bt_common_field_class_type_string(field_class->type)));
 198
 199         if (extended) {
 200                 BUF_APPEND(", %sis-frozen=%d", PRFIELD(field_class->frozen));
 201                 BUF_APPEND(", %sis-part-of-trace-class=%d",
 202                         PRFIELD(field_class->part_of_trace_class));
 203         } else {
 204                 return;
 205         }
 206
 207         switch (field_class->type) {
 208         case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER:
 209         case BT_FIELD_CLASS_TYPE_SIGNED_INTEGER:
 210         {
 211                 format_integer_field_class(buf_ch, extended, prefix, field_class);
 212                 break;
 213         }
 214         case BT_FIELD_CLASS_TYPE_REAL:
 215         {
 216                 const struct bt_field_class_real *real_fc = (void *) field_class;
 217
 218                 BUF_APPEND(", %sis-single-precision=%d",
 219                         PRFIELD(real_fc->is_single_precision));
 220                 break;
 221         }
 222         case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
 223         case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
 224         {
 225                 const struct bt_field_class_enumeration *enum_fc =
 226                         (const void *) field_class;
 227
 228                 format_integer_field_class(buf_ch, extended, prefix, field_class);
 229                 BUF_APPEND(", %smapping-count=%u",
 230                         PRFIELD(enum_fc->mappings->len));
 231                 break;
 232         }
 233         case BT_FIELD_CLASS_TYPE_STRUCTURE:
 234         {
 235                 const struct bt_field_class_structure *struct_fc =
 236                         (const void *) field_class;
 237
 238                 if (struct_fc->common.named_fcs) {
 239                         BUF_APPEND(", %smember-count=%u",
 240                                 PRFIELD(struct_fc->common.named_fcs->len));
 241                 }
 242
 243                 break;
 244         }
 245         case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
 246         {
 247                 const struct bt_field_class_static_array *array_fc =
 248                         (const void *) field_class;
 249
 250                 format_array_field_class(buf_ch, extended, prefix, field_class);
 251                 BUF_APPEND(", %slength=%" PRIu64, PRFIELD(array_fc->length));
 252                 break;
 253         }
 254         case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY:
 255         {
 256                 const struct bt_field_class_dynamic_array *array_fc =
 257                         (const void *) field_class;
 258
 259                 format_array_field_class(buf_ch, extended, prefix, field_class);
 260
 261                 if (array_fc->length_fc) {
 262                         SET_TMP_PREFIX("length-fc-");
 263                         format_field_class(buf_ch, extended, tmp_prefix,
 264                                 array_fc->length_fc);
 265                 }
 266
 267                 if (array_fc->length_field_path) {
 268                         SET_TMP_PREFIX("length-field-path-");
 269                         format_field_path(buf_ch, extended, tmp_prefix,
 270                                 array_fc->length_field_path);
 271                 }
 272
 273                 break;
 274         }
 275         case BT_FIELD_CLASS_TYPE_VARIANT:
 276         {
 277                 const struct bt_field_class_variant *var_fc =
 278                         (const void *) field_class;
 279
 280                 if (var_fc->common.named_fcs) {
 281                         BUF_APPEND(", %soption-count=%u",
 282                                 PRFIELD(var_fc->common.named_fcs->len));
 283                 }
 284
 285                 if (var_fc->selector_fc) {
 286                         SET_TMP_PREFIX("selector-fc-");
 287                         format_field_class(buf_ch, extended, tmp_prefix,
 288                                 var_fc->selector_fc);
 289                 }
 290
 291                 if (var_fc->selector_field_path) {
 292                         SET_TMP_PREFIX("selector-field-path-");
 293                         format_field_path(buf_ch, extended, tmp_prefix,
 294                                 var_fc->selector_field_path);
 295                 }
 296
 297                 break;
 298         }
 299         default:
 300                 break;
 301         }
 302 }
 303
 304 static inline void format_field_integer_extended(char **buf_ch,
 305                 const char *prefix, const struct bt_field *field)
 306 {
 307         const struct bt_field_integer *integer = (void *) field;
 308         const struct bt_field_class_integer *field_class =
 309                 (void *) field->class;
 310         const char *fmt = NULL;
 311
 312         BT_ASSERT(field_class);
 313
 314         if (field_class->base == BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL) {
 315                 fmt = ", %svalue=%" PRIo64;
 316         } else if (field_class->base == BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL) {
 317                 fmt = ", %svalue=%" PRIx64;
 318         }
 319
 320         if (field_class->common.type == BT_FIELD_CLASS_TYPE_SIGNED_INTEGER ||
 321                         field_class->common.type == BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION) {
 322                 if (!fmt) {
 323                         fmt = ", %svalue=%" PRId64;
 324                 }
 325
 326                 BUF_APPEND(fmt, PRFIELD(integer->value.i));
 327         } else {
 328                 if (!fmt) {
 329                         fmt = ", %svalue=%" PRIu64;
 330                 }
 331
 332                 BUF_APPEND(fmt, PRFIELD(integer->value.u));
 333         }
 334 }
 335
 336 static inline void format_field(char **buf_ch, bool extended,
 337                 const char *prefix, const struct bt_field *field)
 338 {
 339         BUF_APPEND(", %sis-set=%d", PRFIELD(field->is_set));
 340
 341         if (extended) {
 342                 BUF_APPEND(", %sis-frozen=%d", PRFIELD(field->frozen));
 343         }
 344
 345         BUF_APPEND(", %sclass-addr=%p", PRFIELD(field->class));
 346
 347         if (!field->class) {
 348                 return;
 349         }
 350
 351         BUF_APPEND(", %sclass-type=%s",
 352                 PRFIELD(bt_common_field_class_type_string(field->class->type)));
 353
 354         if (!extended || !field->is_set) {
 355                 return;
 356         }
 357
 358         switch (field->class->type) {
 359         case BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER:
 360         case BT_FIELD_CLASS_TYPE_SIGNED_INTEGER:
 361         case BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION:
 362         case BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION:
 363         {
 364                 format_field_integer_extended(buf_ch, prefix, field);
 365                 break;
 366         }
 367         case BT_FIELD_CLASS_TYPE_REAL:
 368         {
 369                 const struct bt_field_real *real_field = (const void *) field;
 370
 371                 BUF_APPEND(", %svalue=%f", PRFIELD(real_field->value));
 372                 break;
 373         }
 374         case BT_FIELD_CLASS_TYPE_STRING:
 375         {
 376                 const struct bt_field_string *str = (const void *) field;
 377
 378                 if (str->buf) {
 379                         BT_ASSERT(str->buf->data);
 380                         BUF_APPEND(", %spartial-value=\"%.32s\"",
 381                                 PRFIELD(str->buf->data));
 382                 }
 383
 384                 break;
 385         }
 386         case BT_FIELD_CLASS_TYPE_STATIC_ARRAY:
 387         case BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY:
 388         {
 389                 const struct bt_field_array *array_field = (const void *) field;
 390
 391                 BUF_APPEND(", %slength=%" PRIu64, PRFIELD(array_field->length));
 392
 393                 if (array_field->fields) {
 394                         BUF_APPEND(", %sallocated-length=%u",
 395                                 PRFIELD(array_field->fields->len));
 396                 }
 397
 398                 break;
 399         }
 400         case BT_FIELD_CLASS_TYPE_VARIANT:
 401         {
 402                 const struct bt_field_variant *var_field = (const void *) field;
 403
 404                 BUF_APPEND(", %sselected-field-index=%" PRIu64,
 405                         PRFIELD(var_field->selected_index));
 406                 break;
 407         }
 408         default:
 409                 break;
 410         }
 411 }
 412
 413 static inline void format_field_path(char **buf_ch, bool extended,
 414                 const char *prefix, const struct bt_field_path *field_path)
 415 {
 416         uint64_t i;
 417
 418         if (field_path->items) {
 419                 BT_ASSERT(field_path->items);
 420                 BUF_APPEND(", %sitem-count=%u",
 421                         PRFIELD(field_path->items->len));
 422         }
 423
 424         if (!extended || !field_path->items) {
 425                 return;
 426         }
 427
 428         BUF_APPEND(", %spath=[%s",
 429                 PRFIELD(bt_common_scope_string(field_path->root)));
 430
 431         for (i = 0; i < bt_field_path_get_item_count(field_path); i++) {
 432                 const struct bt_field_path_item *fp_item =
 433                         bt_field_path_borrow_item_by_index_const(field_path, i);
 434
 435                 switch (bt_field_path_item_get_type(fp_item)) {
 436                 case BT_FIELD_PATH_ITEM_TYPE_INDEX:
 437                         BUF_APPEND(", %" PRIu64,
 438                                 bt_field_path_item_index_get_index(fp_item));
 439                         break;
 440                 case BT_FIELD_PATH_ITEM_TYPE_CURRENT_ARRAY_ELEMENT:
 441                         BUF_APPEND("%s", ", <CUR>");
 442                         break;
 443                 default:
 444                         abort();
 445                 }
 446         }
 447
 448         BUF_APPEND("%s", "]");
 449 }
 450
 451 static inline void format_trace_class(char **buf_ch, bool extended,
 452                 const char *prefix, const struct bt_trace_class *trace_class)
 453 {
 454         if (!extended) {
 455                 return;
 456         }
 457
 458         BUF_APPEND(", %sis-frozen=%d", PRFIELD(trace_class->frozen));
 459
 460         if (trace_class->stream_classes) {
 461                 BUF_APPEND(", %sstream-class-count=%u",
 462                         PRFIELD(trace_class->stream_classes->len));
 463         }
 464
 465         BUF_APPEND(", %sassigns-auto-sc-id=%d",
 466                 PRFIELD(trace_class->assigns_automatic_stream_class_id));
 467 }
 468
 469 static inline void format_trace(char **buf_ch, bool extended,
 470                 const char *prefix, const struct bt_trace *trace)
 471 {
 472         char tmp_prefix[TMP_PREFIX_LEN];
 473
 474         if (trace->name.value) {
 475                 BUF_APPEND(", %sname=\"%s\"", PRFIELD(trace->name.value));
 476         }
 477
 478         if (!extended) {
 479                 return;
 480         }
 481
 482         if (trace->uuid.value) {
 483                 BUF_APPEND_UUID(trace->uuid.value);
 484         }
 485
 486         BUF_APPEND(", %sis-frozen=%d", PRFIELD(trace->frozen));
 487
 488         if (trace->streams) {
 489                 BUF_APPEND(", %sstream-count=%u",
 490                         PRFIELD(trace->streams->len));
 491         }
 492
 493         if (!trace->class) {
 494                 return;
 495         }
 496
 497         BUF_APPEND(", %strace-class-addr=%p", PRFIELD(trace->class));
 498         SET_TMP_PREFIX("trace-class-");
 499         format_trace_class(buf_ch, false, tmp_prefix, trace->class);
 500 }
 501
 502 static inline void format_stream_class(char **buf_ch, bool extended,
 503                 const char *prefix,
 504                 const struct bt_stream_class *stream_class)
 505 {
 506         const struct bt_trace_class *trace_class;
 507         char tmp_prefix[TMP_PREFIX_LEN];
 508
 509         BUF_APPEND(", %sid=%" PRIu64, PRFIELD(stream_class->id));
 510
 511         if (stream_class->name.value) {
 512                 BUF_APPEND(", %sname=\"%s\"",
 513                         PRFIELD(stream_class->name.value));
 514         }
 515
 516         if (!extended) {
 517                 return;
 518         }
 519
 520         BUF_APPEND(", %sis-frozen=%d", PRFIELD(stream_class->frozen));
 521
 522         if (stream_class->event_classes) {
 523                 BUF_APPEND(", %sevent-class-count=%u",
 524                         PRFIELD(stream_class->event_classes->len));
 525         }
 526
 527         BUF_APPEND(", %spacket-context-fc-addr=%p, "
 528                 "%sevent-common-context-fc-addr=%p",
 529                 PRFIELD(stream_class->packet_context_fc),
 530                 PRFIELD(stream_class->event_common_context_fc));
 531         trace_class = bt_stream_class_borrow_trace_class_inline(stream_class);
 532         if (!trace_class) {
 533                 return;
 534         }
 535
 536         BUF_APPEND(", %sassigns-auto-ec-id=%d, %sassigns-auto-stream-id=%d, "
 537                 "%spackets-have-default-beginning-cs=%d, "
 538                 "%spackets-have-default-end-cs=%d, "
 539                 "%ssupports-discarded-events=%d, "
 540                 "%sdiscarded-events-have-default-cs=%d, "
 541                 "%ssupports-discarded-packets=%d, "
 542                 "%sdiscarded-packets-have-default-cs=%d",
 543                 PRFIELD(stream_class->assigns_automatic_event_class_id),
 544                 PRFIELD(stream_class->assigns_automatic_stream_id),
 545                 PRFIELD(stream_class->packets_have_beginning_default_clock_snapshot),
 546                 PRFIELD(stream_class->packets_have_end_default_clock_snapshot),
 547                 PRFIELD(stream_class->supports_discarded_events),
 548                 PRFIELD(stream_class->discarded_events_have_default_clock_snapshots),
 549                 PRFIELD(stream_class->supports_discarded_packets),
 550                 PRFIELD(stream_class->discarded_packets_have_default_clock_snapshots));
 551         BUF_APPEND(", %strace-class-addr=%p", PRFIELD(trace_class));
 552         SET_TMP_PREFIX("trace-class-");
 553         format_trace_class(buf_ch, false, tmp_prefix, trace_class);
 554         SET_TMP_PREFIX("pcf-pool-");
 555         format_object_pool(buf_ch, extended, tmp_prefix,
 556                 &stream_class->packet_context_field_pool);
 557 }
 558
 559 static inline void format_event_class(char **buf_ch, bool extended,
 560                 const char *prefix, const struct bt_event_class *event_class)
 561 {
 562         const struct bt_stream_class *stream_class;
 563         const struct bt_trace_class *trace_class;
 564         char tmp_prefix[TMP_PREFIX_LEN];
 565
 566         BUF_APPEND(", %sid=%" PRIu64, PRFIELD(event_class->id));
 567
 568         if (event_class->name.value) {
 569                 BUF_APPEND(", %sname=\"%s\"",
 570                         PRFIELD(event_class->name.value));
 571         }
 572
 573         if (!extended) {
 574                 return;
 575         }
 576
 577         BUF_APPEND(", %sis-frozen=%d", PRFIELD(event_class->frozen));
 578
 579         if (event_class->log_level.base.avail) {
 580                 BUF_APPEND(", %slog-level=%s",
 581                         PRFIELD(bt_common_event_class_log_level_string(
 582                                 (int) event_class->log_level.value)));
 583         }
 584
 585         if (event_class->emf_uri.value) {
 586                 BUF_APPEND(", %semf-uri=\"%s\"",
 587                         PRFIELD(event_class->emf_uri.value));
 588         }
 589
 590         BUF_APPEND(", %sspecific-context-fc-addr=%p, %spayload-fc-addr=%p",
 591                 PRFIELD(event_class->specific_context_fc),
 592                 PRFIELD(event_class->payload_fc));
 593
 594         stream_class = bt_event_class_borrow_stream_class_const(event_class);
 595         if (!stream_class) {
 596                 return;
 597         }
 598
 599         BUF_APPEND(", %sstream-class-addr=%p", PRFIELD(stream_class));
 600         SET_TMP_PREFIX("stream-class-");
 601         format_stream_class(buf_ch, false, tmp_prefix, stream_class);
 602         trace_class = bt_stream_class_borrow_trace_class_inline(stream_class);
 603         if (!trace_class) {
 604                 return;
 605         }
 606
 607         BUF_APPEND(", %strace-class-addr=%p", PRFIELD(trace_class));
 608         SET_TMP_PREFIX("trace-class-");
 609         format_trace_class(buf_ch, false, tmp_prefix, trace_class);
 610         SET_TMP_PREFIX("event-pool-");
 611         format_object_pool(buf_ch, extended, tmp_prefix,
 612                 &event_class->event_pool);
 613 }
 614
 615 static inline void format_stream(char **buf_ch, bool extended,
 616                 const char *prefix, const struct bt_stream *stream)
 617 {
 618         const struct bt_stream_class *stream_class;
 619         const struct bt_trace_class *trace_class = NULL;
 620         const struct bt_trace *trace = NULL;
 621         char tmp_prefix[TMP_PREFIX_LEN];
 622
 623         BUF_APPEND(", %sid=%" PRIu64, PRFIELD(stream->id));
 624
 625         if (stream->name.value) {
 626                 BUF_APPEND(", %sname=\"%s\"", PRFIELD(stream->name.value));
 627         }
 628
 629         if (!extended) {
 630                 return;
 631         }
 632
 633         stream_class = bt_stream_borrow_class_const(stream);
 634         if (stream_class) {
 635                 BUF_APPEND(", %sstream-class-addr=%p", PRFIELD(stream_class));
 636                 SET_TMP_PREFIX("stream-class-");
 637                 format_stream_class(buf_ch, false, tmp_prefix, stream_class);
 638                 trace_class = bt_stream_class_borrow_trace_class_inline(stream_class);
 639         }
 640
 641         if (trace_class) {
 642                 BUF_APPEND(", %strace-class-addr=%p", PRFIELD(trace_class));
 643                 SET_TMP_PREFIX("trace-class-");
 644                 format_trace_class(buf_ch, false, tmp_prefix, trace_class);
 645         }
 646
 647         trace = bt_stream_borrow_trace_inline(stream);
 648         if (trace) {
 649                 BUF_APPEND(", %strace-addr=%p", PRFIELD(trace));
 650                 SET_TMP_PREFIX("trace-");
 651                 format_trace(buf_ch, false, tmp_prefix, trace);
 652         }
 653
 654         SET_TMP_PREFIX("packet-pool-");
 655         format_object_pool(buf_ch, extended, tmp_prefix, &stream->packet_pool);
 656 }
 657
 658 static inline void format_packet(char **buf_ch, bool extended,
 659                 const char *prefix, const struct bt_packet *packet)
 660 {
 661         const struct bt_stream *stream;
 662         const struct bt_trace_class *trace_class;
 663         char tmp_prefix[TMP_PREFIX_LEN];
 664
 665         if (!extended) {
 666                 return;
 667         }
 668
 669         BUF_APPEND(", %sis-frozen=%d, %scontext-field-addr=%p",
 670                 PRFIELD(packet->frozen),
 671                 PRFIELD(packet->context_field ? packet->context_field->field : NULL));
 672         stream = bt_packet_borrow_stream_const(packet);
 673         if (!stream) {
 674                 return;
 675         }
 676
 677         BUF_APPEND(", %sstream-addr=%p", PRFIELD(stream));
 678         SET_TMP_PREFIX("stream-");
 679         format_stream(buf_ch, false, tmp_prefix, stream);
 680         trace_class = (const struct bt_trace_class *) bt_object_borrow_parent(&stream->base);
 681         if (!trace_class) {
 682                 return;
 683         }
 684
 685         BUF_APPEND(", %strace-class-addr=%p", PRFIELD(trace_class));
 686         SET_TMP_PREFIX("trace-class-");
 687         format_trace_class(buf_ch, false, tmp_prefix, trace_class);
 688 }
 689
 690 static inline void format_event(char **buf_ch, bool extended,
 691                 const char *prefix, const struct bt_event *event)
 692 {
 693         const struct bt_packet *packet;
 694         const struct bt_stream *stream;
 695         const struct bt_trace_class *trace_class;
 696         const struct bt_stream_class *stream_class;
 697         char tmp_prefix[TMP_PREFIX_LEN];
 698
 699         if (!extended) {
 700                 return;
 701         }
 702
 703         BUF_APPEND(", %sis-frozen=%d, "
 704                 "%scommon-context-field-addr=%p, "
 705                 "%sspecific-context-field-addr=%p, "
 706                 "%spayload-field-addr=%p, ",
 707                 PRFIELD(event->frozen),
 708                 PRFIELD(event->common_context_field),
 709                 PRFIELD(event->specific_context_field),
 710                 PRFIELD(event->payload_field));
 711         BUF_APPEND(", %sevent-class-addr=%p", PRFIELD(event->class));
 712
 713         if (!event->class) {
 714                 return;
 715         }
 716
 717         SET_TMP_PREFIX("event-class-");
 718         format_event_class(buf_ch, false, tmp_prefix, event->class);
 719         stream_class = bt_event_class_borrow_stream_class(event->class);
 720         if (stream_class) {
 721                 BUF_APPEND(", %sstream-class-addr=%p", PRFIELD(stream_class));
 722                 SET_TMP_PREFIX("stream-class-");
 723                 format_stream_class(buf_ch, false, tmp_prefix,
 724                         stream_class);
 725
 726                 trace_class = bt_stream_class_borrow_trace_class_inline(
 727                         stream_class);
 728                 if (trace_class) {
 729                         BUF_APPEND(", %strace-class-addr=%p",
 730                                 PRFIELD(trace_class));
 731                         SET_TMP_PREFIX("trace-class-");
 732                         format_trace_class(buf_ch, false, tmp_prefix,
 733                                 trace_class);
 734                 }
 735         }
 736
 737         packet = bt_event_borrow_packet_const(event);
 738         if (!packet) {
 739                 return;
 740         }
 741
 742         BUF_APPEND(", %spacket-addr=%p", PRFIELD(packet));
 743         SET_TMP_PREFIX("packet-");
 744         format_packet(buf_ch, false, tmp_prefix, packet);
 745         stream = bt_packet_borrow_stream_const(packet);
 746         if (!stream) {
 747                 return;
 748         }
 749
 750         BUF_APPEND(", %sstream-addr=%p", PRFIELD(stream));
 751         SET_TMP_PREFIX("stream-");
 752         format_stream(buf_ch, false, tmp_prefix, stream);
 753 }
 754
 755 static inline void format_clock_class(char **buf_ch, bool extended,
 756                 const char *prefix, const struct bt_clock_class *clock_class)
 757 {
 758         char tmp_prefix[TMP_PREFIX_LEN];
 759
 760         if (clock_class->name.value) {
 761                 BUF_APPEND(", %sname=\"%s\"", PRFIELD(clock_class->name.value));
 762         }
 763
 764         BUF_APPEND(", %sfreq=%" PRIu64, PRFIELD(clock_class->frequency));
 765
 766         if (!extended) {
 767                 return;
 768         }
 769
 770         if (clock_class->description.value) {
 771                 BUF_APPEND(", %spartial-descr=\"%.32s\"",
 772                         PRFIELD(clock_class->description.value));
 773         }
 774
 775         if (clock_class->uuid.value) {
 776                 BUF_APPEND_UUID(clock_class->uuid.value);
 777         }
 778
 779         BUF_APPEND(", %sis-frozen=%d, %sprecision=%" PRIu64 ", "
 780                 "%soffset-s=%" PRId64 ", "
 781                 "%soffset-cycles=%" PRIu64 ", %sorigin-is-unix-epoch=%d, "
 782                 "%sbase-offset-ns=%" PRId64,
 783                 PRFIELD(clock_class->frozen), PRFIELD(clock_class->precision),
 784                 PRFIELD(clock_class->offset_seconds),
 785                 PRFIELD(clock_class->offset_cycles),
 786                 PRFIELD(clock_class->origin_is_unix_epoch),
 787                 PRFIELD(clock_class->base_offset.value_ns));
 788
 789         SET_TMP_PREFIX("cs-pool-");
 790         format_object_pool(buf_ch, extended, tmp_prefix,
 791                 &clock_class->cs_pool);
 792 }
 793
 794 static inline void format_clock_snapshot(char **buf_ch, bool extended,
 795                 const char *prefix, const struct bt_clock_snapshot *clock_snapshot)
 796 {
 797         char tmp_prefix[TMP_PREFIX_LEN];
 798         BUF_APPEND(", %svalue=%" PRIu64 ", %sns-from-origin=%" PRId64,
 799                 PRFIELD(clock_snapshot->value_cycles),
 800                 PRFIELD(clock_snapshot->ns_from_origin));
 801
 802         if (!extended) {
 803                 return;
 804         }
 805
 806         BUF_APPEND(", %sis-set=%d", PRFIELD(clock_snapshot->is_set));
 807
 808         if (clock_snapshot->clock_class) {
 809                 BUF_APPEND(", %sclock-class-addr=%p",
 810                         PRFIELD(clock_snapshot->clock_class));
 811                 SET_TMP_PREFIX("clock-class-");
 812                 format_clock_class(buf_ch, false, tmp_prefix,
 813                         clock_snapshot->clock_class);
 814         }
 815 }
 816
 817 static inline void format_value(char **buf_ch, bool extended,
 818                 const char *prefix, const struct bt_value *value)
 819 {
 820         BUF_APPEND(", %stype=%s",
 821                 PRFIELD(bt_common_value_type_string(bt_value_get_type(value))));
 822
 823         if (!extended) {
 824                 return;
 825         }
 826
 827         switch (bt_value_get_type(value)) {
 828         case BT_VALUE_TYPE_BOOL:
 829         {
 830                 bt_bool val = bt_value_bool_get(value);
 831
 832                 BUF_APPEND(", %svalue=%d", PRFIELD(val));
 833                 break;
 834         }
 835         case BT_VALUE_TYPE_UNSIGNED_INTEGER:
 836         {
 837                 BUF_APPEND(", %svalue=%" PRIu64,
 838                         PRFIELD(bt_value_unsigned_integer_get(value)));
 839                 break;
 840         }
 841         case BT_VALUE_TYPE_SIGNED_INTEGER:
 842         {
 843                 BUF_APPEND(", %svalue=%" PRId64,
 844                         PRFIELD(bt_value_signed_integer_get(value)));
 845                 break;
 846         }
 847         case BT_VALUE_TYPE_REAL:
 848         {
 849                 double val = bt_value_real_get(value);
 850
 851                 BUF_APPEND(", %svalue=%f", PRFIELD(val));
 852                 break;
 853         }
 854         case BT_VALUE_TYPE_STRING:
 855         {
 856                 const char *val = bt_value_string_get(value);
 857
 858                 BUF_APPEND(", %spartial-value=\"%.32s\"", PRFIELD(val));
 859                 break;
 860         }
 861         case BT_VALUE_TYPE_ARRAY:
 862         {
 863                 int64_t count = bt_value_array_get_size(value);
 864
 865                 BT_ASSERT(count >= 0);
 866                 BUF_APPEND(", %selement-count=%" PRId64, PRFIELD(count));
 867                 break;
 868         }
 869         case BT_VALUE_TYPE_MAP:
 870         {
 871                 int64_t count = bt_value_map_get_size(value);
 872
 873                 BT_ASSERT(count >= 0);
 874                 BUF_APPEND(", %selement-count=%" PRId64, PRFIELD(count));
 875                 break;
 876         }
 877         default:
 878                 break;
 879         }
 880 }
 881
 882 static inline void format_message(char **buf_ch, bool extended,
 883                 const char *prefix, const struct bt_message *msg)
 884 {
 885         char tmp_prefix[TMP_PREFIX_LEN];
 886
 887         BUF_APPEND(", %stype=%s",
 888                 PRFIELD(bt_message_type_string(msg->type)));
 889
 890         if (!extended) {
 891                 return;
 892         }
 893
 894         BUF_APPEND(", %sis-frozen=%d, %sgraph-addr=%p",
 895                 PRFIELD(msg->frozen), PRFIELD(msg->graph));
 896
 897         switch (msg->type) {
 898         case BT_MESSAGE_TYPE_EVENT:
 899         {
 900                 const struct bt_message_event *msg_event =
 901                         (const void *) msg;
 902
 903                 if (msg_event->event) {
 904                         SET_TMP_PREFIX("event-");
 905                         format_event(buf_ch, true, tmp_prefix,
 906                                 msg_event->event);
 907                 }
 908
 909                 if (msg_event->default_cs) {
 910                         SET_TMP_PREFIX("default-cs-");
 911                         format_clock_snapshot(buf_ch, true, tmp_prefix,
 912                                 msg_event->default_cs);
 913                 }
 914
 915                 break;
 916         }
 917         case BT_MESSAGE_TYPE_STREAM_BEGINNING:
 918         case BT_MESSAGE_TYPE_STREAM_END:
 919         {
 920                 const struct bt_message_stream *msg_stream = (const void *) msg;
 921
 922                 if (msg_stream->stream) {
 923                         SET_TMP_PREFIX("stream-");
 924                         format_stream(buf_ch, true, tmp_prefix,
 925                                 msg_stream->stream);
 926                 }
 927
 928                 break;
 929         }
 930         case BT_MESSAGE_TYPE_STREAM_ACTIVITY_BEGINNING:
 931         case BT_MESSAGE_TYPE_STREAM_ACTIVITY_END:
 932         {
 933                 const struct bt_message_stream_activity *msg_stream_activity =
 934                         (const void *) msg;
 935
 936                 if (msg_stream_activity->stream) {
 937                         SET_TMP_PREFIX("stream-");
 938                         format_stream(buf_ch, true, tmp_prefix,
 939                                 msg_stream_activity->stream);
 940                 }
 941
 942                 BUF_APPEND(", %sdefault-cs-state=%s",
 943                         PRFIELD(bt_message_stream_activity_clock_snapshot_state_string(
 944                                 msg_stream_activity->default_cs_state)));
 945
 946                 if (msg_stream_activity->default_cs) {
 947                         SET_TMP_PREFIX("default-cs-");
 948                         format_clock_snapshot(buf_ch, true, tmp_prefix,
 949                                 msg_stream_activity->default_cs);
 950                 }
 951
 952                 break;
 953         }
 954         case BT_MESSAGE_TYPE_PACKET_BEGINNING:
 955         case BT_MESSAGE_TYPE_PACKET_END:
 956         {
 957                 const struct bt_message_packet *msg_packet = (const void *) msg;
 958
 959                 if (msg_packet->packet) {
 960                         SET_TMP_PREFIX("packet-");
 961                         format_packet(buf_ch, true, tmp_prefix,
 962                                 msg_packet->packet);
 963                 }
 964
 965                 if (msg_packet->default_cs) {
 966                         SET_TMP_PREFIX("default-cs-");
 967                         format_clock_snapshot(buf_ch, true, tmp_prefix,
 968                                 msg_packet->default_cs);
 969                 }
 970
 971                 break;
 972         }
 973         case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
 974         case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
 975         {
 976                 const struct bt_message_discarded_items *msg_disc_items =
 977                         (const void *) msg;
 978
 979                 if (msg_disc_items->stream) {
 980                         SET_TMP_PREFIX("stream-");
 981                         format_stream(buf_ch, true, tmp_prefix,
 982                                 msg_disc_items->stream);
 983                 }
 984
 985                 if (msg_disc_items->default_begin_cs) {
 986                         SET_TMP_PREFIX("default-begin-cs-");
 987                         format_clock_snapshot(buf_ch, true, tmp_prefix,
 988                                 msg_disc_items->default_begin_cs);
 989                 }
 990
 991                 if (msg_disc_items->default_end_cs) {
 992                         SET_TMP_PREFIX("default-end-cs-");
 993                         format_clock_snapshot(buf_ch, true, tmp_prefix,
 994                                 msg_disc_items->default_end_cs);
 995                 }
 996
 997                 if (msg_disc_items->count.base.avail) {
 998                         BUF_APPEND(", %scount=%" PRIu64,
 999                                 PRFIELD(msg_disc_items->count.value));
1000                 }
1001
1002                 break;
1003         }
1004         default:
1005                 break;
1006         }
1007 }
1008
1009 static inline void format_plugin_so_shared_lib_handle(char **buf_ch,
1010                 const char *prefix,
1011                 const struct bt_plugin_so_shared_lib_handle *handle)
1012 {
1013         BUF_APPEND(", %saddr=%p", PRFIELD(handle));
1014
1015         if (handle->path) {
1016                 BUF_APPEND(", %spath=\"%s\"", PRFIELD_GSTRING(handle->path));
1017         }
1018 }
1019
1020 static inline void format_component_class(char **buf_ch, bool extended,
1021                 const char *prefix,
1022                 const struct bt_component_class *comp_class)
1023 {
1024         char tmp_prefix[TMP_PREFIX_LEN];
1025
1026         BUF_APPEND(", %stype=%s, %sname=\"%s\"",
1027                 PRFIELD(bt_component_class_type_string(comp_class->type)),
1028                 PRFIELD_GSTRING(comp_class->name));
1029
1030         if (comp_class->description) {
1031                 BUF_APPEND(", %spartial-descr=\"%.32s\"",
1032                         PRFIELD_GSTRING(comp_class->description));
1033         }
1034
1035         if (!extended) {
1036                 return;
1037         }
1038
1039         BUF_APPEND(", %sis-frozen=%d", PRFIELD(comp_class->frozen));
1040
1041         if (comp_class->so_handle) {
1042                 SET_TMP_PREFIX("so-handle-");
1043                 format_plugin_so_shared_lib_handle(buf_ch, tmp_prefix,
1044                         comp_class->so_handle);
1045         }
1046 }
1047
1048 static inline void format_component(char **buf_ch, bool extended,
1049                 const char *prefix, const struct bt_component *component)
1050 {
1051         char tmp_prefix[TMP_PREFIX_LEN];
1052
1053         BUF_APPEND(", %sname=\"%s\", %slog-level=%s",
1054                 PRFIELD_GSTRING(component->name),
1055                 PRFIELD(bt_common_logging_level_string(component->log_level)));
1056
1057         if (component->class) {
1058                 SET_TMP_PREFIX("class-");
1059                 format_component_class(buf_ch, extended, tmp_prefix,
1060                         component->class);
1061         }
1062
1063         if (!extended) {
1064                 return;
1065         }
1066
1067         if (component->input_ports) {
1068                 BUF_APPEND(", %sinput-port-count=%u",
1069                         PRFIELD(component->input_ports->len));
1070         }
1071
1072         if (component->output_ports) {
1073                 BUF_APPEND(", %soutput-port-count=%u",
1074                         PRFIELD(component->output_ports->len));
1075         }
1076 }
1077
1078 static inline void format_port(char **buf_ch, bool extended,
1079                 const char *prefix, const struct bt_port *port)
1080 {
1081         char tmp_prefix[TMP_PREFIX_LEN];
1082
1083         BUF_APPEND(", %stype=%s, %sname=\"%s\"",
1084                 PRFIELD(bt_port_type_string(port->type)),
1085                 PRFIELD_GSTRING(port->name));
1086
1087         if (!extended) {
1088                 return;
1089         }
1090
1091         if (port->connection) {
1092                 SET_TMP_PREFIX("conn-");
1093                 format_connection(buf_ch, false, tmp_prefix, port->connection);
1094         }
1095 }
1096
1097 static inline void format_connection(char **buf_ch, bool extended,
1098                 const char *prefix, const struct bt_connection *connection)
1099 {
1100         char tmp_prefix[TMP_PREFIX_LEN];
1101
1102         if (!extended) {
1103                 return;
1104         }
1105
1106         if (connection->upstream_port) {
1107                 SET_TMP_PREFIX("upstream-port-");
1108                 format_port(buf_ch, false, tmp_prefix,
1109                         connection->upstream_port);
1110         }
1111
1112         if (connection->downstream_port) {
1113                 SET_TMP_PREFIX("downstream-port-");
1114                 format_port(buf_ch, false, tmp_prefix,
1115                         connection->downstream_port);
1116         }
1117 }
1118
1119 static inline void format_graph(char **buf_ch, bool extended,
1120                 const char *prefix, const struct bt_graph *graph)
1121 {
1122         char tmp_prefix[TMP_PREFIX_LEN];
1123
1124         BUF_APPEND(", %sis-canceled=%d, %scan-consume=%d, "
1125                 "%sconfig-state=%s",
1126                 PRFIELD(graph->canceled),
1127                 PRFIELD(graph->can_consume),
1128                 PRFIELD(bt_graph_configuration_state_string(graph->config_state)));
1129
1130         if (!extended) {
1131                 return;
1132         }
1133
1134         if (graph->components) {
1135                 BUF_APPEND(", %scomp-count=%u",
1136                         PRFIELD(graph->components->len));
1137         }
1138
1139         if (graph->connections) {
1140                 BUF_APPEND(", %sconn-count=%u",
1141                         PRFIELD(graph->connections->len));
1142         }
1143
1144         SET_TMP_PREFIX("en-pool-");
1145         format_object_pool(buf_ch, extended, tmp_prefix,
1146                 &graph->event_msg_pool);
1147         SET_TMP_PREFIX("pbn-pool-");
1148         format_object_pool(buf_ch, extended, tmp_prefix,
1149                 &graph->packet_begin_msg_pool);
1150         SET_TMP_PREFIX("pen-pool-");
1151         format_object_pool(buf_ch, extended, tmp_prefix,
1152                 &graph->packet_end_msg_pool);
1153 }
1154
1155 static inline void format_message_iterator(char **buf_ch,
1156                 bool extended, const char *prefix,
1157                 const struct bt_message_iterator *iterator)
1158 {
1159         const char *type;
1160         char tmp_prefix[TMP_PREFIX_LEN];
1161
1162         if (iterator->type == BT_MESSAGE_ITERATOR_TYPE_SELF_COMPONENT_PORT_INPUT) {
1163                 type = "BT_MESSAGE_ITERATOR_TYPE_SELF_COMPONENT_PORT_INPUT";
1164         } else if (iterator->type == BT_MESSAGE_ITERATOR_TYPE_PORT_OUTPUT) {
1165                 type = "BT_MESSAGE_ITERATOR_TYPE_PORT_OUTPUT";
1166         } else {
1167                 type = "(unknown)";
1168         }
1169
1170         BUF_APPEND(", %stype=%s", PRFIELD(type));
1171
1172         switch (iterator->type) {
1173         case BT_MESSAGE_ITERATOR_TYPE_SELF_COMPONENT_PORT_INPUT:
1174         {
1175                 const struct bt_self_component_port_input_message_iterator *
1176                         port_in_iter = (const void *) iterator;
1177
1178                 if (port_in_iter->upstream_component) {
1179                         SET_TMP_PREFIX("upstream-comp-");
1180                         format_component(buf_ch, false, tmp_prefix,
1181                                 port_in_iter->upstream_component);
1182                 }
1183
1184                 if (port_in_iter->upstream_port) {
1185                         SET_TMP_PREFIX("upstream-port-");
1186                         format_port(buf_ch, false, tmp_prefix,
1187                                 port_in_iter->upstream_port);
1188                 }
1189
1190                 if (port_in_iter->connection) {
1191                         SET_TMP_PREFIX("upstream-conn-");
1192                         format_connection(buf_ch, false, tmp_prefix,
1193                                 port_in_iter->connection);
1194                 }
1195                 break;
1196         }
1197         case BT_MESSAGE_ITERATOR_TYPE_PORT_OUTPUT:
1198         {
1199                 const struct bt_port_output_message_iterator *port_out_iter =
1200                         (const void *) iterator;
1201
1202                 if (port_out_iter->graph) {
1203                         SET_TMP_PREFIX("graph-");
1204                         format_graph(buf_ch, false, tmp_prefix,
1205                                 port_out_iter->graph);
1206                 }
1207
1208                 if (port_out_iter->colander) {
1209                         SET_TMP_PREFIX("colander-comp-");
1210                         format_component(buf_ch, false, tmp_prefix,
1211                                 (void *) port_out_iter->colander);
1212                 }
1213
1214                 break;
1215         }
1216         default:
1217                 break;
1218         }
1219 }
1220
1221 static inline void format_plugin(char **buf_ch, bool extended,
1222                 const char *prefix, const struct bt_plugin *plugin)
1223 {
1224         char tmp_prefix[TMP_PREFIX_LEN];
1225
1226         BUF_APPEND(", %stype=%s", PRFIELD(bt_plugin_type_string(plugin->type)));
1227
1228         if (plugin->info.path_set) {
1229                 BUF_APPEND(", %spath=\"%s\"",
1230                         PRFIELD_GSTRING(plugin->info.path));
1231         }
1232
1233         if (plugin->info.name_set) {
1234                 BUF_APPEND(", %sname=\"%s\"",
1235                         PRFIELD_GSTRING(plugin->info.name));
1236         }
1237
1238         if (!extended) {
1239                 return;
1240         }
1241
1242         if (plugin->info.author_set) {
1243                 BUF_APPEND(", %sauthor=\"%s\"",
1244                         PRFIELD_GSTRING(plugin->info.author));
1245         }
1246
1247         if (plugin->info.license_set) {
1248                 BUF_APPEND(", %slicense=\"%s\"",
1249                         PRFIELD_GSTRING(plugin->info.license));
1250         }
1251
1252         if (plugin->info.version_set) {
1253                 BUF_APPEND(", %sversion=%u.%u.%u%s",
1254                         PRFIELD(plugin->info.version.major),
1255                         plugin->info.version.minor,
1256                         plugin->info.version.patch,
1257                         plugin->info.version.extra ?
1258                                 plugin->info.version.extra->str : "");
1259         }
1260
1261         BUF_APPEND(", %ssrc-comp-class-count=%u, %sflt-comp-class-count=%u, "
1262                 "%ssink-comp-class-count=%u",
1263                 PRFIELD(plugin->src_comp_classes->len),
1264                 PRFIELD(plugin->flt_comp_classes->len),
1265                 PRFIELD(plugin->sink_comp_classes->len));
1266
1267         if (plugin->spec_data) {
1268                 const struct bt_plugin_so_spec_data *spec_data =
1269                         (const void *) plugin->spec_data;
1270
1271                 if (spec_data->shared_lib_handle) {
1272                         SET_TMP_PREFIX("so-handle-");
1273                         format_plugin_so_shared_lib_handle(buf_ch, tmp_prefix,
1274                                 spec_data->shared_lib_handle);
1275                 }
1276         }
1277 }
1278
1279 static inline void format_error_cause(char **buf_ch, bool extended,
1280                 const char *prefix, const struct bt_error_cause *cause)
1281 {
1282         const struct bt_error_cause_component_class_id *comp_class_id = NULL;
1283
1284         BUF_APPEND(", %sactor-type=%s, %smodule-name=\"%s\"",
1285                 PRFIELD(bt_error_cause_actor_type_string(cause->actor_type)),
1286                 PRFIELD_GSTRING(cause->module_name));
1287
1288         if (!extended) {
1289                 return;
1290         }
1291
1292         BUF_APPEND(", %spartial-msg=\"%.32s\"",
1293                 PRFIELD_GSTRING(cause->message));
1294
1295         switch (cause->actor_type) {
1296         case BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT:
1297         {
1298                 const struct bt_error_cause_component_actor *spec_cause =
1299                         (const void *) cause;
1300
1301                 BUF_APPEND(", %scomp-name=\"%s\"",
1302                         PRFIELD_GSTRING(spec_cause->comp_name));
1303                 comp_class_id = &spec_cause->comp_class_id;
1304                 break;
1305         }
1306         case BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS:
1307         {
1308                 const struct bt_error_cause_component_class_actor *spec_cause =
1309                         (const void *) cause;
1310
1311                 comp_class_id = &spec_cause->comp_class_id;
1312                 break;
1313         }
1314         case BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR:
1315         {
1316                 const struct bt_error_cause_message_iterator_actor *spec_cause =
1317                         (const void *) cause;
1318
1319                 BUF_APPEND(", %scomp-name=\"%s\", %scomp-out-port-name=\"%s\"",
1320                         PRFIELD_GSTRING(spec_cause->comp_name),
1321                         PRFIELD_GSTRING(spec_cause->output_port_name));
1322                 comp_class_id = &spec_cause->comp_class_id;
1323                 break;
1324         }
1325         default:
1326                 break;
1327         }
1328
1329         if (comp_class_id) {
1330                 BUF_APPEND(", %scomp-cls-type=%s, %scomp-cls-name=\"%s\", "
1331                         "%splugin-name=\"%s\"",
1332                         PRFIELD(bt_component_class_type_string(
1333                                 comp_class_id->type)),
1334                         PRFIELD_GSTRING(comp_class_id->name),
1335                         PRFIELD_GSTRING(comp_class_id->plugin_name));
1336         }
1337 }
1338
1339 static inline void handle_conversion_specifier_bt(void *priv_data,
1340                 char **buf_ch, size_t avail_size,
1341                 const char **out_fmt_ch, va_list *args)
1342 {
1343         const char *fmt_ch = *out_fmt_ch;
1344         bool extended = false;
1345         char prefix[64];
1346         char *prefix_ch = prefix;
1347         const void *obj;
1348
1349         /* skip "%!" */
1350         fmt_ch += 2;
1351
1352         if (*fmt_ch == 'u') {
1353                 /* UUID */
1354                 obj = va_arg(*args, void *);
1355                 format_uuid(buf_ch, obj);
1356                 goto update_fmt;
1357         }
1358
1359         if (*fmt_ch == '[') {
1360                 /* local prefix */
1361                 fmt_ch++;
1362
1363                 while (true) {
1364                         if (*fmt_ch == ']') {
1365                                 *prefix_ch = '\0';
1366                                 fmt_ch++;
1367                                 break;
1368                         }
1369
1370                         *prefix_ch = *fmt_ch;
1371                         prefix_ch++;
1372                         fmt_ch++;
1373                 }
1374         }
1375
1376         *prefix_ch = '\0';
1377
1378         if (*fmt_ch == '+') {
1379                 extended = true;
1380                 fmt_ch++;
1381         }
1382
1383         obj = va_arg(*args, void *);
1384         BUF_APPEND("%saddr=%p", prefix, obj);
1385
1386         if (!obj) {
1387                 goto update_fmt;
1388         }
1389
1390         switch (*fmt_ch) {
1391         case 'F':
1392                 format_field_class(buf_ch, extended, prefix, obj);
1393                 break;
1394         case 'f':
1395                 format_field(buf_ch, extended, prefix, obj);
1396                 break;
1397         case 'P':
1398                 format_field_path(buf_ch, extended, prefix, obj);
1399                 break;
1400         case 'E':
1401                 format_event_class(buf_ch, extended, prefix, obj);
1402                 break;
1403         case 'e':
1404                 format_event(buf_ch, extended, prefix, obj);
1405                 break;
1406         case 'S':
1407                 format_stream_class(buf_ch, extended, prefix, obj);
1408                 break;
1409         case 's':
1410                 format_stream(buf_ch, extended, prefix, obj);
1411                 break;
1412         case 'a':
1413                 format_packet(buf_ch, extended, prefix, obj);
1414                 break;
1415         case 't':
1416                 format_trace(buf_ch, extended, prefix, obj);
1417                 break;
1418         case 'T':
1419                 format_trace_class(buf_ch, extended, prefix, obj);
1420                 break;
1421         case 'K':
1422                 format_clock_class(buf_ch, extended, prefix, obj);
1423                 break;
1424         case 'k':
1425                 format_clock_snapshot(buf_ch, extended, prefix, obj);
1426                 break;
1427         case 'v':
1428                 format_value(buf_ch, extended, prefix, obj);
1429                 break;
1430         case 'n':
1431                 format_message(buf_ch, extended, prefix, obj);
1432                 break;
1433         case 'i':
1434                 format_message_iterator(buf_ch, extended, prefix, obj);
1435                 break;
1436         case 'C':
1437                 format_component_class(buf_ch, extended, prefix, obj);
1438                 break;
1439         case 'c':
1440                 format_component(buf_ch, extended, prefix, obj);
1441                 break;
1442         case 'p':
1443                 format_port(buf_ch, extended, prefix, obj);
1444                 break;
1445         case 'x':
1446                 format_connection(buf_ch, extended, prefix, obj);
1447                 break;
1448         case 'l':
1449                 format_plugin(buf_ch, extended, prefix, obj);
1450                 break;
1451         case 'g':
1452                 format_graph(buf_ch, extended, prefix, obj);
1453                 break;
1454         case 'o':
1455                 format_object_pool(buf_ch, extended, prefix, obj);
1456                 break;
1457         case 'O':
1458                 format_object(buf_ch, extended, prefix, obj);
1459                 break;
1460         case 'r':
1461                 format_error_cause(buf_ch, extended, prefix, obj);
1462                 break;
1463         default:
1464                 abort();
1465         }
1466
1467 update_fmt:
1468         fmt_ch++;
1469         *out_fmt_ch = fmt_ch;
1470 }
1471
1472 void bt_lib_log(const char *func, const char *file, unsigned line,
1473                 int lvl, const char *tag, const char *fmt, ...)
1474 {
1475         va_list args;
1476
1477         BT_ASSERT(fmt);
1478         va_start(args, fmt);
1479         bt_common_custom_vsnprintf(lib_logging_buf, LIB_LOGGING_BUF_SIZE, '!',
1480                 handle_conversion_specifier_bt, NULL, fmt, &args);
1481         va_end(args);
1482         _bt_log_write_d(func, file, line, lvl, tag, "%s", lib_logging_buf);
1483 }
1484
1485 void bt_lib_maybe_log_and_append_cause(const char *func, const char *file,
1486                 unsigned line, int lvl, const char *tag,
1487                 const char *fmt, ...)
1488 {
1489         va_list args;
1490         bt_current_thread_error_append_cause_status status;
1491
1492         BT_ASSERT(fmt);
1493         va_start(args, fmt);
1494         bt_common_custom_vsnprintf(lib_logging_buf, LIB_LOGGING_BUF_SIZE, '!',
1495                 handle_conversion_specifier_bt, NULL, fmt, &args);
1496         va_end(args);
1497
1498         /* Log conditionally, but always append the error cause */
1499         if (BT_LOG_ON(lvl)) {
1500                 _bt_log_write_d(func, file, line, lvl, tag, "%s",
1501                         lib_logging_buf);
1502         }
1503
1504         status = bt_current_thread_error_append_cause_from_unknown(
1505                 "Babeltrace library", file, line, "%s", lib_logging_buf);
1506         if (status) {
1507                 /*
1508                  * Worst case: this error cause is not appended to the
1509                  * current thread's error.
1510                  *
1511                  * We can accept this as it's an almost impossible
1512                  * scenario and returning an error here would mean you
1513                  * need to check the return value of each
1514                  * BT_LIB_LOG*_APPEND_CAUSE() macro and that would be
1515                  * cumbersome.
1516                  */
1517                 BT_LOGE("Cannot append error cause to current thread's "
1518                         "error object: status=%s",
1519                         bt_common_func_status_string(status));
1520         }
1521 }