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