/*

 * perf_util.c - helper functions for perf_events

 *

 * Copyright (c) 2009 Google, Inc

 * Contributed by Stephane Eranian <eranian@gmail.com>

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

 * of the Software, and to permit persons to whom the Software is furnished to do so,

 * subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in all

 * copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,

 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A

 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE

 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

#include <sys/types.h>

#include <inttypes.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <err.h>

#include <perfmon/pfmlib_perf_event.h>

#include "perf_util.h"

/* the **fd parameter must point to a null pointer on the first call

 * max_fds and num_fds must both point to a zero value on the first call

 * The return value is success (0) vs. failure (non-zero)

 */

int

perf_setup_argv_events(const char **argv, perf_event_desc_t **fds, int *num_fds)

{

	perf_event_desc_t *fd;

	pfm_perf_encode_arg_t arg;

	int new_max, ret, num, max_fds;

	int group_leader;

	if (!(argv && fds && num_fds))

		return -1;

	fd = *fds;

	if (fd) {

		max_fds = fd[0].max_fds;

		if (max_fds < 2)

			return -1;

		num = *num_fds;

	} else {

		max_fds = num = 0; /* bootstrap */

	}

	group_leader = num;

	while(*argv) {

		if (num == max_fds) {

			if (max_fds == 0)

				new_max = 2;

			else

				new_max = max_fds << 1;

			if (new_max < max_fds) {

				warn("too many entries");

				goto error;

			}

			fd = realloc(fd, new_max * sizeof(*fd));

			if (!fd) {

				warn("cannot allocate memory");

				goto error;

			}

			/* reset newly allocated chunk */

			memset(fd + max_fds, 0, (new_max - max_fds) * sizeof(*fd));

			max_fds = new_max;

			/* update max size */

			fd[0].max_fds = max_fds;

		}

		/* ABI compatibility, set before calling libpfm */

		fd[num].hw.size = sizeof(fd[num].hw);

		memset(&arg, 0, sizeof(arg));

		arg.attr = &fd[num].hw;

		arg.fstr = &fd[num].fstr; /* fd[].fstr is NULL */

		ret = pfm_get_os_event_encoding(*argv, PFM_PLM0|PFM_PLM3, PFM_OS_PERF_EVENT_EXT, &arg;;

		if (ret != PFM_SUCCESS) {

			warnx("event %s: %s", *argv, pfm_strerror(ret));

			goto error;

		}

		fd[num].name = strdup(*argv);

		fd[num].group_leader = group_leader;

		fd[num].idx = arg.idx;

		fd[num].cpu = arg.cpu;

		num++;

		argv++;

	}

	*num_fds = num;

	*fds = fd;

	return 0;

error:

	perf_free_fds(fd, num);

	return -1;

}

int

perf_setup_list_events(const char *ev, perf_event_desc_t **fd, int *num_fds)

{

	const char **argv;

	char *p, *q, *events;

	int i, ret, num = 0;

	if (!(ev && fd && num_fds))

		return -1;

	events = strdup(ev);

	if (!events)

		return -1;

	q = events;

	while((p = strchr(q, ','))) {

		num++;

		q = p + 1;

	}

	num++;

	num++; /* terminator */

	argv = malloc(num * sizeof(char *));

	if (!argv) {

		free(events);

		return -1;

	}

	i = 0; q = events;

	while((p = strchr(q, ','))) {

		*p = '\0';

		argv[i++] = q;

		q = p + 1;

	}

	argv[i++] = q;

	argv[i] = NULL;

	ret = perf_setup_argv_events(argv, fd, num_fds);

	free(argv);

	free(events); /* strdup in perf_setup_argv_events() */

	return ret;

}

void

perf_free_fds(perf_event_desc_t *fds, int num_fds)

{

	int i;

	for (i = 0 ; i < num_fds; i++) {

		free(fds[i].name);

		free(fds[i].fstr);

	}

	free(fds);

}

int

perf_get_group_nevents(perf_event_desc_t *fds, int num, int idx)

{

	int leader;

	int i;

	if (idx < 0 || idx >= num)

		return 0;

	leader = fds[idx].group_leader;

	for (i = leader + 1; i < num; i++) {

		if (fds[i].group_leader != leader) {

			/* This is a new group leader, so the previous

			 * event was the final event of the preceding

			 * group.

			 */

			return i - leader;

		}

	}

	return i - leader;

}

int

perf_read_buffer(perf_event_desc_t *hw, void *buf, size_t sz)

{

	struct perf_event_mmap_page *hdr = hw->buf;

	size_t pgmsk = hw->pgmsk;

	void *data;

	unsigned long tail;

	size_t avail_sz, m, c;

	/*

	 * data points to beginning of buffer payload

	 */

	data = ((void *)hdr)+sysconf(_SC_PAGESIZE);

	/*

	 * position of tail within the buffer payload

	 */

	tail = hdr->data_tail & pgmsk;

	/*

	 * size of what is available

	 *

	 * data_head, data_tail never wrap around

	 */

	avail_sz = hdr->data_head - hdr->data_tail;

	if (sz > avail_sz)

		return -1;

	/*

	 * sz <= avail_sz, we can satisfy the request

	 */

	/*

	 * c = size till end of buffer

	 *

	 * buffer payload size is necessarily

	 * a power of two, so we can do:

	 */

	c = pgmsk + 1 -  tail;

	/*

	 * min with requested size

	 */

	m = c < sz ? c : sz;

	/* copy beginning */

	memcpy(buf, data+tail, m);

	/*

	 * copy wrapped around leftover

	 */

	if (sz > m)

		memcpy(buf+m, data, sz - m);

	//printf("\nhead=%lx tail=%lx new_tail=%lx sz=%zu\n", hdr->data_head, hdr->data_tail, hdr->data_tail+sz, sz);

	hdr->data_tail += sz;

	return 0;

}

void

perf_skip_buffer(perf_event_desc_t *hw, size_t sz)

{

	struct perf_event_mmap_page *hdr = hw->buf;

	if ((hdr->data_tail + sz) > hdr->data_head)

		sz = hdr->data_head - hdr->data_tail;

	hdr->data_tail += sz;

}

static size_t

__perf_handle_raw(perf_event_desc_t *hw)

{

	size_t sz = 0;

	uint32_t raw_sz, i;

	char *buf;

	int ret;

	ret = perf_read_buffer_32(hw, &raw_sz);

	if (ret) {

		warnx("cannot read raw size");

		return -1;

	}

	sz += sizeof(raw_sz);

	printf("\n\tRAWSZ:%u\n", raw_sz);

	buf = malloc(raw_sz);

	if (!buf) {

		warn("cannot allocate raw buffer");

		return -1;

	}

	ret = perf_read_buffer(hw, buf, raw_sz);

	if (ret) {

		warnx("cannot read raw data");

		free(buf);

		return -1;

	}

	if (raw_sz)

		putchar('\t');

	for(i=0; i < raw_sz; i++) {

		printf("0x%02x ", buf[i] & 0xff );

		if (((i+1) % 16)  == 0)

			printf("\n\t");

	}

	if (raw_sz)

		putchar('\n');

	free(buf);

	return sz + raw_sz;

}

static int

perf_display_branch_stack(perf_event_desc_t *desc, FILE *fp)

{

	struct perf_branch_entry b;

	uint64_t nr, n;

	int ret;

	ret = perf_read_buffer(desc, &n, sizeof(n));

	if (ret)

		errx(1, "cannot read branch stack nr");

	fprintf(fp, "\n\tBRANCH_STACK:%"PRIu64"\n", n);

	nr = n;

	/*

	 * from most recent to least recent take branch

	 */

	while (nr--) {

		ret = perf_read_buffer(desc, &b, sizeof(b));

		if (ret)

			errx(1, "cannot read branch stack entry");

		fprintf(fp, "\tFROM:0x%016"PRIx64" TO:0x%016"PRIx64" MISPRED:%c PRED:%c IN_TX:%c ABORT:%c CYCLES:%d type:%d\n",

			b.from,

			b.to,

			!(b.mispred || b.predicted) ? '-': (b.mispred ? 'Y' :'N'),

			!(b.mispred || b.predicted) ? '-': (b.predicted? 'Y' :'N'),

			(b.in_tx? 'Y' :'N'),

			(b.abort? 'Y' :'N'),

			b.type,

			b.cycles);

	}

	return (int)(n * sizeof(b) + sizeof(n));

}

static int

perf_display_regs_user(perf_event_desc_t *hw, FILE *fp)

{

	errx(1, "display regs_user not implemented yet\n");

	return 0;

}

static int

perf_display_regs_intr(perf_event_desc_t *hw, FILE *fp)

{

	errx(1, "display regs_intr not implemented yet\n");

	return 0;

}

static int

perf_display_stack_user(perf_event_desc_t *hw, FILE *fp)

{

	uint64_t nr;

	char buf[512];

	size_t sz;

	int ret;

	ret = perf_read_buffer(hw, &nr, sizeof(nr));

	if (ret)

		errx(1, "cannot user stack size");

	fprintf(fp, "USER_STACK: SZ:%"PRIu64"\n", nr);

	/* consume content */

	while (nr) {

		sz = nr;

		if (sz > sizeof(buf))

			sz = sizeof(buf);

		ret = perf_read_buffer(hw, buf, sz);

		if (ret)

			errx(1, "cannot user stack content");

		nr -= sz;

	}

	return 0;

}

int

perf_display_sample(perf_event_desc_t *fds, int num_fds, int idx, struct perf_event_header *ehdr, FILE *fp)

{

	perf_event_desc_t *hw;

	struct { uint32_t pid, tid; } pid;

	struct { uint64_t value, id; } grp;

	uint64_t time_enabled, time_running;

	size_t sz;

	uint64_t type, fmt;

	uint64_t val64;

	const char *str;

	int ret, e;

	if (!fds || !fp || !ehdr  || num_fds < 0 || idx < 0 ||  idx >= num_fds)

		return -1;

	sz = ehdr->size - sizeof(*ehdr);

	hw = fds+idx;

	type = hw->hw.sample_type;

	fmt  = hw->hw.read_format;

	if (type & PERF_SAMPLE_IDENTIFIER) {

		ret = perf_read_buffer_64(hw, &val64);

		if (ret) {

			warnx("cannot read IP");

			return -1;

		}

		fprintf(fp, "ID:%"PRIu64" ", val64);

		sz -= sizeof(val64);

	}

	/*

	 * the sample_type information is laid down

	 * based on the PERF_RECORD_SAMPLE format specified

	 * in the perf_event.h header file.

	 * That order is different from the enum perf_event_sample_format

	 */

	if (type & PERF_SAMPLE_IP) {

		const char *xtra = " ";

		ret = perf_read_buffer_64(hw, &val64);

		if (ret) {

			warnx("cannot read IP");

			return -1;

		}

		/*

		 * MISC_EXACT_IP indicates that kernel is returning

		 * th  IIP of an instruction which caused the event, i.e.,

		 * no skid

		 */

		if (hw->hw.precise_ip && (ehdr->misc & PERF_RECORD_MISC_EXACT_IP))

			xtra = " (exact) ";

		fprintf(fp, "IIP:%#016"PRIx64"%s", val64, xtra);

		sz -= sizeof(val64);

	}

	if (type & PERF_SAMPLE_TID) {

		ret = perf_read_buffer(hw, &pid, sizeof(pid));

		if (ret) {

			warnx( "cannot read PID");

			return -1;

		}

		fprintf(fp, "PID:%d TID:%d ", pid.pid, pid.tid);

		sz -= sizeof(pid);

	}

	if (type & PERF_SAMPLE_TIME) {

		ret = perf_read_buffer_64(hw, &val64);

		if (ret) {

			warnx( "cannot read time");

			return -1;

		}

		fprintf(fp, "TIME:%'"PRIu64" ", val64);

		sz -= sizeof(val64);

	}

	if (type & PERF_SAMPLE_ADDR) {

		ret = perf_read_buffer_64(hw, &val64);

		if (ret) {

			warnx( "cannot read addr");

			return -1;

		}

		fprintf(fp, "ADDR:%#016"PRIx64" ", val64);

		sz -= sizeof(val64);

	}

	if (type & PERF_SAMPLE_ID) {

		ret = perf_read_buffer_64(hw, &val64);

		if (ret) {

			warnx( "cannot read id");

			return -1;

		}

		fprintf(fp, "ID:%"PRIu64" ", val64);

		sz -= sizeof(val64);

	}

	if (type & PERF_SAMPLE_STREAM_ID) {

		ret = perf_read_buffer_64(hw, &val64);

		if (ret) {

			warnx( "cannot read stream_id");

			return -1;

		}

		fprintf(fp, "STREAM_ID:%"PRIu64" ", val64);

		sz -= sizeof(val64);

	}

	if (type & PERF_SAMPLE_CPU) {

		struct { uint32_t cpu, reserved; } cpu;

		ret = perf_read_buffer(hw, &cpu, sizeof(cpu));

		if (ret) {

			warnx( "cannot read cpu");

			return -1;

		}

		fprintf(fp, "CPU:%u ", cpu.cpu);

		sz -= sizeof(cpu);

	}

	if (type & PERF_SAMPLE_PERIOD) {

		ret = perf_read_buffer_64(hw, &val64);

		if (ret) {

			warnx( "cannot read period");

			return -1;

		}

		fprintf(fp, "PERIOD:%'"PRIu64" ", val64);

		sz -= sizeof(val64);

	}

	/* struct read_format {

	 * 	{ u64		value;

	 * 	  { u64		time_enabled; } && PERF_FORMAT_ENABLED

	 * 	  { u64		time_running; } && PERF_FORMAT_RUNNING

	 * 	  { u64		id;           } && PERF_FORMAT_ID

	 * 	} && !PERF_FORMAT_GROUP

	 *

	 * 	{ u64		nr;

	 * 	  { u64		time_enabled; } && PERF_FORMAT_ENABLED

	 * 	  { u64		time_running; } && PERF_FORMAT_RUNNING

	 * 	  { u64		value;

	 * 	    { u64	id;           } && PERF_FORMAT_ID

	 * 	  }		cntr[nr];

	 * 	} && PERF_FORMAT_GROUP

	 * };

	 */

	if (type & PERF_SAMPLE_READ) {

		uint64_t values[3];

		uint64_t nr;

		if (fmt & PERF_FORMAT_GROUP) {

			ret = perf_read_buffer_64(hw, &nr);

			if (ret) {

				warnx( "cannot read nr");

				return -1;

			}

			sz -= sizeof(nr);

			time_enabled = time_running = 1;

			if (fmt & PERF_FORMAT_TOTAL_TIME_ENABLED) {

				ret = perf_read_buffer_64(hw, &time_enabled);

				if (ret) {

					warnx( "cannot read timing info");

					return -1;

				}

				sz -= sizeof(time_enabled);

			}

			if (fmt & PERF_FORMAT_TOTAL_TIME_RUNNING) {

				ret = perf_read_buffer_64(hw, &time_running);

				if (ret) {

					warnx( "cannot read timing info");

					return -1;

				}

				sz -= sizeof(time_running);

			}

			fprintf(fp, "ENA=%'"PRIu64" RUN=%'"PRIu64" NR=%"PRIu64"\n", time_enabled, time_running, nr);

			values[1] = time_enabled;

			values[2] = time_running;

			while(nr--) {

				grp.id = -1;

				ret = perf_read_buffer_64(hw, &grp.value);

				if (ret) {

					warnx( "cannot read group value");

					return -1;

				}

				sz -= sizeof(grp.value);

				if (fmt & PERF_FORMAT_ID) {

					ret = perf_read_buffer_64(hw, &grp.id);

					if (ret) {

						warnx( "cannot read leader id");

						return -1;

					}

					sz -= sizeof(grp.id);

				}

				e = perf_id2event(fds, num_fds, grp.id);

				if (e == -1)

					str = "unknown sample event";

				else

					str = fds[e].name;

				values[0] = grp.value;

				grp.value = perf_scale(values);

				fprintf(fp, "\t%'"PRIu64" %s (%"PRIu64"%s)\n",

					grp.value, str,

					grp.id,

					time_running != time_enabled ? ", scaled":"");

			}

		} else {

			time_enabled = time_running = 0;

			/*

			 * this program does not use FORMAT_GROUP when there is only one event

			 */

			ret = perf_read_buffer_64(hw, &val64);

			if (ret) {

				warnx( "cannot read value");

				return -1;

			}

			sz -= sizeof(val64);

			if (fmt & PERF_FORMAT_TOTAL_TIME_ENABLED) {

				ret = perf_read_buffer_64(hw, &time_enabled);

				if (ret) {

					warnx( "cannot read timing info");

					return -1;

				}

				sz -= sizeof(time_enabled);

			}

			if (fmt & PERF_FORMAT_TOTAL_TIME_RUNNING) {

				ret = perf_read_buffer_64(hw, &time_running);

				if (ret) {

					warnx( "cannot read timing info");

					return -1;

				}

				sz -= sizeof(time_running);

			}

			if (fmt & PERF_FORMAT_ID) {

				ret = perf_read_buffer_64(hw, &val64);

				if (ret) {

					warnx( "cannot read leader id");

					return -1;

				}

				sz -= sizeof(val64);

			}

			fprintf(fp, "ENA=%'"PRIu64" RUN=%'"PRIu64"\n", time_enabled, time_running);

			values[0] = val64;

			values[1] = time_enabled;

			values[2] = time_running;

			val64 = perf_scale(values);

			fprintf(fp, "\t%'"PRIu64" %s %s\n",

				val64, fds[0].name,

				time_running != time_enabled ? ", scaled":"");

		}

	}

	if (type & PERF_SAMPLE_CALLCHAIN) {

		uint64_t nr, ip;

		ret = perf_read_buffer_64(hw, &nr);

		if (ret) {

			warnx( "cannot read callchain nr");

			return -1;

		}

		sz -= sizeof(nr);

		while(nr--) {

			ret = perf_read_buffer_64(hw, &ip);

			if (ret) {

				warnx( "cannot read ip");

				return -1;

			}

			sz -= sizeof(ip);

			fprintf(fp, "\t0x%"PRIx64"\n", ip);

		}

	}

	if (type & PERF_SAMPLE_RAW) {

		ret = __perf_handle_raw(hw);

		if (ret == -1)

			return -1;

		sz -= ret;

	}

	if (type & PERF_SAMPLE_BRANCH_STACK) {

		ret = perf_display_branch_stack(hw, fp);

		sz -= ret;

	}

	if (type & PERF_SAMPLE_REGS_USER) {

		ret = perf_display_regs_user(hw, fp);

		sz -= ret;

	}

	if (type & PERF_SAMPLE_STACK_USER) {

		ret = perf_display_stack_user(hw, fp);

		sz -= ret;

	}

	if (type & PERF_SAMPLE_WEIGHT) {

		ret = perf_read_buffer_64(hw, &val64);

		if (ret) {

			warnx( "cannot read weight");

			return -1;

		}

		fprintf(fp, "WEIGHT:%'"PRIu64" ", val64);

		sz -= sizeof(val64);

	}

	if (type & PERF_SAMPLE_DATA_SRC) {

		ret = perf_read_buffer_64(hw, &val64);

		if (ret) {

			warnx( "cannot read data src");

			return -1;

		}

		fprintf(fp, "DATA_SRC:%'"PRIu64" ", val64);

		sz -= sizeof(val64);

	}

	if (type & PERF_SAMPLE_TRANSACTION) {

		ret = perf_read_buffer_64(hw, &val64);

		if (ret) {

			warnx( "cannot read txn");

			return -1;

		}

		fprintf(fp, "TXN:%'"PRIu64" ", val64);

		sz -= sizeof(val64);

	}

	if (type & PERF_SAMPLE_REGS_INTR) {

		ret = perf_display_regs_intr(hw, fp);

		sz -= ret;

	}

	/*

	 * if we have some data left, it is because there is more

	 * than what we know about. In fact, it is more complicated

	 * because we may have the right size but wrong layout. But

	 * that's the best we can do.

	 */

	if (sz) {

		warnx("did not correctly parse sample leftover=%zu", sz);

		perf_skip_buffer(hw, sz);

	}

	fputc('\n',fp);

	return 0;

}

uint64_t

display_lost(perf_event_desc_t *hw, perf_event_desc_t *fds, int num_fds, FILE *fp)

{

	struct { uint64_t id, lost; } lost;

	const char *str;

	int e, ret;

	ret = perf_read_buffer(hw, &lost, sizeof(lost));

	if (ret) {

		warnx("cannot read lost info");

		return 0;

	}

	e = perf_id2event(fds, num_fds, lost.id);

	if (e == -1)

		str = "unknown lost event";

	else

		str = fds[e].name;

	fprintf(fp, "<<<LOST %"PRIu64" SAMPLES FOR EVENT %s>>>\n",

		lost.lost,

		str);

	return lost.lost;

}

void

display_exit(perf_event_desc_t *hw, FILE *fp)

{

	struct { pid_t pid, ppid, tid, ptid; } grp;

	int ret;

	ret = perf_read_buffer(hw, &grp, sizeof(grp));

	if (ret) {

		warnx("cannot read exit info");

		return;

	}

	fprintf(fp,"[%d] exited\n", grp.pid);

}

void

display_freq(int mode, perf_event_desc_t *hw, FILE *fp)

{

	struct { uint64_t time, id, stream_id; } thr;

	int ret;

	ret = perf_read_buffer(hw, &thr, sizeof(thr));

	if (ret) {

		warnx("cannot read throttling info");

		return;

	}

	fprintf(fp, "%s value=%"PRIu64" event ID=%"PRIu64"\n",

		mode ? "Throttled" : "Unthrottled",

		thr.id,

		thr.stream_id);

}