formats/ctf/events.c

   1 /*
   2  * ctf/events.c
   3  *
   4  * Babeltrace Library
   5  *
   6  * Copyright 2011-2012 EfficiOS Inc. and Linux Foundation
   7  *
   8  * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   9  *         Julien Desfossez <julien.desfossez@efficios.com>
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining a copy
  12  * of this software and associated documentation files (the "Software"), to deal
  13  * in the Software without restriction, including without limitation the rights
  14  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  15  * copies of the Software, and to permit persons to whom the Software is
  16  * furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be included in
  19  * all copies or substantial portions of the Software.
  20  */
  21
  22 #include <babeltrace/babeltrace.h>
  23 #include <babeltrace/format.h>
  24 #include <babeltrace/ctf/events.h>
  25 #include <babeltrace/ctf-ir/metadata.h>
  26 #include <babeltrace/prio_heap.h>
  27 #include <babeltrace/iterator-internal.h>
  28 #include <babeltrace/ctf/events-internal.h>
  29 #include <babeltrace/ctf/metadata.h>
  30 #include <glib.h>
  31
  32 #include "events-private.h"
  33
  34 /*
  35  * thread local storage to store the last error that occured
  36  * while reading a field, this variable must be accessed by
  37  * bt_ctf_field_get_error only
  38  */
  39 __thread int bt_ctf_last_field_error = 0;
  40
  41 const struct definition *bt_ctf_get_top_level_scope(const struct bt_ctf_event *ctf_event,
  42                 enum bt_ctf_scope scope)
  43 {
  44         struct definition *tmp = NULL;
  45         struct ctf_event_definition *event;
  46
  47         if (!ctf_event)
  48                 return NULL;
  49
  50         event = ctf_event->parent;
  51         switch (scope) {
  52         case BT_TRACE_PACKET_HEADER:
  53                 if (!event->stream)
  54                         goto error;
  55                 if (event->stream->trace_packet_header)
  56                         tmp = &event->stream->trace_packet_header->p;
  57                 break;
  58         case BT_STREAM_PACKET_CONTEXT:
  59                 if (!event->stream)
  60                         goto error;
  61                 if (event->stream->stream_packet_context)
  62                         tmp = &event->stream->stream_packet_context->p;
  63                 break;
  64         case BT_STREAM_EVENT_HEADER:
  65                 if (!event->stream)
  66                         goto error;
  67                 if (event->stream->stream_event_header)
  68                         tmp = &event->stream->stream_event_header->p;
  69                 break;
  70         case BT_STREAM_EVENT_CONTEXT:
  71                 if (!event->stream)
  72                         goto error;
  73                 if (event->stream->stream_event_context)
  74                         tmp = &event->stream->stream_event_context->p;
  75                 break;
  76         case BT_EVENT_CONTEXT:
  77                 if (event->event_context)
  78                         tmp = &event->event_context->p;
  79                 break;
  80         case BT_EVENT_FIELDS:
  81                 if (event->event_fields)
  82                         tmp = &event->event_fields->p;
  83                 break;
  84         }
  85         return tmp;
  86
  87 error:
  88         return NULL;
  89 }
  90
  91 const struct definition *bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
  92                 const struct definition *scope,
  93                 const char *field)
  94 {
  95         struct definition *def;
  96         char *field_underscore;
  97
  98         if (!ctf_event || !scope || !field)
  99                 return NULL;
 100
 101         def = lookup_definition(scope, field);
 102         /*
 103          * optionally a field can have an underscore prefix, try
 104          * to lookup the field with this prefix if it failed
 105          */
 106         if (!def) {
 107                 field_underscore = g_new(char, strlen(field) + 2);
 108                 field_underscore[0] = '_';
 109                 strcpy(&field_underscore[1], field);
 110                 def = lookup_definition(scope, field_underscore);
 111                 g_free(field_underscore);
 112         }
 113         if (bt_ctf_field_type(bt_ctf_get_field_decl(def)) == CTF_TYPE_VARIANT) {
 114                 struct definition_variant *variant_definition;
 115                 variant_definition = container_of(def,
 116                                 struct definition_variant, p);
 117                 return variant_definition->current_field;
 118         }
 119         return def;
 120 }
 121
 122 const struct definition *bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
 123                 const struct definition *field,
 124                 unsigned int index)
 125 {
 126         struct definition *ret = NULL;
 127
 128         if (!ctf_event || !field)
 129                 return NULL;
 130
 131         if (bt_ctf_field_type(bt_ctf_get_field_decl(field)) == CTF_TYPE_ARRAY) {
 132                 struct definition_array *array_definition;
 133                 array_definition = container_of(field,
 134                                 struct definition_array, p);
 135                 ret = array_index(array_definition, index);
 136         } else if (bt_ctf_field_type(bt_ctf_get_field_decl(field)) == CTF_TYPE_SEQUENCE) {
 137                 struct definition_sequence *sequence_definition;
 138                 sequence_definition = container_of(field,
 139                                 struct definition_sequence, p);
 140                 ret = sequence_index(sequence_definition, index);
 141         }
 142         return ret;
 143 }
 144
 145 const char *bt_ctf_event_name(const struct bt_ctf_event *ctf_event)
 146 {
 147         struct ctf_event_declaration *event_class;
 148         struct ctf_stream_declaration *stream_class;
 149         struct ctf_event_definition *event;
 150
 151         if (!ctf_event)
 152                 return NULL;
 153
 154         event = ctf_event->parent;
 155         stream_class = event->stream->stream_class;
 156         event_class = g_ptr_array_index(stream_class->events_by_id,
 157                         event->stream->event_id);
 158         return g_quark_to_string(event_class->name);
 159 }
 160
 161 const char *bt_ctf_field_name(const struct definition *def)
 162 {
 163         if (!def)
 164                 return NULL;
 165
 166         return rem_(g_quark_to_string(def->name));
 167 }
 168
 169 enum ctf_type_id bt_ctf_field_type(const struct declaration *decl)
 170 {
 171         if (!decl)
 172                 return CTF_TYPE_UNKNOWN;
 173
 174         return decl->id;
 175 }
 176
 177 int bt_ctf_get_field_list(const struct bt_ctf_event *ctf_event,
 178                 const struct definition *scope,
 179                 struct definition const * const **list,
 180                 unsigned int *count)
 181 {
 182         if (!ctf_event || !scope || !list || !count)
 183                 return -EINVAL;
 184
 185         switch (bt_ctf_field_type(bt_ctf_get_field_decl(scope))) {
 186         case CTF_TYPE_INTEGER:
 187         case CTF_TYPE_FLOAT:
 188         case CTF_TYPE_STRING:
 189         case CTF_TYPE_ENUM:
 190                 goto error;
 191         case CTF_TYPE_STRUCT:
 192         {
 193                 const struct definition_struct *def_struct;
 194
 195                 def_struct = container_of(scope, const struct definition_struct, p);
 196                 if (!def_struct)
 197                         goto error;
 198                 if (def_struct->fields->pdata) {
 199                         *list = (struct definition const* const*) def_struct->fields->pdata;
 200                         *count = def_struct->fields->len;
 201                         goto end;
 202                 } else {
 203                         goto error;
 204                 }
 205                 break;
 206         }
 207         case CTF_TYPE_UNTAGGED_VARIANT:
 208                 goto error;
 209         case CTF_TYPE_VARIANT:
 210         {
 211                 const struct definition_variant *def_variant;
 212
 213                 def_variant = container_of(scope, const struct definition_variant, p);
 214                 if (!def_variant)
 215                         goto error;
 216                 if (def_variant->fields->pdata) {
 217                         *list = (struct definition const* const*) def_variant->fields->pdata;
 218                         *count = def_variant->fields->len;
 219                         goto end;
 220                 } else {
 221                         goto error;
 222                 }
 223                 break;
 224         }
 225         case CTF_TYPE_ARRAY:
 226         {
 227                 const struct definition_array *def_array;
 228
 229                 def_array = container_of(scope, const struct definition_array, p);
 230                 if (!def_array)
 231                         goto error;
 232                 if (def_array->elems->pdata) {
 233                         *list = (struct definition const* const*) def_array->elems->pdata;
 234                         *count = def_array->elems->len;
 235                         goto end;
 236                 } else {
 237                         goto error;
 238                 }
 239                 break;
 240         }
 241         case CTF_TYPE_SEQUENCE:
 242         {
 243                 const struct definition_sequence *def_sequence;
 244
 245                 def_sequence = container_of(scope, const struct definition_sequence, p);
 246                 if (!def_sequence)
 247                         goto error;
 248                 if (def_sequence->elems->pdata) {
 249                         *list = (struct definition const* const*) def_sequence->elems->pdata;
 250                         *count = def_sequence->elems->len;
 251                         goto end;
 252                 } else {
 253                         goto error;
 254                 }
 255                 break;
 256         }
 257         default:
 258                 break;
 259         }
 260
 261 end:
 262         return 0;
 263
 264 error:
 265         *list = NULL;
 266         *count = 0;
 267         return -1;
 268 }
 269
 270 struct bt_context *bt_ctf_event_get_context(const struct bt_ctf_event *ctf_event)
 271 {
 272         struct bt_context *ret = NULL;
 273         struct ctf_file_stream *cfs;
 274         struct ctf_trace *trace;
 275         struct ctf_event_definition *event;
 276
 277         if (!ctf_event)
 278                 return NULL;
 279
 280         event = ctf_event->parent;
 281         cfs = container_of(event->stream, struct ctf_file_stream,
 282                         parent);
 283         trace = cfs->parent.stream_class->trace;
 284         if (trace->ctx)
 285                 ret = trace->ctx;
 286
 287         return ret;
 288 }
 289
 290 int bt_ctf_event_get_handle_id(const struct bt_ctf_event *ctf_event)
 291 {
 292         int ret = -1;
 293         struct ctf_file_stream *cfs;
 294         struct ctf_trace *trace;
 295         struct ctf_event_definition *event;
 296
 297         if (!ctf_event)
 298                 return -EINVAL;
 299
 300         event = ctf_event->parent;
 301         cfs = container_of(event->stream, struct ctf_file_stream,
 302                         parent);
 303         trace = cfs->parent.stream_class->trace;
 304         if (trace->handle)
 305                 ret = trace->handle->id;
 306
 307         return ret;
 308 }
 309
 310 uint64_t bt_ctf_get_timestamp(const struct bt_ctf_event *ctf_event)
 311 {
 312         struct ctf_event_definition *event;
 313
 314         if (!ctf_event)
 315                 return -1ULL;
 316
 317         event = ctf_event->parent;
 318         if (event && event->stream->has_timestamp)
 319                 return event->stream->real_timestamp;
 320         else
 321                 return -1ULL;
 322 }
 323
 324 uint64_t bt_ctf_get_cycles(const struct bt_ctf_event *ctf_event)
 325 {
 326         struct ctf_event_definition *event;
 327
 328         if (!ctf_event)
 329                 return -1ULL;
 330
 331         event = ctf_event->parent;
 332         if (event && event->stream->has_timestamp)
 333                 return event->stream->cycles_timestamp;
 334         else
 335                 return -1ULL;
 336 }
 337
 338 static void bt_ctf_field_set_error(int error)
 339 {
 340         bt_ctf_last_field_error = error;
 341 }
 342
 343 int bt_ctf_field_get_error(void)
 344 {
 345         int ret;
 346         ret = bt_ctf_last_field_error;
 347         bt_ctf_last_field_error = 0;
 348
 349         return ret;
 350 }
 351
 352 static struct declaration_integer *get_declaration_integer(const struct declaration *decl)
 353 {
 354         struct declaration_field *field_decl;
 355         struct declaration_integer *ret = NULL;
 356
 357         if (decl && bt_ctf_field_type(decl) == CTF_TYPE_INTEGER) {
 358                 field_decl = (struct declaration_field *) decl;
 359                 ret = ((struct declaration_integer *) field_decl->declaration);
 360         }
 361
 362         return ret;
 363 }
 364
 365 static struct declaration_string *get_declaration_string(const struct declaration *decl)
 366 {
 367         struct declaration_field *field_decl;
 368         struct declaration_string *ret = NULL;
 369
 370         if (decl && bt_ctf_field_type(decl) == CTF_TYPE_STRING) {
 371                 field_decl = (struct declaration_field *) decl;
 372                 ret = ((struct declaration_string *) field_decl->declaration);
 373         }
 374
 375         return ret;
 376 }
 377
 378 static struct declaration_array *get_declaration_array(const struct declaration *decl)
 379 {
 380         struct declaration_field *field_decl;
 381         struct declaration_array *ret = NULL;
 382
 383         if (decl && bt_ctf_field_type(decl) == CTF_TYPE_ARRAY) {
 384                 field_decl = (struct declaration_field *) decl;
 385                 ret = ((struct declaration_array *) field_decl->declaration);
 386         }
 387
 388         return ret;
 389 }
 390
 391 int bt_ctf_get_int_signedness(const struct declaration *decl)
 392 {
 393         int ret;
 394         struct declaration_integer *integer;
 395
 396         integer = get_declaration_integer(decl);
 397         if (integer) {
 398                 ret = integer->signedness;
 399         } else {
 400                 ret = -EINVAL;
 401                 bt_ctf_field_set_error(-EINVAL);
 402         }
 403
 404         return ret;
 405 }
 406
 407 int bt_ctf_get_int_base(const struct declaration *decl)
 408 {
 409         int ret;
 410         struct declaration_integer *integer;
 411
 412         integer = get_declaration_integer(decl);
 413         if (integer) {
 414                 ret = integer->base;
 415         } else {
 416                 ret = -EINVAL;
 417                 bt_ctf_field_set_error(-EINVAL);
 418         }
 419
 420         return ret;
 421 }
 422
 423 int bt_ctf_get_int_byte_order(const struct declaration *decl)
 424 {
 425         int ret;
 426         struct declaration_integer *integer;
 427
 428         integer = get_declaration_integer(decl);
 429         if (integer) {
 430                 ret = integer->byte_order;
 431         } else {
 432                 ret = -EINVAL;
 433                 bt_ctf_field_set_error(-EINVAL);
 434         }
 435
 436         return ret;
 437 }
 438
 439 ssize_t bt_ctf_get_int_len(const struct declaration *decl)
 440 {
 441         ssize_t ret;
 442         struct declaration_integer *integer;
 443
 444         integer = get_declaration_integer(decl);
 445         if (integer) {
 446                 ret = (ssize_t) integer->len;
 447         } else {
 448                 ret = -EINVAL;
 449                 bt_ctf_field_set_error(-EINVAL);
 450         }
 451
 452         return ret;
 453 }
 454
 455 const struct definition *bt_ctf_get_enum_int(const struct definition *field)
 456 {
 457         struct definition_enum *def_enum;
 458
 459         if (!field || bt_ctf_field_type(bt_ctf_get_field_decl(field)) != CTF_TYPE_ENUM) {
 460                 bt_ctf_field_set_error(-EINVAL);
 461                 return NULL;
 462         }
 463         def_enum = container_of(field, struct definition_enum, p);
 464         return &def_enum->integer->p;
 465 }
 466
 467 const char *bt_ctf_get_enum_str(const struct definition *field)
 468 {
 469         struct definition_enum *def_enum;
 470         struct declaration_enum *decl_enum;
 471         GArray *array;
 472         const char *ret;
 473
 474         if (!field || bt_ctf_field_type(bt_ctf_get_field_decl(field)) != CTF_TYPE_ENUM) {
 475                 bt_ctf_field_set_error(-EINVAL);
 476                 return NULL;
 477         }
 478         def_enum = container_of(field, struct definition_enum, p);
 479         decl_enum = def_enum->declaration;
 480         if (get_int_signedness(&def_enum->integer->p)) {
 481                 array = enum_int_to_quark_set(decl_enum,
 482                         get_signed_int(&def_enum->integer->p));
 483         } else {
 484                 array = enum_uint_to_quark_set(decl_enum,
 485                         get_unsigned_int(&def_enum->integer->p));
 486         }
 487         if (!array) {
 488                 bt_ctf_field_set_error(-ENOENT);
 489                 return NULL;
 490         }
 491
 492         if (array->len == 0) {
 493                 g_array_unref(array);
 494                 bt_ctf_field_set_error(-ENOENT);
 495                 return NULL;
 496         }
 497         /* Return first string. Arbitrary choice. */
 498         ret = g_quark_to_string(g_array_index(array, GQuark, 0));
 499         g_array_unref(array);
 500         return ret;
 501 }
 502
 503 enum ctf_string_encoding bt_ctf_get_encoding(const struct declaration *decl)
 504 {
 505         enum ctf_string_encoding ret = 0;
 506         struct declaration_integer *integer;
 507         struct declaration_string *string;
 508
 509         if (!decl)
 510                 goto error;
 511
 512         if (bt_ctf_field_type(decl) == CTF_TYPE_INTEGER) {
 513                 integer = get_declaration_integer(decl);
 514                 if (integer) {
 515                         ret = integer->encoding;
 516                 } else {
 517                         goto error;
 518                 }
 519         } else if (bt_ctf_field_type(decl) == CTF_TYPE_STRING) {
 520                 string = get_declaration_string(decl);
 521                 if (string) {
 522                         ret = string->encoding;
 523                 } else {
 524                         goto error;
 525                 }
 526         } else {
 527                 goto error;
 528         }
 529         return ret;
 530
 531 error:
 532         bt_ctf_field_set_error(-EINVAL);
 533         return -1;
 534 }
 535
 536 int bt_ctf_get_array_len(const struct declaration *decl)
 537 {
 538         int ret;
 539         struct declaration_array *array;
 540
 541         if (decl && bt_ctf_field_type(decl) == CTF_TYPE_ARRAY) {
 542                 array = get_declaration_array(decl);
 543                 if (array) {
 544                         ret = array->len;
 545                 } else {
 546                         goto error;
 547                 }
 548         } else {
 549                 goto error;
 550         }
 551
 552         return ret;
 553
 554 error:
 555         bt_ctf_field_set_error(-EINVAL);
 556         return -1;
 557 }
 558
 559 uint64_t bt_ctf_get_uint64(const struct definition *field)
 560 {
 561         uint64_t ret = 0;
 562
 563         if (field && bt_ctf_field_type(bt_ctf_get_field_decl(field)) == CTF_TYPE_INTEGER)
 564                 ret = get_unsigned_int(field);
 565         else
 566                 bt_ctf_field_set_error(-EINVAL);
 567
 568         return ret;
 569 }
 570
 571 int64_t bt_ctf_get_int64(const struct definition *field)
 572 {
 573         int64_t ret = 0;
 574
 575         if (field && bt_ctf_field_type(bt_ctf_get_field_decl(field)) == CTF_TYPE_INTEGER)
 576                 ret = get_signed_int(field);
 577         else
 578                 bt_ctf_field_set_error(-EINVAL);
 579
 580         return ret;
 581
 582 }
 583
 584 char *bt_ctf_get_char_array(const struct definition *field)
 585 {
 586         char *ret = NULL;
 587         GString *char_array;
 588
 589         if (field && bt_ctf_field_type(bt_ctf_get_field_decl(field)) == CTF_TYPE_ARRAY) {
 590                 char_array = get_char_array(field);
 591                 if (char_array) {
 592                         ret = char_array->str;
 593                         goto end;
 594                 }
 595         }
 596         bt_ctf_field_set_error(-EINVAL);
 597
 598 end:
 599         return ret;
 600 }
 601
 602 char *bt_ctf_get_string(const struct definition *field)
 603 {
 604         char *ret = NULL;
 605
 606         if (field && bt_ctf_field_type(bt_ctf_get_field_decl(field)) == CTF_TYPE_STRING)
 607                 ret = get_string(field);
 608         else
 609                 bt_ctf_field_set_error(-EINVAL);
 610
 611         return ret;
 612 }
 613
 614 int bt_ctf_get_event_decl_list(int handle_id, struct bt_context *ctx,
 615                 struct bt_ctf_event_decl * const **list,
 616                 unsigned int *count)
 617 {
 618         struct bt_trace_handle *handle;
 619         struct trace_descriptor *td;
 620         struct ctf_trace *tin;
 621
 622         if (!ctx || !list || !count)
 623                 goto error;
 624
 625         handle = g_hash_table_lookup(ctx->trace_handles,
 626                         (gpointer) (unsigned long) handle_id);
 627         if (!handle)
 628                 goto error;
 629
 630         td = handle->td;
 631         tin = container_of(td, struct ctf_trace, parent);
 632
 633         *list = (struct bt_ctf_event_decl * const*) tin->event_declarations->pdata;
 634         *count = tin->event_declarations->len;
 635         return 0;
 636
 637 error:
 638         return -1;
 639 }
 640
 641 const char *bt_ctf_get_decl_event_name(const struct bt_ctf_event_decl *event)
 642 {
 643         if (!event)
 644                 return NULL;
 645
 646         return g_quark_to_string(event->parent.name);
 647 }
 648
 649 int bt_ctf_get_decl_fields(struct bt_ctf_event_decl *event_decl,
 650                 enum bt_ctf_scope scope,
 651                 struct bt_ctf_field_decl const * const **list,
 652                 unsigned int *count)
 653 {
 654         int i;
 655         GArray *fields = NULL;
 656         gpointer *ret_list = NULL;
 657         GPtrArray *fields_array = NULL;
 658         int ret = 0;
 659         *count = 0;
 660
 661         if (!event_decl || !list || !count)
 662                 return -EINVAL;
 663
 664         switch (scope) {
 665         case BT_EVENT_CONTEXT:
 666                 if (event_decl->context_decl) {
 667                         ret_list = event_decl->context_decl->pdata;
 668                         *count = event_decl->context_decl->len;
 669                         goto end;
 670                 }
 671                 event_decl->context_decl = g_ptr_array_new();
 672                 if (!event_decl->parent.context_decl) {
 673                         ret = -1;
 674                         goto end;
 675                 }
 676                 fields = event_decl->parent.context_decl->fields;
 677                 fields_array = event_decl->context_decl;
 678                 break;
 679         case BT_EVENT_FIELDS:
 680                 if (event_decl->fields_decl) {
 681                         ret_list = event_decl->fields_decl->pdata;
 682                         *count = event_decl->fields_decl->len;
 683                         goto end;
 684                 }
 685                 event_decl->fields_decl = g_ptr_array_new();
 686                 if (!event_decl->parent.fields_decl) {
 687                         ret = -1;
 688                         goto end;
 689                 }
 690                 fields = event_decl->parent.fields_decl->fields;
 691                 fields_array = event_decl->fields_decl;
 692                 break;
 693         case BT_STREAM_PACKET_CONTEXT:
 694                 if (event_decl->packet_context_decl) {
 695                         ret_list = event_decl->packet_context_decl->pdata;
 696                         *count = event_decl->packet_context_decl->len;
 697                         goto end;
 698                 }
 699                 event_decl->packet_context_decl = g_ptr_array_new();
 700                 if (!event_decl->parent.stream->packet_context_decl) {
 701                         ret = -1;
 702                         goto end;
 703                 }
 704                 fields = event_decl->parent.stream->packet_context_decl->fields;
 705                 fields_array = event_decl->packet_context_decl;
 706                 break;
 707         case BT_STREAM_EVENT_CONTEXT:
 708                 if (event_decl->event_context_decl) {
 709                         ret_list = event_decl->event_context_decl->pdata;
 710                         *count = event_decl->event_context_decl->len;
 711                         goto end;
 712                 }
 713                 event_decl->event_context_decl = g_ptr_array_new();
 714                 if (!event_decl->parent.stream->event_context_decl) {
 715                         ret = -1;
 716                         goto end;
 717                 }
 718                 fields = event_decl->parent.stream->event_context_decl->fields;
 719                 fields_array = event_decl->event_context_decl;
 720                 break;
 721         case BT_STREAM_EVENT_HEADER:
 722                 if (event_decl->event_header_decl) {
 723                         ret_list = event_decl->event_header_decl->pdata;
 724                         *count = event_decl->event_header_decl->len;
 725                         goto end;
 726                 }
 727                 event_decl->event_header_decl = g_ptr_array_new();
 728                 if (!event_decl->parent.stream->event_header_decl) {
 729                         ret = -1;
 730                         goto end;
 731                 }
 732                 fields = event_decl->parent.stream->event_header_decl->fields;
 733                 fields_array = event_decl->event_header_decl;
 734                 break;
 735         case BT_TRACE_PACKET_HEADER:
 736                 if (event_decl->packet_header_decl) {
 737                         ret_list = event_decl->packet_header_decl->pdata;
 738                         *count = event_decl->packet_header_decl->len;
 739                         goto end;
 740                 }
 741                 event_decl->packet_header_decl = g_ptr_array_new();
 742                 if (!event_decl->parent.stream->trace->packet_header_decl) {
 743                         ret = -1;
 744                         goto end;
 745                 }
 746                 fields = event_decl->parent.stream->trace->packet_header_decl->fields;
 747                 fields_array = event_decl->packet_header_decl;
 748                 break;
 749         }
 750
 751         for (i = 0; i < fields->len; i++) {
 752                 g_ptr_array_add(fields_array,
 753                                 &g_array_index(fields,
 754                                         struct declaration_field, i));
 755         }
 756         ret_list = fields_array->pdata;
 757         *count = fields->len;
 758
 759 end:
 760         *list = (struct bt_ctf_field_decl const* const*) ret_list;
 761
 762         return ret;
 763 }
 764
 765 const char *bt_ctf_get_decl_field_name(const struct bt_ctf_field_decl *field)
 766 {
 767         if (!field)
 768                 return NULL;
 769
 770         return rem_(g_quark_to_string(((struct declaration_field *) field)->name));
 771 }
 772
 773 const struct declaration *bt_ctf_get_field_decl(const struct definition *def)
 774 {
 775         if (def)
 776                 return def->declaration;
 777
 778         return NULL;
 779 }