plugins/writer/write.c

   1 /*
   2  * writer.c
   3  *
   4  * Babeltrace CTF Writer Output Plugin Event Handling
   5  *
   6  * Copyright 2016 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/event.h>
  30 #include <babeltrace/ctf-ir/packet.h>
  31 #include <babeltrace/ctf-ir/event-class.h>
  32 #include <babeltrace/ctf-ir/stream.h>
  33 #include <babeltrace/ctf-ir/stream-class.h>
  34 #include <babeltrace/ctf-ir/clock-class.h>
  35 #include <babeltrace/ctf-ir/fields.h>
  36 #include <babeltrace/ctf-writer/stream-class.h>
  37 #include <babeltrace/ctf-writer/stream.h>
  38
  39 #include "writer.h"
  40
  41 static
  42 enum bt_component_status copy_clock_class(FILE *err, struct bt_ctf_writer *writer,
  43                 struct bt_ctf_stream_class *writer_stream_class,
  44                 struct bt_ctf_clock_class *clock_class)
  45 {
  46         int64_t offset, offset_s;
  47         int int_ret;
  48         uint64_t u64_ret;
  49         const char *name, *description;
  50         struct bt_ctf_clock_class *writer_clock_class = NULL;
  51         struct bt_ctf_trace *trace = NULL;
  52         enum bt_component_status ret;
  53
  54         name = bt_ctf_clock_class_get_name(clock_class);
  55         if (!name) {
  56                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
  57                                 __LINE__);
  58                 ret = BT_COMPONENT_STATUS_ERROR;
  59                 goto end;
  60         }
  61
  62         writer_clock_class = bt_ctf_clock_class_create(name);
  63         if (!writer_clock_class) {
  64                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
  65                                 __LINE__);
  66                 ret = BT_COMPONENT_STATUS_ERROR;
  67                 goto end;
  68         }
  69
  70         description = bt_ctf_clock_class_get_description(clock_class);
  71         if (!description) {
  72                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
  73                                 __LINE__);
  74                 ret = BT_COMPONENT_STATUS_ERROR;
  75                 goto end_destroy;
  76         }
  77
  78         int_ret = bt_ctf_clock_class_set_description(writer_clock_class,
  79                         description);
  80         if (int_ret != 0) {
  81                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
  82                                 __LINE__);
  83                 ret = BT_COMPONENT_STATUS_ERROR;
  84                 goto end_destroy;
  85         }
  86
  87         u64_ret = bt_ctf_clock_class_get_frequency(clock_class);
  88         if (u64_ret == -1ULL) {
  89                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
  90                                 __LINE__);
  91                 ret = BT_COMPONENT_STATUS_ERROR;
  92                 goto end_destroy;
  93         }
  94         int_ret = bt_ctf_clock_class_set_frequency(writer_clock_class, u64_ret);
  95         if (int_ret != 0) {
  96                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
  97                                 __LINE__);
  98                 ret = BT_COMPONENT_STATUS_ERROR;
  99                 goto end_destroy;
 100         }
 101
 102         u64_ret = bt_ctf_clock_class_get_precision(clock_class);
 103         if (u64_ret == -1ULL) {
 104                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 105                                 __LINE__);
 106                 ret = BT_COMPONENT_STATUS_ERROR;
 107                 goto end_destroy;
 108         }
 109         int_ret = bt_ctf_clock_class_set_precision(writer_clock_class,
 110                 u64_ret);
 111         if (int_ret != 0) {
 112                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 113                                 __LINE__);
 114                 ret = BT_COMPONENT_STATUS_ERROR;
 115                 goto end_destroy;
 116         }
 117
 118         int_ret = bt_ctf_clock_class_get_offset_s(clock_class, &offset_s);
 119         if (int_ret != 0) {
 120                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 121                                 __LINE__);
 122                 ret = BT_COMPONENT_STATUS_ERROR;
 123                 goto end_destroy;
 124         }
 125
 126         int_ret = bt_ctf_clock_class_set_offset_s(writer_clock_class, offset_s);
 127         if (int_ret != 0) {
 128                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 129                                 __LINE__);
 130                 ret = BT_COMPONENT_STATUS_ERROR;
 131                 goto end_destroy;
 132         }
 133
 134         int_ret = bt_ctf_clock_class_get_offset_cycles(clock_class, &offset);
 135         if (int_ret != 0) {
 136                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 137                                 __LINE__);
 138                 ret = BT_COMPONENT_STATUS_ERROR;
 139                 goto end_destroy;
 140         }
 141
 142         int_ret = bt_ctf_clock_class_set_offset_cycles(writer_clock_class, offset);
 143         if (int_ret != 0) {
 144                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 145                                 __LINE__);
 146                 ret = BT_COMPONENT_STATUS_ERROR;
 147                 goto end_destroy;
 148         }
 149
 150         int_ret = bt_ctf_clock_class_get_is_absolute(clock_class);
 151         if (int_ret == -1) {
 152                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 153                                 __LINE__);
 154                 ret = BT_COMPONENT_STATUS_ERROR;
 155                 goto end_destroy;
 156         }
 157
 158         int_ret = bt_ctf_clock_class_set_is_absolute(writer_clock_class, int_ret);
 159         if (int_ret != 0) {
 160                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 161                                 __LINE__);
 162                 ret = BT_COMPONENT_STATUS_ERROR;
 163                 goto end_destroy;
 164         }
 165
 166         trace = bt_ctf_writer_get_trace(writer);
 167         if (!trace) {
 168                 ret = BT_COMPONENT_STATUS_ERROR;
 169                 goto end_destroy;
 170         }
 171
 172         int_ret = bt_ctf_trace_add_clock_class(trace, writer_clock_class);
 173         if (int_ret != 0) {
 174                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 175                                 __LINE__);
 176                 ret = BT_COMPONENT_STATUS_ERROR;
 177                 goto end_destroy;
 178         }
 179
 180         /*
 181          * Ownership transferred to the writer and the stream_class.
 182          */
 183         bt_put(writer_clock_class);
 184         ret = BT_COMPONENT_STATUS_OK;
 185
 186         goto end;
 187
 188 end_destroy:
 189         BT_PUT(writer_clock_class);
 190 end:
 191         BT_PUT(trace);
 192         return ret;
 193 }
 194
 195 static
 196 struct bt_ctf_event_class *copy_event_class(FILE *err, struct bt_ctf_event_class *event_class)
 197 {
 198         struct bt_ctf_event_class *writer_event_class = NULL;
 199         const char *name;
 200         struct bt_ctf_field_type *context;
 201         int count, i, ret;
 202
 203         name = bt_ctf_event_class_get_name(event_class);
 204         if (!name) {
 205                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 206                                 __FILE__, __LINE__);
 207                 goto end;
 208         }
 209
 210         writer_event_class = bt_ctf_event_class_create(name);
 211         if (!writer_event_class) {
 212                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 213                                 __FILE__, __LINE__);
 214                 goto end;
 215         }
 216
 217         count = bt_ctf_event_class_get_attribute_count(event_class);
 218         for (i = 0; i < count; i++) {
 219                 const char *attr_name;
 220                 struct bt_value *attr_value;
 221                 int ret;
 222
 223                 attr_name = bt_ctf_event_class_get_attribute_name(event_class, i);
 224                 if (!attr_name) {
 225                         fprintf(err, "[error] %s in %s:%d\n", __func__,
 226                                         __FILE__, __LINE__);
 227                         BT_PUT(writer_event_class);
 228                         goto end;
 229                 }
 230                 attr_value = bt_ctf_event_class_get_attribute_value(event_class, i);
 231                 if (!attr_value) {
 232                         fprintf(err, "[error] %s in %s:%d\n", __func__,
 233                                         __FILE__, __LINE__);
 234                         BT_PUT(writer_event_class);
 235                         goto end;
 236                 }
 237
 238                 ret = bt_ctf_event_class_set_attribute(writer_event_class,
 239                                 attr_name, attr_value);
 240                 bt_put(attr_value);
 241                 if (ret < 0) {
 242                         fprintf(err, "[error] %s in %s:%d\n", __func__,
 243                                         __FILE__, __LINE__);
 244                         BT_PUT(writer_event_class);
 245                         goto end;
 246                 }
 247         }
 248
 249         context = bt_ctf_event_class_get_context_type(event_class);
 250         ret = bt_ctf_event_class_set_context_type(writer_event_class, context);
 251         bt_put(context);
 252         if (ret < 0) {
 253                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 254                                 __LINE__);
 255                 goto end;
 256         }
 257
 258         count = bt_ctf_event_class_get_field_count(event_class);
 259         for (i = 0; i < count; i++) {
 260                 const char *field_name;
 261                 struct bt_ctf_field_type *field_type;
 262                 int ret;
 263
 264                 ret = bt_ctf_event_class_get_field(event_class, &field_name,
 265                                 &field_type, i);
 266                 if (ret < 0) {
 267                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
 268                         BT_PUT(writer_event_class);
 269                         goto end;
 270                 }
 271
 272                 ret = bt_ctf_event_class_add_field(writer_event_class, field_type,
 273                                 field_name);
 274                 if (ret < 0) {
 275                         fprintf(err, "[error] Cannot add field %s\n", field_name);
 276                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
 277                         bt_put(field_type);
 278                         BT_PUT(writer_event_class);
 279                         goto end;
 280                 }
 281                 bt_put(field_type);
 282         }
 283
 284 end:
 285         return writer_event_class;
 286 }
 287
 288 static
 289 enum bt_component_status copy_event_classes(FILE *err,
 290                 struct bt_ctf_writer *writer,
 291                 struct bt_ctf_stream_class *stream_class,
 292                 struct bt_ctf_stream_class *writer_stream_class)
 293 {
 294         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 295         int count, i;
 296
 297         count = bt_ctf_stream_class_get_event_class_count(stream_class);
 298         if (count < 0) {
 299                 fprintf(err, "[error] %s in %s:%d\n", __func__,
 300                                 __FILE__, __LINE__);
 301                 goto end;
 302         }
 303
 304         for (i = 0; i < count; i++) {
 305                 struct bt_ctf_event_class *event_class, *writer_event_class;
 306                 int int_ret;
 307
 308                 event_class = bt_ctf_stream_class_get_event_class(
 309                                 stream_class, i);
 310                 if (!event_class) {
 311                         fprintf(err, "[error] %s in %s:%d\n", __func__,
 312                                         __FILE__, __LINE__);
 313                         ret = BT_COMPONENT_STATUS_ERROR;
 314                         bt_put(event_class);
 315                         goto end;
 316                 }
 317                 writer_event_class = copy_event_class(err, event_class);
 318                 if (!writer_event_class) {
 319                         fprintf(err, "[error] %s in %s:%d\n", __func__,
 320                                         __FILE__, __LINE__);
 321                         ret = BT_COMPONENT_STATUS_ERROR;
 322                         bt_put(event_class);
 323                         goto end;
 324                 }
 325                 int_ret = bt_ctf_stream_class_add_event_class(writer_stream_class,
 326                                 writer_event_class);
 327                 if (int_ret < 0) {
 328                         fprintf(err, "[error] Failed to add event class\n");
 329                         fprintf(err, "[error] %s in %s:%d\n", __func__,
 330                                         __FILE__, __LINE__);
 331                         ret = BT_COMPONENT_STATUS_ERROR;
 332                         bt_put(event_class);
 333                         goto end;
 334                 }
 335                 bt_put(event_class);
 336                 bt_put(writer_event_class);
 337         }
 338
 339 end:
 340         return ret;
 341 }
 342
 343 static
 344 enum bt_component_status copy_stream_class(FILE *err,
 345                 struct bt_ctf_writer *writer,
 346                 struct bt_ctf_stream_class *stream_class,
 347                 struct bt_ctf_stream_class *writer_stream_class)
 348 {
 349         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 350         struct bt_ctf_field_type *type;
 351         int ret_int, clock_class_count, i;
 352         struct bt_ctf_trace *trace;
 353
 354         trace = bt_ctf_stream_class_get_trace(stream_class);
 355         if (!trace) {
 356                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 357                                 __LINE__);
 358                 ret = BT_COMPONENT_STATUS_ERROR;
 359                 goto end;
 360         }
 361
 362         clock_class_count = bt_ctf_trace_get_clock_class_count(trace);
 363
 364         for (i = 0; i < clock_class_count; i++) {
 365                 struct bt_ctf_clock_class *clock_class =
 366                         bt_ctf_trace_get_clock_class(trace, i);
 367
 368                 if (!clock_class) {
 369                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 370                                         __LINE__);
 371                         ret = BT_COMPONENT_STATUS_ERROR;
 372                         goto end_put_trace;
 373                 }
 374
 375                 ret = copy_clock_class(err, writer, writer_stream_class, clock_class);
 376                 bt_put(clock_class);
 377                 if (ret != BT_COMPONENT_STATUS_OK) {
 378                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 379                                         __LINE__);
 380                         goto end_put_trace;
 381                 }
 382         }
 383
 384         type = bt_ctf_stream_class_get_packet_context_type(stream_class);
 385         if (!type) {
 386                 ret = BT_COMPONENT_STATUS_ERROR;
 387                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 388                                 __LINE__);
 389                 goto end_put_trace;
 390         }
 391
 392         ret_int = bt_ctf_stream_class_set_packet_context_type(
 393                         writer_stream_class, type);
 394         bt_put(type);
 395         if (ret_int < 0) {
 396                 ret = BT_COMPONENT_STATUS_ERROR;
 397                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 398                                 __LINE__);
 399                 goto end_put_trace;
 400         }
 401
 402         type = bt_ctf_stream_class_get_event_header_type(stream_class);
 403         if (!type) {
 404                 ret = BT_COMPONENT_STATUS_ERROR;
 405                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 406                                 __LINE__);
 407                 goto end_put_trace;
 408         }
 409
 410         ret_int = bt_ctf_stream_class_set_event_header_type(
 411                         writer_stream_class, type);
 412         bt_put(type);
 413         if (ret_int < 0) {
 414                 ret = BT_COMPONENT_STATUS_ERROR;
 415                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 416                                 __LINE__);
 417                 goto end_put_trace;
 418         }
 419
 420         type = bt_ctf_stream_class_get_event_context_type(stream_class);
 421         if (!type) {
 422                 ret = BT_COMPONENT_STATUS_ERROR;
 423                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 424                                 __LINE__);
 425                 goto end_put_trace;
 426         }
 427         ret_int = bt_ctf_stream_class_set_event_context_type(
 428                         writer_stream_class, type);
 429         bt_put(type);
 430         if (ret_int < 0) {
 431                 ret = BT_COMPONENT_STATUS_ERROR;
 432                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 433                                 __LINE__);
 434                 goto end_put_trace;
 435         }
 436
 437         ret = copy_event_classes(err, writer, stream_class, writer_stream_class);
 438         if (ret != BT_COMPONENT_STATUS_OK) {
 439                 fprintf(err, "[error] Failed to copy event classes\n");
 440                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 441                                 __LINE__);
 442                 goto end_put_trace;
 443         }
 444
 445 end_put_trace:
 446         bt_put(trace);
 447 end:
 448         return ret;
 449 }
 450
 451 static
 452 enum bt_component_status copy_trace(FILE *err, struct bt_ctf_writer *ctf_writer,
 453                 struct bt_ctf_trace *trace)
 454 {
 455         struct bt_ctf_trace *writer_trace;
 456         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 457         int field_count, i, int_ret;
 458         struct bt_ctf_field_type *header_type;
 459
 460         writer_trace = bt_ctf_writer_get_trace(ctf_writer);
 461         if (!writer_trace) {
 462                 ret = BT_COMPONENT_STATUS_ERROR;
 463                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 464                                 __LINE__);
 465                 goto end;
 466         }
 467
 468         field_count = bt_ctf_trace_get_environment_field_count(trace);
 469         for (i = 0; i < field_count; i++) {
 470                 int ret_int;
 471                 const char *name;
 472                 struct bt_value *value;
 473
 474                 name = bt_ctf_trace_get_environment_field_name(trace, i);
 475                 if (!name) {
 476                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 477                                         __LINE__);
 478                         ret = BT_COMPONENT_STATUS_ERROR;
 479                         goto end_put_writer_trace;
 480                 }
 481                 value = bt_ctf_trace_get_environment_field_value(trace, i);
 482                 if (!value) {
 483                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 484                                         __LINE__);
 485                         ret = BT_COMPONENT_STATUS_ERROR;
 486                         goto end_put_writer_trace;
 487                 }
 488
 489                 ret_int = bt_ctf_trace_set_environment_field(writer_trace,
 490                                 name, value);
 491                 bt_put(value);
 492                 if (ret_int < 0) {
 493                         fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 494                                         __LINE__);
 495                         fprintf(err, "[error] Unable to set environment field %s\n",
 496                                         name);
 497                         ret = BT_COMPONENT_STATUS_ERROR;
 498                         goto end_put_writer_trace;
 499                 }
 500         }
 501
 502         header_type = bt_ctf_trace_get_packet_header_type(writer_trace);
 503         if (!header_type) {
 504                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
 505                 ret = BT_COMPONENT_STATUS_ERROR;
 506                 goto end_put_writer_trace;
 507         }
 508
 509         int_ret = bt_ctf_trace_set_packet_header_type(writer_trace, header_type);
 510         if (int_ret < 0) {
 511                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
 512                 ret = BT_COMPONENT_STATUS_ERROR;
 513                 goto end_put_header_type;
 514         }
 515
 516 end_put_header_type:
 517         bt_put(header_type);
 518 end_put_writer_trace:
 519         bt_put(writer_trace);
 520 end:
 521         return ret;
 522 }
 523
 524 static
 525 struct bt_ctf_stream_class *insert_new_stream_class(
 526                 struct writer_component *writer_component,
 527                 struct bt_ctf_writer *ctf_writer,
 528                 struct bt_ctf_stream_class *stream_class)
 529 {
 530         struct bt_ctf_stream_class *writer_stream_class;
 531         const char *name = bt_ctf_stream_class_get_name(stream_class);
 532         enum bt_component_status ret;
 533
 534         if (strlen(name) == 0) {
 535                 name = NULL;
 536         }
 537
 538         writer_stream_class = bt_ctf_stream_class_create(name);
 539         if (!writer_stream_class) {
 540                 fprintf(writer_component->err, "[error] %s in %s:%d\n",
 541                                 __func__, __FILE__, __LINE__);
 542                 goto end;
 543         }
 544
 545         ret = copy_stream_class(writer_component->err,
 546                         ctf_writer, stream_class, writer_stream_class);
 547         if (ret != BT_COMPONENT_STATUS_OK) {
 548                 fprintf(writer_component->err, "[error] Failed to copy stream class\n");
 549                 fprintf(writer_component->err, "[error] %s in %s:%d\n",
 550                                 __func__, __FILE__, __LINE__);
 551                 BT_PUT(writer_stream_class);
 552                 goto end;
 553         }
 554         g_hash_table_insert(writer_component->stream_class_map,
 555                         (gpointer) stream_class, writer_stream_class);
 556
 557 end:
 558         return writer_stream_class;
 559 }
 560
 561 static
 562 struct bt_ctf_stream *insert_new_stream(
 563                 struct writer_component *writer_component,
 564                 struct bt_ctf_writer *ctf_writer,
 565                 struct bt_ctf_stream_class *stream_class,
 566                 struct bt_ctf_stream *stream)
 567 {
 568         struct bt_ctf_stream *writer_stream;
 569         struct bt_ctf_stream_class *writer_stream_class;
 570
 571         writer_stream_class = g_hash_table_lookup(
 572                         writer_component->stream_class_map,
 573                         (gpointer) stream_class);
 574         if (writer_stream_class) {
 575                 if (!bt_get(writer_stream_class)) {
 576                         writer_stream = NULL;
 577                         fprintf(writer_component->err, "[error] %s in %s:%d\n",
 578                                         __func__, __FILE__, __LINE__);
 579                         goto end;
 580                 }
 581         } else {
 582                 writer_stream_class = insert_new_stream_class(
 583                                 writer_component, ctf_writer, stream_class);
 584                 if (!writer_stream_class) {
 585                         writer_stream = NULL;
 586                         fprintf(writer_component->err, "[error] %s in %s:%d\n",
 587                                         __func__, __FILE__, __LINE__);
 588                         goto end_put;
 589                 }
 590         }
 591
 592         writer_stream = bt_ctf_writer_create_stream(ctf_writer,
 593                         writer_stream_class);
 594         if (!writer_stream) {
 595                 fprintf(writer_component->err, "[error] %s in %s:%d\n",
 596                                 __func__, __FILE__, __LINE__);
 597                 goto end_put;
 598         }
 599
 600         g_hash_table_insert(writer_component->stream_map, (gpointer) stream,
 601                         writer_stream);
 602
 603         bt_ctf_writer_flush_metadata(ctf_writer);
 604
 605 end_put:
 606         bt_put(writer_stream_class);
 607 end:
 608         return writer_stream;
 609 }
 610
 611 static
 612 struct bt_ctf_stream *lookup_stream(struct writer_component *writer_component,
 613                 struct bt_ctf_stream *stream)
 614 {
 615         return (struct bt_ctf_stream *) g_hash_table_lookup(
 616                         writer_component->stream_map,
 617                         (gpointer) stream);
 618 }
 619
 620 static
 621 struct bt_ctf_event_class *get_event_class(struct writer_component *writer_component,
 622                 struct bt_ctf_stream_class *writer_stream_class,
 623                 struct bt_ctf_event_class *event_class)
 624 {
 625         return bt_ctf_stream_class_get_event_class_by_name(writer_stream_class,
 626                         bt_ctf_event_class_get_name(event_class));
 627 }
 628
 629 struct bt_ctf_writer *insert_new_writer(
 630                 struct writer_component *writer_component,
 631                 struct bt_ctf_trace *trace)
 632 {
 633         struct bt_ctf_writer *ctf_writer;
 634         char trace_name[PATH_MAX];
 635         enum bt_component_status ret;
 636
 637         snprintf(trace_name, PATH_MAX, "%s/%s_%03d",
 638                         writer_component->base_path->str,
 639                         writer_component->trace_name_base->str,
 640                         writer_component->trace_id++);
 641         printf_verbose("CTF-Writer creating trace in %s\n", trace_name);
 642
 643         ctf_writer = bt_ctf_writer_create(trace_name);
 644         if (!ctf_writer) {
 645                 fprintf(writer_component->err, "[error] %s in %s:%d\n",
 646                                 __func__, __FILE__, __LINE__);
 647                 goto end;
 648         }
 649
 650         ret = copy_trace(writer_component->err, ctf_writer, trace);
 651         if (ret != BT_COMPONENT_STATUS_OK) {
 652                 fprintf(writer_component->err, "[error] Failed to copy trace\n");
 653                 fprintf(writer_component->err, "[error] %s in %s:%d\n",
 654                                 __func__, __FILE__, __LINE__);
 655                 BT_PUT(ctf_writer);
 656                 goto end;
 657         }
 658
 659         g_hash_table_insert(writer_component->trace_map, (gpointer) trace,
 660                         ctf_writer);
 661
 662 end:
 663         return ctf_writer;
 664 }
 665
 666 static
 667 struct bt_ctf_writer *get_writer(struct writer_component *writer_component,
 668                 struct bt_ctf_stream_class *stream_class)
 669 {
 670         struct bt_ctf_trace *trace;
 671         struct bt_ctf_writer *ctf_writer;
 672
 673         trace = bt_ctf_stream_class_get_trace(stream_class);
 674         if (!trace) {
 675                 ctf_writer = NULL;
 676                 fprintf(writer_component->err, "[error] %s in %s:%d\n",
 677                                 __func__, __FILE__, __LINE__);
 678                 goto end;
 679         }
 680
 681         ctf_writer = g_hash_table_lookup(writer_component->trace_map,
 682                         (gpointer) trace);
 683         if (ctf_writer) {
 684                 if (!bt_get(ctf_writer)) {
 685                         ctf_writer = NULL;
 686                         fprintf(writer_component->err, "[error] %s in %s:%d\n",
 687                                         __func__, __FILE__, __LINE__);
 688                         goto end;
 689                 }
 690         } else {
 691                 ctf_writer = insert_new_writer(writer_component, trace);
 692         }
 693         bt_put(trace);
 694
 695 end:
 696         return ctf_writer;
 697 }
 698
 699 static
 700 struct bt_ctf_stream *get_writer_stream(
 701                 struct writer_component *writer_component,
 702                 struct bt_ctf_packet *packet, struct bt_ctf_stream *stream)
 703 {
 704         struct bt_ctf_stream_class *stream_class;
 705         struct bt_ctf_writer *ctf_writer;
 706         struct bt_ctf_stream *writer_stream;
 707
 708         stream_class = bt_ctf_stream_get_class(stream);
 709         if (!stream_class) {
 710                 writer_stream = NULL;
 711                 fprintf(writer_component->err, "[error] %s in %s:%d\n",
 712                                 __func__, __FILE__, __LINE__);
 713                 goto end;
 714         }
 715
 716         ctf_writer = get_writer(writer_component, stream_class);
 717         if (!ctf_writer) {
 718                 writer_stream = NULL;
 719                 fprintf(writer_component->err, "[error] %s in %s:%d\n",
 720                                 __func__, __FILE__, __LINE__);
 721                 goto end_put_stream_class;
 722         }
 723
 724         writer_stream = lookup_stream(writer_component, stream);
 725
 726         if (writer_stream) {
 727                 if (!bt_get(writer_stream)) {
 728                         writer_stream = NULL;
 729                         fprintf(writer_component->err, "[error] %s in %s:%d\n",
 730                                         __func__, __FILE__, __LINE__);
 731                         goto end_put_stream_class;
 732                 }
 733         } else {
 734                 writer_stream = insert_new_stream(writer_component, ctf_writer,
 735                                 stream_class, stream);
 736                 bt_get(writer_stream);
 737         }
 738
 739         bt_put(ctf_writer);
 740 end_put_stream_class:
 741         bt_put(stream_class);
 742 end:
 743         return writer_stream;
 744 }
 745
 746 BT_HIDDEN
 747 enum bt_component_status writer_new_packet(
 748                 struct writer_component *writer_component,
 749                 struct bt_ctf_packet *packet)
 750 {
 751         struct bt_ctf_stream *stream, *writer_stream;
 752         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 753
 754         stream = bt_ctf_packet_get_stream(packet);
 755         if (!stream) {
 756                 ret = BT_COMPONENT_STATUS_ERROR;
 757                 fprintf(writer_component->err, "[error] %s in %s:%d\n",
 758                                 __func__, __FILE__, __LINE__);
 759                 goto end;
 760         }
 761
 762         /* TODO: copy values for event discarded and packet_seq_num */
 763         writer_stream = get_writer_stream(writer_component, packet, stream);
 764         if (!writer_stream) {
 765                 ret = BT_COMPONENT_STATUS_ERROR;
 766                 fprintf(writer_component->err, "[error] %s in %s:%d\n",
 767                                 __func__, __FILE__, __LINE__);
 768                 goto end_put;
 769         }
 770
 771         bt_put(writer_stream);
 772
 773 end_put:
 774         bt_put(stream);
 775 end:
 776         return ret;
 777 }
 778
 779 static
 780 enum bt_component_status copy_packet_context_field(FILE *err,
 781                 struct bt_ctf_field *field, const char *field_name,
 782                 struct bt_ctf_field *writer_packet_context,
 783                 struct bt_ctf_field_type *writer_packet_context_type)
 784 {
 785         enum bt_component_status ret;
 786         struct bt_ctf_field *writer_field;
 787         int int_ret;
 788         uint64_t value;
 789
 790         /*
 791          * TODO: handle the special case of the first/last packet that might
 792          * be trimmed. In these cases, the timestamp_begin/end need to be
 793          * explicitely set to the first/last event timestamps.
 794          */
 795
 796         writer_field = bt_ctf_field_structure_get_field(writer_packet_context,
 797                         field_name);
 798         if (!writer_field) {
 799                 ret = BT_COMPONENT_STATUS_ERROR;
 800                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 801                                 __LINE__);
 802                 goto end;
 803         }
 804
 805         int_ret = bt_ctf_field_unsigned_integer_get_value(field, &value);
 806         if (int_ret < 0) {
 807                 fprintf(err, "[error] Wrong packet_context field type\n");
 808                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 809                                 __LINE__);
 810                 ret = BT_COMPONENT_STATUS_ERROR;
 811                 goto end_put_writer_field;
 812         }
 813
 814         int_ret = bt_ctf_field_unsigned_integer_set_value(writer_field, value);
 815         if (int_ret < 0) {
 816                 ret = BT_COMPONENT_STATUS_ERROR;
 817                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 818                                 __LINE__);
 819                 goto end_put_writer_field;
 820         }
 821
 822         ret = BT_COMPONENT_STATUS_OK;
 823
 824 end_put_writer_field:
 825         bt_put(writer_field);
 826 end:
 827         return ret;
 828 }
 829
 830 static
 831 enum bt_component_status copy_packet_context(FILE *err,
 832                 struct bt_ctf_packet *packet,
 833                 struct bt_ctf_stream *writer_stream)
 834 {
 835         enum bt_component_status ret;
 836         struct bt_ctf_field *packet_context, *writer_packet_context;
 837         struct bt_ctf_field_type *struct_type, *writer_packet_context_type;
 838         struct bt_ctf_stream_class *writer_stream_class;
 839         int nr_fields, i, int_ret;
 840
 841         packet_context = bt_ctf_packet_get_context(packet);
 842         if (!packet_context) {
 843                 ret = BT_COMPONENT_STATUS_ERROR;
 844                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 845                                 __LINE__);
 846                 goto end;
 847         }
 848
 849         writer_stream_class = bt_ctf_stream_get_class(writer_stream);
 850         if (!writer_stream_class) {
 851                 ret = BT_COMPONENT_STATUS_ERROR;
 852                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 853                                 __LINE__);
 854                 goto end_put_packet_context;
 855         }
 856
 857         writer_packet_context_type = bt_ctf_stream_class_get_packet_context_type(
 858                         writer_stream_class);
 859         if (!writer_packet_context_type) {
 860                 ret = BT_COMPONENT_STATUS_ERROR;
 861                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 862                                 __LINE__);
 863                 goto end_put_writer_stream_class;
 864         }
 865
 866         struct_type = bt_ctf_field_get_type(packet_context);
 867         if (!struct_type) {
 868                 ret = BT_COMPONENT_STATUS_ERROR;
 869                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 870                                 __LINE__);
 871                 goto end_put_writer_packet_context_type;
 872         }
 873
 874         writer_packet_context = bt_ctf_field_create(writer_packet_context_type);
 875         if (!writer_packet_context) {
 876                 ret = BT_COMPONENT_STATUS_ERROR;
 877                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
 878                                 __LINE__);
 879                 goto end_put_struct_type;
 880         }
 881
 882         nr_fields = bt_ctf_field_type_structure_get_field_count(struct_type);
 883         for (i = 0; i < nr_fields; i++) {
 884                 struct bt_ctf_field *field;
 885                 struct bt_ctf_field_type *field_type;
 886                 const char *field_name;
 887
 888                 field =  bt_ctf_field_structure_get_field_by_index(
 889                                 packet_context, i);
 890                 if (!field) {
 891                         ret = BT_COMPONENT_STATUS_ERROR;
 892                         fprintf(err, "[error] %s in %s:%d\n", __func__,
 893                                         __FILE__, __LINE__);
 894                         goto end_put_writer_packet_context;
 895                 }
 896                 if (bt_ctf_field_type_structure_get_field(struct_type,
 897                                         &field_name, &field_type, i) < 0) {
 898                         ret = BT_COMPONENT_STATUS_ERROR;
 899                         bt_put(field);
 900                         fprintf(err, "[error] %s in %s:%d\n", __func__,
 901                                         __FILE__, __LINE__);
 902                         goto end_put_writer_packet_context;
 903                 }
 904
 905                 if (bt_ctf_field_type_get_type_id(field_type) != BT_CTF_TYPE_ID_INTEGER) {
 906                         fprintf(err, "[error] Unexpected packet context field type\n");
 907                         bt_put(field);
 908                         ret = BT_COMPONENT_STATUS_ERROR;
 909                         goto end_put_writer_packet_context;
 910                 }
 911
 912                 ret = copy_packet_context_field(err, field, field_name,
 913                                 writer_packet_context, writer_packet_context_type);
 914                 bt_put(field_type);
 915                 bt_put(field);
 916                 if (ret != BT_COMPONENT_STATUS_OK) {
 917                         fprintf(err, "[error] %s in %s:%d\n", __func__,
 918                                         __FILE__, __LINE__);
 919                         goto end_put_writer_packet_context;
 920                 }
 921         }
 922
 923         int_ret = bt_ctf_stream_set_packet_context(writer_stream,
 924                         writer_packet_context);
 925         if (int_ret < 0) {
 926                 ret = BT_COMPONENT_STATUS_ERROR;
 927                 goto end_put_writer_packet_context;
 928         }
 929
 930 end_put_writer_packet_context:
 931         bt_put(writer_packet_context);
 932 end_put_struct_type:
 933         bt_put(struct_type);
 934 end_put_writer_packet_context_type:
 935         bt_put(writer_packet_context_type);
 936 end_put_writer_stream_class:
 937         bt_put(writer_stream_class);
 938 end_put_packet_context:
 939         bt_put(packet_context);
 940 end:
 941         return ret;
 942 }
 943
 944 BT_HIDDEN
 945 enum bt_component_status writer_close_packet(
 946                 struct writer_component *writer_component,
 947                 struct bt_ctf_packet *packet)
 948 {
 949         struct bt_ctf_stream *stream, *writer_stream;
 950         enum bt_component_status ret;
 951
 952         stream = bt_ctf_packet_get_stream(packet);
 953         if (!stream) {
 954                 ret = BT_COMPONENT_STATUS_ERROR;
 955                 fprintf(writer_component->err, "[error] %s in %s:%d\n",
 956                                 __func__, __FILE__, __LINE__);
 957                 goto end;
 958         }
 959
 960         writer_stream = lookup_stream(writer_component, stream);
 961         if (!writer_stream) {
 962                 ret = BT_COMPONENT_STATUS_ERROR;
 963                 fprintf(writer_component->err, "[error] %s in %s:%d\n",
 964                                 __func__, __FILE__, __LINE__);
 965                 goto end_put;
 966         }
 967
 968         if (!bt_get(writer_stream)) {
 969                 fprintf(writer_component->err,
 970                                 "[error] Failed to get reference on writer stream\n");
 971                 fprintf(writer_component->err, "[error] %s in %s:%d\n",
 972                                 __func__, __FILE__, __LINE__);
 973                 ret = BT_COMPONENT_STATUS_ERROR;
 974                 goto end_put;
 975         }
 976
 977         ret = copy_packet_context(writer_component->err, packet, writer_stream);
 978         if (ret != BT_COMPONENT_STATUS_OK) {
 979                 ret = BT_COMPONENT_STATUS_ERROR;
 980                 fprintf(writer_component->err, "[error] %s in %s:%d\n",
 981                                 __func__, __FILE__, __LINE__);
 982                 goto end_put;
 983         }
 984
 985         ret = bt_ctf_stream_flush(writer_stream);
 986         if (ret < 0) {
 987                 fprintf(writer_component->err,
 988                                 "[error] Failed to flush packet\n");
 989                 ret = BT_COMPONENT_STATUS_ERROR;
 990         }
 991
 992         ret = BT_COMPONENT_STATUS_OK;
 993
 994         bt_put(writer_stream);
 995
 996 end_put:
 997         bt_put(stream);
 998 end:
 999         return ret;
1000 }
1001
1002 static
1003 struct bt_ctf_event *copy_event(FILE *err, struct bt_ctf_event *event,
1004                 struct bt_ctf_event_class *writer_event_class)
1005 {
1006         struct bt_ctf_event *writer_event;
1007         struct bt_ctf_field *field, *copy_field;
1008         int ret;
1009
1010         writer_event = bt_ctf_event_create(writer_event_class);
1011         if (!writer_event) {
1012                 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
1013                                 __LINE__);
1014                 goto end;
1015         }
1016
1017         field = bt_ctf_event_get_header(event);
1018         if (!field) {
1019                 BT_PUT(writer_event);
1020                 fprintf(err, "[error] %s in %s:%d\n", __func__,
1021                                 __FILE__, __LINE__);
1022                 goto end;
1023         }
1024         copy_field = bt_ctf_field_copy(field);
1025         bt_put(field);
1026         if (copy_field) {
1027                 ret = bt_ctf_event_set_header(writer_event, copy_field);
1028                 if (ret < 0) {
1029                         fprintf(err, "[error] %s in %s:%d\n", __func__,
1030                                         __FILE__, __LINE__);
1031                         goto error;
1032                 }
1033                 bt_put(copy_field);
1034         }
1035
1036         /* Optional field, so it can fail silently. */
1037         field = bt_ctf_event_get_stream_event_context(event);
1038         copy_field = bt_ctf_field_copy(field);
1039         bt_put(field);
1040         if (copy_field) {
1041                 ret = bt_ctf_event_set_stream_event_context(writer_event,
1042                                 copy_field);
1043                 if (ret < 0) {
1044                         fprintf(err, "[error] %s in %s:%d\n", __func__,
1045                                         __FILE__, __LINE__);
1046                         goto error;
1047                 }
1048                 bt_put(copy_field);
1049         }
1050
1051         /* Optional field, so it can fail silently. */
1052         field = bt_ctf_event_get_event_context(event);
1053         copy_field = bt_ctf_field_copy(field);
1054         bt_put(field);
1055         if (copy_field) {
1056                 ret = bt_ctf_event_set_event_context(writer_event, copy_field);
1057                 if (ret < 0) {
1058                         fprintf(err, "[error] %s in %s:%d\n", __func__,
1059                                         __FILE__, __LINE__);
1060                         goto error;
1061                 }
1062                 bt_put(copy_field);
1063         }
1064
1065         field = bt_ctf_event_get_payload_field(event);
1066         if (!field) {
1067                 BT_PUT(writer_event);
1068                 fprintf(err, "[error] %s in %s:%d\n", __func__,
1069                                 __FILE__, __LINE__);
1070                 goto end;
1071         }
1072         copy_field = bt_ctf_field_copy(field);
1073         bt_put(field);
1074         if (copy_field) {
1075                 ret = bt_ctf_event_set_payload_field(writer_event, copy_field);
1076                 if (ret < 0) {
1077                         fprintf(err, "[error] %s in %s:%d\n", __func__,
1078                                         __FILE__, __LINE__);
1079                         goto error;
1080                 }
1081                 bt_put(copy_field);
1082         }
1083         goto end;
1084
1085 error:
1086         bt_put(copy_field);
1087         BT_PUT(writer_event);
1088 end:
1089         return writer_event;
1090 }
1091
1092 BT_HIDDEN
1093 enum bt_component_status writer_output_event(
1094                 struct writer_component *writer_component,
1095                 struct bt_ctf_event *event)
1096 {
1097         enum bt_component_status ret;
1098         struct bt_ctf_event_class *event_class, *writer_event_class;
1099         struct bt_ctf_stream *stream, *writer_stream;
1100         struct bt_ctf_stream_class *stream_class, *writer_stream_class;
1101         struct bt_ctf_event *writer_event;
1102         const char *event_name;
1103         int int_ret;
1104
1105         event_class = bt_ctf_event_get_class(event);
1106         if (!event_class) {
1107                 ret = BT_COMPONENT_STATUS_ERROR;
1108                 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1109                                 __FILE__, __LINE__);
1110                 goto end;
1111         }
1112
1113         event_name = bt_ctf_event_class_get_name(event_class);
1114         if (!event_name) {
1115                 ret = BT_COMPONENT_STATUS_ERROR;
1116                 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1117                                 __FILE__, __LINE__);
1118                 goto end_put_event_class;
1119         }
1120
1121         stream = bt_ctf_event_get_stream(event);
1122         if (!stream) {
1123                 ret = BT_COMPONENT_STATUS_ERROR;
1124                 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1125                                 __FILE__, __LINE__);
1126                 goto end_put_event_class;
1127         }
1128
1129         writer_stream = lookup_stream(writer_component, stream);
1130         if (!writer_stream || !bt_get(writer_stream)) {
1131                 ret = BT_COMPONENT_STATUS_ERROR;
1132                 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1133                                 __FILE__, __LINE__);
1134                 goto end_put_stream;
1135         }
1136
1137         stream_class = bt_ctf_event_class_get_stream_class(event_class);
1138         if (!stream_class) {
1139                 ret = BT_COMPONENT_STATUS_ERROR;
1140                 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1141                                 __FILE__, __LINE__);
1142                 goto end_put_writer_stream;
1143         }
1144
1145         writer_stream_class = g_hash_table_lookup(
1146                         writer_component->stream_class_map,
1147                         (gpointer) stream_class);
1148         if (!writer_stream_class || !bt_get(writer_stream_class)) {
1149                 ret = BT_COMPONENT_STATUS_ERROR;
1150                 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1151                                 __FILE__, __LINE__);
1152                 goto end_put_stream_class;
1153         }
1154
1155         writer_event_class = get_event_class(writer_component,
1156                         writer_stream_class, event_class);
1157         if (!writer_event_class) {
1158                 ret = BT_COMPONENT_STATUS_ERROR;
1159                 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1160                                 __FILE__, __LINE__);
1161                 goto end_put_writer_stream_class;
1162         }
1163
1164         writer_event = copy_event(writer_component->err, event, writer_event_class);
1165         if (!writer_event) {
1166                 ret = BT_COMPONENT_STATUS_ERROR;
1167                 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1168                                 __FILE__, __LINE__);
1169                 fprintf(writer_component->err, "[error] Failed to copy event %s\n",
1170                                 bt_ctf_event_class_get_name(writer_event_class));
1171                 goto end_put_writer_event_class;
1172         }
1173
1174         int_ret = bt_ctf_stream_append_event(writer_stream, writer_event);
1175         if (int_ret < 0) {
1176                 ret = BT_COMPONENT_STATUS_ERROR;
1177                 fprintf(writer_component->err, "[error] %s in %s:%d\n", __func__,
1178                                 __FILE__, __LINE__);
1179                 fprintf(writer_component->err, "[error] Failed to append event %s\n",
1180                                 bt_ctf_event_class_get_name(writer_event_class));
1181                 goto end_put_writer_event;
1182         }
1183
1184         ret = BT_COMPONENT_STATUS_OK;
1185
1186 end_put_writer_event:
1187         bt_put(writer_event);
1188 end_put_writer_event_class:
1189         bt_put(writer_event_class);
1190 end_put_writer_stream_class:
1191         bt_put(writer_stream_class);
1192 end_put_stream_class:
1193         bt_put(stream_class);
1194 end_put_writer_stream:
1195         bt_put(writer_stream);
1196 end_put_stream:
1197         bt_put(stream);
1198 end_put_event_class:
1199         bt_put(event_class);
1200 end:
1201         return ret;
1202 }