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