lib/ctf-ir/packet.c

   1 /*
   2  * packet.c
   3  *
   4  * Babeltrace CTF IR - Stream packet
   5  *
   6  * Copyright 2016 Philippe Proulx <pproulx@efficios.com>
   7  *
   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:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  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
  24  * SOFTWARE.
  25  */
  26
  27 #define BT_LOG_TAG "PACKET"
  28 #include <babeltrace/lib-logging-internal.h>
  29
  30 #include <babeltrace/assert-pre-internal.h>
  31 #include <babeltrace/ctf-ir/fields-internal.h>
  32 #include <babeltrace/ctf-ir/packet.h>
  33 #include <babeltrace/ctf-ir/packet-internal.h>
  34 #include <babeltrace/ctf-ir/field-wrapper-internal.h>
  35 #include <babeltrace/ctf-ir/trace.h>
  36 #include <babeltrace/ctf-ir/stream-class-internal.h>
  37 #include <babeltrace/ctf-ir/stream-class.h>
  38 #include <babeltrace/ctf-ir/stream.h>
  39 #include <babeltrace/ctf-ir/stream-internal.h>
  40 #include <babeltrace/ctf-ir/clock-value-internal.h>
  41 #include <babeltrace/ctf-ir/trace-internal.h>
  42 #include <babeltrace/object-internal.h>
  43 #include <babeltrace/ref.h>
  44 #include <babeltrace/assert-internal.h>
  45 #include <inttypes.h>
  46
  47 #define BT_ASSERT_PRE_PACKET_HOT(_packet) \
  48         BT_ASSERT_PRE_HOT((_packet), "Packet", ": %!+a", (_packet))
  49
  50 struct bt_stream *bt_packet_borrow_stream(struct bt_packet *packet)
  51 {
  52         BT_ASSERT_PRE_NON_NULL(packet, "Packet");
  53         return packet->stream;
  54 }
  55
  56 struct bt_field *bt_packet_borrow_header_field(struct bt_packet *packet)
  57 {
  58         BT_ASSERT_PRE_NON_NULL(packet, "Packet");
  59         return packet->header_field ? packet->header_field->field : NULL;
  60 }
  61
  62 struct bt_field *bt_packet_borrow_context_field(struct bt_packet *packet)
  63 {
  64         BT_ASSERT_PRE_NON_NULL(packet, "Packet");
  65         return packet->context_field ? packet->context_field->field : NULL;
  66 }
  67
  68 BT_HIDDEN
  69 void _bt_packet_set_is_frozen(struct bt_packet *packet, bool is_frozen)
  70 {
  71         if (!packet) {
  72                 return;
  73         }
  74
  75         BT_LIB_LOGD("Setting packet's frozen state: %![packet-]+a, "
  76                 "is-frozen=%d", packet, is_frozen);
  77
  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,
  81                         is_frozen);
  82         }
  83
  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,
  87                         is_frozen);
  88         }
  89
  90         packet->frozen = is_frozen;
  91 }
  92
  93 static inline
  94 void reset_counter_snapshots(struct bt_packet *packet)
  95 {
  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;
 100 }
 101
 102 static inline
 103 void reset_packet(struct bt_packet *packet)
 104 {
 105         BT_ASSERT(packet);
 106         BT_LIB_LOGD("Resetting packet: %!+a", packet);
 107         bt_packet_set_is_frozen(packet, false);
 108
 109         if (packet->header_field) {
 110                 bt_field_set_is_frozen(packet->header_field->field, false);
 111                 bt_field_reset(packet->header_field->field);
 112         }
 113
 114         if (packet->context_field) {
 115                 bt_field_set_is_frozen(packet->context_field->field, false);
 116                 bt_field_reset(packet->context_field->field);
 117         }
 118
 119         if (packet->default_beginning_cv) {
 120                 bt_clock_value_reset(packet->default_beginning_cv);
 121         }
 122
 123         if (packet->default_end_cv) {
 124                 bt_clock_value_reset(packet->default_end_cv);
 125         }
 126
 127         reset_counter_snapshots(packet);
 128 }
 129
 130 static
 131 void recycle_header_field(struct bt_field_wrapper *header_field,
 132                 struct bt_trace *trace)
 133 {
 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,
 139                 header_field);
 140 }
 141
 142 static
 143 void recycle_context_field(struct bt_field_wrapper *context_field,
 144                 struct bt_stream_class *stream_class)
 145 {
 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,
 151                 context_field);
 152 }
 153
 154 BT_HIDDEN
 155 void bt_packet_recycle(struct bt_packet *packet)
 156 {
 157         struct bt_stream *stream;
 158
 159         BT_ASSERT(packet);
 160         BT_LIB_LOGD("Recycling packet: %!+a", packet);
 161
 162         /*
 163          * Those are the important ordered steps:
 164          *
 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.
 171          *
 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).
 179          *
 180          * 3. Recycle the packet object.
 181          *
 182          * 4. Put our stream reference.
 183          */
 184         reset_packet(packet);
 185         stream = packet->stream;
 186         BT_ASSERT(stream);
 187         packet->stream = NULL;
 188         bt_object_pool_recycle_object(&stream->packet_pool, packet);
 189         bt_object_put_no_null_check(&stream->base);
 190 }
 191
 192 BT_HIDDEN
 193 void bt_packet_destroy(struct bt_packet *packet)
 194 {
 195         BT_LIB_LOGD("Destroying packet: %!+a", packet);
 196
 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));
 203                 } else {
 204                         bt_field_wrapper_destroy(packet->header_field);
 205                 }
 206         }
 207
 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);
 213                 } else {
 214                         bt_field_wrapper_destroy(packet->context_field);
 215                 }
 216         }
 217
 218         if (packet->default_beginning_cv) {
 219                 BT_LOGD_STR("Recycling beginning clock value.");
 220                 bt_clock_value_recycle(packet->default_beginning_cv);
 221         }
 222
 223         if (packet->default_end_cv) {
 224                 BT_LOGD_STR("Recycling end clock value.");
 225                 bt_clock_value_recycle(packet->default_end_cv);
 226         }
 227
 228         BT_LOGD_STR("Putting packet's stream.");
 229         bt_put(packet->stream);
 230         g_free(packet);
 231 }
 232
 233 BT_HIDDEN
 234 struct bt_packet *bt_packet_new(struct bt_stream *stream)
 235 {
 236         struct bt_packet *packet = NULL;
 237         struct bt_trace *trace = NULL;
 238
 239         BT_ASSERT(stream);
 240         BT_LIB_LOGD("Creating packet object: %![stream-]+s", stream);
 241         packet = g_new0(struct bt_packet, 1);
 242         if (!packet) {
 243                 BT_LOGE_STR("Failed to allocate one packet object.");
 244                 goto error;
 245         }
 246
 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);
 251         BT_ASSERT(trace);
 252
 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.");
 260                         goto error;
 261                 }
 262         }
 263
 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.");
 271                         goto error;
 272                 }
 273         }
 274
 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 */
 281                                 goto error;
 282                         }
 283                 }
 284
 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 */
 290                                 goto error;
 291                         }
 292                 }
 293         }
 294
 295         reset_counter_snapshots(packet);
 296         BT_LIB_LOGD("Created packet object: %!+a", packet);
 297         goto end;
 298
 299 error:
 300         BT_PUT(packet);
 301
 302 end:
 303         return packet;
 304 }
 305
 306 struct bt_packet *bt_packet_create(struct bt_stream *stream)
 307 {
 308         struct bt_packet *packet = NULL;
 309
 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);
 315                 goto end;
 316         }
 317
 318         if (likely(!packet->stream)) {
 319                 packet->stream = stream;
 320                 bt_object_get_no_null_check_no_parent_check(
 321                         &packet->stream->base);
 322         }
 323
 324 end:
 325         return packet;
 326 }
 327
 328 int bt_packet_move_header_field(struct bt_packet *packet,
 329                 struct bt_packet_header_field *header_field)
 330 {
 331         struct bt_trace *trace;
 332         struct bt_field_wrapper *field_wrapper = (void *) header_field;
 333
 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",
 340                 trace);
 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);
 346
 347         /* Recycle current header field: always exists */
 348         BT_ASSERT(packet->header_field);
 349         recycle_header_field(packet->header_field, trace);
 350
 351         /* Move new field */
 352         packet->header_field = field_wrapper;
 353         return 0;
 354 }
 355
 356 int bt_packet_move_context_field(struct bt_packet *packet,
 357                 struct bt_packet_context_field *context_field)
 358 {
 359         struct bt_stream_class *stream_class;
 360         struct bt_field_wrapper *field_wrapper = (void *) context_field;
 361
 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",
 368                 stream_class);
 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);
 374
 375         /* Recycle current context field: always exists */
 376         BT_ASSERT(packet->context_field);
 377         recycle_context_field(packet->context_field, stream_class);
 378
 379         /* Move new field */
 380         packet->context_field = field_wrapper;
 381         return 0;
 382 }
 383
 384 int bt_packet_set_default_beginning_clock_value(struct bt_packet *packet,
 385                 uint64_t value_cycles)
 386 {
 387         struct bt_stream_class *sc;
 388
 389         BT_ASSERT_PRE_NON_NULL(packet, "Packet");
 390         BT_ASSERT_PRE_PACKET_HOT(packet);
 391         sc = packet->stream->class;
 392         BT_ASSERT(sc);
 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",
 399                 packet, sc);
 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);
 404         return 0;
 405 }
 406
 407 enum bt_clock_value_status bt_packet_borrow_default_beginning_clock_value(
 408                 struct bt_packet *packet, struct bt_clock_value **clock_value)
 409 {
 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;
 414 }
 415
 416 int bt_packet_set_default_end_clock_value(struct bt_packet *packet,
 417                 uint64_t value_cycles)
 418 {
 419         struct bt_stream_class *sc;
 420
 421         BT_ASSERT_PRE_NON_NULL(packet, "Packet");
 422         BT_ASSERT_PRE_PACKET_HOT(packet);
 423         sc = packet->stream->class;
 424         BT_ASSERT(sc);
 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",
 431                 packet, sc);
 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);
 436         return 0;
 437 }
 438
 439 enum bt_clock_value_status bt_packet_borrow_default_end_clock_value(
 440                 struct bt_packet *packet, struct bt_clock_value **clock_value)
 441 {
 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;
 446 }
 447
 448 enum bt_property_availability bt_packet_get_discarded_event_counter_snapshot(
 449                 struct bt_packet *packet, uint64_t *value)
 450 {
 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;
 455 }
 456
 457 int bt_packet_set_discarded_event_counter_snapshot(struct bt_packet *packet,
 458                 uint64_t value)
 459 {
 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);
 466         return 0;
 467 }
 468
 469 enum bt_property_availability bt_packet_get_packet_counter_snapshot(
 470                 struct bt_packet *packet, uint64_t *value)
 471 {
 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;
 476 }
 477
 478 int bt_packet_set_packet_counter_snapshot(struct bt_packet *packet,
 479                 uint64_t value)
 480 {
 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);
 487         return 0;
 488 }