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

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