Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 454c407e authored by Tom Zanussi's avatar Tom Zanussi Committed by Arnaldo Carvalho de Melo
Browse files

perf: add perf-inject builtin 



Currently, perf 'live mode' writes build-ids at the end of the
session, which isn't actually useful for processing live mode events.

What would be better would be to have the build-ids sent before any of
the samples that reference them, which can be done by processing the
event stream and retrieving the build-ids on the first hit.  Doing
that in perf-record itself, however, is off-limits.

This patch introduces perf-inject, which does the same job while
leaving perf-record untouched.  Normal mode perf still records the
build-ids at the end of the session as it should, but for live mode,
perf-inject can be injected in between the record and report steps
e.g.:

perf record -o - ./hackbench 10 | perf inject -v -b | perf report -v -i -

perf-inject reads a perf-record event stream and repipes it to stdout.
At any point the processing code can inject other events into the
event stream - in this case build-ids (-b option) are read and
injected as needed into the event stream.

Build-ids are just the first user of perf-inject - potentially
anything that needs userspace processing to augment the trace stream
with additional information could make use of this facility.

Cc: Ingo Molnar <mingo@elte.hu>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
LKML-Reference: <1272696080-16435-3-git-send-email-tzanussi@gmail.com>
Signed-off-by: default avatarTom Zanussi <tzanussi@gmail.com>
Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent 789688fa

tools/perf/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -490,6 +490,7 @@ BUILTIN_OBJS += $(OUTPUT)builtin-kmem.o 
BUILTIN_OBJS += $(OUTPUT)builtin-lock.o

BUILTIN_OBJS += $(OUTPUT)builtin-kvm.o

BUILTIN_OBJS += $(OUTPUT)builtin-test.o

BUILTIN_OBJS += $(OUTPUT)builtin-inject.o



PERFLIBS = $(LIB_FILE)

tools/perf/builtin-annotate.c

+1 −1
Original line number Diff line number Diff line
@@ -554,7 +554,7 @@ static int __cmd_annotate(void) 
	int ret;

	struct perf_session *session;



	session = perf_session__new(input_name, O_RDONLY, force);

	session = perf_session__new(input_name, O_RDONLY, force, false);

	if (session == NULL)

		return -ENOMEM;

tools/perf/builtin-buildid-list.c

+1 −1
Original line number Diff line number Diff line
@@ -39,7 +39,7 @@ static int __cmd_buildid_list(void) 
	int err = -1;

	struct perf_session *session;



	session = perf_session__new(input_name, O_RDONLY, force);

	session = perf_session__new(input_name, O_RDONLY, force, false);

	if (session == NULL)

		return -1;

tools/perf/builtin-diff.c

+2 −2
Original line number Diff line number Diff line
@@ -156,8 +156,8 @@ static int __cmd_diff(void) 
	int ret, i;

	struct perf_session *session[2];



	session[0] = perf_session__new(input_old, O_RDONLY, force);

	session[1] = perf_session__new(input_new, O_RDONLY, force);

	session[0] = perf_session__new(input_old, O_RDONLY, force, false);

	session[1] = perf_session__new(input_new, O_RDONLY, force, false);

	if (session[0] == NULL || session[1] == NULL)

		return -ENOMEM;

tools/perf/builtin-inject.c

0 → 100644
+228 −0
Original line number Diff line number Diff line 
/*

 * builtin-inject.c

 *

 * Builtin inject command: Examine the live mode (stdin) event stream

 * and repipe it to stdout while optionally injecting additional

 * events into it.

 */

#include "builtin.h"



#include "perf.h"

#include "util/session.h"

#include "util/debug.h"



#include "util/parse-options.h"



static char		const *input_name = "-";

static bool		inject_build_ids;



static int event__repipe(event_t *event __used,

			 struct perf_session *session __used)

{

	uint32_t size;

	void *buf = event;



	size = event->header.size;



	while (size) {

		int ret = write(STDOUT_FILENO, buf, size);

		if (ret < 0)

			return -errno;



		size -= ret;

		buf += ret;

	}



	return 0;

}



static int event__repipe_mmap(event_t *self, struct perf_session *session)

{

	int err;



	err = event__process_mmap(self, session);

	event__repipe(self, session);



	return err;

}



static int event__repipe_task(event_t *self, struct perf_session *session)

{

	int err;



	err = event__process_task(self, session);

	event__repipe(self, session);



	return err;

}



