formats/ctf/writer/writer.c

   1 /*
   2  * writer.c
   3  *
   4  * Babeltrace CTF Writer
   5  *
   6  * Copyright 2013 EfficiOS Inc.
   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/writer.h>
  30 #include <babeltrace/ctf-writer/clock.h>
  31 #include <babeltrace/ctf-writer/clock-internal.h>
  32 #include <babeltrace/ctf-writer/writer-internal.h>
  33 #include <babeltrace/ctf-writer/event-types-internal.h>
  34 #include <babeltrace/ctf-writer/event-fields-internal.h>
  35 #include <babeltrace/ctf-writer/functor-internal.h>
  36 #include <babeltrace/ctf-writer/stream-internal.h>
  37 #include <babeltrace/ctf-writer/stream.h>
  38 #include <babeltrace/compiler.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <sys/stat.h>
  42 #include <errno.h>
  43 #include <unistd.h>
  44 #include <fcntl.h>
  45 #include <inttypes.h>
  46
  47 #define DEFAULT_IDENTIFIER_SIZE 128
  48 #define DEFAULT_METADATA_STRING_SIZE 4096
  49
  50 static
  51 void environment_variable_destroy(struct environment_variable *var);
  52 static
  53 void bt_ctf_writer_destroy(struct bt_ctf_ref *ref);
  54 static
  55 int init_trace_packet_header(struct bt_ctf_writer *writer);
  56 static
  57 int create_stream_file(struct bt_ctf_writer *writer,
  58                 struct bt_ctf_stream *stream);
  59 static
  60 void stream_flush_cb(struct bt_ctf_stream *stream,
  61                 struct bt_ctf_writer *writer);
  62
  63 static
  64 const char * const reserved_keywords_str[] = {"align", "callsite",
  65         "const", "char", "clock", "double", "enum", "env", "event",
  66         "floating_point", "float", "integer", "int", "long", "short", "signed",
  67         "stream", "string", "struct", "trace", "typealias", "typedef",
  68         "unsigned", "variant", "void" "_Bool", "_Complex", "_Imaginary"};
  69
  70 static
  71 const unsigned int field_type_aliases_alignments[] = {
  72         [FIELD_TYPE_ALIAS_UINT5_T] = 1,
  73         [FIELD_TYPE_ALIAS_UINT8_T ... FIELD_TYPE_ALIAS_UINT16_T] = 8,
  74         [FIELD_TYPE_ALIAS_UINT27_T] = 1,
  75         [FIELD_TYPE_ALIAS_UINT32_T ... FIELD_TYPE_ALIAS_UINT64_T] = 8,
  76 };
  77
  78 static
  79 const unsigned int field_type_aliases_sizes[] = {
  80         [FIELD_TYPE_ALIAS_UINT5_T] = 5,
  81         [FIELD_TYPE_ALIAS_UINT8_T] = 8,
  82         [FIELD_TYPE_ALIAS_UINT16_T] = 16,
  83         [FIELD_TYPE_ALIAS_UINT27_T] = 27,
  84         [FIELD_TYPE_ALIAS_UINT32_T] = 32,
  85         [FIELD_TYPE_ALIAS_UINT64_T] = 64,
  86 };
  87
  88 static GHashTable *reserved_keywords_set;
  89 static int init_done;
  90 static int global_data_refcount;
  91
  92 struct bt_ctf_writer *bt_ctf_writer_create(const char *path)
  93 {
  94         struct bt_ctf_writer *writer = NULL;
  95
  96         if (!path) {
  97                 goto error;
  98         }
  99
 100         writer = g_new0(struct bt_ctf_writer, 1);
 101         if (!writer) {
 102                 goto error;
 103         }
 104
 105         bt_ctf_writer_set_byte_order(writer, BT_CTF_BYTE_ORDER_NATIVE);
 106         bt_ctf_ref_init(&writer->ref_count);
 107         writer->path = g_string_new(path);
 108         if (!writer->path) {
 109                 goto error_destroy;
 110         }
 111
 112         /* Create trace directory if necessary and open a metadata file */
 113         if (g_mkdir_with_parents(path, S_IRWXU | S_IRWXG)) {
 114                 perror("g_mkdir_with_parents");
 115                 goto error_destroy;
 116         }
 117
 118         writer->trace_dir_fd = open(path, O_RDONLY, S_IRWXU | S_IRWXG);
 119         if (writer->trace_dir_fd < 0) {
 120                 perror("open");
 121                 goto error_destroy;
 122         }
 123
 124         writer->metadata_fd = openat(writer->trace_dir_fd, "metadata",
 125                 O_WRONLY | O_CREAT | O_TRUNC,
 126                 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
 127         writer->environment = g_ptr_array_new_with_free_func(
 128                 (GDestroyNotify)environment_variable_destroy);
 129         writer->clocks = g_ptr_array_new_with_free_func(
 130                 (GDestroyNotify)bt_ctf_clock_put);
 131         writer->streams = g_ptr_array_new_with_free_func(
 132                 (GDestroyNotify)bt_ctf_stream_put);
 133         writer->stream_classes = g_ptr_array_new_with_free_func(
 134                 (GDestroyNotify)bt_ctf_stream_class_put);
 135         if (!writer->environment || !writer->clocks ||
 136                 !writer->stream_classes || !writer->streams) {
 137                 goto error_destroy;
 138         }
 139
 140         /* Generate a trace UUID */
 141         uuid_generate(writer->uuid);
 142         if (init_trace_packet_header(writer)) {
 143                 goto error_destroy;
 144         }
 145
 146         return writer;
 147 error_destroy:
 148         unlinkat(writer->trace_dir_fd, "metadata", 0);
 149         bt_ctf_writer_destroy(&writer->ref_count);
 150         writer = NULL;
 151 error:
 152         return writer;
 153 }
 154
 155 void bt_ctf_writer_destroy(struct bt_ctf_ref *ref)
 156 {
 157         struct bt_ctf_writer *writer;
 158
 159         if (!ref) {
 160                 return;
 161         }
 162
 163         writer = container_of(ref, struct bt_ctf_writer, ref_count);
 164         bt_ctf_writer_flush_metadata(writer);
 165         if (writer->path) {
 166                 g_string_free(writer->path, TRUE);
 167         }
 168
 169         if (writer->trace_dir_fd > 0) {
 170                 if (close(writer->trace_dir_fd)) {
 171                         perror("close");
 172                         abort();
 173                 }
 174         }
 175
 176         if (writer->metadata_fd > 0) {
 177                 if (close(writer->metadata_fd)) {
 178                         perror("close");
 179                         abort();
 180                 }
 181         }
 182
 183         if (writer->environment) {
 184                 g_ptr_array_free(writer->environment, TRUE);
 185         }
 186
 187         if (writer->clocks) {
 188                 g_ptr_array_free(writer->clocks, TRUE);
 189         }
 190
 191         if (writer->streams) {
 192                 g_ptr_array_free(writer->streams, TRUE);
 193         }
 194
 195         if (writer->stream_classes) {
 196                 g_ptr_array_free(writer->stream_classes, TRUE);
 197         }
 198
 199         bt_ctf_field_type_put(writer->trace_packet_header_type);
 200         bt_ctf_field_put(writer->trace_packet_header);
 201         g_free(writer);
 202 }
 203
 204 struct bt_ctf_stream *bt_ctf_writer_create_stream(struct bt_ctf_writer *writer,
 205                 struct bt_ctf_stream_class *stream_class)
 206 {
 207         int ret;
 208         int stream_class_found = 0;
 209         size_t i;
 210         int stream_fd;
 211         struct bt_ctf_stream *stream = NULL;
 212
 213         if (!writer || !stream_class) {
 214                 goto error;
 215         }
 216
 217         stream = bt_ctf_stream_create(stream_class);
 218         if (!stream) {
 219                 goto error;
 220         }
 221
 222         stream_fd = create_stream_file(writer, stream);
 223         if (stream_fd < 0 || bt_ctf_stream_set_fd(stream, stream_fd)) {
 224                 goto error;
 225         }
 226
 227         bt_ctf_stream_set_flush_callback(stream, (flush_func)stream_flush_cb,
 228                 writer);
 229         ret = bt_ctf_stream_class_set_byte_order(stream->stream_class,
 230                 writer->byte_order == LITTLE_ENDIAN ?
 231                 BT_CTF_BYTE_ORDER_LITTLE_ENDIAN : BT_CTF_BYTE_ORDER_BIG_ENDIAN);
 232         if (ret) {
 233                 goto error;
 234         }
 235
 236         for (i = 0; i < writer->stream_classes->len; i++) {
 237                 if (writer->stream_classes->pdata[i] == stream->stream_class) {
 238                         stream_class_found = 1;
 239                 }
 240         }
 241
 242         if (!stream_class_found) {
 243                 if (bt_ctf_stream_class_set_id(stream->stream_class,
 244                         writer->next_stream_id++)) {
 245                         goto error;
 246                 }
 247
 248                 bt_ctf_stream_class_get(stream->stream_class);
 249                 g_ptr_array_add(writer->stream_classes, stream->stream_class);
 250         }
 251
 252         bt_ctf_stream_get(stream);
 253         g_ptr_array_add(writer->streams, stream);
 254         writer->frozen = 1;
 255         return stream;
 256 error:
 257         bt_ctf_stream_put(stream);
 258         return NULL;
 259 }
 260
 261 int bt_ctf_writer_add_environment_field(struct bt_ctf_writer *writer,
 262                 const char *name,
 263                 const char *value)
 264 {
 265         struct environment_variable *var = NULL;
 266         char *escaped_value = NULL;
 267         int ret = 0;
 268
 269         if (!writer || !name || !value || validate_identifier(name)) {
 270                 ret = -1;
 271                 goto error;
 272         }
 273
 274         if (strchr(name, ' ')) {
 275                 ret = -1;
 276                 goto error;
 277         }
 278
 279         var = g_new0(struct environment_variable, 1);
 280         if (!var) {
 281                 ret = -1;
 282                 goto error;
 283         }
 284
 285         escaped_value = g_strescape(value, NULL);
 286         if (!escaped_value) {
 287                 ret = -1;
 288                 goto error;
 289         }
 290
 291         var->name = g_string_new(name);
 292         var->value = g_string_new(escaped_value);
 293         g_free(escaped_value);
 294         if (!var->name || !var->value) {
 295                 ret = -1;
 296                 goto error;
 297         }
 298
 299         g_ptr_array_add(writer->environment, var);
 300         return ret;
 301
 302 error:
 303         if (var && var->name) {
 304                 g_string_free(var->name, TRUE);
 305         }
 306
 307         if (var && var->value) {
 308                 g_string_free(var->value, TRUE);
 309         }
 310
 311         g_free(var);
 312         return ret;
 313 }
 314
 315 int bt_ctf_writer_add_clock(struct bt_ctf_writer *writer,
 316                 struct bt_ctf_clock *clock)
 317 {
 318         int ret = 0;
 319         struct search_query query = { .value = clock, .found = 0 };
 320
 321         if (!writer || !clock) {
 322                 ret = -1;
 323                 goto end;
 324         }
 325
 326         /* Check for duplicate clocks */
 327         g_ptr_array_foreach(writer->clocks, value_exists, &query);
 328         if (query.found) {
 329                 ret = -1;
 330                 goto end;
 331         }
 332
 333         bt_ctf_clock_get(clock);
 334         g_ptr_array_add(writer->clocks, clock);
 335 end:
 336         return ret;
 337 }
 338
 339 BT_HIDDEN
 340 const char *get_byte_order_string(int byte_order)
 341 {
 342         const char *string;
 343
 344         switch (byte_order) {
 345         case LITTLE_ENDIAN:
 346                 string = "le";
 347                 break;
 348         case BIG_ENDIAN:
 349                 string = "be";
 350                 break;
 351         default:
 352                 string = "unknown";
 353                 break;
 354         }
 355
 356         return string;
 357 }
 358
 359 static
 360 int append_trace_metadata(struct bt_ctf_writer *writer,
 361                 struct metadata_context *context)
 362 {
 363         unsigned char *uuid = writer->uuid;
 364         int ret;
 365
 366         g_string_append(context->string, "trace {\n");
 367
 368         g_string_append(context->string, "\tmajor = 1;\n");
 369         g_string_append(context->string, "\tminor = 8;\n");
 370
 371         g_string_append_printf(context->string,
 372                 "\tuuid = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n",
 373                 uuid[0], uuid[1], uuid[2], uuid[3],
 374                 uuid[4], uuid[5], uuid[6], uuid[7],
 375                 uuid[8], uuid[9], uuid[10], uuid[11],
 376                 uuid[12], uuid[13], uuid[14], uuid[15]);
 377         g_string_append_printf(context->string, "\tbyte_order = %s;\n",
 378                 get_byte_order_string(writer->byte_order));
 379
 380         g_string_append(context->string, "\tpacket.header := ");
 381         context->current_indentation_level++;
 382         g_string_assign(context->field_name, "");
 383         ret = bt_ctf_field_type_serialize(writer->trace_packet_header_type,
 384                 context);
 385         if (ret) {
 386                 goto end;
 387         }
 388         context->current_indentation_level--;
 389
 390         g_string_append(context->string, ";\n};\n\n");
 391 end:
 392         return ret;
 393 }
 394
 395 static
 396 void append_env_field_metadata(struct environment_variable *var,
 397                 struct metadata_context *context)
 398 {
 399         g_string_append_printf(context->string, "\t%s = \"%s\";\n",
 400                 var->name->str, var->value->str);
 401 }
 402
 403 static
 404 void append_env_metadata(struct bt_ctf_writer *writer,
 405                 struct metadata_context *context)
 406 {
 407         if (writer->environment->len == 0) {
 408                 return;
 409         }
 410
 411         g_string_append(context->string, "env {\n");
 412         g_ptr_array_foreach(writer->environment,
 413                 (GFunc)append_env_field_metadata, context);
 414         g_string_append(context->string, "};\n\n");
 415 }
 416
 417 char *bt_ctf_writer_get_metadata_string(struct bt_ctf_writer *writer)
 418 {
 419         char *metadata = NULL;
 420         struct metadata_context *context = NULL;
 421         int err = 0;
 422         size_t i;
 423
 424         if (!writer) {
 425                 goto end;
 426         }
 427
 428         context = g_new0(struct metadata_context, 1);
 429         if (!context) {
 430                 goto end;
 431         }
 432
 433         context->field_name = g_string_sized_new(DEFAULT_IDENTIFIER_SIZE);
 434         context->string = g_string_sized_new(DEFAULT_METADATA_STRING_SIZE);
 435         g_string_append(context->string, "/* CTF 1.8 */\n\n");
 436         if (append_trace_metadata(writer, context)) {
 437                 goto error;
 438         }
 439         append_env_metadata(writer, context);
 440         g_ptr_array_foreach(writer->clocks,
 441                 (GFunc)bt_ctf_clock_serialize, context);
 442
 443         for (i = 0; i < writer->stream_classes->len; i++) {
 444                 err = bt_ctf_stream_class_serialize(
 445                         writer->stream_classes->pdata[i], context);
 446                 if (err) {
 447                         goto error;
 448                 }
 449         }
 450
 451         metadata = context->string->str;
 452 error:
 453         g_string_free(context->string, err ? TRUE : FALSE);
 454         g_string_free(context->field_name, TRUE);
 455         g_free(context);
 456 end:
 457         return metadata;
 458 }
 459
 460 void bt_ctf_writer_flush_metadata(struct bt_ctf_writer *writer)
 461 {
 462         int ret;
 463         char *metadata_string = NULL;
 464
 465         if (!writer) {
 466                 goto end;
 467         }
 468
 469         metadata_string = bt_ctf_writer_get_metadata_string(writer);
 470         if (!metadata_string) {
 471                 goto end;
 472         }
 473
 474         if (lseek(writer->metadata_fd, 0, SEEK_SET) == (off_t)-1) {
 475                 perror("lseek");
 476                 goto end;
 477         }
 478
 479         if (ftruncate(writer->metadata_fd, 0)) {
 480                 perror("ftruncate");
 481                 goto end;
 482         }
 483
 484         ret = write(writer->metadata_fd, metadata_string,
 485                 strlen(metadata_string));
 486         if (ret < 0) {
 487                 perror("write");
 488                 goto end;
 489         }
 490 end:
 491         g_free(metadata_string);
 492 }
 493
 494 int bt_ctf_writer_set_byte_order(struct bt_ctf_writer *writer,
 495                 enum bt_ctf_byte_order byte_order)
 496 {
 497         int ret = 0;
 498         int internal_byte_order;
 499
 500         if (!writer || writer->frozen) {
 501                 ret = -1;
 502                 goto end;
 503         }
 504
 505         switch (byte_order) {
 506         case BT_CTF_BYTE_ORDER_NATIVE:
 507                 internal_byte_order =  (G_BYTE_ORDER == G_LITTLE_ENDIAN) ?
 508                         LITTLE_ENDIAN : BIG_ENDIAN;
 509                 break;
 510         case BT_CTF_BYTE_ORDER_LITTLE_ENDIAN:
 511                 internal_byte_order = LITTLE_ENDIAN;
 512                 break;
 513         case BT_CTF_BYTE_ORDER_BIG_ENDIAN:
 514         case BT_CTF_BYTE_ORDER_NETWORK:
 515                 internal_byte_order = BIG_ENDIAN;
 516                 break;
 517         default:
 518                 ret = -1;
 519                 goto end;
 520         }
 521
 522         writer->byte_order = internal_byte_order;
 523         if (writer->trace_packet_header_type ||
 524                 writer->trace_packet_header) {
 525                 init_trace_packet_header(writer);
 526         }
 527 end:
 528         return ret;
 529 }
 530
 531 void bt_ctf_writer_get(struct bt_ctf_writer *writer)
 532 {
 533         if (!writer) {
 534                 return;
 535         }
 536
 537         bt_ctf_ref_get(&writer->ref_count);
 538 }
 539
 540 void bt_ctf_writer_put(struct bt_ctf_writer *writer)
 541 {
 542         if (!writer) {
 543                 return;
 544         }
 545
 546         bt_ctf_ref_put(&writer->ref_count, bt_ctf_writer_destroy);
 547 }
 548
 549 BT_HIDDEN
 550 int validate_identifier(const char *input_string)
 551 {
 552         int ret = 0;
 553         char *string = NULL;
 554         char *save_ptr, *token;
 555
 556         if (!input_string || input_string[0] == '\0') {
 557                 ret = -1;
 558                 goto end;
 559         }
 560
 561         string = strdup(input_string);
 562         if (!string) {
 563                 ret = -1;
 564                 goto end;
 565         }
 566
 567         token = strtok_r(string, " ", &save_ptr);
 568         while (token) {
 569                 if (g_hash_table_lookup_extended(reserved_keywords_set,
 570                         GINT_TO_POINTER(g_quark_from_string(token)),
 571                         NULL, NULL)) {
 572                         ret = -1;
 573                         goto end;
 574                 }
 575
 576                 token = strtok_r(NULL, " ", &save_ptr);
 577         }
 578 end:
 579         free(string);
 580         return ret;
 581 }
 582
 583 BT_HIDDEN
 584 struct bt_ctf_field_type *get_field_type(enum field_type_alias alias)
 585 {
 586         unsigned int alignment, size;
 587         struct bt_ctf_field_type *field_type;
 588
 589         if (alias >= NR_FIELD_TYPE_ALIAS) {
 590                 return NULL;
 591         }
 592
 593         alignment = field_type_aliases_alignments[alias];
 594         size = field_type_aliases_sizes[alias];
 595         field_type = bt_ctf_field_type_integer_create(size);
 596         bt_ctf_field_type_set_alignment(field_type, alignment);
 597         return field_type;
 598 }
 599
 600 static
 601 int init_trace_packet_header(struct bt_ctf_writer *writer)
 602 {
 603         size_t i;
 604         int ret = 0;
 605         struct bt_ctf_field *trace_packet_header = NULL,
 606                 *magic = NULL, *uuid_array = NULL;
 607         struct bt_ctf_field_type *_uint32_t =
 608                 get_field_type(FIELD_TYPE_ALIAS_UINT32_T);
 609         struct bt_ctf_field_type *_uint8_t =
 610                 get_field_type(FIELD_TYPE_ALIAS_UINT8_T);
 611         struct bt_ctf_field_type *trace_packet_header_type =
 612                 bt_ctf_field_type_structure_create();
 613         struct bt_ctf_field_type *uuid_array_type =
 614                 bt_ctf_field_type_array_create(_uint8_t, 16);
 615
 616         if (!trace_packet_header_type || !uuid_array_type) {
 617                 ret = -1;
 618                 goto end;
 619         }
 620
 621         ret = bt_ctf_field_type_set_byte_order(_uint32_t,
 622                 (writer->byte_order == LITTLE_ENDIAN ?
 623                 BT_CTF_BYTE_ORDER_LITTLE_ENDIAN :
 624                 BT_CTF_BYTE_ORDER_BIG_ENDIAN));
 625         if (ret) {
 626                 goto end;
 627         }
 628
 629         ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
 630                 _uint32_t, "magic");
 631         if (ret) {
 632                 goto end;
 633         }
 634
 635         ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
 636                 uuid_array_type, "uuid");
 637         if (ret) {
 638                 goto end;
 639         }
 640
 641         ret = bt_ctf_field_type_structure_add_field(trace_packet_header_type,
 642                 _uint32_t, "stream_id");
 643         if (ret) {
 644                 goto end;
 645         }
 646
 647         trace_packet_header = bt_ctf_field_create(trace_packet_header_type);
 648         if (!trace_packet_header) {
 649                 ret = -1;
 650                 goto end;
 651         }
 652
 653         magic = bt_ctf_field_structure_get_field(trace_packet_header, "magic");
 654         ret = bt_ctf_field_unsigned_integer_set_value(magic, 0xC1FC1FC1);
 655         if (ret) {
 656                 goto end;
 657         }
 658
 659         uuid_array = bt_ctf_field_structure_get_field(trace_packet_header,
 660                 "uuid");
 661         for (i = 0; i < 16; i++) {
 662                 struct bt_ctf_field *uuid_element =
 663                         bt_ctf_field_array_get_field(uuid_array, i);
 664                 ret = bt_ctf_field_unsigned_integer_set_value(uuid_element,
 665                         writer->uuid[i]);
 666                 bt_ctf_field_put(uuid_element);
 667                 if (ret) {
 668                         goto end;
 669                 }
 670         }
 671
 672         bt_ctf_field_type_put(writer->trace_packet_header_type);
 673         bt_ctf_field_put(writer->trace_packet_header);
 674         writer->trace_packet_header_type = trace_packet_header_type;
 675         writer->trace_packet_header = trace_packet_header;
 676 end:
 677         bt_ctf_field_type_put(uuid_array_type);
 678         bt_ctf_field_type_put(_uint32_t);
 679         bt_ctf_field_type_put(_uint8_t);
 680         bt_ctf_field_put(magic);
 681         bt_ctf_field_put(uuid_array);
 682         if (ret) {
 683                 bt_ctf_field_type_put(trace_packet_header_type);
 684                 bt_ctf_field_put(trace_packet_header);
 685         }
 686
 687         return ret;
 688 }
 689
 690 static
 691 void environment_variable_destroy(struct environment_variable *var)
 692 {
 693         g_string_free(var->name, TRUE);
 694         g_string_free(var->value, TRUE);
 695         g_free(var);
 696 }
 697
 698 static
 699 int create_stream_file(struct bt_ctf_writer *writer,
 700                 struct bt_ctf_stream *stream)
 701 {
 702         int fd;
 703         GString *filename = g_string_new(stream->stream_class->name->str);
 704
 705         g_string_append_printf(filename, "_%" PRIu32, stream->id);
 706         fd = openat(writer->trace_dir_fd, filename->str,
 707                 O_RDWR | O_CREAT | O_TRUNC,
 708                 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
 709         g_string_free(filename, TRUE);
 710         return fd;
 711 }
 712
 713 static
 714 void stream_flush_cb(struct bt_ctf_stream *stream, struct bt_ctf_writer *writer)
 715 {
 716         struct bt_ctf_field *stream_id;
 717
 718         /* Start a new packet in the stream */
 719         if (stream->flushed_packet_count) {
 720                 /* ctf_init_pos has already initialized the first packet */
 721                 ctf_packet_seek(&stream->pos.parent, 0, SEEK_CUR);
 722         }
 723
 724         stream_id = bt_ctf_field_structure_get_field(
 725                 writer->trace_packet_header, "stream_id");
 726         bt_ctf_field_unsigned_integer_set_value(stream_id, stream->id);
 727         bt_ctf_field_put(stream_id);
 728
 729         /* Write the trace_packet_header */
 730         bt_ctf_field_serialize(writer->trace_packet_header, &stream->pos);
 731 }
 732
 733 static __attribute__((constructor))
 734 void writer_init(void)
 735 {
 736         size_t i;
 737         const size_t reserved_keywords_count =
 738                 sizeof(reserved_keywords_str) / sizeof(char *);
 739
 740         global_data_refcount++;
 741         if (init_done) {
 742                 return;
 743         }
 744
 745         reserved_keywords_set = g_hash_table_new(g_direct_hash, g_direct_equal);
 746         for (i = 0; i < reserved_keywords_count; i++) {
 747                 gpointer quark = GINT_TO_POINTER(g_quark_from_string(
 748                         reserved_keywords_str[i]));
 749
 750                 g_hash_table_insert(reserved_keywords_set, quark, quark);
 751         }
 752
 753         init_done = 1;
 754 }
 755
 756 static __attribute__((destructor))
 757 void writer_finalize(void)
 758 {
 759         if (--global_data_refcount == 0) {
 760                 g_hash_table_destroy(reserved_keywords_set);
 761         }
 762 }