projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ctf plugin: notif iter: use "borrow" functions for metadata where possible
[babeltrace.git] / lib / lib-logging.c
CommitLineData
476ef981
PP		 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
3dca2276
PP		 23#define BT_LOG_TAG "LIB-LOGGING"
24
476ef981
PP		 25#include <stdarg.h>
26#include <stdio.h>
27#include <stdlib.h>
28#include <string.h>
29#include <inttypes.h>
30#include <stdint.h>
476ef981
PP		 31#include <wchar.h>
32#include <glib.h>
33#include <babeltrace/common-internal.h>
34#include <babeltrace/lib-logging-internal.h>
35#include <babeltrace/object-internal.h>
36#include <babeltrace/ref-internal.h>
37#include <babeltrace/values-internal.h>
38#include <babeltrace/ctf-ir/field-types-internal.h>
39#include <babeltrace/ctf-ir/fields-internal.h>
40#include <babeltrace/ctf-ir/event-class-internal.h>
41#include <babeltrace/ctf-ir/event-internal.h>
42#include <babeltrace/ctf-ir/packet-internal.h>
43#include <babeltrace/ctf-ir/stream-class-internal.h>
44#include <babeltrace/ctf-ir/stream-internal.h>
45#include <babeltrace/ctf-ir/trace-internal.h>
46#include <babeltrace/ctf-ir/clock-class-internal.h>
47#include <babeltrace/ctf-ir/clock-value-internal.h>
48#include <babeltrace/ctf-ir/field-path-internal.h>
3dca2276
PP		 49#include <babeltrace/ctf-ir/utils-internal.h>
50#include <babeltrace/ctf-writer/field-types-internal.h>
51#include <babeltrace/ctf-writer/fields-internal.h>
52#include <babeltrace/ctf-writer/event-internal.h>
53#include <babeltrace/ctf-writer/stream-class-internal.h>
54#include <babeltrace/ctf-writer/stream-internal.h>
55#include <babeltrace/ctf-writer/trace-internal.h>
56#include <babeltrace/ctf-writer/clock-internal.h>
57#include <babeltrace/ctf-writer/writer-internal.h>
476ef981
PP		 58#include <babeltrace/graph/clock-class-priority-map-internal.h>
59#include <babeltrace/graph/component-class-internal.h>
60#include <babeltrace/graph/component-class-sink-colander-internal.h>
61#include <babeltrace/graph/component-filter-internal.h>
62#include <babeltrace/graph/component-internal.h>
63#include <babeltrace/graph/component-sink-internal.h>
64#include <babeltrace/graph/component-source-internal.h>
65#include <babeltrace/graph/connection-internal.h>
66#include <babeltrace/graph/graph-internal.h>
67#include <babeltrace/graph/notification-discarded-elements-internal.h>
68#include <babeltrace/graph/notification-event-internal.h>
69#include <babeltrace/graph/notification-heap-internal.h>
70#include <babeltrace/graph/notification-inactivity-internal.h>
71#include <babeltrace/graph/notification-internal.h>
72#include <babeltrace/graph/notification-iterator-internal.h>
73#include <babeltrace/graph/notification-packet-internal.h>
74#include <babeltrace/graph/notification-stream-internal.h>
75#include <babeltrace/graph/port-internal.h>
76#include <babeltrace/plugin/plugin-internal.h>
77#include <babeltrace/plugin/plugin-so-internal.h>
476ef981
PP		 78
79#define LIB_LOGGING_BUF_SIZE (4096 * 4)
80
81static char __thread lib_logging_buf[LIB_LOGGING_BUF_SIZE];
82
83#define BUF_APPEND(_fmt, ...) \
84 do { \
85 int _count; \
86 size_t _size = LIB_LOGGING_BUF_SIZE - \
87 (size_t) (*buf_ch - lib_logging_buf); \
88 _count = snprintf(*buf_ch, _size, (_fmt), __VA_ARGS__); \
f6ccaed9 89 BT_ASSERT(_count >= 0); \
476ef981
PP		 90 *buf_ch += MIN(_count, _size); \
91 if (*buf_ch >= lib_logging_buf + LIB_LOGGING_BUF_SIZE - 1) { \
92 return; \
93 } \
94 } while (0)
95
96#define BUF_APPEND_UUID(_uuid) \
97 BUF_APPEND(", %suuid=\"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\"", \
98 prefix, \
99 (unsigned int) (_uuid)[0], \
100 (unsigned int) (_uuid)[1], \
101 (unsigned int) (_uuid)[2], \
102 (unsigned int) (_uuid)[3], \
103 (unsigned int) (_uuid)[4], \
104 (unsigned int) (_uuid)[5], \
105 (unsigned int) (_uuid)[6], \
106 (unsigned int) (_uuid)[7], \
107 (unsigned int) (_uuid)[8], \
108 (unsigned int) (_uuid)[9], \
109 (unsigned int) (_uuid)[10], \
110 (unsigned int) (_uuid)[11], \
111 (unsigned int) (_uuid)[12], \
112 (unsigned int) (_uuid)[13], \
113 (unsigned int) (_uuid)[14], \
114 (unsigned int) (_uuid)[15])
115
116#define PRFIELD(_expr) prefix, (_expr)
117
118#define SET_TMP_PREFIX(_prefix2) \
119 do { \
120 strcpy(tmp_prefix, prefix); \
121 strcat(tmp_prefix, (_prefix2)); \
122 } while (0)
123
3dca2276
PP		 124typedef void (*format_func)(char **, bool, const char *, void *);
125
476ef981
PP		 126static inline void format_component(char **buf_ch, bool extended,
127 const char *prefix, struct bt_component *component);
128
129static inline void format_port(char **buf_ch, bool extended,
130 const char *prefix, struct bt_port *port);
131
132static inline void format_connection(char **buf_ch, bool extended,
133 const char *prefix, struct bt_connection *connection);
134
135static inline void format_ref_count(char **buf_ch, bool extended,
136 const char *prefix, struct bt_object *obj)
137{
138 BUF_APPEND(", %sref-count=%lu", prefix, obj->ref_count.count);
139}
140
3dca2276
PP		 141static inline void format_field_type_common(char **buf_ch, bool extended,
142 const char *prefix, struct bt_field_type_common *field_type)
476ef981
PP		 143{
144 BUF_APPEND(", %stype-id=%s, %salignment=%u",
3dca2276 145 PRFIELD(bt_common_field_type_id_string(field_type->id)),
476ef981
PP		 146 PRFIELD(field_type->alignment));
147
148 if (extended) {
149 BUF_APPEND(", %sis-frozen=%d", PRFIELD(field_type->frozen));
150 } else {
151 return;
152 }
153
154 if (field_type->id == BT_FIELD_TYPE_ID_UNKNOWN) {
155 return;
156 }
157
158 switch (field_type->id) {
159 case BT_FIELD_TYPE_ID_INTEGER:
160 {
3dca2276
PP		 161 struct bt_field_type_common_integer *integer =
162 BT_FROM_COMMON(field_type);
476ef981
PP		 163
164 BUF_APPEND(", %ssize=%u, %sis-signed=%d, %sbyte-order=%s, "
165 "%sbase=%d, %sencoding=%s, "
166 "%smapped-clock-class-addr=%p",
167 PRFIELD(integer->size), PRFIELD(integer->is_signed),
3dca2276 168 PRFIELD(bt_common_byte_order_string(integer->user_byte_order)),
476ef981 169 PRFIELD(integer->base),
3dca2276
PP		 170 PRFIELD(bt_common_string_encoding_string(integer->encoding)),
171 PRFIELD(integer->mapped_clock_class));
476ef981 172
3dca2276 173 if (integer->mapped_clock_class) {
476ef981 174 BUF_APPEND(", %smapped-clock-class-name=\"%s\"",
3dca2276 175 PRFIELD(bt_clock_class_get_name(integer->mapped_clock_class)));
476ef981
PP		 176 }
177 break;
178 }
179 case BT_FIELD_TYPE_ID_FLOAT:
180 {
3dca2276
PP		 181 struct bt_field_type_common_floating_point *flt =
182 BT_FROM_COMMON(field_type);
476ef981
PP		 183
184 BUF_APPEND(", %sexp-dig=%u, %smant-dig=%u, %sbyte-order=%s",
185 PRFIELD(flt->exp_dig), PRFIELD(flt->mant_dig),
3dca2276 186 PRFIELD(bt_common_byte_order_string(flt->user_byte_order)));
476ef981
PP		 187 break;
188 }
189 case BT_FIELD_TYPE_ID_ENUM:
190 {
3dca2276
PP		 191 struct bt_field_type_common_enumeration *enm =
192 BT_FROM_COMMON(field_type);
476ef981
PP		 193
194 BUF_APPEND(", %smapping-count=%u",
195 PRFIELD(enm->entries->len));
196 break;
197 }
198 case BT_FIELD_TYPE_ID_STRING:
199 {
3dca2276
PP		 200 struct bt_field_type_common_string *str =
201 BT_FROM_COMMON(field_type);
476ef981
PP		 202
203 BUF_APPEND(", %sencoding=%s",
3dca2276 204 PRFIELD(bt_common_string_encoding_string(str->encoding)));
476ef981
PP		 205 break;
206 }
207 case BT_FIELD_TYPE_ID_STRUCT:
208 {
3dca2276
PP		 209 struct bt_field_type_common_structure *structure =
210 BT_FROM_COMMON(field_type);
476ef981
PP		 211
212 BUF_APPEND(", %sfield-count=%u",
213 PRFIELD(structure->fields->len));
214 break;
215 }
216 case BT_FIELD_TYPE_ID_SEQUENCE:
217 {
3dca2276
PP		 218 struct bt_field_type_common_sequence *seq =
219 BT_FROM_COMMON(field_type);
476ef981
PP		 220
221 BUF_APPEND(", %slength-ft-addr=\"%s\", %selem-ft-addr=%p",
222 PRFIELD(seq->length_field_name->str),
3dca2276 223 PRFIELD(seq->element_ft));
476ef981
PP		 224 break;
225 }
226 case BT_FIELD_TYPE_ID_VARIANT:
227 {
3dca2276
PP		 228 struct bt_field_type_common_variant *variant =
229 BT_FROM_COMMON(field_type);
476ef981
PP		 230
231 BUF_APPEND(", %stag-name=\"%s\", %stag-ft-addr=%p, "
232 "%sfield-count=%u",
233 PRFIELD(variant->tag_name->str),
3dca2276 234 PRFIELD(variant->tag_ft), PRFIELD(variant->fields->len));
476ef981
PP		 235 break;
236 }
237 default:
238 break;
239 }
240}
241
3dca2276
PP		 242static inline void format_field_type(char **buf_ch, bool extended,
243 const char *prefix, struct bt_field_type *field_type)
244{
245 format_field_type_common(buf_ch, extended, prefix,
246 (void *) field_type);
247}
248
249static inline void format_writer_field_type(char **buf_ch, bool extended,
250 const char *prefix, struct bt_ctf_field_type *field_type)
251{
252 format_field_type_common(buf_ch, extended, prefix,
253 (void *) field_type);
254}
255
256static inline void format_field_common_integer_extended(char **buf_ch,
257 const char *prefix, struct bt_field_common *field)
476ef981 258{
3dca2276
PP		 259 struct bt_field_common_integer *integer = BT_FROM_COMMON(field);
260 struct bt_field_type_common_integer *field_type =
261 BT_FROM_COMMON(field->type);
476ef981
PP		 262 const char *fmt = NULL;
263
264 if (field_type->base == 8) {
265 fmt = ", %svalue=%" PRIo64;
266 } else if (field_type->base == 16) {
267 fmt = ", %svalue=%" PRIx64;
268 }
269
270 if (field_type->is_signed) {
271 if (!fmt) {
272 fmt = ", %svalue=%" PRId64;
273 }
274
275 BUF_APPEND(fmt, PRFIELD(integer->payload.signd));
276 } else {
277 if (!fmt) {
278 fmt = ", %svalue=%" PRIu64;
279 }
280
281 BUF_APPEND(fmt, PRFIELD(integer->payload.unsignd));
282 }
283}
284
3dca2276
PP		 285static inline void format_field_common(char **buf_ch, bool extended,
286 const char *prefix, struct bt_field_common *field)
476ef981
PP		 287{
288 BUF_APPEND(", %sis-set=%d", PRFIELD(field->payload_set));
289
290 if (extended) {
291 BUF_APPEND(", %sis-frozen=%d", PRFIELD(field->frozen));
292 }
293
294 BUF_APPEND(", %stype-addr=%p, %stype-id=%s",
295 PRFIELD(field->type),
3dca2276 296 PRFIELD(bt_common_field_type_id_string(field->type->id)));
476ef981
PP		 297
298 if (!extended || field->type->id == BT_FIELD_TYPE_ID_UNKNOWN ||
299 !field->payload_set) {
300 return;
301 }
302
303 switch (field->type->id) {
304 case BT_FIELD_TYPE_ID_INTEGER:
305 {
3dca2276 306 format_field_common_integer_extended(buf_ch, prefix, field);
476ef981
PP		 307 break;
308 }
309 case BT_FIELD_TYPE_ID_FLOAT:
310 {
3dca2276
PP		 311 struct bt_field_common_floating_point *flt =
312 BT_FROM_COMMON(field);
476ef981
PP		 313
314 BUF_APPEND(", %svalue=%f", PRFIELD(flt->payload));
315 break;
316 }
317 case BT_FIELD_TYPE_ID_ENUM:
318 {
3dca2276
PP		 319 struct bt_field_common_enumeration *enm =
320 BT_FROM_COMMON(field);
476ef981
PP		 321
322 if (enm->payload) {
3dca2276 323 format_field_common_integer_extended(buf_ch, prefix,
476ef981
PP		 324 enm->payload);
325 }
326 break;
327 }
328 case BT_FIELD_TYPE_ID_STRING:
329 {
3dca2276
PP		 330 struct bt_field_common_string *str =
331 BT_FROM_COMMON(field);
476ef981 332
f6ccaed9 333 BT_ASSERT(str->payload);
476ef981
PP		 334 BUF_APPEND(", %spartial-value=\"%.32s\"",
335 PRFIELD(str->payload->str));
336 break;
337 }
338 case BT_FIELD_TYPE_ID_SEQUENCE:
339 {
3dca2276
PP		 340 struct bt_field_common_sequence *seq =
341 BT_FROM_COMMON(field);
476ef981
PP		 342
343 BUF_APPEND(", %slength-field-addr=%p", PRFIELD(seq->length));
344 break;
345 }
346 case BT_FIELD_TYPE_ID_VARIANT:
347 {
3dca2276
PP		 348 struct bt_field_common_variant *variant =
349 BT_FROM_COMMON(field);
476ef981
PP		 350
351 BUF_APPEND(", %stag-field-addr=%p, %svalue-field-addr=%p",
352 PRFIELD(variant->tag), PRFIELD(variant->payload));
353 break;
354 }
355 default:
356 break;
357 }
358}
359
3dca2276
PP		 360static inline void format_field(char **buf_ch, bool extended,
361 const char *prefix, struct bt_field *field)
362{
363 format_field_common(buf_ch, extended, prefix, (void *) field);
364}
365
366static inline void format_writer_field(char **buf_ch, bool extended,
367 const char *prefix, struct bt_ctf_field *field)
368{
369 format_field_common(buf_ch, extended, prefix, (void *) field);
370}
371
476ef981
PP		 372static inline void format_field_path(char **buf_ch, bool extended,
373 const char *prefix, struct bt_field_path *field_path)
374{
375 uint64_t i;
376
f6ccaed9 377 BT_ASSERT(field_path->indexes);
476ef981
PP		 378 BUF_APPEND(", %sindex-count=%u", PRFIELD(field_path->indexes->len));
379
380 if (!extended) {
381 return;
382 }
383
3dca2276 384 BUF_APPEND(", %spath=[%s", PRFIELD(bt_common_scope_string(field_path->root)));
476ef981
PP		 385
386 for (i = 0; i < field_path->indexes->len; i++) {
387 int index = g_array_index(field_path->indexes, int, i);
388
389 BUF_APPEND(", %d", index);
390 }
391
392 BUF_APPEND("%s", "]");
393}
394
3dca2276
PP		 395static inline void format_trace_common(char **buf_ch, bool extended,
396 const char *prefix, struct bt_trace_common *trace)
476ef981
PP		 397{
398 if (trace->name) {
399 BUF_APPEND(", %sname=\"%s\"", PRFIELD(trace->name->str));
400 }
401
402 if (!extended) {
403 return;
404 }
405
3dca2276 406 BUF_APPEND(", %sis-frozen=%d", PRFIELD(trace->frozen));
476ef981
PP		 407
408 if (trace->uuid_set) {
409 BUF_APPEND_UUID(trace->uuid);
410 }
411
412 BUF_APPEND(", %sclock-class-count=%u, %sstream-class-count=%u, "
3dca2276
PP		 413 "%sstream-count=%u, %spacket-header-ft-addr=%p",
414 PRFIELD(trace->clock_classes->len),
476ef981
PP		 415 PRFIELD(trace->stream_classes->len),
416 PRFIELD(trace->streams->len),
3dca2276 417 PRFIELD(trace->packet_header_field_type));
476ef981
PP		 418}
419
3dca2276
PP		 420static inline void format_trace(char **buf_ch, bool extended,
421 const char *prefix, struct bt_trace *trace)
476ef981 422{
3dca2276
PP		 423 format_trace_common(buf_ch, extended, prefix, BT_TO_COMMON(trace));
424
425 if (extended) {
426 BUF_APPEND(", %sis-static=%d", PRFIELD(trace->is_static));
427 }
428}
429
430static inline void format_writer_trace(char **buf_ch, bool extended,
431 const char *prefix, struct bt_ctf_trace *trace)
432{
433 format_trace_common(buf_ch, extended, prefix, BT_TO_COMMON(trace));
434}
435
436static inline void format_stream_class_common(char **buf_ch, bool extended,
437 const char *prefix, struct bt_stream_class_common *stream_class,
438 format_func trace_format_func)
439{
440 struct bt_trace_common *trace;
476ef981
PP		 441 char tmp_prefix[64];
442
443 if (stream_class->id_set) {
444 BUF_APPEND(", %sid=%" PRId64, PRFIELD(stream_class->id));
445 }
446
447 if (stream_class->name) {
448 BUF_APPEND(", %sname=\"%s\"", PRFIELD(stream_class->name->str));
449 }
450
451 if (!extended) {
452 return;
453 }
454
455 BUF_APPEND(", %sis-frozen=%d", PRFIELD(stream_class->frozen));
476ef981
PP		 456 BUF_APPEND(", %sevent-class-count=%u, %spacket-context-ft-addr=%p, "
457 "%sevent-header-ft-addr=%p, %sevent-context-ft-addr=%p",
458 PRFIELD(stream_class->event_classes->len),
3dca2276
PP		 459 PRFIELD(stream_class->packet_context_field_type),
460 PRFIELD(stream_class->event_header_field_type),
461 PRFIELD(stream_class->event_context_field_type));
462 trace = bt_stream_class_common_borrow_trace(stream_class);
476ef981
PP		 463 if (!trace) {
464 return;
465 }
466
467 BUF_APPEND(", %strace-addr=%p", PRFIELD(trace));
468 SET_TMP_PREFIX("trace-");
3dca2276 469 trace_format_func(buf_ch, false, tmp_prefix, trace);
476ef981
PP		 470}
471
3dca2276
PP		 472static inline void format_stream_class(char **buf_ch, bool extended,
473 const char *prefix, struct bt_stream_class *stream_class)
476ef981 474{
3dca2276
PP		 475 format_stream_class_common(buf_ch, extended, prefix,
476 BT_TO_COMMON(stream_class), (format_func) format_trace);
477}
478
479static inline void format_writer_stream_class(char **buf_ch, bool extended,
480 const char *prefix, struct bt_ctf_stream_class *stream_class)
481{
482 format_stream_class_common(buf_ch, extended, prefix,
483 BT_TO_COMMON(stream_class), (format_func) format_writer_trace);
484
485 if (extended && stream_class->clock) {
486 BUF_APPEND(", %sctf-writer-clock-addr=%p, "
487 "%sctf-writer-clock-name=\"%s\"",
488 PRFIELD(stream_class->clock),
489 PRFIELD(bt_clock_class_get_name(
490 BT_TO_COMMON(stream_class->clock->clock_class))));
491 }
492}
493
494static inline void format_event_class_common(char **buf_ch, bool extended,
495 const char *prefix, struct bt_event_class_common *event_class,
496 format_func format_stream_class_func,
497 format_func format_trace_func)
498{
499 struct bt_stream_class_common *stream_class;
500 struct bt_trace_common *trace;
476ef981
PP		 501 char tmp_prefix[64];
502
503 BUF_APPEND(", %sid=%" PRId64, PRFIELD(event_class->id));
504
505 if (event_class->name) {
506 BUF_APPEND(", %sname=\"%s\"", PRFIELD(event_class->name->str));
507 }
508
509 if (!extended) {
510 return;
511 }
512
513 BUF_APPEND(", %sis-frozen=%d, %slog-level=%s",
514 PRFIELD(event_class->frozen),
3dca2276 515 PRFIELD(bt_common_event_class_log_level_string(event_class->log_level)));
476ef981
PP		 516
517 if (event_class->emf_uri) {
518 BUF_APPEND(", %semf-uri=\"%s\"",
519 PRFIELD(event_class->emf_uri->str));
520 }
521
522 BUF_APPEND(", %scontext-ft-addr=%p, %spayload-ft-addr=%p",
3dca2276
PP		 523 PRFIELD(event_class->context_field_type),
524 PRFIELD(event_class->payload_field_type));
476ef981 525
3dca2276 526 stream_class = bt_event_class_common_borrow_stream_class(event_class);
476ef981
PP		 527 if (!stream_class) {
528 return;
529 }
530
531 BUF_APPEND(", %sstream-class-addr=%p", PRFIELD(stream_class));
532 SET_TMP_PREFIX("stream-class-");
3dca2276
PP		 533 format_stream_class_func(buf_ch, false, tmp_prefix, stream_class);
534 trace = bt_stream_class_common_borrow_trace(stream_class);
476ef981
PP		 535 if (!trace) {
536 return;
537 }
538
539 BUF_APPEND(", %strace-addr=%p", PRFIELD(trace));
540 SET_TMP_PREFIX("trace-");
3dca2276 541 format_trace_func(buf_ch, false, tmp_prefix, trace);
476ef981
PP		 542}
543
3dca2276
PP		 544static inline void format_event_class(char **buf_ch, bool extended,
545 const char *prefix, struct bt_event_class *event_class)
476ef981 546{
3dca2276
PP		 547 format_event_class_common(buf_ch, extended, prefix,
548 BT_TO_COMMON(event_class), (format_func) format_stream_class,
549 (format_func) format_trace);
550}
551
552static inline void format_writer_event_class(char **buf_ch, bool extended,
553 const char *prefix, struct bt_ctf_event_class *event_class)
554{
555 format_event_class_common(buf_ch, extended, prefix,
556 BT_TO_COMMON(event_class),
557 (format_func) format_writer_stream_class,
558 (format_func) format_writer_trace);
559}
560
561static inline void format_stream_common(char **buf_ch, bool extended,
562 const char *prefix, struct bt_stream_common *stream,
563 format_func format_stream_class_func,
564 format_func format_trace_func)
565{
566 struct bt_stream_class_common *stream_class;
567 struct bt_trace_common *trace;
476ef981
PP		 568 char tmp_prefix[64];
569
570 BUF_APPEND(", %sid=%" PRId64, PRFIELD(stream->id));
571
572 if (stream->name) {
573 BUF_APPEND(", %sname=\"%s\"", PRFIELD(stream->name->str));
574 }
575
476ef981
PP		 576 if (!extended) {
577 return;
578 }
579
3dca2276 580 stream_class = bt_stream_common_borrow_class(stream);
476ef981
PP		 581 if (!stream_class) {
582 return;
583 }
584
585 BUF_APPEND(", %sstream-class-addr=%p", PRFIELD(stream_class));
586 SET_TMP_PREFIX("stream-class-");
3dca2276
PP		 587 format_stream_class_func(buf_ch, false, tmp_prefix, stream_class);
588 trace = bt_stream_class_common_borrow_trace(stream_class);
476ef981
PP		 589 if (!trace) {
590 return;
591 }
592
3dca2276 593 trace = (void *) bt_object_borrow_parent(stream);
476ef981
PP		 594 if (!trace) {
595 return;
596 }
597
598 BUF_APPEND(", %strace-addr=%p", PRFIELD(trace));
599 SET_TMP_PREFIX("trace-");
3dca2276
PP		 600 format_trace_common(buf_ch, false, tmp_prefix, trace);
601}
602
603static inline void format_stream(char **buf_ch, bool extended,
604 const char *prefix, struct bt_stream *stream)
605{
606 format_stream_common(buf_ch, extended, prefix, BT_TO_COMMON(stream),
607 (format_func) format_stream_class,
608 (format_func) format_trace);
609}
610
611static inline void format_writer_stream(char **buf_ch, bool extended,
612 const char *prefix, struct bt_ctf_stream *stream)
613{
614 format_stream_common(buf_ch, extended, prefix, BT_TO_COMMON(stream),
615 (format_func) format_writer_stream_class,
616 (format_func) format_writer_trace);
617
618 BUF_APPEND(", %sheader-field-addr=%p, %scontext-field-addr=%p"
619 ", %sfd=%d, %smmap-offset=%zu, "
620 "%smmap-base-offset=%zu, %spacket-size=%" PRIu64 ", "
621 "%soffset=%" PRId64 ", %sevent-count=%u, "
622 "%sflushed-packet-count=%u, "
623 "%sdiscarded-event-count=%" PRIu64 ", "
624 "%ssize=%" PRIu64 ", %slast-ts-end=%" PRIu64,
625 PRFIELD(stream->packet_header),
626 PRFIELD(stream->packet_context),
627 PRFIELD(stream->pos.fd),
628 PRFIELD((size_t) stream->pos.mmap_offset),
629 PRFIELD((size_t) stream->pos.mmap_base_offset),
630 PRFIELD(stream->pos.packet_size),
631 PRFIELD(stream->pos.offset),
632 PRFIELD(stream->events->len),
633 PRFIELD(stream->flushed_packet_count),
634 PRFIELD(stream->discarded_events),
635 PRFIELD(stream->size), PRFIELD(stream->last_ts_end));
476ef981
PP		 636}
637
638static inline void format_packet(char **buf_ch, bool extended,
639 const char *prefix, struct bt_packet *packet)
640{
641 struct bt_stream *stream;
642 struct bt_trace *trace;
643 char tmp_prefix[64];
644
645 if (!extended) {
646 return;
647 }
648
649 BUF_APPEND(", %sis-frozen=%d, %sheader-field-addr=%p, "
650 "%scontext-field-addr=%p",
651 PRFIELD(packet->frozen),
652 PRFIELD(packet->header),
653 PRFIELD(packet->context));
654 stream = bt_packet_borrow_stream(packet);
655 if (!stream) {
656 return;
657 }
658
659 BUF_APPEND(", %sstream-addr=%p", PRFIELD(stream));
660 SET_TMP_PREFIX("stream-");
661 format_stream(buf_ch, false, tmp_prefix, stream);
662 trace = (struct bt_trace *) bt_object_borrow_parent(stream);
663 if (!trace) {
664 return;
665 }
666
667 BUF_APPEND(", %strace-addr=%p", PRFIELD(trace));
668 SET_TMP_PREFIX("trace-");
669 format_trace(buf_ch, false, tmp_prefix, trace);
670}
671
3dca2276
PP		 672static inline void format_event_common(char **buf_ch, bool extended,
673 const char *prefix, struct bt_event_common *event,
674 format_func format_event_class_func,
675 format_func format_stream_class_func,
676 format_func format_trace_func)
476ef981 677{
3dca2276
PP		 678 struct bt_trace_common *trace;
679 struct bt_stream_class_common *stream_class;
476ef981
PP		 680 char tmp_prefix[64];
681
682 if (!extended) {
683 return;
684 }
685
686 BUF_APPEND(", %sis-frozen=%d, %sheader-field-addr=%p, "
687 "%sstream-context-field-addr=%p, "
3dca2276 688 "%scontext-field-addr=%p, %spayload-field-addr=%p, ",
476ef981 689 PRFIELD(event->frozen),
3dca2276
PP		 690 PRFIELD(event->header_field),
691 PRFIELD(event->stream_event_context_field),
692 PRFIELD(event->context_field),
693 PRFIELD(event->payload_field));
694 BUF_APPEND(", %sevent-class-addr=%p", PRFIELD(event->class));
476ef981 695 SET_TMP_PREFIX("event-class-");
3dca2276
PP		 696 format_event_class_func(buf_ch, false, tmp_prefix, event->class);
697 stream_class = bt_event_class_common_borrow_stream_class(event->class);
476ef981
PP		 698 if (stream_class) {
699 BUF_APPEND(", %sstream-class-addr=%p", PRFIELD(stream_class));
700 SET_TMP_PREFIX("stream-class-");
3dca2276
PP		 701 format_stream_class_func(buf_ch, false, tmp_prefix,
702 stream_class);
476ef981 703
3dca2276 704 trace = bt_stream_class_common_borrow_trace(stream_class);
476ef981
PP		 705 if (trace) {
706 BUF_APPEND(", %strace-addr=%p", PRFIELD(trace));
707 SET_TMP_PREFIX("trace-");
3dca2276 708 format_trace_func(buf_ch, false, tmp_prefix, trace);
476ef981
PP		 709 }
710 }
3dca2276
PP		 711}
712
713static inline void format_event(char **buf_ch, bool extended,
714 const char *prefix, struct bt_event *event)
715{
716 struct bt_packet *packet;
717 struct bt_stream *stream;
718 char tmp_prefix[64];
719
720 format_event_common(buf_ch, extended, prefix, BT_TO_COMMON(event),
721 (format_func) format_event_class,
722 (format_func) format_stream_class, (format_func) format_trace);
723
724 if (!extended) {
725 return;
726 }
727
728 BUF_APPEND(", %sclock-value-count=%u",
729 PRFIELD(g_hash_table_size(event->clock_values)));
476ef981
PP		 730
731 packet = bt_event_borrow_packet(event);
732 if (!packet) {
733 return;
734 }
735
736 BUF_APPEND(", %spacket-addr=%p", PRFIELD(packet));
737 SET_TMP_PREFIX("packet-");
738 format_packet(buf_ch, false, tmp_prefix, packet);
739 stream = bt_packet_borrow_stream(packet);
740 if (!stream) {
741 return;
742 }
743
744 BUF_APPEND(", %sstream-addr=%p", PRFIELD(stream));
745 SET_TMP_PREFIX("stream-");
746 format_stream(buf_ch, false, tmp_prefix, stream);
747}
748
3dca2276
PP		 749static inline void format_writer_event(char **buf_ch, bool extended,
750 const char *prefix, struct bt_event *event)
751{
752 format_event_common(buf_ch, extended, prefix, BT_TO_COMMON(event),
753 (format_func) format_writer_event_class,
754 (format_func) format_writer_stream_class,
755 (format_func) format_writer_trace);
756}
757
476ef981
PP		 758static inline void format_clock_class(char **buf_ch, bool extended,
759 const char *prefix, struct bt_clock_class *clock_class)
760{
761 BUF_APPEND(", %sname=\"%s\", %sfreq=%" PRIu64,
762 PRFIELD(clock_class->name->str),
763 PRFIELD(clock_class->frequency));
764
765 if (!extended) {
766 return;
767 }
768
769 if (clock_class->description) {
770 BUF_APPEND(", %spartial-description=\"%.32s\"",
771 PRFIELD(clock_class->description->str));
772 }
773
774 BUF_APPEND(", %sis-frozen=%d, %sprecision=%" PRIu64 ", "
775 "%soffset-s=%" PRId64 ", "
776 "%soffset-cycles=%" PRId64 ", %sis-absolute=%d",
777 PRFIELD(clock_class->frozen), PRFIELD(clock_class->precision),
778 PRFIELD(clock_class->offset_s), PRFIELD(clock_class->offset),
779 PRFIELD(clock_class->absolute));
780
781 if (clock_class->uuid_set) {
782 BUF_APPEND_UUID(clock_class->uuid);
783 }
784}
785
786static inline void format_clock_value(char **buf_ch, bool extended,
787 const char *prefix, struct bt_clock_value *clock_value)
788{
789 char tmp_prefix[64];
790 BUF_APPEND(", %svalue=%" PRIu64 ", %sns-from-epoch=%" PRId64,
791 PRFIELD(clock_value->value),
792 PRFIELD(clock_value->ns_from_epoch));
793
794 if (!extended) {
795 return;
796 }
797
798 BUF_APPEND(", %sclock-class-addr=%p",
799 PRFIELD(clock_value->clock_class));
800 SET_TMP_PREFIX("clock-class-");
801 format_clock_class(buf_ch, false, tmp_prefix, clock_value->clock_class);
802}
803
804static inline void format_value(char **buf_ch, bool extended,
805 const char *prefix, struct bt_value *value)
806{
807 BUF_APPEND(", %stype=%s",
808 PRFIELD(bt_value_type_string(bt_value_get_type(value))));
809
810 if (!extended) {
811 return;
812 }
813
814 switch (bt_value_get_type(value)) {
815 case BT_VALUE_TYPE_BOOL:
816 {
817 bt_bool val;
476ef981 818
f6ccaed9 819 (void) bt_value_bool_get(value, &val);
476ef981
PP		 820 BUF_APPEND(", %svalue=%d", PRFIELD(val));
821 break;
822 }
823 case BT_VALUE_TYPE_INTEGER:
824 {
825 int64_t val;
476ef981 826
f6ccaed9 827 (void) bt_value_integer_get(value, &val);
476ef981
PP		 828 BUF_APPEND(", %svalue=%" PRId64, PRFIELD(val));
829 break;
830 }
831 case BT_VALUE_TYPE_FLOAT:
832 {
833 double val;
476ef981 834
f6ccaed9 835 (void) bt_value_float_get(value, &val);
476ef981
PP		 836 BUF_APPEND(", %svalue=%f", PRFIELD(val));
837 break;
838 }
839 case BT_VALUE_TYPE_STRING:
840 {
841 const char *val;
476ef981 842
f6ccaed9 843 (void) bt_value_string_get(value, &val);
476ef981
PP		 844 BUF_APPEND(", %spartial-value=\"%.32s\"", PRFIELD(val));
845 break;
846 }
847 case BT_VALUE_TYPE_ARRAY:
848 {
849 int64_t count = bt_value_array_size(value);
850
f6ccaed9 851 BT_ASSERT(count >= 0);
476ef981
PP		 852 BUF_APPEND(", %selement-count=%" PRId64, PRFIELD(count));
853 break;
854 }
855 case BT_VALUE_TYPE_MAP:
856 {
857 int64_t count = bt_value_map_size(value);
858
f6ccaed9 859 BT_ASSERT(count >= 0);
476ef981
PP		 860 BUF_APPEND(", %selement-count=%" PRId64, PRFIELD(count));
861 break;
862 }
863 default:
864 break;
865 }
866}
867
868static inline void format_notification(char **buf_ch, bool extended,
869 const char *prefix, struct bt_notification *notif)
870{
871 char tmp_prefix[64];
872
873 BUF_APPEND(", %stype=%s",
874 PRFIELD(bt_notification_type_string(notif->type)));
875
876 if (!extended) {
877 return;
878 }
879
880 BUF_APPEND(", %sis-frozen=%d", PRFIELD(notif->frozen));
881
882 switch (notif->type) {
883 case BT_NOTIFICATION_TYPE_EVENT:
884 {
885 struct bt_notification_event *notif_event = (void *) notif;
886
887 SET_TMP_PREFIX("event-");
888 format_event(buf_ch, true, tmp_prefix, notif_event->event);
889
890 if (!notif_event->cc_prio_map) {
891 return;
892 }
893
894 BUF_APPEND(", %scc-prio-map-addr=%p, %scc-prio-map-cc-count=%u",
895 PRFIELD(notif_event->cc_prio_map),
896 PRFIELD(notif_event->cc_prio_map->entries->len));
897 break;
898 }
899 case BT_NOTIFICATION_TYPE_INACTIVITY:
900 {
901 struct bt_notification_inactivity *notif_inactivity =
902 (void *) notif;
903
904 if (!notif_inactivity->cc_prio_map) {
905 return;
906 }
907
908 BUF_APPEND(", %scc-prio-map-addr=%p, %scc-prio-map-cc-count=%u",
909 PRFIELD(notif_inactivity->cc_prio_map),
910 PRFIELD(notif_inactivity->cc_prio_map->entries->len));
911 break;
912 }
913 case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
914 {
915 struct bt_notification_stream_begin *notif_stream =
916 (void *) notif;
917
918 SET_TMP_PREFIX("stream-");
919 format_stream(buf_ch, true, tmp_prefix, notif_stream->stream);
920 break;
921 }
922 case BT_NOTIFICATION_TYPE_STREAM_END:
923 {
924 struct bt_notification_stream_end *notif_stream =
925 (void *) notif;
926
927 SET_TMP_PREFIX("stream-");
928 format_stream(buf_ch, true, tmp_prefix, notif_stream->stream);
929 break;
930 }
931 case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
932 {
933 struct bt_notification_packet_begin *notif_packet =
934 (void *) notif;
935
936 SET_TMP_PREFIX("packet-");
937 format_packet(buf_ch, true, tmp_prefix, notif_packet->packet);
938 break;
939 }
940 case BT_NOTIFICATION_TYPE_PACKET_END:
941 {
942 struct bt_notification_packet_end *notif_packet =
943 (void *) notif;
944
945 SET_TMP_PREFIX("packet-");
946 format_packet(buf_ch, true, tmp_prefix, notif_packet->packet);
947 break;
948 }
949 case BT_NOTIFICATION_TYPE_DISCARDED_EVENTS:
950 case BT_NOTIFICATION_TYPE_DISCARDED_PACKETS:
951 {
952 struct bt_notification_discarded_elements *notif_discarded =
953 (void *) notif;
954
955 BUF_APPEND(", %scount=%" PRId64,
956 PRFIELD(notif_discarded->count));
957
958 if (notif_discarded->begin_clock_value) {
959 SET_TMP_PREFIX("begin-clock-value-");
960 format_clock_value(buf_ch, true, tmp_prefix,
961 notif_discarded->begin_clock_value);
962 }
963
964 if (notif_discarded->end_clock_value) {
965 SET_TMP_PREFIX("end-clock-value-");
966 format_clock_value(buf_ch, true, tmp_prefix,
967 notif_discarded->end_clock_value);
968 }
969 break;
970 }
971 default:
972 break;
973 }
974}
975
976static inline void format_plugin_so_shared_lib_handle(char **buf_ch,
977 const char *prefix,
978 struct bt_plugin_so_shared_lib_handle *handle)
979{
980 BUF_APPEND(", %saddr=%p", PRFIELD(handle));
981
982 if (handle->path) {
983 BUF_APPEND(", %spath=\"%s\"", PRFIELD(handle->path->str));
984 }
985}
986
987static inline void format_component_class(char **buf_ch, bool extended,
988 const char *prefix, struct bt_component_class *comp_class)
989{
990 char tmp_prefix[64];
991
992 BUF_APPEND(", %stype=%s, %sname=\"%s\"",
993 PRFIELD(bt_component_class_type_string(comp_class->type)),
994 PRFIELD(comp_class->name->str));
995
996 if (comp_class->description) {
997 BUF_APPEND(", %spartial-descr=\"%.32s\"",
998 PRFIELD(comp_class->description->str));
999 }
1000
1001 if (!extended) {
1002 return;
1003 }
1004
1005 BUF_APPEND(", %sis-frozen=%d", PRFIELD(comp_class->frozen));
1006
1007 if (comp_class->so_handle) {
1008 SET_TMP_PREFIX("so-handle-");
1009 format_plugin_so_shared_lib_handle(buf_ch, tmp_prefix,
1010 comp_class->so_handle);
1011 }
1012}
1013
1014static inline void format_component(char **buf_ch, bool extended,
1015 const char *prefix, struct bt_component *component)
1016{
1017 char tmp_prefix[64];
1018
1019 BUF_APPEND(", %sname=\"%s\"", PRFIELD(component->name->str));
1020 SET_TMP_PREFIX("class-");
1021 format_component_class(buf_ch, extended, tmp_prefix, component->class);
1022
1023 if (!extended) {
1024 return;
1025 }
1026
1027 BUF_APPEND(", %sinput-port-count=%u, %soutput-port-count=%u",
1028 PRFIELD(component->input_ports ? component->input_ports->len : 0),
1029 PRFIELD(component->output_ports ? component->output_ports->len : 0));
1030}
1031
1032static inline void format_port(char **buf_ch, bool extended,
1033 const char *prefix, struct bt_port *port)
1034{
1035 char tmp_prefix[64];
1036
1037 BUF_APPEND(", %stype=%s, %sname=\"%s\"",
1038 PRFIELD(bt_port_type_string(port->type)),
1039 PRFIELD(port->name->str));
1040
1041 if (!extended) {
1042 return;
1043 }
1044
1045 if (port->connection) {
1046 SET_TMP_PREFIX("conn-");
1047 format_connection(buf_ch, false, tmp_prefix, port->connection);
1048 }
1049}
1050
1051static inline void format_connection(char **buf_ch, bool extended,
1052 const char *prefix, struct bt_connection *connection)
1053{
1054 char tmp_prefix[64];
1055
1056 if (!extended) {
1057 return;
1058 }
1059
1060 if (connection->upstream_port) {
1061 SET_TMP_PREFIX("upstream-port-");
1062 format_port(buf_ch, false, tmp_prefix,
1063 connection->upstream_port);
1064 }
1065
1066 if (connection->downstream_port) {
1067 SET_TMP_PREFIX("downstream-port-");
1068 format_port(buf_ch, false, tmp_prefix,
1069 connection->downstream_port);
1070 }
1071}
1072
1073static inline void format_graph(char **buf_ch, bool extended,
1074 const char *prefix, struct bt_graph *graph)
1075{
1076 BUF_APPEND(", %sis-canceled=%d", PRFIELD(graph->canceled));
1077
1078 if (!extended) {
1079 return;
1080 }
1081
1082 BUF_APPEND(", %scomp-count=%u, %sconn-count=%u",
1083 PRFIELD(graph->components->len),
1084 PRFIELD(graph->connections->len));
1085}
1086
1087static inline void format_notification_iterator(char **buf_ch,
1088 bool extended, const char *prefix,
1089 struct bt_notification_iterator *iterator)
1090{
1091 const char *type;
1092 char tmp_prefix[64];
1093
1094 if (iterator->type == BT_NOTIFICATION_ITERATOR_TYPE_PRIVATE_CONNECTION) {
1095 type = "BT_NOTIFICATION_ITERATOR_TYPE_PRIVATE_CONNECTION";
1096 } else if (iterator->type == BT_NOTIFICATION_ITERATOR_TYPE_OUTPUT_PORT) {
1097 type = "BT_NOTIFICATION_ITERATOR_TYPE_OUTPUT_PORT";
1098 } else {
1099 type = "(unknown)";
1100 }
1101
1102 BUF_APPEND(", %stype=%s", PRFIELD(type));
1103
1104 switch (iterator->type) {
1105 case BT_NOTIFICATION_ITERATOR_TYPE_PRIVATE_CONNECTION:
1106 {
1107 struct bt_notification_iterator_private_connection *
1108 iter_priv_conn = (void *) iterator;
1109
1110 if (iter_priv_conn->upstream_component) {
1111 SET_TMP_PREFIX("upstream-comp-");
1112 format_component(buf_ch, false, tmp_prefix,
1113 iter_priv_conn->upstream_component);
1114 }
1115
1116 if (iter_priv_conn->upstream_port) {
1117 SET_TMP_PREFIX("upstream-port-");
1118 format_port(buf_ch, false, tmp_prefix,
1119 iter_priv_conn->upstream_port);
1120 }
1121
1122 if (iter_priv_conn->connection) {
1123 SET_TMP_PREFIX("upstream-conn-");
1124 format_connection(buf_ch, false, tmp_prefix,
1125 iter_priv_conn->connection);
1126 }
1127 break;
1128 }
1129 case BT_NOTIFICATION_ITERATOR_TYPE_OUTPUT_PORT:
1130 {
1131 struct bt_notification_iterator_output_port *iter_output_port =
1132 (void *) iterator;
1133
1134 SET_TMP_PREFIX("graph-");
1135 format_graph(buf_ch, false, tmp_prefix,
1136 iter_output_port->graph);
1137 SET_TMP_PREFIX("colander-comp-");
1138 format_component(buf_ch, false, tmp_prefix,
1139 iter_output_port->colander);
1140 SET_TMP_PREFIX("output-port-");
1141 format_port(buf_ch, false, tmp_prefix,
1142 iter_output_port->output_port);
1143 break;
1144 }
1145 default:
1146 break;
1147 }
1148}
1149
1150static inline void format_plugin(char **buf_ch, bool extended,
1151 const char *prefix, struct bt_plugin *plugin)
1152{
1153 char tmp_prefix[64];
1154
1155 BUF_APPEND(", %stype=%s", PRFIELD(bt_plugin_type_string(plugin->type)));
1156
1157 if (plugin->info.path_set) {
1158 BUF_APPEND(", %spath=\"%s\"",
1159 PRFIELD(plugin->info.path->str));
1160 }
1161
1162 if (plugin->info.name_set) {
1163 BUF_APPEND(", %sname=\"%s\"",
1164 PRFIELD(plugin->info.name->str));
1165 }
1166
1167 if (!extended) {
1168 return;
1169 }
1170
1171 if (plugin->info.author_set) {
1172 BUF_APPEND(", %sauthor=\"%s\"",
1173 PRFIELD(plugin->info.author->str));
1174 }
1175
1176 if (plugin->info.license_set) {
1177 BUF_APPEND(", %slicense=\"%s\"",
1178 PRFIELD(plugin->info.license->str));
1179 }
1180
1181 if (plugin->info.version_set) {
1182 BUF_APPEND(", %sversion=%u.%u.%u%s",
1183 PRFIELD(plugin->info.version.major),
1184 plugin->info.version.minor,
1185 plugin->info.version.patch,
1186 plugin->info.version.extra ?
1187 plugin->info.version.extra->str : "");
1188 }
1189
1190 BUF_APPEND(", %sis-frozen=%d, %scomp-class-count=%u",
1191 PRFIELD(plugin->frozen),
1192 PRFIELD(plugin->comp_classes->len));
1193
1194 if (plugin->spec_data) {
1195 struct bt_plugin_so_spec_data *spec_data =
1196 (void *) plugin->spec_data;
1197
1198 if (spec_data->shared_lib_handle) {
1199 SET_TMP_PREFIX("so-handle-");
1200 format_plugin_so_shared_lib_handle(buf_ch, tmp_prefix,
1201 spec_data->shared_lib_handle);
1202 }
1203 }
1204}
1205
1206static inline void format_ctf_writer(char **buf_ch, bool extended,
1207 const char *prefix, struct bt_ctf_writer *writer)
1208{
1209 /* TODO */
1210}
1211
3dca2276
PP		 1212static inline void format_stream_class_common_common(char **buf_ch,
1213 bool extended, const char *prefix,
1214 struct bt_stream_class_common *stream_class)
1215{
1216 format_stream_class_common(buf_ch, extended, prefix, stream_class,
1217 (format_func) format_trace_common);
1218}
1219
1220static inline void format_event_class_common_common(char **buf_ch,
1221 bool extended, const char *prefix,
1222 struct bt_event_class_common *event_class)
1223{
1224 format_event_class_common(buf_ch, extended, prefix, event_class,
1225 (format_func) format_stream_class_common,
1226 (format_func) format_trace_common);
1227}
1228
1229static inline void format_event_common_common(char **buf_ch,
1230 bool extended, const char *prefix,
1231 struct bt_event_common *event)
1232{
1233 format_event_common(buf_ch, extended, prefix, event,
1234 (format_func) format_event_class_common,
1235 (format_func) format_stream_class_common,
1236 (format_func) format_trace_common);
1237}
1238
1239static inline void format_stream_common_common(char **buf_ch, bool extended,
1240 const char *prefix, struct bt_stream_common *stream)
1241{
1242 format_stream_common(buf_ch, extended, prefix, stream,
1243 (format_func) format_stream_class_common,
1244 (format_func) format_trace_common);
1245}
1246
476ef981
PP		 1247static inline void handle_conversion_specifier_bt(void *priv_data,
1248 char **buf_ch, size_t avail_size,
1249 const char **out_fmt_ch, va_list *args)
1250{
1251 const char *fmt_ch = *out_fmt_ch;
1252 bool extended = false;
1253 char prefix[64];
1254 char *prefix_ch = prefix;
1255 void *obj;
3dca2276
PP		 1256 enum {
1257 CAT_DEFAULT,
1258 CAT_WRITER,
1259 CAT_COMMON,
1260 } cat = CAT_DEFAULT;
476ef981
PP		 1261
1262 /* skip "%!" */
1263 fmt_ch += 2;
1264
1265 if (*fmt_ch == '[') {
1266 /* local prefix */
1267 fmt_ch++;
1268
1269 while (true) {
1270 if (*fmt_ch == ']') {
1271 *prefix_ch = '\0';
1272 fmt_ch++;
1273 break;
1274 }
1275
1276 *prefix_ch = *fmt_ch;
1277 prefix_ch++;
1278 fmt_ch++;
1279 }
1280 }
1281
1282 *prefix_ch = '\0';
1283
1284 if (*fmt_ch == '+') {
1285 extended = true;
1286 fmt_ch++;
1287 }
1288
3dca2276
PP		 1289 if (*fmt_ch == 'w') {
1290 cat = CAT_WRITER;
1291 fmt_ch++;
1292 } else if (*fmt_ch == '_') {
1293 cat = CAT_COMMON;
1294 fmt_ch++;
1295 }
1296
476ef981
PP		 1297 obj = va_arg(*args, void *);
1298 BUF_APPEND("%saddr=%p", prefix, obj);
1299
1300 if (!obj) {
1301 goto update_fmt;
1302 }
1303
3dca2276
PP		 1304 switch (cat) {
1305 case CAT_DEFAULT:
1306 switch (*fmt_ch) {
1307 case 'r':
1308 format_ref_count(buf_ch, extended, prefix, obj);
1309 break;
1310 case 'F':
1311 format_field_type(buf_ch, extended, prefix, obj);
1312 break;
1313 case 'f':
1314 format_field(buf_ch, extended, prefix, obj);
1315 break;
1316 case 'P':
1317 format_field_path(buf_ch, extended, prefix, obj);
1318 break;
1319 case 'E':
1320 format_event_class(buf_ch, extended, prefix, obj);
1321 break;
1322 case 'e':
1323 format_event(buf_ch, extended, prefix, obj);
1324 break;
1325 case 'S':
1326 format_stream_class(buf_ch, extended, prefix, obj);
1327 break;
1328 case 's':
1329 format_stream(buf_ch, extended, prefix, obj);
1330 break;
1331 case 'a':
1332 format_packet(buf_ch, extended, prefix, obj);
1333 break;
1334 case 't':
1335 format_trace(buf_ch, extended, prefix, obj);
1336 break;
1337 case 'K':
1338 format_clock_class(buf_ch, extended, prefix, obj);
1339 break;
1340 case 'k':
1341 format_clock_value(buf_ch, extended, prefix, obj);
1342 break;
1343 case 'v':
1344 format_value(buf_ch, extended, prefix, obj);
1345 break;
1346 case 'n':
1347 format_notification(buf_ch, extended, prefix, obj);
1348 break;
1349 case 'i':
1350 format_notification_iterator(buf_ch, extended, prefix, obj);
1351 break;
1352 case 'C':
1353 format_component_class(buf_ch, extended, prefix, obj);
1354 break;
1355 case 'c':
1356 format_component(buf_ch, extended, prefix, obj);
1357 break;
1358 case 'p':
1359 format_port(buf_ch, extended, prefix, obj);
1360 break;
1361 case 'x':
1362 format_connection(buf_ch, extended, prefix, obj);
1363 break;
1364 case 'u':
1365 format_plugin(buf_ch, extended, prefix, obj);
1366 break;
1367 case 'g':
1368 format_graph(buf_ch, extended, prefix, obj);
1369 break;
1370 default:
1371 abort();
1372 }
476ef981 1373 break;
3dca2276
PP		 1374 case CAT_WRITER:
1375 switch (*fmt_ch) {
1376 case 'F':
1377 format_writer_field_type(buf_ch, extended, prefix, obj);
1378 break;
1379 case 'f':
1380 format_writer_field(buf_ch, extended, prefix, obj);
1381 break;
1382 case 'E':
1383 format_writer_event_class(buf_ch, extended, prefix, obj);
1384 break;
1385 case 'e':
1386 format_writer_event(buf_ch, extended, prefix, obj);
1387 break;
1388 case 'S':
1389 format_writer_stream_class(buf_ch, extended, prefix, obj);
1390 break;
1391 case 's':
1392 format_writer_stream(buf_ch, extended, prefix, obj);
1393 break;
1394 case 't':
1395 format_writer_trace(buf_ch, extended, prefix, obj);
1396 break;
1397 case 'w':
1398 format_ctf_writer(buf_ch, extended, prefix, obj);
1399 break;
1400 default:
1401 abort();
1402 }
476ef981 1403 break;
3dca2276
PP		 1404 case CAT_COMMON:
1405 switch (*fmt_ch) {
1406 case 'F':
1407 format_field_type_common(buf_ch, extended, prefix, obj);
1408 break;
1409 case 'f':
1410 format_field_common(buf_ch, extended, prefix, obj);
1411 break;
1412 case 'E':
1413 format_event_class_common_common(buf_ch, extended, prefix, obj);
1414 break;
1415 case 'e':
1416 format_event_common_common(buf_ch, extended, prefix, obj);
1417 break;
1418 case 'S':
1419 format_stream_class_common_common(buf_ch, extended, prefix, obj);
1420 break;
1421 case 's':
1422 format_stream_common_common(buf_ch, extended, prefix, obj);
1423 break;
1424 case 't':
1425 format_trace_common(buf_ch, extended, prefix, obj);
1426 break;
1427 default:
1428 abort();
1429 }
476ef981 1430 break;
476ef981
PP		 1431 }
1432
1433update_fmt:
1434 fmt_ch++;
1435 *out_fmt_ch = fmt_ch;
1436}
1437
1438BT_HIDDEN
1439void bt_lib_log(const char *func, const char *file, unsigned line,
1440 int lvl, const char *tag, const char *fmt, ...)
1441{
1442 va_list args;
1443
f6ccaed9 1444 BT_ASSERT(fmt);
476ef981
PP		 1445 va_start(args, fmt);
1446 bt_common_custom_vsnprintf(lib_logging_buf, LIB_LOGGING_BUF_SIZE, '!',
1447 handle_conversion_specifier_bt, NULL, fmt, &args);
1448 va_end(args);
1449 _bt_log_write_d(func, file, line, lvl, tag, "%s", lib_logging_buf);
1450}
BabelTrace - Trace Format Babel Tower
This page took 0.09801 seconds and 4 git commands to generate.