]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - tools/perf/util/data-convert-bt.c
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'vfio-ccw-20190717-2' of https://git.kernel.org/pub/scm/linux/kernel/git...
[mirror_ubuntu-hirsute-kernel.git] / 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-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 }
Ubuntu Hirsute Linux kernel mirror