projects / babeltrace.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Remove stdbool.h includes from C++ files
[babeltrace.git] / src / plugins / ctf / common / msg-iter / msg-iter.cpp
1 /*
2 * SPDX-License-Identifier: MIT
3 *
4 * Copyright (c) 2015-2018 EfficiOS Inc. and Linux Foundation
5 * Copyright (c) 2015-2018 Philippe Proulx <pproulx@efficios.com>
6 *
7 * Babeltrace - CTF message iterator
8 */
9
10 #include <glib.h>
11 #include <inttypes.h>
12 #include <stddef.h>
13 #include <stdint.h>
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <string.h>
17
18 #include <babeltrace2/babeltrace.h>
19
20 #define BT_COMP_LOG_SELF_COMP (msg_it->self_comp)
21 #define BT_LOG_OUTPUT_LEVEL (msg_it->log_level)
22 #define BT_LOG_TAG "PLUGIN/CTF/MSG-ITER"
23 #include "logging/comp-logging.h"
24
25 #include "common/assert.h"
26 #include "common/common.h"
27
28 #include "../bfcr/bfcr.hpp"
29 #include "msg-iter.hpp"
30
31 struct ctf_msg_iter;
32
33 /* A visit stack entry */
34 struct stack_entry
35 {
36 /*
37 * Current base field, one of:
38 *
39 * * string
40 * * structure
41 * * array
42 * * sequence
43 * * variant
44 *
45 * Field is borrowed.
46 */
47 bt_field *base;
48
49 /* Index of next field to set */
50 size_t index;
51 };
52
53 struct ctf_msg_iter;
54
55 /* Visit stack */
56 struct stack
57 {
58 struct ctf_msg_iter *msg_it;
59
60 /* Entries (struct stack_entry) */
61 GArray *entries;
62
63 /* Number of active entries */
64 size_t size;
65 };
66
67 /* State */
68 enum state
69 {
70 STATE_INIT,
71 STATE_SWITCH_PACKET,
72 STATE_DSCOPE_TRACE_PACKET_HEADER_BEGIN,
73 STATE_DSCOPE_TRACE_PACKET_HEADER_CONTINUE,
74 STATE_AFTER_TRACE_PACKET_HEADER,
75 STATE_DSCOPE_STREAM_PACKET_CONTEXT_BEGIN,
76 STATE_DSCOPE_STREAM_PACKET_CONTEXT_CONTINUE,
77 STATE_AFTER_STREAM_PACKET_CONTEXT,
78 STATE_EMIT_MSG_STREAM_BEGINNING,
79 STATE_CHECK_EMIT_MSG_DISCARDED_EVENTS,
80 STATE_CHECK_EMIT_MSG_DISCARDED_PACKETS,
81 STATE_EMIT_MSG_DISCARDED_EVENTS,
82 STATE_EMIT_MSG_DISCARDED_PACKETS,
83 STATE_EMIT_MSG_PACKET_BEGINNING,
84 STATE_DSCOPE_EVENT_HEADER_BEGIN,
85 STATE_DSCOPE_EVENT_HEADER_CONTINUE,
86 STATE_AFTER_EVENT_HEADER,
87 STATE_DSCOPE_EVENT_COMMON_CONTEXT_BEGIN,
88 STATE_DSCOPE_EVENT_COMMON_CONTEXT_CONTINUE,
89 STATE_DSCOPE_EVENT_SPEC_CONTEXT_BEGIN,
90 STATE_DSCOPE_EVENT_SPEC_CONTEXT_CONTINUE,
91 STATE_DSCOPE_EVENT_PAYLOAD_BEGIN,
92 STATE_DSCOPE_EVENT_PAYLOAD_CONTINUE,
93 STATE_EMIT_MSG_EVENT,
94 STATE_EMIT_QUEUED_MSG_EVENT,
95 STATE_SKIP_PACKET_PADDING,
96 STATE_EMIT_MSG_PACKET_END_MULTI,
97 STATE_EMIT_MSG_PACKET_END_SINGLE,
98 STATE_EMIT_QUEUED_MSG_PACKET_END,
99 STATE_CHECK_EMIT_MSG_STREAM_END,
100 STATE_EMIT_MSG_STREAM_END,
101 STATE_DONE,
102 };
103
104 struct end_of_packet_snapshots
105 {
106 uint64_t discarded_events;
107 uint64_t packets;
108 uint64_t beginning_clock;
109 uint64_t end_clock;
110 };
111
112 /* CTF message iterator */
113 struct ctf_msg_iter
114 {
115 /* Visit stack */
116 struct stack *stack;
117
118 /* Current message iterator to create messages (weak) */
119 bt_self_message_iterator *self_msg_iter;
120
121 /*
122 * True if library objects are unavailable during the decoding and
123 * should not be created/used.
124 */
125 bool dry_run;
126
127 /*
128 * Current dynamic scope field pointer.
129 *
130 * This is set by read_dscope_begin_state() and contains the
131 * value of one of the pointers in `dscopes` below.
132 */
133 bt_field *cur_dscope_field;
134
135 /*
136 * True if we're done filling a string field from a text
137 * array/sequence payload.
138 */
139 bool done_filling_string;
140
141 /* Trace and classes */
142 /* True to set IR fields */
143 bool set_ir_fields;
144
145 struct
146 {
147 struct ctf_trace_class *tc;
148 struct ctf_stream_class *sc;
149 struct ctf_event_class *ec;
150 } meta;
151
152 /* Current packet (NULL if not created yet) */
153 bt_packet *packet;
154
155 /* Current stream (NULL if not set yet) */
156 bt_stream *stream;
157
158 /* Current event (NULL if not created yet) */
159 bt_event *event;
160
161 /* Current event message (NULL if not created yet) */
162 bt_message *event_msg;
163
164 /*
165 * True if we need to emit a packet beginning message before we emit
166 * the next event message or the packet end message.
167 */
168 bool emit_delayed_packet_beginning_msg;
169
170 /*
171 * True if this is the first packet we are reading, and therefore if we
172 * should emit a stream beginning message.
173 */
174 bool emit_stream_beginning_message;
175
176 /*
177 * True if we need to emit a stream end message at the end of the
178 * current stream. A live stream may never receive any data and thus
179 * never send a stream beginning message which removes the need to emit
180 * a stream end message.
181 */
182 bool emit_stream_end_message;
183
184 /* Database of current dynamic scopes */
185 struct
186 {
187 bt_field *stream_packet_context;
188 bt_field *event_common_context;
189 bt_field *event_spec_context;
190 bt_field *event_payload;
191 } dscopes;
192
193 /* Current state */
194 enum state state;
195
196 /* Current medium buffer data */
197 struct
198 {
199 /* Last address provided by medium */
200 const uint8_t *addr;
201
202 /* Buffer size provided by medium (bytes) */
203 size_t sz;
204
205 /* Offset within whole packet of addr (bits) */
206 size_t packet_offset;
207
208 /* Current position from addr (bits) */
209 size_t at;
210
211 /* Position of the last event header from addr (bits) */
212 size_t last_eh_at;
213 } buf;
214
215 /* Binary type reader */
216 struct bt_bfcr *bfcr;
217
218 /* Current medium data */
219 struct
220 {
221 struct ctf_msg_iter_medium_ops medops;
222 size_t max_request_sz;
223 void *data;
224 } medium;
225
226 /* Current packet size (bits) (-1 if unknown) */
227 int64_t cur_exp_packet_total_size;
228
229 /* Current content size (bits) (-1 if unknown) */
230 int64_t cur_exp_packet_content_size;
231
232 /* Current stream class ID */
233 int64_t cur_stream_class_id;
234
235 /* Current event class ID */
236 int64_t cur_event_class_id;
237
238 /* Current data stream ID */
239 int64_t cur_data_stream_id;
240
241 /*
242 * Offset, in the underlying media, of the current packet's
243 * start (-1 if unknown).
244 */
245 off_t cur_packet_offset;
246
247 /* Default clock's current value */
248 uint64_t default_clock_snapshot;
249
250 /* End of current packet snapshots */
251 struct end_of_packet_snapshots snapshots;
252
253 /* End of previous packet snapshots */
254 struct end_of_packet_snapshots prev_packet_snapshots;
255
256 /* Stored values (for sequence lengths, variant tags) */
257 GArray *stored_values;
258
259 /* Iterator's current log level */
260 bt_logging_level log_level;
261
262 /* Iterator's owning self component, or `NULL` if none (query) */
263 bt_self_component *self_comp;
264 };
265
266 static inline const char *state_string(enum state state)
267 {
268 switch (state) {
269 case STATE_INIT:
270 return "INIT";
271 case STATE_SWITCH_PACKET:
272 return "SWITCH_PACKET";
273 case STATE_DSCOPE_TRACE_PACKET_HEADER_BEGIN:
274 return "DSCOPE_TRACE_PACKET_HEADER_BEGIN";
275 case STATE_DSCOPE_TRACE_PACKET_HEADER_CONTINUE:
276 return "DSCOPE_TRACE_PACKET_HEADER_CONTINUE";
277 case STATE_AFTER_TRACE_PACKET_HEADER:
278 return "AFTER_TRACE_PACKET_HEADER";
279 case STATE_DSCOPE_STREAM_PACKET_CONTEXT_BEGIN:
280 return "DSCOPE_STREAM_PACKET_CONTEXT_BEGIN";
281 case STATE_DSCOPE_STREAM_PACKET_CONTEXT_CONTINUE:
282 return "DSCOPE_STREAM_PACKET_CONTEXT_CONTINUE";
283 case STATE_AFTER_STREAM_PACKET_CONTEXT:
284 return "AFTER_STREAM_PACKET_CONTEXT";
285 case STATE_EMIT_MSG_STREAM_BEGINNING:
286 return "EMIT_MSG_STREAM_BEGINNING";
287 case STATE_CHECK_EMIT_MSG_DISCARDED_EVENTS:
288 return "CHECK_EMIT_MSG_DISCARDED_EVENTS";
289 case STATE_CHECK_EMIT_MSG_DISCARDED_PACKETS:
290 return "CHECK_EMIT_MSG_DISCARDED_PACKETS";
291 case STATE_EMIT_MSG_PACKET_BEGINNING:
292 return "EMIT_MSG_PACKET_BEGINNING";
293 case STATE_EMIT_MSG_DISCARDED_EVENTS:
294 return "EMIT_MSG_DISCARDED_EVENTS";
295 case STATE_EMIT_MSG_DISCARDED_PACKETS:
296 return "EMIT_MSG_DISCARDED_PACKETS";
297 case STATE_DSCOPE_EVENT_HEADER_BEGIN:
298 return "DSCOPE_EVENT_HEADER_BEGIN";
299 case STATE_DSCOPE_EVENT_HEADER_CONTINUE:
300 return "DSCOPE_EVENT_HEADER_CONTINUE";
301 case STATE_AFTER_EVENT_HEADER:
302 return "AFTER_EVENT_HEADER";
303 case STATE_DSCOPE_EVENT_COMMON_CONTEXT_BEGIN:
304 return "DSCOPE_EVENT_COMMON_CONTEXT_BEGIN";
305 case STATE_DSCOPE_EVENT_COMMON_CONTEXT_CONTINUE:
306 return "DSCOPE_EVENT_COMMON_CONTEXT_CONTINUE";
307 case STATE_DSCOPE_EVENT_SPEC_CONTEXT_BEGIN:
308 return "DSCOPE_EVENT_SPEC_CONTEXT_BEGIN";
309 case STATE_DSCOPE_EVENT_SPEC_CONTEXT_CONTINUE:
310 return "DSCOPE_EVENT_SPEC_CONTEXT_CONTINUE";
311 case STATE_DSCOPE_EVENT_PAYLOAD_BEGIN:
312 return "DSCOPE_EVENT_PAYLOAD_BEGIN";
313 case STATE_DSCOPE_EVENT_PAYLOAD_CONTINUE:
314 return "DSCOPE_EVENT_PAYLOAD_CONTINUE";
315 case STATE_EMIT_MSG_EVENT:
316 return "EMIT_MSG_EVENT";
317 case STATE_EMIT_QUEUED_MSG_EVENT:
318 return "EMIT_QUEUED_MSG_EVENT";
319 case STATE_SKIP_PACKET_PADDING:
320 return "SKIP_PACKET_PADDING";
321 case STATE_EMIT_MSG_PACKET_END_MULTI:
322 return "EMIT_MSG_PACKET_END_MULTI";
323 case STATE_EMIT_MSG_PACKET_END_SINGLE:
324 return "EMIT_MSG_PACKET_END_SINGLE";
325 case STATE_EMIT_QUEUED_MSG_PACKET_END:
326 return "EMIT_QUEUED_MSG_PACKET_END";
327 case STATE_CHECK_EMIT_MSG_STREAM_END:
328 return "CHECK_EMIT_MSG_STREAM_END";
329 case STATE_EMIT_MSG_STREAM_END:
330 return "EMIT_MSG_STREAM_END";
331 case STATE_DONE:
332 return "DONE";
333 }
334
335 bt_common_abort();
336 }
337
338 static struct stack *stack_new(struct ctf_msg_iter *msg_it)
339 {
340 bt_self_component *self_comp = msg_it->self_comp;
341 struct stack *stack = NULL;
342
343 stack = g_new0(struct stack, 1);
344 if (!stack) {
345 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to allocate one stack.");
346 goto error;
347 }
348
349 stack->msg_it = msg_it;
350 stack->entries = g_array_new(FALSE, TRUE, sizeof(struct stack_entry));
351 if (!stack->entries) {
352 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to allocate a GArray.");
353 goto error;
354 }
355
356 BT_COMP_LOGD("Created stack: msg-it-addr=%p, stack-addr=%p", msg_it, stack);
357 goto end;
358
359 error:
360 g_free(stack);
361 stack = NULL;
362
363 end:
364 return stack;
365 }
366
367 static void stack_destroy(struct stack *stack)
368 {
369 struct ctf_msg_iter *msg_it;
370
371 BT_ASSERT_DBG(stack);
372 msg_it = stack->msg_it;
373 BT_COMP_LOGD("Destroying stack: addr=%p", stack);
374
375 if (stack->entries) {
376 g_array_free(stack->entries, TRUE);
377 }
378
379 g_free(stack);
380 }
381
382 static void stack_push(struct stack *stack, bt_field *base)
383 {
384 struct stack_entry *entry;
385 struct ctf_msg_iter *msg_it;
386
387 BT_ASSERT_DBG(stack);
388 msg_it = stack->msg_it;
389 BT_ASSERT_DBG(base);
390 BT_COMP_LOGT("Pushing base field on stack: stack-addr=%p, "
391 "stack-size-before=%zu, stack-size-after=%zu",
392 stack, stack->size, stack->size + 1);
393
394 if (stack->entries->len == stack->size) {
395 g_array_set_size(stack->entries, stack->size + 1);
396 }
397
398 entry = &bt_g_array_index(stack->entries, struct stack_entry, stack->size);
399 entry->base = base;
400 entry->index = 0;
401 stack->size++;
402 }
403
404 static inline unsigned int stack_size(struct stack *stack)
405 {
406 BT_ASSERT_DBG(stack);
407 return stack->size;
408 }
409
410 static void stack_pop(struct stack *stack)
411 {
412 struct ctf_msg_iter *msg_it;
413
414 BT_ASSERT_DBG(stack);
415 BT_ASSERT_DBG(stack_size(stack));
416 msg_it = stack->msg_it;
417 BT_COMP_LOGT("Popping from stack: "
418 "stack-addr=%p, stack-size-before=%zu, stack-size-after=%zu",
419 stack, stack->size, stack->size - 1);
420 stack->size--;
421 }
422
423 static inline struct stack_entry *stack_top(struct stack *stack)
424 {
425 BT_ASSERT_DBG(stack);
426 BT_ASSERT_DBG(stack_size(stack));
427 return &bt_g_array_index(stack->entries, struct stack_entry, stack->size - 1);
428 }
429
430 static inline bool stack_empty(struct stack *stack)
431 {
432 return stack_size(stack) == 0;
433 }
434
435 static void stack_clear(struct stack *stack)
436 {
437 BT_ASSERT_DBG(stack);
438 stack->size = 0;
439 }
440
441 static inline enum ctf_msg_iter_status
442 msg_iter_status_from_m_status(enum ctf_msg_iter_medium_status m_status)
443 {
444 /* They are the same */
445 return (ctf_msg_iter_status) m_status;
446 }
447
448 static inline size_t buf_size_bits(struct ctf_msg_iter *msg_it)
449 {
450 return msg_it->buf.sz * 8;
451 }
452
453 static inline size_t buf_available_bits(struct ctf_msg_iter *msg_it)
454 {
455 return buf_size_bits(msg_it) - msg_it->buf.at;
456 }
457
458 static inline size_t packet_at(struct ctf_msg_iter *msg_it)
459 {
460 return msg_it->buf.packet_offset + msg_it->buf.at;
461 }
462
463 static inline void buf_consume_bits(struct ctf_msg_iter *msg_it, size_t incr)
464 {
465 BT_COMP_LOGT("Advancing cursor: msg-it-addr=%p, cur-before=%zu, cur-after=%zu", msg_it,
466 msg_it->buf.at, msg_it->buf.at + incr);
467 msg_it->buf.at += incr;
468 }
469
470 static enum ctf_msg_iter_status request_medium_bytes(struct ctf_msg_iter *msg_it)
471 {
472 bt_self_component *self_comp = msg_it->self_comp;
473 uint8_t *buffer_addr = NULL;
474 size_t buffer_sz = 0;
475 enum ctf_msg_iter_medium_status m_status;
476
477 BT_COMP_LOGD("Calling user function (request bytes): msg-it-addr=%p, "
478 "request-size=%zu",
479 msg_it, msg_it->medium.max_request_sz);
480 m_status = msg_it->medium.medops.request_bytes(msg_it->medium.max_request_sz, &buffer_addr,
481 &buffer_sz, msg_it->medium.data);
482 BT_COMP_LOGD("User function returned: status=%s, buf-addr=%p, buf-size=%zu",
483 ctf_msg_iter_medium_status_string(m_status), buffer_addr, buffer_sz);
484 if (m_status == CTF_MSG_ITER_MEDIUM_STATUS_OK) {
485 BT_ASSERT(buffer_sz != 0);
486
487 /* New packet offset is old one + old size (in bits) */
488 msg_it->buf.packet_offset += buf_size_bits(msg_it);
489
490 /* Restart at the beginning of the new medium buffer */
491 msg_it->buf.at = 0;
492 msg_it->buf.last_eh_at = SIZE_MAX;
493
494 /* New medium buffer size */
495 msg_it->buf.sz = buffer_sz;
496
497 /* New medium buffer address */
498 msg_it->buf.addr = buffer_addr;
499
500 BT_COMP_LOGD("User function returned new bytes: "
501 "packet-offset=%zu, cur=%zu, size=%zu, addr=%p",
502 msg_it->buf.packet_offset, msg_it->buf.at, msg_it->buf.sz, msg_it->buf.addr);
503 BT_COMP_LOGT_MEM(buffer_addr, buffer_sz, "Returned bytes at %p:", buffer_addr);
504 } else if (m_status == CTF_MSG_ITER_MEDIUM_STATUS_EOF) {
505 /*
506 * User returned end of stream: validate that we're not
507 * in the middle of a packet header, packet context, or
508 * event.
509 */
510 if (msg_it->cur_exp_packet_total_size >= 0) {
511 if (packet_at(msg_it) == msg_it->cur_exp_packet_total_size) {
512 goto end;
513 }
514 } else {
515 if (packet_at(msg_it) == 0) {
516 goto end;
517 }
518
519 if (msg_it->buf.last_eh_at != SIZE_MAX && msg_it->buf.at == msg_it->buf.last_eh_at) {
520 goto end;
521 }
522 }
523
524 /* All other states are invalid */
525 BT_COMP_LOGE_APPEND_CAUSE(
526 self_comp,
527 "User function returned %s, but message iterator is in an unexpected state: "
528 "state=%s, cur-packet-size=%" PRId64 ", cur=%zu, "
529 "packet-cur=%zu, last-eh-at=%zu",
530 ctf_msg_iter_medium_status_string(m_status), state_string(msg_it->state),
531 msg_it->cur_exp_packet_total_size, msg_it->buf.at, packet_at(msg_it),
532 msg_it->buf.last_eh_at);
533 m_status = CTF_MSG_ITER_MEDIUM_STATUS_ERROR;
534 } else if (m_status < 0) {
535 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
536 "User function failed: "
537 "status=%s",
538 ctf_msg_iter_medium_status_string(m_status));
539 }
540
541 end:
542 return msg_iter_status_from_m_status(m_status);
543 }
544
545 static inline enum ctf_msg_iter_status buf_ensure_available_bits(struct ctf_msg_iter *msg_it)
546 {
547 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
548
549 if (G_UNLIKELY(buf_available_bits(msg_it) == 0)) {
550 /*
551 * This _cannot_ return CTF_MSG_ITER_STATUS_OK
552 * _and_ no bits.
553 */
554 status = request_medium_bytes(msg_it);
555 }
556
557 return status;
558 }
559
560 static enum ctf_msg_iter_status
561 read_dscope_begin_state(struct ctf_msg_iter *msg_it, struct ctf_field_class *dscope_fc,
562 enum state done_state, enum state continue_state, bt_field *dscope_field)
563 {
564 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
565 bt_self_component *self_comp = msg_it->self_comp;
566 enum bt_bfcr_status bfcr_status;
567 size_t consumed_bits;
568
569 msg_it->cur_dscope_field = dscope_field;
570 BT_COMP_LOGT("Starting BFCR: msg-it-addr=%p, bfcr-addr=%p, fc-addr=%p", msg_it, msg_it->bfcr,
571 dscope_fc);
572 consumed_bits = bt_bfcr_start(msg_it->bfcr, dscope_fc, msg_it->buf.addr, msg_it->buf.at,
573 packet_at(msg_it), msg_it->buf.sz, &bfcr_status);
574 BT_COMP_LOGT("BFCR consumed bits: size=%zu", consumed_bits);
575
576 switch (bfcr_status) {
577 case BT_BFCR_STATUS_OK:
578 /* Field class was read completely */
579 BT_COMP_LOGT_STR("Field was completely decoded.");
580 msg_it->state = done_state;
581 break;
582 case BT_BFCR_STATUS_EOF:
583 BT_COMP_LOGT_STR("BFCR needs more data to decode field completely.");
584 msg_it->state = continue_state;
585 break;
586 default:
587 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
588 "BFCR failed to start: msg-it-addr=%p, bfcr-addr=%p, "
589 "status=%s",
590 msg_it, msg_it->bfcr, bt_bfcr_status_string(bfcr_status));
591 status = CTF_MSG_ITER_STATUS_ERROR;
592 goto end;
593 }
594
595 /* Consume bits now since we know we're not in an error state */
596 buf_consume_bits(msg_it, consumed_bits);
597
598 end:
599 return status;
600 }
601
602 static enum ctf_msg_iter_status read_dscope_continue_state(struct ctf_msg_iter *msg_it,
603 enum state done_state)
604 {
605 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
606 bt_self_component *self_comp = msg_it->self_comp;
607 enum bt_bfcr_status bfcr_status;
608 size_t consumed_bits;
609
610 BT_COMP_LOGT("Continuing BFCR: msg-it-addr=%p, bfcr-addr=%p", msg_it, msg_it->bfcr);
611
612 status = buf_ensure_available_bits(msg_it);
613 if (status != CTF_MSG_ITER_STATUS_OK) {
614 if (status < 0) {
615 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
616 "Cannot ensure that buffer has at least one byte: "
617 "msg-addr=%p, status=%s",
618 msg_it, ctf_msg_iter_status_string(status));
619 } else {
620 BT_COMP_LOGT("Cannot ensure that buffer has at least one byte: "
621 "msg-addr=%p, status=%s",
622 msg_it, ctf_msg_iter_status_string(status));
623 }
624
625 goto end;
626 }
627
628 consumed_bits = bt_bfcr_continue(msg_it->bfcr, msg_it->buf.addr, msg_it->buf.sz, &bfcr_status);
629 BT_COMP_LOGT("BFCR consumed bits: size=%zu", consumed_bits);
630
631 switch (bfcr_status) {
632 case BT_BFCR_STATUS_OK:
633 /* Type was read completely. */
634 BT_COMP_LOGT_STR("Field was completely decoded.");
635 msg_it->state = done_state;
636 break;
637 case BT_BFCR_STATUS_EOF:
638 /* Stay in this continue state. */
639 BT_COMP_LOGT_STR("BFCR needs more data to decode field completely.");
640 break;
641 default:
642 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
643 "BFCR failed to continue: msg-it-addr=%p, bfcr-addr=%p, "
644 "status=%s",
645 msg_it, msg_it->bfcr, bt_bfcr_status_string(bfcr_status));
646 status = CTF_MSG_ITER_STATUS_ERROR;
647 goto end;
648 }
649
650 /* Consume bits now since we know we're not in an error state. */
651 buf_consume_bits(msg_it, consumed_bits);
652 end:
653 return status;
654 }
655
656 static void release_event_dscopes(struct ctf_msg_iter *msg_it)
657 {
658 msg_it->dscopes.event_common_context = NULL;
659 msg_it->dscopes.event_spec_context = NULL;
660 msg_it->dscopes.event_payload = NULL;
661 }
662
663 static void release_all_dscopes(struct ctf_msg_iter *msg_it)
664 {
665 msg_it->dscopes.stream_packet_context = NULL;
666
667 release_event_dscopes(msg_it);
668 }
669
670 static enum ctf_msg_iter_status switch_packet_state(struct ctf_msg_iter *msg_it)
671 {
672 enum ctf_msg_iter_status status;
673 bt_self_component *self_comp = msg_it->self_comp;
674
675 /*
676 * We don't put the stream class here because we need to make
677 * sure that all the packets processed by the same message
678 * iterator refer to the same stream class (the first one).
679 */
680 BT_ASSERT(msg_it);
681
682 if (msg_it->cur_exp_packet_total_size != -1) {
683 msg_it->cur_packet_offset += msg_it->cur_exp_packet_total_size;
684 }
685
686 BT_COMP_LOGD("Switching packet: msg-it-addr=%p, cur=%zu, "
687 "packet-offset=%" PRId64,
688 msg_it, msg_it->buf.at, msg_it->cur_packet_offset);
689 stack_clear(msg_it->stack);
690 msg_it->meta.ec = NULL;
691 BT_PACKET_PUT_REF_AND_RESET(msg_it->packet);
692 BT_MESSAGE_PUT_REF_AND_RESET(msg_it->event_msg);
693 release_all_dscopes(msg_it);
694 msg_it->cur_dscope_field = NULL;
695
696 if (msg_it->medium.medops.switch_packet) {
697 enum ctf_msg_iter_medium_status medium_status;
698
699 medium_status = msg_it->medium.medops.switch_packet(msg_it->medium.data);
700 if (medium_status == CTF_MSG_ITER_MEDIUM_STATUS_EOF) {
701 /* No more packets. */
702 msg_it->state = STATE_CHECK_EMIT_MSG_STREAM_END;
703 status = CTF_MSG_ITER_STATUS_OK;
704 goto end;
705 } else if (medium_status != CTF_MSG_ITER_MEDIUM_STATUS_OK) {
706 status = msg_iter_status_from_m_status(medium_status);
707 goto end;
708 }
709
710 /*
711 * After the packet switch, the medium might want to give us a
712 * different buffer for the new packet.
713 */
714 status = request_medium_bytes(msg_it);
715 if (status != CTF_MSG_ITER_STATUS_OK) {
716 goto end;
717 }
718 }
719
720 /*
721 * Adjust current buffer so that addr points to the beginning of the new
722 * packet.
723 */
724 if (msg_it->buf.addr) {
725 size_t consumed_bytes = (size_t) (msg_it->buf.at / CHAR_BIT);
726
727 /* Packets are assumed to start on a byte frontier. */
728 if (msg_it->buf.at % CHAR_BIT) {
729 BT_COMP_LOGE_APPEND_CAUSE(
730 self_comp,
731 "Cannot switch packet: current position is not a multiple of 8: "
732 "msg-it-addr=%p, cur=%zu",
733 msg_it, msg_it->buf.at);
734 status = CTF_MSG_ITER_STATUS_ERROR;
735 goto end;
736 }
737
738 msg_it->buf.addr += consumed_bytes;
739 msg_it->buf.sz -= consumed_bytes;
740 msg_it->buf.at = 0;
741 msg_it->buf.packet_offset = 0;
742 BT_COMP_LOGD("Adjusted buffer: addr=%p, size=%zu", msg_it->buf.addr, msg_it->buf.sz);
743 }
744
745 msg_it->cur_exp_packet_content_size = -1;
746 msg_it->cur_exp_packet_total_size = -1;
747 msg_it->cur_stream_class_id = -1;
748 msg_it->cur_event_class_id = -1;
749 msg_it->cur_data_stream_id = -1;
750 msg_it->prev_packet_snapshots = msg_it->snapshots;
751 msg_it->snapshots.discarded_events = UINT64_C(-1);
752 msg_it->snapshots.packets = UINT64_C(-1);
753 msg_it->snapshots.beginning_clock = UINT64_C(-1);
754 msg_it->snapshots.end_clock = UINT64_C(-1);
755 msg_it->state = STATE_DSCOPE_TRACE_PACKET_HEADER_BEGIN;
756
757 status = CTF_MSG_ITER_STATUS_OK;
758 end:
759 return status;
760 }
761
762 static enum ctf_msg_iter_status read_packet_header_begin_state(struct ctf_msg_iter *msg_it)
763 {
764 struct ctf_field_class *packet_header_fc = NULL;
765 bt_self_component *self_comp = msg_it->self_comp;
766 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
767
768 /*
769 * Make sure at least one bit is available for this packet. An
770 * empty packet is impossible. If we reach the end of the medium
771 * at this point, then it's considered the end of the stream.
772 */
773 status = buf_ensure_available_bits(msg_it);
774 switch (status) {
775 case CTF_MSG_ITER_STATUS_OK:
776 break;
777 case CTF_MSG_ITER_STATUS_EOF:
778 status = CTF_MSG_ITER_STATUS_OK;
779 msg_it->state = STATE_CHECK_EMIT_MSG_STREAM_END;
780 goto end;
781 default:
782 goto end;
783 }
784
785 /* Packet header class is common to the whole trace class. */
786 packet_header_fc = msg_it->meta.tc->packet_header_fc;
787 if (!packet_header_fc) {
788 msg_it->state = STATE_AFTER_TRACE_PACKET_HEADER;
789 goto end;
790 }
791
792 msg_it->cur_stream_class_id = -1;
793 msg_it->cur_event_class_id = -1;
794 msg_it->cur_data_stream_id = -1;
795 BT_COMP_LOGD("Decoding packet header field: "
796 "msg-it-addr=%p, trace-class-addr=%p, fc-addr=%p",
797 msg_it, msg_it->meta.tc, packet_header_fc);
798 status = read_dscope_begin_state(msg_it, packet_header_fc, STATE_AFTER_TRACE_PACKET_HEADER,
799 STATE_DSCOPE_TRACE_PACKET_HEADER_CONTINUE, NULL);
800 if (status < 0) {
801 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
802 "Cannot decode packet header field: "
803 "msg-it-addr=%p, trace-class-addr=%p, "
804 "fc-addr=%p",
805 msg_it, msg_it->meta.tc, packet_header_fc);
806 }
807
808 end:
809 return status;
810 }
811
812 static enum ctf_msg_iter_status read_packet_header_continue_state(struct ctf_msg_iter *msg_it)
813 {
814 return read_dscope_continue_state(msg_it, STATE_AFTER_TRACE_PACKET_HEADER);
815 }
816
817 static inline enum ctf_msg_iter_status set_current_stream_class(struct ctf_msg_iter *msg_it)
818 {
819 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
820 bt_self_component *self_comp = msg_it->self_comp;
821 struct ctf_stream_class *new_stream_class = NULL;
822
823 if (msg_it->cur_stream_class_id == -1) {
824 /*
825 * No current stream class ID field, therefore only one
826 * stream class.
827 */
828 if (msg_it->meta.tc->stream_classes->len != 1) {
829 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
830 "Need exactly one stream class since there's "
831 "no stream class ID field: "
832 "msg-it-addr=%p",
833 msg_it);
834 status = CTF_MSG_ITER_STATUS_ERROR;
835 goto end;
836 }
837
838 new_stream_class = (ctf_stream_class *) msg_it->meta.tc->stream_classes->pdata[0];
839 msg_it->cur_stream_class_id = new_stream_class->id;
840 }
841
842 new_stream_class =
843 ctf_trace_class_borrow_stream_class_by_id(msg_it->meta.tc, msg_it->cur_stream_class_id);
844 if (!new_stream_class) {
845 BT_COMP_LOGE_APPEND_CAUSE(
846 self_comp,
847 "No stream class with ID of stream class ID to use in trace class: "
848 "msg-it-addr=%p, stream-class-id=%" PRIu64 ", "
849 "trace-class-addr=%p",
850 msg_it, msg_it->cur_stream_class_id, msg_it->meta.tc);
851 status = CTF_MSG_ITER_STATUS_ERROR;
852 goto end;
853 }
854
855 if (msg_it->meta.sc) {
856 if (new_stream_class != msg_it->meta.sc) {
857 BT_COMP_LOGE_APPEND_CAUSE(
858 self_comp,
859 "Two packets refer to two different stream classes within the same packet sequence: "
860 "msg-it-addr=%p, prev-stream-class-addr=%p, "
861 "prev-stream-class-id=%" PRId64 ", "
862 "next-stream-class-addr=%p, "
863 "next-stream-class-id=%" PRId64 ", "
864 "trace-addr=%p",
865 msg_it, msg_it->meta.sc, msg_it->meta.sc->id, new_stream_class,
866 new_stream_class->id, msg_it->meta.tc);
867 status = CTF_MSG_ITER_STATUS_ERROR;
868 goto end;
869 }
870 } else {
871 msg_it->meta.sc = new_stream_class;
872 }
873
874 BT_COMP_LOGD("Set current stream class: "
875 "msg-it-addr=%p, stream-class-addr=%p, "
876 "stream-class-id=%" PRId64,
877 msg_it, msg_it->meta.sc, msg_it->meta.sc->id);
878
879 end:
880 return status;
881 }
882
883 static inline enum ctf_msg_iter_status set_current_stream(struct ctf_msg_iter *msg_it)
884 {
885 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
886 bt_self_component *self_comp = msg_it->self_comp;
887 bt_stream *stream = NULL;
888
889 BT_COMP_LOGD("Calling user function (get stream): msg-it-addr=%p, "
890 "stream-class-addr=%p, stream-class-id=%" PRId64,
891 msg_it, msg_it->meta.sc, msg_it->meta.sc->id);
892 stream = msg_it->medium.medops.borrow_stream(msg_it->meta.sc->ir_sc, msg_it->cur_data_stream_id,
893 msg_it->medium.data);
894 bt_stream_get_ref(stream);
895 BT_COMP_LOGD("User function returned: stream-addr=%p", stream);
896 if (!stream) {
897 BT_COMP_LOGE_APPEND_CAUSE(
898 self_comp,
899 "User function failed to return a stream object for the given stream class.");
900 status = CTF_MSG_ITER_STATUS_ERROR;
901 goto end;
902 }
903
904 if (msg_it->stream && stream != msg_it->stream) {
905 BT_COMP_LOGE_APPEND_CAUSE(
906 self_comp,
907 "User function returned a different stream than the previous one for the same sequence of packets.");
908 status = CTF_MSG_ITER_STATUS_ERROR;
909 goto end;
910 }
911
912 BT_STREAM_MOVE_REF(msg_it->stream, stream);
913
914 end:
915 bt_stream_put_ref(stream);
916 return status;
917 }
918
919 static inline enum ctf_msg_iter_status set_current_packet(struct ctf_msg_iter *msg_it)
920 {
921 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
922 bt_self_component *self_comp = msg_it->self_comp;
923 bt_packet *packet = NULL;
924
925 BT_COMP_LOGD("Creating packet from stream: "
926 "msg-it-addr=%p, stream-addr=%p, "
927 "stream-class-addr=%p, "
928 "stream-class-id=%" PRId64,
929 msg_it, msg_it->stream, msg_it->meta.sc, msg_it->meta.sc->id);
930
931 /* Create packet */
932 BT_ASSERT(msg_it->stream);
933 packet = bt_packet_create(msg_it->stream);
934 if (!packet) {
935 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
936 "Cannot create packet from stream: "
937 "msg-it-addr=%p, stream-addr=%p, "
938 "stream-class-addr=%p, "
939 "stream-class-id=%" PRId64,
940 msg_it, msg_it->stream, msg_it->meta.sc, msg_it->meta.sc->id);
941 goto error;
942 }
943
944 goto end;
945
946 error:
947 BT_PACKET_PUT_REF_AND_RESET(packet);
948 status = CTF_MSG_ITER_STATUS_ERROR;
949
950 end:
951 BT_PACKET_MOVE_REF(msg_it->packet, packet);
952 return status;
953 }
954
955 static enum ctf_msg_iter_status after_packet_header_state(struct ctf_msg_iter *msg_it)
956 {
957 enum ctf_msg_iter_status status;
958
959 status = set_current_stream_class(msg_it);
960 if (status != CTF_MSG_ITER_STATUS_OK) {
961 goto end;
962 }
963
964 if (!msg_it->dry_run) {
965 status = set_current_stream(msg_it);
966 if (status != CTF_MSG_ITER_STATUS_OK) {
967 goto end;
968 }
969
970 status = set_current_packet(msg_it);
971 if (status != CTF_MSG_ITER_STATUS_OK) {
972 goto end;
973 }
974 }
975
976 msg_it->state = STATE_DSCOPE_STREAM_PACKET_CONTEXT_BEGIN;
977
978 status = CTF_MSG_ITER_STATUS_OK;
979
980 end:
981 return status;
982 }
983
984 static enum ctf_msg_iter_status read_packet_context_begin_state(struct ctf_msg_iter *msg_it)
985 {
986 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
987 bt_self_component *self_comp = msg_it->self_comp;
988 struct ctf_field_class *packet_context_fc;
989
990 BT_ASSERT(msg_it->meta.sc);
991 packet_context_fc = msg_it->meta.sc->packet_context_fc;
992 if (!packet_context_fc) {
993 BT_COMP_LOGD("No packet packet context field class in stream class: continuing: "
994 "msg-it-addr=%p, stream-class-addr=%p, "
995 "stream-class-id=%" PRId64,
996 msg_it, msg_it->meta.sc, msg_it->meta.sc->id);
997 msg_it->state = STATE_AFTER_STREAM_PACKET_CONTEXT;
998 goto end;
999 }
1000
1001 if (packet_context_fc->in_ir && !msg_it->dry_run) {
1002 BT_ASSERT(!msg_it->dscopes.stream_packet_context);
1003 BT_ASSERT(msg_it->packet);
1004 msg_it->dscopes.stream_packet_context = bt_packet_borrow_context_field(msg_it->packet);
1005 BT_ASSERT(msg_it->dscopes.stream_packet_context);
1006 }
1007
1008 BT_COMP_LOGD("Decoding packet context field: "
1009 "msg-it-addr=%p, stream-class-addr=%p, "
1010 "stream-class-id=%" PRId64 ", fc-addr=%p",
1011 msg_it, msg_it->meta.sc, msg_it->meta.sc->id, packet_context_fc);
1012 status = read_dscope_begin_state(msg_it, packet_context_fc, STATE_AFTER_STREAM_PACKET_CONTEXT,
1013 STATE_DSCOPE_STREAM_PACKET_CONTEXT_CONTINUE,
1014 msg_it->dscopes.stream_packet_context);
1015 if (status < 0) {
1016 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1017 "Cannot decode packet context field: "
1018 "msg-it-addr=%p, stream-class-addr=%p, "
1019 "stream-class-id=%" PRId64 ", fc-addr=%p",
1020 msg_it, msg_it->meta.sc, msg_it->meta.sc->id, packet_context_fc);
1021 }
1022
1023 end:
1024 return status;
1025 }
1026
1027 static enum ctf_msg_iter_status read_packet_context_continue_state(struct ctf_msg_iter *msg_it)
1028 {
1029 return read_dscope_continue_state(msg_it, STATE_AFTER_STREAM_PACKET_CONTEXT);
1030 }
1031
1032 static enum ctf_msg_iter_status set_current_packet_content_sizes(struct ctf_msg_iter *msg_it)
1033 {
1034 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
1035 bt_self_component *self_comp = msg_it->self_comp;
1036
1037 if (msg_it->cur_exp_packet_total_size == -1) {
1038 if (msg_it->cur_exp_packet_content_size != -1) {
1039 msg_it->cur_exp_packet_total_size = msg_it->cur_exp_packet_content_size;
1040 }
1041 } else {
1042 if (msg_it->cur_exp_packet_content_size == -1) {
1043 msg_it->cur_exp_packet_content_size = msg_it->cur_exp_packet_total_size;
1044 }
1045 }
1046
1047 BT_ASSERT(
1048 (msg_it->cur_exp_packet_total_size >= 0 && msg_it->cur_exp_packet_content_size >= 0) ||
1049 (msg_it->cur_exp_packet_total_size < 0 && msg_it->cur_exp_packet_content_size < 0));
1050
1051 if (msg_it->cur_exp_packet_content_size > msg_it->cur_exp_packet_total_size) {
1052 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1053 "Invalid packet or content size: "
1054 "content size is greater than packet size: "
1055 "msg-it-addr=%p, packet-context-field-addr=%p, "
1056 "packet-size=%" PRId64 ", content-size=%" PRId64,
1057 msg_it, msg_it->dscopes.stream_packet_context,
1058 msg_it->cur_exp_packet_total_size,
1059 msg_it->cur_exp_packet_content_size);
1060 status = CTF_MSG_ITER_STATUS_ERROR;
1061 goto end;
1062 }
1063
1064 BT_COMP_LOGD("Set current packet and content sizes: "
1065 "msg-it-addr=%p, packet-size=%" PRIu64 ", content-size=%" PRIu64,
1066 msg_it, msg_it->cur_exp_packet_total_size, msg_it->cur_exp_packet_content_size);
1067
1068 end:
1069 return status;
1070 }
1071
1072 static enum ctf_msg_iter_status after_packet_context_state(struct ctf_msg_iter *msg_it)
1073 {
1074 enum ctf_msg_iter_status status;
1075
1076 status = set_current_packet_content_sizes(msg_it);
1077 if (status != CTF_MSG_ITER_STATUS_OK) {
1078 goto end;
1079 }
1080
1081 if (msg_it->emit_stream_beginning_message) {
1082 msg_it->state = STATE_EMIT_MSG_STREAM_BEGINNING;
1083 } else {
1084 msg_it->state = STATE_CHECK_EMIT_MSG_DISCARDED_EVENTS;
1085 }
1086
1087 end:
1088 return status;
1089 }
1090
1091 static enum ctf_msg_iter_status read_event_header_begin_state(struct ctf_msg_iter *msg_it)
1092 {
1093 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
1094 bt_self_component *self_comp = msg_it->self_comp;
1095 struct ctf_field_class *event_header_fc = NULL;
1096
1097 /* Reset the position of the last event header */
1098 msg_it->buf.last_eh_at = msg_it->buf.at;
1099 msg_it->cur_event_class_id = -1;
1100
1101 /* Check if we have some content left */
1102 if (msg_it->cur_exp_packet_content_size >= 0) {
1103 if (G_UNLIKELY(packet_at(msg_it) == msg_it->cur_exp_packet_content_size)) {
1104 /* No more events! */
1105 BT_COMP_LOGD("Reached end of packet: msg-it-addr=%p, "
1106 "cur=%zu",
1107 msg_it, packet_at(msg_it));
1108 msg_it->state = STATE_EMIT_MSG_PACKET_END_MULTI;
1109 goto end;
1110 } else if (G_UNLIKELY(packet_at(msg_it) > msg_it->cur_exp_packet_content_size)) {
1111 /* That's not supposed to happen */
1112 BT_COMP_LOGD(
1113 "Before decoding event header field: cursor is passed the packet's content: "
1114 "msg-it-addr=%p, content-size=%" PRId64 ", "
1115 "cur=%zu",
1116 msg_it, msg_it->cur_exp_packet_content_size, packet_at(msg_it));
1117 status = CTF_MSG_ITER_STATUS_ERROR;
1118 goto end;
1119 }
1120 } else {
1121 /*
1122 * "Infinite" content: we're done when the medium has
1123 * nothing else for us.
1124 */
1125 status = buf_ensure_available_bits(msg_it);
1126 switch (status) {
1127 case CTF_MSG_ITER_STATUS_OK:
1128 break;
1129 case CTF_MSG_ITER_STATUS_EOF:
1130 status = CTF_MSG_ITER_STATUS_OK;
1131 msg_it->state = STATE_EMIT_MSG_PACKET_END_SINGLE;
1132 goto end;
1133 default:
1134 goto end;
1135 }
1136 }
1137
1138 release_event_dscopes(msg_it);
1139 BT_ASSERT(msg_it->meta.sc);
1140 event_header_fc = msg_it->meta.sc->event_header_fc;
1141 if (!event_header_fc) {
1142 msg_it->state = STATE_AFTER_EVENT_HEADER;
1143 goto end;
1144 }
1145
1146 BT_COMP_LOGD("Decoding event header field: "
1147 "msg-it-addr=%p, stream-class-addr=%p, "
1148 "stream-class-id=%" PRId64 ", "
1149 "fc-addr=%p",
1150 msg_it, msg_it->meta.sc, msg_it->meta.sc->id, event_header_fc);
1151 status = read_dscope_begin_state(msg_it, event_header_fc, STATE_AFTER_EVENT_HEADER,
1152 STATE_DSCOPE_EVENT_HEADER_CONTINUE, NULL);
1153 if (status < 0) {
1154 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1155 "Cannot decode event header field: "
1156 "msg-it-addr=%p, stream-class-addr=%p, "
1157 "stream-class-id=%" PRId64 ", fc-addr=%p",
1158 msg_it, msg_it->meta.sc, msg_it->meta.sc->id, event_header_fc);
1159 }
1160
1161 end:
1162 return status;
1163 }
1164
1165 static enum ctf_msg_iter_status read_event_header_continue_state(struct ctf_msg_iter *msg_it)
1166 {
1167 return read_dscope_continue_state(msg_it, STATE_AFTER_EVENT_HEADER);
1168 }
1169
1170 static inline enum ctf_msg_iter_status set_current_event_class(struct ctf_msg_iter *msg_it)
1171 {
1172 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
1173 bt_self_component *self_comp = msg_it->self_comp;
1174
1175 struct ctf_event_class *new_event_class = NULL;
1176
1177 if (msg_it->cur_event_class_id == -1) {
1178 /*
1179 * No current event class ID field, therefore only one
1180 * event class.
1181 */
1182 if (msg_it->meta.sc->event_classes->len != 1) {
1183 BT_COMP_LOGE_APPEND_CAUSE(
1184 self_comp,
1185 "Need exactly one event class since there's no event class ID field: "
1186 "msg-it-addr=%p",
1187 msg_it);
1188 status = CTF_MSG_ITER_STATUS_ERROR;
1189 goto end;
1190 }
1191
1192 new_event_class = (ctf_event_class *) msg_it->meta.sc->event_classes->pdata[0];
1193 msg_it->cur_event_class_id = new_event_class->id;
1194 }
1195
1196 new_event_class =
1197 ctf_stream_class_borrow_event_class_by_id(msg_it->meta.sc, msg_it->cur_event_class_id);
1198 if (!new_event_class) {
1199 BT_COMP_LOGE_APPEND_CAUSE(
1200 self_comp,
1201 "No event class with ID of event class ID to use in stream class: "
1202 "msg-it-addr=%p, stream-class-id=%" PRIu64 ", "
1203 "event-class-id=%" PRIu64 ", "
1204 "trace-class-addr=%p",
1205 msg_it, msg_it->meta.sc->id, msg_it->cur_event_class_id, msg_it->meta.tc);
1206 status = CTF_MSG_ITER_STATUS_ERROR;
1207 goto end;
1208 }
1209
1210 msg_it->meta.ec = new_event_class;
1211 BT_COMP_LOGD("Set current event class: "
1212 "msg-it-addr=%p, event-class-addr=%p, "
1213 "event-class-id=%" PRId64 ", "
1214 "event-class-name=\"%s\"",
1215 msg_it, msg_it->meta.ec, msg_it->meta.ec->id, msg_it->meta.ec->name->str);
1216
1217 end:
1218 return status;
1219 }
1220
1221 static inline enum ctf_msg_iter_status set_current_event_message(struct ctf_msg_iter *msg_it)
1222 {
1223 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
1224 bt_self_component *self_comp = msg_it->self_comp;
1225 bt_message *msg = NULL;
1226
1227 BT_ASSERT_DBG(msg_it->meta.ec);
1228 BT_ASSERT_DBG(msg_it->packet);
1229 BT_COMP_LOGD("Creating event message from event class and packet: "
1230 "msg-it-addr=%p, ec-addr=%p, ec-name=\"%s\", packet-addr=%p",
1231 msg_it, msg_it->meta.ec, msg_it->meta.ec->name->str, msg_it->packet);
1232 BT_ASSERT_DBG(msg_it->self_msg_iter);
1233 BT_ASSERT_DBG(msg_it->meta.sc);
1234
1235 if (bt_stream_class_borrow_default_clock_class(msg_it->meta.sc->ir_sc)) {
1236 msg = bt_message_event_create_with_packet_and_default_clock_snapshot(
1237 msg_it->self_msg_iter, msg_it->meta.ec->ir_ec, msg_it->packet,
1238 msg_it->default_clock_snapshot);
1239 } else {
1240 msg = bt_message_event_create_with_packet(msg_it->self_msg_iter, msg_it->meta.ec->ir_ec,
1241 msg_it->packet);
1242 }
1243
1244 if (!msg) {
1245 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1246 "Cannot create event message: "
1247 "msg-it-addr=%p, ec-addr=%p, ec-name=\"%s\", "
1248 "packet-addr=%p",
1249 msg_it, msg_it->meta.ec, msg_it->meta.ec->name->str,
1250 msg_it->packet);
1251 goto error;
1252 }
1253
1254 goto end;
1255
1256 error:
1257 BT_MESSAGE_PUT_REF_AND_RESET(msg);
1258 status = CTF_MSG_ITER_STATUS_ERROR;
1259
1260 end:
1261 BT_MESSAGE_MOVE_REF(msg_it->event_msg, msg);
1262 return status;
1263 }
1264
1265 static enum ctf_msg_iter_status after_event_header_state(struct ctf_msg_iter *msg_it)
1266 {
1267 enum ctf_msg_iter_status status;
1268
1269 status = set_current_event_class(msg_it);
1270 if (status != CTF_MSG_ITER_STATUS_OK) {
1271 goto end;
1272 }
1273
1274 if (G_UNLIKELY(msg_it->dry_run)) {
1275 goto next_state;
1276 }
1277
1278 status = set_current_event_message(msg_it);
1279 if (status != CTF_MSG_ITER_STATUS_OK) {
1280 goto end;
1281 }
1282
1283 msg_it->event = bt_message_event_borrow_event(msg_it->event_msg);
1284 BT_ASSERT_DBG(msg_it->event);
1285
1286 next_state:
1287 msg_it->state = STATE_DSCOPE_EVENT_COMMON_CONTEXT_BEGIN;
1288
1289 end:
1290 return status;
1291 }
1292
1293 static enum ctf_msg_iter_status read_event_common_context_begin_state(struct ctf_msg_iter *msg_it)
1294 {
1295 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
1296 bt_self_component *self_comp = msg_it->self_comp;
1297 struct ctf_field_class *event_common_context_fc;
1298
1299 event_common_context_fc = msg_it->meta.sc->event_common_context_fc;
1300 if (!event_common_context_fc) {
1301 msg_it->state = STATE_DSCOPE_EVENT_SPEC_CONTEXT_BEGIN;
1302 goto end;
1303 }
1304
1305 if (event_common_context_fc->in_ir && !msg_it->dry_run) {
1306 BT_ASSERT_DBG(!msg_it->dscopes.event_common_context);
1307 msg_it->dscopes.event_common_context = bt_event_borrow_common_context_field(msg_it->event);
1308 BT_ASSERT_DBG(msg_it->dscopes.event_common_context);
1309 }
1310
1311 BT_COMP_LOGT("Decoding event common context field: "
1312 "msg-it-addr=%p, stream-class-addr=%p, "
1313 "stream-class-id=%" PRId64 ", "
1314 "fc-addr=%p",
1315 msg_it, msg_it->meta.sc, msg_it->meta.sc->id, event_common_context_fc);
1316 status = read_dscope_begin_state(
1317 msg_it, event_common_context_fc, STATE_DSCOPE_EVENT_SPEC_CONTEXT_BEGIN,
1318 STATE_DSCOPE_EVENT_COMMON_CONTEXT_CONTINUE, msg_it->dscopes.event_common_context);
1319 if (status < 0) {
1320 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1321 "Cannot decode event common context field: "
1322 "msg-it-addr=%p, stream-class-addr=%p, "
1323 "stream-class-id=%" PRId64 ", fc-addr=%p",
1324 msg_it, msg_it->meta.sc, msg_it->meta.sc->id,
1325 event_common_context_fc);
1326 }
1327
1328 end:
1329 return status;
1330 }
1331
1332 static enum ctf_msg_iter_status
1333 read_event_common_context_continue_state(struct ctf_msg_iter *msg_it)
1334 {
1335 return read_dscope_continue_state(msg_it, STATE_DSCOPE_EVENT_SPEC_CONTEXT_BEGIN);
1336 }
1337
1338 static enum ctf_msg_iter_status read_event_spec_context_begin_state(struct ctf_msg_iter *msg_it)
1339 {
1340 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
1341 bt_self_component *self_comp = msg_it->self_comp;
1342 struct ctf_field_class *event_spec_context_fc;
1343
1344 event_spec_context_fc = msg_it->meta.ec->spec_context_fc;
1345 if (!event_spec_context_fc) {
1346 msg_it->state = STATE_DSCOPE_EVENT_PAYLOAD_BEGIN;
1347 goto end;
1348 }
1349
1350 if (event_spec_context_fc->in_ir && !msg_it->dry_run) {
1351 BT_ASSERT_DBG(!msg_it->dscopes.event_spec_context);
1352 msg_it->dscopes.event_spec_context = bt_event_borrow_specific_context_field(msg_it->event);
1353 BT_ASSERT_DBG(msg_it->dscopes.event_spec_context);
1354 }
1355
1356 BT_COMP_LOGT("Decoding event specific context field: "
1357 "msg-it-addr=%p, event-class-addr=%p, "
1358 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
1359 "fc-addr=%p",
1360 msg_it, msg_it->meta.ec, msg_it->meta.ec->name->str, msg_it->meta.ec->id,
1361 event_spec_context_fc);
1362 status = read_dscope_begin_state(
1363 msg_it, event_spec_context_fc, STATE_DSCOPE_EVENT_PAYLOAD_BEGIN,
1364 STATE_DSCOPE_EVENT_SPEC_CONTEXT_CONTINUE, msg_it->dscopes.event_spec_context);
1365 if (status < 0) {
1366 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1367 "Cannot decode event specific context field: "
1368 "msg-it-addr=%p, event-class-addr=%p, "
1369 "event-class-name=\"%s\", "
1370 "event-class-id=%" PRId64 ", fc-addr=%p",
1371 msg_it, msg_it->meta.ec, msg_it->meta.ec->name->str,
1372 msg_it->meta.ec->id, event_spec_context_fc);
1373 }
1374
1375 end:
1376 return status;
1377 }
1378
1379 static enum ctf_msg_iter_status read_event_spec_context_continue_state(struct ctf_msg_iter *msg_it)
1380 {
1381 return read_dscope_continue_state(msg_it, STATE_DSCOPE_EVENT_PAYLOAD_BEGIN);
1382 }
1383
1384 static enum ctf_msg_iter_status read_event_payload_begin_state(struct ctf_msg_iter *msg_it)
1385 {
1386 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
1387 bt_self_component *self_comp = msg_it->self_comp;
1388 struct ctf_field_class *event_payload_fc;
1389
1390 event_payload_fc = msg_it->meta.ec->payload_fc;
1391 if (!event_payload_fc) {
1392 msg_it->state = STATE_EMIT_MSG_EVENT;
1393 goto end;
1394 }
1395
1396 if (event_payload_fc->in_ir && !msg_it->dry_run) {
1397 BT_ASSERT_DBG(!msg_it->dscopes.event_payload);
1398 msg_it->dscopes.event_payload = bt_event_borrow_payload_field(msg_it->event);
1399 BT_ASSERT_DBG(msg_it->dscopes.event_payload);
1400 }
1401
1402 BT_COMP_LOGT("Decoding event payload field: "
1403 "msg-it-addr=%p, event-class-addr=%p, "
1404 "event-class-name=\"%s\", event-class-id=%" PRId64 ", "
1405 "fc-addr=%p",
1406 msg_it, msg_it->meta.ec, msg_it->meta.ec->name->str, msg_it->meta.ec->id,
1407 event_payload_fc);
1408 status =
1409 read_dscope_begin_state(msg_it, event_payload_fc, STATE_EMIT_MSG_EVENT,
1410 STATE_DSCOPE_EVENT_PAYLOAD_CONTINUE, msg_it->dscopes.event_payload);
1411 if (status < 0) {
1412 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1413 "Cannot decode event payload field: "
1414 "msg-it-addr=%p, event-class-addr=%p, "
1415 "event-class-name=\"%s\", "
1416 "event-class-id=%" PRId64 ", fc-addr=%p",
1417 msg_it, msg_it->meta.ec, msg_it->meta.ec->name->str,
1418 msg_it->meta.ec->id, event_payload_fc);
1419 }
1420
1421 end:
1422 return status;
1423 }
1424
1425 static enum ctf_msg_iter_status read_event_payload_continue_state(struct ctf_msg_iter *msg_it)
1426 {
1427 return read_dscope_continue_state(msg_it, STATE_EMIT_MSG_EVENT);
1428 }
1429
1430 static enum ctf_msg_iter_status skip_packet_padding_state(struct ctf_msg_iter *msg_it)
1431 {
1432 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
1433 size_t bits_to_skip;
1434 const enum state next_state = STATE_SWITCH_PACKET;
1435
1436 BT_ASSERT(msg_it->cur_exp_packet_total_size > 0);
1437 bits_to_skip = msg_it->cur_exp_packet_total_size - packet_at(msg_it);
1438 if (bits_to_skip == 0) {
1439 msg_it->state = next_state;
1440 goto end;
1441 } else {
1442 size_t bits_to_consume;
1443
1444 BT_COMP_LOGD("Trying to skip %zu bits of padding: msg-it-addr=%p, size=%zu", bits_to_skip,
1445 msg_it, bits_to_skip);
1446 status = buf_ensure_available_bits(msg_it);
1447 if (status != CTF_MSG_ITER_STATUS_OK) {
1448 goto end;
1449 }
1450
1451 bits_to_consume = MIN(buf_available_bits(msg_it), bits_to_skip);
1452 BT_COMP_LOGD("Skipping %zu bits of padding: msg-it-addr=%p, size=%zu", bits_to_consume,
1453 msg_it, bits_to_consume);
1454 buf_consume_bits(msg_it, bits_to_consume);
1455 bits_to_skip = msg_it->cur_exp_packet_total_size - packet_at(msg_it);
1456 if (bits_to_skip == 0) {
1457 msg_it->state = next_state;
1458 goto end;
1459 }
1460 }
1461
1462 end:
1463 return status;
1464 }
1465
1466 static enum ctf_msg_iter_status check_emit_msg_discarded_events(struct ctf_msg_iter *msg_it)
1467 {
1468 msg_it->state = STATE_EMIT_MSG_DISCARDED_EVENTS;
1469
1470 if (!msg_it->meta.sc->has_discarded_events) {
1471 msg_it->state = STATE_CHECK_EMIT_MSG_DISCARDED_PACKETS;
1472 goto end;
1473 }
1474
1475 if (msg_it->prev_packet_snapshots.discarded_events == UINT64_C(-1)) {
1476 if (msg_it->snapshots.discarded_events == 0 ||
1477 msg_it->snapshots.discarded_events == UINT64_C(-1)) {
1478 /*
1479 * Stream's first packet with no discarded
1480 * events or no information about discarded
1481 * events: do not emit.
1482 */
1483 msg_it->state = STATE_CHECK_EMIT_MSG_DISCARDED_PACKETS;
1484 }
1485 } else {
1486 /*
1487 * If the previous packet has a value for this counter,
1488 * then this counter is defined for the whole stream.
1489 */
1490 BT_ASSERT(msg_it->snapshots.discarded_events != UINT64_C(-1));
1491
1492 if (msg_it->snapshots.discarded_events - msg_it->prev_packet_snapshots.discarded_events ==
1493 0) {
1494 /*
1495 * No discarded events since previous packet: do
1496 * not emit.
1497 */
1498 msg_it->state = STATE_CHECK_EMIT_MSG_DISCARDED_PACKETS;
1499 }
1500 }
1501
1502 end:
1503 return CTF_MSG_ITER_STATUS_OK;
1504 }
1505
1506 static enum ctf_msg_iter_status check_emit_msg_discarded_packets(struct ctf_msg_iter *msg_it)
1507 {
1508 msg_it->state = STATE_EMIT_MSG_DISCARDED_PACKETS;
1509
1510 if (!msg_it->meta.sc->has_discarded_packets) {
1511 msg_it->state = STATE_EMIT_MSG_PACKET_BEGINNING;
1512 goto end;
1513 }
1514
1515 if (msg_it->prev_packet_snapshots.packets == UINT64_C(-1)) {
1516 /*
1517 * Stream's first packet or no information about
1518 * discarded packets: do not emit. In other words, if
1519 * this is the first packet and its sequence number is
1520 * not 0, do not consider that packets were previously
1521 * lost: we might be reading a partial stream (LTTng
1522 * snapshot for example).
1523 */
1524 msg_it->state = STATE_EMIT_MSG_PACKET_BEGINNING;
1525 } else {
1526 /*
1527 * If the previous packet has a value for this counter,
1528 * then this counter is defined for the whole stream.
1529 */
1530 BT_ASSERT(msg_it->snapshots.packets != UINT64_C(-1));
1531
1532 if (msg_it->snapshots.packets - msg_it->prev_packet_snapshots.packets <= 1) {
1533 /*
1534 * No discarded packets since previous packet:
1535 * do not emit.
1536 */
1537 msg_it->state = STATE_EMIT_MSG_PACKET_BEGINNING;
1538 }
1539 }
1540
1541 end:
1542 return CTF_MSG_ITER_STATUS_OK;
1543 }
1544
1545 static inline enum state check_emit_msg_stream_end(struct ctf_msg_iter *msg_it)
1546 {
1547 enum state next_state;
1548
1549 if (msg_it->emit_stream_end_message) {
1550 next_state = STATE_EMIT_MSG_STREAM_END;
1551 } else {
1552 next_state = STATE_DONE;
1553 }
1554
1555 return next_state;
1556 }
1557
1558 static inline enum ctf_msg_iter_status handle_state(struct ctf_msg_iter *msg_it)
1559 {
1560 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
1561 const enum state state = msg_it->state;
1562
1563 BT_COMP_LOGT("Handling state: msg-it-addr=%p, state=%s", msg_it, state_string(state));
1564
1565 // TODO: optimalize!
1566 switch (state) {
1567 case STATE_INIT:
1568 msg_it->state = STATE_SWITCH_PACKET;
1569 break;
1570 case STATE_SWITCH_PACKET:
1571 status = switch_packet_state(msg_it);
1572 break;
1573 case STATE_DSCOPE_TRACE_PACKET_HEADER_BEGIN:
1574 status = read_packet_header_begin_state(msg_it);
1575 break;
1576 case STATE_DSCOPE_TRACE_PACKET_HEADER_CONTINUE:
1577 status = read_packet_header_continue_state(msg_it);
1578 break;
1579 case STATE_AFTER_TRACE_PACKET_HEADER:
1580 status = after_packet_header_state(msg_it);
1581 break;
1582 case STATE_DSCOPE_STREAM_PACKET_CONTEXT_BEGIN:
1583 status = read_packet_context_begin_state(msg_it);
1584 break;
1585 case STATE_DSCOPE_STREAM_PACKET_CONTEXT_CONTINUE:
1586 status = read_packet_context_continue_state(msg_it);
1587 break;
1588 case STATE_AFTER_STREAM_PACKET_CONTEXT:
1589 status = after_packet_context_state(msg_it);
1590 break;
1591 case STATE_EMIT_MSG_STREAM_BEGINNING:
1592 msg_it->state = STATE_CHECK_EMIT_MSG_DISCARDED_EVENTS;
1593 break;
1594 case STATE_CHECK_EMIT_MSG_DISCARDED_EVENTS:
1595 status = check_emit_msg_discarded_events(msg_it);
1596 break;
1597 case STATE_EMIT_MSG_DISCARDED_EVENTS:
1598 msg_it->state = STATE_CHECK_EMIT_MSG_DISCARDED_PACKETS;
1599 break;
1600 case STATE_CHECK_EMIT_MSG_DISCARDED_PACKETS:
1601 status = check_emit_msg_discarded_packets(msg_it);
1602 break;
1603 case STATE_EMIT_MSG_DISCARDED_PACKETS:
1604 msg_it->state = STATE_EMIT_MSG_PACKET_BEGINNING;
1605 break;
1606 case STATE_EMIT_MSG_PACKET_BEGINNING:
1607 msg_it->state = STATE_DSCOPE_EVENT_HEADER_BEGIN;
1608 break;
1609 case STATE_DSCOPE_EVENT_HEADER_BEGIN:
1610 status = read_event_header_begin_state(msg_it);
1611 break;
1612 case STATE_DSCOPE_EVENT_HEADER_CONTINUE:
1613 status = read_event_header_continue_state(msg_it);
1614 break;
1615 case STATE_AFTER_EVENT_HEADER:
1616 status = after_event_header_state(msg_it);
1617 break;
1618 case STATE_DSCOPE_EVENT_COMMON_CONTEXT_BEGIN:
1619 status = read_event_common_context_begin_state(msg_it);
1620 break;
1621 case STATE_DSCOPE_EVENT_COMMON_CONTEXT_CONTINUE:
1622 status = read_event_common_context_continue_state(msg_it);
1623 break;
1624 case STATE_DSCOPE_EVENT_SPEC_CONTEXT_BEGIN:
1625 status = read_event_spec_context_begin_state(msg_it);
1626 break;
1627 case STATE_DSCOPE_EVENT_SPEC_CONTEXT_CONTINUE:
1628 status = read_event_spec_context_continue_state(msg_it);
1629 break;
1630 case STATE_DSCOPE_EVENT_PAYLOAD_BEGIN:
1631 status = read_event_payload_begin_state(msg_it);
1632 break;
1633 case STATE_DSCOPE_EVENT_PAYLOAD_CONTINUE:
1634 status = read_event_payload_continue_state(msg_it);
1635 break;
1636 case STATE_EMIT_MSG_EVENT:
1637 msg_it->state = STATE_DSCOPE_EVENT_HEADER_BEGIN;
1638 break;
1639 case STATE_EMIT_QUEUED_MSG_EVENT:
1640 msg_it->state = STATE_EMIT_MSG_EVENT;
1641 break;
1642 case STATE_SKIP_PACKET_PADDING:
1643 status = skip_packet_padding_state(msg_it);
1644 break;
1645 case STATE_EMIT_MSG_PACKET_END_MULTI:
1646 msg_it->state = STATE_SKIP_PACKET_PADDING;
1647 break;
1648 case STATE_EMIT_MSG_PACKET_END_SINGLE:
1649 msg_it->state = STATE_EMIT_MSG_STREAM_END;
1650 break;
1651 case STATE_EMIT_QUEUED_MSG_PACKET_END:
1652 msg_it->state = STATE_EMIT_MSG_PACKET_END_SINGLE;
1653 break;
1654 case STATE_CHECK_EMIT_MSG_STREAM_END:
1655 msg_it->state = check_emit_msg_stream_end(msg_it);
1656 break;
1657 case STATE_EMIT_MSG_STREAM_END:
1658 msg_it->state = STATE_DONE;
1659 break;
1660 case STATE_DONE:
1661 break;
1662 default:
1663 BT_COMP_LOGF("Unknown CTF plugin message iterator state: "
1664 "msg-it-addr=%p, state=%d",
1665 msg_it, msg_it->state);
1666 bt_common_abort();
1667 }
1668
1669 BT_COMP_LOGT("Handled state: msg-it-addr=%p, status=%s, "
1670 "prev-state=%s, cur-state=%s",
1671 msg_it, ctf_msg_iter_status_string(status), state_string(state),
1672 state_string(msg_it->state));
1673 return status;
1674 }
1675
1676 void ctf_msg_iter_reset_for_next_stream_file(struct ctf_msg_iter *msg_it)
1677 {
1678 BT_ASSERT(msg_it);
1679 BT_COMP_LOGD("Resetting message iterator: addr=%p", msg_it);
1680 stack_clear(msg_it->stack);
1681 msg_it->meta.sc = NULL;
1682 msg_it->meta.ec = NULL;
1683 BT_PACKET_PUT_REF_AND_RESET(msg_it->packet);
1684 BT_STREAM_PUT_REF_AND_RESET(msg_it->stream);
1685 BT_MESSAGE_PUT_REF_AND_RESET(msg_it->event_msg);
1686 release_all_dscopes(msg_it);
1687 msg_it->cur_dscope_field = NULL;
1688
1689 msg_it->buf.addr = NULL;
1690 msg_it->buf.sz = 0;
1691 msg_it->buf.at = 0;
1692 msg_it->buf.last_eh_at = SIZE_MAX;
1693 msg_it->buf.packet_offset = 0;
1694 msg_it->state = STATE_INIT;
1695 msg_it->cur_exp_packet_content_size = -1;
1696 msg_it->cur_exp_packet_total_size = -1;
1697 msg_it->cur_packet_offset = -1;
1698 msg_it->cur_event_class_id = -1;
1699 msg_it->snapshots.beginning_clock = UINT64_C(-1);
1700 msg_it->snapshots.end_clock = UINT64_C(-1);
1701 }
1702
1703 /**
1704 * Resets the internal state of a CTF message iterator.
1705 */
1706 void ctf_msg_iter_reset(struct ctf_msg_iter *msg_it)
1707 {
1708 ctf_msg_iter_reset_for_next_stream_file(msg_it);
1709 msg_it->cur_stream_class_id = -1;
1710 msg_it->cur_data_stream_id = -1;
1711 msg_it->snapshots.discarded_events = UINT64_C(-1);
1712 msg_it->snapshots.packets = UINT64_C(-1);
1713 msg_it->prev_packet_snapshots.discarded_events = UINT64_C(-1);
1714 msg_it->prev_packet_snapshots.packets = UINT64_C(-1);
1715 msg_it->prev_packet_snapshots.beginning_clock = UINT64_C(-1);
1716 msg_it->prev_packet_snapshots.end_clock = UINT64_C(-1);
1717 msg_it->emit_stream_beginning_message = true;
1718 msg_it->emit_stream_end_message = false;
1719 }
1720
1721 static bt_field *borrow_next_field(struct ctf_msg_iter *msg_it)
1722 {
1723 bt_field *next_field = NULL;
1724 bt_field *base_field;
1725 const bt_field_class *base_fc;
1726 bt_field_class_type base_fc_type;
1727 size_t index;
1728
1729 BT_ASSERT_DBG(!stack_empty(msg_it->stack));
1730 index = stack_top(msg_it->stack)->index;
1731 base_field = stack_top(msg_it->stack)->base;
1732 BT_ASSERT_DBG(base_field);
1733 base_fc = bt_field_borrow_class_const(base_field);
1734 BT_ASSERT_DBG(base_fc);
1735 base_fc_type = bt_field_class_get_type(base_fc);
1736
1737 if (base_fc_type == BT_FIELD_CLASS_TYPE_STRUCTURE) {
1738 BT_ASSERT_DBG(index < bt_field_class_structure_get_member_count(
1739 bt_field_borrow_class_const(base_field)));
1740 next_field = bt_field_structure_borrow_member_field_by_index(base_field, index);
1741 } else if (bt_field_class_type_is(base_fc_type, BT_FIELD_CLASS_TYPE_ARRAY)) {
1742 BT_ASSERT_DBG(index < bt_field_array_get_length(base_field));
1743 next_field = bt_field_array_borrow_element_field_by_index(base_field, index);
1744 } else if (bt_field_class_type_is(base_fc_type, BT_FIELD_CLASS_TYPE_VARIANT)) {
1745 BT_ASSERT_DBG(index == 0);
1746 next_field = bt_field_variant_borrow_selected_option_field(base_field);
1747 } else {
1748 bt_common_abort();
1749 }
1750
1751 BT_ASSERT_DBG(next_field);
1752 return next_field;
1753 }
1754
1755 static void update_default_clock(struct ctf_msg_iter *msg_it, uint64_t new_val,
1756 uint64_t new_val_size)
1757 {
1758 uint64_t new_val_mask;
1759 uint64_t cur_value_masked;
1760
1761 BT_ASSERT_DBG(new_val_size > 0);
1762
1763 /*
1764 * Special case for a 64-bit new value, which is the limit
1765 * of a clock value as of this version: overwrite the
1766 * current value directly.
1767 */
1768 if (new_val_size == 64) {
1769 msg_it->default_clock_snapshot = new_val;
1770 goto end;
1771 }
1772
1773 new_val_mask = (1ULL << new_val_size) - 1;
1774 cur_value_masked = msg_it->default_clock_snapshot & new_val_mask;
1775
1776 if (new_val < cur_value_masked) {
1777 /*
1778 * It looks like a wrap happened on the number of bits
1779 * of the requested new value. Assume that the clock
1780 * value wrapped only one time.
1781 */
1782 msg_it->default_clock_snapshot += new_val_mask + 1;
1783 }
1784
1785 /* Clear the low bits of the current clock value. */
1786 msg_it->default_clock_snapshot &= ~new_val_mask;
1787
1788 /* Set the low bits of the current clock value. */
1789 msg_it->default_clock_snapshot |= new_val;
1790
1791 end:
1792 BT_COMP_LOGT("Updated default clock's value from integer field's value: "
1793 "value=%" PRIu64,
1794 msg_it->default_clock_snapshot);
1795 }
1796
1797 /*
1798 * Ensure the message iterator's `stored_values` array is large enough to
1799 * accomodate `storing_index`.
1800 *
1801 * We may need more slots in the array than initially allocated if more
1802 * metadata arrives along the way.
1803 */
1804 static void ensure_stored_values_size(ctf_msg_iter *msg_it, uint64_t storing_index)
1805 {
1806 if (G_UNLIKELY(storing_index >= msg_it->stored_values->len)) {
1807 g_array_set_size(msg_it->stored_values, msg_it->meta.tc->stored_value_count);
1808 }
1809 }
1810
1811 static enum bt_bfcr_status bfcr_unsigned_int_cb(uint64_t value, struct ctf_field_class *fc,
1812 void *data)
1813 {
1814 ctf_msg_iter *msg_it = (ctf_msg_iter *) data;
1815 bt_self_component *self_comp = msg_it->self_comp;
1816 enum bt_bfcr_status status = BT_BFCR_STATUS_OK;
1817
1818 bt_field *field = NULL;
1819
1820 BT_COMP_LOGT("Unsigned integer function called from BFCR: "
1821 "msg-it-addr=%p, bfcr-addr=%p, fc-addr=%p, "
1822 "fc-type=%d, fc-in-ir=%d, value=%" PRIu64,
1823 msg_it, msg_it->bfcr, fc, fc->type, fc->in_ir, value);
1824
1825 ctf_field_class_int *int_fc = ctf_field_class_as_int(fc);
1826
1827 if (G_LIKELY(int_fc->meaning == CTF_FIELD_CLASS_MEANING_NONE)) {
1828 goto update_def_clock;
1829 }
1830
1831 switch (int_fc->meaning) {
1832 case CTF_FIELD_CLASS_MEANING_EVENT_CLASS_ID:
1833 msg_it->cur_event_class_id = value;
1834 break;
1835 case CTF_FIELD_CLASS_MEANING_DATA_STREAM_ID:
1836 msg_it->cur_data_stream_id = value;
1837 break;
1838 case CTF_FIELD_CLASS_MEANING_PACKET_BEGINNING_TIME:
1839 msg_it->snapshots.beginning_clock = value;
1840 break;
1841 case CTF_FIELD_CLASS_MEANING_PACKET_END_TIME:
1842 msg_it->snapshots.end_clock = value;
1843 break;
1844 case CTF_FIELD_CLASS_MEANING_STREAM_CLASS_ID:
1845 msg_it->cur_stream_class_id = value;
1846 break;
1847 case CTF_FIELD_CLASS_MEANING_MAGIC:
1848 if (value != 0xc1fc1fc1) {
1849 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1850 "Invalid CTF magic number: msg-it-addr=%p, "
1851 "magic=%" PRIx64,
1852 msg_it, value);
1853 status = BT_BFCR_STATUS_ERROR;
1854 goto end;
1855 }
1856
1857 break;
1858 case CTF_FIELD_CLASS_MEANING_PACKET_COUNTER_SNAPSHOT:
1859 msg_it->snapshots.packets = value;
1860 break;
1861 case CTF_FIELD_CLASS_MEANING_DISC_EV_REC_COUNTER_SNAPSHOT:
1862 msg_it->snapshots.discarded_events = value;
1863 break;
1864 case CTF_FIELD_CLASS_MEANING_EXP_PACKET_TOTAL_SIZE:
1865 msg_it->cur_exp_packet_total_size = value;
1866 break;
1867 case CTF_FIELD_CLASS_MEANING_EXP_PACKET_CONTENT_SIZE:
1868 msg_it->cur_exp_packet_content_size = value;
1869 break;
1870 default:
1871 bt_common_abort();
1872 }
1873
1874 update_def_clock:
1875 if (G_UNLIKELY(int_fc->mapped_clock_class)) {
1876 update_default_clock(msg_it, value, int_fc->base.size);
1877 }
1878
1879 if (G_UNLIKELY(int_fc->storing_index >= 0)) {
1880 ensure_stored_values_size(msg_it, int_fc->storing_index);
1881 bt_g_array_index(msg_it->stored_values, uint64_t, (uint64_t) int_fc->storing_index) = value;
1882 }
1883
1884 if (G_UNLIKELY(!fc->in_ir || msg_it->dry_run)) {
1885 goto end;
1886 }
1887
1888 field = borrow_next_field(msg_it);
1889 BT_ASSERT_DBG(field);
1890 BT_ASSERT_DBG(bt_field_borrow_class_const(field) == fc->ir_fc);
1891 BT_ASSERT_DBG(bt_field_class_type_is(bt_field_get_class_type(field),
1892 BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER));
1893 bt_field_integer_unsigned_set_value(field, value);
1894 stack_top(msg_it->stack)->index++;
1895
1896 end:
1897 return status;
1898 }
1899
1900 static enum bt_bfcr_status bfcr_unsigned_int_char_cb(uint64_t value, struct ctf_field_class *fc,
1901 void *data)
1902 {
1903 int ret;
1904 ctf_msg_iter *msg_it = (ctf_msg_iter *) data;
1905 bt_self_component *self_comp = msg_it->self_comp;
1906 enum bt_bfcr_status status = BT_BFCR_STATUS_OK;
1907 bt_field *string_field = NULL;
1908 char str[2] = {'\0', '\0'};
1909
1910 BT_COMP_LOGT("Unsigned integer character function called from BFCR: "
1911 "msg-it-addr=%p, bfcr-addr=%p, fc-addr=%p, "
1912 "fc-type=%d, fc-in-ir=%d, value=%" PRIu64,
1913 msg_it, msg_it->bfcr, fc, fc->type, fc->in_ir, value);
1914
1915 ctf_field_class_int *int_fc = ctf_field_class_as_int(fc);
1916 BT_ASSERT_DBG(int_fc->meaning == CTF_FIELD_CLASS_MEANING_NONE);
1917 BT_ASSERT_DBG(!int_fc->mapped_clock_class);
1918 BT_ASSERT_DBG(int_fc->storing_index < 0);
1919
1920 if (G_UNLIKELY(!fc->in_ir || msg_it->dry_run)) {
1921 goto end;
1922 }
1923
1924 if (msg_it->done_filling_string) {
1925 goto end;
1926 }
1927
1928 if (value == 0) {
1929 msg_it->done_filling_string = true;
1930 goto end;
1931 }
1932
1933 string_field = stack_top(msg_it->stack)->base;
1934 BT_ASSERT_DBG(bt_field_get_class_type(string_field) == BT_FIELD_CLASS_TYPE_STRING);
1935
1936 /* Append character */
1937 str[0] = (char) value;
1938 ret = bt_field_string_append_with_length(string_field, str, 1);
1939 if (ret) {
1940 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
1941 "Cannot append character to string field's value: "
1942 "msg-it-addr=%p, field-addr=%p, ret=%d",
1943 msg_it, string_field, ret);
1944 status = BT_BFCR_STATUS_ERROR;
1945 goto end;
1946 }
1947
1948 end:
1949 return status;
1950 }
1951
1952 static enum bt_bfcr_status bfcr_signed_int_cb(int64_t value, struct ctf_field_class *fc, void *data)
1953 {
1954 enum bt_bfcr_status status = BT_BFCR_STATUS_OK;
1955 bt_field *field = NULL;
1956 ctf_msg_iter *msg_it = (ctf_msg_iter *) data;
1957
1958 BT_COMP_LOGT("Signed integer function called from BFCR: "
1959 "msg-it-addr=%p, bfcr-addr=%p, fc-addr=%p, "
1960 "fc-type=%d, fc-in-ir=%d, value=%" PRId64,
1961 msg_it, msg_it->bfcr, fc, fc->type, fc->in_ir, value);
1962
1963 ctf_field_class_int *int_fc = ctf_field_class_as_int(fc);
1964 BT_ASSERT_DBG(int_fc->meaning == CTF_FIELD_CLASS_MEANING_NONE);
1965
1966 if (G_UNLIKELY(int_fc->storing_index >= 0)) {
1967 ensure_stored_values_size(msg_it, int_fc->storing_index);
1968 bt_g_array_index(msg_it->stored_values, uint64_t, (uint64_t) int_fc->storing_index) =
1969 (uint64_t) value;
1970 }
1971
1972 if (G_UNLIKELY(!fc->in_ir || msg_it->dry_run)) {
1973 goto end;
1974 }
1975
1976 field = borrow_next_field(msg_it);
1977 BT_ASSERT_DBG(field);
1978 BT_ASSERT_DBG(bt_field_borrow_class_const(field) == fc->ir_fc);
1979 BT_ASSERT_DBG(
1980 bt_field_class_type_is(bt_field_get_class_type(field), BT_FIELD_CLASS_TYPE_SIGNED_INTEGER));
1981 bt_field_integer_signed_set_value(field, value);
1982 stack_top(msg_it->stack)->index++;
1983
1984 end:
1985 return status;
1986 }
1987
1988 static enum bt_bfcr_status bfcr_floating_point_cb(double value, struct ctf_field_class *fc,
1989 void *data)
1990 {
1991 enum bt_bfcr_status status = BT_BFCR_STATUS_OK;
1992 bt_field *field = NULL;
1993 ctf_msg_iter *msg_it = (ctf_msg_iter *) data;
1994 bt_field_class_type type;
1995
1996 BT_COMP_LOGT("Floating point number function called from BFCR: "
1997 "msg-it-addr=%p, bfcr-addr=%p, fc-addr=%p, "
1998 "fc-type=%d, fc-in-ir=%d, value=%f",
1999 msg_it, msg_it->bfcr, fc, fc->type, fc->in_ir, value);
2000
2001 if (G_UNLIKELY(!fc->in_ir || msg_it->dry_run)) {
2002 goto end;
2003 }
2004
2005 field = borrow_next_field(msg_it);
2006 type = bt_field_get_class_type(field);
2007 BT_ASSERT_DBG(field);
2008 BT_ASSERT_DBG(bt_field_borrow_class_const(field) == fc->ir_fc);
2009 BT_ASSERT_DBG(bt_field_class_type_is(type, BT_FIELD_CLASS_TYPE_REAL));
2010
2011 if (type == BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL) {
2012 bt_field_real_single_precision_set_value(field, (float) value);
2013 } else {
2014 bt_field_real_double_precision_set_value(field, value);
2015 }
2016 stack_top(msg_it->stack)->index++;
2017
2018 end:
2019 return status;
2020 }
2021
2022 static enum bt_bfcr_status bfcr_string_begin_cb(struct ctf_field_class *fc, void *data)
2023 {
2024 bt_field *field = NULL;
2025 ctf_msg_iter *msg_it = (ctf_msg_iter *) data;
2026
2027 BT_COMP_LOGT("String (beginning) function called from BFCR: "
2028 "msg-it-addr=%p, bfcr-addr=%p, fc-addr=%p, "
2029 "fc-type=%d, fc-in-ir=%d",
2030 msg_it, msg_it->bfcr, fc, fc->type, fc->in_ir);
2031
2032 if (G_UNLIKELY(!fc->in_ir || msg_it->dry_run)) {
2033 goto end;
2034 }
2035
2036 field = borrow_next_field(msg_it);
2037 BT_ASSERT_DBG(field);
2038 BT_ASSERT_DBG(bt_field_borrow_class_const(field) == fc->ir_fc);
2039 BT_ASSERT_DBG(bt_field_get_class_type(field) == BT_FIELD_CLASS_TYPE_STRING);
2040 bt_field_string_clear(field);
2041
2042 /*
2043 * Push on stack. Not a compound class per se, but we know that
2044 * only bfcr_string_cb() may be called between this call and a
2045 * subsequent call to bfcr_string_end_cb().
2046 */
2047 stack_push(msg_it->stack, field);
2048
2049 end:
2050 return BT_BFCR_STATUS_OK;
2051 }
2052
2053 static enum bt_bfcr_status bfcr_string_cb(const char *value, size_t len, struct ctf_field_class *fc,
2054 void *data)
2055 {
2056 enum bt_bfcr_status status = BT_BFCR_STATUS_OK;
2057 bt_field *field = NULL;
2058 ctf_msg_iter *msg_it = (ctf_msg_iter *) data;
2059 bt_self_component *self_comp = msg_it->self_comp;
2060 int ret;
2061
2062 BT_COMP_LOGT("String (substring) function called from BFCR: "
2063 "msg-it-addr=%p, bfcr-addr=%p, fc-addr=%p, "
2064 "fc-type=%d, fc-in-ir=%d, string-length=%zu",
2065 msg_it, msg_it->bfcr, fc, fc->type, fc->in_ir, len);
2066
2067 if (G_UNLIKELY(!fc->in_ir || msg_it->dry_run)) {
2068 goto end;
2069 }
2070
2071 field = stack_top(msg_it->stack)->base;
2072 BT_ASSERT_DBG(field);
2073
2074 /* Append current substring */
2075 ret = bt_field_string_append_with_length(field, value, len);
2076 if (ret) {
2077 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
2078 "Cannot append substring to string field's value: "
2079 "msg-it-addr=%p, field-addr=%p, string-length=%zu, "
2080 "ret=%d",
2081 msg_it, field, len, ret);
2082 status = BT_BFCR_STATUS_ERROR;
2083 goto end;
2084 }
2085
2086 end:
2087 return status;
2088 }
2089
2090 static enum bt_bfcr_status bfcr_string_end_cb(struct ctf_field_class *fc, void *data)
2091 {
2092 ctf_msg_iter *msg_it = (ctf_msg_iter *) data;
2093
2094 BT_COMP_LOGT("String (end) function called from BFCR: "
2095 "msg-it-addr=%p, bfcr-addr=%p, fc-addr=%p, "
2096 "fc-type=%d, fc-in-ir=%d",
2097 msg_it, msg_it->bfcr, fc, fc->type, fc->in_ir);
2098
2099 if (G_UNLIKELY(!fc->in_ir || msg_it->dry_run)) {
2100 goto end;
2101 }
2102
2103 /* Pop string field */
2104 stack_pop(msg_it->stack);
2105
2106 /* Go to next field */
2107 stack_top(msg_it->stack)->index++;
2108
2109 end:
2110 return BT_BFCR_STATUS_OK;
2111 }
2112
2113 static enum bt_bfcr_status bfcr_compound_begin_cb(struct ctf_field_class *fc, void *data)
2114 {
2115 ctf_msg_iter *msg_it = (ctf_msg_iter *) data;
2116 bt_field *field;
2117
2118 BT_COMP_LOGT("Compound (beginning) function called from BFCR: "
2119 "msg-it-addr=%p, bfcr-addr=%p, fc-addr=%p, "
2120 "fc-type=%d, fc-in-ir=%d",
2121 msg_it, msg_it->bfcr, fc, fc->type, fc->in_ir);
2122
2123 if (G_UNLIKELY(!fc->in_ir || msg_it->dry_run)) {
2124 goto end;
2125 }
2126
2127 /* Borrow field */
2128 if (stack_empty(msg_it->stack)) {
2129 /* Root: already set by read_dscope_begin_state() */
2130 field = msg_it->cur_dscope_field;
2131 } else {
2132 field = borrow_next_field(msg_it);
2133 BT_ASSERT_DBG(field);
2134 }
2135
2136 /* Push field */
2137 BT_ASSERT_DBG(field);
2138 BT_ASSERT_DBG(bt_field_borrow_class_const(field) == fc->ir_fc);
2139 stack_push(msg_it->stack, field);
2140
2141 /*
2142 * Change BFCR "unsigned int" callback if it's a text
2143 * array/sequence.
2144 */
2145 if (fc->type == CTF_FIELD_CLASS_TYPE_ARRAY || fc->type == CTF_FIELD_CLASS_TYPE_SEQUENCE) {
2146 ctf_field_class_array_base *array_fc = ctf_field_class_as_array_base(fc);
2147
2148 if (array_fc->is_text) {
2149 BT_ASSERT_DBG(bt_field_get_class_type(field) == BT_FIELD_CLASS_TYPE_STRING);
2150 msg_it->done_filling_string = false;
2151 bt_field_string_clear(field);
2152 bt_bfcr_set_unsigned_int_cb(msg_it->bfcr, bfcr_unsigned_int_char_cb);
2153 }
2154 }
2155
2156 end:
2157 return BT_BFCR_STATUS_OK;
2158 }
2159
2160 static enum bt_bfcr_status bfcr_compound_end_cb(struct ctf_field_class *fc, void *data)
2161 {
2162 ctf_msg_iter *msg_it = (ctf_msg_iter *) data;
2163
2164 BT_COMP_LOGT("Compound (end) function called from BFCR: "
2165 "msg-it-addr=%p, bfcr-addr=%p, fc-addr=%p, "
2166 "fc-type=%d, fc-in-ir=%d",
2167 msg_it, msg_it->bfcr, fc, fc->type, fc->in_ir);
2168
2169 if (G_UNLIKELY(!fc->in_ir || msg_it->dry_run)) {
2170 goto end;
2171 }
2172
2173 BT_ASSERT_DBG(!stack_empty(msg_it->stack));
2174 BT_ASSERT_DBG(bt_field_borrow_class_const(stack_top(msg_it->stack)->base) == fc->ir_fc);
2175
2176 /*
2177 * Reset BFCR "unsigned int" callback if it's a text
2178 * array/sequence.
2179 */
2180 if (fc->type == CTF_FIELD_CLASS_TYPE_ARRAY || fc->type == CTF_FIELD_CLASS_TYPE_SEQUENCE) {
2181 ctf_field_class_array_base *array_fc = ctf_field_class_as_array_base(fc);
2182
2183 if (array_fc->is_text) {
2184 BT_ASSERT_DBG(bt_field_get_class_type(stack_top(msg_it->stack)->base) ==
2185 BT_FIELD_CLASS_TYPE_STRING);
2186 bt_bfcr_set_unsigned_int_cb(msg_it->bfcr, bfcr_unsigned_int_cb);
2187 }
2188 }
2189
2190 /* Pop stack */
2191 stack_pop(msg_it->stack);
2192
2193 /* If the stack is not empty, increment the base's index */
2194 if (!stack_empty(msg_it->stack)) {
2195 stack_top(msg_it->stack)->index++;
2196 }
2197
2198 end:
2199 return BT_BFCR_STATUS_OK;
2200 }
2201
2202 static int64_t bfcr_get_sequence_length_cb(struct ctf_field_class *fc, void *data)
2203 {
2204 bt_field *seq_field;
2205 ctf_msg_iter *msg_it = (ctf_msg_iter *) data;
2206 bt_self_component *self_comp = msg_it->self_comp;
2207 struct ctf_field_class_sequence *seq_fc = ctf_field_class_as_sequence(fc);
2208 int64_t length;
2209 int ret;
2210
2211 length =
2212 (uint64_t) bt_g_array_index(msg_it->stored_values, uint64_t, seq_fc->stored_length_index);
2213
2214 if (G_UNLIKELY(msg_it->dry_run)) {
2215 goto end;
2216 }
2217
2218 seq_field = stack_top(msg_it->stack)->base;
2219 BT_ASSERT_DBG(seq_field);
2220
2221 /*
2222 * bfcr_get_sequence_length_cb() also gets called back for a
2223 * text sequence, but the destination field is a string field.
2224 * Only set the field's sequence length if the destination field
2225 * is a sequence field.
2226 */
2227 if (!seq_fc->base.is_text) {
2228 BT_ASSERT_DBG(bt_field_class_type_is(bt_field_get_class_type(seq_field),
2229 BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY));
2230 ret = bt_field_array_dynamic_set_length(seq_field, (uint64_t) length);
2231 if (ret) {
2232 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
2233 "Cannot set dynamic array field's length field: "
2234 "msg-it-addr=%p, field-addr=%p, "
2235 "length=%" PRIu64,
2236 msg_it, seq_field, length);
2237 length = -1;
2238 }
2239 }
2240
2241 end:
2242 return length;
2243 }
2244
2245 static struct ctf_field_class *
2246 bfcr_borrow_variant_selected_field_class_cb(struct ctf_field_class *fc, void *data)
2247 {
2248 int ret;
2249 uint64_t i;
2250 int64_t option_index = -1;
2251 ctf_msg_iter *msg_it = (ctf_msg_iter *) data;
2252 ctf_field_class_variant *var_fc = ctf_field_class_as_variant(fc);
2253 struct ctf_named_field_class *selected_option = NULL;
2254 bt_self_component *self_comp = msg_it->self_comp;
2255 struct ctf_field_class *ret_fc = NULL;
2256 union
2257 {
2258 uint64_t u;
2259 int64_t i;
2260 } tag;
2261
2262 /* Get variant's tag */
2263 tag.u = bt_g_array_index(msg_it->stored_values, uint64_t, var_fc->stored_tag_index);
2264
2265 /*
2266 * Check each range to find the selected option's index.
2267 */
2268 if (var_fc->tag_fc->base.is_signed) {
2269 for (i = 0; i < var_fc->ranges->len; i++) {
2270 struct ctf_field_class_variant_range *range =
2271 ctf_field_class_variant_borrow_range_by_index(var_fc, i);
2272
2273 if (tag.i >= range->range.lower.i && tag.i <= range->range.upper.i) {
2274 option_index = (int64_t) range->option_index;
2275 break;
2276 }
2277 }
2278 } else {
2279 for (i = 0; i < var_fc->ranges->len; i++) {
2280 struct ctf_field_class_variant_range *range =
2281 ctf_field_class_variant_borrow_range_by_index(var_fc, i);
2282
2283 if (tag.u >= range->range.lower.u && tag.u <= range->range.upper.u) {
2284 option_index = (int64_t) range->option_index;
2285 break;
2286 }
2287 }
2288 }
2289
2290 if (option_index < 0) {
2291 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
2292 "Cannot find variant field class's option: "
2293 "msg-it-addr=%p, var-fc-addr=%p, u-tag=%" PRIu64 ", "
2294 "i-tag=%" PRId64,
2295 msg_it, var_fc, tag.u, tag.i);
2296 ret_fc = NULL;
2297 goto end;
2298 }
2299
2300 selected_option =
2301 ctf_field_class_variant_borrow_option_by_index(var_fc, (uint64_t) option_index);
2302
2303 if (selected_option->fc->in_ir && !msg_it->dry_run) {
2304 bt_field *var_field = stack_top(msg_it->stack)->base;
2305
2306 ret = bt_field_variant_select_option_by_index(var_field, option_index);
2307 if (ret) {
2308 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
2309 "Cannot select variant field's option field: "
2310 "msg-it-addr=%p, var-field-addr=%p, "
2311 "opt-index=%" PRId64,
2312 msg_it, var_field, option_index);
2313 ret_fc = NULL;
2314 goto end;
2315 }
2316 }
2317
2318 ret_fc = selected_option->fc;
2319
2320 end:
2321 return ret_fc;
2322 }
2323
2324 static bt_message *create_msg_stream_beginning(struct ctf_msg_iter *msg_it)
2325 {
2326 bt_self_component *self_comp = msg_it->self_comp;
2327 bt_message *msg;
2328
2329 BT_ASSERT(msg_it->stream);
2330 BT_ASSERT(msg_it->self_msg_iter);
2331 msg = bt_message_stream_beginning_create(msg_it->self_msg_iter, msg_it->stream);
2332 if (!msg) {
2333 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
2334 "Cannot create stream beginning message: "
2335 "msg-it-addr=%p, stream-addr=%p",
2336 msg_it, msg_it->stream);
2337 }
2338
2339 return msg;
2340 }
2341
2342 static bt_message *create_msg_stream_end(struct ctf_msg_iter *msg_it)
2343 {
2344 bt_self_component *self_comp = msg_it->self_comp;
2345 bt_message *msg;
2346
2347 if (!msg_it->stream) {
2348 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
2349 "Cannot create stream end message because stream is NULL: "
2350 "msg-it-addr=%p",
2351 msg_it);
2352 msg = NULL;
2353 goto end;
2354 }
2355
2356 BT_ASSERT(msg_it->self_msg_iter);
2357 msg = bt_message_stream_end_create(msg_it->self_msg_iter, msg_it->stream);
2358 if (!msg) {
2359 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
2360 "Cannot create stream end message: "
2361 "msg-it-addr=%p, stream-addr=%p",
2362 msg_it, msg_it->stream);
2363 }
2364
2365 end:
2366 return msg;
2367 }
2368
2369 static bt_message *create_msg_packet_beginning(struct ctf_msg_iter *msg_it, bool use_default_cs)
2370 {
2371 bt_self_component *self_comp = msg_it->self_comp;
2372 bt_message *msg;
2373 const bt_stream_class *sc = msg_it->meta.sc->ir_sc;
2374
2375 BT_ASSERT(msg_it->packet);
2376 BT_ASSERT(sc);
2377 BT_ASSERT(msg_it->self_msg_iter);
2378
2379 if (msg_it->meta.sc->packets_have_ts_begin) {
2380 BT_ASSERT(msg_it->snapshots.beginning_clock != UINT64_C(-1));
2381 uint64_t raw_cs_value;
2382
2383 /*
2384 * Either use the decoded packet `timestamp_begin` field or the
2385 * current stream's default clock_snapshot.
2386 */
2387 if (use_default_cs) {
2388 raw_cs_value = msg_it->default_clock_snapshot;
2389 } else {
2390 raw_cs_value = msg_it->snapshots.beginning_clock;
2391 }
2392
2393 msg = bt_message_packet_beginning_create_with_default_clock_snapshot(
2394 msg_it->self_msg_iter, msg_it->packet, raw_cs_value);
2395 } else {
2396 msg = bt_message_packet_beginning_create(msg_it->self_msg_iter, msg_it->packet);
2397 }
2398
2399 if (!msg) {
2400 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
2401 "Cannot create packet beginning message: "
2402 "msg-it-addr=%p, packet-addr=%p",
2403 msg_it, msg_it->packet);
2404 goto end;
2405 }
2406
2407 end:
2408 return msg;
2409 }
2410
2411 static bt_message *emit_delayed_packet_beg_msg(struct ctf_msg_iter *msg_it)
2412 {
2413 bool packet_beg_ts_need_fix_up;
2414
2415 msg_it->emit_delayed_packet_beginning_msg = false;
2416
2417 /*
2418 * Only fix the packet's timestamp_begin if it's larger than the first
2419 * event of the packet. If there was no event in the packet, the
2420 * `default_clock_snapshot` field will be either equal or greater than
2421 * `snapshots.beginning_clock` so there is not fix needed.
2422 */
2423 packet_beg_ts_need_fix_up = msg_it->default_clock_snapshot < msg_it->snapshots.beginning_clock;
2424
2425 /* create_msg_packet_beginning() logs errors */
2426 return create_msg_packet_beginning(msg_it, packet_beg_ts_need_fix_up);
2427 }
2428
2429 static bt_message *create_msg_packet_end(struct ctf_msg_iter *msg_it)
2430 {
2431 bt_message *msg;
2432 bool update_default_cs = true;
2433 bt_self_component *self_comp = msg_it->self_comp;
2434
2435 if (!msg_it->packet) {
2436 msg = NULL;
2437 goto end;
2438 }
2439
2440 /*
2441 * Check if we need to emit the delayed packet
2442 * beginning message instead of the packet end message.
2443 */
2444 if (G_UNLIKELY(msg_it->emit_delayed_packet_beginning_msg)) {
2445 msg = emit_delayed_packet_beg_msg(msg_it);
2446 /* Don't forget to emit the packet end message. */
2447 msg_it->state = STATE_EMIT_QUEUED_MSG_PACKET_END;
2448 goto end;
2449 }
2450
2451 /* Check if may be affected by lttng-crash timestamp_end quirk. */
2452 if (G_UNLIKELY(msg_it->meta.tc->quirks.lttng_crash)) {
2453 /*
2454 * Check if the `timestamp_begin` field is non-zero but
2455 * `timestamp_end` is zero. It means the trace is affected by
2456 * the lttng-crash packet `timestamp_end` quirk and must be
2457 * fixed up by omitting to update the default clock snapshot to
2458 * the `timestamp_end` as is typically done.
2459 */
2460 if (msg_it->snapshots.beginning_clock != 0 && msg_it->snapshots.end_clock == 0) {
2461 update_default_cs = false;
2462 }
2463 }
2464
2465 /*
2466 * Check if may be affected by lttng event-after-packet `timestamp_end`
2467 * quirk.
2468 */
2469 if (msg_it->meta.tc->quirks.lttng_event_after_packet) {
2470 /*
2471 * Check if `timestamp_end` is smaller then the current
2472 * default_clock_snapshot (which is set to the last event
2473 * decoded). It means the trace is affected by the lttng
2474 * `event-after-packet` packet `timestamp_end` quirk and must
2475 * be fixed up by omitting to update the default clock snapshot
2476 * to the `timestamp_end` as is typically done.
2477 */
2478 if (msg_it->snapshots.end_clock < msg_it->default_clock_snapshot) {
2479 update_default_cs = false;
2480 }
2481 }
2482
2483 /* Update default clock from packet's end time. */
2484 if (msg_it->snapshots.end_clock != UINT64_C(-1) && update_default_cs) {
2485 msg_it->default_clock_snapshot = msg_it->snapshots.end_clock;
2486 }
2487
2488 BT_ASSERT(msg_it->self_msg_iter);
2489
2490 if (msg_it->meta.sc->packets_have_ts_end) {
2491 BT_ASSERT(msg_it->snapshots.end_clock != UINT64_C(-1));
2492 msg = bt_message_packet_end_create_with_default_clock_snapshot(
2493 msg_it->self_msg_iter, msg_it->packet, msg_it->default_clock_snapshot);
2494 } else {
2495 msg = bt_message_packet_end_create(msg_it->self_msg_iter, msg_it->packet);
2496 }
2497
2498 if (!msg) {
2499 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
2500 "Cannot create packet end message: "
2501 "msg-it-addr=%p, packet-addr=%p",
2502 msg_it, msg_it->packet);
2503 goto end;
2504 }
2505
2506 BT_PACKET_PUT_REF_AND_RESET(msg_it->packet);
2507
2508 end:
2509 return msg;
2510 }
2511
2512 static bt_message *create_msg_discarded_events(struct ctf_msg_iter *msg_it)
2513 {
2514 bt_message *msg;
2515 bt_self_component *self_comp = msg_it->self_comp;
2516 uint64_t beginning_raw_value = UINT64_C(-1);
2517 uint64_t end_raw_value = UINT64_C(-1);
2518
2519 BT_ASSERT(msg_it->self_msg_iter);
2520 BT_ASSERT(msg_it->stream);
2521 BT_ASSERT(msg_it->meta.sc->has_discarded_events);
2522
2523 if (msg_it->meta.sc->discarded_events_have_default_cs) {
2524 if (msg_it->prev_packet_snapshots.discarded_events == UINT64_C(-1)) {
2525 /*
2526 * We discarded events, but before (and possibly
2527 * including) the current packet: use this packet's time
2528 * range, and do not have a specific count.
2529 */
2530 beginning_raw_value = msg_it->snapshots.beginning_clock;
2531 end_raw_value = msg_it->snapshots.end_clock;
2532 } else {
2533 beginning_raw_value = msg_it->prev_packet_snapshots.end_clock;
2534 end_raw_value = msg_it->snapshots.end_clock;
2535 }
2536
2537 BT_ASSERT(beginning_raw_value != UINT64_C(-1));
2538 BT_ASSERT(end_raw_value != UINT64_C(-1));
2539 msg = bt_message_discarded_events_create_with_default_clock_snapshots(
2540 msg_it->self_msg_iter, msg_it->stream, beginning_raw_value, end_raw_value);
2541 } else {
2542 msg = bt_message_discarded_events_create(msg_it->self_msg_iter, msg_it->stream);
2543 }
2544
2545 if (!msg) {
2546 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
2547 "Cannot create discarded events message: "
2548 "msg-it-addr=%p, stream-addr=%p",
2549 msg_it, msg_it->stream);
2550 goto end;
2551 }
2552
2553 if (msg_it->prev_packet_snapshots.discarded_events != UINT64_C(-1)) {
2554 bt_message_discarded_events_set_count(msg,
2555 msg_it->snapshots.discarded_events -
2556 msg_it->prev_packet_snapshots.discarded_events);
2557 }
2558
2559 end:
2560 return msg;
2561 }
2562
2563 static bt_message *create_msg_discarded_packets(struct ctf_msg_iter *msg_it)
2564 {
2565 bt_message *msg;
2566 bt_self_component *self_comp = msg_it->self_comp;
2567
2568 BT_ASSERT(msg_it->self_msg_iter);
2569 BT_ASSERT(msg_it->stream);
2570 BT_ASSERT(msg_it->meta.sc->has_discarded_packets);
2571 BT_ASSERT(msg_it->prev_packet_snapshots.packets != UINT64_C(-1));
2572
2573 if (msg_it->meta.sc->discarded_packets_have_default_cs) {
2574 BT_ASSERT(msg_it->prev_packet_snapshots.end_clock != UINT64_C(-1));
2575 BT_ASSERT(msg_it->snapshots.beginning_clock != UINT64_C(-1));
2576 msg = bt_message_discarded_packets_create_with_default_clock_snapshots(
2577 msg_it->self_msg_iter, msg_it->stream, msg_it->prev_packet_snapshots.end_clock,
2578 msg_it->snapshots.beginning_clock);
2579 } else {
2580 msg = bt_message_discarded_packets_create(msg_it->self_msg_iter, msg_it->stream);
2581 }
2582
2583 if (!msg) {
2584 BT_COMP_LOGE_APPEND_CAUSE(self_comp,
2585 "Cannot create discarded packets message: "
2586 "msg-it-addr=%p, stream-addr=%p",
2587 msg_it, msg_it->stream);
2588 goto end;
2589 }
2590
2591 bt_message_discarded_packets_set_count(msg, msg_it->snapshots.packets -
2592 msg_it->prev_packet_snapshots.packets - 1);
2593
2594 end:
2595 return msg;
2596 }
2597
2598 struct ctf_msg_iter *ctf_msg_iter_create(struct ctf_trace_class *tc, size_t max_request_sz,
2599 struct ctf_msg_iter_medium_ops medops, void *data,
2600 bt_logging_level log_level, bt_self_component *self_comp,
2601 bt_self_message_iterator *self_msg_iter)
2602 {
2603 struct ctf_msg_iter *msg_it = NULL;
2604 struct bt_bfcr_cbs cbs = {
2605 .classes =
2606 {
2607 .signed_int = bfcr_signed_int_cb,
2608 .unsigned_int = bfcr_unsigned_int_cb,
2609 .floating_point = bfcr_floating_point_cb,
2610 .string_begin = bfcr_string_begin_cb,
2611 .string = bfcr_string_cb,
2612 .string_end = bfcr_string_end_cb,
2613 .compound_begin = bfcr_compound_begin_cb,
2614 .compound_end = bfcr_compound_end_cb,
2615 },
2616 .query =
2617 {
2618 .get_sequence_length = bfcr_get_sequence_length_cb,
2619 .borrow_variant_selected_field_class = bfcr_borrow_variant_selected_field_class_cb,
2620 },
2621 };
2622
2623 BT_ASSERT(tc);
2624 BT_ASSERT(medops.request_bytes);
2625 BT_ASSERT(medops.borrow_stream);
2626 BT_ASSERT(max_request_sz > 0);
2627
2628 BT_COMP_LOG_CUR_LVL(BT_LOG_DEBUG, log_level, self_comp,
2629 "Creating CTF plugin message iterator: "
2630 "trace-addr=%p, max-request-size=%zu, "
2631 "data=%p, log-level=%s",
2632 tc, max_request_sz, data, bt_common_logging_level_string(log_level));
2633 msg_it = g_new0(struct ctf_msg_iter, 1);
2634 if (!msg_it) {
2635 BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
2636 "Failed to allocate one CTF plugin message iterator.");
2637 goto end;
2638 }
2639 msg_it->self_comp = self_comp;
2640 msg_it->self_msg_iter = self_msg_iter;
2641 msg_it->log_level = log_level;
2642 msg_it->meta.tc = tc;
2643 msg_it->medium.medops = medops;
2644 msg_it->medium.max_request_sz = max_request_sz;
2645 msg_it->medium.data = data;
2646 msg_it->stack = stack_new(msg_it);
2647 msg_it->stored_values = g_array_new(FALSE, TRUE, sizeof(uint64_t));
2648 g_array_set_size(msg_it->stored_values, tc->stored_value_count);
2649
2650 if (!msg_it->stack) {
2651 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to create field stack.");
2652 goto error;
2653 }
2654
2655 msg_it->bfcr = bt_bfcr_create(cbs, msg_it, log_level, NULL);
2656 if (!msg_it->bfcr) {
2657 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to create binary class reader (BFCR).");
2658 goto error;
2659 }
2660
2661 ctf_msg_iter_reset(msg_it);
2662 BT_COMP_LOGD("Created CTF plugin message iterator: "
2663 "trace-addr=%p, max-request-size=%zu, "
2664 "data=%p, msg-it-addr=%p, log-level=%s",
2665 tc, max_request_sz, data, msg_it, bt_common_logging_level_string(log_level));
2666 msg_it->cur_packet_offset = 0;
2667
2668 end:
2669 return msg_it;
2670
2671 error:
2672 ctf_msg_iter_destroy(msg_it);
2673 msg_it = NULL;
2674 goto end;
2675 }
2676
2677 void ctf_msg_iter_destroy(struct ctf_msg_iter *msg_it)
2678 {
2679 BT_PACKET_PUT_REF_AND_RESET(msg_it->packet);
2680 BT_STREAM_PUT_REF_AND_RESET(msg_it->stream);
2681 release_all_dscopes(msg_it);
2682
2683 BT_COMP_LOGD("Destroying CTF plugin message iterator: addr=%p", msg_it);
2684
2685 if (msg_it->stack) {
2686 BT_COMP_LOGD_STR("Destroying field stack.");
2687 stack_destroy(msg_it->stack);
2688 }
2689
2690 if (msg_it->bfcr) {
2691 BT_COMP_LOGD("Destroying BFCR: bfcr-addr=%p", msg_it->bfcr);
2692 bt_bfcr_destroy(msg_it->bfcr);
2693 }
2694
2695 if (msg_it->stored_values) {
2696 g_array_free(msg_it->stored_values, TRUE);
2697 }
2698
2699 g_free(msg_it);
2700 }
2701
2702 enum ctf_msg_iter_status ctf_msg_iter_get_next_message(struct ctf_msg_iter *msg_it,
2703 const bt_message **message)
2704 {
2705 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
2706 bt_self_component *self_comp = msg_it->self_comp;
2707
2708 BT_ASSERT_DBG(msg_it);
2709 BT_ASSERT_DBG(message);
2710 BT_COMP_LOGD("Getting next message: msg-it-addr=%p", msg_it);
2711
2712 while (true) {
2713 status = handle_state(msg_it);
2714 if (G_UNLIKELY(status == CTF_MSG_ITER_STATUS_AGAIN)) {
2715 BT_COMP_LOGD_STR("Medium returned CTF_MSG_ITER_STATUS_AGAIN.");
2716 goto end;
2717 } else if (G_UNLIKELY(status != CTF_MSG_ITER_STATUS_OK)) {
2718 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot handle state: msg-it-addr=%p, state=%s",
2719 msg_it, state_string(msg_it->state));
2720 goto end;
2721 }
2722
2723 switch (msg_it->state) {
2724 case STATE_EMIT_MSG_EVENT:
2725 BT_ASSERT_DBG(msg_it->event_msg);
2726
2727 /*
2728 * Check if we need to emit the delayed packet
2729 * beginning message instead of the event message.
2730 */
2731 if (G_UNLIKELY(msg_it->emit_delayed_packet_beginning_msg)) {
2732 *message = emit_delayed_packet_beg_msg(msg_it);
2733 if (!*message) {
2734 status = CTF_MSG_ITER_STATUS_ERROR;
2735 }
2736
2737 /*
2738 * Don't forget to emit the event message of
2739 * the event record that was just decoded.
2740 */
2741 msg_it->state = STATE_EMIT_QUEUED_MSG_EVENT;
2742
2743 } else {
2744 *message = msg_it->event_msg;
2745 msg_it->event_msg = NULL;
2746 }
2747 goto end;
2748 case STATE_EMIT_MSG_DISCARDED_EVENTS:
2749 /* create_msg_discared_events() logs errors */
2750 *message = create_msg_discarded_events(msg_it);
2751
2752 if (!*message) {
2753 status = CTF_MSG_ITER_STATUS_ERROR;
2754 }
2755
2756 goto end;
2757 case STATE_EMIT_MSG_DISCARDED_PACKETS:
2758 /* create_msg_discared_packets() logs errors */
2759 *message = create_msg_discarded_packets(msg_it);
2760
2761 if (!*message) {
2762 status = CTF_MSG_ITER_STATUS_ERROR;
2763 }
2764
2765 goto end;
2766 case STATE_EMIT_MSG_PACKET_BEGINNING:
2767 if (G_UNLIKELY(msg_it->meta.tc->quirks.barectf_event_before_packet)) {
2768 msg_it->emit_delayed_packet_beginning_msg = true;
2769 /*
2770 * There is no message to return yet as this
2771 * packet beginning message is delayed until we
2772 * decode the first event message of the
2773 * packet.
2774 */
2775 break;
2776 } else {
2777 /* create_msg_packet_beginning() logs errors */
2778 *message = create_msg_packet_beginning(msg_it, false);
2779 if (!*message) {
2780 status = CTF_MSG_ITER_STATUS_ERROR;
2781 }
2782 }
2783
2784 goto end;
2785 case STATE_EMIT_MSG_PACKET_END_SINGLE:
2786 case STATE_EMIT_MSG_PACKET_END_MULTI:
2787 /* create_msg_packet_end() logs errors */
2788 *message = create_msg_packet_end(msg_it);
2789
2790 if (!*message) {
2791 status = CTF_MSG_ITER_STATUS_ERROR;
2792 }
2793
2794 goto end;
2795 case STATE_EMIT_MSG_STREAM_BEGINNING:
2796 /* create_msg_stream_beginning() logs errors */
2797 *message = create_msg_stream_beginning(msg_it);
2798 msg_it->emit_stream_beginning_message = false;
2799 msg_it->emit_stream_end_message = true;
2800
2801 if (!*message) {
2802 status = CTF_MSG_ITER_STATUS_ERROR;
2803 }
2804
2805 goto end;
2806 case STATE_EMIT_MSG_STREAM_END:
2807 /* create_msg_stream_end() logs errors */
2808 *message = create_msg_stream_end(msg_it);
2809 msg_it->emit_stream_end_message = false;
2810
2811 if (!*message) {
2812 status = CTF_MSG_ITER_STATUS_ERROR;
2813 }
2814
2815 goto end;
2816 case STATE_DONE:
2817 status = CTF_MSG_ITER_STATUS_EOF;
2818 goto end;
2819 default:
2820 /* Non-emitting state: continue */
2821 break;
2822 }
2823 }
2824
2825 end:
2826 return status;
2827 }
2828
2829 static enum ctf_msg_iter_status decode_until_state(struct ctf_msg_iter *msg_it,
2830 enum state target_state_1,
2831 enum state target_state_2)
2832 {
2833 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
2834 bt_self_component *self_comp = msg_it->self_comp;
2835
2836 BT_ASSERT_DBG(msg_it);
2837
2838 do {
2839 /*
2840 * Check if we reached the state at which we want to stop
2841 * decoding.
2842 */
2843 if (msg_it->state == target_state_1 || msg_it->state == target_state_2) {
2844 goto end;
2845 }
2846
2847 status = handle_state(msg_it);
2848 if (G_UNLIKELY(status == CTF_MSG_ITER_STATUS_AGAIN)) {
2849 BT_COMP_LOGD_STR("Medium returned CTF_MSG_ITER_STATUS_AGAIN.");
2850 goto end;
2851 } else if (G_UNLIKELY(status != CTF_MSG_ITER_STATUS_OK)) {
2852 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Cannot handle state: msg-it-addr=%p, state=%s",
2853 msg_it, state_string(msg_it->state));
2854 goto end;
2855 }
2856
2857 switch (msg_it->state) {
2858 case STATE_INIT:
2859 case STATE_SWITCH_PACKET:
2860 case STATE_DSCOPE_TRACE_PACKET_HEADER_BEGIN:
2861 case STATE_DSCOPE_TRACE_PACKET_HEADER_CONTINUE:
2862 case STATE_AFTER_TRACE_PACKET_HEADER:
2863 case STATE_DSCOPE_STREAM_PACKET_CONTEXT_BEGIN:
2864 case STATE_DSCOPE_STREAM_PACKET_CONTEXT_CONTINUE:
2865 case STATE_AFTER_STREAM_PACKET_CONTEXT:
2866 case STATE_EMIT_MSG_STREAM_BEGINNING:
2867 case STATE_CHECK_EMIT_MSG_DISCARDED_EVENTS:
2868 case STATE_EMIT_MSG_DISCARDED_EVENTS:
2869 case STATE_CHECK_EMIT_MSG_DISCARDED_PACKETS:
2870 case STATE_EMIT_MSG_DISCARDED_PACKETS:
2871 case STATE_EMIT_MSG_PACKET_BEGINNING:
2872 case STATE_DSCOPE_EVENT_HEADER_BEGIN:
2873 case STATE_DSCOPE_EVENT_HEADER_CONTINUE:
2874 case STATE_AFTER_EVENT_HEADER:
2875 case STATE_DSCOPE_EVENT_COMMON_CONTEXT_BEGIN:
2876 case STATE_DSCOPE_EVENT_COMMON_CONTEXT_CONTINUE:
2877 case STATE_DSCOPE_EVENT_SPEC_CONTEXT_BEGIN:
2878 case STATE_DSCOPE_EVENT_SPEC_CONTEXT_CONTINUE:
2879 case STATE_DSCOPE_EVENT_PAYLOAD_BEGIN:
2880 case STATE_DSCOPE_EVENT_PAYLOAD_CONTINUE:
2881 case STATE_EMIT_MSG_EVENT:
2882 case STATE_EMIT_QUEUED_MSG_EVENT:
2883 case STATE_SKIP_PACKET_PADDING:
2884 case STATE_EMIT_MSG_PACKET_END_MULTI:
2885 case STATE_EMIT_MSG_PACKET_END_SINGLE:
2886 case STATE_EMIT_QUEUED_MSG_PACKET_END:
2887 case STATE_EMIT_MSG_STREAM_END:
2888 break;
2889 case STATE_DONE:
2890 /* fall-through */
2891 default:
2892 /* We should never get to the STATE_DONE state. */
2893 BT_COMP_LOGF("Unexpected state: msg-it-addr=%p, state=%s", msg_it,
2894 state_string(msg_it->state));
2895 bt_common_abort();
2896 }
2897 } while (true);
2898
2899 end:
2900 return status;
2901 }
2902
2903 static enum ctf_msg_iter_status read_packet_header_context_fields(struct ctf_msg_iter *msg_it)
2904 {
2905 int ret;
2906 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
2907
2908 status = decode_until_state(msg_it, STATE_EMIT_MSG_PACKET_BEGINNING, (state) -1);
2909 if (status != CTF_MSG_ITER_STATUS_OK) {
2910 goto end;
2911 }
2912
2913 ret = set_current_packet_content_sizes(msg_it);
2914 if (ret) {
2915 status = CTF_MSG_ITER_STATUS_ERROR;
2916 goto end;
2917 }
2918
2919 end:
2920 return status;
2921 }
2922
2923 enum ctf_msg_iter_status ctf_msg_iter_seek(struct ctf_msg_iter *msg_it, off_t offset)
2924 {
2925 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
2926 enum ctf_msg_iter_medium_status medium_status;
2927
2928 BT_ASSERT(msg_it);
2929 BT_ASSERT(offset >= 0);
2930 BT_ASSERT(msg_it->medium.medops.seek);
2931
2932 medium_status = msg_it->medium.medops.seek(offset, msg_it->medium.data);
2933 if (medium_status != CTF_MSG_ITER_MEDIUM_STATUS_OK) {
2934 if (medium_status == CTF_MSG_ITER_MEDIUM_STATUS_EOF) {
2935 status = CTF_MSG_ITER_STATUS_EOF;
2936 } else {
2937 status = CTF_MSG_ITER_STATUS_ERROR;
2938 goto end;
2939 }
2940 }
2941
2942 ctf_msg_iter_reset(msg_it);
2943 msg_it->cur_packet_offset = offset;
2944
2945 end:
2946 return status;
2947 }
2948
2949 static enum ctf_msg_iter_status clock_snapshot_at_msg_iter_state(struct ctf_msg_iter *msg_it,
2950 enum state target_state_1,
2951 enum state target_state_2,
2952 uint64_t *clock_snapshot)
2953 {
2954 enum ctf_msg_iter_status status = CTF_MSG_ITER_STATUS_OK;
2955
2956 BT_ASSERT_DBG(msg_it);
2957 BT_ASSERT_DBG(clock_snapshot);
2958 status = decode_until_state(msg_it, target_state_1, target_state_2);
2959 if (status != CTF_MSG_ITER_STATUS_OK) {
2960 goto end;
2961 }
2962
2963 *clock_snapshot = msg_it->default_clock_snapshot;
2964 end:
2965 return status;
2966 }
2967
2968 enum ctf_msg_iter_status
2969 ctf_msg_iter_curr_packet_first_event_clock_snapshot(struct ctf_msg_iter *msg_it,
2970 uint64_t *first_clock_snapshot)
2971 {
2972 return clock_snapshot_at_msg_iter_state(msg_it, STATE_AFTER_EVENT_HEADER, (state) -1,
2973 first_clock_snapshot);
2974 }
2975
2976 enum ctf_msg_iter_status
2977 ctf_msg_iter_curr_packet_last_event_clock_snapshot(struct ctf_msg_iter *msg_it,
2978 uint64_t *last_clock_snapshot)
2979 {
2980 return clock_snapshot_at_msg_iter_state(msg_it, STATE_EMIT_MSG_PACKET_END_SINGLE,
2981 STATE_EMIT_MSG_PACKET_END_MULTI, last_clock_snapshot);
2982 }
2983
2984 enum ctf_msg_iter_status
2985 ctf_msg_iter_get_packet_properties(struct ctf_msg_iter *msg_it,
2986 struct ctf_msg_iter_packet_properties *props)
2987 {
2988 enum ctf_msg_iter_status status;
2989
2990 BT_ASSERT_DBG(msg_it);
2991 BT_ASSERT_DBG(props);
2992 status = read_packet_header_context_fields(msg_it);
2993 if (status != CTF_MSG_ITER_STATUS_OK) {
2994 goto end;
2995 }
2996
2997 props->exp_packet_total_size = msg_it->cur_exp_packet_total_size;
2998 props->exp_packet_content_size = msg_it->cur_exp_packet_content_size;
2999 props->stream_class_id = (uint64_t) msg_it->cur_stream_class_id;
3000 props->data_stream_id = msg_it->cur_data_stream_id;
3001 props->snapshots.discarded_events = msg_it->snapshots.discarded_events;
3002 props->snapshots.packets = msg_it->snapshots.packets;
3003 props->snapshots.beginning_clock = msg_it->snapshots.beginning_clock;
3004 props->snapshots.end_clock = msg_it->snapshots.end_clock;
3005
3006 end:
3007 return status;
3008 }
3009
3010 void ctf_msg_iter_set_dry_run(struct ctf_msg_iter *msg_it, bool val)
3011 {
3012 msg_it->dry_run = val;
3013 }
BabelTrace - Trace Format Babel Tower
This page took 0.151829 seconds and 4 git commands to generate.