1 // SPDX-License-Identifier: GPL-2.0-only
3 * CTF writing support via babeltrace.
5 * Copyright (C) 2014, Jiri Olsa <jolsa@redhat.com>
6 * Copyright (C) 2014, Sebastian Andrzej Siewior <bigeasy@linutronix.de>
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>
24 #include "data-convert.h"
32 #include <linux/ctype.h>
33 #include <linux/err.h>
34 #include <linux/time64.h>
38 #define pr_N(n, fmt, ...) \
39 eprintf(n, debug_data_convert, fmt, ##__VA_ARGS__)
41 #define pr(fmt, ...) pr_N(1, pr_fmt(fmt), ##__VA_ARGS__)
42 #define pr2(fmt, ...) pr_N(2, pr_fmt(fmt), ##__VA_ARGS__)
44 #define pr_time2(t, fmt, ...) pr_time_N(2, debug_data_convert, t, pr_fmt(fmt), ##__VA_ARGS__)
47 struct bt_ctf_event_class *event_class;
53 struct bt_ctf_stream *stream;
59 /* writer primitives */
60 struct bt_ctf_writer *writer;
61 struct ctf_stream **stream;
63 struct bt_ctf_stream_class *stream_class;
64 struct bt_ctf_clock *clock;
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;
77 struct bt_ctf_field_type *array[6];
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;
87 struct perf_tool tool;
88 struct ctf_writer writer;
94 /* Ordered events configured queue size. */
98 static int value_set(struct bt_ctf_field_type *type,
99 struct bt_ctf_event *event,
100 const char *name, u64 val)
102 struct bt_ctf_field *field;
103 bool sign = bt_ctf_field_type_integer_get_signed(type);
106 field = bt_ctf_field_create(type);
108 pr_err("failed to create a field %s\n", name);
113 ret = bt_ctf_field_signed_integer_set_value(field, val);
115 pr_err("failed to set field value %s\n", name);
119 ret = bt_ctf_field_unsigned_integer_set_value(field, val);
121 pr_err("failed to set field value %s\n", name);
126 ret = bt_ctf_event_set_payload(event, name, field);
128 pr_err("failed to set payload %s\n", name);
132 pr2(" SET [%s = %" PRIu64 "]\n", name, val);
135 bt_ctf_field_put(field);
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, \
145 struct bt_ctf_field_type *type = cw->data._name; \
146 return value_set(type, event, name, (u64) val); \
149 #define FUNC_VALUE_SET(_name) __FUNC_VALUE_SET(_name, _name)
155 __FUNC_VALUE_SET(u64_hex, u64)
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)
162 struct bt_ctf_field_type *type = cw->data.string;
163 struct bt_ctf_field *field;
166 field = bt_ctf_field_create(type);
168 pr_err("failed to create a field %s\n", name);
172 ret = string_set_value(field, string);
174 pr_err("failed to set value %s\n", name);
178 ret = bt_ctf_event_set_payload(event, name, field);
180 pr_err("failed to set payload %s\n", name);
183 bt_ctf_field_put(field);
187 static struct bt_ctf_field_type*
188 get_tracepoint_field_type(struct ctf_writer *cw, struct tep_format_field *field)
190 unsigned long flags = field->flags;
192 if (flags & TEP_FIELD_IS_STRING)
193 return cw->data.string;
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;
201 if (flags & TEP_FIELD_IS_SIGNED) {
202 if (field->size == 8)
208 if (field->size == 8)
214 static unsigned long long adjust_signedness(unsigned long long value_int, int size)
216 unsigned long long value_mask;
219 * value_mask = (1 << (size * 8 - 1)) - 1.
220 * Directly set value_mask for code readers.
224 value_mask = 0x7fULL;
227 value_mask = 0x7fffULL;
230 value_mask = 0x7fffffffULL;
234 * For 64 bit value, return it self. There is no need
243 /* If it is a positive value, don't adjust. */
244 if ((value_int & (~0ULL - value_mask)) == 0)
247 /* Fill upper part of value_int with 1 to make it a negative long long. */
248 return (value_int & value_mask) | ~value_mask;
251 static int string_set_value(struct bt_ctf_field *field, const char *string)
254 size_t len = strlen(string), i, p;
257 for (i = p = 0; i < len; i++, p++) {
258 if (isprint(string[i])) {
261 buffer[p] = string[i];
265 snprintf(numstr, sizeof(numstr), "\\x%02x",
266 (unsigned int)(string[i]) & 0xff);
269 buffer = zalloc(i + (len - i) * 4 + 2);
271 pr_err("failed to set unprintable string '%s'\n", string);
272 return bt_ctf_field_string_set_value(field, "UNPRINTABLE-STRING");
275 strncpy(buffer, string, i);
277 memcpy(buffer + p, numstr, 4);
283 return bt_ctf_field_string_set_value(field, string);
284 err = bt_ctf_field_string_set_value(field, buffer);
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)
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;
308 offset = fmtf->offset;
310 if (flags & TEP_FIELD_IS_STRING)
311 flags &= ~TEP_FIELD_IS_ARRAY;
313 if (flags & TEP_FIELD_IS_DYNAMIC) {
314 unsigned long long tmp_val;
316 tmp_val = tep_read_number(fmtf->event->tep,
321 if (flags & TEP_FIELD_IS_RELATIVE)
322 offset += fmtf->offset + fmtf->size;
325 if (flags & TEP_FIELD_IS_ARRAY) {
327 type = bt_ctf_event_class_get_field_by_name(
329 array_field = bt_ctf_field_create(type);
330 bt_ctf_field_type_put(type);
332 pr_err("Failed to create array type %s\n", name);
336 len = fmtf->size / fmtf->arraylen;
337 n_items = fmtf->arraylen;
343 type = get_tracepoint_field_type(cw, fmtf);
345 for (i = 0; i < n_items; i++) {
346 if (flags & TEP_FIELD_IS_ARRAY)
347 field = bt_ctf_field_array_get_field(array_field, i);
349 field = bt_ctf_field_create(type);
352 pr_err("failed to create a field %s\n", name);
356 if (flags & TEP_FIELD_IS_STRING)
357 ret = string_set_value(field, data + offset + i * len);
359 unsigned long long value_int;
361 value_int = tep_read_number(
363 data + offset + i * len, len);
365 if (!(flags & TEP_FIELD_IS_SIGNED))
366 ret = bt_ctf_field_unsigned_integer_set_value(
369 ret = bt_ctf_field_signed_integer_set_value(
370 field, adjust_signedness(value_int, len));
374 pr_err("failed to set file value %s\n", name);
377 if (!(flags & TEP_FIELD_IS_ARRAY)) {
378 ret = bt_ctf_event_set_payload(event, name, field);
380 pr_err("failed to set payload %s\n", name);
384 bt_ctf_field_put(field);
386 if (flags & TEP_FIELD_IS_ARRAY) {
387 ret = bt_ctf_event_set_payload(event, name, array_field);
389 pr_err("Failed add payload array %s\n", name);
392 bt_ctf_field_put(array_field);
397 bt_ctf_field_put(field);
401 static int add_tracepoint_fields_values(struct ctf_writer *cw,
402 struct bt_ctf_event_class *event_class,
403 struct bt_ctf_event *event,
404 struct tep_format_field *fields,
405 struct perf_sample *sample)
407 struct tep_format_field *field;
410 for (field = fields; field; field = field->next) {
411 ret = add_tracepoint_field_value(cw, event_class, event, sample,
419 static int add_tracepoint_values(struct ctf_writer *cw,
420 struct bt_ctf_event_class *event_class,
421 struct bt_ctf_event *event,
423 struct perf_sample *sample)
425 struct tep_format_field *common_fields = evsel->tp_format->format.common_fields;
426 struct tep_format_field *fields = evsel->tp_format->format.fields;
429 ret = add_tracepoint_fields_values(cw, event_class, event,
430 common_fields, sample);
432 ret = add_tracepoint_fields_values(cw, event_class, event,
439 add_bpf_output_values(struct bt_ctf_event_class *event_class,
440 struct bt_ctf_event *event,
441 struct perf_sample *sample)
443 struct bt_ctf_field_type *len_type, *seq_type;
444 struct bt_ctf_field *len_field, *seq_field;
445 unsigned int raw_size = sample->raw_size;
446 unsigned int nr_elements = raw_size / sizeof(u32);
450 if (nr_elements * sizeof(u32) != raw_size)
451 pr_warning("Incorrect raw_size (%u) in bpf output event, skip %zu bytes\n",
452 raw_size, nr_elements * sizeof(u32) - raw_size);
454 len_type = bt_ctf_event_class_get_field_by_name(event_class, "raw_len");
455 len_field = bt_ctf_field_create(len_type);
457 pr_err("failed to create 'raw_len' for bpf output event\n");
462 ret = bt_ctf_field_unsigned_integer_set_value(len_field, nr_elements);
464 pr_err("failed to set field value for raw_len\n");
467 ret = bt_ctf_event_set_payload(event, "raw_len", len_field);
469 pr_err("failed to set payload to raw_len\n");
473 seq_type = bt_ctf_event_class_get_field_by_name(event_class, "raw_data");
474 seq_field = bt_ctf_field_create(seq_type);
476 pr_err("failed to create 'raw_data' for bpf output event\n");
481 ret = bt_ctf_field_sequence_set_length(seq_field, len_field);
483 pr_err("failed to set length of 'raw_data'\n");
487 for (i = 0; i < nr_elements; i++) {
488 struct bt_ctf_field *elem_field =
489 bt_ctf_field_sequence_get_field(seq_field, i);
491 ret = bt_ctf_field_unsigned_integer_set_value(elem_field,
492 ((u32 *)(sample->raw_data))[i]);
494 bt_ctf_field_put(elem_field);
496 pr_err("failed to set raw_data[%d]\n", i);
501 ret = bt_ctf_event_set_payload(event, "raw_data", seq_field);
503 pr_err("failed to set payload for raw_data\n");
506 bt_ctf_field_put(seq_field);
508 bt_ctf_field_type_put(seq_type);
510 bt_ctf_field_put(len_field);
512 bt_ctf_field_type_put(len_type);
517 add_callchain_output_values(struct bt_ctf_event_class *event_class,
518 struct bt_ctf_event *event,
519 struct ip_callchain *callchain)
521 struct bt_ctf_field_type *len_type, *seq_type;
522 struct bt_ctf_field *len_field, *seq_field;
523 unsigned int nr_elements = callchain->nr;
527 len_type = bt_ctf_event_class_get_field_by_name(
528 event_class, "perf_callchain_size");
529 len_field = bt_ctf_field_create(len_type);
531 pr_err("failed to create 'perf_callchain_size' for callchain output event\n");
536 ret = bt_ctf_field_unsigned_integer_set_value(len_field, nr_elements);
538 pr_err("failed to set field value for perf_callchain_size\n");
541 ret = bt_ctf_event_set_payload(event, "perf_callchain_size", len_field);
543 pr_err("failed to set payload to perf_callchain_size\n");
547 seq_type = bt_ctf_event_class_get_field_by_name(
548 event_class, "perf_callchain");
549 seq_field = bt_ctf_field_create(seq_type);
551 pr_err("failed to create 'perf_callchain' for callchain output event\n");
556 ret = bt_ctf_field_sequence_set_length(seq_field, len_field);
558 pr_err("failed to set length of 'perf_callchain'\n");
562 for (i = 0; i < nr_elements; i++) {
563 struct bt_ctf_field *elem_field =
564 bt_ctf_field_sequence_get_field(seq_field, i);
566 ret = bt_ctf_field_unsigned_integer_set_value(elem_field,
567 ((u64 *)(callchain->ips))[i]);
569 bt_ctf_field_put(elem_field);
571 pr_err("failed to set callchain[%d]\n", i);
576 ret = bt_ctf_event_set_payload(event, "perf_callchain", seq_field);
578 pr_err("failed to set payload for raw_data\n");
581 bt_ctf_field_put(seq_field);
583 bt_ctf_field_type_put(seq_type);
585 bt_ctf_field_put(len_field);
587 bt_ctf_field_type_put(len_type);
591 static int add_generic_values(struct ctf_writer *cw,
592 struct bt_ctf_event *event,
594 struct perf_sample *sample)
596 u64 type = evsel->core.attr.sample_type;
601 * PERF_SAMPLE_TIME - not needed as we have it in
603 * PERF_SAMPLE_READ - TODO
604 * PERF_SAMPLE_RAW - tracepoint fields are handled separately
605 * PERF_SAMPLE_BRANCH_STACK - TODO
606 * PERF_SAMPLE_REGS_USER - TODO
607 * PERF_SAMPLE_STACK_USER - TODO
610 if (type & PERF_SAMPLE_IP) {
611 ret = value_set_u64_hex(cw, event, "perf_ip", sample->ip);
616 if (type & PERF_SAMPLE_TID) {
617 ret = value_set_s32(cw, event, "perf_tid", sample->tid);
621 ret = value_set_s32(cw, event, "perf_pid", sample->pid);
626 if ((type & PERF_SAMPLE_ID) ||
627 (type & PERF_SAMPLE_IDENTIFIER)) {
628 ret = value_set_u64(cw, event, "perf_id", sample->id);
633 if (type & PERF_SAMPLE_STREAM_ID) {
634 ret = value_set_u64(cw, event, "perf_stream_id", sample->stream_id);
639 if (type & PERF_SAMPLE_PERIOD) {
640 ret = value_set_u64(cw, event, "perf_period", sample->period);
645 if (type & PERF_SAMPLE_WEIGHT) {
646 ret = value_set_u64(cw, event, "perf_weight", sample->weight);
651 if (type & PERF_SAMPLE_DATA_SRC) {
652 ret = value_set_u64(cw, event, "perf_data_src",
658 if (type & PERF_SAMPLE_TRANSACTION) {
659 ret = value_set_u64(cw, event, "perf_transaction",
660 sample->transaction);
668 static int ctf_stream__flush(struct ctf_stream *cs)
673 err = bt_ctf_stream_flush(cs->stream);
675 pr_err("CTF stream %d flush failed\n", cs->cpu);
677 pr("Flush stream for cpu %d (%u samples)\n",
686 static struct ctf_stream *ctf_stream__create(struct ctf_writer *cw, int cpu)
688 struct ctf_stream *cs;
689 struct bt_ctf_field *pkt_ctx = NULL;
690 struct bt_ctf_field *cpu_field = NULL;
691 struct bt_ctf_stream *stream = NULL;
694 cs = zalloc(sizeof(*cs));
696 pr_err("Failed to allocate ctf stream\n");
700 stream = bt_ctf_writer_create_stream(cw->writer, cw->stream_class);
702 pr_err("Failed to create CTF stream\n");
706 pkt_ctx = bt_ctf_stream_get_packet_context(stream);
708 pr_err("Failed to obtain packet context\n");
712 cpu_field = bt_ctf_field_structure_get_field(pkt_ctx, "cpu_id");
713 bt_ctf_field_put(pkt_ctx);
715 pr_err("Failed to obtain cpu field\n");
719 ret = bt_ctf_field_unsigned_integer_set_value(cpu_field, (u32) cpu);
721 pr_err("Failed to update CPU number\n");
725 bt_ctf_field_put(cpu_field);
733 bt_ctf_field_put(cpu_field);
735 bt_ctf_stream_put(stream);
741 static void ctf_stream__delete(struct ctf_stream *cs)
744 bt_ctf_stream_put(cs->stream);
749 static struct ctf_stream *ctf_stream(struct ctf_writer *cw, int cpu)
751 struct ctf_stream *cs = cw->stream[cpu];
754 cs = ctf_stream__create(cw, cpu);
755 cw->stream[cpu] = cs;
761 static int get_sample_cpu(struct ctf_writer *cw, struct perf_sample *sample,
766 if (evsel->core.attr.sample_type & PERF_SAMPLE_CPU)
769 if (cpu > cw->stream_cnt) {
770 pr_err("Event was recorded for CPU %d, limit is at %d.\n",
771 cpu, cw->stream_cnt);
778 #define STREAM_FLUSH_COUNT 100000
781 * Currently we have no other way to determine the
782 * time for the stream flush other than keep track
783 * of the number of events and check it against
786 static bool is_flush_needed(struct ctf_stream *cs)
788 return cs->count >= STREAM_FLUSH_COUNT;
791 static int process_sample_event(struct perf_tool *tool,
792 union perf_event *_event,
793 struct perf_sample *sample,
795 struct machine *machine __maybe_unused)
797 struct convert *c = container_of(tool, struct convert, tool);
798 struct evsel_priv *priv = evsel->priv;
799 struct ctf_writer *cw = &c->writer;
800 struct ctf_stream *cs;
801 struct bt_ctf_event_class *event_class;
802 struct bt_ctf_event *event;
804 unsigned long type = evsel->core.attr.sample_type;
806 if (WARN_ONCE(!priv, "Failed to setup all events.\n"))
809 event_class = priv->event_class;
813 c->events_size += _event->header.size;
815 pr_time2(sample->time, "sample %" PRIu64 "\n", c->events_count);
817 event = bt_ctf_event_create(event_class);
819 pr_err("Failed to create an CTF event\n");
823 bt_ctf_clock_set_time(cw->clock, sample->time);
825 ret = add_generic_values(cw, event, evsel, sample);
829 if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) {
830 ret = add_tracepoint_values(cw, event_class, event,
836 if (type & PERF_SAMPLE_CALLCHAIN) {
837 ret = add_callchain_output_values(event_class,
838 event, sample->callchain);
843 if (evsel__is_bpf_output(evsel)) {
844 ret = add_bpf_output_values(event_class, event, sample);
849 cs = ctf_stream(cw, get_sample_cpu(cw, sample, evsel));
851 if (is_flush_needed(cs))
852 ctf_stream__flush(cs);
855 bt_ctf_stream_append_event(cs->stream, event);
858 bt_ctf_event_put(event);
862 #define __NON_SAMPLE_SET_FIELD(_name, _type, _field) \
864 ret = value_set_##_type(cw, event, #_field, _event->_name._field);\
869 #define __FUNC_PROCESS_NON_SAMPLE(_name, body) \
870 static int process_##_name##_event(struct perf_tool *tool, \
871 union perf_event *_event, \
872 struct perf_sample *sample, \
873 struct machine *machine) \
875 struct convert *c = container_of(tool, struct convert, tool);\
876 struct ctf_writer *cw = &c->writer; \
877 struct bt_ctf_event_class *event_class = cw->_name##_class;\
878 struct bt_ctf_event *event; \
879 struct ctf_stream *cs; \
882 c->non_sample_count++; \
883 c->events_size += _event->header.size; \
884 event = bt_ctf_event_create(event_class); \
886 pr_err("Failed to create an CTF event\n"); \
890 bt_ctf_clock_set_time(cw->clock, sample->time); \
892 cs = ctf_stream(cw, 0); \
894 if (is_flush_needed(cs)) \
895 ctf_stream__flush(cs); \
898 bt_ctf_stream_append_event(cs->stream, event); \
900 bt_ctf_event_put(event); \
902 return perf_event__process_##_name(tool, _event, sample, machine);\
905 __FUNC_PROCESS_NON_SAMPLE(comm,
906 __NON_SAMPLE_SET_FIELD(comm, u32, pid);
907 __NON_SAMPLE_SET_FIELD(comm, u32, tid);
908 __NON_SAMPLE_SET_FIELD(comm, string, comm);
910 __FUNC_PROCESS_NON_SAMPLE(fork,
911 __NON_SAMPLE_SET_FIELD(fork, u32, pid);
912 __NON_SAMPLE_SET_FIELD(fork, u32, ppid);
913 __NON_SAMPLE_SET_FIELD(fork, u32, tid);
914 __NON_SAMPLE_SET_FIELD(fork, u32, ptid);
915 __NON_SAMPLE_SET_FIELD(fork, u64, time);
918 __FUNC_PROCESS_NON_SAMPLE(exit,
919 __NON_SAMPLE_SET_FIELD(fork, u32, pid);
920 __NON_SAMPLE_SET_FIELD(fork, u32, ppid);
921 __NON_SAMPLE_SET_FIELD(fork, u32, tid);
922 __NON_SAMPLE_SET_FIELD(fork, u32, ptid);
923 __NON_SAMPLE_SET_FIELD(fork, u64, time);
925 __FUNC_PROCESS_NON_SAMPLE(mmap,
926 __NON_SAMPLE_SET_FIELD(mmap, u32, pid);
927 __NON_SAMPLE_SET_FIELD(mmap, u32, tid);
928 __NON_SAMPLE_SET_FIELD(mmap, u64_hex, start);
929 __NON_SAMPLE_SET_FIELD(mmap, string, filename);
931 __FUNC_PROCESS_NON_SAMPLE(mmap2,
932 __NON_SAMPLE_SET_FIELD(mmap2, u32, pid);
933 __NON_SAMPLE_SET_FIELD(mmap2, u32, tid);
934 __NON_SAMPLE_SET_FIELD(mmap2, u64_hex, start);
935 __NON_SAMPLE_SET_FIELD(mmap2, string, filename);
937 #undef __NON_SAMPLE_SET_FIELD
938 #undef __FUNC_PROCESS_NON_SAMPLE
940 /* If dup < 0, add a prefix. Else, add _dupl_X suffix. */
941 static char *change_name(char *name, char *orig_name, int dup)
943 char *new_name = NULL;
952 * Add '_' prefix to potential keywork. According to
953 * Mathieu Desnoyers (https://lore.kernel.org/lkml/1074266107.40857.1422045946295.JavaMail.zimbra@efficios.com),
954 * further CTF spec updating may require us to use '$'.
957 len = strlen(name) + sizeof("_");
959 len = strlen(orig_name) + sizeof("_dupl_X");
961 new_name = malloc(len);
966 snprintf(new_name, len, "_%s", name);
968 snprintf(new_name, len, "%s_dupl_%d", orig_name, dup);
971 if (name != orig_name)
976 static int event_class_add_field(struct bt_ctf_event_class *event_class,
977 struct bt_ctf_field_type *type,
978 struct tep_format_field *field)
980 struct bt_ctf_field_type *t = NULL;
985 /* alias was already assigned */
986 if (field->alias != field->name)
987 return bt_ctf_event_class_add_field(event_class, type,
988 (char *)field->alias);
992 /* If 'name' is a keywork, add prefix. */
993 if (bt_ctf_validate_identifier(name))
994 name = change_name(name, field->name, -1);
997 pr_err("Failed to fix invalid identifier.");
1000 while ((t = bt_ctf_event_class_get_field_by_name(event_class, name))) {
1001 bt_ctf_field_type_put(t);
1002 name = change_name(name, field->name, dup++);
1004 pr_err("Failed to create dup name for '%s'\n", field->name);
1009 ret = bt_ctf_event_class_add_field(event_class, type, name);
1011 field->alias = name;
1016 static int add_tracepoint_fields_types(struct ctf_writer *cw,
1017 struct tep_format_field *fields,
1018 struct bt_ctf_event_class *event_class)
1020 struct tep_format_field *field;
1023 for (field = fields; field; field = field->next) {
1024 struct bt_ctf_field_type *type;
1025 unsigned long flags = field->flags;
1027 pr2(" field '%s'\n", field->name);
1029 type = get_tracepoint_field_type(cw, field);
1034 * A string is an array of chars. For this we use the string
1035 * type and don't care that it is an array. What we don't
1036 * support is an array of strings.
1038 if (flags & TEP_FIELD_IS_STRING)
1039 flags &= ~TEP_FIELD_IS_ARRAY;
1041 if (flags & TEP_FIELD_IS_ARRAY)
1042 type = bt_ctf_field_type_array_create(type, field->arraylen);
1044 ret = event_class_add_field(event_class, type, field);
1046 if (flags & TEP_FIELD_IS_ARRAY)
1047 bt_ctf_field_type_put(type);
1050 pr_err("Failed to add field '%s': %d\n",
1059 static int add_tracepoint_types(struct ctf_writer *cw,
1060 struct evsel *evsel,
1061 struct bt_ctf_event_class *class)
1063 struct tep_format_field *common_fields = evsel->tp_format->format.common_fields;
1064 struct tep_format_field *fields = evsel->tp_format->format.fields;
1067 ret = add_tracepoint_fields_types(cw, common_fields, class);
1069 ret = add_tracepoint_fields_types(cw, fields, class);
1074 static int add_bpf_output_types(struct ctf_writer *cw,
1075 struct bt_ctf_event_class *class)
1077 struct bt_ctf_field_type *len_type = cw->data.u32;
1078 struct bt_ctf_field_type *seq_base_type = cw->data.u32_hex;
1079 struct bt_ctf_field_type *seq_type;
1082 ret = bt_ctf_event_class_add_field(class, len_type, "raw_len");
1086 seq_type = bt_ctf_field_type_sequence_create(seq_base_type, "raw_len");
1090 return bt_ctf_event_class_add_field(class, seq_type, "raw_data");
1093 static int add_generic_types(struct ctf_writer *cw, struct evsel *evsel,
1094 struct bt_ctf_event_class *event_class)
1096 u64 type = evsel->core.attr.sample_type;
1100 * PERF_SAMPLE_TIME - not needed as we have it in
1102 * PERF_SAMPLE_READ - TODO
1103 * PERF_SAMPLE_CALLCHAIN - TODO
1104 * PERF_SAMPLE_RAW - tracepoint fields and BPF output
1105 * are handled separately
1106 * PERF_SAMPLE_BRANCH_STACK - TODO
1107 * PERF_SAMPLE_REGS_USER - TODO
1108 * PERF_SAMPLE_STACK_USER - TODO
1111 #define ADD_FIELD(cl, t, n) \
1113 pr2(" field '%s'\n", n); \
1114 if (bt_ctf_event_class_add_field(cl, t, n)) { \
1115 pr_err("Failed to add field '%s';\n", n); \
1120 if (type & PERF_SAMPLE_IP)
1121 ADD_FIELD(event_class, cw->data.u64_hex, "perf_ip");
1123 if (type & PERF_SAMPLE_TID) {
1124 ADD_FIELD(event_class, cw->data.s32, "perf_tid");
1125 ADD_FIELD(event_class, cw->data.s32, "perf_pid");
1128 if ((type & PERF_SAMPLE_ID) ||
1129 (type & PERF_SAMPLE_IDENTIFIER))
1130 ADD_FIELD(event_class, cw->data.u64, "perf_id");
1132 if (type & PERF_SAMPLE_STREAM_ID)
1133 ADD_FIELD(event_class, cw->data.u64, "perf_stream_id");
1135 if (type & PERF_SAMPLE_PERIOD)
1136 ADD_FIELD(event_class, cw->data.u64, "perf_period");
1138 if (type & PERF_SAMPLE_WEIGHT)
1139 ADD_FIELD(event_class, cw->data.u64, "perf_weight");
1141 if (type & PERF_SAMPLE_DATA_SRC)
1142 ADD_FIELD(event_class, cw->data.u64, "perf_data_src");
1144 if (type & PERF_SAMPLE_TRANSACTION)
1145 ADD_FIELD(event_class, cw->data.u64, "perf_transaction");
1147 if (type & PERF_SAMPLE_CALLCHAIN) {
1148 ADD_FIELD(event_class, cw->data.u32, "perf_callchain_size");
1149 ADD_FIELD(event_class,
1150 bt_ctf_field_type_sequence_create(
1151 cw->data.u64_hex, "perf_callchain_size"),
1159 static int add_event(struct ctf_writer *cw, struct evsel *evsel)
1161 struct bt_ctf_event_class *event_class;
1162 struct evsel_priv *priv;
1163 const char *name = evsel__name(evsel);
1166 pr("Adding event '%s' (type %d)\n", name, evsel->core.attr.type);
1168 event_class = bt_ctf_event_class_create(name);
1172 ret = add_generic_types(cw, evsel, event_class);
1176 if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) {
1177 ret = add_tracepoint_types(cw, evsel, event_class);
1182 if (evsel__is_bpf_output(evsel)) {
1183 ret = add_bpf_output_types(cw, event_class);
1188 ret = bt_ctf_stream_class_add_event_class(cw->stream_class, event_class);
1190 pr("Failed to add event class into stream.\n");
1194 priv = malloc(sizeof(*priv));
1198 priv->event_class = event_class;
1203 bt_ctf_event_class_put(event_class);
1204 pr_err("Failed to add event '%s'.\n", name);
1208 static int setup_events(struct ctf_writer *cw, struct perf_session *session)
1210 struct evlist *evlist = session->evlist;
1211 struct evsel *evsel;
1214 evlist__for_each_entry(evlist, evsel) {
1215 ret = add_event(cw, evsel);
1222 #define __NON_SAMPLE_ADD_FIELD(t, n) \
1224 pr2(" field '%s'\n", #n); \
1225 if (bt_ctf_event_class_add_field(event_class, cw->data.t, #n)) {\
1226 pr_err("Failed to add field '%s';\n", #n);\
1231 #define __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(_name, body) \
1232 static int add_##_name##_event(struct ctf_writer *cw) \
1234 struct bt_ctf_event_class *event_class; \
1237 pr("Adding "#_name" event\n"); \
1238 event_class = bt_ctf_event_class_create("perf_" #_name);\
1243 ret = bt_ctf_stream_class_add_event_class(cw->stream_class, event_class);\
1245 pr("Failed to add event class '"#_name"' into stream.\n");\
1249 cw->_name##_class = event_class; \
1250 bt_ctf_event_class_put(event_class); \
1254 __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(comm,
1255 __NON_SAMPLE_ADD_FIELD(u32, pid);
1256 __NON_SAMPLE_ADD_FIELD(u32, tid);
1257 __NON_SAMPLE_ADD_FIELD(string, comm);
1260 __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(fork,
1261 __NON_SAMPLE_ADD_FIELD(u32, pid);
1262 __NON_SAMPLE_ADD_FIELD(u32, ppid);
1263 __NON_SAMPLE_ADD_FIELD(u32, tid);
1264 __NON_SAMPLE_ADD_FIELD(u32, ptid);
1265 __NON_SAMPLE_ADD_FIELD(u64, time);
1268 __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(exit,
1269 __NON_SAMPLE_ADD_FIELD(u32, pid);
1270 __NON_SAMPLE_ADD_FIELD(u32, ppid);
1271 __NON_SAMPLE_ADD_FIELD(u32, tid);
1272 __NON_SAMPLE_ADD_FIELD(u32, ptid);
1273 __NON_SAMPLE_ADD_FIELD(u64, time);
1276 __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(mmap,
1277 __NON_SAMPLE_ADD_FIELD(u32, pid);
1278 __NON_SAMPLE_ADD_FIELD(u32, tid);
1279 __NON_SAMPLE_ADD_FIELD(u64_hex, start);
1280 __NON_SAMPLE_ADD_FIELD(string, filename);
1283 __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(mmap2,
1284 __NON_SAMPLE_ADD_FIELD(u32, pid);
1285 __NON_SAMPLE_ADD_FIELD(u32, tid);
1286 __NON_SAMPLE_ADD_FIELD(u64_hex, start);
1287 __NON_SAMPLE_ADD_FIELD(string, filename);
1289 #undef __NON_SAMPLE_ADD_FIELD
1290 #undef __FUNC_ADD_NON_SAMPLE_EVENT_CLASS
1292 static int setup_non_sample_events(struct ctf_writer *cw,
1293 struct perf_session *session __maybe_unused)
1297 ret = add_comm_event(cw);
1300 ret = add_exit_event(cw);
1303 ret = add_fork_event(cw);
1306 ret = add_mmap_event(cw);
1309 ret = add_mmap2_event(cw);
1315 static void cleanup_events(struct perf_session *session)
1317 struct evlist *evlist = session->evlist;
1318 struct evsel *evsel;
1320 evlist__for_each_entry(evlist, evsel) {
1321 struct evsel_priv *priv;
1324 bt_ctf_event_class_put(priv->event_class);
1325 zfree(&evsel->priv);
1328 evlist__delete(evlist);
1329 session->evlist = NULL;
1332 static int setup_streams(struct ctf_writer *cw, struct perf_session *session)
1334 struct ctf_stream **stream;
1335 struct perf_header *ph = &session->header;
1339 * Try to get the number of cpus used in the data file,
1340 * if not present fallback to the MAX_CPUS.
1342 ncpus = ph->env.nr_cpus_avail ?: MAX_CPUS;
1344 stream = zalloc(sizeof(*stream) * ncpus);
1346 pr_err("Failed to allocate streams.\n");
1350 cw->stream = stream;
1351 cw->stream_cnt = ncpus;
1355 static void free_streams(struct ctf_writer *cw)
1359 for (cpu = 0; cpu < cw->stream_cnt; cpu++)
1360 ctf_stream__delete(cw->stream[cpu]);
1365 static int ctf_writer__setup_env(struct ctf_writer *cw,
1366 struct perf_session *session)
1368 struct perf_header *header = &session->header;
1369 struct bt_ctf_writer *writer = cw->writer;
1371 #define ADD(__n, __v) \
1373 if (bt_ctf_writer_add_environment_field(writer, __n, __v)) \
1377 ADD("host", header->env.hostname);
1378 ADD("sysname", "Linux");
1379 ADD("release", header->env.os_release);
1380 ADD("version", header->env.version);
1381 ADD("machine", header->env.arch);
1382 ADD("domain", "kernel");
1383 ADD("tracer_name", "perf");
1389 static int ctf_writer__setup_clock(struct ctf_writer *cw,
1390 struct perf_session *session,
1393 struct bt_ctf_clock *clock = cw->clock;
1394 const char *desc = "perf clock";
1398 struct perf_env *env = &session->header.env;
1400 if (!env->clock.enabled) {
1401 pr_err("Can't provide --tod time, missing clock data. "
1402 "Please record with -k/--clockid option.\n");
1406 desc = clockid_name(env->clock.clockid);
1407 offset = env->clock.tod_ns - env->clock.clockid_ns;
1410 #define SET(__n, __v) \
1412 if (bt_ctf_clock_set_##__n(clock, __v)) \
1416 SET(frequency, 1000000000);
1417 SET(offset, offset);
1418 SET(description, desc);
1420 SET(is_absolute, 0);
1426 static struct bt_ctf_field_type *create_int_type(int size, bool sign, bool hex)
1428 struct bt_ctf_field_type *type;
1430 type = bt_ctf_field_type_integer_create(size);
1435 bt_ctf_field_type_integer_set_signed(type, 1))
1439 bt_ctf_field_type_integer_set_base(type, BT_CTF_INTEGER_BASE_HEXADECIMAL))
1442 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
1443 bt_ctf_field_type_set_byte_order(type, BT_CTF_BYTE_ORDER_BIG_ENDIAN);
1445 bt_ctf_field_type_set_byte_order(type, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
1448 pr2("Created type: INTEGER %d-bit %ssigned %s\n",
1449 size, sign ? "un" : "", hex ? "hex" : "");
1453 bt_ctf_field_type_put(type);
1457 static void ctf_writer__cleanup_data(struct ctf_writer *cw)
1461 for (i = 0; i < ARRAY_SIZE(cw->data.array); i++)
1462 bt_ctf_field_type_put(cw->data.array[i]);
1465 static int ctf_writer__init_data(struct ctf_writer *cw)
1467 #define CREATE_INT_TYPE(type, size, sign, hex) \
1469 (type) = create_int_type(size, sign, hex); \
1474 CREATE_INT_TYPE(cw->data.s64, 64, true, false);
1475 CREATE_INT_TYPE(cw->data.u64, 64, false, false);
1476 CREATE_INT_TYPE(cw->data.s32, 32, true, false);
1477 CREATE_INT_TYPE(cw->data.u32, 32, false, false);
1478 CREATE_INT_TYPE(cw->data.u32_hex, 32, false, true);
1479 CREATE_INT_TYPE(cw->data.u64_hex, 64, false, true);
1481 cw->data.string = bt_ctf_field_type_string_create();
1482 if (cw->data.string)
1486 ctf_writer__cleanup_data(cw);
1487 pr_err("Failed to create data types.\n");
1491 static void ctf_writer__cleanup(struct ctf_writer *cw)
1493 ctf_writer__cleanup_data(cw);
1495 bt_ctf_clock_put(cw->clock);
1497 bt_ctf_stream_class_put(cw->stream_class);
1498 bt_ctf_writer_put(cw->writer);
1500 /* and NULL all the pointers */
1501 memset(cw, 0, sizeof(*cw));
1504 static int ctf_writer__init(struct ctf_writer *cw, const char *path,
1505 struct perf_session *session, bool tod)
1507 struct bt_ctf_writer *writer;
1508 struct bt_ctf_stream_class *stream_class;
1509 struct bt_ctf_clock *clock;
1510 struct bt_ctf_field_type *pkt_ctx_type;
1514 writer = bt_ctf_writer_create(path);
1518 cw->writer = writer;
1521 clock = bt_ctf_clock_create("perf_clock");
1523 pr("Failed to create CTF clock.\n");
1529 if (ctf_writer__setup_clock(cw, session, tod)) {
1530 pr("Failed to setup CTF clock.\n");
1534 /* CTF stream class */
1535 stream_class = bt_ctf_stream_class_create("perf_stream");
1536 if (!stream_class) {
1537 pr("Failed to create CTF stream class.\n");
1541 cw->stream_class = stream_class;
1543 /* CTF clock stream setup */
1544 if (bt_ctf_stream_class_set_clock(stream_class, clock)) {
1545 pr("Failed to assign CTF clock to stream class.\n");
1549 if (ctf_writer__init_data(cw))
1552 /* Add cpu_id for packet context */
1553 pkt_ctx_type = bt_ctf_stream_class_get_packet_context_type(stream_class);
1557 ret = bt_ctf_field_type_structure_add_field(pkt_ctx_type, cw->data.u32, "cpu_id");
1558 bt_ctf_field_type_put(pkt_ctx_type);
1562 /* CTF clock writer setup */
1563 if (bt_ctf_writer_add_clock(writer, clock)) {
1564 pr("Failed to assign CTF clock to writer.\n");
1571 ctf_writer__cleanup(cw);
1573 pr_err("Failed to setup CTF writer.\n");
1577 static int ctf_writer__flush_streams(struct ctf_writer *cw)
1581 for (cpu = 0; cpu < cw->stream_cnt && !ret; cpu++)
1582 ret = ctf_stream__flush(cw->stream[cpu]);
1587 static int convert__config(const char *var, const char *value, void *cb)
1589 struct convert *c = cb;
1591 if (!strcmp(var, "convert.queue-size"))
1592 return perf_config_u64(&c->queue_size, var, value);
1597 int bt_convert__perf2ctf(const char *input, const char *path,
1598 struct perf_data_convert_opts *opts)
1600 struct perf_session *session;
1601 struct perf_data data = {
1603 .mode = PERF_DATA_MODE_READ,
1604 .force = opts->force,
1606 struct convert c = {
1608 .sample = process_sample_event,
1609 .mmap = perf_event__process_mmap,
1610 .mmap2 = perf_event__process_mmap2,
1611 .comm = perf_event__process_comm,
1612 .exit = perf_event__process_exit,
1613 .fork = perf_event__process_fork,
1614 .lost = perf_event__process_lost,
1615 .tracing_data = perf_event__process_tracing_data,
1616 .build_id = perf_event__process_build_id,
1617 .namespaces = perf_event__process_namespaces,
1618 .ordered_events = true,
1619 .ordering_requires_timestamps = true,
1622 struct ctf_writer *cw = &c.writer;
1626 c.tool.comm = process_comm_event;
1627 c.tool.exit = process_exit_event;
1628 c.tool.fork = process_fork_event;
1629 c.tool.mmap = process_mmap_event;
1630 c.tool.mmap2 = process_mmap2_event;
1633 err = perf_config(convert__config, &c);
1638 /* perf.data session */
1639 session = perf_session__new(&data, &c.tool);
1640 if (IS_ERR(session))
1641 return PTR_ERR(session);
1644 if (ctf_writer__init(cw, path, session, opts->tod))
1648 ordered_events__set_alloc_size(&session->ordered_events,
1652 /* CTF writer env/clock setup */
1653 if (ctf_writer__setup_env(cw, session))
1656 /* CTF events setup */
1657 if (setup_events(cw, session))
1660 if (opts->all && setup_non_sample_events(cw, session))
1663 if (setup_streams(cw, session))
1666 err = perf_session__process_events(session);
1668 err = ctf_writer__flush_streams(cw);
1670 pr_err("Error during conversion.\n");
1673 "[ perf data convert: Converted '%s' into CTF data '%s' ]\n",
1677 "[ perf data convert: Converted and wrote %.3f MB (%" PRIu64 " samples",
1678 (double) c.events_size / 1024.0 / 1024.0,
1681 if (!c.non_sample_count)
1682 fprintf(stderr, ") ]\n");
1684 fprintf(stderr, ", %" PRIu64 " non-samples) ]\n", c.non_sample_count);
1686 cleanup_events(session);
1687 perf_session__delete(session);
1688 ctf_writer__cleanup(cw);
1693 ctf_writer__cleanup(cw);
1695 perf_session__delete(session);
1696 pr_err("Error during conversion setup.\n");