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-bt.h"
32 #include <linux/ctype.h>
34 #define pr_N(n, fmt, ...) \
35 eprintf(n, debug_data_convert, fmt, ##__VA_ARGS__)
37 #define pr(fmt, ...) pr_N(1, pr_fmt(fmt), ##__VA_ARGS__)
38 #define pr2(fmt, ...) pr_N(2, pr_fmt(fmt), ##__VA_ARGS__)
40 #define pr_time2(t, fmt, ...) pr_time_N(2, debug_data_convert, t, pr_fmt(fmt), ##__VA_ARGS__)
43 struct bt_ctf_event_class *event_class;
49 struct bt_ctf_stream *stream;
55 /* writer primitives */
56 struct bt_ctf_writer *writer;
57 struct ctf_stream **stream;
59 struct bt_ctf_stream_class *stream_class;
60 struct bt_ctf_clock *clock;
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;
73 struct bt_ctf_field_type *array[6];
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;
83 struct perf_tool tool;
84 struct ctf_writer writer;
90 /* Ordered events configured queue size. */
94 static int value_set(struct bt_ctf_field_type *type,
95 struct bt_ctf_event *event,
96 const char *name, u64 val)
98 struct bt_ctf_field *field;
99 bool sign = bt_ctf_field_type_integer_get_signed(type);
102 field = bt_ctf_field_create(type);
104 pr_err("failed to create a field %s\n", name);
109 ret = bt_ctf_field_signed_integer_set_value(field, val);
111 pr_err("failed to set field value %s\n", name);
115 ret = bt_ctf_field_unsigned_integer_set_value(field, val);
117 pr_err("failed to set field value %s\n", name);
122 ret = bt_ctf_event_set_payload(event, name, field);
124 pr_err("failed to set payload %s\n", name);
128 pr2(" SET [%s = %" PRIu64 "]\n", name, val);
131 bt_ctf_field_put(field);
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, \
141 struct bt_ctf_field_type *type = cw->data._name; \
142 return value_set(type, event, name, (u64) val); \
145 #define FUNC_VALUE_SET(_name) __FUNC_VALUE_SET(_name, _name)
151 __FUNC_VALUE_SET(u64_hex, u64)
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)
158 struct bt_ctf_field_type *type = cw->data.string;
159 struct bt_ctf_field *field;
162 field = bt_ctf_field_create(type);
164 pr_err("failed to create a field %s\n", name);
168 ret = string_set_value(field, string);
170 pr_err("failed to set value %s\n", name);
174 ret = bt_ctf_event_set_payload(event, name, field);
176 pr_err("failed to set payload %s\n", name);
179 bt_ctf_field_put(field);
183 static struct bt_ctf_field_type*
184 get_tracepoint_field_type(struct ctf_writer *cw, struct tep_format_field *field)
186 unsigned long flags = field->flags;
188 if (flags & TEP_FIELD_IS_STRING)
189 return cw->data.string;
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;
197 if (flags & TEP_FIELD_IS_SIGNED) {
198 if (field->size == 8)
204 if (field->size == 8)
210 static unsigned long long adjust_signedness(unsigned long long value_int, int size)
212 unsigned long long value_mask;
215 * value_mask = (1 << (size * 8 - 1)) - 1.
216 * Directly set value_mask for code readers.
220 value_mask = 0x7fULL;
223 value_mask = 0x7fffULL;
226 value_mask = 0x7fffffffULL;
230 * For 64 bit value, return it self. There is no need
239 /* If it is a positive value, don't adjust. */
240 if ((value_int & (~0ULL - value_mask)) == 0)
243 /* Fill upper part of value_int with 1 to make it a negative long long. */
244 return (value_int & value_mask) | ~value_mask;
247 static int string_set_value(struct bt_ctf_field *field, const char *string)
250 size_t len = strlen(string), i, p;
253 for (i = p = 0; i < len; i++, p++) {
254 if (isprint(string[i])) {
257 buffer[p] = string[i];
261 snprintf(numstr, sizeof(numstr), "\\x%02x",
262 (unsigned int)(string[i]) & 0xff);
265 buffer = zalloc(i + (len - i) * 4 + 2);
267 pr_err("failed to set unprintable string '%s'\n", string);
268 return bt_ctf_field_string_set_value(field, "UNPRINTABLE-STRING");
271 strncpy(buffer, string, i);
273 memcpy(buffer + p, numstr, 4);
279 return bt_ctf_field_string_set_value(field, string);
280 err = bt_ctf_field_string_set_value(field, buffer);
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)
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;
304 offset = fmtf->offset;
306 if (flags & TEP_FIELD_IS_STRING)
307 flags &= ~TEP_FIELD_IS_ARRAY;
309 if (flags & TEP_FIELD_IS_DYNAMIC) {
310 unsigned long long tmp_val;
312 tmp_val = tep_read_number(fmtf->event->tep,
319 if (flags & TEP_FIELD_IS_ARRAY) {
321 type = bt_ctf_event_class_get_field_by_name(
323 array_field = bt_ctf_field_create(type);
324 bt_ctf_field_type_put(type);
326 pr_err("Failed to create array type %s\n", name);
330 len = fmtf->size / fmtf->arraylen;
331 n_items = fmtf->arraylen;
337 type = get_tracepoint_field_type(cw, fmtf);
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);
343 field = bt_ctf_field_create(type);
346 pr_err("failed to create a field %s\n", name);
350 if (flags & TEP_FIELD_IS_STRING)
351 ret = string_set_value(field, data + offset + i * len);
353 unsigned long long value_int;
355 value_int = tep_read_number(
357 data + offset + i * len, len);
359 if (!(flags & TEP_FIELD_IS_SIGNED))
360 ret = bt_ctf_field_unsigned_integer_set_value(
363 ret = bt_ctf_field_signed_integer_set_value(
364 field, adjust_signedness(value_int, len));
368 pr_err("failed to set file value %s\n", name);
371 if (!(flags & TEP_FIELD_IS_ARRAY)) {
372 ret = bt_ctf_event_set_payload(event, name, field);
374 pr_err("failed to set payload %s\n", name);
378 bt_ctf_field_put(field);
380 if (flags & TEP_FIELD_IS_ARRAY) {
381 ret = bt_ctf_event_set_payload(event, name, array_field);
383 pr_err("Failed add payload array %s\n", name);
386 bt_ctf_field_put(array_field);
391 bt_ctf_field_put(field);
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)
401 struct tep_format_field *field;
404 for (field = fields; field; field = field->next) {
405 ret = add_tracepoint_field_value(cw, event_class, event, sample,
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)
419 struct tep_format_field *common_fields = evsel->tp_format->format.common_fields;
420 struct tep_format_field *fields = evsel->tp_format->format.fields;
423 ret = add_tracepoint_fields_values(cw, event_class, event,
424 common_fields, sample);
426 ret = add_tracepoint_fields_values(cw, event_class, event,
433 add_bpf_output_values(struct bt_ctf_event_class *event_class,
434 struct bt_ctf_event *event,
435 struct perf_sample *sample)
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);
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);
448 len_type = bt_ctf_event_class_get_field_by_name(event_class, "raw_len");
449 len_field = bt_ctf_field_create(len_type);
451 pr_err("failed to create 'raw_len' for bpf output event\n");
456 ret = bt_ctf_field_unsigned_integer_set_value(len_field, nr_elements);
458 pr_err("failed to set field value for raw_len\n");
461 ret = bt_ctf_event_set_payload(event, "raw_len", len_field);
463 pr_err("failed to set payload to raw_len\n");
467 seq_type = bt_ctf_event_class_get_field_by_name(event_class, "raw_data");
468 seq_field = bt_ctf_field_create(seq_type);
470 pr_err("failed to create 'raw_data' for bpf output event\n");
475 ret = bt_ctf_field_sequence_set_length(seq_field, len_field);
477 pr_err("failed to set length of 'raw_data'\n");
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);
485 ret = bt_ctf_field_unsigned_integer_set_value(elem_field,
486 ((u32 *)(sample->raw_data))[i]);
488 bt_ctf_field_put(elem_field);
490 pr_err("failed to set raw_data[%d]\n", i);
495 ret = bt_ctf_event_set_payload(event, "raw_data", seq_field);
497 pr_err("failed to set payload for raw_data\n");
500 bt_ctf_field_put(seq_field);
502 bt_ctf_field_type_put(seq_type);
504 bt_ctf_field_put(len_field);
506 bt_ctf_field_type_put(len_type);
511 add_callchain_output_values(struct bt_ctf_event_class *event_class,
512 struct bt_ctf_event *event,
513 struct ip_callchain *callchain)
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;
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);
525 pr_err("failed to create 'perf_callchain_size' for callchain output event\n");
530 ret = bt_ctf_field_unsigned_integer_set_value(len_field, nr_elements);
532 pr_err("failed to set field value for perf_callchain_size\n");
535 ret = bt_ctf_event_set_payload(event, "perf_callchain_size", len_field);
537 pr_err("failed to set payload to perf_callchain_size\n");
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);
545 pr_err("failed to create 'perf_callchain' for callchain output event\n");
550 ret = bt_ctf_field_sequence_set_length(seq_field, len_field);
552 pr_err("failed to set length of 'perf_callchain'\n");
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);
560 ret = bt_ctf_field_unsigned_integer_set_value(elem_field,
561 ((u64 *)(callchain->ips))[i]);
563 bt_ctf_field_put(elem_field);
565 pr_err("failed to set callchain[%d]\n", i);
570 ret = bt_ctf_event_set_payload(event, "perf_callchain", seq_field);
572 pr_err("failed to set payload for raw_data\n");
575 bt_ctf_field_put(seq_field);
577 bt_ctf_field_type_put(seq_type);
579 bt_ctf_field_put(len_field);
581 bt_ctf_field_type_put(len_type);
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)
590 u64 type = evsel->attr.sample_type;
595 * PERF_SAMPLE_TIME - not needed as we have it in
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
604 if (type & PERF_SAMPLE_IP) {
605 ret = value_set_u64_hex(cw, event, "perf_ip", sample->ip);
610 if (type & PERF_SAMPLE_TID) {
611 ret = value_set_s32(cw, event, "perf_tid", sample->tid);
615 ret = value_set_s32(cw, event, "perf_pid", sample->pid);
620 if ((type & PERF_SAMPLE_ID) ||
621 (type & PERF_SAMPLE_IDENTIFIER)) {
622 ret = value_set_u64(cw, event, "perf_id", sample->id);
627 if (type & PERF_SAMPLE_STREAM_ID) {
628 ret = value_set_u64(cw, event, "perf_stream_id", sample->stream_id);
633 if (type & PERF_SAMPLE_PERIOD) {
634 ret = value_set_u64(cw, event, "perf_period", sample->period);
639 if (type & PERF_SAMPLE_WEIGHT) {
640 ret = value_set_u64(cw, event, "perf_weight", sample->weight);
645 if (type & PERF_SAMPLE_DATA_SRC) {
646 ret = value_set_u64(cw, event, "perf_data_src",
652 if (type & PERF_SAMPLE_TRANSACTION) {
653 ret = value_set_u64(cw, event, "perf_transaction",
654 sample->transaction);
662 static int ctf_stream__flush(struct ctf_stream *cs)
667 err = bt_ctf_stream_flush(cs->stream);
669 pr_err("CTF stream %d flush failed\n", cs->cpu);
671 pr("Flush stream for cpu %d (%u samples)\n",
680 static struct ctf_stream *ctf_stream__create(struct ctf_writer *cw, int cpu)
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;
688 cs = zalloc(sizeof(*cs));
690 pr_err("Failed to allocate ctf stream\n");
694 stream = bt_ctf_writer_create_stream(cw->writer, cw->stream_class);
696 pr_err("Failed to create CTF stream\n");
700 pkt_ctx = bt_ctf_stream_get_packet_context(stream);
702 pr_err("Failed to obtain packet context\n");
706 cpu_field = bt_ctf_field_structure_get_field(pkt_ctx, "cpu_id");
707 bt_ctf_field_put(pkt_ctx);
709 pr_err("Failed to obtain cpu field\n");
713 ret = bt_ctf_field_unsigned_integer_set_value(cpu_field, (u32) cpu);
715 pr_err("Failed to update CPU number\n");
719 bt_ctf_field_put(cpu_field);
727 bt_ctf_field_put(cpu_field);
729 bt_ctf_stream_put(stream);
735 static void ctf_stream__delete(struct ctf_stream *cs)
738 bt_ctf_stream_put(cs->stream);
743 static struct ctf_stream *ctf_stream(struct ctf_writer *cw, int cpu)
745 struct ctf_stream *cs = cw->stream[cpu];
748 cs = ctf_stream__create(cw, cpu);
749 cw->stream[cpu] = cs;
755 static int get_sample_cpu(struct ctf_writer *cw, struct perf_sample *sample,
756 struct perf_evsel *evsel)
760 if (evsel->attr.sample_type & PERF_SAMPLE_CPU)
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);
772 #define STREAM_FLUSH_COUNT 100000
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
780 static bool is_flush_needed(struct ctf_stream *cs)
782 return cs->count >= STREAM_FLUSH_COUNT;
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)
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;
798 unsigned long type = evsel->attr.sample_type;
800 if (WARN_ONCE(!priv, "Failed to setup all events.\n"))
803 event_class = priv->event_class;
807 c->events_size += _event->header.size;
809 pr_time2(sample->time, "sample %" PRIu64 "\n", c->events_count);
811 event = bt_ctf_event_create(event_class);
813 pr_err("Failed to create an CTF event\n");
817 bt_ctf_clock_set_time(cw->clock, sample->time);
819 ret = add_generic_values(cw, event, evsel, sample);
823 if (evsel->attr.type == PERF_TYPE_TRACEPOINT) {
824 ret = add_tracepoint_values(cw, event_class, event,
830 if (type & PERF_SAMPLE_CALLCHAIN) {
831 ret = add_callchain_output_values(event_class,
832 event, sample->callchain);
837 if (perf_evsel__is_bpf_output(evsel)) {
838 ret = add_bpf_output_values(event_class, event, sample);
843 cs = ctf_stream(cw, get_sample_cpu(cw, sample, evsel));
845 if (is_flush_needed(cs))
846 ctf_stream__flush(cs);
849 bt_ctf_stream_append_event(cs->stream, event);
852 bt_ctf_event_put(event);
856 #define __NON_SAMPLE_SET_FIELD(_name, _type, _field) \
858 ret = value_set_##_type(cw, event, #_field, _event->_name._field);\
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) \
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; \
876 c->non_sample_count++; \
877 c->events_size += _event->header.size; \
878 event = bt_ctf_event_create(event_class); \
880 pr_err("Failed to create an CTF event\n"); \
884 bt_ctf_clock_set_time(cw->clock, sample->time); \
886 cs = ctf_stream(cw, 0); \
888 if (is_flush_needed(cs)) \
889 ctf_stream__flush(cs); \
892 bt_ctf_stream_append_event(cs->stream, event); \
894 bt_ctf_event_put(event); \
896 return perf_event__process_##_name(tool, _event, sample, machine);\
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);
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);
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);
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);
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);
931 #undef __NON_SAMPLE_SET_FIELD
932 #undef __FUNC_PROCESS_NON_SAMPLE
934 /* If dup < 0, add a prefix. Else, add _dupl_X suffix. */
935 static char *change_name(char *name, char *orig_name, int dup)
937 char *new_name = NULL;
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 '$'.
951 len = strlen(name) + sizeof("_");
953 len = strlen(orig_name) + sizeof("_dupl_X");
955 new_name = malloc(len);
960 snprintf(new_name, len, "_%s", name);
962 snprintf(new_name, len, "%s_dupl_%d", orig_name, dup);
965 if (name != orig_name)
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)
974 struct bt_ctf_field_type *t = NULL;
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);
986 /* If 'name' is a keywork, add prefix. */
987 if (bt_ctf_validate_identifier(name))
988 name = change_name(name, field->name, -1);
991 pr_err("Failed to fix invalid identifier.");
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++);
998 pr_err("Failed to create dup name for '%s'\n", field->name);
1003 ret = bt_ctf_event_class_add_field(event_class, type, name);
1005 field->alias = name;
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)
1014 struct tep_format_field *field;
1017 for (field = fields; field; field = field->next) {
1018 struct bt_ctf_field_type *type;
1019 unsigned long flags = field->flags;
1021 pr2(" field '%s'\n", field->name);
1023 type = get_tracepoint_field_type(cw, field);
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.
1032 if (flags & TEP_FIELD_IS_STRING)
1033 flags &= ~TEP_FIELD_IS_ARRAY;
1035 if (flags & TEP_FIELD_IS_ARRAY)
1036 type = bt_ctf_field_type_array_create(type, field->arraylen);
1038 ret = event_class_add_field(event_class, type, field);
1040 if (flags & TEP_FIELD_IS_ARRAY)
1041 bt_ctf_field_type_put(type);
1044 pr_err("Failed to add field '%s': %d\n",
1053 static int add_tracepoint_types(struct ctf_writer *cw,
1054 struct perf_evsel *evsel,
1055 struct bt_ctf_event_class *class)
1057 struct tep_format_field *common_fields = evsel->tp_format->format.common_fields;
1058 struct tep_format_field *fields = evsel->tp_format->format.fields;
1061 ret = add_tracepoint_fields_types(cw, common_fields, class);
1063 ret = add_tracepoint_fields_types(cw, fields, class);
1068 static int add_bpf_output_types(struct ctf_writer *cw,
1069 struct bt_ctf_event_class *class)
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;
1076 ret = bt_ctf_event_class_add_field(class, len_type, "raw_len");
1080 seq_type = bt_ctf_field_type_sequence_create(seq_base_type, "raw_len");
1084 return bt_ctf_event_class_add_field(class, seq_type, "raw_data");
1087 static int add_generic_types(struct ctf_writer *cw, struct perf_evsel *evsel,
1088 struct bt_ctf_event_class *event_class)
1090 u64 type = evsel->attr.sample_type;
1094 * PERF_SAMPLE_TIME - not needed as we have it in
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
1105 #define ADD_FIELD(cl, t, n) \
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); \
1114 if (type & PERF_SAMPLE_IP)
1115 ADD_FIELD(event_class, cw->data.u64_hex, "perf_ip");
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");
1122 if ((type & PERF_SAMPLE_ID) ||
1123 (type & PERF_SAMPLE_IDENTIFIER))
1124 ADD_FIELD(event_class, cw->data.u64, "perf_id");
1126 if (type & PERF_SAMPLE_STREAM_ID)
1127 ADD_FIELD(event_class, cw->data.u64, "perf_stream_id");
1129 if (type & PERF_SAMPLE_PERIOD)
1130 ADD_FIELD(event_class, cw->data.u64, "perf_period");
1132 if (type & PERF_SAMPLE_WEIGHT)
1133 ADD_FIELD(event_class, cw->data.u64, "perf_weight");
1135 if (type & PERF_SAMPLE_DATA_SRC)
1136 ADD_FIELD(event_class, cw->data.u64, "perf_data_src");
1138 if (type & PERF_SAMPLE_TRANSACTION)
1139 ADD_FIELD(event_class, cw->data.u64, "perf_transaction");
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"),
1153 static int add_event(struct ctf_writer *cw, struct perf_evsel *evsel)
1155 struct bt_ctf_event_class *event_class;
1156 struct evsel_priv *priv;
1157 const char *name = perf_evsel__name(evsel);
1160 pr("Adding event '%s' (type %d)\n", name, evsel->attr.type);
1162 event_class = bt_ctf_event_class_create(name);
1166 ret = add_generic_types(cw, evsel, event_class);
1170 if (evsel->attr.type == PERF_TYPE_TRACEPOINT) {
1171 ret = add_tracepoint_types(cw, evsel, event_class);
1176 if (perf_evsel__is_bpf_output(evsel)) {
1177 ret = add_bpf_output_types(cw, event_class);
1182 ret = bt_ctf_stream_class_add_event_class(cw->stream_class, event_class);
1184 pr("Failed to add event class into stream.\n");
1188 priv = malloc(sizeof(*priv));
1192 priv->event_class = event_class;
1197 bt_ctf_event_class_put(event_class);
1198 pr_err("Failed to add event '%s'.\n", name);
1202 static int setup_events(struct ctf_writer *cw, struct perf_session *session)
1204 struct perf_evlist *evlist = session->evlist;
1205 struct perf_evsel *evsel;
1208 evlist__for_each_entry(evlist, evsel) {
1209 ret = add_event(cw, evsel);
1216 #define __NON_SAMPLE_ADD_FIELD(t, n) \
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);\
1225 #define __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(_name, body) \
1226 static int add_##_name##_event(struct ctf_writer *cw) \
1228 struct bt_ctf_event_class *event_class; \
1231 pr("Adding "#_name" event\n"); \
1232 event_class = bt_ctf_event_class_create("perf_" #_name);\
1237 ret = bt_ctf_stream_class_add_event_class(cw->stream_class, event_class);\
1239 pr("Failed to add event class '"#_name"' into stream.\n");\
1243 cw->_name##_class = event_class; \
1244 bt_ctf_event_class_put(event_class); \
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);
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);
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);
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);
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);
1283 #undef __NON_SAMPLE_ADD_FIELD
1284 #undef __FUNC_ADD_NON_SAMPLE_EVENT_CLASS
1286 static int setup_non_sample_events(struct ctf_writer *cw,
1287 struct perf_session *session __maybe_unused)
1291 ret = add_comm_event(cw);
1294 ret = add_exit_event(cw);
1297 ret = add_fork_event(cw);
1300 ret = add_mmap_event(cw);
1303 ret = add_mmap2_event(cw);
1309 static void cleanup_events(struct perf_session *session)
1311 struct perf_evlist *evlist = session->evlist;
1312 struct perf_evsel *evsel;
1314 evlist__for_each_entry(evlist, evsel) {
1315 struct evsel_priv *priv;
1318 bt_ctf_event_class_put(priv->event_class);
1319 zfree(&evsel->priv);
1322 perf_evlist__delete(evlist);
1323 session->evlist = NULL;
1326 static int setup_streams(struct ctf_writer *cw, struct perf_session *session)
1328 struct ctf_stream **stream;
1329 struct perf_header *ph = &session->header;
1333 * Try to get the number of cpus used in the data file,
1334 * if not present fallback to the MAX_CPUS.
1336 ncpus = ph->env.nr_cpus_avail ?: MAX_CPUS;
1338 stream = zalloc(sizeof(*stream) * ncpus);
1340 pr_err("Failed to allocate streams.\n");
1344 cw->stream = stream;
1345 cw->stream_cnt = ncpus;
1349 static void free_streams(struct ctf_writer *cw)
1353 for (cpu = 0; cpu < cw->stream_cnt; cpu++)
1354 ctf_stream__delete(cw->stream[cpu]);
1359 static int ctf_writer__setup_env(struct ctf_writer *cw,
1360 struct perf_session *session)
1362 struct perf_header *header = &session->header;
1363 struct bt_ctf_writer *writer = cw->writer;
1365 #define ADD(__n, __v) \
1367 if (bt_ctf_writer_add_environment_field(writer, __n, __v)) \
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");
1383 static int ctf_writer__setup_clock(struct ctf_writer *cw)
1385 struct bt_ctf_clock *clock = cw->clock;
1387 bt_ctf_clock_set_description(clock, "perf clock");
1389 #define SET(__n, __v) \
1391 if (bt_ctf_clock_set_##__n(clock, __v)) \
1395 SET(frequency, 1000000000);
1399 SET(is_absolute, 0);
1405 static struct bt_ctf_field_type *create_int_type(int size, bool sign, bool hex)
1407 struct bt_ctf_field_type *type;
1409 type = bt_ctf_field_type_integer_create(size);
1414 bt_ctf_field_type_integer_set_signed(type, 1))
1418 bt_ctf_field_type_integer_set_base(type, BT_CTF_INTEGER_BASE_HEXADECIMAL))
1421 #if __BYTE_ORDER == __BIG_ENDIAN
1422 bt_ctf_field_type_set_byte_order(type, BT_CTF_BYTE_ORDER_BIG_ENDIAN);
1424 bt_ctf_field_type_set_byte_order(type, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
1427 pr2("Created type: INTEGER %d-bit %ssigned %s\n",
1428 size, sign ? "un" : "", hex ? "hex" : "");
1432 bt_ctf_field_type_put(type);
1436 static void ctf_writer__cleanup_data(struct ctf_writer *cw)
1440 for (i = 0; i < ARRAY_SIZE(cw->data.array); i++)
1441 bt_ctf_field_type_put(cw->data.array[i]);
1444 static int ctf_writer__init_data(struct ctf_writer *cw)
1446 #define CREATE_INT_TYPE(type, size, sign, hex) \
1448 (type) = create_int_type(size, sign, hex); \
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);
1460 cw->data.string = bt_ctf_field_type_string_create();
1461 if (cw->data.string)
1465 ctf_writer__cleanup_data(cw);
1466 pr_err("Failed to create data types.\n");
1470 static void ctf_writer__cleanup(struct ctf_writer *cw)
1472 ctf_writer__cleanup_data(cw);
1474 bt_ctf_clock_put(cw->clock);
1476 bt_ctf_stream_class_put(cw->stream_class);
1477 bt_ctf_writer_put(cw->writer);
1479 /* and NULL all the pointers */
1480 memset(cw, 0, sizeof(*cw));
1483 static int ctf_writer__init(struct ctf_writer *cw, const char *path)
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;
1492 writer = bt_ctf_writer_create(path);
1496 cw->writer = writer;
1499 clock = bt_ctf_clock_create("perf_clock");
1501 pr("Failed to create CTF clock.\n");
1507 if (ctf_writer__setup_clock(cw)) {
1508 pr("Failed to setup CTF clock.\n");
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");
1519 cw->stream_class = stream_class;
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");
1527 if (ctf_writer__init_data(cw))
1530 /* Add cpu_id for packet context */
1531 pkt_ctx_type = bt_ctf_stream_class_get_packet_context_type(stream_class);
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);
1540 /* CTF clock writer setup */
1541 if (bt_ctf_writer_add_clock(writer, clock)) {
1542 pr("Failed to assign CTF clock to writer.\n");
1549 ctf_writer__cleanup(cw);
1551 pr_err("Failed to setup CTF writer.\n");
1555 static int ctf_writer__flush_streams(struct ctf_writer *cw)
1559 for (cpu = 0; cpu < cw->stream_cnt && !ret; cpu++)
1560 ret = ctf_stream__flush(cw->stream[cpu]);
1565 static int convert__config(const char *var, const char *value, void *cb)
1567 struct convert *c = cb;
1569 if (!strcmp(var, "convert.queue-size"))
1570 return perf_config_u64(&c->queue_size, var, value);
1575 int bt_convert__perf2ctf(const char *input, const char *path,
1576 struct perf_data_convert_opts *opts)
1578 struct perf_session *session;
1579 struct perf_data data = {
1581 .mode = PERF_DATA_MODE_READ,
1582 .force = opts->force,
1584 struct convert c = {
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,
1600 struct ctf_writer *cw = &c.writer;
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;
1611 err = perf_config(convert__config, &c);
1616 if (ctf_writer__init(cw, path))
1620 /* perf.data session */
1621 session = perf_session__new(&data, 0, &c.tool);
1626 ordered_events__set_alloc_size(&session->ordered_events,
1630 /* CTF writer env/clock setup */
1631 if (ctf_writer__setup_env(cw, session))
1634 /* CTF events setup */
1635 if (setup_events(cw, session))
1638 if (opts->all && setup_non_sample_events(cw, session))
1641 if (setup_streams(cw, session))
1644 err = perf_session__process_events(session);
1646 err = ctf_writer__flush_streams(cw);
1648 pr_err("Error during conversion.\n");
1651 "[ perf data convert: Converted '%s' into CTF data '%s' ]\n",
1655 "[ perf data convert: Converted and wrote %.3f MB (%" PRIu64 " samples",
1656 (double) c.events_size / 1024.0 / 1024.0,
1659 if (!c.non_sample_count)
1660 fprintf(stderr, ") ]\n");
1662 fprintf(stderr, ", %" PRIu64 " non-samples) ]\n", c.non_sample_count);
1664 cleanup_events(session);
1665 perf_session__delete(session);
1666 ctf_writer__cleanup(cw);
1671 perf_session__delete(session);
1673 ctf_writer__cleanup(cw);
1674 pr_err("Error during conversion setup.\n");