Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit e742f3dc0886a92403d578e8ac771e5e33d06d08

Authored by Ingo Molnar 2015-01-28 22:40:30 +0800

Exists in ti-lsk-linux-4.1.y and in 10 other branches

Merge tag 'perf-urgent-for-mingo' of git://git.kernel.org/pub/scm/linux/kernel/g…

…it/acme/linux into perf/urgent

Pull perf/urgent fixes from Arnaldo Carvalho de Melo:

" User visible fixes:

  - Fix probing at function return (Namhyumg Kim)

  Developer visible fixes:

  - Symbol processing changes necessary for fixing support for
    kretprobes in 'perf probe' (Namhyung Kim, Arnaldo Carvalho de Melo)

  - Annotation memory leaks and instruction parsing fixes (Rabin Vincent)

  - Fix perl build on ARM64 (Wang Nam)
"

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@kernel.org>

Showing 7 changed files Inline Diff

tools/perf/scripts/perl/Perf-Trace-Util/Context.c
tools/perf/util/annotate.c
tools/perf/util/evlist.c
tools/perf/util/map.h
tools/perf/util/probe-event.c
tools/perf/util/symbol.c
tools/perf/util/symbol.h

tools/perf/scripts/perl/Perf-Trace-Util/Context.c

Diff comments View file @ e742f3d

1	/*	1	/*
2	* This file was generated automatically by ExtUtils::ParseXS version 2.18_02 from the	2	* This file was generated automatically by ExtUtils::ParseXS version 2.18_02 from the
3	* contents of Context.xs. Do not edit this file, edit Context.xs instead.	3	* contents of Context.xs. Do not edit this file, edit Context.xs instead.
4	*	4	*
5	* ANY CHANGES MADE HERE WILL BE LOST!	5	* ANY CHANGES MADE HERE WILL BE LOST!
6	*	6	*
7	*/	7	*/
8		8	#include <stdbool.h>
		9	#ifndef HAS_BOOL
		10	# define HAS_BOOL 1
		11	#endif
9	#line 1 "Context.xs"	12	#line 1 "Context.xs"
10	/*	13	/*
11	* Context.xs. XS interfaces for perf script.	14	* Context.xs. XS interfaces for perf script.
12	*	15	*
13	* Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com>	16	* Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com>
14	*	17	*
15	* This program is free software; you can redistribute it and/or modify	18	* This program is free software; you can redistribute it and/or modify
16	* it under the terms of the GNU General Public License as published by	19	* it under the terms of the GNU General Public License as published by
17	* the Free Software Foundation; either version 2 of the License, or	20	* the Free Software Foundation; either version 2 of the License, or
18	* (at your option) any later version.	21	* (at your option) any later version.
19	*	22	*
20	* This program is distributed in the hope that it will be useful,	23	* This program is distributed in the hope that it will be useful,
21	* but WITHOUT ANY WARRANTY; without even the implied warranty of	24	* but WITHOUT ANY WARRANTY; without even the implied warranty of
22	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	25	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23	* GNU General Public License for more details.	26	* GNU General Public License for more details.
24	*	27	*
25	* You should have received a copy of the GNU General Public License	28	* You should have received a copy of the GNU General Public License
26	* along with this program; if not, write to the Free Software	29	* along with this program; if not, write to the Free Software
27	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	30	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28	*	31	*
29	*/	32	*/
30		33
31	#include "EXTERN.h"	34	#include "EXTERN.h"
32	#include "perl.h"	35	#include "perl.h"
33	#include "XSUB.h"	36	#include "XSUB.h"
34	#include "../../../perf.h"	37	#include "../../../perf.h"
35	#include "../../../util/trace-event.h"	38	#include "../../../util/trace-event.h"
36		39
37	#ifndef PERL_UNUSED_VAR	40	#ifndef PERL_UNUSED_VAR
38	# define PERL_UNUSED_VAR(var) if (0) var = var	41	# define PERL_UNUSED_VAR(var) if (0) var = var
39	#endif	42	#endif
40		43
41	#line 42 "Context.c"	44	#line 42 "Context.c"
42		45
43	XS(XS_Perf__Trace__Context_common_pc); /* prototype to pass -Wmissing-prototypes */	46	XS(XS_Perf__Trace__Context_common_pc); /* prototype to pass -Wmissing-prototypes */
44	XS(XS_Perf__Trace__Context_common_pc)	47	XS(XS_Perf__Trace__Context_common_pc)
45	{	48	{
46	#ifdef dVAR	49	#ifdef dVAR
47	dVAR; dXSARGS;	50	dVAR; dXSARGS;
48	#else	51	#else
49	dXSARGS;	52	dXSARGS;
50	#endif	53	#endif
51	if (items != 1)	54	if (items != 1)
52	Perl_croak(aTHX_ "Usage: %s(%s)", "Perf::Trace::Context::common_pc", "context");	55	Perl_croak(aTHX_ "Usage: %s(%s)", "Perf::Trace::Context::common_pc", "context");
53	PERL_UNUSED_VAR(cv); /* -W */	56	PERL_UNUSED_VAR(cv); /* -W */
54	{	57	{
55	struct scripting_context * context = INT2PTR(struct scripting_context *,SvIV(ST(0)));	58	struct scripting_context * context = INT2PTR(struct scripting_context *,SvIV(ST(0)));
56	int RETVAL;	59	int RETVAL;
57	dXSTARG;	60	dXSTARG;
58		61
59	RETVAL = common_pc(context);	62	RETVAL = common_pc(context);
60	XSprePUSH; PUSHi((IV)RETVAL);	63	XSprePUSH; PUSHi((IV)RETVAL);
61	}	64	}
62	XSRETURN(1);	65	XSRETURN(1);
63	}	66	}
64		67
65		68
66	XS(XS_Perf__Trace__Context_common_flags); /* prototype to pass -Wmissing-prototypes */	69	XS(XS_Perf__Trace__Context_common_flags); /* prototype to pass -Wmissing-prototypes */
67	XS(XS_Perf__Trace__Context_common_flags)	70	XS(XS_Perf__Trace__Context_common_flags)
68	{	71	{
69	#ifdef dVAR	72	#ifdef dVAR
70	dVAR; dXSARGS;	73	dVAR; dXSARGS;
71	#else	74	#else
72	dXSARGS;	75	dXSARGS;
73	#endif	76	#endif
74	if (items != 1)	77	if (items != 1)
75	Perl_croak(aTHX_ "Usage: %s(%s)", "Perf::Trace::Context::common_flags", "context");	78	Perl_croak(aTHX_ "Usage: %s(%s)", "Perf::Trace::Context::common_flags", "context");
76	PERL_UNUSED_VAR(cv); /* -W */	79	PERL_UNUSED_VAR(cv); /* -W */
77	{	80	{
78	struct scripting_context * context = INT2PTR(struct scripting_context *,SvIV(ST(0)));	81	struct scripting_context * context = INT2PTR(struct scripting_context *,SvIV(ST(0)));
79	int RETVAL;	82	int RETVAL;
80	dXSTARG;	83	dXSTARG;
81		84
82	RETVAL = common_flags(context);	85	RETVAL = common_flags(context);
83	XSprePUSH; PUSHi((IV)RETVAL);	86	XSprePUSH; PUSHi((IV)RETVAL);
84	}	87	}
85	XSRETURN(1);	88	XSRETURN(1);
86	}	89	}
87		90
88		91
89	XS(XS_Perf__Trace__Context_common_lock_depth); /* prototype to pass -Wmissing-prototypes */	92	XS(XS_Perf__Trace__Context_common_lock_depth); /* prototype to pass -Wmissing-prototypes */
90	XS(XS_Perf__Trace__Context_common_lock_depth)	93	XS(XS_Perf__Trace__Context_common_lock_depth)
91	{	94	{
92	#ifdef dVAR	95	#ifdef dVAR
93	dVAR; dXSARGS;	96	dVAR; dXSARGS;
94	#else	97	#else
95	dXSARGS;	98	dXSARGS;
96	#endif	99	#endif
97	if (items != 1)	100	if (items != 1)
98	Perl_croak(aTHX_ "Usage: %s(%s)", "Perf::Trace::Context::common_lock_depth", "context");	101	Perl_croak(aTHX_ "Usage: %s(%s)", "Perf::Trace::Context::common_lock_depth", "context");
99	PERL_UNUSED_VAR(cv); /* -W */	102	PERL_UNUSED_VAR(cv); /* -W */
100	{	103	{
101	struct scripting_context * context = INT2PTR(struct scripting_context *,SvIV(ST(0)));	104	struct scripting_context * context = INT2PTR(struct scripting_context *,SvIV(ST(0)));
102	int RETVAL;	105	int RETVAL;
103	dXSTARG;	106	dXSTARG;
104		107
105	RETVAL = common_lock_depth(context);	108	RETVAL = common_lock_depth(context);
106	XSprePUSH; PUSHi((IV)RETVAL);	109	XSprePUSH; PUSHi((IV)RETVAL);
107	}	110	}
108	XSRETURN(1);	111	XSRETURN(1);
109	}	112	}
110		113
111	#ifdef __cplusplus	114	#ifdef __cplusplus
112	extern "C"	115	extern "C"
113	#endif	116	#endif
114	XS(boot_Perf__Trace__Context); /* prototype to pass -Wmissing-prototypes */	117	XS(boot_Perf__Trace__Context); /* prototype to pass -Wmissing-prototypes */
115	XS(boot_Perf__Trace__Context)	118	XS(boot_Perf__Trace__Context)
116	{	119	{
117	#ifdef dVAR	120	#ifdef dVAR
118	dVAR; dXSARGS;	121	dVAR; dXSARGS;
119	#else	122	#else
120	dXSARGS;	123	dXSARGS;
121	#endif	124	#endif
122	const char* file = __FILE__;	125	const char* file = __FILE__;
123		126
124	PERL_UNUSED_VAR(cv); /* -W */	127	PERL_UNUSED_VAR(cv); /* -W */
125	PERL_UNUSED_VAR(items); /* -W */	128	PERL_UNUSED_VAR(items); /* -W */
126	XS_VERSION_BOOTCHECK ;	129	XS_VERSION_BOOTCHECK ;
127		130
128	newXSproto("Perf::Trace::Context::common_pc", XS_Perf__Trace__Context_common_pc, file, "$");	131	newXSproto("Perf::Trace::Context::common_pc", XS_Perf__Trace__Context_common_pc, file, "$");
129	newXSproto("Perf::Trace::Context::common_flags", XS_Perf__Trace__Context_common_flags, file, "$");	132	newXSproto("Perf::Trace::Context::common_flags", XS_Perf__Trace__Context_common_flags, file, "$");
130	newXSproto("Perf::Trace::Context::common_lock_depth", XS_Perf__Trace__Context_common_lock_depth, file, "$");	133	newXSproto("Perf::Trace::Context::common_lock_depth", XS_Perf__Trace__Context_common_lock_depth, file, "$");
131	if (PL_unitcheckav)	134	if (PL_unitcheckav)
132	call_list(PL_scopestack_ix, PL_unitcheckav);	135	call_list(PL_scopestack_ix, PL_unitcheckav);
133	XSRETURN_YES;	136	XSRETURN_YES;
134	}	137	}
135		138
136		139

tools/perf/util/annotate.c

Diff comments View file @ e742f3d

 /*
  * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
  *
  * Parts came from builtin-annotate.c, see those files for further
  * copyright notes.
  *
  * Released under the GPL v2. (and only v2, not any later version)
  */
 #include "util.h"
 #include "ui/ui.h"
 #include "sort.h"
 #include "build-id.h"
 #include "color.h"
 #include "cache.h"
 #include "symbol.h"
 #include "debug.h"
 #include "annotate.h"
 #include "evsel.h"
 #include <regex.h>
 #include <pthread.h>
 #include <linux/bitops.h>
 const char 	*disassembler_style;
 const char	*objdump_path;
 static regex_t	 file_lineno;
 static struct ins *ins__find(const char *name);
 static int disasm_line__parse(char *line, char **namep, char **rawp);
 static void ins__delete(struct ins_operands *ops)
 {
 	zfree(&ops->source.raw);
 	zfree(&ops->source.name);
 	zfree(&ops->target.raw);
 	zfree(&ops->target.name);
 }
 static int ins__raw_scnprintf(struct ins *ins, char *bf, size_t size,
 			      struct ins_operands *ops)
 {
 	return scnprintf(bf, size, "%-6.6s %s", ins->name, ops->raw);
 }
 int ins__scnprintf(struct ins *ins, char *bf, size_t size,
 		  struct ins_operands *ops)
 {
 	if (ins->ops->scnprintf)
 		return ins->ops->scnprintf(ins, bf, size, ops);
 	return ins__raw_scnprintf(ins, bf, size, ops);
 }
 static int call__parse(struct ins_operands *ops)
 {
 	char *endptr, *tok, *name;
 	ops->target.addr = strtoull(ops->raw, &endptr, 16);
 	name = strchr(endptr, '<');
 	if (name == NULL)
 		goto indirect_call;
 	name++;
 	tok = strchr(name, '>');
 	if (tok == NULL)
 		return -1;
 	*tok = '\0';
 	ops->target.name = strdup(name);
 	*tok = '>';
 	return ops->target.name == NULL ? -1 : 0;
 indirect_call:
 	tok = strchr(endptr, '(');
 	if (tok != NULL) {
 		ops->target.addr = 0;
 		return 0;
 	}
 	tok = strchr(endptr, '*');
 	if (tok == NULL)
 		return -1;
 	ops->target.addr = strtoull(tok + 1, NULL, 16);
 	return 0;
 }
 static int call__scnprintf(struct ins *ins, char *bf, size_t size,
 			   struct ins_operands *ops)
 {
 	if (ops->target.name)
 		return scnprintf(bf, size, "%-6.6s %s", ins->name, ops->target.name);
 	if (ops->target.addr == 0)
 		return ins__raw_scnprintf(ins, bf, size, ops);
 	return scnprintf(bf, size, "%-6.6s *%" PRIx64, ins->name, ops->target.addr);
 }
 static struct ins_ops call_ops = {
 	.parse	   = call__parse,
 	.scnprintf = call__scnprintf,
 };
 bool ins__is_call(const struct ins *ins)
 {
 	return ins->ops == &call_ops;
 }
 static int jump__parse(struct ins_operands *ops)
 {
 	const char *s = strchr(ops->raw, '+');
 	ops->target.addr = strtoull(ops->raw, NULL, 16);
 	if (s++ != NULL)
 		ops->target.offset = strtoull(s, NULL, 16);
 	else
 		ops->target.offset = UINT64_MAX;
 	return 0;
 }
 static int jump__scnprintf(struct ins *ins, char *bf, size_t size,
 			   struct ins_operands *ops)
 {
 	return scnprintf(bf, size, "%-6.6s %" PRIx64, ins->name, ops->target.offset);
 }
 static struct ins_ops jump_ops = {
 	.parse	   = jump__parse,
 	.scnprintf = jump__scnprintf,
 };
 bool ins__is_jump(const struct ins *ins)
 {
 	return ins->ops == &jump_ops;
 }
 static int comment__symbol(char *raw, char *comment, u64 *addrp, char **namep)
 {
 	char *endptr, *name, *t;
 	if (strstr(raw, "(%rip)") == NULL)
 		return 0;
 	*addrp = strtoull(comment, &endptr, 16);
 	name = strchr(endptr, '<');
 	if (name == NULL)
 		return -1;
 	name++;
 	t = strchr(name, '>');
 	if (t == NULL)
 		return 0;
 	*t = '\0';
 	*namep = strdup(name);
 	*t = '>';
 	return 0;
 }
 static int lock__parse(struct ins_operands *ops)
 {
 	char *name;
 	ops->locked.ops = zalloc(sizeof(*ops->locked.ops));
 	if (ops->locked.ops == NULL)
 		return 0;
 	if (disasm_line__parse(ops->raw, &name, &ops->locked.ops->raw) < 0)
 		goto out_free_ops;
 	ops->locked.ins = ins__find(name);
+	free(name);
 	if (ops->locked.ins == NULL)
 		goto out_free_ops;
 	if (!ops->locked.ins->ops)
 		return 0;
-	if (ops->locked.ins->ops->parse)
+	if (ops->locked.ins->ops->parse &&
-		ops->locked.ins->ops->parse(ops->locked.ops);
+	    ops->locked.ins->ops->parse(ops->locked.ops) < 0)
+		goto out_free_ops;
 	return 0;
 out_free_ops:
 	zfree(&ops->locked.ops);
 	return 0;
 }
 static int lock__scnprintf(struct ins *ins, char *bf, size_t size,
 			   struct ins_operands *ops)
 {
 	int printed;
 	if (ops->locked.ins == NULL)
 		return ins__raw_scnprintf(ins, bf, size, ops);
 	printed = scnprintf(bf, size, "%-6.6s ", ins->name);
 	return printed + ins__scnprintf(ops->locked.ins, bf + printed,
 					size - printed, ops->locked.ops);
 }
 static void lock__delete(struct ins_operands *ops)
 {
+	struct ins *ins = ops->locked.ins;
+	if (ins && ins->ops->free)
+		ins->ops->free(ops->locked.ops);
+	else
+		ins__delete(ops->locked.ops);
 	zfree(&ops->locked.ops);
 	zfree(&ops->target.raw);
 	zfree(&ops->target.name);
 }
 static struct ins_ops lock_ops = {
 	.free	   = lock__delete,
 	.parse	   = lock__parse,
 	.scnprintf = lock__scnprintf,
 };
 static int mov__parse(struct ins_operands *ops)
 {
 	char *s = strchr(ops->raw, ','), *target, *comment, prev;
 	if (s == NULL)
 		return -1;
 	*s = '\0';
 	ops->source.raw = strdup(ops->raw);
 	*s = ',';
 	if (ops->source.raw == NULL)
 		return -1;
 	target = ++s;
 	comment = strchr(s, '#');
 	if (comment != NULL)
 		s = comment - 1;
 	else
 		s = strchr(s, '\0') - 1;
 	while (s > target && isspace(s[0]))
 		--s;
 	s++;
 	prev = *s;
 	*s = '\0';
 	ops->target.raw = strdup(target);
 	*s = prev;
 	if (ops->target.raw == NULL)
 		goto out_free_source;
 	if (comment == NULL)
 		return 0;
 	while (comment[0] != '\0' && isspace(comment[0]))
 		++comment;
 	comment__symbol(ops->source.raw, comment, &ops->source.addr, &ops->source.name);
 	comment__symbol(ops->target.raw, comment, &ops->target.addr, &ops->target.name);
 	return 0;
 out_free_source:
 	zfree(&ops->source.raw);
 	return -1;
 }
 static int mov__scnprintf(struct ins *ins, char *bf, size_t size,
 			   struct ins_operands *ops)
 {
 	return scnprintf(bf, size, "%-6.6s %s,%s", ins->name,
 			 ops->source.name ?: ops->source.raw,
 			 ops->target.name ?: ops->target.raw);
 }
 static struct ins_ops mov_ops = {
 	.parse	   = mov__parse,
 	.scnprintf = mov__scnprintf,
 };
 static int dec__parse(struct ins_operands *ops)
 {
 	char *target, *comment, *s, prev;
 	target = s = ops->raw;
 	while (s[0] != '\0' && !isspace(s[0]))
 		++s;
 	prev = *s;
 	*s = '\0';
 	ops->target.raw = strdup(target);
 	*s = prev;
 	if (ops->target.raw == NULL)
 		return -1;
 	comment = strchr(s, '#');
 	if (comment == NULL)
 		return 0;
 	while (comment[0] != '\0' && isspace(comment[0]))
 		++comment;
 	comment__symbol(ops->target.raw, comment, &ops->target.addr, &ops->target.name);
 	return 0;
 }
 static int dec__scnprintf(struct ins *ins, char *bf, size_t size,
 			   struct ins_operands *ops)
 {
 	return scnprintf(bf, size, "%-6.6s %s", ins->name,
 			 ops->target.name ?: ops->target.raw);
 }
 static struct ins_ops dec_ops = {
 	.parse	   = dec__parse,
 	.scnprintf = dec__scnprintf,
 };
 static int nop__scnprintf(struct ins *ins __maybe_unused, char *bf, size_t size,
 			  struct ins_operands *ops __maybe_unused)
 {
 	return scnprintf(bf, size, "%-6.6s", "nop");
 }
 static struct ins_ops nop_ops = {
 	.scnprintf = nop__scnprintf,
 };
 /*
  * Must be sorted by name!
  */
 static struct ins instructions[] = {
 	{ .name = "add",   .ops  = &mov_ops, },
 	{ .name = "addl",  .ops  = &mov_ops, },
 	{ .name = "addq",  .ops  = &mov_ops, },
 	{ .name = "addw",  .ops  = &mov_ops, },
 	{ .name = "and",   .ops  = &mov_ops, },
 	{ .name = "bts",   .ops  = &mov_ops, },
 	{ .name = "call",  .ops  = &call_ops, },
 	{ .name = "callq", .ops  = &call_ops, },
 	{ .name = "cmp",   .ops  = &mov_ops, },
 	{ .name = "cmpb",  .ops  = &mov_ops, },
 	{ .name = "cmpl",  .ops  = &mov_ops, },
 	{ .name = "cmpq",  .ops  = &mov_ops, },
 	{ .name = "cmpw",  .ops  = &mov_ops, },
 	{ .name = "cmpxch", .ops  = &mov_ops, },
 	{ .name = "dec",   .ops  = &dec_ops, },
 	{ .name = "decl",  .ops  = &dec_ops, },
 	{ .name = "imul",  .ops  = &mov_ops, },
 	{ .name = "inc",   .ops  = &dec_ops, },
 	{ .name = "incl",  .ops  = &dec_ops, },
 	{ .name = "ja",	   .ops  = &jump_ops, },
 	{ .name = "jae",   .ops  = &jump_ops, },
 	{ .name = "jb",	   .ops  = &jump_ops, },
 	{ .name = "jbe",   .ops  = &jump_ops, },
 	{ .name = "jc",	   .ops  = &jump_ops, },
 	{ .name = "jcxz",  .ops  = &jump_ops, },
 	{ .name = "je",	   .ops  = &jump_ops, },
 	{ .name = "jecxz", .ops  = &jump_ops, },
 	{ .name = "jg",	   .ops  = &jump_ops, },
 	{ .name = "jge",   .ops  = &jump_ops, },
 	{ .name = "jl",    .ops  = &jump_ops, },
 	{ .name = "jle",   .ops  = &jump_ops, },
 	{ .name = "jmp",   .ops  = &jump_ops, },
 	{ .name = "jmpq",  .ops  = &jump_ops, },
 	{ .name = "jna",   .ops  = &jump_ops, },
 	{ .name = "jnae",  .ops  = &jump_ops, },
 	{ .name = "jnb",   .ops  = &jump_ops, },
 	{ .name = "jnbe",  .ops  = &jump_ops, },
 	{ .name = "jnc",   .ops  = &jump_ops, },
 	{ .name = "jne",   .ops  = &jump_ops, },
 	{ .name = "jng",   .ops  = &jump_ops, },
 	{ .name = "jnge",  .ops  = &jump_ops, },
 	{ .name = "jnl",   .ops  = &jump_ops, },
 	{ .name = "jnle",  .ops  = &jump_ops, },
 	{ .name = "jno",   .ops  = &jump_ops, },
 	{ .name = "jnp",   .ops  = &jump_ops, },
 	{ .name = "jns",   .ops  = &jump_ops, },
 	{ .name = "jnz",   .ops  = &jump_ops, },
 	{ .name = "jo",	   .ops  = &jump_ops, },
 	{ .name = "jp",	   .ops  = &jump_ops, },
 	{ .name = "jpe",   .ops  = &jump_ops, },
 	{ .name = "jpo",   .ops  = &jump_ops, },
 	{ .name = "jrcxz", .ops  = &jump_ops, },
 	{ .name = "js",	   .ops  = &jump_ops, },
 	{ .name = "jz",	   .ops  = &jump_ops, },
 	{ .name = "lea",   .ops  = &mov_ops, },
 	{ .name = "lock",  .ops  = &lock_ops, },
 	{ .name = "mov",   .ops  = &mov_ops, },
 	{ .name = "movb",  .ops  = &mov_ops, },
 	{ .name = "movdqa",.ops  = &mov_ops, },
 	{ .name = "movl",  .ops  = &mov_ops, },
 	{ .name = "movq",  .ops  = &mov_ops, },
 	{ .name = "movslq", .ops  = &mov_ops, },
 	{ .name = "movzbl", .ops  = &mov_ops, },
 	{ .name = "movzwl", .ops  = &mov_ops, },
 	{ .name = "nop",   .ops  = &nop_ops, },
 	{ .name = "nopl",  .ops  = &nop_ops, },
 	{ .name = "nopw",  .ops  = &nop_ops, },
 	{ .name = "or",    .ops  = &mov_ops, },
 	{ .name = "orl",   .ops  = &mov_ops, },
 	{ .name = "test",  .ops  = &mov_ops, },
 	{ .name = "testb", .ops  = &mov_ops, },
 	{ .name = "testl", .ops  = &mov_ops, },
 	{ .name = "xadd",  .ops  = &mov_ops, },
 	{ .name = "xbeginl", .ops  = &jump_ops, },
 	{ .name = "xbeginq", .ops  = &jump_ops, },
 };
 static int ins__cmp(const void *name, const void *insp)
 {
 	const struct ins *ins = insp;
 	return strcmp(name, ins->name);
 }
 static struct ins *ins__find(const char *name)
 {
 	const int nmemb = ARRAY_SIZE(instructions);
 	return bsearch(name, instructions, nmemb, sizeof(struct ins), ins__cmp);
 }
 int symbol__annotate_init(struct map *map __maybe_unused, struct symbol *sym)
 {
 	struct annotation *notes = symbol__annotation(sym);
 	pthread_mutex_init(&notes->lock, NULL);
 	return 0;
 }
 int symbol__alloc_hist(struct symbol *sym)
 {
 	struct annotation *notes = symbol__annotation(sym);
 	const size_t size = symbol__size(sym);
 	size_t sizeof_sym_hist;
 	/* Check for overflow when calculating sizeof_sym_hist */
 	if (size > (SIZE_MAX - sizeof(struct sym_hist)) / sizeof(u64))
 		return -1;
 	sizeof_sym_hist = (sizeof(struct sym_hist) + size * sizeof(u64));
 	/* Check for overflow in zalloc argument */
 	if (sizeof_sym_hist > (SIZE_MAX - sizeof(*notes->src))
 				/ symbol_conf.nr_events)
 		return -1;
 	notes->src = zalloc(sizeof(*notes->src) + symbol_conf.nr_events * sizeof_sym_hist);
 	if (notes->src == NULL)
 		return -1;
 	notes->src->sizeof_sym_hist = sizeof_sym_hist;
 	notes->src->nr_histograms   = symbol_conf.nr_events;
 	INIT_LIST_HEAD(&notes->src->source);
 	return 0;
 }
 void symbol__annotate_zero_histograms(struct symbol *sym)
 {
 	struct annotation *notes = symbol__annotation(sym);
 	pthread_mutex_lock(&notes->lock);
 	if (notes->src != NULL)
 		memset(notes->src->histograms, 0,
 		       notes->src->nr_histograms * notes->src->sizeof_sym_hist);
 	pthread_mutex_unlock(&notes->lock);
 }
 static int __symbol__inc_addr_samples(struct symbol *sym, struct map *map,
 				      struct annotation *notes, int evidx, u64 addr)
 {
 	unsigned offset;
 	struct sym_hist *h;
 	pr_debug3("%s: addr=%#" PRIx64 "\n", __func__, map->unmap_ip(map, addr));
 	if (addr < sym->start || addr >= sym->end)
 		return -ERANGE;
 	offset = addr - sym->start;
 	h = annotation__histogram(notes, evidx);
 	h->sum++;
 	h->addr[offset]++;
 	pr_debug3("%#" PRIx64 " %s: period++ [addr: %#" PRIx64 ", %#" PRIx64
 		  ", evidx=%d] => %" PRIu64 "\n", sym->start, sym->name,
 		  addr, addr - sym->start, evidx, h->addr[offset]);
 	return 0;
 }
 static int symbol__inc_addr_samples(struct symbol *sym, struct map *map,
 				    int evidx, u64 addr)
 {
 	struct annotation *notes;
 	if (sym == NULL)
 		return 0;
 	notes = symbol__annotation(sym);
 	if (notes->src == NULL) {
 		if (symbol__alloc_hist(sym) < 0)
 			return -ENOMEM;
 	}
 	return __symbol__inc_addr_samples(sym, map, notes, evidx, addr);
 }
 int addr_map_symbol__inc_samples(struct addr_map_symbol *ams, int evidx)
 {
 	return symbol__inc_addr_samples(ams->sym, ams->map, evidx, ams->al_addr);
 }
 int hist_entry__inc_addr_samples(struct hist_entry *he, int evidx, u64 ip)
 {
 	return symbol__inc_addr_samples(he->ms.sym, he->ms.map, evidx, ip);
 }
 static void disasm_line__init_ins(struct disasm_line *dl)
 {
 	dl->ins = ins__find(dl->name);
 	if (dl->ins == NULL)
 		return;
 	if (!dl->ins->ops)
 		return;
-	if (dl->ins->ops->parse)
+	if (dl->ins->ops->parse && dl->ins->ops->parse(&dl->ops) < 0)
-		dl->ins->ops->parse(&dl->ops);
+		dl->ins = NULL;
 }
 static int disasm_line__parse(char *line, char **namep, char **rawp)
 {
 	char *name = line, tmp;
 	while (isspace(name[0]))
 		++name;
 	if (name[0] == '\0')
 		return -1;
 	*rawp = name + 1;
 	while ((*rawp)[0] != '\0' && !isspace((*rawp)[0]))
 		++*rawp;
 	tmp = (*rawp)[0];
 	(*rawp)[0] = '\0';
 	*namep = strdup(name);
 	if (*namep == NULL)
 		goto out_free_name;
 	(*rawp)[0] = tmp;
 	if ((*rawp)[0] != '\0') {
 		(*rawp)++;
 		while (isspace((*rawp)[0]))
 			++(*rawp);
 	}
 	return 0;
 out_free_name:
 	zfree(namep);
 	return -1;
 }
 static struct disasm_line *disasm_line__new(s64 offset, char *line,
 					size_t privsize, int line_nr)
 {
 	struct disasm_line *dl = zalloc(sizeof(*dl) + privsize);
 	if (dl != NULL) {
 		dl->offset = offset;
 		dl->line = strdup(line);
 		dl->line_nr = line_nr;
 		if (dl->line == NULL)
 			goto out_delete;
 		if (offset != -1) {
 			if (disasm_line__parse(dl->line, &dl->name, &dl->ops.raw) < 0)
 				goto out_free_line;
 			disasm_line__init_ins(dl);
 		}
 	}
 	return dl;
 out_free_line:
 	zfree(&dl->line);
 out_delete:
 	free(dl);
 	return NULL;
 }
 void disasm_line__free(struct disasm_line *dl)
 {
 	zfree(&dl->line);
 	zfree(&dl->name);
 	if (dl->ins && dl->ins->ops->free)
 		dl->ins->ops->free(&dl->ops);
 	else
 		ins__delete(&dl->ops);
 	free(dl);
 }
 int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw)
 {
 	if (raw || !dl->ins)
 		return scnprintf(bf, size, "%-6.6s %s", dl->name, dl->ops.raw);
 	return ins__scnprintf(dl->ins, bf, size, &dl->ops);
 }
 static void disasm__add(struct list_head *head, struct disasm_line *line)
 {
 	list_add_tail(&line->node, head);
 }
 struct disasm_line *disasm__get_next_ip_line(struct list_head *head, struct disasm_line *pos)
 {
 	list_for_each_entry_continue(pos, head, node)
 		if (pos->offset >= 0)
 			return pos;
 	return NULL;
 }
 double disasm__calc_percent(struct annotation *notes, int evidx, s64 offset,
 			    s64 end, const char **path)
 {
 	struct source_line *src_line = notes->src->lines;
 	double percent = 0.0;
 	if (src_line) {
 		size_t sizeof_src_line = sizeof(*src_line) +
 				sizeof(src_line->p) * (src_line->nr_pcnt - 1);
 		while (offset < end) {
 			src_line = (void *)notes->src->lines +
 					(sizeof_src_line * offset);
 			if (*path == NULL)
 				*path = src_line->path;
 			percent += src_line->p[evidx].percent;
 			offset++;
 		}
 	} else {
 		struct sym_hist *h = annotation__histogram(notes, evidx);
 		unsigned int hits = 0;
 		while (offset < end)
 			hits += h->addr[offset++];
 		if (h->sum)
 			percent = 100.0 * hits / h->sum;
 	}
 	return percent;
 }
 static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 start,
 		      struct perf_evsel *evsel, u64 len, int min_pcnt, int printed,
 		      int max_lines, struct disasm_line *queue)
 {
 	static const char *prev_line;
 	static const char *prev_color;
 	if (dl->offset != -1) {
 		const char *path = NULL;
 		double percent, max_percent = 0.0;
 		double *ppercents = &percent;
 		int i, nr_percent = 1;
 		const char *color;
 		struct annotation *notes = symbol__annotation(sym);
 		s64 offset = dl->offset;
 		const u64 addr = start + offset;
 		struct disasm_line *next;
 		next = disasm__get_next_ip_line(&notes->src->source, dl);
 		if (perf_evsel__is_group_event(evsel)) {
 			nr_percent = evsel->nr_members;
 			ppercents = calloc(nr_percent, sizeof(double));
 			if (ppercents == NULL)
 				return -1;
 		}
 		for (i = 0; i < nr_percent; i++) {
 			percent = disasm__calc_percent(notes,
 					notes->src->lines ? i : evsel->idx + i,
 					offset,
 					next ? next->offset : (s64) len,
 					&path);
 			ppercents[i] = percent;
 			if (percent > max_percent)
 				max_percent = percent;
 		}
 		if (max_percent < min_pcnt)
 			return -1;
 		if (max_lines && printed >= max_lines)
 			return 1;
 		if (queue != NULL) {
 			list_for_each_entry_from(queue, &notes->src->source, node) {
 				if (queue == dl)
 					break;
 				disasm_line__print(queue, sym, start, evsel, len,
 						    0, 0, 1, NULL);
 			}
 		}
 		color = get_percent_color(max_percent);
 		/*
 		 * Also color the filename and line if needed, with
 		 * the same color than the percentage. Don't print it
 		 * twice for close colored addr with the same filename:line
 		 */
 		if (path) {
 			if (!prev_line || strcmp(prev_line, path)
 				       || color != prev_color) {
 				color_fprintf(stdout, color, " %s", path);
 				prev_line = path;
 				prev_color = color;
 			}
 		}
 		for (i = 0; i < nr_percent; i++) {
 			percent = ppercents[i];
 			color = get_percent_color(percent);
 			color_fprintf(stdout, color, " %7.2f", percent);
 		}
 		printf(" :	");
 		color_fprintf(stdout, PERF_COLOR_MAGENTA, "  %" PRIx64 ":", addr);
 		color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", dl->line);
 		if (ppercents != &percent)
 			free(ppercents);
 	} else if (max_lines && printed >= max_lines)
 		return 1;
 	else {
 		int width = 8;
 		if (queue)
 			return -1;
 		if (perf_evsel__is_group_event(evsel))
 			width *= evsel->nr_members;
 		if (!*dl->line)
 			printf(" %*s:\n", width, " ");
 		else
 			printf(" %*s:	%s\n", width, " ", dl->line);
 	}
 	return 0;
 }
 /*
  * symbol__parse_objdump_line() parses objdump output (with -d --no-show-raw)
  * which looks like following
  *
  *  0000000000415500 <_init>:
  *    415500:       sub    $0x8,%rsp
  *    415504:       mov    0x2f5ad5(%rip),%rax        # 70afe0 <_DYNAMIC+0x2f8>
  *    41550b:       test   %rax,%rax
  *    41550e:       je     415515 <_init+0x15>
  *    415510:       callq  416e70 <__gmon_start__@plt>
  *    415515:       add    $0x8,%rsp
  *    415519:       retq
  *
  * it will be parsed and saved into struct disasm_line as
  *  <offset>       <name>  <ops.raw>
  *
  * The offset will be a relative offset from the start of the symbol and -1
  * means that it's not a disassembly line so should be treated differently.
  * The ops.raw part will be parsed further according to type of the instruction.
  */
 static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
 				      FILE *file, size_t privsize,
 				      int *line_nr)
 {
 	struct annotation *notes = symbol__annotation(sym);
 	struct disasm_line *dl;
 	char *line = NULL, *parsed_line, *tmp, *tmp2, *c;
 	size_t line_len;
 	s64 line_ip, offset = -1;
 	regmatch_t match[2];
 	if (getline(&line, &line_len, file) < 0)
 		return -1;
 	if (!line)
 		return -1;
 	while (line_len != 0 && isspace(line[line_len - 1]))
 		line[--line_len] = '\0';
 	c = strchr(line, '\n');
 	if (c)
 		*c = 0;
 	line_ip = -1;
 	parsed_line = line;
 	/* /filename:linenr ? Save line number and ignore. */
 	if (regexec(&file_lineno, line, 2, match, 0) == 0) {
 		*line_nr = atoi(line + match[1].rm_so);
 		return 0;
 	}
 	/*
 	 * Strip leading spaces:
 	 */
 	tmp = line;
 	while (*tmp) {
 		if (*tmp != ' ')
 			break;
 		tmp++;
 	}
 	if (*tmp) {
 		/*
 		 * Parse hexa addresses followed by ':'
 		 */
 		line_ip = strtoull(tmp, &tmp2, 16);
 		if (*tmp2 != ':' || tmp == tmp2 || tmp2[1] == '\0')
 			line_ip = -1;
 	}
 	if (line_ip != -1) {
 		u64 start = map__rip_2objdump(map, sym->start),
 		    end = map__rip_2objdump(map, sym->end);
 		offset = line_ip - start;
 		if ((u64)line_ip < start || (u64)line_ip >= end)
 			offset = -1;
 		else
 			parsed_line = tmp2 + 1;
 	}
 	dl = disasm_line__new(offset, parsed_line, privsize, *line_nr);
 	free(line);
 	(*line_nr)++;
 	if (dl == NULL)
 		return -1;
 	if (dl->ops.target.offset == UINT64_MAX)
 		dl->ops.target.offset = dl->ops.target.addr -
 					map__rip_2objdump(map, sym->start);
 	/* kcore has no symbols, so add the call target name */
 	if (dl->ins && ins__is_call(dl->ins) && !dl->ops.target.name) {
 		struct addr_map_symbol target = {
 			.map = map,
 			.addr = dl->ops.target.addr,
 		};
 		if (!map_groups__find_ams(&target, NULL) &&
 		    target.sym->start == target.al_addr)
 			dl->ops.target.name = strdup(target.sym->name);
 	}
 	disasm__add(&notes->src->source, dl);
 	return 0;
 }
 static __attribute__((constructor)) void symbol__init_regexpr(void)
 {
 	regcomp(&file_lineno, "^/[^:]+:([0-9]+)", REG_EXTENDED);
 }
 static void delete_last_nop(struct symbol *sym)
 {
 	struct annotation *notes = symbol__annotation(sym);
 	struct list_head *list = &notes->src->source;
 	struct disasm_line *dl;
 	while (!list_empty(list)) {
 		dl = list_entry(list->prev, struct disasm_line, node);
 		if (dl->ins && dl->ins->ops) {
 			if (dl->ins->ops != &nop_ops)
 				return;
 		} else {
 			if (!strstr(dl->line, " nop ") &&
 			    !strstr(dl->line, " nopl ") &&
 			    !strstr(dl->line, " nopw "))
 				return;
 		}
 		list_del(&dl->node);
 		disasm_line__free(dl);
 	}
 }
 int symbol__annotate(struct symbol *sym, struct map *map, size_t privsize)
 {
 	struct dso *dso = map->dso;
 	char *filename = dso__build_id_filename(dso, NULL, 0);
 	bool free_filename = true;
 	char command[PATH_MAX * 2];
 	FILE *file;
 	int err = 0;
 	char symfs_filename[PATH_MAX];
 	struct kcore_extract kce;
 	bool delete_extract = false;
 	int lineno = 0;
 	if (filename)
 		symbol__join_symfs(symfs_filename, filename);
 	if (filename == NULL) {
 		if (dso->has_build_id) {
 			pr_err("Can't annotate %s: not enough memory\n",
 			       sym->name);
 			return -ENOMEM;
 		}
 		goto fallback;
 	} else if (dso__is_kcore(dso)) {
 		goto fallback;
 	} else if (readlink(symfs_filename, command, sizeof(command)) < 0 ||
 		   strstr(command, "[kernel.kallsyms]") ||
 		   access(symfs_filename, R_OK)) {
 		free(filename);
 fallback:
 		/*
 		 * If we don't have build-ids or the build-id file isn't in the
 		 * cache, or is just a kallsyms file, well, lets hope that this
 		 * DSO is the same as when 'perf record' ran.
 		 */
 		filename = (char *)dso->long_name;
 		symbol__join_symfs(symfs_filename, filename);
 		free_filename = false;
 	}
 	if (dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
 	    !dso__is_kcore(dso)) {
 		char bf[BUILD_ID_SIZE * 2 + 16] = " with build id ";
 		char *build_id_msg = NULL;
 		if (dso->annotate_warned)
 			goto out_free_filename;
 		if (dso->has_build_id) {
 			build_id__sprintf(dso->build_id,
 					  sizeof(dso->build_id), bf + 15);
 			build_id_msg = bf;
 		}
 		err = -ENOENT;
 		dso->annotate_warned = 1;
 		pr_err("Can't annotate %s:\n\n"
 		       "No vmlinux file%s\nwas found in the path.\n\n"
 		       "Please use:\n\n"
 		       "  perf buildid-cache -vu vmlinux\n\n"
 		       "or:\n\n"
 		       "  --vmlinux vmlinux\n",
 		       sym->name, build_id_msg ?: "");
 		goto out_free_filename;
 	}
 	pr_debug("%s: filename=%s, sym=%s, start=%#" PRIx64 ", end=%#" PRIx64 "\n", __func__,
 		 filename, sym->name, map->unmap_ip(map, sym->start),
 		 map->unmap_ip(map, sym->end));
 	pr_debug("annotating [%p] %30s : [%p] %30s\n",
 		 dso, dso->long_name, sym, sym->name);
 	if (dso__is_kcore(dso)) {
 		kce.kcore_filename = symfs_filename;
 		kce.addr = map__rip_2objdump(map, sym->start);
 		kce.offs = sym->start;
 		kce.len = sym->end - sym->start;
 		if (!kcore_extract__create(&kce)) {
 			delete_extract = true;
 			strlcpy(symfs_filename, kce.extract_filename,
 				sizeof(symfs_filename));
 			if (free_filename) {
 				free(filename);
 				free_filename = false;
 			}
 			filename = symfs_filename;
 		}
 	}
 	snprintf(command, sizeof(command),
 		 "%s %s%s --start-address=0x%016" PRIx64
 		 " --stop-address=0x%016" PRIx64
 		 " -l -d %s %s -C %s 2>/dev/null|grep -v %s|expand",
 		 objdump_path ? objdump_path : "objdump",
 		 disassembler_style ? "-M " : "",
 		 disassembler_style ? disassembler_style : "",
 		 map__rip_2objdump(map, sym->start),
 		 map__rip_2objdump(map, sym->end),
 		 symbol_conf.annotate_asm_raw ? "" : "--no-show-raw",
 		 symbol_conf.annotate_src ? "-S" : "",
 		 symfs_filename, filename);
 	pr_debug("Executing: %s\n", command);
 	file = popen(command, "r");
 	if (!file)
 		goto out_free_filename;
 	while (!feof(file))
 		if (symbol__parse_objdump_line(sym, map, file, privsize,
 			    &lineno) < 0)
 			break;
 	/*
 	 * kallsyms does not have symbol sizes so there may a nop at the end.
 	 * Remove it.
 	 */
 	if (dso__is_kcore(dso))
 		delete_last_nop(sym);
 	pclose(file);
 out_free_filename:
 	if (delete_extract)
 		kcore_extract__delete(&kce);
 	if (free_filename)
 		free(filename);
 	return err;
 }
 static void insert_source_line(struct rb_root *root, struct source_line *src_line)
 {
 	struct source_line *iter;
 	struct rb_node **p = &root->rb_node;
 	struct rb_node *parent = NULL;
 	int i, ret;
 	while (*p != NULL) {
 		parent = *p;
 		iter = rb_entry(parent, struct source_line, node);
 		ret = strcmp(iter->path, src_line->path);
 		if (ret == 0) {
 			for (i = 0; i < src_line->nr_pcnt; i++)
 				iter->p[i].percent_sum += src_line->p[i].percent;
 			return;
 		}
 		if (ret < 0)
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 	}
 	for (i = 0; i < src_line->nr_pcnt; i++)
 		src_line->p[i].percent_sum = src_line->p[i].percent;
 	rb_link_node(&src_line->node, parent, p);
 	rb_insert_color(&src_line->node, root);
 }
 static int cmp_source_line(struct source_line *a, struct source_line *b)
 {
 	int i;
 	for (i = 0; i < a->nr_pcnt; i++) {
 		if (a->p[i].percent_sum == b->p[i].percent_sum)
 			continue;
 		return a->p[i].percent_sum > b->p[i].percent_sum;
 	}
 	return 0;
 }
 static void __resort_source_line(struct rb_root *root, struct source_line *src_line)
 {
 	struct source_line *iter;
 	struct rb_node **p = &root->rb_node;
 	struct rb_node *parent = NULL;
 	while (*p != NULL) {
 		parent = *p;
 		iter = rb_entry(parent, struct source_line, node);
 		if (cmp_source_line(src_line, iter))
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 	}
 	rb_link_node(&src_line->node, parent, p);
 	rb_insert_color(&src_line->node, root);
 }
 static void resort_source_line(struct rb_root *dest_root, struct rb_root *src_root)
 {
 	struct source_line *src_line;
 	struct rb_node *node;
 	node = rb_first(src_root);
 	while (node) {
 		struct rb_node *next;
 		src_line = rb_entry(node, struct source_line, node);
 		next = rb_next(node);
 		rb_erase(node, src_root);
 		__resort_source_line(dest_root, src_line);
 		node = next;
 	}
 }
 static void symbol__free_source_line(struct symbol *sym, int len)
 {
 	struct annotation *notes = symbol__annotation(sym);
 	struct source_line *src_line = notes->src->lines;
 	size_t sizeof_src_line;
 	int i;
 	sizeof_src_line = sizeof(*src_line) +
 			  (sizeof(src_line->p) * (src_line->nr_pcnt - 1));
 	for (i = 0; i < len; i++) {
 		free_srcline(src_line->path);
 		src_line = (void *)src_line + sizeof_src_line;
 	}
 	zfree(&notes->src->lines);
 }
 /* Get the filename:line for the colored entries */
 static int symbol__get_source_line(struct symbol *sym, struct map *map,
 				   struct perf_evsel *evsel,
 				   struct rb_root *root, int len)
 {
 	u64 start;
 	int i, k;
 	int evidx = evsel->idx;
 	struct source_line *src_line;
 	struct annotation *notes = symbol__annotation(sym);
 	struct sym_hist *h = annotation__histogram(notes, evidx);
 	struct rb_root tmp_root = RB_ROOT;
 	int nr_pcnt = 1;
 	u64 h_sum = h->sum;
 	size_t sizeof_src_line = sizeof(struct source_line);
 	if (perf_evsel__is_group_event(evsel)) {
 		for (i = 1; i < evsel->nr_members; i++) {
 			h = annotation__histogram(notes, evidx + i);
 			h_sum += h->sum;
 		}
 		nr_pcnt = evsel->nr_members;
 		sizeof_src_line += (nr_pcnt - 1) * sizeof(src_line->p);
 	}
 	if (!h_sum)
 		return 0;
 	src_line = notes->src->lines = calloc(len, sizeof_src_line);
 	if (!notes->src->lines)
 		return -1;
 	start = map__rip_2objdump(map, sym->start);
 	for (i = 0; i < len; i++) {
 		u64 offset;
 		double percent_max = 0.0;
 		src_line->nr_pcnt = nr_pcnt;
 		for (k = 0; k < nr_pcnt; k++) {
 			h = annotation__histogram(notes, evidx + k);
 			src_line->p[k].percent = 100.0 * h->addr[i] / h->sum;
 			if (src_line->p[k].percent > percent_max)
 				percent_max = src_line->p[k].percent;
 		}
 		if (percent_max <= 0.5)
 			goto next;
 		offset = start + i;
 		src_line->path = get_srcline(map->dso, offset, NULL, false);
 		insert_source_line(&tmp_root, src_line);
 	next:
 		src_line = (void *)src_line + sizeof_src_line;
 	}
 	resort_source_line(root, &tmp_root);
 	return 0;
 }
 static void print_summary(struct rb_root *root, const char *filename)
 {
 	struct source_line *src_line;
 	struct rb_node *node;
 	printf("\nSorted summary for file %s\n", filename);
 	printf("----------------------------------------------\n\n");
 	if (RB_EMPTY_ROOT(root)) {
 		printf(" Nothing higher than %1.1f%%\n", MIN_GREEN);
 		return;
 	}
 	node = rb_first(root);
 	while (node) {
 		double percent, percent_max = 0.0;
 		const char *color;
 		char *path;
 		int i;
 		src_line = rb_entry(node, struct source_line, node);
 		for (i = 0; i < src_line->nr_pcnt; i++) {
 			percent = src_line->p[i].percent_sum;
 			color = get_percent_color(percent);
 			color_fprintf(stdout, color, " %7.2f", percent);
 			if (percent > percent_max)
 				percent_max = percent;
 		}
 		path = src_line->path;
 		color = get_percent_color(percent_max);
 		color_fprintf(stdout, color, " %s\n", path);
 		node = rb_next(node);
 	}
 }
 static void symbol__annotate_hits(struct symbol *sym, struct perf_evsel *evsel)
 {
 	struct annotation *notes = symbol__annotation(sym);
 	struct sym_hist *h = annotation__histogram(notes, evsel->idx);
 	u64 len = symbol__size(sym), offset;
 	for (offset = 0; offset < len; ++offset)
 		if (h->addr[offset] != 0)
 			printf("%*" PRIx64 ": %" PRIu64 "\n", BITS_PER_LONG / 2,
 			       sym->start + offset, h->addr[offset]);
 	printf("%*s: %" PRIu64 "\n", BITS_PER_LONG / 2, "h->sum", h->sum);
 }
 int symbol__annotate_printf(struct symbol *sym, struct map *map,
 			    struct perf_evsel *evsel, bool full_paths,
 			    int min_pcnt, int max_lines, int context)
 {
 	struct dso *dso = map->dso;
 	char *filename;
 	const char *d_filename;
 	const char *evsel_name = perf_evsel__name(evsel);
 	struct annotation *notes = symbol__annotation(sym);
 	struct disasm_line *pos, *queue = NULL;
 	u64 start = map__rip_2objdump(map, sym->start);
 	int printed = 2, queue_len = 0;
 	int more = 0;
 	u64 len;
 	int width = 8;
 	int namelen, evsel_name_len, graph_dotted_len;
 	filename = strdup(dso->long_name);
 	if (!filename)
 		return -ENOMEM;
 	if (full_paths)
 		d_filename = filename;
 	else
 		d_filename = basename(filename);
 	len = symbol__size(sym);
 	namelen = strlen(d_filename);
 	evsel_name_len = strlen(evsel_name);
 	if (perf_evsel__is_group_event(evsel))
 		width *= evsel->nr_members;
 	printf(" %-*.*s|	Source code & Disassembly of %s for %s\n",
 	       width, width, "Percent", d_filename, evsel_name);
 	graph_dotted_len = width + namelen + evsel_name_len;
 	printf("-%-*.*s-----------------------------------------\n",
 	       graph_dotted_len, graph_dotted_len, graph_dotted_line);
 	if (verbose)
 		symbol__annotate_hits(sym, evsel);
 	list_for_each_entry(pos, &notes->src->source, node) {
 		if (context && queue == NULL) {
 			queue = pos;
 			queue_len = 0;
 		}
 		switch (disasm_line__print(pos, sym, start, evsel, len,
 					    min_pcnt, printed, max_lines,
 					    queue)) {
 		case 0:
 			++printed;
 			if (context) {
 				printed += queue_len;
 				queue = NULL;
 				queue_len = 0;
 			}
 			break;
 		case 1:
 			/* filtered by max_lines */
 			++more;
 			break;
 		case -1:
 		default:
 			/*
 			 * Filtered by min_pcnt or non IP lines when
 			 * context != 0
 			 */
 			if (!context)
 				break;
 			if (queue_len == context)
 				queue = list_entry(queue->node.next, typeof(*queue), node);
 			else
 				++queue_len;
 			break;
 		}
 	}
 	free(filename);
 	return more;
 }
 void symbol__annotate_zero_histogram(struct symbol *sym, int evidx)
 {
 	struct annotation *notes = symbol__annotation(sym);
 	struct sym_hist *h = annotation__histogram(notes, evidx);
 	memset(h, 0, notes->src->sizeof_sym_hist);
 }
 void symbol__annotate_decay_histogram(struct symbol *sym, int evidx)
 {
 	struct annotation *notes = symbol__annotation(sym);
 	struct sym_hist *h = annotation__histogram(notes, evidx);
 	int len = symbol__size(sym), offset;
 	h->sum = 0;
 	for (offset = 0; offset < len; ++offset) {
 		h->addr[offset] = h->addr[offset] * 7 / 8;
 		h->sum += h->addr[offset];
 	}
 }
 void disasm__purge(struct list_head *head)
 {
 	struct disasm_line *pos, *n;
 	list_for_each_entry_safe(pos, n, head, node) {
 		list_del(&pos->node);
 		disasm_line__free(pos);
 	}
 }
 static size_t disasm_line__fprintf(struct disasm_line *dl, FILE *fp)
 {
 	size_t printed;
 	if (dl->offset == -1)
 		return fprintf(fp, "%s\n", dl->line);
 	printed = fprintf(fp, "%#" PRIx64 " %s", dl->offset, dl->name);
 	if (dl->ops.raw[0] != '\0') {
 		printed += fprintf(fp, "%.*s %s\n", 6 - (int)printed, " ",
 				   dl->ops.raw);
 	}
 	return printed + fprintf(fp, "\n");
 }
 size_t disasm__fprintf(struct list_head *head, FILE *fp)
 {
 	struct disasm_line *pos;
 	size_t printed = 0;
 	list_for_each_entry(pos, head, node)
 		printed += disasm_line__fprintf(pos, fp);
 	return printed;
 }
 int symbol__tty_annotate(struct symbol *sym, struct map *map,
 			 struct perf_evsel *evsel, bool print_lines,
 			 bool full_paths, int min_pcnt, int max_lines)
 {
 	struct dso *dso = map->dso;
 	struct rb_root source_line = RB_ROOT;
 	u64 len;
 	if (symbol__annotate(sym, map, 0) < 0)
 		return -1;
 	len = symbol__size(sym);
 	if (print_lines) {
 		symbol__get_source_line(sym, map, evsel, &source_line, len);
 		print_summary(&source_line, dso->long_name);
 	}
 	symbol__annotate_printf(sym, map, evsel, full_paths,
 				min_pcnt, max_lines, 0);
 	if (print_lines)
 		symbol__free_source_line(sym, len);
 	disasm__purge(&symbol__annotation(sym)->src->source);
 	return 0;
 }
 int hist_entry__annotate(struct hist_entry *he, size_t privsize)
 {
 	return symbol__annotate(he->ms.sym, he->ms.map, privsize);
 }
 bool ui__has_annotation(void)
 {
 	return use_browser == 1 && sort__has_sym;
 }

tools/perf/util/evlist.c

Diff comments View file @ e742f3d

1	/*	1	/*
2	* Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>	2	* Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
3	*	3	*
4	* Parts came from builtin-{top,stat,record}.c, see those files for further	4	* Parts came from builtin-{top,stat,record}.c, see those files for further
5	* copyright notes.	5	* copyright notes.
6	*	6	*
7	* Released under the GPL v2. (and only v2, not any later version)	7	* Released under the GPL v2. (and only v2, not any later version)
8	*/	8	*/
9	#include "util.h"	9	#include "util.h"
10	#include <api/fs/debugfs.h>	10	#include <api/fs/debugfs.h>
11	#include <api/fs/fs.h>	11	#include <api/fs/fs.h>
12	#include <poll.h>	12	#include <poll.h>
13	#include "cpumap.h"	13	#include "cpumap.h"
14	#include "thread_map.h"	14	#include "thread_map.h"
15	#include "target.h"	15	#include "target.h"
16	#include "evlist.h"	16	#include "evlist.h"
17	#include "evsel.h"	17	#include "evsel.h"
18	#include "debug.h"	18	#include "debug.h"
19	#include <unistd.h>	19	#include <unistd.h>
20		20
21	#include "parse-events.h"	21	#include "parse-events.h"
22	#include "parse-options.h"	22	#include "parse-options.h"
23		23
24	#include <sys/mman.h>	24	#include <sys/mman.h>
25		25
26	#include <linux/bitops.h>	26	#include <linux/bitops.h>
27	#include <linux/hash.h>	27	#include <linux/hash.h>
28	#include <linux/log2.h>	28	#include <linux/log2.h>
29		29
30	static void perf_evlist__mmap_put(struct perf_evlist *evlist, int idx);	30	static void perf_evlist__mmap_put(struct perf_evlist *evlist, int idx);
31	static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx);	31	static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx);
32		32
33	#define FD(e, x, y) ((int )xyarray__entry(e->fd, x, y))	33	#define FD(e, x, y) ((int )xyarray__entry(e->fd, x, y))
34	#define SID(e, x, y) xyarray__entry(e->sample_id, x, y)	34	#define SID(e, x, y) xyarray__entry(e->sample_id, x, y)
35		35
36	void perf_evlist__init(struct perf_evlist evlist, struct cpu_map cpus,	36	void perf_evlist__init(struct perf_evlist evlist, struct cpu_map cpus,
37	struct thread_map *threads)	37	struct thread_map *threads)
38	{	38	{
39	int i;	39	int i;
40		40
41	for (i = 0; i < PERF_EVLIST__HLIST_SIZE; ++i)	41	for (i = 0; i < PERF_EVLIST__HLIST_SIZE; ++i)
42	INIT_HLIST_HEAD(&evlist->heads[i]);	42	INIT_HLIST_HEAD(&evlist->heads[i]);
43	INIT_LIST_HEAD(&evlist->entries);	43	INIT_LIST_HEAD(&evlist->entries);
44	perf_evlist__set_maps(evlist, cpus, threads);	44	perf_evlist__set_maps(evlist, cpus, threads);
45	fdarray__init(&evlist->pollfd, 64);	45	fdarray__init(&evlist->pollfd, 64);
46	evlist->workload.pid = -1;	46	evlist->workload.pid = -1;
47	}	47	}
48		48
49	struct perf_evlist *perf_evlist__new(void)	49	struct perf_evlist *perf_evlist__new(void)
50	{	50	{
51	struct perf_evlist evlist = zalloc(sizeof(evlist));	51	struct perf_evlist evlist = zalloc(sizeof(evlist));
52		52
53	if (evlist != NULL)	53	if (evlist != NULL)
54	perf_evlist__init(evlist, NULL, NULL);	54	perf_evlist__init(evlist, NULL, NULL);
55		55
56	return evlist;	56	return evlist;
57	}	57	}
58		58
59	struct perf_evlist *perf_evlist__new_default(void)	59	struct perf_evlist *perf_evlist__new_default(void)
60	{	60	{
61	struct perf_evlist *evlist = perf_evlist__new();	61	struct perf_evlist *evlist = perf_evlist__new();
62		62
63	if (evlist && perf_evlist__add_default(evlist)) {	63	if (evlist && perf_evlist__add_default(evlist)) {
64	perf_evlist__delete(evlist);	64	perf_evlist__delete(evlist);
65	evlist = NULL;	65	evlist = NULL;
66	}	66	}
67		67
68	return evlist;	68	return evlist;
69	}	69	}
70		70
71	/**	71	/**
72	* perf_evlist__set_id_pos - set the positions of event ids.	72	* perf_evlist__set_id_pos - set the positions of event ids.
73	* @evlist: selected event list	73	* @evlist: selected event list
74	*	74	*
75	* Events with compatible sample types all have the same id_pos	75	* Events with compatible sample types all have the same id_pos
76	* and is_pos. For convenience, put a copy on evlist.	76	* and is_pos. For convenience, put a copy on evlist.
77	*/	77	*/
78	void perf_evlist__set_id_pos(struct perf_evlist *evlist)	78	void perf_evlist__set_id_pos(struct perf_evlist *evlist)
79	{	79	{
80	struct perf_evsel *first = perf_evlist__first(evlist);	80	struct perf_evsel *first = perf_evlist__first(evlist);
81		81
82	evlist->id_pos = first->id_pos;	82	evlist->id_pos = first->id_pos;
83	evlist->is_pos = first->is_pos;	83	evlist->is_pos = first->is_pos;
84	}	84	}
85		85
86	static void perf_evlist__update_id_pos(struct perf_evlist *evlist)	86	static void perf_evlist__update_id_pos(struct perf_evlist *evlist)
87	{	87	{
88	struct perf_evsel *evsel;	88	struct perf_evsel *evsel;
89		89
90	evlist__for_each(evlist, evsel)	90	evlist__for_each(evlist, evsel)
91	perf_evsel__calc_id_pos(evsel);	91	perf_evsel__calc_id_pos(evsel);
92		92
93	perf_evlist__set_id_pos(evlist);	93	perf_evlist__set_id_pos(evlist);
94	}	94	}
95		95
96	static void perf_evlist__purge(struct perf_evlist *evlist)	96	static void perf_evlist__purge(struct perf_evlist *evlist)
97	{	97	{
98	struct perf_evsel pos, n;	98	struct perf_evsel pos, n;
99		99
100	evlist__for_each_safe(evlist, n, pos) {	100	evlist__for_each_safe(evlist, n, pos) {
101	list_del_init(&pos->node);	101	list_del_init(&pos->node);
102	perf_evsel__delete(pos);	102	perf_evsel__delete(pos);
103	}	103	}
104		104
105	evlist->nr_entries = 0;	105	evlist->nr_entries = 0;
106	}	106	}
107		107
108	void perf_evlist__exit(struct perf_evlist *evlist)	108	void perf_evlist__exit(struct perf_evlist *evlist)
109	{	109	{
110	zfree(&evlist->mmap);	110	zfree(&evlist->mmap);
111	fdarray__exit(&evlist->pollfd);	111	fdarray__exit(&evlist->pollfd);
112	}	112	}
113		113
114	void perf_evlist__delete(struct perf_evlist *evlist)	114	void perf_evlist__delete(struct perf_evlist *evlist)
115	{	115	{
116	perf_evlist__munmap(evlist);	116	perf_evlist__munmap(evlist);
117	perf_evlist__close(evlist);	117	perf_evlist__close(evlist);
118	cpu_map__delete(evlist->cpus);	118	cpu_map__delete(evlist->cpus);
119	thread_map__delete(evlist->threads);	119	thread_map__delete(evlist->threads);
120	evlist->cpus = NULL;	120	evlist->cpus = NULL;
121	evlist->threads = NULL;	121	evlist->threads = NULL;
122	perf_evlist__purge(evlist);	122	perf_evlist__purge(evlist);
123	perf_evlist__exit(evlist);	123	perf_evlist__exit(evlist);
124	free(evlist);	124	free(evlist);
125	}	125	}
126		126
127	void perf_evlist__add(struct perf_evlist evlist, struct perf_evsel entry)	127	void perf_evlist__add(struct perf_evlist evlist, struct perf_evsel entry)
128	{	128	{
129	list_add_tail(&entry->node, &evlist->entries);	129	list_add_tail(&entry->node, &evlist->entries);
130	entry->idx = evlist->nr_entries;	130	entry->idx = evlist->nr_entries;
131	entry->tracking = !entry->idx;	131	entry->tracking = !entry->idx;
132		132
133	if (!evlist->nr_entries++)	133	if (!evlist->nr_entries++)
134	perf_evlist__set_id_pos(evlist);	134	perf_evlist__set_id_pos(evlist);
135	}	135	}
136		136
137	void perf_evlist__splice_list_tail(struct perf_evlist *evlist,	137	void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
138	struct list_head *list,	138	struct list_head *list,
139	int nr_entries)	139	int nr_entries)
140	{	140	{
141	bool set_id_pos = !evlist->nr_entries;	141	bool set_id_pos = !evlist->nr_entries;
142		142
143	list_splice_tail(list, &evlist->entries);	143	list_splice_tail(list, &evlist->entries);
144	evlist->nr_entries += nr_entries;	144	evlist->nr_entries += nr_entries;
145	if (set_id_pos)	145	if (set_id_pos)
146	perf_evlist__set_id_pos(evlist);	146	perf_evlist__set_id_pos(evlist);
147	}	147	}
148		148
149	void __perf_evlist__set_leader(struct list_head *list)	149	void __perf_evlist__set_leader(struct list_head *list)
150	{	150	{
151	struct perf_evsel evsel, leader;	151	struct perf_evsel evsel, leader;
152		152
153	leader = list_entry(list->next, struct perf_evsel, node);	153	leader = list_entry(list->next, struct perf_evsel, node);
154	evsel = list_entry(list->prev, struct perf_evsel, node);	154	evsel = list_entry(list->prev, struct perf_evsel, node);
155		155
156	leader->nr_members = evsel->idx - leader->idx + 1;	156	leader->nr_members = evsel->idx - leader->idx + 1;
157		157
158	__evlist__for_each(list, evsel) {	158	__evlist__for_each(list, evsel) {
159	evsel->leader = leader;	159	evsel->leader = leader;
160	}	160	}
161	}	161	}
162		162
163	void perf_evlist__set_leader(struct perf_evlist *evlist)	163	void perf_evlist__set_leader(struct perf_evlist *evlist)
164	{	164	{
165	if (evlist->nr_entries) {	165	if (evlist->nr_entries) {
166	evlist->nr_groups = evlist->nr_entries > 1 ? 1 : 0;	166	evlist->nr_groups = evlist->nr_entries > 1 ? 1 : 0;
167	__perf_evlist__set_leader(&evlist->entries);	167	__perf_evlist__set_leader(&evlist->entries);
168	}	168	}
169	}	169	}
170		170
171	int perf_evlist__add_default(struct perf_evlist *evlist)	171	int perf_evlist__add_default(struct perf_evlist *evlist)
172	{	172	{
173	struct perf_event_attr attr = {	173	struct perf_event_attr attr = {
174	.type = PERF_TYPE_HARDWARE,	174	.type = PERF_TYPE_HARDWARE,
175	.config = PERF_COUNT_HW_CPU_CYCLES,	175	.config = PERF_COUNT_HW_CPU_CYCLES,
176	};	176	};
177	struct perf_evsel *evsel;	177	struct perf_evsel *evsel;
178		178
179	event_attr_init(&attr);	179	event_attr_init(&attr);
180		180
181	evsel = perf_evsel__new(&attr);	181	evsel = perf_evsel__new(&attr);
182	if (evsel == NULL)	182	if (evsel == NULL)
183	goto error;	183	goto error;
184		184
185	/* use strdup() because free(evsel) assumes name is allocated */	185	/* use strdup() because free(evsel) assumes name is allocated */
186	evsel->name = strdup("cycles");	186	evsel->name = strdup("cycles");
187	if (!evsel->name)	187	if (!evsel->name)
188	goto error_free;	188	goto error_free;
189		189
190	perf_evlist__add(evlist, evsel);	190	perf_evlist__add(evlist, evsel);
191	return 0;	191	return 0;
192	error_free:	192	error_free:
193	perf_evsel__delete(evsel);	193	perf_evsel__delete(evsel);
194	error:	194	error:
195	return -ENOMEM;	195	return -ENOMEM;
196	}	196	}
197		197
198	static int perf_evlist__add_attrs(struct perf_evlist *evlist,	198	static int perf_evlist__add_attrs(struct perf_evlist *evlist,
199	struct perf_event_attr *attrs, size_t nr_attrs)	199	struct perf_event_attr *attrs, size_t nr_attrs)
200	{	200	{
201	struct perf_evsel evsel, n;	201	struct perf_evsel evsel, n;
202	LIST_HEAD(head);	202	LIST_HEAD(head);
203	size_t i;	203	size_t i;
204		204
205	for (i = 0; i < nr_attrs; i++) {	205	for (i = 0; i < nr_attrs; i++) {
206	evsel = perf_evsel__new_idx(attrs + i, evlist->nr_entries + i);	206	evsel = perf_evsel__new_idx(attrs + i, evlist->nr_entries + i);
207	if (evsel == NULL)	207	if (evsel == NULL)
208	goto out_delete_partial_list;	208	goto out_delete_partial_list;
209	list_add_tail(&evsel->node, &head);	209	list_add_tail(&evsel->node, &head);
210	}	210	}
211		211
212	perf_evlist__splice_list_tail(evlist, &head, nr_attrs);	212	perf_evlist__splice_list_tail(evlist, &head, nr_attrs);
213		213
214	return 0;	214	return 0;
215		215
216	out_delete_partial_list:	216	out_delete_partial_list:
217	__evlist__for_each_safe(&head, n, evsel)	217	__evlist__for_each_safe(&head, n, evsel)
218	perf_evsel__delete(evsel);	218	perf_evsel__delete(evsel);
219	return -1;	219	return -1;
220	}	220	}
221		221
222	int __perf_evlist__add_default_attrs(struct perf_evlist *evlist,	222	int __perf_evlist__add_default_attrs(struct perf_evlist *evlist,
223	struct perf_event_attr *attrs, size_t nr_attrs)	223	struct perf_event_attr *attrs, size_t nr_attrs)
224	{	224	{
225	size_t i;	225	size_t i;
226		226
227	for (i = 0; i < nr_attrs; i++)	227	for (i = 0; i < nr_attrs; i++)
228	event_attr_init(attrs + i);	228	event_attr_init(attrs + i);
229		229
230	return perf_evlist__add_attrs(evlist, attrs, nr_attrs);	230	return perf_evlist__add_attrs(evlist, attrs, nr_attrs);
231	}	231	}
232		232
233	struct perf_evsel *	233	struct perf_evsel *
234	perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)	234	perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)
235	{	235	{
236	struct perf_evsel *evsel;	236	struct perf_evsel *evsel;
237		237
238	evlist__for_each(evlist, evsel) {	238	evlist__for_each(evlist, evsel) {
239	if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&	239	if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
240	(int)evsel->attr.config == id)	240	(int)evsel->attr.config == id)
241	return evsel;	241	return evsel;
242	}	242	}
243		243
244	return NULL;	244	return NULL;
245	}	245	}
246		246
247	struct perf_evsel *	247	struct perf_evsel *
248	perf_evlist__find_tracepoint_by_name(struct perf_evlist *evlist,	248	perf_evlist__find_tracepoint_by_name(struct perf_evlist *evlist,
249	const char *name)	249	const char *name)
250	{	250	{
251	struct perf_evsel *evsel;	251	struct perf_evsel *evsel;
252		252
253	evlist__for_each(evlist, evsel) {	253	evlist__for_each(evlist, evsel) {
254	if ((evsel->attr.type == PERF_TYPE_TRACEPOINT) &&	254	if ((evsel->attr.type == PERF_TYPE_TRACEPOINT) &&
255	(strcmp(evsel->name, name) == 0))	255	(strcmp(evsel->name, name) == 0))
256	return evsel;	256	return evsel;
257	}	257	}
258		258
259	return NULL;	259	return NULL;
260	}	260	}
261		261
262	int perf_evlist__add_newtp(struct perf_evlist *evlist,	262	int perf_evlist__add_newtp(struct perf_evlist *evlist,
263	const char sys, const char name, void *handler)	263	const char sys, const char name, void *handler)
264	{	264	{
265	struct perf_evsel *evsel = perf_evsel__newtp(sys, name);	265	struct perf_evsel *evsel = perf_evsel__newtp(sys, name);
266		266
267	if (evsel == NULL)	267	if (evsel == NULL)
268	return -1;	268	return -1;
269		269
270	evsel->handler = handler;	270	evsel->handler = handler;
271	perf_evlist__add(evlist, evsel);	271	perf_evlist__add(evlist, evsel);
272	return 0;	272	return 0;
273	}	273	}
274		274
275	static int perf_evlist__nr_threads(struct perf_evlist *evlist,	275	static int perf_evlist__nr_threads(struct perf_evlist *evlist,
276	struct perf_evsel *evsel)	276	struct perf_evsel *evsel)
277	{	277	{
278	if (evsel->system_wide)	278	if (evsel->system_wide)
279	return 1;	279	return 1;
280	else	280	else
281	return thread_map__nr(evlist->threads);	281	return thread_map__nr(evlist->threads);
282	}	282	}
283		283
284	void perf_evlist__disable(struct perf_evlist *evlist)	284	void perf_evlist__disable(struct perf_evlist *evlist)
285	{	285	{
286	int cpu, thread;	286	int cpu, thread;
287	struct perf_evsel *pos;	287	struct perf_evsel *pos;
288	int nr_cpus = cpu_map__nr(evlist->cpus);	288	int nr_cpus = cpu_map__nr(evlist->cpus);
289	int nr_threads;	289	int nr_threads;
290		290
291	for (cpu = 0; cpu < nr_cpus; cpu++) {	291	for (cpu = 0; cpu < nr_cpus; cpu++) {
292	evlist__for_each(evlist, pos) {	292	evlist__for_each(evlist, pos) {
293	if (!perf_evsel__is_group_leader(pos) \|\| !pos->fd)	293	if (!perf_evsel__is_group_leader(pos) \|\| !pos->fd)
294	continue;	294	continue;
295	nr_threads = perf_evlist__nr_threads(evlist, pos);	295	nr_threads = perf_evlist__nr_threads(evlist, pos);
296	for (thread = 0; thread < nr_threads; thread++)	296	for (thread = 0; thread < nr_threads; thread++)
297	ioctl(FD(pos, cpu, thread),	297	ioctl(FD(pos, cpu, thread),
298	PERF_EVENT_IOC_DISABLE, 0);	298	PERF_EVENT_IOC_DISABLE, 0);
299	}	299	}
300	}	300	}
301	}	301	}
302		302
303	void perf_evlist__enable(struct perf_evlist *evlist)	303	void perf_evlist__enable(struct perf_evlist *evlist)
304	{	304	{
305	int cpu, thread;	305	int cpu, thread;
306	struct perf_evsel *pos;	306	struct perf_evsel *pos;
307	int nr_cpus = cpu_map__nr(evlist->cpus);	307	int nr_cpus = cpu_map__nr(evlist->cpus);
308	int nr_threads;	308	int nr_threads;
309		309
310	for (cpu = 0; cpu < nr_cpus; cpu++) {	310	for (cpu = 0; cpu < nr_cpus; cpu++) {
311	evlist__for_each(evlist, pos) {	311	evlist__for_each(evlist, pos) {
312	if (!perf_evsel__is_group_leader(pos) \|\| !pos->fd)	312	if (!perf_evsel__is_group_leader(pos) \|\| !pos->fd)
313	continue;	313	continue;
314	nr_threads = perf_evlist__nr_threads(evlist, pos);	314	nr_threads = perf_evlist__nr_threads(evlist, pos);
315	for (thread = 0; thread < nr_threads; thread++)	315	for (thread = 0; thread < nr_threads; thread++)
316	ioctl(FD(pos, cpu, thread),	316	ioctl(FD(pos, cpu, thread),
317	PERF_EVENT_IOC_ENABLE, 0);	317	PERF_EVENT_IOC_ENABLE, 0);
318	}	318	}
319	}	319	}
320	}	320	}
321		321
322	int perf_evlist__disable_event(struct perf_evlist *evlist,	322	int perf_evlist__disable_event(struct perf_evlist *evlist,
323	struct perf_evsel *evsel)	323	struct perf_evsel *evsel)
324	{	324	{
325	int cpu, thread, err;	325	int cpu, thread, err;
326	int nr_cpus = cpu_map__nr(evlist->cpus);	326	int nr_cpus = cpu_map__nr(evlist->cpus);
327	int nr_threads = perf_evlist__nr_threads(evlist, evsel);	327	int nr_threads = perf_evlist__nr_threads(evlist, evsel);
328		328
329	if (!evsel->fd)	329	if (!evsel->fd)
330	return 0;	330	return 0;
331		331
332	for (cpu = 0; cpu < nr_cpus; cpu++) {	332	for (cpu = 0; cpu < nr_cpus; cpu++) {
333	for (thread = 0; thread < nr_threads; thread++) {	333	for (thread = 0; thread < nr_threads; thread++) {
334	err = ioctl(FD(evsel, cpu, thread),	334	err = ioctl(FD(evsel, cpu, thread),
335	PERF_EVENT_IOC_DISABLE, 0);	335	PERF_EVENT_IOC_DISABLE, 0);
336	if (err)	336	if (err)
337	return err;	337	return err;
338	}	338	}
339	}	339	}
340	return 0;	340	return 0;
341	}	341	}
342		342
343	int perf_evlist__enable_event(struct perf_evlist *evlist,	343	int perf_evlist__enable_event(struct perf_evlist *evlist,
344	struct perf_evsel *evsel)	344	struct perf_evsel *evsel)
345	{	345	{
346	int cpu, thread, err;	346	int cpu, thread, err;
347	int nr_cpus = cpu_map__nr(evlist->cpus);	347	int nr_cpus = cpu_map__nr(evlist->cpus);
348	int nr_threads = perf_evlist__nr_threads(evlist, evsel);	348	int nr_threads = perf_evlist__nr_threads(evlist, evsel);
349		349
350	if (!evsel->fd)	350	if (!evsel->fd)
351	return -EINVAL;	351	return -EINVAL;
352		352
353	for (cpu = 0; cpu < nr_cpus; cpu++) {	353	for (cpu = 0; cpu < nr_cpus; cpu++) {
354	for (thread = 0; thread < nr_threads; thread++) {	354	for (thread = 0; thread < nr_threads; thread++) {
355	err = ioctl(FD(evsel, cpu, thread),	355	err = ioctl(FD(evsel, cpu, thread),
356	PERF_EVENT_IOC_ENABLE, 0);	356	PERF_EVENT_IOC_ENABLE, 0);
357	if (err)	357	if (err)
358	return err;	358	return err;
359	}	359	}
360	}	360	}
361	return 0;	361	return 0;
362	}	362	}
363		363
364	static int perf_evlist__enable_event_cpu(struct perf_evlist *evlist,	364	static int perf_evlist__enable_event_cpu(struct perf_evlist *evlist,
365	struct perf_evsel *evsel, int cpu)	365	struct perf_evsel *evsel, int cpu)
366	{	366	{
367	int thread, err;	367	int thread, err;
368	int nr_threads = perf_evlist__nr_threads(evlist, evsel);	368	int nr_threads = perf_evlist__nr_threads(evlist, evsel);
369		369
370	if (!evsel->fd)	370	if (!evsel->fd)
371	return -EINVAL;	371	return -EINVAL;
372		372
373	for (thread = 0; thread < nr_threads; thread++) {	373	for (thread = 0; thread < nr_threads; thread++) {
374	err = ioctl(FD(evsel, cpu, thread),	374	err = ioctl(FD(evsel, cpu, thread),
375	PERF_EVENT_IOC_ENABLE, 0);	375	PERF_EVENT_IOC_ENABLE, 0);
376	if (err)	376	if (err)
377	return err;	377	return err;
378	}	378	}
379	return 0;	379	return 0;
380	}	380	}
381		381
382	static int perf_evlist__enable_event_thread(struct perf_evlist *evlist,	382	static int perf_evlist__enable_event_thread(struct perf_evlist *evlist,
383	struct perf_evsel *evsel,	383	struct perf_evsel *evsel,
384	int thread)	384	int thread)
385	{	385	{
386	int cpu, err;	386	int cpu, err;
387	int nr_cpus = cpu_map__nr(evlist->cpus);	387	int nr_cpus = cpu_map__nr(evlist->cpus);
388		388
389	if (!evsel->fd)	389	if (!evsel->fd)
390	return -EINVAL;	390	return -EINVAL;
391		391
392	for (cpu = 0; cpu < nr_cpus; cpu++) {	392	for (cpu = 0; cpu < nr_cpus; cpu++) {
393	err = ioctl(FD(evsel, cpu, thread), PERF_EVENT_IOC_ENABLE, 0);	393	err = ioctl(FD(evsel, cpu, thread), PERF_EVENT_IOC_ENABLE, 0);
394	if (err)	394	if (err)
395	return err;	395	return err;
396	}	396	}
397	return 0;	397	return 0;
398	}	398	}
399		399
400	int perf_evlist__enable_event_idx(struct perf_evlist *evlist,	400	int perf_evlist__enable_event_idx(struct perf_evlist *evlist,
401	struct perf_evsel *evsel, int idx)	401	struct perf_evsel *evsel, int idx)
402	{	402	{
403	bool per_cpu_mmaps = !cpu_map__empty(evlist->cpus);	403	bool per_cpu_mmaps = !cpu_map__empty(evlist->cpus);
404		404
405	if (per_cpu_mmaps)	405	if (per_cpu_mmaps)
406	return perf_evlist__enable_event_cpu(evlist, evsel, idx);	406	return perf_evlist__enable_event_cpu(evlist, evsel, idx);
407	else	407	else
408	return perf_evlist__enable_event_thread(evlist, evsel, idx);	408	return perf_evlist__enable_event_thread(evlist, evsel, idx);
409	}	409	}
410		410
411	int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)	411	int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
412	{	412	{
413	int nr_cpus = cpu_map__nr(evlist->cpus);	413	int nr_cpus = cpu_map__nr(evlist->cpus);
414	int nr_threads = thread_map__nr(evlist->threads);	414	int nr_threads = thread_map__nr(evlist->threads);
415	int nfds = 0;	415	int nfds = 0;
416	struct perf_evsel *evsel;	416	struct perf_evsel *evsel;
417		417
418	evlist__for_each(evlist, evsel) {	418	evlist__for_each(evlist, evsel) {
419	if (evsel->system_wide)	419	if (evsel->system_wide)
420	nfds += nr_cpus;	420	nfds += nr_cpus;
421	else	421	else
422	nfds += nr_cpus * nr_threads;	422	nfds += nr_cpus * nr_threads;
423	}	423	}
424		424
425	if (fdarray__available_entries(&evlist->pollfd) < nfds &&	425	if (fdarray__available_entries(&evlist->pollfd) < nfds &&
426	fdarray__grow(&evlist->pollfd, nfds) < 0)	426	fdarray__grow(&evlist->pollfd, nfds) < 0)
427	return -ENOMEM;	427	return -ENOMEM;
428		428
429	return 0;	429	return 0;
430	}	430	}
431		431
432	static int __perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd, int idx)	432	static int __perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd, int idx)
433	{	433	{
434	int pos = fdarray__add(&evlist->pollfd, fd, POLLIN \| POLLERR \| POLLHUP);	434	int pos = fdarray__add(&evlist->pollfd, fd, POLLIN \| POLLERR \| POLLHUP);
435	/*	435	/*
436	* Save the idx so that when we filter out fds POLLHUP'ed we can	436	* Save the idx so that when we filter out fds POLLHUP'ed we can
437	* close the associated evlist->mmap[] entry.	437	* close the associated evlist->mmap[] entry.
438	*/	438	*/
439	if (pos >= 0) {	439	if (pos >= 0) {
440	evlist->pollfd.priv[pos].idx = idx;	440	evlist->pollfd.priv[pos].idx = idx;
441		441
442	fcntl(fd, F_SETFL, O_NONBLOCK);	442	fcntl(fd, F_SETFL, O_NONBLOCK);
443	}	443	}
444		444
445	return pos;	445	return pos;
446	}	446	}
447		447
448	int perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)	448	int perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)
449	{	449	{
450	return __perf_evlist__add_pollfd(evlist, fd, -1);	450	return __perf_evlist__add_pollfd(evlist, fd, -1);
451	}	451	}
452		452
453	static void perf_evlist__munmap_filtered(struct fdarray *fda, int fd)	453	static void perf_evlist__munmap_filtered(struct fdarray *fda, int fd)
454	{	454	{
455	struct perf_evlist *evlist = container_of(fda, struct perf_evlist, pollfd);	455	struct perf_evlist *evlist = container_of(fda, struct perf_evlist, pollfd);
456		456
457	perf_evlist__mmap_put(evlist, fda->priv[fd].idx);	457	perf_evlist__mmap_put(evlist, fda->priv[fd].idx);
458	}	458	}
459		459
460	int perf_evlist__filter_pollfd(struct perf_evlist *evlist, short revents_and_mask)	460	int perf_evlist__filter_pollfd(struct perf_evlist *evlist, short revents_and_mask)
461	{	461	{
462	return fdarray__filter(&evlist->pollfd, revents_and_mask,	462	return fdarray__filter(&evlist->pollfd, revents_and_mask,
463	perf_evlist__munmap_filtered);	463	perf_evlist__munmap_filtered);
464	}	464	}
465		465
466	int perf_evlist__poll(struct perf_evlist *evlist, int timeout)	466	int perf_evlist__poll(struct perf_evlist *evlist, int timeout)
467	{	467	{
468	return fdarray__poll(&evlist->pollfd, timeout);	468	return fdarray__poll(&evlist->pollfd, timeout);
469	}	469	}
470		470
471	static void perf_evlist__id_hash(struct perf_evlist *evlist,	471	static void perf_evlist__id_hash(struct perf_evlist *evlist,
472	struct perf_evsel *evsel,	472	struct perf_evsel *evsel,
473	int cpu, int thread, u64 id)	473	int cpu, int thread, u64 id)
474	{	474	{
475	int hash;	475	int hash;
476	struct perf_sample_id *sid = SID(evsel, cpu, thread);	476	struct perf_sample_id *sid = SID(evsel, cpu, thread);
477		477
478	sid->id = id;	478	sid->id = id;
479	sid->evsel = evsel;	479	sid->evsel = evsel;
480	hash = hash_64(sid->id, PERF_EVLIST__HLIST_BITS);	480	hash = hash_64(sid->id, PERF_EVLIST__HLIST_BITS);
481	hlist_add_head(&sid->node, &evlist->heads[hash]);	481	hlist_add_head(&sid->node, &evlist->heads[hash]);
482	}	482	}
483		483
484	void perf_evlist__id_add(struct perf_evlist evlist, struct perf_evsel evsel,	484	void perf_evlist__id_add(struct perf_evlist evlist, struct perf_evsel evsel,
485	int cpu, int thread, u64 id)	485	int cpu, int thread, u64 id)
486	{	486	{
487	perf_evlist__id_hash(evlist, evsel, cpu, thread, id);	487	perf_evlist__id_hash(evlist, evsel, cpu, thread, id);
488	evsel->id[evsel->ids++] = id;	488	evsel->id[evsel->ids++] = id;
489	}	489	}
490		490
491	static int perf_evlist__id_add_fd(struct perf_evlist *evlist,	491	static int perf_evlist__id_add_fd(struct perf_evlist *evlist,
492	struct perf_evsel *evsel,	492	struct perf_evsel *evsel,
493	int cpu, int thread, int fd)	493	int cpu, int thread, int fd)
494	{	494	{
495	u64 read_data[4] = { 0, };	495	u64 read_data[4] = { 0, };
496	int id_idx = 1; /* The first entry is the counter value */	496	int id_idx = 1; /* The first entry is the counter value */
497	u64 id;	497	u64 id;
498	int ret;	498	int ret;
499		499
500	ret = ioctl(fd, PERF_EVENT_IOC_ID, &id);	500	ret = ioctl(fd, PERF_EVENT_IOC_ID, &id);
501	if (!ret)	501	if (!ret)
502	goto add;	502	goto add;
503		503
504	if (errno != ENOTTY)	504	if (errno != ENOTTY)
505	return -1;	505	return -1;
506		506
507	/* Legacy way to get event id.. All hail to old kernels! */	507	/* Legacy way to get event id.. All hail to old kernels! */
508		508
509	/*	509	/*
510	* This way does not work with group format read, so bail	510	* This way does not work with group format read, so bail
511	* out in that case.	511	* out in that case.
512	*/	512	*/
513	if (perf_evlist__read_format(evlist) & PERF_FORMAT_GROUP)	513	if (perf_evlist__read_format(evlist) & PERF_FORMAT_GROUP)
514	return -1;	514	return -1;
515		515
516	if (!(evsel->attr.read_format & PERF_FORMAT_ID) \|\|	516	if (!(evsel->attr.read_format & PERF_FORMAT_ID) \|\|
517	read(fd, &read_data, sizeof(read_data)) == -1)	517	read(fd, &read_data, sizeof(read_data)) == -1)
518	return -1;	518	return -1;
519		519
520	if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)	520	if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
521	++id_idx;	521	++id_idx;
522	if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)	522	if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
523	++id_idx;	523	++id_idx;
524		524
525	id = read_data[id_idx];	525	id = read_data[id_idx];
526		526
527	add:	527	add:
528	perf_evlist__id_add(evlist, evsel, cpu, thread, id);	528	perf_evlist__id_add(evlist, evsel, cpu, thread, id);
529	return 0;	529	return 0;
530	}	530	}
531		531
532	static void perf_evlist__set_sid_idx(struct perf_evlist *evlist,	532	static void perf_evlist__set_sid_idx(struct perf_evlist *evlist,
533	struct perf_evsel *evsel, int idx, int cpu,	533	struct perf_evsel *evsel, int idx, int cpu,
534	int thread)	534	int thread)
535	{	535	{
536	struct perf_sample_id *sid = SID(evsel, cpu, thread);	536	struct perf_sample_id *sid = SID(evsel, cpu, thread);
537	sid->idx = idx;	537	sid->idx = idx;
538	if (evlist->cpus && cpu >= 0)	538	if (evlist->cpus && cpu >= 0)
539	sid->cpu = evlist->cpus->map[cpu];	539	sid->cpu = evlist->cpus->map[cpu];
540	else	540	else
541	sid->cpu = -1;	541	sid->cpu = -1;
542	if (!evsel->system_wide && evlist->threads && thread >= 0)	542	if (!evsel->system_wide && evlist->threads && thread >= 0)
543	sid->tid = evlist->threads->map[thread];	543	sid->tid = evlist->threads->map[thread];
544	else	544	else
545	sid->tid = -1;	545	sid->tid = -1;
546	}	546	}
547		547
548	struct perf_sample_id perf_evlist__id2sid(struct perf_evlist evlist, u64 id)	548	struct perf_sample_id perf_evlist__id2sid(struct perf_evlist evlist, u64 id)
549	{	549	{
550	struct hlist_head *head;	550	struct hlist_head *head;
551	struct perf_sample_id *sid;	551	struct perf_sample_id *sid;
552	int hash;	552	int hash;
553		553
554	hash = hash_64(id, PERF_EVLIST__HLIST_BITS);	554	hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
555	head = &evlist->heads[hash];	555	head = &evlist->heads[hash];
556		556
557	hlist_for_each_entry(sid, head, node)	557	hlist_for_each_entry(sid, head, node)
558	if (sid->id == id)	558	if (sid->id == id)
559	return sid;	559	return sid;
560		560
561	return NULL;	561	return NULL;
562	}	562	}
563		563
564	struct perf_evsel perf_evlist__id2evsel(struct perf_evlist evlist, u64 id)	564	struct perf_evsel perf_evlist__id2evsel(struct perf_evlist evlist, u64 id)
565	{	565	{
566	struct perf_sample_id *sid;	566	struct perf_sample_id *sid;
567		567
568	if (evlist->nr_entries == 1)	568	if (evlist->nr_entries == 1)
569	return perf_evlist__first(evlist);	569	return perf_evlist__first(evlist);
570		570
571	sid = perf_evlist__id2sid(evlist, id);	571	sid = perf_evlist__id2sid(evlist, id);
572	if (sid)	572	if (sid)
573	return sid->evsel;	573	return sid->evsel;
574		574
575	if (!perf_evlist__sample_id_all(evlist))	575	if (!perf_evlist__sample_id_all(evlist))
576	return perf_evlist__first(evlist);	576	return perf_evlist__first(evlist);
577		577
578	return NULL;	578	return NULL;
579	}	579	}
580		580
581	static int perf_evlist__event2id(struct perf_evlist *evlist,	581	static int perf_evlist__event2id(struct perf_evlist *evlist,
582	union perf_event event, u64 id)	582	union perf_event event, u64 id)
583	{	583	{
584	const u64 *array = event->sample.array;	584	const u64 *array = event->sample.array;
585	ssize_t n;	585	ssize_t n;
586		586
587	n = (event->header.size - sizeof(event->header)) >> 3;	587	n = (event->header.size - sizeof(event->header)) >> 3;
588		588
589	if (event->header.type == PERF_RECORD_SAMPLE) {	589	if (event->header.type == PERF_RECORD_SAMPLE) {
590	if (evlist->id_pos >= n)	590	if (evlist->id_pos >= n)
591	return -1;	591	return -1;
592	*id = array[evlist->id_pos];	592	*id = array[evlist->id_pos];
593	} else {	593	} else {
594	if (evlist->is_pos > n)	594	if (evlist->is_pos > n)
595	return -1;	595	return -1;
596	n -= evlist->is_pos;	596	n -= evlist->is_pos;
597	*id = array[n];	597	*id = array[n];
598	}	598	}
599	return 0;	599	return 0;
600	}	600	}
601		601
602	static struct perf_evsel perf_evlist__event2evsel(struct perf_evlist evlist,	602	static struct perf_evsel perf_evlist__event2evsel(struct perf_evlist evlist,
603	union perf_event *event)	603	union perf_event *event)
604	{	604	{
605	struct perf_evsel *first = perf_evlist__first(evlist);	605	struct perf_evsel *first = perf_evlist__first(evlist);
606	struct hlist_head *head;	606	struct hlist_head *head;
607	struct perf_sample_id *sid;	607	struct perf_sample_id *sid;
608	int hash;	608	int hash;
609	u64 id;	609	u64 id;
610		610
611	if (evlist->nr_entries == 1)	611	if (evlist->nr_entries == 1)
612	return first;	612	return first;
613		613
614	if (!first->attr.sample_id_all &&	614	if (!first->attr.sample_id_all &&
615	event->header.type != PERF_RECORD_SAMPLE)	615	event->header.type != PERF_RECORD_SAMPLE)
616	return first;	616	return first;
617		617
618	if (perf_evlist__event2id(evlist, event, &id))	618	if (perf_evlist__event2id(evlist, event, &id))
619	return NULL;	619	return NULL;
620		620
621	/* Synthesized events have an id of zero */	621	/* Synthesized events have an id of zero */
622	if (!id)	622	if (!id)
623	return first;	623	return first;
624		624
625	hash = hash_64(id, PERF_EVLIST__HLIST_BITS);	625	hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
626	head = &evlist->heads[hash];	626	head = &evlist->heads[hash];
627		627
628	hlist_for_each_entry(sid, head, node) {	628	hlist_for_each_entry(sid, head, node) {
629	if (sid->id == id)	629	if (sid->id == id)
630	return sid->evsel;	630	return sid->evsel;
631	}	631	}
632	return NULL;	632	return NULL;
633	}	633	}
634		634
635	union perf_event perf_evlist__mmap_read(struct perf_evlist evlist, int idx)	635	union perf_event perf_evlist__mmap_read(struct perf_evlist evlist, int idx)
636	{	636	{
637	struct perf_mmap *md = &evlist->mmap[idx];	637	struct perf_mmap *md = &evlist->mmap[idx];
638	unsigned int head = perf_mmap__read_head(md);	638	unsigned int head = perf_mmap__read_head(md);
639	unsigned int old = md->prev;	639	unsigned int old = md->prev;
640	unsigned char *data = md->base + page_size;	640	unsigned char *data = md->base + page_size;
641	union perf_event *event = NULL;	641	union perf_event *event = NULL;
642		642
643	if (evlist->overwrite) {	643	if (evlist->overwrite) {
644	/*	644	/*
645	* If we're further behind than half the buffer, there's a chance	645	* If we're further behind than half the buffer, there's a chance
646	* the writer will bite our tail and mess up the samples under us.	646	* the writer will bite our tail and mess up the samples under us.
647	*	647	*
648	* If we somehow ended up ahead of the head, we got messed up.	648	* If we somehow ended up ahead of the head, we got messed up.
649	*	649	*
650	* In either case, truncate and restart at head.	650	* In either case, truncate and restart at head.
651	*/	651	*/
652	int diff = head - old;	652	int diff = head - old;
653	if (diff > md->mask / 2 \|\| diff < 0) {	653	if (diff > md->mask / 2 \|\| diff < 0) {
654	fprintf(stderr, "WARNING: failed to keep up with mmap data.\n");	654	fprintf(stderr, "WARNING: failed to keep up with mmap data.\n");
655		655
656	/*	656	/*
657	* head points to a known good entry, start there.	657	* head points to a known good entry, start there.
658	*/	658	*/
659	old = head;	659	old = head;
660	}	660	}
661	}	661	}
662		662
663	if (old != head) {	663	if (old != head) {
664	size_t size;	664	size_t size;
665		665
666	event = (union perf_event *)&data[old & md->mask];	666	event = (union perf_event *)&data[old & md->mask];
667	size = event->header.size;	667	size = event->header.size;
668		668
669	/*	669	/*
670	* Event straddles the mmap boundary -- header should always	670	* Event straddles the mmap boundary -- header should always
671	* be inside due to u64 alignment of output.	671	* be inside due to u64 alignment of output.
672	*/	672	*/
673	if ((old & md->mask) + size != ((old + size) & md->mask)) {	673	if ((old & md->mask) + size != ((old + size) & md->mask)) {
674	unsigned int offset = old;	674	unsigned int offset = old;
675	unsigned int len = min(sizeof(*event), size), cpy;	675	unsigned int len = min(sizeof(*event), size), cpy;
676	void *dst = md->event_copy;	676	void *dst = md->event_copy;
677		677
678	do {	678	do {
679	cpy = min(md->mask + 1 - (offset & md->mask), len);	679	cpy = min(md->mask + 1 - (offset & md->mask), len);
680	memcpy(dst, &data[offset & md->mask], cpy);	680	memcpy(dst, &data[offset & md->mask], cpy);
681	offset += cpy;	681	offset += cpy;
682	dst += cpy;	682	dst += cpy;
683	len -= cpy;	683	len -= cpy;
684	} while (len);	684	} while (len);
685		685
686	event = (union perf_event *) md->event_copy;	686	event = (union perf_event *) md->event_copy;
687	}	687	}
688		688
689	old += size;	689	old += size;
690	}	690	}
691		691
692	md->prev = old;	692	md->prev = old;
693		693
694	return event;	694	return event;
695	}	695	}
696		696
697	static bool perf_mmap__empty(struct perf_mmap *md)	697	static bool perf_mmap__empty(struct perf_mmap *md)
698	{	698	{
699	return perf_mmap__read_head(md) != md->prev;	699	return perf_mmap__read_head(md) != md->prev;
700	}	700	}
701		701
702	static void perf_evlist__mmap_get(struct perf_evlist *evlist, int idx)	702	static void perf_evlist__mmap_get(struct perf_evlist *evlist, int idx)
703	{	703	{
704	++evlist->mmap[idx].refcnt;	704	++evlist->mmap[idx].refcnt;
705	}	705	}
706		706
707	static void perf_evlist__mmap_put(struct perf_evlist *evlist, int idx)	707	static void perf_evlist__mmap_put(struct perf_evlist *evlist, int idx)
708	{	708	{
709	BUG_ON(evlist->mmap[idx].refcnt == 0);	709	BUG_ON(evlist->mmap[idx].refcnt == 0);
710		710
711	if (--evlist->mmap[idx].refcnt == 0)	711	if (--evlist->mmap[idx].refcnt == 0)
712	__perf_evlist__munmap(evlist, idx);	712	__perf_evlist__munmap(evlist, idx);
713	}	713	}
714		714
715	void perf_evlist__mmap_consume(struct perf_evlist *evlist, int idx)	715	void perf_evlist__mmap_consume(struct perf_evlist *evlist, int idx)
716	{	716	{
717	struct perf_mmap *md = &evlist->mmap[idx];	717	struct perf_mmap *md = &evlist->mmap[idx];
718		718
719	if (!evlist->overwrite) {	719	if (!evlist->overwrite) {
720	unsigned int old = md->prev;	720	unsigned int old = md->prev;
721		721
722	perf_mmap__write_tail(md, old);	722	perf_mmap__write_tail(md, old);
723	}	723	}
724		724
725	if (md->refcnt == 1 && perf_mmap__empty(md))	725	if (md->refcnt == 1 && perf_mmap__empty(md))
726	perf_evlist__mmap_put(evlist, idx);	726	perf_evlist__mmap_put(evlist, idx);
727	}	727	}
728		728
729	static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx)	729	static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx)
730	{	730	{
731	if (evlist->mmap[idx].base != NULL) {	731	if (evlist->mmap[idx].base != NULL) {
732	munmap(evlist->mmap[idx].base, evlist->mmap_len);	732	munmap(evlist->mmap[idx].base, evlist->mmap_len);
733	evlist->mmap[idx].base = NULL;	733	evlist->mmap[idx].base = NULL;
734	evlist->mmap[idx].refcnt = 0;	734	evlist->mmap[idx].refcnt = 0;
735	}	735	}
736	}	736	}
737		737
738	void perf_evlist__munmap(struct perf_evlist *evlist)	738	void perf_evlist__munmap(struct perf_evlist *evlist)
739	{	739	{
740	int i;	740	int i;
741		741
742	if (evlist->mmap == NULL)	742	if (evlist->mmap == NULL)
743	return;	743	return;
744		744
745	for (i = 0; i < evlist->nr_mmaps; i++)	745	for (i = 0; i < evlist->nr_mmaps; i++)
746	__perf_evlist__munmap(evlist, i);	746	__perf_evlist__munmap(evlist, i);
747		747
748	zfree(&evlist->mmap);	748	zfree(&evlist->mmap);
749	}	749	}
750		750
751	static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)	751	static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
752	{	752	{
753	evlist->nr_mmaps = cpu_map__nr(evlist->cpus);	753	evlist->nr_mmaps = cpu_map__nr(evlist->cpus);
754	if (cpu_map__empty(evlist->cpus))	754	if (cpu_map__empty(evlist->cpus))
755	evlist->nr_mmaps = thread_map__nr(evlist->threads);	755	evlist->nr_mmaps = thread_map__nr(evlist->threads);
756	evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));	756	evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
757	return evlist->mmap != NULL ? 0 : -ENOMEM;	757	return evlist->mmap != NULL ? 0 : -ENOMEM;
758	}	758	}
759		759
760	struct mmap_params {	760	struct mmap_params {
761	int prot;	761	int prot;
762	int mask;	762	int mask;
763	};	763	};
764		764
765	static int __perf_evlist__mmap(struct perf_evlist *evlist, int idx,	765	static int __perf_evlist__mmap(struct perf_evlist *evlist, int idx,
766	struct mmap_params *mp, int fd)	766	struct mmap_params *mp, int fd)
767	{	767	{
768	/*	768	/*
769	* The last one will be done at perf_evlist__mmap_consume(), so that we	769	* The last one will be done at perf_evlist__mmap_consume(), so that we
770	* make sure we don't prevent tools from consuming every last event in	770	* make sure we don't prevent tools from consuming every last event in
771	* the ring buffer.	771	* the ring buffer.
772	*	772	*
773	* I.e. we can get the POLLHUP meaning that the fd doesn't exist	773	* I.e. we can get the POLLHUP meaning that the fd doesn't exist
774	* anymore, but the last events for it are still in the ring buffer,	774	* anymore, but the last events for it are still in the ring buffer,
775	* waiting to be consumed.	775	* waiting to be consumed.
776	*	776	*
777	* Tools can chose to ignore this at their own discretion, but the	777	* Tools can chose to ignore this at their own discretion, but the
778	* evlist layer can't just drop it when filtering events in	778	* evlist layer can't just drop it when filtering events in
779	* perf_evlist__filter_pollfd().	779	* perf_evlist__filter_pollfd().
780	*/	780	*/
781	evlist->mmap[idx].refcnt = 2;	781	evlist->mmap[idx].refcnt = 2;
782	evlist->mmap[idx].prev = 0;	782	evlist->mmap[idx].prev = 0;
783	evlist->mmap[idx].mask = mp->mask;	783	evlist->mmap[idx].mask = mp->mask;
784	evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, mp->prot,	784	evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, mp->prot,
785	MAP_SHARED, fd, 0);	785	MAP_SHARED, fd, 0);
786	if (evlist->mmap[idx].base == MAP_FAILED) {	786	if (evlist->mmap[idx].base == MAP_FAILED) {
787	pr_debug2("failed to mmap perf event ring buffer, error %d\n",	787	pr_debug2("failed to mmap perf event ring buffer, error %d\n",
788	errno);	788	errno);
789	evlist->mmap[idx].base = NULL;	789	evlist->mmap[idx].base = NULL;
790	return -1;	790	return -1;
791	}	791	}
792		792
793	return 0;	793	return 0;
794	}	794	}
795		795
796	static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx,	796	static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx,
797	struct mmap_params *mp, int cpu,	797	struct mmap_params *mp, int cpu,
798	int thread, int *output)	798	int thread, int *output)
799	{	799	{
800	struct perf_evsel *evsel;	800	struct perf_evsel *evsel;
801		801
802	evlist__for_each(evlist, evsel) {	802	evlist__for_each(evlist, evsel) {
803	int fd;	803	int fd;
804		804
805	if (evsel->system_wide && thread)	805	if (evsel->system_wide && thread)
806	continue;	806	continue;
807		807
808	fd = FD(evsel, cpu, thread);	808	fd = FD(evsel, cpu, thread);
809		809
810	if (*output == -1) {	810	if (*output == -1) {
811	*output = fd;	811	*output = fd;
812	if (__perf_evlist__mmap(evlist, idx, mp, *output) < 0)	812	if (__perf_evlist__mmap(evlist, idx, mp, *output) < 0)
813	return -1;	813	return -1;
814	} else {	814	} else {
815	if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, *output) != 0)	815	if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, *output) != 0)
816	return -1;	816	return -1;
817		817
818	perf_evlist__mmap_get(evlist, idx);	818	perf_evlist__mmap_get(evlist, idx);
819	}	819	}
820		820
821	/*	821	/*
822	* The system_wide flag causes a selected event to be opened	822	* The system_wide flag causes a selected event to be opened
823	* always without a pid. Consequently it will never get a	823	* always without a pid. Consequently it will never get a
824	* POLLHUP, but it is used for tracking in combination with	824	* POLLHUP, but it is used for tracking in combination with
825	* other events, so it should not need to be polled anyway.	825	* other events, so it should not need to be polled anyway.
826	* Therefore don't add it for polling.	826	* Therefore don't add it for polling.
827	*/	827	*/
828	if (!evsel->system_wide &&	828	if (!evsel->system_wide &&
829	__perf_evlist__add_pollfd(evlist, fd, idx) < 0) {	829	__perf_evlist__add_pollfd(evlist, fd, idx) < 0) {
830	perf_evlist__mmap_put(evlist, idx);	830	perf_evlist__mmap_put(evlist, idx);
831	return -1;	831	return -1;
832	}	832	}
833		833
834	if (evsel->attr.read_format & PERF_FORMAT_ID) {	834	if (evsel->attr.read_format & PERF_FORMAT_ID) {
835	if (perf_evlist__id_add_fd(evlist, evsel, cpu, thread,	835	if (perf_evlist__id_add_fd(evlist, evsel, cpu, thread,
836	fd) < 0)	836	fd) < 0)
837	return -1;	837	return -1;
838	perf_evlist__set_sid_idx(evlist, evsel, idx, cpu,	838	perf_evlist__set_sid_idx(evlist, evsel, idx, cpu,
839	thread);	839	thread);
840	}	840	}
841	}	841	}
842		842
843	return 0;	843	return 0;
844	}	844	}
845		845
846	static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist,	846	static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist,
847	struct mmap_params *mp)	847	struct mmap_params *mp)
848	{	848	{
849	int cpu, thread;	849	int cpu, thread;
850	int nr_cpus = cpu_map__nr(evlist->cpus);	850	int nr_cpus = cpu_map__nr(evlist->cpus);
851	int nr_threads = thread_map__nr(evlist->threads);	851	int nr_threads = thread_map__nr(evlist->threads);
852		852
853	pr_debug2("perf event ring buffer mmapped per cpu\n");	853	pr_debug2("perf event ring buffer mmapped per cpu\n");
854	for (cpu = 0; cpu < nr_cpus; cpu++) {	854	for (cpu = 0; cpu < nr_cpus; cpu++) {
855	int output = -1;	855	int output = -1;
856		856
857	for (thread = 0; thread < nr_threads; thread++) {	857	for (thread = 0; thread < nr_threads; thread++) {
858	if (perf_evlist__mmap_per_evsel(evlist, cpu, mp, cpu,	858	if (perf_evlist__mmap_per_evsel(evlist, cpu, mp, cpu,
859	thread, &output))	859	thread, &output))
860	goto out_unmap;	860	goto out_unmap;
861	}	861	}
862	}	862	}
863		863
864	return 0;	864	return 0;
865		865
866	out_unmap:	866	out_unmap:
867	for (cpu = 0; cpu < nr_cpus; cpu++)	867	for (cpu = 0; cpu < nr_cpus; cpu++)
868	__perf_evlist__munmap(evlist, cpu);	868	__perf_evlist__munmap(evlist, cpu);
869	return -1;	869	return -1;
870	}	870	}
871		871
872	static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist,	872	static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist,
873	struct mmap_params *mp)	873	struct mmap_params *mp)
874	{	874	{
875	int thread;	875	int thread;
876	int nr_threads = thread_map__nr(evlist->threads);	876	int nr_threads = thread_map__nr(evlist->threads);
877		877
878	pr_debug2("perf event ring buffer mmapped per thread\n");	878	pr_debug2("perf event ring buffer mmapped per thread\n");
879	for (thread = 0; thread < nr_threads; thread++) {	879	for (thread = 0; thread < nr_threads; thread++) {
880	int output = -1;	880	int output = -1;
881		881
882	if (perf_evlist__mmap_per_evsel(evlist, thread, mp, 0, thread,	882	if (perf_evlist__mmap_per_evsel(evlist, thread, mp, 0, thread,
883	&output))	883	&output))
884	goto out_unmap;	884	goto out_unmap;
885	}	885	}
886		886
887	return 0;	887	return 0;
888		888
889	out_unmap:	889	out_unmap:
890	for (thread = 0; thread < nr_threads; thread++)	890	for (thread = 0; thread < nr_threads; thread++)
891	__perf_evlist__munmap(evlist, thread);	891	__perf_evlist__munmap(evlist, thread);
892	return -1;	892	return -1;
893	}	893	}
894		894
895	static size_t perf_evlist__mmap_size(unsigned long pages)	895	static size_t perf_evlist__mmap_size(unsigned long pages)
896	{	896	{
897	if (pages == UINT_MAX) {	897	if (pages == UINT_MAX) {
898	int max;	898	int max;
899		899
900	if (sysctl__read_int("kernel/perf_event_mlock_kb", &max) < 0) {	900	if (sysctl__read_int("kernel/perf_event_mlock_kb", &max) < 0) {
901	/*	901	/*
902	* Pick a once upon a time good value, i.e. things look	902	* Pick a once upon a time good value, i.e. things look
903	* strange since we can't read a sysctl value, but lets not	903	* strange since we can't read a sysctl value, but lets not
904	* die yet...	904	* die yet...
905	*/	905	*/
906	max = 512;	906	max = 512;
907	} else {	907	} else {
908	max -= (page_size / 1024);	908	max -= (page_size / 1024);
909	}	909	}
910		910
911	pages = (max * 1024) / page_size;	911	pages = (max * 1024) / page_size;
912	if (!is_power_of_2(pages))	912	if (!is_power_of_2(pages))
913	pages = rounddown_pow_of_two(pages);	913	pages = rounddown_pow_of_two(pages);
914	} else if (!is_power_of_2(pages))	914	} else if (!is_power_of_2(pages))
915	return 0;	915	return 0;
916		916
917	return (pages + 1) * page_size;	917	return (pages + 1) * page_size;
918	}	918	}
919		919
920	static long parse_pages_arg(const char *str, unsigned long min,	920	static long parse_pages_arg(const char *str, unsigned long min,
921	unsigned long max)	921	unsigned long max)
922	{	922	{
923	unsigned long pages, val;	923	unsigned long pages, val;
924	static struct parse_tag tags[] = {	924	static struct parse_tag tags[] = {
925	{ .tag = 'B', .mult = 1 },	925	{ .tag = 'B', .mult = 1 },
926	{ .tag = 'K', .mult = 1 << 10 },	926	{ .tag = 'K', .mult = 1 << 10 },
927	{ .tag = 'M', .mult = 1 << 20 },	927	{ .tag = 'M', .mult = 1 << 20 },
928	{ .tag = 'G', .mult = 1 << 30 },	928	{ .tag = 'G', .mult = 1 << 30 },
929	{ .tag = 0 },	929	{ .tag = 0 },
930	};	930	};
931		931
932	if (str == NULL)	932	if (str == NULL)
933	return -EINVAL;	933	return -EINVAL;
934		934
935	val = parse_tag_value(str, tags);	935	val = parse_tag_value(str, tags);
936	if (val != (unsigned long) -1) {	936	if (val != (unsigned long) -1) {
937	/* we got file size value */	937	/* we got file size value */
938	pages = PERF_ALIGN(val, page_size) / page_size;	938	pages = PERF_ALIGN(val, page_size) / page_size;
939	} else {	939	} else {
940	/* we got pages count value */	940	/* we got pages count value */
941	char *eptr;	941	char *eptr;
942	pages = strtoul(str, &eptr, 10);	942	pages = strtoul(str, &eptr, 10);
943	if (*eptr != '\0')	943	if (*eptr != '\0')
944	return -EINVAL;	944	return -EINVAL;
945	}	945	}
946		946
947	if (pages == 0 && min == 0) {	947	if (pages == 0 && min == 0) {
948	/* leave number of pages at 0 */	948	/* leave number of pages at 0 */
949	} else if (!is_power_of_2(pages)) {	949	} else if (!is_power_of_2(pages)) {
950	/* round pages up to next power of 2 */	950	/* round pages up to next power of 2 */
951	pages = roundup_pow_of_two(pages);	951	pages = roundup_pow_of_two(pages);
952	if (!pages)	952	if (!pages)
953	return -EINVAL;	953	return -EINVAL;
954	pr_info("rounding mmap pages size to %lu bytes (%lu pages)\n",	954	pr_info("rounding mmap pages size to %lu bytes (%lu pages)\n",
955	pages * page_size, pages);	955	pages * page_size, pages);
956	}	956	}
957		957
958	if (pages > max)	958	if (pages > max)
959	return -EINVAL;	959	return -EINVAL;
960		960
961	return pages;	961	return pages;
962	}	962	}
963		963
964	int perf_evlist__parse_mmap_pages(const struct option opt, const char str,	964	int perf_evlist__parse_mmap_pages(const struct option opt, const char str,
965	int unset __maybe_unused)	965	int unset __maybe_unused)
966	{	966	{
967	unsigned int *mmap_pages = opt->value;	967	unsigned int *mmap_pages = opt->value;
968	unsigned long max = UINT_MAX;	968	unsigned long max = UINT_MAX;
969	long pages;	969	long pages;
970		970
971	if (max > SIZE_MAX / page_size)	971	if (max > SIZE_MAX / page_size)
972	max = SIZE_MAX / page_size;	972	max = SIZE_MAX / page_size;
973		973
974	pages = parse_pages_arg(str, 1, max);	974	pages = parse_pages_arg(str, 1, max);
975	if (pages < 0) {	975	if (pages < 0) {
976	pr_err("Invalid argument for --mmap_pages/-m\n");	976	pr_err("Invalid argument for --mmap_pages/-m\n");
977	return -1;	977	return -1;
978	}	978	}
979		979
980	*mmap_pages = pages;	980	*mmap_pages = pages;
981	return 0;	981	return 0;
982	}	982	}
983		983
984	/**	984	/**
985	* perf_evlist__mmap - Create mmaps to receive events.	985	* perf_evlist__mmap - Create mmaps to receive events.
986	* @evlist: list of events	986	* @evlist: list of events
987	* @pages: map length in pages	987	* @pages: map length in pages
988	* @overwrite: overwrite older events?	988	* @overwrite: overwrite older events?
989	*	989	*
990	* If @overwrite is %false the user needs to signal event consumption using	990	* If @overwrite is %false the user needs to signal event consumption using
991	* perf_mmap__write_tail(). Using perf_evlist__mmap_read() does this	991	* perf_mmap__write_tail(). Using perf_evlist__mmap_read() does this
992	* automatically.	992	* automatically.
993	*	993	*
994	* Return: %0 on success, negative error code otherwise.	994	* Return: %0 on success, negative error code otherwise.
995	*/	995	*/
996	int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,	996	int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
997	bool overwrite)	997	bool overwrite)
998	{	998	{
999	struct perf_evsel *evsel;	999	struct perf_evsel *evsel;
1000	const struct cpu_map *cpus = evlist->cpus;	1000	const struct cpu_map *cpus = evlist->cpus;
1001	const struct thread_map *threads = evlist->threads;	1001	const struct thread_map *threads = evlist->threads;
1002	struct mmap_params mp = {	1002	struct mmap_params mp = {
1003	.prot = PROT_READ \| (overwrite ? 0 : PROT_WRITE),	1003	.prot = PROT_READ \| (overwrite ? 0 : PROT_WRITE),
1004	};	1004	};
1005		1005
1006	if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0)	1006	if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0)
1007	return -ENOMEM;	1007	return -ENOMEM;
1008		1008
1009	if (evlist->pollfd.entries == NULL && perf_evlist__alloc_pollfd(evlist) < 0)	1009	if (evlist->pollfd.entries == NULL && perf_evlist__alloc_pollfd(evlist) < 0)
1010	return -ENOMEM;	1010	return -ENOMEM;
1011		1011
1012	evlist->overwrite = overwrite;	1012	evlist->overwrite = overwrite;
1013	evlist->mmap_len = perf_evlist__mmap_size(pages);	1013	evlist->mmap_len = perf_evlist__mmap_size(pages);
1014	pr_debug("mmap size %zuB\n", evlist->mmap_len);	1014	pr_debug("mmap size %zuB\n", evlist->mmap_len);
1015	mp.mask = evlist->mmap_len - page_size - 1;	1015	mp.mask = evlist->mmap_len - page_size - 1;
1016		1016
1017	evlist__for_each(evlist, evsel) {	1017	evlist__for_each(evlist, evsel) {
1018	if ((evsel->attr.read_format & PERF_FORMAT_ID) &&	1018	if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
1019	evsel->sample_id == NULL &&	1019	evsel->sample_id == NULL &&
1020	perf_evsel__alloc_id(evsel, cpu_map__nr(cpus), threads->nr) < 0)	1020	perf_evsel__alloc_id(evsel, cpu_map__nr(cpus), threads->nr) < 0)
1021	return -ENOMEM;	1021	return -ENOMEM;
1022	}	1022	}
1023		1023
1024	if (cpu_map__empty(cpus))	1024	if (cpu_map__empty(cpus))
1025	return perf_evlist__mmap_per_thread(evlist, &mp);	1025	return perf_evlist__mmap_per_thread(evlist, &mp);
1026		1026
1027	return perf_evlist__mmap_per_cpu(evlist, &mp);	1027	return perf_evlist__mmap_per_cpu(evlist, &mp);
1028	}	1028	}
1029		1029
1030	int perf_evlist__create_maps(struct perf_evlist evlist, struct target target)	1030	int perf_evlist__create_maps(struct perf_evlist evlist, struct target target)
1031	{	1031	{
1032	evlist->threads = thread_map__new_str(target->pid, target->tid,	1032	evlist->threads = thread_map__new_str(target->pid, target->tid,
1033	target->uid);	1033	target->uid);
1034		1034
1035	if (evlist->threads == NULL)	1035	if (evlist->threads == NULL)
1036	return -1;	1036	return -1;
1037		1037
1038	if (target__uses_dummy_map(target))	1038	if (target__uses_dummy_map(target))
1039	evlist->cpus = cpu_map__dummy_new();	1039	evlist->cpus = cpu_map__dummy_new();
1040	else	1040	else
1041	evlist->cpus = cpu_map__new(target->cpu_list);	1041	evlist->cpus = cpu_map__new(target->cpu_list);
1042		1042
1043	if (evlist->cpus == NULL)	1043	if (evlist->cpus == NULL)
1044	goto out_delete_threads;	1044	goto out_delete_threads;
1045		1045
1046	return 0;	1046	return 0;
1047		1047
1048	out_delete_threads:	1048	out_delete_threads:
1049	thread_map__delete(evlist->threads);	1049	thread_map__delete(evlist->threads);
1050	evlist->threads = NULL;	1050	evlist->threads = NULL;
1051	return -1;	1051	return -1;
1052	}	1052	}
1053		1053
1054	int perf_evlist__apply_filters(struct perf_evlist *evlist)	1054	int perf_evlist__apply_filters(struct perf_evlist *evlist)
1055	{	1055	{
1056	struct perf_evsel *evsel;	1056	struct perf_evsel *evsel;
1057	int err = 0;	1057	int err = 0;
1058	const int ncpus = cpu_map__nr(evlist->cpus),	1058	const int ncpus = cpu_map__nr(evlist->cpus),
1059	nthreads = thread_map__nr(evlist->threads);	1059	nthreads = thread_map__nr(evlist->threads);
1060		1060
1061	evlist__for_each(evlist, evsel) {	1061	evlist__for_each(evlist, evsel) {
1062	if (evsel->filter == NULL)	1062	if (evsel->filter == NULL)
1063	continue;	1063	continue;
1064		1064
1065	err = perf_evsel__set_filter(evsel, ncpus, nthreads, evsel->filter);	1065	err = perf_evsel__set_filter(evsel, ncpus, nthreads, evsel->filter);
1066	if (err)	1066	if (err)
1067	break;	1067	break;
1068	}	1068	}
1069		1069
1070	return err;	1070	return err;
1071	}	1071	}
1072		1072
1073	int perf_evlist__set_filter(struct perf_evlist evlist, const char filter)	1073	int perf_evlist__set_filter(struct perf_evlist evlist, const char filter)
1074	{	1074	{
1075	struct perf_evsel *evsel;	1075	struct perf_evsel *evsel;
1076	int err = 0;	1076	int err = 0;
1077	const int ncpus = cpu_map__nr(evlist->cpus),	1077	const int ncpus = cpu_map__nr(evlist->cpus),
1078	nthreads = thread_map__nr(evlist->threads);	1078	nthreads = thread_map__nr(evlist->threads);
1079		1079
1080	evlist__for_each(evlist, evsel) {	1080	evlist__for_each(evlist, evsel) {
1081	err = perf_evsel__set_filter(evsel, ncpus, nthreads, filter);	1081	err = perf_evsel__set_filter(evsel, ncpus, nthreads, filter);
1082	if (err)	1082	if (err)
1083	break;	1083	break;
1084	}	1084	}
1085		1085
1086	return err;	1086	return err;
1087	}	1087	}
1088		1088
1089	bool perf_evlist__valid_sample_type(struct perf_evlist *evlist)	1089	bool perf_evlist__valid_sample_type(struct perf_evlist *evlist)
1090	{	1090	{
1091	struct perf_evsel *pos;	1091	struct perf_evsel *pos;
1092		1092
1093	if (evlist->nr_entries == 1)	1093	if (evlist->nr_entries == 1)
1094	return true;	1094	return true;
1095		1095
1096	if (evlist->id_pos < 0 \|\| evlist->is_pos < 0)	1096	if (evlist->id_pos < 0 \|\| evlist->is_pos < 0)
1097	return false;	1097	return false;
1098		1098
1099	evlist__for_each(evlist, pos) {	1099	evlist__for_each(evlist, pos) {
1100	if (pos->id_pos != evlist->id_pos \|\|	1100	if (pos->id_pos != evlist->id_pos \|\|
1101	pos->is_pos != evlist->is_pos)	1101	pos->is_pos != evlist->is_pos)
1102	return false;	1102	return false;
1103	}	1103	}
1104		1104
1105	return true;	1105	return true;
1106	}	1106	}
1107		1107
1108	u64 __perf_evlist__combined_sample_type(struct perf_evlist *evlist)	1108	u64 __perf_evlist__combined_sample_type(struct perf_evlist *evlist)
1109	{	1109	{
1110	struct perf_evsel *evsel;	1110	struct perf_evsel *evsel;
1111		1111
1112	if (evlist->combined_sample_type)	1112	if (evlist->combined_sample_type)
1113	return evlist->combined_sample_type;	1113	return evlist->combined_sample_type;
1114		1114
1115	evlist__for_each(evlist, evsel)	1115	evlist__for_each(evlist, evsel)
1116	evlist->combined_sample_type \|= evsel->attr.sample_type;	1116	evlist->combined_sample_type \|= evsel->attr.sample_type;
1117		1117
1118	return evlist->combined_sample_type;	1118	return evlist->combined_sample_type;
1119	}	1119	}
1120		1120
1121	u64 perf_evlist__combined_sample_type(struct perf_evlist *evlist)	1121	u64 perf_evlist__combined_sample_type(struct perf_evlist *evlist)
1122	{	1122	{
1123	evlist->combined_sample_type = 0;	1123	evlist->combined_sample_type = 0;
1124	return __perf_evlist__combined_sample_type(evlist);	1124	return __perf_evlist__combined_sample_type(evlist);
1125	}	1125	}
1126		1126
1127	bool perf_evlist__valid_read_format(struct perf_evlist *evlist)	1127	bool perf_evlist__valid_read_format(struct perf_evlist *evlist)
1128	{	1128	{
1129	struct perf_evsel first = perf_evlist__first(evlist), pos = first;	1129	struct perf_evsel first = perf_evlist__first(evlist), pos = first;
1130	u64 read_format = first->attr.read_format;	1130	u64 read_format = first->attr.read_format;
1131	u64 sample_type = first->attr.sample_type;	1131	u64 sample_type = first->attr.sample_type;
1132		1132
1133	evlist__for_each(evlist, pos) {	1133	evlist__for_each(evlist, pos) {
1134	if (read_format != pos->attr.read_format)	1134	if (read_format != pos->attr.read_format)
1135	return false;	1135	return false;
1136	}	1136	}
1137		1137
1138	/* PERF_SAMPLE_READ imples PERF_FORMAT_ID. */	1138	/* PERF_SAMPLE_READ imples PERF_FORMAT_ID. */
1139	if ((sample_type & PERF_SAMPLE_READ) &&	1139	if ((sample_type & PERF_SAMPLE_READ) &&
1140	!(read_format & PERF_FORMAT_ID)) {	1140	!(read_format & PERF_FORMAT_ID)) {
1141	return false;	1141	return false;
1142	}	1142	}
1143		1143
1144	return true;	1144	return true;
1145	}	1145	}
1146		1146
1147	u64 perf_evlist__read_format(struct perf_evlist *evlist)	1147	u64 perf_evlist__read_format(struct perf_evlist *evlist)
1148	{	1148	{
1149	struct perf_evsel *first = perf_evlist__first(evlist);	1149	struct perf_evsel *first = perf_evlist__first(evlist);
1150	return first->attr.read_format;	1150	return first->attr.read_format;
1151	}	1151	}
1152		1152
1153	u16 perf_evlist__id_hdr_size(struct perf_evlist *evlist)	1153	u16 perf_evlist__id_hdr_size(struct perf_evlist *evlist)
1154	{	1154	{
1155	struct perf_evsel *first = perf_evlist__first(evlist);	1155	struct perf_evsel *first = perf_evlist__first(evlist);
1156	struct perf_sample *data;	1156	struct perf_sample *data;
1157	u64 sample_type;	1157	u64 sample_type;
1158	u16 size = 0;	1158	u16 size = 0;
1159		1159
1160	if (!first->attr.sample_id_all)	1160	if (!first->attr.sample_id_all)
1161	goto out;	1161	goto out;
1162		1162
1163	sample_type = first->attr.sample_type;	1163	sample_type = first->attr.sample_type;
1164		1164
1165	if (sample_type & PERF_SAMPLE_TID)	1165	if (sample_type & PERF_SAMPLE_TID)
1166	size += sizeof(data->tid) * 2;	1166	size += sizeof(data->tid) * 2;
1167		1167
1168	if (sample_type & PERF_SAMPLE_TIME)	1168	if (sample_type & PERF_SAMPLE_TIME)
1169	size += sizeof(data->time);	1169	size += sizeof(data->time);
1170		1170
1171	if (sample_type & PERF_SAMPLE_ID)	1171	if (sample_type & PERF_SAMPLE_ID)
1172	size += sizeof(data->id);	1172	size += sizeof(data->id);
1173		1173
1174	if (sample_type & PERF_SAMPLE_STREAM_ID)	1174	if (sample_type & PERF_SAMPLE_STREAM_ID)
1175	size += sizeof(data->stream_id);	1175	size += sizeof(data->stream_id);
1176		1176
1177	if (sample_type & PERF_SAMPLE_CPU)	1177	if (sample_type & PERF_SAMPLE_CPU)
1178	size += sizeof(data->cpu) * 2;	1178	size += sizeof(data->cpu) * 2;
1179		1179
1180	if (sample_type & PERF_SAMPLE_IDENTIFIER)	1180	if (sample_type & PERF_SAMPLE_IDENTIFIER)
1181	size += sizeof(data->id);	1181	size += sizeof(data->id);
1182	out:	1182	out:
1183	return size;	1183	return size;
1184	}	1184	}
1185		1185
1186	bool perf_evlist__valid_sample_id_all(struct perf_evlist *evlist)	1186	bool perf_evlist__valid_sample_id_all(struct perf_evlist *evlist)
1187	{	1187	{
1188	struct perf_evsel first = perf_evlist__first(evlist), pos = first;	1188	struct perf_evsel first = perf_evlist__first(evlist), pos = first;
1189		1189
1190	evlist__for_each_continue(evlist, pos) {	1190	evlist__for_each_continue(evlist, pos) {
1191	if (first->attr.sample_id_all != pos->attr.sample_id_all)	1191	if (first->attr.sample_id_all != pos->attr.sample_id_all)
1192	return false;	1192	return false;
1193	}	1193	}
1194		1194
1195	return true;	1195	return true;
1196	}	1196	}
1197		1197
1198	bool perf_evlist__sample_id_all(struct perf_evlist *evlist)	1198	bool perf_evlist__sample_id_all(struct perf_evlist *evlist)
1199	{	1199	{
1200	struct perf_evsel *first = perf_evlist__first(evlist);	1200	struct perf_evsel *first = perf_evlist__first(evlist);
1201	return first->attr.sample_id_all;	1201	return first->attr.sample_id_all;
1202	}	1202	}
1203		1203
1204	void perf_evlist__set_selected(struct perf_evlist *evlist,	1204	void perf_evlist__set_selected(struct perf_evlist *evlist,
1205	struct perf_evsel *evsel)	1205	struct perf_evsel *evsel)
1206	{	1206	{
1207	evlist->selected = evsel;	1207	evlist->selected = evsel;
1208	}	1208	}
1209		1209
1210	void perf_evlist__close(struct perf_evlist *evlist)	1210	void perf_evlist__close(struct perf_evlist *evlist)
1211	{	1211	{
1212	struct perf_evsel *evsel;	1212	struct perf_evsel *evsel;
1213	int ncpus = cpu_map__nr(evlist->cpus);	1213	int ncpus = cpu_map__nr(evlist->cpus);
1214	int nthreads = thread_map__nr(evlist->threads);	1214	int nthreads = thread_map__nr(evlist->threads);
1215	int n;	1215	int n;
1216		1216
1217	evlist__for_each_reverse(evlist, evsel) {	1217	evlist__for_each_reverse(evlist, evsel) {
1218	n = evsel->cpus ? evsel->cpus->nr : ncpus;	1218	n = evsel->cpus ? evsel->cpus->nr : ncpus;
1219	perf_evsel__close(evsel, n, nthreads);	1219	perf_evsel__close(evsel, n, nthreads);
1220	}	1220	}
1221	}	1221	}
1222		1222
1223	static int perf_evlist__create_syswide_maps(struct perf_evlist *evlist)	1223	static int perf_evlist__create_syswide_maps(struct perf_evlist *evlist)
1224	{	1224	{
1225	int err = -ENOMEM;	1225	int err = -ENOMEM;
1226		1226
1227	/*	1227	/*
1228	* Try reading /sys/devices/system/cpu/online to get	1228	* Try reading /sys/devices/system/cpu/online to get
1229	* an all cpus map.	1229	* an all cpus map.
1230	*	1230	*
1231	* FIXME: -ENOMEM is the best we can do here, the cpu_map	1231	* FIXME: -ENOMEM is the best we can do here, the cpu_map
1232	* code needs an overhaul to properly forward the	1232	* code needs an overhaul to properly forward the
1233	* error, and we may not want to do that fallback to a	1233	* error, and we may not want to do that fallback to a
1234	* default cpu identity map :-\	1234	* default cpu identity map :-\
1235	*/	1235	*/
1236	evlist->cpus = cpu_map__new(NULL);	1236	evlist->cpus = cpu_map__new(NULL);
1237	if (evlist->cpus == NULL)	1237	if (evlist->cpus == NULL)
1238	goto out;	1238	goto out;
1239		1239
1240	evlist->threads = thread_map__new_dummy();	1240	evlist->threads = thread_map__new_dummy();
1241	if (evlist->threads == NULL)	1241	if (evlist->threads == NULL)
1242	goto out_free_cpus;	1242	goto out_free_cpus;
1243		1243
1244	err = 0;	1244	err = 0;
1245	out:	1245	out:
1246	return err;	1246	return err;
1247	out_free_cpus:	1247	out_free_cpus:
1248	cpu_map__delete(evlist->cpus);	1248	cpu_map__delete(evlist->cpus);
1249	evlist->cpus = NULL;	1249	evlist->cpus = NULL;
1250	goto out;	1250	goto out;
1251	}	1251	}
1252		1252
1253	int perf_evlist__open(struct perf_evlist *evlist)	1253	int perf_evlist__open(struct perf_evlist *evlist)
1254	{	1254	{
1255	struct perf_evsel *evsel;	1255	struct perf_evsel *evsel;
1256	int err;	1256	int err;
1257		1257
1258	/*	1258	/*
1259	* Default: one fd per CPU, all threads, aka systemwide	1259	* Default: one fd per CPU, all threads, aka systemwide
1260	* as sys_perf_event_open(cpu = -1, thread = -1) is EINVAL	1260	* as sys_perf_event_open(cpu = -1, thread = -1) is EINVAL
1261	*/	1261	*/
1262	if (evlist->threads == NULL && evlist->cpus == NULL) {	1262	if (evlist->threads == NULL && evlist->cpus == NULL) {
1263	err = perf_evlist__create_syswide_maps(evlist);	1263	err = perf_evlist__create_syswide_maps(evlist);
1264	if (err < 0)	1264	if (err < 0)
1265	goto out_err;	1265	goto out_err;
1266	}	1266	}
1267		1267
1268	perf_evlist__update_id_pos(evlist);	1268	perf_evlist__update_id_pos(evlist);
1269		1269
1270	evlist__for_each(evlist, evsel) {	1270	evlist__for_each(evlist, evsel) {
1271	err = perf_evsel__open(evsel, evlist->cpus, evlist->threads);	1271	err = perf_evsel__open(evsel, evlist->cpus, evlist->threads);
1272	if (err < 0)	1272	if (err < 0)
1273	goto out_err;	1273	goto out_err;
1274	}	1274	}
1275		1275
1276	return 0;	1276	return 0;
1277	out_err:	1277	out_err:
1278	perf_evlist__close(evlist);	1278	perf_evlist__close(evlist);
1279	errno = -err;	1279	errno = -err;
1280	return err;	1280	return err;
1281	}	1281	}
1282		1282
1283	int perf_evlist__prepare_workload(struct perf_evlist evlist, struct target target,	1283	int perf_evlist__prepare_workload(struct perf_evlist evlist, struct target target,
1284	const char *argv[], bool pipe_output,	1284	const char *argv[], bool pipe_output,
1285	void (exec_error)(int signo, siginfo_t info, void *ucontext))	1285	void (exec_error)(int signo, siginfo_t info, void *ucontext))
1286	{	1286	{
1287	int child_ready_pipe[2], go_pipe[2];	1287	int child_ready_pipe[2], go_pipe[2];
1288	char bf;	1288	char bf;
1289		1289
1290	if (pipe(child_ready_pipe) < 0) {	1290	if (pipe(child_ready_pipe) < 0) {
1291	perror("failed to create 'ready' pipe");	1291	perror("failed to create 'ready' pipe");
1292	return -1;	1292	return -1;
1293	}	1293	}
1294		1294
1295	if (pipe(go_pipe) < 0) {	1295	if (pipe(go_pipe) < 0) {
1296	perror("failed to create 'go' pipe");	1296	perror("failed to create 'go' pipe");
1297	goto out_close_ready_pipe;	1297	goto out_close_ready_pipe;
1298	}	1298	}
1299		1299
1300	evlist->workload.pid = fork();	1300	evlist->workload.pid = fork();
1301	if (evlist->workload.pid < 0) {	1301	if (evlist->workload.pid < 0) {
1302	perror("failed to fork");	1302	perror("failed to fork");
1303	goto out_close_pipes;	1303	goto out_close_pipes;
1304	}	1304	}
1305		1305
1306	if (!evlist->workload.pid) {	1306	if (!evlist->workload.pid) {
1307	int ret;	1307	int ret;
1308		1308
1309	if (pipe_output)	1309	if (pipe_output)
1310	dup2(2, 1);	1310	dup2(2, 1);
1311		1311
1312	signal(SIGTERM, SIG_DFL);	1312	signal(SIGTERM, SIG_DFL);
1313		1313
1314	close(child_ready_pipe[0]);	1314	close(child_ready_pipe[0]);
1315	close(go_pipe[1]);	1315	close(go_pipe[1]);
1316	fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);	1316	fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
1317		1317
1318	/*	1318	/*
1319	* Tell the parent we're ready to go	1319	* Tell the parent we're ready to go
1320	*/	1320	*/
1321	close(child_ready_pipe[1]);	1321	close(child_ready_pipe[1]);
1322		1322
1323	/*	1323	/*
1324	* Wait until the parent tells us to go.	1324	* Wait until the parent tells us to go.
1325	*/	1325	*/
1326	ret = read(go_pipe[0], &bf, 1);	1326	ret = read(go_pipe[0], &bf, 1);
1327	/*	1327	/*
1328	* The parent will ask for the execvp() to be performed by	1328	* The parent will ask for the execvp() to be performed by
1329	* writing exactly one byte, in workload.cork_fd, usually via	1329	* writing exactly one byte, in workload.cork_fd, usually via
1330	* perf_evlist__start_workload().	1330	* perf_evlist__start_workload().
1331	*	1331	*
1332	* For cancelling the workload without actuallin running it,	1332	* For cancelling the workload without actuallin running it,
1333	* the parent will just close workload.cork_fd, without writing	1333	* the parent will just close workload.cork_fd, without writing
1334	* anything, i.e. read will return zero and we just exit()	1334	* anything, i.e. read will return zero and we just exit()
1335	* here.	1335	* here.
1336	*/	1336	*/
1337	if (ret != 1) {	1337	if (ret != 1) {
1338	if (ret == -1)	1338	if (ret == -1)
1339	perror("unable to read pipe");	1339	perror("unable to read pipe");
1340	exit(ret);	1340	exit(ret);
1341	}	1341	}
1342		1342
1343	execvp(argv[0], (char **)argv);	1343	execvp(argv[0], (char **)argv);
1344		1344
1345	if (exec_error) {	1345	if (exec_error) {
1346	union sigval val;	1346	union sigval val;
1347		1347
1348	val.sival_int = errno;	1348	val.sival_int = errno;
1349	if (sigqueue(getppid(), SIGUSR1, val))	1349	if (sigqueue(getppid(), SIGUSR1, val))
1350	perror(argv[0]);	1350	perror(argv[0]);
1351	} else	1351	} else
1352	perror(argv[0]);	1352	perror(argv[0]);
1353	exit(-1);	1353	exit(-1);
1354	}	1354	}
1355		1355
1356	if (exec_error) {	1356	if (exec_error) {
1357	struct sigaction act = {	1357	struct sigaction act = {
1358	.sa_flags = SA_SIGINFO,	1358	.sa_flags = SA_SIGINFO,
1359	.sa_sigaction = exec_error,	1359	.sa_sigaction = exec_error,
1360	};	1360	};
1361	sigaction(SIGUSR1, &act, NULL);	1361	sigaction(SIGUSR1, &act, NULL);
1362	}	1362	}
1363		1363
1364	if (target__none(target)) {	1364	if (target__none(target)) {
1365	if (evlist->threads == NULL) {	1365	if (evlist->threads == NULL) {
1366	fprintf(stderr, "FATAL: evlist->threads need to be set at this point (%s:%d).\n",	1366	fprintf(stderr, "FATAL: evlist->threads need to be set at this point (%s:%d).\n",
1367	__func__, __LINE__);	1367	__func__, __LINE__);
1368	goto out_close_pipes;	1368	goto out_close_pipes;
1369	}	1369	}
1370	evlist->threads->map[0] = evlist->workload.pid;	1370	evlist->threads->map[0] = evlist->workload.pid;
1371	}	1371	}
1372		1372
1373	close(child_ready_pipe[1]);	1373	close(child_ready_pipe[1]);
1374	close(go_pipe[0]);	1374	close(go_pipe[0]);
1375	/*	1375	/*
1376	* wait for child to settle	1376	* wait for child to settle
1377	*/	1377	*/
1378	if (read(child_ready_pipe[0], &bf, 1) == -1) {	1378	if (read(child_ready_pipe[0], &bf, 1) == -1) {
1379	perror("unable to read pipe");	1379	perror("unable to read pipe");
1380	goto out_close_pipes;	1380	goto out_close_pipes;
1381	}	1381	}
1382		1382
1383	fcntl(go_pipe[1], F_SETFD, FD_CLOEXEC);	1383	fcntl(go_pipe[1], F_SETFD, FD_CLOEXEC);
1384	evlist->workload.cork_fd = go_pipe[1];	1384	evlist->workload.cork_fd = go_pipe[1];
1385	close(child_ready_pipe[0]);	1385	close(child_ready_pipe[0]);
1386	return 0;	1386	return 0;
1387		1387
1388	out_close_pipes:	1388	out_close_pipes:
1389	close(go_pipe[0]);	1389	close(go_pipe[0]);
1390	close(go_pipe[1]);	1390	close(go_pipe[1]);
1391	out_close_ready_pipe:	1391	out_close_ready_pipe:
1392	close(child_ready_pipe[0]);	1392	close(child_ready_pipe[0]);
1393	close(child_ready_pipe[1]);	1393	close(child_ready_pipe[1]);
1394	return -1;	1394	return -1;
1395	}	1395	}
1396		1396
1397	int perf_evlist__start_workload(struct perf_evlist *evlist)	1397	int perf_evlist__start_workload(struct perf_evlist *evlist)
1398	{	1398	{
1399	if (evlist->workload.cork_fd > 0) {	1399	if (evlist->workload.cork_fd > 0) {
1400	char bf = 0;	1400	char bf = 0;
1401	int ret;	1401	int ret;
1402	/*	1402	/*
1403	* Remove the cork, let it rip!	1403	* Remove the cork, let it rip!
1404	*/	1404	*/
1405	ret = write(evlist->workload.cork_fd, &bf, 1);	1405	ret = write(evlist->workload.cork_fd, &bf, 1);
1406	if (ret < 0)	1406	if (ret < 0)
1407	perror("enable to write to pipe");	1407	perror("enable to write to pipe");
1408		1408
1409	close(evlist->workload.cork_fd);	1409	close(evlist->workload.cork_fd);
1410	return ret;	1410	return ret;
1411	}	1411	}
1412		1412
1413	return 0;	1413	return 0;
1414	}	1414	}
1415		1415
1416	int perf_evlist__parse_sample(struct perf_evlist evlist, union perf_event event,	1416	int perf_evlist__parse_sample(struct perf_evlist evlist, union perf_event event,
1417	struct perf_sample *sample)	1417	struct perf_sample *sample)
1418	{	1418	{
1419	struct perf_evsel *evsel = perf_evlist__event2evsel(evlist, event);	1419	struct perf_evsel *evsel = perf_evlist__event2evsel(evlist, event);
1420		1420
1421	if (!evsel)	1421	if (!evsel)
1422	return -EFAULT;	1422	return -EFAULT;
1423	return perf_evsel__parse_sample(evsel, event, sample);	1423	return perf_evsel__parse_sample(evsel, event, sample);
1424	}	1424	}
1425		1425
1426	size_t perf_evlist__fprintf(struct perf_evlist evlist, FILE fp)	1426	size_t perf_evlist__fprintf(struct perf_evlist evlist, FILE fp)
1427	{	1427	{
1428	struct perf_evsel *evsel;	1428	struct perf_evsel *evsel;
1429	size_t printed = 0;	1429	size_t printed = 0;
1430		1430
1431	evlist__for_each(evlist, evsel) {	1431	evlist__for_each(evlist, evsel) {
1432	printed += fprintf(fp, "%s%s", evsel->idx ? ", " : "",	1432	printed += fprintf(fp, "%s%s", evsel->idx ? ", " : "",
1433	perf_evsel__name(evsel));	1433	perf_evsel__name(evsel));
1434	}	1434	}
1435		1435
1436	return printed + fprintf(fp, "\n");	1436	return printed + fprintf(fp, "\n");
1437	}	1437	}
1438		1438
1439	int perf_evlist__strerror_tp(struct perf_evlist *evlist __maybe_unused,	1439	int perf_evlist__strerror_tp(struct perf_evlist *evlist __maybe_unused,
1440	int err, char *buf, size_t size)	1440	int err, char *buf, size_t size)
1441	{	1441	{
1442	char sbuf[128];	1442	char sbuf[128];
1443		1443
1444	switch (err) {	1444	switch (err) {
1445	case ENOENT:	1445	case ENOENT:
1446	scnprintf(buf, size, "%s",	1446	scnprintf(buf, size, "%s",
1447	"Error:\tUnable to find debugfs\n"	1447	"Error:\tUnable to find debugfs\n"
1448	"Hint:\tWas your kernel was compiled with debugfs support?\n"	1448	"Hint:\tWas your kernel compiled with debugfs support?\n"
1449	"Hint:\tIs the debugfs filesystem mounted?\n"	1449	"Hint:\tIs the debugfs filesystem mounted?\n"
1450	"Hint:\tTry 'sudo mount -t debugfs nodev /sys/kernel/debug'");	1450	"Hint:\tTry 'sudo mount -t debugfs nodev /sys/kernel/debug'");
1451	break;	1451	break;
1452	case EACCES:	1452	case EACCES:
1453	scnprintf(buf, size,	1453	scnprintf(buf, size,
1454	"Error:\tNo permissions to read %s/tracing/events/raw_syscalls\n"	1454	"Error:\tNo permissions to read %s/tracing/events/raw_syscalls\n"
1455	"Hint:\tTry 'sudo mount -o remount,mode=755 %s'\n",	1455	"Hint:\tTry 'sudo mount -o remount,mode=755 %s'\n",
1456	debugfs_mountpoint, debugfs_mountpoint);	1456	debugfs_mountpoint, debugfs_mountpoint);
1457	break;	1457	break;
1458	default:	1458	default:
1459	scnprintf(buf, size, "%s", strerror_r(err, sbuf, sizeof(sbuf)));	1459	scnprintf(buf, size, "%s", strerror_r(err, sbuf, sizeof(sbuf)));
1460	break;	1460	break;
1461	}	1461	}
1462		1462
1463	return 0;	1463	return 0;
1464	}	1464	}
1465		1465
1466	int perf_evlist__strerror_open(struct perf_evlist *evlist __maybe_unused,	1466	int perf_evlist__strerror_open(struct perf_evlist *evlist __maybe_unused,
1467	int err, char *buf, size_t size)	1467	int err, char *buf, size_t size)
1468	{	1468	{
1469	int printed, value;	1469	int printed, value;
1470	char sbuf[STRERR_BUFSIZE], *emsg = strerror_r(err, sbuf, sizeof(sbuf));	1470	char sbuf[STRERR_BUFSIZE], *emsg = strerror_r(err, sbuf, sizeof(sbuf));
1471		1471
1472	switch (err) {	1472	switch (err) {
1473	case EACCES:	1473	case EACCES:
1474	case EPERM:	1474	case EPERM:
1475	printed = scnprintf(buf, size,	1475	printed = scnprintf(buf, size,
1476	"Error:\t%s.\n"	1476	"Error:\t%s.\n"
1477	"Hint:\tCheck /proc/sys/kernel/perf_event_paranoid setting.", emsg);	1477	"Hint:\tCheck /proc/sys/kernel/perf_event_paranoid setting.", emsg);
1478		1478
1479	value = perf_event_paranoid();	1479	value = perf_event_paranoid();
1480		1480
1481	printed += scnprintf(buf + printed, size - printed, "\nHint:\t");	1481	printed += scnprintf(buf + printed, size - printed, "\nHint:\t");
1482		1482
1483	if (value >= 2) {	1483	if (value >= 2) {
1484	printed += scnprintf(buf + printed, size - printed,	1484	printed += scnprintf(buf + printed, size - printed,
1485	"For your workloads it needs to be <= 1\nHint:\t");	1485	"For your workloads it needs to be <= 1\nHint:\t");
1486	}	1486	}
1487	printed += scnprintf(buf + printed, size - printed,	1487	printed += scnprintf(buf + printed, size - printed,
1488	"For system wide tracing it needs to be set to -1.\n");	1488	"For system wide tracing it needs to be set to -1.\n");
1489		1489
1490	printed += scnprintf(buf + printed, size - printed,	1490	printed += scnprintf(buf + printed, size - printed,
1491	"Hint:\tTry: 'sudo sh -c \"echo -1 > /proc/sys/kernel/perf_event_paranoid\"'\n"	1491	"Hint:\tTry: 'sudo sh -c \"echo -1 > /proc/sys/kernel/perf_event_paranoid\"'\n"
1492	"Hint:\tThe current value is %d.", value);	1492	"Hint:\tThe current value is %d.", value);
1493	break;	1493	break;
1494	default:	1494	default:
1495	scnprintf(buf, size, "%s", emsg);	1495	scnprintf(buf, size, "%s", emsg);
1496	break;	1496	break;
1497	}	1497	}
1498		1498
1499	return 0;	1499	return 0;
1500	}	1500	}
1501		1501
1502	int perf_evlist__strerror_mmap(struct perf_evlist evlist, int err, char buf, size_t size)	1502	int perf_evlist__strerror_mmap(struct perf_evlist evlist, int err, char buf, size_t size)
1503	{	1503	{
1504	char sbuf[STRERR_BUFSIZE], *emsg = strerror_r(err, sbuf, sizeof(sbuf));	1504	char sbuf[STRERR_BUFSIZE], *emsg = strerror_r(err, sbuf, sizeof(sbuf));
1505	int pages_attempted = evlist->mmap_len / 1024, pages_max_per_user, printed = 0;	1505	int pages_attempted = evlist->mmap_len / 1024, pages_max_per_user, printed = 0;
1506		1506
1507	switch (err) {	1507	switch (err) {
1508	case EPERM:	1508	case EPERM:
1509	sysctl__read_int("kernel/perf_event_mlock_kb", &pages_max_per_user);	1509	sysctl__read_int("kernel/perf_event_mlock_kb", &pages_max_per_user);
1510	printed += scnprintf(buf + printed, size - printed,	1510	printed += scnprintf(buf + printed, size - printed,
1511	"Error:\t%s.\n"	1511	"Error:\t%s.\n"
1512	"Hint:\tCheck /proc/sys/kernel/perf_event_mlock_kb (%d kB) setting.\n"	1512	"Hint:\tCheck /proc/sys/kernel/perf_event_mlock_kb (%d kB) setting.\n"
1513	"Hint:\tTried using %zd kB.\n",	1513	"Hint:\tTried using %zd kB.\n",
1514	emsg, pages_max_per_user, pages_attempted);	1514	emsg, pages_max_per_user, pages_attempted);
1515		1515
1516	if (pages_attempted >= pages_max_per_user) {	1516	if (pages_attempted >= pages_max_per_user) {
1517	printed += scnprintf(buf + printed, size - printed,	1517	printed += scnprintf(buf + printed, size - printed,
1518	"Hint:\tTry 'sudo sh -c \"echo %d > /proc/sys/kernel/perf_event_mlock_kb\"', or\n",	1518	"Hint:\tTry 'sudo sh -c \"echo %d > /proc/sys/kernel/perf_event_mlock_kb\"', or\n",
1519	pages_max_per_user + pages_attempted);	1519	pages_max_per_user + pages_attempted);
1520	}	1520	}
1521		1521
1522	printed += scnprintf(buf + printed, size - printed,	1522	printed += scnprintf(buf + printed, size - printed,
1523	"Hint:\tTry using a smaller -m/--mmap-pages value.");	1523	"Hint:\tTry using a smaller -m/--mmap-pages value.");
1524	break;	1524	break;
1525	default:	1525	default:
1526	scnprintf(buf, size, "%s", emsg);	1526	scnprintf(buf, size, "%s", emsg);
1527	break;	1527	break;
1528	}	1528	}
1529		1529
1530	return 0;	1530	return 0;
1531	}	1531	}
1532		1532
1533	void perf_evlist__to_front(struct perf_evlist *evlist,	1533	void perf_evlist__to_front(struct perf_evlist *evlist,
1534	struct perf_evsel *move_evsel)	1534	struct perf_evsel *move_evsel)
1535	{	1535	{
1536	struct perf_evsel evsel, n;	1536	struct perf_evsel evsel, n;
1537	LIST_HEAD(move);	1537	LIST_HEAD(move);
1538		1538
1539	if (move_evsel == perf_evlist__first(evlist))	1539	if (move_evsel == perf_evlist__first(evlist))
1540	return;	1540	return;
1541		1541
1542	evlist__for_each_safe(evlist, n, evsel) {	1542	evlist__for_each_safe(evlist, n, evsel) {
1543	if (evsel->leader == move_evsel->leader)	1543	if (evsel->leader == move_evsel->leader)
1544	list_move_tail(&evsel->node, &move);	1544	list_move_tail(&evsel->node, &move);
1545	}	1545	}
1546		1546
1547	list_splice(&move, &evlist->entries);	1547	list_splice(&move, &evlist->entries);
1548	}	1548	}
1549		1549
1550	void perf_evlist__set_tracking_event(struct perf_evlist *evlist,	1550	void perf_evlist__set_tracking_event(struct perf_evlist *evlist,
1551	struct perf_evsel *tracking_evsel)	1551	struct perf_evsel *tracking_evsel)
1552	{	1552	{
1553	struct perf_evsel *evsel;	1553	struct perf_evsel *evsel;
1554		1554
1555	if (tracking_evsel->tracking)	1555	if (tracking_evsel->tracking)
1556	return;	1556	return;
1557		1557
1558	evlist__for_each(evlist, evsel) {	1558	evlist__for_each(evlist, evsel) {
1559	if (evsel != tracking_evsel)	1559	if (evsel != tracking_evsel)
1560	evsel->tracking = false;	1560	evsel->tracking = false;
1561	}	1561	}
1562		1562
1563	tracking_evsel->tracking = true;	1563	tracking_evsel->tracking = true;
1564	}	1564	}
1565		1565

tools/perf/util/map.h

Diff comments View file @ e742f3d

 #ifndef __PERF_MAP_H
 #define __PERF_MAP_H
 #include <linux/compiler.h>
 #include <linux/list.h>
 #include <linux/rbtree.h>
 #include <stdio.h>
 #include <stdbool.h>
 #include <linux/types.h>
 enum map_type {
 	MAP__FUNCTION = 0,
 	MAP__VARIABLE,
 };
 #define MAP__NR_TYPES (MAP__VARIABLE + 1)
 extern const char *map_type__name[MAP__NR_TYPES];
 struct dso;
 struct ip_callchain;
 struct ref_reloc_sym;
 struct map_groups;
 struct machine;
 struct perf_evsel;
 struct map {
 	union {
 		struct rb_node	rb_node;
 		struct list_head node;
 	};
 	u64			start;
 	u64			end;
 	u8 /* enum map_type */	type;
 	bool			referenced;
 	bool			erange_warned;
 	u32			priv;
 	u32			prot;
 	u32			flags;
 	u64			pgoff;
 	u64			reloc;
 	u32			maj, min; /* only valid for MMAP2 record */
 	u64			ino;      /* only valid for MMAP2 record */
 	u64			ino_generation;/* only valid for MMAP2 record */
 	/* ip -> dso rip */
 	u64			(*map_ip)(struct map *, u64);
 	/* dso rip -> ip */
 	u64			(*unmap_ip)(struct map *, u64);
 	struct dso		*dso;
 	struct map_groups	*groups;
 };
 struct kmap {
 	struct ref_reloc_sym	*ref_reloc_sym;
 	struct map_groups	*kmaps;
 };
 struct map_groups {
 	struct rb_root	 maps[MAP__NR_TYPES];
 	struct list_head removed_maps[MAP__NR_TYPES];
 	struct machine	 *machine;
 	int		 refcnt;
 };
 struct map_groups *map_groups__new(struct machine *machine);
 void map_groups__delete(struct map_groups *mg);
 bool map_groups__empty(struct map_groups *mg);
 static inline struct map_groups *map_groups__get(struct map_groups *mg)
 {
 	++mg->refcnt;
 	return mg;
 }
 void map_groups__put(struct map_groups *mg);
 static inline struct kmap *map__kmap(struct map *map)
 {
 	return (struct kmap *)(map + 1);
 }
 static inline u64 map__map_ip(struct map *map, u64 ip)
 {
 	return ip - map->start + map->pgoff;
 }
 static inline u64 map__unmap_ip(struct map *map, u64 ip)
 {
 	return ip + map->start - map->pgoff;
 }
 static inline u64 identity__map_ip(struct map *map __maybe_unused, u64 ip)
 {
 	return ip;
 }
 /* rip/ip <-> addr suitable for passing to `objdump --start-address=` */
 u64 map__rip_2objdump(struct map *map, u64 rip);
 /* objdump address -> memory address */
 u64 map__objdump_2mem(struct map *map, u64 ip);
 struct symbol;
 struct thread;
 /* map__for_each_symbol - iterate over the symbols in the given map
  *
  * @map: the 'struct map *' in which symbols itereated
  * @pos: the 'struct symbol *' to use as a loop cursor
  * @n: the 'struct rb_node *' to use as a temporary storage
  * Note: caller must ensure map->dso is not NULL (map is loaded).
  */
 #define map__for_each_symbol(map, pos, n)	\
 	dso__for_each_symbol(map->dso, pos, n, map->type)
+/* map__for_each_symbol_with_name - iterate over the symbols in the given map
+ *                                  that have the given name
+ *
+ * @map: the 'struct map *' in which symbols itereated
+ * @sym_name: the symbol name
+ * @pos: the 'struct symbol *' to use as a loop cursor
+ * @filter: to use when loading the DSO
+ */
+#define __map__for_each_symbol_by_name(map, sym_name, pos, filter)	\
+	for (pos = map__find_symbol_by_name(map, sym_name, filter);	\
+	     pos && strcmp(pos->name, sym_name) == 0;		\
+	     pos = symbol__next_by_name(pos))
+#define map__for_each_symbol_by_name(map, sym_name, pos)		\
+	__map__for_each_symbol_by_name(map, sym_name, (pos), NULL)
 typedef int (*symbol_filter_t)(struct map *map, struct symbol *sym);
 void map__init(struct map *map, enum map_type type,
 	       u64 start, u64 end, u64 pgoff, struct dso *dso);
 struct map *map__new(struct machine *machine, u64 start, u64 len,
 		     u64 pgoff, u32 pid, u32 d_maj, u32 d_min, u64 ino,
 		     u64 ino_gen, u32 prot, u32 flags,
 		     char *filename, enum map_type type, struct thread *thread);
 struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
 void map__delete(struct map *map);
 struct map *map__clone(struct map *map);
 int map__overlap(struct map *l, struct map *r);
 size_t map__fprintf(struct map *map, FILE *fp);
 size_t map__fprintf_dsoname(struct map *map, FILE *fp);
 int map__fprintf_srcline(struct map *map, u64 addr, const char *prefix,
 			 FILE *fp);
 int map__load(struct map *map, symbol_filter_t filter);
 struct symbol *map__find_symbol(struct map *map,
 				u64 addr, symbol_filter_t filter);
 struct symbol *map__find_symbol_by_name(struct map *map, const char *name,
 					symbol_filter_t filter);
 void map__fixup_start(struct map *map);
 void map__fixup_end(struct map *map);
 void map__reloc_vmlinux(struct map *map);
 size_t __map_groups__fprintf_maps(struct map_groups *mg, enum map_type type,
 				  FILE *fp);
 void maps__insert(struct rb_root *maps, struct map *map);
 void maps__remove(struct rb_root *maps, struct map *map);
 struct map *maps__find(struct rb_root *maps, u64 addr);
 struct map *maps__first(struct rb_root *maps);
 struct map *maps__next(struct map *map);
 void map_groups__init(struct map_groups *mg, struct machine *machine);
 void map_groups__exit(struct map_groups *mg);
 int map_groups__clone(struct map_groups *mg,
 		      struct map_groups *parent, enum map_type type);
 size_t map_groups__fprintf(struct map_groups *mg, FILE *fp);
 int maps__set_kallsyms_ref_reloc_sym(struct map **maps, const char *symbol_name,
 				     u64 addr);
 static inline void map_groups__insert(struct map_groups *mg, struct map *map)
 {
 	maps__insert(&mg->maps[map->type], map);
 	map->groups = mg;
 }
 static inline void map_groups__remove(struct map_groups *mg, struct map *map)
 {
 	maps__remove(&mg->maps[map->type], map);
 }
 static inline struct map *map_groups__find(struct map_groups *mg,
 					   enum map_type type, u64 addr)
 {
 	return maps__find(&mg->maps[type], addr);
 }
 static inline struct map *map_groups__first(struct map_groups *mg,
 					    enum map_type type)
 {
 	return maps__first(&mg->maps[type]);
 }
 static inline struct map *map_groups__next(struct map *map)
 {
 	return maps__next(map);
 }
 struct symbol *map_groups__find_symbol(struct map_groups *mg,
 				       enum map_type type, u64 addr,
 				       struct map **mapp,
 				       symbol_filter_t filter);
 struct symbol *map_groups__find_symbol_by_name(struct map_groups *mg,
 					       enum map_type type,
 					       const char *name,
 					       struct map **mapp,
 					       symbol_filter_t filter);
 struct addr_map_symbol;
 int map_groups__find_ams(struct addr_map_symbol *ams, symbol_filter_t filter);
 static inline
 struct symbol *map_groups__find_function_by_name(struct map_groups *mg,
 						 const char *name, struct map **mapp,
 						 symbol_filter_t filter)
 {
 	return map_groups__find_symbol_by_name(mg, MAP__FUNCTION, name, mapp, filter);
 }
 int map_groups__fixup_overlappings(struct map_groups *mg, struct map *map,
 				   FILE *fp);
 struct map *map_groups__find_by_name(struct map_groups *mg,
 				     enum map_type type, const char *name);
 void map_groups__flush(struct map_groups *mg);
 #endif /* __PERF_MAP_H */

tools/perf/util/probe-event.c

Diff comments View file @ e742f3d

1	/*	1	/*
2	* probe-event.c : perf-probe definition to probe_events format converter	2	* probe-event.c : perf-probe definition to probe_events format converter
3	*	3	*
4	* Written by Masami Hiramatsu <mhiramat@redhat.com>	4	* Written by Masami Hiramatsu <mhiramat@redhat.com>
5	*	5	*
6	* This program is free software; you can redistribute it and/or modify	6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by	7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or	8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.	9	* (at your option) any later version.
10	*	10	*
11	* This program is distributed in the hope that it will be useful,	11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.	14	* GNU General Public License for more details.
15	*	15	*
16	* You should have received a copy of the GNU General Public License	16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software	17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.	18	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19	*	19	*
20	*/	20	*/
21		21
22	#include <sys/utsname.h>	22	#include <sys/utsname.h>
23	#include <sys/types.h>	23	#include <sys/types.h>
24	#include <sys/stat.h>	24	#include <sys/stat.h>
25	#include <fcntl.h>	25	#include <fcntl.h>
26	#include <errno.h>	26	#include <errno.h>
27	#include <stdio.h>	27	#include <stdio.h>
28	#include <unistd.h>	28	#include <unistd.h>
29	#include <stdlib.h>	29	#include <stdlib.h>
30	#include <string.h>	30	#include <string.h>
31	#include <stdarg.h>	31	#include <stdarg.h>
32	#include <limits.h>	32	#include <limits.h>
33	#include <elf.h>	33	#include <elf.h>
34		34
35	#include "util.h"	35	#include "util.h"
36	#include "event.h"	36	#include "event.h"
37	#include "strlist.h"	37	#include "strlist.h"
38	#include "debug.h"	38	#include "debug.h"
39	#include "cache.h"	39	#include "cache.h"
40	#include "color.h"	40	#include "color.h"
41	#include "symbol.h"	41	#include "symbol.h"
42	#include "thread.h"	42	#include "thread.h"
43	#include <api/fs/debugfs.h>	43	#include <api/fs/debugfs.h>
44	#include "trace-event.h" /* For __maybe_unused */	44	#include "trace-event.h" /* For __maybe_unused */
45	#include "probe-event.h"	45	#include "probe-event.h"
46	#include "probe-finder.h"	46	#include "probe-finder.h"
47	#include "session.h"	47	#include "session.h"
48		48
49	#define MAX_CMDLEN 256	49	#define MAX_CMDLEN 256
50	#define PERFPROBE_GROUP "probe"	50	#define PERFPROBE_GROUP "probe"
51		51
52	bool probe_event_dry_run; /* Dry run flag */	52	bool probe_event_dry_run; /* Dry run flag */
53		53
54	#define semantic_error(msg ...) pr_err("Semantic error :" msg)	54	#define semantic_error(msg ...) pr_err("Semantic error :" msg)
55		55
56	/* If there is no space to write, returns -E2BIG. */	56	/* If there is no space to write, returns -E2BIG. */
57	static int e_snprintf(char str, size_t size, const char format, ...)	57	static int e_snprintf(char str, size_t size, const char format, ...)
58	__attribute__((format(printf, 3, 4)));	58	__attribute__((format(printf, 3, 4)));
59		59
60	static int e_snprintf(char str, size_t size, const char format, ...)	60	static int e_snprintf(char str, size_t size, const char format, ...)
61	{	61	{
62	int ret;	62	int ret;
63	va_list ap;	63	va_list ap;
64	va_start(ap, format);	64	va_start(ap, format);
65	ret = vsnprintf(str, size, format, ap);	65	ret = vsnprintf(str, size, format, ap);
66	va_end(ap);	66	va_end(ap);
67	if (ret >= (int)size)	67	if (ret >= (int)size)
68	ret = -E2BIG;	68	ret = -E2BIG;
69	return ret;	69	return ret;
70	}	70	}
71		71
72	static char synthesize_perf_probe_point(struct perf_probe_point pp);	72	static char synthesize_perf_probe_point(struct perf_probe_point pp);
73	static void clear_probe_trace_event(struct probe_trace_event *tev);	73	static void clear_probe_trace_event(struct probe_trace_event *tev);
74	static struct machine *host_machine;	74	static struct machine *host_machine;
75		75
76	/* Initialize symbol maps and path of vmlinux/modules */	76	/* Initialize symbol maps and path of vmlinux/modules */
77	static int init_symbol_maps(bool user_only)	77	static int init_symbol_maps(bool user_only)
78	{	78	{
79	int ret;	79	int ret;
80		80
81	symbol_conf.sort_by_name = true;	81	symbol_conf.sort_by_name = true;
82	ret = symbol__init(NULL);	82	ret = symbol__init(NULL);
83	if (ret < 0) {	83	if (ret < 0) {
84	pr_debug("Failed to init symbol map.\n");	84	pr_debug("Failed to init symbol map.\n");
85	goto out;	85	goto out;
86	}	86	}
87		87
88	if (host_machine \|\| user_only) /* already initialized */	88	if (host_machine \|\| user_only) /* already initialized */
89	return 0;	89	return 0;
90		90
91	if (symbol_conf.vmlinux_name)	91	if (symbol_conf.vmlinux_name)
92	pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);	92	pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
93		93
94	host_machine = machine__new_host();	94	host_machine = machine__new_host();
95	if (!host_machine) {	95	if (!host_machine) {
96	pr_debug("machine__new_host() failed.\n");	96	pr_debug("machine__new_host() failed.\n");
97	symbol__exit();	97	symbol__exit();
98	ret = -1;	98	ret = -1;
99	}	99	}
100	out:	100	out:
101	if (ret < 0)	101	if (ret < 0)
102	pr_warning("Failed to init vmlinux path.\n");	102	pr_warning("Failed to init vmlinux path.\n");
103	return ret;	103	return ret;
104	}	104	}
105		105
106	static void exit_symbol_maps(void)	106	static void exit_symbol_maps(void)
107	{	107	{
108	if (host_machine) {	108	if (host_machine) {
109	machine__delete(host_machine);	109	machine__delete(host_machine);
110	host_machine = NULL;	110	host_machine = NULL;
111	}	111	}
112	symbol__exit();	112	symbol__exit();
113	}	113	}
114		114
115	static struct symbol __find_kernel_function_by_name(const char name,	115	static struct symbol __find_kernel_function_by_name(const char name,
116	struct map **mapp)	116	struct map **mapp)
117	{	117	{
118	return machine__find_kernel_function_by_name(host_machine, name, mapp,	118	return machine__find_kernel_function_by_name(host_machine, name, mapp,
119	NULL);	119	NULL);
120	}	120	}
121		121
122	static struct symbol __find_kernel_function(u64 addr, struct map *mapp)	122	static struct symbol __find_kernel_function(u64 addr, struct map *mapp)
123	{	123	{
124	return machine__find_kernel_function(host_machine, addr, mapp, NULL);	124	return machine__find_kernel_function(host_machine, addr, mapp, NULL);
125	}	125	}
126		126
127	static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void)	127	static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void)
128	{	128	{
129	/* kmap->ref_reloc_sym should be set if host_machine is initialized */	129	/* kmap->ref_reloc_sym should be set if host_machine is initialized */
130	struct kmap *kmap;	130	struct kmap *kmap;
131		131
132	if (map__load(host_machine->vmlinux_maps[MAP__FUNCTION], NULL) < 0)	132	if (map__load(host_machine->vmlinux_maps[MAP__FUNCTION], NULL) < 0)
133	return NULL;	133	return NULL;
134		134
135	kmap = map__kmap(host_machine->vmlinux_maps[MAP__FUNCTION]);	135	kmap = map__kmap(host_machine->vmlinux_maps[MAP__FUNCTION]);
136	return kmap->ref_reloc_sym;	136	return kmap->ref_reloc_sym;
137	}	137	}
138		138
139	static u64 kernel_get_symbol_address_by_name(const char *name, bool reloc)	139	static u64 kernel_get_symbol_address_by_name(const char *name, bool reloc)
140	{	140	{
141	struct ref_reloc_sym *reloc_sym;	141	struct ref_reloc_sym *reloc_sym;
142	struct symbol *sym;	142	struct symbol *sym;
143	struct map *map;	143	struct map *map;
144		144
145	/* ref_reloc_sym is just a label. Need a special fix*/	145	/* ref_reloc_sym is just a label. Need a special fix*/
146	reloc_sym = kernel_get_ref_reloc_sym();	146	reloc_sym = kernel_get_ref_reloc_sym();
147	if (reloc_sym && strcmp(name, reloc_sym->name) == 0)	147	if (reloc_sym && strcmp(name, reloc_sym->name) == 0)
148	return (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;	148	return (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;
149	else {	149	else {
150	sym = __find_kernel_function_by_name(name, &map);	150	sym = __find_kernel_function_by_name(name, &map);
151	if (sym)	151	if (sym)
152	return map->unmap_ip(map, sym->start) -	152	return map->unmap_ip(map, sym->start) -
153	(reloc) ? 0 : map->reloc;	153	(reloc) ? 0 : map->reloc;
154	}	154	}
155	return 0;	155	return 0;
156	}	156	}
157		157
158	static struct map kernel_get_module_map(const char module)	158	static struct map kernel_get_module_map(const char module)
159	{	159	{
160	struct rb_node *nd;	160	struct rb_node *nd;
161	struct map_groups *grp = &host_machine->kmaps;	161	struct map_groups *grp = &host_machine->kmaps;
162		162
163	/* A file path -- this is an offline module */	163	/* A file path -- this is an offline module */
164	if (module && strchr(module, '/'))	164	if (module && strchr(module, '/'))
165	return machine__new_module(host_machine, 0, module);	165	return machine__new_module(host_machine, 0, module);
166		166
167	if (!module)	167	if (!module)
168	module = "kernel";	168	module = "kernel";
169		169
170	for (nd = rb_first(&grp->maps[MAP__FUNCTION]); nd; nd = rb_next(nd)) {	170	for (nd = rb_first(&grp->maps[MAP__FUNCTION]); nd; nd = rb_next(nd)) {
171	struct map *pos = rb_entry(nd, struct map, rb_node);	171	struct map *pos = rb_entry(nd, struct map, rb_node);
172	if (strncmp(pos->dso->short_name + 1, module,	172	if (strncmp(pos->dso->short_name + 1, module,
173	pos->dso->short_name_len - 2) == 0) {	173	pos->dso->short_name_len - 2) == 0) {
174	return pos;	174	return pos;
175	}	175	}
176	}	176	}
177	return NULL;	177	return NULL;
178	}	178	}
179		179
180	static struct dso kernel_get_module_dso(const char module)	180	static struct dso kernel_get_module_dso(const char module)
181	{	181	{
182	struct dso *dso;	182	struct dso *dso;
183	struct map *map;	183	struct map *map;
184	const char *vmlinux_name;	184	const char *vmlinux_name;
185		185
186	if (module) {	186	if (module) {
187	list_for_each_entry(dso, &host_machine->kernel_dsos.head,	187	list_for_each_entry(dso, &host_machine->kernel_dsos.head,
188	node) {	188	node) {
189	if (strncmp(dso->short_name + 1, module,	189	if (strncmp(dso->short_name + 1, module,
190	dso->short_name_len - 2) == 0)	190	dso->short_name_len - 2) == 0)
191	goto found;	191	goto found;
192	}	192	}
193	pr_debug("Failed to find module %s.\n", module);	193	pr_debug("Failed to find module %s.\n", module);
194	return NULL;	194	return NULL;
195	}	195	}
196		196
197	map = host_machine->vmlinux_maps[MAP__FUNCTION];	197	map = host_machine->vmlinux_maps[MAP__FUNCTION];
198	dso = map->dso;	198	dso = map->dso;
199		199
200	vmlinux_name = symbol_conf.vmlinux_name;	200	vmlinux_name = symbol_conf.vmlinux_name;
201	if (vmlinux_name) {	201	if (vmlinux_name) {
202	if (dso__load_vmlinux(dso, map, vmlinux_name, false, NULL) <= 0)	202	if (dso__load_vmlinux(dso, map, vmlinux_name, false, NULL) <= 0)
203	return NULL;	203	return NULL;
204	} else {	204	} else {
205	if (dso__load_vmlinux_path(dso, map, NULL) <= 0) {	205	if (dso__load_vmlinux_path(dso, map, NULL) <= 0) {
206	pr_debug("Failed to load kernel map.\n");	206	pr_debug("Failed to load kernel map.\n");
207	return NULL;	207	return NULL;
208	}	208	}
209	}	209	}
210	found:	210	found:
211	return dso;	211	return dso;
212	}	212	}
213		213
214	const char kernel_get_module_path(const char module)	214	const char kernel_get_module_path(const char module)
215	{	215	{
216	struct dso *dso = kernel_get_module_dso(module);	216	struct dso *dso = kernel_get_module_dso(module);
217	return (dso) ? dso->long_name : NULL;	217	return (dso) ? dso->long_name : NULL;
218	}	218	}
219		219
220	static int convert_exec_to_group(const char exec, char *result)	220	static int convert_exec_to_group(const char exec, char *result)
221	{	221	{
222	char ptr1, ptr2, *exec_copy;	222	char ptr1, ptr2, *exec_copy;
223	char buf[64];	223	char buf[64];
224	int ret;	224	int ret;
225		225
226	exec_copy = strdup(exec);	226	exec_copy = strdup(exec);
227	if (!exec_copy)	227	if (!exec_copy)
228	return -ENOMEM;	228	return -ENOMEM;
229		229
230	ptr1 = basename(exec_copy);	230	ptr1 = basename(exec_copy);
231	if (!ptr1) {	231	if (!ptr1) {
232	ret = -EINVAL;	232	ret = -EINVAL;
233	goto out;	233	goto out;
234	}	234	}
235		235
236	ptr2 = strpbrk(ptr1, "-._");	236	ptr2 = strpbrk(ptr1, "-._");
237	if (ptr2)	237	if (ptr2)
238	*ptr2 = '\0';	238	*ptr2 = '\0';
239	ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1);	239	ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1);
240	if (ret < 0)	240	if (ret < 0)
241	goto out;	241	goto out;
242		242
243	*result = strdup(buf);	243	*result = strdup(buf);
244	ret = *result ? 0 : -ENOMEM;	244	ret = *result ? 0 : -ENOMEM;
245		245
246	out:	246	out:
247	free(exec_copy);	247	free(exec_copy);
248	return ret;	248	return ret;
249	}	249	}
250		250
251	static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)	251	static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
252	{	252	{
253	int i;	253	int i;
254		254
255	for (i = 0; i < ntevs; i++)	255	for (i = 0; i < ntevs; i++)
256	clear_probe_trace_event(tevs + i);	256	clear_probe_trace_event(tevs + i);
257	}	257	}
258		258
259	#ifdef HAVE_DWARF_SUPPORT	259	#ifdef HAVE_DWARF_SUPPORT
260		260
261	/* Open new debuginfo of given module */	261	/* Open new debuginfo of given module */
262	static struct debuginfo open_debuginfo(const char module, bool silent)	262	static struct debuginfo open_debuginfo(const char module, bool silent)
263	{	263	{
264	const char *path = module;	264	const char *path = module;
265	struct debuginfo *ret;	265	struct debuginfo *ret;
266		266
267	if (!module \|\| !strchr(module, '/')) {	267	if (!module \|\| !strchr(module, '/')) {
268	path = kernel_get_module_path(module);	268	path = kernel_get_module_path(module);
269	if (!path) {	269	if (!path) {
270	if (!silent)	270	if (!silent)
271	pr_err("Failed to find path of %s module.\n",	271	pr_err("Failed to find path of %s module.\n",
272	module ?: "kernel");	272	module ?: "kernel");
273	return NULL;	273	return NULL;
274	}	274	}
275	}	275	}
276	ret = debuginfo__new(path);	276	ret = debuginfo__new(path);
277	if (!ret && !silent) {	277	if (!ret && !silent) {
278	pr_warning("The %s file has no debug information.\n", path);	278	pr_warning("The %s file has no debug information.\n", path);
279	if (!module \|\| !strtailcmp(path, ".ko"))	279	if (!module \|\| !strtailcmp(path, ".ko"))
280	pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, ");	280	pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, ");
281	else	281	else
282	pr_warning("Rebuild with -g, ");	282	pr_warning("Rebuild with -g, ");
283	pr_warning("or install an appropriate debuginfo package.\n");	283	pr_warning("or install an appropriate debuginfo package.\n");
284	}	284	}
285	return ret;	285	return ret;
286	}	286	}
287		287
288		288
289	static int get_text_start_address(const char exec, unsigned long address)	289	static int get_text_start_address(const char exec, unsigned long address)
290	{	290	{
291	Elf *elf;	291	Elf *elf;
292	GElf_Ehdr ehdr;	292	GElf_Ehdr ehdr;
293	GElf_Shdr shdr;	293	GElf_Shdr shdr;
294	int fd, ret = -ENOENT;	294	int fd, ret = -ENOENT;
295		295
296	fd = open(exec, O_RDONLY);	296	fd = open(exec, O_RDONLY);
297	if (fd < 0)	297	if (fd < 0)
298	return -errno;	298	return -errno;
299		299
300	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);	300	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
301	if (elf == NULL)	301	if (elf == NULL)
302	return -EINVAL;	302	return -EINVAL;
303		303
304	if (gelf_getehdr(elf, &ehdr) == NULL)	304	if (gelf_getehdr(elf, &ehdr) == NULL)
305	goto out;	305	goto out;
306		306
307	if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL))	307	if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL))
308	goto out;	308	goto out;
309		309
310	*address = shdr.sh_addr - shdr.sh_offset;	310	*address = shdr.sh_addr - shdr.sh_offset;
311	ret = 0;	311	ret = 0;
312	out:	312	out:
313	elf_end(elf);	313	elf_end(elf);
314	return ret;	314	return ret;
315	}	315	}
316		316
317	/*	317	/*
318	* Convert trace point to probe point with debuginfo	318	* Convert trace point to probe point with debuginfo
319	*/	319	*/
320	static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp,	320	static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp,
321	struct perf_probe_point *pp,	321	struct perf_probe_point *pp,
322	bool is_kprobe)	322	bool is_kprobe)
323	{	323	{
324	struct debuginfo *dinfo = NULL;	324	struct debuginfo *dinfo = NULL;
325	unsigned long stext = 0;	325	unsigned long stext = 0;
326	u64 addr = tp->address;	326	u64 addr = tp->address;
327	int ret = -ENOENT;	327	int ret = -ENOENT;
328		328
329	/* convert the address to dwarf address */	329	/* convert the address to dwarf address */
330	if (!is_kprobe) {	330	if (!is_kprobe) {
331	if (!addr) {	331	if (!addr) {
332	ret = -EINVAL;	332	ret = -EINVAL;
333	goto error;	333	goto error;
334	}	334	}
335	ret = get_text_start_address(tp->module, &stext);	335	ret = get_text_start_address(tp->module, &stext);
336	if (ret < 0)	336	if (ret < 0)
337	goto error;	337	goto error;
338	addr += stext;	338	addr += stext;
339	} else {	339	} else {
340	addr = kernel_get_symbol_address_by_name(tp->symbol, false);	340	addr = kernel_get_symbol_address_by_name(tp->symbol, false);
341	if (addr == 0)	341	if (addr == 0)
342	goto error;	342	goto error;
343	addr += tp->offset;	343	addr += tp->offset;
344	}	344	}
345		345
346	pr_debug("try to find information at %" PRIx64 " in %s\n", addr,	346	pr_debug("try to find information at %" PRIx64 " in %s\n", addr,
347	tp->module ? : "kernel");	347	tp->module ? : "kernel");
348		348
349	dinfo = open_debuginfo(tp->module, verbose == 0);	349	dinfo = open_debuginfo(tp->module, verbose == 0);
350	if (dinfo) {	350	if (dinfo) {
351	ret = debuginfo__find_probe_point(dinfo,	351	ret = debuginfo__find_probe_point(dinfo,
352	(unsigned long)addr, pp);	352	(unsigned long)addr, pp);
353	debuginfo__delete(dinfo);	353	debuginfo__delete(dinfo);
354	} else	354	} else
355	ret = -ENOENT;	355	ret = -ENOENT;
356		356
357	if (ret > 0) {	357	if (ret > 0) {
358	pp->retprobe = tp->retprobe;	358	pp->retprobe = tp->retprobe;
359	return 0;	359	return 0;
360	}	360	}
361	error:	361	error:
362	pr_debug("Failed to find corresponding probes from debuginfo.\n");	362	pr_debug("Failed to find corresponding probes from debuginfo.\n");
363	return ret ? : -ENOENT;	363	return ret ? : -ENOENT;
364	}	364	}
365		365
366	static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs,	366	static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs,
367	int ntevs, const char *exec)	367	int ntevs, const char *exec)
368	{	368	{
369	int i, ret = 0;	369	int i, ret = 0;
370	unsigned long stext = 0;	370	unsigned long stext = 0;
371		371
372	if (!exec)	372	if (!exec)
373	return 0;	373	return 0;
374		374
375	ret = get_text_start_address(exec, &stext);	375	ret = get_text_start_address(exec, &stext);
376	if (ret < 0)	376	if (ret < 0)
377	return ret;	377	return ret;
378		378
379	for (i = 0; i < ntevs && ret >= 0; i++) {	379	for (i = 0; i < ntevs && ret >= 0; i++) {
380	/* point.address is the addres of point.symbol + point.offset */	380	/* point.address is the addres of point.symbol + point.offset */
381	tevs[i].point.address -= stext;	381	tevs[i].point.address -= stext;
382	tevs[i].point.module = strdup(exec);	382	tevs[i].point.module = strdup(exec);
383	if (!tevs[i].point.module) {	383	if (!tevs[i].point.module) {
384	ret = -ENOMEM;	384	ret = -ENOMEM;
385	break;	385	break;
386	}	386	}
387	tevs[i].uprobes = true;	387	tevs[i].uprobes = true;
388	}	388	}
389		389
390	return ret;	390	return ret;
391	}	391	}
392		392
393	static int add_module_to_probe_trace_events(struct probe_trace_event *tevs,	393	static int add_module_to_probe_trace_events(struct probe_trace_event *tevs,
394	int ntevs, const char *module)	394	int ntevs, const char *module)
395	{	395	{
396	int i, ret = 0;	396	int i, ret = 0;
397	char *tmp;	397	char *tmp;
398		398
399	if (!module)	399	if (!module)
400	return 0;	400	return 0;
401		401
402	tmp = strrchr(module, '/');	402	tmp = strrchr(module, '/');
403	if (tmp) {	403	if (tmp) {
404	/* This is a module path -- get the module name */	404	/* This is a module path -- get the module name */
405	module = strdup(tmp + 1);	405	module = strdup(tmp + 1);
406	if (!module)	406	if (!module)
407	return -ENOMEM;	407	return -ENOMEM;
408	tmp = strchr(module, '.');	408	tmp = strchr(module, '.');
409	if (tmp)	409	if (tmp)
410	*tmp = '\0';	410	*tmp = '\0';
411	tmp = (char )module; / For free() */	411	tmp = (char )module; / For free() */
412	}	412	}
413		413
414	for (i = 0; i < ntevs; i++) {	414	for (i = 0; i < ntevs; i++) {
415	tevs[i].point.module = strdup(module);	415	tevs[i].point.module = strdup(module);
416	if (!tevs[i].point.module) {	416	if (!tevs[i].point.module) {
417	ret = -ENOMEM;	417	ret = -ENOMEM;
418	break;	418	break;
419	}	419	}
420	}	420	}
421		421
422	free(tmp);	422	free(tmp);
423	return ret;	423	return ret;
424	}	424	}
425		425
426	/* Post processing the probe events */	426	/* Post processing the probe events */
427	static int post_process_probe_trace_events(struct probe_trace_event *tevs,	427	static int post_process_probe_trace_events(struct probe_trace_event *tevs,
428	int ntevs, const char *module,	428	int ntevs, const char *module,
429	bool uprobe)	429	bool uprobe)
430	{	430	{
431	struct ref_reloc_sym *reloc_sym;	431	struct ref_reloc_sym *reloc_sym;
432	char *tmp;	432	char *tmp;
433	int i;	433	int i;
434		434
435	if (uprobe)	435	if (uprobe)
436	return add_exec_to_probe_trace_events(tevs, ntevs, module);	436	return add_exec_to_probe_trace_events(tevs, ntevs, module);
437		437
438	/* Note that currently ref_reloc_sym based probe is not for drivers */	438	/* Note that currently ref_reloc_sym based probe is not for drivers */
439	if (module)	439	if (module)
440	return add_module_to_probe_trace_events(tevs, ntevs, module);	440	return add_module_to_probe_trace_events(tevs, ntevs, module);
441		441
442	reloc_sym = kernel_get_ref_reloc_sym();	442	reloc_sym = kernel_get_ref_reloc_sym();
443	if (!reloc_sym) {	443	if (!reloc_sym) {
444	pr_warning("Relocated base symbol is not found!\n");	444	pr_warning("Relocated base symbol is not found!\n");
445	return -EINVAL;	445	return -EINVAL;
446	}	446	}
447		447
448	for (i = 0; i < ntevs; i++) {	448	for (i = 0; i < ntevs; i++) {
449	if (tevs[i].point.address) {	449	if (tevs[i].point.address && !tevs[i].point.retprobe) {
450	tmp = strdup(reloc_sym->name);	450	tmp = strdup(reloc_sym->name);
451	if (!tmp)	451	if (!tmp)
452	return -ENOMEM;	452	return -ENOMEM;
453	free(tevs[i].point.symbol);	453	free(tevs[i].point.symbol);
454	tevs[i].point.symbol = tmp;	454	tevs[i].point.symbol = tmp;
455	tevs[i].point.offset = tevs[i].point.address -	455	tevs[i].point.offset = tevs[i].point.address -
456	reloc_sym->unrelocated_addr;	456	reloc_sym->unrelocated_addr;
457	}	457	}
458	}	458	}
459	return 0;	459	return 0;
460	}	460	}
461		461
462	/* Try to find perf_probe_event with debuginfo */	462	/* Try to find perf_probe_event with debuginfo */
463	static int try_to_find_probe_trace_events(struct perf_probe_event *pev,	463	static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
464	struct probe_trace_event **tevs,	464	struct probe_trace_event **tevs,
465	int max_tevs, const char *target)	465	int max_tevs, const char *target)
466	{	466	{
467	bool need_dwarf = perf_probe_event_need_dwarf(pev);	467	bool need_dwarf = perf_probe_event_need_dwarf(pev);
468	struct debuginfo *dinfo;	468	struct debuginfo *dinfo;
469	int ntevs, ret = 0;	469	int ntevs, ret = 0;
470		470
471	dinfo = open_debuginfo(target, !need_dwarf);	471	dinfo = open_debuginfo(target, !need_dwarf);
472		472
473	if (!dinfo) {	473	if (!dinfo) {
474	if (need_dwarf)	474	if (need_dwarf)
475	return -ENOENT;	475	return -ENOENT;
476	pr_debug("Could not open debuginfo. Try to use symbols.\n");	476	pr_debug("Could not open debuginfo. Try to use symbols.\n");
477	return 0;	477	return 0;
478	}	478	}
479		479
480	pr_debug("Try to find probe point from debuginfo.\n");	480	pr_debug("Try to find probe point from debuginfo.\n");
481	/* Searching trace events corresponding to a probe event */	481	/* Searching trace events corresponding to a probe event */
482	ntevs = debuginfo__find_trace_events(dinfo, pev, tevs, max_tevs);	482	ntevs = debuginfo__find_trace_events(dinfo, pev, tevs, max_tevs);
483		483
484	debuginfo__delete(dinfo);	484	debuginfo__delete(dinfo);
485		485
486	if (ntevs > 0) { /* Succeeded to find trace events */	486	if (ntevs > 0) { /* Succeeded to find trace events */
487	pr_debug("Found %d probe_trace_events.\n", ntevs);	487	pr_debug("Found %d probe_trace_events.\n", ntevs);
488	ret = post_process_probe_trace_events(*tevs, ntevs,	488	ret = post_process_probe_trace_events(*tevs, ntevs,
489	target, pev->uprobes);	489	target, pev->uprobes);
490	if (ret < 0) {	490	if (ret < 0) {
491	clear_probe_trace_events(*tevs, ntevs);	491	clear_probe_trace_events(*tevs, ntevs);
492	zfree(tevs);	492	zfree(tevs);
493	}	493	}
494	return ret < 0 ? ret : ntevs;	494	return ret < 0 ? ret : ntevs;
495	}	495	}
496		496
497	if (ntevs == 0) { /* No error but failed to find probe point. */	497	if (ntevs == 0) { /* No error but failed to find probe point. */
498	pr_warning("Probe point '%s' not found in debuginfo.\n",	498	pr_warning("Probe point '%s' not found in debuginfo.\n",
499	synthesize_perf_probe_point(&pev->point));	499	synthesize_perf_probe_point(&pev->point));
500	if (need_dwarf)	500	if (need_dwarf)
501	return -ENOENT;	501	return -ENOENT;
502	return 0;	502	return 0;
503	}	503	}
504	/* Error path : ntevs < 0 */	504	/* Error path : ntevs < 0 */
505	pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);	505	pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
506	if (ntevs == -EBADF) {	506	if (ntevs == -EBADF) {
507	pr_warning("Warning: No dwarf info found in the vmlinux - "	507	pr_warning("Warning: No dwarf info found in the vmlinux - "
508	"please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");	508	"please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
509	if (!need_dwarf) {	509	if (!need_dwarf) {
510	pr_debug("Trying to use symbols.\n");	510	pr_debug("Trying to use symbols.\n");
511	return 0;	511	return 0;
512	}	512	}
513	}	513	}
514	return ntevs;	514	return ntevs;
515	}	515	}
516		516
517	/*	517	/*
518	* Find a src file from a DWARF tag path. Prepend optional source path prefix	518	* Find a src file from a DWARF tag path. Prepend optional source path prefix
519	* and chop off leading directories that do not exist. Result is passed back as	519	* and chop off leading directories that do not exist. Result is passed back as
520	* a newly allocated path on success.	520	* a newly allocated path on success.
521	* Return 0 if file was found and readable, -errno otherwise.	521	* Return 0 if file was found and readable, -errno otherwise.
522	*/	522	*/
523	static int get_real_path(const char raw_path, const char comp_dir,	523	static int get_real_path(const char raw_path, const char comp_dir,
524	char **new_path)	524	char **new_path)
525	{	525	{
526	const char *prefix = symbol_conf.source_prefix;	526	const char *prefix = symbol_conf.source_prefix;
527		527
528	if (!prefix) {	528	if (!prefix) {
529	if (raw_path[0] != '/' && comp_dir)	529	if (raw_path[0] != '/' && comp_dir)
530	/* If not an absolute path, try to use comp_dir */	530	/* If not an absolute path, try to use comp_dir */
531	prefix = comp_dir;	531	prefix = comp_dir;
532	else {	532	else {
533	if (access(raw_path, R_OK) == 0) {	533	if (access(raw_path, R_OK) == 0) {
534	*new_path = strdup(raw_path);	534	*new_path = strdup(raw_path);
535	return 0;	535	return 0;
536	} else	536	} else
537	return -errno;	537	return -errno;
538	}	538	}
539	}	539	}
540		540
541	*new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));	541	*new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
542	if (!*new_path)	542	if (!*new_path)
543	return -ENOMEM;	543	return -ENOMEM;
544		544
545	for (;;) {	545	for (;;) {
546	sprintf(*new_path, "%s/%s", prefix, raw_path);	546	sprintf(*new_path, "%s/%s", prefix, raw_path);
547		547
548	if (access(*new_path, R_OK) == 0)	548	if (access(*new_path, R_OK) == 0)
549	return 0;	549	return 0;
550		550
551	if (!symbol_conf.source_prefix)	551	if (!symbol_conf.source_prefix)
552	/* In case of searching comp_dir, don't retry */	552	/* In case of searching comp_dir, don't retry */
553	return -errno;	553	return -errno;
554		554
555	switch (errno) {	555	switch (errno) {
556	case ENAMETOOLONG:	556	case ENAMETOOLONG:
557	case ENOENT:	557	case ENOENT:
558	case EROFS:	558	case EROFS:
559	case EFAULT:	559	case EFAULT:
560	raw_path = strchr(++raw_path, '/');	560	raw_path = strchr(++raw_path, '/');
561	if (!raw_path) {	561	if (!raw_path) {
562	zfree(new_path);	562	zfree(new_path);
563	return -ENOENT;	563	return -ENOENT;
564	}	564	}
565	continue;	565	continue;
566		566
567	default:	567	default:
568	zfree(new_path);	568	zfree(new_path);
569	return -errno;	569	return -errno;
570	}	570	}
571	}	571	}
572	}	572	}
573		573
574	#define LINEBUF_SIZE 256	574	#define LINEBUF_SIZE 256
575	#define NR_ADDITIONAL_LINES 2	575	#define NR_ADDITIONAL_LINES 2
576		576
577	static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)	577	static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
578	{	578	{
579	char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE];	579	char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE];
580	const char *color = show_num ? "" : PERF_COLOR_BLUE;	580	const char *color = show_num ? "" : PERF_COLOR_BLUE;
581	const char *prefix = NULL;	581	const char *prefix = NULL;
582		582
583	do {	583	do {
584	if (fgets(buf, LINEBUF_SIZE, fp) == NULL)	584	if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
585	goto error;	585	goto error;
586	if (skip)	586	if (skip)
587	continue;	587	continue;
588	if (!prefix) {	588	if (!prefix) {
589	prefix = show_num ? "%7d " : " ";	589	prefix = show_num ? "%7d " : " ";
590	color_fprintf(stdout, color, prefix, l);	590	color_fprintf(stdout, color, prefix, l);
591	}	591	}
592	color_fprintf(stdout, color, "%s", buf);	592	color_fprintf(stdout, color, "%s", buf);
593		593
594	} while (strchr(buf, '\n') == NULL);	594	} while (strchr(buf, '\n') == NULL);
595		595
596	return 1;	596	return 1;
597	error:	597	error:
598	if (ferror(fp)) {	598	if (ferror(fp)) {
599	pr_warning("File read error: %s\n",	599	pr_warning("File read error: %s\n",
600	strerror_r(errno, sbuf, sizeof(sbuf)));	600	strerror_r(errno, sbuf, sizeof(sbuf)));
601	return -1;	601	return -1;
602	}	602	}
603	return 0;	603	return 0;
604	}	604	}
605		605
606	static int _show_one_line(FILE *fp, int l, bool skip, bool show_num)	606	static int _show_one_line(FILE *fp, int l, bool skip, bool show_num)
607	{	607	{
608	int rv = __show_one_line(fp, l, skip, show_num);	608	int rv = __show_one_line(fp, l, skip, show_num);
609	if (rv == 0) {	609	if (rv == 0) {
610	pr_warning("Source file is shorter than expected.\n");	610	pr_warning("Source file is shorter than expected.\n");
611	rv = -1;	611	rv = -1;
612	}	612	}
613	return rv;	613	return rv;
614	}	614	}
615		615
616	#define show_one_line_with_num(f,l) _show_one_line(f,l,false,true)	616	#define show_one_line_with_num(f,l) _show_one_line(f,l,false,true)
617	#define show_one_line(f,l) _show_one_line(f,l,false,false)	617	#define show_one_line(f,l) _show_one_line(f,l,false,false)
618	#define skip_one_line(f,l) _show_one_line(f,l,true,false)	618	#define skip_one_line(f,l) _show_one_line(f,l,true,false)
619	#define show_one_line_or_eof(f,l) __show_one_line(f,l,false,false)	619	#define show_one_line_or_eof(f,l) __show_one_line(f,l,false,false)
620		620
621	/*	621	/*
622	* Show line-range always requires debuginfo to find source file and	622	* Show line-range always requires debuginfo to find source file and
623	* line number.	623	* line number.
624	*/	624	*/
625	static int __show_line_range(struct line_range lr, const char module)	625	static int __show_line_range(struct line_range lr, const char module)
626	{	626	{
627	int l = 1;	627	int l = 1;
628	struct int_node *ln;	628	struct int_node *ln;
629	struct debuginfo *dinfo;	629	struct debuginfo *dinfo;
630	FILE *fp;	630	FILE *fp;
631	int ret;	631	int ret;
632	char *tmp;	632	char *tmp;
633	char sbuf[STRERR_BUFSIZE];	633	char sbuf[STRERR_BUFSIZE];
634		634
635	/* Search a line range */	635	/* Search a line range */
636	dinfo = open_debuginfo(module, false);	636	dinfo = open_debuginfo(module, false);
637	if (!dinfo)	637	if (!dinfo)
638	return -ENOENT;	638	return -ENOENT;
639		639
640	ret = debuginfo__find_line_range(dinfo, lr);	640	ret = debuginfo__find_line_range(dinfo, lr);
641	debuginfo__delete(dinfo);	641	debuginfo__delete(dinfo);
642	if (ret == 0 \|\| ret == -ENOENT) {	642	if (ret == 0 \|\| ret == -ENOENT) {
643	pr_warning("Specified source line is not found.\n");	643	pr_warning("Specified source line is not found.\n");
644	return -ENOENT;	644	return -ENOENT;
645	} else if (ret < 0) {	645	} else if (ret < 0) {
646	pr_warning("Debuginfo analysis failed.\n");	646	pr_warning("Debuginfo analysis failed.\n");
647	return ret;	647	return ret;
648	}	648	}
649		649
650	/* Convert source file path */	650	/* Convert source file path */
651	tmp = lr->path;	651	tmp = lr->path;
652	ret = get_real_path(tmp, lr->comp_dir, &lr->path);	652	ret = get_real_path(tmp, lr->comp_dir, &lr->path);
653	free(tmp); /* Free old path */	653	free(tmp); /* Free old path */
654	if (ret < 0) {	654	if (ret < 0) {
655	pr_warning("Failed to find source file path.\n");	655	pr_warning("Failed to find source file path.\n");
656	return ret;	656	return ret;
657	}	657	}
658		658
659	setup_pager();	659	setup_pager();
660		660
661	if (lr->function)	661	if (lr->function)
662	fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,	662	fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
663	lr->start - lr->offset);	663	lr->start - lr->offset);
664	else	664	else
665	fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);	665	fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
666		666
667	fp = fopen(lr->path, "r");	667	fp = fopen(lr->path, "r");
668	if (fp == NULL) {	668	if (fp == NULL) {
669	pr_warning("Failed to open %s: %s\n", lr->path,	669	pr_warning("Failed to open %s: %s\n", lr->path,
670	strerror_r(errno, sbuf, sizeof(sbuf)));	670	strerror_r(errno, sbuf, sizeof(sbuf)));
671	return -errno;	671	return -errno;
672	}	672	}
673	/* Skip to starting line number */	673	/* Skip to starting line number */
674	while (l < lr->start) {	674	while (l < lr->start) {
675	ret = skip_one_line(fp, l++);	675	ret = skip_one_line(fp, l++);
676	if (ret < 0)	676	if (ret < 0)
677	goto end;	677	goto end;
678	}	678	}
679		679
680	intlist__for_each(ln, lr->line_list) {	680	intlist__for_each(ln, lr->line_list) {
681	for (; ln->i > l; l++) {	681	for (; ln->i > l; l++) {
682	ret = show_one_line(fp, l - lr->offset);	682	ret = show_one_line(fp, l - lr->offset);
683	if (ret < 0)	683	if (ret < 0)
684	goto end;	684	goto end;
685	}	685	}
686	ret = show_one_line_with_num(fp, l++ - lr->offset);	686	ret = show_one_line_with_num(fp, l++ - lr->offset);
687	if (ret < 0)	687	if (ret < 0)
688	goto end;	688	goto end;
689	}	689	}
690		690
691	if (lr->end == INT_MAX)	691	if (lr->end == INT_MAX)
692	lr->end = l + NR_ADDITIONAL_LINES;	692	lr->end = l + NR_ADDITIONAL_LINES;
693	while (l <= lr->end) {	693	while (l <= lr->end) {
694	ret = show_one_line_or_eof(fp, l++ - lr->offset);	694	ret = show_one_line_or_eof(fp, l++ - lr->offset);
695	if (ret <= 0)	695	if (ret <= 0)
696	break;	696	break;
697	}	697	}
698	end:	698	end:
699	fclose(fp);	699	fclose(fp);
700	return ret;	700	return ret;
701	}	701	}
702		702
703	int show_line_range(struct line_range lr, const char module, bool user)	703	int show_line_range(struct line_range lr, const char module, bool user)
704	{	704	{
705	int ret;	705	int ret;
706		706
707	ret = init_symbol_maps(user);	707	ret = init_symbol_maps(user);
708	if (ret < 0)	708	if (ret < 0)
709	return ret;	709	return ret;
710	ret = __show_line_range(lr, module);	710	ret = __show_line_range(lr, module);
711	exit_symbol_maps();	711	exit_symbol_maps();
712		712
713	return ret;	713	return ret;
714	}	714	}
715		715
716	static int show_available_vars_at(struct debuginfo *dinfo,	716	static int show_available_vars_at(struct debuginfo *dinfo,
717	struct perf_probe_event *pev,	717	struct perf_probe_event *pev,
718	int max_vls, struct strfilter *_filter,	718	int max_vls, struct strfilter *_filter,
719	bool externs)	719	bool externs)
720	{	720	{
721	char *buf;	721	char *buf;
722	int ret, i, nvars;	722	int ret, i, nvars;
723	struct str_node *node;	723	struct str_node *node;
724	struct variable_list vls = NULL, vl;	724	struct variable_list vls = NULL, vl;
725	const char *var;	725	const char *var;
726		726
727	buf = synthesize_perf_probe_point(&pev->point);	727	buf = synthesize_perf_probe_point(&pev->point);
728	if (!buf)	728	if (!buf)
729	return -EINVAL;	729	return -EINVAL;
730	pr_debug("Searching variables at %s\n", buf);	730	pr_debug("Searching variables at %s\n", buf);
731		731
732	ret = debuginfo__find_available_vars_at(dinfo, pev, &vls,	732	ret = debuginfo__find_available_vars_at(dinfo, pev, &vls,
733	max_vls, externs);	733	max_vls, externs);
734	if (ret <= 0) {	734	if (ret <= 0) {
735	if (ret == 0 \|\| ret == -ENOENT) {	735	if (ret == 0 \|\| ret == -ENOENT) {
736	pr_err("Failed to find the address of %s\n", buf);	736	pr_err("Failed to find the address of %s\n", buf);
737	ret = -ENOENT;	737	ret = -ENOENT;
738	} else	738	} else
739	pr_warning("Debuginfo analysis failed.\n");	739	pr_warning("Debuginfo analysis failed.\n");
740	goto end;	740	goto end;
741	}	741	}
742		742
743	/* Some variables are found */	743	/* Some variables are found */
744	fprintf(stdout, "Available variables at %s\n", buf);	744	fprintf(stdout, "Available variables at %s\n", buf);
745	for (i = 0; i < ret; i++) {	745	for (i = 0; i < ret; i++) {
746	vl = &vls[i];	746	vl = &vls[i];
747	/*	747	/*
748	* A probe point might be converted to	748	* A probe point might be converted to
749	* several trace points.	749	* several trace points.
750	*/	750	*/
751	fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol,	751	fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol,
752	vl->point.offset);	752	vl->point.offset);
753	zfree(&vl->point.symbol);	753	zfree(&vl->point.symbol);
754	nvars = 0;	754	nvars = 0;
755	if (vl->vars) {	755	if (vl->vars) {
756	strlist__for_each(node, vl->vars) {	756	strlist__for_each(node, vl->vars) {
757	var = strchr(node->s, '\t') + 1;	757	var = strchr(node->s, '\t') + 1;
758	if (strfilter__compare(_filter, var)) {	758	if (strfilter__compare(_filter, var)) {
759	fprintf(stdout, "\t\t%s\n", node->s);	759	fprintf(stdout, "\t\t%s\n", node->s);
760	nvars++;	760	nvars++;
761	}	761	}
762	}	762	}
763	strlist__delete(vl->vars);	763	strlist__delete(vl->vars);
764	}	764	}
765	if (nvars == 0)	765	if (nvars == 0)
766	fprintf(stdout, "\t\t(No matched variables)\n");	766	fprintf(stdout, "\t\t(No matched variables)\n");
767	}	767	}
768	free(vls);	768	free(vls);
769	end:	769	end:
770	free(buf);	770	free(buf);
771	return ret;	771	return ret;
772	}	772	}
773		773
774	/* Show available variables on given probe point */	774	/* Show available variables on given probe point */
775	int show_available_vars(struct perf_probe_event *pevs, int npevs,	775	int show_available_vars(struct perf_probe_event *pevs, int npevs,
776	int max_vls, const char *module,	776	int max_vls, const char *module,
777	struct strfilter *_filter, bool externs)	777	struct strfilter *_filter, bool externs)
778	{	778	{
779	int i, ret = 0;	779	int i, ret = 0;
780	struct debuginfo *dinfo;	780	struct debuginfo *dinfo;
781		781
782	ret = init_symbol_maps(pevs->uprobes);	782	ret = init_symbol_maps(pevs->uprobes);
783	if (ret < 0)	783	if (ret < 0)
784	return ret;	784	return ret;
785		785
786	dinfo = open_debuginfo(module, false);	786	dinfo = open_debuginfo(module, false);
787	if (!dinfo) {	787	if (!dinfo) {
788	ret = -ENOENT;	788	ret = -ENOENT;
789	goto out;	789	goto out;
790	}	790	}
791		791
792	setup_pager();	792	setup_pager();
793		793
794	for (i = 0; i < npevs && ret >= 0; i++)	794	for (i = 0; i < npevs && ret >= 0; i++)
795	ret = show_available_vars_at(dinfo, &pevs[i], max_vls, _filter,	795	ret = show_available_vars_at(dinfo, &pevs[i], max_vls, _filter,
796	externs);	796	externs);
797		797
798	debuginfo__delete(dinfo);	798	debuginfo__delete(dinfo);
799	out:	799	out:
800	exit_symbol_maps();	800	exit_symbol_maps();
801	return ret;	801	return ret;
802	}	802	}
803		803
804	#else /* !HAVE_DWARF_SUPPORT */	804	#else /* !HAVE_DWARF_SUPPORT */
805		805
806	static int	806	static int
807	find_perf_probe_point_from_dwarf(struct probe_trace_point *tp __maybe_unused,	807	find_perf_probe_point_from_dwarf(struct probe_trace_point *tp __maybe_unused,
808	struct perf_probe_point *pp __maybe_unused,	808	struct perf_probe_point *pp __maybe_unused,
809	bool is_kprobe __maybe_unused)	809	bool is_kprobe __maybe_unused)
810	{	810	{
811	return -ENOSYS;	811	return -ENOSYS;
812	}	812	}
813		813
814	static int try_to_find_probe_trace_events(struct perf_probe_event *pev,	814	static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
815	struct probe_trace_event **tevs __maybe_unused,	815	struct probe_trace_event **tevs __maybe_unused,
816	int max_tevs __maybe_unused,	816	int max_tevs __maybe_unused,
817	const char *target __maybe_unused)	817	const char *target __maybe_unused)
818	{	818	{
819	if (perf_probe_event_need_dwarf(pev)) {	819	if (perf_probe_event_need_dwarf(pev)) {
820	pr_warning("Debuginfo-analysis is not supported.\n");	820	pr_warning("Debuginfo-analysis is not supported.\n");
821	return -ENOSYS;	821	return -ENOSYS;
822	}	822	}
823		823
824	return 0;	824	return 0;
825	}	825	}
826		826
827	int show_line_range(struct line_range *lr __maybe_unused,	827	int show_line_range(struct line_range *lr __maybe_unused,
828	const char *module __maybe_unused,	828	const char *module __maybe_unused,
829	bool user __maybe_unused)	829	bool user __maybe_unused)
830	{	830	{
831	pr_warning("Debuginfo-analysis is not supported.\n");	831	pr_warning("Debuginfo-analysis is not supported.\n");
832	return -ENOSYS;	832	return -ENOSYS;
833	}	833	}
834		834
835	int show_available_vars(struct perf_probe_event *pevs __maybe_unused,	835	int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
836	int npevs __maybe_unused, int max_vls __maybe_unused,	836	int npevs __maybe_unused, int max_vls __maybe_unused,
837	const char *module __maybe_unused,	837	const char *module __maybe_unused,
838	struct strfilter *filter __maybe_unused,	838	struct strfilter *filter __maybe_unused,
839	bool externs __maybe_unused)	839	bool externs __maybe_unused)
840	{	840	{
841	pr_warning("Debuginfo-analysis is not supported.\n");	841	pr_warning("Debuginfo-analysis is not supported.\n");
842	return -ENOSYS;	842	return -ENOSYS;
843	}	843	}
844	#endif	844	#endif
845		845
846	void line_range__clear(struct line_range *lr)	846	void line_range__clear(struct line_range *lr)
847	{	847	{
848	free(lr->function);	848	free(lr->function);
849	free(lr->file);	849	free(lr->file);
850	free(lr->path);	850	free(lr->path);
851	free(lr->comp_dir);	851	free(lr->comp_dir);
852	intlist__delete(lr->line_list);	852	intlist__delete(lr->line_list);
853	memset(lr, 0, sizeof(*lr));	853	memset(lr, 0, sizeof(*lr));
854	}	854	}
855		855
856	int line_range__init(struct line_range *lr)	856	int line_range__init(struct line_range *lr)
857	{	857	{
858	memset(lr, 0, sizeof(*lr));	858	memset(lr, 0, sizeof(*lr));
859	lr->line_list = intlist__new(NULL);	859	lr->line_list = intlist__new(NULL);
860	if (!lr->line_list)	860	if (!lr->line_list)
861	return -ENOMEM;	861	return -ENOMEM;
862	else	862	else
863	return 0;	863	return 0;
864	}	864	}
865		865
866	static int parse_line_num(char *ptr, int val, const char *what)	866	static int parse_line_num(char *ptr, int val, const char *what)
867	{	867	{
868	const char start = ptr;	868	const char start = ptr;
869		869
870	errno = 0;	870	errno = 0;
871	val = strtol(ptr, ptr, 0);	871	val = strtol(ptr, ptr, 0);
872	if (errno \|\| *ptr == start) {	872	if (errno \|\| *ptr == start) {
873	semantic_error("'%s' is not a valid number.\n", what);	873	semantic_error("'%s' is not a valid number.\n", what);
874	return -EINVAL;	874	return -EINVAL;
875	}	875	}
876	return 0;	876	return 0;
877	}	877	}
878		878
879	/*	879	/*
880	* Stuff 'lr' according to the line range described by 'arg'.	880	* Stuff 'lr' according to the line range described by 'arg'.
881	* The line range syntax is described by:	881	* The line range syntax is described by:
882	*	882	*
883	* SRC[:SLN[+NUM\|-ELN]]	883	* SRC[:SLN[+NUM\|-ELN]]
884	* FNC[@SRC][:SLN[+NUM\|-ELN]]	884	* FNC[@SRC][:SLN[+NUM\|-ELN]]
885	*/	885	*/
886	int parse_line_range_desc(const char arg, struct line_range lr)	886	int parse_line_range_desc(const char arg, struct line_range lr)
887	{	887	{
888	char range, file, *name = strdup(arg);	888	char range, file, *name = strdup(arg);
889	int err;	889	int err;
890		890
891	if (!name)	891	if (!name)
892	return -ENOMEM;	892	return -ENOMEM;
893		893
894	lr->start = 0;	894	lr->start = 0;
895	lr->end = INT_MAX;	895	lr->end = INT_MAX;
896		896
897	range = strchr(name, ':');	897	range = strchr(name, ':');
898	if (range) {	898	if (range) {
899	*range++ = '\0';	899	*range++ = '\0';
900		900
901	err = parse_line_num(&range, &lr->start, "start line");	901	err = parse_line_num(&range, &lr->start, "start line");
902	if (err)	902	if (err)
903	goto err;	903	goto err;
904		904
905	if (range == '+' \|\| range == '-') {	905	if (range == '+' \|\| range == '-') {
906	const char c = *range++;	906	const char c = *range++;
907		907
908	err = parse_line_num(&range, &lr->end, "end line");	908	err = parse_line_num(&range, &lr->end, "end line");
909	if (err)	909	if (err)
910	goto err;	910	goto err;
911		911
912	if (c == '+') {	912	if (c == '+') {
913	lr->end += lr->start;	913	lr->end += lr->start;
914	/*	914	/*
915	* Adjust the number of lines here.	915	* Adjust the number of lines here.
916	* If the number of lines == 1, the	916	* If the number of lines == 1, the
917	* the end of line should be equal to	917	* the end of line should be equal to
918	* the start of line.	918	* the start of line.
919	*/	919	*/
920	lr->end--;	920	lr->end--;
921	}	921	}
922	}	922	}
923		923
924	pr_debug("Line range is %d to %d\n", lr->start, lr->end);	924	pr_debug("Line range is %d to %d\n", lr->start, lr->end);
925		925
926	err = -EINVAL;	926	err = -EINVAL;
927	if (lr->start > lr->end) {	927	if (lr->start > lr->end) {
928	semantic_error("Start line must be smaller"	928	semantic_error("Start line must be smaller"
929	" than end line.\n");	929	" than end line.\n");
930	goto err;	930	goto err;
931	}	931	}
932	if (*range != '\0') {	932	if (*range != '\0') {
933	semantic_error("Tailing with invalid str '%s'.\n", range);	933	semantic_error("Tailing with invalid str '%s'.\n", range);
934	goto err;	934	goto err;
935	}	935	}
936	}	936	}
937		937
938	file = strchr(name, '@');	938	file = strchr(name, '@');
939	if (file) {	939	if (file) {
940	*file = '\0';	940	*file = '\0';
941	lr->file = strdup(++file);	941	lr->file = strdup(++file);
942	if (lr->file == NULL) {	942	if (lr->file == NULL) {
943	err = -ENOMEM;	943	err = -ENOMEM;
944	goto err;	944	goto err;
945	}	945	}
946	lr->function = name;	946	lr->function = name;
947	} else if (strchr(name, '.'))	947	} else if (strchr(name, '.'))
948	lr->file = name;	948	lr->file = name;
949	else	949	else
950	lr->function = name;	950	lr->function = name;
951		951
952	return 0;	952	return 0;
953	err:	953	err:
954	free(name);	954	free(name);
955	return err;	955	return err;
956	}	956	}
957		957
958	/* Check the name is good for event/group */	958	/* Check the name is good for event/group */
959	static bool check_event_name(const char *name)	959	static bool check_event_name(const char *name)
960	{	960	{
961	if (!isalpha(name) && name != '_')	961	if (!isalpha(name) && name != '_')
962	return false;	962	return false;
963	while (*++name != '\0') {	963	while (*++name != '\0') {
964	if (!isalpha(name) && !isdigit(name) && *name != '_')	964	if (!isalpha(name) && !isdigit(name) && *name != '_')
965	return false;	965	return false;
966	}	966	}
967	return true;	967	return true;
968	}	968	}
969		969
970	/* Parse probepoint definition. */	970	/* Parse probepoint definition. */
971	static int parse_perf_probe_point(char arg, struct perf_probe_event pev)	971	static int parse_perf_probe_point(char arg, struct perf_probe_event pev)
972	{	972	{
973	struct perf_probe_point *pp = &pev->point;	973	struct perf_probe_point *pp = &pev->point;
974	char ptr, tmp;	974	char ptr, tmp;
975	char c, nc = 0;	975	char c, nc = 0;
976	/*	976	/*
977	* <Syntax>	977	* <Syntax>
978	* perf probe [EVENT=]SRC[:LN\|;PTN]	978	* perf probe [EVENT=]SRC[:LN\|;PTN]
979	* perf probe [EVENT=]FUNC[@SRC][+OFFS\|%return\|:LN\|;PAT]	979	* perf probe [EVENT=]FUNC[@SRC][+OFFS\|%return\|:LN\|;PAT]
980	*	980	*
981	* TODO:Group name support	981	* TODO:Group name support
982	*/	982	*/
983		983
984	ptr = strpbrk(arg, ";=@+%");	984	ptr = strpbrk(arg, ";=@+%");
985	if (ptr && ptr == '=') { / Event name */	985	if (ptr && ptr == '=') { / Event name */
986	*ptr = '\0';	986	*ptr = '\0';
987	tmp = ptr + 1;	987	tmp = ptr + 1;
988	if (strchr(arg, ':')) {	988	if (strchr(arg, ':')) {
989	semantic_error("Group name is not supported yet.\n");	989	semantic_error("Group name is not supported yet.\n");
990	return -ENOTSUP;	990	return -ENOTSUP;
991	}	991	}
992	if (!check_event_name(arg)) {	992	if (!check_event_name(arg)) {
993	semantic_error("%s is bad for event name -it must "	993	semantic_error("%s is bad for event name -it must "
994	"follow C symbol-naming rule.\n", arg);	994	"follow C symbol-naming rule.\n", arg);
995	return -EINVAL;	995	return -EINVAL;
996	}	996	}
997	pev->event = strdup(arg);	997	pev->event = strdup(arg);
998	if (pev->event == NULL)	998	if (pev->event == NULL)
999	return -ENOMEM;	999	return -ENOMEM;
1000	pev->group = NULL;	1000	pev->group = NULL;
1001	arg = tmp;	1001	arg = tmp;
1002	}	1002	}
1003		1003
1004	ptr = strpbrk(arg, ";:+@%");	1004	ptr = strpbrk(arg, ";:+@%");
1005	if (ptr) {	1005	if (ptr) {
1006	nc = *ptr;	1006	nc = *ptr;
1007	*ptr++ = '\0';	1007	*ptr++ = '\0';
1008	}	1008	}
1009		1009
1010	tmp = strdup(arg);	1010	tmp = strdup(arg);
1011	if (tmp == NULL)	1011	if (tmp == NULL)
1012	return -ENOMEM;	1012	return -ENOMEM;
1013		1013
1014	/* Check arg is function or file and copy it */	1014	/* Check arg is function or file and copy it */
1015	if (strchr(tmp, '.')) /* File */	1015	if (strchr(tmp, '.')) /* File */
1016	pp->file = tmp;	1016	pp->file = tmp;
1017	else /* Function */	1017	else /* Function */
1018	pp->function = tmp;	1018	pp->function = tmp;
1019		1019
1020	/* Parse other options */	1020	/* Parse other options */
1021	while (ptr) {	1021	while (ptr) {
1022	arg = ptr;	1022	arg = ptr;
1023	c = nc;	1023	c = nc;
1024	if (c == ';') { /* Lazy pattern must be the last part */	1024	if (c == ';') { /* Lazy pattern must be the last part */
1025	pp->lazy_line = strdup(arg);	1025	pp->lazy_line = strdup(arg);
1026	if (pp->lazy_line == NULL)	1026	if (pp->lazy_line == NULL)
1027	return -ENOMEM;	1027	return -ENOMEM;
1028	break;	1028	break;
1029	}	1029	}
1030	ptr = strpbrk(arg, ";:+@%");	1030	ptr = strpbrk(arg, ";:+@%");
1031	if (ptr) {	1031	if (ptr) {
1032	nc = *ptr;	1032	nc = *ptr;
1033	*ptr++ = '\0';	1033	*ptr++ = '\0';
1034	}	1034	}
1035	switch (c) {	1035	switch (c) {
1036	case ':': /* Line number */	1036	case ':': /* Line number */
1037	pp->line = strtoul(arg, &tmp, 0);	1037	pp->line = strtoul(arg, &tmp, 0);
1038	if (*tmp != '\0') {	1038	if (*tmp != '\0') {
1039	semantic_error("There is non-digit char"	1039	semantic_error("There is non-digit char"
1040	" in line number.\n");	1040	" in line number.\n");
1041	return -EINVAL;	1041	return -EINVAL;
1042	}	1042	}
1043	break;	1043	break;
1044	case '+': /* Byte offset from a symbol */	1044	case '+': /* Byte offset from a symbol */
1045	pp->offset = strtoul(arg, &tmp, 0);	1045	pp->offset = strtoul(arg, &tmp, 0);
1046	if (*tmp != '\0') {	1046	if (*tmp != '\0') {
1047	semantic_error("There is non-digit character"	1047	semantic_error("There is non-digit character"
1048	" in offset.\n");	1048	" in offset.\n");
1049	return -EINVAL;	1049	return -EINVAL;
1050	}	1050	}
1051	break;	1051	break;
1052	case '@': /* File name */	1052	case '@': /* File name */
1053	if (pp->file) {	1053	if (pp->file) {
1054	semantic_error("SRC@SRC is not allowed.\n");	1054	semantic_error("SRC@SRC is not allowed.\n");
1055	return -EINVAL;	1055	return -EINVAL;
1056	}	1056	}
1057	pp->file = strdup(arg);	1057	pp->file = strdup(arg);
1058	if (pp->file == NULL)	1058	if (pp->file == NULL)
1059	return -ENOMEM;	1059	return -ENOMEM;
1060	break;	1060	break;
1061	case '%': /* Probe places */	1061	case '%': /* Probe places */
1062	if (strcmp(arg, "return") == 0) {	1062	if (strcmp(arg, "return") == 0) {
1063	pp->retprobe = 1;	1063	pp->retprobe = 1;
1064	} else { /* Others not supported yet */	1064	} else { /* Others not supported yet */
1065	semantic_error("%%%s is not supported.\n", arg);	1065	semantic_error("%%%s is not supported.\n", arg);
1066	return -ENOTSUP;	1066	return -ENOTSUP;
1067	}	1067	}
1068	break;	1068	break;
1069	default: /* Buggy case */	1069	default: /* Buggy case */
1070	pr_err("This program has a bug at %s:%d.\n",	1070	pr_err("This program has a bug at %s:%d.\n",
1071	__FILE__, __LINE__);	1071	__FILE__, __LINE__);
1072	return -ENOTSUP;	1072	return -ENOTSUP;
1073	break;	1073	break;
1074	}	1074	}
1075	}	1075	}
1076		1076
1077	/* Exclusion check */	1077	/* Exclusion check */
1078	if (pp->lazy_line && pp->line) {	1078	if (pp->lazy_line && pp->line) {
1079	semantic_error("Lazy pattern can't be used with"	1079	semantic_error("Lazy pattern can't be used with"
1080	" line number.\n");	1080	" line number.\n");
1081	return -EINVAL;	1081	return -EINVAL;
1082	}	1082	}
1083		1083
1084	if (pp->lazy_line && pp->offset) {	1084	if (pp->lazy_line && pp->offset) {
1085	semantic_error("Lazy pattern can't be used with offset.\n");	1085	semantic_error("Lazy pattern can't be used with offset.\n");
1086	return -EINVAL;	1086	return -EINVAL;
1087	}	1087	}
1088		1088
1089	if (pp->line && pp->offset) {	1089	if (pp->line && pp->offset) {
1090	semantic_error("Offset can't be used with line number.\n");	1090	semantic_error("Offset can't be used with line number.\n");
1091	return -EINVAL;	1091	return -EINVAL;
1092	}	1092	}
1093		1093
1094	if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {	1094	if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
1095	semantic_error("File always requires line number or "	1095	semantic_error("File always requires line number or "
1096	"lazy pattern.\n");	1096	"lazy pattern.\n");
1097	return -EINVAL;	1097	return -EINVAL;
1098	}	1098	}
1099		1099
1100	if (pp->offset && !pp->function) {	1100	if (pp->offset && !pp->function) {
1101	semantic_error("Offset requires an entry function.\n");	1101	semantic_error("Offset requires an entry function.\n");
1102	return -EINVAL;	1102	return -EINVAL;
1103	}	1103	}
1104		1104
1105	if (pp->retprobe && !pp->function) {	1105	if (pp->retprobe && !pp->function) {
1106	semantic_error("Return probe requires an entry function.\n");	1106	semantic_error("Return probe requires an entry function.\n");
1107	return -EINVAL;	1107	return -EINVAL;
1108	}	1108	}
1109		1109
1110	if ((pp->offset \|\| pp->line \|\| pp->lazy_line) && pp->retprobe) {	1110	if ((pp->offset \|\| pp->line \|\| pp->lazy_line) && pp->retprobe) {
1111	semantic_error("Offset/Line/Lazy pattern can't be used with "	1111	semantic_error("Offset/Line/Lazy pattern can't be used with "
1112	"return probe.\n");	1112	"return probe.\n");
1113	return -EINVAL;	1113	return -EINVAL;
1114	}	1114	}
1115		1115
1116	pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",	1116	pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
1117	pp->function, pp->file, pp->line, pp->offset, pp->retprobe,	1117	pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
1118	pp->lazy_line);	1118	pp->lazy_line);
1119	return 0;	1119	return 0;
1120	}	1120	}
1121		1121
1122	/* Parse perf-probe event argument */	1122	/* Parse perf-probe event argument */
1123	static int parse_perf_probe_arg(char str, struct perf_probe_arg arg)	1123	static int parse_perf_probe_arg(char str, struct perf_probe_arg arg)
1124	{	1124	{
1125	char tmp, goodname;	1125	char tmp, goodname;
1126	struct perf_probe_arg_field **fieldp;	1126	struct perf_probe_arg_field **fieldp;
1127		1127
1128	pr_debug("parsing arg: %s into ", str);	1128	pr_debug("parsing arg: %s into ", str);
1129		1129
1130	tmp = strchr(str, '=');	1130	tmp = strchr(str, '=');
1131	if (tmp) {	1131	if (tmp) {
1132	arg->name = strndup(str, tmp - str);	1132	arg->name = strndup(str, tmp - str);
1133	if (arg->name == NULL)	1133	if (arg->name == NULL)
1134	return -ENOMEM;	1134	return -ENOMEM;
1135	pr_debug("name:%s ", arg->name);	1135	pr_debug("name:%s ", arg->name);
1136	str = tmp + 1;	1136	str = tmp + 1;
1137	}	1137	}
1138		1138
1139	tmp = strchr(str, ':');	1139	tmp = strchr(str, ':');
1140	if (tmp) { /* Type setting */	1140	if (tmp) { /* Type setting */
1141	*tmp = '\0';	1141	*tmp = '\0';
1142	arg->type = strdup(tmp + 1);	1142	arg->type = strdup(tmp + 1);
1143	if (arg->type == NULL)	1143	if (arg->type == NULL)
1144	return -ENOMEM;	1144	return -ENOMEM;
1145	pr_debug("type:%s ", arg->type);	1145	pr_debug("type:%s ", arg->type);
1146	}	1146	}
1147		1147
1148	tmp = strpbrk(str, "-.[");	1148	tmp = strpbrk(str, "-.[");
1149	if (!is_c_varname(str) \|\| !tmp) {	1149	if (!is_c_varname(str) \|\| !tmp) {
1150	/* A variable, register, symbol or special value */	1150	/* A variable, register, symbol or special value */
1151	arg->var = strdup(str);	1151	arg->var = strdup(str);
1152	if (arg->var == NULL)	1152	if (arg->var == NULL)
1153	return -ENOMEM;	1153	return -ENOMEM;
1154	pr_debug("%s\n", arg->var);	1154	pr_debug("%s\n", arg->var);
1155	return 0;	1155	return 0;
1156	}	1156	}
1157		1157
1158	/* Structure fields or array element */	1158	/* Structure fields or array element */
1159	arg->var = strndup(str, tmp - str);	1159	arg->var = strndup(str, tmp - str);
1160	if (arg->var == NULL)	1160	if (arg->var == NULL)
1161	return -ENOMEM;	1161	return -ENOMEM;
1162	goodname = arg->var;	1162	goodname = arg->var;
1163	pr_debug("%s, ", arg->var);	1163	pr_debug("%s, ", arg->var);
1164	fieldp = &arg->field;	1164	fieldp = &arg->field;
1165		1165
1166	do {	1166	do {
1167	*fieldp = zalloc(sizeof(struct perf_probe_arg_field));	1167	*fieldp = zalloc(sizeof(struct perf_probe_arg_field));
1168	if (*fieldp == NULL)	1168	if (*fieldp == NULL)
1169	return -ENOMEM;	1169	return -ENOMEM;
1170	if (tmp == '[') { / Array */	1170	if (tmp == '[') { / Array */
1171	str = tmp;	1171	str = tmp;
1172	(*fieldp)->index = strtol(str + 1, &tmp, 0);	1172	(*fieldp)->index = strtol(str + 1, &tmp, 0);
1173	(*fieldp)->ref = true;	1173	(*fieldp)->ref = true;
1174	if (*tmp != ']' \|\| tmp == str + 1) {	1174	if (*tmp != ']' \|\| tmp == str + 1) {
1175	semantic_error("Array index must be a"	1175	semantic_error("Array index must be a"
1176	" number.\n");	1176	" number.\n");
1177	return -EINVAL;	1177	return -EINVAL;
1178	}	1178	}
1179	tmp++;	1179	tmp++;
1180	if (*tmp == '\0')	1180	if (*tmp == '\0')
1181	tmp = NULL;	1181	tmp = NULL;
1182	} else { /* Structure */	1182	} else { /* Structure */
1183	if (*tmp == '.') {	1183	if (*tmp == '.') {
1184	str = tmp + 1;	1184	str = tmp + 1;
1185	(*fieldp)->ref = false;	1185	(*fieldp)->ref = false;
1186	} else if (tmp[1] == '>') {	1186	} else if (tmp[1] == '>') {
1187	str = tmp + 2;	1187	str = tmp + 2;
1188	(*fieldp)->ref = true;	1188	(*fieldp)->ref = true;
1189	} else {	1189	} else {
1190	semantic_error("Argument parse error: %s\n",	1190	semantic_error("Argument parse error: %s\n",
1191	str);	1191	str);
1192	return -EINVAL;	1192	return -EINVAL;
1193	}	1193	}
1194	tmp = strpbrk(str, "-.[");	1194	tmp = strpbrk(str, "-.[");
1195	}	1195	}
1196	if (tmp) {	1196	if (tmp) {
1197	(*fieldp)->name = strndup(str, tmp - str);	1197	(*fieldp)->name = strndup(str, tmp - str);
1198	if ((*fieldp)->name == NULL)	1198	if ((*fieldp)->name == NULL)
1199	return -ENOMEM;	1199	return -ENOMEM;
1200	if (*str != '[')	1200	if (*str != '[')
1201	goodname = (*fieldp)->name;	1201	goodname = (*fieldp)->name;
1202	pr_debug("%s(%d), ", (fieldp)->name, (fieldp)->ref);	1202	pr_debug("%s(%d), ", (fieldp)->name, (fieldp)->ref);
1203	fieldp = &(*fieldp)->next;	1203	fieldp = &(*fieldp)->next;
1204	}	1204	}
1205	} while (tmp);	1205	} while (tmp);
1206	(*fieldp)->name = strdup(str);	1206	(*fieldp)->name = strdup(str);
1207	if ((*fieldp)->name == NULL)	1207	if ((*fieldp)->name == NULL)
1208	return -ENOMEM;	1208	return -ENOMEM;
1209	if (*str != '[')	1209	if (*str != '[')
1210	goodname = (*fieldp)->name;	1210	goodname = (*fieldp)->name;
1211	pr_debug("%s(%d)\n", (fieldp)->name, (fieldp)->ref);	1211	pr_debug("%s(%d)\n", (fieldp)->name, (fieldp)->ref);
1212		1212
1213	/* If no name is specified, set the last field name (not array index)*/	1213	/* If no name is specified, set the last field name (not array index)*/
1214	if (!arg->name) {	1214	if (!arg->name) {
1215	arg->name = strdup(goodname);	1215	arg->name = strdup(goodname);
1216	if (arg->name == NULL)	1216	if (arg->name == NULL)
1217	return -ENOMEM;	1217	return -ENOMEM;
1218	}	1218	}
1219	return 0;	1219	return 0;
1220	}	1220	}
1221		1221
1222	/* Parse perf-probe event command */	1222	/* Parse perf-probe event command */
1223	int parse_perf_probe_command(const char cmd, struct perf_probe_event pev)	1223	int parse_perf_probe_command(const char cmd, struct perf_probe_event pev)
1224	{	1224	{
1225	char **argv;	1225	char **argv;
1226	int argc, i, ret = 0;	1226	int argc, i, ret = 0;
1227		1227
1228	argv = argv_split(cmd, &argc);	1228	argv = argv_split(cmd, &argc);
1229	if (!argv) {	1229	if (!argv) {
1230	pr_debug("Failed to split arguments.\n");	1230	pr_debug("Failed to split arguments.\n");
1231	return -ENOMEM;	1231	return -ENOMEM;
1232	}	1232	}
1233	if (argc - 1 > MAX_PROBE_ARGS) {	1233	if (argc - 1 > MAX_PROBE_ARGS) {
1234	semantic_error("Too many probe arguments (%d).\n", argc - 1);	1234	semantic_error("Too many probe arguments (%d).\n", argc - 1);
1235	ret = -ERANGE;	1235	ret = -ERANGE;
1236	goto out;	1236	goto out;
1237	}	1237	}
1238	/* Parse probe point */	1238	/* Parse probe point */
1239	ret = parse_perf_probe_point(argv[0], pev);	1239	ret = parse_perf_probe_point(argv[0], pev);
1240	if (ret < 0)	1240	if (ret < 0)
1241	goto out;	1241	goto out;
1242		1242
1243	/* Copy arguments and ensure return probe has no C argument */	1243	/* Copy arguments and ensure return probe has no C argument */
1244	pev->nargs = argc - 1;	1244	pev->nargs = argc - 1;
1245	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);	1245	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1246	if (pev->args == NULL) {	1246	if (pev->args == NULL) {
1247	ret = -ENOMEM;	1247	ret = -ENOMEM;
1248	goto out;	1248	goto out;
1249	}	1249	}
1250	for (i = 0; i < pev->nargs && ret >= 0; i++) {	1250	for (i = 0; i < pev->nargs && ret >= 0; i++) {
1251	ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);	1251	ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
1252	if (ret >= 0 &&	1252	if (ret >= 0 &&
1253	is_c_varname(pev->args[i].var) && pev->point.retprobe) {	1253	is_c_varname(pev->args[i].var) && pev->point.retprobe) {
1254	semantic_error("You can't specify local variable for"	1254	semantic_error("You can't specify local variable for"
1255	" kretprobe.\n");	1255	" kretprobe.\n");
1256	ret = -EINVAL;	1256	ret = -EINVAL;
1257	}	1257	}
1258	}	1258	}
1259	out:	1259	out:
1260	argv_free(argv);	1260	argv_free(argv);
1261		1261
1262	return ret;	1262	return ret;
1263	}	1263	}
1264		1264
1265	/* Return true if this perf_probe_event requires debuginfo */	1265	/* Return true if this perf_probe_event requires debuginfo */
1266	bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)	1266	bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
1267	{	1267	{
1268	int i;	1268	int i;
1269		1269
1270	if (pev->point.file \|\| pev->point.line \|\| pev->point.lazy_line)	1270	if (pev->point.file \|\| pev->point.line \|\| pev->point.lazy_line)
1271	return true;	1271	return true;
1272		1272
1273	for (i = 0; i < pev->nargs; i++)	1273	for (i = 0; i < pev->nargs; i++)
1274	if (is_c_varname(pev->args[i].var))	1274	if (is_c_varname(pev->args[i].var))
1275	return true;	1275	return true;
1276		1276
1277	return false;	1277	return false;
1278	}	1278	}
1279		1279
1280	/* Parse probe_events event into struct probe_point */	1280	/* Parse probe_events event into struct probe_point */
1281	static int parse_probe_trace_command(const char *cmd,	1281	static int parse_probe_trace_command(const char *cmd,
1282	struct probe_trace_event *tev)	1282	struct probe_trace_event *tev)
1283	{	1283	{
1284	struct probe_trace_point *tp = &tev->point;	1284	struct probe_trace_point *tp = &tev->point;
1285	char pr;	1285	char pr;
1286	char *p;	1286	char *p;
1287	char argv0_str = NULL, fmt, fmt1_str, fmt2_str, *fmt3_str;	1287	char argv0_str = NULL, fmt, fmt1_str, fmt2_str, *fmt3_str;
1288	int ret, i, argc;	1288	int ret, i, argc;
1289	char **argv;	1289	char **argv;
1290		1290
1291	pr_debug("Parsing probe_events: %s\n", cmd);	1291	pr_debug("Parsing probe_events: %s\n", cmd);
1292	argv = argv_split(cmd, &argc);	1292	argv = argv_split(cmd, &argc);
1293	if (!argv) {	1293	if (!argv) {
1294	pr_debug("Failed to split arguments.\n");	1294	pr_debug("Failed to split arguments.\n");
1295	return -ENOMEM;	1295	return -ENOMEM;
1296	}	1296	}
1297	if (argc < 2) {	1297	if (argc < 2) {
1298	semantic_error("Too few probe arguments.\n");	1298	semantic_error("Too few probe arguments.\n");
1299	ret = -ERANGE;	1299	ret = -ERANGE;
1300	goto out;	1300	goto out;
1301	}	1301	}
1302		1302
1303	/* Scan event and group name. */	1303	/* Scan event and group name. */
1304	argv0_str = strdup(argv[0]);	1304	argv0_str = strdup(argv[0]);
1305	if (argv0_str == NULL) {	1305	if (argv0_str == NULL) {
1306	ret = -ENOMEM;	1306	ret = -ENOMEM;
1307	goto out;	1307	goto out;
1308	}	1308	}
1309	fmt1_str = strtok_r(argv0_str, ":", &fmt);	1309	fmt1_str = strtok_r(argv0_str, ":", &fmt);
1310	fmt2_str = strtok_r(NULL, "/", &fmt);	1310	fmt2_str = strtok_r(NULL, "/", &fmt);
1311	fmt3_str = strtok_r(NULL, " \t", &fmt);	1311	fmt3_str = strtok_r(NULL, " \t", &fmt);
1312	if (fmt1_str == NULL \|\| strlen(fmt1_str) != 1 \|\| fmt2_str == NULL	1312	if (fmt1_str == NULL \|\| strlen(fmt1_str) != 1 \|\| fmt2_str == NULL
1313	\|\| fmt3_str == NULL) {	1313	\|\| fmt3_str == NULL) {
1314	semantic_error("Failed to parse event name: %s\n", argv[0]);	1314	semantic_error("Failed to parse event name: %s\n", argv[0]);
1315	ret = -EINVAL;	1315	ret = -EINVAL;
1316	goto out;	1316	goto out;
1317	}	1317	}
1318	pr = fmt1_str[0];	1318	pr = fmt1_str[0];
1319	tev->group = strdup(fmt2_str);	1319	tev->group = strdup(fmt2_str);
1320	tev->event = strdup(fmt3_str);	1320	tev->event = strdup(fmt3_str);
1321	if (tev->group == NULL \|\| tev->event == NULL) {	1321	if (tev->group == NULL \|\| tev->event == NULL) {
1322	ret = -ENOMEM;	1322	ret = -ENOMEM;
1323	goto out;	1323	goto out;
1324	}	1324	}
1325	pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);	1325	pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
1326		1326
1327	tp->retprobe = (pr == 'r');	1327	tp->retprobe = (pr == 'r');
1328		1328
1329	/* Scan module name(if there), function name and offset */	1329	/* Scan module name(if there), function name and offset */
1330	p = strchr(argv[1], ':');	1330	p = strchr(argv[1], ':');
1331	if (p) {	1331	if (p) {
1332	tp->module = strndup(argv[1], p - argv[1]);	1332	tp->module = strndup(argv[1], p - argv[1]);
1333	p++;	1333	p++;
1334	} else	1334	} else
1335	p = argv[1];	1335	p = argv[1];
1336	fmt1_str = strtok_r(p, "+", &fmt);	1336	fmt1_str = strtok_r(p, "+", &fmt);
1337	if (fmt1_str[0] == '0') /* only the address started with 0x */	1337	if (fmt1_str[0] == '0') /* only the address started with 0x */
1338	tp->address = strtoul(fmt1_str, NULL, 0);	1338	tp->address = strtoul(fmt1_str, NULL, 0);
1339	else {	1339	else {
1340	/* Only the symbol-based probe has offset */	1340	/* Only the symbol-based probe has offset */
1341	tp->symbol = strdup(fmt1_str);	1341	tp->symbol = strdup(fmt1_str);
1342	if (tp->symbol == NULL) {	1342	if (tp->symbol == NULL) {
1343	ret = -ENOMEM;	1343	ret = -ENOMEM;
1344	goto out;	1344	goto out;
1345	}	1345	}
1346	fmt2_str = strtok_r(NULL, "", &fmt);	1346	fmt2_str = strtok_r(NULL, "", &fmt);
1347	if (fmt2_str == NULL)	1347	if (fmt2_str == NULL)
1348	tp->offset = 0;	1348	tp->offset = 0;
1349	else	1349	else
1350	tp->offset = strtoul(fmt2_str, NULL, 10);	1350	tp->offset = strtoul(fmt2_str, NULL, 10);
1351	}	1351	}
1352		1352
1353	tev->nargs = argc - 2;	1353	tev->nargs = argc - 2;
1354	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);	1354	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1355	if (tev->args == NULL) {	1355	if (tev->args == NULL) {
1356	ret = -ENOMEM;	1356	ret = -ENOMEM;
1357	goto out;	1357	goto out;
1358	}	1358	}
1359	for (i = 0; i < tev->nargs; i++) {	1359	for (i = 0; i < tev->nargs; i++) {
1360	p = strchr(argv[i + 2], '=');	1360	p = strchr(argv[i + 2], '=');
1361	if (p) /* We don't need which register is assigned. */	1361	if (p) /* We don't need which register is assigned. */
1362	*p++ = '\0';	1362	*p++ = '\0';
1363	else	1363	else
1364	p = argv[i + 2];	1364	p = argv[i + 2];
1365	tev->args[i].name = strdup(argv[i + 2]);	1365	tev->args[i].name = strdup(argv[i + 2]);
1366	/* TODO: parse regs and offset */	1366	/* TODO: parse regs and offset */
1367	tev->args[i].value = strdup(p);	1367	tev->args[i].value = strdup(p);
1368	if (tev->args[i].name == NULL \|\| tev->args[i].value == NULL) {	1368	if (tev->args[i].name == NULL \|\| tev->args[i].value == NULL) {
1369	ret = -ENOMEM;	1369	ret = -ENOMEM;
1370	goto out;	1370	goto out;
1371	}	1371	}
1372	}	1372	}
1373	ret = 0;	1373	ret = 0;
1374	out:	1374	out:
1375	free(argv0_str);	1375	free(argv0_str);
1376	argv_free(argv);	1376	argv_free(argv);
1377	return ret;	1377	return ret;
1378	}	1378	}
1379		1379
1380	/* Compose only probe arg */	1380	/* Compose only probe arg */
1381	int synthesize_perf_probe_arg(struct perf_probe_arg pa, char buf, size_t len)	1381	int synthesize_perf_probe_arg(struct perf_probe_arg pa, char buf, size_t len)
1382	{	1382	{
1383	struct perf_probe_arg_field *field = pa->field;	1383	struct perf_probe_arg_field *field = pa->field;
1384	int ret;	1384	int ret;
1385	char *tmp = buf;	1385	char *tmp = buf;
1386		1386
1387	if (pa->name && pa->var)	1387	if (pa->name && pa->var)
1388	ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var);	1388	ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var);
1389	else	1389	else
1390	ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var);	1390	ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var);
1391	if (ret <= 0)	1391	if (ret <= 0)
1392	goto error;	1392	goto error;
1393	tmp += ret;	1393	tmp += ret;
1394	len -= ret;	1394	len -= ret;
1395		1395
1396	while (field) {	1396	while (field) {
1397	if (field->name[0] == '[')	1397	if (field->name[0] == '[')
1398	ret = e_snprintf(tmp, len, "%s", field->name);	1398	ret = e_snprintf(tmp, len, "%s", field->name);
1399	else	1399	else
1400	ret = e_snprintf(tmp, len, "%s%s",	1400	ret = e_snprintf(tmp, len, "%s%s",
1401	field->ref ? "->" : ".", field->name);	1401	field->ref ? "->" : ".", field->name);
1402	if (ret <= 0)	1402	if (ret <= 0)
1403	goto error;	1403	goto error;
1404	tmp += ret;	1404	tmp += ret;
1405	len -= ret;	1405	len -= ret;
1406	field = field->next;	1406	field = field->next;
1407	}	1407	}
1408		1408
1409	if (pa->type) {	1409	if (pa->type) {
1410	ret = e_snprintf(tmp, len, ":%s", pa->type);	1410	ret = e_snprintf(tmp, len, ":%s", pa->type);
1411	if (ret <= 0)	1411	if (ret <= 0)
1412	goto error;	1412	goto error;
1413	tmp += ret;	1413	tmp += ret;
1414	len -= ret;	1414	len -= ret;
1415	}	1415	}
1416		1416
1417	return tmp - buf;	1417	return tmp - buf;
1418	error:	1418	error:
1419	pr_debug("Failed to synthesize perf probe argument: %d\n", ret);	1419	pr_debug("Failed to synthesize perf probe argument: %d\n", ret);
1420	return ret;	1420	return ret;
1421	}	1421	}
1422		1422
1423	/* Compose only probe point (not argument) */	1423	/* Compose only probe point (not argument) */
1424	static char synthesize_perf_probe_point(struct perf_probe_point pp)	1424	static char synthesize_perf_probe_point(struct perf_probe_point pp)
1425	{	1425	{
1426	char buf, tmp;	1426	char buf, tmp;
1427	char offs[32] = "", line[32] = "", file[32] = "";	1427	char offs[32] = "", line[32] = "", file[32] = "";
1428	int ret, len;	1428	int ret, len;
1429		1429
1430	buf = zalloc(MAX_CMDLEN);	1430	buf = zalloc(MAX_CMDLEN);
1431	if (buf == NULL) {	1431	if (buf == NULL) {
1432	ret = -ENOMEM;	1432	ret = -ENOMEM;
1433	goto error;	1433	goto error;
1434	}	1434	}
1435	if (pp->offset) {	1435	if (pp->offset) {
1436	ret = e_snprintf(offs, 32, "+%lu", pp->offset);	1436	ret = e_snprintf(offs, 32, "+%lu", pp->offset);
1437	if (ret <= 0)	1437	if (ret <= 0)
1438	goto error;	1438	goto error;
1439	}	1439	}
1440	if (pp->line) {	1440	if (pp->line) {
1441	ret = e_snprintf(line, 32, ":%d", pp->line);	1441	ret = e_snprintf(line, 32, ":%d", pp->line);
1442	if (ret <= 0)	1442	if (ret <= 0)
1443	goto error;	1443	goto error;
1444	}	1444	}
1445	if (pp->file) {	1445	if (pp->file) {
1446	tmp = pp->file;	1446	tmp = pp->file;
1447	len = strlen(tmp);	1447	len = strlen(tmp);
1448	if (len > 30) {	1448	if (len > 30) {
1449	tmp = strchr(pp->file + len - 30, '/');	1449	tmp = strchr(pp->file + len - 30, '/');
1450	tmp = tmp ? tmp + 1 : pp->file + len - 30;	1450	tmp = tmp ? tmp + 1 : pp->file + len - 30;
1451	}	1451	}
1452	ret = e_snprintf(file, 32, "@%s", tmp);	1452	ret = e_snprintf(file, 32, "@%s", tmp);
1453	if (ret <= 0)	1453	if (ret <= 0)
1454	goto error;	1454	goto error;
1455	}	1455	}
1456		1456
1457	if (pp->function)	1457	if (pp->function)
1458	ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,	1458	ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
1459	offs, pp->retprobe ? "%return" : "", line,	1459	offs, pp->retprobe ? "%return" : "", line,
1460	file);	1460	file);
1461	else	1461	else
1462	ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);	1462	ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
1463	if (ret <= 0)	1463	if (ret <= 0)
1464	goto error;	1464	goto error;
1465		1465
1466	return buf;	1466	return buf;
1467	error:	1467	error:
1468	pr_debug("Failed to synthesize perf probe point: %d\n", ret);	1468	pr_debug("Failed to synthesize perf probe point: %d\n", ret);
1469	free(buf);	1469	free(buf);
1470	return NULL;	1470	return NULL;
1471	}	1471	}
1472		1472
1473	#if 0	1473	#if 0
1474	char synthesize_perf_probe_command(struct perf_probe_event pev)	1474	char synthesize_perf_probe_command(struct perf_probe_event pev)
1475	{	1475	{
1476	char *buf;	1476	char *buf;
1477	int i, len, ret;	1477	int i, len, ret;
1478		1478
1479	buf = synthesize_perf_probe_point(&pev->point);	1479	buf = synthesize_perf_probe_point(&pev->point);
1480	if (!buf)	1480	if (!buf)
1481	return NULL;	1481	return NULL;
1482		1482
1483	len = strlen(buf);	1483	len = strlen(buf);
1484	for (i = 0; i < pev->nargs; i++) {	1484	for (i = 0; i < pev->nargs; i++) {
1485	ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",	1485	ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
1486	pev->args[i].name);	1486	pev->args[i].name);
1487	if (ret <= 0) {	1487	if (ret <= 0) {
1488	free(buf);	1488	free(buf);
1489	return NULL;	1489	return NULL;
1490	}	1490	}
1491	len += ret;	1491	len += ret;
1492	}	1492	}
1493		1493
1494	return buf;	1494	return buf;
1495	}	1495	}
1496	#endif	1496	#endif
1497		1497
1498	static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,	1498	static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
1499	char *buf, size_t buflen,	1499	char *buf, size_t buflen,
1500	int depth)	1500	int depth)
1501	{	1501	{
1502	int ret;	1502	int ret;
1503	if (ref->next) {	1503	if (ref->next) {
1504	depth = __synthesize_probe_trace_arg_ref(ref->next, buf,	1504	depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
1505	buflen, depth + 1);	1505	buflen, depth + 1);
1506	if (depth < 0)	1506	if (depth < 0)
1507	goto out;	1507	goto out;
1508	}	1508	}
1509		1509
1510	ret = e_snprintf(buf, buflen, "%+ld(", ref->offset);	1510	ret = e_snprintf(buf, buflen, "%+ld(", ref->offset);
1511	if (ret < 0)	1511	if (ret < 0)
1512	depth = ret;	1512	depth = ret;
1513	else {	1513	else {
1514	*buf += ret;	1514	*buf += ret;
1515	*buflen -= ret;	1515	*buflen -= ret;
1516	}	1516	}
1517	out:	1517	out:
1518	return depth;	1518	return depth;
1519		1519
1520	}	1520	}
1521		1521
1522	static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,	1522	static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
1523	char *buf, size_t buflen)	1523	char *buf, size_t buflen)
1524	{	1524	{
1525	struct probe_trace_arg_ref *ref = arg->ref;	1525	struct probe_trace_arg_ref *ref = arg->ref;
1526	int ret, depth = 0;	1526	int ret, depth = 0;
1527	char *tmp = buf;	1527	char *tmp = buf;
1528		1528
1529	/* Argument name or separator */	1529	/* Argument name or separator */
1530	if (arg->name)	1530	if (arg->name)
1531	ret = e_snprintf(buf, buflen, " %s=", arg->name);	1531	ret = e_snprintf(buf, buflen, " %s=", arg->name);
1532	else	1532	else
1533	ret = e_snprintf(buf, buflen, " ");	1533	ret = e_snprintf(buf, buflen, " ");
1534	if (ret < 0)	1534	if (ret < 0)
1535	return ret;	1535	return ret;
1536	buf += ret;	1536	buf += ret;
1537	buflen -= ret;	1537	buflen -= ret;
1538		1538
1539	/* Special case: @XXX */	1539	/* Special case: @XXX */
1540	if (arg->value[0] == '@' && arg->ref)	1540	if (arg->value[0] == '@' && arg->ref)
1541	ref = ref->next;	1541	ref = ref->next;
1542		1542
1543	/* Dereferencing arguments */	1543	/* Dereferencing arguments */
1544	if (ref) {	1544	if (ref) {
1545	depth = __synthesize_probe_trace_arg_ref(ref, &buf,	1545	depth = __synthesize_probe_trace_arg_ref(ref, &buf,
1546	&buflen, 1);	1546	&buflen, 1);
1547	if (depth < 0)	1547	if (depth < 0)
1548	return depth;	1548	return depth;
1549	}	1549	}
1550		1550
1551	/* Print argument value */	1551	/* Print argument value */
1552	if (arg->value[0] == '@' && arg->ref)	1552	if (arg->value[0] == '@' && arg->ref)
1553	ret = e_snprintf(buf, buflen, "%s%+ld", arg->value,	1553	ret = e_snprintf(buf, buflen, "%s%+ld", arg->value,
1554	arg->ref->offset);	1554	arg->ref->offset);
1555	else	1555	else
1556	ret = e_snprintf(buf, buflen, "%s", arg->value);	1556	ret = e_snprintf(buf, buflen, "%s", arg->value);
1557	if (ret < 0)	1557	if (ret < 0)
1558	return ret;	1558	return ret;
1559	buf += ret;	1559	buf += ret;
1560	buflen -= ret;	1560	buflen -= ret;
1561		1561
1562	/* Closing */	1562	/* Closing */
1563	while (depth--) {	1563	while (depth--) {
1564	ret = e_snprintf(buf, buflen, ")");	1564	ret = e_snprintf(buf, buflen, ")");
1565	if (ret < 0)	1565	if (ret < 0)
1566	return ret;	1566	return ret;
1567	buf += ret;	1567	buf += ret;
1568	buflen -= ret;	1568	buflen -= ret;
1569	}	1569	}
1570	/* Print argument type */	1570	/* Print argument type */
1571	if (arg->type) {	1571	if (arg->type) {
1572	ret = e_snprintf(buf, buflen, ":%s", arg->type);	1572	ret = e_snprintf(buf, buflen, ":%s", arg->type);
1573	if (ret <= 0)	1573	if (ret <= 0)
1574	return ret;	1574	return ret;
1575	buf += ret;	1575	buf += ret;
1576	}	1576	}
1577		1577
1578	return buf - tmp;	1578	return buf - tmp;
1579	}	1579	}
1580		1580
1581	char synthesize_probe_trace_command(struct probe_trace_event tev)	1581	char synthesize_probe_trace_command(struct probe_trace_event tev)
1582	{	1582	{
1583	struct probe_trace_point *tp = &tev->point;	1583	struct probe_trace_point *tp = &tev->point;
1584	char *buf;	1584	char *buf;
1585	int i, len, ret;	1585	int i, len, ret;
1586		1586
1587	buf = zalloc(MAX_CMDLEN);	1587	buf = zalloc(MAX_CMDLEN);
1588	if (buf == NULL)	1588	if (buf == NULL)
1589	return NULL;	1589	return NULL;
1590		1590
1591	len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',	1591	len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',
1592	tev->group, tev->event);	1592	tev->group, tev->event);
1593	if (len <= 0)	1593	if (len <= 0)
1594	goto error;	1594	goto error;
1595		1595
1596	/* Uprobes must have tp->address and tp->module */	1596	/* Uprobes must have tp->address and tp->module */
1597	if (tev->uprobes && (!tp->address \|\| !tp->module))	1597	if (tev->uprobes && (!tp->address \|\| !tp->module))
1598	goto error;	1598	goto error;
1599		1599
1600	/* Use the tp->address for uprobes */	1600	/* Use the tp->address for uprobes */
1601	if (tev->uprobes)	1601	if (tev->uprobes)
1602	ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s:0x%lx",	1602	ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s:0x%lx",
1603	tp->module, tp->address);	1603	tp->module, tp->address);
1604	else	1604	else
1605	ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s%s%s+%lu",	1605	ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s%s%s+%lu",
1606	tp->module ?: "", tp->module ? ":" : "",	1606	tp->module ?: "", tp->module ? ":" : "",
1607	tp->symbol, tp->offset);	1607	tp->symbol, tp->offset);
1608		1608
1609	if (ret <= 0)	1609	if (ret <= 0)
1610	goto error;	1610	goto error;
1611	len += ret;	1611	len += ret;
1612		1612
1613	for (i = 0; i < tev->nargs; i++) {	1613	for (i = 0; i < tev->nargs; i++) {
1614	ret = synthesize_probe_trace_arg(&tev->args[i], buf + len,	1614	ret = synthesize_probe_trace_arg(&tev->args[i], buf + len,
1615	MAX_CMDLEN - len);	1615	MAX_CMDLEN - len);
1616	if (ret <= 0)	1616	if (ret <= 0)
1617	goto error;	1617	goto error;
1618	len += ret;	1618	len += ret;
1619	}	1619	}
1620		1620
1621	return buf;	1621	return buf;
1622	error:	1622	error:
1623	free(buf);	1623	free(buf);
1624	return NULL;	1624	return NULL;
1625	}	1625	}
1626		1626
1627	static int find_perf_probe_point_from_map(struct probe_trace_point *tp,	1627	static int find_perf_probe_point_from_map(struct probe_trace_point *tp,
1628	struct perf_probe_point *pp,	1628	struct perf_probe_point *pp,
1629	bool is_kprobe)	1629	bool is_kprobe)
1630	{	1630	{
1631	struct symbol *sym = NULL;	1631	struct symbol *sym = NULL;
1632	struct map *map;	1632	struct map *map;
1633	u64 addr;	1633	u64 addr;
1634	int ret = -ENOENT;	1634	int ret = -ENOENT;
1635		1635
1636	if (!is_kprobe) {	1636	if (!is_kprobe) {
1637	map = dso__new_map(tp->module);	1637	map = dso__new_map(tp->module);
1638	if (!map)	1638	if (!map)
1639	goto out;	1639	goto out;
1640	addr = tp->address;	1640	addr = tp->address;
1641	sym = map__find_symbol(map, addr, NULL);	1641	sym = map__find_symbol(map, addr, NULL);
1642	} else {	1642	} else {
1643	addr = kernel_get_symbol_address_by_name(tp->symbol, true);	1643	addr = kernel_get_symbol_address_by_name(tp->symbol, true);
1644	if (addr) {	1644	if (addr) {
1645	addr += tp->offset;	1645	addr += tp->offset;
1646	sym = __find_kernel_function(addr, &map);	1646	sym = __find_kernel_function(addr, &map);
1647	}	1647	}
1648	}	1648	}
1649	if (!sym)	1649	if (!sym)
1650	goto out;	1650	goto out;
1651		1651
1652	pp->retprobe = tp->retprobe;	1652	pp->retprobe = tp->retprobe;
1653	pp->offset = addr - map->unmap_ip(map, sym->start);	1653	pp->offset = addr - map->unmap_ip(map, sym->start);
1654	pp->function = strdup(sym->name);	1654	pp->function = strdup(sym->name);
1655	ret = pp->function ? 0 : -ENOMEM;	1655	ret = pp->function ? 0 : -ENOMEM;
1656		1656
1657	out:	1657	out:
1658	if (map && !is_kprobe) {	1658	if (map && !is_kprobe) {
1659	dso__delete(map->dso);	1659	dso__delete(map->dso);
1660	map__delete(map);	1660	map__delete(map);
1661	}	1661	}
1662		1662
1663	return ret;	1663	return ret;
1664	}	1664	}
1665		1665
1666	static int convert_to_perf_probe_point(struct probe_trace_point *tp,	1666	static int convert_to_perf_probe_point(struct probe_trace_point *tp,
1667	struct perf_probe_point *pp,	1667	struct perf_probe_point *pp,
1668	bool is_kprobe)	1668	bool is_kprobe)
1669	{	1669	{
1670	char buf[128];	1670	char buf[128];
1671	int ret;	1671	int ret;
1672		1672
1673	ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe);	1673	ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe);
1674	if (!ret)	1674	if (!ret)
1675	return 0;	1675	return 0;
1676	ret = find_perf_probe_point_from_map(tp, pp, is_kprobe);	1676	ret = find_perf_probe_point_from_map(tp, pp, is_kprobe);
1677	if (!ret)	1677	if (!ret)
1678	return 0;	1678	return 0;
1679		1679
1680	pr_debug("Failed to find probe point from both of dwarf and map.\n");	1680	pr_debug("Failed to find probe point from both of dwarf and map.\n");
1681		1681
1682	if (tp->symbol) {	1682	if (tp->symbol) {
1683	pp->function = strdup(tp->symbol);	1683	pp->function = strdup(tp->symbol);
1684	pp->offset = tp->offset;	1684	pp->offset = tp->offset;
1685	} else if (!tp->module && !is_kprobe) {	1685	} else if (!tp->module && !is_kprobe) {
1686	ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address);	1686	ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address);
1687	if (ret < 0)	1687	if (ret < 0)
1688	return ret;	1688	return ret;
1689	pp->function = strdup(buf);	1689	pp->function = strdup(buf);
1690	pp->offset = 0;	1690	pp->offset = 0;
1691	}	1691	}
1692	if (pp->function == NULL)	1692	if (pp->function == NULL)
1693	return -ENOMEM;	1693	return -ENOMEM;
1694		1694
1695	pp->retprobe = tp->retprobe;	1695	pp->retprobe = tp->retprobe;
1696		1696
1697	return 0;	1697	return 0;
1698	}	1698	}
1699		1699
1700	static int convert_to_perf_probe_event(struct probe_trace_event *tev,	1700	static int convert_to_perf_probe_event(struct probe_trace_event *tev,
1701	struct perf_probe_event *pev, bool is_kprobe)	1701	struct perf_probe_event *pev, bool is_kprobe)
1702	{	1702	{
1703	char buf[64] = "";	1703	char buf[64] = "";
1704	int i, ret;	1704	int i, ret;
1705		1705
1706	/* Convert event/group name */	1706	/* Convert event/group name */
1707	pev->event = strdup(tev->event);	1707	pev->event = strdup(tev->event);
1708	pev->group = strdup(tev->group);	1708	pev->group = strdup(tev->group);
1709	if (pev->event == NULL \|\| pev->group == NULL)	1709	if (pev->event == NULL \|\| pev->group == NULL)
1710	return -ENOMEM;	1710	return -ENOMEM;
1711		1711
1712	/* Convert trace_point to probe_point */	1712	/* Convert trace_point to probe_point */
1713	ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);	1713	ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
1714	if (ret < 0)	1714	if (ret < 0)
1715	return ret;	1715	return ret;
1716		1716
1717	/* Convert trace_arg to probe_arg */	1717	/* Convert trace_arg to probe_arg */
1718	pev->nargs = tev->nargs;	1718	pev->nargs = tev->nargs;
1719	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);	1719	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1720	if (pev->args == NULL)	1720	if (pev->args == NULL)
1721	return -ENOMEM;	1721	return -ENOMEM;
1722	for (i = 0; i < tev->nargs && ret >= 0; i++) {	1722	for (i = 0; i < tev->nargs && ret >= 0; i++) {
1723	if (tev->args[i].name)	1723	if (tev->args[i].name)
1724	pev->args[i].name = strdup(tev->args[i].name);	1724	pev->args[i].name = strdup(tev->args[i].name);
1725	else {	1725	else {
1726	ret = synthesize_probe_trace_arg(&tev->args[i],	1726	ret = synthesize_probe_trace_arg(&tev->args[i],
1727	buf, 64);	1727	buf, 64);
1728	pev->args[i].name = strdup(buf);	1728	pev->args[i].name = strdup(buf);
1729	}	1729	}
1730	if (pev->args[i].name == NULL && ret >= 0)	1730	if (pev->args[i].name == NULL && ret >= 0)
1731	ret = -ENOMEM;	1731	ret = -ENOMEM;
1732	}	1732	}
1733		1733
1734	if (ret < 0)	1734	if (ret < 0)
1735	clear_perf_probe_event(pev);	1735	clear_perf_probe_event(pev);
1736		1736
1737	return ret;	1737	return ret;
1738	}	1738	}
1739		1739
1740	void clear_perf_probe_event(struct perf_probe_event *pev)	1740	void clear_perf_probe_event(struct perf_probe_event *pev)
1741	{	1741	{
1742	struct perf_probe_point *pp = &pev->point;	1742	struct perf_probe_point *pp = &pev->point;
1743	struct perf_probe_arg_field field, next;	1743	struct perf_probe_arg_field field, next;
1744	int i;	1744	int i;
1745		1745
1746	free(pev->event);	1746	free(pev->event);
1747	free(pev->group);	1747	free(pev->group);
1748	free(pp->file);	1748	free(pp->file);
1749	free(pp->function);	1749	free(pp->function);
1750	free(pp->lazy_line);	1750	free(pp->lazy_line);
1751		1751
1752	for (i = 0; i < pev->nargs; i++) {	1752	for (i = 0; i < pev->nargs; i++) {
1753	free(pev->args[i].name);	1753	free(pev->args[i].name);
1754	free(pev->args[i].var);	1754	free(pev->args[i].var);
1755	free(pev->args[i].type);	1755	free(pev->args[i].type);
1756	field = pev->args[i].field;	1756	field = pev->args[i].field;
1757	while (field) {	1757	while (field) {
1758	next = field->next;	1758	next = field->next;
1759	zfree(&field->name);	1759	zfree(&field->name);
1760	free(field);	1760	free(field);
1761	field = next;	1761	field = next;
1762	}	1762	}
1763	}	1763	}
1764	free(pev->args);	1764	free(pev->args);
1765	memset(pev, 0, sizeof(*pev));	1765	memset(pev, 0, sizeof(*pev));
1766	}	1766	}
1767		1767
1768	static void clear_probe_trace_event(struct probe_trace_event *tev)	1768	static void clear_probe_trace_event(struct probe_trace_event *tev)
1769	{	1769	{
1770	struct probe_trace_arg_ref ref, next;	1770	struct probe_trace_arg_ref ref, next;
1771	int i;	1771	int i;
1772		1772
1773	free(tev->event);	1773	free(tev->event);
1774	free(tev->group);	1774	free(tev->group);
1775	free(tev->point.symbol);	1775	free(tev->point.symbol);
1776	free(tev->point.module);	1776	free(tev->point.module);
1777	for (i = 0; i < tev->nargs; i++) {	1777	for (i = 0; i < tev->nargs; i++) {
1778	free(tev->args[i].name);	1778	free(tev->args[i].name);
1779	free(tev->args[i].value);	1779	free(tev->args[i].value);
1780	free(tev->args[i].type);	1780	free(tev->args[i].type);
1781	ref = tev->args[i].ref;	1781	ref = tev->args[i].ref;
1782	while (ref) {	1782	while (ref) {
1783	next = ref->next;	1783	next = ref->next;
1784	free(ref);	1784	free(ref);
1785	ref = next;	1785	ref = next;
1786	}	1786	}
1787	}	1787	}
1788	free(tev->args);	1788	free(tev->args);
1789	memset(tev, 0, sizeof(*tev));	1789	memset(tev, 0, sizeof(*tev));
1790	}	1790	}
1791		1791
1792	static void print_open_warning(int err, bool is_kprobe)	1792	static void print_open_warning(int err, bool is_kprobe)
1793	{	1793	{
1794	char sbuf[STRERR_BUFSIZE];	1794	char sbuf[STRERR_BUFSIZE];
1795		1795
1796	if (err == -ENOENT) {	1796	if (err == -ENOENT) {
1797	const char *config;	1797	const char *config;
1798		1798
1799	if (!is_kprobe)	1799	if (!is_kprobe)
1800	config = "CONFIG_UPROBE_EVENTS";	1800	config = "CONFIG_UPROBE_EVENTS";
1801	else	1801	else
1802	config = "CONFIG_KPROBE_EVENTS";	1802	config = "CONFIG_KPROBE_EVENTS";
1803		1803
1804	pr_warning("%cprobe_events file does not exist"	1804	pr_warning("%cprobe_events file does not exist"
1805	" - please rebuild kernel with %s.\n",	1805	" - please rebuild kernel with %s.\n",
1806	is_kprobe ? 'k' : 'u', config);	1806	is_kprobe ? 'k' : 'u', config);
1807	} else if (err == -ENOTSUP)	1807	} else if (err == -ENOTSUP)
1808	pr_warning("Debugfs is not mounted.\n");	1808	pr_warning("Debugfs is not mounted.\n");
1809	else	1809	else
1810	pr_warning("Failed to open %cprobe_events: %s\n",	1810	pr_warning("Failed to open %cprobe_events: %s\n",
1811	is_kprobe ? 'k' : 'u',	1811	is_kprobe ? 'k' : 'u',
1812	strerror_r(-err, sbuf, sizeof(sbuf)));	1812	strerror_r(-err, sbuf, sizeof(sbuf)));
1813	}	1813	}
1814		1814
1815	static void print_both_open_warning(int kerr, int uerr)	1815	static void print_both_open_warning(int kerr, int uerr)
1816	{	1816	{
1817	/* Both kprobes and uprobes are disabled, warn it. */	1817	/* Both kprobes and uprobes are disabled, warn it. */
1818	if (kerr == -ENOTSUP && uerr == -ENOTSUP)	1818	if (kerr == -ENOTSUP && uerr == -ENOTSUP)
1819	pr_warning("Debugfs is not mounted.\n");	1819	pr_warning("Debugfs is not mounted.\n");
1820	else if (kerr == -ENOENT && uerr == -ENOENT)	1820	else if (kerr == -ENOENT && uerr == -ENOENT)
1821	pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS "	1821	pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS "
1822	"or/and CONFIG_UPROBE_EVENTS.\n");	1822	"or/and CONFIG_UPROBE_EVENTS.\n");
1823	else {	1823	else {
1824	char sbuf[STRERR_BUFSIZE];	1824	char sbuf[STRERR_BUFSIZE];
1825	pr_warning("Failed to open kprobe events: %s.\n",	1825	pr_warning("Failed to open kprobe events: %s.\n",
1826	strerror_r(-kerr, sbuf, sizeof(sbuf)));	1826	strerror_r(-kerr, sbuf, sizeof(sbuf)));
1827	pr_warning("Failed to open uprobe events: %s.\n",	1827	pr_warning("Failed to open uprobe events: %s.\n",
1828	strerror_r(-uerr, sbuf, sizeof(sbuf)));	1828	strerror_r(-uerr, sbuf, sizeof(sbuf)));
1829	}	1829	}
1830	}	1830	}
1831		1831
1832	static int open_probe_events(const char *trace_file, bool readwrite)	1832	static int open_probe_events(const char *trace_file, bool readwrite)
1833	{	1833	{
1834	char buf[PATH_MAX];	1834	char buf[PATH_MAX];
1835	const char *__debugfs;	1835	const char *__debugfs;
1836	int ret;	1836	int ret;
1837		1837
1838	__debugfs = debugfs_find_mountpoint();	1838	__debugfs = debugfs_find_mountpoint();
1839	if (__debugfs == NULL)	1839	if (__debugfs == NULL)
1840	return -ENOTSUP;	1840	return -ENOTSUP;
1841		1841
1842	ret = e_snprintf(buf, PATH_MAX, "%s/%s", __debugfs, trace_file);	1842	ret = e_snprintf(buf, PATH_MAX, "%s/%s", __debugfs, trace_file);
1843	if (ret >= 0) {	1843	if (ret >= 0) {
1844	pr_debug("Opening %s write=%d\n", buf, readwrite);	1844	pr_debug("Opening %s write=%d\n", buf, readwrite);
1845	if (readwrite && !probe_event_dry_run)	1845	if (readwrite && !probe_event_dry_run)
1846	ret = open(buf, O_RDWR, O_APPEND);	1846	ret = open(buf, O_RDWR, O_APPEND);
1847	else	1847	else
1848	ret = open(buf, O_RDONLY, 0);	1848	ret = open(buf, O_RDONLY, 0);
1849		1849
1850	if (ret < 0)	1850	if (ret < 0)
1851	ret = -errno;	1851	ret = -errno;
1852	}	1852	}
1853	return ret;	1853	return ret;
1854	}	1854	}
1855		1855
1856	static int open_kprobe_events(bool readwrite)	1856	static int open_kprobe_events(bool readwrite)
1857	{	1857	{
1858	return open_probe_events("tracing/kprobe_events", readwrite);	1858	return open_probe_events("tracing/kprobe_events", readwrite);
1859	}	1859	}
1860		1860
1861	static int open_uprobe_events(bool readwrite)	1861	static int open_uprobe_events(bool readwrite)
1862	{	1862	{
1863	return open_probe_events("tracing/uprobe_events", readwrite);	1863	return open_probe_events("tracing/uprobe_events", readwrite);
1864	}	1864	}
1865		1865
1866	/* Get raw string list of current kprobe_events or uprobe_events */	1866	/* Get raw string list of current kprobe_events or uprobe_events */
1867	static struct strlist *get_probe_trace_command_rawlist(int fd)	1867	static struct strlist *get_probe_trace_command_rawlist(int fd)
1868	{	1868	{
1869	int ret, idx;	1869	int ret, idx;
1870	FILE *fp;	1870	FILE *fp;
1871	char buf[MAX_CMDLEN];	1871	char buf[MAX_CMDLEN];
1872	char *p;	1872	char *p;
1873	struct strlist *sl;	1873	struct strlist *sl;
1874		1874
1875	sl = strlist__new(true, NULL);	1875	sl = strlist__new(true, NULL);
1876		1876
1877	fp = fdopen(dup(fd), "r");	1877	fp = fdopen(dup(fd), "r");
1878	while (!feof(fp)) {	1878	while (!feof(fp)) {
1879	p = fgets(buf, MAX_CMDLEN, fp);	1879	p = fgets(buf, MAX_CMDLEN, fp);
1880	if (!p)	1880	if (!p)
1881	break;	1881	break;
1882		1882
1883	idx = strlen(p) - 1;	1883	idx = strlen(p) - 1;
1884	if (p[idx] == '\n')	1884	if (p[idx] == '\n')
1885	p[idx] = '\0';	1885	p[idx] = '\0';
1886	ret = strlist__add(sl, buf);	1886	ret = strlist__add(sl, buf);
1887	if (ret < 0) {	1887	if (ret < 0) {
1888	pr_debug("strlist__add failed (%d)\n", ret);	1888	pr_debug("strlist__add failed (%d)\n", ret);
1889	strlist__delete(sl);	1889	strlist__delete(sl);
1890	return NULL;	1890	return NULL;
1891	}	1891	}
1892	}	1892	}
1893	fclose(fp);	1893	fclose(fp);
1894		1894
1895	return sl;	1895	return sl;
1896	}	1896	}
1897		1897
1898	/* Show an event */	1898	/* Show an event */
1899	static int show_perf_probe_event(struct perf_probe_event *pev,	1899	static int show_perf_probe_event(struct perf_probe_event *pev,
1900	const char *module)	1900	const char *module)
1901	{	1901	{
1902	int i, ret;	1902	int i, ret;
1903	char buf[128];	1903	char buf[128];
1904	char *place;	1904	char *place;
1905		1905
1906	/* Synthesize only event probe point */	1906	/* Synthesize only event probe point */
1907	place = synthesize_perf_probe_point(&pev->point);	1907	place = synthesize_perf_probe_point(&pev->point);
1908	if (!place)	1908	if (!place)
1909	return -EINVAL;	1909	return -EINVAL;
1910		1910
1911	ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);	1911	ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);
1912	if (ret < 0)	1912	if (ret < 0)
1913	return ret;	1913	return ret;
1914		1914
1915	pr_info(" %-20s (on %s", buf, place);	1915	pr_info(" %-20s (on %s", buf, place);
1916	if (module)	1916	if (module)
1917	pr_info(" in %s", module);	1917	pr_info(" in %s", module);
1918		1918
1919	if (pev->nargs > 0) {	1919	if (pev->nargs > 0) {
1920	pr_info(" with");	1920	pr_info(" with");
1921	for (i = 0; i < pev->nargs; i++) {	1921	for (i = 0; i < pev->nargs; i++) {
1922	ret = synthesize_perf_probe_arg(&pev->args[i],	1922	ret = synthesize_perf_probe_arg(&pev->args[i],
1923	buf, 128);	1923	buf, 128);
1924	if (ret < 0)	1924	if (ret < 0)
1925	break;	1925	break;
1926	pr_info(" %s", buf);	1926	pr_info(" %s", buf);
1927	}	1927	}
1928	}	1928	}
1929	pr_info(")\n");	1929	pr_info(")\n");
1930	free(place);	1930	free(place);
1931	return ret;	1931	return ret;
1932	}	1932	}
1933		1933
1934	static int __show_perf_probe_events(int fd, bool is_kprobe)	1934	static int __show_perf_probe_events(int fd, bool is_kprobe)
1935	{	1935	{
1936	int ret = 0;	1936	int ret = 0;
1937	struct probe_trace_event tev;	1937	struct probe_trace_event tev;
1938	struct perf_probe_event pev;	1938	struct perf_probe_event pev;
1939	struct strlist *rawlist;	1939	struct strlist *rawlist;
1940	struct str_node *ent;	1940	struct str_node *ent;
1941		1941
1942	memset(&tev, 0, sizeof(tev));	1942	memset(&tev, 0, sizeof(tev));
1943	memset(&pev, 0, sizeof(pev));	1943	memset(&pev, 0, sizeof(pev));
1944		1944
1945	rawlist = get_probe_trace_command_rawlist(fd);	1945	rawlist = get_probe_trace_command_rawlist(fd);
1946	if (!rawlist)	1946	if (!rawlist)
1947	return -ENOMEM;	1947	return -ENOMEM;
1948		1948
1949	strlist__for_each(ent, rawlist) {	1949	strlist__for_each(ent, rawlist) {
1950	ret = parse_probe_trace_command(ent->s, &tev);	1950	ret = parse_probe_trace_command(ent->s, &tev);
1951	if (ret >= 0) {	1951	if (ret >= 0) {
1952	ret = convert_to_perf_probe_event(&tev, &pev,	1952	ret = convert_to_perf_probe_event(&tev, &pev,
1953	is_kprobe);	1953	is_kprobe);
1954	if (ret >= 0)	1954	if (ret >= 0)
1955	ret = show_perf_probe_event(&pev,	1955	ret = show_perf_probe_event(&pev,
1956	tev.point.module);	1956	tev.point.module);
1957	}	1957	}
1958	clear_perf_probe_event(&pev);	1958	clear_perf_probe_event(&pev);
1959	clear_probe_trace_event(&tev);	1959	clear_probe_trace_event(&tev);
1960	if (ret < 0)	1960	if (ret < 0)
1961	break;	1961	break;
1962	}	1962	}
1963	strlist__delete(rawlist);	1963	strlist__delete(rawlist);
1964		1964
1965	return ret;	1965	return ret;
1966	}	1966	}
1967		1967
1968	/* List up current perf-probe events */	1968	/* List up current perf-probe events */
1969	int show_perf_probe_events(void)	1969	int show_perf_probe_events(void)
1970	{	1970	{
1971	int kp_fd, up_fd, ret;	1971	int kp_fd, up_fd, ret;
1972		1972
1973	setup_pager();	1973	setup_pager();
1974		1974
1975	ret = init_symbol_maps(false);	1975	ret = init_symbol_maps(false);
1976	if (ret < 0)	1976	if (ret < 0)
1977	return ret;	1977	return ret;
1978		1978
1979	kp_fd = open_kprobe_events(false);	1979	kp_fd = open_kprobe_events(false);
1980	if (kp_fd >= 0) {	1980	if (kp_fd >= 0) {
1981	ret = __show_perf_probe_events(kp_fd, true);	1981	ret = __show_perf_probe_events(kp_fd, true);
1982	close(kp_fd);	1982	close(kp_fd);
1983	if (ret < 0)	1983	if (ret < 0)
1984	goto out;	1984	goto out;
1985	}	1985	}
1986		1986
1987	up_fd = open_uprobe_events(false);	1987	up_fd = open_uprobe_events(false);
1988	if (kp_fd < 0 && up_fd < 0) {	1988	if (kp_fd < 0 && up_fd < 0) {
1989	print_both_open_warning(kp_fd, up_fd);	1989	print_both_open_warning(kp_fd, up_fd);
1990	ret = kp_fd;	1990	ret = kp_fd;
1991	goto out;	1991	goto out;
1992	}	1992	}
1993		1993
1994	if (up_fd >= 0) {	1994	if (up_fd >= 0) {
1995	ret = __show_perf_probe_events(up_fd, false);	1995	ret = __show_perf_probe_events(up_fd, false);
1996	close(up_fd);	1996	close(up_fd);
1997	}	1997	}
1998	out:	1998	out:
1999	exit_symbol_maps();	1999	exit_symbol_maps();
2000	return ret;	2000	return ret;
2001	}	2001	}
2002		2002
2003	/* Get current perf-probe event names */	2003	/* Get current perf-probe event names */
2004	static struct strlist *get_probe_trace_event_names(int fd, bool include_group)	2004	static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
2005	{	2005	{
2006	char buf[128];	2006	char buf[128];
2007	struct strlist sl, rawlist;	2007	struct strlist sl, rawlist;
2008	struct str_node *ent;	2008	struct str_node *ent;
2009	struct probe_trace_event tev;	2009	struct probe_trace_event tev;
2010	int ret = 0;	2010	int ret = 0;
2011		2011
2012	memset(&tev, 0, sizeof(tev));	2012	memset(&tev, 0, sizeof(tev));
2013	rawlist = get_probe_trace_command_rawlist(fd);	2013	rawlist = get_probe_trace_command_rawlist(fd);
2014	if (!rawlist)	2014	if (!rawlist)
2015	return NULL;	2015	return NULL;
2016	sl = strlist__new(true, NULL);	2016	sl = strlist__new(true, NULL);
2017	strlist__for_each(ent, rawlist) {	2017	strlist__for_each(ent, rawlist) {
2018	ret = parse_probe_trace_command(ent->s, &tev);	2018	ret = parse_probe_trace_command(ent->s, &tev);
2019	if (ret < 0)	2019	if (ret < 0)
2020	break;	2020	break;
2021	if (include_group) {	2021	if (include_group) {
2022	ret = e_snprintf(buf, 128, "%s:%s", tev.group,	2022	ret = e_snprintf(buf, 128, "%s:%s", tev.group,
2023	tev.event);	2023	tev.event);
2024	if (ret >= 0)	2024	if (ret >= 0)
2025	ret = strlist__add(sl, buf);	2025	ret = strlist__add(sl, buf);
2026	} else	2026	} else
2027	ret = strlist__add(sl, tev.event);	2027	ret = strlist__add(sl, tev.event);
2028	clear_probe_trace_event(&tev);	2028	clear_probe_trace_event(&tev);
2029	if (ret < 0)	2029	if (ret < 0)
2030	break;	2030	break;
2031	}	2031	}
2032	strlist__delete(rawlist);	2032	strlist__delete(rawlist);
2033		2033
2034	if (ret < 0) {	2034	if (ret < 0) {
2035	strlist__delete(sl);	2035	strlist__delete(sl);
2036	return NULL;	2036	return NULL;
2037	}	2037	}
2038	return sl;	2038	return sl;
2039	}	2039	}
2040		2040
2041	static int write_probe_trace_event(int fd, struct probe_trace_event *tev)	2041	static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
2042	{	2042	{
2043	int ret = 0;	2043	int ret = 0;
2044	char *buf = synthesize_probe_trace_command(tev);	2044	char *buf = synthesize_probe_trace_command(tev);
2045	char sbuf[STRERR_BUFSIZE];	2045	char sbuf[STRERR_BUFSIZE];
2046		2046
2047	if (!buf) {	2047	if (!buf) {
2048	pr_debug("Failed to synthesize probe trace event.\n");	2048	pr_debug("Failed to synthesize probe trace event.\n");
2049	return -EINVAL;	2049	return -EINVAL;
2050	}	2050	}
2051		2051
2052	pr_debug("Writing event: %s\n", buf);	2052	pr_debug("Writing event: %s\n", buf);
2053	if (!probe_event_dry_run) {	2053	if (!probe_event_dry_run) {
2054	ret = write(fd, buf, strlen(buf));	2054	ret = write(fd, buf, strlen(buf));
2055	if (ret <= 0) {	2055	if (ret <= 0) {
2056	ret = -errno;	2056	ret = -errno;
2057	pr_warning("Failed to write event: %s\n",	2057	pr_warning("Failed to write event: %s\n",
2058	strerror_r(errno, sbuf, sizeof(sbuf)));	2058	strerror_r(errno, sbuf, sizeof(sbuf)));
2059	}	2059	}
2060	}	2060	}
2061	free(buf);	2061	free(buf);
2062	return ret;	2062	return ret;
2063	}	2063	}
2064		2064
2065	static int get_new_event_name(char buf, size_t len, const char base,	2065	static int get_new_event_name(char buf, size_t len, const char base,
2066	struct strlist *namelist, bool allow_suffix)	2066	struct strlist *namelist, bool allow_suffix)
2067	{	2067	{
2068	int i, ret;	2068	int i, ret;
2069		2069
2070	/* Try no suffix */	2070	/* Try no suffix */
2071	ret = e_snprintf(buf, len, "%s", base);	2071	ret = e_snprintf(buf, len, "%s", base);
2072	if (ret < 0) {	2072	if (ret < 0) {
2073	pr_debug("snprintf() failed: %d\n", ret);	2073	pr_debug("snprintf() failed: %d\n", ret);
2074	return ret;	2074	return ret;
2075	}	2075	}
2076	if (!strlist__has_entry(namelist, buf))	2076	if (!strlist__has_entry(namelist, buf))
2077	return 0;	2077	return 0;
2078		2078
2079	if (!allow_suffix) {	2079	if (!allow_suffix) {
2080	pr_warning("Error: event \"%s\" already exists. "	2080	pr_warning("Error: event \"%s\" already exists. "
2081	"(Use -f to force duplicates.)\n", base);	2081	"(Use -f to force duplicates.)\n", base);
2082	return -EEXIST;	2082	return -EEXIST;
2083	}	2083	}
2084		2084
2085	/* Try to add suffix */	2085	/* Try to add suffix */
2086	for (i = 1; i < MAX_EVENT_INDEX; i++) {	2086	for (i = 1; i < MAX_EVENT_INDEX; i++) {
2087	ret = e_snprintf(buf, len, "%s_%d", base, i);	2087	ret = e_snprintf(buf, len, "%s_%d", base, i);
2088	if (ret < 0) {	2088	if (ret < 0) {
2089	pr_debug("snprintf() failed: %d\n", ret);	2089	pr_debug("snprintf() failed: %d\n", ret);
2090	return ret;	2090	return ret;
2091	}	2091	}
2092	if (!strlist__has_entry(namelist, buf))	2092	if (!strlist__has_entry(namelist, buf))
2093	break;	2093	break;
2094	}	2094	}
2095	if (i == MAX_EVENT_INDEX) {	2095	if (i == MAX_EVENT_INDEX) {
2096	pr_warning("Too many events are on the same function.\n");	2096	pr_warning("Too many events are on the same function.\n");
2097	ret = -ERANGE;	2097	ret = -ERANGE;
2098	}	2098	}
2099		2099
2100	return ret;	2100	return ret;
2101	}	2101	}
2102		2102
2103	static int __add_probe_trace_events(struct perf_probe_event *pev,	2103	static int __add_probe_trace_events(struct perf_probe_event *pev,
2104	struct probe_trace_event *tevs,	2104	struct probe_trace_event *tevs,
2105	int ntevs, bool allow_suffix)	2105	int ntevs, bool allow_suffix)
2106	{	2106	{
2107	int i, fd, ret;	2107	int i, fd, ret;
2108	struct probe_trace_event *tev = NULL;	2108	struct probe_trace_event *tev = NULL;
2109	char buf[64];	2109	char buf[64];
2110	const char event, group;	2110	const char event, group;
2111	struct strlist *namelist;	2111	struct strlist *namelist;
2112		2112
2113	if (pev->uprobes)	2113	if (pev->uprobes)
2114	fd = open_uprobe_events(true);	2114	fd = open_uprobe_events(true);
2115	else	2115	else
2116	fd = open_kprobe_events(true);	2116	fd = open_kprobe_events(true);
2117		2117
2118	if (fd < 0) {	2118	if (fd < 0) {
2119	print_open_warning(fd, !pev->uprobes);	2119	print_open_warning(fd, !pev->uprobes);
2120	return fd;	2120	return fd;
2121	}	2121	}
2122		2122
2123	/* Get current event names */	2123	/* Get current event names */
2124	namelist = get_probe_trace_event_names(fd, false);	2124	namelist = get_probe_trace_event_names(fd, false);
2125	if (!namelist) {	2125	if (!namelist) {
2126	pr_debug("Failed to get current event list.\n");	2126	pr_debug("Failed to get current event list.\n");
2127	return -EIO;	2127	return -EIO;
2128	}	2128	}
2129		2129
2130	ret = 0;	2130	ret = 0;
2131	pr_info("Added new event%s\n", (ntevs > 1) ? "s:" : ":");	2131	pr_info("Added new event%s\n", (ntevs > 1) ? "s:" : ":");
2132	for (i = 0; i < ntevs; i++) {	2132	for (i = 0; i < ntevs; i++) {
2133	tev = &tevs[i];	2133	tev = &tevs[i];
2134	if (pev->event)	2134	if (pev->event)
2135	event = pev->event;	2135	event = pev->event;
2136	else	2136	else
2137	if (pev->point.function)	2137	if (pev->point.function)
2138	event = pev->point.function;	2138	event = pev->point.function;
2139	else	2139	else
2140	event = tev->point.symbol;	2140	event = tev->point.symbol;
2141	if (pev->group)	2141	if (pev->group)
2142	group = pev->group;	2142	group = pev->group;
2143	else	2143	else
2144	group = PERFPROBE_GROUP;	2144	group = PERFPROBE_GROUP;
2145		2145
2146	/* Get an unused new event name */	2146	/* Get an unused new event name */
2147	ret = get_new_event_name(buf, 64, event,	2147	ret = get_new_event_name(buf, 64, event,
2148	namelist, allow_suffix);	2148	namelist, allow_suffix);
2149	if (ret < 0)	2149	if (ret < 0)
2150	break;	2150	break;
2151	event = buf;	2151	event = buf;
2152		2152
2153	tev->event = strdup(event);	2153	tev->event = strdup(event);
2154	tev->group = strdup(group);	2154	tev->group = strdup(group);
2155	if (tev->event == NULL \|\| tev->group == NULL) {	2155	if (tev->event == NULL \|\| tev->group == NULL) {
2156	ret = -ENOMEM;	2156	ret = -ENOMEM;
2157	break;	2157	break;
2158	}	2158	}
2159	ret = write_probe_trace_event(fd, tev);	2159	ret = write_probe_trace_event(fd, tev);
2160	if (ret < 0)	2160	if (ret < 0)
2161	break;	2161	break;
2162	/* Add added event name to namelist */	2162	/* Add added event name to namelist */
2163	strlist__add(namelist, event);	2163	strlist__add(namelist, event);
2164		2164
2165	/* Trick here - save current event/group */	2165	/* Trick here - save current event/group */
2166	event = pev->event;	2166	event = pev->event;
2167	group = pev->group;	2167	group = pev->group;
2168	pev->event = tev->event;	2168	pev->event = tev->event;
2169	pev->group = tev->group;	2169	pev->group = tev->group;
2170	show_perf_probe_event(pev, tev->point.module);	2170	show_perf_probe_event(pev, tev->point.module);
2171	/* Trick here - restore current event/group */	2171	/* Trick here - restore current event/group */
2172	pev->event = (char *)event;	2172	pev->event = (char *)event;
2173	pev->group = (char *)group;	2173	pev->group = (char *)group;
2174		2174
2175	/*	2175	/*
2176	* Probes after the first probe which comes from same	2176	* Probes after the first probe which comes from same
2177	* user input are always allowed to add suffix, because	2177	* user input are always allowed to add suffix, because
2178	* there might be several addresses corresponding to	2178	* there might be several addresses corresponding to
2179	* one code line.	2179	* one code line.
2180	*/	2180	*/
2181	allow_suffix = true;	2181	allow_suffix = true;
2182	}	2182	}
2183		2183
2184	if (ret >= 0) {	2184	if (ret >= 0) {
2185	/* Show how to use the event. */	2185	/* Show how to use the event. */
2186	pr_info("\nYou can now use it in all perf tools, such as:\n\n");	2186	pr_info("\nYou can now use it in all perf tools, such as:\n\n");
2187	pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,	2187	pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
2188	tev->event);	2188	tev->event);
2189	}	2189	}
2190		2190
2191	strlist__delete(namelist);	2191	strlist__delete(namelist);
2192	close(fd);	2192	close(fd);
2193	return ret;	2193	return ret;
2194	}	2194	}
2195		2195
2196	static char *looking_function_name;	2196	static int find_probe_functions(struct map map, char name)
2197	static int num_matched_functions;
2198
2199	static int probe_function_filter(struct map *map __maybe_unused,
2200	struct symbol *sym)
2201	{	2197	{
2202	if ((sym->binding == STB_GLOBAL \|\| sym->binding == STB_LOCAL) &&	2198	int found = 0;
2203	strcmp(looking_function_name, sym->name) == 0) {	2199	struct symbol *sym;
2204	num_matched_functions++;	2200
2205	return 0;	2201	map__for_each_symbol_by_name(map, name, sym) {
		2202	if (sym->binding == STB_GLOBAL \|\| sym->binding == STB_LOCAL)
		2203	found++;
2206	}	2204	}
2207	return 1;	2205
		2206	return found;
2208	}	2207	}
2209		2208
2210	#define strdup_or_goto(str, label) \	2209	#define strdup_or_goto(str, label) \
2211	({ char *__p = strdup(str); if (!__p) goto label; __p; })	2210	({ char *__p = strdup(str); if (!__p) goto label; __p; })
2212		2211
2213	/*	2212	/*
2214	* Find probe function addresses from map.	2213	* Find probe function addresses from map.
2215	* Return an error or the number of found probe_trace_event	2214	* Return an error or the number of found probe_trace_event
2216	*/	2215	*/
2217	static int find_probe_trace_events_from_map(struct perf_probe_event *pev,	2216	static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
2218	struct probe_trace_event **tevs,	2217	struct probe_trace_event **tevs,
2219	int max_tevs, const char *target)	2218	int max_tevs, const char *target)
2220	{	2219	{
2221	struct map *map = NULL;	2220	struct map *map = NULL;
2222	struct kmap *kmap = NULL;	2221	struct kmap *kmap = NULL;
2223	struct ref_reloc_sym *reloc_sym = NULL;	2222	struct ref_reloc_sym *reloc_sym = NULL;
2224	struct symbol *sym;	2223	struct symbol *sym;
2225	struct rb_node *nd;
2226	struct probe_trace_event *tev;	2224	struct probe_trace_event *tev;
2227	struct perf_probe_point *pp = &pev->point;	2225	struct perf_probe_point *pp = &pev->point;
2228	struct probe_trace_point *tp;	2226	struct probe_trace_point *tp;
		2227	int num_matched_functions;
2229	int ret, i;	2228	int ret, i;
2230		2229
2231	/* Init maps of given executable or kernel */	2230	/* Init maps of given executable or kernel */
2232	if (pev->uprobes)	2231	if (pev->uprobes)
2233	map = dso__new_map(target);	2232	map = dso__new_map(target);
2234	else	2233	else
2235	map = kernel_get_module_map(target);	2234	map = kernel_get_module_map(target);
2236	if (!map) {	2235	if (!map) {
2237	ret = -EINVAL;	2236	ret = -EINVAL;
2238	goto out;	2237	goto out;
2239	}	2238	}
2240		2239
2241	/*	2240	/*
2242	* Load matched symbols: Since the different local symbols may have	2241	* Load matched symbols: Since the different local symbols may have
2243	* same name but different addresses, this lists all the symbols.	2242	* same name but different addresses, this lists all the symbols.
2244	*/	2243	*/
2245	num_matched_functions = 0;	2244	num_matched_functions = find_probe_functions(map, pp->function);
2246	looking_function_name = pp->function;	2245	if (num_matched_functions == 0) {
2247	ret = map__load(map, probe_function_filter);
2248	if (ret \|\| num_matched_functions == 0) {
2249	pr_err("Failed to find symbol %s in %s\n", pp->function,	2246	pr_err("Failed to find symbol %s in %s\n", pp->function,
2250	target ? : "kernel");	2247	target ? : "kernel");
2251	ret = -ENOENT;	2248	ret = -ENOENT;
2252	goto out;	2249	goto out;
2253	} else if (num_matched_functions > max_tevs) {	2250	} else if (num_matched_functions > max_tevs) {
2254	pr_err("Too many functions matched in %s\n",	2251	pr_err("Too many functions matched in %s\n",
2255	target ? : "kernel");	2252	target ? : "kernel");
2256	ret = -E2BIG;	2253	ret = -E2BIG;
2257	goto out;	2254	goto out;
2258	}	2255	}
2259		2256
2260	if (!pev->uprobes) {	2257	if (!pev->uprobes && !pp->retprobe) {
2261	kmap = map__kmap(map);	2258	kmap = map__kmap(map);
2262	reloc_sym = kmap->ref_reloc_sym;	2259	reloc_sym = kmap->ref_reloc_sym;
2263	if (!reloc_sym) {	2260	if (!reloc_sym) {
2264	pr_warning("Relocated base symbol is not found!\n");	2261	pr_warning("Relocated base symbol is not found!\n");
2265	ret = -EINVAL;	2262	ret = -EINVAL;
2266	goto out;	2263	goto out;
2267	}	2264	}
2268	}	2265	}
2269		2266
2270	/* Setup result trace-probe-events */	2267	/* Setup result trace-probe-events */
2271	tevs = zalloc(sizeof(tev) * num_matched_functions);	2268	tevs = zalloc(sizeof(tev) * num_matched_functions);
2272	if (!*tevs) {	2269	if (!*tevs) {
2273	ret = -ENOMEM;	2270	ret = -ENOMEM;
2274	goto out;	2271	goto out;
2275	}	2272	}
2276		2273
2277	ret = 0;	2274	ret = 0;
2278	map__for_each_symbol(map, sym, nd) {	2275
		2276	map__for_each_symbol_by_name(map, pp->function, sym) {
2279	tev = (*tevs) + ret;	2277	tev = (*tevs) + ret;
2280	tp = &tev->point;	2278	tp = &tev->point;
2281	if (ret == num_matched_functions) {	2279	if (ret == num_matched_functions) {
2282	pr_warning("Too many symbols are listed. Skip it.\n");	2280	pr_warning("Too many symbols are listed. Skip it.\n");
2283	break;	2281	break;
2284	}	2282	}
2285	ret++;	2283	ret++;
2286		2284
2287	if (pp->offset > sym->end - sym->start) {	2285	if (pp->offset > sym->end - sym->start) {
2288	pr_warning("Offset %ld is bigger than the size of %s\n",	2286	pr_warning("Offset %ld is bigger than the size of %s\n",
2289	pp->offset, sym->name);	2287	pp->offset, sym->name);
2290	ret = -ENOENT;	2288	ret = -ENOENT;
2291	goto err_out;	2289	goto err_out;
2292	}	2290	}
2293	/* Add one probe point */	2291	/* Add one probe point */
2294	tp->address = map->unmap_ip(map, sym->start) + pp->offset;	2292	tp->address = map->unmap_ip(map, sym->start) + pp->offset;
2295	if (reloc_sym) {	2293	if (reloc_sym) {
2296	tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out);	2294	tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out);
2297	tp->offset = tp->address - reloc_sym->addr;	2295	tp->offset = tp->address - reloc_sym->addr;
2298	} else {	2296	} else {
2299	tp->symbol = strdup_or_goto(sym->name, nomem_out);	2297	tp->symbol = strdup_or_goto(sym->name, nomem_out);
2300	tp->offset = pp->offset;	2298	tp->offset = pp->offset;
2301	}	2299	}
2302	tp->retprobe = pp->retprobe;	2300	tp->retprobe = pp->retprobe;
2303	if (target)	2301	if (target)
2304	tev->point.module = strdup_or_goto(target, nomem_out);	2302	tev->point.module = strdup_or_goto(target, nomem_out);
2305	tev->uprobes = pev->uprobes;	2303	tev->uprobes = pev->uprobes;
2306	tev->nargs = pev->nargs;	2304	tev->nargs = pev->nargs;
2307	if (tev->nargs) {	2305	if (tev->nargs) {
2308	tev->args = zalloc(sizeof(struct probe_trace_arg) *	2306	tev->args = zalloc(sizeof(struct probe_trace_arg) *
2309	tev->nargs);	2307	tev->nargs);
2310	if (tev->args == NULL)	2308	if (tev->args == NULL)
2311	goto nomem_out;	2309	goto nomem_out;
2312	}	2310	}
2313	for (i = 0; i < tev->nargs; i++) {	2311	for (i = 0; i < tev->nargs; i++) {
2314	if (pev->args[i].name)	2312	if (pev->args[i].name)
2315	tev->args[i].name =	2313	tev->args[i].name =
2316	strdup_or_goto(pev->args[i].name,	2314	strdup_or_goto(pev->args[i].name,
2317	nomem_out);	2315	nomem_out);
2318		2316
2319	tev->args[i].value = strdup_or_goto(pev->args[i].var,	2317	tev->args[i].value = strdup_or_goto(pev->args[i].var,
2320	nomem_out);	2318	nomem_out);
2321	if (pev->args[i].type)	2319	if (pev->args[i].type)
2322	tev->args[i].type =	2320	tev->args[i].type =
2323	strdup_or_goto(pev->args[i].type,	2321	strdup_or_goto(pev->args[i].type,
2324	nomem_out);	2322	nomem_out);
2325	}	2323	}
2326	}	2324	}
2327		2325
2328	out:	2326	out:
2329	if (map && pev->uprobes) {	2327	if (map && pev->uprobes) {
2330	/* Only when using uprobe(exec) map needs to be released */	2328	/* Only when using uprobe(exec) map needs to be released */
2331	dso__delete(map->dso);	2329	dso__delete(map->dso);
2332	map__delete(map);	2330	map__delete(map);
2333	}	2331	}
2334	return ret;	2332	return ret;
2335		2333
2336	nomem_out:	2334	nomem_out:
2337	ret = -ENOMEM;	2335	ret = -ENOMEM;
2338	err_out:	2336	err_out:
2339	clear_probe_trace_events(*tevs, num_matched_functions);	2337	clear_probe_trace_events(*tevs, num_matched_functions);
2340	zfree(tevs);	2338	zfree(tevs);
2341	goto out;	2339	goto out;
2342	}	2340	}
2343		2341
2344	static int convert_to_probe_trace_events(struct perf_probe_event *pev,	2342	static int convert_to_probe_trace_events(struct perf_probe_event *pev,
2345	struct probe_trace_event **tevs,	2343	struct probe_trace_event **tevs,
2346	int max_tevs, const char *target)	2344	int max_tevs, const char *target)
2347	{	2345	{
2348	int ret;	2346	int ret;
2349		2347
2350	if (pev->uprobes && !pev->group) {	2348	if (pev->uprobes && !pev->group) {
2351	/* Replace group name if not given */	2349	/* Replace group name if not given */
2352	ret = convert_exec_to_group(target, &pev->group);	2350	ret = convert_exec_to_group(target, &pev->group);
2353	if (ret != 0) {	2351	if (ret != 0) {
2354	pr_warning("Failed to make a group name.\n");	2352	pr_warning("Failed to make a group name.\n");
2355	return ret;	2353	return ret;
2356	}	2354	}
2357	}	2355	}
2358		2356
2359	/* Convert perf_probe_event with debuginfo */	2357	/* Convert perf_probe_event with debuginfo */
2360	ret = try_to_find_probe_trace_events(pev, tevs, max_tevs, target);	2358	ret = try_to_find_probe_trace_events(pev, tevs, max_tevs, target);
2361	if (ret != 0)	2359	if (ret != 0)
2362	return ret; /* Found in debuginfo or got an error */	2360	return ret; /* Found in debuginfo or got an error */
2363		2361
2364	return find_probe_trace_events_from_map(pev, tevs, max_tevs, target);	2362	return find_probe_trace_events_from_map(pev, tevs, max_tevs, target);
2365	}	2363	}
2366		2364
2367	struct __event_package {	2365	struct __event_package {
2368	struct perf_probe_event *pev;	2366	struct perf_probe_event *pev;
2369	struct probe_trace_event *tevs;	2367	struct probe_trace_event *tevs;
2370	int ntevs;	2368	int ntevs;
2371	};	2369	};
2372		2370
2373	int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,	2371	int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
2374	int max_tevs, const char *target, bool force_add)	2372	int max_tevs, const char *target, bool force_add)
2375	{	2373	{
2376	int i, j, ret;	2374	int i, j, ret;
2377	struct __event_package *pkgs;	2375	struct __event_package *pkgs;
2378		2376
2379	ret = 0;	2377	ret = 0;
2380	pkgs = zalloc(sizeof(struct __event_package) * npevs);	2378	pkgs = zalloc(sizeof(struct __event_package) * npevs);
2381		2379
2382	if (pkgs == NULL)	2380	if (pkgs == NULL)
2383	return -ENOMEM;	2381	return -ENOMEM;
2384		2382
2385	ret = init_symbol_maps(pevs->uprobes);	2383	ret = init_symbol_maps(pevs->uprobes);
2386	if (ret < 0) {	2384	if (ret < 0) {
2387	free(pkgs);	2385	free(pkgs);
2388	return ret;	2386	return ret;
2389	}	2387	}
2390		2388
2391	/* Loop 1: convert all events */	2389	/* Loop 1: convert all events */
2392	for (i = 0; i < npevs; i++) {	2390	for (i = 0; i < npevs; i++) {
2393	pkgs[i].pev = &pevs[i];	2391	pkgs[i].pev = &pevs[i];
2394	/* Convert with or without debuginfo */	2392	/* Convert with or without debuginfo */
2395	ret = convert_to_probe_trace_events(pkgs[i].pev,	2393	ret = convert_to_probe_trace_events(pkgs[i].pev,
2396	&pkgs[i].tevs,	2394	&pkgs[i].tevs,
2397	max_tevs,	2395	max_tevs,
2398	target);	2396	target);
2399	if (ret < 0)	2397	if (ret < 0)
2400	goto end;	2398	goto end;
2401	pkgs[i].ntevs = ret;	2399	pkgs[i].ntevs = ret;
2402	}	2400	}
2403		2401
2404	/* Loop 2: add all events */	2402	/* Loop 2: add all events */
2405	for (i = 0; i < npevs; i++) {	2403	for (i = 0; i < npevs; i++) {
2406	ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,	2404	ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
2407	pkgs[i].ntevs, force_add);	2405	pkgs[i].ntevs, force_add);
2408	if (ret < 0)	2406	if (ret < 0)
2409	break;	2407	break;
2410	}	2408	}
2411	end:	2409	end:
2412	/* Loop 3: cleanup and free trace events */	2410	/* Loop 3: cleanup and free trace events */
2413	for (i = 0; i < npevs; i++) {	2411	for (i = 0; i < npevs; i++) {
2414	for (j = 0; j < pkgs[i].ntevs; j++)	2412	for (j = 0; j < pkgs[i].ntevs; j++)
2415	clear_probe_trace_event(&pkgs[i].tevs[j]);	2413	clear_probe_trace_event(&pkgs[i].tevs[j]);
2416	zfree(&pkgs[i].tevs);	2414	zfree(&pkgs[i].tevs);
2417	}	2415	}
2418	free(pkgs);	2416	free(pkgs);
2419	exit_symbol_maps();	2417	exit_symbol_maps();
2420		2418
2421	return ret;	2419	return ret;
2422	}	2420	}
2423		2421
2424	static int __del_trace_probe_event(int fd, struct str_node *ent)	2422	static int __del_trace_probe_event(int fd, struct str_node *ent)
2425	{	2423	{
2426	char *p;	2424	char *p;
2427	char buf[128];	2425	char buf[128];
2428	int ret;	2426	int ret;
2429		2427
2430	/* Convert from perf-probe event to trace-probe event */	2428	/* Convert from perf-probe event to trace-probe event */
2431	ret = e_snprintf(buf, 128, "-:%s", ent->s);	2429	ret = e_snprintf(buf, 128, "-:%s", ent->s);
2432	if (ret < 0)	2430	if (ret < 0)
2433	goto error;	2431	goto error;
2434		2432
2435	p = strchr(buf + 2, ':');	2433	p = strchr(buf + 2, ':');
2436	if (!p) {	2434	if (!p) {
2437	pr_debug("Internal error: %s should have ':' but not.\n",	2435	pr_debug("Internal error: %s should have ':' but not.\n",
2438	ent->s);	2436	ent->s);
2439	ret = -ENOTSUP;	2437	ret = -ENOTSUP;
2440	goto error;	2438	goto error;
2441	}	2439	}
2442	*p = '/';	2440	*p = '/';
2443		2441
2444	pr_debug("Writing event: %s\n", buf);	2442	pr_debug("Writing event: %s\n", buf);
2445	ret = write(fd, buf, strlen(buf));	2443	ret = write(fd, buf, strlen(buf));
2446	if (ret < 0) {	2444	if (ret < 0) {
2447	ret = -errno;	2445	ret = -errno;
2448	goto error;	2446	goto error;
2449	}	2447	}
2450		2448
2451	pr_info("Removed event: %s\n", ent->s);	2449	pr_info("Removed event: %s\n", ent->s);
2452	return 0;	2450	return 0;
2453	error:	2451	error:
2454	pr_warning("Failed to delete event: %s\n",	2452	pr_warning("Failed to delete event: %s\n",
2455	strerror_r(-ret, buf, sizeof(buf)));	2453	strerror_r(-ret, buf, sizeof(buf)));
2456	return ret;	2454	return ret;
2457	}	2455	}
2458		2456
2459	static int del_trace_probe_event(int fd, const char *buf,	2457	static int del_trace_probe_event(int fd, const char *buf,
2460	struct strlist *namelist)	2458	struct strlist *namelist)
2461	{	2459	{
2462	struct str_node ent, n;	2460	struct str_node ent, n;
2463	int ret = -1;	2461	int ret = -1;
2464		2462
2465	if (strpbrk(buf, "?")) { / Glob-exp */	2463	if (strpbrk(buf, "?")) { / Glob-exp */
2466	strlist__for_each_safe(ent, n, namelist)	2464	strlist__for_each_safe(ent, n, namelist)
2467	if (strglobmatch(ent->s, buf)) {	2465	if (strglobmatch(ent->s, buf)) {
2468	ret = __del_trace_probe_event(fd, ent);	2466	ret = __del_trace_probe_event(fd, ent);
2469	if (ret < 0)	2467	if (ret < 0)
2470	break;	2468	break;
2471	strlist__remove(namelist, ent);	2469	strlist__remove(namelist, ent);
2472	}	2470	}
2473	} else {	2471	} else {
2474	ent = strlist__find(namelist, buf);	2472	ent = strlist__find(namelist, buf);
2475	if (ent) {	2473	if (ent) {
2476	ret = __del_trace_probe_event(fd, ent);	2474	ret = __del_trace_probe_event(fd, ent);
2477	if (ret >= 0)	2475	if (ret >= 0)
2478	strlist__remove(namelist, ent);	2476	strlist__remove(namelist, ent);
2479	}	2477	}
2480	}	2478	}
2481		2479
2482	return ret;	2480	return ret;
2483	}	2481	}
2484		2482
2485	int del_perf_probe_events(struct strlist *dellist)	2483	int del_perf_probe_events(struct strlist *dellist)
2486	{	2484	{
2487	int ret = -1, ufd = -1, kfd = -1;	2485	int ret = -1, ufd = -1, kfd = -1;
2488	char buf[128];	2486	char buf[128];
2489	const char group, event;	2487	const char group, event;
2490	char p, str;	2488	char p, str;
2491	struct str_node *ent;	2489	struct str_node *ent;
2492	struct strlist namelist = NULL, unamelist = NULL;	2490	struct strlist namelist = NULL, unamelist = NULL;
2493		2491
2494	/* Get current event names */	2492	/* Get current event names */
2495	kfd = open_kprobe_events(true);	2493	kfd = open_kprobe_events(true);
2496	if (kfd >= 0)	2494	if (kfd >= 0)
2497	namelist = get_probe_trace_event_names(kfd, true);	2495	namelist = get_probe_trace_event_names(kfd, true);
2498		2496
2499	ufd = open_uprobe_events(true);	2497	ufd = open_uprobe_events(true);
2500	if (ufd >= 0)	2498	if (ufd >= 0)
2501	unamelist = get_probe_trace_event_names(ufd, true);	2499	unamelist = get_probe_trace_event_names(ufd, true);
2502		2500
2503	if (kfd < 0 && ufd < 0) {	2501	if (kfd < 0 && ufd < 0) {
2504	print_both_open_warning(kfd, ufd);	2502	print_both_open_warning(kfd, ufd);
2505	goto error;	2503	goto error;
2506	}	2504	}
2507		2505
2508	if (namelist == NULL && unamelist == NULL)	2506	if (namelist == NULL && unamelist == NULL)
2509	goto error;	2507	goto error;
2510		2508
2511	strlist__for_each(ent, dellist) {	2509	strlist__for_each(ent, dellist) {
2512	str = strdup(ent->s);	2510	str = strdup(ent->s);
2513	if (str == NULL) {	2511	if (str == NULL) {
2514	ret = -ENOMEM;	2512	ret = -ENOMEM;
2515	goto error;	2513	goto error;
2516	}	2514	}
2517	pr_debug("Parsing: %s\n", str);	2515	pr_debug("Parsing: %s\n", str);
2518	p = strchr(str, ':');	2516	p = strchr(str, ':');
2519	if (p) {	2517	if (p) {
2520	group = str;	2518	group = str;
2521	*p = '\0';	2519	*p = '\0';
2522	event = p + 1;	2520	event = p + 1;
2523	} else {	2521	} else {
2524	group = "*";	2522	group = "*";
2525	event = str;	2523	event = str;
2526	}	2524	}
2527		2525
2528	ret = e_snprintf(buf, 128, "%s:%s", group, event);	2526	ret = e_snprintf(buf, 128, "%s:%s", group, event);
2529	if (ret < 0) {	2527	if (ret < 0) {
2530	pr_err("Failed to copy event.");	2528	pr_err("Failed to copy event.");
2531	free(str);	2529	free(str);
2532	goto error;	2530	goto error;
2533	}	2531	}
2534		2532
2535	pr_debug("Group: %s, Event: %s\n", group, event);	2533	pr_debug("Group: %s, Event: %s\n", group, event);
2536		2534
2537	if (namelist)	2535	if (namelist)
2538	ret = del_trace_probe_event(kfd, buf, namelist);	2536	ret = del_trace_probe_event(kfd, buf, namelist);
2539		2537
2540	if (unamelist && ret != 0)	2538	if (unamelist && ret != 0)
2541	ret = del_trace_probe_event(ufd, buf, unamelist);	2539	ret = del_trace_probe_event(ufd, buf, unamelist);
2542		2540
2543	if (ret != 0)	2541	if (ret != 0)
2544	pr_info("Info: Event \"%s\" does not exist.\n", buf);	2542	pr_info("Info: Event \"%s\" does not exist.\n", buf);
2545		2543
2546	free(str);	2544	free(str);
2547	}	2545	}
2548		2546
2549	error:	2547	error:
2550	if (kfd >= 0) {	2548	if (kfd >= 0) {
2551	strlist__delete(namelist);	2549	strlist__delete(namelist);
2552	close(kfd);	2550	close(kfd);
2553	}	2551	}
2554		2552
2555	if (ufd >= 0) {	2553	if (ufd >= 0) {
2556	strlist__delete(unamelist);	2554	strlist__delete(unamelist);
2557	close(ufd);	2555	close(ufd);
2558	}	2556	}
2559		2557
2560	return ret;	2558	return ret;
2561	}	2559	}
2562		2560
2563	/* TODO: don't use a global variable for filter ... */	2561	/* TODO: don't use a global variable for filter ... */
2564	static struct strfilter *available_func_filter;	2562	static struct strfilter *available_func_filter;
2565		2563
2566	/*	2564	/*
2567	* If a symbol corresponds to a function with global binding and	2565	* If a symbol corresponds to a function with global binding and
2568	* matches filter return 0. For all others return 1.	2566	* matches filter return 0. For all others return 1.
2569	*/	2567	*/
2570	static int filter_available_functions(struct map *map __maybe_unused,	2568	static int filter_available_functions(struct map *map __maybe_unused,
2571	struct symbol *sym)	2569	struct symbol *sym)
2572	{	2570	{
2573	if ((sym->binding == STB_GLOBAL \|\| sym->binding == STB_LOCAL) &&	2571	if ((sym->binding == STB_GLOBAL \|\| sym->binding == STB_LOCAL) &&
2574	strfilter__compare(available_func_filter, sym->name))	2572	strfilter__compare(available_func_filter, sym->name))
2575	return 0;	2573	return 0;
2576	return 1;	2574	return 1;
2577	}	2575	}
2578		2576
2579	int show_available_funcs(const char target, struct strfilter _filter,	2577	int show_available_funcs(const char target, struct strfilter _filter,
2580	bool user)	2578	bool user)
2581	{	2579	{
2582	struct map *map;	2580	struct map *map;
2583	int ret;	2581	int ret;
2584		2582
2585	ret = init_symbol_maps(user);	2583	ret = init_symbol_maps(user);
2586	if (ret < 0)	2584	if (ret < 0)
2587	return ret;	2585	return ret;
2588		2586
2589	/* Get a symbol map */	2587	/* Get a symbol map */
2590	if (user)	2588	if (user)
2591	map = dso__new_map(target);	2589	map = dso__new_map(target);
2592	else	2590	else
2593	map = kernel_get_module_map(target);	2591	map = kernel_get_module_map(target);
2594	if (!map) {	2592	if (!map) {
2595	pr_err("Failed to get a map for %s\n", (target) ? : "kernel");	2593	pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
2596	return -EINVAL;	2594	return -EINVAL;
2597	}	2595	}
2598		2596
2599	/* Load symbols with given filter */	2597	/* Load symbols with given filter */
2600	available_func_filter = _filter;	2598	available_func_filter = _filter;
2601	if (map__load(map, filter_available_functions)) {	2599	if (map__load(map, filter_available_functions)) {
2602	pr_err("Failed to load symbols in %s\n", (target) ? : "kernel");	2600	pr_err("Failed to load symbols in %s\n", (target) ? : "kernel");
2603	goto end;	2601	goto end;
2604	}	2602	}
2605	if (!dso__sorted_by_name(map->dso, map->type))	2603	if (!dso__sorted_by_name(map->dso, map->type))
2606	dso__sort_by_name(map->dso, map->type);	2604	dso__sort_by_name(map->dso, map->type);
2607		2605
2608	/* Show all (filtered) symbols */	2606	/* Show all (filtered) symbols */
2609	setup_pager();	2607	setup_pager();
2610	dso__fprintf_symbols_by_name(map->dso, map->type, stdout);	2608	dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
2611	end:	2609	end:
2612	if (user) {	2610	if (user) {
2613	dso__delete(map->dso);	2611	dso__delete(map->dso);
2614	map__delete(map);	2612	map__delete(map);
2615	}	2613	}
2616	exit_symbol_maps();	2614	exit_symbol_maps();

tools/perf/util/symbol.c

Diff comments View file @ e742f3d

 #include <dirent.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/param.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <inttypes.h>
 #include "build-id.h"
 #include "util.h"
 #include "debug.h"
 #include "machine.h"
 #include "symbol.h"
 #include "strlist.h"
 #include "header.h"
 #include <elf.h>
 #include <limits.h>
 #include <symbol/kallsyms.h>
 #include <sys/utsname.h>
 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
 				symbol_filter_t filter);
 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
 			symbol_filter_t filter);
 int vmlinux_path__nr_entries;
 char **vmlinux_path;
 struct symbol_conf symbol_conf = {
 	.use_modules		= true,
 	.try_vmlinux_path	= true,
 	.annotate_src		= true,
 	.demangle		= true,
 	.demangle_kernel	= false,
 	.cumulate_callchain	= true,
 	.show_hist_headers	= true,
 	.symfs			= "",
 };
 static enum dso_binary_type binary_type_symtab[] = {
 	DSO_BINARY_TYPE__KALLSYMS,
 	DSO_BINARY_TYPE__GUEST_KALLSYMS,
 	DSO_BINARY_TYPE__JAVA_JIT,
 	DSO_BINARY_TYPE__DEBUGLINK,
 	DSO_BINARY_TYPE__BUILD_ID_CACHE,
 	DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
 	DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
 	DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
 	DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
 	DSO_BINARY_TYPE__GUEST_KMODULE,
 	DSO_BINARY_TYPE__GUEST_KMODULE_COMP,
 	DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE,
 	DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP,
 	DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO,
 	DSO_BINARY_TYPE__NOT_FOUND,
 };
 #define DSO_BINARY_TYPE__SYMTAB_CNT ARRAY_SIZE(binary_type_symtab)
 bool symbol_type__is_a(char symbol_type, enum map_type map_type)
 {
 	symbol_type = toupper(symbol_type);
 	switch (map_type) {
 	case MAP__FUNCTION:
 		return symbol_type == 'T' || symbol_type == 'W';
 	case MAP__VARIABLE:
 		return symbol_type == 'D';
 	default:
 		return false;
 	}
 }
 static int prefix_underscores_count(const char *str)
 {
 	const char *tail = str;
 	while (*tail == '_')
 		tail++;
 	return tail - str;
 }
 #define SYMBOL_A 0
 #define SYMBOL_B 1
 static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
 {
 	s64 a;
 	s64 b;
 	size_t na, nb;
 	/* Prefer a symbol with non zero length */
 	a = syma->end - syma->start;
 	b = symb->end - symb->start;
 	if ((b == 0) && (a > 0))
 		return SYMBOL_A;
 	else if ((a == 0) && (b > 0))
 		return SYMBOL_B;
 	/* Prefer a non weak symbol over a weak one */
 	a = syma->binding == STB_WEAK;
 	b = symb->binding == STB_WEAK;
 	if (b && !a)
 		return SYMBOL_A;
 	if (a && !b)
 		return SYMBOL_B;
 	/* Prefer a global symbol over a non global one */
 	a = syma->binding == STB_GLOBAL;
 	b = symb->binding == STB_GLOBAL;
 	if (a && !b)
 		return SYMBOL_A;
 	if (b && !a)
 		return SYMBOL_B;
 	/* Prefer a symbol with less underscores */
 	a = prefix_underscores_count(syma->name);
 	b = prefix_underscores_count(symb->name);
 	if (b > a)
 		return SYMBOL_A;
 	else if (a > b)
 		return SYMBOL_B;
 	/* Choose the symbol with the longest name */
 	na = strlen(syma->name);
 	nb = strlen(symb->name);
 	if (na > nb)
 		return SYMBOL_A;
 	else if (na < nb)
 		return SYMBOL_B;
 	/* Avoid "SyS" kernel syscall aliases */
 	if (na >= 3 && !strncmp(syma->name, "SyS", 3))
 		return SYMBOL_B;
 	if (na >= 10 && !strncmp(syma->name, "compat_SyS", 10))
 		return SYMBOL_B;
 	return SYMBOL_A;
 }
 void symbols__fixup_duplicate(struct rb_root *symbols)
 {
 	struct rb_node *nd;
 	struct symbol *curr, *next;
 	nd = rb_first(symbols);
 	while (nd) {
 		curr = rb_entry(nd, struct symbol, rb_node);
 again:
 		nd = rb_next(&curr->rb_node);
 		next = rb_entry(nd, struct symbol, rb_node);
 		if (!nd)
 			break;
 		if (curr->start != next->start)
 			continue;
 		if (choose_best_symbol(curr, next) == SYMBOL_A) {
 			rb_erase(&next->rb_node, symbols);
 			symbol__delete(next);
 			goto again;
 		} else {
 			nd = rb_next(&curr->rb_node);
 			rb_erase(&curr->rb_node, symbols);
 			symbol__delete(curr);
 		}
 	}
 }
 void symbols__fixup_end(struct rb_root *symbols)
 {
 	struct rb_node *nd, *prevnd = rb_first(symbols);
 	struct symbol *curr, *prev;
 	if (prevnd == NULL)
 		return;
 	curr = rb_entry(prevnd, struct symbol, rb_node);
 	for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 		prev = curr;
 		curr = rb_entry(nd, struct symbol, rb_node);
 		if (prev->end == prev->start && prev->end != curr->start)
 			prev->end = curr->start;
 	}
 	/* Last entry */
 	if (curr->end == curr->start)
 		curr->end = roundup(curr->start, 4096);
 }
 void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
 {
 	struct map *prev, *curr;
 	struct rb_node *nd, *prevnd = rb_first(&mg->maps[type]);
 	if (prevnd == NULL)
 		return;
 	curr = rb_entry(prevnd, struct map, rb_node);
 	for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 		prev = curr;
 		curr = rb_entry(nd, struct map, rb_node);
 		prev->end = curr->start;
 	}
 	/*
 	 * We still haven't the actual symbols, so guess the
 	 * last map final address.
 	 */
 	curr->end = ~0ULL;
 }
 struct symbol *symbol__new(u64 start, u64 len, u8 binding, const char *name)
 {
 	size_t namelen = strlen(name) + 1;
 	struct symbol *sym = calloc(1, (symbol_conf.priv_size +
 					sizeof(*sym) + namelen));
 	if (sym == NULL)
 		return NULL;
 	if (symbol_conf.priv_size)
 		sym = ((void *)sym) + symbol_conf.priv_size;
 	sym->start   = start;
 	sym->end     = len ? start + len : start;
 	sym->binding = binding;
 	sym->namelen = namelen - 1;
 	pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n",
 		  __func__, name, start, sym->end);
 	memcpy(sym->name, name, namelen);
 	return sym;
 }
 void symbol__delete(struct symbol *sym)
 {
 	free(((void *)sym) - symbol_conf.priv_size);
 }
 size_t symbol__fprintf(struct symbol *sym, FILE *fp)
 {
 	return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %c %s\n",
 		       sym->start, sym->end,
 		       sym->binding == STB_GLOBAL ? 'g' :
 		       sym->binding == STB_LOCAL  ? 'l' : 'w',
 		       sym->name);
 }
 size_t symbol__fprintf_symname_offs(const struct symbol *sym,
 				    const struct addr_location *al, FILE *fp)
 {
 	unsigned long offset;
 	size_t length;
 	if (sym && sym->name) {
 		length = fprintf(fp, "%s", sym->name);
 		if (al) {
 			if (al->addr < sym->end)
 				offset = al->addr - sym->start;
 			else
 				offset = al->addr - al->map->start - sym->start;
 			length += fprintf(fp, "+0x%lx", offset);
 		}
 		return length;
 	} else
 		return fprintf(fp, "[unknown]");
 }
 size_t symbol__fprintf_symname(const struct symbol *sym, FILE *fp)
 {
 	return symbol__fprintf_symname_offs(sym, NULL, fp);
 }
 void symbols__delete(struct rb_root *symbols)
 {
 	struct symbol *pos;
 	struct rb_node *next = rb_first(symbols);
 	while (next) {
 		pos = rb_entry(next, struct symbol, rb_node);
 		next = rb_next(&pos->rb_node);
 		rb_erase(&pos->rb_node, symbols);
 		symbol__delete(pos);
 	}
 }
 void symbols__insert(struct rb_root *symbols, struct symbol *sym)
 {
 	struct rb_node **p = &symbols->rb_node;
 	struct rb_node *parent = NULL;
 	const u64 ip = sym->start;
 	struct symbol *s;
 	while (*p != NULL) {
 		parent = *p;
 		s = rb_entry(parent, struct symbol, rb_node);
 		if (ip < s->start)
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 	}
 	rb_link_node(&sym->rb_node, parent, p);
 	rb_insert_color(&sym->rb_node, symbols);
 }
 static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
 {
 	struct rb_node *n;
 	if (symbols == NULL)
 		return NULL;
 	n = symbols->rb_node;
 	while (n) {
 		struct symbol *s = rb_entry(n, struct symbol, rb_node);
 		if (ip < s->start)
 			n = n->rb_left;
 		else if (ip >= s->end)
 			n = n->rb_right;
 		else
 			return s;
 	}
 	return NULL;
 }
 static struct symbol *symbols__first(struct rb_root *symbols)
 {
 	struct rb_node *n = rb_first(symbols);
 	if (n)
 		return rb_entry(n, struct symbol, rb_node);
 	return NULL;
 }
 static struct symbol *symbols__next(struct symbol *sym)
 {
 	struct rb_node *n = rb_next(&sym->rb_node);
 	if (n)
 		return rb_entry(n, struct symbol, rb_node);
 	return NULL;
 }
 struct symbol_name_rb_node {
 	struct rb_node	rb_node;
 	struct symbol	sym;
 };
 static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym)
 {
 	struct rb_node **p = &symbols->rb_node;
 	struct rb_node *parent = NULL;
 	struct symbol_name_rb_node *symn, *s;
 	symn = container_of(sym, struct symbol_name_rb_node, sym);
 	while (*p != NULL) {
 		parent = *p;
 		s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
 		if (strcmp(sym->name, s->sym.name) < 0)
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 	}
 	rb_link_node(&symn->rb_node, parent, p);
 	rb_insert_color(&symn->rb_node, symbols);
 }
 static void symbols__sort_by_name(struct rb_root *symbols,
 				  struct rb_root *source)
 {
 	struct rb_node *nd;
 	for (nd = rb_first(source); nd; nd = rb_next(nd)) {
 		struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 		symbols__insert_by_name(symbols, pos);
 	}
 }
 static struct symbol *symbols__find_by_name(struct rb_root *symbols,
 					    const char *name)
 {
 	struct rb_node *n;
+	struct symbol_name_rb_node *s;
 	if (symbols == NULL)
 		return NULL;
 	n = symbols->rb_node;
 	while (n) {
-		struct symbol_name_rb_node *s;
 		int cmp;
 		s = rb_entry(n, struct symbol_name_rb_node, rb_node);
 		cmp = strcmp(name, s->sym.name);
 		if (cmp < 0)
 			n = n->rb_left;
 		else if (cmp > 0)
 			n = n->rb_right;
 		else
-			return &s->sym;
+			break;
 	}
-	return NULL;
+	if (n == NULL)
+		return NULL;
+	/* return first symbol that has same name (if any) */
+	for (n = rb_prev(n); n; n = rb_prev(n)) {
+		struct symbol_name_rb_node *tmp;
+		tmp = rb_entry(n, struct symbol_name_rb_node, rb_node);
+		if (strcmp(tmp->sym.name, s->sym.name))
+			break;
+		s = tmp;
+	}
+	return &s->sym;
 }
 struct symbol *dso__find_symbol(struct dso *dso,
 				enum map_type type, u64 addr)
 {
 	return symbols__find(&dso->symbols[type], addr);
 }
 struct symbol *dso__first_symbol(struct dso *dso, enum map_type type)
 {
 	return symbols__first(&dso->symbols[type]);
 }
 struct symbol *dso__next_symbol(struct symbol *sym)
 {
 	return symbols__next(sym);
 }
+struct symbol *symbol__next_by_name(struct symbol *sym)
+{
+	struct symbol_name_rb_node *s = container_of(sym, struct symbol_name_rb_node, sym);
+	struct rb_node *n = rb_next(&s->rb_node);
+	return n ? &rb_entry(n, struct symbol_name_rb_node, rb_node)->sym : NULL;
+}
+ /*
+  * Teturns first symbol that matched with @name.
+  */
 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
 					const char *name)
 {
 	return symbols__find_by_name(&dso->symbol_names[type], name);
 }
 void dso__sort_by_name(struct dso *dso, enum map_type type)
 {
 	dso__set_sorted_by_name(dso, type);
 	return symbols__sort_by_name(&dso->symbol_names[type],
 				     &dso->symbols[type]);
 }
 size_t dso__fprintf_symbols_by_name(struct dso *dso,
 				    enum map_type type, FILE *fp)
 {
 	size_t ret = 0;
 	struct rb_node *nd;
 	struct symbol_name_rb_node *pos;
 	for (nd = rb_first(&dso->symbol_names[type]); nd; nd = rb_next(nd)) {
 		pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
 		fprintf(fp, "%s\n", pos->sym.name);
 	}
 	return ret;
 }
 int modules__parse(const char *filename, void *arg,
 		   int (*process_module)(void *arg, const char *name,
 					 u64 start))
 {
 	char *line = NULL;
 	size_t n;
 	FILE *file;
 	int err = 0;
 	file = fopen(filename, "r");
 	if (file == NULL)
 		return -1;
 	while (1) {
 		char name[PATH_MAX];
 		u64 start;
 		char *sep;
 		ssize_t line_len;
 		line_len = getline(&line, &n, file);
 		if (line_len < 0) {
 			if (feof(file))
 				break;
 			err = -1;
 			goto out;
 		}
 		if (!line) {
 			err = -1;
 			goto out;
 		}
 		line[--line_len] = '\0'; /* \n */
 		sep = strrchr(line, 'x');
 		if (sep == NULL)
 			continue;
 		hex2u64(sep + 1, &start);
 		sep = strchr(line, ' ');
 		if (sep == NULL)
 			continue;
 		*sep = '\0';
 		scnprintf(name, sizeof(name), "[%s]", line);
 		err = process_module(arg, name, start);
 		if (err)
 			break;
 	}
 out:
 	free(line);
 	fclose(file);
 	return err;
 }
 struct process_kallsyms_args {
 	struct map *map;
 	struct dso *dso;
 };
 /*
  * These are symbols in the kernel image, so make sure that
  * sym is from a kernel DSO.
  */
 bool symbol__is_idle(struct symbol *sym)
 {
 	const char * const idle_symbols[] = {
 		"cpu_idle",
 		"cpu_startup_entry",
 		"intel_idle",
 		"default_idle",
 		"native_safe_halt",
 		"enter_idle",
 		"exit_idle",
 		"mwait_idle",
 		"mwait_idle_with_hints",
 		"poll_idle",
 		"ppc64_runlatch_off",
 		"pseries_dedicated_idle_sleep",
 		NULL
 	};
 	int i;
 	if (!sym)
 		return false;
 	for (i = 0; idle_symbols[i]; i++) {
 		if (!strcmp(idle_symbols[i], sym->name))
 			return true;
 	}
 	return false;
 }
 static int map__process_kallsym_symbol(void *arg, const char *name,
 				       char type, u64 start)
 {
 	struct symbol *sym;
 	struct process_kallsyms_args *a = arg;
 	struct rb_root *root = &a->dso->symbols[a->map->type];
 	if (!symbol_type__is_a(type, a->map->type))
 		return 0;
 	/*
 	 * module symbols are not sorted so we add all
 	 * symbols, setting length to 0, and rely on
 	 * symbols__fixup_end() to fix it up.
 	 */
 	sym = symbol__new(start, 0, kallsyms2elf_type(type), name);
 	if (sym == NULL)
 		return -ENOMEM;
 	/*
 	 * We will pass the symbols to the filter later, in
 	 * map__split_kallsyms, when we have split the maps per module
 	 */
 	symbols__insert(root, sym);
 	return 0;
 }
 /*
  * Loads the function entries in /proc/kallsyms into kernel_map->dso,
  * so that we can in the next step set the symbol ->end address and then
  * call kernel_maps__split_kallsyms.
  */
 static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
 				  struct map *map)
 {
 	struct process_kallsyms_args args = { .map = map, .dso = dso, };
 	return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
 }
 static int dso__split_kallsyms_for_kcore(struct dso *dso, struct map *map,
 					 symbol_filter_t filter)
 {
 	struct map_groups *kmaps = map__kmap(map)->kmaps;
 	struct map *curr_map;
 	struct symbol *pos;
 	int count = 0, moved = 0;
 	struct rb_root *root = &dso->symbols[map->type];
 	struct rb_node *next = rb_first(root);
 	while (next) {
 		char *module;
 		pos = rb_entry(next, struct symbol, rb_node);
 		next = rb_next(&pos->rb_node);
 		module = strchr(pos->name, '\t');
 		if (module)
 			*module = '\0';
 		curr_map = map_groups__find(kmaps, map->type, pos->start);
 		if (!curr_map || (filter && filter(curr_map, pos))) {
 			rb_erase(&pos->rb_node, root);
 			symbol__delete(pos);
 		} else {
 			pos->start -= curr_map->start - curr_map->pgoff;
 			if (pos->end)
 				pos->end -= curr_map->start - curr_map->pgoff;
 			if (curr_map != map) {
 				rb_erase(&pos->rb_node, root);
 				symbols__insert(
 					&curr_map->dso->symbols[curr_map->type],
 					pos);
 				++moved;
 			} else {
 				++count;
 			}
 		}
 	}
 	/* Symbols have been adjusted */
 	dso->adjust_symbols = 1;
 	return count + moved;
 }
 /*
  * Split the symbols into maps, making sure there are no overlaps, i.e. the
  * kernel range is broken in several maps, named [kernel].N, as we don't have
  * the original ELF section names vmlinux have.
  */
 static int dso__split_kallsyms(struct dso *dso, struct map *map, u64 delta,
 			       symbol_filter_t filter)
 {
 	struct map_groups *kmaps = map__kmap(map)->kmaps;
 	struct machine *machine = kmaps->machine;
 	struct map *curr_map = map;
 	struct symbol *pos;
 	int count = 0, moved = 0;
 	struct rb_root *root = &dso->symbols[map->type];
 	struct rb_node *next = rb_first(root);
 	int kernel_range = 0;
 	while (next) {
 		char *module;
 		pos = rb_entry(next, struct symbol, rb_node);
 		next = rb_next(&pos->rb_node);
 		module = strchr(pos->name, '\t');
 		if (module) {
 			if (!symbol_conf.use_modules)
 				goto discard_symbol;
 			*module++ = '\0';
 			if (strcmp(curr_map->dso->short_name, module)) {
 				if (curr_map != map &&
 				    dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 				    machine__is_default_guest(machine)) {
 					/*
 					 * We assume all symbols of a module are
 					 * continuous in * kallsyms, so curr_map
 					 * points to a module and all its
 					 * symbols are in its kmap. Mark it as
 					 * loaded.
 					 */
 					dso__set_loaded(curr_map->dso,
 							curr_map->type);
 				}
 				curr_map = map_groups__find_by_name(kmaps,
 							map->type, module);
 				if (curr_map == NULL) {
 					pr_debug("%s/proc/{kallsyms,modules} "
 					         "inconsistency while looking "
 						 "for \"%s\" module!\n",
 						 machine->root_dir, module);
 					curr_map = map;
 					goto discard_symbol;
 				}
 				if (curr_map->dso->loaded &&
 				    !machine__is_default_guest(machine))
 					goto discard_symbol;
 			}
 			/*
 			 * So that we look just like we get from .ko files,
 			 * i.e. not prelinked, relative to map->start.
 			 */
 			pos->start = curr_map->map_ip(curr_map, pos->start);
 			pos->end   = curr_map->map_ip(curr_map, pos->end);
 		} else if (curr_map != map) {
 			char dso_name[PATH_MAX];
 			struct dso *ndso;
 			if (delta) {
 				/* Kernel was relocated at boot time */
 				pos->start -= delta;
 				pos->end -= delta;
 			}
 			if (count == 0) {
 				curr_map = map;
 				goto filter_symbol;
 			}
 			if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 				snprintf(dso_name, sizeof(dso_name),
 					"[guest.kernel].%d",
 					kernel_range++);
 			else
 				snprintf(dso_name, sizeof(dso_name),
 					"[kernel].%d",
 					kernel_range++);
 			ndso = dso__new(dso_name);
 			if (ndso == NULL)
 				return -1;
 			ndso->kernel = dso->kernel;
 			curr_map = map__new2(pos->start, ndso, map->type);
 			if (curr_map == NULL) {
 				dso__delete(ndso);
 				return -1;
 			}
 			curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
 			map_groups__insert(kmaps, curr_map);
 			++kernel_range;
 		} else if (delta) {
 			/* Kernel was relocated at boot time */
 			pos->start -= delta;
 			pos->end -= delta;
 		}
 filter_symbol:
 		if (filter && filter(curr_map, pos)) {
 discard_symbol:		rb_erase(&pos->rb_node, root);
 			symbol__delete(pos);
 		} else {
 			if (curr_map != map) {
 				rb_erase(&pos->rb_node, root);
 				symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
 				++moved;
 			} else
 				++count;
 		}
 	}
 	if (curr_map != map &&
 	    dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 	    machine__is_default_guest(kmaps->machine)) {
 		dso__set_loaded(curr_map->dso, curr_map->type);
 	}
 	return count + moved;
 }
 bool symbol__restricted_filename(const char *filename,
 				 const char *restricted_filename)
 {
 	bool restricted = false;
 	if (symbol_conf.kptr_restrict) {
 		char *r = realpath(filename, NULL);
 		if (r != NULL) {
 			restricted = strcmp(r, restricted_filename) == 0;
 			free(r);
 			return restricted;
 		}
 	}
 	return restricted;
 }
 struct module_info {
 	struct rb_node rb_node;
 	char *name;
 	u64 start;
 };
 static void add_module(struct module_info *mi, struct rb_root *modules)
 {
 	struct rb_node **p = &modules->rb_node;
 	struct rb_node *parent = NULL;
 	struct module_info *m;
 	while (*p != NULL) {
 		parent = *p;
 		m = rb_entry(parent, struct module_info, rb_node);
 		if (strcmp(mi->name, m->name) < 0)
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 	}
 	rb_link_node(&mi->rb_node, parent, p);
 	rb_insert_color(&mi->rb_node, modules);
 }
 static void delete_modules(struct rb_root *modules)
 {
 	struct module_info *mi;
 	struct rb_node *next = rb_first(modules);
 	while (next) {
 		mi = rb_entry(next, struct module_info, rb_node);
 		next = rb_next(&mi->rb_node);
 		rb_erase(&mi->rb_node, modules);
 		zfree(&mi->name);
 		free(mi);
 	}
 }
 static struct module_info *find_module(const char *name,
 				       struct rb_root *modules)
 {
 	struct rb_node *n = modules->rb_node;
 	while (n) {
 		struct module_info *m;
 		int cmp;
 		m = rb_entry(n, struct module_info, rb_node);
 		cmp = strcmp(name, m->name);
 		if (cmp < 0)
 			n = n->rb_left;
 		else if (cmp > 0)
 			n = n->rb_right;
 		else
 			return m;
 	}
 	return NULL;
 }
 static int __read_proc_modules(void *arg, const char *name, u64 start)
 {
 	struct rb_root *modules = arg;
 	struct module_info *mi;
 	mi = zalloc(sizeof(struct module_info));
 	if (!mi)
 		return -ENOMEM;
 	mi->name = strdup(name);
 	mi->start = start;
 	if (!mi->name) {
 		free(mi);
 		return -ENOMEM;
 	}
 	add_module(mi, modules);
 	return 0;
 }
 static int read_proc_modules(const char *filename, struct rb_root *modules)
 {
 	if (symbol__restricted_filename(filename, "/proc/modules"))
 		return -1;
 	if (modules__parse(filename, modules, __read_proc_modules)) {
 		delete_modules(modules);
 		return -1;
 	}
 	return 0;
 }
 int compare_proc_modules(const char *from, const char *to)
 {
 	struct rb_root from_modules = RB_ROOT;
 	struct rb_root to_modules = RB_ROOT;
 	struct rb_node *from_node, *to_node;
 	struct module_info *from_m, *to_m;
 	int ret = -1;
 	if (read_proc_modules(from, &from_modules))
 		return -1;
 	if (read_proc_modules(to, &to_modules))
 		goto out_delete_from;
 	from_node = rb_first(&from_modules);
 	to_node = rb_first(&to_modules);
 	while (from_node) {
 		if (!to_node)
 			break;
 		from_m = rb_entry(from_node, struct module_info, rb_node);
 		to_m = rb_entry(to_node, struct module_info, rb_node);
 		if (from_m->start != to_m->start ||
 		    strcmp(from_m->name, to_m->name))
 			break;
 		from_node = rb_next(from_node);
 		to_node = rb_next(to_node);
 	}
 	if (!from_node && !to_node)
 		ret = 0;
 	delete_modules(&to_modules);
 out_delete_from:
 	delete_modules(&from_modules);
 	return ret;
 }
 static int do_validate_kcore_modules(const char *filename, struct map *map,
 				  struct map_groups *kmaps)
 {
 	struct rb_root modules = RB_ROOT;
 	struct map *old_map;
 	int err;
 	err = read_proc_modules(filename, &modules);
 	if (err)
 		return err;
 	old_map = map_groups__first(kmaps, map->type);
 	while (old_map) {
 		struct map *next = map_groups__next(old_map);
 		struct module_info *mi;
 		if (old_map == map || old_map->start == map->start) {
 			/* The kernel map */
 			old_map = next;
 			continue;
 		}
 		/* Module must be in memory at the same address */
 		mi = find_module(old_map->dso->short_name, &modules);
 		if (!mi || mi->start != old_map->start) {
 			err = -EINVAL;
 			goto out;
 		}
 		old_map = next;
 	}
 out:
 	delete_modules(&modules);
 	return err;
 }
 /*
  * If kallsyms is referenced by name then we look for filename in the same
  * directory.
  */
 static bool filename_from_kallsyms_filename(char *filename,
 					    const char *base_name,
 					    const char *kallsyms_filename)
 {
 	char *name;
 	strcpy(filename, kallsyms_filename);
 	name = strrchr(filename, '/');
 	if (!name)
 		return false;
 	name += 1;
 	if (!strcmp(name, "kallsyms")) {
 		strcpy(name, base_name);
 		return true;
 	}
 	return false;
 }
 static int validate_kcore_modules(const char *kallsyms_filename,
 				  struct map *map)
 {
 	struct map_groups *kmaps = map__kmap(map)->kmaps;
 	char modules_filename[PATH_MAX];
 	if (!filename_from_kallsyms_filename(modules_filename, "modules",
 					     kallsyms_filename))
 		return -EINVAL;
 	if (do_validate_kcore_modules(modules_filename, map, kmaps))
 		return -EINVAL;
 	return 0;
 }
 static int validate_kcore_addresses(const char *kallsyms_filename,
 				    struct map *map)
 {
 	struct kmap *kmap = map__kmap(map);
 	if (kmap->ref_reloc_sym && kmap->ref_reloc_sym->name) {
 		u64 start;
 		start = kallsyms__get_function_start(kallsyms_filename,
 						     kmap->ref_reloc_sym->name);
 		if (start != kmap->ref_reloc_sym->addr)
 			return -EINVAL;
 	}
 	return validate_kcore_modules(kallsyms_filename, map);
 }
 struct kcore_mapfn_data {
 	struct dso *dso;
 	enum map_type type;
 	struct list_head maps;
 };
 static int kcore_mapfn(u64 start, u64 len, u64 pgoff, void *data)
 {
 	struct kcore_mapfn_data *md = data;
 	struct map *map;
 	map = map__new2(start, md->dso, md->type);
 	if (map == NULL)
 		return -ENOMEM;
 	map->end = map->start + len;
 	map->pgoff = pgoff;
 	list_add(&map->node, &md->maps);
 	return 0;
 }
 static int dso__load_kcore(struct dso *dso, struct map *map,
 			   const char *kallsyms_filename)
 {
 	struct map_groups *kmaps = map__kmap(map)->kmaps;
 	struct machine *machine = kmaps->machine;
 	struct kcore_mapfn_data md;
 	struct map *old_map, *new_map, *replacement_map = NULL;
 	bool is_64_bit;
 	int err, fd;
 	char kcore_filename[PATH_MAX];
 	struct symbol *sym;
 	/* This function requires that the map is the kernel map */
 	if (map != machine->vmlinux_maps[map->type])
 		return -EINVAL;
 	if (!filename_from_kallsyms_filename(kcore_filename, "kcore",
 					     kallsyms_filename))
 		return -EINVAL;
 	/* Modules and kernel must be present at their original addresses */
 	if (validate_kcore_addresses(kallsyms_filename, map))
 		return -EINVAL;
 	md.dso = dso;
 	md.type = map->type;
 	INIT_LIST_HEAD(&md.maps);
 	fd = open(kcore_filename, O_RDONLY);
 	if (fd < 0)
 		return -EINVAL;
 	/* Read new maps into temporary lists */
 	err = file__read_maps(fd, md.type == MAP__FUNCTION, kcore_mapfn, &md,
 			      &is_64_bit);
 	if (err)
 		goto out_err;
 	dso->is_64_bit = is_64_bit;
 	if (list_empty(&md.maps)) {
 		err = -EINVAL;
 		goto out_err;
 	}
 	/* Remove old maps */
 	old_map = map_groups__first(kmaps, map->type);
 	while (old_map) {
 		struct map *next = map_groups__next(old_map);
 		if (old_map != map)
 			map_groups__remove(kmaps, old_map);
 		old_map = next;
 	}
 	/* Find the kernel map using the first symbol */
 	sym = dso__first_symbol(dso, map->type);
 	list_for_each_entry(new_map, &md.maps, node) {
 		if (sym && sym->start >= new_map->start &&
 		    sym->start < new_map->end) {
 			replacement_map = new_map;
 			break;
 		}
 	}
 	if (!replacement_map)
 		replacement_map = list_entry(md.maps.next, struct map, node);
 	/* Add new maps */
 	while (!list_empty(&md.maps)) {
 		new_map = list_entry(md.maps.next, struct map, node);
 		list_del(&new_map->node);
 		if (new_map == replacement_map) {
 			map->start	= new_map->start;
 			map->end	= new_map->end;
 			map->pgoff	= new_map->pgoff;
 			map->map_ip	= new_map->map_ip;
 			map->unmap_ip	= new_map->unmap_ip;
 			map__delete(new_map);
 			/* Ensure maps are correctly ordered */
 			map_groups__remove(kmaps, map);
 			map_groups__insert(kmaps, map);
 		} else {
 			map_groups__insert(kmaps, new_map);
 		}
 	}
 	/*
 	 * Set the data type and long name so that kcore can be read via
 	 * dso__data_read_addr().
 	 */
 	if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 		dso->binary_type = DSO_BINARY_TYPE__GUEST_KCORE;
 	else
 		dso->binary_type = DSO_BINARY_TYPE__KCORE;
 	dso__set_long_name(dso, strdup(kcore_filename), true);
 	close(fd);
 	if (map->type == MAP__FUNCTION)
 		pr_debug("Using %s for kernel object code\n", kcore_filename);
 	else
 		pr_debug("Using %s for kernel data\n", kcore_filename);
 	return 0;
 out_err:
 	while (!list_empty(&md.maps)) {
 		map = list_entry(md.maps.next, struct map, node);
 		list_del(&map->node);
 		map__delete(map);
 	}
 	close(fd);
 	return -EINVAL;
 }
 /*
  * If the kernel is relocated at boot time, kallsyms won't match.  Compute the
  * delta based on the relocation reference symbol.
  */
 static int kallsyms__delta(struct map *map, const char *filename, u64 *delta)
 {
 	struct kmap *kmap = map__kmap(map);
 	u64 addr;
 	if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->name)
 		return 0;
 	addr = kallsyms__get_function_start(filename,
 					    kmap->ref_reloc_sym->name);
 	if (!addr)
 		return -1;
 	*delta = addr - kmap->ref_reloc_sym->addr;
 	return 0;
 }
 int dso__load_kallsyms(struct dso *dso, const char *filename,
 		       struct map *map, symbol_filter_t filter)
 {
 	u64 delta = 0;
 	if (symbol__restricted_filename(filename, "/proc/kallsyms"))
 		return -1;
 	if (dso__load_all_kallsyms(dso, filename, map) < 0)
 		return -1;
 	if (kallsyms__delta(map, filename, &delta))
 		return -1;
 	symbols__fixup_duplicate(&dso->symbols[map->type]);
 	symbols__fixup_end(&dso->symbols[map->type]);
 	if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 		dso->symtab_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
 	else
 		dso->symtab_type = DSO_BINARY_TYPE__KALLSYMS;
 	if (!dso__load_kcore(dso, map, filename))
 		return dso__split_kallsyms_for_kcore(dso, map, filter);
 	else
 		return dso__split_kallsyms(dso, map, delta, filter);
 }
 static int dso__load_perf_map(struct dso *dso, struct map *map,
 			      symbol_filter_t filter)
 {
 	char *line = NULL;
 	size_t n;
 	FILE *file;
 	int nr_syms = 0;
 	file = fopen(dso->long_name, "r");
 	if (file == NULL)
 		goto out_failure;
 	while (!feof(file)) {
 		u64 start, size;
 		struct symbol *sym;
 		int line_len, len;
 		line_len = getline(&line, &n, file);
 		if (line_len < 0)
 			break;
 		if (!line)
 			goto out_failure;
 		line[--line_len] = '\0'; /* \n */
 		len = hex2u64(line, &start);
 		len++;
 		if (len + 2 >= line_len)
 			continue;
 		len += hex2u64(line + len, &size);
 		len++;
 		if (len + 2 >= line_len)
 			continue;
 		sym = symbol__new(start, size, STB_GLOBAL, line + len);
 		if (sym == NULL)
 			goto out_delete_line;
 		if (filter && filter(map, sym))
 			symbol__delete(sym);
 		else {
 			symbols__insert(&dso->symbols[map->type], sym);
 			nr_syms++;
 		}
 	}
 	free(line);
 	fclose(file);
 	return nr_syms;
 out_delete_line:
 	free(line);
 out_failure:
 	return -1;
 }
 static bool dso__is_compatible_symtab_type(struct dso *dso, bool kmod,
 					   enum dso_binary_type type)
 {
 	switch (type) {
 	case DSO_BINARY_TYPE__JAVA_JIT:
 	case DSO_BINARY_TYPE__DEBUGLINK:
 	case DSO_BINARY_TYPE__SYSTEM_PATH_DSO:
 	case DSO_BINARY_TYPE__FEDORA_DEBUGINFO:
 	case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO:
 	case DSO_BINARY_TYPE__BUILDID_DEBUGINFO:
 	case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO:
 		return !kmod && dso->kernel == DSO_TYPE_USER;
 	case DSO_BINARY_TYPE__KALLSYMS:
 	case DSO_BINARY_TYPE__VMLINUX:
 	case DSO_BINARY_TYPE__KCORE:
 		return dso->kernel == DSO_TYPE_KERNEL;
 	case DSO_BINARY_TYPE__GUEST_KALLSYMS:
 	case DSO_BINARY_TYPE__GUEST_VMLINUX:
 	case DSO_BINARY_TYPE__GUEST_KCORE:
 		return dso->kernel == DSO_TYPE_GUEST_KERNEL;
 	case DSO_BINARY_TYPE__GUEST_KMODULE:
 	case DSO_BINARY_TYPE__GUEST_KMODULE_COMP:
 	case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE:
 	case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP:
 		/*
 		 * kernel modules know their symtab type - it's set when
 		 * creating a module dso in machine__new_module().
 		 */
 		return kmod && dso->symtab_type == type;
 	case DSO_BINARY_TYPE__BUILD_ID_CACHE:
 		return true;
 	case DSO_BINARY_TYPE__NOT_FOUND:
 	default:
 		return false;
 	}
 }
 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
 {
 	char *name;
 	int ret = -1;
 	u_int i;
 	struct machine *machine;
 	char *root_dir = (char *) "";
 	int ss_pos = 0;
 	struct symsrc ss_[2];
 	struct symsrc *syms_ss = NULL, *runtime_ss = NULL;
 	bool kmod;
 	dso__set_loaded(dso, map->type);
 	if (dso->kernel == DSO_TYPE_KERNEL)
 		return dso__load_kernel_sym(dso, map, filter);
 	else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 		return dso__load_guest_kernel_sym(dso, map, filter);
 	if (map->groups && map->groups->machine)
 		machine = map->groups->machine;
 	else
 		machine = NULL;
 	dso->adjust_symbols = 0;
 	if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
 		struct stat st;
 		if (lstat(dso->name, &st) < 0)
 			return -1;
 		if (st.st_uid && (st.st_uid != geteuid())) {
 			pr_warning("File %s not owned by current user or root, "
 				"ignoring it.\n", dso->name);
 			return -1;
 		}
 		ret = dso__load_perf_map(dso, map, filter);
 		dso->symtab_type = ret > 0 ? DSO_BINARY_TYPE__JAVA_JIT :
 					     DSO_BINARY_TYPE__NOT_FOUND;
 		return ret;
 	}
 	if (machine)
 		root_dir = machine->root_dir;
 	name = malloc(PATH_MAX);
 	if (!name)
 		return -1;
 	kmod = dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE ||
 		dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP ||
 		dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE ||
 		dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP;
 	/*
 	 * Iterate over candidate debug images.
 	 * Keep track of "interesting" ones (those which have a symtab, dynsym,
 	 * and/or opd section) for processing.
 	 */
 	for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) {
 		struct symsrc *ss = &ss_[ss_pos];
 		bool next_slot = false;
 		enum dso_binary_type symtab_type = binary_type_symtab[i];
 		if (!dso__is_compatible_symtab_type(dso, kmod, symtab_type))
 			continue;
 		if (dso__read_binary_type_filename(dso, symtab_type,
 						   root_dir, name, PATH_MAX))
 			continue;
 		/* Name is now the name of the next image to try */
 		if (symsrc__init(ss, dso, name, symtab_type) < 0)
 			continue;
 		if (!syms_ss && symsrc__has_symtab(ss)) {
 			syms_ss = ss;
 			next_slot = true;
 			if (!dso->symsrc_filename)
 				dso->symsrc_filename = strdup(name);
 		}
 		if (!runtime_ss && symsrc__possibly_runtime(ss)) {
 			runtime_ss = ss;
 			next_slot = true;
 		}
 		if (next_slot) {
 			ss_pos++;
 			if (syms_ss && runtime_ss)
 				break;
 		} else {
 			symsrc__destroy(ss);
 		}
 	}
 	if (!runtime_ss && !syms_ss)
 		goto out_free;
 	if (runtime_ss && !syms_ss) {
 		syms_ss = runtime_ss;
 	}
 	/* We'll have to hope for the best */
 	if (!runtime_ss && syms_ss)
 		runtime_ss = syms_ss;
 	if (syms_ss)
 		ret = dso__load_sym(dso, map, syms_ss, runtime_ss, filter, kmod);
 	else
 		ret = -1;
 	if (ret > 0) {
 		int nr_plt;
 		nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss, map, filter);
 		if (nr_plt > 0)
 			ret += nr_plt;
 	}
 	for (; ss_pos > 0; ss_pos--)
 		symsrc__destroy(&ss_[ss_pos - 1]);
 out_free:
 	free(name);
 	if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
 		return 0;
 	return ret;
 }
 struct map *map_groups__find_by_name(struct map_groups *mg,
 				     enum map_type type, const char *name)
 {
 	struct rb_node *nd;
 	for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
 		struct map *map = rb_entry(nd, struct map, rb_node);
 		if (map->dso && strcmp(map->dso->short_name, name) == 0)
 			return map;
 	}
 	return NULL;
 }
 int dso__load_vmlinux(struct dso *dso, struct map *map,
 		      const char *vmlinux, bool vmlinux_allocated,
 		      symbol_filter_t filter)
 {
 	int err = -1;
 	struct symsrc ss;
 	char symfs_vmlinux[PATH_MAX];
 	enum dso_binary_type symtab_type;
 	if (vmlinux[0] == '/')
 		snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s", vmlinux);
 	else
 		symbol__join_symfs(symfs_vmlinux, vmlinux);
 	if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 		symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
 	else
 		symtab_type = DSO_BINARY_TYPE__VMLINUX;
 	if (symsrc__init(&ss, dso, symfs_vmlinux, symtab_type))
 		return -1;
 	err = dso__load_sym(dso, map, &ss, &ss, filter, 0);
 	symsrc__destroy(&ss);
 	if (err > 0) {
 		if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 			dso->binary_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
 		else
 			dso->binary_type = DSO_BINARY_TYPE__VMLINUX;
 		dso__set_long_name(dso, vmlinux, vmlinux_allocated);
 		dso__set_loaded(dso, map->type);
 		pr_debug("Using %s for symbols\n", symfs_vmlinux);
 	}
 	return err;
 }
 int dso__load_vmlinux_path(struct dso *dso, struct map *map,
 			   symbol_filter_t filter)
 {
 	int i, err = 0;
 	char *filename = NULL;
 	if (!symbol_conf.ignore_vmlinux_buildid)
 		filename = dso__build_id_filename(dso, NULL, 0);
 	if (filename != NULL) {
 		err = dso__load_vmlinux(dso, map, filename, true, filter);
 		if (err > 0)
 			goto out;
 		free(filename);
 	}
 	pr_debug("Looking at the vmlinux_path (%d entries long)\n",
 		 vmlinux_path__nr_entries + 1);
 	for (i = 0; i < vmlinux_path__nr_entries; ++i) {
 		err = dso__load_vmlinux(dso, map, vmlinux_path[i], false, filter);
 		if (err > 0)
 			break;
 	}
 out:
 	return err;
 }
 static int find_matching_kcore(struct map *map, char *dir, size_t dir_sz)
 {
 	char kallsyms_filename[PATH_MAX];
 	struct dirent *dent;
 	int ret = -1;
 	DIR *d;
 	d = opendir(dir);
 	if (!d)
 		return -1;
 	while (1) {
 		dent = readdir(d);
 		if (!dent)
 			break;
 		if (dent->d_type != DT_DIR)
 			continue;
 		scnprintf(kallsyms_filename, sizeof(kallsyms_filename),
 			  "%s/%s/kallsyms", dir, dent->d_name);
 		if (!validate_kcore_addresses(kallsyms_filename, map)) {
 			strlcpy(dir, kallsyms_filename, dir_sz);
 			ret = 0;
 			break;
 		}
 	}
 	closedir(d);
 	return ret;
 }
 static char *dso__find_kallsyms(struct dso *dso, struct map *map)
 {
 	u8 host_build_id[BUILD_ID_SIZE];
 	char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 	bool is_host = false;
 	char path[PATH_MAX];
 	if (!dso->has_build_id) {
 		/*
 		 * Last resort, if we don't have a build-id and couldn't find
 		 * any vmlinux file, try the running kernel kallsyms table.
 		 */
 		goto proc_kallsyms;
 	}
 	if (sysfs__read_build_id("/sys/kernel/notes", host_build_id,
 				 sizeof(host_build_id)) == 0)
 		is_host = dso__build_id_equal(dso, host_build_id);
 	build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
 	scnprintf(path, sizeof(path), "%s/[kernel.kcore]/%s", buildid_dir,
 		  sbuild_id);
 	/* Use /proc/kallsyms if possible */
 	if (is_host) {
 		DIR *d;
 		int fd;
 		/* If no cached kcore go with /proc/kallsyms */
 		d = opendir(path);
 		if (!d)
 			goto proc_kallsyms;
 		closedir(d);
 		/*
 		 * Do not check the build-id cache, until we know we cannot use
 		 * /proc/kcore.
 		 */
 		fd = open("/proc/kcore", O_RDONLY);
 		if (fd != -1) {
 			close(fd);
 			/* If module maps match go with /proc/kallsyms */
 			if (!validate_kcore_addresses("/proc/kallsyms", map))
 				goto proc_kallsyms;
 		}
 		/* Find kallsyms in build-id cache with kcore */
 		if (!find_matching_kcore(map, path, sizeof(path)))
 			return strdup(path);
 		goto proc_kallsyms;
 	}
 	/* Find kallsyms in build-id cache with kcore */
 	if (!find_matching_kcore(map, path, sizeof(path)))
 		return strdup(path);
 	scnprintf(path, sizeof(path), "%s/[kernel.kallsyms]/%s",
 		  buildid_dir, sbuild_id);
 	if (access(path, F_OK)) {
 		pr_err("No kallsyms or vmlinux with build-id %s was found\n",
 		       sbuild_id);
 		return NULL;
 	}
 	return strdup(path);
 proc_kallsyms:
 	return strdup("/proc/kallsyms");
 }
 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
 				symbol_filter_t filter)
 {
 	int err;
 	const char *kallsyms_filename = NULL;
 	char *kallsyms_allocated_filename = NULL;
 	/*
 	 * Step 1: if the user specified a kallsyms or vmlinux filename, use
 	 * it and only it, reporting errors to the user if it cannot be used.
 	 *
 	 * For instance, try to analyse an ARM perf.data file _without_ a
 	 * build-id, or if the user specifies the wrong path to the right
 	 * vmlinux file, obviously we can't fallback to another vmlinux (a
 	 * x86_86 one, on the machine where analysis is being performed, say),
 	 * or worse, /proc/kallsyms.
 	 *
 	 * If the specified file _has_ a build-id and there is a build-id
 	 * section in the perf.data file, we will still do the expected
 	 * validation in dso__load_vmlinux and will bail out if they don't
 	 * match.
 	 */
 	if (symbol_conf.kallsyms_name != NULL) {
 		kallsyms_filename = symbol_conf.kallsyms_name;
 		goto do_kallsyms;
 	}
 	if (!symbol_conf.ignore_vmlinux && symbol_conf.vmlinux_name != NULL) {
 		return dso__load_vmlinux(dso, map, symbol_conf.vmlinux_name,
 					 false, filter);
 	}
 	if (!symbol_conf.ignore_vmlinux && vmlinux_path != NULL) {
 		err = dso__load_vmlinux_path(dso, map, filter);
 		if (err > 0)
 			return err;
 	}
 	/* do not try local files if a symfs was given */
 	if (symbol_conf.symfs[0] != 0)
 		return -1;
 	kallsyms_allocated_filename = dso__find_kallsyms(dso, map);
 	if (!kallsyms_allocated_filename)
 		return -1;
 	kallsyms_filename = kallsyms_allocated_filename;
 do_kallsyms:
 	err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
 	if (err > 0)
 		pr_debug("Using %s for symbols\n", kallsyms_filename);
 	free(kallsyms_allocated_filename);
 	if (err > 0 && !dso__is_kcore(dso)) {
 		dso->binary_type = DSO_BINARY_TYPE__KALLSYMS;
 		dso__set_long_name(dso, "[kernel.kallsyms]", false);
 		map__fixup_start(map);
 		map__fixup_end(map);
 	}
 	return err;
 }
 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
 				      symbol_filter_t filter)
 {
 	int err;
 	const char *kallsyms_filename = NULL;
 	struct machine *machine;
 	char path[PATH_MAX];
 	if (!map->groups) {
 		pr_debug("Guest kernel map hasn't the point to groups\n");
 		return -1;
 	}
 	machine = map->groups->machine;
 	if (machine__is_default_guest(machine)) {
 		/*
 		 * if the user specified a vmlinux filename, use it and only
 		 * it, reporting errors to the user if it cannot be used.
 		 * Or use file guest_kallsyms inputted by user on commandline
 		 */
 		if (symbol_conf.default_guest_vmlinux_name != NULL) {
 			err = dso__load_vmlinux(dso, map,
 						symbol_conf.default_guest_vmlinux_name,
 						false, filter);
 			return err;
 		}
 		kallsyms_filename = symbol_conf.default_guest_kallsyms;
 		if (!kallsyms_filename)
 			return -1;
 	} else {
 		sprintf(path, "%s/proc/kallsyms", machine->root_dir);
 		kallsyms_filename = path;
 	}
 	err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
 	if (err > 0)
 		pr_debug("Using %s for symbols\n", kallsyms_filename);
 	if (err > 0 && !dso__is_kcore(dso)) {
 		dso->binary_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
 		machine__mmap_name(machine, path, sizeof(path));
 		dso__set_long_name(dso, strdup(path), true);
 		map__fixup_start(map);
 		map__fixup_end(map);
 	}
 	return err;
 }
 static void vmlinux_path__exit(void)
 {
 	while (--vmlinux_path__nr_entries >= 0)
 		zfree(&vmlinux_path[vmlinux_path__nr_entries]);
 	zfree(&vmlinux_path);
 }
 static int vmlinux_path__init(struct perf_session_env *env)
 {
 	struct utsname uts;
 	char bf[PATH_MAX];
 	char *kernel_version;
 	vmlinux_path = malloc(sizeof(char *) * 6);
 	if (vmlinux_path == NULL)
 		return -1;
 	vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	/* only try kernel version if no symfs was given */
 	if (symbol_conf.symfs[0] != 0)
 		return 0;
 	if (env) {
 		kernel_version = env->os_release;
 	} else {
 		if (uname(&uts) < 0)
 			goto out_fail;
 		kernel_version = uts.release;
 	}
 	snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", kernel_version);
 	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	snprintf(bf, sizeof(bf), "/usr/lib/debug/boot/vmlinux-%s",
 		 kernel_version);
 	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
         ++vmlinux_path__nr_entries;
 	snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", kernel_version);
 	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
 		 kernel_version);
 	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	return 0;
 out_fail:
 	vmlinux_path__exit();
 	return -1;
 }
 int setup_list(struct strlist **list, const char *list_str,
 		      const char *list_name)
 {
 	if (list_str == NULL)
 		return 0;
 	*list = strlist__new(true, list_str);
 	if (!*list) {
 		pr_err("problems parsing %s list\n", list_name);
 		return -1;
 	}
 	return 0;
 }
 static bool symbol__read_kptr_restrict(void)
 {
 	bool value = false;
 	if (geteuid() != 0) {
 		FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
 		if (fp != NULL) {
 			char line[8];
 			if (fgets(line, sizeof(line), fp) != NULL)
 				value = atoi(line) != 0;
 			fclose(fp);
 		}
 	}
 	return value;
 }
 int symbol__init(struct perf_session_env *env)
 {
 	const char *symfs;
 	if (symbol_conf.initialized)
 		return 0;
 	symbol_conf.priv_size = PERF_ALIGN(symbol_conf.priv_size, sizeof(u64));
 	symbol__elf_init();
 	if (symbol_conf.sort_by_name)
 		symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
 					  sizeof(struct symbol));
 	if (symbol_conf.try_vmlinux_path && vmlinux_path__init(env) < 0)
 		return -1;
 	if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
 		pr_err("'.' is the only non valid --field-separator argument\n");
 		return -1;
 	}
 	if (setup_list(&symbol_conf.dso_list,
 		       symbol_conf.dso_list_str, "dso") < 0)
 		return -1;
 	if (setup_list(&symbol_conf.comm_list,
 		       symbol_conf.comm_list_str, "comm") < 0)
 		goto out_free_dso_list;
 	if (setup_list(&symbol_conf.sym_list,
 		       symbol_conf.sym_list_str, "symbol") < 0)
 		goto out_free_comm_list;
 	/*
 	 * A path to symbols of "/" is identical to ""
 	 * reset here for simplicity.
 	 */
 	symfs = realpath(symbol_conf.symfs, NULL);
 	if (symfs == NULL)
 		symfs = symbol_conf.symfs;
 	if (strcmp(symfs, "/") == 0)
 		symbol_conf.symfs = "";
 	if (symfs != symbol_conf.symfs)
 		free((void *)symfs);
 	symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
 	symbol_conf.initialized = true;
 	return 0;
 out_free_comm_list:
 	strlist__delete(symbol_conf.comm_list);
 out_free_dso_list:
 	strlist__delete(symbol_conf.dso_list);
 	return -1;
 }
 void symbol__exit(void)
 {
 	if (!symbol_conf.initialized)
 		return;
 	strlist__delete(symbol_conf.sym_list);
 	strlist__delete(symbol_conf.dso_list);
 	strlist__delete(symbol_conf.comm_list);
 	vmlinux_path__exit();
 	symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
 	symbol_conf.initialized = false;
 }

tools/perf/util/symbol.h

Diff comments View file @ e742f3d

 #ifndef __PERF_SYMBOL
 #define __PERF_SYMBOL 1
 #include <linux/types.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include "map.h"
 #include "../perf.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
 #include <stdio.h>
 #include <byteswap.h>
 #include <libgen.h>
 #include "build-id.h"
 #include "event.h"
 #include "util.h"
 #ifdef HAVE_LIBELF_SUPPORT
 #include <libelf.h>
 #include <gelf.h>
 #endif
 #include <elf.h>
 #include "dso.h"
 /*
  * libelf 0.8.x and earlier do not support ELF_C_READ_MMAP;
  * for newer versions we can use mmap to reduce memory usage:
  */
 #ifdef HAVE_LIBELF_MMAP_SUPPORT
 # define PERF_ELF_C_READ_MMAP ELF_C_READ_MMAP
 #else
 # define PERF_ELF_C_READ_MMAP ELF_C_READ
 #endif
 #ifdef HAVE_LIBELF_SUPPORT
 extern Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
 				GElf_Shdr *shp, const char *name, size_t *idx);
 #endif
 #ifndef DMGL_PARAMS
 #define DMGL_NO_OPTS     0              /* For readability... */
 #define DMGL_PARAMS      (1 << 0)       /* Include function args */
 #define DMGL_ANSI        (1 << 1)       /* Include const, volatile, etc */
 #endif
 /** struct symbol - symtab entry
  *
  * @ignore - resolvable but tools ignore it (e.g. idle routines)
  */
 struct symbol {
 	struct rb_node	rb_node;
 	u64		start;
 	u64		end;
 	u16		namelen;
 	u8		binding;
 	bool		ignore;
 	char		name[0];
 };
 void symbol__delete(struct symbol *sym);
 void symbols__delete(struct rb_root *symbols);
 /* symbols__for_each_entry - iterate over symbols (rb_root)
  *
  * @symbols: the rb_root of symbols
  * @pos: the 'struct symbol *' to use as a loop cursor
  * @nd: the 'struct rb_node *' to use as a temporary storage
  */
 #define symbols__for_each_entry(symbols, pos, nd)			\
 	for (nd = rb_first(symbols);					\
 	     nd && (pos = rb_entry(nd, struct symbol, rb_node));	\
 	     nd = rb_next(nd))
 static inline size_t symbol__size(const struct symbol *sym)
 {
 	return sym->end - sym->start;
 }
 struct strlist;
 struct symbol_conf {
 	unsigned short	priv_size;
 	unsigned short	nr_events;
 	bool		try_vmlinux_path,
 			ignore_vmlinux,
 			ignore_vmlinux_buildid,
 			show_kernel_path,
 			use_modules,
 			sort_by_name,
 			show_nr_samples,
 			show_total_period,
 			use_callchain,
 			cumulate_callchain,
 			exclude_other,
 			show_cpu_utilization,
 			initialized,
 			kptr_restrict,
 			annotate_asm_raw,
 			annotate_src,
 			event_group,
 			demangle,
 			demangle_kernel,
 			filter_relative,
 			show_hist_headers,
 			branch_callstack;
 	const char	*vmlinux_name,
 			*kallsyms_name,
 			*source_prefix,
 			*field_sep;
 	const char	*default_guest_vmlinux_name,
 			*default_guest_kallsyms,
 			*default_guest_modules;
 	const char	*guestmount;
 	const char	*dso_list_str,
 			*comm_list_str,
 			*sym_list_str,
 			*col_width_list_str;
        struct strlist	*dso_list,
 			*comm_list,
 			*sym_list,
 			*dso_from_list,
 			*dso_to_list,
 			*sym_from_list,
 			*sym_to_list;
 	const char	*symfs;
 };
 extern struct symbol_conf symbol_conf;
 static inline int __symbol__join_symfs(char *bf, size_t size, const char *path)
 {
 	return path__join(bf, size, symbol_conf.symfs, path);
 }
 #define symbol__join_symfs(bf, path) __symbol__join_symfs(bf, sizeof(bf), path)
 extern int vmlinux_path__nr_entries;
 extern char **vmlinux_path;
 static inline void *symbol__priv(struct symbol *sym)
 {
 	return ((void *)sym) - symbol_conf.priv_size;
 }
 struct ref_reloc_sym {
 	const char	*name;
 	u64		addr;
 	u64		unrelocated_addr;
 };
 struct map_symbol {
 	struct map    *map;
 	struct symbol *sym;
 	bool	      unfolded;
 	bool	      has_children;
 };
 struct addr_map_symbol {
 	struct map    *map;
 	struct symbol *sym;
 	u64	      addr;
 	u64	      al_addr;
 };
 struct branch_info {
 	struct addr_map_symbol from;
 	struct addr_map_symbol to;
 	struct branch_flags flags;
 };
 struct mem_info {
 	struct addr_map_symbol iaddr;
 	struct addr_map_symbol daddr;
 	union perf_mem_data_src data_src;
 };
 struct addr_location {
 	struct machine *machine;
 	struct thread *thread;
 	struct map    *map;
 	struct symbol *sym;
 	u64	      addr;
 	char	      level;
 	u8	      filtered;
 	u8	      cpumode;
 	s32	      cpu;
 };
 struct symsrc {
 	char *name;
 	int fd;
 	enum dso_binary_type type;
 #ifdef HAVE_LIBELF_SUPPORT
 	Elf *elf;
 	GElf_Ehdr ehdr;
 	Elf_Scn *opdsec;
 	size_t opdidx;
 	GElf_Shdr opdshdr;
 	Elf_Scn *symtab;
 	GElf_Shdr symshdr;
 	Elf_Scn *dynsym;
 	size_t dynsym_idx;
 	GElf_Shdr dynshdr;
 	bool adjust_symbols;
 	bool is_64_bit;
 #endif
 };
 void symsrc__destroy(struct symsrc *ss);
 int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
 		 enum dso_binary_type type);
 bool symsrc__has_symtab(struct symsrc *ss);
 bool symsrc__possibly_runtime(struct symsrc *ss);
 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter);
 int dso__load_vmlinux(struct dso *dso, struct map *map,
 		      const char *vmlinux, bool vmlinux_allocated,
 		      symbol_filter_t filter);
 int dso__load_vmlinux_path(struct dso *dso, struct map *map,
 			   symbol_filter_t filter);
 int dso__load_kallsyms(struct dso *dso, const char *filename, struct map *map,
 		       symbol_filter_t filter);
 struct symbol *dso__find_symbol(struct dso *dso, enum map_type type,
 				u64 addr);
 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
 					const char *name);
+struct symbol *symbol__next_by_name(struct symbol *sym);
 struct symbol *dso__first_symbol(struct dso *dso, enum map_type type);
 struct symbol *dso__next_symbol(struct symbol *sym);
 enum dso_type dso__type_fd(int fd);
 int filename__read_build_id(const char *filename, void *bf, size_t size);
 int sysfs__read_build_id(const char *filename, void *bf, size_t size);
 int modules__parse(const char *filename, void *arg,
 		   int (*process_module)(void *arg, const char *name,
 					 u64 start));
 int filename__read_debuglink(const char *filename, char *debuglink,
 			     size_t size);
 struct perf_session_env;
 int symbol__init(struct perf_session_env *env);
 void symbol__exit(void);
 void symbol__elf_init(void);
 struct symbol *symbol__new(u64 start, u64 len, u8 binding, const char *name);
 size_t symbol__fprintf_symname_offs(const struct symbol *sym,
 				    const struct addr_location *al, FILE *fp);
 size_t symbol__fprintf_symname(const struct symbol *sym, FILE *fp);
 size_t symbol__fprintf(struct symbol *sym, FILE *fp);
 bool symbol_type__is_a(char symbol_type, enum map_type map_type);
 bool symbol__restricted_filename(const char *filename,
 				 const char *restricted_filename);
 bool symbol__is_idle(struct symbol *sym);
 int dso__load_sym(struct dso *dso, struct map *map, struct symsrc *syms_ss,
 		  struct symsrc *runtime_ss, symbol_filter_t filter,
 		  int kmodule);
 int dso__synthesize_plt_symbols(struct dso *dso, struct symsrc *ss,
 				struct map *map, symbol_filter_t filter);
 void symbols__insert(struct rb_root *symbols, struct symbol *sym);
 void symbols__fixup_duplicate(struct rb_root *symbols);
 void symbols__fixup_end(struct rb_root *symbols);
 void __map_groups__fixup_end(struct map_groups *mg, enum map_type type);
 typedef int (*mapfn_t)(u64 start, u64 len, u64 pgoff, void *data);
 int file__read_maps(int fd, bool exe, mapfn_t mapfn, void *data,
 		    bool *is_64_bit);
 #define PERF_KCORE_EXTRACT "/tmp/perf-kcore-XXXXXX"
 struct kcore_extract {
 	char *kcore_filename;
 	u64 addr;
 	u64 offs;
 	u64 len;
 	char extract_filename[sizeof(PERF_KCORE_EXTRACT)];
 	int fd;
 };
 int kcore_extract__create(struct kcore_extract *kce);
 void kcore_extract__delete(struct kcore_extract *kce);
 int kcore_copy(const char *from_dir, const char *to_dir);
 int compare_proc_modules(const char *from, const char *to);
 int setup_list(struct strlist **list, const char *list_str,
 	       const char *list_name);
 #endif /* __PERF_SYMBOL */