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