data-convert-bt.c

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