4 * Babeltrace trace IR - Stream packet
6 * Copyright 2016 Philippe Proulx <pproulx@efficios.com>
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27 #define BT_LOG_TAG "PACKET"
28 #include <babeltrace/lib-logging-internal.h>
30 #include <babeltrace/assert-pre-internal.h>
31 #include <babeltrace/trace-ir/fields-internal.h>
32 #include <babeltrace/trace-ir/packet.h>
33 #include <babeltrace/trace-ir/packet-internal.h>
34 #include <babeltrace/trace-ir/field-wrapper-internal.h>
35 #include <babeltrace/trace-ir/trace.h>
36 #include <babeltrace/trace-ir/stream-class-internal.h>
37 #include <babeltrace/trace-ir/stream-class.h>
38 #include <babeltrace/trace-ir/stream.h>
39 #include <babeltrace/trace-ir/stream-internal.h>
40 #include <babeltrace/trace-ir/clock-value-internal.h>
41 #include <babeltrace/trace-ir/trace-internal.h>
42 #include <babeltrace/object-internal.h>
43 #include <babeltrace/ref.h>
44 #include <babeltrace/assert-internal.h>
47 #define BT_ASSERT_PRE_PACKET_HOT(_packet) \
48 BT_ASSERT_PRE_HOT((_packet), "Packet", ": %!+a", (_packet))
50 struct bt_stream
*bt_packet_borrow_stream(struct bt_packet
*packet
)
52 BT_ASSERT_PRE_NON_NULL(packet
, "Packet");
53 return packet
->stream
;
56 struct bt_field
*bt_packet_borrow_header_field(struct bt_packet
*packet
)
58 BT_ASSERT_PRE_NON_NULL(packet
, "Packet");
59 return packet
->header_field
? packet
->header_field
->field
: NULL
;
62 struct bt_field
*bt_packet_borrow_context_field(struct bt_packet
*packet
)
64 BT_ASSERT_PRE_NON_NULL(packet
, "Packet");
65 return packet
->context_field
? packet
->context_field
->field
: NULL
;
69 void _bt_packet_set_is_frozen(struct bt_packet
*packet
, bool is_frozen
)
75 BT_LIB_LOGD("Setting packet's frozen state: %![packet-]+a, "
76 "is-frozen=%d", packet
, is_frozen
);
78 if (packet
->header_field
) {
79 BT_LOGD_STR("Setting packet's header field's frozen state.");
80 bt_field_set_is_frozen(packet
->header_field
->field
,
84 if (packet
->context_field
) {
85 BT_LOGD_STR("Setting packet's context field's frozen state.");
86 bt_field_set_is_frozen(packet
->context_field
->field
,
90 packet
->frozen
= is_frozen
;
94 void reset_counter_snapshots(struct bt_packet
*packet
)
96 packet
->discarded_event_counter_snapshot
.base
.avail
=
97 BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE
;
98 packet
->packet_counter_snapshot
.base
.avail
=
99 BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE
;
103 void reset_packet(struct bt_packet
*packet
)
106 BT_LIB_LOGD("Resetting packet: %!+a", packet
);
107 bt_packet_set_is_frozen(packet
, false);
109 if (packet
->header_field
) {
110 bt_field_set_is_frozen(packet
->header_field
->field
, false);
111 bt_field_reset(packet
->header_field
->field
);
114 if (packet
->context_field
) {
115 bt_field_set_is_frozen(packet
->context_field
->field
, false);
116 bt_field_reset(packet
->context_field
->field
);
119 if (packet
->default_beginning_cv
) {
120 bt_clock_value_reset(packet
->default_beginning_cv
);
123 if (packet
->default_end_cv
) {
124 bt_clock_value_reset(packet
->default_end_cv
);
127 reset_counter_snapshots(packet
);
131 void recycle_header_field(struct bt_field_wrapper
*header_field
,
132 struct bt_trace
*trace
)
134 BT_ASSERT(header_field
);
135 BT_LIB_LOGD("Recycling packet header field: "
136 "addr=%p, %![trace-]+t, %![field-]+f", header_field
,
137 trace
, header_field
->field
);
138 bt_object_pool_recycle_object(&trace
->packet_header_field_pool
,
143 void recycle_context_field(struct bt_field_wrapper
*context_field
,
144 struct bt_stream_class
*stream_class
)
146 BT_ASSERT(context_field
);
147 BT_LIB_LOGD("Recycling packet context field: "
148 "addr=%p, %![sc-]+S, %![field-]+f", context_field
,
149 stream_class
, context_field
->field
);
150 bt_object_pool_recycle_object(&stream_class
->packet_context_field_pool
,
155 void bt_packet_recycle(struct bt_packet
*packet
)
157 struct bt_stream
*stream
;
160 BT_LIB_LOGD("Recycling packet: %!+a", packet
);
163 * Those are the important ordered steps:
165 * 1. Reset the packet object (put any permanent reference it
166 * has, unfreeze it and its fields in developer mode, etc.),
167 * but do NOT put its stream's reference. This stream
168 * contains the pool to which we're about to recycle this
169 * packet object, so we must guarantee its existence thanks
170 * to this existing reference.
172 * 2. Move the stream reference to our `stream`
173 * variable so that we can set the packet's stream member
174 * to NULL before recycling it. We CANNOT do this after
175 * we put the stream reference because this bt_put()
176 * could destroy the stream, also destroying its
177 * packet pool, thus also destroying our packet object (this
178 * would result in an invalid write access).
180 * 3. Recycle the packet object.
182 * 4. Put our stream reference.
184 reset_packet(packet
);
185 stream
= packet
->stream
;
187 packet
->stream
= NULL
;
188 bt_object_pool_recycle_object(&stream
->packet_pool
, packet
);
189 bt_object_put_no_null_check(&stream
->base
);
193 void bt_packet_destroy(struct bt_packet
*packet
)
195 BT_LIB_LOGD("Destroying packet: %!+a", packet
);
197 if (packet
->header_field
) {
198 if (packet
->stream
) {
199 BT_LOGD_STR("Recycling packet's header field.");
200 recycle_header_field(packet
->header_field
,
201 bt_stream_class_borrow_trace_inline(
202 packet
->stream
->class));
204 bt_field_wrapper_destroy(packet
->header_field
);
208 if (packet
->context_field
) {
209 if (packet
->stream
) {
210 BT_LOGD_STR("Recycling packet's context field.");
211 recycle_context_field(packet
->context_field
,
212 packet
->stream
->class);
214 bt_field_wrapper_destroy(packet
->context_field
);
218 if (packet
->default_beginning_cv
) {
219 BT_LOGD_STR("Recycling beginning clock value.");
220 bt_clock_value_recycle(packet
->default_beginning_cv
);
223 if (packet
->default_end_cv
) {
224 BT_LOGD_STR("Recycling end clock value.");
225 bt_clock_value_recycle(packet
->default_end_cv
);
228 BT_LOGD_STR("Putting packet's stream.");
229 bt_put(packet
->stream
);
234 struct bt_packet
*bt_packet_new(struct bt_stream
*stream
)
236 struct bt_packet
*packet
= NULL
;
237 struct bt_trace
*trace
= NULL
;
240 BT_LIB_LOGD("Creating packet object: %![stream-]+s", stream
);
241 packet
= g_new0(struct bt_packet
, 1);
243 BT_LOGE_STR("Failed to allocate one packet object.");
247 bt_object_init_shared(&packet
->base
,
248 (bt_object_release_func
) bt_packet_recycle
);
249 packet
->stream
= bt_get(stream
);
250 trace
= bt_stream_class_borrow_trace_inline(stream
->class);
253 if (trace
->packet_header_ft
) {
254 BT_LOGD_STR("Creating initial packet header field.");
255 packet
->header_field
= bt_field_wrapper_create(
256 &trace
->packet_header_field_pool
,
257 trace
->packet_header_ft
);
258 if (!packet
->header_field
) {
259 BT_LOGE_STR("Cannot create packet header field wrapper.");
264 if (stream
->class->packet_context_ft
) {
265 BT_LOGD_STR("Creating initial packet context field.");
266 packet
->context_field
= bt_field_wrapper_create(
267 &stream
->class->packet_context_field_pool
,
268 stream
->class->packet_context_ft
);
269 if (!packet
->context_field
) {
270 BT_LOGE_STR("Cannot create packet context field wrapper.");
275 if (stream
->class->default_clock_class
) {
276 if (stream
->class->packets_have_default_beginning_cv
) {
277 packet
->default_beginning_cv
= bt_clock_value_create(
278 stream
->class->default_clock_class
);
279 if (!packet
->default_beginning_cv
) {
280 /* bt_clock_value_create() logs errors */
285 if (stream
->class->packets_have_default_end_cv
) {
286 packet
->default_end_cv
= bt_clock_value_create(
287 stream
->class->default_clock_class
);
288 if (!packet
->default_end_cv
) {
289 /* bt_clock_value_create() logs errors */
295 reset_counter_snapshots(packet
);
296 BT_LIB_LOGD("Created packet object: %!+a", packet
);
306 struct bt_packet
*bt_packet_create(struct bt_stream
*stream
)
308 struct bt_packet
*packet
= NULL
;
310 BT_ASSERT_PRE_NON_NULL(stream
, "Stream");
311 packet
= bt_object_pool_create_object(&stream
->packet_pool
);
312 if (unlikely(!packet
)) {
313 BT_LIB_LOGE("Cannot allocate one packet from stream's packet pool: "
314 "%![stream-]+s", stream
);
318 if (likely(!packet
->stream
)) {
319 packet
->stream
= stream
;
320 bt_object_get_no_null_check_no_parent_check(
321 &packet
->stream
->base
);
328 int bt_packet_move_header_field(struct bt_packet
*packet
,
329 struct bt_packet_header_field
*header_field
)
331 struct bt_trace
*trace
;
332 struct bt_field_wrapper
*field_wrapper
= (void *) header_field
;
334 BT_ASSERT_PRE_NON_NULL(packet
, "Packet");
335 BT_ASSERT_PRE_NON_NULL(field_wrapper
, "Header field");
336 BT_ASSERT_PRE_PACKET_HOT(packet
);
337 trace
= bt_stream_class_borrow_trace_inline(packet
->stream
->class);
338 BT_ASSERT_PRE(trace
->packet_header_ft
,
339 "Trace has no packet header field type: %!+t",
341 BT_ASSERT_PRE(field_wrapper
->field
->type
==
342 trace
->packet_header_ft
,
343 "Unexpected packet header field's type: "
344 "%![ft-]+F, %![expected-ft-]+F", field_wrapper
->field
->type
,
345 trace
->packet_header_ft
);
347 /* Recycle current header field: always exists */
348 BT_ASSERT(packet
->header_field
);
349 recycle_header_field(packet
->header_field
, trace
);
352 packet
->header_field
= field_wrapper
;
356 int bt_packet_move_context_field(struct bt_packet
*packet
,
357 struct bt_packet_context_field
*context_field
)
359 struct bt_stream_class
*stream_class
;
360 struct bt_field_wrapper
*field_wrapper
= (void *) context_field
;
362 BT_ASSERT_PRE_NON_NULL(packet
, "Packet");
363 BT_ASSERT_PRE_NON_NULL(field_wrapper
, "Context field");
364 BT_ASSERT_PRE_HOT(packet
, "Packet", ": %!+a", packet
);
365 stream_class
= packet
->stream
->class;
366 BT_ASSERT_PRE(stream_class
->packet_context_ft
,
367 "Stream class has no packet context field type: %!+S",
369 BT_ASSERT_PRE(field_wrapper
->field
->type
==
370 stream_class
->packet_context_ft
,
371 "Unexpected packet header field's type: "
372 "%![ft-]+F, %![expected-ft-]+F", field_wrapper
->field
->type
,
373 stream_class
->packet_context_ft
);
375 /* Recycle current context field: always exists */
376 BT_ASSERT(packet
->context_field
);
377 recycle_context_field(packet
->context_field
, stream_class
);
380 packet
->context_field
= field_wrapper
;
384 int bt_packet_set_default_beginning_clock_value(struct bt_packet
*packet
,
385 uint64_t value_cycles
)
387 struct bt_stream_class
*sc
;
389 BT_ASSERT_PRE_NON_NULL(packet
, "Packet");
390 BT_ASSERT_PRE_PACKET_HOT(packet
);
391 sc
= packet
->stream
->class;
393 BT_ASSERT_PRE(sc
->default_clock_class
,
394 "Packet's stream class has no default clock class: "
395 "%![packet-]+a, %![sc-]+S", packet
, sc
);
396 BT_ASSERT_PRE(sc
->packets_have_default_beginning_cv
,
397 "Packet's stream class indicates that its packets have "
398 "no default beginning clock value: %![packet-]+a, %![sc-]+S",
400 BT_ASSERT(packet
->default_beginning_cv
);
401 bt_clock_value_set_value_inline(packet
->default_beginning_cv
, value_cycles
);
402 BT_LIB_LOGV("Set packet's default beginning clock value: "
403 "%![packet-]+a, value=%" PRIu64
, value_cycles
);
407 enum bt_clock_value_status
bt_packet_borrow_default_beginning_clock_value(
408 struct bt_packet
*packet
, struct bt_clock_value
**clock_value
)
410 BT_ASSERT_PRE_NON_NULL(packet
, "Packet");
411 BT_ASSERT_PRE_NON_NULL(clock_value
, "Clock value (output)");
412 *clock_value
= packet
->default_beginning_cv
;
413 return BT_CLOCK_VALUE_STATUS_KNOWN
;
416 int bt_packet_set_default_end_clock_value(struct bt_packet
*packet
,
417 uint64_t value_cycles
)
419 struct bt_stream_class
*sc
;
421 BT_ASSERT_PRE_NON_NULL(packet
, "Packet");
422 BT_ASSERT_PRE_PACKET_HOT(packet
);
423 sc
= packet
->stream
->class;
425 BT_ASSERT_PRE(sc
->default_clock_class
,
426 "Packet's stream class has no default clock class: "
427 "%![packet-]+a, %![sc-]+S", packet
, sc
);
428 BT_ASSERT_PRE(sc
->packets_have_default_end_cv
,
429 "Packet's stream class indicates that its packets have "
430 "no default end clock value: %![packet-]+a, %![sc-]+S",
432 BT_ASSERT(packet
->default_end_cv
);
433 bt_clock_value_set_value_inline(packet
->default_end_cv
, value_cycles
);
434 BT_LIB_LOGV("Set packet's default end clock value: "
435 "%![packet-]+a, value=%" PRIu64
, value_cycles
);
439 enum bt_clock_value_status
bt_packet_borrow_default_end_clock_value(
440 struct bt_packet
*packet
, struct bt_clock_value
**clock_value
)
442 BT_ASSERT_PRE_NON_NULL(packet
, "Packet");
443 BT_ASSERT_PRE_NON_NULL(clock_value
, "Clock value (output)");
444 *clock_value
= packet
->default_end_cv
;
445 return BT_CLOCK_VALUE_STATUS_KNOWN
;
448 enum bt_property_availability
bt_packet_get_discarded_event_counter_snapshot(
449 struct bt_packet
*packet
, uint64_t *value
)
451 BT_ASSERT_PRE_NON_NULL(packet
, "Packet");
452 BT_ASSERT_PRE_NON_NULL(value
, "Value (output)");
453 *value
= packet
->discarded_event_counter_snapshot
.value
;
454 return packet
->discarded_event_counter_snapshot
.base
.avail
;
457 int bt_packet_set_discarded_event_counter_snapshot(struct bt_packet
*packet
,
460 BT_ASSERT_PRE_NON_NULL(packet
, "Packet");
461 BT_ASSERT_PRE_PACKET_HOT(packet
);
462 BT_ASSERT_PRE(packet
->stream
->class->packets_have_discarded_event_counter_snapshot
,
463 "Packet's stream's discarded event counter is not enabled: "
464 "%![packet-]+a", packet
);
465 bt_property_uint_set(&packet
->discarded_event_counter_snapshot
, value
);
469 enum bt_property_availability
bt_packet_get_packet_counter_snapshot(
470 struct bt_packet
*packet
, uint64_t *value
)
472 BT_ASSERT_PRE_NON_NULL(packet
, "Packet");
473 BT_ASSERT_PRE_NON_NULL(value
, "Value (output)");
474 *value
= packet
->packet_counter_snapshot
.value
;
475 return packet
->packet_counter_snapshot
.base
.avail
;
478 int bt_packet_set_packet_counter_snapshot(struct bt_packet
*packet
,
481 BT_ASSERT_PRE_NON_NULL(packet
, "Packet");
482 BT_ASSERT_PRE_PACKET_HOT(packet
);
483 BT_ASSERT_PRE(packet
->stream
->class->packets_have_packet_counter_snapshot
,
484 "Packet's stream's packet counter is not enabled: "
485 "%![packet-]+a", packet
);
486 bt_property_uint_set(&packet
->packet_counter_snapshot
, value
);