formats/ctf/ir/event.c

   1 /*
   2  * event.c
   3  *
   4  * Babeltrace CTF IR - Event
   5  *
   6  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 #include <babeltrace/ctf-ir/fields-internal.h>
  30 #include <babeltrace/ctf-ir/field-types-internal.h>
  31 #include <babeltrace/ctf-ir/clock-class.h>
  32 #include <babeltrace/ctf-ir/event-internal.h>
  33 #include <babeltrace/ctf-ir/event-class.h>
  34 #include <babeltrace/ctf-ir/event-class-internal.h>
  35 #include <babeltrace/ctf-ir/stream-class.h>
  36 #include <babeltrace/ctf-ir/stream-class-internal.h>
  37 #include <babeltrace/ctf-ir/stream-internal.h>
  38 #include <babeltrace/ctf-ir/packet.h>
  39 #include <babeltrace/ctf-ir/packet-internal.h>
  40 #include <babeltrace/ctf-ir/trace-internal.h>
  41 #include <babeltrace/ctf-ir/validation-internal.h>
  42 #include <babeltrace/ctf-ir/packet-internal.h>
  43 #include <babeltrace/ctf-ir/utils.h>
  44 #include <babeltrace/ref.h>
  45 #include <babeltrace/ctf-ir/attributes-internal.h>
  46 #include <babeltrace/compiler.h>
  47
  48 static
  49 void bt_ctf_event_destroy(struct bt_object *obj);
  50
  51 struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class)
  52 {
  53         int ret;
  54         enum bt_ctf_validation_flag validation_flags =
  55                 BT_CTF_VALIDATION_FLAG_STREAM |
  56                 BT_CTF_VALIDATION_FLAG_EVENT;
  57         struct bt_ctf_event *event = NULL;
  58         struct bt_ctf_trace *trace = NULL;
  59         struct bt_ctf_stream_class *stream_class = NULL;
  60         struct bt_ctf_field_type *packet_header_type = NULL;
  61         struct bt_ctf_field_type *packet_context_type = NULL;
  62         struct bt_ctf_field_type *event_header_type = NULL;
  63         struct bt_ctf_field_type *stream_event_ctx_type = NULL;
  64         struct bt_ctf_field_type *event_context_type = NULL;
  65         struct bt_ctf_field_type *event_payload_type = NULL;
  66         struct bt_ctf_field *event_header = NULL;
  67         struct bt_ctf_field *stream_event_context = NULL;
  68         struct bt_ctf_field *event_context = NULL;
  69         struct bt_ctf_field *event_payload = NULL;
  70         struct bt_value *environment = NULL;
  71         struct bt_ctf_validation_output validation_output = { 0 };
  72         int trace_valid = 0;
  73
  74         if (!event_class) {
  75                 goto error;
  76         }
  77
  78         stream_class = bt_ctf_event_class_get_stream_class(event_class);
  79
  80         /*
  81          * We disallow the creation of an event if its event class has not been
  82          * associated to a stream class.
  83          */
  84         if (!stream_class) {
  85                 goto error;
  86         }
  87
  88         /* A stream class should always have an existing event header type */
  89         assert(stream_class->event_header_type);
  90
  91         /* The event class was frozen when added to its stream class */
  92         assert(event_class->frozen);
  93
  94         /* Validate the trace (if any), the stream class, and the event class */
  95         trace = bt_ctf_stream_class_get_trace(stream_class);
  96         if (trace) {
  97                 packet_header_type = bt_ctf_trace_get_packet_header_type(trace);
  98                 trace_valid = trace->valid;
  99                 assert(trace_valid);
 100                 environment = trace->environment;
 101         }
 102
 103         packet_context_type = bt_ctf_stream_class_get_packet_context_type(
 104                 stream_class);
 105         event_header_type = bt_ctf_stream_class_get_event_header_type(
 106                 stream_class);
 107         stream_event_ctx_type = bt_ctf_stream_class_get_event_context_type(
 108                 stream_class);
 109         event_context_type = bt_ctf_event_class_get_context_type(event_class);
 110         event_payload_type = bt_ctf_event_class_get_payload_type(event_class);
 111         ret = bt_ctf_validate_class_types(environment, packet_header_type,
 112                 packet_context_type, event_header_type, stream_event_ctx_type,
 113                 event_context_type, event_payload_type, trace_valid,
 114                 stream_class->valid, event_class->valid,
 115                 &validation_output, validation_flags);
 116         BT_PUT(packet_header_type);
 117         BT_PUT(packet_context_type);
 118         BT_PUT(event_header_type);
 119         BT_PUT(stream_event_ctx_type);
 120         BT_PUT(event_context_type);
 121         BT_PUT(event_payload_type);
 122         if (ret) {
 123                 /*
 124                  * This means something went wrong during the validation
 125                  * process, not that the objects are invalid.
 126                  */
 127                 goto error;
 128         }
 129
 130         if ((validation_output.valid_flags & validation_flags) !=
 131                         validation_flags) {
 132                 /* Invalid trace/stream class/event class */
 133                 goto error;
 134         }
 135
 136         /*
 137          * At this point we know the trace (if associated to the stream
 138          * class), the stream class, and the event class, with their
 139          * current types, are valid. We may proceed with creating
 140          * the event.
 141          */
 142         event = g_new0(struct bt_ctf_event, 1);
 143         if (!event) {
 144                 goto error;
 145         }
 146
 147         bt_object_init(event, bt_ctf_event_destroy);
 148
 149         /*
 150          * event does not share a common ancestor with the event class; it has
 151          * to guarantee its existence by holding a reference. This reference
 152          * shall be released once the event is associated to a stream since,
 153          * from that point, the event and its class will share the same
 154          * lifetime.
 155          */
 156         event->event_class = bt_get(event_class);
 157         event->clock_values = g_hash_table_new_full(g_direct_hash,
 158                         g_direct_equal, bt_put, bt_put);
 159         event_header =
 160                 bt_ctf_field_create(validation_output.event_header_type);
 161         if (!event_header) {
 162                 goto error;
 163         }
 164
 165         if (validation_output.stream_event_ctx_type) {
 166                 stream_event_context = bt_ctf_field_create(
 167                         validation_output.stream_event_ctx_type);
 168                 if (!stream_event_context) {
 169                         goto error;
 170                 }
 171         }
 172
 173         if (validation_output.event_context_type) {
 174                 event_context = bt_ctf_field_create(
 175                         validation_output.event_context_type);
 176                 if (!event_context) {
 177                         goto error;
 178                 }
 179         }
 180
 181         if (validation_output.event_payload_type) {
 182                 event_payload = bt_ctf_field_create(
 183                         validation_output.event_payload_type);
 184                 if (!event_payload) {
 185                         goto error;
 186                 }
 187         }
 188
 189         /*
 190          * At this point all the fields are created, potentially from
 191          * validated copies of field types, so that the field types and
 192          * fields can be replaced in the trace, stream class,
 193          * event class, and created event.
 194          */
 195         bt_ctf_validation_replace_types(trace, stream_class,
 196                 event_class, &validation_output, validation_flags);
 197         BT_MOVE(event->event_header, event_header);
 198         BT_MOVE(event->stream_event_context, stream_event_context);
 199         BT_MOVE(event->context_payload, event_context);
 200         BT_MOVE(event->fields_payload, event_payload);
 201
 202         /*
 203          * Put what was not moved in bt_ctf_validation_replace_types().
 204          */
 205         bt_ctf_validation_output_put_types(&validation_output);
 206
 207         /*
 208          * Freeze the stream class since the event header must not be changed
 209          * anymore.
 210          */
 211         bt_ctf_stream_class_freeze(stream_class);
 212
 213         /*
 214          * Mark stream class, and event class as valid since
 215          * they're all frozen now.
 216          */
 217         stream_class->valid = 1;
 218         event_class->valid = 1;
 219
 220         /* Put stuff we borrowed from the event class */
 221         BT_PUT(stream_class);
 222         BT_PUT(trace);
 223
 224         return event;
 225
 226 error:
 227         bt_ctf_validation_output_put_types(&validation_output);
 228         BT_PUT(event);
 229         BT_PUT(stream_class);
 230         BT_PUT(trace);
 231         BT_PUT(event_header);
 232         BT_PUT(stream_event_context);
 233         BT_PUT(event_context);
 234         BT_PUT(event_payload);
 235         assert(!packet_header_type);
 236         assert(!packet_context_type);
 237         assert(!event_header_type);
 238         assert(!stream_event_ctx_type);
 239         assert(!event_context_type);
 240         assert(!event_payload_type);
 241
 242         return event;
 243 }
 244
 245 struct bt_ctf_event_class *bt_ctf_event_get_class(struct bt_ctf_event *event)
 246 {
 247         struct bt_ctf_event_class *event_class = NULL;
 248
 249         if (!event) {
 250                 goto end;
 251         }
 252
 253         event_class = event->event_class;
 254         bt_get(event_class);
 255 end:
 256         return event_class;
 257 }
 258
 259 struct bt_ctf_stream *bt_ctf_event_get_stream(struct bt_ctf_event *event)
 260 {
 261         struct bt_ctf_stream *stream = NULL;
 262
 263         if (!event) {
 264                 goto end;
 265         }
 266
 267         /*
 268          * If the event has a parent, then this is its (writer) stream.
 269          * If the event has no parent, then if it has a packet, this
 270          * is its (non-writer) stream.
 271          */
 272         if (event->base.parent) {
 273                 stream = (struct bt_ctf_stream *) bt_object_get_parent(event);
 274         } else {
 275                 if (event->packet) {
 276                         stream = bt_get(event->packet->stream);
 277                 }
 278         }
 279
 280 end:
 281         return stream;
 282 }
 283
 284 int bt_ctf_event_set_payload(struct bt_ctf_event *event,
 285                 const char *name,
 286                 struct bt_ctf_field *payload)
 287 {
 288         int ret = 0;
 289
 290         if (!event || !payload || event->frozen) {
 291                 ret = -1;
 292                 goto end;
 293         }
 294
 295         if (name) {
 296                 ret = bt_ctf_field_structure_set_field(event->fields_payload,
 297                         name, payload);
 298         } else {
 299                 struct bt_ctf_field_type *payload_type;
 300
 301                 payload_type = bt_ctf_field_get_type(payload);
 302
 303                 if (bt_ctf_field_type_compare(payload_type,
 304                                 event->event_class->fields) == 0) {
 305                         bt_put(event->fields_payload);
 306                         bt_get(payload);
 307                         event->fields_payload = payload;
 308                 } else {
 309                         ret = -1;
 310                 }
 311
 312                 bt_put(payload_type);
 313         }
 314 end:
 315         return ret;
 316 }
 317
 318 struct bt_ctf_field *bt_ctf_event_get_payload_field(struct bt_ctf_event *event)
 319 {
 320         struct bt_ctf_field *payload = NULL;
 321
 322         if (!event || !event->fields_payload) {
 323                 goto end;
 324         }
 325
 326         payload = event->fields_payload;
 327         bt_get(payload);
 328 end:
 329         return payload;
 330 }
 331
 332 int bt_ctf_event_set_payload_field(struct bt_ctf_event *event,
 333                 struct bt_ctf_field *payload)
 334 {
 335         int ret = 0;
 336         struct bt_ctf_field_type *payload_type = NULL;
 337
 338         if (!event || event->frozen) {
 339                 ret = -1;
 340                 goto end;
 341         }
 342
 343         payload_type = bt_ctf_field_get_type(payload);
 344         if (!payload_type) {
 345                 ret = -1;
 346                 goto end;
 347         }
 348
 349         if (bt_ctf_field_type_get_type_id(payload_type) !=
 350                         BT_CTF_TYPE_ID_STRUCT) {
 351                 ret = -1;
 352                 goto end;
 353         }
 354
 355         bt_put(event->fields_payload);
 356         event->fields_payload = bt_get(payload);
 357 end:
 358         bt_put(payload_type);
 359         return ret;
 360 }
 361
 362 struct bt_ctf_field *bt_ctf_event_get_payload(struct bt_ctf_event *event,
 363                 const char *name)
 364 {
 365         struct bt_ctf_field *field = NULL;
 366
 367         if (!event) {
 368                 goto end;
 369         }
 370
 371         if (name) {
 372                 field = bt_ctf_field_structure_get_field(event->fields_payload,
 373                         name);
 374         } else {
 375                 field = event->fields_payload;
 376                 bt_get(field);
 377         }
 378 end:
 379         return field;
 380 }
 381
 382 struct bt_ctf_field *bt_ctf_event_get_payload_by_index(
 383                 struct bt_ctf_event *event, int index)
 384 {
 385         struct bt_ctf_field *field = NULL;
 386
 387         if (!event || index < 0) {
 388                 goto end;
 389         }
 390
 391         field = bt_ctf_field_structure_get_field_by_index(event->fields_payload,
 392                 index);
 393 end:
 394         return field;
 395 }
 396
 397 struct bt_ctf_field *bt_ctf_event_get_header(
 398                 struct bt_ctf_event *event)
 399 {
 400         struct bt_ctf_field *header = NULL;
 401
 402         if (!event || !event->event_header) {
 403                 goto end;
 404         }
 405
 406         header = event->event_header;
 407         bt_get(header);
 408 end:
 409         return header;
 410 }
 411
 412 int bt_ctf_event_set_header(struct bt_ctf_event *event,
 413                 struct bt_ctf_field *header)
 414 {
 415         int ret = 0;
 416         struct bt_ctf_field_type *field_type = NULL;
 417         struct bt_ctf_stream_class *stream_class = NULL;
 418
 419         if (!event || event->frozen) {
 420                 ret = -1;
 421                 goto end;
 422         }
 423
 424         stream_class = (struct bt_ctf_stream_class *) bt_object_get_parent(
 425                         event->event_class);
 426         /*
 427          * Ensure the provided header's type matches the one registered to the
 428          * stream class.
 429          */
 430         field_type = bt_ctf_field_get_type(header);
 431         if (bt_ctf_field_type_compare(field_type,
 432                         stream_class->event_header_type)) {
 433                 ret = -1;
 434                 goto end;
 435         }
 436
 437         bt_put(event->event_header);
 438         event->event_header = bt_get(header);
 439 end:
 440         bt_put(stream_class);
 441         bt_put(field_type);
 442         return ret;
 443 }
 444
 445 struct bt_ctf_field *bt_ctf_event_get_event_context(
 446                 struct bt_ctf_event *event)
 447 {
 448         struct bt_ctf_field *context = NULL;
 449
 450         if (!event || !event->context_payload) {
 451                 goto end;
 452         }
 453
 454         context = event->context_payload;
 455         bt_get(context);
 456 end:
 457         return context;
 458 }
 459
 460 int bt_ctf_event_set_event_context(struct bt_ctf_event *event,
 461                 struct bt_ctf_field *context)
 462 {
 463         int ret = 0;
 464         struct bt_ctf_field_type *field_type = NULL;
 465
 466         if (!event || event->frozen) {
 467                 ret = -1;
 468                 goto end;
 469         }
 470
 471         field_type = bt_ctf_field_get_type(context);
 472         if (bt_ctf_field_type_compare(field_type,
 473                         event->event_class->context)) {
 474                 ret = -1;
 475                 goto end;
 476         }
 477
 478         bt_put(event->context_payload);
 479         event->context_payload = bt_get(context);
 480 end:
 481         bt_put(field_type);
 482         return ret;
 483 }
 484
 485 struct bt_ctf_field *bt_ctf_event_get_stream_event_context(
 486                 struct bt_ctf_event *event)
 487 {
 488         struct bt_ctf_field *stream_event_context = NULL;
 489
 490         if (!event || !event->stream_event_context) {
 491                 goto end;
 492         }
 493
 494         stream_event_context = event->stream_event_context;
 495 end:
 496         return bt_get(stream_event_context);
 497 }
 498
 499 int bt_ctf_event_set_stream_event_context(struct bt_ctf_event *event,
 500                 struct bt_ctf_field *stream_event_context)
 501 {
 502         int ret = 0;
 503         struct bt_ctf_field_type *field_type = NULL;
 504         struct bt_ctf_stream_class *stream_class = NULL;
 505
 506         if (!event || event->frozen) {
 507                 ret = -1;
 508                 goto end;
 509         }
 510
 511         stream_class = bt_ctf_event_class_get_stream_class(event->event_class);
 512         /*
 513          * We should not have been able to create the event without associating
 514          * the event class to a stream class.
 515          */
 516         assert(stream_class);
 517
 518         field_type = bt_ctf_field_get_type(stream_event_context);
 519         if (bt_ctf_field_type_compare(field_type,
 520                         stream_class->event_context_type)) {
 521                 ret = -1;
 522                 goto end;
 523         }
 524
 525         bt_get(stream_event_context);
 526         BT_MOVE(event->stream_event_context, stream_event_context);
 527 end:
 528         BT_PUT(stream_class);
 529         bt_put(field_type);
 530         return ret;
 531 }
 532
 533 void bt_ctf_event_get(struct bt_ctf_event *event)
 534 {
 535         bt_get(event);
 536 }
 537
 538 void bt_ctf_event_put(struct bt_ctf_event *event)
 539 {
 540         bt_put(event);
 541 }
 542
 543 void bt_ctf_event_destroy(struct bt_object *obj)
 544 {
 545         struct bt_ctf_event *event;
 546
 547         event = container_of(obj, struct bt_ctf_event, base);
 548         if (!event->base.parent) {
 549                 /*
 550                  * Event was keeping a reference to its class since it shared no
 551                  * common ancestor with it to guarantee they would both have the
 552                  * same lifetime.
 553                  */
 554                 bt_put(event->event_class);
 555         }
 556         g_hash_table_destroy(event->clock_values);
 557         bt_put(event->event_header);
 558         bt_put(event->stream_event_context);
 559         bt_put(event->context_payload);
 560         bt_put(event->fields_payload);
 561         bt_put(event->packet);
 562         g_free(event);
 563 }
 564
 565 struct bt_ctf_clock_value *bt_ctf_event_get_clock_value(
 566                 struct bt_ctf_event *event, struct bt_ctf_clock_class *clock_class)
 567 {
 568         struct bt_ctf_clock_value *clock_value = NULL;
 569
 570         if (!event || !clock_class) {
 571                 goto end;
 572         }
 573
 574         clock_value = g_hash_table_lookup(event->clock_values, clock_class);
 575         if (!clock_value) {
 576                 goto end;
 577         }
 578
 579         bt_get(clock_value);
 580 end:
 581         return clock_value;
 582 }
 583
 584 int bt_ctf_event_set_clock_value(struct bt_ctf_event *event,
 585                 struct bt_ctf_clock_value *value)
 586 {
 587         int ret = 0;
 588
 589         if (!event || !value || event->frozen) {
 590                 ret = -1;
 591                 goto end;
 592         }
 593
 594         g_hash_table_insert(event->clock_values,
 595                 bt_ctf_clock_value_get_class(value), bt_get(value));
 596 end:
 597         return ret;
 598 }
 599
 600 BT_HIDDEN
 601 int bt_ctf_event_validate(struct bt_ctf_event *event)
 602 {
 603         /* Make sure each field's payload has been set */
 604         int ret;
 605         struct bt_ctf_stream_class *stream_class = NULL;
 606
 607         assert(event);
 608         ret = bt_ctf_field_validate(event->event_header);
 609         if (ret) {
 610                 goto end;
 611         }
 612
 613         stream_class = bt_ctf_event_class_get_stream_class(event->event_class);
 614         /*
 615          * We should not have been able to create the event without associating
 616          * the event class to a stream class.
 617          */
 618         assert(stream_class);
 619         if (stream_class->event_context_type) {
 620                 ret = bt_ctf_field_validate(event->stream_event_context);
 621                 if (ret) {
 622                         goto end;
 623                 }
 624         }
 625
 626         ret = bt_ctf_field_validate(event->fields_payload);
 627         if (ret) {
 628                 goto end;
 629         }
 630
 631         if (event->event_class->context) {
 632                 ret = bt_ctf_field_validate(event->context_payload);
 633         }
 634 end:
 635         bt_put(stream_class);
 636         return ret;
 637 }
 638
 639 BT_HIDDEN
 640 int bt_ctf_event_serialize(struct bt_ctf_event *event,
 641                 struct ctf_stream_pos *pos)
 642 {
 643         int ret = 0;
 644
 645         assert(event);
 646         assert(pos);
 647         if (event->context_payload) {
 648                 ret = bt_ctf_field_serialize(event->context_payload, pos);
 649                 if (ret) {
 650                         goto end;
 651                 }
 652         }
 653
 654         if (event->fields_payload) {
 655                 ret = bt_ctf_field_serialize(event->fields_payload, pos);
 656                 if (ret) {
 657                         goto end;
 658                 }
 659         }
 660 end:
 661         return ret;
 662 }
 663
 664 struct bt_ctf_packet *bt_ctf_event_get_packet(struct bt_ctf_event *event)
 665 {
 666         struct bt_ctf_packet *packet = NULL;
 667
 668         if (!event || !event->packet) {
 669                 goto end;
 670         }
 671
 672         packet = bt_get(event->packet);
 673 end:
 674         return packet;
 675 }
 676
 677 int bt_ctf_event_set_packet(struct bt_ctf_event *event,
 678                 struct bt_ctf_packet *packet)
 679 {
 680         struct bt_ctf_stream_class *event_stream_class = NULL;
 681         struct bt_ctf_stream_class *packet_stream_class = NULL;
 682         struct bt_ctf_stream *stream = NULL;
 683         int ret = 0;
 684
 685         if (!event || !packet || event->frozen) {
 686                 ret = -1;
 687                 goto end;
 688         }
 689
 690         /*
 691          * Make sure the new packet was created by this event's
 692          * stream, if it is set.
 693          */
 694         stream = bt_ctf_event_get_stream(event);
 695         if (stream) {
 696                 if (packet->stream != stream) {
 697                         ret = -1;
 698                         goto end;
 699                 }
 700         } else {
 701                 event_stream_class =
 702                         bt_ctf_event_class_get_stream_class(event->event_class);
 703                 packet_stream_class =
 704                         bt_ctf_stream_get_class(packet->stream);
 705
 706                 assert(event_stream_class);
 707                 assert(packet_stream_class);
 708
 709                 if (event_stream_class != packet_stream_class) {
 710                         ret = -1;
 711                         goto end;
 712                 }
 713         }
 714
 715         bt_get(packet);
 716         BT_MOVE(event->packet, packet);
 717
 718 end:
 719         BT_PUT(stream);
 720         BT_PUT(event_stream_class);
 721         BT_PUT(packet_stream_class);
 722
 723         return ret;
 724 }
 725
 726 BT_HIDDEN
 727 void bt_ctf_event_freeze(struct bt_ctf_event *event)
 728 {
 729         assert(event);
 730         bt_ctf_packet_freeze(event->packet);
 731         bt_ctf_field_freeze(event->event_header);
 732         bt_ctf_field_freeze(event->stream_event_context);
 733         bt_ctf_field_freeze(event->context_payload);
 734         bt_ctf_field_freeze(event->fields_payload);
 735         event->frozen = 1;
 736 }