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