tools/perf/util/data-convert-bt.c

   1 /*
   2  * CTF writing support via babeltrace.
   3  *
   4  * Copyright (C) 2014, Jiri Olsa <jolsa@redhat.com>
   5  * Copyright (C) 2014, Sebastian Andrzej Siewior <bigeasy@linutronix.de>
   6  *
   7  * Released under the GPL v2. (and only v2, not any later version)
   8  */
   9
  10 #include <errno.h>
  11 #include <inttypes.h>
  12 #include <linux/compiler.h>
  13 #include <linux/kernel.h>
  14 #include <babeltrace/ctf-writer/writer.h>
  15 #include <babeltrace/ctf-writer/clock.h>
  16 #include <babeltrace/ctf-writer/stream.h>
  17 #include <babeltrace/ctf-writer/event.h>
  18 #include <babeltrace/ctf-writer/event-types.h>
  19 #include <babeltrace/ctf-writer/event-fields.h>
  20 #include <babeltrace/ctf-ir/utils.h>
  21 #include <babeltrace/ctf/events.h>
  22 #include <traceevent/event-parse.h>
  23 #include "asm/bug.h"
  24 #include "data-convert-bt.h"
  25 #include "session.h"
  26 #include "util.h"
  27 #include "debug.h"
  28 #include "tool.h"
  29 #include "evlist.h"
  30 #include "evsel.h"
  31 #include "machine.h"
  32 #include "config.h"
  33 #include "sane_ctype.h"
  34
  35 #define pr_N(n, fmt, ...) \
  36         eprintf(n, debug_data_convert, fmt, ##__VA_ARGS__)
  37
  38 #define pr(fmt, ...)  pr_N(1, pr_fmt(fmt), ##__VA_ARGS__)
  39 #define pr2(fmt, ...) pr_N(2, pr_fmt(fmt), ##__VA_ARGS__)
  40
  41 #define pr_time2(t, fmt, ...) pr_time_N(2, debug_data_convert, t, pr_fmt(fmt), ##__VA_ARGS__)
  42
  43 struct evsel_priv {
  44         struct bt_ctf_event_class *event_class;
  45 };
  46
  47 #define MAX_CPUS        4096
  48
  49 struct ctf_stream {
  50         struct bt_ctf_stream *stream;
  51         int cpu;
  52         u32 count;
  53 };
  54
  55 struct ctf_writer {
  56         /* writer primitives */
  57         struct bt_ctf_writer             *writer;
  58         struct ctf_stream               **stream;
  59         int                               stream_cnt;
  60         struct bt_ctf_stream_class       *stream_class;
  61         struct bt_ctf_clock              *clock;
  62
  63         /* data types */
  64         union {
  65                 struct {
  66                         struct bt_ctf_field_type        *s64;
  67                         struct bt_ctf_field_type        *u64;
  68                         struct bt_ctf_field_type        *s32;
  69                         struct bt_ctf_field_type        *u32;
  70                         struct bt_ctf_field_type        *string;
  71                         struct bt_ctf_field_type        *u32_hex;
  72                         struct bt_ctf_field_type        *u64_hex;
  73                 };
  74                 struct bt_ctf_field_type *array[6];
  75         } data;
  76         struct bt_ctf_event_class       *comm_class;
  77         struct bt_ctf_event_class       *exit_class;
  78         struct bt_ctf_event_class       *fork_class;
  79         struct bt_ctf_event_class       *mmap_class;
  80         struct bt_ctf_event_class       *mmap2_class;
  81 };
  82
  83 struct convert {
  84         struct perf_tool        tool;
  85         struct ctf_writer       writer;
  86
  87         u64                     events_size;
  88         u64                     events_count;
  89         u64                     non_sample_count;
  90
  91         /* Ordered events configured queue size. */
  92         u64                     queue_size;
  93 };
  94
  95 static int value_set(struct bt_ctf_field_type *type,
  96                      struct bt_ctf_event *event,
  97                      const char *name, u64 val)
  98 {
  99         struct bt_ctf_field *field;
 100         bool sign = bt_ctf_field_type_integer_get_signed(type);
 101         int ret;
 102
 103         field = bt_ctf_field_create(type);
 104         if (!field) {
 105                 pr_err("failed to create a field %s\n", name);
 106                 return -1;
 107         }
 108
 109         if (sign) {
 110                 ret = bt_ctf_field_signed_integer_set_value(field, val);
 111                 if (ret) {
 112                         pr_err("failed to set field value %s\n", name);
 113                         goto err;
 114                 }
 115         } else {
 116                 ret = bt_ctf_field_unsigned_integer_set_value(field, val);
 117                 if (ret) {
 118                         pr_err("failed to set field value %s\n", name);
 119                         goto err;
 120                 }
 121         }
 122
 123         ret = bt_ctf_event_set_payload(event, name, field);
 124         if (ret) {
 125                 pr_err("failed to set payload %s\n", name);
 126                 goto err;
 127         }
 128
 129         pr2("  SET [%s = %" PRIu64 "]\n", name, val);
 130
 131 err:
 132         bt_ctf_field_put(field);
 133         return ret;
 134 }
 135
 136 #define __FUNC_VALUE_SET(_name, _val_type)                              \
 137 static __maybe_unused int value_set_##_name(struct ctf_writer *cw,      \
 138                              struct bt_ctf_event *event,                \
 139                              const char *name,                          \
 140                              _val_type val)                             \
 141 {                                                                       \
 142         struct bt_ctf_field_type *type = cw->data._name;                \
 143         return value_set(type, event, name, (u64) val);                 \
 144 }
 145
 146 #define FUNC_VALUE_SET(_name) __FUNC_VALUE_SET(_name, _name)
 147
 148 FUNC_VALUE_SET(s32)
 149 FUNC_VALUE_SET(u32)
 150 FUNC_VALUE_SET(s64)
 151 FUNC_VALUE_SET(u64)
 152 __FUNC_VALUE_SET(u64_hex, u64)
 153
 154 static int string_set_value(struct bt_ctf_field *field, const char *string);
 155 static __maybe_unused int
 156 value_set_string(struct ctf_writer *cw, struct bt_ctf_event *event,
 157                  const char *name, const char *string)
 158 {
 159         struct bt_ctf_field_type *type = cw->data.string;
 160         struct bt_ctf_field *field;
 161         int ret = 0;
 162
 163         field = bt_ctf_field_create(type);
 164         if (!field) {
 165                 pr_err("failed to create a field %s\n", name);
 166                 return -1;
 167         }
 168
 169         ret = string_set_value(field, string);
 170         if (ret) {
 171                 pr_err("failed to set value %s\n", name);
 172                 goto err_put_field;
 173         }
 174
 175         ret = bt_ctf_event_set_payload(event, name, field);
 176         if (ret)
 177                 pr_err("failed to set payload %s\n", name);
 178
 179 err_put_field:
 180         bt_ctf_field_put(field);
 181         return ret;
 182 }
 183
 184 static struct bt_ctf_field_type*
 185 get_tracepoint_field_type(struct ctf_writer *cw, struct format_field *field)
 186 {
 187         unsigned long flags = field->flags;
 188
 189         if (flags & FIELD_IS_STRING)
 190                 return cw->data.string;
 191
 192         if (!(flags & FIELD_IS_SIGNED)) {
 193                 /* unsigned long are mostly pointers */
 194                 if (flags & FIELD_IS_LONG || flags & FIELD_IS_POINTER)
 195                         return cw->data.u64_hex;
 196         }
 197
 198         if (flags & FIELD_IS_SIGNED) {
 199                 if (field->size == 8)
 200                         return cw->data.s64;
 201                 else
 202                         return cw->data.s32;
 203         }
 204
 205         if (field->size == 8)
 206                 return cw->data.u64;
 207         else
 208                 return cw->data.u32;
 209 }
 210
 211 static unsigned long long adjust_signedness(unsigned long long value_int, int size)
 212 {
 213         unsigned long long value_mask;
 214
 215         /*
 216          * value_mask = (1 << (size * 8 - 1)) - 1.
 217          * Directly set value_mask for code readers.
 218          */
 219         switch (size) {
 220         case 1:
 221                 value_mask = 0x7fULL;
 222                 break;
 223         case 2:
 224                 value_mask = 0x7fffULL;
 225                 break;
 226         case 4:
 227                 value_mask = 0x7fffffffULL;
 228                 break;
 229         case 8:
 230                 /*
 231                  * For 64 bit value, return it self. There is no need
 232                  * to fill high bit.
 233                  */
 234                 /* Fall through */
 235         default:
 236                 /* BUG! */
 237                 return value_int;
 238         }
 239
 240         /* If it is a positive value, don't adjust. */
 241         if ((value_int & (~0ULL - value_mask)) == 0)
 242                 return value_int;
 243
 244         /* Fill upper part of value_int with 1 to make it a negative long long. */
 245         return (value_int & value_mask) | ~value_mask;
 246 }
 247
 248 static int string_set_value(struct bt_ctf_field *field, const char *string)
 249 {
 250         char *buffer = NULL;
 251         size_t len = strlen(string), i, p;
 252         int err;
 253
 254         for (i = p = 0; i < len; i++, p++) {
 255                 if (isprint(string[i])) {
 256                         if (!buffer)
 257                                 continue;
 258                         buffer[p] = string[i];
 259                 } else {
 260                         char numstr[5];
 261
 262                         snprintf(numstr, sizeof(numstr), "\\x%02x",
 263                                  (unsigned int)(string[i]) & 0xff);
 264
 265                         if (!buffer) {
 266                                 buffer = zalloc(i + (len - i) * 4 + 2);
 267                                 if (!buffer) {
 268                                         pr_err("failed to set unprintable string '%s'\n", string);
 269                                         return bt_ctf_field_string_set_value(field, "UNPRINTABLE-STRING");
 270                                 }
 271                                 if (i > 0)
 272                                         strncpy(buffer, string, i);
 273                         }
 274                         memcpy(buffer + p, numstr, 4);
 275                         p += 3;
 276                 }
 277         }
 278
 279         if (!buffer)
 280                 return bt_ctf_field_string_set_value(field, string);
 281         err = bt_ctf_field_string_set_value(field, buffer);
 282         free(buffer);
 283         return err;
 284 }
 285
 286 static int add_tracepoint_field_value(struct ctf_writer *cw,
 287                                       struct bt_ctf_event_class *event_class,
 288                                       struct bt_ctf_event *event,
 289                                       struct perf_sample *sample,
 290                                       struct format_field *fmtf)
 291 {
 292         struct bt_ctf_field_type *type;
 293         struct bt_ctf_field *array_field;
 294         struct bt_ctf_field *field;
 295         const char *name = fmtf->name;
 296         void *data = sample->raw_data;
 297         unsigned long flags = fmtf->flags;
 298         unsigned int n_items;
 299         unsigned int i;
 300         unsigned int offset;
 301         unsigned int len;
 302         int ret;
 303
 304         name = fmtf->alias;
 305         offset = fmtf->offset;
 306         len = fmtf->size;
 307         if (flags & FIELD_IS_STRING)
 308                 flags &= ~FIELD_IS_ARRAY;
 309
 310         if (flags & FIELD_IS_DYNAMIC) {
 311                 unsigned long long tmp_val;
 312
 313                 tmp_val = tep_read_number(fmtf->event->pevent,
 314                                           data + offset, len);
 315                 offset = tmp_val;
 316                 len = offset >> 16;
 317                 offset &= 0xffff;
 318         }
 319
 320         if (flags & FIELD_IS_ARRAY) {
 321
 322                 type = bt_ctf_event_class_get_field_by_name(
 323                                 event_class, name);
 324                 array_field = bt_ctf_field_create(type);
 325                 bt_ctf_field_type_put(type);
 326                 if (!array_field) {
 327                         pr_err("Failed to create array type %s\n", name);
 328                         return -1;
 329                 }
 330
 331                 len = fmtf->size / fmtf->arraylen;
 332                 n_items = fmtf->arraylen;
 333         } else {
 334                 n_items = 1;
 335                 array_field = NULL;
 336         }
 337
 338         type = get_tracepoint_field_type(cw, fmtf);
 339
 340         for (i = 0; i < n_items; i++) {
 341                 if (flags & FIELD_IS_ARRAY)
 342                         field = bt_ctf_field_array_get_field(array_field, i);
 343                 else
 344                         field = bt_ctf_field_create(type);
 345
 346                 if (!field) {
 347                         pr_err("failed to create a field %s\n", name);
 348                         return -1;
 349                 }
 350
 351                 if (flags & FIELD_IS_STRING)
 352                         ret = string_set_value(field, data + offset + i * len);
 353                 else {
 354                         unsigned long long value_int;
 355
 356                         value_int = tep_read_number(
 357                                         fmtf->event->pevent,
 358                                         data + offset + i * len, len);
 359
 360                         if (!(flags & FIELD_IS_SIGNED))
 361                                 ret = bt_ctf_field_unsigned_integer_set_value(
 362                                                 field, value_int);
 363                         else
 364                                 ret = bt_ctf_field_signed_integer_set_value(
 365                                                 field, adjust_signedness(value_int, len));
 366                 }
 367
 368                 if (ret) {
 369                         pr_err("failed to set file value %s\n", name);
 370                         goto err_put_field;
 371                 }
 372                 if (!(flags & FIELD_IS_ARRAY)) {
 373                         ret = bt_ctf_event_set_payload(event, name, field);
 374                         if (ret) {
 375                                 pr_err("failed to set payload %s\n", name);
 376                                 goto err_put_field;
 377                         }
 378                 }
 379                 bt_ctf_field_put(field);
 380         }
 381         if (flags & FIELD_IS_ARRAY) {
 382                 ret = bt_ctf_event_set_payload(event, name, array_field);
 383                 if (ret) {
 384                         pr_err("Failed add payload array %s\n", name);
 385                         return -1;
 386                 }
 387                 bt_ctf_field_put(array_field);
 388         }
 389         return 0;
 390
 391 err_put_field:
 392         bt_ctf_field_put(field);
 393         return -1;
 394 }
 395
 396 static int add_tracepoint_fields_values(struct ctf_writer *cw,
 397                                         struct bt_ctf_event_class *event_class,
 398                                         struct bt_ctf_event *event,
 399                                         struct format_field *fields,
 400                                         struct perf_sample *sample)
 401 {
 402         struct format_field *field;
 403         int ret;
 404
 405         for (field = fields; field; field = field->next) {
 406                 ret = add_tracepoint_field_value(cw, event_class, event, sample,
 407                                 field);
 408                 if (ret)
 409                         return -1;
 410         }
 411         return 0;
 412 }
 413
 414 static int add_tracepoint_values(struct ctf_writer *cw,
 415                                  struct bt_ctf_event_class *event_class,
 416                                  struct bt_ctf_event *event,
 417                                  struct perf_evsel *evsel,
 418                                  struct perf_sample *sample)
 419 {
 420         struct format_field *common_fields = evsel->tp_format->format.common_fields;
 421         struct format_field *fields        = evsel->tp_format->format.fields;
 422         int ret;
 423
 424         ret = add_tracepoint_fields_values(cw, event_class, event,
 425                                            common_fields, sample);
 426         if (!ret)
 427                 ret = add_tracepoint_fields_values(cw, event_class, event,
 428                                                    fields, sample);
 429
 430         return ret;
 431 }
 432
 433 static int
 434 add_bpf_output_values(struct bt_ctf_event_class *event_class,
 435                       struct bt_ctf_event *event,
 436                       struct perf_sample *sample)
 437 {
 438         struct bt_ctf_field_type *len_type, *seq_type;
 439         struct bt_ctf_field *len_field, *seq_field;
 440         unsigned int raw_size = sample->raw_size;
 441         unsigned int nr_elements = raw_size / sizeof(u32);
 442         unsigned int i;
 443         int ret;
 444
 445         if (nr_elements * sizeof(u32) != raw_size)
 446                 pr_warning("Incorrect raw_size (%u) in bpf output event, skip %zu bytes\n",
 447                            raw_size, nr_elements * sizeof(u32) - raw_size);
 448
 449         len_type = bt_ctf_event_class_get_field_by_name(event_class, "raw_len");
 450         len_field = bt_ctf_field_create(len_type);
 451         if (!len_field) {
 452                 pr_err("failed to create 'raw_len' for bpf output event\n");
 453                 ret = -1;
 454                 goto put_len_type;
 455         }
 456
 457         ret = bt_ctf_field_unsigned_integer_set_value(len_field, nr_elements);
 458         if (ret) {
 459                 pr_err("failed to set field value for raw_len\n");
 460                 goto put_len_field;
 461         }
 462         ret = bt_ctf_event_set_payload(event, "raw_len", len_field);
 463         if (ret) {
 464                 pr_err("failed to set payload to raw_len\n");
 465                 goto put_len_field;
 466         }
 467
 468         seq_type = bt_ctf_event_class_get_field_by_name(event_class, "raw_data");
 469         seq_field = bt_ctf_field_create(seq_type);
 470         if (!seq_field) {
 471                 pr_err("failed to create 'raw_data' for bpf output event\n");
 472                 ret = -1;
 473                 goto put_seq_type;
 474         }
 475
 476         ret = bt_ctf_field_sequence_set_length(seq_field, len_field);
 477         if (ret) {
 478                 pr_err("failed to set length of 'raw_data'\n");
 479                 goto put_seq_field;
 480         }
 481
 482         for (i = 0; i < nr_elements; i++) {
 483                 struct bt_ctf_field *elem_field =
 484                         bt_ctf_field_sequence_get_field(seq_field, i);
 485
 486                 ret = bt_ctf_field_unsigned_integer_set_value(elem_field,
 487                                 ((u32 *)(sample->raw_data))[i]);
 488
 489                 bt_ctf_field_put(elem_field);
 490                 if (ret) {
 491                         pr_err("failed to set raw_data[%d]\n", i);
 492                         goto put_seq_field;
 493                 }
 494         }
 495
 496         ret = bt_ctf_event_set_payload(event, "raw_data", seq_field);
 497         if (ret)
 498                 pr_err("failed to set payload for raw_data\n");
 499
 500 put_seq_field:
 501         bt_ctf_field_put(seq_field);
 502 put_seq_type:
 503         bt_ctf_field_type_put(seq_type);
 504 put_len_field:
 505         bt_ctf_field_put(len_field);
 506 put_len_type:
 507         bt_ctf_field_type_put(len_type);
 508         return ret;
 509 }
 510
 511 static int
 512 add_callchain_output_values(struct bt_ctf_event_class *event_class,
 513                       struct bt_ctf_event *event,
 514                       struct ip_callchain *callchain)
 515 {
 516         struct bt_ctf_field_type *len_type, *seq_type;
 517         struct bt_ctf_field *len_field, *seq_field;
 518         unsigned int nr_elements = callchain->nr;
 519         unsigned int i;
 520         int ret;
 521
 522         len_type = bt_ctf_event_class_get_field_by_name(
 523                         event_class, "perf_callchain_size");
 524         len_field = bt_ctf_field_create(len_type);
 525         if (!len_field) {
 526                 pr_err("failed to create 'perf_callchain_size' for callchain output event\n");
 527                 ret = -1;
 528                 goto put_len_type;
 529         }
 530
 531         ret = bt_ctf_field_unsigned_integer_set_value(len_field, nr_elements);
 532         if (ret) {
 533                 pr_err("failed to set field value for perf_callchain_size\n");
 534                 goto put_len_field;
 535         }
 536         ret = bt_ctf_event_set_payload(event, "perf_callchain_size", len_field);
 537         if (ret) {
 538                 pr_err("failed to set payload to perf_callchain_size\n");
 539                 goto put_len_field;
 540         }
 541
 542         seq_type = bt_ctf_event_class_get_field_by_name(
 543                         event_class, "perf_callchain");
 544         seq_field = bt_ctf_field_create(seq_type);
 545         if (!seq_field) {
 546                 pr_err("failed to create 'perf_callchain' for callchain output event\n");
 547                 ret = -1;
 548                 goto put_seq_type;
 549         }
 550
 551         ret = bt_ctf_field_sequence_set_length(seq_field, len_field);
 552         if (ret) {
 553                 pr_err("failed to set length of 'perf_callchain'\n");
 554                 goto put_seq_field;
 555         }
 556
 557         for (i = 0; i < nr_elements; i++) {
 558                 struct bt_ctf_field *elem_field =
 559                         bt_ctf_field_sequence_get_field(seq_field, i);
 560
 561                 ret = bt_ctf_field_unsigned_integer_set_value(elem_field,
 562                                 ((u64 *)(callchain->ips))[i]);
 563
 564                 bt_ctf_field_put(elem_field);
 565                 if (ret) {
 566                         pr_err("failed to set callchain[%d]\n", i);
 567                         goto put_seq_field;
 568                 }
 569         }
 570
 571         ret = bt_ctf_event_set_payload(event, "perf_callchain", seq_field);
 572         if (ret)
 573                 pr_err("failed to set payload for raw_data\n");
 574
 575 put_seq_field:
 576         bt_ctf_field_put(seq_field);
 577 put_seq_type:
 578         bt_ctf_field_type_put(seq_type);
 579 put_len_field:
 580         bt_ctf_field_put(len_field);
 581 put_len_type:
 582         bt_ctf_field_type_put(len_type);
 583         return ret;
 584 }
 585
 586 static int add_generic_values(struct ctf_writer *cw,
 587                               struct bt_ctf_event *event,
 588                               struct perf_evsel *evsel,
 589                               struct perf_sample *sample)
 590 {
 591         u64 type = evsel->attr.sample_type;
 592         int ret;
 593
 594         /*
 595          * missing:
 596          *   PERF_SAMPLE_TIME         - not needed as we have it in
 597          *                              ctf event header
 598          *   PERF_SAMPLE_READ         - TODO
 599          *   PERF_SAMPLE_RAW          - tracepoint fields are handled separately
 600          *   PERF_SAMPLE_BRANCH_STACK - TODO
 601          *   PERF_SAMPLE_REGS_USER    - TODO
 602          *   PERF_SAMPLE_STACK_USER   - TODO
 603          */
 604
 605         if (type & PERF_SAMPLE_IP) {
 606                 ret = value_set_u64_hex(cw, event, "perf_ip", sample->ip);
 607                 if (ret)
 608                         return -1;
 609         }
 610
 611         if (type & PERF_SAMPLE_TID) {
 612                 ret = value_set_s32(cw, event, "perf_tid", sample->tid);
 613                 if (ret)
 614                         return -1;
 615
 616                 ret = value_set_s32(cw, event, "perf_pid", sample->pid);
 617                 if (ret)
 618                         return -1;
 619         }
 620
 621         if ((type & PERF_SAMPLE_ID) ||
 622             (type & PERF_SAMPLE_IDENTIFIER)) {
 623                 ret = value_set_u64(cw, event, "perf_id", sample->id);
 624                 if (ret)
 625                         return -1;
 626         }
 627
 628         if (type & PERF_SAMPLE_STREAM_ID) {
 629                 ret = value_set_u64(cw, event, "perf_stream_id", sample->stream_id);
 630                 if (ret)
 631                         return -1;
 632         }
 633
 634         if (type & PERF_SAMPLE_PERIOD) {
 635                 ret = value_set_u64(cw, event, "perf_period", sample->period);
 636                 if (ret)
 637                         return -1;
 638         }
 639
 640         if (type & PERF_SAMPLE_WEIGHT) {
 641                 ret = value_set_u64(cw, event, "perf_weight", sample->weight);
 642                 if (ret)
 643                         return -1;
 644         }
 645
 646         if (type & PERF_SAMPLE_DATA_SRC) {
 647                 ret = value_set_u64(cw, event, "perf_data_src",
 648                                 sample->data_src);
 649                 if (ret)
 650                         return -1;
 651         }
 652
 653         if (type & PERF_SAMPLE_TRANSACTION) {
 654                 ret = value_set_u64(cw, event, "perf_transaction",
 655                                 sample->transaction);
 656                 if (ret)
 657                         return -1;
 658         }
 659
 660         return 0;
 661 }
 662
 663 static int ctf_stream__flush(struct ctf_stream *cs)
 664 {
 665         int err = 0;
 666
 667         if (cs) {
 668                 err = bt_ctf_stream_flush(cs->stream);
 669                 if (err)
 670                         pr_err("CTF stream %d flush failed\n", cs->cpu);
 671
 672                 pr("Flush stream for cpu %d (%u samples)\n",
 673                    cs->cpu, cs->count);
 674
 675                 cs->count = 0;
 676         }
 677
 678         return err;
 679 }
 680
 681 static struct ctf_stream *ctf_stream__create(struct ctf_writer *cw, int cpu)
 682 {
 683         struct ctf_stream *cs;
 684         struct bt_ctf_field *pkt_ctx   = NULL;
 685         struct bt_ctf_field *cpu_field = NULL;
 686         struct bt_ctf_stream *stream   = NULL;
 687         int ret;
 688
 689         cs = zalloc(sizeof(*cs));
 690         if (!cs) {
 691                 pr_err("Failed to allocate ctf stream\n");
 692                 return NULL;
 693         }
 694
 695         stream = bt_ctf_writer_create_stream(cw->writer, cw->stream_class);
 696         if (!stream) {
 697                 pr_err("Failed to create CTF stream\n");
 698                 goto out;
 699         }
 700
 701         pkt_ctx = bt_ctf_stream_get_packet_context(stream);
 702         if (!pkt_ctx) {
 703                 pr_err("Failed to obtain packet context\n");
 704                 goto out;
 705         }
 706
 707         cpu_field = bt_ctf_field_structure_get_field(pkt_ctx, "cpu_id");
 708         bt_ctf_field_put(pkt_ctx);
 709         if (!cpu_field) {
 710                 pr_err("Failed to obtain cpu field\n");
 711                 goto out;
 712         }
 713
 714         ret = bt_ctf_field_unsigned_integer_set_value(cpu_field, (u32) cpu);
 715         if (ret) {
 716                 pr_err("Failed to update CPU number\n");
 717                 goto out;
 718         }
 719
 720         bt_ctf_field_put(cpu_field);
 721
 722         cs->cpu    = cpu;
 723         cs->stream = stream;
 724         return cs;
 725
 726 out:
 727         if (cpu_field)
 728                 bt_ctf_field_put(cpu_field);
 729         if (stream)
 730                 bt_ctf_stream_put(stream);
 731
 732         free(cs);
 733         return NULL;
 734 }
 735
 736 static void ctf_stream__delete(struct ctf_stream *cs)
 737 {
 738         if (cs) {
 739                 bt_ctf_stream_put(cs->stream);
 740                 free(cs);
 741         }
 742 }
 743
 744 static struct ctf_stream *ctf_stream(struct ctf_writer *cw, int cpu)
 745 {
 746         struct ctf_stream *cs = cw->stream[cpu];
 747
 748         if (!cs) {
 749                 cs = ctf_stream__create(cw, cpu);
 750                 cw->stream[cpu] = cs;
 751         }
 752
 753         return cs;
 754 }
 755
 756 static int get_sample_cpu(struct ctf_writer *cw, struct perf_sample *sample,
 757                           struct perf_evsel *evsel)
 758 {
 759         int cpu = 0;
 760
 761         if (evsel->attr.sample_type & PERF_SAMPLE_CPU)
 762                 cpu = sample->cpu;
 763
 764         if (cpu > cw->stream_cnt) {
 765                 pr_err("Event was recorded for CPU %d, limit is at %d.\n",
 766                         cpu, cw->stream_cnt);
 767                 cpu = 0;
 768         }
 769
 770         return cpu;
 771 }
 772
 773 #define STREAM_FLUSH_COUNT 100000
 774
 775 /*
 776  * Currently we have no other way to determine the
 777  * time for the stream flush other than keep track
 778  * of the number of events and check it against
 779  * threshold.
 780  */
 781 static bool is_flush_needed(struct ctf_stream *cs)
 782 {
 783         return cs->count >= STREAM_FLUSH_COUNT;
 784 }
 785
 786 static int process_sample_event(struct perf_tool *tool,
 787                                 union perf_event *_event,
 788                                 struct perf_sample *sample,
 789                                 struct perf_evsel *evsel,
 790                                 struct machine *machine __maybe_unused)
 791 {
 792         struct convert *c = container_of(tool, struct convert, tool);
 793         struct evsel_priv *priv = evsel->priv;
 794         struct ctf_writer *cw = &c->writer;
 795         struct ctf_stream *cs;
 796         struct bt_ctf_event_class *event_class;
 797         struct bt_ctf_event *event;
 798         int ret;
 799         unsigned long type = evsel->attr.sample_type;
 800
 801         if (WARN_ONCE(!priv, "Failed to setup all events.\n"))
 802                 return 0;
 803
 804         event_class = priv->event_class;
 805
 806         /* update stats */
 807         c->events_count++;
 808         c->events_size += _event->header.size;
 809
 810         pr_time2(sample->time, "sample %" PRIu64 "\n", c->events_count);
 811
 812         event = bt_ctf_event_create(event_class);
 813         if (!event) {
 814                 pr_err("Failed to create an CTF event\n");
 815                 return -1;
 816         }
 817
 818         bt_ctf_clock_set_time(cw->clock, sample->time);
 819
 820         ret = add_generic_values(cw, event, evsel, sample);
 821         if (ret)
 822                 return -1;
 823
 824         if (evsel->attr.type == PERF_TYPE_TRACEPOINT) {
 825                 ret = add_tracepoint_values(cw, event_class, event,
 826                                             evsel, sample);
 827                 if (ret)
 828                         return -1;
 829         }
 830
 831         if (type & PERF_SAMPLE_CALLCHAIN) {
 832                 ret = add_callchain_output_values(event_class,
 833                                 event, sample->callchain);
 834                 if (ret)
 835                         return -1;
 836         }
 837
 838         if (perf_evsel__is_bpf_output(evsel)) {
 839                 ret = add_bpf_output_values(event_class, event, sample);
 840                 if (ret)
 841                         return -1;
 842         }
 843
 844         cs = ctf_stream(cw, get_sample_cpu(cw, sample, evsel));
 845         if (cs) {
 846                 if (is_flush_needed(cs))
 847                         ctf_stream__flush(cs);
 848
 849                 cs->count++;
 850                 bt_ctf_stream_append_event(cs->stream, event);
 851         }
 852
 853         bt_ctf_event_put(event);
 854         return cs ? 0 : -1;
 855 }
 856
 857 #define __NON_SAMPLE_SET_FIELD(_name, _type, _field)    \
 858 do {                                                    \
 859         ret = value_set_##_type(cw, event, #_field, _event->_name._field);\
 860         if (ret)                                        \
 861                 return -1;                              \
 862 } while(0)
 863
 864 #define __FUNC_PROCESS_NON_SAMPLE(_name, body)  \
 865 static int process_##_name##_event(struct perf_tool *tool,      \
 866                                    union perf_event *_event,    \
 867                                    struct perf_sample *sample,  \
 868                                    struct machine *machine)     \
 869 {                                                               \
 870         struct convert *c = container_of(tool, struct convert, tool);\
 871         struct ctf_writer *cw = &c->writer;                     \
 872         struct bt_ctf_event_class *event_class = cw->_name##_class;\
 873         struct bt_ctf_event *event;                             \
 874         struct ctf_stream *cs;                                  \
 875         int ret;                                                \
 876                                                                 \
 877         c->non_sample_count++;                                  \
 878         c->events_size += _event->header.size;                  \
 879         event = bt_ctf_event_create(event_class);               \
 880         if (!event) {                                           \
 881                 pr_err("Failed to create an CTF event\n");      \
 882                 return -1;                                      \
 883         }                                                       \
 884                                                                 \
 885         bt_ctf_clock_set_time(cw->clock, sample->time);         \
 886         body                                                    \
 887         cs = ctf_stream(cw, 0);                                 \
 888         if (cs) {                                               \
 889                 if (is_flush_needed(cs))                        \
 890                         ctf_stream__flush(cs);                  \
 891                                                                 \
 892                 cs->count++;                                    \
 893                 bt_ctf_stream_append_event(cs->stream, event);  \
 894         }                                                       \
 895         bt_ctf_event_put(event);                                \
 896                                                                 \
 897         return perf_event__process_##_name(tool, _event, sample, machine);\
 898 }
 899
 900 __FUNC_PROCESS_NON_SAMPLE(comm,
 901         __NON_SAMPLE_SET_FIELD(comm, u32, pid);
 902         __NON_SAMPLE_SET_FIELD(comm, u32, tid);
 903         __NON_SAMPLE_SET_FIELD(comm, string, comm);
 904 )
 905 __FUNC_PROCESS_NON_SAMPLE(fork,
 906         __NON_SAMPLE_SET_FIELD(fork, u32, pid);
 907         __NON_SAMPLE_SET_FIELD(fork, u32, ppid);
 908         __NON_SAMPLE_SET_FIELD(fork, u32, tid);
 909         __NON_SAMPLE_SET_FIELD(fork, u32, ptid);
 910         __NON_SAMPLE_SET_FIELD(fork, u64, time);
 911 )
 912
 913 __FUNC_PROCESS_NON_SAMPLE(exit,
 914         __NON_SAMPLE_SET_FIELD(fork, u32, pid);
 915         __NON_SAMPLE_SET_FIELD(fork, u32, ppid);
 916         __NON_SAMPLE_SET_FIELD(fork, u32, tid);
 917         __NON_SAMPLE_SET_FIELD(fork, u32, ptid);
 918         __NON_SAMPLE_SET_FIELD(fork, u64, time);
 919 )
 920 __FUNC_PROCESS_NON_SAMPLE(mmap,
 921         __NON_SAMPLE_SET_FIELD(mmap, u32, pid);
 922         __NON_SAMPLE_SET_FIELD(mmap, u32, tid);
 923         __NON_SAMPLE_SET_FIELD(mmap, u64_hex, start);
 924         __NON_SAMPLE_SET_FIELD(mmap, string, filename);
 925 )
 926 __FUNC_PROCESS_NON_SAMPLE(mmap2,
 927         __NON_SAMPLE_SET_FIELD(mmap2, u32, pid);
 928         __NON_SAMPLE_SET_FIELD(mmap2, u32, tid);
 929         __NON_SAMPLE_SET_FIELD(mmap2, u64_hex, start);
 930         __NON_SAMPLE_SET_FIELD(mmap2, string, filename);
 931 )
 932 #undef __NON_SAMPLE_SET_FIELD
 933 #undef __FUNC_PROCESS_NON_SAMPLE
 934
 935 /* If dup < 0, add a prefix. Else, add _dupl_X suffix. */
 936 static char *change_name(char *name, char *orig_name, int dup)
 937 {
 938         char *new_name = NULL;
 939         size_t len;
 940
 941         if (!name)
 942                 name = orig_name;
 943
 944         if (dup >= 10)
 945                 goto out;
 946         /*
 947          * Add '_' prefix to potential keywork.  According to
 948          * Mathieu Desnoyers (https://lkml.org/lkml/2015/1/23/652),
 949          * futher CTF spec updating may require us to use '$'.
 950          */
 951         if (dup < 0)
 952                 len = strlen(name) + sizeof("_");
 953         else
 954                 len = strlen(orig_name) + sizeof("_dupl_X");
 955
 956         new_name = malloc(len);
 957         if (!new_name)
 958                 goto out;
 959
 960         if (dup < 0)
 961                 snprintf(new_name, len, "_%s", name);
 962         else
 963                 snprintf(new_name, len, "%s_dupl_%d", orig_name, dup);
 964
 965 out:
 966         if (name != orig_name)
 967                 free(name);
 968         return new_name;
 969 }
 970
 971 static int event_class_add_field(struct bt_ctf_event_class *event_class,
 972                 struct bt_ctf_field_type *type,
 973                 struct format_field *field)
 974 {
 975         struct bt_ctf_field_type *t = NULL;
 976         char *name;
 977         int dup = 1;
 978         int ret;
 979
 980         /* alias was already assigned */
 981         if (field->alias != field->name)
 982                 return bt_ctf_event_class_add_field(event_class, type,
 983                                 (char *)field->alias);
 984
 985         name = field->name;
 986
 987         /* If 'name' is a keywork, add prefix. */
 988         if (bt_ctf_validate_identifier(name))
 989                 name = change_name(name, field->name, -1);
 990
 991         if (!name) {
 992                 pr_err("Failed to fix invalid identifier.");
 993                 return -1;
 994         }
 995         while ((t = bt_ctf_event_class_get_field_by_name(event_class, name))) {
 996                 bt_ctf_field_type_put(t);
 997                 name = change_name(name, field->name, dup++);
 998                 if (!name) {
 999                         pr_err("Failed to create dup name for '%s'\n", field->name);
1000                         return -1;
1001                 }
1002         }
1003
1004         ret = bt_ctf_event_class_add_field(event_class, type, name);
1005         if (!ret)
1006                 field->alias = name;
1007
1008         return ret;
1009 }
1010
1011 static int add_tracepoint_fields_types(struct ctf_writer *cw,
1012                                        struct format_field *fields,
1013                                        struct bt_ctf_event_class *event_class)
1014 {
1015         struct format_field *field;
1016         int ret;
1017
1018         for (field = fields; field; field = field->next) {
1019                 struct bt_ctf_field_type *type;
1020                 unsigned long flags = field->flags;
1021
1022                 pr2("  field '%s'\n", field->name);
1023
1024                 type = get_tracepoint_field_type(cw, field);
1025                 if (!type)
1026                         return -1;
1027
1028                 /*
1029                  * A string is an array of chars. For this we use the string
1030                  * type and don't care that it is an array. What we don't
1031                  * support is an array of strings.
1032                  */
1033                 if (flags & FIELD_IS_STRING)
1034                         flags &= ~FIELD_IS_ARRAY;
1035
1036                 if (flags & FIELD_IS_ARRAY)
1037                         type = bt_ctf_field_type_array_create(type, field->arraylen);
1038
1039                 ret = event_class_add_field(event_class, type, field);
1040
1041                 if (flags & FIELD_IS_ARRAY)
1042                         bt_ctf_field_type_put(type);
1043
1044                 if (ret) {
1045                         pr_err("Failed to add field '%s': %d\n",
1046                                         field->name, ret);
1047                         return -1;
1048                 }
1049         }
1050
1051         return 0;
1052 }
1053
1054 static int add_tracepoint_types(struct ctf_writer *cw,
1055                                 struct perf_evsel *evsel,
1056                                 struct bt_ctf_event_class *class)
1057 {
1058         struct format_field *common_fields = evsel->tp_format->format.common_fields;
1059         struct format_field *fields        = evsel->tp_format->format.fields;
1060         int ret;
1061
1062         ret = add_tracepoint_fields_types(cw, common_fields, class);
1063         if (!ret)
1064                 ret = add_tracepoint_fields_types(cw, fields, class);
1065
1066         return ret;
1067 }
1068
1069 static int add_bpf_output_types(struct ctf_writer *cw,
1070                                 struct bt_ctf_event_class *class)
1071 {
1072         struct bt_ctf_field_type *len_type = cw->data.u32;
1073         struct bt_ctf_field_type *seq_base_type = cw->data.u32_hex;
1074         struct bt_ctf_field_type *seq_type;
1075         int ret;
1076
1077         ret = bt_ctf_event_class_add_field(class, len_type, "raw_len");
1078         if (ret)
1079                 return ret;
1080
1081         seq_type = bt_ctf_field_type_sequence_create(seq_base_type, "raw_len");
1082         if (!seq_type)
1083                 return -1;
1084
1085         return bt_ctf_event_class_add_field(class, seq_type, "raw_data");
1086 }
1087
1088 static int add_generic_types(struct ctf_writer *cw, struct perf_evsel *evsel,
1089                              struct bt_ctf_event_class *event_class)
1090 {
1091         u64 type = evsel->attr.sample_type;
1092
1093         /*
1094          * missing:
1095          *   PERF_SAMPLE_TIME         - not needed as we have it in
1096          *                              ctf event header
1097          *   PERF_SAMPLE_READ         - TODO
1098          *   PERF_SAMPLE_CALLCHAIN    - TODO
1099          *   PERF_SAMPLE_RAW          - tracepoint fields and BPF output
1100          *                              are handled separately
1101          *   PERF_SAMPLE_BRANCH_STACK - TODO
1102          *   PERF_SAMPLE_REGS_USER    - TODO
1103          *   PERF_SAMPLE_STACK_USER   - TODO
1104          */
1105
1106 #define ADD_FIELD(cl, t, n)                                             \
1107         do {                                                            \
1108                 pr2("  field '%s'\n", n);                               \
1109                 if (bt_ctf_event_class_add_field(cl, t, n)) {           \
1110                         pr_err("Failed to add field '%s';\n", n);       \
1111                         return -1;                                      \
1112                 }                                                       \
1113         } while (0)
1114
1115         if (type & PERF_SAMPLE_IP)
1116                 ADD_FIELD(event_class, cw->data.u64_hex, "perf_ip");
1117
1118         if (type & PERF_SAMPLE_TID) {
1119                 ADD_FIELD(event_class, cw->data.s32, "perf_tid");
1120                 ADD_FIELD(event_class, cw->data.s32, "perf_pid");
1121         }
1122
1123         if ((type & PERF_SAMPLE_ID) ||
1124             (type & PERF_SAMPLE_IDENTIFIER))
1125                 ADD_FIELD(event_class, cw->data.u64, "perf_id");
1126
1127         if (type & PERF_SAMPLE_STREAM_ID)
1128                 ADD_FIELD(event_class, cw->data.u64, "perf_stream_id");
1129
1130         if (type & PERF_SAMPLE_PERIOD)
1131                 ADD_FIELD(event_class, cw->data.u64, "perf_period");
1132
1133         if (type & PERF_SAMPLE_WEIGHT)
1134                 ADD_FIELD(event_class, cw->data.u64, "perf_weight");
1135
1136         if (type & PERF_SAMPLE_DATA_SRC)
1137                 ADD_FIELD(event_class, cw->data.u64, "perf_data_src");
1138
1139         if (type & PERF_SAMPLE_TRANSACTION)
1140                 ADD_FIELD(event_class, cw->data.u64, "perf_transaction");
1141
1142         if (type & PERF_SAMPLE_CALLCHAIN) {
1143                 ADD_FIELD(event_class, cw->data.u32, "perf_callchain_size");
1144                 ADD_FIELD(event_class,
1145                         bt_ctf_field_type_sequence_create(
1146                                 cw->data.u64_hex, "perf_callchain_size"),
1147                         "perf_callchain");
1148         }
1149
1150 #undef ADD_FIELD
1151         return 0;
1152 }
1153
1154 static int add_event(struct ctf_writer *cw, struct perf_evsel *evsel)
1155 {
1156         struct bt_ctf_event_class *event_class;
1157         struct evsel_priv *priv;
1158         const char *name = perf_evsel__name(evsel);
1159         int ret;
1160
1161         pr("Adding event '%s' (type %d)\n", name, evsel->attr.type);
1162
1163         event_class = bt_ctf_event_class_create(name);
1164         if (!event_class)
1165                 return -1;
1166
1167         ret = add_generic_types(cw, evsel, event_class);
1168         if (ret)
1169                 goto err;
1170
1171         if (evsel->attr.type == PERF_TYPE_TRACEPOINT) {
1172                 ret = add_tracepoint_types(cw, evsel, event_class);
1173                 if (ret)
1174                         goto err;
1175         }
1176
1177         if (perf_evsel__is_bpf_output(evsel)) {
1178                 ret = add_bpf_output_types(cw, event_class);
1179                 if (ret)
1180                         goto err;
1181         }
1182
1183         ret = bt_ctf_stream_class_add_event_class(cw->stream_class, event_class);
1184         if (ret) {
1185                 pr("Failed to add event class into stream.\n");
1186                 goto err;
1187         }
1188
1189         priv = malloc(sizeof(*priv));
1190         if (!priv)
1191                 goto err;
1192
1193         priv->event_class = event_class;
1194         evsel->priv       = priv;
1195         return 0;
1196
1197 err:
1198         bt_ctf_event_class_put(event_class);
1199         pr_err("Failed to add event '%s'.\n", name);
1200         return -1;
1201 }
1202
1203 static int setup_events(struct ctf_writer *cw, struct perf_session *session)
1204 {
1205         struct perf_evlist *evlist = session->evlist;
1206         struct perf_evsel *evsel;
1207         int ret;
1208
1209         evlist__for_each_entry(evlist, evsel) {
1210                 ret = add_event(cw, evsel);
1211                 if (ret)
1212                         return ret;
1213         }
1214         return 0;
1215 }
1216
1217 #define __NON_SAMPLE_ADD_FIELD(t, n)                                            \
1218         do {                                                    \
1219                 pr2("  field '%s'\n", #n);                      \
1220                 if (bt_ctf_event_class_add_field(event_class, cw->data.t, #n)) {\
1221                         pr_err("Failed to add field '%s';\n", #n);\
1222                         return -1;                              \
1223                 }                                               \
1224         } while(0)
1225
1226 #define __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(_name, body)          \
1227 static int add_##_name##_event(struct ctf_writer *cw)           \
1228 {                                                               \
1229         struct bt_ctf_event_class *event_class;                 \
1230         int ret;                                                \
1231                                                                 \
1232         pr("Adding "#_name" event\n");                          \
1233         event_class = bt_ctf_event_class_create("perf_" #_name);\
1234         if (!event_class)                                       \
1235                 return -1;                                      \
1236         body                                                    \
1237                                                                 \
1238         ret = bt_ctf_stream_class_add_event_class(cw->stream_class, event_class);\
1239         if (ret) {                                              \
1240                 pr("Failed to add event class '"#_name"' into stream.\n");\
1241                 return ret;                                     \
1242         }                                                       \
1243                                                                 \
1244         cw->_name##_class = event_class;                        \
1245         bt_ctf_event_class_put(event_class);                    \
1246         return 0;                                               \
1247 }
1248
1249 __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(comm,
1250         __NON_SAMPLE_ADD_FIELD(u32, pid);
1251         __NON_SAMPLE_ADD_FIELD(u32, tid);
1252         __NON_SAMPLE_ADD_FIELD(string, comm);
1253 )
1254
1255 __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(fork,
1256         __NON_SAMPLE_ADD_FIELD(u32, pid);
1257         __NON_SAMPLE_ADD_FIELD(u32, ppid);
1258         __NON_SAMPLE_ADD_FIELD(u32, tid);
1259         __NON_SAMPLE_ADD_FIELD(u32, ptid);
1260         __NON_SAMPLE_ADD_FIELD(u64, time);
1261 )
1262
1263 __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(exit,
1264         __NON_SAMPLE_ADD_FIELD(u32, pid);
1265         __NON_SAMPLE_ADD_FIELD(u32, ppid);
1266         __NON_SAMPLE_ADD_FIELD(u32, tid);
1267         __NON_SAMPLE_ADD_FIELD(u32, ptid);
1268         __NON_SAMPLE_ADD_FIELD(u64, time);
1269 )
1270
1271 __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(mmap,
1272         __NON_SAMPLE_ADD_FIELD(u32, pid);
1273         __NON_SAMPLE_ADD_FIELD(u32, tid);
1274         __NON_SAMPLE_ADD_FIELD(u64_hex, start);
1275         __NON_SAMPLE_ADD_FIELD(string, filename);
1276 )
1277
1278 __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(mmap2,
1279         __NON_SAMPLE_ADD_FIELD(u32, pid);
1280         __NON_SAMPLE_ADD_FIELD(u32, tid);
1281         __NON_SAMPLE_ADD_FIELD(u64_hex, start);
1282         __NON_SAMPLE_ADD_FIELD(string, filename);
1283 )
1284 #undef __NON_SAMPLE_ADD_FIELD
1285 #undef __FUNC_ADD_NON_SAMPLE_EVENT_CLASS
1286
1287 static int setup_non_sample_events(struct ctf_writer *cw,
1288                                    struct perf_session *session __maybe_unused)
1289 {
1290         int ret;
1291
1292         ret = add_comm_event(cw);
1293         if (ret)
1294                 return ret;
1295         ret = add_exit_event(cw);
1296         if (ret)
1297                 return ret;
1298         ret = add_fork_event(cw);
1299         if (ret)
1300                 return ret;
1301         ret = add_mmap_event(cw);
1302         if (ret)
1303                 return ret;
1304         ret = add_mmap2_event(cw);
1305         if (ret)
1306                 return ret;
1307         return 0;
1308 }
1309
1310 static void cleanup_events(struct perf_session *session)
1311 {
1312         struct perf_evlist *evlist = session->evlist;
1313         struct perf_evsel *evsel;
1314
1315         evlist__for_each_entry(evlist, evsel) {
1316                 struct evsel_priv *priv;
1317
1318                 priv = evsel->priv;
1319                 bt_ctf_event_class_put(priv->event_class);
1320                 zfree(&evsel->priv);
1321         }
1322
1323         perf_evlist__delete(evlist);
1324         session->evlist = NULL;
1325 }
1326
1327 static int setup_streams(struct ctf_writer *cw, struct perf_session *session)
1328 {
1329         struct ctf_stream **stream;
1330         struct perf_header *ph = &session->header;
1331         int ncpus;
1332
1333         /*
1334          * Try to get the number of cpus used in the data file,
1335          * if not present fallback to the MAX_CPUS.
1336          */
1337         ncpus = ph->env.nr_cpus_avail ?: MAX_CPUS;
1338
1339         stream = zalloc(sizeof(*stream) * ncpus);
1340         if (!stream) {
1341                 pr_err("Failed to allocate streams.\n");
1342                 return -ENOMEM;
1343         }
1344
1345         cw->stream     = stream;
1346         cw->stream_cnt = ncpus;
1347         return 0;
1348 }
1349
1350 static void free_streams(struct ctf_writer *cw)
1351 {
1352         int cpu;
1353
1354         for (cpu = 0; cpu < cw->stream_cnt; cpu++)
1355                 ctf_stream__delete(cw->stream[cpu]);
1356
1357         free(cw->stream);
1358 }
1359
1360 static int ctf_writer__setup_env(struct ctf_writer *cw,
1361                                  struct perf_session *session)
1362 {
1363         struct perf_header *header = &session->header;
1364         struct bt_ctf_writer *writer = cw->writer;
1365
1366 #define ADD(__n, __v)                                                   \
1367 do {                                                                    \
1368         if (bt_ctf_writer_add_environment_field(writer, __n, __v))      \
1369                 return -1;                                              \
1370 } while (0)
1371
1372         ADD("host",    header->env.hostname);
1373         ADD("sysname", "Linux");
1374         ADD("release", header->env.os_release);
1375         ADD("version", header->env.version);
1376         ADD("machine", header->env.arch);
1377         ADD("domain", "kernel");
1378         ADD("tracer_name", "perf");
1379
1380 #undef ADD
1381         return 0;
1382 }
1383
1384 static int ctf_writer__setup_clock(struct ctf_writer *cw)
1385 {
1386         struct bt_ctf_clock *clock = cw->clock;
1387
1388         bt_ctf_clock_set_description(clock, "perf clock");
1389
1390 #define SET(__n, __v)                           \
1391 do {                                            \
1392         if (bt_ctf_clock_set_##__n(clock, __v)) \
1393                 return -1;                      \
1394 } while (0)
1395
1396         SET(frequency,   1000000000);
1397         SET(offset_s,    0);
1398         SET(offset,      0);
1399         SET(precision,   10);
1400         SET(is_absolute, 0);
1401
1402 #undef SET
1403         return 0;
1404 }
1405
1406 static struct bt_ctf_field_type *create_int_type(int size, bool sign, bool hex)
1407 {
1408         struct bt_ctf_field_type *type;
1409
1410         type = bt_ctf_field_type_integer_create(size);
1411         if (!type)
1412                 return NULL;
1413
1414         if (sign &&
1415             bt_ctf_field_type_integer_set_signed(type, 1))
1416                 goto err;
1417
1418         if (hex &&
1419             bt_ctf_field_type_integer_set_base(type, BT_CTF_INTEGER_BASE_HEXADECIMAL))
1420                 goto err;
1421
1422 #if __BYTE_ORDER == __BIG_ENDIAN
1423         bt_ctf_field_type_set_byte_order(type, BT_CTF_BYTE_ORDER_BIG_ENDIAN);
1424 #else
1425         bt_ctf_field_type_set_byte_order(type, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
1426 #endif
1427
1428         pr2("Created type: INTEGER %d-bit %ssigned %s\n",
1429             size, sign ? "un" : "", hex ? "hex" : "");
1430         return type;
1431
1432 err:
1433         bt_ctf_field_type_put(type);
1434         return NULL;
1435 }
1436
1437 static void ctf_writer__cleanup_data(struct ctf_writer *cw)
1438 {
1439         unsigned int i;
1440
1441         for (i = 0; i < ARRAY_SIZE(cw->data.array); i++)
1442                 bt_ctf_field_type_put(cw->data.array[i]);
1443 }
1444
1445 static int ctf_writer__init_data(struct ctf_writer *cw)
1446 {
1447 #define CREATE_INT_TYPE(type, size, sign, hex)          \
1448 do {                                                    \
1449         (type) = create_int_type(size, sign, hex);      \
1450         if (!(type))                                    \
1451                 goto err;                               \
1452 } while (0)
1453
1454         CREATE_INT_TYPE(cw->data.s64, 64, true,  false);
1455         CREATE_INT_TYPE(cw->data.u64, 64, false, false);
1456         CREATE_INT_TYPE(cw->data.s32, 32, true,  false);
1457         CREATE_INT_TYPE(cw->data.u32, 32, false, false);
1458         CREATE_INT_TYPE(cw->data.u32_hex, 32, false, true);
1459         CREATE_INT_TYPE(cw->data.u64_hex, 64, false, true);
1460
1461         cw->data.string  = bt_ctf_field_type_string_create();
1462         if (cw->data.string)
1463                 return 0;
1464
1465 err:
1466         ctf_writer__cleanup_data(cw);
1467         pr_err("Failed to create data types.\n");
1468         return -1;
1469 }
1470
1471 static void ctf_writer__cleanup(struct ctf_writer *cw)
1472 {
1473         ctf_writer__cleanup_data(cw);
1474
1475         bt_ctf_clock_put(cw->clock);
1476         free_streams(cw);
1477         bt_ctf_stream_class_put(cw->stream_class);
1478         bt_ctf_writer_put(cw->writer);
1479
1480         /* and NULL all the pointers */
1481         memset(cw, 0, sizeof(*cw));
1482 }
1483
1484 static int ctf_writer__init(struct ctf_writer *cw, const char *path)
1485 {
1486         struct bt_ctf_writer            *writer;
1487         struct bt_ctf_stream_class      *stream_class;
1488         struct bt_ctf_clock             *clock;
1489         struct bt_ctf_field_type        *pkt_ctx_type;
1490         int                             ret;
1491
1492         /* CTF writer */
1493         writer = bt_ctf_writer_create(path);
1494         if (!writer)
1495                 goto err;
1496
1497         cw->writer = writer;
1498
1499         /* CTF clock */
1500         clock = bt_ctf_clock_create("perf_clock");
1501         if (!clock) {
1502                 pr("Failed to create CTF clock.\n");
1503                 goto err_cleanup;
1504         }
1505
1506         cw->clock = clock;
1507
1508         if (ctf_writer__setup_clock(cw)) {
1509                 pr("Failed to setup CTF clock.\n");
1510                 goto err_cleanup;
1511         }
1512
1513         /* CTF stream class */
1514         stream_class = bt_ctf_stream_class_create("perf_stream");
1515         if (!stream_class) {
1516                 pr("Failed to create CTF stream class.\n");
1517                 goto err_cleanup;
1518         }
1519
1520         cw->stream_class = stream_class;
1521
1522         /* CTF clock stream setup */
1523         if (bt_ctf_stream_class_set_clock(stream_class, clock)) {
1524                 pr("Failed to assign CTF clock to stream class.\n");
1525                 goto err_cleanup;
1526         }
1527
1528         if (ctf_writer__init_data(cw))
1529                 goto err_cleanup;
1530
1531         /* Add cpu_id for packet context */
1532         pkt_ctx_type = bt_ctf_stream_class_get_packet_context_type(stream_class);
1533         if (!pkt_ctx_type)
1534                 goto err_cleanup;
1535
1536         ret = bt_ctf_field_type_structure_add_field(pkt_ctx_type, cw->data.u32, "cpu_id");
1537         bt_ctf_field_type_put(pkt_ctx_type);
1538         if (ret)
1539                 goto err_cleanup;
1540
1541         /* CTF clock writer setup */
1542         if (bt_ctf_writer_add_clock(writer, clock)) {
1543                 pr("Failed to assign CTF clock to writer.\n");
1544                 goto err_cleanup;
1545         }
1546
1547         return 0;
1548
1549 err_cleanup:
1550         ctf_writer__cleanup(cw);
1551 err:
1552         pr_err("Failed to setup CTF writer.\n");
1553         return -1;
1554 }
1555
1556 static int ctf_writer__flush_streams(struct ctf_writer *cw)
1557 {
1558         int cpu, ret = 0;
1559
1560         for (cpu = 0; cpu < cw->stream_cnt && !ret; cpu++)
1561                 ret = ctf_stream__flush(cw->stream[cpu]);
1562
1563         return ret;
1564 }
1565
1566 static int convert__config(const char *var, const char *value, void *cb)
1567 {
1568         struct convert *c = cb;
1569
1570         if (!strcmp(var, "convert.queue-size"))
1571                 return perf_config_u64(&c->queue_size, var, value);
1572
1573         return 0;
1574 }
1575
1576 int bt_convert__perf2ctf(const char *input, const char *path,
1577                          struct perf_data_convert_opts *opts)
1578 {
1579         struct perf_session *session;
1580         struct perf_data data = {
1581                 .file.path = input,
1582                 .mode      = PERF_DATA_MODE_READ,
1583                 .force     = opts->force,
1584         };
1585         struct convert c = {
1586                 .tool = {
1587                         .sample          = process_sample_event,
1588                         .mmap            = perf_event__process_mmap,
1589                         .mmap2           = perf_event__process_mmap2,
1590                         .comm            = perf_event__process_comm,
1591                         .exit            = perf_event__process_exit,
1592                         .fork            = perf_event__process_fork,
1593                         .lost            = perf_event__process_lost,
1594                         .tracing_data    = perf_event__process_tracing_data,
1595                         .build_id        = perf_event__process_build_id,
1596                         .namespaces      = perf_event__process_namespaces,
1597                         .ordered_events  = true,
1598                         .ordering_requires_timestamps = true,
1599                 },
1600         };
1601         struct ctf_writer *cw = &c.writer;
1602         int err;
1603
1604         if (opts->all) {
1605                 c.tool.comm = process_comm_event;
1606                 c.tool.exit = process_exit_event;
1607                 c.tool.fork = process_fork_event;
1608                 c.tool.mmap = process_mmap_event;
1609                 c.tool.mmap2 = process_mmap2_event;
1610         }
1611
1612         err = perf_config(convert__config, &c);
1613         if (err)
1614                 return err;
1615
1616         /* CTF writer */
1617         if (ctf_writer__init(cw, path))
1618                 return -1;
1619
1620         err = -1;
1621         /* perf.data session */
1622         session = perf_session__new(&data, 0, &c.tool);
1623         if (!session)
1624                 goto free_writer;
1625
1626         if (c.queue_size) {
1627                 ordered_events__set_alloc_size(&session->ordered_events,
1628                                                c.queue_size);
1629         }
1630
1631         /* CTF writer env/clock setup  */
1632         if (ctf_writer__setup_env(cw, session))
1633                 goto free_session;
1634
1635         /* CTF events setup */
1636         if (setup_events(cw, session))
1637                 goto free_session;
1638
1639         if (opts->all && setup_non_sample_events(cw, session))
1640                 goto free_session;
1641
1642         if (setup_streams(cw, session))
1643                 goto free_session;
1644
1645         err = perf_session__process_events(session);
1646         if (!err)
1647                 err = ctf_writer__flush_streams(cw);
1648         else
1649                 pr_err("Error during conversion.\n");
1650
1651         fprintf(stderr,
1652                 "[ perf data convert: Converted '%s' into CTF data '%s' ]\n",
1653                 data.file.path, path);
1654
1655         fprintf(stderr,
1656                 "[ perf data convert: Converted and wrote %.3f MB (%" PRIu64 " samples",
1657                 (double) c.events_size / 1024.0 / 1024.0,
1658                 c.events_count);
1659
1660         if (!c.non_sample_count)
1661                 fprintf(stderr, ") ]\n");
1662         else
1663                 fprintf(stderr, ", %" PRIu64 " non-samples) ]\n", c.non_sample_count);
1664
1665         cleanup_events(session);
1666         perf_session__delete(session);
1667         ctf_writer__cleanup(cw);
1668
1669         return err;
1670
1671 free_session:
1672         perf_session__delete(session);
1673 free_writer:
1674         ctf_writer__cleanup(cw);
1675         pr_err("Error during conversion setup.\n");
1676         return err;
1677 }