formats/ctf/ir/event-class.c

   1 /*
   2  * event-class.c
   3  *
   4  * Babeltrace CTF IR - Event 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-ir/fields-internal.h>
  30 #include <babeltrace/ctf-ir/field-types-internal.h>
  31 #include <babeltrace/ctf-ir/event-class.h>
  32 #include <babeltrace/ctf-ir/event-class-internal.h>
  33 #include <babeltrace/ctf-ir/stream-class.h>
  34 #include <babeltrace/ctf-ir/stream-class-internal.h>
  35 #include <babeltrace/ctf-ir/trace-internal.h>
  36 #include <babeltrace/ctf-ir/validation-internal.h>
  37 #include <babeltrace/ctf-ir/utils.h>
  38 #include <babeltrace/ref.h>
  39 #include <babeltrace/ctf-ir/attributes-internal.h>
  40 #include <babeltrace/compiler.h>
  41 #include <babeltrace/endian.h>
  42
  43 static
  44 void bt_ctf_event_class_destroy(struct bt_object *obj);
  45
  46 struct bt_ctf_event_class *bt_ctf_event_class_create(const char *name)
  47 {
  48         int ret;
  49         struct bt_value *obj = NULL;
  50         struct bt_ctf_event_class *event_class = NULL;
  51
  52         if (bt_ctf_validate_identifier(name)) {
  53                 goto error;
  54         }
  55
  56         event_class = g_new0(struct bt_ctf_event_class, 1);
  57         if (!event_class) {
  58                 goto error;
  59         }
  60
  61         event_class->id = -1;
  62         bt_object_init(event_class, bt_ctf_event_class_destroy);
  63         event_class->fields = bt_ctf_field_type_structure_create();
  64         if (!event_class->fields) {
  65                 goto error;
  66         }
  67
  68         event_class->attributes = bt_ctf_attributes_create();
  69         if (!event_class->attributes) {
  70                 goto error;
  71         }
  72
  73         obj = bt_value_integer_create_init(-1);
  74         if (!obj) {
  75                 goto error;
  76         }
  77
  78         ret = bt_ctf_attributes_set_field_value(event_class->attributes,
  79                 "id", obj);
  80         if (ret) {
  81                 goto error;
  82         }
  83
  84         BT_PUT(obj);
  85
  86         obj = bt_value_string_create_init(name);
  87         if (!obj) {
  88                 goto error;
  89         }
  90
  91         ret = bt_ctf_attributes_set_field_value(event_class->attributes,
  92                 "name", obj);
  93         if (ret) {
  94                 goto error;
  95         }
  96
  97         BT_PUT(obj);
  98
  99         return event_class;
 100
 101 error:
 102         BT_PUT(event_class);
 103         BT_PUT(obj);
 104         return event_class;
 105 }
 106
 107 const char *bt_ctf_event_class_get_name(struct bt_ctf_event_class *event_class)
 108 {
 109         struct bt_value *obj = NULL;
 110         const char *name = NULL;
 111
 112         if (!event_class) {
 113                 goto end;
 114         }
 115
 116         if (event_class->name) {
 117                 name = event_class->name;
 118                 goto end;
 119         }
 120
 121         obj = bt_ctf_attributes_get_field_value(event_class->attributes,
 122                 BT_CTF_EVENT_CLASS_ATTR_NAME_INDEX);
 123         if (!obj) {
 124                 goto end;
 125         }
 126
 127         if (bt_value_string_get(obj, &name)) {
 128                 name = NULL;
 129         }
 130
 131 end:
 132         BT_PUT(obj);
 133         return name;
 134 }
 135
 136 int64_t bt_ctf_event_class_get_id(struct bt_ctf_event_class *event_class)
 137 {
 138         struct bt_value *obj = NULL;
 139         int64_t ret = 0;
 140
 141         if (!event_class) {
 142                 ret = -1;
 143                 goto end;
 144         }
 145
 146         if (event_class->id >= 0) {
 147                 ret = event_class->id;
 148                 goto end;
 149         }
 150
 151         obj = bt_ctf_attributes_get_field_value(event_class->attributes,
 152                 BT_CTF_EVENT_CLASS_ATTR_ID_INDEX);
 153         if (!obj) {
 154                 goto end;
 155         }
 156
 157         if (bt_value_integer_get(obj, &ret)) {
 158                 ret = -1;
 159         }
 160
 161         if (ret < 0) {
 162                 /* means ID is not set */
 163                 ret = -1;
 164                 goto end;
 165         }
 166
 167 end:
 168         BT_PUT(obj);
 169         return ret;
 170 }
 171
 172 int bt_ctf_event_class_set_id(struct bt_ctf_event_class *event_class,
 173                 uint32_t id)
 174 {
 175         int ret = 0;
 176         struct bt_value *obj = NULL;
 177         struct bt_ctf_stream_class *stream_class = NULL;
 178
 179
 180         if (!event_class) {
 181                 ret = -1;
 182                 goto end;
 183         }
 184
 185         stream_class = bt_ctf_event_class_get_stream_class(event_class);
 186         if (stream_class) {
 187                 /*
 188                  * We don't allow changing the id if the event class has already
 189                  * been added to a stream class.
 190                  */
 191                 ret = -1;
 192                 goto end;
 193         }
 194
 195         obj = bt_ctf_attributes_get_field_value(event_class->attributes,
 196                 BT_CTF_EVENT_CLASS_ATTR_ID_INDEX);
 197         if (!obj) {
 198                 goto end;
 199         }
 200
 201         if (bt_value_integer_set(obj, id)) {
 202                 ret = -1;
 203                 goto end;
 204         }
 205
 206 end:
 207         BT_PUT(obj);
 208         BT_PUT(stream_class);
 209         return ret;
 210 }
 211
 212 int bt_ctf_event_class_set_attribute(
 213                 struct bt_ctf_event_class *event_class, const char *name,
 214                 struct bt_value *value)
 215 {
 216         int ret = 0;
 217
 218         if (!event_class || !name || !value || event_class->frozen) {
 219                 ret = -1;
 220                 goto end;
 221         }
 222
 223         if (!strcmp(name, "id") || !strcmp(name, "loglevel") ||
 224                         !strcmp(name, "stream_id")) {
 225                 if (!bt_value_is_integer(value)) {
 226                         ret = -1;
 227                         goto end;
 228                 }
 229         } else if (!strcmp(name, "name") || !strcmp(name, "model.emf.uri")) {
 230                 if (!bt_value_is_string(value)) {
 231                         ret = -1;
 232                         goto end;
 233                 }
 234         } else {
 235                 /* unknown attribute */
 236                 ret = -1;
 237                 goto end;
 238         }
 239
 240         /* "id" special case: >= 0 */
 241         if (!strcmp(name, "id")) {
 242                 int64_t val;
 243
 244                 ret = bt_value_integer_get(value, &val);
 245
 246                 if (ret) {
 247                         goto end;
 248                 }
 249
 250                 if (val < 0) {
 251                         ret = -1;
 252                         goto end;
 253                 }
 254         }
 255
 256         ret = bt_ctf_attributes_set_field_value(event_class->attributes,
 257                         name, value);
 258
 259 end:
 260         return ret;
 261 }
 262
 263 int bt_ctf_event_class_get_attribute_count(
 264                 struct bt_ctf_event_class *event_class)
 265 {
 266         int ret = 0;
 267
 268         if (!event_class) {
 269                 ret = -1;
 270                 goto end;
 271         }
 272
 273         ret = bt_ctf_attributes_get_count(event_class->attributes);
 274
 275 end:
 276         return ret;
 277 }
 278
 279 const char *
 280 bt_ctf_event_class_get_attribute_name(
 281                 struct bt_ctf_event_class *event_class, int index)
 282 {
 283         const char *ret;
 284
 285         if (!event_class) {
 286                 ret = NULL;
 287                 goto end;
 288         }
 289
 290         ret = bt_ctf_attributes_get_field_name(event_class->attributes, index);
 291
 292 end:
 293         return ret;
 294 }
 295
 296 struct bt_value *
 297 bt_ctf_event_class_get_attribute_value(struct bt_ctf_event_class *event_class,
 298                 int index)
 299 {
 300         struct bt_value *ret;
 301
 302         if (!event_class) {
 303                 ret = NULL;
 304                 goto end;
 305         }
 306
 307         ret = bt_ctf_attributes_get_field_value(event_class->attributes, index);
 308
 309 end:
 310         return ret;
 311 }
 312
 313 struct bt_value *
 314 bt_ctf_event_class_get_attribute_value_by_name(
 315                 struct bt_ctf_event_class *event_class, const char *name)
 316 {
 317         struct bt_value *ret;
 318
 319         if (!event_class || !name) {
 320                 ret = NULL;
 321                 goto end;
 322         }
 323
 324         ret = bt_ctf_attributes_get_field_value_by_name(event_class->attributes,
 325                 name);
 326
 327 end:
 328         return ret;
 329
 330 }
 331
 332 struct bt_ctf_stream_class *bt_ctf_event_class_get_stream_class(
 333                 struct bt_ctf_event_class *event_class)
 334 {
 335         return (struct bt_ctf_stream_class *) bt_object_get_parent(event_class);
 336 }
 337
 338 struct bt_ctf_field_type *bt_ctf_event_class_get_payload_type(
 339                 struct bt_ctf_event_class *event_class)
 340 {
 341         struct bt_ctf_field_type *payload = NULL;
 342
 343         if (!event_class) {
 344                 goto end;
 345         }
 346
 347         bt_get(event_class->fields);
 348         payload = event_class->fields;
 349 end:
 350         return payload;
 351 }
 352
 353 int bt_ctf_event_class_set_payload_type(struct bt_ctf_event_class *event_class,
 354                 struct bt_ctf_field_type *payload)
 355 {
 356         int ret = 0;
 357
 358         if (!event_class) {
 359                 ret = -1;
 360                 goto end;
 361         }
 362
 363         if (payload && bt_ctf_field_type_get_type_id(payload) !=
 364                         BT_CTF_TYPE_ID_STRUCT) {
 365                 ret = -1;
 366                 goto end;
 367         }
 368
 369         bt_put(event_class->fields);
 370         event_class->fields = bt_get(payload);
 371 end:
 372         return ret;
 373 }
 374
 375 int bt_ctf_event_class_add_field(struct bt_ctf_event_class *event_class,
 376                 struct bt_ctf_field_type *type,
 377                 const char *name)
 378 {
 379         int ret = 0;
 380
 381         if (!event_class || !type || bt_ctf_validate_identifier(name) ||
 382                 event_class->frozen) {
 383                 ret = -1;
 384                 goto end;
 385         }
 386
 387         if (bt_ctf_field_type_get_type_id(event_class->fields) !=
 388                 BT_CTF_TYPE_ID_STRUCT) {
 389                 ret = -1;
 390                 goto end;
 391         }
 392
 393         ret = bt_ctf_field_type_structure_add_field(event_class->fields,
 394                 type, name);
 395 end:
 396         return ret;
 397 }
 398
 399 int bt_ctf_event_class_get_field_count(
 400                 struct bt_ctf_event_class *event_class)
 401 {
 402         int ret;
 403
 404         if (!event_class) {
 405                 ret = -1;
 406                 goto end;
 407         }
 408
 409         if (bt_ctf_field_type_get_type_id(event_class->fields) !=
 410                 BT_CTF_TYPE_ID_STRUCT) {
 411                 ret = -1;
 412                 goto end;
 413         }
 414
 415         ret = bt_ctf_field_type_structure_get_field_count(event_class->fields);
 416 end:
 417         return ret;
 418 }
 419
 420 int bt_ctf_event_class_get_field(struct bt_ctf_event_class *event_class,
 421                 const char **field_name, struct bt_ctf_field_type **field_type,
 422                 int index)
 423 {
 424         int ret;
 425
 426         if (!event_class || index < 0) {
 427                 ret = -1;
 428                 goto end;
 429         }
 430
 431         if (bt_ctf_field_type_get_type_id(event_class->fields) !=
 432                 BT_CTF_TYPE_ID_STRUCT) {
 433                 ret = -1;
 434                 goto end;
 435         }
 436
 437         ret = bt_ctf_field_type_structure_get_field(event_class->fields,
 438                 field_name, field_type, index);
 439 end:
 440         return ret;
 441 }
 442
 443 struct bt_ctf_field_type *bt_ctf_event_class_get_field_by_name(
 444                 struct bt_ctf_event_class *event_class, const char *name)
 445 {
 446         GQuark name_quark;
 447         struct bt_ctf_field_type *field_type = NULL;
 448
 449         if (!event_class || !name) {
 450                 goto end;
 451         }
 452
 453         if (bt_ctf_field_type_get_type_id(event_class->fields) !=
 454                 BT_CTF_TYPE_ID_STRUCT) {
 455                 goto end;
 456         }
 457
 458         name_quark = g_quark_try_string(name);
 459         if (!name_quark) {
 460                 goto end;
 461         }
 462
 463         /*
 464          * No need to increment field_type's reference count since getting it
 465          * from the structure already does.
 466          */
 467         field_type = bt_ctf_field_type_structure_get_field_type_by_name(
 468                 event_class->fields, name);
 469 end:
 470         return field_type;
 471 }
 472
 473 struct bt_ctf_field_type *bt_ctf_event_class_get_context_type(
 474                 struct bt_ctf_event_class *event_class)
 475 {
 476         struct bt_ctf_field_type *context_type = NULL;
 477
 478         if (!event_class || !event_class->context) {
 479                 goto end;
 480         }
 481
 482         bt_get(event_class->context);
 483         context_type = event_class->context;
 484 end:
 485         return context_type;
 486 }
 487
 488 int bt_ctf_event_class_set_context_type(
 489                 struct bt_ctf_event_class *event_class,
 490                 struct bt_ctf_field_type *context)
 491 {
 492         int ret = 0;
 493
 494         if (!event_class || event_class->frozen) {
 495                 ret = -1;
 496                 goto end;
 497         }
 498
 499         if (context && bt_ctf_field_type_get_type_id(context) !=
 500                         BT_CTF_TYPE_ID_STRUCT) {
 501                 ret = -1;
 502                 goto end;
 503         }
 504
 505         bt_put(event_class->context);
 506         event_class->context = bt_get(context);
 507 end:
 508         return ret;
 509
 510 }
 511
 512 void bt_ctf_event_class_get(struct bt_ctf_event_class *event_class)
 513 {
 514         bt_get(event_class);
 515 }
 516
 517 void bt_ctf_event_class_put(struct bt_ctf_event_class *event_class)
 518 {
 519         bt_put(event_class);
 520 }
 521
 522 BT_HIDDEN
 523 int bt_ctf_event_class_set_stream_id(struct bt_ctf_event_class *event_class,
 524                 uint32_t stream_id)
 525 {
 526         int ret = 0;
 527         struct bt_value *obj;
 528
 529         obj = bt_value_integer_create_init(stream_id);
 530
 531         if (!obj) {
 532                 ret = -1;
 533                 goto end;
 534         }
 535
 536         ret = bt_ctf_attributes_set_field_value(event_class->attributes,
 537                 "stream_id", obj);
 538
 539         if (event_class->frozen) {
 540                 bt_ctf_attributes_freeze(event_class->attributes);
 541         }
 542
 543 end:
 544         BT_PUT(obj);
 545         return ret;
 546 }
 547
 548 static
 549 void bt_ctf_event_class_destroy(struct bt_object *obj)
 550 {
 551         struct bt_ctf_event_class *event_class;
 552
 553         event_class = container_of(obj, struct bt_ctf_event_class, base);
 554         bt_ctf_attributes_destroy(event_class->attributes);
 555         bt_put(event_class->context);
 556         bt_put(event_class->fields);
 557         g_free(event_class);
 558 }
 559
 560 BT_HIDDEN
 561 void bt_ctf_event_class_freeze(struct bt_ctf_event_class *event_class)
 562 {
 563         assert(event_class);
 564         event_class->frozen = 1;
 565         event_class->name = bt_ctf_event_class_get_name(event_class);
 566         event_class->id = bt_ctf_event_class_get_id(event_class);
 567         bt_ctf_field_type_freeze(event_class->context);
 568         bt_ctf_field_type_freeze(event_class->fields);
 569         bt_ctf_attributes_freeze(event_class->attributes);
 570 }
 571
 572 BT_HIDDEN
 573 int bt_ctf_event_class_serialize(struct bt_ctf_event_class *event_class,
 574                 struct metadata_context *context)
 575 {
 576         int i;
 577         int count;
 578         int ret = 0;
 579         struct bt_value *attr_value = NULL;
 580
 581         assert(event_class);
 582         assert(context);
 583
 584         context->current_indentation_level = 1;
 585         g_string_assign(context->field_name, "");
 586         g_string_append(context->string, "event {\n");
 587         count = bt_ctf_event_class_get_attribute_count(event_class);
 588
 589         if (count < 0) {
 590                 ret = -1;
 591                 goto end;
 592         }
 593
 594         for (i = 0; i < count; ++i) {
 595                 const char *attr_name = NULL;
 596
 597                 attr_name = bt_ctf_event_class_get_attribute_name(
 598                         event_class, i);
 599                 attr_value = bt_ctf_event_class_get_attribute_value(
 600                         event_class, i);
 601
 602                 if (!attr_name || !attr_value) {
 603                         ret = -1;
 604                         goto end;
 605                 }
 606
 607                 switch (bt_value_get_type(attr_value)) {
 608                 case BT_VALUE_TYPE_INTEGER:
 609                 {
 610                         int64_t value;
 611
 612                         ret = bt_value_integer_get(attr_value, &value);
 613
 614                         if (ret) {
 615                                 goto end;
 616                         }
 617
 618                         g_string_append_printf(context->string,
 619                                 "\t%s = %" PRId64 ";\n", attr_name, value);
 620                         break;
 621                 }
 622
 623                 case BT_VALUE_TYPE_STRING:
 624                 {
 625                         const char *value;
 626
 627                         ret = bt_value_string_get(attr_value, &value);
 628
 629                         if (ret) {
 630                                 goto end;
 631                         }
 632
 633                         g_string_append_printf(context->string,
 634                                 "\t%s = \"%s\";\n", attr_name, value);
 635                         break;
 636                 }
 637
 638                 default:
 639                         /* should never happen */
 640                         assert(false);
 641                         break;
 642                 }
 643
 644                 BT_PUT(attr_value);
 645         }
 646
 647         if (event_class->context) {
 648                 g_string_append(context->string, "\tcontext := ");
 649                 ret = bt_ctf_field_type_serialize(event_class->context,
 650                         context);
 651                 if (ret) {
 652                         goto end;
 653                 }
 654                 g_string_append(context->string, ";\n");
 655         }
 656
 657         if (event_class->fields) {
 658                 g_string_append(context->string, "\tfields := ");
 659                 ret = bt_ctf_field_type_serialize(event_class->fields, context);
 660                 if (ret) {
 661                         goto end;
 662                 }
 663                 g_string_append(context->string, ";\n");
 664         }
 665
 666         g_string_append(context->string, "};\n\n");
 667 end:
 668         context->current_indentation_level = 0;
 669         BT_PUT(attr_value);
 670         return ret;
 671 }
 672
 673 void bt_ctf_event_class_set_native_byte_order(
 674                 struct bt_ctf_event_class *event_class,
 675                 int byte_order)
 676 {
 677         if (!event_class) {
 678                 return;
 679         }
 680
 681         assert(byte_order == 0 || byte_order == LITTLE_ENDIAN ||
 682                 byte_order == BIG_ENDIAN);
 683
 684         bt_ctf_field_type_set_native_byte_order(event_class->context,
 685                 byte_order);
 686         bt_ctf_field_type_set_native_byte_order(event_class->fields,
 687                 byte_order);
 688 }