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