formats/ctf/ir/stream-class.c

   1 /*
   2  * stream-class.c
   3  *
   4  * Babeltrace CTF IR - Stream Class
   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-writer/clock.h>
  30 #include <babeltrace/ctf-ir/clock-internal.h>
  31 #include <babeltrace/ctf-writer/event.h>
  32 #include <babeltrace/ctf-ir/event-internal.h>
  33 #include <babeltrace/ctf-ir/event-types-internal.h>
  34 #include <babeltrace/ctf-ir/event-fields-internal.h>
  35 #include <babeltrace/ctf-writer/stream.h>
  36 #include <babeltrace/ctf-ir/stream-class-internal.h>
  37 #include <babeltrace/ctf-writer/functor-internal.h>
  38 #include <babeltrace/compiler.h>
  39 #include <babeltrace/align.h>
  40
  41 static
  42 void bt_ctf_stream_class_destroy(struct bt_ctf_ref *ref);
  43 static
  44 int init_event_header(struct bt_ctf_stream_class *stream_class,
  45                 enum bt_ctf_byte_order byte_order);
  46 static
  47 int init_packet_context(struct bt_ctf_stream_class *stream_class,
  48                 enum bt_ctf_byte_order byte_order);
  49
  50 struct bt_ctf_stream_class *bt_ctf_stream_class_create(const char *name)
  51 {
  52         int ret;
  53         struct bt_ctf_stream_class *stream_class = NULL;
  54
  55         if (!name || !strlen(name)) {
  56                 goto error;
  57         }
  58
  59         stream_class = g_new0(struct bt_ctf_stream_class, 1);
  60         if (!stream_class) {
  61                 goto error;
  62         }
  63
  64         stream_class->name = g_string_new(name);
  65         stream_class->event_classes = g_ptr_array_new_with_free_func(
  66                 (GDestroyNotify)bt_ctf_event_class_put);
  67         if (!stream_class->event_classes) {
  68                 goto error_destroy;
  69         }
  70
  71         ret = init_packet_context(stream_class, BT_CTF_BYTE_ORDER_NATIVE);
  72         if (ret) {
  73                 goto error_destroy;
  74         }
  75
  76         bt_ctf_ref_init(&stream_class->ref_count);
  77         return stream_class;
  78
  79 error_destroy:
  80         bt_ctf_stream_class_destroy(&stream_class->ref_count);
  81         stream_class = NULL;
  82 error:
  83         return stream_class;
  84 }
  85
  86 const char *bt_ctf_stream_class_get_name(
  87                 struct bt_ctf_stream_class *stream_class)
  88 {
  89         const char *name = NULL;
  90
  91         if (!stream_class) {
  92                 goto end;
  93         }
  94
  95         name = stream_class->name->str;
  96 end:
  97         return name;
  98 }
  99
 100 struct bt_ctf_clock *bt_ctf_stream_class_get_clock(
 101                 struct bt_ctf_stream_class *stream_class)
 102 {
 103         struct bt_ctf_clock *clock = NULL;
 104
 105         if (!stream_class || !stream_class->clock) {
 106                 goto end;
 107         }
 108
 109         clock = stream_class->clock;
 110         bt_ctf_clock_get(clock);
 111 end:
 112         return clock;
 113 }
 114
 115 int bt_ctf_stream_class_set_clock(struct bt_ctf_stream_class *stream_class,
 116                 struct bt_ctf_clock *clock)
 117 {
 118         int ret = 0;
 119
 120         if (!stream_class || !clock || stream_class->frozen) {
 121                 ret = -1;
 122                 goto end;
 123         }
 124
 125         if (stream_class->clock) {
 126                 bt_ctf_clock_put(stream_class->clock);
 127         }
 128
 129         stream_class->clock = clock;
 130         bt_ctf_clock_get(clock);
 131 end:
 132         return ret;
 133 }
 134
 135 int64_t bt_ctf_stream_class_get_id(struct bt_ctf_stream_class *stream_class)
 136 {
 137         int64_t ret;
 138
 139         if (!stream_class || !stream_class->id_set) {
 140                 ret = -1;
 141                 goto end;
 142         }
 143
 144         ret = (int64_t) stream_class->id;
 145 end:
 146         return ret;
 147 }
 148
 149 int bt_ctf_stream_class_set_id(struct bt_ctf_stream_class *stream_class,
 150                 uint32_t id)
 151 {
 152         int ret = 0;
 153
 154         if (!stream_class || stream_class->frozen) {
 155                 ret = -1;
 156                 goto end;
 157         }
 158
 159         stream_class->id = id;
 160         stream_class->id_set = 1;
 161 end:
 162         return ret;
 163 }
 164
 165 int bt_ctf_stream_class_add_event_class(
 166                 struct bt_ctf_stream_class *stream_class,
 167                 struct bt_ctf_event_class *event_class)
 168 {
 169         int ret = 0;
 170         int64_t event_id;
 171
 172         if (!stream_class || !event_class) {
 173                 ret = -1;
 174                 goto end;
 175         }
 176
 177         /* Check for duplicate event classes */
 178         struct search_query query = { .value = event_class, .found = 0 };
 179         g_ptr_array_foreach(stream_class->event_classes, value_exists, &query);
 180         if (query.found) {
 181                 ret = -1;
 182                 goto end;
 183         }
 184
 185         /* Only set an event id if none was explicitly set before */
 186         event_id = bt_ctf_event_class_get_id(event_class);
 187         if (event_id < 0) {
 188                 if (bt_ctf_event_class_set_id(event_class,
 189                         stream_class->next_event_id++)) {
 190                         ret = -1;
 191                         goto end;
 192                 }
 193         }
 194
 195         ret = bt_ctf_event_class_set_stream_class(event_class, stream_class);
 196         if (ret) {
 197                 goto end;
 198         }
 199
 200         bt_ctf_event_class_get(event_class);
 201         g_ptr_array_add(stream_class->event_classes, event_class);
 202 end:
 203         return ret;
 204 }
 205
 206 int bt_ctf_stream_class_get_event_class_count(
 207                 struct bt_ctf_stream_class *stream_class)
 208 {
 209         int ret;
 210
 211         if (!stream_class) {
 212                 ret = -1;
 213                 goto end;
 214         }
 215
 216         ret = (int) stream_class->event_classes->len;
 217 end:
 218         return ret;
 219 }
 220
 221 struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class(
 222                 struct bt_ctf_stream_class *stream_class, int index)
 223 {
 224         struct bt_ctf_event_class *event_class = NULL;
 225
 226         if (!stream_class || index < 0 ||
 227                 index >= stream_class->event_classes->len) {
 228                 goto end;
 229         }
 230
 231         event_class = g_ptr_array_index(stream_class->event_classes, index);
 232         bt_ctf_event_class_get(event_class);
 233 end:
 234         return event_class;
 235 }
 236
 237 struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class_by_name(
 238                 struct bt_ctf_stream_class *stream_class, const char *name)
 239 {
 240         size_t i;
 241         GQuark name_quark;
 242         struct bt_ctf_event_class *event_class = NULL;
 243
 244         if (!stream_class || !name) {
 245                 goto end;
 246         }
 247
 248         name_quark = g_quark_try_string(name);
 249         if (!name_quark) {
 250                 goto end;
 251         }
 252
 253         for (i = 0; i < stream_class->event_classes->len; i++) {
 254                 struct bt_ctf_event_class *current_event_class =
 255                         g_ptr_array_index(stream_class->event_classes, i);
 256
 257                 if (name_quark == current_event_class->name) {
 258                         event_class = current_event_class;
 259                         bt_ctf_event_class_get(event_class);
 260                         goto end;
 261                 }
 262         }
 263 end:
 264         return event_class;
 265 }
 266
 267 struct bt_ctf_field_type *bt_ctf_stream_class_get_packet_context_type(
 268                 struct bt_ctf_stream_class *stream_class)
 269 {
 270         struct bt_ctf_field_type *ret = NULL;
 271
 272         if (!stream_class) {
 273                 goto end;
 274         }
 275
 276         assert(stream_class->packet_context_type);
 277         bt_ctf_field_type_get(stream_class->packet_context_type);
 278         ret = stream_class->packet_context_type;
 279 end:
 280         return ret;
 281 }
 282
 283 int bt_ctf_stream_class_set_packet_context_type(
 284                 struct bt_ctf_stream_class *stream_class,
 285                 struct bt_ctf_field_type *packet_context_type)
 286 {
 287         int ret = 0;
 288
 289         if (!stream_class || !packet_context_type || stream_class->frozen) {
 290                 ret = -1;
 291                 goto end;
 292         }
 293
 294         assert(stream_class->packet_context_type);
 295         if (bt_ctf_field_type_get_type_id(packet_context_type) !=
 296                 CTF_TYPE_STRUCT) {
 297                 /* A packet context must be a structure */
 298                 ret = -1;
 299                 goto end;
 300         }
 301
 302         bt_ctf_field_type_put(stream_class->packet_context_type);
 303         bt_ctf_field_type_get(packet_context_type);
 304         stream_class->packet_context_type = packet_context_type;
 305 end:
 306         return ret;
 307 }
 308
 309 struct bt_ctf_field_type *bt_ctf_stream_class_get_event_context_type(
 310                 struct bt_ctf_stream_class *stream_class)
 311 {
 312         struct bt_ctf_field_type *ret = NULL;
 313
 314         if (!stream_class || !stream_class->event_context_type) {
 315                 goto end;
 316         }
 317
 318         assert(stream_class->event_context_type);
 319         bt_ctf_field_type_get(stream_class->event_context_type);
 320         ret = stream_class->event_context_type;
 321 end:
 322         return ret;
 323 }
 324
 325 int bt_ctf_stream_class_set_event_context_type(
 326                 struct bt_ctf_stream_class *stream_class,
 327                 struct bt_ctf_field_type *event_context_type)
 328 {
 329         int ret = 0;
 330
 331         if (!stream_class || !event_context_type || stream_class->frozen) {
 332                 ret = -1;
 333                 goto end;
 334         }
 335
 336         if (bt_ctf_field_type_get_type_id(event_context_type) !=
 337                 CTF_TYPE_STRUCT) {
 338                 /* A packet context must be a structure */
 339                 ret = -1;
 340                 goto end;
 341         }
 342
 343         bt_ctf_field_type_put(stream_class->event_context_type);
 344         bt_ctf_field_type_get(event_context_type);
 345         stream_class->event_context_type = event_context_type;
 346 end:
 347         return ret;
 348 }
 349
 350 void bt_ctf_stream_class_get(struct bt_ctf_stream_class *stream_class)
 351 {
 352         if (!stream_class) {
 353                 return;
 354         }
 355
 356         bt_ctf_ref_get(&stream_class->ref_count);
 357 }
 358
 359 void bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class)
 360 {
 361         if (!stream_class) {
 362                 return;
 363         }
 364
 365         bt_ctf_ref_put(&stream_class->ref_count, bt_ctf_stream_class_destroy);
 366 }
 367
 368 BT_HIDDEN
 369 void bt_ctf_stream_class_freeze(struct bt_ctf_stream_class *stream_class)
 370 {
 371         if (!stream_class) {
 372                 return;
 373         }
 374
 375         stream_class->frozen = 1;
 376         bt_ctf_field_type_freeze(stream_class->packet_context_type);
 377         bt_ctf_field_type_freeze(stream_class->event_context_type);
 378         bt_ctf_clock_freeze(stream_class->clock);
 379         g_ptr_array_foreach(stream_class->event_classes,
 380                 (GFunc)bt_ctf_event_class_freeze, NULL);
 381 }
 382
 383 BT_HIDDEN
 384 int bt_ctf_stream_class_set_byte_order(struct bt_ctf_stream_class *stream_class,
 385         enum bt_ctf_byte_order byte_order)
 386 {
 387         int ret = 0;
 388
 389         ret = init_event_header(stream_class, byte_order);
 390         if (ret) {
 391                 goto end;
 392         }
 393 end:
 394         return ret;
 395 }
 396
 397 BT_HIDDEN
 398 int bt_ctf_stream_class_serialize(struct bt_ctf_stream_class *stream_class,
 399                 struct metadata_context *context)
 400 {
 401         int64_t ret = 0;
 402         size_t i;
 403
 404         g_string_assign(context->field_name, "");
 405         context->current_indentation_level = 1;
 406         if (!stream_class->id_set) {
 407                 ret = -1;
 408                 goto end;
 409         }
 410
 411         g_string_append_printf(context->string,
 412                 "stream {\n\tid = %" PRIu32 ";\n\tevent.header := ",
 413                 stream_class->id);
 414         ret = bt_ctf_field_type_serialize(stream_class->event_header_type,
 415                 context);
 416         if (ret) {
 417                 goto end;
 418         }
 419
 420         g_string_append(context->string, ";\n\n\tpacket.context := ");
 421         ret = bt_ctf_field_type_serialize(stream_class->packet_context_type,
 422                 context);
 423         if (ret) {
 424                 goto end;
 425         }
 426
 427         if (stream_class->event_context_type) {
 428                 g_string_append(context->string, ";\n\n\tevent.context := ");
 429                 ret = bt_ctf_field_type_serialize(
 430                         stream_class->event_context_type, context);
 431                 if (ret) {
 432                         goto end;
 433                 }
 434         }
 435
 436         g_string_append(context->string, ";\n};\n\n");
 437         for (i = 0; i < stream_class->event_classes->len; i++) {
 438                 struct bt_ctf_event_class *event_class =
 439                         stream_class->event_classes->pdata[i];
 440
 441                 ret = bt_ctf_event_class_serialize(event_class, context);
 442                 if (ret) {
 443                         goto end;
 444                 }
 445         }
 446 end:
 447         context->current_indentation_level = 0;
 448         return ret;
 449 }
 450
 451 static
 452 void bt_ctf_stream_class_destroy(struct bt_ctf_ref *ref)
 453 {
 454         struct bt_ctf_stream_class *stream_class;
 455
 456         if (!ref) {
 457                 return;
 458         }
 459
 460         stream_class = container_of(ref, struct bt_ctf_stream_class, ref_count);
 461         bt_ctf_clock_put(stream_class->clock);
 462
 463         if (stream_class->event_classes) {
 464                 size_t i;
 465
 466                 /* Unregister this stream class from the event classes */
 467                 for (i = 0; i < stream_class->event_classes->len; i++) {
 468                         struct bt_ctf_event_class *event_class =
 469                                 g_ptr_array_index(stream_class->event_classes,
 470                                 i);
 471
 472                         bt_ctf_event_class_set_stream_class(event_class, NULL);
 473                 }
 474
 475                 g_ptr_array_free(stream_class->event_classes, TRUE);
 476         }
 477
 478         if (stream_class->name) {
 479                 g_string_free(stream_class->name, TRUE);
 480         }
 481
 482         bt_ctf_field_type_put(stream_class->event_header_type);
 483         bt_ctf_field_put(stream_class->event_header);
 484         bt_ctf_field_type_put(stream_class->packet_context_type);
 485         if (stream_class->event_context_type) {
 486                 bt_ctf_field_type_put(stream_class->event_context_type);
 487         }
 488         g_free(stream_class);
 489 }
 490
 491 static
 492 int init_event_header(struct bt_ctf_stream_class *stream_class,
 493                 enum bt_ctf_byte_order byte_order)
 494 {
 495         int ret = 0;
 496         struct bt_ctf_field_type *event_header_type =
 497                 bt_ctf_field_type_structure_create();
 498         struct bt_ctf_field_type *_uint32_t =
 499                 get_field_type(FIELD_TYPE_ALIAS_UINT32_T);
 500         struct bt_ctf_field_type *_uint64_t =
 501                 get_field_type(FIELD_TYPE_ALIAS_UINT64_T);
 502
 503         if (!event_header_type) {
 504                 ret = -1;
 505                 goto end;
 506         }
 507
 508         ret = bt_ctf_field_type_set_byte_order(_uint32_t, byte_order);
 509         if (ret) {
 510                 goto end;
 511         }
 512
 513         ret = bt_ctf_field_type_set_byte_order(_uint64_t, byte_order);
 514         if (ret) {
 515                 goto end;
 516         }
 517
 518         ret = bt_ctf_field_type_structure_add_field(event_header_type,
 519                 _uint32_t, "id");
 520         if (ret) {
 521                 goto end;
 522         }
 523
 524         ret = bt_ctf_field_type_structure_add_field(event_header_type,
 525                 _uint64_t, "timestamp");
 526         if (ret) {
 527                 goto end;
 528         }
 529
 530         stream_class->event_header_type = event_header_type;
 531         stream_class->event_header = bt_ctf_field_create(
 532                 stream_class->event_header_type);
 533         if (!stream_class->event_header) {
 534                 ret = -1;
 535         }
 536 end:
 537         if (ret) {
 538                 bt_ctf_field_type_put(event_header_type);
 539         }
 540
 541         bt_ctf_field_type_put(_uint32_t);
 542         bt_ctf_field_type_put(_uint64_t);
 543         return ret;
 544 }
 545
 546 static
 547 int init_packet_context(struct bt_ctf_stream_class *stream_class,
 548                 enum bt_ctf_byte_order byte_order)
 549 {
 550         int ret = 0;
 551         struct bt_ctf_field_type *packet_context_type =
 552                 bt_ctf_field_type_structure_create();
 553         struct bt_ctf_field_type *_uint64_t =
 554                 get_field_type(FIELD_TYPE_ALIAS_UINT64_T);
 555
 556         if (!packet_context_type) {
 557                 ret = -1;
 558                 goto end;
 559         }
 560
 561         /*
 562          * We create a stream packet context as proposed in the CTF
 563          * specification.
 564          */
 565         ret = bt_ctf_field_type_set_byte_order(_uint64_t, byte_order);
 566         if (ret) {
 567                 goto end;
 568         }
 569
 570         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 571                 _uint64_t, "timestamp_begin");
 572         if (ret) {
 573                 goto end;
 574         }
 575
 576         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 577                 _uint64_t, "timestamp_end");
 578         if (ret) {
 579                 goto end;
 580         }
 581
 582         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 583                 _uint64_t, "content_size");
 584         if (ret) {
 585                 goto end;
 586         }
 587
 588         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 589                 _uint64_t, "packet_size");
 590         if (ret) {
 591                 goto end;
 592         }
 593
 594         ret = bt_ctf_field_type_structure_add_field(packet_context_type,
 595                 _uint64_t, "events_discarded");
 596         if (ret) {
 597                 goto end;
 598         }
 599
 600         stream_class->packet_context_type = packet_context_type;
 601 end:
 602         if (ret) {
 603                 bt_ctf_field_type_put(packet_context_type);
 604                 goto end;
 605         }
 606
 607         bt_ctf_field_type_put(_uint64_t);
 608         return ret;
 609 }