static int event__repipe_tracing_data(event_t *self,

				      struct perf_session *session)

{

	int err;



	event__repipe(self, session);

	err = event__process_tracing_data(self, session);



	return err;

}



static int read_buildid(struct map *self, struct perf_session *session)

{

	const char *name = self->dso->long_name;

	int err;



	if (filename__read_build_id(self->dso->long_name, self->dso->build_id,

				    sizeof(self->dso->build_id)) > 0) {

		char sbuild_id[BUILD_ID_SIZE * 2 + 1];



		self->dso->has_build_id = true;



		build_id__sprintf(self->dso->build_id,

				  sizeof(self->dso->build_id),

				  sbuild_id);

		pr_debug("build id found for %s: %s\n", self->dso->long_name,

			 sbuild_id);

	}



	if (self->dso->has_build_id) {

		u16 misc = PERF_RECORD_MISC_USER;

		struct machine *machine;



		misc = self->dso->kernel ? PERF_RECORD_MISC_KERNEL : misc;



		machine = perf_session__find_host_machine(session);

		if (!machine) {

			pr_err("Can't find machine for session\n");

			return -1;

		}



		err = event__synthesize_build_id(self->dso, misc,

						 event__repipe, machine,

						 session);

		if (err) {

			pr_err("Can't synthesize build_id event for %s\n",

			       name);

			return -1;

		}

	} else {

		pr_debug("no build_id found for %s\n", name);

		return -1;

	}



	return 0;

}



static int event__inject_buildid(event_t *event, struct perf_session *session)

{

	struct addr_location al;

	struct thread *thread;

	u8 cpumode;

	int err = 0;



	cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;



	thread = perf_session__findnew(session, event->ip.pid);

	if (thread == NULL) {

		pr_err("problem processing %d event, skipping it.\n",

		       event->header.type);

		err = -1;

		goto repipe;

	}



	thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,

			      event->ip.pid, event->ip.ip, &al);



	if (al.map != NULL) {

		if (!al.map->dso->hit) {

			al.map->dso->hit = 1;

			if (map__load(al.map, NULL) >= 0)

				read_buildid(al.map, session);

			else

				pr_warning("no symbols found in %s, maybe "

					   "install a debug package?\n",

					   al.map->dso->long_name);

		}

	}



repipe:

	event__repipe(event, session);

	return err;

}



struct perf_event_ops inject_ops = {

	.sample		= event__repipe,

	.mmap		= event__repipe,

	.comm		= event__repipe,

	.fork		= event__repipe,

	.exit		= event__repipe,

	.lost		= event__repipe,

	.read		= event__repipe,

	.throttle	= event__repipe,

	.unthrottle	= event__repipe,

	.attr		= event__repipe,

	.event_type 	= event__repipe,

	.tracing_data 	= event__repipe,

	.build_id 	= event__repipe,

};



extern volatile int session_done;



static void sig_handler(int sig __attribute__((__unused__)))

{

	session_done = 1;

}



static int __cmd_inject(void)

{

	struct perf_session *session;

	int ret = -EINVAL;



	signal(SIGINT, sig_handler);



	if (inject_build_ids) {

		inject_ops.sample	= event__inject_buildid;

		inject_ops.mmap		= event__repipe_mmap;

		inject_ops.fork		= event__repipe_task;

		inject_ops.tracing_data	= event__repipe_tracing_data;

	}



	session = perf_session__new(input_name, O_RDONLY, false, true);

	if (session == NULL)

		return -ENOMEM;



	ret = perf_session__process_events(session, &inject_ops);



	perf_session__delete(session);



	return ret;

}



static const char * const report_usage[] = {

	"perf inject [<options>]",

	NULL

};



static const struct option options[] = {

	OPT_BOOLEAN('b', "inject build-ids", &inject_build_ids,

		    "Inject build-ids into the output stream"),

	OPT_INCR('v', "verbose", &verbose,

		 "be more verbose (show build ids, etc)"),

	OPT_END()

};



int cmd_inject(int argc, const char **argv, const char *prefix __used)

{

	argc = parse_options(argc, argv, options, report_usage, 0);



	/*

	 * Any (unrecognized) arguments left?

	 */

	if (argc)

		usage_with_options(report_usage, options);



	if (symbol__init() < 0)

		return -1;



	return __cmd_inject();

}