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