/*

 * task_inherit.c - example of a task counting event in a tree of child processes

 *

 * 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 <unistd.h>

#include <string.h>

#include <stdarg.h>

#include <signal.h>

#include <sys/wait.h>

#include <locale.h>

#include <err.h>

#include "perf_util.h"

#define MAX_GROUPS 256

typedef struct {

	const char *events[MAX_GROUPS];

	int num_groups;

	int format_group;

	int inherit;

	int print;

	int pin;

	pid_t pid;

} options_t;

static options_t options;

static volatile int quit;

int

child(char **arg)

{

	/*

	 * execute the requested command

	 */

	execvp(arg[0], arg);

	errx(1, "cannot exec: %s\n", arg[0]);

	/* not reached */

}

static void

read_groups(perf_event_desc_t *fds, int num)

{

	uint64_t *values = NULL;

	size_t new_sz, sz = 0;

	int i, evt;

	ssize_t ret;

	/*

	 * 	{ 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

	 *

	 * we do not use FORMAT_ID in this program

	 */

	for (evt = 0; evt < num; ) {

		int num_evts_to_read;

		if (options.format_group) {

			num_evts_to_read = perf_get_group_nevents(fds, num, evt);

			new_sz = sizeof(uint64_t) * (3 + num_evts_to_read);

		} else {

			num_evts_to_read = 1;

			new_sz = sizeof(uint64_t) * 3;

		}

		if (new_sz > sz) {

			sz = new_sz;

			values = realloc(values, sz);

		}

		if (!values)

			err(1, "cannot allocate memory for values\n");

		ret = read(fds[evt].fd, values, new_sz);

		if (ret != (ssize_t)new_sz) { /* unsigned */

			if (ret == -1)

				err(1, "cannot read values event %s", fds[evt].name);

			/* likely pinned and could not be loaded */

			warnx("could not read event %d, tried to read %zu bytes, but got %zd",

				evt, new_sz, ret);

		}

		/*

		 * propagate to save area

		 */

		for (i = evt; i < (evt + num_evts_to_read); i++) {

			if (options.format_group)

				values[0] = values[3 + (i - evt)];

			/*

			 * scaling because we may be sharing the PMU and

			 * thus may be multiplexed

			 */

			fds[i].values[0] = values[0];

			fds[i].values[1] = values[1];

			fds[i].values[2] = values[2];

		}

		evt += num_evts_to_read;

	}

	if (values)

		free(values);

}

static void

print_counts(perf_event_desc_t *fds, int num)

{

	double ratio;

	uint64_t val, delta;

	int i;

	read_groups(fds, num);

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

		val   = perf_scale(fds[i].values);

		delta = perf_scale_delta(fds[i].values, fds[i].prev_values);

		ratio = perf_scale_ratio(fds[i].values);

		/* separate groups */

		if (perf_is_group_leader(fds, i))

			putchar('\n');

		if (options.print)

			printf("%'20"PRIu64" %'20"PRIu64" %s (%.2f%% scaling, ena=%'"PRIu64", run=%'"PRIu64")\n",

				val,

				delta,

				fds[i].name,

				(1.0-ratio)*100.0,

				fds[i].values[1],

				fds[i].values[2]);

		else

			printf("%'20"PRIu64" %s (%.2f%% scaling, ena=%'"PRIu64", run=%'"PRIu64")\n",

				val,

				fds[i].name,

				(1.0-ratio)*100.0,

				fds[i].values[1],

				fds[i].values[2]);

		fds[i].prev_values[0] = fds[i].values[0];

		fds[i].prev_values[1] = fds[i].values[1];

		fds[i].prev_values[2] = fds[i].values[2];

	}

}

static void sig_handler(int n)

{

	quit = 1;

}

int

parent(char **arg)

{

	perf_event_desc_t *fds = NULL;

	int status, ret, i, num_fds = 0, grp, group_fd;

	int ready[2], go[2];

	char buf;

	pid_t pid;

	go[0] = go[1] = -1;

	if (pfm_initialize() != PFM_SUCCESS)

		errx(1, "libpfm initialization failed");

	for (grp = 0; grp < options.num_groups; grp++) {

		int ret;

		ret = perf_setup_list_events(options.events[grp], &fds, &num_fds);

		if (ret || !num_fds)

			exit(1);

	}

	pid = options.pid;

	if (!pid) {

		ret = pipe(ready);

		if (ret)

			err(1, "cannot create pipe ready");

		ret = pipe(go);

		if (ret)

			err(1, "cannot create pipe go");

		/*

		 * Create the child task

		 */

		if ((pid=fork()) == -1)

			err(1, "Cannot fork process");

		/*

		 * and launch the child code

		 *

		 * The pipe is used to avoid a race condition

		 * between for() and exec(). We need the pid

		 * of the new tak but we want to start measuring

		 * at the first user level instruction. Thus we

		 * need to prevent exec until we have attached

		 * the events.

		 */

		if (pid == 0) {

			close(ready[0]);

			close(go[1]);

			/*

			 * let the parent know we exist

			 */

			close(ready[1]);

			if (read(go[0], &buf, 1) == -1)

				err(1, "unable to read go_pipe");

			exit(child(arg));

		}

		close(ready[1]);

		close(go[0]);

		if (read(ready[0], &buf, 1) == -1)

			err(1, "unable to read child_ready_pipe");

		close(ready[0]);

	}

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

		int is_group_leader; /* boolean */

		is_group_leader = perf_is_group_leader(fds, i);

		if (is_group_leader) {

			/* this is the group leader */

			group_fd = -1;

		} else {

			group_fd = fds[fds[i].group_leader].fd;

		}

		/*

		 * create leader disabled with enable_on-exec

		 */

		if (!options.pid) {

			fds[i].hw.disabled = is_group_leader;

			fds[i].hw.enable_on_exec = is_group_leader;

		}

		fds[i].hw.read_format = PERF_FORMAT_SCALE;

		/* request timing information necessary for scaling counts */

		if (is_group_leader && options.format_group)

			fds[i].hw.read_format |= PERF_FORMAT_GROUP;

		if (options.inherit)

			fds[i].hw.inherit = 1;

		if (options.pin && is_group_leader)

			fds[i].hw.pinned = 1;

		fds[i].fd = perf_event_open(&fds[i].hw, pid, -1, group_fd, 0);

		if (fds[i].fd == -1) {

			warn("cannot attach event%d %s", i, fds[i].name);

			goto error;

		}

	}

	if (!options.pid && go[1] > -1)

		close(go[1]);

	if (options.print) {

		if (!options.pid) {

			while(waitpid(pid, &status, WNOHANG) == 0) {

				sleep(1);

				print_counts(fds, num_fds);

			}

		} else {

			while(quit == 0) {

				sleep(1);

				print_counts(fds, num_fds);

			}

		}

	} else {

		if (!options.pid)

			waitpid(pid, &status, 0);

		else

			pause();

		print_counts(fds, num_fds);

	}

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

		close(fds[i].fd);

	perf_free_fds(fds, num_fds);

	/* free libpfm resources cleanly */

	pfm_terminate();

	return 0;

error:

	free(fds);

	if (!options.pid)

		kill(SIGKILL, pid);

	/* free libpfm resources cleanly */

	pfm_terminate();

	return -1;

}

static void

usage(void)

{

	printf("usage: task [-h] [-i] [-g] [-p] [-P] [-t pid] [-e event1,event2,...] cmd\n"

		"-h\t\tget help\n"

		"-i\t\tinherit across fork\n"

		"-f\t\tuse PERF_FORMAT_GROUP for reading up counts (experimental, not working)\n"

		"-p\t\tprint counts every second\n"

		"-P\t\tpin events\n"

		"-t pid\tmeasure existing pid\n"

		"-e ev,ev\tgroup of events to measure (multiple -e switches are allowed)\n"

		);

}

int

main(int argc, char **argv)

{

	int c;

	setlocale(LC_ALL, "");

	while ((c=getopt(argc, argv,"+he:ifpPt:")) != -1) {

		switch(c) {

			case 'e':

				if (options.num_groups < MAX_GROUPS) {

					options.events[options.num_groups++] = optarg;

				} else {

					errx(1, "you cannot specify more than %d groups.\n",

						MAX_GROUPS);

				}

				break;

			case 'f':

				options.format_group = 1;

				break;

			case 'p':

				options.print = 1;

				break;

			case 'P':

				options.pin = 1;

				break;

			case 'i':

				options.inherit = 1;

				break;

			case 't':

				options.pid = atoi(optarg);

				break;

			case 'h':

				usage();

				exit(0);

			default:

				errx(1, "unknown error");

		}

	}

	if (options.num_groups == 0) {

		options.events[0] = "cycles,instructions";

		options.num_groups = 1;

	}

	if (!argv[optind] && !options.pid)

		errx(1, "you must specify a command to execute or a thread to attach to\n");

	signal(SIGINT, sig_handler);

	return parent(argv+optind);

}